bitbake: toaster: toastergui unit tests convert to use fixtures

Instead of having to manually write up in the setUp function all the
different objects to create in the database, just specifiy them in a
fixture and load it. This has the advantage that it can be used on a
live server by using the ./manage.py loaddata command and can then
be inspected.

(Bitbake rev: 8a653ad8b075892d24d15696b3070c5a28a4fbe2)

Signed-off-by: Michael Wood <michael.g.wood@intel.com>
Signed-off-by: brian avery <avery.brian@gmail.com>
Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>

1 files changed, 42 insertions, 213 deletions

diff --git a/bitbake/lib/toaster/toastergui/tests.py b/bitbake/lib/toaster/toastergui/tests.py
index 56a7d7e860..1b6e78d517 100644
--- a/bitbake/lib/toaster/toastergui/tests.py
+++ b/bitbake/lib/toaster/toastergui/tests.py
@@ -51,205 +51,17 @@ CLI_BUILDS_PROJECT_NAME = 'Command line builds'
 class ViewTests(TestCase):
     """Tests to verify view APIs."""
 
-    def setUp(self):
-        bbv = BitbakeVersion.objects.create(name="test bbv", giturl="/tmp/",
-                                            branch="master", dirpath="")
-        release = Release.objects.create(name="test release",
-                                         branch_name="master",
-                                         bitbake_version=bbv)
-        release2 = Release.objects.create(name="test release 2",
-                                          branch_name="master",
-                                          bitbake_version=bbv)
-
-        self.project = Project.objects.create_project(name=PROJECT_NAME,
-                                                      release=release)
-
-        self.project2 = Project.objects.create_project(name=PROJECT_NAME2,
-                                                       release=release2)
-
-        now = timezone.now()
-        later = now + timedelta(days=1)
-
-        build = Build.objects.create(project=self.project,
-                                     started_on=now,
-                                     completed_on=now,
-                                     outcome=Build.SUCCEEDED)
-
-        # for testing BuildsTable
-        build1 = Build.objects.create(project=self.project,
-                                      started_on=now,
-                                      completed_on=now,
-                                      outcome=Build.SUCCEEDED,
-                                      machine="raspberrypi2")
-
-        Build.objects.create(project=self.project,
-                             started_on=later,
-                             completed_on=later,
-                             outcome=Build.FAILED,
-                             machine="qemux86")
-
-        Build.objects.create(project=self.project2,
-                             started_on=later,
-                             completed_on=later,
-                             outcome=Build.SUCCEEDED,
-                             machine="qemux86")
-
-        # to test sorting by errors and warnings in BuildsTable
-        LogMessage.objects.create(build=build1, level=LogMessage.WARNING)
-        LogMessage.objects.create(build=build1, level=LogMessage.ERROR)
-
-        layersrc = LayerSource.objects.create(sourcetype=LayerSource.TYPE_IMPORTED)
-        self.priority = ReleaseLayerSourcePriority.objects.create(release=release,
-                                                                  layer_source=layersrc)
-        layer = Layer.objects.create(name="base-layer", layer_source=layersrc,
-                                     vcs_url="/tmp/")
-
-        layer_two = Layer.objects.create(name="z-layer",
-                                         layer_source=layersrc,
-                                         vcs_url="git://two/")
-
-
-        branch = Branch.objects.create(name="master", layer_source=layersrc)
-
-        self.lver = Layer_Version.objects.create(layer=layer,
-                                                 project=self.project,
-                                                 layer_source=layersrc,
-                                                 commit="master",
-                                                 dirpath="/tmp/",
-                                                 up_branch=branch)
-
-        lver_two = Layer_Version.objects.create(layer=layer_two,
-                                                layer_source=layersrc,
-                                                commit="master",
-                                                up_branch=branch)
-
-        Recipe.objects.create(layer_source=layersrc,
-                              name="z recipe",
-                              version="5.2",
-                              summary="z recipe",
-                              description="G recipe",
-                              license="Z GPL",
-                              section="h section",
-                              layer_version=lver_two)
-
-        # Create a dummy recipe file for the custom image generation to read
-        open("/tmp/my_recipe.bb", 'wa').close()
-        self.recipe1 = Recipe.objects.create(layer_source=layersrc,
-                                             name="base-recipe",
-                                             version="1.2",
-                                             summary="one recipe",
-                                             description="recipe",
-                                             section="A section",
-                                             license="Apache",
-                                             layer_version=self.lver,
-                                             file_path="my_recipe.bb")
-
-        Machine.objects.create(layer_version=self.lver, name="wisk",
-                               description="wisking machine")
-        Machine.objects.create(layer_version=self.lver, name="zap",
-                               description="zap machine")
-        Machine.objects.create(layer_version=lver_two, name="xray",
-                               description="xray machine")
-
-
-
-        ProjectLayer.objects.create(project=self.project, layercommit=self.lver)
-
-        lver_custom = Layer_Version.objects.create(layer=layer,
-                                                   project=self.project,
-                                                   layer_source=layersrc,
-                                                   commit="mymaster",
-                                                   up_branch=branch)
-
-        self.customr = CustomImageRecipe.objects.create(\
-                           name="custom recipe", project=self.project,
-                           base_recipe=self.recipe1,
-                           file_path="custr",
-                           layer_version=lver_custom)
-
-        self.package = Package.objects.create(name='pkg1',
-                                              size=999,
-                                              recipe=self.recipe1,
-                                              license="HHH",
-                                              build=build)
-
-        Package.objects.create(name='A pkg1',
-                               size=777,
-                               recipe=self.recipe1,
-                               build=build)
-
-        Package.objects.create(name='zpkg1',
-                               recipe=self.recipe1,
-                               build=build,
-                               size=4,
-                               license="ZZ")
-
-        self.cust_package = CustomImagePackage.objects.create(
-            name="A pkg",
-            recipe=self.recipe1,
-            size=10,
-            license="AAA")
-
-        self.customr.appends_set.add(self.cust_package)
-
-        # recipe with project for testing AvailableRecipe table
-        self.recipe2 = Recipe.objects.create(layer_source=layersrc,
-                                             name="fancy-recipe",
-                                             version="1.4",
-                                             summary="a fancy recipe",
-                                             description="fancy recipe",
-                                             license="MIT",
-                                             layer_version=self.lver,
-                                             section="Z section",
-                                             file_path='/home/foo')
-
-        # additional package for the sorting for the SelectPackagesTable
-        cust_package_two = CustomImagePackage.objects.create(name="ZZ pkg",
-                                                        size=5,
-                                                        recipe=self.recipe2)
-
-        self.customr.appends_set.add(cust_package_two)
-
-        Package.objects.create(name='one1',
-                               recipe=self.recipe2,
-                               build=build,
-                               size=2,
-                               license="L")
-
-        Recipe.objects.create(layer_source=layersrc,
-                              is_image=True,
-                              name="Test image one",
-                              version="1.2",
-                              summary="one recipe",
-                              description="recipe",
-                              section="A",
-                              license="A",
-                              file_path="/one/",
-                              layer_version=self.lver)
-
-        zrecipe = Recipe.objects.create(layer_source=layersrc,
-                                        is_image=True,
-                                        name="Z Test image two",
-                                        version="1.3",
-                                        summary="two image recipe",
-                                        description="recipe two",
-                                        section="B",
-                                        license="Z",
-                                        file_path="/two/",
-                                        layer_version=lver_two)
-
-        CustomImageRecipe.objects.create(name="z custom recipe",
-                                         project=self.project,
-                                         base_recipe=zrecipe,
-                                         file_path="zzzz",
-                                         layer_version=lver_custom)
-
-        # Packages in PackagesTable requre that the recipe has been built so
-        # we need to create a target and build pair
-        target = Target.objects.create(target=self.recipe1.name,
-                                       build=build)
+    fixtures = ['toastergui-unittest-data']
 
