1.7.0-1 (patches unapplied)import/1.7.0-1 ubuntu/wily-proposed ubuntu/wily-devel ubuntu/wily

Imported using git-ubuntu import.
author: Thomas Goirand <zigo@debian.org> 2015-09-26 19:37:25 +0000
committer: git-ubuntu importer <ubuntu-devel-discuss@lists.ubuntu.com> 2015-09-27 04:10:17 +0000
commit: ebeeea8f7893f20d811b5ac6cf1137787419cccd (patch)
tree: 77b1268ef539955f427306a909080847578d20cf /openstackclient/tests
parent: 3b23dabb641692af41b4988583a0c80698ea94c1 (diff)
7 files changed, 782 insertions, 8 deletions
diff --git a/openstackclient/tests/common/test_context.py b/openstackclient/tests/common/test_context.py
new file mode 100644
index 0000000..55e4285
--- /dev/null
+++ b/openstackclient/tests/common/test_context.py
@@ -0,0 +1,202 @@
+#   Licensed under the Apache License, Version 2.0 (the "License"); you may
+#   not use this file except in compliance with the License. You may obtain
+#   a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#   License for the specific language governing permissions and limitations
+#   under the License.
+#
+
+import logging
+import mock
+
+from openstackclient.common import context
+from openstackclient.tests import utils
+
+
+class TestContext(utils.TestCase):
+
+    def test_log_level_from_options(self):
+        opts = mock.Mock()
+        opts.verbose_level = 0
+        self.assertEqual(logging.ERROR, context.log_level_from_options(opts))
+        opts.verbose_level = 1
+        self.assertEqual(logging.WARNING, context.log_level_from_options(opts))
+        opts.verbose_level = 2
+        self.assertEqual(logging.INFO, context.log_level_from_options(opts))
+        opts.verbose_level = 3
+        self.assertEqual(logging.DEBUG, context.log_level_from_options(opts))
+
+    def test_log_level_from_config(self):
+        cfg = {'verbose_level': 0}
+        self.assertEqual(logging.ERROR, context.log_level_from_config(cfg))
+        cfg = {'verbose_level': 1}
+        self.assertEqual(logging.WARNING, context.log_level_from_config(cfg))
+        cfg = {'verbose_level': 2}
+        self.assertEqual(logging.INFO, context.log_level_from_config(cfg))
+        cfg = {'verbose_level': 3}
+        self.assertEqual(logging.DEBUG, context.log_level_from_config(cfg))
+        cfg = {'verbose_level': 1, 'log_level': 'critical'}
+        self.assertEqual(logging.CRITICAL, context.log_level_from_config(cfg))
+        cfg = {'verbose_level': 1, 'log_level': 'error'}
+        self.assertEqual(logging.ERROR, context.log_level_from_config(cfg))
+        cfg = {'verbose_level': 1, 'log_level': 'warning'}
+        self.assertEqual(logging.WARNING, context.log_level_from_config(cfg))
+        cfg = {'verbose_level': 1, 'log_level': 'info'}
+        self.assertEqual(logging.INFO, context.log_level_from_config(cfg))
+        cfg = {'verbose_level': 1, 'log_level': 'debug'}
+        self.assertEqual(logging.DEBUG, context.log_level_from_config(cfg))
+        cfg = {'verbose_level': 1, 'log_level': 'bogus'}
+        self.assertEqual(logging.WARNING, context.log_level_from_config(cfg))
+        cfg = {'verbose_level': 1, 'log_level': 'info', 'debug': True}
+        self.assertEqual(logging.DEBUG, context.log_level_from_config(cfg))
+
+    @mock.patch('warnings.simplefilter')
+    def test_set_warning_filter(self, simplefilter):
+        context.set_warning_filter(logging.ERROR)
+        simplefilter.assert_called_with("ignore")
+        context.set_warning_filter(logging.WARNING)
+        simplefilter.assert_called_with("ignore")
+        context.set_warning_filter(logging.INFO)
+        simplefilter.assert_called_with("once")
+
+
+class TestFileFormatter(utils.TestCase):
+    def test_nothing(self):
+        formatter = context._FileFormatter()
+        self.assertEqual(('%(asctime)s.%(msecs)03d %(process)d %(levelname)s '
+                          '%(name)s %(message)s'), formatter.fmt)
+
+    def test_options(self):
+        class Opts(object):
+            cloud = 'cloudy'
+            os_project_name = 'projecty'
+            username = 'usernamey'
+        options = Opts()
+        formatter = context._FileFormatter(options=options)
+        self.assertEqual(('%(asctime)s.%(msecs)03d %(process)d %(levelname)s '
+                          '%(name)s [cloudy usernamey projecty] %(message)s'),
+                         formatter.fmt)
+
+    def test_config(self):
+        config = mock.Mock()
+        config.config = {'cloud': 'cloudy'}
+        config.auth = {'project_name': 'projecty', 'username': 'usernamey'}
+        formatter = context._FileFormatter(config=config)
+        self.assertEqual(('%(asctime)s.%(msecs)03d %(process)d %(levelname)s '
+                          '%(name)s [cloudy usernamey projecty] %(message)s'),
+                         formatter.fmt)
+
+
+class TestLogConfigurator(utils.TestCase):
+    def setUp(self):
+        super(TestLogConfigurator, self).setUp()
+        self.options = mock.Mock()
+        self.options.verbose_level = 1
+        self.options.log_file = None
+        self.options.debug = False
+        self.root_logger = mock.Mock()
+        self.root_logger.setLevel = mock.Mock()
+        self.root_logger.addHandler = mock.Mock()
+        self.requests_log = mock.Mock()
+        self.requests_log.setLevel = mock.Mock()
+        self.cliff_log = mock.Mock()
+        self.cliff_log.setLevel = mock.Mock()
+        self.stevedore_log = mock.Mock()
+        self.stevedore_log.setLevel = mock.Mock()
+        self.iso8601_log = mock.Mock()
+        self.iso8601_log.setLevel = mock.Mock()
+        self.loggers = [
+            self.root_logger,
+            self.requests_log,
+            self.cliff_log,
+            self.stevedore_log,
+            self.iso8601_log]
+
+    @mock.patch('logging.StreamHandler')
+    @mock.patch('logging.getLogger')
+    @mock.patch('openstackclient.common.context.set_warning_filter')
+    def test_init(self, warning_filter, getLogger, handle):
+        getLogger.side_effect = self.loggers
+        console_logger = mock.Mock()
+        console_logger.setFormatter = mock.Mock()
+        console_logger.setLevel = mock.Mock()
+        handle.return_value = console_logger
+
+        configurator = context.LogConfigurator(self.options)
+
+        getLogger.assert_called_with('iso8601')  # last call
+        warning_filter.assert_called_with(logging.WARNING)
+        self.root_logger.setLevel.assert_called_with(logging.DEBUG)
+        self.root_logger.addHandler.assert_called_with(console_logger)
+        self.requests_log.setLevel.assert_called_with(logging.ERROR)
+        self.cliff_log.setLevel.assert_called_with(logging.ERROR)
+        self.stevedore_log.setLevel.assert_called_with(logging.ERROR)
+        self.iso8601_log.setLevel.assert_called_with(logging.ERROR)
+        self.assertEqual(False, configurator.dump_trace)
+
+    @mock.patch('logging.getLogger')
+    @mock.patch('openstackclient.common.context.set_warning_filter')
+    def test_init_no_debug(self, warning_filter, getLogger):
+        getLogger.side_effect = self.loggers
+        self.options.debug = True
+
+        configurator = context.LogConfigurator(self.options)
+
+        warning_filter.assert_called_with(logging.DEBUG)
+        self.requests_log.setLevel.assert_called_with(logging.DEBUG)
+        self.assertEqual(True, configurator.dump_trace)
+
+    @mock.patch('logging.FileHandler')
+    @mock.patch('logging.getLogger')
+    @mock.patch('openstackclient.common.context.set_warning_filter')
+    @mock.patch('openstackclient.common.context._FileFormatter')
+    def test_init_log_file(self, formatter, warning_filter, getLogger, handle):
+        getLogger.side_effect = self.loggers
+        self.options.log_file = '/tmp/log_file'
+        file_logger = mock.Mock()
+        file_logger.setFormatter = mock.Mock()
+        file_logger.setLevel = mock.Mock()
+        handle.return_value = file_logger
+        mock_formatter = mock.Mock()
+        formatter.return_value = mock_formatter
+
+        context.LogConfigurator(self.options)
+
+        handle.assert_called_with(filename=self.options.log_file)
+        self.root_logger.addHandler.assert_called_with(file_logger)
+        file_logger.setFormatter.assert_called_with(mock_formatter)
+        file_logger.setLevel.assert_called_with(logging.WARNING)
+
+    @mock.patch('logging.FileHandler')
+    @mock.patch('logging.getLogger')
+    @mock.patch('openstackclient.common.context.set_warning_filter')
+    @mock.patch('openstackclient.common.context._FileFormatter')
+    def test_configure(self, formatter, warning_filter, getLogger, handle):
+        getLogger.side_effect = self.loggers
+        configurator = context.LogConfigurator(self.options)
+        cloud_config = mock.Mock()
+        config_log = '/tmp/config_log'
+        cloud_config.config = {
+            'log_file': config_log,
+            'verbose_level': 1,
+            'log_level': 'info'}
+        file_logger = mock.Mock()
+        file_logger.setFormatter = mock.Mock()
+        file_logger.setLevel = mock.Mock()
+        handle.return_value = file_logger
+        mock_formatter = mock.Mock()
+        formatter.return_value = mock_formatter
+
+        configurator.configure(cloud_config)
+
+        warning_filter.assert_called_with(logging.INFO)
+        handle.assert_called_with(filename=config_log)
+        self.root_logger.addHandler.assert_called_with(file_logger)
+        file_logger.setFormatter.assert_called_with(mock_formatter)
+        file_logger.setLevel.assert_called_with(logging.INFO)
+        self.assertEqual(False, configurator.dump_trace)
diff --git a/openstackclient/tests/common/test_quota.py b/openstackclient/tests/common/test_quota.py
index f0013e4..b6ad156 100644
--- a/openstackclient/tests/common/test_quota.py
+++ b/openstackclient/tests/common/test_quota.py
@@ -12,6 +12,8 @@
 
 import copy
 
