Example #1
0
    def test_overridden_thread_local_behaves_like_fixed(self):
        resolver = MockResolver(self)
        resolver.define_actions([
            ((
                "xn--4ca0bs.example.com",
                dns.rdatatype.A,
                dns.rdataclass.IN,
                False,
                (dns.flags.RD | dns.flags.AD),
            ), dns.resolver.Timeout()),
            ((
                "xn--4ca0bs.example.com",
                dns.rdatatype.A,
                dns.rdataclass.IN,
                True,
                (dns.flags.RD | dns.flags.AD),
            ), dns.resolver.Timeout()),
        ])

        network.set_resolver(resolver)
        self.base.get_resolver.return_value = resolver

        with resolver:
            with self.assertRaises(TimeoutError):
                run_coroutine(
                    network.repeated_query(
                        "äöü.example.com".encode("idna"),
                        dns.rdatatype.A,
                    ))

        self.assertSequenceEqual(self.base.mock_calls, [
            unittest.mock.call.get_resolver(),
        ])
Example #2
0
    def test_retry_with_tcp_on_first_timeout_with_fixed_resolver(self):
        resolver = MockResolver(self)
        resolver.define_actions([((
            "xn--4ca0bs.example.com",
            dns.rdatatype.A,
            dns.rdataclass.IN,
            False,
            (dns.flags.RD | dns.flags.AD),
        ), dns.resolver.Timeout()),
                                 (
                                     (
                                         "xn--4ca0bs.example.com",
                                         dns.rdatatype.A,
                                         dns.rdataclass.IN,
                                         True,
                                         (dns.flags.RD | dns.flags.AD),
                                     ),
                                     self.answer,
                                 )])

        with resolver:
            result = run_coroutine(
                network.repeated_query(
                    "äöü.example.com".encode("idna"),
                    dns.rdatatype.A,
                    resolver=resolver,
                ))

        self.assertIs(
            result,
            self.answer,
        )

        self.assertSequenceEqual(self.base.mock_calls, [])
Example #3
0
    def test_retry_up_to_2_times_with_fixed_resolver(self):
        resolver = MockResolver(self)
        resolver.define_actions([
            (
                (
                    "xn--4ca0bs.example.com",
                    dns.rdatatype.A,
                    dns.rdataclass.IN,
                    False,
                    (dns.flags.RD | dns.flags.AD),
                ),
                dns.resolver.Timeout()
            ),
            (
                (
                    "xn--4ca0bs.example.com",
                    dns.rdatatype.A,
                    dns.rdataclass.IN,
                    True,
                    (dns.flags.RD | dns.flags.AD),
                ),
                dns.resolver.Timeout()
            ),
        ])

        with resolver:
            with self.assertRaises(TimeoutError):
                run_coroutine(network.repeated_query(
                    "äöü.example.com".encode("idna"),
                    dns.rdatatype.A,
                    resolver=resolver,
                ))

        self.assertSequenceEqual(self.base.mock_calls, [])
Example #4
0
    def test_re_raise_NoNameservers_on_validation_query(self):
        self.tlr.define_actions([
            (
                (
                    "xn--4ca0bs.example.com",
                    dns.rdatatype.A,
                    dns.rdataclass.IN,
                    False,
                    (dns.flags.RD | dns.flags.AD),
                ),
                dns.resolver.NoNameservers(),
            ),
            (
                (
                    "xn--4ca0bs.example.com",
                    dns.rdatatype.A,
                    dns.rdataclass.IN,
                    False,
                    (dns.flags.RD | dns.flags.AD | dns.flags.CD),
                ),
                dns.resolver.NoNameservers()
            ),
        ])

        with self.tlr:
            with self.assertRaises(dns.resolver.NoNameservers):
                run_coroutine(network.repeated_query(
                    "äöü.example.com".encode("idna"),
                    dns.rdatatype.A,
                ))
