def test_querystring_as_pairlist(self):
        data = {
            'request': {
                'query_string': [
                    ['foo', 'bar'],
                    ['password', 'hello'],
                    ['the_secret', 'hello'],
                    ['a_password_here', 'hello'],
                    ['api_key', 'secret_key'],
                ],
            }
        }

        proc = SensitiveDataFilter()
        proc.apply(data)

        assert 'request' in data
        http = data['request']
        assert http['query_string'] == [
            ['foo', 'bar'],
            ['password', FILTER_MASK],
            ['the_secret', FILTER_MASK],
            ['a_password_here', FILTER_MASK],
            ['api_key', FILTER_MASK],
        ]

    def test_extra(self):
        data = {'extra': VARS}

        proc = SensitiveDataFilter()
        proc.apply(data)

        assert 'extra' in data
        self._check_vars_sanitized(data['extra'], proc)

    def test_extra(self):
        data = {"extra": VARS}

        proc = SensitiveDataFilter()
        proc.apply(data)

        self.assertTrue("extra" in data)
        self._check_vars_sanitized(data["extra"], proc)

    def test_sanitize_credit_card_within_value(self):
        proc = SensitiveDataFilter()
        result = proc.sanitize('foo', "'4571234567890111'")
        assert result == FILTER_MASK

        proc = SensitiveDataFilter()
        result = proc.sanitize('foo', "foo 4571234567890111")
        assert result == FILTER_MASK

    def test_sanitize_credit_card_within_value(self):
        proc = SensitiveDataFilter()
        result = proc.sanitize('foo', "'4242424242424242'")
        self.assertEquals(result, proc.MASK)

        proc = SensitiveDataFilter()
        result = proc.sanitize('foo', "foo 4242424242424242")
        self.assertEquals(result, proc.MASK)

 def test_sanitize_url(self):
     proc = SensitiveDataFilter()
     result = proc.sanitize('foo', 'pg://matt:[email protected]/1')
     self.assertEquals(result, 'pg://matt:%[email protected]/1' % proc.MASK)
     # Make sure we don't mess up any other url.
     # This url specifically if passed through urlunsplit(urlsplit()),
     # it'll change the value.
     result = proc.sanitize('foo', 'postgres:///path')
     self.assertEquals(result, 'postgres:///path')

    def test_querystring_as_string_with_partials(self):
        data = {"request": {"query_string": "foo=bar&password&baz=bar"}}

        proc = SensitiveDataFilter()
        proc.apply(data)

        self.assertTrue("request" in data)
        http = data["request"]
        self.assertEquals(http["query_string"], "foo=bar&password&baz=bar" % dict(m=proc.MASK))

    def test_does_not_fail_on_non_string(self):
        data = {
            'extra': {
                'foo': 1,
            },
        }

        proc = SensitiveDataFilter()
        result = proc.apply(data)
        self.assertEquals(data['extra'], {'foo': 1})

    def test_does_sanitize_public_key(self):
        data = {
            'extra': {
                's': PUBLIC_KEY,
            },
        }

        proc = SensitiveDataFilter()
        proc.apply(data)
        assert data['extra'] == {'s': FILTER_MASK}

    def test_exclude_fields_on_field_name(self):
        data = {
            'extra': {
                'password': '123-45-6789',
            },
        }

        proc = SensitiveDataFilter(exclude_fields=['password'])
        proc.apply(data)
        assert data['extra'] == {'password': '123-45-6789'}

    def test_does_not_fail_on_non_string(self):
        data = {
            'extra': {
                'foo': 1,
            },
        }

        proc = SensitiveDataFilter()
        proc.apply(data)
        assert data['extra'] == {'foo': 1}

    def test_exclude_fields_on_field_value(self):
        data = {
            'extra': {
                'foobar': '123-45-6789',
            },
        }

        proc = SensitiveDataFilter(exclude_fields=['foobar'])
        proc.apply(data)
        assert data['extra'] == {'foobar': '123-45-6789'}

    def test_explicit_fields(self):
        data = {
            'extra': {
                'mystuff': 'xxx',
            },
        }

        proc = SensitiveDataFilter(fields=['mystuff'])
        proc.apply(data)
        assert data['extra']['mystuff'] == FILTER_MASK

    def test_empty_field(self):
        data = {
            'extra': {
                'foobar': 'xxx',
            },
        }

        proc = SensitiveDataFilter(fields=[''])
        proc.apply(data)
        assert data['extra'] == {'foobar': 'xxx'}

    def test_does_sanitize_rsa_private_key(self):
        data = {
            'extra': {
                's': RSA_PRIVATE_KEY,
            },
        }

        proc = SensitiveDataFilter()
        proc.apply(data)
        assert data['extra'] == {'s': FILTER_MASK}

    def test_does_sanitize_social_security_number(self):
        data = {
            'extra': {
                's': '123-45-6789',
            },
        }

        proc = SensitiveDataFilter()
        proc.apply(data)
        assert data['extra'] == {'s': FILTER_MASK}

    def test_http(self):
        data = {"request": {"data": VARS, "env": VARS, "headers": VARS, "cookies": VARS}}

        proc = SensitiveDataFilter()
        proc.apply(data)

        self.assertTrue("request" in data)
        http = data["request"]
        for n in ("data", "env", "headers", "cookies"):
            self.assertTrue(n in http)
            self._check_vars_sanitized(http[n], proc)

    def test_sanitize_additional_sensitive_fields(self):
        additional_sensitive_dict = {'fieldy_field': 'value', 'moar_other_field': 'another value'}
        data = {'extra': dict(list(VARS.items()) + list(additional_sensitive_dict.items()))}

        proc = SensitiveDataFilter(additional_sensitive_dict.keys())
        proc.apply(data)

        for field in additional_sensitive_dict.keys():
            assert data['extra'][field] == FILTER_MASK

        self._check_vars_sanitized(data['extra'], proc)

    def test_sanitize_http_body(self):
        data = {
            'sentry.interfaces.Http': {
                'data': '{"email":"[email protected]","password":"zzzzz"}',
            },
        }

        proc = SensitiveDataFilter()
        proc.apply(data)
        assert 'sentry.interfaces.Http' in data
        http = data['sentry.interfaces.Http']
        assert http['data'] == FILTER_MASK

    def test_sanitize_http_body(self):
        data = {
            'sentry.interfaces.Http': {
                'data': '{"email":"[email protected]","password":"zzzzz"}',
            },
        }

        proc = SensitiveDataFilter()
        result = proc.apply(data)
        self.assertTrue('sentry.interfaces.Http' in data)
        http = data['sentry.interfaces.Http']
        self.assertEquals(http['data'], proc.MASK)