protected void setupRepositories() throws Exception {
    resource = "test-resource";

    // ----------------------------------------------------------------------
    // Create the test repository for the wagon we are testing.
    // ----------------------------------------------------------------------

    testRepository = new Repository();

    testRepository.setUrl(getTestRepositoryUrl());

    testRepository.setPermissions(getPermissions());

    // ----------------------------------------------------------------------
    // Create a test local repository.
    // ----------------------------------------------------------------------

    localRepositoryPath = FileTestUtils.createDir("local-repository").getPath();

    localRepository = createFileRepository("file://" + localRepositoryPath);

    message("Local repository: " + localRepository);

    File f = new File(localRepositoryPath);

    if (!f.exists()) {
      f.mkdirs();
    }
  }
  public void testFailedGetIfNewer() throws Exception {
    if (supportsGetIfNewer()) {
      setupRepositories();
      setupWagonTestingFixtures();
      message("Getting test artifact from test repository " + testRepository);
      Wagon wagon = getWagon();
      wagon.addTransferListener(checksumObserver);
      wagon.connect(testRepository, getAuthInfo());
      destFile = FileTestUtils.createUniqueFile(getName(), getName());
      destFile.deleteOnExit();
      try {
        wagon.getIfNewer("fubar.txt", destFile, 0);
        fail("File was found when it shouldn't have been");
      } catch (ResourceDoesNotExistException e) {
        // expected
        assertTrue(true);
      } finally {
        wagon.removeTransferListener(checksumObserver);

        wagon.disconnect();

        tearDownWagonTestingFixtures();
      }
    }
  }
  protected void assertResourcesAreInRemoteSide(Wagon wagon, List<String> resourceNames)
      throws IOException, TransferFailedException, ResourceDoesNotExistException,
          AuthorizationException {
    for (String resourceName : resourceNames) {
      File destFile = FileTestUtils.createUniqueFile(getName(), resourceName);

      destFile.deleteOnExit();

      wagon.get(resourceName, destFile);
    }
  }
  /**
   * Test for putting a directory with a destination that multiple directories deep, all of which
   * haven't been created.
   *
   * @throws Exception
   * @since 1.0-beta-2
   */
  public void testWagonPutDirectoryDeepDestination() throws Exception {
    setupRepositories();

    setupWagonTestingFixtures();

    Wagon wagon = getWagon();

    if (wagon.supportsDirectoryCopy()) {
      sourceFile = new File(FileTestUtils.getTestOutputDir(), "deep0/deep1/deep2");

      FileUtils.deleteDirectory(sourceFile);

      writeTestFile("test-resource-1.txt");
      writeTestFile("a/test-resource-2.txt");
      writeTestFile("a/b/test-resource-3.txt");
      writeTestFile("c/test-resource-4.txt");
      writeTestFile("d/e/f/test-resource-5.txt");

      wagon.connect(testRepository, getAuthInfo());

      wagon.putDirectory(sourceFile, "deep0/deep1/deep2");

      destFile = FileTestUtils.createUniqueFile(getName(), getName());

      destFile.deleteOnExit();

      wagon.get("deep0/deep1/deep2/test-resource-1.txt", destFile);
      wagon.get("deep0/deep1/deep2/a/test-resource-2.txt", destFile);
      wagon.get("deep0/deep1/deep2/a/b/test-resource-3.txt", destFile);
      wagon.get("deep0/deep1/deep2/c/test-resource-4.txt", destFile);
      wagon.get("deep0/deep1/deep2/d/e/f/test-resource-5.txt", destFile);

      wagon.disconnect();
    }

    tearDownWagonTestingFixtures();
  }
  /**
   * Test that when putting a directory that already exists new files get also copied
   *
   * @throws Exception
   * @since 1.0-beta-1
   */
  public void testWagonPutDirectoryWhenDirectoryAlreadyExists() throws Exception {

    final String dirName = "directory-copy-existing";

    final String resourceToCreate = "test-resource-1.txt";

    final String[] resources = {
      "a/test-resource-2.txt", "a/b/test-resource-3.txt", "c/test-resource-4.txt"
    };

    setupRepositories();

    setupWagonTestingFixtures();

    Wagon wagon = getWagon();

    if (wagon.supportsDirectoryCopy()) {
      sourceFile = new File(FileTestUtils.getTestOutputDir(), dirName);

      FileUtils.deleteDirectory(sourceFile);

      createDirectory(wagon, resourceToCreate, dirName);

      for (String resource : resources) {
        writeTestFile(resource);
      }

      wagon.connect(testRepository, getAuthInfo());

      wagon.putDirectory(sourceFile, dirName);

      List<String> resourceNames = new ArrayList<String>(resources.length + 1);

      resourceNames.add(dirName + "/" + resourceToCreate);
      for (String resource : resources) {
        resourceNames.add(dirName + "/" + resource);
      }

      assertResourcesAreInRemoteSide(wagon, resourceNames);

      wagon.disconnect();
    }

    tearDownWagonTestingFixtures();
  }
  protected void getFile(int expectedSize) throws Exception {
    destFile = FileTestUtils.createUniqueFile(getName(), getName());
    destFile.deleteOnExit();

    Wagon wagon = getWagon();

    ProgressAnswer progressAnswer = replaceMockForGet(wagon, expectedSize);

    message("Getting test artifact from test repository " + testRepository);

    connectWagon(wagon);

    wagon.get(this.resource, destFile);

    disconnectWagon(wagon);

    verifyMock(progressAnswer, expectedSize);
  }
  protected ProgressAnswer setupGetIfNewerTest(
      Wagon wagon, boolean expectedResult, int expectedSize)
      throws NoSuchAlgorithmException, IOException {
    checksumObserver = new ChecksumObserver();

    destFile = FileTestUtils.createUniqueFile(getName(), getName());
    destFile.delete();
    assertFalse(destFile.exists());
    destFile.deleteOnExit();

    ProgressAnswer progressAnswer = null;
    if (expectedResult) {
      progressAnswer = replaceMockForGet(wagon, expectedSize);
    } else {
      replaceMockForSkippedGetIfNewer(wagon, expectedSize);
    }
    return progressAnswer;
  }
  protected void putFile(String resourceName, String testFileName, String content)
      throws Exception {
    sourceFile = new File(FileTestUtils.getTestOutputDir(), testFileName);
    sourceFile.getParentFile().mkdirs();
    FileUtils.fileWrite(sourceFile.getAbsolutePath(), content);

    Wagon wagon = getWagon();

    ProgressAnswer progressAnswer = replayMockForPut(resourceName, content, wagon);

    message("Putting test artifact: " + resourceName + " into test repository " + testRepository);

    connectWagon(wagon);

    wagon.put(sourceFile, resourceName);

    disconnectWagon(wagon);

    verifyMock(progressAnswer, content.length());
  }
 public void setupBeforeEachTest() throws IOException {
   FileUtils.deleteDirectory(ACTUAL_UNIT_TEST_DIR);
   FileTestUtils.filteredCopy(ORIGINAL_UNIT_TEST_DIR, ACTUAL_UNIT_TEST_DIR, NO_DOT_FILES);
 }