Example #5
0
    def test_use_thread_local_resolver(self):
        self.tlr.define_actions([
            (
                (
                    "xn--4ca0bs.example.com",
                    dns.rdatatype.A,
                    dns.rdataclass.IN,
                    False,
                    (dns.flags.RD | dns.flags.AD),
                ),
                self.answer,
            )
        ])

        with self.tlr:
            result = run_coroutine(network.repeated_query(
                "äöü.example.com".encode("idna"),
                dns.rdatatype.A,
            ))

        self.assertSequenceEqual(
            self.base.mock_calls,
            [
                unittest.mock.call.get_resolver(),
            ]
        )

        self.assertIs(
            result,
            self.answer,
        )
Example #6
0
    def test_treat_NXDOMAIN_as_succeeded_query_in_validation_query(self):
        self.tlr.define_actions([
            (
                (
                    "xn--4ca0bs.example.com",
                    dns.rdatatype.A,
                    dns.rdataclass.IN,
                    False,
                    (dns.flags.RD | dns.flags.AD),
                ),
                dns.resolver.NoNameservers(),
            ),
            (
                (
                    "xn--4ca0bs.example.com",
                    dns.rdatatype.A,
                    dns.rdataclass.IN,
                    False,
                    (dns.flags.RD | dns.flags.AD | dns.flags.CD),
                ),
                dns.resolver.NXDOMAIN(),
            ),
        ])

        with self.tlr:
            with self.assertRaisesRegex(
                    network.ValidationError,
                    "nameserver error, most likely DNSSEC validation failed"):
                run_coroutine(network.repeated_query(
                    "äöü.example.com".encode("idna"),
                    dns.rdatatype.A,
                    require_ad=True,
                ))
Example #7
0
    def test_run_query_in_default_executor_by_default(self):
        resolver = MockResolver(self)
        resolver.define_actions([
            (
                (
                    "xn--4ca0bs.example.com",
                    dns.rdatatype.A,
                    dns.rdataclass.IN,
                    False,
                    (dns.flags.RD | dns.flags.AD),
                ),
                self.answer
            )
        ])

        with resolver:
            result = run_coroutine(network.repeated_query(
                "äöü.example.com".encode("idna"),
                dns.rdatatype.A,
                resolver=resolver,
            ))

        self.assertIs(
            result,
            self.answer,
        )

        self.run_in_executor.assert_called_with(
            None,
            unittest.mock.ANY,
        )
Example #8
0
    def test_use_resolver_from_arguments(self):
        resolver = MockResolver(self)
        resolver.define_actions([
            (
                (
                    "xn--4ca0bs.example.com",
                    dns.rdatatype.A,
                    dns.rdataclass.IN,
                    False,
                    (dns.flags.RD | dns.flags.AD),
                ),
                self.answer
            )
        ])

        with resolver:
            result = run_coroutine(network.repeated_query(
                "äöü.example.com".encode("idna"),
                dns.rdatatype.A,
                resolver=resolver,
            ))

        self.assertIs(
            result,
            self.answer,
        )

        self.assertSequenceEqual(self.base.mock_calls, [])
Example #9
0
    def test_pass_if_AD_present_with_require_ad(self):
        answer = MockAnswer(
            [],
            flags=dns.flags.AD,
        )

        self.tlr.define_actions([
            (
                (
                    "xn--4ca0bs.example.com",
                    dns.rdatatype.A,
                    dns.rdataclass.IN,
                    False,
                    (dns.flags.RD | dns.flags.AD),
                ),
                answer,
            )
        ])

        with self.tlr:
            result = run_coroutine(network.repeated_query(
                "äöü.example.com".encode("idna"),
                dns.rdatatype.A,
                require_ad=True,
            ))

        self.assertIs(result, answer)
