def test_listeners(): """`listeners()` returns a copied list of listeners.""" call_me = Mock() ee = BaseEventEmitter() @ee.on('event') def event_handler(): pass @ee.once('event') def once_handler(): pass listeners = ee.listeners('event') assert listeners[0] == event_handler assert listeners[1] == once_handler # listeners is a copy, you can't mutate the innards this way listeners[0] = call_me ee.emit('event') call_me.assert_not_called()
def test_change_day_in_battle(self): mock_process = Mock() f = FieldClock() field = MagicMock(in_battle=True, process_battle_and_movement=mock_process) f.change_day(field) mock_process.assert_not_called()
def test_callbacks_and_pool_when_oto(self): """ Test to ensure the callbacks are correcltly called and the connection is returned when there is an OTO @since 3.12 @jira_ticket PYTHON-630 @expected_result the connection is correctly returned to the pool after an OTO, also the only the errback is called and not the callback when the message finally arrives. @test_category metadata """ start_and_prime_singledc() cluster = Cluster(protocol_version=PROTOCOL_VERSION, compression=False) session = cluster.connect() self.addCleanup(cluster.shutdown) query_to_prime = "SELECT * from testkesypace.testtable" server_delay = 2 # seconds prime_query(query_to_prime, then={"delay_in_ms": server_delay * 1000}) future = session.execute_async(query_to_prime, timeout=1) callback, errback = Mock(name='callback'), Mock(name='errback') future.add_callbacks(callback, errback) self.assertRaises(OperationTimedOut, future.result) assert_quiescent_pool_state(self, cluster) time.sleep(server_delay + 1) # PYTHON-630 -- only the errback should be called errback.assert_called_once() callback.assert_not_called()
def test_command_has_no_sub___action_from_command_is_called(self, action_res, other_action_res, sub_parser_names, command_name): selected = choice(sub_parser_names) action_mock = Mock(return_value=action_res) other_action_mock = Mock(return_value=other_action_res) class SubCmd(cmd.Base): def action(self, args): return action_mock(args) class OtherSubCmd(cmd.Base): def action(self, args): return other_action_mock(args) class Cmd(cmd.Base): sub_commands = dict( (n, (SubCmd if n == selected else OtherSubCmd)) for n in sub_parser_names ) sys.argv = ['foo', selected] command = Cmd(command_name) res = command.run() self.assertEqual(res, action_res) action_mock.assert_called_once_with(command.parse_args()) other_action_mock.assert_not_called()
def test_execute_with_ids(self): engine = Mock() engine.log = Mock() engine.log.info = MagicMock() engine.log.failed = MagicMock() topics1 = [Mock()] get_topics_mock1 = Mock(return_value=topics1) topics2 = [] get_topics_mock2 = Mock(return_value=topics2) execute_mock1 = Mock() # Exception shouldn't be thrown because there are no tocpis for plugin execute_mock2 = Mock(return_value=Exception) self.tracker1.execute = execute_mock1 self.tracker1.get_topics = get_topics_mock1 self.tracker2.execute = execute_mock2 self.tracker2.get_topics = get_topics_mock2 ids = [1, 2] self.trackers_manager.execute(engine, ids) self.assertTrue(engine.log.info.called) self.assertFalse(engine.log.failed.called) # Check that exception from tracker2 wasn't raised get_topics_mock1.assert_called_with(ids) execute_mock1.assert_called_with(topics1, engine) get_topics_mock2.assert_called_with(ids) execute_mock2.assert_not_called()
def test_init_adds_members(self): mock_connection = Mock() obj = type('TestType', (ObjectProxy,), {})(mock_connection, ['a:get', 'a:set', 'setTest']) self.assertTrue(hasattr(type(obj), 'a')) self.assertTrue(hasattr(obj, 'setTest')) mock_connection.assert_not_called()
def test_lazylist_map_no_call(): mock_func = Mock() double_func = lambda x: x * 2 ll = LazyList([mock_func]) ll_mapped = ll.map(double_func) assert id(ll) != id(ll_mapped) mock_func.assert_not_called()
def test_keyspace_flag_raises_before_v5(self): keyspace_message = QueryMessage('a', consistency_level=3, keyspace='ks') io = Mock(name='io') with self.assertRaisesRegexp(UnsupportedOperation, 'Keyspaces.*set'): keyspace_message.send_body(io, protocol_version=4) io.assert_not_called()
def test_enforce_hostname_middleware(): get_resp_mock = Mock() mw = EnforceHostnameMiddleware(get_resp_mock) req = RequestFactory().get('/', HTTP_HOST='basket.mozilla.org') resp = mw(req) get_resp_mock.assert_called_once_with(req) get_resp_mock.reset_mock() req = RequestFactory().get('/', HTTP_HOST='basket.allizom.org') resp = mw(req) get_resp_mock.assert_not_called() assert resp.status_code == 301 assert resp['location'] == 'http://basket.mozilla.org/' # IP address should not redirect get_resp_mock.reset_mock() req = RequestFactory().get('/', HTTP_HOST='123.123.123.123') resp = mw(req) get_resp_mock.assert_called_once_with(req) # IP with port should also work get_resp_mock.reset_mock() req = RequestFactory().get('/', HTTP_HOST='1.2.3.4:12345') resp = mw(req) get_resp_mock.assert_called_once_with(req)
def test_update(self, include_prerelease, is_started, start_interval, enabled, interval, start_called, stop_called): checker = NewVersionChecker(False) def start_side_effect(i): checker.interval = i start_mock = Mock(side_effect=start_side_effect) stop_mock = Mock() is_started_mock = Mock(return_value=is_started) checker.interval = start_interval checker.start = start_mock checker.stop = stop_mock checker.is_started = is_started_mock checker.update(include_prerelease, enabled, interval) self.assertEqual(checker.interval, interval) self.assertEqual(checker.include_prereleases, include_prerelease) if start_called: start_mock.assert_called_once_with(interval) else: start_mock.assert_not_called() if stop_called: stop_mock.assert_called_once() else: stop_mock.assert_not_called()
def report_changed_test(self): """Test reporting changed properties.""" test1 = self.Test1() callback = Mock() test1.PropertiesChanged.connect(callback) test1.flush_changes() callback.assert_not_called() test1.report_changed_property("A") test1.flush_changes() callback.assert_called_once_with("I1", {"A": 1}, []) callback.reset_mock() test1.report_changed_property("B") test1.flush_changes() callback.assert_called_once_with("I1", {"B": 2}, []) callback.reset_mock() test1.report_changed_property("B") test1.report_changed_property("A") test1.flush_changes() callback.assert_called_once_with("I1", {"A": 1, "B": 2}, []) callback.reset_mock()
def test_DBExporter(): path = u'apa/movie' xt = u'tree:tiger:ASDASDSADASDASDSADASDASDSADASDASDSADASD' db = DB(':memory:') db.update(Object(u"dir:apa", { u'directory': ValueSet(u"dir:/apa"), })) db.update(Object('some_file', { u'directory': ValueSet(u"dir:apa/movie"), u'xt': ValueSet(xt), })) asset = Mock() asset.__enter__ = Mock(return_value=asset) asset.__exit__ = Mock(return_value=False) asset.status = Mock( return_value=proto.AssetStatus(status=proto.SUCCESS)) bithorde = Mock() bithorde.open = Mock(return_value=asset) bithorde.pool = Mock(return_value=itertools) writer = Mock() magnet = u'magnet:?xt=urn:' + xt exp = links.DBExporter(db, bithorde, writer) exp.export(False) writer.assert_called_once_with(path, magnet) writer.reset_mock() exp.export(False) writer.assert_not_called() exp.export(True) writer.assert_called_once_with(path, magnet)
def test__play_card(self): board = Mock() self.p.play_card(board) self.assertEqual(self.p.gold, 9) board.assert_not_called() self.sp.play_card(board) self.assertEqual(self.sp.gold, 8) board.assert_not_called()
def test_ecr_login_image_exists(_check_output): session_mock = Mock() image = '520713654638.dkr.ecr.us-east-1.amazonaws.com/image-i-have:1.0' sagemaker.local.image._ecr_login_if_needed(session_mock, image) session_mock.assert_not_called() _check_output.assert_called()
def test__del__0(self): self.ftp.connected = Mock(return_value=False) m_disconnect = Mock() self.ftp.disconnect = m_disconnect del(self.ftp) m_disconnect.assert_not_called()
def test_must_do_nothing(self): # Parameter references are not resolved by GetAtt input = "foo" expected = "foo" supported_resource_refs = Mock() self.assertEqual(expected, GetAttAction().resolve_parameter_refs(input, supported_resource_refs)) supported_resource_refs.assert_not_called()
def test_add_empty_noop(self): m = Mock() lc, parent, slug = self.link_collection([]) lc.add([]) parent.http_post.assert_not_called() for _ in lc: m() m.assert_not_called()
def test_lazylist_copy_lazy(): mock_func = Mock() mock_func.return_value = 1 ll = LazyList([mock_func] * 10) copied_ll = ll.copy() assert len(copied_ll) == 10 assert id(ll._callables) != id(copied_ll._callables) mock_func.assert_not_called()
def test_only_call_actions(self): self.options['-invoke'] = True invoke = Mock() self.dispatcher._invoke = invoke dispatch(self.options, self.dispatcher) invoke.assert_not_called()
def test_upgrade_where_subscription_save_fails_at_first(self, create_customer: mock.Mock) -> None: user = self.example_user("hamlet") self.login(user.email) with mock.patch('stripe.Subscription.create', side_effect=stripe.error.CardError('message', 'param', 'code', json_body={})): self.client_post("/upgrade/", {'stripeToken': self.token, 'signed_seat_count': self.signed_seat_count, 'salt': self.salt, 'plan': Plan.CLOUD_ANNUAL}) # Check that we created a customer in stripe create_customer.assert_called() create_customer.reset_mock() # Check that we created a Customer with has_billing_relationship=False self.assertTrue(Customer.objects.filter( stripe_customer_id=self.stripe_customer_id, has_billing_relationship=False).exists()) # Check that we correctly populated RealmAuditLog audit_log_entries = list(RealmAuditLog.objects.filter(acting_user=user) .values_list('event_type', flat=True).order_by('id')) self.assertEqual(audit_log_entries, [RealmAuditLog.STRIPE_CUSTOMER_CREATED, RealmAuditLog.STRIPE_CARD_ADDED]) # Check that we did not update Realm realm = get_realm("zulip") self.assertFalse(realm.has_seat_based_plan) # Check that we still get redirected to /upgrade response = self.client_get("/billing/") self.assertEqual(response.status_code, 302) self.assertEqual('/upgrade/', response.url) # mock_create_customer just returns a customer with no subscription object with mock.patch("stripe.Subscription.create", side_effect=mock_customer_with_subscription): with mock.patch("stripe.Customer.retrieve", side_effect=mock_create_customer): with mock.patch("stripe.Customer.save", side_effect=mock_create_customer): self.client_post("/upgrade/", {'stripeToken': self.token, 'signed_seat_count': self.signed_seat_count, 'salt': self.salt, 'plan': Plan.CLOUD_ANNUAL}) # Check that we do not create a new customer in stripe create_customer.assert_not_called() # Impossible to create two Customers, but check that we updated has_billing_relationship self.assertTrue(Customer.objects.filter( stripe_customer_id=self.stripe_customer_id, has_billing_relationship=True).exists()) # Check that we correctly populated RealmAuditLog audit_log_entries = list(RealmAuditLog.objects.filter(acting_user=user) .values_list('event_type', flat=True).order_by('id')) self.assertEqual(audit_log_entries, [RealmAuditLog.STRIPE_CUSTOMER_CREATED, RealmAuditLog.STRIPE_CARD_ADDED, RealmAuditLog.STRIPE_CARD_ADDED, RealmAuditLog.STRIPE_PLAN_CHANGED, RealmAuditLog.REALM_PLAN_TYPE_CHANGED]) # Check that we correctly updated Realm realm = get_realm("zulip") self.assertTrue(realm.has_seat_based_plan) # Check that we can no longer access /upgrade response = self.client_get("/upgrade/") self.assertEqual(response.status_code, 302) self.assertEqual('/billing/', response.url)
def test_areyousure_no(self): yes = Mock() no = Mock() yes_func, no_func = self.sut.areyousure(yes, no) no_func() no.assert_called_once() self.widget.escape.assert_called_once() yes.assert_not_called()
def test_no_apply_to_directories_not_matching(self): """Don't apply to directories.""" with testutil.in_tempdir(os.getcwd(), "file_patterns") as temp_dir: with testutil.in_tempdir(os.getcwd(), "matched"): function_applied = Mock() util.apply_to_directories(function_applied, temp_dir, matching=["{0}/*".format("other")]) function_applied.assert_not_called() # suppress(PYC70)
def test_format_magic_method_without_regex_simple(self): m = Mock() s = XFormatUnicode(u'thiago fraz\xe3o') s._do_formatting = m s._do_formatting.return_value = '' ret = u'bla {0}'.format(s) m.assert_not_called() self.assertEquals(ret, 'bla ' + s)
def test_format_magic_method_without_regex_complex(self): m = Mock() s = XFormatUnicode(u'bla') s._do_formatting = m s._do_formatting.return_value = '' ret = u'{0:^10}'.format(s) m.assert_not_called() self.assertEquals(ret, ' bla ')
def test_downgrade_with_no_subscription( self, mock_retrieve_customer: Mock, mock_save_customer: Mock) -> None: realm = get_realm('zulip') Customer.objects.create( realm=realm, stripe_customer_id=self.stripe_customer_id, has_billing_relationship=True) self.login(self.example_email('iago')) response = self.client_post("/json/billing/downgrade", {}) self.assert_json_error_contains(response, 'Please reload') self.assertEqual(ujson.loads(response.content)['error_description'], 'downgrade without subscription') mock_save_customer.assert_not_called()
def test_uses_celery(self, shared_task): with patch.object(settings, 'ASYNC_TASK', new=AsyncTask.CELERY.value): func = Mock() task = Task(func) task(1, a=2) func.assert_not_called() shared_task.assert_called_once_with(func) self.assertEqual(shared_task.return_value, task.target) shared_task.return_value.delay.assert_called_once_with(1, a=2)
def test_must_skip_invalid_input_dict(self, sub_all_refs_mock): input = {"a": "b"} expected = {"a": "b"} handler_mock = Mock() sub = SubAction() result = sub._handle_sub_value(input, handler_mock) self.assertEqual(expected, result) handler_mock.assert_not_called() sub_all_refs_mock.assert_not_called()
def test_handle_sub_value_must_skip_no_string(self, sub_all_refs_mock): input = [{"a":"b"}] expected = [{"a":"b"}] handler_mock = Mock() sub = SubAction() result = sub._handle_sub_value(input, handler_mock) self.assertEqual(expected, result) handler_mock.assert_not_called() sub_all_refs_mock.assert_not_called()
def test_bad_request_missed_required_field_set_pause_state(self): set_topic_paused_mock = Mock(side_effect=KeyError) self.tracker_manager.set_topic_paused = set_topic_paused_mock topic_parse = TopicPauseState(self.tracker_manager) self.api.add_route('/api/topic/{id}/pause', topic_parse) self.simulate_request("/api/topic/{0}/pause".format(1), method="POST", body=json.dumps({'wrong': 'value'})) self.assertEqual(self.srmock.status, falcon.HTTP_BAD_REQUEST) set_topic_paused_mock.assert_not_called()
def test_uses_threading(self, Thread): with patch.object(settings, 'ASYNC_TASK', new=AsyncTask.THREADING.value): func = Mock() task = Task(func) task(1, a=2) func.assert_not_called() Thread.assert_called_once_with(target=func, args=(1,), kwargs={'a': 2}) thread = Thread.return_value self.assertTrue(thread.daemon) thread.start.assert_called_once()
class TestECSServiceCPUAlarm_load_aws_obj(unittest.TestCase): def setUp(self): aws_data = { 'AlarmName': 'my_cluster-my_service-high', 'AlarmArn': 'actual_aws_alarm_arn', 'AlarmDescription': 'Scale up ECS service my_service in cluster my_cluster if Service Average CPU ' 'is >=60 for 300 seconds', 'AlarmConfigurationUpdatedTimestamp': datetime(2015, 1, 1), 'ActionsEnabled': True, 'OKActions': [], 'AlarmActions': [ 'arn:aws:something:something', ], 'InsufficientDataActions': [], 'StateValue': 'OK', 'StateReason': 'string', 'StateReasonData': 'string', 'StateUpdatedTimestamp': datetime(2015, 1, 1), 'MetricName': 'CPUUtilization', 'Namespace': 'AWS/ECS', 'Statistic': 'Average', 'Dimensions': [ { 'Name': 'ClusterName', 'Value': 'my_cluster' }, { 'Name': 'ServiceName', 'Value': 'my_service' }, ], 'Period': 60, 'Unit': 'Percent', 'EvaluationPeriods': 5, 'Threshold': 60.0, 'ComparisonOperator': 'GreaterThanOrEqualToThreshold' } cloudwatch_client = Mock() self.describe_alarms = Mock() cloudwatch_client.describe_alarms = self.describe_alarms cloudwatch_client.describe_alarms.return_value = aws_data cloudwatch_client.list_metrics = Mock() cloudwatch_client.list_metrics.return_value = {'Metrics': []} client = Mock() client.return_value = cloudwatch_client with Replacer() as r: r('boto3.client', client) self.alarm = ECSServiceCPUAlarm('my_service', 'my_cluster', aws=aws_data) def test_arn(self): self.assertEqual(self.alarm.arn, 'actual_aws_alarm_arn') def test_name(self): self.assertEqual(self.alarm.name, 'my_cluster-my_service-high') def test_cpu(self): self.assertEqual(self.alarm.cpu, ">=60.0") def test_check_every_seconds(self): self.assertEqual(self.alarm.check_every_seconds, 60) def test_check_every_periods(self): self.assertEqual(self.alarm.periods, 5) def test_describe_alarms_not_called(self): self.describe_alarms.assert_not_called()
def test_dont_run_function_if_python_module_available(self): """Function not executed when python module available.""" mock = Mock() python_util.run_if_module_unavailable("sys", mock) mock.assert_not_called() # suppress(PYC70)