Metacat

/**

 *  '$RCSfile$'

 *    Purpose: A Class that implements a metadata catalog as a java Servlet

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

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Matt Jones, Dan Higgins, Jivka Bojilova, Chad Berkley, Matthew Perry

 *

 *   '$Author: daigle $'

 *     '$Date: 2008-09-24 11:28:29 -0700 (Wed, 24 Sep 2008) $'

 * '$Revision: 4384 $'

 *

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

import java.io.IOException;

import java.io.StringReader;

import java.util.Hashtable;

import javax.xml.xpath.XPath;

import javax.xml.xpath.XPathExpression;

import javax.xml.xpath.XPathFactory;

import org.xml.sax.InputSource;

import edu.ucsb.nceas.MCTestCase;

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

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

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

import edu.ucsb.nceas.metacat.shared.ServiceException;

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

import edu.ucsb.nceas.utilities.PropertyNotFoundException;

import junit.framework.Test;

import junit.framework.TestSuite;

/*

 * A junit test class to test public methods in AuthLdap class.

 */

public class WorkflowSchedulerTest extends MCTestCase {

	// Constants

	private static String docId = null;

	private static String dataDocId = null;

	private static String sessionId = null;

	private static String workflowJobName;

	private static String workflowSchedulerUrl;

	private static XPathFactory xPathFactory = null;

	private static final String WORKFLOW_ID_BASE = "urn:lsid:gamma.msi.ucsb.edu/OpenAuth/:";

	private static String WORKFLOW_ID = null;

	private static final String KAR_ID_BASE = "urn:lsid:gamma.msi.ucsb.edu/OpenAuth/:";

	private static String KAR_ID = null;

	private static final String WORKFLOW_NAME = "tpc02-water-flow-base";

	private static final String START_TIME = "10/10/2008 10:10:10";

	private static final String END_TIME = "10/10/2009 10:10:10";

	private static final String INTERVAL_VALUE = "100";

	private static final String INTERVAL_UNIT = "min";

	static {

		try {

			PropertyService.getInstance();

			workflowSchedulerUrl = PropertyService

					.getProperty("test.workflowSchedulerUrl");

		} catch (PropertyNotFoundException pnfe) {

			System.err.println("Could not get property in static block: "

					+ pnfe.getMessage());

		} catch (ServiceException se) {

			System.err.println("Service problem in static block: " + se.getMessage());

		}

	}

	/**

	 * Constructor to build the test

	 * 

	 * @param name

	 *            the name of the test method

	 */

	public WorkflowSchedulerTest(String name) {

		super(name);

		xPathFactory = XPathFactory.newInstance();

	}

	/**

	 * Establish a testing framework by initializing appropriate objects

	 */

	public void setUp() throws Exception {

		metacatConnectionNeeded = true;

		super.setUp();	

		//debug("session id: " + sessionId);

		//debug("doc id: " + docId);

		//debug("data doc id: " + dataDocId);

		try {

			if (sessionId == null) {

				String loginResult = m.login(username, password);

				//debug("WorkflowSchedulerTest.initialize - login result: " + loginResult);

				if (loginResult.contains("<sessionId>")) {

					int startIndex = loginResult.indexOf("<sessionId>") + 11;

					int endIndex = loginResult.indexOf("</sessionId>");

					sessionId = loginResult.substring(startIndex, endIndex);

					//debug("WorkflowSchedulerTest.initialize - session id: " + sessionId);

				} else {

					fail("could not get session ID from login results");

				}

			}

			if (docId == null) {

				// insert a document for us to test with

				docId = generateDocumentId() + ".1";

				String testDoc = 

					getTestDocFromFile(testdatadir + "tpc02-water-flow-base.xml");

				// debug("test doc: " + testDoc);

				insertDocumentId(docId, testDoc, SUCCESS, false);

				WORKFLOW_ID = WORKFLOW_ID_BASE + docId.replace('.', ':');

			}

			if (dataDocId == null) {

				// insert a data document (kar file) for us to test with

				dataDocId = generateDocumentId() + ".1";

				String filePath = testdatadir + "888.42.1-tpc02-water-flow-base-10.kar";

				// debug("test doc: " + testDoc);

				uploadDocumentId(dataDocId, filePath, SUCCESS, false);

				KAR_ID = KAR_ID_BASE + dataDocId.replace('.', ':');

			}

		} catch (IOException ioe) {

			fail("WorkflowSchedulerTest.initialize - I/O exception: " + ioe.getMessage());

		} catch (MetacatInaccessibleException mie) {

			fail("WorkflowSchedulerTest.initialize - Metacat Inaccessible: " + mie.getMessage());

		} catch (MetacatAuthException mae) {

			fail("WorkflowSchedulerTest.initialize - Metacat auth issue: " + mae.getMessage());

		}	

	}

	/**

	 * Create a suite of tests to be run together

	 */

	public static Test suite() {

		TestSuite suite = new TestSuite();

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

		suite.addTest(new WorkflowSchedulerTest("scheduleJobTest"));

		suite.addTest(new WorkflowSchedulerTest("unscheduleJobTest"));

		suite.addTest(new WorkflowSchedulerTest("rescheduleJobTest"));

		suite.addTest(new WorkflowSchedulerTest("deleteJobTest"));

		return suite;

	}

