示例#1
0
class IsBoundWithTests(SynchronousTestCase):
    """
    Tests for :class:`otter.test.utils.IsBoundWith` class
    """
    def setUp(self):
        """
        Sample object
        """
        self.bound = IsBoundWith(a=10, b=20)

    def test_match_not_boundlog(self):
        """
        Does not match non `BoundLog`
        """
        m = self.bound.match('junk')
        self.assertEqual(m.describe(), 'log is not a BoundLog')

    def test_match_kwargs(self):
        """
        Returns None on matching kwargs
        """
        log = BoundLog(lambda: None, lambda: None).bind(a=10, b=20)
        self.assertIsNone(self.bound.match(log))

    def test_not_match_kwargs(self):
        """
        Returns mismatch on non-matching kwargs
        """
        log = BoundLog(lambda: None, lambda: None).bind(a=10, b=2)
        self.assertEqual(
            self.bound.match(log).describe(),
            'Expected kwargs {} but got {} instead'.format(
                dict(a=10, b=20), dict(a=10, b=2)))

    def test_nested_match(self):
        """
        works with Nested BoundLog
        """
        log = BoundLog(lambda: None, lambda: None).bind(a=10, b=20).bind(c=3)
        self.assertIsNone(IsBoundWith(a=10, b=20, c=3).match(log))

    def test_kwargs_order(self):
        """
        kwargs bound in order, i.e. next bound overriding previous bound should
        retain the value
        """
        log = BoundLog(lambda: None, lambda: None).bind(a=10, b=20).bind(a=3)
        self.assertIsNone(IsBoundWith(a=3, b=20).match(log))

    def test_str(self):
        """
        str(matcher) returns something useful
        """
        self.assertEqual(str(self.bound),
                         'IsBoundWith {}'.format(dict(a=10, b=20)))
示例#2
0
class IsBoundWithTests(SynchronousTestCase):
    """
    Tests for :class:`otter.test.utils.IsBoundWith` class
    """

    def setUp(self):
        """
        Sample object
        """
        self.bound = IsBoundWith(a=10, b=20)

    def test_match_not_boundlog(self):
        """
        Does not match non `BoundLog`
        """
        m = self.bound.match('junk')
        self.assertEqual(m.describe(), 'log is not a BoundLog')

    def test_match_kwargs(self):
        """
        Returns None on matching kwargs
        """
        log = BoundLog(lambda: None, lambda: None).bind(a=10, b=20)
        self.assertIsNone(self.bound.match(log))

    def test_not_match_kwargs(self):
        """
        Returns mismatch on non-matching kwargs
        """
        log = BoundLog(lambda: None, lambda: None).bind(a=10, b=2)
        self.assertEqual(
            self.bound.match(log).describe(),
            'Expected kwargs {} but got {} instead'.format(dict(a=10, b=20), dict(a=10, b=2)))

    def test_nested_match(self):
        """
        works with Nested BoundLog
        """
        log = BoundLog(lambda: None, lambda: None).bind(a=10, b=20).bind(c=3)
        self.assertIsNone(IsBoundWith(a=10, b=20, c=3).match(log))

    def test_kwargs_order(self):
        """
        kwargs bound in order, i.e. next bound overriding previous bound should
        retain the value
        """
        log = BoundLog(lambda: None, lambda: None).bind(a=10, b=20).bind(a=3)
        self.assertIsNone(IsBoundWith(a=3, b=20).match(log))

    def test_str(self):
        """
        str(matcher) returns something useful
        """
        self.assertEqual(str(self.bound), 'IsBoundWith {}'.format(dict(a=10, b=20)))
示例#3
0
 def test_merge_effectful_fields_no_log_with_context(self):
     """
     A log is returned with fields from the default otter log and the
     context when no log is passed.
     """
     result = merge_effectful_fields(self.disp, None)
     self.assertEqual(result, matches(IsBoundWith(f1='v', system='otter')))
示例#4
0
 def test_kwargs_order(self):
     """
     kwargs bound in order, i.e. next bound overriding previous bound should
     retain the value
     """
     log = BoundLog(lambda: None, lambda: None).bind(a=10, b=20).bind(a=3)
     self.assertIsNone(IsBoundWith(a=3, b=20).match(log))
示例#5
0
 def test_log_none_effectful_fields(self):
     """
     When log is not passed, but there are log fields from BoundFields,
     the log passed to treq has those fields.
     """
     log = mock_log()
     # we have to include system='otter' in the expected log here because
     # the code falls back to otter.log.log, which has the system key bound.
     expected_log = matches(IsBoundWith(bound='stuff', system='otter'))
     req = ('GET', 'http://google.com/', None, None, None, {
         'log': expected_log
     })
     response = StubResponse(200, {})
     treq = StubTreq(reqs=[(req, response)],
                     contents=[(response, "content")])
     req = Request(method="get", url="http://google.com/")
     req.treq = treq
     req_eff = Effect(req)
     bound_log_eff = with_log(req_eff, bound='stuff')
     dispatcher = ComposedDispatcher(
         [get_simple_dispatcher(None),
          get_log_dispatcher(log, {})])
     self.assertEqual(
         self.successResultOf(perform(dispatcher, bound_log_eff)),
         (response, "content"))
