def setUp(self):
     super(TestPackagingController, self).setUp()
     self.context = mock.MagicMock()
     self.context.cache_dir = '/root'
     self.context.async_section.return_value = Executor()
     self.driver = mock.MagicMock(spec=PackagingDriverBase)
     self.controller = PackagingController(self.context, self.driver)
 def setUp(self):
     super(TestPackagingController, self).setUp()
     self.context = mock.MagicMock()
     self.context.cache_dir = '/root'
     self.context.async_section.return_value = Executor()
     self.driver = mock.MagicMock(spec=PackagingDriverBase)
     self.controller = PackagingController(self.context, self.driver)
class TestPackagingController(base.TestCase):
    def setUp(self):
        super(TestPackagingController, self).setUp()
        self.context = mock.MagicMock()
        self.context.cache_dir = '/root'
        self.context.async_section.return_value = Executor()
        self.driver = mock.MagicMock(spec=PackagingDriverBase)
        self.controller = PackagingController(self.context, self.driver)

    @mock.patch("packetary.controllers.packaging.stevedore")
    def test_load_fail_if_unknown_driver(self, stevedore):
        stevedore.ExtensionManager.return_value = {}
        self.assertRaisesRegexp(
            NotImplementedError,
            "The driver unknown_driver is not supported yet.",
            PackagingController.load, "contex", "unknown_driver", "config")

    @mock.patch("packetary.controllers.packaging.stevedore")
    def test_load_driver(self, stevedore):
        stevedore.ExtensionManager.return_value = {
            "test": mock.MagicMock(obj=self.driver)
        }
        PackagingController._drivers = None
        controller = PackagingController.load("context", "test", "config")
        self.assertIs(self.driver, controller.driver)
        stevedore.ExtensionManager.assert_called_once_with(
            "packetary.packaging_drivers",
            invoke_on_load=True,
            invoke_args=("config", ))

    def test_get_data_schema(self):
        self.driver.get_data_schema.return_value = {}
        self.assertIs(self.driver.get_data_schema.return_value,
                      self.controller.get_data_schema())
        self.driver.get_data_schema.assert_called_once_with()

    def test_build_packages(self):
        src = '/src'
        spec = 'http://localhost/spec.txt'
        data = {'src': src, 'test': {'spec': spec}}
        self.driver.get_for_caching.return_value = [src, spec]
        output_dir = '/tmp/'
        callback = mock.MagicMock()
        self.controller.build_packages(data, output_dir, callback)
        self.driver.build_packages.assert_called_once_with(
            data, {
                src: src,
                spec: '/root/spec.txt'
            }, output_dir, callback)

    def test_add_to_cache(self):
        cache = {}
        self.controller._add_to_cache('/test', cache)
        self.assertEqual('/test', cache['/test'])
        self.assertEqual(0, self.context.connection.retrieve.call_count)
        self.controller._add_to_cache('http://localhost/test.txt', cache)
        self.assertEqual('/root/test.txt', cache['http://localhost/test.txt'])
        self.context.connection.retrieve.assert_called_once_with(
            'http://localhost/test.txt', '/root/test.txt')
 def test_load_driver(self, stevedore):
     stevedore.ExtensionManager.return_value = {
         "test": mock.MagicMock(obj=self.driver)
     }
     PackagingController._drivers = None
     controller = PackagingController.load("context", "test", "config")
     self.assertIs(self.driver, controller.driver)
     stevedore.ExtensionManager.assert_called_once_with(
         "packetary.packaging_drivers",
         invoke_on_load=True,
         invoke_args=("config", ))
 def test_load_driver(self, stevedore):
     stevedore.ExtensionManager.return_value = {
         "test": mock.MagicMock(obj=self.driver)
     }
     PackagingController._drivers = None
     controller = PackagingController.load("context", "test", "config")
     self.assertIs(self.driver, controller.driver)
     stevedore.ExtensionManager.assert_called_once_with(
         "packetary.packaging_drivers", invoke_on_load=True,
         invoke_args=("config",)
     )
    def create(cls, config, driver_type, driver_config):
        """Creates the packaging API instance.

        :param config: the global config
        :param driver_type: the name of driver which will be used
        :param driver_config: the config of driver

        :return PackagingApi instance
        """
        context = config if isinstance(config, Context) else Context(config)
        return cls(
            PackagingController.load(context, driver_type, driver_config)
        )
class TestPackagingController(base.TestCase):
    def setUp(self):
        super(TestPackagingController, self).setUp()
        self.context = mock.MagicMock()
        self.context.cache_dir = '/root'
        self.context.async_section.return_value = Executor()
        self.driver = mock.MagicMock(spec=PackagingDriverBase)
        self.controller = PackagingController(self.context, self.driver)

    @mock.patch("packetary.controllers.packaging.stevedore")
    def test_load_fail_if_unknown_driver(self, stevedore):
        stevedore.ExtensionManager.return_value = {}
        self.assertRaisesRegexp(
            NotImplementedError,
            "The driver unknown_driver is not supported yet.",
            PackagingController.load, "contex", "unknown_driver", "config"
        )

    @mock.patch("packetary.controllers.packaging.stevedore")
    def test_load_driver(self, stevedore):
        stevedore.ExtensionManager.return_value = {
            "test": mock.MagicMock(obj=self.driver)
        }
        PackagingController._drivers = None
        controller = PackagingController.load("context", "test", "config")
        self.assertIs(self.driver, controller.driver)
        stevedore.ExtensionManager.assert_called_once_with(
            "packetary.packaging_drivers", invoke_on_load=True,
            invoke_args=("config",)
        )

    def test_get_data_schema(self):
        self.driver.get_data_schema.return_value = {}
        self.assertIs(
            self.driver.get_data_schema.return_value,
            self.controller.get_data_schema()
        )
        self.driver.get_data_schema.assert_called_once_with()

    def test_build_packages(self):
        src = '/src'
        spec = 'http://localhost/spec.txt'
        data = {'src': src, 'test': {'spec': spec}}
        self.driver.get_for_caching.return_value = [src, spec]
        output_dir = '/tmp/'
        callback = mock.MagicMock()
        self.controller.build_packages(data, output_dir, callback)
        self.driver.build_packages.assert_called_once_with(
            data,
            {src: src, spec: '/root/spec.txt'},
            output_dir,
            callback
        )

    def test_add_to_cache(self):
        cache = {}
        self.controller._add_to_cache('/test', cache)
        self.assertEqual('/test', cache['/test'])
        self.assertEqual(0, self.context.connection.retrieve.call_count)
        self.controller._add_to_cache('http://localhost/test.txt', cache)
        self.assertEqual('/root/test.txt', cache['http://localhost/test.txt'])
        self.context.connection.retrieve.assert_called_once_with(
            'http://localhost/test.txt', '/root/test.txt'
        )