def test_api_base(self):
app = Mock()
app.configure_mock(**{'record.side_effect': AttributeError})
api = flask_restful.Api(app)
self.assertEquals(api.urls, {})
self.assertEquals(api.prefix, '')
self.assertEquals(api.default_mediatype, 'application/json')
def web_request():
"""Mock web request for views testing."""
from pyramid_localize.request import LocalizeRequestMixin
from pyramid_localize.request import database_locales
from pyramid_localize.request import locale_id
from pyramid_localize.request import locales
class TestRequest(LocalizeRequestMixin, Request): # pylint:disable=too-many-ancestors
"""Test request object."""
@reify
def _database_locales(self):
return database_locales(self)
@reify
def locale_id(self):
"""Returns a database locale id."""
return locale_id(self)
def locales(self, *args, **kwargs):
"""Return all availablee locales."""
return locales(self, *args, **kwargs)
request = TestRequest({})
config = Mock()
config.configure_mock(
**{'localize.locales.available': ['en', 'pl', 'de', 'cz']}
)
configurator = testing.setUp()
request.registry = configurator.registry # pylint:disable=attribute-defined-outside-init
request.registry['config'] = config
return request
def test_what_is_deal_valid(self, mock_sub_popen):
process_mock = Mock()
attrs = {'communicate.return_value': ('ouput', 'error')}
process_mock.configure_mock(**attrs)
mock_sub_popen.return_value = process_mock
test.ask(question='What is the deal with <requirements.txt>?');
self.assertTrue(mock_sub_popen.called);
def test_location_from_contact(self):
"""
If location information is input (include address label/name), then
a location should be created along with the contact.
"""
request = Mock()
request.configure_mock(user=self.staff_user, impersonator=None)
data = {
"name": "John Doe",
"partner": self.partner.pk,
"company_id": 1
}
address_info = {
'label': 'Home',
'address_line_one': "123 Fake St",
'address_line_two': "Ste 321",
'city': "Somewhere",
"state": "NM"}
data.update(address_info)
form = ContactForm(data=data)
self.assertTrue(form.is_valid())
form.save(request, self.partner.pk)
self.assertTrue(Location.objects.filter(**address_info).exists())
def test_get_repo_branch(self, mock_sub_popen):
process_mock = Mock()
attrs = {'communicate.return_value': ('ouput', 'error')}
process_mock.configure_mock(**attrs)
mock_sub_popen.return_value = process_mock
test.ask(question='What branch is <test/main_test.py>?')
self.assertTrue(mock_sub_popen.called);
def test_get_repo_url(self, mock_sub_popen):
process_mock = Mock()
attrs = {'communicate.return_value': ('ouput', 'error')}
process_mock.configure_mock(**attrs)
mock_sub_popen.return_value = process_mock
test.ask(question='Where did <Job_Story_Traces.txt> come from?')
self.assertTrue(mock_sub_popen.called);
def test_user_update_view_post(self):
self.client.login(username='******', password='******')
bob = get_user_model().objects.get(username='******')
url = reverse('kanisa_manage_users_update', args=[bob.pk, ])
mock_file = Mock(spec=django.core.files.File)
mock_file.configure_mock(name='foo.bar')
mock_file.read.return_value = "Just some data"
resp = self.client.post(url, {'email': '*****@*****.**',
'first_name': 'Bob',
'last_name': 'Builder',
'image': mock_file},
follow=True)
self.assertEqual(resp.status_code, 200)
self.assertTrue('form' not in resp.context)
self.assertEqual([m.message for m in resp.context['messages']],
['Registered User "Bob" saved.', ])
bob = get_user_model().objects.get(username='******')
# Clean up after our file
bob.image.delete()
self.assertEqual(bob.email, '*****@*****.**')
self.client.logout()
def test_invalid_path(self, mock_sub_popen):
self.assertEqual(1, 1);
process_mock = Mock()
attrs = {'communicate.return_value': ('ouput', 'error')}
process_mock.configure_mock(**attrs)
mock_sub_popen.return_value = process_mock
self.assertRaises(Exception, test.ask, 'What is the deal with <blarg>?');
def testModelHandlerPUTModelCreate(self, createModel,
getMetricDisplayFieldsMock, _engineMock):
cols = []
for key in METRIC_DISPLAY_FIELDS:
m = Mock()
m.configure_mock(name=key)
cols.append(m)
getMetricDisplayFieldsMock.return_value=cols
metric = Mock(**dict((col, getattr(self.metric, col))
for col in METRIC_DISPLAY_FIELDS))
metric.keys.return_value = [col for col in METRIC_DISPLAY_FIELDS]
metric.name = self.metric.name
createModel.return_value = metric
params = {"type": "metric",
"region": "us-east-1",
"namespace": "AWS/EC2",
"datasource": "cloudwatch",
"metric": "CPUUtilization",
"dimensions": {
"InstanceId": "i-0c149c66"
}}
response = self.app.put("/", json.dumps(params), headers=self.headers)
assertions.assertResponseStatusCode(self, response, 201)
assertions. assertResponseHeaders(self, response, "json")
self.assertTrue(createModel.called)
def test_fetch_options(self):
mock = Mock()
mock.configure_mock(**{
"files.return_value.list.return_value.execute.return_value": GDRIVE_LIST_RESPONSE})
with patch("clients.drive.build", return_value=mock):
response = self.client.get(reverse("spreadsheet_list"))
self.assertTrue(response.status_code, 200)
# Only 3 inputs
self.assertTrue(
len([
m.start() for m in re.finditer(
'<input type="radio" name="spreadsheet_id"',
response.content
)
]),
3
)
# Only 3 anchors
self.assertTrue(
len([
m.start() for m in re.finditer(
'<a href="http://example.com/spreadsheet/00[123]" target="_blank">Link</a>',
response.content
)
]),
3
)
self.assertIn("Spreadsheet 001", response.content)
self.assertIn("Spreadsheet 002", response.content)
self.assertIn("Spreadsheet 003", response.content)
def test_common_lib_path_not_in_pythonpath_env_var(self, mock_create_token, mock_subproc_popen):
process_mock = Mock()
attrs = {'communicate.return_value': ('output', 'error')}
process_mock.configure_mock(**attrs)
mock_subproc_popen.return_value = process_mock
mock_create_token = Mock()
mock_create_token.return_value = 'WHOLETTHEDOGSOUT'
mock_dispatcher = Mock()
process_container = ProcessSensorContainer(None, poll_interval=0.1,
dispatcher=mock_dispatcher)
sensor = {
'class_name': 'wolfpack.StupidSensor',
'ref': 'wolfpack.StupidSensor',
'id': '567890',
'trigger_types': ['some_trigga'],
'pack': 'wolfpack',
'file_path': '/opt/stackstorm/packs/wolfpack/sensors/stupid_sensor.py',
'poll_interval': 5
}
process_container._enable_common_pack_libs = False
process_container._sensors = {'pack.StupidSensor': sensor}
process_container._spawn_sensor_process(sensor)
_, call_kwargs = mock_subproc_popen.call_args
actual_env = call_kwargs['env']
self.assertTrue('PYTHONPATH' in actual_env)
pack_common_lib_path = '/opt/stackstorm/packs/wolfpack/lib'
self.assertTrue(pack_common_lib_path not in actual_env['PYTHONPATH'])
class TestFactoryBoyMiddleware(TestCase):
def setUp(self):
self.middleware = FactoryBoyMiddleware()
self.request = Mock()
self.request.session = {}
def test_process_request_creates_object(self):
self.request.configure_mock(
**{
'GET': {
'FACTORY_BOY_MODEL_PATH': 'mysite.tests.factories.UserFactory', # noqa
'FACTORY_BOY_ARGS': ''
}
}
)
response = self.middleware.process_request(self.request)
self.assertEqual(201, response.status_code)
self.assertEqual(
'johndoe',
json.loads(response.content.decode('utf-8')).get('username')
)
self.assertEqual(1, len(User.objects.values()))
self.assertEqual('johndoe', User.objects.values()[0]['username'])
class TestModelsUpdateAccount(AccountTestCase):
@patch.object(sitewit.models.SitewitService, 'put')
def setUp(self, put_mock):
self.put_mock = put_mock
self._mock_response(put_mock, self.response_brief)
self.site = Mock(id=self.site_id)
self.user = Mock(
location=self.country_code, currency=self.currency,
time_zone=self.time_zone)
self.user.configure_mock(name=self.user_name, email=self.user_email)
self.account = Account.update(
self.token, url=self.url, country_code=self.country_code,
currency=self.currency
)
def test_demands_put_is_called(self):
put_data = {
'url': self.url,
'currency': self.currency,
'countryCode': self.country_code,
}
self.assertDemandsIsCalled(self.put_mock, put_data, self.token)
def test_account_object_is_returned(self):
self.assertAccountIsValid(self.account)
def test_layer1(self):
"""Testing method / function layer1."""
# Initializing key variables
expected_dict = {
199: {'cdpCacheDeviceId': 'byte_string_1',
'cdpCachePlatform': 'byte_string_1',
'cdpCacheDevicePort': 'byte_string_1'},
299: {'cdpCacheDeviceId': 'byte_string_2',
'cdpCachePlatform': 'byte_string_2',
'cdpCacheDevicePort': 'byte_string_2'}
}
# Set the stage for SNMPwalk
snmpobj = Mock(spec=Query)
mock_spec = {'swalk.return_value': self.walk_results_string}
snmpobj.configure_mock(**mock_spec)
# Get results
testobj = testimport.init_query(snmpobj)
results = testobj.layer1()
# Basic testing of results
for primary in results.keys():
for secondary in results[primary].keys():
self.assertEqual(
results[primary][secondary],
expected_dict[primary][secondary])
def test_start(self):
# A large set of mocks required to make sure that this test tests start, not
# any other function
# Does not currently cover exception in the event read loop
resource = {
'resource': {
'SlackBotAccessToken': 'token'
}
}
mock_messenger = MagicMock(return_value="dummy messenger")
mock_event_handler = Mock()
attrs = {'handle.return_value': "dummy return"}
mock_event_handler.configure_mock(**attrs)
mock_rtm = MagicMock(return_value=mock_event_handler)
mock_slack_clients = MagicMock(return_value="dummy clients")
slackbot = SlackBot("token", mock_slack_clients)
slackbot.clients = Mock(rtm=Mock(rtm_connect=None, rtm_read=None, server=Mock(username=None, login_data={'team':{'name': None}}, domain=None)))
slackbot.clients.rtm.rtm_connect = MagicMock(return_value=True)
slackbot.clients.rtm.server.username = "******"
slackbot.clients.rtm.server.login_data['team']['name'] = "dummy team name"
slackbot.clients.rtm.server.domain = "dummy domain"
slackbot.clients.rtm.rtm_read = MagicMock(return_value=['event1', 'event2', 'event3'])
# Ensure that start completes without error
self.assertEqual(slackbot.start(resource, mock_messenger, mock_rtm), None)
def _generate_worksheets_mocks(self, tabs_names):
sub_mocks = []
for tab in tabs_names:
mock = Mock()
mock.configure_mock(**{"title.text": tab})
sub_mocks.append(mock)
return Mock(entry=sub_mocks)
def test_file_not_in_repo(self, mock_sub_popen):
process_mock = Mock()
attrs = {'communicate.return_value': ('ouput', 'error')}
process_mock.configure_mock(**attrs)
mock_sub_popen.return_value = process_mock
test.ask(question='Is <blarg> in the repo?')
self.assertFalse(mock_sub_popen.called);
def test_dispatch_triggers_on_spawn_exit(self):
mock_dispatcher = Mock()
process_container = ProcessSensorContainer(None, poll_interval=0.1,
dispatcher=mock_dispatcher)
sensor = {
'class_name': 'pack.StupidSensor'
}
process = Mock()
process_attrs = {'pid': 1234}
process.configure_mock(**process_attrs)
cmd = 'sensor_wrapper.py --class-name pack.StupidSensor'
process_container._dispatch_trigger_for_sensor_spawn(sensor, process, cmd)
mock_dispatcher.dispatch.assert_called_with(
'core.st2.sensor.process_spawn',
payload={
'timestamp': 1439441533,
'cmd': 'sensor_wrapper.py --class-name pack.StupidSensor',
'pid': 1234,
'id': 'pack.StupidSensor'})
process_container._dispatch_trigger_for_sensor_exit(sensor, 1)
mock_dispatcher.dispatch.assert_called_with(
'core.st2.sensor.process_exit',
payload={
'id': 'pack.StupidSensor',
'timestamp': 1439441533,
'exit_code': 1
})
def test_file_in_repo(self, mock_sub_popen):
process_mock = Mock()
attrs = {'communicate.return_value': ('ouput', 'error')}
process_mock.configure_mock(**attrs)
mock_sub_popen.return_value = process_mock
result = test.ask(question='Is <requirements.txt> in the repo?')
self.assertTrue(mock_sub_popen.called);
def test_in_repo_changed(self, mock_sub_popen):
process_mock = Mock()
attrs = {'communicate.return_value': ('ouput', 'error')}
process_mock.configure_mock(**attrs)
mock_sub_popen.return_value = process_mock
test.ask(question='What is the status of <requirements.txt>?')
self.assertTrue(mock_sub_popen.called);
def test_in_repo_root(self, mock_sub_popen):
process_mock = Mock()
attrs = {'communicate.return_value': ('ouput', 'error')}
process_mock.configure_mock(**attrs)
mock_sub_popen.return_value = process_mock
get_repo_root("requirements.txt")
self.assertTrue(mock_sub_popen.called);
def createMockSpec(self, additional_spec_items={}):
default_server_disk_spec = aws_disk.AwsDiskSpec(
_COMPONENT,
disk_size=5,
disk_type=aws_disk.IO1,
iops=1000)
default_server_vm_spec = virtual_machine.BaseVmSpec(
'NAME', **{'machine_type': 'db.t1.micro',
'zone': 'us-west-2b'})
spec_dict = {
'engine': MYSQL,
'engine_version': '5.7.11',
'run_uri': '123',
'database_name': 'fakedbname',
'database_password': '******',
'database_username': '******',
'high_availability': False,
'vm_spec': default_server_vm_spec,
'disk_spec': default_server_disk_spec,
}
spec_dict.update(additional_spec_items)
mock_db_spec = Mock(
spec=benchmark_config_spec._ManagedRelationalDbSpec)
mock_db_spec.configure_mock(**spec_dict)
return mock_db_spec
def mock_cert_dir(self):
mocked_cd = Mock()
product_cert = Mock()
product = Mock()
product.configure_mock(id=69, name='Red Hat Enterprise Linux Server')
product_cert.configure_mock(products=[product])
mocked_cd.findByProduct.return_value = product_cert
self.mock(checkin, 'CertificateDirectory', mocked_cd)
def test_file_info(self, mock_subproc_popen):
obj = Interface()
process_mock = Mock()
attrs = {'communicate.return_value': ('__file__', '')}
process_mock.configure_mock(**attrs)
mock_subproc_popen.return_value = process_mock
result = obj.ask('What is the deal with <{}>?'.format(__file__))
self.assertEqual(result, '__file__')
def test_repo_url(self, mock_subproc_popen):
obj = Interface()
process_mock = Mock()
attrs = {'communicate.return_value': ('__file__', '')}
process_mock.configure_mock(**attrs)
mock_subproc_popen.return_value = process_mock
result = obj.ask('Where did <{}> come from?'.format(__file__))
self.assertEqual(result, '__file__')
def test_fileInRepo_No(self, mock_subproc_popen):
obj = Interface()
process_mock = Mock()
attrs = {'communicate.return_value': ('test.txt', '')}
process_mock.configure_mock(**attrs)
mock_subproc_popen.return_value = process_mock
result = obj.ask('Is the <test.txt> in the repo?')
self.assertEqual(result, 'No')
def test_mock_name__name_attr__not_respected():
mock = Mock(name='foo')
assert 'name' not in dir(mock)
mock.configure_mock(name='bar')
assert 'name' in dir(mock)
assert mock.name == 'bar'
assert mock_name(mock) == 'foo' # repr doesn't respect name attribute
def make_fake_sizes():
extra = {'numberOfCores': 1}
size = Mock(extra=extra)
size.configure_mock(name='Standard_D1')
extra = {'numberOfCores': 4}
size2 = Mock(extra=extra)
size2.configure_mock(name='Standard_A3')
return [size, size2]
def test_get_repo_root_path_get_untracked_files(self, mock_subproc_popen):
process_mock = Mock()
attrs = {'communicate.side_effect': [('', 'empty'), ('', 'empty'), ('git_utils_test.py', 'onlyFile'),
(__file__, '4'), ('something', '5'), ('maybe', '6')]}
process_mock.configure_mock(**attrs)
mock_subproc_popen.return_value = process_mock
result = source.git_utils.is_file_in_repo(os.path.relpath(__file__))
self.assertEqual(result, 'Yes')
def test_file_in_repo(self, mock_subproc_popen):
obj = Interface()
process_mock = Mock()
attrs = {'communicate.return_value': ('', '')}
process_mock.configure_mock(**attrs)
mock_subproc_popen.return_value = process_mock
result = obj.ask('Is the <nose2.cfg> in the repo?')
self.assertEqual(result, 'Yes')
def _setup_macro_mocks(self):
olevba_mock = Mock()
olevba_mock.configure_mock(**{'stdout.read.return_value': '| AutoExec | AutoOpen'})
self._side_effect.append(olevba_mock)
def _setup_popen_mock(self, return_value):
process_mock = Mock()
process_mock.configure_mock(**{'stdout.read.return_value': return_value})
self._side_effect.append(process_mock)
def testChunk(self):
dev1 = Mock()
attrs = {"req_grow": True,
"id": 1,
"name": "req1"}
dev1.configure_mock(**attrs)
req1 = Request(dev1)
req1.base = 10
dev2 = Mock()
attrs = {"req_grow": False,
"id": 2,
"name": "req2"}
dev2.configure_mock(**attrs)
req2 = Request(dev2)
req2.base = 20
chunk = Chunk(110, requests=[req1, req2])
self.assertEqual(chunk.pool, 80)
self.assertEqual(chunk.base, 10)
dev3 = Mock()
attrs = {"req_grow": True,
"id": 3,
"name": "req3"}
dev3.configure_mock(**attrs)
req3 = Request(dev3)
req3.base = 20
req3.max_growth = 35
chunk.addRequest(req3)
self.assertEqual(chunk.pool, 60)
self.assertEqual(chunk.base, 30)
self.assertEqual(chunk.lengthToSize(30), 30)
self.assertEqual(chunk.sizeToLength(40), 40)
self.assertEqual(chunk.hasGrowable, True)
chunk.growRequests()
# the chunk is done growing since its pool has been exhausted
self.assertEqual(chunk.done, True)
# there is still one request remaining since req1 has no maximum growth
self.assertEqual(chunk.remaining, 1)
# req1 is 10 units and growable with no limit
# req2 is 20 units and not growable
# req3 is 20 units and growable with a limits of 35 units of growth
#
# Requests are grown at rates proportional to their share of the
# combined base size of all growable requests. If req3 had no max growth
# it would get 40 units and req1 would get 20. Since req3 has a limit,
# it will get 35 and req1 will get its 20 plus the leftovers from req3,
# which comes out to 25.
self.assertEqual(req1.growth, 25)
self.assertEqual(req2.growth, 0)
self.assertEqual(req3.growth, 35)
def mock_with_name(name):
mock = Mock()
mock.configure_mock(name=name, url='https://url')
return mock
def over_limit(LIMIT):
over_limit_cursor = Mock()
over_limit_cursor.configure_mock(rowcount=LIMIT + 10)
return over_limit_cursor
def return_return_value(content):
parse_mock = Mock()
parse_mock.configure_mock(**{"get_base_image": get_base_image})
return parse_mock
class ModelTest(UTCase):
def setUp(self):
self.driver = Mock()
self.doc = {'foo': 'bar', 'bar': 'baz'}
self.model = Model(self.driver, self.doc)
def test_model_access(self):
self.assertEqual(self.model.data, self.doc)
self.assertEqual(self.model.foo, self.doc['foo'])
self.assertEqual(self.model['foo'], self.doc['foo'])
self.model.baz = 'biz'
self.assertEqual(self.model.baz, 'biz')
self.assertEqual(self.model['baz'], 'biz')
del self.model.baz
with self.assertRaises(AttributeError):
self.model.baz
with self.assertRaises(KeyError):
self.model['baz']
def test_model_str_repr(self):
result = json.loads(str(self.model))
self.assertEqual(result, self.doc)
self.assertTrue(repr(self.model).startswith('Model('))
self.assertTrue(repr(self.model).endswith(')'))
o = len('Model(')
l = len(')')
result = json.loads(repr(self.model)[o:-l])
self.assertTrue(result, self.doc)
def test_model_get_filter(self):
c = self.model._get_filter()
ast = c.get_ast()
expected_val = [{
'name':
'cond_eq',
'val': [{
'name': 'prop',
'val': 'foo'
}, {
'name': 'val',
'val': 'bar'
}]
}, {
'name':
'cond_eq',
'val': [{
'name': 'prop',
'val': 'bar'
}, {
'name': 'val',
'val': 'baz'
}]
}]
self.assertEqual(ast.name, 'join_and')
self.assertTrue(ast.val[0] == expected_val[0]
or ast.val[0] == expected_val[1])
self.assertTrue(ast.val[1] == expected_val[0]
or ast.val[1] == expected_val[1])
def test_model_get_update(self):
a = self.model._get_update()
ast = [_a.get_ast() for _a in a]
a1 = {
'name': 'assign',
'val': [{
'name': 'prop',
'val': 'foo'
}, {
'name': 'val',
'val': 'bar'
}]
}
a2 = {
'name': 'assign',
'val': [{
'name': 'prop',
'val': 'bar'
}, {
'name': 'val',
'val': 'baz'
}]
}
self.assertEqual(len(ast), 2)
self.assertIn(a1, ast)
self.assertIn(a2, ast)
def test_model_save(self):
attrs = {
'put_element.return_value':
Model(self.driver, {
'_id': 'some id',
'foo': 'bar',
'bar': 'baz'
})
}
a1 = {
'name': 'assign',
'val': [{
'name': 'prop',
'val': 'foo'
}, {
'name': 'val',
'val': 'bar'
}]
}
a2 = {
'name': 'assign',
'val': [{
'name': 'prop',
'val': 'bar'
}, {
'name': 'val',
'val': 'baz'
}]
}
self.driver.configure_mock(**attrs)
new_model = self.model.save()
self.assertEqual(new_model._id, 'some id')
args = self.driver.put_element.call_args[0]
self.assertEqual(len(args), 1)
self.assertIsInstance(args[0], list)
self.assertIn(a1, args[0])
self.assertIn(a2, args[0])
def test_model_remove(self):
attrs = {'remove_elements.return_value': None}
self.driver.configure_mock(**attrs)
expected_val = [{
'name':
'cond_eq',
'val': [{
'name': 'prop',
'val': 'foo'
}, {
'name': 'val',
'val': 'bar'
}]
}, {
'name':
'cond_eq',
'val': [{
'name': 'prop',
'val': 'bar'
}, {
'name': 'val',
'val': 'baz'
}]
}]
self.model.delete()
args = self.driver.remove_elements.call_args[0]
self.assertEqual(len(args), 1)
self.assertIsInstance(args[0], list)
self.assertEqual(len(args[0]), 1)
self.assertIsInstance(args[0][0], AST)
self.assertTrue(args[0][0].name, 'filter')
self.assertIsInstance(args[0][0].val, AST)
self.assertEqual(args[0][0].val.name, 'join_and')
self.assertTrue(args[0][0].val.val[0] == expected_val[0]
or args[0][0].val.val[0] == expected_val[1])
self.assertTrue(args[0][0].val.val[1] == expected_val[0]
or args[0][0].val.val[1] == expected_val[1])
# returns: 555
mockFoo.configure_mock(return_value = 999)
print mockFoo()
# returns: 999
'''
class Database(object):
def insert(self):
pass
mockFoo = Mock(spec=Database)
fooSpec = {'insert.return_value': "true"}
mockFoo.configure_mock(**fooSpec)
print mockFoo.insert()
fooSpec = {'insert.side_effect': StandardError}
try:
mockFoo.configure_mock(**fooSpec)
print mockFoo.insert()
except StandardError as e:
print("Test Passed")
#fooSpec = {'callFoo.return_value':"narf", 'doFoo.return_value':"zort", 'doFoo.side_effect':StandardError}
#mockFoo = Mock(spec = fooSpec, return_value = 555)
# returns: narf
#print mockFoo.doFoo("narf")
# raises: StandardError
#fooSpec = {'doFoo.side_effect':None}
def host_2():
host = Mock(vm=[])
host.configure_mock(name='host-2')
host.hardware.systemInfo.uuid = 'host_uuid_2'
return host
def build_mock_object(obj_id):
""" Build a mock object with the passed id"""
mock_object = Mock()
object_config = {'pk': obj_id, 'name': "object {}".format(obj_id)}
mock_object.configure_mock(**object_config)
return mock_object
def test_api_prefix(self):
app = Mock()
app.configure_mock(**{'record.side_effect': AttributeError})
api = flask_restful.Api(app, prefix='/foo')
self.assertEquals(api.prefix, '/foo')
def trigger(self,
http_method,
path,
content,
mock_request,
federation_auth_origin=None):
""" Fire an HTTP event.
Args:
http_method : The HTTP method
path : The HTTP path
content : The HTTP body
mock_request : Mocked request to pass to the event so it can get
content.
federation_auth_origin (bytes|None): domain to authenticate as, for federation
Returns:
A tuple of (code, response)
Raises:
KeyError If no event is found which will handle the path.
"""
path = self.prefix + path
# annoyingly we return a twisted http request which has chained calls
# to get at the http content, hence mock it here.
mock_content = Mock()
config = {'read.return_value': content}
mock_content.configure_mock(**config)
mock_request.content = mock_content
mock_request.method = http_method.encode('ascii')
mock_request.uri = path.encode('ascii')
mock_request.getClientIP.return_value = "-"
headers = {}
if federation_auth_origin is not None:
headers[b"Authorization"] = [
b"X-Matrix origin=%s,key=,sig=" % (federation_auth_origin, )
]
mock_request.requestHeaders.getRawHeaders = mock_getRawHeaders(headers)
# return the right path if the event requires it
mock_request.path = path
# add in query params to the right place
try:
mock_request.args = urlparse.parse_qs(path.split('?')[1])
mock_request.path = path.split('?')[0]
path = mock_request.path
except Exception:
pass
if isinstance(path, bytes):
path = path.decode('utf8')
for (method, pattern, func) in self.callbacks:
if http_method != method:
continue
matcher = pattern.match(path)
if matcher:
try:
args = [urlparse.unquote(u) for u in matcher.groups()]
(code, response) = yield func(mock_request, *args)
defer.returnValue((code, response))
except CodeMessageException as e:
defer.returnValue((e.code, cs_error(e.msg,
code=e.errcode)))
raise KeyError("No event can handle %s" % path)
class QueryManagerTest(UTCase):
def setUp(self):
self.inserted_doc = {'_id': 'some id', 'foo': 'bar'}
self.feature = Mock()
featurecls = MagicMock(return_value=self.feature)
featurecls.__class__ = type
featurecls.name = 'query'
featurecls.mro = MagicMock(return_value=[Feature])
cls = type('DummyDriver', (Middleware,), {})
cls = addfeatures([featurecls])(cls)
self.query = QueryManager()
self.query.set_child_middleware(cls())
def test_all(self):
q = self.query.all()
self.assertIsInstance(q, Query)
self.assertEqual(q.ast, [])
self.assertEqual(q.result, None)
self.assertTrue(q.manager is self.query)
def test_from_ast(self):
expected = [
AST(
'filter',
AST(
'cond_eq', [
AST('prop', 'foo'),
AST('val', 'bar')
]
)
)
]
attrs = {
'find_elements.return_value': []
}
self.feature.configure_mock(**attrs)
q = self.query.from_ast(expected)
self.assertIsInstance(q, Query)
self.assertEqual(q.ast, expected)
list(q)
self.feature.find_elements.assert_called_with(expected)
def test_to_ast(self):
expected = [
{
'name': 'filter',
'val': {
'name': 'cond_eq',
'val': [
{
'name': 'prop',
'val': 'foo'
},
{
'name': 'val',
'val': 'bar'
}
]
}
}
]
q = self.query.all().filter(C('foo') == 'bar')
self.assertEqual(q.to_ast(), expected)
def test_validate_ast(self):
with self.assertRaises(ASTSingleStatementError):
self.query.validate_ast(AST('not_get_or_create', 'unused'))
for stmt in ['update', 'delete', 'get', 'count', 'group']:
with self.assertRaises(ASTLastStatementError):
self.query.validate_ast([
AST(stmt, 'unused'),
AST('unused', 'unused')
])
with self.assertRaises(ASTInvalidStatementError):
self.query.validate_ast([
AST('unknown', 'unused')
])
with self.assertRaises(ASTInvalidFormatError):
self.query.validate_ast('invalid format')
self.query.validate_ast([
AST('filter', 'unused'),
AST('update', 'unused')
])
def test_manager_get_none(self):
attrs = {
'find_elements.return_value': []
}
self.feature.configure_mock(**attrs)
result = self.query.get(C('foo'))
self.assertIsNone(result)
self.feature.find_elements.assert_called_with({
'name': 'cond_exists',
'val': [
{
'name': 'prop',
'val': 'foo'
},
{
'name': 'val',
'val': True
}
]
})
def test_manager_get_one(self):
expected = {'foo': 'bar'}
attrs = {
'find_elements.return_value': [expected]
}
self.feature.configure_mock(**attrs)
result = self.query.get(C('foo'))
self.assertEqual(result, expected)
self.feature.find_elements.assert_called_with({
'name': 'cond_exists',
'val': [
{
'name': 'prop',
'val': 'foo'
},
{
'name': 'val',
'val': True
}
]
})
def test_manager_create(self):
expected = {'_id': 'some id', 'foo': 'bar'}
attrs = {
'put_element.return_value': expected
}
self.feature.configure_mock(**attrs)
result = self.query.create(A('foo', 'bar'))
self.assertEqual(result, expected)
self.feature.put_element.assert_called_with([{
'name': 'assign',
'val': [
{
'name': 'prop',
'val': 'foo'
},
{
'name': 'val',
'val': 'bar'
}
]
}])
def test_query_copy(self):
q1 = self.query.all()
q2 = q1._copy()
self.assertIsInstance(q1, Query)
self.assertIsInstance(q2, Query)
self.assertIsNot(q1, q2)
self.assertIs(q1.manager, q2.manager)
self.assertEqual(q1.ast, q2.ast)
self.assertIsNone(q2.result)
def test_query_count(self):
attrs = {
'count_elements.return_value': 3
}
self.feature.configure_mock(**attrs)
result = self.query.all().filter(C('foo') == 'bar').count()
self.assertEqual(result, 3)
self.feature.count_elements.assert_called_with([{
'name': 'filter',
'val': {
'name': 'cond_eq',
'val': [
{
'name': 'prop',
'val': 'foo'
},
{
'name': 'val',
'val': 'bar'
}
]
}
}])
def test_query_get_none(self):
attrs = {
'find_elements.return_value': []
}
self.feature.configure_mock(**attrs)
result = self.query.all().get(C('foo'))
self.assertIsNone(result)
self.feature.find_elements.assert_called_with([
{
'name': 'get',
'val': {
'name': 'cond_exists',
'val': [
{
'name': 'prop',
'val': 'foo'
},
{
'name': 'val',
'val': True
}
]
}
}
])
def test_query_get_one(self):
expected = {'foo': 'bar'}
attrs = {
'find_elements.return_value': [expected]
}
self.feature.configure_mock(**attrs)
result = self.query.all().get(C('foo'))
self.assertEqual(result, expected)
self.feature.find_elements.assert_called_with([
{
'name': 'get',
'val': {
'name': 'cond_exists',
'val': [
{
'name': 'prop',
'val': 'foo'
},
{
'name': 'val',
'val': True
}
]
}
}
])
def test_query_filter(self):
expected = [
{'_id': 'some id 1', 'foo': 'bar'},
{'_id': 'some id 2', 'foo': 'bar'},
{'_id': 'some id 3', 'foo': 'bar'}
]
attrs = {
'find_elements.return_value': expected
}
self.feature.configure_mock(**attrs)
result = self.query.all().filter(C('foo') == 'bar')
self.assertIsInstance(result, Query)
result = list(result)
self.assertEqual(result, expected)
self.feature.find_elements.assert_called_with([
{
'name': 'filter',
'val': {
'name': 'cond_eq',
'val': [
{
'name': 'prop',
'val': 'foo'
},
{
'name': 'val',
'val': 'bar'
}
]
}
}
])
def test_query_exclude(self):
expected = [
{'_id': 'some id 1', 'foo': 'baz'},
{'_id': 'some id 2', 'foo': 'baz'},
{'_id': 'some id 3', 'foo': 'baz'}
]
attrs = {
'find_elements.return_value': expected
}
self.feature.configure_mock(**attrs)
result = self.query.all().exclude(C('foo') == 'bar')
self.assertIsInstance(result, Query)
result = list(result)
self.assertEqual(result, expected)
self.feature.find_elements.assert_called_with([
{
'name': 'exclude',
'val': {
'name': 'cond_eq',
'val': [
{
'name': 'prop',
'val': 'foo'
},
{
'name': 'val',
'val': 'bar'
}
]
}
}
])
def test_query_slice(self):
expected = [
{'_id': 'some id 2', 'foo': 'bar'},
{'_id': 'some id 3', 'foo': 'bar'}
]
attrs = {
'find_elements.return_value': expected
}
self.feature.configure_mock(**attrs)
result = self.query.all()[1:2]
self.assertIsInstance(result, Query)
result = list(result)
self.assertEqual(result, expected)
self.feature.find_elements.assert_called_with([
{
'name': 'slice',
'val': slice(1, 2)
}
])
def test_query_cache(self):
expected = [
{'_id': 'some id 1', 'foo': 'bar'},
{'_id': 'some id 2', 'foo': 'bar'},
{'_id': 'some id 3', 'foo': 'bar'}
]
attrs = {
'find_elements.return_value': expected
}
self.feature.configure_mock(**attrs)
query = self.query.all()
self.assertIsInstance(query, Query)
result1 = list(query)
self.assertEqual(result1, expected)
result2 = list(query)
self.assertEqual(result2, expected)
self.feature.find_elements.assert_called_once_with([])
def test_query_update(self):
attrs = {
'update_elements.return_value': 3
}
self.feature.configure_mock(**attrs)
result = self.query.all().update(A('foo', 'bar'))
self.assertEqual(result, 3)
self.feature.update_elements.assert_called_with([], [
{
'name': 'assign',
'val': [
{
'name': 'prop',
'val': 'foo'
},
{
'name': 'val',
'val': 'bar'
}
]
}
])
def test_query_delete(self):
attrs = {
'remove_elements.return_value': 3
}
self.feature.configure_mock(**attrs)
result = self.query.all().delete()
self.assertEqual(result, 3)
self.feature.remove_elements.assert_called_with([])
def test_query_group(self):
expected = {'foo': ['bar', 'baz', 'biz']}
attrs = {
'find_elements.return_value': expected
}
self.feature.configure_mock(**attrs)
result = self.query.all().group('foo', F('sum', E('bar')))
self.assertEqual(result, expected)
self.feature.find_elements.assert_called_with([
{
'name': 'group',
'val': [
{
'name': 'prop',
'val': 'foo'
},
{
'name': 'func_sum',
'val': [
{
'name': 'ref',
'val': 'bar'
}
]
}
]
}
])
def test_validate(self):
# 1. Set up all the mocking so that Block.validate() should pass
m_chain_manager = Mock(name='Mock ChainManager')
attrs_all_pass = {
'get_block_is_duplicate.return_value': False,
'validate_mining_nonce.return_value': True,
'get_config_by_block_number.return_value': config.dev,
'new_state_container.return_value': StateContainer(None, None, None, None, None, None, 5,
None, config.dev, False, None, None)
}
m_chain_manager.configure_mock(**attrs_all_pass)
self.block._validate_parent_child_relation = Mock(return_value=True)
result = self.block.validate(m_chain_manager, OrderedDict())
self.assertTrue(result)
# 2. Switch the mock checks one by one to invalid, and make sure that validate() returns False
# The Block is already in the State (a duplicate)
m_chain_manager.get_block_is_duplicate.return_value = True
result = self.block.validate(m_chain_manager, OrderedDict())
self.assertFalse(result)
m_chain_manager.get_block_is_duplicate.return_value = False
# The mining nonce is invalid
m_chain_manager.validate_mining_nonce.return_value = False
result = self.block.validate(m_chain_manager, OrderedDict())
self.assertFalse(result)
m_chain_manager.validate_mining_nonce.return_value = True
# No parent block found, and it's not in future_blocks either
m_chain_manager.get_block.return_value = None
result = self.block.validate(m_chain_manager, OrderedDict())
self.assertFalse(result)
m_chain_manager.get_block.return_value = Mock(name='mock Block')
# The parent_block is not actually Block's parent
self.block._validate_parent_child_relation.return_value = False
result = self.block.validate(m_chain_manager, OrderedDict())
self.assertFalse(result)
self.block._validate_parent_child_relation.return_value = True
# Block.transactions is [] (it should at least have the CoinBase TX in there)
with patch('qrl.core.Block.Block.transactions', new_callable=PropertyMock) as m_transactions:
m_transactions.return_value = []
result = self.block.validate(m_chain_manager, OrderedDict())
self.assertFalse(result)
# There was a problem with the CoinBase TX
with patch('qrl.core.txs.CoinBase.CoinBase._validate_extended') as m_validate_extended:
m_validate_extended.return_value = False
result = self.block.validate(m_chain_manager, OrderedDict())
self.assertFalse(result)
m_validate_extended.return_value = None
m_validate_extended.side_effect = Exception
result = self.block.validate(m_chain_manager, OrderedDict())
self.assertFalse(result)
# The BlockHeader doesn't fit with this Block
self.blockheader.validate.return_value = False
result = self.block.validate(m_chain_manager, OrderedDict())
self.assertFalse(result)
def vmware_vm_no_uuid(host_1):
vmware_vm = Mock(spec=vim.VirtualMachine)
vmware_vm.configure_mock(name='VM1')
vmware_vm.summary.runtime.host = host_1
vmware_vm.config = None
return vmware_vm
def setup_mocks(
self,
atexit,
check_call_state,
check_output_state,
NamedTemporaryFile_state,
check_output,
_open,
Session_from_config,
Session_from_cli,
rmtree,
NamedTemporaryFile_destroy,
time,
check_call_destroy,
popen_call,
mock_os_destroy,
TemporaryDirectory,
ZipFile,
mock_os_release,
mock_find_latest_release_version,
credstash,
):
mock_metadata_file = MagicMock(spec=TextIOWrapper)
metadata = {
'account-scheme-url': 's3://bucket/key',
'team': 'your-team',
'type': 'docker',
}
mock_metadata_file.read.return_value = yaml.dump(metadata)
mock_metadata_file_open = MagicMock()
mock_metadata_file_open.__enter__.return_value = mock_metadata_file
account_scheme = {
'accounts': {
'foodev': {
'id': '123456789',
'role': 'admin',
}
},
'release-account': 'foodev',
'release-bucket': 'releases',
'default-region': 'us-north-4',
'environments': {
'live': 'foodev',
},
'terraform-backend-s3-bucket': 'tfstate-bucket',
'terraform-backend-s3-dynamodb-table': 'tflocks-table',
}
mock_account_scheme = MagicMock(spec=TextIOWrapper)
mock_account_scheme.read.return_value = json.dumps(account_scheme)
mock_account_scheme_open = MagicMock()
mock_account_scheme_open.__enter__.return_value = mock_account_scheme
_open.side_effect = lambda filename: \
mock_account_scheme_open \
if filename.endswith(ACCOUNT_SCHEME_FILE) \
else mock_metadata_file_open
mock_sts_client = Mock()
mock_sts_client.get_caller_identity.return_value = {
u'UserId': 'foo',
'Arn': 'dummy_arn'
}
mock_sts_client.assume_role.return_value = {
'Credentials': {
'AccessKeyId': 'dummy-access-key',
'SecretAccessKey': 'dummy-secret-key',
'SessionToken': 'dummy-session-token',
}
}
mock_root_session = Mock()
mock_root_session.client.return_value = mock_sts_client
mock_root_session.region_name = 'eu-west-12'
mock_s3_body = Mock()
mock_s3_body.read.return_value = json.dumps(account_scheme)
mock_s3_resource = Mock()
mock_s3_resource.Object.return_value.get.return_value = {
'Body': mock_s3_body,
}
mock_root_session.resource.return_value = mock_s3_resource
Session_from_cli.return_value = mock_root_session
aws_access_key_id = 'dummy-access-key-id'
aws_secret_access_key = 'dummy-secret-access-key'
aws_session_token = 'dummy-session-token'
mock_assumed_session = Mock()
mock_assumed_session.region_name = 'us-north-4'
mock_assumed_session.get_credentials.return_value = BotoCreds(
aws_access_key_id, aws_secret_access_key, aws_session_token)
mock_db_client = Mock()
mock_db_client.describe_table.return_value = {
'Table': {
'TableName': 'terraform_locks',
'AttributeDefinitions': [{
'AttributeName': 'LockID'
}]
}
}
mock_s3_client = Mock()
mock_s3_client.list_buckets.return_value = {
'Buckets': [{
'Name': 'tfstate'
}]
}
mock_s3_client.get_bucket_tagging.return_value = {
'TagSet': [{
'Key': 'is-cdflow-tfstate-bucket',
'Value': 'true'
}],
}
mock_s3_client.get_bucket_location.return_value = {
'LocationConstraint': mock_assumed_session.region_name,
}
mock_assumed_session.client.side_effect = (
mock_s3_client,
mock_db_client,
)
Session_from_config.return_value = mock_assumed_session
TemporaryDirectory.return_value.__enter__.return_value = '/tmp/foo'
mock_os_destroy.environ = {'foo': 'bar'}
mock_os_release.environ = {'CDFLOW_IMAGE_DIGEST': 'hash'}
component_name = 'dummy-component'
check_output.return_value = '[email protected]:org/{}.git'.format(
component_name).encode('utf-8')
credstash.listSecrets.return_value = []
mock_find_latest_release_version.return_value = '1'
process_mock = Mock()
process_mock.poll.return_value = 2
attrs = {
'communicate.return_value':
(''.encode('utf-8'), ''.encode('utf-8'))
}
process_mock.configure_mock(**attrs)
popen_call.return_value = process_mock
check_output_state.return_value = '* default'.encode('utf-8')
return (
check_call_state,
check_call_destroy,
popen_call,
TemporaryDirectory,
mock_assumed_session,
NamedTemporaryFile_destroy,
time,
aws_access_key_id,
aws_secret_access_key,
aws_session_token,
rmtree,
component_name,
)
def r53_mock(self):
'''
Mock route53 connection and dsn records
Returns:
R53 Mock object
'''
r53_mock = Mock()
r53_connect_result = Mock(name='r53_connect')
r53_mock.return_value = r53_connect_result
m1 = Mock(alias_dns_name="unittest1")
m1.name = 'unittest_elb-12345678.dsd.io.'
m1.type = 'A'
m1.alias_hosted_zone_id = "ASDAKSLSA"
m1.alias_evaluate_target_health = False
m2 = Mock(resource_records=['"12345678"'])
m2.name = 'stack.active.unittest-dev.dsd.io.'
m2.type = 'TXT'
m2.alias_hosted_zone_id = "ASDAKSLSA"
m2.alias_evaluate_target_health = False
m3 = Mock(alias_dns_name="unittest1")
m3.name = 'unittest_elb.dsd.io.'
m3.type = 'A'
m3.alias_hosted_zone_id = "ASDAKSLSA"
m3.alias_evaluate_target_health = False
m4 = Mock(resource_records=['"12345678"'])
m4.name = 'stack.test.unittest-dev.dsd.io.'
m4.type = 'TXT'
m4.alias_hosted_zone_id = "ASDAKSLSA"
m4.alias_evaluate_target_health = False
m5 = Mock(resource_records=['"12345678"'])
m5.name = 'deployarn.test.unittest-dev.dsd.io.'
m5.type = 'TXT'
m5.alias_hosted_zone_id = "ASDAKSLSA"
m5.alias_evaluate_target_health = False
m6 = Mock(resource_records=['"12345678"'])
m6.name = 'unittest.unittest.dsd.io.'
m6.type = 'A'
m6.alias_hosted_zone_id = "Z3P5QSUBK4POTI"
m6.alias_evaluate_target_health = False
m7 = Mock(resource_records=['"12345678"'])
m7.name = 'unittest-12345678.unittest.dsd.io.'
m7.type = 'A'
m7.alias_hosted_zone_id = "Z3P5QSUBK4POTI"
m7.alias_evaluate_target_health = False
response = [m1, m2, m3, m4, m5, m6, m7]
hosted_name = {
"GetHostedZoneResponse": {
"HostedZone": {
"Id": "/hostedzone/Z3P5QSUBK4POTI",
"Name": "www.example.com."
}
}
}
mock_config = {
'update_dns_record.return_value': True,
'get_all_rrsets.return_value': response,
'delete_dns_record.return_value': True,
'get_hosted_zone_by_name.return_value': hosted_name
}
r53_connect_result.configure_mock(**mock_config)
boto.route53.connect_to_region = r53_mock
r = r53.R53("profile_name")
return r
class TestConstraintsMiddleware(unittest.TestCase):
""" Tests for common.middleware.constraints.check_constraints """
def setUp(self):
self.conf = {'policies': 'swiftonfile,cephfs-policy'}
self.container1_info_mock = Mock()
self.container1_info_mock.return_value = {
'status': 0,
'sync_key': None,
'storage_policy': '0',
'meta': {},
'cors': {
'allow_origin': None,
'expose_headers': None,
'max_age': None
},
'sysmeta': {},
'read_acl': None,
'object_count': None,
'write_acl': None,
'versions': None,
'bytes': None
}
self.container2_info_mock = Mock()
self.container2_info_mock.return_value = {
'status': 0,
'sync_key': None,
'storage_policy': '2',
'meta': {},
'cors': {
'allow_origin': None,
'expose_headers': None,
'max_age': None
},
'sysmeta': {},
'read_acl': None,
'object_count': None,
'write_acl': None,
'versions': None,
'bytes': None
}
self.policies_mock = Mock()
self.sof_policy_mock = Mock()
self.sof_policy_mock.name = 'swiftonfile'
attrs = {'get_by_index.return_value': self.sof_policy_mock}
self.policies_mock.configure_mock(**attrs)
self.test_check = check_constraints.filter_factory(self.conf)(
FakeApp())
def test_GET(self):
path = '/V1.0/a/c/o'
resp = Request.blank(path, environ={
'REQUEST_METHOD': 'GET'
}).get_response(self.test_check)
self.assertEqual(resp.status_int, 200)
def test_PUT_container(self):
path = '/V1.0/a/c'
resp = Request.blank(path, environ={
'REQUEST_METHOD': 'PUT'
}).get_response(self.test_check)
self.assertEqual(resp.status_int, 200)
def test_PUT_object_with_double_slashes(self):
path = '/V1.0/a/c2//o'
with nested(
patch(
"swiftonfile.swift.common.middleware.check_constraints."
"get_container_info", self.container2_info_mock),
patch(
"swiftonfile.swift.common.middleware.check_constraints."
"POLICIES", self.policies_mock)):
resp = Request.blank(path, environ={
'REQUEST_METHOD': 'PUT'
}).get_response(self.test_check)
self.assertEqual(resp.status_int, 400)
self.assertTrue('Invalid object name' in resp.body)
self.assertTrue('cannot begin, end, or have' in resp.body)
def test_PUT_object_end_with_slashes(self):
path = '/V1.0/a/c2/o/'
with nested(
patch(
"swiftonfile.swift.common.middleware.check_constraints."
"get_container_info", self.container2_info_mock),
patch(
"swiftonfile.swift.common.middleware.check_constraints."
"POLICIES", self.policies_mock)):
resp = Request.blank(path, environ={
'REQUEST_METHOD': 'PUT'
}).get_response(self.test_check)
self.assertEqual(resp.status_int, 400)
self.assertTrue('Invalid object name' in resp.body)
self.assertTrue(
'can end with a slash only if it is a directory' in resp.body)
def test_PUT_object_named_dot(self):
path = '/V1.0/a/c2/.'
with nested(
patch(
"swiftonfile.swift.common.middleware.check_constraints."
"get_container_info", self.container2_info_mock),
patch(
"swiftonfile.swift.common.middleware.check_constraints."
"POLICIES", self.policies_mock)):
resp = Request.blank(path, environ={
'REQUEST_METHOD': 'PUT'
}).get_response(self.test_check)
self.assertEqual(resp.status_int, 400)
self.assertTrue('Invalid object name' in resp.body)
self.assertTrue('cannot have . or ..' in resp.body)
def test_PUT_container_with_long_names(self):
longname = 'c' * 256
path = '/V1.0/a/' + longname
resp = Request.blank(path,
method='PUT',
headers={
'X-Storage-Policy': 'swiftonfile'
}).get_response(self.test_check)
self.assertEqual(resp.status_int, 400)
# test case where storage policy is not defined in header and
# container would be created in default policy, which happens to be
# a swiftonfile policy
default_policies_mock = Mock()
sof_policy_mock = Mock()
sof_policy_mock.name = 'swiftonfile'
attrs = {'default.return_value': self.sof_policy_mock}
default_policies_mock.configure_mock(**attrs)
with patch(
"swiftonfile.swift.common.middleware.check_constraints."
"POLICIES", default_policies_mock):
resp = Request.blank(path,
method='PUT').get_response(self.test_check)
self.assertEqual(resp.status_int, 400)
def test_PUT_object_with_long_names(self):
for i in (220, 221):
longname = 'o' * i
path = '/V1.0/a/c2/' + longname
with nested(
patch(
"swiftonfile.swift.common.middleware."
"check_constraints.get_container_info",
self.container2_info_mock),
patch(
"swiftonfile.swift.common.middleware."
"check_constraints.POLICIES", self.policies_mock)):
resp = Request.blank(path, environ={
'REQUEST_METHOD': 'PUT'
}).get_response(self.test_check)
self.assertEqual(resp.status_int, 200)
longname = 'o' * 222
path = '/V1.0/a/c2/' + longname
with nested(
patch(
"swiftonfile.swift.common.middleware.check_constraints."
"get_container_info", self.container2_info_mock),
patch(
"swiftonfile.swift.common.middleware.check_constraints."
"POLICIES", self.policies_mock)):
resp = Request.blank(path, environ={
'REQUEST_METHOD': 'PUT'
}).get_response(self.test_check)
self.assertEqual(resp.status_int, 400)
self.assertTrue('too long' in resp.body)
def test_PUT_object_with_policy0(self):
path = '/V1.0/a/c1//o'
with patch(
"swiftonfile.swift.common.middleware."
"check_constraints.get_container_info",
self.container1_info_mock):
resp = Request.blank(path, environ={
'REQUEST_METHOD': 'PUT'
}).get_response(self.test_check)
self.assertEqual(resp.status_int, 200)
longname = 'o' * 222
path = '/V1.0/a/c2/' + longname
with patch(
"swiftonfile.swift.common.middleware.check_constraints."
"get_container_info", self.container1_info_mock):
resp = Request.blank(path, environ={
'REQUEST_METHOD': 'PUT'
}).get_response(self.test_check)
self.assertEqual(resp.status_int, 200)
iq = self.protocol.offer('1234', '[email protected]/test', 'documents',
items)
self.assertEqual(iq.getType(), 'result')
self.assertNotEqual(iq.getID(), None)
self.assertEqual(iq.getQuery().getName(), 'query')
self.assertEqual(iq.getQuery().getNamespace(),
fshare_protocol.NS_FILE_SHARING)
self.assertEqual(iq.getQuery().getAttr('node'), 'documents')
node = iq.getQuery()
self.assertEqual(len(node.getChildren()), 2)
# Mock modules
gajim = Mock()
attr = {'get_jid_from_account.return_value': '[email protected]/test'}
gajim.configure_mock(**attr)
fshare_protocol.gajim = gajim
fshare_protocol.helpers = Mock()
class TestProtocolDispatcher(unittest.TestCase):
def setUp(self):
self.account = '*****@*****.**'
self.protocol = fshare_protocol.Protocol(self.account)
testc = {self.account: Mock()}
fshare_protocol.gajim.connections = testc
database = Mock()
top_dirs = [(u'relative_path1', None, None, None, None, 1),
(u'relative_path2', None, None, None, None, 1)]
file_ = (u'file1', u'hash', 999, u'description', u'date', u'file_path',
0)
def low_count():
low_count_cursor = Mock()
low_count_cursor.configure_mock(rowcount=1)
return low_count_cursor
def get_mock_item(self, render_method="blt", **kwargs):
m = Mock()
m.configure_mock(render_method=render_method, **kwargs)
return m
def get_mock_input(type):
assert(type in type_map.keys())
m = Mock()
m.configure_mock(available_keys = {"mock_driver": type_map[type]})
return m
def get_mock_callback(**kwargs):
m = Mock()
m.configure_mock(**kwargs)
m.configure_mock(__name__="test_callback")
return m
def over_default(DEFAULT):
over_default_cursor = Mock()
over_default_cursor.configure_mock(rowcount=DEFAULT + 10)
return over_default_cursor
def vm_esxi_properties(vmware_vm_1):
dynamic_property = Mock(val='VM1')
dynamic_property.configure_mock(name='name')
return Mock(obj=vmware_vm_1, propSet=[dynamic_property])
class TestBaseParser(unittest.TestCase):
def setUp(self):
self.mock = Mock(__class__=BaseParser, allow_empty_results=False)
self.meth = MethodProxy(BaseParser, self.mock)
def _asserts_of_proper__new__instance_adjustment(self, instance):
# BaseQueued.__new__() ensures that
self.assertIsNot(instance.input_queue, BaseParser.input_queue)
def _asserts_of_proper_preinit_hook_instance_adjustment(self, instance,
binding_key):
# for classes with `default_binding_key`
# BaseParser.preinit_hook() ensures that
self.assertEqual(instance.input_queue, {
'exchange': 'raw',
'exchange_type': 'topic',
'queue_name': binding_key,
'binding_keys': [binding_key],
})
self.assertEqual(BaseParser.input_queue, {
'exchange': 'raw',
'exchange_type': 'topic',
})
def _basic_init_related_asserts(self,
instance,
subclass,
super_mock,
super_cls_mock,
expected_config,
expected_config_full):
# assert that an instance of the proper type has been returned
self.assertIsInstance(instance, subclass)
# assert that super used properly
super_mock.assert_called_once_with(BaseParser, instance)
super_cls_mock.__init__.assert_called_once_with(a=sentinel.a,
bb=sentinel.bb)
# assert that configuration stuff has been obtained properly
self.assertEqual(instance.config, expected_config)
self.assertIsInstance(instance.config, ConfigSection)
self.assertEqual(instance.config_full, expected_config_full)
self.assertIsInstance(instance.config_full, Config)
def test_basics(self):
self.assertTrue(issubclass(BaseParser, QueuedBase))
self.assertTrue(hasattr(BaseParser, 'default_binding_key'))
self.assertTrue(hasattr(BaseParser, 'config_spec_pattern'))
self.assertTrue(hasattr(BaseParser, 'constant_items'))
self.assertTrue(hasattr(BaseParser, 'record_dict_class'))
self.assertTrue(hasattr(BaseParser, 'event_type'))
def test_config_spec_pattern(self):
config_spec = BaseParser.config_spec_pattern.format(parser_class_name='example_foo')
config_spec_parsed = parse_config_spec(config_spec)
prefetch_count_opt_spec = config_spec_parsed.get_opt_spec('example_foo.prefetch_count')
self.assertEqual(prefetch_count_opt_spec.name, 'prefetch_count')
self.assertEqual(prefetch_count_opt_spec.converter_spec, 'int')
def test_initialization_without_default_binding_key(self):
class SomeParser(BaseParser):
pass # no `default_binding_key` defined => it's an abstract class
with self.assertRaises(NotImplementedError):
SomeParser()
unready_instance = SomeParser.__new__(SomeParser)
self._asserts_of_proper__new__instance_adjustment(unready_instance)
# for classes without `default_binding_key`
# `queue_name` and `binding_keys` items are *not* added...
self.assertEqual(unready_instance.input_queue,
BaseParser.input_queue)
self.assertEqual(BaseParser.input_queue, {
'exchange': 'raw',
'exchange_type': 'topic',
})
@foreach(
param(
mocked_conf_from_files={},
expected_config=ConfigSection('SomeParser', {'prefetch_count': 1}),
expected_config_full=Config.make({'SomeParser': {'prefetch_count': 1}}),
),
param(
mocked_conf_from_files={
'SomeParser': {
'prefetch_count': '42'
},
'another_section': {
'another_opt': '123.456'
},
},
expected_config=ConfigSection('SomeParser', {'prefetch_count': 42}),
expected_config_full=Config.make({'SomeParser': {'prefetch_count': 42}}),
),
param(
custom_config_spec_pattern=concat_reducing_indent(
BaseParser.config_spec_pattern,
'''
some_opt = [-3, null] :: json
[another_section]
another_opt :: float
yet_another_opt = Foo Bar Spam Ham
''',
),
mocked_conf_from_files={
'SomeParser': {
'prefetch_count': '42'
},
'another_section': {
'another_opt': '123.456'
},
},
expected_config=ConfigSection('SomeParser', {
'prefetch_count': 42,
'some_opt': [-3, None],
}),
expected_config_full=Config.make({
'SomeParser': {
'prefetch_count': 42,
'some_opt': [-3, None],
},
'another_section': {
'another_opt': 123.456,
'yet_another_opt': 'Foo Bar Spam Ham',
},
}),
),
)
@foreach(
param(binding_key='foo.bar'),
param(binding_key='foo.bar.33'),
)
def test_initialization_with_default_binding_key(self,
binding_key,
mocked_conf_from_files,
expected_config,
expected_config_full,
custom_config_spec_pattern=None):
class SomeParser(BaseParser):
default_binding_key = binding_key # => it's a concrete class
if custom_config_spec_pattern is not None:
SomeParser.config_spec_pattern = custom_config_spec_pattern
unready_instance = SomeParser.__new__(SomeParser)
self._asserts_of_proper__new__instance_adjustment(unready_instance)
self._asserts_of_proper_preinit_hook_instance_adjustment(unready_instance, binding_key)
super_cls_mock = SimpleNamespace(__init__=Mock())
with patch_always('n6.parsers.generic.super',
return_value=super_cls_mock) as super_mock, \
patch('n6.parsers.generic.Config._load_n6_config_files',
return_value=mocked_conf_from_files):
# instantiation
instance = SomeParser(a=sentinel.a, bb=sentinel.bb)
self._asserts_of_proper__new__instance_adjustment(instance)
self._asserts_of_proper_preinit_hook_instance_adjustment(instance, binding_key)
self._basic_init_related_asserts(
instance,
SomeParser,
super_mock,
super_cls_mock,
expected_config,
expected_config_full)
def test__make_binding_keys(self):
self.mock.default_binding_key = 'fooo.barr'
binding_keys = self.meth.make_binding_keys()
self.assertEqual(binding_keys, ['fooo.barr'])
self.assertEqual(self.mock.mock_calls, [])
def test__make_binding_keys_with_raw_format_version_tag(self):
self.mock.default_binding_key = 'fooo.barr.33'
binding_keys = self.meth.make_binding_keys()
self.assertEqual(binding_keys, ['fooo.barr.33'])
self.assertEqual(self.mock.mock_calls, [])
def test__get_script_init_kwargs(self):
self.assertIsInstance(vars(BaseParser)['get_script_init_kwargs'],
classmethod)
init_kwargs = BaseParser.get_script_init_kwargs.__func__(self.mock)
self.assertEqual(init_kwargs, {})
self.assertEqual(self.mock.mock_calls, [])
def test__run_handling__interrupted(self):
self.mock.configure_mock(**{'run.side_effect': KeyboardInterrupt})
self.meth.run_handling()
self.mock.run.assert_called_once_with()
self.mock.stop.assert_called_once_with()
def test__run_handling__not_interrupted(self):
self.meth.run_handling()
self.mock.run.assert_called_once_with()
self.assertEqual(self.mock.stop.mock_calls, [])
@patch('n6.parsers.generic.FilePagedSequence')
def test__input_callback(self, FilePagedSequence_mock):
FilePagedSequence_mock.return_value = MagicMock()
FilePagedSequence_mock.return_value.__enter__.return_value = sentinel.working_seq
data = MagicMock(**{'get.return_value': sentinel.rid})
self.mock.configure_mock(**{
'_fix_body.return_value': sentinel.body,
'prepare_data.return_value': data,
'setting_error_event_info': MagicMock(),
'get_output_rk.return_value': sentinel.output_rk,
'get_output_bodies.return_value': [sentinel.output_body1,
sentinel.output_body2],
})
self.meth.input_callback(sentinel.routing_key,
sentinel.body,
sentinel.properties)
self.assertEqual(self.mock.mock_calls, [
call._fix_body(sentinel.body),
call.prepare_data(sentinel.routing_key,
sentinel.body,
sentinel.properties),
call.prepare_data().get('properties.message_id'),
call.setting_error_event_info(sentinel.rid),
call.setting_error_event_info().__enter__(),
call.get_output_rk(data),
call.get_output_bodies(data, sentinel.working_seq),
call.publish_output(routing_key=sentinel.output_rk,
body=sentinel.output_body1),
call.publish_output(routing_key=sentinel.output_rk,
body=sentinel.output_body2),
call.setting_error_event_info().__exit__(None, None, None),
])
self.assertEqual(FilePagedSequence_mock.mock_calls, [
call(page_size=1000),
call().__enter__(),
call().__exit__(None, None, None),
])
def test__prepare_data(self):
data = self.meth.prepare_data(
routing_key='ham.spam',
body=sentinel.body,
properties=SimpleNamespace(foo=sentinel.foo,
bar=sentinel.bar,
timestamp=1389348840,
headers={'a': sentinel.a}))
self.assertEqual(data, {
'a': sentinel.a,
'properties.foo': sentinel.foo,
'properties.bar': sentinel.bar,
'source': 'ham.spam',
'properties.timestamp': '2014-01-10 10:14:00',
'raw_format_version_tag': None,
'raw': sentinel.body,
})
def test__prepare_data__rk__with_raw_format_version_tag(self):
data = self.meth.prepare_data(
routing_key='ham.spam.33',
body=sentinel.body,
properties=SimpleNamespace(foo=sentinel.foo,
bar=sentinel.bar,
timestamp=1389348840,
headers={'a': sentinel.a}))
self.assertEqual(data, {
'a': sentinel.a,
'properties.foo': sentinel.foo,
'properties.bar': sentinel.bar,
'source': 'ham.spam',
'properties.timestamp': '2014-01-10 10:14:00',
'raw_format_version_tag': '33',
'raw': sentinel.body,
})
def test__get_output_rk(self):
self.mock.configure_mock(**{
'event_type': 'foobar',
})
data = {'source': 'ham.spam'}
output_rk = self.meth.get_output_rk(data)
self.assertEqual(output_rk, 'foobar.parsed.ham.spam')
def test__get_output_bodies(self):
parsed = [MagicMock(**{'__class__': RecordDict,
'used_as_context_manager': True,
'get_ready_json.return_value':
getattr(sentinel,
'output_body{}'.format(i))})
for i in (1, 2)]
self.mock.configure_mock(**{
'parse.return_value': parsed,
'get_output_message_id.side_effect': [
sentinel.msg_A,
sentinel.msg_B,
],
'setting_error_event_info': MagicMock(),
'postprocess_parsed.side_effect': (
lambda data, parsed, total, item_no: parsed
),
})
seq_mock = FilePagedSequence._instance_mock()
output_bodies = self.meth.get_output_bodies(sentinel.data, seq_mock)
self.assertIs(output_bodies, seq_mock)
self.assertEqual(seq_mock._list, [
sentinel.output_body1,
sentinel.output_body2,
])
self.assertEqual(parsed[0].mock_calls, [
call.__setitem__('id', sentinel.msg_A),
call.get_ready_json(),
])
self.assertEqual(parsed[1].mock_calls, [
call.__setitem__('id', sentinel.msg_B),
call.get_ready_json(),
])
self.assertEqual(self.mock.mock_calls, [
call.parse(sentinel.data),
call.get_output_message_id(parsed[0]),
call.delete_too_long_address(parsed[0]),
call.get_output_message_id(parsed[1]),
call.delete_too_long_address(parsed[1]),
call.setting_error_event_info(parsed[0]),
call.setting_error_event_info().__enter__(),
call.postprocess_parsed(sentinel.data,
parsed[0],
2,
item_no=1),
call.setting_error_event_info().__exit__(None, None, None),
call.setting_error_event_info(parsed[1]),
call.setting_error_event_info().__enter__(),
call.postprocess_parsed(sentinel.data,
parsed[1],
2,
item_no=2),
call.setting_error_event_info().__exit__(None, None, None),
])
def test__get_output_bodies__record_dict_not_used_as_context_manager(self):
parsed = [MagicMock(**{'__class__': RecordDict,
'used_as_context_manager': False})
for i in (1, 2)]
self.mock.configure_mock(**{'parse.return_value': parsed})
with self.assertRaises(AssertionError):
self.meth.get_output_bodies(sentinel.data,
FilePagedSequence._instance_mock())
self.assertEqual(self.mock.method_calls, [
call.parse(sentinel.data),
])
def test__get_output_bodies__parse_yielded_no_items(self):
self.mock.configure_mock(**{'parse.return_value': iter([])})
with self.assertRaises(ValueError):
self.meth.get_output_bodies(sentinel.data,
FilePagedSequence._instance_mock())
self.assertEqual(self.mock.method_calls, [
call.parse(sentinel.data),
])
def test__get_output_bodies__parse_yielded_no_items__allow_empty_results(self):
self.mock.configure_mock(**{'parse.return_value': iter([]),
'allow_empty_results': True})
seq_mock = FilePagedSequence._instance_mock()
output_bodies = self.meth.get_output_bodies(sentinel.data, seq_mock)
self.assertIs(output_bodies, seq_mock)
self.assertEqual(seq_mock._list, []) # just empty
self.assertEqual(self.mock.mock_calls, [
call.parse(sentinel.data),
])
def test__delete_too_long_address__address_is_ok(self):
parsed = RecordDict()
parsed['address'] = [{'ip': i+1} for i in xrange(MAX_IPS_IN_ADDRESS)]
expected = RecordDict()
expected['address'] = [{'ip': i+1} for i in xrange(MAX_IPS_IN_ADDRESS)]
self.meth.delete_too_long_address(parsed)
self.assertEqual(parsed, expected)
def test__delete_too_long_address__address_is_too_long(self):
ips = MAX_IPS_IN_ADDRESS + 1
parsed = RecordDict()
parsed['id'] = '0123456789abcdef0123456789abcdef'
parsed['address'] = [{'ip': i+1} for i in xrange(ips)]
expected = RecordDict()
expected['id'] = '0123456789abcdef0123456789abcdef'
self.meth.delete_too_long_address(parsed)
self.assertEqual(parsed, expected)
def test__delete_too_long_address__address_is_empty(self):
parsed = RecordDict()
parsed.update({'source': 'foo.bar'})
expected = RecordDict()
expected.update({'source': 'foo.bar'})
self.meth.delete_too_long_address(parsed)
self.assertEqual(parsed, expected)
def test__get_output_message_id(self):
inputs_and_resultant_hash_bases = [
# basics
(
{'source': 'foo.bar'},
'source,foo.bar'
),
(
{u'source': u'foo.bar'},
'source,foo.bar'
),
# proper sorting of multiple values
(
{'key1': 2, 'key2': ['value2', 'value3', 'value1']},
'key1,2\nkey2,value1,value2,value3'
),
# ...and of keys + proper encoding of unicode keys/values
(
{u'key2': [u'value3', u'value1', u'value2'], u'key1': 2L},
'key1,2\nkey2,value1,value2,value3'
),
# ...as well as proper int/long normalization/representation
(
{u'key2': [30, 10, 20L], u'key1': 9000111222333444555666777888999000L},
'key1,9000111222333444555666777888999000\nkey2,10,20,30'
),
# non-ascii values
(
{'target': 'zażółć', u'client': [u'jaźń', u'gęślą']},
'client,gęślą,jaźń\ntarget,zażółć'
),
(
{u'target': u'zażółć', 'client': ['jaźń', 'gęślą']},
'client,gęślą,jaźń\ntarget,zażółć'
),
# subdicts
(
{'dip': u'3.3.3.3', u'address': [{'ip': '255.255.255.0'}, {'ip': '127.0.0.1'}]},
"address,{'ip': '127.0.0.1'},{'ip': '255.255.255.0'}\ndip,3.3.3.3"
),
# non-ascii subdict keys/values
(
{u'key2': [{'ką2': 'vą2'}, {'ką1': 'vą1'}], 'key1': {'ką': 'vą'}},
"key1,{'k\\xc4\\x85': 'v\\xc4\\x85'}\n" +
"key2,{'k\\xc4\\x851': 'v\\xc4\\x851'},{'k\\xc4\\x852': 'v\\xc4\\x852'}"
),
# proper encoding of unicode keys/values + proper sorting of whole subdicts
(
{'key1': {u'ką': u'vą'}, 'key2': [{u'ką2': 'vą2'}, {'ką1': u'vą1'}]},
"key1,{'k\\xc4\\x85': 'v\\xc4\\x85'}\n" +
"key2,{'k\\xc4\\x851': 'v\\xc4\\x851'},{'k\\xc4\\x852': 'v\\xc4\\x852'}"
),
# ...as well as proper int/long normalization/representation
(
{'key1': {u'k': 2L}, 'key2': [{'k2': 2L}, {u'k1': 1}]},
"key1,{'k': 2}\nkey2,{'k1': 1},{'k2': 2}"
),
(
{u'key2': [{'k2': 2}, {'k1': 1}], 'key1': {'k': 3}},
"key1,{'k': 3}\nkey2,{'k1': 1},{'k2': 2}"
),
(
{u'key2': [{'k2': 2L}, {'k1': 1L}], 'key1': {'k': 9000111222333444555666777888999000L}},
"key1,{'k': 9000111222333444555666777888999000}\nkey2,{'k1': 1},{'k2': 2}"
),
# proper sorting of multiple items in subdicts
(
{'key1': {'c': 2, u'a': 3L, u'b': 1L},
'key2': [{'c': 2, u'a': 3L, u'b': 1L}, {'d': 3, u'a': 2L, u'b': 1L}]},
"key1,{'a': 3, 'b': 1, 'c': 2}\n" +
"key2,{'a': 2, 'b': 1, 'd': 3},{'a': 3, 'b': 1, 'c': 2}"
),
]
class _RecordDict(RecordDict):
adjust_key1 = adjust_key2 = None
optional_keys = RecordDict.optional_keys | {'key1', 'key2'}
parser = BaseParser.__new__(BaseParser)
for input_dict, expected_base in inputs_and_resultant_hash_bases:
record_dict = _RecordDict(input_dict)
expected_result = hashlib.md5(expected_base).hexdigest()
result = parser.get_output_message_id(record_dict)
self.assertIsInstance(result, str)
self.assertEqual(result, expected_result)
def test__get_output_message_id__errors(self):
inputs_and_exc_classes = [
# bad subdict key type
(
{'key1': {32: 2}},
TypeError,
),
(
{'key1': [{32: 2}]},
TypeError,
),
# bad subdict value type
(
{'key1': {'k': 2.3}},
TypeError,
),
(
{'key1': [{'k': 2.3}]},
TypeError,
),
(
{'key1': {'k': {'k': 2}}}, # nesting is illegal
TypeError,
),
(
{'key1': [{'k': {'k': 2}}]}, # nesting is illegal
TypeError,
),
# bad value type
(
{'key1': 2.3},
TypeError,
),
(
{'key1': [2.3]},
TypeError,
),
(
{'key1': [[2]]}, # nesting is illegal
TypeError,
),
]
class _RecordDict(RecordDict):
adjust_key1 = adjust_key2 = None
optional_keys = RecordDict.optional_keys | {'key1', 'key2'}
parser = BaseParser.__new__(BaseParser)
for input_dict, exc_class in inputs_and_exc_classes:
record_dict = _RecordDict(input_dict)
with self.assertRaises(exc_class):
parser.get_output_message_id(record_dict)
def test__postprocess_parsed__without__do_not_resolve_fqdn_to_ip(self):
data = {}
parsed = RecordDict()
self.meth.postprocess_parsed(data, parsed, 1, item_no=1)
self.assertEqual(parsed, {})
def test__postprocess_parsed__with__do_not_resolve_fqdn_to_ip__False(self):
data = {'_do_not_resolve_fqdn_to_ip': False}
parsed = RecordDict()
self.meth.postprocess_parsed(data, parsed, 1, item_no=1)
self.assertEqual(parsed, {})
def test__postprocess_parsed__with__do_not_resolve_fqdn_to_ip__True(self):
data = {'_do_not_resolve_fqdn_to_ip': True}
parsed = RecordDict()
self.meth.postprocess_parsed(data, parsed, 1, item_no=1)
self.assertEqual(parsed, {'_do_not_resolve_fqdn_to_ip': True})
def get_mock_output(rows=8, cols=21):
m = Mock()
m.configure_mock(rows=rows, cols=cols, type=["char"])
return m
from mssqlcli.main import MssqlCli
from mock import Mock
DEFAULT = MssqlCli().row_limit
LIMIT = DEFAULT + 1000
over_default = Mock()
over_default.configure_mock(rowcount=DEFAULT + 10)
over_limit = Mock()
over_limit.configure_mock(rowcount=LIMIT + 10)
low_count = Mock()
low_count.configure_mock(rowcount=1)
def test_default_row_limit():
cli = MssqlCli()
stmt = "SELECT * FROM students"
result = cli._should_show_limit_prompt(stmt, low_count)
assert result is False
result = cli._should_show_limit_prompt(stmt, over_default)
assert result is True
def test_set_row_limit():
cli = MssqlCli(row_limit=LIMIT)
stmt = "SELECT * FROM students"
result = cli._should_show_limit_prompt(stmt, over_default)
assert result is False
def trigger(self, http_method, path, content, mock_request):
""" Fire an HTTP event.
Args:
http_method : The HTTP method
path : The HTTP path
content : The HTTP body
mock_request : Mocked request to pass to the event so it can get
content.
Returns:
A tuple of (code, response)
Raises:
KeyError If no event is found which will handle the path.
"""
path = self.prefix + path
# annoyingly we return a twisted http request which has chained calls
# to get at the http content, hence mock it here.
mock_content = Mock()
config = {'read.return_value': content}
mock_content.configure_mock(**config)
mock_request.content = mock_content
mock_request.method = http_method
mock_request.uri = path
mock_request.getClientIP.return_value = "-"
mock_request.requestHeaders.getRawHeaders.return_value = [
"X-Matrix origin=test,key=,sig="
]
# return the right path if the event requires it
mock_request.path = path
# add in query params to the right place
try:
mock_request.args = urlparse.parse_qs(path.split('?')[1])
mock_request.path = path.split('?')[0]
path = mock_request.path
except:
pass
for (method, pattern, func) in self.callbacks:
if http_method != method:
continue
matcher = pattern.match(path)
if matcher:
try:
args = [
urllib.unquote(u).decode("UTF-8")
for u in matcher.groups()
]
(code, response) = yield func(mock_request, *args)
defer.returnValue((code, response))
except CodeMessageException as e:
defer.returnValue((e.code, cs_error(e.msg)))
raise KeyError("No event can handle %s" % path)
def get_mock_object(x=5, y=5, width=1, height=1, **kwargs):
m = Mock()
m.configure_mock(x=x, y=y, width=width, height=height, **kwargs)
return m
