Metacat

/**

 *  '$RCSfile$'

 *  Copyright: 2010 Regents of the University of California and the

 *              National Center for Ecological Analysis and Synthesis

 *  Purpose: To test the Access Controls in metacat by JUnit

 *

 *   '$Author: leinfelder $'

 *     '$Date: 2011-07-07 15:16:56 -0700 (Thu, 07 Jul 2011) $'

 * '$Revision: 6322 $'

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

package edu.ucsb.nceas.metacat.dataone;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.Reader;

import java.text.SimpleDateFormat;

import java.util.Date;

import junit.framework.Test;

import junit.framework.TestSuite;

import org.apache.commons.io.IOUtils;

import org.dataone.client.ObjectFormatCache;

import org.dataone.service.Constants;

import org.dataone.service.exceptions.InsufficientResources;

import org.dataone.service.exceptions.InvalidRequest;

import org.dataone.service.exceptions.NotAuthorized;

import org.dataone.service.exceptions.NotFound;

import org.dataone.service.exceptions.NotImplemented;

import org.dataone.service.exceptions.ServiceFailure;

import org.dataone.service.impl.ObjectFormatServiceImpl;

import org.dataone.service.types.AccessPolicy;

import org.dataone.service.types.AccessRule;

import org.dataone.service.types.Checksum;

import org.dataone.service.types.ChecksumAlgorithm;

import org.dataone.service.types.Event;

import org.dataone.service.types.Identifier;

import org.dataone.service.types.Log;

import org.dataone.service.types.NodeReference;

import org.dataone.service.types.ObjectFormat;

import org.dataone.service.types.ObjectFormatIdentifier;

import org.dataone.service.types.ObjectFormatList;

import org.dataone.service.types.ObjectInfo;

import org.dataone.service.types.ObjectList;

import org.dataone.service.types.Permission;

import org.dataone.service.types.Replica;

import org.dataone.service.types.ReplicationPolicy;

import org.dataone.service.types.ReplicationStatus;

import org.dataone.service.types.Session;

import org.dataone.service.types.Subject;

import org.dataone.service.types.SystemMetadata;

import org.dataone.service.types.util.ServiceTypeUtil;

import edu.ucsb.nceas.MCTestCase;

import edu.ucsb.nceas.metacat.client.Metacat;

import edu.ucsb.nceas.metacat.client.MetacatFactory;

/**

 * A JUnit test for testing the dataone CNCore implementation

 */

public class CNodeServiceTest extends MCTestCase {   

    /**

    * constructor for the test

    */

    public CNodeServiceTest(String name)

    {

        super(name);

    }

    /**

	 * Establish a testing framework by initializing appropriate objects

	 */

	public void setUp() throws Exception 

	{

		super.setUp();

	}

	/**

	 * Release any objects after tests are complete

	 */

	public void tearDown() 

	{

	}

	/**

	 * Create a suite of tests to be run together

	 */

	public static Test suite() 

	{

		TestSuite suite = new TestSuite();

		suite.addTest(new CNodeServiceTest("initialize"));

		suite.addTest(new CNodeServiceTest("testAssertRelation"));

		suite.addTest(new CNodeServiceTest("testChecksum"));

		suite.addTest(new CNodeServiceTest("testCreate"));

		suite.addTest(new CNodeServiceTest("testGet"));

		suite.addTest(new CNodeServiceTest("testGetFormat"));

		suite.addTest(new CNodeServiceTest("testGetLogRecords"));

		suite.addTest(new CNodeServiceTest("testGetSystemMetadata"));

		suite.addTest(new CNodeServiceTest("testIsAuthorized"));

		suite.addTest(new CNodeServiceTest("testListFormats"));

		suite.addTest(new CNodeServiceTest("testListNodes"));

		suite.addTest(new CNodeServiceTest("testObjectFormatNotFoundException"));

		suite.addTest(new CNodeServiceTest("testRegisterSystemMetadata"));

		suite.addTest(new CNodeServiceTest("testReplicationPolicy"));

		suite.addTest(new CNodeServiceTest("testReplicationStatus"));

		suite.addTest(new CNodeServiceTest("testReserveIdentifier"));

		suite.addTest(new CNodeServiceTest("testSearch"));

		suite.addTest(new CNodeServiceTest("testSetAccessPolicy"));

		suite.addTest(new CNodeServiceTest("testSetOwner"));

		return suite;

	}

	/**

	 * constructs a "fake" session with a test subject

	 * @return

	 */

