def test_ask_registry(self):
        validator = GeographicValidator()

        registry_1 = self._registry("https://registry_1_url")
        registry_2 = self._registry("https://registry_2_url")
        registry_3 = self._registry("https://registry_3_url")

        true_response = MockRequestsResponse(200, content="{}")
        unknown_response = MockRequestsResponse(200,
                                                content='{"unknown": "place"}')
        ambiguous_response = MockRequestsResponse(
            200, content='{"ambiguous": "place"}')
        problem_response = MockRequestsResponse(404)

        # Registry 1 knows about the place
        self.responses.append(true_response)
        response_1 = validator.ask_registry(json.dumps({"CA": "Victoria, BC"}),
                                            self._db, self.do_request)
        eq_(response_1, True)
        eq_(len(self.requests), 1)
        request_1 = self.requests.pop()
        eq_(request_1[0],
            'https://registry_1_url/coverage?coverage={"CA": "Victoria, BC"}')

        # Registry 1 says the place is unknown, but Registry 2 finds it.
        self.responses.append(true_response)
        self.responses.append(unknown_response)
        response_2 = validator.ask_registry(json.dumps({"CA": "Victoria, BC"}),
                                            self._db, self.do_request)
        eq_(response_2, True)
        eq_(len(self.requests), 2)
        request_2 = self.requests.pop()
        eq_(request_2[0],
            'https://registry_2_url/coverage?coverage={"CA": "Victoria, BC"}')
        request_1 = self.requests.pop()
        eq_(request_1[0],
            'https://registry_1_url/coverage?coverage={"CA": "Victoria, BC"}')

        # Registry_1 says the place is ambiguous and Registry_2 says it's unknown, but Registry_3 finds it.
        self.responses.append(true_response)
        self.responses.append(unknown_response)
        self.responses.append(ambiguous_response)
        response_3 = validator.ask_registry(json.dumps({"CA": "Victoria, BC"}),
                                            self._db, self.do_request)
        eq_(response_3, True)
        eq_(len(self.requests), 3)
        request_3 = self.requests.pop()
        eq_(request_3[0],
            'https://registry_3_url/coverage?coverage={"CA": "Victoria, BC"}')
        request_2 = self.requests.pop()
        eq_(request_2[0],
            'https://registry_2_url/coverage?coverage={"CA": "Victoria, BC"}')
        request_1 = self.requests.pop()
        eq_(request_1[0],
            'https://registry_1_url/coverage?coverage={"CA": "Victoria, BC"}')

        # Registry 1 returns a problem detail, but Registry 2 finds the place
        self.responses.append(true_response)
        self.responses.append(problem_response)
        response_4 = validator.ask_registry(json.dumps({"CA": "Victoria, BC"}),
                                            self._db, self.do_request)
        eq_(response_4, True)
        eq_(len(self.requests), 2)
        request_2 = self.requests.pop()
        eq_(request_2[0],
            'https://registry_2_url/coverage?coverage={"CA": "Victoria, BC"}')
        request_1 = self.requests.pop()
        eq_(request_1[0],
            'https://registry_1_url/coverage?coverage={"CA": "Victoria, BC"}')

        # Registry 1 returns a problem detail and the other two registries can't find the place
        self.responses.append(unknown_response)
        self.responses.append(ambiguous_response)
        self.responses.append(problem_response)
        response_5 = validator.ask_registry(json.dumps({"CA": "Victoria, BC"}),
                                            self._db, self.do_request)
        eq_(response_5.status_code, 502)
        eq_(response_5.detail,
            "Unable to contact the registry at https://registry_1_url.")
        eq_(len(self.requests), 3)
        request_3 = self.requests.pop()
        eq_(request_3[0],
            'https://registry_3_url/coverage?coverage={"CA": "Victoria, BC"}')
        request_2 = self.requests.pop()
        eq_(request_2[0],
            'https://registry_2_url/coverage?coverage={"CA": "Victoria, BC"}')
        request_1 = self.requests.pop()
        eq_(request_1[0],
            'https://registry_1_url/coverage?coverage={"CA": "Victoria, BC"}')
    def test_ask_registry(self, monkeypatch):
        validator = GeographicValidator()

        registry_1 = "https://registry_1_url"
        registry_2 = "https://registry_2_url"
        registry_3 = "https://registry_3_url"
        registries = self._registries([registry_1, registry_2, registry_3],
                                      monkeypatch)

        true_response = MockRequestsResponse(200, content="{}")
        unknown_response = MockRequestsResponse(200,
                                                content='{"unknown": "place"}')
        ambiguous_response = MockRequestsResponse(
            200, content='{"ambiguous": "place"}')
        problem_response = MockRequestsResponse(404)

        # Registry 1 knows about the place
        self.responses.append(true_response)
        response_1 = validator.ask_registry(json.dumps({"CA": "Victoria, BC"}),
                                            self._db, self.do_request)
        assert response_1 == True
        assert len(self.requests) == 1
        request_1 = self.requests.pop()
        assert (
            request_1[0] ==
            'https://registry_1_url/coverage?coverage={"CA": "Victoria, BC"}')

        # Registry 1 says the place is unknown, but Registry 2 finds it.
        self.responses.append(true_response)
        self.responses.append(unknown_response)
        response_2 = validator.ask_registry(json.dumps({"CA": "Victoria, BC"}),
                                            self._db, self.do_request)
        assert response_2 == True
        assert len(self.requests) == 2
        request_2 = self.requests.pop()
        assert (
            request_2[0] ==
            'https://registry_2_url/coverage?coverage={"CA": "Victoria, BC"}')
        request_1 = self.requests.pop()
        assert (
            request_1[0] ==
            'https://registry_1_url/coverage?coverage={"CA": "Victoria, BC"}')

        # Registry_1 says the place is ambiguous and Registry_2 says it's unknown, but Registry_3 finds it.
        self.responses.append(true_response)
        self.responses.append(unknown_response)
        self.responses.append(ambiguous_response)
        response_3 = validator.ask_registry(json.dumps({"CA": "Victoria, BC"}),
                                            self._db, self.do_request)
        assert response_3 == True
        assert len(self.requests) == 3
        request_3 = self.requests.pop()
        assert (
            request_3[0] ==
            'https://registry_3_url/coverage?coverage={"CA": "Victoria, BC"}')
        request_2 = self.requests.pop()
        assert (
            request_2[0] ==
            'https://registry_2_url/coverage?coverage={"CA": "Victoria, BC"}')
        request_1 = self.requests.pop()
        assert (
            request_1[0] ==
            'https://registry_1_url/coverage?coverage={"CA": "Victoria, BC"}')

        # Registry 1 returns a problem detail, but Registry 2 finds the place
        self.responses.append(true_response)
        self.responses.append(problem_response)
        response_4 = validator.ask_registry(json.dumps({"CA": "Victoria, BC"}),
                                            self._db, self.do_request)
        assert response_4 == True
        assert len(self.requests) == 2
        request_2 = self.requests.pop()
        assert (
            request_2[0] ==
            'https://registry_2_url/coverage?coverage={"CA": "Victoria, BC"}')
        request_1 = self.requests.pop()
        assert (
            request_1[0] ==
            'https://registry_1_url/coverage?coverage={"CA": "Victoria, BC"}')

        # Registry 1 returns a problem detail and the other two registries can't find the place
        self.responses.append(unknown_response)
        self.responses.append(ambiguous_response)
        self.responses.append(problem_response)
        response_5 = validator.ask_registry(json.dumps({"CA": "Victoria, BC"}),
                                            self._db, self.do_request)
        assert response_5.status_code == 502
        assert (response_5.detail ==
                "Unable to contact the registry at https://registry_1_url.")
        assert len(self.requests) == 3
        request_3 = self.requests.pop()
        assert (
            request_3[0] ==
            'https://registry_3_url/coverage?coverage={"CA": "Victoria, BC"}')
        request_2 = self.requests.pop()
        assert (
            request_2[0] ==
            'https://registry_2_url/coverage?coverage={"CA": "Victoria, BC"}')
        request_1 = self.requests.pop()
        assert (
            request_1[0] ==
            'https://registry_1_url/coverage?coverage={"CA": "Victoria, BC"}')
    def test_ask_registry(self):
        validator = GeographicValidator()

        registry_1 = self._registry("https://registry_1_url")
        registry_2 = self._registry("https://registry_2_url")
        registry_3 = self._registry("https://registry_3_url")

        true_response = MockRequestsResponse(200, content="{}")
        unknown_response = MockRequestsResponse(200, content='{"unknown": "place"}')
        ambiguous_response = MockRequestsResponse(200, content='{"ambiguous": "place"}')
        problem_response = MockRequestsResponse(404)

        # Registry 1 knows about the place
        self.responses.append(true_response)
        response_1 = validator.ask_registry(json.dumps({"CA": "Victoria, BC"}), self._db, self.do_request)
        eq_(response_1, True)
        eq_(len(self.requests), 1)
        request_1 = self.requests.pop()
        eq_(request_1[0], 'https://registry_1_url/coverage?coverage={"CA": "Victoria, BC"}')

        # Registry 1 says the place is unknown, but Registry 2 finds it.
        self.responses.append(true_response)
        self.responses.append(unknown_response)
        response_2 = validator.ask_registry(json.dumps({"CA": "Victoria, BC"}), self._db, self.do_request)
        eq_(response_2, True)
        eq_(len(self.requests), 2)
        request_2 = self.requests.pop()
        eq_(request_2[0], 'https://registry_2_url/coverage?coverage={"CA": "Victoria, BC"}')
        request_1 = self.requests.pop()
        eq_(request_1[0], 'https://registry_1_url/coverage?coverage={"CA": "Victoria, BC"}')

        # Registry_1 says the place is ambiguous and Registry_2 says it's unknown, but Registry_3 finds it.
        self.responses.append(true_response)
        self.responses.append(unknown_response)
        self.responses.append(ambiguous_response)
        response_3 = validator.ask_registry(json.dumps({"CA": "Victoria, BC"}), self._db, self.do_request)
        eq_(response_3, True)
        eq_(len(self.requests), 3)
        request_3 = self.requests.pop()
        eq_(request_3[0], 'https://registry_3_url/coverage?coverage={"CA": "Victoria, BC"}')
        request_2 = self.requests.pop()
        eq_(request_2[0], 'https://registry_2_url/coverage?coverage={"CA": "Victoria, BC"}')
        request_1 = self.requests.pop()
        eq_(request_1[0], 'https://registry_1_url/coverage?coverage={"CA": "Victoria, BC"}')

        # Registry 1 returns a problem detail, but Registry 2 finds the place
        self.responses.append(true_response)
        self.responses.append(problem_response)
        response_4 = validator.ask_registry(json.dumps({"CA": "Victoria, BC"}), self._db, self.do_request)
        eq_(response_4, True)
        eq_(len(self.requests), 2)
        request_2 = self.requests.pop()
        eq_(request_2[0], 'https://registry_2_url/coverage?coverage={"CA": "Victoria, BC"}')
        request_1 = self.requests.pop()
        eq_(request_1[0], 'https://registry_1_url/coverage?coverage={"CA": "Victoria, BC"}')

        # Registry 1 returns a problem detail and the other two registries can't find the place
        self.responses.append(unknown_response)
        self.responses.append(ambiguous_response)
        self.responses.append(problem_response)
        response_5 = validator.ask_registry(json.dumps({"CA": "Victoria, BC"}), self._db, self.do_request)
        eq_(response_5.status_code, 502)
        eq_(response_5.detail, "Unable to contact the registry at https://registry_1_url.")
        eq_(len(self.requests), 3)
        request_3 = self.requests.pop()
        eq_(request_3[0], 'https://registry_3_url/coverage?coverage={"CA": "Victoria, BC"}')
        request_2 = self.requests.pop()
        eq_(request_2[0], 'https://registry_2_url/coverage?coverage={"CA": "Victoria, BC"}')
        request_1 = self.requests.pop()
        eq_(request_1[0], 'https://registry_1_url/coverage?coverage={"CA": "Victoria, BC"}')