Beispiel #1
0
    def test_body_assertion_var_failed(self):
        # Given
        response_body = 'Unexpected value'
        expected = 'Expected var value'
        config = Config.from_dict(
            {
                'host': 'host',
                'vars': {
                    'some_var': expected
                }
            },
            __file__,
        )
        spec = {
            'type': 'body',
            'value': {
                'type': 'ref',
                'var': 'some_var'
            },
        }
        assertion = BodyAssertion.from_dict(spec)
        case = MockTestCase()
        response = Mock()
        response.text = response_body

        # When
        assertion.run(config, 'url', case, response)

        # Then
        self.assertEqual(case.assertEqual.call_count, 1)
        call = case.assertEqual.call_args
        args, kwargs = call
        self.assertEqual(args, (response_body, expected))
        self.assertIn('msg', kwargs)
Beispiel #2
0
    def test_sha256_assertion_failure(self):
        # Given
        url = 'http://localhost'
        expected = hashlib.sha256('data'.encode('ascii')).hexdigest()
        body = 'other-data'.encode('ascii')
        actual = hashlib.sha256(body).hexdigest()
        responses.add(
            responses.GET,
            url,
            body=body,
            status=200,
        )
        response = requests.get(url)

        config = Config.from_dict({'host': 'host'}, __file__)
        spec = {
            'type': 'sha256',
            'expected': expected,
        }
        assertion = Sha256BodyAssertion.from_dict(spec)
        case = MockTestCase()

        # When
        assertion.run(config, url, case, response)

        # Then
        self.assertEqual(case.assertEqual.call_count, 1)
        call = case.assertEqual.call_args
        args, kwargs = call
        self.assertEqual(args, (actual, expected))
        self.assertIn('msg', kwargs)
Beispiel #3
0
    def test_body_from_var(self):
        # Given
        config = Config.from_dict(
            {
                'host': 'name.domain',
                'vars': {
                    'data': 'some-data',
                },
            }, __file__)
        spec = {
            'body': {
                'format': 'plain',
                'value': {
                    'type': 'ref',
                    'var': 'data'
                },
            },
        }
        parameter = BodyTestParameter.from_dict(spec)
        expected = {
            'headers': {
                'Content-Type': 'text/plain'
            },
            'data': 'some-data',
        }

        # When
        with parameter.load(config) as loaded:
            # Then
            self.assertEqual(loaded, expected)
Beispiel #4
0
    def test_body_from_var(self):
        # Given
        config = Config.from_dict(
            {
                'host': 'name.domain',
                'vars': {
                    'data': 'some-data',
                },
            },
            __file__)
        spec = {
            'body': {
                'format': 'plain',
                'value': {'type': 'ref', 'var': 'data'},
            },
        }
        parameter = BodyTestParameter.from_dict(spec)
        expected = {
            'headers': {'Content-Type': 'text/plain'},
            'data': 'some-data',
        }

        # When
        with parameter.load(config) as loaded:
            # Then
            self.assertEqual(loaded, expected)
Beispiel #5
0
    def test_sha256_assertion_failure(self):
        # Given
        url = 'http://localhost'
        expected = hashlib.sha256('data'.encode('ascii')).hexdigest()
        body = 'other-data'.encode('ascii')
        actual = hashlib.sha256(body).hexdigest()
        responses.add(
            responses.GET,
            url,
            body=body,
            status=200,
        )
        response = requests.get(url)

        config = Config.from_dict({'host': 'host'}, __file__)
        spec = {
            'type': 'sha256',
            'expected': expected,
        }
        assertion = Sha256BodyAssertion.from_dict(spec)
        case = MockTestCase()

        # When
        assertion.run(config, url, case, response)

        # Then
        self.assertEqual(case.assertEqual.call_count, 1)
        call = case.assertEqual.call_args
        args, kwargs = call
        self.assertEqual(args, (actual, expected))
        self.assertIn('msg', kwargs)
