def _fake_popen( self, stdout, stderr, sleeptime ): def wait_stdout( self ): import time for line in stdout.splitlines(): time.sleep(sleeptime) yield line def wait_stderr( self ): import time for line in stderr.splitlines(): time.sleep(sleeptime) yield line m = Mock(spec=subprocess.Popen) sout = Mock() sout.read = stdout sout.__iter__ = wait_stdout serr = Mock() serr.read = stderr serr.__iter__ = wait_stderr m.return_value.stdout = sout m.return_value.stderr = serr return m
def default_execute_query_se(query, arraysize): if STARTOF_MINMAX_QUERY in query: mock_query_results_config = {'get_col_index.return_value': 1} mock_query_results = Mock(**mock_query_results_config) mock_query_results.__iter__ = Mock(return_value=iter([[1, 2]])) elif "FROM v$logmnr_contents" in query: mock_row = [1, 2, 3, 4, 5, 6, 7, 8, 9] mock_query_results_config = { 'get_col_index.return_value': 1, 'fetchone.return_value': mock_row } mock_query_results = Mock(**mock_query_results_config) mock_query_results.__iter__ = Mock(return_value=iter([mock_row])) elif "WHERE DICTIONARY_BEGIN = 'YES'" in query: redolog_name = 'my_redolog_name' mock_row = [redolog_name] mock_query_results_config = { 'get_col_index.return_value': 0, 'fetchone.return_value': redolog_name } mock_query_results = Mock(**mock_query_results_config) mock_query_results.__iter__ = Mock(return_value=iter([mock_row])) else: mock_query_results_config = { 'fetchall.return_value': [('schema', 'table')] } mock_query_results = Mock(**mock_query_results_config) mock_query_results.__iter__ = Mock(return_value=iter([])) return mock_query_results
def _fake_popen(self, stdout, stderr, sleeptime): def wait_stdout(self): import time for line in stdout.splitlines(): time.sleep(sleeptime) yield line def wait_stderr(self): import time for line in stderr.splitlines(): time.sleep(sleeptime) yield line m = Mock(spec=subprocess.Popen) sout = Mock() sout.read = stdout sout.__iter__ = wait_stdout serr = Mock() serr.read = stderr serr.__iter__ = wait_stderr m.return_value.stdout = sout m.return_value.stderr = serr return m
def test_step_status_is_collected_and_reported(self, format_summary): feature = Mock() scenario = Mock() steps = [Mock(), Mock(), Mock(), Mock(), Mock()] steps[0].status = 'failed' steps[0].__iter__ = Mock(return_value=iter([])) steps[1].status = 'undefined' steps[1].__iter__ = Mock(return_value=iter([])) steps[2].status = 'passed' steps[2].__iter__ = Mock(return_value=iter([])) steps[3].status = 'passed' steps[3].__iter__ = Mock(return_value=iter([])) steps[4].status = None steps[4].__iter__ = Mock(return_value=iter([])) feature.status = 'failed' feature.duration = 12.3 feature.__iter__ = Mock(return_value=iter([scenario])) scenario.status = 'failed' scenario.__iter__ = Mock(return_value=iter(steps)) config = Mock() reporter = SummaryReporter(config) reporter.feature(feature) reporter.end() expected = { 'passed': 2, 'failed': 1, 'skipped': 1, 'untested': 0, 'undefined': 1, } eq_(format_summary.call_args_list[2][0], ('step', expected))
def testMagicMethodsIsolatedBetweenMocks(self): mock1 = Mock() mock2 = Mock() mock1.__iter__ = Mock(return_value=iter([])) self.assertEqual(list(mock1), []) self.assertRaises(TypeError, lambda: list(mock2))
def test_scenario_status_is_collected_and_reported(self, format_summary, stderr): # pylint: disable=W0621 # W0621 Redefining name ... from outer scope (format_summary) feature = Mock() scenarios = [Mock(), Mock(), Mock(), Mock(), Mock()] scenarios[0].status = 'failed' scenarios[0].__iter__ = Mock(return_value=iter([])) scenarios[1].status = 'failed' scenarios[1].__iter__ = Mock(return_value=iter([])) scenarios[2].status = 'skipped' scenarios[2].__iter__ = Mock(return_value=iter([])) scenarios[3].status = 'passed' scenarios[3].__iter__ = Mock(return_value=iter([])) scenarios[4].status = None scenarios[4].__iter__ = Mock(return_value=iter([])) feature.status = 'failed' feature.duration = 12.3 feature.__iter__ = Mock(return_value=iter(scenarios)) config = Mock() reporter = SummaryReporter(config) reporter.feature(feature) reporter.end() expected = { 'passed': 1, 'failed': 2, 'skipped': 2, 'untested': 0, } eq_(format_summary.call_args_list[1][0], ('scenario', expected))
def test_scenario_status_is_collected_and_reported(self, format_summary, stdout): feature = Mock() scenarios = [Mock(), Mock(), Mock(), Mock(), Mock()] scenarios[0].status = Status.failed scenarios[0].__iter__ = Mock(return_value=iter([])) scenarios[1].status = Status.failed scenarios[1].__iter__ = Mock(return_value=iter([])) scenarios[2].status = Status.skipped scenarios[2].__iter__ = Mock(return_value=iter([])) scenarios[3].status = Status.passed scenarios[3].__iter__ = Mock(return_value=iter([])) scenarios[4].status = Status.untested scenarios[4].__iter__ = Mock(return_value=iter([])) feature.status = Status.failed feature.duration = 12.3 feature.__iter__ = Mock(return_value=iter(scenarios)) config = Mock() sys.stdout.encoding = "UTF-8" reporter = SummaryReporter(config) reporter.feature(feature) reporter.end() expected = { Status.passed.name: 1, Status.failed.name: 2, Status.skipped.name: 1, Status.untested.name: 1, } eq_(format_summary.call_args_list[1][0], ('scenario', expected))
def test_checkout_deliveries_with_shipping_method(monkeypatch): shipping_cost = 5 items_cost = 5 partition = Mock( is_shipping_required=MagicMock(return_value=True), get_total=Mock(return_value=Price(items_cost, currency=settings.DEFAULT_CURRENCY)), get_price_per_item=Mock(return_value=Price(items_cost, currency=settings.DEFAULT_CURRENCY))) def f(): yield partition partition.__iter__ = Mock(return_value=f()) cart = Mock(partition=Mock(return_value=[partition]), currency=settings.DEFAULT_CURRENCY) shipping_method_mock = Mock(get_total=Mock(return_value=Price(shipping_cost, currency=settings.DEFAULT_CURRENCY))) monkeypatch.setattr(Checkout, 'shipping_method', shipping_method_mock) checkout = Checkout( cart, AnonymousUser(), 'tracking_code') deliveries = list(checkout.deliveries) assert deliveries[0][1] == Price(shipping_cost, currency=settings.DEFAULT_CURRENCY) assert deliveries[0][2] == Price(items_cost + shipping_cost, currency=settings.DEFAULT_CURRENCY) assert deliveries[0][0][0][0] == partition
def test_scenario_status_is_collected_and_reported(self, format_summary, stdout): feature = Mock() scenarios = [Mock(), Mock(), Mock(), Mock(), Mock()] scenarios[0].status = 'failed' scenarios[0].__iter__ = Mock(return_value=iter([])) scenarios[1].status = 'failed' scenarios[1].__iter__ = Mock(return_value=iter([])) scenarios[2].status = 'skipped' scenarios[2].__iter__ = Mock(return_value=iter([])) scenarios[3].status = 'passed' scenarios[3].__iter__ = Mock(return_value=iter([])) scenarios[4].status = None scenarios[4].__iter__ = Mock(return_value=iter([])) feature.status = 'failed' feature.duration = 12.3 feature.__iter__ = Mock(return_value=iter(scenarios)) config = Mock() reporter = SummaryReporter(config) reporter.feature(feature) reporter.end() expected = { 'passed': 1, 'failed': 2, 'skipped': 2, 'untested': 0, } eq_(format_summary.call_args_list[1][0], ('scenario', expected))
def test_magic_methods_isolated_between_mocks(self): mock1 = Mock() mock2 = Mock() mock1.__iter__ = Mock(return_value=iter([])) self.assertEqual(list(mock1), []) self.assertRaises(TypeError, lambda: list(mock2))
def test_if_pkg_candidate_is_unavailable_then_pkg_is_not_considered(self): origin = Mock() origin.origin = 'allowed-origin' pkg = Mock() pkg.name = 'findutils' pkg.is_upgradable = False pkg.is_installed = True pkg.installed = Mock() pkg.installed.policy_priority = -1 pkg.installed.origins = [origin] pkg.installed.version = '1:0.1' pkg.candidate = None pkg.versions = [pkg.installed] cache = Mock() cache.__iter__ = Mock(return_value=iter([pkg])) options = Mock() pkgs_to_upgrade, pkgs_kept_back = \ calculate_upgradable_pkgs( cache, options, ['o=allowed-origin'], ['findutils'], []) self.assertListEqual([], pkgs_to_upgrade) self.assertEqual(0, len(pkgs_kept_back))
def testMagicMethodsAndSpecSet(self): class Iterable(object): def __iter__(self): pass mock = Mock(spec_set=Iterable) self.assertRaises(AttributeError, lambda: mock.__iter__) mock.__iter__ = Mock(return_value=iter([])) self.assertEqual(list(mock), []) class NonIterable(object): pass mock = Mock(spec_set=NonIterable) self.assertRaises(AttributeError, lambda: mock.__iter__) def set_int(): mock.__int__ = Mock(return_value=iter([])) self.assertRaises(AttributeError, set_int) mock = MagicMock(spec_set=Iterable) self.assertEqual(list(mock), []) self.assertRaises(AttributeError, set_int)
def test_scenario_status_is_collected_and_reported(self, format_summary, stdout): feature = Mock() scenarios = [Mock(), Mock(), Mock(), Mock(), Mock()] scenarios[0].status = Status.failed scenarios[0].__iter__ = Mock(return_value=iter([])) scenarios[1].status = Status.failed scenarios[1].__iter__ = Mock(return_value=iter([])) scenarios[2].status = Status.skipped scenarios[2].__iter__ = Mock(return_value=iter([])) scenarios[3].status = Status.passed scenarios[3].__iter__ = Mock(return_value=iter([])) scenarios[4].status = Status.untested scenarios[4].__iter__ = Mock(return_value=iter([])) feature.status = Status.failed feature.duration = 12.3 feature.__iter__ = Mock(return_value=iter(scenarios)) config = Mock() reporter = SummaryReporter(config) reporter.feature(feature) reporter.end() expected = { Status.passed.name: 1, Status.failed.name: 2, Status.skipped.name: 1, Status.untested.name: 1, } eq_(format_summary.call_args_list[1][0], ('scenario', expected))
def test_catter(): fs = Filesystem(DB(':memory:')) fs.root().add_file('zeroes', [test_asset_ids], 130) asset = Mock() asset.__enter__ = Mock(return_value=asset) asset.__exit__ = Mock(return_value=False) asset.status = Mock(return_value=proto.AssetStatus(size=1024 * 1024, status=proto.SUCCESS)) asset.__iter__ = Mock(return_value=('\x00' * (128 * 1024) for _ in range(8))) bithorde = Mock() bithorde.open = Mock(return_value=asset) cat = Cat(fs, bithorde) sha = sha1() for chunk in cat(P('zeroes')): sha.update(chunk) assert_equals(sha.hexdigest(), '3b71f43ff30f4b15b5cd85dd9e95ebc7e84eb5a3') with assert_raises(FNotFound): for chunk in cat(P('NON-EXISTING')): pass asset.status = Mock(return_value=proto.AssetStatus(status=proto.NOTFOUND)) with assert_raises(NotFoundError): for chunk in cat(P('zeroes')): pass
def test_if_origin_does_not_match_then_blacklist_is_not_checked(self): origin = Mock() origin.origin = "some-other-origin" pkg = Mock() pkg.name = "postgresql" pkg.is_upgradable = True pkg.candidate = Mock() pkg.candidate.policy_priority = 500 pkg.candidate.origins = [origin] pkg.versions = [pkg.candidate] cache = Mock() cache.__iter__ = Mock(return_value=iter([pkg])) options = Mock() pkgs_to_upgrade, pkgs_kept_back = \ calculate_upgradable_pkgs(cache, options, ["o=allowed-origin"], ["postgresql"], []) self.assertListEqual([], pkgs_to_upgrade) self.assertEqual(0, len(pkgs_kept_back))
def test_scenario_status_is_collected_and_reported(self, format_summary, stdout): feature = Mock() scenarios = [Mock(), Mock(), Mock(), Mock(), Mock()] scenarios[0].status = 'failed' scenarios[0].__iter__ = Mock(return_value=iter([])) scenarios[1].status = 'failed' scenarios[1].__iter__ = Mock(return_value=iter([])) scenarios[2].status = 'skipped' scenarios[2].__iter__ = Mock(return_value=iter([])) scenarios[3].status = 'passed' scenarios[3].__iter__ = Mock(return_value=iter([])) scenarios[4].status = None scenarios[4].__iter__ = Mock(return_value=iter([])) feature.status = 'failed' feature.duration = 12.3 feature.__iter__ = Mock(return_value=iter(scenarios)) config = Mock() config.order = ('defined', None) reporter = SummaryReporter(config) reporter.feature(feature) reporter.end() expected = { 'passed': 1, 'failed': 2, 'skipped': 2, 'untested': 0, } eq_(format_summary.call_args_list[1][0], ('scenario', expected))
def test_bound_methods(self): m = Mock() # XXXX should this be an expected failure instead? # this seems like it should work, but is hard to do without introducing # other api inconsistencies. Failure message could be better though. m.__iter__ = [3].__iter__ self.assertRaises(TypeError, iter, m)
def test_set_admin(self): user = "******" MockAdmin = Mock() MockAdmin.__iter__ = Mock(return_value=iter([user])) mock_set_secure_cookie = Mock() with patch.object(settings, 'ADMINISTRATORS', MockAdmin): with patch.object(self.auth_handler, 'set_secure_cookie', mock_set_secure_cookie): self.auth_handler.set_admin(user) mock_set_secure_cookie.assert_called_once_with('admin', 'true')
def test_set_admin_not_administrator(self): # Mock auth_handler.clear_cookie user = "******" MockAdmin = Mock() MockAdmin.__iter__ = Mock(return_value=iter([])) mock_clear_cookie = Mock() with patch.object(settings, 'ADMINISTRATORS', MockAdmin): with patch.object(self.auth_handler, 'clear_cookie', mock_clear_cookie): self.auth_handler.set_admin(user) mock_clear_cookie.assert_called_once_with('admin')
def queryset(self): """Mock "queryset" of instances with numeric id and unicode repr.""" o1 = Mock() o1.pk = 1 o1.__unicode__ = lambda self: "one" o2 = Mock() o2.pk = 2 o2.__unicode__ = lambda self: "two" qs = Mock() qs.__iter__ = lambda self: iter([o1, o2]) qs.all.return_value = qs return qs
def make_mock_manifest(*items): rv = Mock(tests_root="/foobar") tests = [] rv.__iter__ = lambda self: iter(tests) rv.__getitem__ = lambda self, k: tests[k] for test_type, dir_path, num_tests in items: for i in range(num_tests): filename = dir_path + "/%i.html" % i tests.append((test_type, filename, {TestharnessTest("/foo.bar", filename, "/", filename)})) return rv
def test_step_status_is_collected_and_reported(self, format_summary, stdout): feature = Mock() scenario = Mock() steps = [Mock(), Mock(), Mock(), Mock(), Mock()] steps[0].status = Status.failed steps[0].__iter__ = Mock(return_value=iter([])) steps[1].status = Status.passed steps[1].__iter__ = Mock(return_value=iter([])) steps[2].status = Status.passed steps[2].__iter__ = Mock(return_value=iter([])) steps[3].status = Status.skipped steps[4].__iter__ = Mock(return_value=iter([])) steps[4].status = Status.undefined steps[4].__iter__ = Mock(return_value=iter([])) feature.status = Status.failed feature.duration = 12.3 feature.__iter__ = Mock(return_value=iter([scenario])) scenario.status = Status.failed scenario.__iter__ = Mock(return_value=iter(steps)) config = Mock() sys.stdout.encoding = "UTF-8" reporter = SummaryReporter(config) reporter.feature(feature) reporter.end() expected = { "all": 5, Status.passed.name: 2, Status.failed.name: 1, Status.skipped.name: 1, Status.untested.name: 0, Status.undefined.name: 1, } step_index = 2 # HINT: Index for steps if not rules are used. expected_parts = ("step", expected) assert format_summary.call_args_list[step_index][0] == expected_parts
def test_widget(self): subfield_1 = Mock(name='subfield_1') subfield_1.return_value = u'[first input]' subfield_2 = Mock(name='subfield_2') subfield_2.return_value = u'[second input]' field = Mock(name='field') field.style = {'style': 'display:none;'} field.__iter__ = Mock(return_value=iter([subfield_1, subfield_2])) widget = HoneyPotWidget() actual = widget(field) subfield_2.assert_called_with(style='display:none;') subfield_1.assert_called_with(style='display:none;') self.assertEqual(actual, '[first input][second input]')
def fake_et_iterator(parent): """Fake iterator over child elements.""" def internal_fake_iterator(parent): while False: yield None xml_element1 = Mock() xml_element1.tag = 'simpleexpression' xml_element1.__iter__ = internal_fake_iterator elements = [xml_element1] for elem in elements: yield elem
def _fake_test(self, *args, **kwargs): _fake_test.called = True self._raw_data = _fake_raw_data metrics_mock = metrics_mock_class() preds = Mock() preds.size = 100 preds.__iter__ = Mock(return_value=iter([0] * 100)) metrics_mock._preds = preds metrics_mock._probs = [numpy.array([0.1, 0.2])] * 100 metrics_mock._true_data = scipy.sparse.coo_matrix( [[0, 0, 0]] * 100) return metrics_mock
def execute_query_se(query, arraysize): if STARTOF_MINMAX_QUERY in query: mock_query_results_config = {'get_col_index.return_value': 1} mock_query_results = Mock(**mock_query_results_config) mock_query_results.__iter__ = Mock(return_value=iter([[1, 2]])) elif "FROM v$logmnr_contents" in query: mock_query_results_config = { 'get_col_index.return_value': 1, 'fetchone.return_value': (None if not logminer_results_deque else logminer_results_deque.popleft()) } mock_query_results = Mock(**mock_query_results_config) # Mock a single result with two columns returned mock_query_results.__iter__ = Mock( return_value=iter(logminer_results_deque)) else: mock_query_results_config = { 'fetchall.return_value': [('schema', 'table')] } mock_query_results = Mock(**mock_query_results_config) mock_query_results.__iter__ = Mock(return_value=iter([])) return mock_query_results
def test_pagination_es_query_no_data(self): request = Mock() request.query_params = {'limit': 20, 'offset': 30} search_result = Mock() search_result.hits = Mock() search_result.hits.total = 0 search_result.__iter__ = Mock(return_value=iter([])) query = Mock() query.__getitem__ = Mock(return_value=query) query.execute.return_value = search_result pagination = ESQueryPagination() paginated_query = pagination.paginate_es_query(query, request) expect(paginated_query).to.eq([])
def testLenContainsIter(self): mock = Mock() self.assertRaises(TypeError, len, mock) self.assertRaises(TypeError, iter, mock) self.assertRaises(TypeError, lambda: 'foo' in mock) mock.__len__ = lambda s: 6 self.assertEqual(len(mock), 6) mock.__contains__ = lambda s, o: o == 3 self.assertTrue(3 in mock) self.assertFalse(6 in mock) mock.__iter__ = lambda s: iter('foobarbaz') self.assertEqual(list(mock), list('foobarbaz'))
def test_len_contains_iter(self): mock = Mock() self.assertRaises(TypeError, len, mock) self.assertRaises(TypeError, iter, mock) self.assertRaises(TypeError, lambda: 'foo' in mock) mock.__len__ = lambda s: 6 self.assertEqual(len(mock), 6) mock.__contains__ = lambda s, o: o == 3 self.assertIn(3, mock) self.assertNotIn(6, mock) mock.__iter__ = lambda s: iter('foobarbaz') self.assertEqual(list(mock), list('foobarbaz'))
def get_fake_db(): """ Return a fake MongoDB """ fake_mongo = Mock(stream_mode=False) values = [2, 3] def fake_next(): if not values: return None return values.pop() def fake_iter(): return iter([]) fake_mongo.__next__ = fake_next fake_mongo.__iter__ = fake_iter return fake_mongo
def test_scenario_outline_status_is_collected_and_reported( self, stdout, format_summary): feature = Mock() scenarios = [ ScenarioOutline(u"<string>", 0, u"scenario_outline", u"name"), Mock(), Mock(), Mock() ] subscenarios = [Mock(), Mock(), Mock(), Mock()] subscenarios[0].status = Status.passed subscenarios[0].__iter__ = Mock(return_value=iter([])) subscenarios[1].status = Status.failed subscenarios[1].__iter__ = Mock(return_value=iter([])) subscenarios[2].status = Status.failed subscenarios[2].__iter__ = Mock(return_value=iter([])) subscenarios[3].status = Status.skipped subscenarios[3].__iter__ = Mock(return_value=iter([])) scenarios[0]._scenarios = subscenarios scenarios[1].status = Status.failed scenarios[1].__iter__ = Mock(return_value=iter([])) scenarios[2].status = Status.skipped scenarios[2].__iter__ = Mock(return_value=iter([])) scenarios[3].status = Status.passed scenarios[3].__iter__ = Mock(return_value=iter([])) feature.status = Status.failed feature.duration = 12.4 feature.__iter__ = Mock(return_value=iter(scenarios)) config = Mock() sys.stdout.encoding = "UTF-8" reporter = SummaryReporter(config) reporter.feature(feature) reporter.end() expected = { "all": 7, Status.passed.name: 2, Status.failed.name: 3, Status.skipped.name: 2, Status.untested.name: 0, } scenario_index = 1 # -- HINT: Index for scenarios if no Rules are used. expected_parts = ("scenario", expected) assert format_summary.call_args_list[scenario_index][ 0] == expected_parts
def test_default_refresh_config(self, nest_mock): dev = SpikeRecorder() neurons = Mock() neurons.__iter__ = Mock(return_value=iter([])) dev.connect(neurons) nest_mock.GetStatus.return_value = [{ 'times': [0, 8, 15], 'senders': [8, 9, 10] }] neurons.id_to_index = TestSpikeRecorder.id_to_index dev.refresh(0.0) spikes = dev.times self.assertEqual(3, len(spikes)) print spikes self.assertEqual(8.0, spikes[0][0])
def test_checkout_deliveries(): partition = Mock( get_total=Mock(return_value=Price(10, currency=settings.DEFAULT_CURRENCY)), get_price_per_item=Mock(return_value=Price(10, currency=settings.DEFAULT_CURRENCY))) def f(): yield partition partition.__iter__ = Mock(return_value=f()) cart = Mock(partition=Mock(return_value=[partition]), currency=settings.DEFAULT_CURRENCY) checkout = Checkout( cart, AnonymousUser(), 'tracking_code') deliveries = list(checkout.deliveries) assert deliveries[0][1] == Price(0, currency=settings.DEFAULT_CURRENCY) assert deliveries[0][2] == partition.get_total() assert deliveries[0][0][0][0] == partition
def test_use_indices_config(self, nest_mock): dev = SpikeRecorder(use_ids=False) neurons = Mock() neurons.__iter__ = Mock(return_value=iter([1])) neurons.grandparent = Mock() populationView = Mock() neurons.grandparent.__getitem__ = populationView neurons.grandparent.all_cells = [1] dev.connect(neurons) recorder_device = neurons.grandparent.recorder recorder_device.reset.assert_called_once_with() populationView().record.assert_called_once_with("spikes", to_file=False) nest_mock.SetStatus.assert_any_call( recorder_device._spike_detector.device, {"to_memory": True}) nest_mock.SetStatus.assert_any_call( recorder_device._spike_detector.device, {"to_file": False}) self.assertDictEqual(dev._parameters, {'use_ids': False})
def test_paginate_es_query(self): allegation = AllegationFactory(crid=123456) attachment_1 = AttachmentFileFactory(id=1, allegation=allegation, title='Document Title 1', text_content='Text Content 1') attachment_2 = AttachmentFileFactory(id=2, allegation=allegation, title='Document Title 2', text_content='Text Content 2') AttachmentFileFactory(id=3, allegation=allegation, title='Document Title 3', text_content='Text Content 3') queryset = AttachmentFile.objects.all() class MockObject(object): pass returned_value_1 = MockObject() returned_value_2 = MockObject() setattr(returned_value_1, 'id', 1) setattr(returned_value_2, 'id', 2) request = Mock() request.query_params = {'limit': 20, 'offset': 30} search_result = Mock() search_result.hits = Mock() search_result.hits.total = 50 search_result.__iter__ = Mock( return_value=iter([returned_value_1, returned_value_2])) query = Mock() query.__getitem__ = Mock(return_value=query) query.execute.return_value = search_result pagination = ESQuerysetPagination() paginated_query = pagination.paginate_es_query(query, request, queryset) expect(list(paginated_query)).to.eq([attachment_1, attachment_2]) expect(pagination.count).to.eq(50) expect(pagination.limit).to.eq(20) expect(pagination.offset).to.eq(30) expect(pagination.request).to.eq(request)
def test_scenario_outline_status_is_collected_and_reported( self, stdout, format_summary): feature = Mock() scenarios = [ ScenarioOutline(u"<string>", 0, u"scenario_outline", u"name"), Mock(), Mock(), Mock() ] subscenarios = [Mock(), Mock(), Mock(), Mock()] subscenarios[0].status = Status.passed subscenarios[0].__iter__ = Mock(return_value=iter([])) subscenarios[1].status = Status.failed subscenarios[1].__iter__ = Mock(return_value=iter([])) subscenarios[2].status = Status.failed subscenarios[2].__iter__ = Mock(return_value=iter([])) subscenarios[3].status = Status.skipped subscenarios[3].__iter__ = Mock(return_value=iter([])) scenarios[0]._scenarios = subscenarios scenarios[1].status = Status.failed scenarios[1].__iter__ = Mock(return_value=iter([])) scenarios[2].status = Status.skipped scenarios[2].__iter__ = Mock(return_value=iter([])) scenarios[3].status = Status.passed scenarios[3].__iter__ = Mock(return_value=iter([])) feature.status = Status.failed feature.duration = 12.4 feature.__iter__ = Mock(return_value=iter(scenarios)) config = Mock() sys.stdout.encoding = "UTF-8" reporter = SummaryReporter(config) reporter.feature(feature) reporter.end() expected = { Status.passed.name: 2, Status.failed.name: 3, Status.skipped.name: 2, Status.untested.name: 0, } eq_(format_summary.call_args_list[1][0], ('scenario', expected))
def test_scenario_outline_status_is_collected_and_reported( self, stderr, format_summary): feature = Mock() scenarios = [ ScenarioOutline(u"<string>", 0, u"scenario_outline", u"name"), Mock(), Mock(), Mock() ] subscenarios = [Mock(), Mock(), Mock(), Mock()] subscenarios[0].status = 'passed' subscenarios[0].__iter__ = Mock(return_value=iter([])) subscenarios[1].status = 'failed' subscenarios[1].__iter__ = Mock(return_value=iter([])) subscenarios[2].status = 'failed' subscenarios[2].__iter__ = Mock(return_value=iter([])) subscenarios[3].status = 'skipped' subscenarios[3].__iter__ = Mock(return_value=iter([])) scenarios[0]._scenarios = subscenarios scenarios[1].status = 'failed' scenarios[1].__iter__ = Mock(return_value=iter([])) scenarios[2].status = 'skipped' scenarios[2].__iter__ = Mock(return_value=iter([])) scenarios[3].status = 'passed' scenarios[3].__iter__ = Mock(return_value=iter([])) feature.status = 'failed' feature.duration = 12.4 feature.__iter__ = Mock(return_value=iter(scenarios)) config = Mock() reporter = SummaryReporter(config) reporter.feature(feature) reporter.end() expected = { 'passed': 2, 'failed': 3, 'skipped': 2, 'untested': 0, } eq_(format_summary.call_args_list[1][0], ('scenario', expected))
def test_paginate_es_query(self): request = Mock() request.query_params = {'limit': 20, 'offset': 30} search_result = Mock() search_result.hits = Mock() search_result.hits.total = 50 search_result.__iter__ = Mock(return_value=iter([1, 2, 3])) query = Mock() query.__getitem__ = Mock(return_value=query) query.execute.return_value = search_result pagination = ESQueryPagination() paginated_query = pagination.paginate_es_query(query, request) query.__getitem__.assert_called_with(slice(30, 50)) expect(paginated_query).to.eq([1, 2, 3]) expect(pagination.count).to.eq(50) expect(pagination.limit).to.eq(20) expect(pagination.offset).to.eq(30) expect(pagination.request).to.eq(request)
def test_reprocess_events(self): event1 = Mock(spec=Event) event1.process.return_value = True # processed event2 = Mock(spec=Event) event2.process.return_value = False # not processed events = [event1, event2] modeladmin_mock = Mock() request_mock = Mock() queryset = Mock() queryset.__iter__ = Mock(return_value=iter(events)) queryset.count.return_value = len(events) reprocess_events(modeladmin_mock, request_mock, queryset) event1.process.assert_called_with(force=True) event2.process.assert_called_with(force=True) modeladmin_mock.message_user.assert_called_with( request_mock, "1/2 event(s) successfully re-processed.")
def test_scenario_outline_status_is_collected_and_reported(self, stdout, format_summary): feature = Mock() scenarios = [ ScenarioOutline(u"<string>", 0, u"scenario_outline", u"name"), Mock(), Mock(), Mock() ] subscenarios = [ Mock(), Mock(), Mock(), Mock() ] subscenarios[0].status = Status.passed subscenarios[0].__iter__ = Mock(return_value=iter([])) subscenarios[1].status = Status.failed subscenarios[1].__iter__ = Mock(return_value=iter([])) subscenarios[2].status = Status.failed subscenarios[2].__iter__ = Mock(return_value=iter([])) subscenarios[3].status = Status.skipped subscenarios[3].__iter__ = Mock(return_value=iter([])) scenarios[0]._scenarios = subscenarios scenarios[1].status = Status.failed scenarios[1].__iter__ = Mock(return_value=iter([])) scenarios[2].status = Status.skipped scenarios[2].__iter__ = Mock(return_value=iter([])) scenarios[3].status = Status.passed scenarios[3].__iter__ = Mock(return_value=iter([])) feature.status = Status.failed feature.duration = 12.4 feature.__iter__ = Mock(return_value=iter(scenarios)) config = Mock() sys.stdout.encoding = "UTF-8" reporter = SummaryReporter(config) reporter.feature(feature) reporter.end() expected = { "all": 7, Status.passed.name: 2, Status.failed.name: 3, Status.skipped.name: 2, Status.untested.name: 0, } scenario_index = 1 # -- HINT: Index for scenarios if no Rules are used. expected_parts = ("scenario", expected) assert format_summary.call_args_list[scenario_index][0] == expected_parts
def test_angle_brackets_in_schema(): ''' Serializer is able to find a type that matches schema in angle-bracket notation. ''' class FakeSerializer(TypeRegistrySerializationBase): # We don't need docstrings here. pylint: disable=C0111 signature = 42 def serialize_int(self, data): pass def deserialize_int(self, data): pass registry = Mock() registry.primitives = [int] registry.__iter__ = Mock(side_effect=lambda: iter([int])) serializer = FakeSerializer(registry) # test that the following function call does *not* raise any exceptions serializer.schema_to_type('TimeSeries<int>')
def test_scenario_outline_status_is_collected_and_reported(self, stdout, format_summary): # FIX: issue40 # ENSURE: ScenarioOutline's scenarios are walked and collected. feature = Mock() scenarios = [ ScenarioOutline(u"<string>", 0, u"scenario_outline", u"name"), Mock(), Mock(), Mock() ] subscenarios = [ Mock(), Mock(), Mock(), Mock() ] subscenarios[0].status = 'passed' subscenarios[0].__iter__ = Mock(return_value=iter([])) subscenarios[1].status = 'failed' subscenarios[1].__iter__ = Mock(return_value=iter([])) subscenarios[2].status = 'failed' subscenarios[2].__iter__ = Mock(return_value=iter([])) subscenarios[3].status = 'skipped' subscenarios[3].__iter__ = Mock(return_value=iter([])) scenarios[0]._scenarios = subscenarios scenarios[1].status = 'failed' scenarios[1].__iter__ = Mock(return_value=iter([])) scenarios[2].status = 'skipped' scenarios[2].__iter__ = Mock(return_value=iter([])) scenarios[3].status = 'passed' scenarios[3].__iter__ = Mock(return_value=iter([])) feature.status = 'failed' feature.duration = 12.4 feature.__iter__ = Mock(return_value=iter(scenarios)) config = Mock() reporter = SummaryReporter(config) reporter.feature(feature) reporter.end() expected = { 'passed': 2, 'failed': 3, 'skipped': 2, 'untested': 0, } eq_(format_summary.call_args_list[1][0], ('scenario', expected))
def test_parses_feature_files_and_appends_to_feature_list(self, abspath, parse_file): feature_files = ["one", "two", "three"] feature = Mock() feature.tags = [] feature.__iter__ = Mock(return_value=iter([])) feature.run.return_value = False self.runner.feature_files.return_value = feature_files abspath.side_effect = lambda x: x.upper() self.config.lang = "fritz" self.config.format = ["plain"] self.config.output.encoding = None self.config.exclude = lambda s: False self.config.junit = False self.config.summary = False parse_file.return_value = feature self.runner.run_with_paths() expected_parse_file_args = [((x.upper(),), {"language": "fritz"}) for x in feature_files] eq_(parse_file.call_args_list, expected_parse_file_args) eq_(self.runner.features, [feature] * 3)
def test_dir(self): mock = Mock() attrs = set(dir(mock)) type_attrs = set([m for m in dir(Mock) if not m.startswith('_')]) # all public attributes from the type are included self.assertEqual(set(), type_attrs - attrs) # creates these attributes mock.a, mock.b self.assertIn('a', dir(mock)) self.assertIn('b', dir(mock)) # instance attributes mock.c = mock.d = None self.assertIn('c', dir(mock)) self.assertIn('d', dir(mock)) # magic methods mock.__iter__ = lambda s: iter([]) self.assertIn('__iter__', dir(mock))
def test_scenario_outline_status_is_collected_and_reported(self, stdout, format_summary): feature = Mock() scenarios = [ ScenarioOutline(u"<string>", 0, u"scenario_outline", u"name"), Mock(), Mock(), Mock() ] subscenarios = [ Mock(), Mock(), Mock(), Mock() ] subscenarios[0].status = Status.passed subscenarios[0].__iter__ = Mock(return_value=iter([])) subscenarios[1].status = Status.failed subscenarios[1].__iter__ = Mock(return_value=iter([])) subscenarios[2].status = Status.failed subscenarios[2].__iter__ = Mock(return_value=iter([])) subscenarios[3].status = Status.skipped subscenarios[3].__iter__ = Mock(return_value=iter([])) scenarios[0]._scenarios = subscenarios scenarios[1].status = Status.failed scenarios[1].__iter__ = Mock(return_value=iter([])) scenarios[2].status = Status.skipped scenarios[2].__iter__ = Mock(return_value=iter([])) scenarios[3].status = Status.passed scenarios[3].__iter__ = Mock(return_value=iter([])) feature.status = Status.failed feature.duration = 12.4 feature.__iter__ = Mock(return_value=iter(scenarios)) config = Mock() sys.stdout.encoding = "UTF-8" reporter = SummaryReporter(config) reporter.feature(feature) reporter.end() expected = { Status.passed.name: 2, Status.failed.name: 3, Status.skipped.name: 2, Status.untested.name: 0, } eq_(format_summary.call_args_list[1][0], ('scenario', expected))
def test_magic_methods_and_spec_set(self): class Iterable(object): def __iter__(self): pass mock = Mock(spec_set=Iterable) self.assertRaises(AttributeError, lambda: mock.__iter__) mock.__iter__ = Mock(return_value=iter([])) self.assertEqual(list(mock), []) class NonIterable(object): pass mock = Mock(spec_set=NonIterable) self.assertRaises(AttributeError, lambda: mock.__iter__) def set_int(): mock.__int__ = Mock(return_value=iter([])) self.assertRaises(AttributeError, set_int) mock = MagicMock(spec_set=Iterable) self.assertEqual(list(mock), []) self.assertRaises(AttributeError, set_int)
def test_parses_feature_files_and_appends_to_feature_list(self, abspath, parse_file): feature_locations = ['one', 'two', 'three'] feature = Mock() feature.tags = [] feature.__iter__ = Mock(return_value=iter([])) feature.run.return_value = False self.runner.feature_locations.return_value = feature_locations abspath.side_effect = lambda x: x.upper() self.config.lang = 'fritz' self.config.format = ['plain'] self.config.outputs = [ StreamOpener(stream=sys.stdout) ] self.config.output.encoding = None self.config.exclude = lambda s: False self.config.junit = False self.config.summary = False parse_file.return_value = feature self.runner.run_with_paths() expected_parse_file_args = \ [((x.upper(),), {'language': 'fritz'}) for x in feature_locations] eq_(parse_file.call_args_list, expected_parse_file_args) eq_(self.runner.features, [feature] * 3)
#! coding: utf-8 from datetime import datetime from mock import patch, Mock #from itertools import permutations import itertools def real(name): for i in itertools.permutations(xrange(len(name))): print i #real("abcabcabcabc") with patch('itertools.permutations') as perm_mock: perm_mock.return_value = [ (0, 1, 2, 7, 5, 9, 11, 6, 10, 3, 8, 4), (0, 1, 2, 7, 5, 9, 11, 6, 10, 4, 3, 8) ] real("abcabcabcabc") mock_file = Mock() mock_file.name = 'my_filename.doc' mock_file.__iter__ = Mock(return_value = iter(['строка 1', 'строка 2', 'строка 3'])) stat = mock_file.stat.return_value stat.size, stat.access_time = 1000, datetime(2012, 1, 1) for line in mock_file: print line print mock_file print mock_file.name print mock_file.name2
def create_document_list(*docs): doc_list_mock = Mock() doc_list_mock.__iter__ = Mock() doc_list_mock.__iter__.return_value = iter(docs) return doc_list_mock