예제 #1
0
  /**
   * Tests the LDIFDiff tool with the provided information to ensure that the normal mode of
   * operation works as expected. This is a bit tricky because the attributes and values will be
   * written in an indeterminate order, so we can't just use string equality. We'll have to use a
   * crude checksum mechanism to test whether they are equal. Combined with other methods in this
   * class, this should be good enough.
   *
   * @param sourceFile The path to the file containing the source data set.
   * @param targetFile The path to the file containing the target data set.
   * @param normalDiffFile The path to the file containing the expected diff in "normal" form (at
   *     most one record per entry), or {@code null} if the diff is supposed to fail.
   * @throws Exception If an unexpected problem occurs.
   */
  @Test(dataProvider = "ignoreentriesdata")
  public void testVerifyIgnoreEntries(
      String sourceFile, String targetFile, String ignoreEntriesFile, String normalDiffFile)
      throws Exception {
    File outputFile = File.createTempFile("difftest", "ldif");
    outputFile.deleteOnExit();

    String[] args = {
      "-s", sourceFile,
      "-t", targetFile,
      "-e", ignoreEntriesFile,
      "-o", outputFile.getAbsolutePath(),
      "-O"
    };

    if (ignoreEntriesFile.endsWith("does-not-exist")) {
      // We expect this to fail, so just make sure that it does.
      assertEquals(LDIFDiff.mainDiff(args, true, System.out, System.err), 1);
      return;
    }

    assertEquals(LDIFDiff.mainDiff(args, true, System.out, System.err), 0);
    assertEquals(calcChecksum(outputFile), calcChecksum(normalDiffFile));

    outputFile.delete();
  }
예제 #2
0
  /**
   * Tests the LDIFDiff tool with the provided information to ensure that the single value changes
   * mode of operation works as expected. This is a bit tricky because the attributes and values
   * will be written in an indeterminate order, so we can't just use string equality. We'll have to
   * use a crude checksum mechanism to test whether they are equal. Combined with other methods in
   * this class, this should be good enough.
   *
   * @param sourceFile The path to the file containing the source data set.
   * @param targetFile The path to the file containing the target data set.
   * @param normalDiffFile The path to the file containing the expected diff in "normal" form (at
   *     most one record per entry), or {@code null} if the diff is supposed to fail.
   * @param singleValueDiffFile The path to the file containing the expected diff in "single-value"
   *     form, where each attribute-level change results in a separate entry per attribute value.
   * @param resultCode The result code that should be returned with --useCompareResultCode flag
   * @throws Exception If an unexpected problem occurs.
   */
  @Test(dataProvider = "testdata")
  public void testVerifySingleValue(
      String sourceFile,
      String targetFile,
      String normalDiffFile,
      String singleValueDiffFile,
      int resultCode)
      throws Exception {
    File outputFile = File.createTempFile("difftest", "ldif");
    outputFile.deleteOnExit();

    String[] args = {
      "-s", sourceFile, "-t", targetFile, "-o", outputFile.getAbsolutePath(), "-O", "-S"
    };
    String[] argsUseCompare = {
      "-s", sourceFile,
      "-t", targetFile,
      // No need to write to the outputFile
      "--useCompareResultCode"
    };

    if (singleValueDiffFile == null) {
      // We expect this to fail, so just make sure that it does.
      assertFalse(LDIFDiff.mainDiff(args, true, System.out, System.err) == 0);
      outputFile.delete();
      return;
    }

    assertEquals(LDIFDiff.mainDiff(args, true, System.out, System.err), 0);
    assertEquals(calcChecksum(outputFile), calcChecksum(singleValueDiffFile));

    assertEquals(LDIFDiff.mainDiff(argsUseCompare, true, System.out, System.err), resultCode);
    outputFile.delete();
  }