Beispiel #6
0
    def test_load_variable(self):
        # Given
        config = Config.from_dict(
            {
                'host': 'name.domain',
                'vars': {
                    'some_var': 'application/json',
                },
            },
            __file__)
        spec = {
            'headers': {
                'Content-Type': {
                    'type': 'ref',
                    'var': 'some_var',
                },
            },
        }
        parameter = HeadersTestParameter.from_dict(spec)
        expected = {'headers': {'Content-Type': 'application/json'}}

        # When
        with parameter.load(config) as loaded:
            # Then
            self.assertEqual(loaded, expected)
Beispiel #7
0
    def test_no_expected_value(self):
        # Given
        config = Config.from_dict({'host': 'host'}, __file__)
        response = Mock()
        response.headers = {'Content-Type': 'application/json'}
        spec = {
            'name': 'header',
            'header': 'Content-Type',
        }

        # When
        assertion = HeaderAssertion.from_dict(spec)

        # Then
        self.assertEqual(assertion.header, spec['header'])
        self.assertEqual(assertion.expected_value, None)
        self.assertEqual(assertion.regexp, False)

        # When
        case = MockTestCase()
        assertion.run(config, 'http://host/uri', case, response)

        # Then
        self.assertEqual(case.assertIn.call_count, 1)
        call = case.assertIn.call_args
        args, kwargs = call
        self.assertEqual(args, (spec['header'], response.headers))
        self.assertIn('msg', kwargs)

        self.assertFalse(case.assertRegexpMatches.called)
        self.assertFalse(case.assertEqual.called)
Beispiel #8
0
    def test_body_yaml(self):
        # Given
        config = Config.from_dict({'host': 'name.domain'}, __file__)
        spec = {
            'body': {
                'format': 'yaml',
                'lookup-var': False,
                'value': {'param': ['value1', 'value2']},
            },
        }
        parameter = BodyTestParameter.from_dict(spec)
        expected = {
            'headers': {'Content-Type': 'application/yaml'},
            'data': textwrap.dedent(
                """\
                param:
                - value1
                - value2
                """
            ),
        }

        # When
        with parameter.load(config) as loaded:
            # Then
            self.assertEqual(loaded, expected)
Beispiel #9
0
    def test_create_multipart_file(self):
        # Given
        config = Config.from_dict({'host': 'name.domain'}, self.test_filename)
        multipart_body = {
            'field1': {
                'filename': self.absolute_filename,
            },
            'field2': {
                'filename': self.relative_filename,
            },
        }
        spec = {
            'body': {
                'format': 'multipart',
                'value': multipart_body,
            },
        }

        loader = BodyTestParameter.from_dict(spec)

        # When
        with loader.load(config) as loaded:
            # Then
            self.assertIn('files', loaded)
            self.assertNotIn('headers', loaded)
            data = loaded['files']
            self.assertIn('field1', data)
            self.assertIn('field2', data)

            fh1 = data['field1']
            self.assertEqual(fh1.name, self.absolute_filename)

            fh2 = data['field2']
            self.assertEqual(fh2.name, self.absolute_filename)
Beispiel #10
0
    def test_create_multipart_file(self):
        # Given
        config = Config.from_dict({'host': 'name.domain'}, self.test_filename)
        multipart_body = {
            'field1': {
                'filename': self.absolute_filename,
            },
            'field2': {
                'filename': self.relative_filename,
            },
        }
        spec = {
            'body': {
                'format': 'multipart',
                'value': multipart_body,
            },
        }

        loader = BodyTestParameter.from_dict(spec)

        # When
        with loader.load(config) as loaded:
            # Then
            self.assertIn('files', loaded)
            self.assertNotIn('headers', loaded)
            data = loaded['files']
            self.assertIn('field1', data)
            self.assertIn('field2', data)

            fh1 = data['field1']
            self.assertEqual(fh1.name, self.absolute_filename)

            fh2 = data['field2']
            self.assertEqual(fh2.name, self.absolute_filename)
