openstack/python-troveclient
Code Issues Proposed changes
Files
2b8282bb1e254e7716eab106ca8cc0d6c0097a51
python-troveclient/troveclient/compat/tests/test_common.py
Sean McGinnis 2b8282bb1e Use unittest.mock instead of third party mock 
Now that we no longer support py27, we can use the standard library
unittest.mock module instead of the third party mock lib.

Change-Id: Ib83e626f51e6e01898bb7931c1660a1a548500f3
Signed-off-by: Sean McGinnis <sean.mcginnis@gmail.com>
2020-04-18 11:59:46 -05:00

399 lines
13 KiB
Python
Raw Blame History

# Copyright (c) 2011 OpenStack Foundation
# All Rights Reserved.
#
# 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 collections
import json
import optparse
import sys
from unittest import mock
import testtools
from troveclient.compat import common
"""
unit tests for common.py
"""
class CommonTest(testtools.TestCase):
def setUp(self):
super(CommonTest, self).setUp()
self.orig_sys_exit = sys.exit
sys.exit = mock.Mock(return_value=None)
def tearDown(self):
super(CommonTest, self).tearDown()
sys.exit = self.orig_sys_exit
def test_methods_of(self):
class DummyClass(object):
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.Mock()
# compat still uses status
resp.status = s
self.assertRaises(Exception,
common.check_for_exceptions, resp, "body")
# a no-exception case
resp = mock.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(testtools.TestCase):
def check_default_options(self, co):
self.assertIsNone(co.username)
self.assertIsNone(co.apikey)
self.assertIsNone(co.tenant_id)
self.assertIsNone(co.auth_url)
self.assertEqual('keystone', co.auth_type)
self.assertEqual('database', co.service_type)
self.assertEqual('RegionOne', co.region)
self.assertIsNone(co.service_url)
self.assertFalse(co.insecure)
self.assertFalse(co.verbose)
self.assertFalse(co.debug)
self.assertIsNone(co.token)
def check_option(self, oparser, option_name):
option = oparser.get_option("--%s" % option_name)
self.assertIsNotNone(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_default(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",
"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(testtools.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(testtools.TestCase):
def setUp(self):
super(CommandsBaseTest, self).setUp()
self.orig_sys_exit = sys.exit
sys.exit = mock.Mock(return_value=None)
self.orig_sys_argv = sys.argv
sys.argv = ['fakecmd']
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
sys.argv = self.orig_sys_argv
def test___init__(self):
self.assertIsNotNone(self.cmd_base)
def test__safe_exec(self):
func = mock.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.Mock(side_effect=ValueError) # an arbitrary exception
r = self.cmd_base._safe_exec(func)
self.assertIsNone(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.assertIsNotNone(option)
option = parser.get_option("--%s" % "test_2")
self.assertIsNotNone(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.Mock(return_value=None)
self.cmd_base.verbose = True
self.assertIsNone(self.cmd_base._pretty_print(func))
self.cmd_base.verbose = False
self.assertIsNone(self.cmd_base._pretty_print(func))
def test__dumps(self):
orig_dumps = json.dumps
json.dumps = mock.Mock(return_value="test-dump")
self.assertEqual("test-dump", self.cmd_base._dumps("item"))
json.dumps = orig_dumps
def test__pretty_list(self):
func = mock.Mock(return_value=None)
self.cmd_base.verbose = True
self.assertIsNone(self.cmd_base._pretty_list(func))
self.cmd_base.verbose = False
self.assertIsNone(self.cmd_base._pretty_list(func))
item = mock.Mock(return_value="test")
item._info = "info"
func = mock.Mock(return_value=[item])
self.assertIsNone(self.cmd_base._pretty_list(func))
def test__pretty_paged(self):
self.cmd_base.limit = "5"
func = mock.Mock(return_value=None)
self.cmd_base.verbose = True
self.assertIsNone(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 self.count
ret = MockIterable()
func = mock.Mock(return_value=ret)
self.assertIsNone(self.cmd_base._pretty_paged(func))
ret.count = 0
self.assertIsNone(self.cmd_base._pretty_paged(func))
func = mock.Mock(side_effect=ValueError)
self.assertIsNone(self.cmd_base._pretty_paged(func))
self.cmd_base.debug = True
self.cmd_base.marker = mock.Mock()
self.assertRaises(ValueError, self.cmd_base._pretty_paged, func)
class AuthTest(testtools.TestCase):
def setUp(self):
super(AuthTest, self).setUp()
self.orig_sys_exit = sys.exit
sys.exit = mock.Mock(return_value=None)
self.orig_sys_argv = sys.argv
sys.argv = ['fakecmd']
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
sys.argv = self.orig_sys_argv
def test___init__(self):
self.assertIsNone(self.auth.dbaas)
self.assertIsNone(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.Mock()
dbaas.authenticate = mock.Mock(return_value=None)
dbaas.client = mock.Mock()
dbaas.client.auth_token = mock.Mock()
dbaas.client.service_url = mock.Mock()
self.auth._get_client = mock.Mock(return_value=dbaas)
self.auth.login()
self.auth.debug = True
self.auth._get_client = mock.Mock(side_effect=ValueError)
self.assertRaises(ValueError, self.auth.login)
self.auth.debug = False
self.auth.login()
class AuthedCommandsBaseTest(testtools.TestCase):
def setUp(self):
super(AuthedCommandsBaseTest, self).setUp()
self.orig_sys_exit = sys.exit
sys.exit = mock.Mock(return_value=None)
self.orig_sys_argv = sys.argv
sys.argv = ['fakecmd']
def tearDown(self):
super(AuthedCommandsBaseTest, self).tearDown()
sys.exit = self.orig_sys_exit
self.orig_sys_argv = sys.argv
def test___init__(self):
parser = common.CliOptions().create_optparser(False)
common.AuthedCommandsBase.debug = True
dbaas = mock.Mock()
dbaas.authenticate = mock.Mock(return_value=None)
dbaas.client = mock.Mock()
dbaas.client.auth_token = mock.Mock()
dbaas.client.service_url = mock.Mock()
dbaas.client.authenticate_with_token = mock.Mock()
common.AuthedCommandsBase._get_client = mock.Mock(return_value=dbaas)
common.AuthedCommandsBase(parser)
class PaginatedTest(testtools.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(next(itr_expected), next(itr))
self.assertEqual(next(itr_expected), next(itr))
self.assertRaises(StopIteration, next, itr_expected)
self.assertRaises(StopIteration, next, itr)
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__()
self.assertEqual("item2", next(itr))
self.assertEqual("item1", next(itr))
self.assertRaises(StopIteration, next, itr)
def test___contains__(self):
self.assertTrue(self.pgn.__contains__("item1"))
self.assertTrue(self.pgn.__contains__("item2"))
self.assertFalse(self.pgn.__contains__("item3"))
View Git Blame Copy Permalink