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-05 11:54:57 -0700 (Tue, 05 Jul 2011) $'

 * '$Revision: 6287 $'

 *

 * 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 static org.junit.Assert.assertTrue;

import static org.junit.Assert.fail;

import java.util.Date;

import junit.framework.Test;

import junit.framework.TestSuite;

import org.dataone.client.ObjectFormatCache;

import org.dataone.service.exceptions.InsufficientResources;

import org.dataone.service.exceptions.InvalidRequest;

import org.dataone.service.exceptions.NotFound;

import org.dataone.service.exceptions.NotImplemented;

import org.dataone.service.exceptions.ServiceFailure;

import org.dataone.service.types.Checksum;

import org.dataone.service.types.ChecksumAlgorithm;

import org.dataone.service.types.Identifier;

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.Session;

import org.dataone.service.types.Subject;

import org.dataone.service.types.SystemMetadata;

import edu.ucsb.nceas.MCTestCase;

/**

 * 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("testListFormats"));

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

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

		return suite;

	}

	/**

	 * test for registering standalone system metadata

	 */

	public void testRegisterSystemMetadata()

	{

	    printTestHeader("testRegisterSystemMetadata");

	    try {

            Session session = new Session();

            Subject subject = new Subject();

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

            session.setSubject(subject);

			Identifier guid = new Identifier();

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

			SystemMetadata sysmeta = createSystemMetadata(guid, subject);

			CNodeService.getInstance().registerSystemMetadata(session, guid, sysmeta);

        }

        catch(Exception e)

        {

            fail("Unexpected error in testDescribe: " + 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);

        return sm;

	}

	/**

	 * test to list the object formats registered in metacat

	 */

	public void testListFormats() {

    printTestHeader("testListFormats");

    // 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");

    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 + " ***************");

	}

}