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: berkley $'

 *     '$Date: 2010-05-03 14:26:08 -0700 (Fri, 14 Aug 2009) $'

 * '$Revision: 5027 $'

 *

 * 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.util.*;

import java.io.*;

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

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

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

import edu.ucsb.nceas.metacat.dataone.CrudService;

import junit.framework.Test;

import junit.framework.TestSuite;

import edu.ucsb.nceas.metacat.properties.PropertyService;

import edu.ucsb.nceas.metacat.client.rest.MetacatRestClient;

import edu.ucsb.nceas.metacat.service.SessionService;

import edu.ucsb.nceas.metacat.util.SessionData;

 * A JUnit test for testing the dataone CrudService class

 */

public class CrudServiceTest extends MCTestCase

    /**

    * consstructor for the test

    */

    public CrudServiceTest(String name)

    {

        super(name);

    }

	 */

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

	}

	/**

     *       InputStream object, Identifier obsoletedGuid, SystemMetadata sysmeta)

     *         throws InvalidToken, ServiceFailure, NotAuthorized, IdentifierNotUnique,

     *           UnsupportedType, InsufficientResources, NotFound, InvalidSystemMetadata,

     *           NotImplemented

	 */

	public void testUpdate()

	{

	    printTestHeader("testUpdate");

	    try

	    {

	        CrudService cs = CrudService.getInstance();

	        AuthToken token = getToken();

            //create a doc

            Identifier id = createDoc(token, getTestDoc());

            String gotDoc = getDoc(token, id);

            SystemMetadata sm = getSystemMetadata(token, id);

            gotDoc = gotDoc.replaceAll("XXX", "YYY");

            Identifier newid = new Identifier();

            newid.setValue(generateDocumentId());

            StringBufferInputStream sbis = new StringBufferInputStream(gotDoc);

            SystemMetadata newsm = createSystemMetadata(newid, gotDoc);

            Identifier updatedid = cs.update(token, newid, sbis, id, newsm);

            String newdoc = getDoc(token, newid);

            assertTrue(gotDoc.equals(newdoc));

            SystemMetadata newnewsm = getSystemMetadata(token, id);

            //get the new sysmeta and make sure the obsoletes field is set

            SystemMetadata newnewnewsm = getSystemMetadata(token, newid);

            assertTrue(newnewnewsm.getObsolete(0).getValue().equals(id.getValue()));

        catch(Exception e)

        {

            e.printStackTrace();

            fail("Error in testUpdate: " + e.getMessage());

        }

	}

	/**

     *       throws InvalidToken, ServiceFailure, NotAuthorized, NotFound,

     *       InvalidRequest, NotImplemented

	 */

	public void testGetSystemMetadata()

	{

	    try

	    {

            CrudService cs = CrudService.getInstance();

            AuthToken token = getToken();

            //run create

            Identifier id = createDoc(token, getTestDoc());

            //get the systemMetadata and make sure it is the correct object for this testDoc

            SystemMetadata sm = getSystemMetadata(token, id);

            assertTrue(sm.getIdentifier().getValue().equals(id.getValue()));

            assertTrue(sm.getChecksum().getValue().equals(checksum(getTestDoc())));

            try

            {

                Identifier fakeid = new Identifier();

                fakeid.setValue("somethingfake.234234");

                getSystemMetadata(token, fakeid);

                fail("getSystemMetadata should have thrown an exception.");

            }

            catch(Exception e)

            {

                assertTrue(true);

            }

        catch(Exception e)

        {

            e.printStackTrace();

            fail("Error testing system metadata: " + e.getMessage());

        }

	/**

     *   throws InvalidToken, ServiceFailure, NotAuthorized, IdentifierNotUnique, UnsupportedType,

     *       InsufficientResources, InvalidSystemMetadata, NotImplemented

     * public InputStream get(AuthToken token, Identifier guid)

     *       throws InvalidToken, ServiceFailure, NotAuthorized, NotFound,

     *       NotImplemented

	    {

	        AuthToken token = getToken();

	        //run create

            try

            {

                Identifier fakeid = new Identifier();

                fakeid.setValue("somethingfake.234234");

                getDoc(token, fakeid);

                fail("testCreateAndGet should have thrown an exception.");

            }

            catch(Exception e)

            {

                assertTrue(true);

            }

        catch(Exception e)

        {

            e.printStackTrace();

            fail("Error in testCreate: " + e.getMessage());

        }

	}

	/**

	 */

	public void testSingletonAccessor()

	{

	    assertNotNull(cs);

	}

	/**

	 * working.

	 */

	public void initialize()

	{

	}

	 */

	private SystemMetadata getSystemMetadata(AuthToken token, Identifier id)

	  throws Exception

	{

	    CrudService cs = CrudService.getInstance();

	    return cs.getSystemMetadata(token, id);

	}

	/**

	 */

	private String getDoc(AuthToken token, Identifier id)

	  throws Exception

	{

	    CrudService cs = CrudService.getInstance();

	    //try to get the same doc then compare them

        InputStream gotDocStream = cs.get(token, id);

        StringBuffer sb = new StringBuffer();

        byte[] b = new byte[1024];

        int numread = gotDocStream.read(b, 0, 1024);

        while(numread != -1)

        {

            sb.append(new String(b, 0, numread));

            numread = gotDocStream.read(b, 0, 1024);

        }

        return sb.toString();

	}

	/**

	 * return a test document

	 */

	{

	/**

	 * authenticate and return a token

	 */

	private AuthToken getToken()

	  throws Exception

	{

	    CrudService cs = CrudService.getInstance();

        //login and get a sessionid

        MetacatRestClient restClient = new MetacatRestClient(cs.getContextUrl());

        String username = PropertyService.getProperty("test.mcUser");

        String password = PropertyService.getProperty("test.mcPassword");

        String response = restClient.login(username, password);

        String sessionid = restClient.getSessionId();

        SessionService sessionService = SessionService.getInstance();

        sessionService.registerSession(new SessionData(sessionid, username, new String[0], password, "CrudServiceLogin"));

        AuthToken token = new AuthToken(sessionid);

        return token;

	}

	/**

	    Identifier id;

        CrudService cs = CrudService.getInstance();

        id = new Identifier();

        String docid = generateDocumentId();

        id.setValue(docid);

        StringBufferInputStream sbis = new StringBufferInputStream(testDoc);

        //create the doc

        cs.create(token, id, sbis, sm);

        return id;

	}

	/**

	 * create a generic SystemMetadata object for testing

	 */

	private SystemMetadata createSystemMetadata(Identifier id, String testDoc)

	  throws Exception

	{

	    SystemMetadata sm = new SystemMetadata();

        sm.setIdentifier(id);

        sm.setObjectFormat(ObjectFormat.convert("eml://ecoinformatics.org/eml-2.1.0"));

        //create the checksum

        String checksumS = checksum(testDoc);

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

        Checksum checksum = new Checksum();

        checksum.setValue(checksumS);

        checksum.setAlgorithm(ca);

        sm.setChecksum(checksum);

        //set the size

        sm.setSize(testDoc.getBytes().length);

        //submitter

        Principal p = new Principal();

        p.setValue("joe");

        sm.setSubmitter(p);

        sm.setRightsHolder(p);

        sm.setDateUploaded(new Date());

        sm.setDateSysMetadataModified(new Date());

        NodeReference nr = new NodeReference();

        nr.setValue("metacat");

        sm.setOriginMemberNode(nr);

        sm.setAuthoritativeMemberNode(nr);

	/**

	 * print a header to start each test

	 */

	private void printTestHeader(String testName)

	{

	    System.out.println();

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

	}

	 * produce an md5 checksum for item

	 */

	private String checksum(String item)

	  throws Exception

	{

        StringBufferInputStream fis =  new StringBufferInputStream(item);

        byte[] buffer = new byte[1024];

        MessageDigest complete = MessageDigest.getInstance("MD5");

        int numRead;

        do

        {

          numRead = fis.read(buffer);

          if (numRead > 0)

          {

            complete.update(buffer, 0, numRead);

          }

        } while (numRead != -1);

        return getHex(complete.digest());

	}

	/**

	 * convert a byte array to a hex string

	 */

	private static String getHex( byte [] raw )

	{

	    final String HEXES = "0123456789ABCDEF";

        if ( raw == null ) {

          return null;

        }

        final StringBuilder hex = new StringBuilder( 2 * raw.length );

        for ( final byte b : raw ) {

          hex.append(HEXES.charAt((b & 0xF0) >> 4))

             .append(HEXES.charAt((b & 0x0F)));

        }

        return hex.toString();

    }