Python IvyResolveFingerprintStrategy.compute_fingerprint Examples

Example #1

    def test_identical_jar_libraries_with_same_jar_dep_management_artifacts_match(self):
        confs = ()
        strategy = IvyResolveFingerprintStrategy(confs)

        managed_jar_deps = self.make_target(
            ":managed",
            target_type=ManagedJarDependencies,
            artifacts=[JarDependency("org.some", "name")],
        )
        self.set_artifact_set_for(managed_jar_deps, PinnedJarArtifactSet())

        jar_lib_1 = self.make_target(
            ":jar-lib-1",
            target_type=JarLibrary,
            jars=[JarDependency("org.some", "name")],
            managed_dependencies=":managed",
        )

        jar_lib_2 = self.make_target(
            ":jar-lib-2",
            target_type=JarLibrary,
            jars=[JarDependency("org.some", "name")],
            managed_dependencies=":managed",
        )

        self.assertEqual(
            strategy.compute_fingerprint(jar_lib_1), strategy.compute_fingerprint(jar_lib_2)
        )

Example #2

    def test_identical_jar_libraries_with_differing_managed_deps_differ(self):
        confs = ()
        strategy = IvyResolveFingerprintStrategy(
            self.create_task(self.context()), confs)

        managed_jar_deps = self.make_target(
            ':managed',
            target_type=ManagedJarDependencies,
            artifacts=[JarDependency('org.some', 'name')])
        self.set_artifact_set_for(managed_jar_deps, PinnedJarArtifactSet())

        jar_lib_with_managed_deps = self.make_target(
            ':jar-lib-1',
            target_type=JarLibrary,
            jars=[JarDependency('org.some', 'name')],
            managed_dependencies=':managed')

        jar_lib_without_managed_deps = self.make_target(
            ':jar-lib-no-managed-dep',
            target_type=JarLibrary,
            jars=[JarDependency('org.some', 'name')])

        self.assertNotEqual(
            strategy.compute_fingerprint(jar_lib_with_managed_deps),
            strategy.compute_fingerprint(jar_lib_without_managed_deps))

Example #3

    def test_identical_jar_libraries_with_differing_managed_deps_differ(self):
        confs = ()
        strategy = IvyResolveFingerprintStrategy(confs)

        managed_jar_deps = self.make_target(
            ":managed",
            target_type=ManagedJarDependencies,
            artifacts=[JarDependency("org.some", "name")],
        )
        self.set_artifact_set_for(managed_jar_deps, PinnedJarArtifactSet())

        jar_lib_with_managed_deps = self.make_target(
            ":jar-lib-1",
            target_type=JarLibrary,
            jars=[JarDependency("org.some", "name")],
            managed_dependencies=":managed",
        )

        jar_lib_without_managed_deps = self.make_target(
            ":jar-lib-no-managed-dep",
            target_type=JarLibrary,
            jars=[JarDependency("org.some", "name")],
        )

        self.assertNotEqual(
            strategy.compute_fingerprint(jar_lib_with_managed_deps),
            strategy.compute_fingerprint(jar_lib_without_managed_deps),
        )

Example #4

File: test_ivy_resolve.py Project: UnrememberMe/pants

    def test_identical_jar_libraries_with_differing_managed_deps_differ(self):
        confs = ()
        strategy = IvyResolveFingerprintStrategy(
            self.create_task(self.context()), confs)

        managed_jar_deps = self.make_target(
            ':managed',
            target_type=ManagedJarDependencies,
            artifacts=[JarDependency('org.some', 'name')])
        self.set_artifact_set_for(managed_jar_deps, PinnedJarArtifactSet())

        jar_lib_with_managed_deps = self.make_target(
            ':jar-lib-1',
            target_type=JarLibrary,
            jars=[JarDependency('org.some', 'name')],
            managed_dependencies=':managed')

        jar_lib_without_managed_deps = self.make_target(
            ':jar-lib-no-managed-dep',
            target_type=JarLibrary,
            jars=[JarDependency('org.some', 'name')])

        self.assertNotEqual(
            strategy.compute_fingerprint(jar_lib_with_managed_deps),
            strategy.compute_fingerprint(jar_lib_without_managed_deps))

Example #5

    def test_options_included_in_fingerprint(self):
        confs = ()
        jar_library = self.make_target(":jar-library", target_type=JarLibrary, jars=[JarDependency("org.some", "name")])

        self.set_options(a=True)
        strategy = IvyResolveFingerprintStrategy(self.create_task(self.context()), confs)
        with_true_a = strategy.compute_fingerprint(jar_library)

        self.set_options(a=False)
        strategy = IvyResolveFingerprintStrategy(self.create_task(self.context()), confs)

        with_false_a = strategy.compute_fingerprint(jar_library)

        self.assertNotEqual(with_true_a, with_false_a)

Example #6

File: test_ivy_resolve.py Project: pall-valmundsson/pants

    def test_target_target_is_none(self):
        confs = ()
        strategy = IvyResolveFingerprintStrategy(confs)

        target = self.make_target(':just-target')

        self.assertIsNone(strategy.compute_fingerprint(target))

Example #7

File: test_ivy_resolve.py Project: baroquebobcat/pants

  def test_jvm_target_without_excludes_is_none(self):
    confs = ()
    strategy = IvyResolveFingerprintStrategy(confs)

    target_without_excludes = self.make_target(':jvm-target', target_type=JvmTarget)

    self.assertIsNone(strategy.compute_fingerprint(target_without_excludes))

Example #8

    def test_jvm_target_with_excludes_is_hashed(self):
        confs = ()
        strategy = IvyResolveFingerprintStrategy(self.create_task(self.context()), confs)

        target_with_excludes = self.make_target(":jvm-target", target_type=JvmTarget, excludes=[Exclude("org.some")])

        self.assertIsNotNone(strategy.compute_fingerprint(target_with_excludes))

