def create_store(config):
    cookbook = create_cookbook(config)
    store = PackagesStore(config, False)

    for klass in [Package1, Package2, Package3, Package4, App]:
        package = klass(config, store, cookbook)
        package.__file__ = 'test/test_packages_common.py'
        store.add_package(package)
    for klass in [MetaPackage]:
        package = klass(config, store)
        package.__file__ = 'test/test_packages_common.py'
        store.add_package(package)
    return store
class PackageTest(unittest.TestCase):
    def setUp(self):
        self.config = common.DummyConfig()
        self.config.packages_dir = '/test'
        self.config.target_platform = Platform.LINUX
        self.store = PackagesStore(self.config, False)

    def testAddPackage(self):
        package = common.Package1(self.config, None, None)
        self.assertEqual(len(self.store._packages), 0)
        self.store.add_package(package)
        self.assertEqual(len(self.store._packages), 1)
        self.assertEqual(package, self.store._packages[package.name])

    def testGetPackage(self):
        package = common.Package1(self.config, None, None)
        self.store.add_package(package)
        self.assertEqual(package, self.store.get_package(package.name))

    def testPackageNotFound(self):
        self.assertRaises(PackageNotFoundError, self.store.get_package,
                          'unknown')

    def testPackagesList(self):
        package = common.Package1(self.config, None, None)
        metapackage = common.MetaPackage(self.config, None)
        self.store.add_package(package)
        self.store.add_package(metapackage)
        l = sorted([package, metapackage], key=lambda x: x.name)
        self.assertEqual(l, self.store.get_packages_list())

    def testPackageDeps(self):
        package = common.Package1(self.config, None, None)
        package2 = common.Package2(self.config, None, None)
        self.store.add_package(package)
        self.store.add_package(package2)
        self.assertEqual(
            package.deps,
            [x.name for x in self.store.get_package_deps(package.name)])

    def testMetaPackageDeps(self):
        metapackage = common.MetaPackage(self.config, None)
        self.store.add_package(metapackage)
        # the metapackage depends on package that are not yet in the store
        self.assertRaises(PackageNotFoundError, self.store.get_package_deps,
                          metapackage.name)
        for klass in [
                common.Package1, common.Package2, common.Package3,
                common.Package4
        ]:
            p = klass(self.config, None, None)
            self.store.add_package(p)
        for klass in [common.MetaPackage]:
            p = klass(self.config, None)
            self.store.add_package(p)
        deps = [
            'gstreamer-test-bindings', 'gstreamer-test1', 'gstreamer-test2',
            'gstreamer-test3'
        ]
        res = [x.name for x in self.store.get_package_deps(metapackage.name)]
        self.assertEqual(sorted(deps), sorted(res))

    def testLoadPackageFromFile(self):
        package_file = tempfile.NamedTemporaryFile()
        package_file.write(PACKAGE)
        package_file.flush()
        p = self.store._load_package_from_file(package_file.name)
        self.assertIsInstance(p, Package)
        self.assertEqual('test-package', p.name)

    def testLoadMetaPackageFromFile(self):
        for x, t in [(SDKPACKAGE, SDKPackage),
                     (INSTALLERPACKAGE, InstallerPackage)]:
            package_file = tempfile.NamedTemporaryFile()
            package_file.write(x)
            package_file.flush()
            p = self.store._load_package_from_file(package_file.name)
            print(p, type(p))
            self.assertIsInstance(p, t)
            self.assertEqual('test-package', p.name)

    def testImports(self):
        package_file = tempfile.NamedTemporaryFile()
        package_file.write(PACKAGE)
        package_file.flush()
        p = self.store._load_package_from_file(package_file.name)
        self.assertIsInstance(p, Package)
        try:
            p.test_imports()
        except ImportError as e:
            self.fail("Import error raised, %s", e)
class PackageTest(unittest.TestCase):

    def setUp(self):
        self.config = common.DummyConfig()
        self.config.packages_dir = '/test'
        self.config.target_platform = Platform.LINUX
        self.store = PackagesStore(self.config, False)

    def testAddPackage(self):
        package = common.Package1(self.config, None, None)
        self.assertEquals(len(self.store._packages), 0)
        self.store.add_package(package)
        self.assertEquals(len(self.store._packages), 1)
        self.assertEquals(package, self.store._packages[package.name])

    def testGetPackage(self):
        package = common.Package1(self.config, None, None)
        self.store.add_package(package)
        self.assertEquals(package, self.store.get_package(package.name))

    def testPackageNotFound(self):
        self.failUnlessRaises(PackageNotFoundError, self.store.get_package,
            'unknown')

    def testPackagesList(self):
        package = common.Package1(self.config, None, None)
        metapackage = common.MetaPackage(self.config, None)
        self.store.add_package(package)
        self.store.add_package(metapackage)
        l = sorted([package, metapackage], key=lambda x: x.name)
        self.assertEquals(l, self.store.get_packages_list())

    def testPackageDeps(self):
        package = common.Package1(self.config, None,  None)
        package2 = common.Package2(self.config, None, None)
        self.store.add_package(package)
        self.store.add_package(package2)
        self.assertEquals(package.deps,
            [x.name for x in self.store.get_package_deps(package.name)])

    def testMetaPackageDeps(self):
        metapackage = common.MetaPackage(self.config, None)
        self.store.add_package(metapackage)
        # the metapackage depends on package that are not yet in the store
        self.failUnlessRaises(PackageNotFoundError,
            self.store.get_package_deps, metapackage.name)
        for klass in [common.Package1, common.Package2, common.Package3,
                common.Package4]:
            p = klass(self.config, None, None)
            self.store.add_package(p)
        for klass in [common.MetaPackage]:
            p = klass(self.config, None)
            self.store.add_package(p)
        deps = ['gstreamer-test-bindings', 'gstreamer-test1',
                'gstreamer-test2', 'gstreamer-test3']
        res = [x.name for x in self.store.get_package_deps(metapackage.name)]
        self.assertEquals(sorted(deps), sorted(res))

    def testLoadPackageFromFile(self):
        package_file = tempfile.NamedTemporaryFile()
        package_file.write(PACKAGE)
        package_file.flush()
        p = self.store._load_package_from_file(package_file.name)
        self.assertIsInstance(p, Package)
        self.assertEquals('test-package', p.name)

    def testLoadMetaPackageFromFile(self):
        for x, t in [(SDKPACKAGE, SDKPackage),
                (INSTALLERPACKAGE, InstallerPackage)]:
            package_file = tempfile.NamedTemporaryFile()
            package_file.write(x)
            package_file.flush()
            p = self.store._load_package_from_file(package_file.name)
            print p, type(p)
            self.assertIsInstance(p, t)
            self.assertEquals('test-package', p.name)

    def testImports(self):
        package_file = tempfile.NamedTemporaryFile()
        package_file.write(PACKAGE)
        package_file.flush()
        p = self.store._load_package_from_file(package_file.name)
        self.assertIsInstance(p, Package)
        try:
            p.test_imports()
        except ImportError, e:
            self.fail("Import error raised, %s", e)