Beispiel #11
0
    def test_load(self):
        # Given
        config = Config.from_dict({'host': 'name.domain'}, __file__)
        expected = {
            'params': {
                'str': 'string value',
                'int': 5,
                'float': 5.2,
                'bool': False,
            },
        }
        spec = {
            'queryparams': {
                'str': 'string value',
                'int': 5,
                'float': 5.2,
                'bool': False,
            },
        }

        loader = QueryParamsTestParameter.from_dict(spec)

        # When
        with loader.load(config) as loaded:
            self.assertEqual(loaded, expected)
Beispiel #12
0
    def test_load(self):
        # Given
        config = Config.from_dict({'host': 'name.domain'}, __file__)
        expected = {
            'params': {
                'str': 'string value',
                'int': 5,
                'float': 5.2,
                'bool': False,
            },
        }
        spec = {
            'queryparams': {
                'str': 'string value',
                'int': 5,
                'float': 5.2,
                'bool': False,
            },
        }

        loader = QueryParamsTestParameter.from_dict(spec)

        # When
        with loader.load(config) as loaded:
            self.assertEqual(loaded, expected)
Beispiel #13
0
    def test_no_expected_value(self):
        # Given
        config = Config.from_dict({'host': 'host'}, __file__)
        response = Mock()
        response.headers = {
            'Content-Type': 'application/json'
        }
        spec = {
            'name': 'header',
            'header': 'Content-Type',
        }

        # When
        assertion = HeaderAssertion.from_dict(spec)

        # Then
        self.assertEqual(assertion.header, spec['header'])
        self.assertEqual(assertion.expected_value, None)
        self.assertEqual(assertion.regexp, False)

        # When
        case = MockTestCase()
        assertion.run(config, 'http://host/uri', case, response)

        # Then
        self.assertEqual(case.assertIn.call_count, 1)
        call = case.assertIn.call_args
        args, kwargs = call
        self.assertEqual(args, (spec['header'], response.headers))
        self.assertIn('msg', kwargs)

        self.assertFalse(case.assertRegexpMatches.called)
        self.assertFalse(case.assertEqual.called)
Beispiel #14
0
    def test_body_yaml(self):
        # Given
        config = Config.from_dict({'host': 'name.domain'}, __file__)
        spec = {
            'body': {
                'format': 'yaml',
                'lookup-var': False,
                'value': {
                    'param': ['value1', 'value2']
                },
            },
        }
        parameter = BodyTestParameter.from_dict(spec)
        expected = {
            'headers': {
                'Content-Type': 'application/yaml'
            },
            'data':
            textwrap.dedent("""\
                param:
                - value1
                - value2
                """),
        }

        # When
        with parameter.load(config) as loaded:
            # Then
            self.assertEqual(loaded, expected)
Beispiel #15
0
    def test_body_assertion_var_failed(self):
        # Given
        response_body = 'Unexpected value'
        expected = 'Expected var value'
        config = Config.from_dict(
            {'host': 'host', 'vars': {'some_var': expected}},
            __file__,
        )
        spec = {
            'type': 'body',
            'value': {'type': 'ref', 'var': 'some_var'},
        }
        assertion = BodyAssertion.from_dict(spec)
        case = MockTestCase()
        response = Mock()
        response.text = response_body

        # When
        assertion.run(config, 'url', case, response)

        # Then
        self.assertEqual(case.assertEqual.call_count, 1)
        call = case.assertEqual.call_args
        args, kwargs = call
        self.assertEqual(args, (response_body, expected))
        self.assertIn('msg', kwargs)
Beispiel #16
0
    def test_load(self):
        # Given
        config = Config.from_dict({'host': 'name.domain'}, __file__)
        spec = {'headers': {'Content-Type': 'application/json'}}
        parameter = HeadersTestParameter.from_dict(spec)

        # When
        with parameter.load(config) as loaded:
            # Then
            self.assertEqual(loaded, spec)
Beispiel #17
0
    def test_load(self):
        # Given
        config = Config.from_dict({'host': 'name.domain'}, __file__)
        spec = {'headers': {'Content-Type': 'application/json'}}
        parameter = HeadersTestParameter.from_dict(spec)

        # When
        with parameter.load(config) as loaded:
            # Then
            self.assertEqual(loaded, spec)
