def test_method_wrappers(self):
class Flask(flask.Flask, FlaskHTTPMethodsMixin):
pass
app = Flask(__name__)
client = app.test_client()
get_handler = Mock(return_value='', spec={})
get_handler.__name__ = 'get_handler'
app.get('/foo')(get_handler)
post_handler = Mock(return_value='', spec={})
post_handler.__name__ = 'post_handler'
app.post('/foo')(post_handler)
response = client.get('/foo')
self.assertEquals(response.status_code, 200)
get_handler.assert_called_once_with()
response = client.post('/foo')
self.assertEquals(response.status_code, 200)
post_handler.assert_called_once_with()
response = client.delete('/foo')
self.assertEquals(response.status_code, 405)
response = client.open('/foo', method='OPTIONS')
self.assertItemsEqual(
response.allow,
('POST', 'HEAD', 'OPTIONS', 'GET')
)
def model_mocks(self, monkeypatch):
request_mock = Mock()
system_mock = Mock()
role_mock = Mock()
job_mock = Mock()
principal_mock = Mock()
request_mock.__name__ = "Request"
system_mock.__name__ = "System"
role_mock.__name__ = "Role"
job_mock.__name__ = "Job"
principal_mock.__name__ = "Principal"
monkeypatch.setattr(bg_utils.mongo.models, "Request", request_mock)
monkeypatch.setattr(bg_utils.mongo.models, "System", system_mock)
monkeypatch.setattr(bg_utils.mongo.models, "Role", role_mock)
monkeypatch.setattr(bg_utils.mongo.models, "Job", job_mock)
monkeypatch.setattr(bg_utils.mongo.models, "Principal", principal_mock)
return {
"request": request_mock,
"system": system_mock,
"role": role_mock,
"job": job_mock,
"principal": principal_mock,
}
def test_ensure_client(self, mock_client):
# Test flow pulling creds from file
vault.client = None
orig_credentials_file = vault.credentials_file
if os.name == 'nt':
vault.credentials_file = os.path.join(os.environ['TEMP'],
'creds.yaml')
else:
vault.credentials_file = '/tmp/creds.yaml'
with open(vault.credentials_file, 'w') as fh:
fh.write('vault_url: "url"\nvault_access_token: "token"')
func = Mock()
func.__name__ = ''
vault.ensure_client(func)()
self.assertIsNotNone(vault.client)
self.assertEqual(func.called, True)
os.remove(vault.credentials_file)
vault.credentials_file = orig_credentials_file
# Test flow pulling creds from environment variables
vault.client = None
os.environ['VAULT_URL'] = 'url'
os.environ['VAULT_ACCESS_TOKEN'] = 'token'
func = Mock()
func.__name__ = ''
vault.ensure_client(func)()
self.assertIsNotNone(vault.client)
self.assertEqual(func.called, True)
del os.environ['VAULT_URL']
del os.environ['VAULT_ACCESS_TOKEN']
# Test flow without credentials
vault.client = None
self.assertRaises(Exception, vault.ensure_client(func))
vault.client = 'client'
def test_load_tokenizer(self, mock_all_subclasses, mock_load_backend):
tokenizer0 = Mock()
tokenizer0.__name__ = 'SplitTokenizer'
tokenizer0Returns = Mock()
tokenizer0.return_value = tokenizer0Returns
tokenizer1 = Mock()
tokenizer1.__name__ = 'NotSqlAlchemyWrapper'
tokenizer2 = Mock()
tokenizer2.__name__ = 'StillNotSqlAlchemyWrapper'
mock_all_subclasses.return_value = [tokenizer0, tokenizer1, tokenizer2]
self.sh._load_tokenizer()
self.assertEqual(self.sh.tokenizer, tokenizer0Returns)
def test_load_backend(self, mock_all_subclasses, mock_load_tokenizer):
backend0 = Mock()
backend0.__name__ = 'SqlAlchemyWrapper'
backend0Returns = Mock()
backend0.return_value = backend0Returns
backend1 = Mock()
backend1.__name__ = 'NotSqlAlchemyWrapper'
backend2 = Mock()
backend2.__name__ = 'StillNotSqlAlchemyWrapper'
mock_all_subclasses.return_value = [backend0, backend1, backend2]
self.sh._load_backend()
self.assertEqual(self.sh.backend, backend0Returns)
def test_switch_on_bind_decorator_with_default_being_an_object(
switch_component, requests_mock, fake_switch_component):
alternate_return = object()
binder = switch_component.bind('test-switch', default=alternate_return)
fake_binder = fake_switch_component.bind('test-switch',
default=alternate_return)
origin_fn = Mock()
origin_fn.__name__ = 'origin_fn'
decorated = binder(origin_fn)
fake_decorated = fake_binder(origin_fn)
assert decorated(1, 2, 3) != alternate_return
origin_fn.assert_called_with(1, 2, 3)
assert origin_fn.call_count == 1
assert fake_decorated(4, 5, 6) != alternate_return
origin_fn.assert_called_with(4, 5, 6)
assert origin_fn.call_count == 2
requests_mock.add_response(
'{"body": {"switch": {"arch.test": {"overall": '
'{"test-switch": {"value": "0"}}}}}, "message": "update"}')
assert requests_mock.wait_processed()
assert decorated(1, 2, 3) == alternate_return
assert origin_fn.call_count == 2
gevent.sleep(0.3)
assert fake_decorated(4, 5, 6) == alternate_return
assert origin_fn.call_count == 2
def test_load_tokenizer(self, mock_all_subclasses, mock_load_backend):
tokenizer0 = Mock()
tokenizer0.__name__ = 'SplitTokenizer'
tokenizer0Returns = Mock()
tokenizer0.return_value = tokenizer0Returns
tokenizer1 = Mock()
tokenizer1.__name__ = 'NotSqlAlchemyWrapper'
tokenizer2 = Mock()
tokenizer2.__name__ = 'StillNotSqlAlchemyWrapper'
mock_all_subclasses.return_value = [tokenizer0, tokenizer1, tokenizer2]
sh = Spicedham()
sh._load_tokenizer()
self.assertEqual(sh.tokenizer, tokenizer0Returns)
sh = Spicedham()
mock_all_subclasses.return_value = []
self.assertRaises(NoTokenizerFoundError, sh._load_tokenizer)
def test_function_cache(self, mkdirs, cache_file, is_expired, exists,
yaml_load, yaml_dump):
""" Test when the file doesn't exist, is forced or is expired """
empty_test = Mock()
empty_test.__name__ = 'empty_test'
empty_test.return_value = 'from empty_test'
is_expired.return_value = False
exists.return_value = False
cache_file.return_value = 'test.yaml'
yaml_load.return_value = "from cache"
""" File doesn't exist, isn't expired, and isn't forced """
with patch.object(cache, 'open', create=True) as mock_open:
result = cache.function_cache(empty_test, 5, False)
mkdirs.assert_called_once_with(cache.BASE_DIR)
mock_open.assert_called_once_with('test.yaml', 'w')
self.assertEqual(result, "from empty_test")
exists.return_value = True
""" Exists, isn't expired, forced """
result = cache.function_cache(empty_test, 5, True)
self.assertEqual(result, "from empty_test")
""" Exists, but expired """
is_expired.return_value = True
result = cache.function_cache(empty_test, 5, False)
self.assertEqual(result, "from empty_test")
self.assertEqual(yaml_load.call_count, 0)
self.assertEqual(empty_test.call_count, 3)
def test_load_backend(self, mock_all_subclasses, mock_load_tokenizer):
backend0 = Mock()
backend0.__name__ = 'SqlAlchemyWrapper'
backend0Returns = Mock()
backend0.return_value = backend0Returns
backend1 = Mock()
backend1.__name__ = 'NotSqlAlchemyWrapper'
backend2 = Mock()
backend2.__name__ = 'StillNotSqlAlchemyWrapper'
mock_all_subclasses.return_value = [backend0, backend1, backend2]
sh = Spicedham()
sh._load_backend()
self.assertEqual(sh.backend, backend0Returns)
sh = Spicedham()
mock_all_subclasses.return_value = []
self.assertRaises(NoBackendFoundError, sh._load_backend)
def test_wrap_memo(self):
func = Mock(name='func')
func.return_value = 42
func.__name__ = 'my_func'
wrapped = memo(func)
# First call gives a call count of 1
self.assertEqual(wrapped(3), 42)
self.assertEqual(func.call_count, 1)
self.assertEqual(wrapped(3), 42)
self.assertEqual(func.call_count, 1)
self.assertEqual(wrapped(x=7, y=1, z=2), 42)
self.assertEqual(func.call_count, 2)
self.assertEqual(wrapped(y=1, x=7, z=2), 42)
self.assertEqual(func.call_count, 2)
self.assertEqual(wrapped(7, 1, 2), 42) # doesn't matter, is is args or kwargs one call of function
self.assertEqual(func.call_count, 2) # arguments in cache should be the same
self.assertEqual(wrapped(7, 2, 2), 42)
self.assertEqual(func.call_count, 3)
self.assertEqual(wrapped([7]), 42)
self.assertEqual(func.call_count, 4)
self.assertEqual(wrapped([7]), 42) # cause list isn't hashable
self.assertEqual(func.call_count, 5)
def test_function_cache(self, mkdirs, cache_file, is_expired, exists,
yaml_load, yaml_dump):
""" Test when the file doesn't exist, is forced or is expired """
empty_test = Mock()
empty_test.__name__ = 'empty_test'
empty_test.return_value = 'from empty_test'
is_expired.return_value = False
exists.return_value = False
cache_file.return_value = 'test.yaml'
yaml_load.return_value = "from cache"
""" File doesn't exist, isn't expired, and isn't forced """
with patch.object(cache, 'open', create=True) as mock_open:
result = cache.function_cache(empty_test, 5, False)
mkdirs.assert_called_once_with(cache.BASE_DIR)
mock_open.assert_called_once_with('test.yaml', 'w')
self.assertEqual(result, "from empty_test")
exists.return_value = True
""" Exists, isn't expired, forced """
result = cache.function_cache(empty_test, 5, True)
self.assertEqual(result, "from empty_test")
""" Exists, but expired """
is_expired.return_value = True
result = cache.function_cache(empty_test, 5, False)
self.assertEqual(result, "from empty_test")
self.assertEqual(yaml_load.call_count, 0)
self.assertEqual(empty_test.call_count, 3)
def test_require_jwt_decorator(self):
mock = Mock(return_value="success")
mock.__name__ = 'test_mock'
mock_fn = jwt.require_jwt(mock)
bad_header = {
"Authorization": "Bearer this-is-not-a-token"
}
nobearer_header = {
"Authorization": "this-is-not-a-token"
}
token = jwt.create_token_for_user(self.default_user)
with self.app.test_request_context(headers=bad_header):
res = mock_fn()
self.assertEqual(401, res.status_code)
with self.app.test_request_context(headers=nobearer_header):
res = mock_fn()
self.assertEqual(401, res.status_code)
with self.app.test_request_context():
res = mock_fn()
self.assertEqual(401, res.status_code)
good_header = {
"Authorization": "Bearer %s" % token
}
with self.app.test_request_context(headers=good_header):
res = mock_fn()
self.assertEqual("success", res)
def test_apply_interval(self):
t = timer2.Timer()
try:
t.schedule.enter_after = Mock()
myfun = Mock()
myfun.__name__ = "myfun"
t.apply_interval(30, myfun)
self.assertEqual(t.schedule.enter_after.call_count, 1)
args1, _ = t.schedule.enter_after.call_args_list[0]
msec1, tref1, _ = args1
self.assertEqual(msec1, 30)
tref1()
self.assertEqual(t.schedule.enter_after.call_count, 2)
args2, _ = t.schedule.enter_after.call_args_list[1]
msec2, tref2, _ = args2
self.assertEqual(msec2, 30)
tref2.cancelled = True
tref2()
self.assertEqual(t.schedule.enter_after.call_count, 2)
finally:
t.stop()
def test_http_request_wrapper(patched_time_sleep):
socket_error = socket.error()
socket_error.errno = errno.E2BIG
with pytest.raises(socket.error):
blobxfer.http_request_wrapper(Mock(side_effect=socket_error))
socket_error.errno = errno.ETIMEDOUT
with pytest.raises(IOError):
mock = Mock(side_effect=socket_error)
mock.__name__ = 'name'
blobxfer.http_request_wrapper(mock, timeout=0.001)
with pytest.raises(requests.exceptions.HTTPError):
exc = requests.exceptions.HTTPError()
exc.response = MagicMock()
exc.response.status_code = 404
mock = Mock(side_effect=exc)
blobxfer.http_request_wrapper(mock)
try:
blobxfer.http_request_wrapper(
_func_raise_requests_exception_once, val=[], timeout=1)
except:
pytest.fail('unexpected Exception raised')
try:
blobxfer.http_request_wrapper(_func_successful_requests_call)
except:
pytest.fail('unexpected Exception raised')
def test_switch_on_bind_decorator_with_default_being_a_factory(
switch_component, requests_mock, fake_switch_component):
alternate_func = Mock()
fake_alternate_func = Mock()
binder = switch_component.bind('test-switch', default=alternate_func)
fake_binder = fake_switch_component.bind('test-switch',
default=fake_alternate_func)
origin_fn = Mock()
origin_fn.__name__ = 'origin_fn'
decorated = binder(origin_fn)
fake_decorated = fake_binder(origin_fn)
decorated(1, 2, 3)
origin_fn.assert_called_with(1, 2, 3)
assert origin_fn.call_count == 1
assert not alternate_func.called
fake_decorated(4, 5, 6)
origin_fn.assert_called_with(4, 5, 6)
assert origin_fn.call_count == 2
assert not fake_alternate_func.called
requests_mock.add_response(
'{"body": {"switch": {"arch.test": {"overall": '
'{"test-switch": {"value": "0"}}}}}, "message": "update"}')
assert requests_mock.wait_processed()
decorated(1, 2, 3)
assert origin_fn.call_count == 2
assert alternate_func.called
gevent.sleep(0.3)
fake_decorated(4, 5, 6)
assert origin_fn.call_count == 2
assert fake_alternate_func.called
def test_apply_interval(self):
t = timer2.Timer()
try:
t.schedule.enter_after = Mock()
myfun = Mock()
myfun.__name__ = 'myfun'
t.apply_interval(30, myfun)
self.assertEqual(t.schedule.enter_after.call_count, 1)
args1, _ = t.schedule.enter_after.call_args_list[0]
msec1, tref1, _ = args1
self.assertEqual(msec1, 30)
tref1()
self.assertEqual(t.schedule.enter_after.call_count, 2)
args2, _ = t.schedule.enter_after.call_args_list[1]
msec2, tref2, _ = args2
self.assertEqual(msec2, 30)
tref2.cancelled = True
tref2()
self.assertEqual(t.schedule.enter_after.call_count, 2)
finally:
t.stop()
def test_wrap_memo(self):
func = Mock(name='func')
func.return_value = 42
func.__name__ = 'my_func'
wrapped = memo(func)
# First call gives a call count of 1
self.assertEqual(wrapped(3), 42)
self.assertEqual(func.call_count, 1)
self.assertEqual(wrapped(3), 42)
self.assertEqual(func.call_count, 1)
self.assertEqual(wrapped(x=7, y=1, z=2), 42)
self.assertEqual(func.call_count, 2)
self.assertEqual(wrapped(y=1, x=7, z=2), 42)
self.assertEqual(func.call_count, 2)
self.assertEqual(
wrapped(7, 1, 2),
42) # doesn't matter, is is args or kwargs one call of function
self.assertEqual(func.call_count,
2) # arguments in cache should be the same
self.assertEqual(wrapped(7, 2, 2), 42)
self.assertEqual(func.call_count, 3)
self.assertEqual(wrapped([7]), 42)
self.assertEqual(func.call_count, 4)
self.assertEqual(wrapped([7]), 42) # cause list isn't hashable
self.assertEqual(func.call_count, 5)
def test_log_entrypoint_calls_function():
func = Mock()
func.__name__ = "test_function"
decorated_func = log_entrypoint(func)
decorated_func()
assert func.called
def test_failgracefully(self):
message = ('Oh no', 'It all went wrong')
mock_func = Mock(side_effect=IOError(*message))
mock_func.__name__ = "Mock"
self.xbmcgui.getCurrentWindowId = Mock(
return_value=self.constants.WEATHER_WINDOW_ID)
decorated_func = self.utilities.failgracefully(mock_func)
decorated_func(1, 2, 3)
mock_func.assert_called_once_with(1, 2, 3)
self.assertTrue(self.xbmc.log.called)
self.assertTrue(self.xbmcgui.Dialog.return_value.ok.called)
self.xbmcgui.Dialog.return_value.ok.assert_called_once_with(
message[0].title(), message[1])
#Test when exception called with only one arg
self.xbmcgui.Dialog.return_value.ok.reset_mock()
message = ('Oh no', )
mock_func.side_effect = IOError(*message)
decorated_func(1, 2, 3)
self.xbmcgui.Dialog.return_value.ok.assert_called_once_with(
message[0].title(), 'See log file for details')
#Test when exception called with no args
self.xbmcgui.Dialog.return_value.ok.reset_mock()
mock_func.side_effect = IOError()
decorated_func(1, 2, 3)
self.xbmcgui.Dialog.return_value.ok.assert_called_once_with(
'Error', 'See log file for details')
def test_cmd_plugin_unload_successful(self):
# GIVEN
###### MOCK PLUGIN
mock_plugin = Mock(spec=Plugin)
mock_plugin.console = self.console
mock_plugin.isEnabled = Mock(return_value=False)
when(self.console).getPlugin("mock").thenReturn(mock_plugin)
self.console._plugins['mock'] = mock_plugin
###### MOCK COMMAND
mock_func = Mock()
mock_func.__name__ = 'cmd_mockfunc'
self.adminPlugin._commands['mockcommand'] = Command(plugin=mock_plugin, cmd='mockcommand', level=100, func=mock_func)
###### MOCK EVENT
mock_plugin.onSay = Mock()
mock_plugin.registerEvent('EVT_CLIENT_SAY', mock_plugin.onSay)
###### MOCK CRON
mock_plugin.mockCronjob = Mock()
mock_plugin.mockCrontab = b3.cron.PluginCronTab(mock_plugin, mock_plugin.mockCronjob, minute='*', second= '*/60')
self.console.cron.add(mock_plugin.mockCrontab)
self.assertIn(id(mock_plugin.mockCrontab), self.console.cron._tabs)
superadmin = FakeClient(self.console, name="superadmin", guid="superadminguid", groupBits=128)
superadmin.connects("1")
# WHEN
superadmin.clearMessageHistory()
superadmin.says("!plugin unload mock")
# THEN
self.assertNotIn('mockcommand', self.adminPlugin._commands)
self.assertIn(self.console.getEventID('EVT_CLIENT_SAY'), self.console._handlers)
self.assertNotIn(mock_plugin, self.console._handlers[self.console.getEventID('EVT_CLIENT_SAY')])
self.assertNotIn(id(mock_plugin.mockCrontab), self.console.cron._tabs)
self.assertListEqual(['Plugin mock has been unloaded'], superadmin.message_history)
def test_multiple_ignored(self):
cb = Mock()
cb.__name__ = 'something'
old = len(models._on_change_callbacks[Webapp])
Webapp.on_change(cb)
eq_(len(models._on_change_callbacks[Webapp]), old + 1)
Webapp.on_change(cb)
eq_(len(models._on_change_callbacks[Webapp]), old + 1)
def mock_task(self):
raw_task = Mock()
# functools.wraps requires the wrapped thing to have a __name__ attr,
# which Mock()s don't usually have. Furthermore, Celery seems to do
# some fancy behind-the-scenes caching on tasks' __name__, such that
# tests pollute each other if the names aren't unique.
raw_task.__name__ = str(uuid.uuid4())
return raw_task
def setUp(self):
self.testobject = Mock()
self.testobject.logger = Mock()
self.testobject.logger.debug = Mock()
foobar = Mock()
foobar.__name__ = "foobar"
self.testobject.foobar = log_function_call(foobar)
self.testobject.original_foobar = foobar
def test_run_command_with_check_output_function(
self, mock_subprocess):
check_output = Mock()
check_output.__name__ = 'check_output'
mock_subprocess.check_output = check_output
run_command(self.command)
check_output.assert_called_once_with(
self.command, stderr=mock_subprocess.STDOUT, shell=True)
def test_register_with_validators(self):
mock_transform = Mock(return_value=None)
mock_transform.__name__ = 'mock_transform'
mock_validator1 = Mock(return_value=None)
mock_validator1.__name__ = 'mock_validator1'
mock_validator2 = Mock(return_value=None)
mock_validator2.__name__ = 'mock_validator2'
validators = [mock_validator1, mock_validator2]
registry.register("XX", mock_transform, validators)
transform = registry.get("XX", "mock_transform")
self.assertEqual(list(transform.validators.values()), validators)
transform()
mock_transform.assert_called_once_with()
def test_register_raw(self):
mock_transform = Mock(return_value=None)
mock_transform.__name__ = 'mock_transform'
registry.register("XX", mock_transform, raw=True)
transform = registry.get("XX", "mock_transform", raw=True)
transform()
mock_transform.assert_called_once_with()
def setUp(self):
self.testobject = Mock()
self.testobject.logger = Mock()
self.testobject.logger.debug = Mock()
foobar = Mock()
foobar.__name__ = "foobar"
self.testobject.foobar = log_function_call(foobar)
self.testobject.original_foobar = foobar
def test_register_raw(self):
mock_transform = Mock(return_value=None)
mock_transform.__name__ = 'mock_transform'
registry.register("XX", mock_transform, raw=True)
transform = registry.get("XX", "mock_transform", raw=True)
transform()
mock_transform.assert_called_once_with()
def test_multiple_ignored(self):
cb = Mock()
cb.__name__ = 'something'
old = len(amo_models._on_change_callbacks[Addon])
Addon.on_change(cb)
assert len(amo_models._on_change_callbacks[Addon]) == old + 1
Addon.on_change(cb)
assert len(amo_models._on_change_callbacks[Addon]) == old + 1
def test_multiple_ignored(self):
cb = Mock()
cb.__name__ = 'something'
old = len(amo_models._on_change_callbacks[Addon])
Addon.on_change(cb)
assert len(amo_models._on_change_callbacks[Addon]) == old + 1
Addon.on_change(cb)
assert len(amo_models._on_change_callbacks[Addon]) == old + 1
def test_multiple_ignored(self):
cb = Mock()
cb.__name__ = 'something'
old = len(amo.models._on_change_callbacks[Addon])
Addon.on_change(cb)
eq_(len(amo.models._on_change_callbacks[Addon]), old + 1)
Addon.on_change(cb)
eq_(len(amo.models._on_change_callbacks[Addon]), old + 1)
def __init__(self, *args, **kwargs):
super(TestRequireArgs, self).__init__(*args, **kwargs)
self.func_ret = 'Method wrapped and executed successfully'
mock = Mock(return_value=self.func_ret)
mock.__name__ = 'require_args_mock'
wrapper_func = require_params(['foo', 'bar'], 'Args not provided')
self.func = wrapper_func(mock)
def test_register_with_validators(self):
mock_transform = Mock(return_value=None)
mock_transform.__name__ = 'mock_transform'
mock_validator1 = Mock(return_value=None)
mock_validator1.__name__ = 'mock_validator1'
mock_validator2 = Mock(return_value=None)
mock_validator2.__name__ = 'mock_validator2'
validators = [mock_validator1, mock_validator2]
registry.register("XX", mock_transform, validators)
transform = registry.get("XX", "mock_transform")
self.assertEqual(transform.validators, validators)
transform()
mock_transform.assert_called_once_with()
def test_multiple_ignored(self):
cb = Mock()
cb.__name__ = 'something'
old = len(amo.models._on_change_callbacks[Addon])
Addon.on_change(cb)
eq_(len(amo.models._on_change_callbacks[Addon]), old + 1)
Addon.on_change(cb)
eq_(len(amo.models._on_change_callbacks[Addon]), old + 1)
def test_multiple_ignored(self):
cb = Mock()
cb.__name__ = 'something'
old = len(mkt.site.models._on_change_callbacks[Webapp])
Webapp.on_change(cb)
eq_(len(mkt.site.models._on_change_callbacks[Webapp]), old + 1)
Webapp.on_change(cb)
eq_(len(mkt.site.models._on_change_callbacks[Webapp]), old + 1)
def test_handle_HTTP_403_Error(self):
error = cb.praw.requests.HTTPError('403 Forbidden')
mock = Mock(side_effect=error)
mock.__name__ = str('mock')
wrapped = cb.handle_praw_exceptions(max_attempts=2)(mock)
with patch('__main__.cb.time.sleep') as mock_sleep:
wrapped()
assert not mock_sleep.called, ("Should not attempt retry "
"after 403 error")
def test_handle_HTTP_403_Error(self):
error = cb.praw.requests.HTTPError('403 Forbidden')
mock = Mock(side_effect=error)
mock.__name__ = str('mock')
wrapped = cb.handle_praw_exceptions(max_attempts=2)(mock)
with patch('{}.cb.time.sleep'.format(__name__)) as mock_sleep:
wrapped()
# Should not attempt retry after 403 error
self.assertFalse(mock_sleep.called)
def test_panelbusy(self):
mock_func = Mock()
mock_func.__name__ = "Mock"
rightbusy = self.utilities.panelbusy("RightPanel")
decorated_func = rightbusy(mock_func)
decorated_func(1,2,3)
self.xbmcgui.Window.return_value.setProperty.assert_called_once_with('RightPanel.IsBusy', 'true')
self.xbmcgui.Window.return_value.clearProperty.assert_called_once_with('RightPanel.IsBusy')
mock_func.assert_called_with(1,2,3)
def test_handle_HTTP_403_Error(self):
error = cb.praw.requests.HTTPError('403 Forbidden')
mock = Mock(side_effect=error)
mock.__name__ = str('mock')
wrapped = cb.handle_api_exceptions(max_attempts=2)(mock)
with patch('{}.cb.time.sleep'.format(__name__)) as mock_sleep:
wrapped()
# Should not attempt retry after 403 error
self.assertFalse(mock_sleep.called)
def test_run_command_check_output_return_tuple(
self, mock_subprocess):
check_output = Mock()
check_output.__name__ = 'check_output'
check_output.return_value = 'command output'
mock_subprocess.check_output = check_output
result = run_command(self.command)
self.assertEqual(result[0], 0)
self.assertEqual(result[1], check_output.return_value)
def test_ensure_clients(self, mock_create_from_env, mock_dns_manager, mock_network_manager):
# Test flow pulling creds from file
sl.client = None
sl.dns_manager = None
sl.network_manager = None
orig_credentials_file = sl.credentials_file
if os.name == 'nt':
sl.credentials_file = os.path.join(os.environ['TEMP'], 'creds.yaml')
else:
sl.credentials_file = '/tmp/creds.yaml'
with open(sl.credentials_file, 'w') as fh:
fh.write('sl_username: "******"\nsl_api_key: "key"')
func = Mock()
func.__name__ = ''
sl.ensure_clients(func)()
self.assertIsNotNone(sl.client)
self.assertIsNotNone(sl.dns_manager)
self.assertIsNotNone(sl.network_manager)
self.assertEqual(func.called, True)
os.remove(sl.credentials_file)
sl.credentials_file = orig_credentials_file
# Test flow pulling creds from environment variables
sl.client = None
sl.dns_manager = None
sl.network_manager = None
os.environ['SL_USERNAME'] = '******'
os.environ['SL_API_KEY'] = 'key'
func = Mock()
func.__name__ = ''
sl.ensure_clients(func)()
self.assertIsNotNone(sl.client)
self.assertEqual(func.called, True)
del os.environ['SL_USERNAME']
del os.environ['SL_API_KEY']
# Test flow without credentials
sl.client = None
sl.dns_manager = None
sl.network_manager = None
self.assertRaises(Exception, sl.ensure_clients(func))
sl.client = 'client'
sl.dns_manager = 'client'
sl.network_manager = 'client'
def test_handle_generic_HTTP_Error(self):
error = cb.praw.requests.HTTPError('')
mock = Mock(side_effect=error)
mock.__name__ = str('mock')
wrapped = cb.handle_praw_exceptions()(mock)
with patch('{}.cb.time.sleep'.format(__name__)) as mock_sleep:
try:
wrapped()
except cb.praw.requests.HTTPError:
self.fail("HTTPError not properly handled")
def test_xbmcbusy(self):
mock_func = Mock()
mock_func.__name__ = "Mock"
self.xbmcgui.getCurrentWindowId = Mock(return_value=self.constants.WEATHER_WINDOW_ID)
decorated_func = self.utilities.xbmcbusy(mock_func)
decorated_func(1,2,3)
self.assertEqual(2, len(self.xbmc.executebuiltin.call_args_list))
self.assertEqual(self.xbmc.executebuiltin.call_args_list[0], (("ActivateWindow(busydialog)",),))
self.assertEqual(self.xbmc.executebuiltin.call_args_list[1], (("Dialog.Close(busydialog)",),))
mock_func.assert_called_with(1,2,3)
def test_raise_modbus_json_rpc_error(modbus_code, json_rpc_exception,
expected):
func = Mock(side_effect=ModbusError(modbus_code))
func.__name__ = 'function_name'
decorated_func = json_rpc_error(func)
with pytest.raises(json_rpc_exception) as exinfo:
decorated_func()
assert str(exinfo.value) == expected
def test_run_lifted_function_return_intermediate_state_crate():
f = Mock()
f.__name__ = 'f'
lifted = lift(f)
prepered = lifted()
result = prepered('foo')
assert result['answer'] == f.return_value
assert result['state'] == f.return_value
def test_handle_generic_HTTP_Error(self):
error = cb.praw.errors.HTTPException('')
mock = Mock(side_effect=error)
mock.__name__ = str('mock')
wrapped = cb.handle_api_exceptions()(mock)
with patch('{}.cb.time.sleep'.format(__name__)) as mock_sleep:
try:
wrapped()
except cb.praw.errors.HTTPException:
self.fail("HTTPError not properly handled")
def test_validate(self):
foo = Mock(return_value=23)
foo.__name__ = 'foo'
wrapped_foo = validate(Schema(things=Text(),
stuff=Integer(default=5)))(foo)
result = wrapped_foo(things="Hi there")
self.assertEquals(result, 23)
foo.assert_called_once_with({'things': 'Hi there', 'stuff': 5})
def test_specific_scenario_name_multiples(self):
from planterbox.feature import FeatureTestCase
from planterbox import step
test_feature = """Feature: A Test Feature
Scenario: A Skipped Scenario.
When I fail because I shouldn't be here
Scenario: A Test Scenario.
When I test a thing
Scenario: A Test Scenario.
When I test a thing
"""
@step(r'I test a thing')
def test_thing(test):
pass
@step(r"I fail because I shouldn't be here")
def fail_test(test):
test.fail('Ran wrong scenairo')
mock_world = Mock(
spec=['test_thing', 'fail_test'],
return_value=None,
)
mock_world.__name__ = 'mock'
mock_world.test_thing = step(r'I test a thing')(Mock(
planterbox_patterns=[],
))
mock_world.fail_test = fail_test
def mock_addFailure(result, exc):
self.exc_info = exc
mock_result = Mock(addFailure=Mock(side_effect=mock_addFailure))
with patch('planterbox.feature.import_module',
Mock(return_value=mock_world)):
test_case = FeatureTestCase(
feature_path='foobar.feature',
feature_text=test_feature,
scenarios_to_run=['A Test Scenario'],
)
test_case.__module__ = 'mock'
test_case.run(mock_result)
if hasattr(self, 'exc_info'):
formatted = test_case.formatTraceback(self.exc_info)
self.fail(formatted)
self.assertEqual(mock_world.test_thing.call_count, 2)
def test_handle_Socket_Error(self):
error = socket.error('[Errno 104] Connection reset by peer')
error.errno = errno.ECONNRESET
mock = Mock(side_effect=error)
mock.__name__ = str('mock')
wrapped = cb.handle_api_exceptions()(mock)
with patch('{}.cb.time.sleep'.format(__name__)) as mock_sleep:
try:
wrapped()
except cb.praw.socket.SocketError:
self.fail("SocketError not properly handled")
def test_it_finds_objects_starting_with_describe(self):
m = Mock()
self._dir.return_value = ['__name__', '_private', 'myFunc', 'MyClass', 'DescribeFood', 'describe_cake']
m.__name__ = "mock"
m._private = "mock"
m._myFunc = lambda: 0
m.MyClass = object
dfood = m.DescribeFood = Mock()
dcake = m.describe_cake = Mock()
self.assertEqual(self.subject.find_in_module(m), [dfood, dcake])
def test_handle_Socket_Error(self):
error = socket.error('[Errno 104] Connection reset by peer')
error.errno = errno.ECONNRESET
mock = Mock(side_effect=error)
mock.__name__ = str('mock')
wrapped = cb.handle_api_exceptions()(mock)
with patch('{}.cb.time.sleep'.format(__name__)) as mock_sleep:
try:
wrapped()
except cb.praw.socket.SocketError:
self.fail("SocketError not properly handled")
def test_specific_scenario_name_multiples(self):
from planterbox.feature import FeatureTestCase
from planterbox import step
test_feature = """Feature: A Test Feature
Scenario: A Skipped Scenario.
When I fail because I shouldn't be here
Scenario: A Test Scenario.
When I test a thing
Scenario: A Test Scenario.
When I test a thing
"""
@step(r'I test a thing')
def test_thing(test):
pass
@step(r"I fail because I shouldn't be here")
def fail_test(test):
test.fail('Ran wrong scenairo')
mock_world = Mock(
spec=['test_thing', 'fail_test'],
return_value=None,
)
mock_world.__name__ = 'mock'
mock_world.test_thing = step(r'I test a thing')(Mock(
planterbox_patterns=[], ))
mock_world.fail_test = fail_test
test_case = FeatureTestCase(
feature_path='foobar.feature',
feature_text=test_feature,
scenarios_to_run=['A Test Scenario'],
)
test_case.__module__ = 'mock'
def mock_addFailure(result, exc):
self.exc_info = exc
mock_result = Mock(addFailure=Mock(side_effect=mock_addFailure))
with patch('planterbox.feature.import_module',
Mock(return_value=mock_world)):
test_case.run(mock_result)
if hasattr(self, 'exc_info'):
formatted = test_case.formatTraceback(self.exc_info)
self.fail(formatted)
self.assertEqual(mock_world.test_thing.call_count, 2)
def test_malformed_request_body(self, request_data, bad_request):
ex = os_ex.MalformedRequestBody()
request_data.side_effect = _raise(ex)
m_func = Mock()
m_func.__name__ = "m_func"
v.validate(m_func)(m_func)()
self._assert_calls(bad_request,
(1, 'MALFORMED_REQUEST_BODY',
'Malformed message body: %(reason)s'))
def local_store_keeps_separate_operations_for_different_arguments(pickle_dump, marshal_dump):
changed_function = Mock(return_value=1)
note_store = get_note_store()
local_note_store = LocalNoteStore(note_store, changed_function)
data_function = Mock()
data_function.__name__ = 'data_function'
local_note_store.get_if_changed(data_function, 1)
local_note_store.get_if_changed(data_function, 2)
assert_equal(data_function.call_count, 2)
def test_handle_API_Exceptions(self):
error = cb.praw.errors.APIException('', '', {})
mock = Mock(side_effect=error)
mock.__name__ = str('mock')
wrapped = cb.handle_praw_exceptions()(mock)
with patch('{}.cb.time.sleep'.format(__name__)) as mock_sleep:
wrapped()
try:
wrapped()
except cb.praw.requests.HTTPError:
self.fail("APIException not properly handled")
def test_no_commit_with_exception(self):
self.request.user.is_authenticated = lambda: False
func = Mock()
func.__name__ = "Mock"
func.side_effect = Exception("Boom!")
changeset_logger.error = Mock()
with patch("pdc.apps.changeset.models.Changeset") as changeset:
self.assertRaises(Exception, self.cm.process_view, self.request, func, [], {})
self.assertTrue(func.called)
self.assertEqual(changeset.mock_calls, [call(author=None)])
self.assertTrue(changeset_logger.error.called)