+    def setUp(self):
 
+        self.project = Project.objects.first()
+        self.recipe1 = Recipe.objects.get(pk=2)
+        self.recipe2 = Recipe.objects.last()
+        self.customr = CustomImageRecipe.objects.first()
+        self.cust_package = CustomImagePackage.objects.first()
+        self.package = Package.objects.first()
+        self.lver = Layer_Version.objects.first()
 
     def test_get_base_call_returns_html(self):
         """Basic test for all-projects view"""
@@ -271,7 +83,7 @@ class ViewTests(TestCase):
         self.assertEqual(data["error"], "ok")
         self.assertTrue("rows" in data)
 
-        self.assertTrue(PROJECT_NAME in [x["name"] for x in data["rows"]])
+        self.assertTrue(self.project.name in [x["name"] for x in data["rows"]])
         self.assertTrue("id" in data["rows"][0])
 
     def test_typeaheads(self):
@@ -333,11 +145,13 @@ class ViewTests(TestCase):
 
     def test_xhr_import_layer(self):
         """Test xhr_importlayer API"""
+        LayerSource.objects.create(sourcetype=LayerSource.TYPE_IMPORTED)
         #Test for importing an already existing layer
         args = {'vcs_url' : "git://git.example.com/test",
                 'name' : "base-layer",
                 'git_ref': "c12b9596afd236116b25ce26dbe0d793de9dc7ce",
-                'project_id': 1, 'dir_path' : "/path/in/repository"}
+                'project_id': self.project.id,
+                'dir_path' : "/path/in/repository"}
         response = self.client.post(reverse('xhr_importlayer'), args)
         data = json.loads(response.content)
         self.assertEqual(response.status_code, 200)