Example #9

File: test_ivy_resolve.py Project: baroquebobcat/pants

  def test_target_target_is_none(self):
    confs = ()
    strategy = IvyResolveFingerprintStrategy(confs)

    target = self.make_target(':just-target')

    self.assertIsNone(strategy.compute_fingerprint(target))

Example #10

    def test_jar_library_with_one_jar_is_hashed(self):
        confs = ()
        strategy = IvyResolveFingerprintStrategy(self.create_task(self.context()), confs)

        jar_library = self.make_target(":jar-library", target_type=JarLibrary, jars=[JarDependency("org.some", "name")])

        self.assertIsNotNone(strategy.compute_fingerprint(jar_library))

Example #11

    def test_target_target_is_none(self):
        confs = ()
        strategy = IvyResolveFingerprintStrategy(self.create_task(self.context()), confs)

        target = self.make_target(":just-target")

        self.assertIsNone(strategy.compute_fingerprint(target))

Example #12

    def test_jvm_target_without_excludes_is_none(self):
        confs = ()
        strategy = IvyResolveFingerprintStrategy(confs)

        target_without_excludes = self.make_target(":jvm-target", target_type=JvmTarget)

        self.assertIsNone(strategy.compute_fingerprint(target_without_excludes))

Example #13

File: test_ivy_resolve.py Project: baroquebobcat/pants

  def test_jar_library_with_one_jar_is_hashed(self):
    confs = ()
    strategy = IvyResolveFingerprintStrategy(confs)

    jar_library = self.make_target(':jar-library', target_type=JarLibrary,
                                   jars=[JarDependency('org.some', 'name')])

    self.assertIsNotNone(strategy.compute_fingerprint(jar_library))

Example #14

File: test_ivy_resolve.py Project: baroquebobcat/pants

  def test_jvm_target_with_excludes_is_hashed(self):
    confs = ()
    strategy = IvyResolveFingerprintStrategy(confs)

    target_with_excludes = self.make_target(':jvm-target', target_type=JvmTarget,
                                               excludes=[Exclude('org.some')])

    self.assertIsNotNone(strategy.compute_fingerprint(target_with_excludes))

Example #15

  def test_jvm_target_with_excludes_is_hashed(self):
    confs = ()
    strategy = IvyResolveFingerprintStrategy(confs)

    target_with_excludes = self.make_target(':jvm-target', target_type=JvmTarget,
                                               excludes=[Exclude('org.some')])

    self.assertIsNotNone(strategy.compute_fingerprint(target_with_excludes))

Example #16

  def test_jar_library_with_one_jar_is_hashed(self):
    confs = ()
    strategy = IvyResolveFingerprintStrategy(confs)

    jar_library = self.make_target(':jar-library', target_type=JarLibrary,
                                   jars=[JarDependency('org.some', 'name')])

    self.assertIsNotNone(strategy.compute_fingerprint(jar_library))

Example #17

    def test_options_included_in_fingerprint(self):
        confs = ()
        jar_library = self.make_target(
            ':jar-library',
            target_type=JarLibrary,
            jars=[JarDependency('org.some', 'name')])

        self.set_options(a=True)
        strategy = IvyResolveFingerprintStrategy(
            self.create_task(self.context()), confs)
        with_true_a = strategy.compute_fingerprint(jar_library)

        self.set_options(a=False)
        strategy = IvyResolveFingerprintStrategy(
            self.create_task(self.context()), confs)

        with_false_a = strategy.compute_fingerprint(jar_library)

        self.assertNotEqual(with_true_a, with_false_a)

Example #18

    def test_identical_jar_libraries_with_same_jar_dep_management_artifacts_match(self):
        confs = ()
        strategy = IvyResolveFingerprintStrategy(self.create_task(self.context()), confs)

        managed_jar_deps = self.make_target(
            ":managed", target_type=ManagedJarDependencies, artifacts=[JarDependency("org.some", "name")]
        )
        self.set_artifact_set_for(managed_jar_deps, PinnedJarArtifactSet())

        jar_lib_1 = self.make_target(
            ":jar-lib-1",
            target_type=JarLibrary,
            jars=[JarDependency("org.some", "name")],
            managed_dependencies=":managed",
        )

        jar_lib_2 = self.make_target(
            ":jar-lib-2",
            target_type=JarLibrary,
            jars=[JarDependency("org.some", "name")],
            managed_dependencies=":managed",
        )

        self.assertEqual(strategy.compute_fingerprint(jar_lib_1), strategy.compute_fingerprint(jar_lib_2))

Example #19

File: test_ivy_resolve.py Project: baroquebobcat/pants

  def test_identical_jar_libraries_with_same_jar_dep_management_artifacts_match(self):
    confs = ()
    strategy = IvyResolveFingerprintStrategy(confs)

    managed_jar_deps = self.make_target(':managed', target_type=ManagedJarDependencies,
                               artifacts=[JarDependency('org.some', 'name')])
    self.set_artifact_set_for(managed_jar_deps, PinnedJarArtifactSet())

    jar_lib_1 = self.make_target(':jar-lib-1', target_type=JarLibrary,
                                   jars=[JarDependency('org.some', 'name')],
                                   managed_dependencies=':managed')


    jar_lib_2 = self.make_target(':jar-lib-2', target_type=JarLibrary,
                              jars=[JarDependency('org.some', 'name')],
                              managed_dependencies=':managed')

    self.assertEqual(strategy.compute_fingerprint(jar_lib_1),
                     strategy.compute_fingerprint(jar_lib_2))