Example #10
0
    def test_use_tcp_after_second_timeout(self):
        def reconfigure():
            self.tlr.set_flags(None)
            self.tlr.define_actions([
                (
                    (
                        "xn--4ca0bs.example.com",
                        dns.rdatatype.A,
                        dns.rdataclass.IN,
                        False,
                        (dns.flags.RD | dns.flags.AD),
                    ),
                    dns.resolver.Timeout(),
                ),
                (
                    (
                        "xn--4ca0bs.example.com",
                        dns.rdatatype.A,
                        dns.rdataclass.IN,
                        True,
                        (dns.flags.RD | dns.flags.AD),
                    ),
                    self.answer,
                )
            ])

        self.base.reconfigure_resolver.side_effect = reconfigure

        self.tlr.define_actions([
            (
                (
                    "xn--4ca0bs.example.com",
                    dns.rdatatype.A,
                    dns.rdataclass.IN,
                    False,
                    (dns.flags.RD | dns.flags.AD),
                ),
                dns.resolver.Timeout(),
            )
        ])

        with self.tlr:
            result = run_coroutine(network.repeated_query(
                "äöü.example.com".encode("idna"),
                dns.rdatatype.A,
            ))

        self.assertSequenceEqual(
            self.base.mock_calls,
            [
                unittest.mock.call.get_resolver(),
                unittest.mock.call.reconfigure_resolver(),
                unittest.mock.call.get_resolver(),
            ]
        )

        self.assertIs(
            result,
            self.answer,
        )
Example #11
0
 def test_reject_non_positive_number_of_attempts(self):
     with self.assertRaisesRegex(
             ValueError,
             "query cannot succeed with non-positive amount of attempts"):
         run_coroutine(network.repeated_query(
             unittest.mock.sentinel.name,
             unittest.mock.sentinel.rdtype,
             nattempts=0))
Example #12
0
    def test_continue_as_normal_on_timeout_after_NoNameservers(self):
        def reconfigure():
            self.tlr.set_flags(None)
            self.tlr.define_actions([
                (
                    (
                        "xn--4ca0bs.example.com",
                        dns.rdatatype.A,
                        dns.rdataclass.IN,
                        False,
                        (dns.flags.RD | dns.flags.AD),
                    ),
                    dns.resolver.Timeout(),
                ),
                (
                    (
                        "xn--4ca0bs.example.com",
                        dns.rdatatype.A,
                        dns.rdataclass.IN,
                        True,
                        (dns.flags.RD | dns.flags.AD),
                    ),
                    self.answer
                ),
            ])

        self.base.reconfigure_resolver.side_effect = reconfigure

        self.tlr.define_actions([
            (
                (
                    "xn--4ca0bs.example.com",
                    dns.rdatatype.A,
                    dns.rdataclass.IN,
                    False,
                    (dns.flags.RD | dns.flags.AD),
                ),
                dns.resolver.NoNameservers(),
            ),
            (
                (
                    "xn--4ca0bs.example.com",
                    dns.rdatatype.A,
                    dns.rdataclass.IN,
                    False,
                    (dns.flags.RD | dns.flags.AD | dns.flags.CD),
                ),
                dns.resolver.Timeout(),
            ),
        ])

        with self.tlr:
            result = run_coroutine(network.repeated_query(
                "äöü.example.com".encode("idna"),
                dns.rdatatype.A,
            ))

        self.assertIs(result, self.answer)
