def create_connection(self):
conn = MagicMock(MongoClient)
db = MagicMock(Database)
coll = MagicMock(Collection)
conn.__getitem__ = MagicMock(return_value=db)
db.__getitem__ = MagicMock(return_value=coll)
return conn
def setUp(self):
mock_handler = MagicMock()
mock_auth_store = MagicMock()
mock_auth_store.__getitem__ = MagicMock(return_value='Foobar')
mock_endpoints_store = MagicMock()
mock_endpoints_store.__getitem__ = MagicMock(return_value='url_root')
self.handler = mock_handler
self.api = MasonApi(mock_handler, mock_auth_store, mock_endpoints_store)
self.api._customer = 'mason-test'
def test__gather_data(self, mock_stat):
path = '/test'
mock_stat.side_effect = OSError
self.assertFalse(self.ptool._gather_data(path)[0])
mock_stat.assert_called_with(path)
mock_stat.reset_mock()
mock_stat.side_effect = None
# create a return value
stat_rv = MagicMock()
def stat_getitem(key):
if int(key) == stat.ST_UID:
return 0
elif int(key) == stat.ST_GID:
return 10
elif int(key) == stat.ST_MODE:
# return extra bits in the mode to emulate a device
# and ensure that they're stripped
return int('060660', 8)
stat_rv.__getitem__ = Mock(side_effect=stat_getitem)
mock_stat.return_value = stat_rv
# disable selinux and acls for this call -- we test them
# separately so that we can skip those tests as appropriate
states = (Bcfg2.Client.Tools.POSIX.base.HAS_SELINUX,
Bcfg2.Client.Tools.POSIX.base.HAS_ACLS)
Bcfg2.Client.Tools.POSIX.base.HAS_SELINUX = False
Bcfg2.Client.Tools.POSIX.base.HAS_ACLS = False
self.assertEqual(self.ptool._gather_data(path),
(stat_rv, '0', '10', '0660', None, None))
Bcfg2.Client.Tools.POSIX.base.HAS_SELINUX, \
Bcfg2.Client.Tools.POSIX.base.HAS_ACLS = states
mock_stat.assert_called_with(path)
def test_object_identity():
'''Check that values that are modified are what is returned'''
class FieldTester(object):
__metaclass__ = ModelMetaclass
field_a = List(scope=Scope.settings)
def __init__(self, model_data):
self._model_data = model_data
# Make sure that model_data always returns a different object
# each time it's actually queried, so that the caching is
# doing the work to maintain object identity.
model_data = MagicMock(spec=dict)
model_data.__getitem__ = lambda self, name: [name]
field_tester = FieldTester(model_data)
value = field_tester.field_a
assert_equals(value, field_tester.field_a)
# Changing the field in place matches a previously fetched value
field_tester.field_a.append(1)
assert_equals(value, field_tester.field_a)
# Changing the previously-fetched value also changes the value returned by the field:
value.append(2)
assert_equals(value, field_tester.field_a)
# Deletion restores the default value. In the case of a List with
# no default defined, this is the empty list.
del field_tester.field_a
assert_equals([], field_tester.field_a)
def test__gather_data(self, mock_stat):
path = '/test'
mock_stat.side_effect = OSError
self.assertFalse(self.ptool._gather_data(path)[0])
mock_stat.assert_called_with(path)
mock_stat.reset_mock()
mock_stat.side_effect = None
# create a return value
stat_rv = MagicMock()
def stat_getitem(key):
if int(key) == stat.ST_UID:
return 0
elif int(key) == stat.ST_GID:
return 10
elif int(key) == stat.ST_MODE:
# return extra bits in the mode to emulate a device
# and ensure that they're stripped
return int('060660', 8)
stat_rv.__getitem__ = Mock(side_effect=stat_getitem)
mock_stat.return_value = stat_rv
# disable selinux and acls for this call -- we test them
# separately so that we can skip those tests as appropriate
states = (Bcfg2.Client.Tools.POSIX.base.HAS_SELINUX,
Bcfg2.Client.Tools.POSIX.base.HAS_ACLS)
Bcfg2.Client.Tools.POSIX.base.HAS_SELINUX = False
Bcfg2.Client.Tools.POSIX.base.HAS_ACLS = False
self.assertEqual(self.ptool._gather_data(path),
(stat_rv, '0', '10', '0660', None, None))
Bcfg2.Client.Tools.POSIX.base.HAS_SELINUX, \
Bcfg2.Client.Tools.POSIX.base.HAS_ACLS = states
mock_stat.assert_called_with(path)
def test_invalid_page(self):
mocked_qs = MagicMock()
mocked_qs.__getitem__().execute().hits.total = 30000
paginator = ESPaginator(mocked_qs, 5)
assert ESPaginator.max_result_window == 25000
with pytest.raises(InvalidPage) as exc:
# We're fetching 5 items per page, so requesting page 5001 should
# fail, since the max result window should is set to 25000.
paginator.page(5000 + 1)
# Make sure we raise exactly `InvalidPage`, this is needed
# unfortunately since `pytest.raises` won't check the exact
# instance but also accepts parent exceptions inherited.
assert (
exc.value.message ==
'That page number is too high for the current page size')
assert isinstance(exc.value, InvalidPage)
with self.assertRaises(EmptyPage):
paginator.page(0)
with self.assertRaises(PageNotAnInteger):
paginator.page('lol')
def test_caching_is_per_instance():
# Test that values cached for one instance do not appear on another
class FieldTester(object):
"""Toy class for ModelMetaclass and field access testing"""
__metaclass__ = ModelMetaclass
field_a = List(scope=Scope.settings)
def __init__(self, model_data):
self._model_data = model_data
self._dirty_fields = set()
model_data = MagicMock(spec=dict)
model_data.__getitem__ = lambda self, name: [name]
# Same model_data used in different objects should result
# in separately-cached values, so that changing a value
# in one instance doesn't affect values stored in others.
field_tester_a = FieldTester(model_data)
field_tester_b = FieldTester(model_data)
value = field_tester_a.field_a
assert_equals(value, field_tester_a.field_a)
field_tester_a.field_a.append(1)
assert_equals(value, field_tester_a.field_a)
assert_not_equals(value, field_tester_b.field_a)
def test_object_identity():
'''Check that values that are modified are what is returned'''
class FieldTester(object):
__metaclass__ = ModelMetaclass
field_a = List(scope=Scope.settings)
def __init__(self, model_data):
self._model_data = model_data
# Make sure that model_data always returns a different object
# each time it's actually queried, so that the caching is
# doing the work to maintain object identity.
model_data = MagicMock(spec=dict)
model_data.__getitem__ = lambda self, name: [name]
field_tester = FieldTester(model_data)
value = field_tester.field_a
assert_equals(value, field_tester.field_a)
# Changing the field in place matches a previously fetched value
field_tester.field_a.append(1)
assert_equals(value, field_tester.field_a)
# Changing the previously-fetched value also changes the value returned by the field:
value.append(2)
assert_equals(value, field_tester.field_a)
# Deletion restores the default value. In the case of a List with
# no default defined, this is the empty list.
del field_tester.field_a
assert_equals([], field_tester.field_a)
def test_check_for_meta_not_m(self):
result = MagicMock(name="result")
result.attrs = {
"content": "somewords;url=",
"http-equiv": 'refresh',
}
result.__getitem__ = Mock(return_value=result.attrs["content"])
with patch.object(BeautifulSoup, "find", return_value=result):
res = check_for_meta("content", "url")
self.assertEqual(res, None)
def test_check_for_meta_not_m(self):
result = MagicMock(name="result")
result.attrs = {
"content": "somewords;url=",
"http-equiv": 'refresh',
}
result.__getitem__ = Mock(return_value=result.attrs["content"])
with patch.object(BeautifulSoup, "find", return_value=result):
res = check_for_meta("content", "url")
self.assertEqual(res, None)
def test_no_pages_beyond_max_window_result(self):
mocked_qs = MagicMock()
mocked_qs.__getitem__().execute().hits.total = 30000
paginator = ESPaginator(mocked_qs, 5)
assert ESPaginator.max_result_window == 25000
page = paginator.page(4999)
assert page.has_next() is True
page = paginator.page(5000)
assert page.has_next() is False
def test_no_pages_beyond_max_window_result(self):
mocked_qs = MagicMock()
mocked_qs.__getitem__().execute().hits.total = 30000
paginator = ESPaginator(mocked_qs, 5)
assert ESPaginator.max_result_window == 25000
page = paginator.page(4999)
assert page.has_next() is True
page = paginator.page(5000)
assert page.has_next() is False
def run(self, tmp=None, task_vars=None):
vm = self._task.get_variable_manager()
if vm.extra_vars.get('no_monitor', False):
def get_dict(context, key):
return context.__context_dict[key]
def set_dict(context, key, value):
context.__context_dict[key] = value
context = MagicMock()
context.__context_dict = {}
context.__getitem__ = get_dict
context.__setitem__ = set_dict
wait = 0
else:
context = zmq.Context()
wait = 2
socket = context.socket(zmq.REQ)
socket.connect("tcp://localhost:5599")
socket.RCVTIMEO = 2000
if task_vars is None:
task_vars = dict()
name = "{}({})".format(self._task.args['name'],
self._task.args['count'])
msg = dict(status=dict(target=name, state='Provisioning'), bar=50)
socket.send_string(str(msg))
socket.recv_string()
super(ActionModule, self).run(tmp, task_vars)
module_args = self._task.args.copy()
linchpin_mock = task_vars['vars'].get('linchpin_mock',
False)
if linchpin_mock:
return mock_utils.get_mock_data(module_args,
"dummy")
else:
module_return = self._execute_module(module_name='dummy',
module_args=module_args,
task_vars=task_vars, tmp=tmp)
del tmp # tmp no longer has any effect
sleep(wait)
msg = dict(status=dict(target=name, state='Done'), bar=50)
socket.send(str(msg).encode('utf-8'))
socket.recv_string()
sleep(wait)
return module_return
def test_wrap_method(self):
old_cache_get = cache.cache.get
old_cache_set = cache.cache.set
try:
key = 'data'
value = 'ValueOfMyKey'
data = {}
self.cached.get_key = MagicMock(return_value=key)
cached_value = MagicMock()
cached_value.is_valid.return_value = False
cached_value.__getitem__ = lambda s, k: data[k]
cached_value.__setitem__ = lambda s, k, v: data.update({k: v})
func = Mock(__name__=key, return_value=value)
self.cached.function = func
cache.cache.get = lambda k: cached_value
cache.cache.set = lambda k, v, e: data.update({key: v, 'e-%s' % key: e})
wrap = self.cached(func)
wrap()
self.assertTrue(func.called)
self.assertIsInstance(data[key], dict)
self.assertIn('data', data[key])
self.assertIn('expire_date', data[key])
self.assertIsInstance(data['e-%s' % key], int)
self.assertEqual(value, data[key]['data'])
cached_value.is_valid.return_value = True
value = wrap()
self.assertEqual(1, func.call_count)
self.assertEqual(cached_value['data'], value)
cached_value.is_valid.return_value = False
func = Mock(__name__=key, return_value=value)
func.side_effect = Exception('Boom!')
self.cached.function = func
value = wrap()
self.assertEqual(cached_value['data'], value)
cache.cache.get = lambda k: None
self.assertRaises(Exception, wrap, ())
finally:
cache.cache.get = old_cache_get
cache.cache.set = old_cache_set
def test_get(self, get_query_set_mock):
query_set = MagicMock()
query_set.count.return_value = 1
query_set.__getitem__ = lambda *_: ["request"]
get_query_set_mock.return_value = (query_set, None)
response = self.fetch("/api/v1/requests?draw=1")
self.assertEqual(200, response.code)
self.serialize_mock.assert_called_once_with(["request"],
many=True,
only=None,
to_string=True)
self.assertEqual("0", response.headers["start"])
self.assertEqual("1", response.headers["length"])
self.assertEqual("1", response.headers["recordsFiltered"])
self.assertEqual("1", response.headers["recordsTotal"])
self.assertEqual("1", response.headers["draw"])
def test_single_hit(self):
"""Test the ESPaginator only queries ES one time."""
mocked_qs = MagicMock()
mocked_qs.count.return_value = 42
paginator = Paginator(mocked_qs, 5)
# With the base paginator, requesting any page forces a count.
paginator.page(1)
assert paginator.count == 42
assert mocked_qs.count.call_count == 1
mocked_qs = MagicMock()
mocked_qs.__getitem__().execute().hits.total = 666
paginator = ESPaginator(mocked_qs, 5)
# With the ES paginator, the count is fetched from the 'total' key
# in the results.
paginator.page(1)
assert paginator.count == 666
assert mocked_qs.count.call_count == 0
def test_single_hit(self):
"""Test the ESPaginator only queries ES one time."""
mocked_qs = MagicMock()
mocked_qs.count.return_value = 42
paginator = Paginator(mocked_qs, 5)
# With the base paginator, requesting any page forces a count.
paginator.page(1)
assert paginator.count == 42
assert mocked_qs.count.call_count == 1
mocked_qs = MagicMock()
mocked_qs.__getitem__().execute().hits.total = 666
paginator = ESPaginator(mocked_qs, 5)
# With the ES paginator, the count is fetched from the 'total' key
# in the results.
paginator.page(1)
assert paginator.count == 666
assert mocked_qs.count.call_count == 0
def setup_save_failure(update_method):
"""
Set up tests for when there's a save error in the underlying KeyValueStore
"""
model_data = MagicMock(spec=dict)
model_data.__getitem__ = lambda self, name: [name]
model_data.update = update_method
class FieldTester(XBlock):
"""
Test XBlock with three fields
"""
field_a = Integer(scope=Scope.settings)
field_b = Integer(scope=Scope.content, default=10)
field_c = Integer(scope=Scope.user_state, default='field c')
field_tester = FieldTester(MagicMock(), model_data)
return field_tester
def test_duplicate_apps_none(self):
# arrange
mock_api: CloudShellAPISession = Mock()
mock_app: ReservationAppResource = Mock()
mock_app.Name = "mock_app_name"
mock_apps: List[ReservationAppResource] = [mock_app]
mock_app_connectors: Dict[str, List[Connector]] = MagicMock()
mock_sandbox_id: str = Mock()
self.init_env_logic._components_service.get_apps_to_duplicate = Mock(return_value=[])
service_app_positions_dict = MagicMock()
mock_service_app_positions = Mock()
service_app_positions_dict.__getitem__ = MagicMock(return_value=mock_service_app_positions)
self.init_env_logic._env_data.users_list = []
self.init_env_logic._duplicate_app_and_get_update_request = []
# act
return_val = self.init_env_logic._duplicate_apps(mock_api, mock_apps, mock_app_connectors, mock_sandbox_id)
# assert
mock_api.EditAppsInReservation.assert_not_called()
mock_api.SetConnectorsInReservation.assert_not_called()
self.assertEqual(return_val, [])
def test_caching_is_per_instance():
'''Test that values cached for one instance do not appear on another'''
class FieldTester(object):
__metaclass__ = ModelMetaclass
field_a = List(scope=Scope.settings)
def __init__(self, model_data):
self._model_data = model_data
model_data = MagicMock(spec=dict)
model_data.__getitem__ = lambda self, name: [name]
# Same model_data used in different objects should result
# in separately-cached values, so that changing a value
# in one instance doesn't affect values stored in others.
field_tester_a = FieldTester(model_data)
field_tester_b = FieldTester(model_data)
value = field_tester_a.field_a
assert_equals(value, field_tester_a.field_a)
field_tester_a.field_a.append(1)
assert_equals(value, field_tester_a.field_a)
assert_not_equals(value, field_tester_b.field_a)
def test_duplicate_apps(self):
# arrange
mock_api: CloudShellAPISession = Mock()
mock_app: ReservationAppResource = Mock()
mock_app.Name = "mock_app_name"
mock_apps: List[ReservationAppResource] = [mock_app]
mock_app_connectors: Dict[str, List[Connector]] = MagicMock()
mock_sandbox_id: str = Mock()
self.init_env_logic._components_service.get_apps_to_duplicate = Mock(return_value=mock_apps)
service_app_positions_dict = MagicMock()
mock_service_app_positions = Mock()
service_app_positions_dict.__getitem__ = MagicMock(return_value=mock_service_app_positions)
self.init_env_logic._components_service.get_service_and_app_name_to_position_dict = MagicMock(
return_value=service_app_positions_dict)
self.init_env_logic._env_data.users_list = [Mock()]
self.init_env_logic._duplicate_app_and_get_update_request = Mock()
# act
self.init_env_logic._duplicate_apps(mock_api, mock_apps, mock_app_connectors, mock_sandbox_id)
# assert
self.init_env_logic._duplicate_app_and_get_update_request.assert_called_once_with(mock_api, "1_mock_app_name",
mock_app, mock_sandbox_id,
mock_service_app_positions, 0)
class CCITests_unittests(unittest.TestCase):
def setUp(self):
self.client = MagicMock()
self.cci = SoftLayer.CCIManager(self.client)
def test_list_instances(self):
all_guests = [call(mask=ANY), call(mask=ANY)]
other_guests = [call(mask=ANY)]
self.cci.list_instances(hourly=True, monthly=True)
self.cci.list_instances(hourly=False, monthly=False)
self.client.__getitem__().getVirtualGuests.assert_has_calls(all_guests)
self.cci.list_instances(hourly=False, monthly=True)
self.client.__getitem__().getMonthlyVirtualGuests.assert_has_calls(other_guests)
self.cci.list_instances(hourly=True, monthly=False)
self.client.__getitem__().getHourlyVirtualGuests.assert_has_calls(other_guests)
def test_get_instance(self):
self.client.__getitem__().getObject.return_value = {
'hourlyVirtualGuests': "this is unique"}
self.cci.get_instance(1)
self.client.__getitem__().getObject.assert_called_once_with(
id=1, mask=ANY)
def test_get_create_options(self):
self.cci.get_create_options()
self.client.__getitem__().getCreateObjectOptions.assert_called_once_with()
def test_cancel_instance(self):
self.cci.cancel_instance(id=1)
self.client.__getitem__().deleteObject.assert_called_once_with(id=1)
@patch('SoftLayer.CCI.CCIManager._generate_create_dict')
def test_create_verify(self, create_dict):
create_dict.return_value = {'test': 1, 'verify': 1}
self.cci.verify_create_instance(test=1, verify=1)
create_dict.assert_called_once_with(test=1, verify=1)
self.client.__getitem__().generateOrderTemplate.assert_called_once_with(
{'test': 1, 'verify': 1})
@patch('SoftLayer.CCI.CCIManager._generate_create_dict')
def test_create_instance(self, create_dict):
create_dict.return_value = {'test': 1, 'verify': 1}
self.cci.create_instance(test=1, verify=1)
create_dict.assert_called_once_with(test=1, verify=1)
self.client.__getitem__().createObject.assert_called_once_with(
{'test': 1, 'verify': 1})
def test_generate_os_and_image(self):
self.assertRaises(
SoftLayer.CCI.CCICreateMutuallyExclusive,
self.cci._generate_create_dict,
cpus=1,
memory=1,
hostname='test',
domain='example.com',
os_code=1,
image_id=1,
)
def test_generate_missing(self):
self.assertRaises(
SoftLayer.CCI.CCICreateMissingRequired,
self.cci._generate_create_dict,
)
self.assertRaises(
SoftLayer.CCI.CCICreateMissingRequired,
self.cci._generate_create_dict,
cpus=1
)
def test_generate_basic(self):
data = self.cci._generate_create_dict(
cpus=1,
memory=1,
hostname='test',
domain='example.com',
os_code="STRING",
)
assert_data = {
'startCpus': 1,
'maxMemory': 1,
'hostname': 'test',
'domain': 'example.com',
'localDiskFlag': True,
'operatingSystemReferenceCode': "STRING",
'hourlyBillingFlag': True,
}
self.assertEqual(data, assert_data)
def test_generate_monthly(self):
data = self.cci._generate_create_dict(
cpus=1,
memory=1,
hostname='test',
domain='example.com',
os_code="STRING",
hourly=False,
)
assert_data = {
'hourlyBillingFlag': False,
'startCpus': 1,
'maxMemory': 1,
'hostname': 'test',
'domain': 'example.com',
'localDiskFlag': True,
'operatingSystemReferenceCode': "STRING",
}
self.assertEqual(data, assert_data)
def test_generate_image_id(self):
data = self.cci._generate_create_dict(
cpus=1,
memory=1,
hostname='test',
domain='example.com',
image_id="45",
)
assert_data = {
'startCpus': 1,
'maxMemory': 1,
'hostname': 'test',
'domain': 'example.com',
'localDiskFlag': True,
'blockDeviceTemplateGroup': {"globalIdentifier": "45"},
'hourlyBillingFlag': True,
}
self.assertEqual(data, assert_data)
def test_generate_private(self):
data = self.cci._generate_create_dict(
cpus=1,
memory=1,
hostname='test',
domain='example.com',
os_code="STRING",
private=True,
)
assert_data = {
'startCpus': 1,
'maxMemory': 1,
'hostname': 'test',
'domain': 'example.com',
'localDiskFlag': True,
'operatingSystemReferenceCode': "STRING",
'hourlyBillingFlag': True,
'dedicatedAccountHostOnlyFlag': True,
}
self.assertEqual(data, assert_data)
def test_generate_datacenter(self):
data = self.cci._generate_create_dict(
cpus=1,
memory=1,
hostname='test',
domain='example.com',
os_code="STRING",
datacenter="sng01",
)
assert_data = {
'startCpus': 1,
'maxMemory': 1,
'hostname': 'test',
'domain': 'example.com',
'localDiskFlag': True,
'operatingSystemReferenceCode': "STRING",
'hourlyBillingFlag': True,
'datacenter': {"name": 'sng01'},
}
self.assertEqual(data, assert_data)
def test_generate_public_vlan(self):
data = self.cci._generate_create_dict(
cpus=1,
memory=1,
hostname='test',
domain='example.com',
os_code="STRING",
public_vlan=1,
)
assert_data = {
'startCpus': 1,
'maxMemory': 1,
'hostname': 'test',
'domain': 'example.com',
'localDiskFlag': True,
'operatingSystemReferenceCode': "STRING",
'hourlyBillingFlag': True,
'primaryNetworkComponent': {"networkVlan": {"id": 1}},
}
self.assertEqual(data, assert_data)
def test_generate_private_vlan(self):
data = self.cci._generate_create_dict(
cpus=1,
memory=1,
hostname='test',
domain='example.com',
os_code="STRING",
private_vlan=1,
)
assert_data = {
'startCpus': 1,
'maxMemory': 1,
'hostname': 'test',
'domain': 'example.com',
'localDiskFlag': True,
'operatingSystemReferenceCode': "STRING",
'hourlyBillingFlag': True,
'primaryBackendNetworkComponent': {"networkVlan": {"id": 1}},
}
self.assertEqual(data, assert_data)
def test_generate_userdata(self):
data = self.cci._generate_create_dict(
cpus=1,
memory=1,
hostname='test',
domain='example.com',
os_code="STRING",
userdata="ICANHAZCCI",
)
assert_data = {
'startCpus': 1,
'maxMemory': 1,
'hostname': 'test',
'domain': 'example.com',
'localDiskFlag': True,
'operatingSystemReferenceCode': "STRING",
'hourlyBillingFlag': True,
'userData': [{'value': "ICANHAZCCI"}],
}
self.assertEqual(data, assert_data)
def test_generate_network(self):
data = self.cci._generate_create_dict(
cpus=1,
memory=1,
hostname='test',
domain='example.com',
os_code="STRING",
nic_speed=9001,
)
assert_data = {
'startCpus': 1,
'maxMemory': 1,
'hostname': 'test',
'domain': 'example.com',
'localDiskFlag': True,
'operatingSystemReferenceCode': "STRING",
'hourlyBillingFlag': True,
'networkComponents': [{'maxSpeed': 9001}],
}
self.assertEqual(data, assert_data)
class CCITests_unittests(unittest.TestCase):
def setUp(self):
self.client = MagicMock()
self.cci = SoftLayer.CCIManager(self.client)
def test_list_instances(self):
mcall = call(mask=ANY, filter={})
service = self.client.__getitem__()
self.cci.list_instances(hourly=True, monthly=True)
service.getVirtualGuests.assert_has_calls(mcall)
self.cci.list_instances(hourly=False, monthly=False)
service.getVirtualGuests.assert_has_calls(mcall)
self.cci.list_instances(hourly=False, monthly=True)
service.getMonthlyVirtualGuests.assert_has_calls(mcall)
self.cci.list_instances(hourly=True, monthly=False)
service.getHourlyVirtualGuests.assert_has_calls(mcall)
def test_list_instances_with_filters(self):
self.cci.list_instances(
hourly=True,
monthly=True,
tags=['tag1', 'tag2'],
cpus=2,
memory=1024,
hostname='hostname',
domain='example.com',
local_disk=True,
datacenter='dal05',
nic_speed=100,
public_ip='1.2.3.4',
private_ip='4.3.2.1',
)
service = self.client.__getitem__()
service.getVirtualGuests.assert_has_calls(call(
filter={
'virtualGuests': {
'datacenter': {
'name': {'operation': '_= dal05'}},
'domain': {'operation': '_= example.com'},
'tagReferences': {
'tag': {'name': {
'operation': 'in',
'options': [{
'name': 'data', 'value': ['tag1', 'tag2']}]}}},
'maxCpu': {'operation': 2},
'localDiskFlag': {'operation': True},
'maxMemory': {'operation': 1024},
'hostname': {'operation': '_= hostname'},
'networkComponents': {'maxSpeed': {'operation': 100}},
'primaryIpAddress': {'operation': '_= 1.2.3.4'},
'primaryBackendIpAddress': {'operation': '_= 4.3.2.1'}
}},
mask=ANY,
))
def test_resolve_ids_ip(self):
self.client.__getitem__().getVirtualGuests.return_value = \
[{'id': '1234'}]
_id = self.cci._get_ids_from_ip('1.2.3.4')
self.assertEqual(_id, ['1234'])
self.client.__getitem__().getVirtualGuests.side_effect = \
[[], [{'id': '4321'}]]
_id = self.cci._get_ids_from_ip('4.3.2.1')
self.assertEqual(_id, ['4321'])
_id = self.cci._get_ids_from_ip('nope')
self.assertEqual(_id, [])
def test_resolve_ids_hostname(self):
self.client.__getitem__().getVirtualGuests.return_value = \
[{'id': '1234'}]
_id = self.cci._get_ids_from_hostname('hostname')
self.assertEqual(_id, ['1234'])
def test_get_instance(self):
self.client.__getitem__().getObject.return_value = {
'hourlyVirtualGuests': "this is unique"}
self.cci.get_instance(1)
self.client.__getitem__().getObject.assert_called_once_with(
id=1, mask=ANY)
def test_get_create_options(self):
self.cci.get_create_options()
f = self.client.__getitem__().getCreateObjectOptions
f.assert_called_once_with()
def test_cancel_instance(self):
self.cci.cancel_instance(id=1)
self.client.__getitem__().deleteObject.assert_called_once_with(id=1)
def test_reload_instance(self):
self.cci.reload_instance(id=1)
f = self.client.__getitem__().reloadCurrentOperatingSystemConfiguration
f.assert_called_once_with(id=1)
@patch('SoftLayer.CCI.CCIManager._generate_create_dict')
def test_create_verify(self, create_dict):
create_dict.return_value = {'test': 1, 'verify': 1}
self.cci.verify_create_instance(test=1, verify=1)
create_dict.assert_called_once_with(test=1, verify=1)
f = self.client.__getitem__().generateOrderTemplate
f.assert_called_once_with({'test': 1, 'verify': 1})
@patch('SoftLayer.CCI.CCIManager._generate_create_dict')
def test_create_instance(self, create_dict):
create_dict.return_value = {'test': 1, 'verify': 1}
self.cci.create_instance(test=1, verify=1)
create_dict.assert_called_once_with(test=1, verify=1)
self.client.__getitem__().createObject.assert_called_once_with(
{'test': 1, 'verify': 1})
def test_generate_os_and_image(self):
self.assertRaises(
SoftLayer.CCI.CCICreateMutuallyExclusive,
self.cci._generate_create_dict,
cpus=1,
memory=1,
hostname='test',
domain='example.com',
os_code=1,
image_id=1,
)
def test_generate_missing(self):
self.assertRaises(
SoftLayer.CCI.CCICreateMissingRequired,
self.cci._generate_create_dict,
)
self.assertRaises(
SoftLayer.CCI.CCICreateMissingRequired,
self.cci._generate_create_dict,
cpus=1
)
def test_generate_basic(self):
data = self.cci._generate_create_dict(
cpus=1,
memory=1,
hostname='test',
domain='example.com',
os_code="STRING",
)
assert_data = {
'startCpus': 1,
'maxMemory': 1,
'hostname': 'test',
'domain': 'example.com',
'localDiskFlag': True,
'operatingSystemReferenceCode': "STRING",
'hourlyBillingFlag': True,
}
self.assertEqual(data, assert_data)
def test_generate_monthly(self):
data = self.cci._generate_create_dict(
cpus=1,
memory=1,
hostname='test',
domain='example.com',
os_code="STRING",
hourly=False,
)
assert_data = {
'hourlyBillingFlag': False,
'startCpus': 1,
'maxMemory': 1,
'hostname': 'test',
'domain': 'example.com',
'localDiskFlag': True,
'operatingSystemReferenceCode': "STRING",
}
self.assertEqual(data, assert_data)
def test_generate_image_id(self):
data = self.cci._generate_create_dict(
cpus=1,
memory=1,
hostname='test',
domain='example.com',
image_id="45",
)
assert_data = {
'startCpus': 1,
'maxMemory': 1,
'hostname': 'test',
'domain': 'example.com',
'localDiskFlag': True,
'blockDeviceTemplateGroup': {"globalIdentifier": "45"},
'hourlyBillingFlag': True,
}
self.assertEqual(data, assert_data)
def test_generate_private(self):
data = self.cci._generate_create_dict(
cpus=1,
memory=1,
hostname='test',
domain='example.com',
os_code="STRING",
private=True,
)
assert_data = {
'startCpus': 1,
'maxMemory': 1,
'hostname': 'test',
'domain': 'example.com',
'localDiskFlag': True,
'operatingSystemReferenceCode': "STRING",
'hourlyBillingFlag': True,
'dedicatedAccountHostOnlyFlag': True,
}
self.assertEqual(data, assert_data)
def test_generate_datacenter(self):
data = self.cci._generate_create_dict(
cpus=1,
memory=1,
hostname='test',
domain='example.com',
os_code="STRING",
datacenter="sng01",
)
assert_data = {
'startCpus': 1,
'maxMemory': 1,
'hostname': 'test',
'domain': 'example.com',
'localDiskFlag': True,
'operatingSystemReferenceCode': "STRING",
'hourlyBillingFlag': True,
'datacenter': {"name": 'sng01'},
}
self.assertEqual(data, assert_data)
def test_generate_public_vlan(self):
data = self.cci._generate_create_dict(
cpus=1,
memory=1,
hostname='test',
domain='example.com',
os_code="STRING",
public_vlan=1,
)
assert_data = {
'startCpus': 1,
'maxMemory': 1,
'hostname': 'test',
'domain': 'example.com',
'localDiskFlag': True,
'operatingSystemReferenceCode': "STRING",
'hourlyBillingFlag': True,
'primaryNetworkComponent': {"networkVlan": {"id": 1}},
}
self.assertEqual(data, assert_data)
def test_generate_private_vlan(self):
data = self.cci._generate_create_dict(
cpus=1,
memory=1,
hostname='test',
domain='example.com',
os_code="STRING",
private_vlan=1,
)
assert_data = {
'startCpus': 1,
'maxMemory': 1,
'hostname': 'test',
'domain': 'example.com',
'localDiskFlag': True,
'operatingSystemReferenceCode': "STRING",
'hourlyBillingFlag': True,
'primaryBackendNetworkComponent': {"networkVlan": {"id": 1}},
}
self.assertEqual(data, assert_data)
def test_generate_userdata(self):
data = self.cci._generate_create_dict(
cpus=1,
memory=1,
hostname='test',
domain='example.com',
os_code="STRING",
userdata="ICANHAZCCI",
)
assert_data = {
'startCpus': 1,
'maxMemory': 1,
'hostname': 'test',
'domain': 'example.com',
'localDiskFlag': True,
'operatingSystemReferenceCode': "STRING",
'hourlyBillingFlag': True,
'userData': [{'value': "ICANHAZCCI"}],
}
self.assertEqual(data, assert_data)
def test_generate_network(self):
data = self.cci._generate_create_dict(
cpus=1,
memory=1,
hostname='test',
domain='example.com',
os_code="STRING",
nic_speed=9001,
)
assert_data = {
'startCpus': 1,
'maxMemory': 1,
'hostname': 'test',
'domain': 'example.com',
'localDiskFlag': True,
'operatingSystemReferenceCode': "STRING",
'hourlyBillingFlag': True,
'networkComponents': [{'maxSpeed': 9001}],
}
self.assertEqual(data, assert_data)
def test_generate_no_disks(self):
data = self.cci._generate_create_dict(
cpus=1,
memory=1,
hostname='test',
domain='example.com',
os_code="STRING"
)
self.assertEqual(data.get('blockDevices'), None)
def test_generate_single_disk(self):
data = self.cci._generate_create_dict(
cpus=1,
memory=1,
hostname='test',
domain='example.com',
os_code="STRING",
disks=[50]
)
assert_data = {
'blockDevices': [
{"device": "0", "diskImage":{"capacity": 50}}]
}
self.assertTrue(data.get('blockDevices'))
self.assertEqual(data['blockDevices'], assert_data['blockDevices'])
def test_generate_multi_disk(self):
data = self.cci._generate_create_dict(
cpus=1,
memory=1,
hostname='test',
domain='example.com',
os_code="STRING",
disks=[50, 70, 100]
)
assert_data = {
'blockDevices': [
{"device": "0", "diskImage":{"capacity": 50}},
{"device": "2", "diskImage":{"capacity": 70}},
{"device": "3", "diskImage":{"capacity": 100}}]
}
self.assertTrue(data.get('blockDevices'))
self.assertEqual(data['blockDevices'], assert_data['blockDevices'])
@patch('SoftLayer.CCI.sleep')
def test_wait(self, _sleep):
guestObject = self.client.__getitem__().getObject
# test 4 iterations with positive match
guestObject.side_effect = [
{'activeTransaction': {'id': 1}},
{'activeTransaction': {'id': 1}},
{'activeTransaction': {'id': 1}},
{'provisionDate': 'aaa'},
{'provisionDate': 'aaa'}
]
value = self.cci.wait_for_transaction(1, 4)
self.assertTrue(value)
_sleep.assert_has_calls([call(1), call(1), call(1)])
guestObject.assert_has_calls([
call(id=1, mask=ANY), call(id=1, mask=ANY),
call(id=1, mask=ANY), call(id=1, mask=ANY),
])
# test 2 iterations, with no matches
_sleep.reset_mock()
guestObject.reset_mock()
guestObject.side_effect = [
{'activeTransaction': {'id': 1}},
{'activeTransaction': {'id': 1}},
{'activeTransaction': {'id': 1}},
{'provisionDate': 'aaa'}
]
value = self.cci.wait_for_transaction(1, 2)
self.assertFalse(value)
_sleep.assert_has_calls([call(1), call(1)])
guestObject.assert_has_calls([
call(id=1, mask=ANY), call(id=1, mask=ANY),
call(id=1, mask=ANY)
])
# 10 iterations at 10 second sleeps with no
# matching values.
_sleep.reset_mock()
guestObject.reset_mock()
guestObject.side_effect = [
{},
{'activeTransaction': {'id': 1}},
{'activeTransaction': {'id': 1}},
{'activeTransaction': {'id': 1}},
{'activeTransaction': {'id': 1}},
{'activeTransaction': {'id': 1}},
{'activeTransaction': {'id': 1}},
{'activeTransaction': {'id': 1}},
{'activeTransaction': {'id': 1}},
{'activeTransaction': {'id': 1}},
{'activeTransaction': {'id': 1}}
]
value = self.cci.wait_for_transaction(1, 10, 10)
self.assertFalse(value)
guestObject.assert_has_calls([
call(id=1, mask=ANY), call(id=1, mask=ANY),
call(id=1, mask=ANY), call(id=1, mask=ANY),
call(id=1, mask=ANY), call(id=1, mask=ANY),
call(id=1, mask=ANY), call(id=1, mask=ANY),
call(id=1, mask=ANY), call(id=1, mask=ANY),
call(id=1, mask=ANY)
])
_sleep.assert_has_calls([
call(10), call(10), call(10), call(10), call(10),
call(10), call(10), call(10), call(10), call(10)])
class HardwareTests(unittest.TestCase):
def setUp(self):
self.client = MagicMock()
self.hardware = HardwareManager(self.client)
def test_list_hardware(self):
mcall = call(mask=ANY, filter={})
service = self.client['Account']
service.getHardware = account_mock.getHardware_Mock()
self.hardware.list_hardware()
service.getHardware.assert_has_calls(mcall)
def test_list_hardware_with_filters(self):
service = self.client['Account']
service.getHardware = account_mock.getHardware_Mock()
self.hardware.list_hardware(
tags=['tag1', 'tag2'],
cpus=2,
memory=1,
hostname='hostname',
domain='example.com',
datacenter='dal05',
nic_speed=100,
public_ip='1.2.3.4',
private_ip='4.3.2.1',
)
service.getHardware.assert_has_calls(call(
filter={
'hardware': {
'datacenter': {'name': {'operation': '_= dal05'}},
'domain': {'operation': '_= example.com'},
'tagReferences': {
'tag': {'name': {
'operation': 'in',
'options': [
{'name': 'data', 'value': ['tag1', 'tag2']}]
}}
},
'memoryCapacity': {'operation': 1},
'processorPhysicalCoreAmount': {'operation': 2},
'hostname': {'operation': '_= hostname'},
'primaryIpAddress': {'operation': '_= 1.2.3.4'},
'networkComponents': {'maxSpeed': {'operation': 100}},
'primaryBackendIpAddress': {'operation': '_= 4.3.2.1'}}
},
mask=ANY,
))
def test_resolve_ids_ip(self):
service = self.client['Account']
service.getHardware = account_mock.getHardware_Mock(1000)
_id = self.hardware._get_ids_from_ip('172.16.1.100')
self.assertEqual(_id, [1000])
_id = self.hardware._get_ids_from_ip('nope')
self.assertEqual(_id, [])
# Now simulate a private IP test
service.getHardware.side_effect = [[], [{'id': 99}]]
_id = self.hardware._get_ids_from_ip('10.0.1.87')
self.assertEqual(_id, [99])
def test_resolve_ids_hostname(self):
service = self.client['Account']
service.getHardware = account_mock.getHardware_Mock(1000)
_id = self.hardware._get_ids_from_hostname('hardware-test1')
self.assertEqual(_id, [1000])
def test_get_hardware(self):
service = self.client['Hardware']
service.getObject = hardware_mock.getObject_Mock(1000)
result = self.hardware.get_hardware(1000)
self.client['Hardware'].getObject.assert_called_once_with(
id=1000, mask=ANY)
expected = hardware_mock.get_raw_hardware_mocks()[1000]
self.assertEqual(expected, result)
def test_reload(self):
post_uri = 'http://test.sftlyr.ws/test.sh'
self.hardware.reload(id=1, post_uri=post_uri, ssh_keys=[1701])
f = self.client.__getitem__().reloadOperatingSystem
f.assert_called_once_with('FORCE',
{'customProvisionScriptUri': post_uri,
'sshKeyIds': [1701]}, id=1)
def test_get_bare_metal_create_options_returns_none_on_error(self):
self.client['Product_Package'].getAllObjects.return_value = [
{'name': 'No Matching Instances', 'id': 0}]
self.assertIsNone(self.hardware.get_bare_metal_create_options())
def test_get_bare_metal_create_options(self):
package_id = 50
self._setup_package_mocks()
self.hardware.get_bare_metal_create_options()
f1 = self.client['Product_Package'].getRegions
f1.assert_called_once_with(id=package_id)
f2 = self.client['Product_Package'].getConfiguration
f2.assert_called_once_with(id=package_id,
mask='mask[itemCategory[group]]')
f3 = self.client['Product_Package'].getCategories
f3.assert_called_once_with(id=package_id)
def test_generate_create_dict_with_all_bare_metal_options(self):
package_id = 50
self._setup_package_mocks()
args = {
'server': 100,
'hostname': 'unicorn',
'domain': 'giggles.woo',
'disks': [500],
'location': 'Wyrmshire',
'os': 200,
'port_speed': 600,
'bare_metal': True,
'hourly': True,
'public_vlan': 10234,
'private_vlan': 20468,
}
expected = {
'hardware': [
{
'domain': 'giggles.woo',
'bareMetalInstanceFlag': True,
'hostname': 'unicorn',
'primaryBackendNetworkComponent':
{'networkVlan': {'id': 20468}},
'primaryNetworkComponent':
{'networkVlan': {'id': 10234}},
}
],
'prices': [
{'id': 100},
{'id': 500},
{'id': 200},
{'id': 600},
{'id': 12000}
],
'hourlyBillingFlag': True,
'location': 'Wyrmshire', 'packageId': 50
}
data = self.hardware._generate_create_dict(**args)
self.assertEqual(expected, data)
def test_generate_create_dict_with_all_dedicated_server_options(self):
package_id = 13
self._setup_package_mocks()
args = {
'server': 100,
'hostname': 'unicorn',
'domain': 'giggles.woo',
'disks': [1000, 1000, 1000, 1000],
'location': 'Wyrmshire',
'os': 200,
'port_speed': 600,
'bare_metal': False,
'package_id': 13,
'ram': 1400,
'disk_controller': 1500,
'ssh_keys': [3000, 3001],
'public_vlan': 10234,
'private_vlan': 20468,
}
expected = {
'hardware': [
{
'domain': 'giggles.woo',
'bareMetalInstanceFlag': False,
'hostname': 'unicorn',
'primaryBackendNetworkComponent':
{'networkVlan': {'id': 20468}},
'primaryNetworkComponent':
{'networkVlan': {'id': 10234}},
}
],
'prices': [
{'id': 100},
{'id': 1000},
{'id': 1000},
{'id': 1000},
{'id': 1000},
{'id': 200},
{'id': 600},
{'id': 1400},
{'id': 1500}],
'sshKeys': [{'sshKeyIds': [3000, 3001]}],
'location': 'Wyrmshire', 'packageId': 13
}
data = self.hardware._generate_create_dict(**args)
self.assertEqual(expected, data)
@patch('SoftLayer.managers.hardware.HardwareManager._generate_create_dict')
def test_verify_order(self, create_dict):
create_dict.return_value = {'test': 1, 'verify': 1}
self.hardware.verify_order(test=1, verify=1)
create_dict.assert_called_once_with(test=1, verify=1)
f = self.client['Product_Order'].verifyOrder
f.assert_called_once_with({'test': 1, 'verify': 1})
@patch('SoftLayer.managers.hardware.HardwareManager._generate_create_dict')
def test_place_order(self, create_dict):
create_dict.return_value = {'test': 1, 'verify': 1}
self.hardware.place_order(test=1, verify=1)
create_dict.assert_called_once_with(test=1, verify=1)
f = self.client['Product_Order'].placeOrder
f.assert_called_once_with({'test': 1, 'verify': 1})
def test_cancel_metal_immediately(self):
b_id = 6327
self.client['Hardware'].getObject = hardware_mock.getObject_Mock(1000)
self.hardware.cancel_metal(b_id, True)
f = self.client['Billing_Item'].cancelService
f.assert_called_once_with(id=b_id)
def test_cancel_metal_on_anniversary(self):
b_id = 6327
self.client['Hardware'].getObject = hardware_mock.getObject_Mock(1000)
self.hardware.cancel_metal(b_id, False)
f = self.client['Billing_Item'].cancelServiceOnAnniversaryDate
f.assert_called_once_with(id=b_id)
def test_cancel_hardware_without_reason(self):
hw_id = 987
self.hardware.cancel_hardware(hw_id)
reasons = self.hardware.get_cancellation_reasons()
f = self.client['Ticket'].createCancelServerTicket
f.assert_called_once_with(hw_id, reasons['unneeded'], '', True,
'HARDWARE')
def test_cancel_hardware_with_reason_and_comment(self):
hw_id = 987
reason = 'sales'
comment = 'Test Comment'
self.hardware.cancel_hardware(hw_id, reason, comment)
reasons = self.hardware.get_cancellation_reasons()
f = self.client['Ticket'].createCancelServerTicket
f.assert_called_once_with(hw_id, reasons[reason], comment, True,
'HARDWARE')
def test_change_port_speed_public(self):
hw_id = 1
speed = 100
self.hardware.change_port_speed(hw_id, True, speed)
service = self.client['Hardware_Server']
f = service.setPublicNetworkInterfaceSpeed
f.assert_called_once_with(speed, id=hw_id)
def test_change_port_speed_private(self):
hw_id = 2
speed = 10
self.hardware.change_port_speed(hw_id, False, speed)
service = self.client['Hardware_Server']
f = service.setPrivateNetworkInterfaceSpeed
f.assert_called_once_with(speed, id=hw_id)
def test_get_available_dedicated_server_packages(self):
self.hardware.get_available_dedicated_server_packages()
service = self.client['Product_Package']
f = service.getObject
f.assert_has_calls([call(id=13, mask='mask[id, name, description]')])
def test_get_dedicated_server_options(self):
package_id = 13
self._setup_package_mocks()
self.hardware.get_dedicated_server_create_options(package_id)
f1 = self.client['Product_Package'].getRegions
f1.assert_called_once_with(id=package_id)
f2 = self.client['Product_Package'].getConfiguration
f2.assert_called_once_with(id=package_id,
mask='mask[itemCategory[group]]')
f3 = self.client['Product_Package'].getCategories
f3.assert_called_once_with(id=package_id)
def test_get_default_value_returns_none_for_unknown_category(self):
package_options = {'categories': ['Cat1', 'Cat2']}
self.assertEqual(None, get_default_value(package_options,
'Unknown Category'))
def test_get_default_value(self):
price_id = 9876
package_options = {'categories':
{'Cat1': {
'items': [{
'prices': [{
'setupFee': 0,
'recurringFee': 0,
}],
'price_id': price_id,
}]
}}}
self.assertEqual(price_id, get_default_value(package_options, 'Cat1'))
def test_edit(self):
# Test editing user data
service = self.client['Hardware_Server']
self.hardware.edit(100, userdata='my data')
service.setUserMetadata.assert_called_once_with(['my data'], id=100)
# Now test a blank edit
self.assertTrue(self.hardware.edit, 100)
# Finally, test a full edit
args = {
'hostname': 'new-host',
'domain': 'new.sftlyr.ws',
'notes': 'random notes',
}
self.hardware.edit(100, **args)
service.editObject.assert_called_once_with(args, id=100)
def _setup_package_mocks(self):
package = self.client['Product_Package']
package.getAllObjects = product_package_mock.getAllObjects_Mock()
package.getConfiguration = product_package_mock.getConfiguration_Mock()
package.getCategories = product_package_mock.getCategories_Mock()
package.getRegions = product_package_mock.getRegions_Mock()
def _create_connection(self, databases):
databases = OrderedDict(databases)
connection = MagicMock(spec=Connection)
connection.database_names = Mock(return_value=databases.keys())
connection.__getitem__ = lambda s, x: databases[x]
return connection
def _create_database(self, collections):
collections = OrderedDict(collections)
db = MagicMock(spec=Database)
db.collection_names = Mock(return_value=collections.keys())
db.__getitem__ = lambda s, x: MockCollection(collections[x])
return db
class SSLTests_unittests(unittest.TestCase):
def setUp(self):
self.client = MagicMock()
self.ssl = SSLManager(self.client)
self.test_id = 10
def test_list_certs(self):
self.ssl.list_certs('valid')
self.client.__getitem__() \
.getValidSecurityCertificates.assert_called_once_with(mask=ANY)
self.ssl.list_certs('expired')
self.client.__getitem__() \
.getExpiredSecurityCertificates.assert_called_once_with(mask=ANY)
self.ssl.list_certs('all')
self.client.__getitem__() \
.getSecurityCertificates.assert_called_once_with(mask=ANY)
def test_add_certificate(self):
test_cert = {
'certificate': 'cert',
'privateKey': 'key',
}
self.ssl.add_certificate(test_cert)
self.client.__getitem__().createObject.assert_called_once_with(
test_cert)
def test_remove_certificate(self):
self.ssl.remove_certificate(self.test_id)
self.client.__getitem__() \
.deleteObject.assert_called_once_with(id=self.test_id)
def test_edit_certificate(self):
test_cert = {
'id': self.test_id,
'certificate': 'cert',
'privateKey': 'key'
}
self.ssl.edit_certificate(test_cert)
self.client.__getitem__().editObject.assert_called_once_with(
{
'id': self.test_id,
'certificate': 'cert',
'privateKey': 'key'
},
id=self.test_id)
def test_get_certificate(self):
self.ssl.get_certificate(self.test_id)
self.client.__getitem__().getObject.assert_called_once_with(
id=self.test_id)
class DNSTests(unittest.TestCase):
def setUp(self):
self.client = MagicMock()
self.dns_client = SoftLayer.DNSManager(self.client)
def test_init_exercise(self):
self.assertTrue(hasattr(self.dns_client, "domain"))
self.assertTrue(hasattr(self.dns_client, "record"))
def test_list_zones(self):
zone_list = ["test"]
self.client.__getitem__().getDomains.return_value = zone_list
zones = self.dns_client.list_zones()
self.assertEqual(zones, zone_list)
def test_get_zone(self):
zone_list = [{"name": "test-example.com"}, {"name": "example.com"}]
# match
self.client.__getitem__().getByDomainName.return_value = zone_list
res = self.dns_client.get_zone("example.com")
self.assertEqual(res, zone_list[1])
# no match
from SoftLayer.DNS import DNSZoneNotFound
self.assertRaises(DNSZoneNotFound, self.dns_client.get_zone, "shouldnt-match.com")
def test_create_zone(self):
self.client.__getitem__().createObject.return_value = {"name": "example.com"}
res = self.dns_client.create_zone("example.com")
self.assertEqual(res, {"name": "example.com"})
def test_delete_zone(self):
self.dns_client.delete_zone(1)
self.client.__getitem__().deleteObject.assert_called_once_with(id=1)
def test_edit_zone(self):
self.dns_client.edit_zone("example.com")
self.client.__getitem__().editObject.assert_called_once_with("example.com")
def test_create_record(self):
self.dns_client.create_record(1, "test", "TXT", "testing", ttl=1200)
self.client.__getitem__().createObject.assert_called_once_with(
{"domainId": 1, "ttl": 1200, "host": "test", "type": "TXT", "data": "testing"}
)
def test_delete_record(self):
self.dns_client.delete_record(1)
self.client.__getitem__().deleteObject.assert_called_once_with(id=1)
def test_search_record(self):
self.client.__getitem__().getByDomainName.return_value = [
{"name": "example.com", "resourceRecords": [{"host": "TEST1"}, {"host": "test2"}, {"host": "test3"}]}
]
res = self.dns_client.search_record("example.com", "test1")
self.assertEqual(res, [{"host": "TEST1"}])
def test_edit_record(self):
self.dns_client.edit_record({"id": 1, "name": "test"})
self.client.__getitem__().editObject.assert_called_once_with({"id": 1, "name": "test"}, id=1)
def test_dump_zone(self):
self.client.__getitem__().getZoneFileContents.return_value = "lots of text"
self.dns_client.dump_zone(1)
self.client.__getitem__().getZoneFileContents.assert_called_once_with(id=1)
class DNSTests(unittest.TestCase):
def setUp(self):
self.client = MagicMock()
self.dns_client = SoftLayer.DNSManager(self.client)
def test_init_exercise(self):
self.assertTrue(hasattr(self.dns_client, 'domain'))
self.assertTrue(hasattr(self.dns_client, 'record'))
def test_list_zones(self):
zone_list = ['test']
self.client.__getitem__().getObject.return_value = {
'domains': zone_list}
zones = self.dns_client.list_zones()
self.assertEqual(zones, zone_list)
def test_get_zone(self):
zone_list = [
{'name': 'test-example.com'},
{'name': 'example.com'},
]
# match
self.client.__getitem__().getByDomainName.return_value = \
zone_list
res = self.dns_client.get_zone('example.com')
self.assertEqual(res, zone_list[1])
# no match
from SoftLayer.DNS import DNSZoneNotFound
self.assertRaises(
DNSZoneNotFound,
self.dns_client.get_zone,
'shouldnt-match.com')
def test_create_zone(self):
self.client.__getitem__().createObject.return_value = \
{'name': 'example.com'}
res = self.dns_client.create_zone('example.com')
self.assertEqual(res, {'name': 'example.com'})
def test_delete_zone(self):
self.dns_client.delete_zone(1)
self.client.__getitem__().deleteObject.assert_called_once_with(id=1)
def test_edit_zone(self):
self.dns_client.edit_zone('example.com')
self.client.__getitem__().editObject.assert_called_once_with(
'example.com')
def test_create_record(self):
self.dns_client.create_record(1, 'test', 'TXT', 'testing', ttl=1200)
self.client.__getitem__().createObject.assert_called_once_with(
{
'domainId': 1,
'ttl': 1200,
'host': 'test',
'type': 'TXT',
'data': 'testing'
})
def test_delete_record(self):
self.dns_client.delete_record(1)
self.client.__getitem__().deleteObject.assert_called_once_with(id=1)
def test_search_record(self):
self.client.__getitem__().getByDomainName.return_value = [{
'name': 'example.com',
'resourceRecords': [
{'host': 'TEST1'},
{'host': 'test2'},
{'host': 'test3'},
]
}]
res = self.dns_client.search_record('example.com', 'test1')
self.assertEqual(res, [{'host': 'TEST1'}])
def test_edit_record(self):
self.dns_client.edit_record({'id': 1, 'name': 'test'})
self.client.__getitem__().editObject.assert_called_once_with(
{'id': 1, 'name': 'test'},
id=1
)
def test_dump_zone(self):
self.client.__getitem__().getZoneFileContents.return_value = (
'lots of text')
self.dns_client.dump_zone(1)
self.client.__getitem__().getZoneFileContents.assert_called_once_with(
id=1)
def _create_connection(self, databases):
databases = OrderedDict(databases)
connection = MagicMock(spec=Connection)
connection.database_names = Mock(return_value=databases.keys())
connection.__getitem__ = lambda s, x: databases[x]
return connection
def _create_database(self, collections):
collections = OrderedDict(collections)
db = MagicMock(spec=Database)
db.collection_names = Mock(return_value=collections.keys())
db.__getitem__ = lambda s, x: MockCollection(collections[x])
return db
