Example #1
0
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()
Example #2
0
 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()
Example #4
0
    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()
Example #8
0
    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()
Example #9
0
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()
Example #11
0
    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()
Example #12
0
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)
Example #13
0
 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()
Example #15
0
    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()
Example #19
0
    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()
Example #20
0
    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)
Example #21
0
    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)
Example #23
0
    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)
Example #24
0
    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    ')
Example #25
0
 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()
Example #26
0
    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()
Example #29
0
    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()
Example #30
0
    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()
Example #31
0
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)