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