Example #13
0
    def test_retry_up_to_3_times_with_thread_local_resolver(self):
        def reconfigure():
            self.tlr.set_flags(None)
            self.tlr.define_actions([
                (
                    (
                        "xn--4ca0bs.example.com",
                        dns.rdatatype.A,
                        dns.rdataclass.IN,
                        False,
                        (dns.flags.RD | dns.flags.AD),
                    ),
                    dns.resolver.Timeout(),
                ),
                (
                    (
                        "xn--4ca0bs.example.com",
                        dns.rdatatype.A,
                        dns.rdataclass.IN,
                        True,
                        (dns.flags.RD | dns.flags.AD),
                    ),
                    dns.resolver.Timeout(),
                )
            ])

        self.base.reconfigure_resolver.side_effect = reconfigure

        self.tlr.define_actions([
            (
                (
                    "xn--4ca0bs.example.com",
                    dns.rdatatype.A,
                    dns.rdataclass.IN,
                    False,
                    (dns.flags.RD | dns.flags.AD),
                ),
                dns.resolver.Timeout(),
            )
        ])

        with self.tlr:
            with self.assertRaises(TimeoutError):
                run_coroutine(network.repeated_query(
                    "äöü.example.com".encode("idna"),
                    dns.rdatatype.A,
                ))

        self.assertSequenceEqual(
            self.base.mock_calls,
            [
                unittest.mock.call.get_resolver(),
                unittest.mock.call.reconfigure_resolver(),
                unittest.mock.call.get_resolver(),
            ]
        )
    def test_check_with_CD_set_after_NoNameservers(self):
        self.tlr.define_actions([
            (
                (
                    "xn--4ca0bs.example.com",
                    dns.rdatatype.A,
                    dns.rdataclass.IN,
                    False,
                    (dns.flags.RD | dns.flags.AD),
                ),
                dns.resolver.NoNameservers(),
            ),
            # need NoNameservers once more since reconfig will happen inbetween
            (
                (
                    "xn--4ca0bs.example.com",
                    dns.rdatatype.A,
                    dns.rdataclass.IN,
                    False,
                    (dns.flags.RD | dns.flags.AD),
                ),
                dns.resolver.NoNameservers(),
            ),
            (
                (
                    "xn--4ca0bs.example.com",
                    dns.rdatatype.A,
                    dns.rdataclass.IN,
                    False,
                    (dns.flags.RD | dns.flags.AD | dns.flags.CD),
                ),
                self.answer,
            ),
        ])

        with self.tlr:
            with self.assertRaisesRegex(
                    network.ValidationError,
                    "nameserver error, most likely DNSSEC validation failed"):
                run_coroutine(
                    network.repeated_query(
                        "äöü.example.com".encode("idna"),
                        dns.rdatatype.A,
                        require_ad=True,
                    ))
Example #15
0
    def test_check_with_CD_set_after_NoNameservers(self):
        self.tlr.define_actions([
            (
                (
                    "xn--4ca0bs.example.com",
                    dns.rdatatype.A,
                    dns.rdataclass.IN,
                    False,
                    (dns.flags.RD | dns.flags.AD),
                ),
                dns.resolver.NoNameservers(),
            ),
            # need NoNameservers once more since reconfig will happen inbetween
            (
                (
                    "xn--4ca0bs.example.com",
                    dns.rdatatype.A,
                    dns.rdataclass.IN,
                    False,
                    (dns.flags.RD | dns.flags.AD),
                ),
                dns.resolver.NoNameservers(),
            ),
            (
                (
                    "xn--4ca0bs.example.com",
                    dns.rdatatype.A,
                    dns.rdataclass.IN,
                    False,
                    (dns.flags.RD | dns.flags.AD | dns.flags.CD),
                ),
                self.answer,
            ),
        ])

        with self.tlr:
            with self.assertRaisesRegex(
                    network.ValidationError,
                    "nameserver error, most likely DNSSEC validation failed"):
                run_coroutine(network.repeated_query(
                    "äöü.example.com".encode("idna"),
                    dns.rdatatype.A,
                    require_ad=True,
                ))
Example #16
0
    def test_overridden_thread_local_behaves_like_fixed(self):
        resolver = MockResolver(self)
        resolver.define_actions([
            (
                (
                    "xn--4ca0bs.example.com",
                    dns.rdatatype.A,
                    dns.rdataclass.IN,
                    False,
                    (dns.flags.RD | dns.flags.AD),
                ),
                dns.resolver.Timeout()
            ),
            (
                (
                    "xn--4ca0bs.example.com",
                    dns.rdatatype.A,
                    dns.rdataclass.IN,
                    True,
                    (dns.flags.RD | dns.flags.AD),
                ),
                dns.resolver.Timeout()
            ),
        ])

        network.set_resolver(resolver)
        self.base.get_resolver.return_value = resolver

        with resolver:
            with self.assertRaises(TimeoutError):
                run_coroutine(network.repeated_query(
                    "äöü.example.com".encode("idna"),
                    dns.rdatatype.A,
                ))

        self.assertSequenceEqual(
            self.base.mock_calls,
            [
                unittest.mock.call.get_resolver(),
            ]
        )
