yocto-poky/bitbake/lib/toaster/orm/tests.py

#! /usr/bin/env python
# ex:ts=4:sw=4:sts=4:et
# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
#
# BitBake Toaster Implementation
#
# Copyright (C) 2013-2015 Intel Corporation
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

"""Test cases for Toaster ORM."""

from django.test import TestCase, TransactionTestCase
from orm.models import LocalLayerSource, LayerIndexLayerSource, ImportedLayerSource, LayerSource
from orm.models import Branch

from orm.models import Project, Build, Layer, Layer_Version, Branch, ProjectLayer
from orm.models import Release, ReleaseLayerSourcePriority, BitbakeVersion

from django.utils import timezone
from django.db import IntegrityError

import os

# set TTS_LAYER_INDEX to the base url to use a different instance of the layer index

class LayerSourceVerifyInheritanceSaveLoad(TestCase):
    """
    Tests to verify inheritance for the LayerSource proxy-inheritance classes.
    """
    def test_object_creation(self):
        """Test LayerSource object creation."""
        for name, sourcetype in [("a1", LayerSource.TYPE_LOCAL),
                                 ("a2", LayerSource.TYPE_LAYERINDEX),
                                 ("a3", LayerSource.TYPE_IMPORTED)]:
            LayerSource.objects.create(name=name, sourcetype=sourcetype)

        objects = LayerSource.objects.all()
        self.assertTrue(isinstance(objects[0], LocalLayerSource))
        self.assertTrue(isinstance(objects[1], LayerIndexLayerSource))
        self.assertTrue(isinstance(objects[2], ImportedLayerSource))

    def test_duplicate_error(self):
        """Test creation of duplicate LayerSource objects."""
        stype = LayerSource.TYPE_LOCAL
        LayerSource.objects.create(name="a1", sourcetype=stype)
        with self.assertRaises(IntegrityError):
            LayerSource.objects.create(name="a1", sourcetype=stype)


class LILSUpdateTestCase(TransactionTestCase):
    """Test Layer Source update."""

    def setUp(self):
        """Create release."""
        bbv = BitbakeVersion.objects.create(\
                  name="master", giturl="git://git.openembedded.org/bitbake")
        Release.objects.create(name="default-release", bitbake_version=bbv,
                               branch_name="master")

    def test_update(self):
        """Check if LayerSource.update can fetch branches."""
        url = os.getenv("TTS_LAYER_INDEX",
                        default="http://layers.openembedded.org/")

        lsobj = LayerSource.objects.create(\
                    name="b1", sourcetype=LayerSource.TYPE_LAYERINDEX,
                    apiurl=url + "layerindex/api/")
        lsobj.update()
        self.assertTrue(lsobj.branch_set.all().count() > 0,
                        "no branches fetched")

class LayerVersionEquivalenceTestCase(TestCase):
    """Verify Layer_Version priority selection."""

    def setUp(self):
        """Create required objects."""
        # create layer source
        self.lsrc = LayerSource.objects.create(name="dummy-layersource",
                                               sourcetype=LayerSource.TYPE_LOCAL)
        # create release
        bbv = BitbakeVersion.objects.create(\
                  name="master", giturl="git://git.openembedded.org/bitbake")
        self.release = Release.objects.create(name="default-release",
                                              bitbake_version=bbv,
                                              branch_name="master")
        # attach layer source to release
        ReleaseLayerSourcePriority.objects.create(\
            release=self.release, layer_source=self.lsrc, priority=1)

        # create a layer version for the layer on the specified branch
        self.layer = Layer.objects.create(name="meta-testlayer",
                                          layer_source=self.lsrc)
        self.branch = Branch.objects.create(name="master", layer_source=self.lsrc)
        self.lver = Layer_Version.objects.create(\
            layer=self.layer, layer_source=self.lsrc, up_branch=self.branch)

        # create project and project layer
        self.project = Project.objects.create_project(name="test-project",
                                                      release=self.release)
        ProjectLayer.objects.create(project=self.project,
                                    layercommit=self.lver)

        # create spoof layer that should not appear in the search results
        layer = Layer.objects.create(name="meta-notvalid",
                                     layer_source=self.lsrc)
        self.lver2 = Layer_Version.objects.create(layer=layer,
                                                  layer_source=self.lsrc,
                                                  up_branch=self.branch)

    def test_single_layersource(self):
        """
        When we have a single layer version,
        get_equivalents_wpriority() should return a list with
        just this layer_version.
        """
        equivqs = self.lver.get_equivalents_wpriority(self.project)
        self.assertEqual(list(equivqs), [self.lver])

    def test_dual_layersource(self):
        """
        If we have two layers with the same name, from different layer sources,
        we expect both layers in, in increasing priority of the layer source.
        """
        lsrc2 = LayerSource.objects.create(\
                    name="dummy-layersource2",
                    sourcetype=LayerSource.TYPE_LOCAL,
                    apiurl="test")

        # assign a lower priority for the second layer source
        self.release.releaselayersourcepriority_set.create(layer_source=lsrc2,
                                                           priority=2)

        # create a new layer_version for a layer with the same name
        # coming from the second layer source
        layer2 = Layer.objects.create(name="meta-testlayer",
                                      layer_source=lsrc2)
        lver2 = Layer_Version.objects.create(layer=layer2, layer_source=lsrc2,
                                             up_branch=self.branch)

        # expect two layer versions, in the priority order
        equivqs = self.lver.get_equivalents_wpriority(self.project)
        self.assertEqual(list(equivqs), [lver2, self.lver])

    def test_build_layerversion(self):
        """
        Any layer version coming from the build should show up
        before any layer version coming from upstream
        """
        build = Build.objects.create(project=self.project,
                                     started_on=timezone.now(),
                                     completed_on=timezone.now())
        lvb = Layer_Version.objects.create(layer=self.layer, build=build,
                                           commit="deadbeef")

        # a build layerversion must be in the equivalence
        # list for the original layerversion
        equivqs = self.lver.get_equivalents_wpriority(self.project)
        self.assertTrue(len(equivqs) == 2)
        self.assertTrue(equivqs[0] == self.lver)
        self.assertTrue(equivqs[1] == lvb)

        # getting the build layerversion equivalent list must
        # return the same list as the original layer
        bequivqs = lvb.get_equivalents_wpriority(self.project)

        self.assertEqual(list(equivqs), list(bequivqs))

    def test_compatible_layerversions(self):
        """
        When we have a 2 layer versions, compatible_layerversions()
        should return a queryset with both.
        """
        compat_lv = self.project.compatible_layerversions()
        self.assertEqual(list(compat_lv), [self.lver, self.lver2])