Beispiel #18
0
    def test_load(self):
        # Given
        config = Config.from_dict({'host': 'name.domain'}, __file__)
        spec = {'method': 'POST'}
        parameter = MethodTestParameter.from_dict(spec)

        # When
        with parameter.load(config) as loaded:
            # Then
            self.assertEqual(loaded, spec)
Beispiel #19
0
    def test_load(self):
        # Given
        config = Config.from_dict({'host': 'name.domain'}, __file__)
        spec = {'method': 'POST'}
        parameter = MethodTestParameter.from_dict(spec)

        # When
        with parameter.load(config) as loaded:
            # Then
            self.assertEqual(loaded, spec)
Beispiel #20
0
    def test_body_assertion_jq_filter(self):
        # Given
        config = Config.from_dict({'host': 'host'}, __file__)
        value = {
            'object1': {
                'dynamic': 1,
                'static': 'Value1',
            },
            'object2': {
                'dynamic': 2,
                'static': 'Value2',
            },
        }
        expected = value.copy()
        for key, obj in value.items():
            # Deliberately not deterministic
            obj['dynamic'] = obj['dynamic'] + time.time()
        spec = {
            'type': 'body',
            'format': 'json',
            'value': expected,
            'lookup-var': False,
            # Filter to remove the non-deterministic value from
            # response and assertion value
            'filter': 'with_entries(del(.value.dynamic))',
        }
        assertion = BodyAssertion.from_dict(spec)
        case = MockTestCase()
        response = Mock()
        response.json.return_value = value

        expected_call = {
            'object1': {
                'static': 'Value1',
            },
            'object2': {
                'static': 'Value2',
            },
        }

        # When
        assertion.run(config, 'url', case, response)

        # Then
        self.assertEqual(case.assertEqual.call_count, 1)
        call = case.assertEqual.call_args
        args, kwargs = call
        self.assertEqual(args, (expected_call, expected_call))
        self.assertIn('msg', kwargs)
Beispiel #21
0
    def test_body_assertion_jq_filter(self):
        # Given
        config = Config.from_dict({'host': 'host'}, __file__)
        value = {
            'object1': {
                'dynamic': 1,
                'static': 'Value1',
            },
            'object2': {
                'dynamic': 2,
                'static': 'Value2',
            },
        }
        expected = value.copy()
        for key, obj in value.items():
            # Deliberately not deterministic
            obj['dynamic'] = obj['dynamic'] + time.time()
        spec = {
            'type': 'body',
            'format': 'json',
            'value': expected,
            'lookup-var': False,
            # Filter to remove the non-deterministic value from
            # response and assertion value
            'filter': 'with_entries(del(.value.dynamic))',
        }
        assertion = BodyAssertion.from_dict(spec)
        case = MockTestCase()
        response = Mock()
        response.json.return_value = value

        expected_call = {
            'object1': {
                'static': 'Value1',
            },
            'object2': {
                'static': 'Value2',
            },
        }

        # When
        assertion.run(config, 'url', case, response)

        # Then
        self.assertEqual(case.assertEqual.call_count, 1)
        call = case.assertEqual.call_args
        args, kwargs = call
        self.assertEqual(args, (expected_call, expected_call))
        self.assertIn('msg', kwargs)
Beispiel #22
0
    def test_load_missing_variable(self):
        # Given
        config = Config.from_dict({'host': 'name.domain'}, __file__)
        spec = {
            'headers': {
                'Content-Type': {
                    'type': 'ref',
                    'var': 'none',
                },
            },
        }
        parameter = HeadersTestParameter.from_dict(spec)

        # When/Then
        with self.assertRaises(InvalidVariable):
            with parameter.load(config):
                pass
Beispiel #23
0
    def test_valid_assertion(self):
        # Given
        config = Config.from_dict({'host': 'host'}, __file__)
        response = Mock()
        response.status_code = 200
        case = MockTestCase()
        assertion = StatusCodeAssertion(200)

        # When
        assertion.run(config, 'http://host/uri', case, response)

        # Then
        self.assertEqual(case.assertEqual.call_count, 1)
        call = case.assertEqual.call_args
        args, kwargs = call
        self.assertEqual(args, (200, 200))
        self.assertIn('msg', kwargs)
