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-09-07 17:16:19 -0700 (Wed, 07 Sep 2011) $'

 * '$Revision: 6397 $'

 *

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

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.Reader;

import java.math.BigInteger;

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

import java.util.Date;

import org.dataone.client.ObjectFormatCache;

import org.dataone.service.util.Constants;

import org.dataone.service.util.TypeMarshaller;

import org.dataone.service.types.v1.util.ObjectFormatServiceImpl;

import org.dataone.service.types.v1.AccessPolicy;

import org.dataone.service.types.v1.AccessRule;

import org.dataone.service.types.v1.Checksum;

import org.dataone.service.types.v1.Identifier;

import org.dataone.service.types.v1.NodeReference;

import org.dataone.service.types.v1.ObjectFormatList;

import org.dataone.service.types.v1.Permission;

import org.dataone.service.types.v1.Session;

import org.dataone.service.types.v1.Subject;

import org.dataone.service.types.v1.SystemMetadata;

import edu.ucsb.nceas.MCTestCase;

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

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

/**

 * A JUnit superclass for testing the dataone Node implementations

 */

public class D1NodeServiceTest extends MCTestCase {   

    /**

    * constructor for the test

    */

    public D1NodeServiceTest(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() {}

	/**

	 * constructs a "fake" session with a test subject

	 * @return

	 */

	protected Session getTestSession() {

		Session session = new Session();

        Subject subject = new Subject();

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

        session.setSubject(subject);

        return session;

	}

	/**

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

	 * working.

	 */

	public void initialize() 

	{

	    printTestHeader("initialize");

		assertTrue(1 == 1);

	}

    private static String checksum(InputStream is) throws NoSuchAlgorithmException, IOException {

        byte[] buffer = new byte[1024];

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

        int numRead;

        do {

            numRead = is.read(buffer);

            if (numRead > 0) {

                complete.update(buffer, 0, numRead);

            }

        } while (numRead != -1);

        // rest to beginning -- not all streams support this

        is.reset();

        String csStr = getHex(complete.digest());

        return csStr;

    }

	/**

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

    }

	/**

	 * create system metadata with a specified id

	 */

	protected SystemMetadata createSystemMetadata(Identifier id, Subject owner, InputStream object)

	  throws Exception

	{

	    SystemMetadata sm = new SystemMetadata();

        // set the id

        sm.setIdentifier(id);

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

        // create the checksum

        String checksumS = "test";

        if (object != null) {

        	checksumS = checksum(object);

        }

        String ca = "MD5";

        Checksum checksum = new Checksum();

        checksum.setValue(checksumS);

        checksum.setAlgorithm(ca);

        sm.setChecksum(checksum);

        // set the size

        sm.setSize(new BigInteger("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

	 */

	protected 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();

				TypeMarshaller.marshalTypeToOutputStream(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();

		}

	}

	/**

	 * print a header to start each test

	 */

	protected void printTestHeader(String testName)

	{

	    System.out.println();

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

	}

}