BuildConfigurationIT.java

/*******************************************************************************
 * Copyright (c) 2013, 2016 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package com.ibm.team.build.internal.hjplugin.tests;

import java.io.File;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.util.Locale;
import java.util.Map;

import org.apache.commons.lang.SystemUtils;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.Assert;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.assertEquals;

import com.ibm.team.build.internal.hjplugin.RTCChangeLogParser;
import com.ibm.team.build.internal.hjplugin.RTCChangeLogSet;
import com.ibm.team.build.internal.hjplugin.RTCFacadeFactory.RTCFacadeWrapper;
import com.ibm.team.build.internal.hjplugin.RTCLoginInfo;
import com.ibm.team.build.internal.hjplugin.tests.utils.AbstractTestCase;
import com.ibm.team.build.internal.hjplugin.tests.utils.FileUtils;
import com.ibm.team.build.internal.hjplugin.tests.utils.Utils;

import hudson.model.TaskListener;
import hudson.util.StreamTaskListener;

@SuppressWarnings("nls")
public class BuildConfigurationIT extends AbstractTestCase {
	private static final String ARTIFACT_WORKSPACE_ITEM_ID = "workspaceItemId";
	private static final String ARTIFACT_STREAM_ITEM_ID = "streamItemId";
	private static final String ARTIFACT_COMPONENT1_ITEM_ID = "component1ItemId";

	private File sandboxDir;
	private RTCFacadeWrapper testingFacade;

	@Before
	public void setUp() throws Exception {

		if (Config.DEFAULT.isConfigured()) {
			// DO NOT initialize Hudson/Jenkins because its slow and we don't need it for the tests
			
			testingFacade = Utils.getTestingFacade();
			
	        File tempDir = new File(System.getProperty("java.io.tmpdir"));
	        File buildTestDir = new File(tempDir, "HJPluginTests");
	        sandboxDir = new File(buildTestDir, getFileUniqueName());
	        sandboxDir.mkdirs();
	        sandboxDir.deleteOnExit();
	        Assert.assertTrue(sandboxDir.exists());
		}
	}

	@After
	public void tearDown() throws Exception {
		// delete the sandbox after Hudson/Jenkins is shutdown
		if (Config.DEFAULT.isConfigured()) {
			// Nothing to do including no need to shutdown Hudson/Jenkins
			FileUtils.delete(sandboxDir);
		}
	}
	
	@Test
	public void testComponentLoading() throws Exception {
		// Test relative location for fetch destination
		// Test create folders for components
		// Test include/exclude components from the load
		
		// setup build request & verify BuildConfiguration
		// checkout & verify contents on disk
		if (Config.DEFAULT.isConfigured()) {
			
			String fetchLocation = "path\\relative";
			RTCLoginInfo loginInfo = Config.DEFAULT.getLoginInfo();
			String workspaceName = getRepositoryWorkspaceUniqueName();
			String componentName = getComponentUniqueName();
			@SuppressWarnings("unchecked")
			Map<String, String> setupArtifacts = (Map<String, String>) testingFacade
					.invoke("testComponentLoading",
							new Class[] { String.class, // serverURL,
									String.class, // userId,
									String.class, // password,
									int.class, // timeout,
									String.class, // workspaceName,
									String.class, // componentName,
									String.class, // hjPath,
									String.class}, // buildPath
							loginInfo.getServerUri(),
							loginInfo.getUserId(),
							loginInfo.getPassword(),
							loginInfo.getTimeout(), workspaceName,
							componentName,
							sandboxDir.getPath(),
							fetchLocation);
			
			try {
				TaskListener listener = new StreamTaskListener(System.out, null);
				
				File changeLogFile = new File(sandboxDir, "RTCChangeLogFile");
				FileOutputStream changeLog = new FileOutputStream(changeLogFile);
				
				// checkout the changes
				Map<String, String> buildProperties = Utils.acceptAndLoad(testingFacade, loginInfo.getServerUri(),
						loginInfo.getUserId(),
						loginInfo.getPassword(),
						loginInfo.getTimeout(),
						setupArtifacts.get("buildResultItemId"), null,
						sandboxDir.getCanonicalPath(), changeLog,
						"Snapshot", listener, Locale.getDefault());
	    		
				String[] children = sandboxDir.list();
				Assert.assertEquals(2, children.length); // changelog plus what we loaded
				File actualRoot = new File(sandboxDir, "path\\relative");
				Assert.assertTrue(actualRoot.exists());
				children = actualRoot.list();
				assertEquals(2, children.length); // metadata plus component root folder
				File shareRoot = new File(actualRoot, componentName);
				Assert.assertTrue(shareRoot.exists());
				Assert.assertTrue(new File(shareRoot, "f").exists());
				Assert.assertTrue(new File(shareRoot, "f/a.txt").exists());
				
	    		RTCChangeLogParser parser = new RTCChangeLogParser();
	    		FileReader changeLogReader = new FileReader(changeLogFile);
	    		RTCChangeLogSet result = (RTCChangeLogSet) parser.parse(null, null, changeLogReader);
	    		
	    		// verify the result
	    		int changeCount = result.getComponentChangeCount() +
	    				result.getChangeSetsAcceptedCount() + result.getChangeSetsDiscardedCount();
	    		Assert.assertFalse(result.isPersonalBuild());

				validateBuildProperties(setupArtifacts.get(ARTIFACT_WORKSPACE_ITEM_ID),
						fetchLocation, false, true, "",
						true, setupArtifacts.get(ARTIFACT_COMPONENT1_ITEM_ID), result.getBaselineSetItemId(),
						changeCount,
						true,
						buildProperties);
				
			} finally {
				// clean up
				testingFacade.invoke(
						"tearDown",
						new Class[] { String.class, // serverURL,
								String.class, // userId,
								String.class, // password,
								int.class, // timeout,
								Map.class}, // setupArtifacts
						loginInfo.getServerUri(),
						loginInfo.getUserId(),
						loginInfo.getPassword(),
						loginInfo.getTimeout(), setupArtifacts);
			}
		}
	}
	
	private void validateBuildProperties(String workspaceItemId,
			String fetchDestination,
			boolean deleteBeforeFetch,
			boolean acceptBeforeFetch,
			String componentLoadRules,
			boolean includeComponents,
			String loadComponents,
			String snapshotItemId,
			int changesAccepted,
			boolean createFoldersForComponents,
			Map<String, String> properties) {

	    final String PROPERTY_WORKSPACE_UUID = "team_scm_workspaceUUID"; //$NON-NLS-1$
	    final String PROPERTY_FETCH_DESTINATION = "team_scm_fetchDestination"; //$NON-NLS-1$
	    final String PROPERTY_DELETE_DESTINATION_BEFORE_FETCH = "team_scm_deleteDestinationBeforeFetch"; //$NON-NLS-1$
	    final String PROPERTY_ACCEPT_BEFORE_FETCH = "team_scm_acceptBeforeFetch"; //$NON-NLS-1$
	    final String PROPERTY_BUILD_ONLY_IF_CHANGES = "team_scm_buildOnlyIfChanges"; //$NON-NLS-1$
	    final String PROPERTY_COMPONENT_LOAD_RULES = "team_scm_componentLoadRules"; //$NON-NLS-1$
	    final String PROPERTY_INCLUDE_COMPONENTS = "team_scm_includeComponents"; //$NON-NLS-1$
	    final String PROPERTY_LOAD_COMPONENTS = "team_scm_loadComponents"; //$NON-NLS-1$
	    final String PROPERTY_SNAPSHOT_UUID = "team_scm_snapshotUUID"; //$NON-NLS-1$
	    final String PROPERTY_CHANGES_ACCEPTED = "team_scm_changesAccepted"; //$NON-NLS-1$
	    final String PROPERTY_CREATE_FOLDERS_FOR_COMPONENTS = "team_scm_createFoldersForComponents"; //$NON-NLS-1$
	    
	    Assert.assertEquals(workspaceItemId, properties.get(PROPERTY_WORKSPACE_UUID));
	    Assert.assertEquals(fetchDestination, properties.get(PROPERTY_FETCH_DESTINATION));
	    Assert.assertEquals(Boolean.toString(deleteBeforeFetch), properties.get(PROPERTY_DELETE_DESTINATION_BEFORE_FETCH));
	    Assert.assertEquals(Boolean.toString(acceptBeforeFetch), properties.get(PROPERTY_ACCEPT_BEFORE_FETCH));
	    Assert.assertEquals(componentLoadRules, properties.get(PROPERTY_COMPONENT_LOAD_RULES));
    	String property = properties.get(PROPERTY_INCLUDE_COMPONENTS);
    	if (property != null) {
	    	Assert.assertEquals(Boolean.toString(includeComponents), properties.get(PROPERTY_INCLUDE_COMPONENTS));
	    } else {
	    	Assert.assertFalse(includeComponents);
	    }
	    Assert.assertEquals(loadComponents, properties.get(PROPERTY_LOAD_COMPONENTS));
	    Assert.assertEquals(snapshotItemId, properties.get(PROPERTY_SNAPSHOT_UUID));
	    Assert.assertEquals((changesAccepted > 0 ? Integer.toString(changesAccepted) : null), properties.get(PROPERTY_CHANGES_ACCEPTED));
	    Assert.assertEquals(Boolean.toString(createFoldersForComponents), properties.get(PROPERTY_CREATE_FOLDERS_FOR_COMPONENTS));
		
	}

	@Test public void testGoodRelativeFetchLocation() throws Exception {
		if (Config.DEFAULT.isConfigured()) {
			RTCLoginInfo loginInfo = Config.DEFAULT.getLoginInfo();
			
			String fetchLocation = "relative\\is\\ok";
			String workspaceName = getRepositoryWorkspaceUniqueName();
			String componentName = getComponentUniqueName();
			
			@SuppressWarnings("unchecked")
			Map<String, String> setupArtifacts = (Map<String, String>) testingFacade
					.invoke("testGoodFetchLocation",
							new Class[] { String.class, // serverURL,
									String.class, // userId,
									String.class, // password,
									int.class, // timeout,
									String.class, // workspaceName,
									String.class, // componentName,
									String.class, // hjPath,
									String.class}, // buildPath
							loginInfo.getServerUri(),
							loginInfo.getUserId(),
							loginInfo.getPassword(),
							loginInfo.getTimeout(), workspaceName,
							componentName,
							sandboxDir.getPath(),
							fetchLocation);
			
			// clean up
			testingFacade.invoke(
					"tearDown",
					new Class[] { String.class, // serverURL,
							String.class, // userId,
							String.class, // password,
							int.class, // timeout,
							Map.class}, // setupArtifacts
					loginInfo.getServerUri(),
					loginInfo.getUserId(),
					loginInfo.getPassword(),
					loginInfo.getTimeout(),
					setupArtifacts);
		}
	}

	@Test public void testGoodAbsoluteFetchLocationWin() throws Exception {
		if (Config.DEFAULT.isConfigured()) {
			RTCLoginInfo loginInfo = Config.DEFAULT.getLoginInfo();
			
			String fetchLocation = "C:\\absolute\\is\\ok\\too";
			String workspaceName = getRepositoryWorkspaceUniqueName();
			String componentName = getComponentUniqueName();

			@SuppressWarnings("unchecked")
			Map<String, String> setupArtifacts = (Map<String, String>) testingFacade
					.invoke("testGoodFetchLocation",
							new Class[] { String.class, // serverURL,
									String.class, // userId,
									String.class, // password,
									int.class, // timeout,
									String.class, // workspaceName,
									String.class, // componentName,
									String.class, // hjPath,
									String.class}, // buildPath
							loginInfo.getServerUri(),
							loginInfo.getUserId(),
							loginInfo.getPassword(),
							loginInfo.getTimeout(), getRepositoryWorkspaceUniqueName(),
							getComponentUniqueName(),
							sandboxDir.getPath(),
							fetchLocation);
			
			// clean up
			testingFacade.invoke(
					"tearDown",
					new Class[] { String.class, // serverURL,
							String.class, // userId,
							String.class, // password,
							int.class, // timeout,
							Map.class}, // setupArtifacts
					loginInfo.getServerUri(),
					loginInfo.getUserId(),
					loginInfo.getPassword(),
					loginInfo.getTimeout(), setupArtifacts);
		}
	}

	@Test public void testBadFetchLocationWin() throws Exception {
		if (Config.DEFAULT.isConfigured() && SystemUtils.IS_OS_WINDOWS) {
			RTCLoginInfo loginInfo = Config.DEFAULT.getLoginInfo();
			
			String fetchLocation = "invalid/questionmark?/character/is/not/ok";
			String repositoryWorkspaceName = getRepositoryWorkspaceUniqueName();
			String componentName = getComponentUniqueName();

			@SuppressWarnings("unchecked")
			Map<String, String> setupArtifacts = (Map<String, String>) testingFacade
					.invoke("testBadFetchLocation",
							new Class[] { String.class, // serverURL,
									String.class, // userId,
									String.class, // password,
									int.class, // timeout,
									String.class, // workspaceName,
									String.class, // componentName,
									String.class, // hjPath,
									String.class}, // buildPath
							loginInfo.getServerUri(),
							loginInfo.getUserId(),
							loginInfo.getPassword(),
							loginInfo.getTimeout(), repositoryWorkspaceName,
							componentName,
							sandboxDir.getPath(),
							fetchLocation);
			
			// clean up
			testingFacade.invoke(
					"tearDown",
					new Class[] { String.class, // serverURL,
							String.class, // userId,
							String.class, // password,
							int.class, // timeout,
							Map.class}, // setupArtifacts
					loginInfo.getServerUri(),
					loginInfo.getUserId(),
					loginInfo.getPassword(),
					loginInfo.getTimeout(), setupArtifacts);
		}
	}

	@Test public void testPersonalBuild() throws Exception {
		// create a build definition
		// load directory ${propertyA}/here
		// build properties
		// myPropsFile = ${team.scm.fetchDestination}/com.ibm.team.build.releng/continuous-buildsystem.properties
		// propertyA = loadDir
		// propertyB = a place (${propertyA}) to load some stuff 
		// propertyC = original
		// using a load rule

		// create a build engine
		// create a build request for this test with personal build specified
		// (build workspace overridden, build engine is a random one, override load rule, override a build property)
		
		// verify that the buildConfiguration returns the personal build workspace
		// as the workspace to be loaded
		// verify the load rule is changed
		// verify the build property is changed
		
		// checkout based on the request
		// make sure the personal build workspace was loaded and the load rule used
		if (Config.DEFAULT.isConfigured()) {
			RTCLoginInfo loginInfo = Config.DEFAULT.getLoginInfo();
			
			String workspaceName = getRepositoryWorkspaceUniqueName();
			String componentName = getComponentUniqueName();
			
			@SuppressWarnings("unchecked")
			Map<String, String> setupArtifacts = (Map<String, String>) testingFacade
					.invoke("testPersonalBuild",
							new Class[] { String.class, // serverURL,
									String.class, // userId,
									String.class, // password,
									int.class, // timeout,
									String.class, // workspaceName,
									String.class, // componentName,
									String.class, // hjPath,
									String.class}, // buildPath
							loginInfo.getServerUri(),
							loginInfo.getUserId(),
							loginInfo.getPassword(),
							loginInfo.getTimeout(), workspaceName,
							componentName,
							sandboxDir.getPath(),
							"${propertyA}/here");
			
			try {
				TaskListener listener = new StreamTaskListener(System.out, null);
				
				File changeLogFile = new File(sandboxDir, "RTCChangeLogFile");
				FileOutputStream changeLog = new FileOutputStream(changeLogFile);

				// put extraneous stuff in the load directory (which is different from sandbox cause
				// we want to get a the change log.
				File loadDir = new File(sandboxDir, "loadDir/here");
				assertTrue(loadDir.mkdirs());
				assertTrue(new File(loadDir, "abc").mkdirs());
				assertTrue(new File(loadDir, "def").mkdirs());
				assertTrue(new File(loadDir, "hij").mkdirs());
				
				// checkout the changes
				Map<String, String> buildProperties = Utils.acceptAndLoad(testingFacade, 
						loginInfo.getServerUri(),
						loginInfo.getUserId(),
						loginInfo.getPassword(),
						loginInfo.getTimeout(),
						setupArtifacts.get("buildResultItemId"), null,
						sandboxDir.getCanonicalPath(), changeLog,
						"Snapshot", listener, Locale.getDefault());
	    		
				String[] children = loadDir.list();
				Assert.assertEquals(5, children.length); // just what the load rule says to load (children of f) + metadata
				Assert.assertTrue(new File(loadDir, "b.txt").exists());
				Assert.assertFalse(new File(loadDir, "i.txt").exists());
				assertTrue(new File(loadDir, "abc").exists());
				assertTrue(new File(loadDir, "def").exists());
				assertTrue(new File(loadDir, "hij").exists());
				
	    		RTCChangeLogParser parser = new RTCChangeLogParser();
	    		FileReader changeLogReader = new FileReader(changeLogFile);
	    		RTCChangeLogSet result = (RTCChangeLogSet) parser.parse(null, null, changeLogReader);
	    		
	    		// verify the result
	    		Assert.assertTrue(result.isPersonalBuild());
	    		int changeCount = result.getComponentChangeCount() +
	    				result.getChangeSetsAcceptedCount() + result.getChangeSetsDiscardedCount();
	    		Assert.assertEquals(0, changeCount);

				validateBuildProperties(setupArtifacts.get(ARTIFACT_STREAM_ITEM_ID),
						"loadDir/here", false, true, setupArtifacts.get("LoadRuleProperty"),
						false, "", result.getBaselineSetItemId(),
						changeCount,
						false,
						buildProperties);
				
				// propertyA = loadDir
				// propertyB = a place (${propertyA}) to load some stuff 
				// propertyC = original
				Assert.assertEquals("loadDir", buildProperties.get("propertyA"));
				Assert.assertEquals("a place (loadDir) to load some stuff", buildProperties.get("propertyB"));
				Assert.assertEquals("overwritten", buildProperties.get("propertyC"));
			} finally {
				// clean up
				testingFacade.invoke(
						"tearDown",
						new Class[] { String.class, // serverURL,
								String.class, // userId,
								String.class, // password,
								int.class, // timeout,
								Map.class}, // setupArtifacts
						loginInfo.getServerUri(),
						loginInfo.getUserId(),
						loginInfo.getPassword(),
						loginInfo.getTimeout(), setupArtifacts);
			}
		}
	}

	@Test public void testOldLoadRules() throws Exception {
		// Create build definition with old style load rules
		// load directory missing
		// don't delete directory before loading (dir has other stuff that will not be deleted)
		// don't accept changes before loading

		// create a build engine
		// create a build request
		
		// verify that the buildConfiguration returns the load rules
		// as the workspace to be loaded
		
		// checkout based on the request
		// make sure only the contents identified by the load rule was loaded
		// verify extra stuff from sandbox directory not deleted
		// verify no changes accepted
		if (Config.DEFAULT.isConfigured()) {
			RTCLoginInfo loginInfo = Config.DEFAULT.getLoginInfo();
			
			String workspaceName = getRepositoryWorkspaceUniqueName();
			String componentName = getComponentUniqueName();

			@SuppressWarnings("unchecked")
			Map<String, String> setupArtifacts = (Map<String, String>) testingFacade
					.invoke("testOldLoadRules",
							new Class[] { String.class, // serverURL,
									String.class, // userId,
									String.class, // password,
									int.class, // timeout,
									String.class, // workspaceName,
									String.class, // componentName,
									String.class}, // hjPath,
							loginInfo.getServerUri(),
							loginInfo.getUserId(),
							loginInfo.getPassword(),
							loginInfo.getTimeout(), workspaceName,
							componentName,
							sandboxDir.getPath());
			
			try {
				TaskListener listener = new StreamTaskListener(System.out, null);
				
				File changeLogFile = new File(sandboxDir, "RTCChangeLogFile");
				FileOutputStream changeLog = new FileOutputStream(changeLogFile);
				assertTrue(new File(sandboxDir, "abc").mkdirs());
				assertTrue(new File(sandboxDir, "def").mkdirs());
				assertTrue(new File(sandboxDir, "hij").mkdirs());
				
				// checkout the changes
				Map<String, String> buildProperties = Utils.acceptAndLoad(testingFacade,
						loginInfo.getServerUri(),
						loginInfo.getUserId(),
						loginInfo.getPassword(),
						loginInfo.getTimeout(),
						setupArtifacts.get("buildResultItemId"), null,
						sandboxDir.getCanonicalPath(), changeLog,
						"Snapshot", listener, Locale.getDefault());
	    		
				String[] children = sandboxDir.list();
				Assert.assertEquals(6, children.length); // change log + 3 dirs made + metadata + file loaded
				Assert.assertTrue(new File(sandboxDir, "a.txt").exists());
				Assert.assertFalse(new File(sandboxDir, "h.txt").exists());
				Assert.assertTrue(new File(sandboxDir, "abc").exists());
				Assert.assertTrue(new File(sandboxDir, "def").exists());
				Assert.assertTrue(new File(sandboxDir, "hij").exists());
				
	    		RTCChangeLogParser parser = new RTCChangeLogParser();
	    		FileReader changeLogReader = new FileReader(changeLogFile);
	    		RTCChangeLogSet result = (RTCChangeLogSet) parser.parse(null, null, changeLogReader);
	    		
	    		// verify the result
	    		int changeCount = result.getComponentChangeCount() +
	    				result.getChangeSetsAcceptedCount() + result.getChangeSetsDiscardedCount();
	    		// no accept done
	    		Assert.assertEquals(0, changeCount);
	    		Assert.assertNull(result.getBaselineSetItemId());

				validateBuildProperties(setupArtifacts.get(ARTIFACT_WORKSPACE_ITEM_ID),
						null, false, false, setupArtifacts.get("LoadRuleProperty"),
						false, "", result.getBaselineSetItemId(),
						changeCount,
						false,
						buildProperties);
				
			} finally {
				// clean up
				testingFacade.invoke(
						"tearDown",
						new Class[] { String.class, // serverURL,
								String.class, // userId,
								String.class, // password,
								int.class, // timeout,
								Map.class}, // setupArtifacts
						loginInfo.getServerUri(),
						loginInfo.getUserId(),
						loginInfo.getPassword(),
						loginInfo.getTimeout(), setupArtifacts);
			}
		}
	}

	@Test public void testNewLoadRules() throws Exception {
		// create a build definition with new format load rules
		// load directory "."
		// delete directory before loading (dir has other stuff that will be deleted)
		// accept changes before loading

		// create a build engine
		// create a build request
		
		// verify that the buildConfiguration returns the load rules
		// and other settings.
		
		// checkout based on the request
		// make sure only the contents identified by the load rule was loaded
		// verify extra stuff deleted from sandbox directory
		// verify changes accepted
		if (Config.DEFAULT.isConfigured()) {
			RTCLoginInfo loginInfo = Config.DEFAULT.getLoginInfo();

			String workspaceName = getRepositoryWorkspaceUniqueName();
			String componentName = getComponentUniqueName();
			String fetchLocation = ".";

			@SuppressWarnings("unchecked")
			Map<String, String> setupArtifacts = (Map<String, String>) testingFacade
					.invoke("testNewLoadRules",
							new Class[] { String.class, // serverURL,
									String.class, // userId,
									String.class, // password,
									int.class, // timeout,
									String.class, // workspaceName,
									String.class, // componentName,
									String.class, // hjPath,
									String.class}, // buildPath
							loginInfo.getServerUri(),
							loginInfo.getUserId(),
							loginInfo.getPassword(),
							loginInfo.getTimeout(), workspaceName,
							componentName,
							sandboxDir.getPath(),
							fetchLocation);
			
			try {
				TaskListener listener = new StreamTaskListener(System.out, null);
				
				File changeLogFile = new File(sandboxDir, "RTCChangeLogFile");
				FileOutputStream changeLog = new FileOutputStream(changeLogFile);

				// put extraneous stuff in the load directory (which is different from sandbox cause
				// we want to get a the change log.
				File loadDir = new File(sandboxDir, "loadDir");
				assertTrue(loadDir.mkdirs());
				assertTrue(new File(loadDir, "abc").mkdirs());
				assertTrue(new File(loadDir, "def").mkdirs());
				assertTrue(new File(loadDir, "hij").mkdirs());
				
				// checkout the changes
				Map<String, String> buildProperties = Utils.acceptAndLoad(testingFacade,
						loginInfo.getServerUri(),
						loginInfo.getUserId(),
						loginInfo.getPassword(),
						loginInfo.getTimeout(),
						setupArtifacts.get("buildResultItemId"), null,
						loadDir.getCanonicalPath(), changeLog,
						"Snapshot", listener, Locale.getDefault());
	    		
				String[] children = loadDir.list();
				Assert.assertEquals(3, children.length); // just what the load rule says to load (children of f) + metadata
				Assert.assertTrue(new File(loadDir, "a.txt").exists());
				Assert.assertTrue(new File(loadDir, "h.txt").exists());
				
	    		RTCChangeLogParser parser = new RTCChangeLogParser();
	    		FileReader changeLogReader = new FileReader(changeLogFile);
	    		RTCChangeLogSet result = (RTCChangeLogSet) parser.parse(null, null, changeLogReader);
	    		
	    		// verify the result
	    		int changeCount = result.getComponentChangeCount() +
	    				result.getChangeSetsAcceptedCount() + result.getChangeSetsDiscardedCount();
	    		Assert.assertEquals(1, changeCount);

				validateBuildProperties(setupArtifacts.get(ARTIFACT_WORKSPACE_ITEM_ID),
						fetchLocation, true, true, setupArtifacts.get("LoadRuleProperty"),
						false, "", result.getBaselineSetItemId(),
						changeCount,
						false,
						buildProperties);
				
			} finally {
				// clean up
				testingFacade.invoke(
						"tearDown",
						new Class[] { String.class, // serverURL,
								String.class, // userId,
								String.class, // password,
								int.class, // timeout,
								Map.class}, // setupArtifacts
						loginInfo.getServerUri(),
						loginInfo.getUserId(),
						loginInfo.getPassword(),
						loginInfo.getTimeout(), setupArtifacts);
			}
		}
	}
	
	@SuppressWarnings("unchecked")
	@Test public void testBuildSnapshotConfiguration() throws Exception {
		if (Config.DEFAULT.isConfigured()) {
			RTCLoginInfo loginInfo = null;
			Map<String, String> setupArtifacts = null;
			try {

			loginInfo = Config.DEFAULT.getLoginInfo();
			String workspaceName = getRepositoryWorkspaceUniqueName();
			String componentName = getComponentUniqueName();
			String snapshotName = getSnapshotUniqueName();
			
			setupArtifacts = (Map<String, String>) testingFacade
					.invoke("setupBuildSnapshot",
							new Class[] { String.class, // serverURL,
									String.class, // userId,
									String.class, // password,
									int.class, // timeout,
									String.class, // workspaceName,
									String.class, // snapshotName,
									String.class, // componentName,
									String.class, // workspacePrefix
					      },
							loginInfo.getServerUri(),
							loginInfo.getUserId(),
							loginInfo.getPassword(),
							loginInfo.getTimeout(), 
							workspaceName,
							snapshotName,
							componentName,
							"HJP"
							);
			
			testingFacade.invoke("testBuildSnapshotConfiguration",
							new Class[] { String.class, // serverURL,
									String.class, // userId,
									String.class, // password,
									int.class, // timeout,
									String.class, // snapshotName,
									String.class, // workspacePrefix
									String.class, // hjPath
					      },
							loginInfo.getServerUri(),
							loginInfo.getUserId(),
							loginInfo.getPassword(),
							loginInfo.getTimeout(), 
							snapshotName,
							"HJP",
							sandboxDir.getPath());
			}
			finally {
				// clean up
				testingFacade.invoke(
						"tearDown",
						new Class[] { String.class, // serverURL,
								String.class, // userId,
								String.class, // password,
								int.class, // timeout,
								Map.class}, // setupArtifacts
						loginInfo.getServerUri(),
						loginInfo.getUserId(),
						loginInfo.getPassword(),
						loginInfo.getTimeout(), setupArtifacts);
			}
		}
	}
}