예제 #3
0
  /**
   * Tests the LDIFDiff tool with an argument that will simply cause it to display usage
   * information.
   */
  @Test
  public void testUsage() {
    String[] args = {"--help"};
    assertEquals(LDIFDiff.mainDiff(args, true, System.out, System.err), 0);

    args = new String[] {"-H"};
    assertEquals(LDIFDiff.mainDiff(args, true, System.out, System.err), 0);

    args = new String[] {"-?"};
    assertEquals(LDIFDiff.mainDiff(args, true, System.out, System.err), 0);
  }
예제 #4
0
  /**
   * Tests the LDIFDiff tool by first identifying the differences between the source and the target
   * (using the single-value format) and then using the LDIFModify tool to apply the identified
   * changes to the source LDIF and verify that it matches the target.
   *
   * @param sourceFile The path to the file containing the source data set.
   * @param targetFile The path to the file containing the target data set.
   * @param normalDiffFile The path to the file containing the expected diff in "normal" form (at
   *     most one record per entry), or {@code null} if the diff is supposed to fail.
   * @param singleValueDiffFile The path to the file containing the expected diff in "single-value"
   *     form, where each attribute-level change results in a separate entry per attribute value.
   * @param resultCode The result code that should be returned with --useCompareResultCode flag
   * @throws Exception If an unexpected problem occurs.
   */
  @Test(dataProvider = "testdata")
  public void testReconstructSingleValue(
      String sourceFile,
      String targetFile,
      String normalDiffFile,
      String singleValueDiffFile,
      int resultCode)
      throws Exception {
    // If the command is expected to fail, or if there aren't any differences,
    // then bail out now.
    if (normalDiffFile == null || singleValueDiffFile.equals(noDiffsFile)) {
      return;
    }

    // Generate the diff file.
    File diffOutputFile = File.createTempFile("difftest", "ldif");
    diffOutputFile.deleteOnExit();

    String[] args = {
      "-s", sourceFile, "-t", targetFile, "-o", diffOutputFile.getAbsolutePath(), "-S"
    };
    String[] argsUseCompare = {
      "-s", sourceFile,
      "-t", targetFile,
      // No need to write to the outputFile
      "--useCompareResultCode"
    };

    assertEquals(LDIFDiff.mainDiff(args, true, System.out, System.err), 0);
    assertEquals(LDIFDiff.mainDiff(argsUseCompare, true, System.out, System.err), resultCode);

    // Use LDIFModify to generate a new target file.
    File newTargetFile = File.createTempFile("difftest", "newtarget.ldif");
    newTargetFile.deleteOnExit();

    DirectoryServer.getInstance();
    args =
        new String[] {
          "-c", DirectoryServer.getConfigFile(),
          "-s", sourceFile,
          "-m", diffOutputFile.getAbsolutePath(),
          "-t", newTargetFile.getAbsolutePath()
        };

    assertEquals(LDIFModify.ldifModifyMain(args, true, System.out, System.err), 0);

    // Use LDIFDiff again to verify that there are effectively no differences
    // between the original target and the new target.
    File newDiffFile = File.createTempFile("difftest", "newdiff.ldif");
    newDiffFile.deleteOnExit();

    args =
        new String[] {
          "-s", targetFile,
          "-t", newTargetFile.getAbsolutePath(),
          "-o", newDiffFile.getAbsolutePath()
        };
    argsUseCompare =
        new String[] {
          "-s",
          targetFile,
          "-t",
          newTargetFile.getAbsolutePath(),
          // No need to write to the outputFile
          "--useCompareResultCode"
        };

    assertEquals(LDIFDiff.mainDiff(args, true, System.out, System.err), 0);
    assertEquals(calcChecksum(newDiffFile), calcChecksum(noDiffsFile));
    assertEquals(LDIFDiff.mainDiff(argsUseCompare, true, System.out, System.err), COMPARE_TRUE);

    diffOutputFile.delete();
    newTargetFile.delete();
    newDiffFile.delete();
  }
예제 #5
0
  /** Tests the LDIFDiff tool with an invalid set of arguments. */
  @Test
  public void testInvalidArguments() {
    String[] args = {"--invalid"};

    assertFalse(LDIFDiff.mainDiff(args, true, System.out, System.err) == 0);
  }