| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| package org.apache.maven.scm; |
| |
| import java.io.File; |
| import java.io.FileWriter; |
| import java.io.IOException; |
| import java.util.Calendar; |
| import java.util.Date; |
| import java.util.TimeZone; |
| |
| import org.apache.maven.scm.manager.ScmManager; |
| import org.apache.maven.scm.repository.ScmRepository; |
| import org.codehaus.plexus.ContainerConfiguration; |
| import org.codehaus.plexus.PlexusConstants; |
| import org.codehaus.plexus.util.FileUtils; |
| import org.codehaus.plexus.util.StringUtils; |
| import org.codehaus.plexus.util.cli.CommandLineUtils; |
| import org.codehaus.plexus.util.cli.CommandLineUtils.StringStreamConsumer; |
| import org.codehaus.plexus.util.cli.Commandline; |
| import org.junit.Before; |
| |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertFalse; |
| import static org.junit.Assert.assertTrue; |
| import static org.junit.Assert.fail; |
| import static org.junit.Assume.assumeTrue; |
| |
| /** |
| * Base class for all SCM tests. Consumers will typically |
| * extend this class while tck test would extend ScmTckTestCase. |
| * <br> |
| * This class basically defines default locations for the |
| * test environment and implements convenience methods. |
| * |
| * @author <a href="mailto:jason@maven.org">Jason van Zyl</a> |
| * |
| */ |
| public abstract class ScmTestCase extends PlexusJUnit4TestCase { |
| protected static final TimeZone GMT_TIME_ZONE = TimeZone.getTimeZone("GMT"); |
| |
| private static boolean debugExecute; |
| |
| private ScmManager scmManager; |
| |
| @Before |
| @Override |
| public void setUp() throws Exception { |
| super.setUp(); |
| |
| deleteDirectory(getRepositoryRoot()); |
| assertFalse(getRepositoryRoot().exists()); |
| deleteDirectory(getWorkingCopy()); |
| assertFalse(getWorkingCopy().exists()); |
| deleteDirectory(getWorkingDirectory()); |
| assertFalse(getWorkingDirectory().exists()); |
| deleteDirectory(getAssertionCopy()); |
| assertFalse(getAssertionCopy().exists()); |
| deleteDirectory(getUpdatingCopy()); |
| assertFalse(getUpdatingCopy().exists()); |
| |
| scmManager = null; |
| } |
| |
| @Override |
| public void customizeContainerConfiguration(final ContainerConfiguration configuration) { |
| configuration.setClassPathScanning(PlexusConstants.SCANNING_INDEX).setAutoWiring(true); |
| } |
| |
| /** |
| * @return default location of the test read/write repository |
| */ |
| protected File getRepositoryRoot() { |
| return PlexusJUnit4TestCase.getTestFile("target/scm-test/repository"); |
| } |
| |
| /** |
| * @return Location of the revisioned (read only) repository |
| */ |
| protected File getRepository() { |
| return PlexusJUnit4TestCase.getTestFile("/src/test/repository"); |
| } |
| |
| /** |
| * @return location of the working copy (always checkout) |
| */ |
| protected File getWorkingCopy() { |
| return PlexusJUnit4TestCase.getTestFile("target/scm-test/working-copy"); |
| } |
| |
| /** |
| * Legacy method - same as getWorkingCopy() |
| * |
| * @return location of the working copy (always checkout) |
| */ |
| protected File getWorkingDirectory() { |
| return getWorkingCopy(); |
| } |
| |
| /** |
| * @return default location for doing assertions on a working tree |
| */ |
| protected File getAssertionCopy() { |
| return PlexusJUnit4TestCase.getTestFile("target/scm-test/assertion-copy"); |
| } |
| |
| /** |
| * @return default location for doing update operations on a working tree |
| */ |
| protected File getUpdatingCopy() { |
| return PlexusJUnit4TestCase.getTestFile("target/scm-test/updating-copy"); |
| } |
| |
| protected ScmManager getScmManager() throws Exception { |
| if (scmManager == null) { |
| scmManager = lookup(ScmManager.class); |
| } |
| |
| return scmManager; |
| } |
| |
| protected ScmRepository makeScmRepository(String scmUrl) throws Exception { |
| return getScmManager().makeScmRepository(scmUrl); |
| } |
| |
| public void assertPath(String expectedPath, String actualPath) throws Exception { |
| assertEquals(expectedPath.replace('\\', '/'), actualPath.replace('\\', '/')); |
| } |
| |
| protected void assertFile(File root, String fileName) throws Exception { |
| File file = new File(root, fileName); |
| |
| assertTrue("Missing file: '" + file.getAbsolutePath() + "'.", file.exists()); |
| |
| assertTrue("File isn't a file: '" + file.getAbsolutePath() + "'.", file.isFile()); |
| |
| String expected = fileName; |
| |
| String actual = FileUtils.fileRead(file); |
| |
| assertEquals( |
| "The file doesn't contain the expected contents. File: " + file.getAbsolutePath(), expected, actual); |
| } |
| |
| protected void assertResultIsSuccess(ScmResult result) { |
| if (result.isSuccess()) { |
| return; |
| } |
| |
| printOutputError(result); |
| |
| fail("The command result success flag was false."); |
| } |
| |
| protected void printOutputError(ScmResult result) { |
| System.err.println("----------------------------------------------------------------------"); |
| System.err.println("Provider message"); |
| System.err.println("----------------------------------------------------------------------"); |
| System.err.println(result.getProviderMessage()); |
| System.err.println("----------------------------------------------------------------------"); |
| |
| System.err.println("----------------------------------------------------------------------"); |
| System.err.println("Command output"); |
| System.err.println("----------------------------------------------------------------------"); |
| System.err.println(result.getCommandOutput()); |
| System.err.println("----------------------------------------------------------------------"); |
| } |
| |
| protected ScmFileSet getScmFileSet() { |
| return new ScmFileSet(getWorkingCopy()); |
| } |
| |
| protected static void setDebugExecute(boolean debugExecute) { |
| ScmTestCase.debugExecute = debugExecute; |
| } |
| |
| /** |
| * Execute the command line |
| * |
| * @param workingDirectory not null |
| * @param executable not null, should be a system command |
| * @param arguments not null |
| * @throws Exception if any |
| * @see CommandLineUtils#executeCommandLine(Commandline, org.codehaus.plexus.util.cli.StreamConsumer, |
| * org.codehaus.plexus.util.cli.StreamConsumer) |
| */ |
| public static void execute(File workingDirectory, String executable, String arguments) throws Exception { |
| Commandline cl = new Commandline(); |
| |
| cl.setExecutable(executable); |
| |
| cl.setWorkingDirectory(workingDirectory.getAbsolutePath()); |
| |
| cl.addArguments(CommandLineUtils.translateCommandline(arguments)); |
| |
| StringStreamConsumer stdout = new CommandLineUtils.StringStreamConsumer(); |
| |
| StringStreamConsumer stderr = new CommandLineUtils.StringStreamConsumer(); |
| |
| System.out.println("Test command line: " + cl); |
| |
| int exitValue = CommandLineUtils.executeCommandLine(cl, stdout, stderr); |
| |
| if (debugExecute || exitValue != 0) { |
| System.err.println("-----------------------------------------"); |
| System.err.println("Command line: " + cl); |
| System.err.println("Working directory: " + cl.getWorkingDirectory()); |
| System.err.println("-----------------------------------------"); |
| System.err.println("Standard output: "); |
| System.err.println("-----------------------------------------"); |
| System.err.println(stdout.getOutput()); |
| System.err.println("-----------------------------------------"); |
| |
| System.err.println("Standard error: "); |
| System.err.println("-----------------------------------------"); |
| System.err.println(stderr.getOutput()); |
| System.err.println("-----------------------------------------"); |
| } |
| |
| if (exitValue != 0) { |
| fail("Exit value wasn't 0, was:" + exitValue); |
| } |
| } |
| |
| protected static void makeDirectory(File basedir, String fileName) { |
| File dir = new File(basedir, fileName); |
| |
| if (!dir.exists()) { |
| assertTrue(dir.mkdirs()); |
| } |
| } |
| |
| protected static void makeFile(File basedir, String fileName) throws IOException { |
| makeFile(basedir, fileName, fileName); |
| } |
| |
| public static void makeFile(File basedir, String fileName, String contents) throws IOException { |
| File file = new File(basedir, fileName); |
| |
| File parent = file.getParentFile(); |
| |
| if (!parent.exists()) { |
| assertTrue(parent.mkdirs()); |
| } |
| |
| try (FileWriter writer = new FileWriter(file)) { |
| writer.write(contents); |
| } |
| } |
| |
| protected void deleteDirectory(File directory) throws IOException { |
| FileUtils.deleteDirectory(directory); |
| } |
| |
| public static Date getDate(int year, int month, int day) { |
| return getDate(year, month, day, 0, 0, 0, null); |
| } |
| |
| protected static Date getDate(int year, int month, int day, TimeZone tz) { |
| return getDate(year, month, day, 0, 0, 0, tz); |
| } |
| |
| protected static Date getDate(int year, int month, int day, int hourOfDay, int minute, int second, TimeZone tz) { |
| Calendar cal = Calendar.getInstance(); |
| |
| if (tz != null) { |
| cal.setTimeZone(tz); |
| } |
| cal.set(year, month, day, hourOfDay, minute, second); |
| cal.set(Calendar.MILLISECOND, 0); |
| |
| return cal.getTime(); |
| } |
| |
| public void assertCommandLine(String expectedCommand, File expectedWorkingDirectory, Commandline actualCommand) |
| throws IOException { |
| Commandline cl = new Commandline(expectedCommand); |
| if (expectedWorkingDirectory != null) { |
| cl.setWorkingDirectory(expectedWorkingDirectory.getAbsolutePath()); |
| } |
| String expectedCommandLineAsExecuted = StringUtils.join(cl.getShellCommandline(), " "); |
| String actualCommandLineAsExecuted = StringUtils.join(actualCommand.getShellCommandline(), " "); |
| assertEquals(expectedCommandLineAsExecuted, actualCommandLineAsExecuted); |
| } |
| |
| public static void checkScmPresence(String scmProviderCommand) { |
| assumeTrue( |
| "Skipping tests because the required command '" + scmProviderCommand + "' is not available.", |
| ScmTestCase.isSystemCmd(scmProviderCommand)); |
| } |
| |
| /** |
| * @param cmd the executable to run, not null. |
| * @return true if and only if the command is on the path |
| */ |
| public static boolean isSystemCmd(String cmd) { |
| try { |
| Runtime.getRuntime().exec(cmd); |
| |
| return true; |
| } catch (IOException e) { |
| return false; |
| } |
| } |
| } |