	private Session getTestSession() {

		Session session = new Session();

        Subject subject = new Subject();

        subject.setValue("cn=test,dc=dataone,dc=org");

        session.setSubject(subject);

        return session;

	}

	/**

	 * test for registering standalone system metadata

	 */

	public void testRegisterSystemMetadata() {

	    printTestHeader("testRegisterSystemMetadata");

	    try {

            Session session = getTestSession();

			Identifier guid = new Identifier();

			guid.setValue("testRegisterSystemMetadata." + System.currentTimeMillis());

			SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject());

			boolean result = CNodeService.getInstance().registerSystemMetadata(session, guid, sysmeta);

			assertTrue(result);

        } catch(Exception e) {

            fail("Unexpected error: " + e.getMessage());

        }

	}

	/**

	 * test for getting system metadata

	 */

	public void testGetSystemMetadata() {

	    printTestHeader("testGetSystemMetadata");

	    try {

            Session session = getTestSession();

			Identifier guid = new Identifier();

			guid.setValue("testGetSystemMetadata." + System.currentTimeMillis());

			SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject());

			boolean result = CNodeService.getInstance().registerSystemMetadata(session, guid, sysmeta);

			assertTrue(result);

			// get it

			SystemMetadata retSysmeta = CNodeService.getInstance().getSystemMetadata(session, guid);

			// check it

			assertEquals(sysmeta.getIdentifier().getValue(), retSysmeta.getIdentifier().getValue());

        } catch(Exception e) {

            fail("Unexpected error: " + e.getMessage());

        }

	}

	public void testGetLogRecords() {

	    printTestHeader("testGetLogRecords");

	    try {

		    Session session = getTestSession();

		    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

		    Date fromDate = sdf.parse("2010-01-01");

		    Date toDate = new Date();

		    Event event = Event.CREATE;

		    int start = 0;

		    int count = 1;

		    Log log = CNodeService.getInstance().getLogRecords(session, fromDate, toDate, 

		    	event, start, count);

		    assertNotNull(log);

		    assertTrue(log.getCount() == count);

		    assertTrue(log.getStart() == start);

		    assertTrue(log.getTotal() > 0);

	    } catch (Exception e) {

		    e.printStackTrace();

		    fail("Unexpected error: " + e.getMessage());

	    } 

	}

	public void testCreate() {

	    printTestHeader("testCreate");

	    try {

            Session session = getTestSession();

			Identifier guid = new Identifier();

			guid.setValue("testCreate." + System.currentTimeMillis());

			SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject());

			InputStream object = new ByteArrayInputStream("test".getBytes("UTF-8"));

			Identifier pid = CNodeService.getInstance().create(session, guid, object, sysmeta);

			assertEquals(guid, pid);

        } catch(Exception e) {

        	e.printStackTrace();

            fail("Unexpected error: " + e.getMessage());

        }

	}

	public void testGet() {

	    printTestHeader("testGet");

	    try {

            Session session = getTestSession();

			Identifier guid = new Identifier();

			guid.setValue("testGet." + System.currentTimeMillis());

			SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject());

			InputStream object = new ByteArrayInputStream("test".getBytes("UTF-8"));

			Identifier pid = CNodeService.getInstance().create(session, guid, object, sysmeta);

			assertEquals(guid, pid);

			// get it

			InputStream retObject = CNodeService.getInstance().get(session, pid);

			// check it

			assertTrue(IOUtils.contentEquals(object, retObject));

        } catch(Exception e) {

        	e.printStackTrace();

            fail("Unexpected error: " + e.getMessage());

        }

	}

	public void testAssertRelation() {

	    printTestHeader("testAssertRelation");

	    try {

            Session session = getTestSession();

			Identifier guid = new Identifier();

			guid.setValue("testAssertRelation." + System.currentTimeMillis());

			SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject());

			Identifier describePid = new Identifier();

			describePid.setValue("describePid." + System.currentTimeMillis());

			sysmeta.addDescribe(describePid);

			// save it

			boolean result = CNodeService.getInstance().registerSystemMetadata(session, guid, sysmeta);

			assertTrue(result);

			// save the other

			SystemMetadata describeSysmeta = createSystemMetadata(describePid, session.getSubject());

			result = CNodeService.getInstance().registerSystemMetadata(session, describePid, describeSysmeta);

			assertTrue(result);

			// check it

			result = CNodeService.getInstance().assertRelation(session, guid, "describes", describePid);

			assertTrue(result);

        } catch(Exception e) {

        	e.printStackTrace();

            fail("Unexpected error: " + e.getMessage());

        }

	}

	public void testChecksum() {

	    printTestHeader("testChecksum");

	    try {

            Session session = getTestSession();

			Identifier guid = new Identifier();

			guid.setValue("testChecksum." + System.currentTimeMillis());

			SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject());

			// save it

			boolean result = CNodeService.getInstance().registerSystemMetadata(session, guid, sysmeta);

			assertTrue(result);

			// check it

			Checksum checksum = CNodeService.getInstance().getChecksum(session, guid);

			assertEquals(sysmeta.getChecksum().getValue(), checksum.getValue());

        } catch(Exception e) {

            fail("Unexpected error: " + e.getMessage());

        }

	}

	public void testListNodes() {

	    printTestHeader("testListNodes");

	    try {

	    	CNodeService.getInstance().listNodes();

        } catch(NotImplemented e) {

        	// expecting not implemented

            assertTrue(true);

        } catch(Exception e) {

            fail("Unexpected error: " + e.getMessage());

        }

	}

	public void testReserveIdentifier() {

	    printTestHeader("testReserveIdentifier");

	    try {

            Session session = getTestSession();

			Identifier guid = new Identifier();

			guid.setValue("testReserveIdentifier." + System.currentTimeMillis());

			// reserve it

			Identifier retPid = CNodeService.getInstance().reserveIdentifier(session, guid, null, null);

			assertEquals(guid, retPid);

        } catch(Exception e) {

        	e.printStackTrace();

            fail("Unexpected error: " + e.getMessage());

        }

	}

	public void testSearch() {

	    printTestHeader("testSearch");

	    try {

            Session session = getTestSession();

			Identifier guid = new Identifier();

			guid.setValue("testSearch." + System.currentTimeMillis());

			SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject());

			// save it

			boolean result = CNodeService.getInstance().registerSystemMetadata(session, guid, sysmeta);

			assertTrue(result);

			// search for it

			ObjectList objectList = CNodeService.getInstance().search(session, null, null);

			// check it

			assertNotNull(objectList);

			result = false;

			for (ObjectInfo objectInfo: objectList.getObjectInfoList()) {

				Identifier pid = objectInfo.getIdentifier();

				if (pid.getValue().equals(guid.getValue())) {

					result = true;

					break;

				}

			}

			assertTrue(result);

        } catch(Exception e) {

            fail("Unexpected error: " + e.getMessage());

        }

	}

	public void testSetOwner() {

	    printTestHeader("testSetOwner");

	    try {

            Session session = getTestSession();

			Identifier guid = new Identifier();

			guid.setValue("testSetOwner." + System.currentTimeMillis());

			SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject());

			// save it

			boolean result = CNodeService.getInstance().registerSystemMetadata(session, guid, sysmeta);

			assertTrue(result);

			Subject rightsHolder = new Subject();

			rightsHolder.setValue("newUser");

			// set it

			Identifier retPid = CNodeService.getInstance().setOwner(session, guid, rightsHolder);

			assertEquals(guid, retPid);

			// get it

			sysmeta = CNodeService.getInstance().getSystemMetadata(session, guid);

			assertNotNull(sysmeta);

			// check it

			assertEquals(rightsHolder.getValue(), sysmeta.getRightsHolder().getValue());

        } catch(Exception e) {

            fail("Unexpected error: " + e.getMessage());

        }

	}

	public void testSetAccessPolicy() {

	    printTestHeader("testSetAccessPolicy");

	    try {

            Session session = getTestSession();

			Identifier guid = new Identifier();

			guid.setValue("testSetAccessPolicy." + System.currentTimeMillis());

			SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject());

			// save it

			boolean result = CNodeService.getInstance().registerSystemMetadata(session, guid, sysmeta);

			assertTrue(result);

			AccessPolicy accessPolicy = new AccessPolicy();

			AccessRule accessRule = new AccessRule();

			accessRule.addPermission(Permission.WRITE);

			Subject publicSubject = new Subject();

			publicSubject.setValue(Constants.PUBLIC_SUBJECT);

			accessRule.addSubject(publicSubject);

			accessPolicy.addAllow(accessRule);

			// set it

			result = CNodeService.getInstance().setAccessPolicy(session, guid, accessPolicy );

			assertTrue(result);

			// check it

			result = CNodeService.getInstance().isAuthorized(session, guid, Permission.WRITE);

			assertTrue(result);

        } catch(Exception e) {

            fail("Unexpected error: " + e.getMessage());

        }

	}

	public void testIsAuthorized() {

	    printTestHeader("testIsAuthorized");

	    try {

            Session session = getTestSession();

			Identifier guid = new Identifier();

			guid.setValue("testIsAuthorized." + System.currentTimeMillis());

			SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject());

			// save it

			boolean result = CNodeService.getInstance().registerSystemMetadata(session, guid, sysmeta);

			assertTrue(result);

			// check it

			Subject publicSubject = new Subject();

			publicSubject.setValue(Constants.PUBLIC_SUBJECT);

			session.setSubject(publicSubject);

			// public read

			result = CNodeService.getInstance().isAuthorized(session, guid, Permission.READ);

			assertTrue(result);

			// not public write

			try {

				result = false;

				result = CNodeService.getInstance().isAuthorized(session, guid, Permission.WRITE);

				fail("Public WRITE should be denied");

			} catch (NotAuthorized nae) {

				result = true;

			}

			assertTrue(result);

        } catch(Exception e) {

            fail("Unexpected error: " + e.getMessage());

        }

	}

	public void testReplicationPolicy() {

	    printTestHeader("testReplicationPolicy");

	    try {

            Session session = getTestSession();

			Identifier guid = new Identifier();

			guid.setValue("testReplicationPolicy." + System.currentTimeMillis());

			SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject());

			// save it

			boolean result = CNodeService.getInstance().registerSystemMetadata(session, guid, sysmeta);

			assertTrue(result);

			ReplicationPolicy policy = new ReplicationPolicy();

			NodeReference node = new NodeReference();

			node.setValue("testNode");

			policy.addPreferredMemberNode(node );

			// set it

			result = CNodeService.getInstance().setReplicationPolicy(session, guid, policy);

			assertTrue(result);

			// get it

			sysmeta = CNodeService.getInstance().getSystemMetadata(session, guid);

			assertNotNull(sysmeta);

			// check it

			assertEquals(policy.getPreferredMemberNode(0).getValue(), sysmeta.getReplicationPolicy().getPreferredMemberNode(0).getValue());

        } catch(Exception e) {

            fail("Unexpected error: " + e.getMessage());

        }

	}

	public void testReplicationStatus() {

	    printTestHeader("testReplicationStatus");

	    try {

            Session session = getTestSession();

			Identifier guid = new Identifier();

			guid.setValue("testReplicationStatus." + System.currentTimeMillis());

			SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject());

			Replica replica = new Replica();

			NodeReference replicaMemberNode = new NodeReference();

			replicaMemberNode.setValue("testNode");

			replica.setReplicationStatus(ReplicationStatus.REQUESTED);

			replica.setReplicaMemberNode(replicaMemberNode);

			replica.setReplicaVerified(new Date());

			sysmeta.addReplica(replica );

			// save it

			boolean result = CNodeService.getInstance().registerSystemMetadata(session, guid, sysmeta);

			assertTrue(result);

			// set it

			ReplicationStatus status = ReplicationStatus.COMPLETED;

			result = CNodeService.getInstance().setReplicationStatus(session, guid, status);

			assertTrue(result);

			// get it

			sysmeta = CNodeService.getInstance().getSystemMetadata(session, guid);

			assertNotNull(sysmeta);

			// check it

			assertEquals(status, sysmeta.getReplica(0).getReplicationStatus());

        } catch(Exception e) {

            fail("Unexpected error: " + e.getMessage());

        }

	}

	/**

	 * Run an initial test that always passes to check that the test harness is

	 * working.

	 */

	public void initialize() 

	{

	    printTestHeader("initialize");

		assertTrue(1 == 1);

	}

	/**

	 * create system metadata with a specified id

	 */

	private SystemMetadata createSystemMetadata(Identifier id, Subject owner)

	  throws Exception

	{

	    SystemMetadata sm = new SystemMetadata();

        // set the id

        sm.setIdentifier(id);

        sm.setObjectFormat(ObjectFormatCache.getInstance().getFormat("application/octet-stream"));

        // create the checksum

        String checksumS = "test";

        ChecksumAlgorithm ca = ChecksumAlgorithm.convert("MD5");

        Checksum checksum = new Checksum();

        checksum.setValue(checksumS);

        checksum.setAlgorithm(ca);

        sm.setChecksum(checksum);

        // set the size

        sm.setSize(0);

        sm.setSubmitter(owner);

        sm.setRightsHolder(owner);

        sm.setDateUploaded(new Date());

        sm.setDateSysMetadataModified(new Date());

        NodeReference nr = new NodeReference();

        nr.setValue("metacat");

        sm.setOriginMemberNode(nr);

        sm.setAuthoritativeMemberNode(nr);

		// set the access to public read

        AccessPolicy accessPolicy = new AccessPolicy();

        AccessRule allow = new AccessRule();

        allow.addPermission(Permission.READ);

        Subject publicSubject = new Subject();

        publicSubject.setValue(Constants.PUBLIC_SUBJECT);

		allow.addSubject(publicSubject);

		accessPolicy.addAllow(allow);

        sm.setAccessPolicy(accessPolicy);

        return sm;

	}

	/**

	 * For fresh Metacat installations without the Object Format List

	 * we insert the default version from d1_common.jar

	 */

	private void setUpFormats() {

		try {

			Metacat m = MetacatFactory.createMetacatConnection(metacatUrl);

			m.login(username, password);

			// check if it exists already

			InputStream is = null;

			try {

				is = m.read(ObjectFormatService.OBJECT_FORMAT_DOCID);

			} catch (Exception e) {

				// probably missing the doc

			}

			if (is == null) {

				ObjectFormatList formats = ObjectFormatServiceImpl.getInstance().listFormats();

				ByteArrayOutputStream out = new ByteArrayOutputStream();

				ServiceTypeUtil.serializeServiceType(ObjectFormatList.class, formats, out);

				Reader xmlDocument = new InputStreamReader(new ByteArrayInputStream(out.toByteArray()));

				m.insert(ObjectFormatService.OBJECT_FORMAT_DOCID + ".1", xmlDocument, null);

			}

			m.logout();

		} catch (Exception e) {

			// any number of things could go wrong

			e.printStackTrace();

		}

	}

	/**

	 * test to list the object formats registered in metacat

	 */

	public void testListFormats() {

    printTestHeader("testListFormats");

    // make sure we are set up

    setUpFormats();

    // there should be at least 59 formats in the list

  	int formatsCount = 59;

  	ObjectFormatList objectFormatList;

  	try {

	    objectFormatList = CNodeService.getInstance().listFormats();

	  	assertTrue(objectFormatList.getTotal() >= formatsCount);

  	} catch (InvalidRequest e) {

  		fail("Could not get the object format list: " + e.getMessage());

  	} catch (ServiceFailure e) {

  		fail("Could not get the object format list: " + e.getMessage());

    } catch (NotFound e) {

  		fail("Could not get the object format list: " + e.getMessage());

    } catch (InsufficientResources e) {

  		fail("Could not get the object format list: " + e.getMessage());

    } catch (NotImplemented e) {

  		fail("Could not get the object format list: " + e.getMessage());

    }

	}

  /**

   * Test getting a single object format from the registered list

   */

  public void testGetFormat() {

    printTestHeader("testGetFormat");

    // make sure we are set up

    setUpFormats();

    String knownFormat = "text/plain";

    ObjectFormatIdentifier fmtid = new ObjectFormatIdentifier();

    fmtid.setValue(knownFormat);

    try {

			String result = 

				CNodeService.getInstance().getFormat(fmtid).getFmtid().getValue();

	  	System.out.println("Expected result: " + knownFormat);

	  	System.out.println("Found    result: " + result);

	  	assertTrue(result.equals(knownFormat));

    } catch (NullPointerException npe) {	  

	    fail("The returned format was null: " + npe.getMessage());

    } catch (NotFound nfe) {     

    	fail("The format " + knownFormat + " was not found: " + nfe.getMessage());

    } catch (InvalidRequest ire) {

    	fail("The format " + knownFormat + " was not found: " + ire.getMessage());

    } catch (ServiceFailure sfe) {

    	fail("The format " + knownFormat + " was not found: " + sfe.getMessage());

    } catch (InsufficientResources ise) {

    	fail("The format " + knownFormat + " was not found: " + ise.getMessage());

    } catch (NotImplemented nie) {

    	fail("The getFormat() method has not been implemented: " + nie.getMessage());

    }

  }

  /**

   * Test getting a non-existent object format, returning NotFound

   */

  public void testObjectFormatNotFoundException() {

    printTestHeader("testObjectFormatNotFoundException");

    ObjectFormatIdentifier fmtid = new ObjectFormatIdentifier();

  	String badFormat = "text/bad-format";

  	fmtid.setValue(badFormat);

  	try {

	    ObjectFormat objectFormat = 

	    	CNodeService.getInstance().getFormat(fmtid);

  	} catch (Exception e) {

  		assertTrue(e instanceof NotFound);

  	}

  }

	/**

	 * print a header to start each test

	 */

	private void printTestHeader(String testName)

	{

	    System.out.println();

	    System.out.println("*************** " + testName + " ***************");

	}

}