Use target not make_target in some tests

tests/python/pants_test/backend/docgen/tasks/test_markdown_to_html.py

@@ -12,7 +12,7 @@
 import bs4
 import mock
 
-from pants.backend.docgen.targets.doc import Page
+from pants.backend.docgen.register import build_file_aliases
 from pants.backend.docgen.tasks import markdown_to_html_utils
 from pants.backend.docgen.tasks.markdown_to_html import MarkdownToHtml
 from pants.base.exceptions import TaskError
@@ -105,9 +105,14 @@ class MarkdownToHtmlTest(TaskTestBase):
   def task_type(cls):
     return MarkdownToHtml
 
+  @classmethod
+  def alias_groups(cls):
+    return build_file_aliases()
+
   def test_rst_render_empty(self):
     self.create_file('empty.rst')
-    empty_rst = self.make_target(':empty_rst', target_type=Page, source='empty.rst')
+    self.add_to_build_file('', 'page(name = "empty_rst", source = "empty.rst")')
+    empty_rst = self.target(':empty_rst')
     task = self.create_task(self.context(target_roots=[empty_rst]))
     task.execute()
 
@@ -117,7 +122,8 @@ def test_rst_render_failure_fail(self):
 
     * `RB #2363 https://rbcommons.com/s/twitter/r/2363/>`_
     """))
-    bad_rst = self.make_target(':bad_rst', target_type=Page, source='bad.rst')
+    self.add_to_build_file('', 'page(name = "bad_rst", source = "bad.rst")')
+    bad_rst = self.target(':bad_rst')
     task = self.create_task(self.context(target_roots=[bad_rst]))
     with self.assertRaises(TaskError):
       task.execute()
@@ -138,8 +144,9 @@ def test_rst_render_failure_warn(self):
 
     * `RB #2363 https://rbcommons.com/s/twitter/r/2363/>`_
     """))
-    bad_rst = self.make_target(':bad_rst', target_type=Page, source='bad.rst')
+    self.add_to_build_file('', 'page(name = "bad_rst", source = "bad.rst")')
     self.set_options(ignore_failure=True)
+    bad_rst = self.target(':bad_rst')
     context = self.context(target_roots=[bad_rst])
     context.log.warn = mock.Mock()
     task = self.create_task(context)