Beispiel #24
0
    def test_valid_assertion(self):
        # Given
        config = Config.from_dict({'host': 'host'}, __file__)
        response = Mock()
        response.status_code = 200
        case = MockTestCase()
        assertion = StatusCodeAssertion(200)

        # When
        assertion.run(config, 'http://host/uri', case, response)

        # Then
        self.assertEqual(case.assertEqual.call_count, 1)
        call = case.assertEqual.call_args
        args, kwargs = call
        self.assertEqual(args, (200, 200))
        self.assertIn('msg', kwargs)
Beispiel #25
0
    def test_load_missing_variable(self):
        # Given
        config = Config.from_dict({'host': 'name.domain'}, __file__)
        spec = {
            'headers': {
                'Content-Type': {
                    'type': 'ref',
                    'var': 'none',
                },
            },
        }
        parameter = HeadersTestParameter.from_dict(spec)

        # When/Then
        with self.assertRaises(InvalidVariable):
            with parameter.load(config):
                pass
Beispiel #26
0
    def test_assert_expected_regexp_failure(self):
        # Given
        config = Config.from_dict({'host': 'host'}, __file__)
        content_type = 'text/github.v3+json'
        expected_content_type = 'application/.*?json'
        response = Mock()
        response.headers = {
            'Content-Type': content_type,
        }
        spec = {
            'name': 'header',
            'header': 'Content-Type',
            'regexp': expected_content_type,
        }

        # When
        assertion = HeaderAssertion.from_dict(spec)

        # Then
        self.assertEqual(assertion.header, spec['header'])
        self.assertEqual(
            assertion.expected_value, re.compile(expected_content_type))
        self.assertEqual(assertion.regexp, True)

        # When
        case = MockTestCase()
        case.assertRegexpMatches.side_effect = AssertionError
        with self.assertRaises(AssertionError):
            assertion.run(config, 'http://host/uri', case, response)

        # Then
        self.assertEqual(case.assertIn.call_count, 1)
        call = case.assertIn.call_args
        args, kwargs = call
        self.assertEqual(args, (spec['header'], response.headers))
        self.assertIn('msg', kwargs)

        self.assertEqual(case.assertRegexpMatches.call_count, 1)
        call = case.assertRegexpMatches.call_args
        args, kwargs = call
        self.assertEqual(args, (content_type, assertion.expected_value))
        self.assertIn('msg', kwargs)
        self.assertFalse(case.assertEqual.called)
Beispiel #27
0
    def test_body_format_none(self):
        # Given
        config = Config.from_dict({'host': 'name.domain'}, __file__)
        spec = {
            'body': {
                'format': 'none',
                'lookup-var': False,
                'value': 'plaintext',
            },
        }
        parameter = BodyTestParameter.from_dict(spec)
        expected = {
            'data': 'plaintext',
        }

        # When
        with parameter.load(config) as loaded:
            # Then
            self.assertEqual(loaded, expected)
Beispiel #28
0
    def test_assert_expected_regexp_failure(self):
        # Given
        config = Config.from_dict({'host': 'host'}, __file__)
        content_type = 'text/github.v3+json'
        expected_content_type = 'application/.*?json'
        response = Mock()
        response.headers = {
            'Content-Type': content_type,
        }
        spec = {
            'name': 'header',
            'header': 'Content-Type',
            'regexp': expected_content_type,
        }

        # When
        assertion = HeaderAssertion.from_dict(spec)

        # Then
        self.assertEqual(assertion.header, spec['header'])
        self.assertEqual(assertion.expected_value,
                         re.compile(expected_content_type))
        self.assertEqual(assertion.regexp, True)

        # When
        case = MockTestCase()
        case.assertRegexpMatches.side_effect = AssertionError
        with self.assertRaises(AssertionError):
            assertion.run(config, 'http://host/uri', case, response)

        # Then
        self.assertEqual(case.assertIn.call_count, 1)
        call = case.assertIn.call_args
        args, kwargs = call
        self.assertEqual(args, (spec['header'], response.headers))
        self.assertIn('msg', kwargs)

        self.assertEqual(case.assertRegexpMatches.call_count, 1)
        call = case.assertRegexpMatches.call_args
        args, kwargs = call
        self.assertEqual(args, (content_type, assertion.expected_value))
        self.assertIn('msg', kwargs)
        self.assertFalse(case.assertEqual.called)