+import mock
+
 from openstackclient.common import quota
 from openstackclient.tests.compute.v2 import fakes as compute_fakes
 from openstackclient.tests import fakes
@@ -38,6 +40,11 @@ class TestQuota(compute_fakes.TestComputev2):
         super(TestQuota, self).setUp()
         self.quotas_mock = self.app.client_manager.compute.quotas
         self.quotas_mock.reset_mock()
+        volume_mock = mock.Mock()
+        volume_mock.quotas = mock.Mock()
+        self.app.client_manager.volume = volume_mock
+        self.volume_quotas_mock = volume_mock.quotas
+        self.volume_quotas_mock.reset_mock()
 
 
 class TestQuotaSet(TestQuota):
@@ -57,6 +64,18 @@ class TestQuotaSet(TestQuota):
             loaded=True,
         )
 
+        self.volume_quotas_mock.find.return_value = FakeQuotaResource(
+            None,
+            copy.deepcopy(compute_fakes.QUOTA),
+            loaded=True,
+        )
+
+        self.volume_quotas_mock.update.return_value = FakeQuotaResource(
+            None,
+            copy.deepcopy(compute_fakes.QUOTA),
+            loaded=True,
+        )
+
         self.cmd = quota.SetQuota(self.app, None)
 
     def test_quota_set(self):