Example #17
0
    def test_raise_ValueError_if_AD_not_present_with_require_ad(self):
        self.tlr.define_actions([(
            (
                "xn--4ca0bs.example.com",
                dns.rdatatype.A,
                dns.rdataclass.IN,
                False,
                (dns.flags.RD | dns.flags.AD),
            ),
            self.answer,
        )])

        with self.tlr:
            with self.assertRaisesRegex(ValueError,
                                        "DNSSEC validation not available"):
                run_coroutine(
                    network.repeated_query(
                        "äöü.example.com".encode("idna"),
                        dns.rdatatype.A,
                        require_ad=True,
                    ))
Example #18
0
    def test_return_None_on_NXDOMAIN(self):
        self.tlr.define_actions([(
            (
                "xn--4ca0bs.example.com",
                dns.rdatatype.A,
                dns.rdataclass.IN,
                False,
                (dns.flags.RD | dns.flags.AD),
            ),
            dns.resolver.NXDOMAIN(),
        )])

        with self.tlr:
            result = run_coroutine(
                network.repeated_query(
                    "äöü.example.com".encode("idna"),
                    dns.rdatatype.A,
                    require_ad=True,
                ))

        self.assertIsNone(result)
Example #19
0
    def test_return_None_on_NXDOMAIN(self):
        self.tlr.define_actions([
            (
                (
                    "xn--4ca0bs.example.com",
                    dns.rdatatype.A,
                    dns.rdataclass.IN,
                    False,
                    (dns.flags.RD | dns.flags.AD),
                ),
                dns.resolver.NXDOMAIN(),
            )
        ])

        with self.tlr:
            result = run_coroutine(network.repeated_query(
                "äöü.example.com".encode("idna"),
                dns.rdatatype.A,
                require_ad=True,
            ))

        self.assertIsNone(result)
Example #20
0
    def test_retry_with_tcp_on_first_timeout_with_fixed_resolver(self):
        resolver = MockResolver(self)
        resolver.define_actions([
            (
                (
                    "xn--4ca0bs.example.com",
                    dns.rdatatype.A,
                    dns.rdataclass.IN,
                    False,
                    (dns.flags.RD | dns.flags.AD),
                ),
                dns.resolver.Timeout()
            ),
            (
                (
                    "xn--4ca0bs.example.com",
                    dns.rdatatype.A,
                    dns.rdataclass.IN,
                    True,
                    (dns.flags.RD | dns.flags.AD),
                ),
                self.answer,
            )
        ])

        with resolver:
            result = run_coroutine(network.repeated_query(
                "äöü.example.com".encode("idna"),
                dns.rdatatype.A,
                resolver=resolver,
            ))

        self.assertIs(
            result,
            self.answer,
        )

        self.assertSequenceEqual(self.base.mock_calls, [])
Example #21
0
    def test_raise_ValueError_if_AD_not_present_with_require_ad(self):
        self.tlr.define_actions([
            (
                (
                    "xn--4ca0bs.example.com",
                    dns.rdatatype.A,
                    dns.rdataclass.IN,
                    False,
                    (dns.flags.RD | dns.flags.AD),
                ),
                self.answer,
            )
        ])

        with self.tlr:
            with self.assertRaisesRegex(
                    ValueError,
                    "DNSSEC validation not available"):
                run_coroutine(network.repeated_query(
                    "äöü.example.com".encode("idna"),
                    dns.rdatatype.A,
                    require_ad=True,
                ))