Beispiel #29
0
    def test_body_format_none(self):
        # Given
        config = Config.from_dict({'host': 'name.domain'}, __file__)
        spec = {
            'body': {
                'format': 'none',
                'lookup-var': False,
                'value': 'plaintext',
            },
        }
        parameter = BodyTestParameter.from_dict(spec)
        expected = {
            'data': 'plaintext',
        }

        # When
        with parameter.load(config) as loaded:
            # Then
            self.assertEqual(loaded, expected)
Beispiel #30
0
    def test_create_multipart_form_data(self):
        # Given
        config = Config.from_dict({'host': 'name.domain'}, __file__)
        expected1 = 'some text'
        expected2 = '{}'
        multipart_body = {
            'field1': {
                'Content-Type': 'text/plain',
                'value': expected1,
            },
            'field2': {
                'Content-Type': 'application/json',
                'value': expected2,
            },
        }
        spec = {
            'body': {
                'format': 'multipart',
                'value': multipart_body,
            },
        }

        loader = BodyTestParameter.from_dict(spec)

        # When
        with loader.load(config) as loaded:
            # Then
            self.assertIn('files', loaded)
            self.assertNotIn('headers', loaded)
            data = loaded['files']
            self.assertIn('field1', data)
            self.assertIn('field2', data)

            name, content, type_ = data['field1']
            self.assertEqual(name, '')
            self.assertEqual(content.read().decode('utf-8'), expected1)
            self.assertEqual(type_, 'text/plain; charset=UTF-8')

            name, content, type_ = data['field2']
            self.assertEqual(name, '')
            self.assertEqual(content.read().decode('utf-8'), expected2)
            self.assertEqual(type_, 'application/json; charset=UTF-8')
Beispiel #31
0
    def test_create_multipart_form_data(self):
        # Given
        config = Config.from_dict({'host': 'name.domain'}, __file__)
        expected1 = 'some text'
        expected2 = '{}'
        multipart_body = {
            'field1': {
                'Content-Type': 'text/plain',
                'value': expected1,
            },
            'field2': {
                'Content-Type': 'application/json',
                'value': expected2,
            },
        }
        spec = {
            'body': {
                'format': 'multipart',
                'value': multipart_body,
            },
        }

        loader = BodyTestParameter.from_dict(spec)

        # When
        with loader.load(config) as loaded:
            # Then
            self.assertIn('files', loaded)
            self.assertNotIn('headers', loaded)
            data = loaded['files']
            self.assertIn('field1', data)
            self.assertIn('field2', data)

            name, content, type_ = data['field1']
            self.assertEqual(name, '')
            self.assertEqual(content.read().decode('utf-8'), expected1)
            self.assertEqual(type_, 'text/plain; charset=UTF-8')

            name, content, type_ = data['field2']
            self.assertEqual(name, '')
            self.assertEqual(content.read().decode('utf-8'), expected2)
            self.assertEqual(type_, 'application/json; charset=UTF-8')
Beispiel #32
0
    def test_body_json(self):
        # Given
        config = Config.from_dict({'host': 'name.domain'}, __file__)
        spec = {
            'body': {
                'format': 'json',
                'lookup-var': False,
                'value': {'param': ['value1', 'value2']},
            },
        }
        parameter = BodyTestParameter.from_dict(spec)
        expected = {
            'headers': {'Content-Type': 'application/json'},
            'data': '{"param": ["value1", "value2"]}',
        }

        # When
        with parameter.load(config) as loaded:
            # Then
            self.assertEqual(loaded, expected)