	/**

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

	 * working.

	 */

	public void initialize() {

		assertTrue(1 == 1);

	}

    public void scheduleJobTest() {

		try {	

			Hashtable<String, String[]> params = new Hashtable<String, String[]>();

			params.put("action", new String[] { "scheduleWorkflow" });

			params.put("workflowid",

					new String[] { WORKFLOW_ID });

			params.put("karid",

					new String[] { KAR_ID });

			params.put("workflowname", new String[] { WORKFLOW_NAME });

			params.put("starttime", new String[] { START_TIME });

			params.put("endtime", new String[] { END_TIME });

			params.put("intervalvalue", new String[] { INTERVAL_VALUE });

			params.put("intervalunit", new String[] { INTERVAL_UNIT });	

			params.put("sessionid", new String[] { sessionId });

			debug("WorkflowSchedulerTest.scheduleJobTest - sending to url: " + workflowSchedulerUrl);

			String schedulerResponse = RequestUtil.get(workflowSchedulerUrl, params);

			debug("WorkflowSchedulerTest.scheduleJobTest - response: " + schedulerResponse);

			XPath xPath=xPathFactory.newXPath();

			XPathExpression xPathExpression = xPath.compile("/success");

			String successMessage = xPathExpression.evaluate(new InputSource(new StringReader(schedulerResponse)));

			assertTrue("success message did not start with 'Scheduled'", 

					successMessage != null && successMessage.startsWith("Scheduled:"));

			String[] successMessageArray = successMessage.split(" ");

			workflowJobName = successMessageArray[1];

			debug("WorkflowSchedulerTest.scheduleJobTest - workflow job name: " + workflowJobName);

			Hashtable<String, String[]> getWorkflowParams = new Hashtable<String, String[]>();

			getWorkflowParams.put("action", new String[] { "getScheduledWorkflow" });

			getWorkflowParams.put("workflowid", new String[] { WORKFLOW_ID });

			String getWorkflowsResponse = RequestUtil.get(workflowSchedulerUrl, getWorkflowParams);

			//debug("WorkflowSchedulerTest.scheduleJobTest - get runs for workflow id " + WORKFLOW_ID + " returns: " + getWorkflowsResponse);

			XPath getWorkflowsXPath=xPathFactory.newXPath();

			XPathExpression getStatusXPathExpression = getWorkflowsXPath.compile("/scheduledWorkflowResultset/scheduledJob[name=\"" + workflowJobName + "\"]/status");

			String status = getStatusXPathExpression.evaluate(new InputSource(new StringReader(getWorkflowsResponse)));

			assertTrue(status != null && status.equals("scheduled"));

		} catch (Exception e) {

			fail("WorkflowSchedulerTest.scheduleJobTest - General exception:\n" + e.getMessage());

		}

	}

    public void unscheduleJobTest() {

		try {

			String loginResult = m.login(username, password);

			String sessionId = null;

			if (loginResult.contains("<sessionId>")) {

				int startIndex = loginResult.indexOf("<sessionId>") + 11;

				int endIndex = loginResult.indexOf("</sessionId>");

				sessionId = loginResult.substring(startIndex, endIndex);

			} else {

				fail("could not get session ID from login results");

			}

			Hashtable<String, String[]> params = new Hashtable<String, String[]>();

			params.put("action", new String[] { "unscheduleWorkflow" });

			params.put("workflowjobname", new String[] { workflowJobName });

			params.put("workflowid", new String[] { WORKFLOW_ID });

			params.put("workflowname", new String[] { "tpc02-water-flow-base" });

			params.put("sessionid", new String[] { sessionId });

			String schedulerResponse = RequestUtil.get(workflowSchedulerUrl, params);

			debug("WorkflowSchedulerTest.unScheduleJobTest - response: " + schedulerResponse);

			XPath xPath=xPathFactory.newXPath();

			XPathExpression xPathExpression = xPath.compile("/success");

			String successMessage = xPathExpression.evaluate(new InputSource(new StringReader(schedulerResponse)));

			assertTrue("success message did not start with 'Unscheduled'", 

					successMessage != null && successMessage.startsWith("Unscheduled:"));

			Hashtable<String, String[]> getWorkflowParams = new Hashtable<String, String[]>();

			getWorkflowParams.put("action", new String[] { "getScheduledWorkflow" });

			getWorkflowParams.put("workflowid", new String[] { WORKFLOW_ID });

			String getWorkflowsResponse = RequestUtil.get(workflowSchedulerUrl, getWorkflowParams);

			//debug("WorkflowSchedulerTest.unScheduleJobTest - get runs for workflow id " + WORKFLOW_ID + " returns: " + getWorkflowsResponse);

			XPath getWorkflowsXPath=xPathFactory.newXPath();

			XPathExpression getStatusXPathExpression = getWorkflowsXPath.compile("/scheduledWorkflowResultset/scheduledJob[name=\"" + workflowJobName + "\"]/status");

			String status = getStatusXPathExpression.evaluate(new InputSource(new StringReader(getWorkflowsResponse)));

			assertTrue(status != null && status.equals("unscheduled"));

		} catch (Exception e) {

			fail("WorkflowSchedulerTest.unScheduleJobTest - General exception:\n" + e.getMessage());

		}

	}