@@ -87,3 +106,29 @@ class TestQuotaSet(TestQuota):
         }
 
         self.quotas_mock.update.assert_called_with('project_test', **kwargs)
+
+    def test_quota_set_volume(self):
+        arglist = [
+            '--gigabytes', str(compute_fakes.floating_ip_num),
+            '--snapshots', str(compute_fakes.fix_ip_num),
+            '--volumes', str(compute_fakes.injected_file_num),
+            compute_fakes.project_name,
+        ]
+        verifylist = [
+            ('gigabytes', compute_fakes.floating_ip_num),
+            ('snapshots', compute_fakes.fix_ip_num),
+            ('volumes', compute_fakes.injected_file_num),
+        ]
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        self.cmd.take_action(parsed_args)
+
+        kwargs = {
+            'gigabytes': compute_fakes.floating_ip_num,
+            'snapshots': compute_fakes.fix_ip_num,
+            'volumes': compute_fakes.injected_file_num,
+        }
+
+        self.volume_quotas_mock.update.assert_called_with('project_test',
+                                                          **kwargs)
diff --git a/openstackclient/tests/compute/v2/test_security_group_rule.py b/openstackclient/tests/compute/v2/test_security_group_rule.py
new file mode 100644
index 0000000..9516f8d
--- /dev/null
+++ b/openstackclient/tests/compute/v2/test_security_group_rule.py
@@ -0,0 +1,338 @@
+#   Licensed under the Apache License, Version 2.0 (the "License"); you may
+#   not use this file except in compliance with the License. You may obtain
+#   a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#   License for the specific language governing permissions and limitations
+#   under the License.
+#
+
+import copy
+import mock
+
+from openstackclient.compute.v2 import security_group
+from openstackclient.tests.compute.v2 import fakes as compute_fakes
+from openstackclient.tests import fakes
+from openstackclient.tests.identity.v2_0 import fakes as identity_fakes
+
+
+security_group_id = '11'
+security_group_name = 'wide-open'
+security_group_description = 'nothing but net'
+
+security_group_rule_id = '1'
+
+SECURITY_GROUP = {
+    'id': security_group_id,
+    'name': security_group_name,
+    'description': security_group_description,
+    'tenant_id': identity_fakes.project_id,
+}
+
+SECURITY_GROUP_RULE = {
+    'id': security_group_rule_id,
+    'group': {},
+    'ip_protocol': 'tcp',
+    'ip_range': '0.0.0.0/0',
+    'parent_group_id': security_group_id,
+    'from_port': 0,
+    'to_port': 0,
+}
+
+SECURITY_GROUP_RULE_ICMP = {
+    'id': security_group_rule_id,
+    'group': {},
+    'ip_protocol': 'icmp',
+    'ip_range': '0.0.0.0/0',
+    'parent_group_id': security_group_id,
+    'from_port': -1,
+    'to_port': -1,
+}
+
+
+class FakeSecurityGroupRuleResource(fakes.FakeResource):
+
+    def get_keys(self):
+        return {'property': 'value'}
+
+
+class TestSecurityGroupRule(compute_fakes.TestComputev2):
+
+    def setUp(self):
+        super(TestSecurityGroupRule, self).setUp()
+
+        self.secgroups_mock = mock.Mock()
+        self.secgroups_mock.resource_class = fakes.FakeResource(None, {})
+        self.app.client_manager.compute.security_groups = self.secgroups_mock
+        self.secgroups_mock.reset_mock()
+
+        self.sg_rules_mock = mock.Mock()
+        self.sg_rules_mock.resource_class = fakes.FakeResource(None, {})
+        self.app.client_manager.compute.security_group_rules = \
+            self.sg_rules_mock
+        self.sg_rules_mock.reset_mock()
+
+
+class TestSecurityGroupRuleCreate(TestSecurityGroupRule):
+
+    def setUp(self):
+        super(TestSecurityGroupRuleCreate, self).setUp()
+
+        self.secgroups_mock.get.return_value = FakeSecurityGroupRuleResource(
+            None,
+            copy.deepcopy(SECURITY_GROUP),
+            loaded=True,
+        )
+
+        # Get the command object to test
+        self.cmd = security_group.CreateSecurityGroupRule(self.app, None)
+
+    def test_security_group_rule_create_no_options(self):
+        self.sg_rules_mock.create.return_value = FakeSecurityGroupRuleResource(
+            None,
+            copy.deepcopy(SECURITY_GROUP_RULE),
+            loaded=True,
+        )
+
+        arglist = [
+            security_group_name,
+        ]
+        verifylist = [
+            ('group', security_group_name),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        # DisplayCommandBase.take_action() returns two tuples
+        columns, data = self.cmd.take_action(parsed_args)
+
+        # SecurityGroupManager.create(name, description)
+        self.sg_rules_mock.create.assert_called_with(
+            security_group_id,
+            'tcp',
+            0,
+            0,
+            '0.0.0.0/0',
+        )
+
+        collist = (
+            'group',
+            'id',
+            'ip_protocol',
+            'ip_range',
+            'parent_group_id',
+            'port_range',
+        )
+        self.assertEqual(collist, columns)
+        datalist = (
+            {},
+            security_group_rule_id,
+            'tcp',
+            '',
+            security_group_id,
+            '0:0',
+        )
+        self.assertEqual(datalist, data)
+
+    def test_security_group_rule_create_ftp(self):
+        sg_rule = copy.deepcopy(SECURITY_GROUP_RULE)
+        sg_rule['from_port'] = 20
+        sg_rule['to_port'] = 21
+        self.sg_rules_mock.create.return_value = FakeSecurityGroupRuleResource(
+            None,
+            sg_rule,
+            loaded=True,
+        )
+
+        arglist = [
+            security_group_name,
+            '--dst-port', '20:21',
+        ]
+        verifylist = [
+            ('group', security_group_name),
+            ('dst_port', (20, 21)),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        # DisplayCommandBase.take_action() returns two tuples
+        columns, data = self.cmd.take_action(parsed_args)
+
+        # SecurityGroupManager.create(name, description)
+        self.sg_rules_mock.create.assert_called_with(
+            security_group_id,
+            'tcp',
+            20,
+            21,
+            '0.0.0.0/0',
+        )
+
+        collist = (
+            'group',
+            'id',
+            'ip_protocol',
+            'ip_range',
+            'parent_group_id',
+            'port_range',
+        )
+        self.assertEqual(collist, columns)
+        datalist = (
+            {},
+            security_group_rule_id,
+            'tcp',
+            '',
+            security_group_id,
+            '20:21',
+        )
+        self.assertEqual(datalist, data)
+
+    def test_security_group_rule_create_ssh(self):
+        sg_rule = copy.deepcopy(SECURITY_GROUP_RULE)
+        sg_rule['from_port'] = 22
+        sg_rule['to_port'] = 22
+        self.sg_rules_mock.create.return_value = FakeSecurityGroupRuleResource(
+            None,
+            sg_rule,
+            loaded=True,
+        )
+
+        arglist = [
+            security_group_name,
+            '--dst-port', '22',
+        ]
+        verifylist = [
+            ('group', security_group_name),
+            ('dst_port', (22, 22)),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        # DisplayCommandBase.take_action() returns two tuples
+        columns, data = self.cmd.take_action(parsed_args)
+
+        # SecurityGroupManager.create(name, description)
+        self.sg_rules_mock.create.assert_called_with(
+            security_group_id,
+            'tcp',
+            22,
+            22,
+            '0.0.0.0/0',
+        )
+
+        collist = (
+            'group',
+            'id',
+            'ip_protocol',
+            'ip_range',
+            'parent_group_id',
+            'port_range',
+        )
+        self.assertEqual(collist, columns)
+        datalist = (
+            {},
+            security_group_rule_id,
+            'tcp',
+            '',
+            security_group_id,
+            '22:22',
+        )
+        self.assertEqual(datalist, data)
+
+    def test_security_group_rule_create_udp(self):
+        sg_rule = copy.deepcopy(SECURITY_GROUP_RULE)
+        sg_rule['ip_protocol'] = 'udp'
+        self.sg_rules_mock.create.return_value = FakeSecurityGroupRuleResource(
+            None,
+            sg_rule,
+            loaded=True,
+        )
+
+        arglist = [
+            security_group_name,
+            '--proto', 'udp',
+        ]
+        verifylist = [
+            ('group', security_group_name),
+            ('proto', 'udp'),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        # DisplayCommandBase.take_action() returns two tuples
+        columns, data = self.cmd.take_action(parsed_args)
+
+        # SecurityGroupManager.create(name, description)
+        self.sg_rules_mock.create.assert_called_with(
+            security_group_id,
+            'udp',
+            0,
+            0,
+            '0.0.0.0/0',
+        )
+
+        collist = (
+            'group',
+            'id',
+            'ip_protocol',
+            'ip_range',
+            'parent_group_id',
+            'port_range',
+        )
+        self.assertEqual(collist, columns)
+        datalist = (
+            {},
+            security_group_rule_id,
+            'udp',
+            '',
+            security_group_id,
+            '0:0',
+        )
+        self.assertEqual(datalist, data)
+
+    def test_security_group_rule_create_icmp(self):
+        self.sg_rules_mock.create.return_value = FakeSecurityGroupRuleResource(
+            None,
+            copy.deepcopy(SECURITY_GROUP_RULE_ICMP),
+            loaded=True,
+        )
+
+        arglist = [
+            security_group_name,
+            '--proto', 'ICMP',
+        ]
+        verifylist = [
+            ('group', security_group_name),
+            ('proto', 'ICMP'),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        # DisplayCommandBase.take_action() returns two tuples
+        columns, data = self.cmd.take_action(parsed_args)
+
+        # SecurityGroupManager.create(name, description)
+        self.sg_rules_mock.create.assert_called_with(
+            security_group_id,
+            'ICMP',
+            -1,
+            -1,
+            '0.0.0.0/0',
+        )
+
+        collist = (
+            'group',
+            'id',
+            'ip_protocol',
+            'ip_range',
+            'parent_group_id',
+            'port_range',
+        )
+        self.assertEqual(collist, columns)
+        datalist = (
+            {},
+            security_group_rule_id,
+            'icmp',
+            '',
+            security_group_id,
+            '',
+        )
+        self.assertEqual(datalist, data)
diff --git a/openstackclient/tests/image/v2/test_image.py b/openstackclient/tests/image/v2/test_image.py
index bfb9476..bb720d7 100644
--- a/openstackclient/tests/image/v2/test_image.py
+++ b/openstackclient/tests/image/v2/test_image.py
@@ -19,6 +19,7 @@ import mock
 import warlock
 
 from glanceclient.v2 import schemas
+from openstackclient.common import exceptions
 from openstackclient.image.v2 import image
 from openstackclient.tests import fakes
 from openstackclient.tests.identity.v3 import fakes as identity_fakes
@@ -41,6 +42,191 @@ class TestImage(image_fakes.TestImagev2):
         self.domain_mock.reset_mock()
 
 
+class TestImageCreate(TestImage):
+
+    def setUp(self):
+        super(TestImageCreate, self).setUp()
+
+        self.images_mock.create.return_value = fakes.FakeResource(
+            None,
+            copy.deepcopy(image_fakes.IMAGE),
+            loaded=True,
+        )
+        # This is the return value for utils.find_resource()
+        self.images_mock.get.return_value = copy.deepcopy(image_fakes.IMAGE)
+        self.images_mock.update.return_value = fakes.FakeResource(
+            None,
+            copy.deepcopy(image_fakes.IMAGE),
+            loaded=True,
+        )
+
+        # Get the command object to test
+        self.cmd = image.CreateImage(self.app, None)
+
+    def test_image_reserve_no_options(self):
+        mock_exception = {
+            'find.side_effect': exceptions.CommandError('x'),
+        }
+        self.images_mock.configure_mock(**mock_exception)
+        arglist = [
+            image_fakes.image_name,
+        ]
+        verifylist = [
+            ('container_format', image.DEFAULT_CONTAINER_FORMAT),
+            ('disk_format', image.DEFAULT_DISK_FORMAT),
+            ('name', image_fakes.image_name),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        # DisplayCommandBase.take_action() returns two tuples
+        columns, data = self.cmd.take_action(parsed_args)
+
+        # ImageManager.create(name=, **)
+        self.images_mock.create.assert_called_with(
+            name=image_fakes.image_name,
+            container_format=image.DEFAULT_CONTAINER_FORMAT,
+            disk_format=image.DEFAULT_DISK_FORMAT,
+        )
+
+        # Verify update() was not called, if it was show the args
+        self.assertEqual(self.images_mock.update.call_args_list, [])
+
+        self.images_mock.upload.assert_called_with(
+            mock.ANY, mock.ANY,
+        )
+
+        self.assertEqual(image_fakes.IMAGE_columns, columns)
+        self.assertEqual(image_fakes.IMAGE_data, data)
+
+    @mock.patch('glanceclient.common.utils.get_data_file', name='Open')
+    def test_image_reserve_options(self, mock_open):
+        mock_file = mock.MagicMock(name='File')
+        mock_open.return_value = mock_file
+        mock_open.read.return_value = None
+        mock_exception = {
+            'find.side_effect': exceptions.CommandError('x'),
+        }
+        self.images_mock.configure_mock(**mock_exception)
+        arglist = [
+            '--container-format', 'ovf',
+            '--disk-format', 'fs',
+            '--min-disk', '10',
+            '--min-ram', '4',
+            '--protected',
+            '--private',
+            image_fakes.image_name,
+        ]
+        verifylist = [
+            ('container_format', 'ovf'),
+            ('disk_format', 'fs'),
+            ('min_disk', 10),
+            ('min_ram', 4),
+            ('protected', True),
+            ('unprotected', False),
+            ('public', False),
+            ('private', True),
+            ('name', image_fakes.image_name),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        # DisplayCommandBase.take_action() returns two tuples
+        columns, data = self.cmd.take_action(parsed_args)
+
+        # ImageManager.create(name=, **)
+        self.images_mock.create.assert_called_with(
+            name=image_fakes.image_name,
+            container_format='ovf',
+            disk_format='fs',
+            min_disk=10,
+            min_ram=4,
+            protected=True,
+            visibility='private',
+        )
+
+        # Verify update() was not called, if it was show the args
+        self.assertEqual(self.images_mock.update.call_args_list, [])
+
+        self.images_mock.upload.assert_called_with(
+            mock.ANY, mock.ANY,
+        )
+
+        self.assertEqual(image_fakes.IMAGE_columns, columns)
+        self.assertEqual(image_fakes.IMAGE_data, data)
+
+    @mock.patch('glanceclient.common.utils.get_data_file', name='Open')
+    def test_image_create_file(self, mock_open):
+        mock_file = mock.MagicMock(name='File')
+        mock_open.return_value = mock_file
+        mock_open.read.return_value = image_fakes.IMAGE_data
+        mock_exception = {
+            'find.side_effect': exceptions.CommandError('x'),
+        }
+        self.images_mock.configure_mock(**mock_exception)
+
+        arglist = [
+            '--file', 'filer',
+            '--unprotected',
+            '--public',
+            '--property', 'Alpha=1',
+            '--property', 'Beta=2',
+            '--tag', 'awesome',
+            '--tag', 'better',
+            image_fakes.image_name,
+        ]
+        verifylist = [
+            ('file', 'filer'),
+            ('protected', False),
+            ('unprotected', True),
+            ('public', True),
+            ('private', False),
+            ('properties', {'Alpha': '1', 'Beta': '2'}),
+            ('tags', ['awesome', 'better']),
+            ('name', image_fakes.image_name),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        # DisplayCommandBase.take_action() returns two tuples
+        columns, data = self.cmd.take_action(parsed_args)
+
+        # ImageManager.create(name=, **)
+        self.images_mock.create.assert_called_with(
+            name=image_fakes.image_name,
+            container_format=image.DEFAULT_CONTAINER_FORMAT,
+            disk_format=image.DEFAULT_DISK_FORMAT,
+            protected=False,
+            visibility='public',
+            Alpha='1',
+            Beta='2',
+            tags=['awesome', 'better'],
+        )
+
+        # Verify update() was not called, if it was show the args
+        self.assertEqual(self.images_mock.update.call_args_list, [])
+
+        self.images_mock.upload.assert_called_with(
+            mock.ANY, mock.ANY,
+        )
+
+        self.assertEqual(image_fakes.IMAGE_columns, columns)
+        self.assertEqual(image_fakes.IMAGE_data, data)
+
+    def test_image_dead_options(self):
+
+        arglist = [
+            '--owner', 'nobody',
+            image_fakes.image_name,
+        ]
+        verifylist = [
+            ('owner', 'nobody'),
+            ('name', image_fakes.image_name),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        self.assertRaises(
+            exceptions.CommandError,
+            self.cmd.take_action, parsed_args)
+
+
 class TestAddProjectToImage(TestImage):
 
     def setUp(self):
diff --git a/openstackclient/tests/test_shell.py b/openstackclient/tests/test_shell.py
index 0e0cc50..c548d89 100644
--- a/openstackclient/tests/test_shell.py
+++ b/openstackclient/tests/test_shell.py
@@ -77,6 +77,8 @@ CLOUD_2 = {
                 'username': 'zaphod',
             },
             'region_name': 'occ-cloud',
+            'log_file': '/tmp/test_log_file',
+            'log_level': 'debug',
         }
     }
 }
diff --git a/openstackclient/tests/volume/v2/fakes.py b/openstackclient/tests/volume/v2/fakes.py
index 0d8c202..7b7758a 100644
--- a/openstackclient/tests/volume/v2/fakes.py
+++ b/openstackclient/tests/volume/v2/fakes.py
@@ -15,14 +15,15 @@
 import copy
 import mock
 
-from openstackclient.tests.compute.v2 import fakes as compute_fakes
 from openstackclient.tests import fakes
 from openstackclient.tests.identity.v2_0 import fakes as identity_fakes
 from openstackclient.tests.image.v2 import fakes as image_fakes
 from openstackclient.tests import utils
 
-volume_attachment_server = copy.deepcopy(compute_fakes.SERVER)
-volume_attachment_server['device'] = 'device'
+volume_attachment_server = {
+    'device': '/dev/ice',
+    'server_id': '1233',
+}
 
 volume_id = "ce26708d-a7f8-4b4b-9861-4a80256615a6"
 volume_name = "fake_volume"
diff --git a/openstackclient/tests/volume/v2/test_volume.py b/openstackclient/tests/volume/v2/test_volume.py
index 348ae37..b15fd02 100644
--- a/openstackclient/tests/volume/v2/test_volume.py
+++ b/openstackclient/tests/volume/v2/test_volume.py
@@ -548,7 +548,7 @@ class TestVolumeList(TestVolume):
         ]
         self.assertEqual(collist, columns)
 
-        server = volume_fakes.volume_attachment_server['id']
+        server = volume_fakes.volume_attachment_server['server_id']
         device = volume_fakes.volume_attachment_server['device']
         msg = 'Attached to %s on %s ' % (server, device)
         datalist = ((
@@ -583,7 +583,7 @@ class TestVolumeList(TestVolume):
         ]
         self.assertEqual(collist, columns)
 
-        server = volume_fakes.volume_attachment_server['id']
+        server = volume_fakes.volume_attachment_server['server_id']
         device = volume_fakes.volume_attachment_server['device']
         msg = 'Attached to %s on %s ' % (server, device)
         datalist = ((
@@ -618,7 +618,7 @@ class TestVolumeList(TestVolume):
         )
         self.assertEqual(collist, tuple(columns))
 
-        server = volume_fakes.volume_attachment_server['id']
+        server = volume_fakes.volume_attachment_server['server_id']
         device = volume_fakes.volume_attachment_server['device']
         msg = 'Attached to %s on %s ' % (server, device)
 
@@ -654,7 +654,7 @@ class TestVolumeList(TestVolume):
         )
         self.assertEqual(collist, tuple(columns))
 
-        server = volume_fakes.volume_attachment_server['id']
+        server = volume_fakes.volume_attachment_server['server_id']
         device = volume_fakes.volume_attachment_server['device']
         msg = 'Attached to %s on %s ' % (server, device)
         datalist = ((
@@ -693,7 +693,7 @@ class TestVolumeList(TestVolume):
         ]
         self.assertEqual(collist, columns)
 
-        server = volume_fakes.volume_attachment_server['id']
+        server = volume_fakes.volume_attachment_server['server_id']
         device = volume_fakes.volume_attachment_server['device']
         msg = 'Attached to %s on %s ' % (server, device)
         datalist = ((
author	Thomas Goirand <zigo@debian.org>	2015-09-26 19:37:25 +0000
committer	git-ubuntu importer <ubuntu-devel-discuss@lists.ubuntu.com>	2015-09-27 04:10:17 +0000
commit	ebeeea8f7893f20d811b5ac6cf1137787419cccd (patch)
tree	77b1268ef539955f427306a909080847578d20cf /openstackclient/tests
parent	3b23dabb641692af41b4988583a0c80698ea94c1 (diff)