Beispiel #33
0
    def test_body_assertion_plain(self):
        # Given
        config = Config.from_dict({'host': 'host'}, __file__)
        expected = 'I am a plaintext response'
        spec = {
            'type': 'body',
            'value': expected,
        }
        assertion = BodyAssertion.from_dict(spec)
        case = MockTestCase()
        response = Mock()
        response.text = expected

        # When
        assertion.run(config, 'url', case, response)

        # Then
        self.assertEqual(case.assertEqual.call_count, 1)
        call = case.assertEqual.call_args
        args, kwargs = call
        self.assertEqual(args, (spec['value'], assertion.value))
        self.assertIn('msg', kwargs)
Beispiel #34
0
    def test_body_assertion_plain(self):
        # Given
        config = Config.from_dict({'host': 'host'}, __file__)
        expected = 'I am a plaintext response'
        spec = {
            'type': 'body',
            'value': expected,
        }
        assertion = BodyAssertion.from_dict(spec)
        case = MockTestCase()
        response = Mock()
        response.text = expected

        # When
        assertion.run(config, 'url', case, response)

        # Then
        self.assertEqual(case.assertEqual.call_count, 1)
        call = case.assertEqual.call_args
        args, kwargs = call
        self.assertEqual(args, (spec['value'], assertion.value))
        self.assertIn('msg', kwargs)
Beispiel #35
0
    def test_body_assertion_json(self):
        # Given
        config = Config.from_dict({'host': 'host'}, __file__)
        expected = {'expected': 'value'}
        spec = {
            'type': 'body',
            'format': 'json',
            'value': expected,
            'lookup-var': False,
        }
        assertion = BodyAssertion.from_dict(spec)
        case = MockTestCase()
        response = Mock()
        response.json.return_value = expected

        # When
        assertion.run(config, 'url', case, response)

        # Then
        self.assertEqual(case.assertEqual.call_count, 1)
        call = case.assertEqual.call_args
        args, kwargs = call
        self.assertEqual(args, (spec['value'], assertion.value))
        self.assertIn('msg', kwargs)
Beispiel #36
0
    def test_body_assertion_json(self):
        # Given
        config = Config.from_dict({'host': 'host'}, __file__)
        expected = {'expected': 'value'}
        spec = {
            'type': 'body',
            'format': 'json',
            'value': expected,
            'lookup-var': False,
        }
        assertion = BodyAssertion.from_dict(spec)
        case = MockTestCase()
        response = Mock()
        response.json.return_value = expected

        # When
        assertion.run(config, 'url', case, response)

        # Then
        self.assertEqual(case.assertEqual.call_count, 1)
        call = case.assertEqual.call_args
        args, kwargs = call
        self.assertEqual(args, (spec['value'], assertion.value))
        self.assertIn('msg', kwargs)
Beispiel #37
0
    def test_body_json(self):
        # Given
        config = Config.from_dict({'host': 'name.domain'}, __file__)
        spec = {
            'body': {
                'format': 'json',
                'lookup-var': False,
                'value': {
                    'param': ['value1', 'value2']
                },
            },
        }
        parameter = BodyTestParameter.from_dict(spec)
        expected = {
            'headers': {
                'Content-Type': 'application/json'
            },
            'data': '{"param": ["value1", "value2"]}',
        }

        # When
        with parameter.load(config) as loaded:
            # Then
            self.assertEqual(loaded, expected)
Beispiel #38
0
    def test_load_variable(self):
        # Given
        config = Config.from_dict(
            {
                'host': 'name.domain',
                'vars': {
                    'some_var': 'application/json',
                },
            }, __file__)
        spec = {
            'headers': {
                'Content-Type': {
                    'type': 'ref',
                    'var': 'some_var',
                },
            },
        }
        parameter = HeadersTestParameter.from_dict(spec)
        expected = {'headers': {'Content-Type': 'application/json'}}

        # When
        with parameter.load(config) as loaded:
            # Then
            self.assertEqual(loaded, expected)