From fadd19e3a99510b08ca210587c907bf16dedff75 Mon Sep 17 00:00:00 2001 From: Michael Basnight Date: Thu, 10 Oct 2013 17:47:44 +0000 Subject: [PATCH] Removing lxml/httplib2 depends These depends are compat only. They dont need to be listed as deps. Change-Id: Ia5718865100148d149e9c7657ace78cb08cacbac --- requirements.txt | 3 - troveclient/common.py | 1 - troveclient/compat/tests/test_common.py | 375 +++++++++++++++++++++ troveclient/{ => compat}/tests/test_xml.py | 0 troveclient/tests/test_common.py | 299 +--------------- 5 files changed, 377 insertions(+), 301 deletions(-) create mode 100644 troveclient/compat/tests/test_common.py rename troveclient/{ => compat}/tests/test_xml.py (100%) diff --git a/requirements.txt b/requirements.txt index 6dd8f944..a40ca9bf 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,10 +1,7 @@ pbr>=0.5.21,<1.0 argparse -lxml>=2.3 PrettyTable>=0.6,<0.8 requests>=1.1 simplejson>=2.0.9 Babel>=1.3 six>=1.4.1 -# Compat -httplib2 diff --git a/troveclient/common.py b/troveclient/common.py index 9d24da94..4cba2892 100644 --- a/troveclient/common.py +++ b/troveclient/common.py @@ -20,7 +20,6 @@ import pickle import sys from troveclient import client -#from troveclient.xml import TroveXmlClient from troveclient import exceptions from urllib import quote diff --git a/troveclient/compat/tests/test_common.py b/troveclient/compat/tests/test_common.py new file mode 100644 index 00000000..78dd02dc --- /dev/null +++ b/troveclient/compat/tests/test_common.py @@ -0,0 +1,375 @@ +import sys +import optparse +import json +import collections + +from testtools import TestCase +from mock import Mock + +from troveclient.compat import common +from troveclient import client + +""" + unit tests for common.py +""" + + +class CommonTest(TestCase): + + def setUp(self): + super(CommonTest, self).setUp() + self.orig_sys_exit = sys.exit + sys.exit = Mock(return_value=None) + + def tearDown(self): + super(CommonTest, self).tearDown() + sys.exit = self.orig_sys_exit + + def test_methods_of(self): + class DummyClass: + def dummyMethod(self): + print("just for test") + + obj = DummyClass() + result = common.methods_of(obj) + self.assertEqual(1, len(result)) + method = result['dummyMethod'] + self.assertIsNotNone(method) + + def test_check_for_exceptions(self): + status = [400, 422, 500] + for s in status: + resp = Mock() + #compat still uses status + resp.status = s + self.assertRaises(Exception, + common.check_for_exceptions, resp, "body") + + # a no-exception case + resp = Mock() + resp.status_code = 200 + common.check_for_exceptions(resp, "body") + + def test_print_actions(self): + cmd = "test-cmd" + actions = {"test": "test action", "help": "help action"} + common.print_actions(cmd, actions) + pass + + def test_print_commands(self): + commands = {"cmd-1": "cmd 1", "cmd-2": "cmd 2"} + common.print_commands(commands) + pass + + def test_limit_url(self): + url_ = "test-url" + limit_ = None + marker_ = None + self.assertEqual(url_, common.limit_url(url_)) + + limit_ = "test-limit" + marker_ = "test-marker" + expected = "test-url?marker=test-marker&limit=test-limit" + self.assertEqual(expected, + common.limit_url(url_, limit=limit_, marker=marker_)) + + +class CliOptionsTest(TestCase): + + def check_default_options(self, co): + self.assertEqual(None, co.username) + self.assertEqual(None, co.apikey) + self.assertEqual(None, co.tenant_id) + self.assertEqual(None, co.auth_url) + self.assertEqual('keystone', co.auth_type) + self.assertEqual('database', co.service_type) + self.assertEqual('RegionOne', co.region) + self.assertEqual(None, co.service_url) + self.assertFalse(co.insecure) + self.assertFalse(co.verbose) + self.assertFalse(co.debug) + self.assertEqual(None, co.token) + self.assertEqual(None, co.xml) + + def check_option(self, oparser, option_name): + option = oparser.get_option("--%s" % option_name) + self.assertNotEqual(None, option) + if option_name in common.CliOptions.DEFAULT_VALUES: + self.assertEqual(common.CliOptions.DEFAULT_VALUES[option_name], + option.default) + + def test___init__(self): + co = common.CliOptions() + self.check_default_options(co) + + def test_deafult(self): + co = common.CliOptions.default() + self.check_default_options(co) + + def test_load_from_file(self): + co = common.CliOptions.load_from_file() + self.check_default_options(co) + + def test_create_optparser(self): + option_names = ["verbose", "debug", "auth_url", "username", "apikey", + "tenant_id", "auth_type", "service_type", + "service_name", "service_type", "service_name", + "service_url", "region", "insecure", "token", + "xml", "secure", "json", "terse", "hide-debug"] + + oparser = common.CliOptions.create_optparser(True) + for option_name in option_names: + self.check_option(oparser, option_name) + + oparser = common.CliOptions.create_optparser(False) + for option_name in option_names: + self.check_option(oparser, option_name) + + +class ArgumentRequiredTest(TestCase): + + def setUp(self): + super(ArgumentRequiredTest, self).setUp() + self.param = "test-param" + self.arg_req = common.ArgumentRequired(self.param) + + def test___init__(self): + self.assertEqual(self.param, self.arg_req.param) + + def test___str__(self): + expected = 'Argument "--%s" required.' % self.param + self.assertEqual(expected, self.arg_req.__str__()) + + +class CommandsBaseTest(TestCase): + + def setUp(self): + super(CommandsBaseTest, self).setUp() + self.orig_sys_exit = sys.exit + sys.exit = Mock(return_value=None) + parser = common.CliOptions().create_optparser(False) + self.cmd_base = common.CommandsBase(parser) + + def tearDown(self): + super(CommandsBaseTest, self).tearDown() + sys.exit = self.orig_sys_exit + + def test___init__(self): + self.assertNotEqual(None, self.cmd_base) + + def test__safe_exec(self): + func = Mock(return_value="test") + self.cmd_base.debug = True + r = self.cmd_base._safe_exec(func) + self.assertEqual("test", r) + + self.cmd_base.debug = False + r = self.cmd_base._safe_exec(func) + self.assertEqual("test", r) + + func = Mock(side_effect=ValueError) # an arbitrary exception + r = self.cmd_base._safe_exec(func) + self.assertEqual(None, r) + + def test__prepare_parser(self): + parser = optparse.OptionParser() + common.CommandsBase.params = ["test_1", "test_2"] + self.cmd_base._prepare_parser(parser) + option = parser.get_option("--%s" % "test_1") + self.assertNotEqual(None, option) + option = parser.get_option("--%s" % "test_2") + self.assertNotEqual(None, option) + + def test__parse_options(self): + parser = optparse.OptionParser() + parser.add_option("--%s" % "test_1", default="test_1v") + parser.add_option("--%s" % "test_2", default="test_2v") + self.cmd_base._parse_options(parser) + self.assertEqual("test_1v", self.cmd_base.test_1) + self.assertEqual("test_2v", self.cmd_base.test_2) + + def test__require(self): + self.assertRaises(common.ArgumentRequired, + self.cmd_base._require, "attr_1") + self.cmd_base.attr_1 = None + self.assertRaises(common.ArgumentRequired, + self.cmd_base._require, "attr_1") + self.cmd_base.attr_1 = "attr_v1" + self.cmd_base._require("attr_1") + + def test__make_list(self): + self.assertRaises(AttributeError, self.cmd_base._make_list, "attr1") + self.cmd_base.attr1 = "v1,v2" + self.cmd_base._make_list("attr1") + self.assertEqual(["v1", "v2"], self.cmd_base.attr1) + self.cmd_base.attr1 = ["v3"] + self.cmd_base._make_list("attr1") + self.assertEqual(["v3"], self.cmd_base.attr1) + + def test__pretty_print(self): + func = Mock(return_value=None) + self.cmd_base.verbose = True + self.assertEqual(None, self.cmd_base._pretty_print(func)) + self.cmd_base.verbose = False + self.assertEqual(None, self.cmd_base._pretty_print(func)) + + def test__dumps(self): + json.dumps = Mock(return_value="test-dump") + self.assertEqual("test-dump", self.cmd_base._dumps("item")) + + def test__pretty_list(self): + func = Mock(return_value=None) + self.cmd_base.verbose = True + self.assertEqual(None, self.cmd_base._pretty_list(func)) + self.cmd_base.verbose = False + self.assertEqual(None, self.cmd_base._pretty_list(func)) + item = Mock(return_value="test") + item._info = "info" + func = Mock(return_value=[item]) + self.assertEqual(None, self.cmd_base._pretty_list(func)) + + def test__pretty_paged(self): + self.cmd_base.limit = "5" + func = Mock(return_value=None) + self.cmd_base.verbose = True + self.assertEqual(None, self.cmd_base._pretty_paged(func)) + + self.cmd_base.verbose = False + + class MockIterable(collections.Iterable): + links = ["item"] + count = 1 + + def __iter__(self): + return ["item1"] + + def __len__(self): + return count + + ret = MockIterable() + func = Mock(return_value=ret) + self.assertEqual(None, self.cmd_base._pretty_paged(func)) + + ret.count = 0 + self.assertEqual(None, self.cmd_base._pretty_paged(func)) + + func = Mock(side_effect=ValueError) + self.assertEqual(None, self.cmd_base._pretty_paged(func)) + self.cmd_base.debug = True + self.cmd_base.marker = Mock() + self.assertRaises(ValueError, self.cmd_base._pretty_paged, func) + + +class AuthTest(TestCase): + + def setUp(self): + super(AuthTest, self).setUp() + self.orig_sys_exit = sys.exit + sys.exit = Mock(return_value=None) + self.parser = common.CliOptions().create_optparser(False) + self.auth = common.Auth(self.parser) + + def tearDown(self): + super(AuthTest, self).tearDown() + sys.exit = self.orig_sys_exit + + def test___init__(self): + self.assertEqual(None, self.auth.dbaas) + self.assertEqual(None, self.auth.apikey) + + def test_login(self): + self.auth.username = "username" + self.auth.apikey = "apikey" + self.auth.tenant_id = "tenant_id" + self.auth.auth_url = "auth_url" + dbaas = Mock() + dbaas.authenticate = Mock(return_value=None) + dbaas.client = Mock() + dbaas.client.auth_token = Mock() + dbaas.client.service_url = Mock() + self.auth._get_client = Mock(return_value=dbaas) + self.auth.login() + + self.auth.debug = True + self.auth._get_client = Mock(side_effect=ValueError) + self.assertRaises(ValueError, self.auth.login) + + self.auth.debug = False + self.auth.login() + + +class AuthedCommandsBaseTest(TestCase): + + def setUp(self): + super(AuthedCommandsBaseTest, self).setUp() + self.orig_sys_exit = sys.exit + sys.exit = Mock(return_value=None) + + def tearDown(self): + super(AuthedCommandsBaseTest, self).tearDown() + sys.exit = self.orig_sys_exit + + def test___init__(self): + parser = common.CliOptions().create_optparser(False) + common.AuthedCommandsBase.debug = True + dbaas = Mock() + dbaas.authenticate = Mock(return_value=None) + dbaas.client = Mock() + dbaas.client.auth_token = Mock() + dbaas.client.service_url = Mock() + dbaas.client.authenticate_with_token = Mock() + common.AuthedCommandsBase._get_client = Mock(return_value=dbaas) + authed_cmd = common.AuthedCommandsBase(parser) + + +class PaginatedTest(TestCase): + + def setUp(self): + super(PaginatedTest, self).setUp() + self.items_ = ["item1", "item2"] + self.next_marker_ = "next-marker" + self.links_ = ["link1", "link2"] + self.pgn = common.Paginated(self.items_, self.next_marker_, + self.links_) + + def tearDown(self): + super(PaginatedTest, self).tearDown() + + def test___init__(self): + self.assertEqual(self.items_, self.pgn.items) + self.assertEqual(self.next_marker_, self.pgn.next) + self.assertEqual(self.links_, self.pgn.links) + + def test___len__(self): + self.assertEqual(len(self.items_), self.pgn.__len__()) + + def test___iter__(self): + itr_expected = self.items_.__iter__() + itr = self.pgn.__iter__() + self.assertEqual(itr_expected.next(), itr.next()) + self.assertEqual(itr_expected.next(), itr.next()) + self.assertRaises(StopIteration, itr_expected.next) + self.assertRaises(StopIteration, itr.next) + + def test___getitem__(self): + self.assertEqual(self.items_[0], self.pgn.__getitem__(0)) + + def test___setitem__(self): + self.pgn.__setitem__(0, "new-item") + self.assertEqual("new-item", self.pgn.items[0]) + + def test___delitem(self): + del self.pgn[0] + self.assertEqual(1, self.pgn.__len__()) + + def test___reversed__(self): + itr = self.pgn.__reversed__() + expected = ["item2", "item1"] + self.assertEqual("item2", itr.next()) + self.assertEqual("item1", itr.next()) + self.assertRaises(StopIteration, itr.next) + + def test___contains__(self): + self.assertTrue(self.pgn.__contains__("item1")) + self.assertTrue(self.pgn.__contains__("item2")) + self.assertFalse(self.pgn.__contains__("item3")) diff --git a/troveclient/tests/test_xml.py b/troveclient/compat/tests/test_xml.py similarity index 100% rename from troveclient/tests/test_xml.py rename to troveclient/compat/tests/test_xml.py diff --git a/troveclient/tests/test_common.py b/troveclient/tests/test_common.py index 78dd02dc..95dda5e9 100644 --- a/troveclient/tests/test_common.py +++ b/troveclient/tests/test_common.py @@ -1,66 +1,19 @@ -import sys -import optparse -import json -import collections - from testtools import TestCase from mock import Mock -from troveclient.compat import common -from troveclient import client - -""" - unit tests for common.py -""" +from troveclient import common class CommonTest(TestCase): - def setUp(self): - super(CommonTest, self).setUp() - self.orig_sys_exit = sys.exit - sys.exit = Mock(return_value=None) - - def tearDown(self): - super(CommonTest, self).tearDown() - sys.exit = self.orig_sys_exit - - def test_methods_of(self): - class DummyClass: - def dummyMethod(self): - print("just for test") - - obj = DummyClass() - result = common.methods_of(obj) - self.assertEqual(1, len(result)) - method = result['dummyMethod'] - self.assertIsNotNone(method) - def test_check_for_exceptions(self): status = [400, 422, 500] for s in status: resp = Mock() - #compat still uses status - resp.status = s + resp.status_code = s self.assertRaises(Exception, common.check_for_exceptions, resp, "body") - # a no-exception case - resp = Mock() - resp.status_code = 200 - common.check_for_exceptions(resp, "body") - - def test_print_actions(self): - cmd = "test-cmd" - actions = {"test": "test action", "help": "help action"} - common.print_actions(cmd, actions) - pass - - def test_print_commands(self): - commands = {"cmd-1": "cmd 1", "cmd-2": "cmd 2"} - common.print_commands(commands) - pass - def test_limit_url(self): url_ = "test-url" limit_ = None @@ -74,254 +27,6 @@ class CommonTest(TestCase): common.limit_url(url_, limit=limit_, marker=marker_)) -class CliOptionsTest(TestCase): - - def check_default_options(self, co): - self.assertEqual(None, co.username) - self.assertEqual(None, co.apikey) - self.assertEqual(None, co.tenant_id) - self.assertEqual(None, co.auth_url) - self.assertEqual('keystone', co.auth_type) - self.assertEqual('database', co.service_type) - self.assertEqual('RegionOne', co.region) - self.assertEqual(None, co.service_url) - self.assertFalse(co.insecure) - self.assertFalse(co.verbose) - self.assertFalse(co.debug) - self.assertEqual(None, co.token) - self.assertEqual(None, co.xml) - - def check_option(self, oparser, option_name): - option = oparser.get_option("--%s" % option_name) - self.assertNotEqual(None, option) - if option_name in common.CliOptions.DEFAULT_VALUES: - self.assertEqual(common.CliOptions.DEFAULT_VALUES[option_name], - option.default) - - def test___init__(self): - co = common.CliOptions() - self.check_default_options(co) - - def test_deafult(self): - co = common.CliOptions.default() - self.check_default_options(co) - - def test_load_from_file(self): - co = common.CliOptions.load_from_file() - self.check_default_options(co) - - def test_create_optparser(self): - option_names = ["verbose", "debug", "auth_url", "username", "apikey", - "tenant_id", "auth_type", "service_type", - "service_name", "service_type", "service_name", - "service_url", "region", "insecure", "token", - "xml", "secure", "json", "terse", "hide-debug"] - - oparser = common.CliOptions.create_optparser(True) - for option_name in option_names: - self.check_option(oparser, option_name) - - oparser = common.CliOptions.create_optparser(False) - for option_name in option_names: - self.check_option(oparser, option_name) - - -class ArgumentRequiredTest(TestCase): - - def setUp(self): - super(ArgumentRequiredTest, self).setUp() - self.param = "test-param" - self.arg_req = common.ArgumentRequired(self.param) - - def test___init__(self): - self.assertEqual(self.param, self.arg_req.param) - - def test___str__(self): - expected = 'Argument "--%s" required.' % self.param - self.assertEqual(expected, self.arg_req.__str__()) - - -class CommandsBaseTest(TestCase): - - def setUp(self): - super(CommandsBaseTest, self).setUp() - self.orig_sys_exit = sys.exit - sys.exit = Mock(return_value=None) - parser = common.CliOptions().create_optparser(False) - self.cmd_base = common.CommandsBase(parser) - - def tearDown(self): - super(CommandsBaseTest, self).tearDown() - sys.exit = self.orig_sys_exit - - def test___init__(self): - self.assertNotEqual(None, self.cmd_base) - - def test__safe_exec(self): - func = Mock(return_value="test") - self.cmd_base.debug = True - r = self.cmd_base._safe_exec(func) - self.assertEqual("test", r) - - self.cmd_base.debug = False - r = self.cmd_base._safe_exec(func) - self.assertEqual("test", r) - - func = Mock(side_effect=ValueError) # an arbitrary exception - r = self.cmd_base._safe_exec(func) - self.assertEqual(None, r) - - def test__prepare_parser(self): - parser = optparse.OptionParser() - common.CommandsBase.params = ["test_1", "test_2"] - self.cmd_base._prepare_parser(parser) - option = parser.get_option("--%s" % "test_1") - self.assertNotEqual(None, option) - option = parser.get_option("--%s" % "test_2") - self.assertNotEqual(None, option) - - def test__parse_options(self): - parser = optparse.OptionParser() - parser.add_option("--%s" % "test_1", default="test_1v") - parser.add_option("--%s" % "test_2", default="test_2v") - self.cmd_base._parse_options(parser) - self.assertEqual("test_1v", self.cmd_base.test_1) - self.assertEqual("test_2v", self.cmd_base.test_2) - - def test__require(self): - self.assertRaises(common.ArgumentRequired, - self.cmd_base._require, "attr_1") - self.cmd_base.attr_1 = None - self.assertRaises(common.ArgumentRequired, - self.cmd_base._require, "attr_1") - self.cmd_base.attr_1 = "attr_v1" - self.cmd_base._require("attr_1") - - def test__make_list(self): - self.assertRaises(AttributeError, self.cmd_base._make_list, "attr1") - self.cmd_base.attr1 = "v1,v2" - self.cmd_base._make_list("attr1") - self.assertEqual(["v1", "v2"], self.cmd_base.attr1) - self.cmd_base.attr1 = ["v3"] - self.cmd_base._make_list("attr1") - self.assertEqual(["v3"], self.cmd_base.attr1) - - def test__pretty_print(self): - func = Mock(return_value=None) - self.cmd_base.verbose = True - self.assertEqual(None, self.cmd_base._pretty_print(func)) - self.cmd_base.verbose = False - self.assertEqual(None, self.cmd_base._pretty_print(func)) - - def test__dumps(self): - json.dumps = Mock(return_value="test-dump") - self.assertEqual("test-dump", self.cmd_base._dumps("item")) - - def test__pretty_list(self): - func = Mock(return_value=None) - self.cmd_base.verbose = True - self.assertEqual(None, self.cmd_base._pretty_list(func)) - self.cmd_base.verbose = False - self.assertEqual(None, self.cmd_base._pretty_list(func)) - item = Mock(return_value="test") - item._info = "info" - func = Mock(return_value=[item]) - self.assertEqual(None, self.cmd_base._pretty_list(func)) - - def test__pretty_paged(self): - self.cmd_base.limit = "5" - func = Mock(return_value=None) - self.cmd_base.verbose = True - self.assertEqual(None, self.cmd_base._pretty_paged(func)) - - self.cmd_base.verbose = False - - class MockIterable(collections.Iterable): - links = ["item"] - count = 1 - - def __iter__(self): - return ["item1"] - - def __len__(self): - return count - - ret = MockIterable() - func = Mock(return_value=ret) - self.assertEqual(None, self.cmd_base._pretty_paged(func)) - - ret.count = 0 - self.assertEqual(None, self.cmd_base._pretty_paged(func)) - - func = Mock(side_effect=ValueError) - self.assertEqual(None, self.cmd_base._pretty_paged(func)) - self.cmd_base.debug = True - self.cmd_base.marker = Mock() - self.assertRaises(ValueError, self.cmd_base._pretty_paged, func) - - -class AuthTest(TestCase): - - def setUp(self): - super(AuthTest, self).setUp() - self.orig_sys_exit = sys.exit - sys.exit = Mock(return_value=None) - self.parser = common.CliOptions().create_optparser(False) - self.auth = common.Auth(self.parser) - - def tearDown(self): - super(AuthTest, self).tearDown() - sys.exit = self.orig_sys_exit - - def test___init__(self): - self.assertEqual(None, self.auth.dbaas) - self.assertEqual(None, self.auth.apikey) - - def test_login(self): - self.auth.username = "username" - self.auth.apikey = "apikey" - self.auth.tenant_id = "tenant_id" - self.auth.auth_url = "auth_url" - dbaas = Mock() - dbaas.authenticate = Mock(return_value=None) - dbaas.client = Mock() - dbaas.client.auth_token = Mock() - dbaas.client.service_url = Mock() - self.auth._get_client = Mock(return_value=dbaas) - self.auth.login() - - self.auth.debug = True - self.auth._get_client = Mock(side_effect=ValueError) - self.assertRaises(ValueError, self.auth.login) - - self.auth.debug = False - self.auth.login() - - -class AuthedCommandsBaseTest(TestCase): - - def setUp(self): - super(AuthedCommandsBaseTest, self).setUp() - self.orig_sys_exit = sys.exit - sys.exit = Mock(return_value=None) - - def tearDown(self): - super(AuthedCommandsBaseTest, self).tearDown() - sys.exit = self.orig_sys_exit - - def test___init__(self): - parser = common.CliOptions().create_optparser(False) - common.AuthedCommandsBase.debug = True - dbaas = Mock() - dbaas.authenticate = Mock(return_value=None) - dbaas.client = Mock() - dbaas.client.auth_token = Mock() - dbaas.client.service_url = Mock() - dbaas.client.authenticate_with_token = Mock() - common.AuthedCommandsBase._get_client = Mock(return_value=dbaas) - authed_cmd = common.AuthedCommandsBase(parser) - - class PaginatedTest(TestCase): def setUp(self):