    public void rescheduleJobTest() {

		try {

			String loginResult = m.login(username, password);

			String sessionId = null;

			if (loginResult.contains("<sessionId>")) {

				int startIndex = loginResult.indexOf("<sessionId>") + 11;

				int endIndex = loginResult.indexOf("</sessionId>");

				sessionId = loginResult.substring(startIndex, endIndex);

			} else {

				fail("could not get session ID from login results");

			}

			Hashtable<String, String[]> params = new Hashtable<String, String[]>();

			params.put("action", new String[] { "rescheduleWorkflow" });

			params.put("workflowjobname", new String[] { workflowJobName });

			params.put("workflowid",

					new String[] { WORKFLOW_ID });

			params.put("workflowname", new String[] { "tpc02-water-flow-base" });

			params.put("sessionid", new String[] { sessionId });

			String schedulerResponse = RequestUtil.get(workflowSchedulerUrl, params);

			debug("WorkflowSchedulerTest.reScheduleJobTest - response: " + schedulerResponse);

			XPath xPath=xPathFactory.newXPath();

			XPathExpression xPathExpression = xPath.compile("/success");

			String successMessage = xPathExpression.evaluate(new InputSource(new StringReader(schedulerResponse)));

			assertTrue("success message did not start with 'Rescheduled'", 

					successMessage != null && successMessage.startsWith("Rescheduled:"));

			Hashtable<String, String[]> getWorkflowParams = new Hashtable<String, String[]>();

			getWorkflowParams.put("action", new String[] { "getScheduledWorkflow" });

			getWorkflowParams.put("workflowid", new String[] { WORKFLOW_ID });

			String getWorkflowsResponse = RequestUtil.get(workflowSchedulerUrl, getWorkflowParams);

			//debug("WorkflowSchedulerTest.reScheduleJobTest - get runs for workflow id " + WORKFLOW_ID + " returns: " + getWorkflowsResponse);

			XPath getWorkflowsXPath=xPathFactory.newXPath();

			XPathExpression getStatusXPathExpression = getWorkflowsXPath.compile("/scheduledWorkflowResultset/scheduledJob[name=\"" + workflowJobName + "\"]/status");

			String status = getStatusXPathExpression.evaluate(new InputSource(new StringReader(getWorkflowsResponse)));

			assertTrue(status != null && status.equals("scheduled"));

		} catch (Exception e) {

			fail("WorkflowSchedulerTest.reScheduleJobTest - General exception:\n" + e.getMessage());

		}

	}

    public void deleteJobTest() {

		try {

			String loginResult = m.login(username, password);

			String sessionId = null;

			if (loginResult.contains("<sessionId>")) {

				int startIndex = loginResult.indexOf("<sessionId>") + 11;

				int endIndex = loginResult.indexOf("</sessionId>");

				sessionId = loginResult.substring(startIndex, endIndex);

			} else {

				fail("could not get session ID from login results");

			}

			Hashtable<String, String[]> params = new Hashtable<String, String[]>();

			params.put("action", new String[] { "deleteScheduledWorkflow" });

			params.put("workflowjobname", new String[] { workflowJobName });

			params.put("sessionid", new String[] { sessionId });

			String schedulerResponse = RequestUtil.get(workflowSchedulerUrl, params);

			debug("WorkflowSchedulerTest.deleteJobTest - response: " + schedulerResponse);

			XPath xPath=xPathFactory.newXPath();

			XPathExpression xPathExpression = xPath.compile("/success");

			String successMessage = xPathExpression.evaluate(new InputSource(new StringReader(schedulerResponse)));

			assertTrue("success message did not start with 'Deleted'", 

					successMessage != null && successMessage.startsWith("Deleted:"));

			Hashtable<String, String[]> getWorkflowParams = new Hashtable<String, String[]>();

			getWorkflowParams.put("action", new String[] { "getScheduledWorkflow" });

			getWorkflowParams.put("workflowid", new String[] { WORKFLOW_ID });

			String getWorkflowsResponse = RequestUtil.get(workflowSchedulerUrl, getWorkflowParams);

			//debug("WorkflowSchedulerTest.deleteJobTest - get runs for workflow id " + WORKFLOW_ID + " returns: " + getWorkflowsResponse);

			XPath getWorkflowsXPath=xPathFactory.newXPath();

			XPathExpression getStatusXPathExpression = getWorkflowsXPath.compile("/scheduledWorkflowResultset/scheduledJob[name=\"" + workflowJobName + "\"]/status");

			String status = getStatusXPathExpression.evaluate(new InputSource(new StringReader(getWorkflowsResponse)));

			assertTrue(status == null || status.equals(""));

		} catch (Exception e) {

			fail("WorkflowSchedulerTest.deleteJobTest - General exception:\n" + e.getMessage());

		}

	}

}