@@ -163,7 +170,8 @@ def test_rst_render_success(self):
 
     * `RB #2363 <https://rbcommons.com/s/twitter/r/2363/>`_
     """))
-    good_rst = self.make_target(':good_rst', target_type=Page, source='good.rst')
+    self.add_to_build_file('', 'page(name = "good_rst", source = "good.rst")')
+    good_rst = self.target(':good_rst')
     context = self.context(target_roots=[good_rst])
     task = self.create_task(context)
     task.execute()

tests/python/pants_test/backend/jvm/targets/test_jvm_binary.py

@@ -7,13 +7,13 @@
 
 import unittest
 
-from pants.backend.jvm.targets.jvm_binary import (Duplicate, JarRules, JvmBinary, ManifestEntries,
-                                                  Skip)
+from pants.backend.jvm.register import build_file_aliases
+from pants.backend.jvm.targets.jvm_binary import Duplicate, JarRules, ManifestEntries, Skip
 from pants.base.exceptions import TargetDefinitionException
 from pants.base.payload_field import FingerprintedField
+from pants.build_graph.build_file_aliases import BuildFileAliases
 from pants.build_graph.target import Target
 from pants.java.jar.exclude import Exclude
-from pants.java.jar.jar_dependency import JarDependency
 from pants_test.test_base import TestBase
 
 
@@ -57,8 +57,22 @@ def test_set_bad_default(self):
 
 class JvmBinaryTest(TestBase):
 
+  @classmethod
+  def alias_groups(cls):
+    return build_file_aliases().merge(
+      BuildFileAliases(
+        objects={
+          'duplicate': Duplicate,
+        },
+      )
+    )
+
   def test_simple(self):
-    target = self.make_target(':foo', JvmBinary, main='com.example.Foo', basename='foo-base')
+    self.add_to_build_file(
+      '',
+      'jvm_binary(name = "foo", main = "com.example.Foo", basename = "foo-base")',
+    )
+    target = self.target(':foo')
     self.assertEquals('com.example.Foo', target.main)
     self.assertEquals('com.example.Foo', target.payload.main)
     self.assertEquals('foo-base', target.basename)
@@ -70,23 +84,34 @@ def test_simple(self):
     self.assertEquals({}, target.payload.manifest_entries.entries)
 
   def test_default_base(self):
-    target = self.make_target(':foo', JvmBinary, main='com.example.Foo')
+    self.add_to_build_file('', 'jvm_binary(name = "foo", main = "com.example.Foo")')
+    target = self.target(':foo')
     self.assertEquals('foo', target.basename)
 
   def test_deploy_jar_excludes(self):
-    target = self.make_target(':foo',
-                              JvmBinary,
-                              main='com.example.Foo',
-                              deploy_excludes=[Exclude(org='example.com', name='foo-lib')])
+    self.add_to_build_file(
+      '',
+      '''jvm_binary(
+  name = "foo",
+  main = "com.example.Foo",
+  deploy_excludes=[exclude(org = "example.com", name = "foo-lib")],
+)''')
+    target = self.target(':foo')
     self.assertEquals([Exclude(org='example.com', name='foo-lib')],
                       target.deploy_excludes)
 
   def test_deploy_jar_rules(self):
-    target = self.make_target(':foo',
-                              JvmBinary,
-                              main='com.example.Foo',
-                              deploy_jar_rules=JarRules([Duplicate('foo', Duplicate.SKIP)],
-                                                        default_dup_action=Duplicate.FAIL))
+    self.add_to_build_file(
+      '',
+      '''jvm_binary(
+  name = "foo",
+  main = "com.example.Foo",
+  deploy_jar_rules = jar_rules(
+    [duplicate("foo", duplicate.SKIP)],
+    default_dup_action = duplicate.FAIL,
+  ),
+)''')
+    target = self.target(':foo')
     jar_rules = target.deploy_jar_rules
     self.assertEquals(1, len(jar_rules.rules))
     self.assertEquals('foo', jar_rules.rules[0].apply_pattern.pattern)
@@ -95,25 +120,39 @@ def test_deploy_jar_rules(self):
     self.assertEquals(Duplicate.FAIL, jar_rules.default_dup_action)
 
   def test_bad_source_declaration(self):
+    self.add_to_build_file(
+      '',
+      'jvm_binary(name = "foo", main = "com.example.Foo", source = ["foo.py"])',
+    )
     with self.assertRaisesRegexp(TargetDefinitionException,
                                  r'Invalid target JvmBinary.*foo.*source must be a single'):
-      self.make_target(':foo', JvmBinary, main='com.example.Foo', source=['foo.py'])
+      self.target(':foo')
 
   def test_bad_sources_declaration(self):
+    self.add_to_build_file(
+      'foo',
+      'jvm_binary(name = "foo", main = "com.example.Foo", sources = ["foo.py"])',
+    )
     with self.assertRaisesRegexp(Target.IllegalArgument,
                                  r'jvm_binary only supports a single "source" argument'):
-      self.make_target('foo:foo', target_type=JvmBinary, main='com.example.Foo', sources=['foo.py'])
+      self.target('foo:foo')
 
   def test_bad_main_declaration(self):
+    self.add_to_build_file('', 'jvm_binary(name = "bar", main = ["com.example.Bar"])')
     with self.assertRaisesRegexp(TargetDefinitionException,
                                  r'Invalid target JvmBinary.*bar.*main must be a fully'):
-      self.make_target(':bar', JvmBinary, main=['com.example.Bar'])
+      self.target(':bar')
 
   def test_bad_jar_rules(self):
+    self.add_to_build_file(
+      '',
+      'jvm_binary(name = "foo", main = "com.example.Foo", deploy_jar_rules="invalid")',
+    )
     with self.assertRaisesRegexp(TargetDefinitionException,
                                  r'Invalid target JvmBinary.*foo.*'
-                                 r'deploy_jar_rules must be a JarRules specification. got unicode'):
-      self.make_target(':foo', JvmBinary, main='com.example.Foo', deploy_jar_rules='invalid')
+                                 r'deploy_jar_rules must be a JarRules specification. '
+                                 r'got (str|unicode)'):
+      self.target(':foo')
 
   def _assert_fingerprints_not_equal(self, fields):
     for field in fields:
@@ -144,31 +183,43 @@ def test_jar_rules_field(self):
     self._assert_fingerprints_not_equal([field1, field2, field3, field4, field5, field6, field7])
 
   def test_manifest_entries(self):
-    target = self.make_target(':foo',
-                              JvmBinary,
-                              main='com.example.Foo',
-                              manifest_entries={'Foo-Field': 'foo'})
+    self.add_to_build_file(
+      '',
+      '''jvm_binary(
+  name = "foo",
+  main = "com.example.Foo",
+  manifest_entries = {"Foo-Field": "foo"},
+)''')
+    target = self.target(":foo")
     self.assertTrue(isinstance(target.payload.manifest_entries, ManifestEntries))
     entries = target.payload.manifest_entries.entries
     self.assertEquals({'Foo-Field': 'foo'}, entries)
 
   def test_manifest_not_dict(self):
+    self.add_to_build_file(
+      '',
+      '''jvm_binary(
+  name = "foo",
+  main = "com.example.Foo",
+  manifest_entries = "foo",
+)''')
     with self.assertRaisesRegexp(TargetDefinitionException,
                                  r'Invalid target JvmBinary.*foo.*: manifest_entries must be a '
-                                 r'dict. got unicode'):
-      self.make_target(':foo',
-                       JvmBinary,
-                       main='com.example.Foo',
-                       manifest_entries='foo')
+                                 r'dict. got (str|unicode)'):
+      self.target(':foo')
 
   def test_manifest_bad_key(self):
-    with self.assertRaisesRegexp(ManifestEntries.ExpectedDictionaryError,
-                                 r'^entries must be dictionary of strings, got key .* '
-                                 r'type JarDependency$'):
-      self.make_target(':foo',
-                       JvmBinary,
-                       main='com.example.Foo',
-                       manifest_entries={JarDependency('bad', 'bad', 'bad'): 'foo'})
+    self.add_to_build_file(
+      '',
+      '''jvm_binary(
+  name = "foo",
+  main = "com.example.Foo",
+  manifest_entries = {jar("bad", "bad", "bad"): "foo"},
+)''')
+    with self.assertRaisesRegexp(TargetDefinitionException,
+                                 r'entries must be dictionary of strings, got key .* '
+                                 r'type JarDependency'):
+      self.target(':foo')
 
   def test_manifest_entries_fingerprint(self):
     field1 = ManifestEntries()

tests/python/pants_test/backend/jvm/tasks/test_binary_create.py

@@ -7,11 +7,7 @@
 
 import os
 
-from pants.backend.jvm.targets.jar_library import JarLibrary
-from pants.backend.jvm.targets.jvm_binary import JvmBinary
 from pants.backend.jvm.tasks.binary_create import BinaryCreate
-from pants.java.jar.exclude import Exclude
-from pants.java.jar.jar_dependency import JarDependency
 from pants.util.contextutil import open_zip
 from pants_test.backend.jvm.tasks.jvm_binary_task_test_base import JvmBinaryTaskTestBase
 
@@ -23,9 +19,8 @@ def task_type(cls):
     return BinaryCreate
 
   def test_jvm_binaries_products(self):
-    binary_target = self.make_target(spec='//bar:bar-binary',
-                                     target_type=JvmBinary,
-                                     source='Bar.java')
+    self.add_to_build_file('bar', 'jvm_binary(name = "bar-binary", source = "Bar.java")')
+    binary_target = self.target('//bar:bar-binary')
     context = self.context(target_roots=[binary_target])
     classpath_products = self.ensure_classpath_products(context)
 
@@ -56,17 +51,26 @@ def test_jvm_binaries_products(self):
                        sorted(jar.namelist()))
 
   def test_jvm_binaries_deploy_excludes(self):
-    foo_jar_lib = self.make_target(spec='3rdparty/jvm/org/example:foo',
-                                   target_type=JarLibrary,
-                                   jars=[JarDependency(org='org.example', name='foo', rev='1.0.0')])
-    binary_target = self.make_target(spec='//bar:bar-binary',
-                                     target_type=JvmBinary,
-                                     source='Bar.java',
-                                     dependencies=[foo_jar_lib],
-                                     deploy_excludes=[Exclude(org='org.pantsbuild')])
+    self.add_to_build_file(
+      '3rdparty/jvm/org/example',
+      'jar_library(name = "foo", jars = [jar(org = "org.example", name = "foo", rev = "1.0.0")])',
+    )
+    foo_jar_lib = self.target('3rdparty/jvm/org/example:foo')
+
+    self.add_to_build_file(
+      'bar',
+      '''jvm_binary(
+  name = "bar-binary",
+  source = "Bar.java",
+  dependencies = ["3rdparty/jvm/org/example:foo"],
+  deploy_excludes = [exclude(org = "org.pantsbuild")],
+)'''
+    )
+    binary_target = self.target('//bar:bar-binary')
     context = self.context(target_roots=[binary_target])
     classpath_products = self.ensure_classpath_products(context)
 
+
     foo_artifact = self.create_artifact(org='org.example', name='foo', rev='1.0.0')
     with open_zip(foo_artifact.pants_path, 'w') as jar:
       jar.writestr('foo/Foo.class', '')