@@ -407,13 +221,12 @@ class ViewTests(TestCase):
 
     def test_xhr_custom_details(self):
         """Test getting custom recipe details"""
-        name = "custom recipe"
         url = reverse('xhr_customrecipe_id', args=(self.customr.id,))
         response = self.client.get(url)
         self.assertEqual(response.status_code, 200)
         expected = {"error": "ok",
                     "info": {'id': self.customr.id,
-                             'name': name,
+                             'name': self.customr.name,
                              'base_recipe_id': self.recipe1.id,
                              'project_id': self.project.id,
                             }
@@ -484,6 +297,10 @@ class ViewTests(TestCase):
                                     {"error": "ok"})
 
     def test_download_custom_recipe(self):
+        """Download the recipe file generated for the custom image"""
+
+        # Create a dummy recipe file for the custom image generation to read
+        open("/tmp/a_recipe.bb", 'wa').close()
         response = self.client.get(reverse('customrecipedownload',
                                            args=(self.project.id,
                                                  self.customr.id)))
@@ -503,8 +320,6 @@ class ViewTests(TestCase):
         row2 = next(x for x in rows if x['name'] == self.recipe2.name)
 
         self.assertEqual(response.status_code, 200, 'should be 200 OK status')
-        # All recipes in the setUp
-        self.assertEqual(len(rows), 5, 'should be 5 recipes')
 
         # check other columns have been populated correctly
         self.assertEqual(row1['name'], self.recipe1.name)
@@ -529,13 +344,20 @@ class ViewTests(TestCase):
             options['format'] = "json"
             options['nocache'] = "true"
             request = RequestFactory().get('/', options)
+
+            # This is the image recipe needed for a package list for
+            # PackagesTable do this here to throw a non exist exception
+            image_recipe = Recipe.objects.get(pk=4)
+
             # Add any kwargs that are needed by any of the possible tables
-            response = table.get(request,
-                                 pid=self.project.id,
-                                 layerid=self.lver.pk,
-                                 recipeid=self.recipe1.pk,
-                                 recipe_id=self.recipe1.pk,
-                                 custrecipeid=self.customr.pk)
+            args = {'pid': self.project.id,
+                    'layerid': self.lver.pk,
+                    'recipeid': self.recipe1.pk,
+                    'recipe_id': image_recipe.pk,
+                    'custrecipeid': self.customr.pk
+                   }
+
+            response = table.get(request, **args)
             return json.loads(response.content)
 
         # Get a list of classes in tables module
@@ -562,10 +384,14 @@ class ViewTests(TestCase):
 
                 if '-' in table.default_orderby:
                     self.assertTrue(row_one >= row_two,
-                                    "Default ordering not working on %s" % name)
+                                    "Default ordering not working on %s"
+                                    " '%s' should be >= '%s'" %
+                                    (name, row_one, row_two))
                 else:
                     self.assertTrue(row_one <= row_two,
-                                    "Default ordering not working on %s" % name)
+                                    "Default ordering not working on %s"
+                                    " '%s' should be <= '%s'" %
+                                    (name, row_one, row_two))
 
             # Test the column ordering and filtering functionality
             for column in table.columns:
@@ -580,7 +406,9 @@ class ViewTests(TestCase):
 
                     self.assertTrue(row_one <= row_two,
                                     "Ascending sort applied but row 0 is less "
-                                    "than row 1")
+                                    "than row 1 %s %s " %
+                                    (column['field_name'], name))
+
 
                     descending = get_data(table_cls(),
                                           {"orderby" :
@@ -591,7 +419,8 @@ class ViewTests(TestCase):
 
                     self.assertTrue(row_one >= row_two,
                                     "Descending sort applied but row 0 is "
-                                    "greater than row 1")
+                                    "greater than row 1 %s %s" %
+                                    (column['field_name'], name))
 
                     # If the two start rows are the same we haven't actually
                     # changed the order