示例#6
0
 def test_merge_effectful_fields_log_and_context(self):
     """
     A log is returned with fields from both the passed-in log and the
     effectful context, with the latter taking precedence.
     """
     log = self.log.bind(f1='v2', passed_log=True)
     result = merge_effectful_fields(self.disp, log)
     self.assertEqual(result, matches(IsBoundWith(passed_log=True, f1='v')))
示例#7
0
 def test_delete_group_log_context(self):
     """
     When run in an effectful log context, the fields are bound to the log
     passed to get_scaling_group.
     """
     self.group.delete_group.return_value = succeed('del')
     expected_lookup = (matches(IsBoundWith(base_log=True, effectful=True)),
                        '00', 'g1')
     result = self.perform_with_group(
         Effect(DeleteGroup(tenant_id='00', group_id='g1')),
         expected_lookup, self.group,
         fallback_dispatcher=get_log_dispatcher(self.log,
                                                {'effectful': True}))
     self.assertEqual(result, 'del')
示例#8
0
    def test_get_scaling_group_info_log_context(self):
        """
        When run in an effectful log context, the fields are bound to the log
        passed to delete_group.
        """
        manifest = {}

        def view_manifest(with_policies, with_webhooks, get_deleting):
            return manifest
        self.group.view_manifest.side_effect = view_manifest
        eff = Effect(GetScalingGroupInfo(tenant_id='00', group_id='g1'))
        expected_lookup = (matches(IsBoundWith(base_log=True, effectful=True)),
                           '00', 'g1')
        result = self.perform_with_group(
            eff, expected_lookup, self.group,
            fallback_dispatcher=get_log_dispatcher(self.log,
                                                   {'effectful': True}))
        self.assertEqual(result, (self.group, manifest))
示例#9
0
    def test_event_executed(self):
        """
        Event is executed successfully and appropriate logs logged.
        """
        del_pol_ids = set()
        d = execute_event("disp", self.mock_store, self.log, self.event,
                          del_pol_ids)

        self.assertIsNone(self.successResultOf(d))
        self.log.msg.assert_called_once_with("sch-exec-pol",
                                             cloud_feed=True,
                                             **self.log_args)
        self.maybe_exec_policy.assert_called_once_with(
            matches(IsBoundWith(**self.log_args)),
            'transaction-id',
            self.mock_group,
            "state",
            policy_id=self.event['policyId'],
            version=self.event['version'])
        self.assertTrue(self.mock_mt.called)
        self.assertEqual(self.new_state, 'newstate')
        self.assertEqual(len(del_pol_ids), 0)
示例#10
0
 def test_log_effectful_fields(self):
     """
     The log passed to treq is bound with the fields from BoundFields.
     """
     log = mock_log().bind(duplicate='should be overridden')
     expected_log = matches(
         IsBoundWith(duplicate='effectful', bound='stuff'))
     req = ('GET', 'http://google.com/', None, None, None, {
         'log': expected_log
     })
     response = StubResponse(200, {})
     treq = StubTreq(reqs=[(req, response)],
                     contents=[(response, "content")])
     req = Request(method="get", url="http://google.com/", log=log)
     req.treq = treq
     req_eff = Effect(req)
     bound_log_eff = with_log(req_eff, bound='stuff', duplicate='effectful')
     dispatcher = ComposedDispatcher(
         [get_simple_dispatcher(None),
          get_log_dispatcher(log, {})])
     self.assertEqual(
         self.successResultOf(perform(dispatcher, bound_log_eff)),
         (response, "content"))
示例#11
0
    def test_execute_webhook(self):
        """
        Execute a webhook by hash returns a 202
        """
        self.mock_store.webhook_info_by_hash.return_value = defer.succeed(
            (self.tenant_id, self.group_id, self.policy_id))
        self.mock_controller.maybe_execute_scaling_policy.return_value = \
            defer.succeed(None)

        response_body = self.assert_status_code(202, '/v1.0/execute/1/11111/',
                                                'POST')

        self.mock_store.get_scaling_group.assert_called_once_with(
            mock.ANY, self.tenant_id, self.group_id)

        logargs = dict(tenant_id=self.tenant_id,
                       scaling_group_id=self.group_id,
                       policy_id=self.policy_id,
                       transaction_id='transaction-id',
                       capability_hash='11111',
                       capability_version='1',
                       system='otter.rest.webhooks.execute_webhook')
        self.mock_controller.modify_and_trigger.assert_called_once_with(
            "disp",
            self.mock_group,
            logargs,
            mock.ANY,
            modify_state_reason="execute_webhook")
        exec_pol = self.mock_controller.maybe_execute_scaling_policy
        exec_pol.assert_called_once_with(matches(IsBoundWith(**logargs)),
                                         'transaction-id',
                                         self.mock_group,
                                         self.mock_state,
                                         policy_id=self.policy_id)

        self.assertEqual(response_body, '')
示例#12
0
 def test_nested_match(self):
     """
     works with Nested BoundLog
     """
     log = BoundLog(lambda: None, lambda: None).bind(a=10, b=20).bind(c=3)
     self.assertIsNone(IsBoundWith(a=10, b=20, c=3).match(log))
示例#13
0
 def setUp(self):
     """
     Sample object
     """
     self.bound = IsBoundWith(a=10, b=20)