rws_tests.py

# Copyright 2022 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import json
import re
import sys
import unittest

from jsonschema import ValidationError
from publicsuffix2 import PublicSuffixList
from unittest import mock
from requests import structures

sys.path.append(".")
from check_sites import find_diff_sets, find_format_diff, run_nonbreaking_checks
from RwsCheck import RwsCheck, WELL_KNOWN
from RwsSet import RwsSet


class TestFindFormatDiff(unittest.TestCase):
    """A test suite for the find_format_diff function"""

    def test_invalid_format(self):
        invalid_format_string = '{\n  "a": "foo", \n    "b": "bar"\n}\n  '
        self.assertEqual(
            find_format_diff(invalid_format_string, json.loads(invalid_format_string)),
            """Formatting for JSON is incorrect;
error was:
```diff
--- PR file
+++ expected
@@ -1,5 +1,4 @@
 {
-  "a": "foo", 
-    "b": "bar"
+  "a": "foo",
+  "b": "bar"
 }
-  
```""",
        )

    def test_valid_format(self):
        valid_format_string = '{\n  "a": "foo",\n  "b": "bar"\n}\n'
        self.assertEqual(
            find_format_diff(valid_format_string, json.loads(valid_format_string)), ""
        )


class TestValidateSchema(unittest.TestCase):
    """A test suite for the validate_schema function of RwsCheck"""

    def test_valid_associated(self):
        json_dict = {
            "sets": [
                {
                    "contact": "abc@example.com",
                    "primary": "https://primary.com",
                    "associatedSites": ["https://associated1.com"],
                    "rationaleBySite": {
                        "https://associated1.com": "example rationale",
                    },
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set(["ca"]))
        rws_check.validate_schema("SCHEMA.json")

    def test_valid_service(self):
        json_dict = {
            "sets": [
                {
                    "contact": "abc@example.com",
                    "primary": "https://primary.com",
                    "serviceSites": ["https://service1.com"],
                    "rationaleBySite": {
                        "https://service1.com": "example rationale",
                    },
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set(["ca"]))
        rws_check.validate_schema("SCHEMA.json")

    def test_valid_ccTLDs(self):
        json_dict = {
            "sets": [
                {
                    "contact": "abc@example.com",
                    "primary": "https://primary.com",
                    "ccTLDs": {"https://primary.com": ["https://primary.ca"]},
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set(["ca"]))
        rws_check.validate_schema("SCHEMA.json")

    def test_valid_full(self):
        json_dict = {
            "sets": [
                {
                    "contact": "abc@example.com",
                    "primary": "https://primary.com",
                    "associatedSites": ["https://associated1.com"],
                    "serviceSites": ["https://service1.com"],
                    "rationaleBySite": {
                        "https://associated1.com": "example rationale",
                        "https://service1.com": "example rationale",
                    },
                    "ccTLDs": {"https://associated1.com": ["https://associated1.ca"]},
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set(["ca"]))
        rws_check.validate_schema("SCHEMA.json")

    def test_duplicate_set(self):
        entry = {
            "contact": "abc@example.com",
            "primary": "https://primary.com",
            "associatedSites": ["https://associated1.com"],
            "serviceSites": ["https://service1.com"],
            "rationaleBySite": {
                "https://associated1.com": "example rationale",
                "https://service1.com": "example rationale",
            },
            "ccTLDs": {"https://associated1.com": ["https://associated1.ca"]},
        }
        json_dict = {"sets": [entry, entry]}
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set(["ca"]))
        with self.assertRaisesRegex(
            ValidationError,
            "Failed validating 'uniqueItems' in schema\['properties'\]\['sets'\]:",
        ):
            rws_check.validate_schema("SCHEMA.json")

    def test_no_primary(self):
        json_dict = {
            "sets": [
                {
                    "contact": "abc@example.com",
                    "associatedSites": ["https://associated1.com"],
                    "serviceSites": ["https://service1.com"],
                    "rationaleBySite": {
                        "https://associated1.com": "example rationale",
                        "https://service1.com": "example rationale",
                    },
                    "ccTLDs": {"https://associated1.com": ["https://associated1.ca"]},
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set(["ca"]))
        with self.assertRaisesRegex(
            ValidationError,
            re.compile(
                "'primary' is a required property.*Failed validating 'required' in schema\['properties'\]\['sets'\]\['items'\]:",
                re.DOTALL,
            ),
        ):
            rws_check.validate_schema("SCHEMA.json")

    def test_primary_only(self):
        json_dict = {
            "sets": [
                {
                    "contact": "abc@example.com",
                    "primary": "https://primary.com",
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set(["ca"]))
        with self.assertRaisesRegex(
            ValidationError,
            "Failed validating 'anyOf' in schema\['properties'\]\['sets'\]\['items'\]:",
        ):
            rws_check.validate_schema("SCHEMA.json")

    def test_no_rationaleBySite(self):
        json_dict = {
            "sets": [
                {
                    "contact": "abc@example.com",
                    "primary": "https://primary1.com",
                    "associatedSites": ["https://associated1.com"],
                    "serviceSites": ["https://service1.com"],
                    "ccTLDs": {"https://associated1.com": ["https://associated1.ca"]},
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set(["ca"]))
        with self.assertRaisesRegex(
            ValidationError,
            re.compile(
                "'rationaleBySite' is a dependency of 'associatedSites'.*Failed validating 'dependentRequired' in schema\['properties'\]\['sets'\]\['items'\]:",
                re.DOTALL,
            ),
        ):
            rws_check.validate_schema("SCHEMA.json")

    def test_invalid_field_type(self):
        json_dict = {
            "sets": [
                {
                    "contact": "abc@example.com",
                    "primary": "https://primary.com",
                    "ccTLDs": {"https://primary.com": "https://primary.ca"},
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set(["ca"]))
        with self.assertRaisesRegex(
            ValidationError,
            re.compile(
                "'https://primary.ca' is not of type 'array'.*Failed validating 'type' in schema\['properties'\]\['sets'\]\['items'\]\['properties'\]\['ccTLDs'\]\['additionalProperties'\]:",
                re.DOTALL,
            ),
        ):
            rws_check.validate_schema("SCHEMA.json")

    def test_no_contact(self):
        json_dict = {
            "sets": [
                {
                    "primary": "https://primary.com",
                    "associatedSites": ["https://associated1.com"],
                    "serviceSites": ["https://service1.com"],
                    "rationaleBySite": {
                        "https://associated1.com": "example rationale",
                        "https://service1.com": "example rationale",
                    },
                    "ccTLDs": {"https://associated1.com": ["https://associated1.ca"]},
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set(["ca"]))
        with self.assertRaisesRegex(
            ValidationError,
            re.compile(
                "'contact' is a required property.*Failed validating 'required' in schema\['properties'\]\['sets'\]\['items'\]:",
                re.DOTALL,
            ),
        ):
            rws_check.validate_schema("SCHEMA.json")

    def test_nonunique_associated_sites(self):
        json_dict = {
            "sets": [
                {
                    "contact": "abc@example.com",
                    "primary": "https://primary.com",
                    "associatedSites": [
                        "https://associated1.com",
                        "https://associated1.com",
                    ],
                    "rationaleBySite": {
                        "https://associated1.com": "example rationale",
                    },
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set(["ca"]))
        with self.assertRaisesRegex(
            ValidationError,
            re.compile(
                "has non-unique elements.*Failed validating 'uniqueItems' in schema\['properties'\]\['sets'\]\['items'\]\['properties'\]\['associatedSites'\]:",
                re.DOTALL,
            ),
        ):
            rws_check.validate_schema("SCHEMA.json")

    def test_nonunique_service_sites(self):
        json_dict = {
            "sets": [
                {
                    "contact": "abc@example.com",
                    "primary": "https://primary.com",
                    "serviceSites": [
                        "https://service1.com",
                        "https://service1.com",
                    ],
                    "rationaleBySite": {
                        "https://service1.com": "example rationale",
                    },
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set(["ca"]))
        with self.assertRaisesRegex(
            ValidationError,
            re.compile(
                "has non-unique elements.*Failed validating 'uniqueItems' in schema\['properties'\]\['sets'\]\['items'\]\['properties'\]\['serviceSites'\]:",
                re.DOTALL,
            ),
        ):
            rws_check.validate_schema("SCHEMA.json")

    def test_unexpected_top_level_property(self):
        json_dict = {"sets": [], "foo": True}
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set(["ca"]))
        with self.assertRaisesRegex(
            ValidationError,
            re.compile(
                "\('foo' was unexpected\).*Failed validating 'additionalProperties' in schema:",
                re.DOTALL,
            ),
        ):
            rws_check.validate_schema("SCHEMA.json")

    def test_unexpected_set_level_property(self):
        json_dict = {
            "sets": [
                {
                    "contact": "abc@example.com",
                    "primary": "https://primary.com",
                    "associatedSites": ["https://associated1.com"],
                    "rationaleBySite": {
                        "https://associated1.com": "example rationale",
                    },
                    "ccTLDs": {"https://associated1.com": ["https://associated1.ca"]},
                    "foo": True,
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set(["ca"]))
        with self.assertRaisesRegex(
            ValidationError,
            re.compile(
                "\('foo' was unexpected\).*Failed validating 'additionalProperties' in schema\['properties'\]\['sets'\]\['items'\]:",
                re.DOTALL,
            ),
        ):
            rws_check.validate_schema("SCHEMA.json")


class TestRwsSetEqual(unittest.TestCase):
    def test_equal_case(self):
        rws_1 = RwsSet(
            ccTLDs={"https://primary.com": ["https://primary.ca"]},
            primary="https://primary.com",
        )
        rws_2 = RwsSet(
            ccTLDs={"https://primary.com": ["https://primary.ca"]},
            primary="https://primary.com",
        )
        self.assertIsNot(rws_1, rws_2)
        self.assertEqual(rws_1, rws_2)
        self.assertEqual(rws_1, rws_1)

    def test_inequal_cases(self):
        rws_1 = RwsSet(
            ccTLDs={"https://primary.com": ["https://primary.ca"]},
            primary="https://primary.com",
        )
        rws_2 = RwsSet(
            ccTLDs={"https://primary.com": ["https://primary.co.uk"]},
            primary="https://primary.com",
        )
        self.assertNotEqual(rws_1, rws_2)

        rws_2.ccTLDs = {"https://primary.com": ["https://primary.ca"]}
        self.assertEqual(rws_1, rws_2)

        rws_1.associated_sites = ["https://associated1.com"]
        rws_2.associated_sites = ["https://associated2.com"]
        self.assertNotEqual(rws_1, rws_2)

        rws_2.associated_sites = ["https://associated1.com"]
        self.assertEqual(rws_1, rws_2)

        rws_1.service_sites = ["https://service1.com"]
        rws_2.service_sites = ["https://service2.com"]
        self.assertNotEqual(rws_1, rws_2)


class TestRwsIncludes(unittest.TestCase):
    def test_primary_case(self):
        rws = RwsSet(
            ccTLDs={"https://primary.com": ["https://primary.ca"]},
            primary="https://primary.com",
        )
        self.assertTrue(rws.includes("https://primary.com"))
        self.assertFalse(rws.includes("https://primary2.com"))

    def test_associated_case(self):
        rws = RwsSet(
            ccTLDs={},
            primary="https://primary.com",
            associated_sites=["https://associated1.com", "https://associated2.com"],
        )
        self.assertTrue(rws.includes("https://associated1.com"))
        self.assertTrue(rws.includes("https://associated2.com"))
        self.assertFalse(rws.includes("https://associated3.com"))

    def test_cctld_case(self):
        rws = RwsSet(
            ccTLDs={
                "https://primary.com": ["https://primary.ca", "https://primary.co.uk"]
            },
            primary="https://primary.com",
        )

        self.assertTrue(rws.includes("https://primary.ca"))
        self.assertFalse(rws.includes("https://primary.ca", with_ccTLDs=False))


class TestLoadSets(unittest.TestCase):
    def test_collision_case(self):
        json_dict = {
            "sets": [
                {
                    "primary": "https://primary.com",
                    "ccTLDs": {"https://primary.com": ["https://primary.ca"]},
                },
                {
                    "primary": "https://primary.com",
                    "ccTLDs": {"https://primary.com": ["https://primary.co.uk"]},
                },
            ]
        }
        rws_check = RwsCheck(
            rws_sites=json_dict, etlds=None, icanns=set(["ca", "co.uk"])
        )
        loaded_sets = rws_check.load_sets()
        expected_sets = {
            "https://primary.com": RwsSet(
                ccTLDs={"https://primary.com": ["https://primary.ca"]},
                primary="https://primary.com",
            )
        }
        self.assertEqual(loaded_sets, expected_sets)
        self.assertEqual(
            rws_check.error_list,
            ["https://primary.com is already a primary of another site"],
        )

    def test_expected_case(self):
        json_dict = {
            "sets": [
                {
                    "primary": "https://primary.com",
                    "ccTLDs": {"https://primary.com": ["https://primary.ca"]},
                },
                {
                    "primary": "https://primary2.com",
                    "ccTLDs": {"https://primary2.com": ["https://primary2.co.uk"]},
                },
            ]
        }
        rws_check = RwsCheck(
            rws_sites=json_dict, etlds=None, icanns=set(["ca", "co.uk"])
        )
        loaded_sets = rws_check.load_sets()
        expected_sets = {
            "https://primary.com": RwsSet(
                ccTLDs={"https://primary.com": ["https://primary.ca"]},
                primary="https://primary.com",
            ),
            "https://primary2.com": RwsSet(
                ccTLDs={"https://primary2.com": ["https://primary2.co.uk"]},
                primary="https://primary2.com",
            ),
        }
        self.assertEqual(loaded_sets, expected_sets)
        self.assertEqual(rws_check.error_list, [])


class TestHasRationales(unittest.TestCase):
    def test_no_rationales(self):
        json_dict = {
            "sets": [
                {
                    "primary": "https://primary.com",
                    "associatedSites": ["https://associated1.com"],
                    "serviceSites": ["https://service1.com"],
                    "rationaleBySite": {},
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set())
        loaded_sets = rws_check.load_sets()
        rws_check.has_all_rationales(loaded_sets)
        self.assertEqual(
            rws_check.error_list,
            [
                "There is no provided rationale for https://associated1.com",
                "There is no provided rationale for https://service1.com",
            ],
        )

    def test_expected_rationales_case(self):
        json_dict = {
            "sets": [
                {
                    "primary": "https://primary.com",
                    "associatedSites": ["https://associated1.com"],
                    "serviceSites": ["https://service1.com"],
                    "rationaleBySite": {
                        "https://associated1.com": "example rationale",
                        "https://service1.com": "example rationale",
                    },
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set())
        loaded_sets = rws_check.load_sets()
        self.assertEqual(rws_check.error_list, [])


class TestCheckExclusivity(unittest.TestCase):
    def test_servicesets_overlap(self):
        json_dict = {
            "sets": [
                {
                    "primary": "https://primary.com",
                    "associatedSites": ["https://associated1.com"],
                    "serviceSites": ["https://service1.com"],
                    "rationaleBySite": {},
                },
                {
                    "primary": "https://primary2.com",
                    "associatedSites": ["https://associated2.com"],
                    "serviceSites": ["https://service1.com"],
                    "rationaleBySite": {},
                },
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set())
        loaded_sets = rws_check.load_sets()
        rws_check.check_exclusivity(loaded_sets)
        self.assertEqual(
            rws_check.error_list,
            [
                "These service sites are already registered in another"
                + " related website set: {'https://service1.com'}"
            ],
        )

    def test_primary_is_associate(self):
        json_dict = {
            "sets": [
                {
                    "primary": "https://primary.com",
                    "associatedSites": ["https://primary2.com"],
                    "serviceSites": ["https://service1.com"],
                    "rationaleBySite": {},
                },
                {
                    "primary": "https://primary2.com",
                    "associatedSites": ["https://associated2.com"],
                    "serviceSites": ["https://service2.com"],
                    "rationaleBySite": {},
                },
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set())
        loaded_sets = rws_check.load_sets()
        rws_check.check_exclusivity(loaded_sets)
        self.assertEqual(
            rws_check.error_list,
            [
                "This primary is already registered in another"
                + " related website set: https://primary2.com"
            ],
        )

    def test_primary_overlap(self):
        json_dict = {
            "sets": [
                {
                    "primary": "https://primary.com",
                    "associatedSites": ["https://associated1.com"],
                    "serviceSites": ["https://primary.com"],
                    "rationaleBySite": {},
                },
                {
                    "primary": "https://primary2.com",
                    "associatedSites": ["https://primary.com"],
                    "serviceSites": ["https://service2.com"],
                    "rationaleBySite": {},
                },
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set())
        loaded_sets = rws_check.load_sets()
        rws_check.check_exclusivity(loaded_sets)
        self.assertEqual(
            rws_check.error_list,
            [
                "These service sites are already registered in another"
                + " related website set: {'https://primary.com'}",
                "These associated sites are already registered in another"
                + " related website set: {'https://primary.com'}",
            ],
        )

    def test_expected_case(self):
        json_dict = {
            "sets": [
                {
                    "primary": "https://primary.com",
                    "associatedSites": ["https://associated1.com"],
                    "serviceSites": ["https://service1.com"],
                    "rationaleBySite": {},
                },
                {
                    "primary": "https://primary2.com",
                    "associatedSites": ["https://associated2.com"],
                    "serviceSites": ["https://service2.com"],
                    "rationaleBySite": {},
                },
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set())
        loaded_sets = rws_check.load_sets()
        rws_check.check_exclusivity(loaded_sets)
        self.assertEqual(rws_check.error_list, [])


class TestFindNonHttps(unittest.TestCase):
    def test_no_https_in_primary(self):
        json_dict = {
            "sets": [
                {
                    "primary": "primary.com",
                    "associatedSites": ["https://associated1.com"],
                    "serviceSites": ["https://service1.com"],
                    "rationaleBySite": {},
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set())
        loaded_sets = rws_check.load_sets()
        rws_check.find_non_https_urls(loaded_sets)
        self.assertEqual(
            rws_check.error_list,
            ["The provided primary site does not begin with https:// " + "primary.com"],
        )

    def test_no_https_in_ccTLD(self):
        json_dict = {
            "sets": [
                {
                    "primary": "https://primary.com",
                    "associatedSites": ["https://associated1.com"],
                    "serviceSites": ["https://service1.com"],
                    "ccTLDs": {"https://primary.com": ["primary.ca"]},
                    "rationaleBySite": {},
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set())
        loaded_sets = rws_check.load_sets()
        rws_check.find_non_https_urls(loaded_sets)
        self.assertEqual(
            rws_check.error_list,
            ["The provided alias site does not begin with" + " https:// primary.ca"],
        )

    def test_multi_no_https(self):
        json_dict = {
            "sets": [
                {
                    "primary": "primary.com",
                    "associatedSites": ["associated1.com"],
                    "serviceSites": ["service1.com"],
                    "ccTLDs": {"primary.com": ["primary.ca"]},
                    "rationaleBySite": {},
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set())
        loaded_sets = rws_check.load_sets()
        rws_check.find_non_https_urls(loaded_sets)
        self.assertEqual(
            rws_check.error_list,
            [
                "The provided primary site does not begin with https:// primary.com",
                "The provided aliased site does not begin with https:// primary.com",
                "The provided alias site does not begin with https:// primary.ca",
                "The provided associated site does not begin with https:// "
                + "associated1.com",
                "The provided service site does not begin with https:// service1.com",
            ],
        )


class TestFindInvalidETLD(unittest.TestCase):
    def test_invalid_etld_primary(self):
        json_dict = {
            "sets": [
                {
                    "primary": "https://primary.c2om",
                    "associatedSites": ["https://associated1.com"],
                    "serviceSites": ["https://service1.com"],
                    "rationaleBySite": {},
                }
            ]
        }
        rws_check = RwsCheck(
            rws_sites=json_dict,
            etlds=PublicSuffixList(psl_file="effective_tld_names.dat"),
            icanns=set(),
        )
        loaded_sets = rws_check.load_sets()
        rws_check.find_invalid_eTLD_Plus1(loaded_sets)
        self.assertEqual(
            rws_check.error_list,
            ["The provided primary site is not an eTLD+1: https://primary.c2om"],
        )

    def test_invalid_etld_cctld(self):
        json_dict = {
            "sets": [
                {
                    "primary": "https://primary.com",
                    "associatedSites": ["https://associated1.com"],
                    "serviceSites": ["https://service1.com"],
                    "ccTLDs": {"https://primary.com": ["https://primary.c2om"]},
                    "rationaleBySite": {},
                }
            ]
        }
        rws_check = RwsCheck(
            rws_sites=json_dict,
            etlds=PublicSuffixList(psl_file="effective_tld_names.dat"),
            icanns=set(),
        )
        loaded_sets = rws_check.load_sets()
        rws_check.find_invalid_eTLD_Plus1(loaded_sets)
        self.assertEqual(
            rws_check.error_list,
            ["The provided alias site is not an eTLD+1: https://primary.c2om"],
        )

    def test_multi_invalid_etlds(self):
        json_dict = {
            "sets": [
                {
                    "primary": "https://primary.c2om",
                    "associatedSites": ["https://associated1.c2om"],
                    "serviceSites": ["https://service1.c2om"],
                    "ccTLDs": {"https://primary.c2om": ["https://primary.c2om"]},
                    "rationaleBySite": {},
                }
            ]
        }
        rws_check = RwsCheck(
            rws_sites=json_dict,
            etlds=PublicSuffixList(psl_file="effective_tld_names.dat"),
            icanns=set(),
        )
        loaded_sets = rws_check.load_sets()
        rws_check.find_invalid_eTLD_Plus1(loaded_sets)
        self.assertEqual(
            rws_check.error_list,
            [
                "The provided primary site is not an eTLD+1: https://primary.c2om",
                "The provided aliased site is not an eTLD+1: https://primary.c2om",
                "The provided alias site is not an eTLD+1: https://primary.c2om",
                "The provided associated site is not an eTLD+1: https://associated1.c2om",
                "The provided service site is not an eTLD+1: https://service1.c2om",
            ],
        )

    def test_not_etld_plus1(self):
        json_dict = {
            "sets": [
                {
                    "primary": "https://subdomain.primary.com",
                    "ccTLDs": {},
                    "rationaleBySite": {},
                }
            ]
        }
        rws_check = RwsCheck(
            rws_sites=json_dict,
            etlds=PublicSuffixList(psl_file="effective_tld_names.dat"),
            icanns=set(),
        )
        loaded_sets = rws_check.load_sets()
        rws_check.find_invalid_eTLD_Plus1(loaded_sets)
        self.assertEqual(
            rws_check.error_list,
            [
                "The provided primary site is not an eTLD+1: https://subdomain.primary.com"
            ],
        )

    def test_valid_etld_plus1(self):
        json_dict = {
            "sets": [
                {
                    "primary": "https://primary.com.ar",
                    "ccTLDs": {},
                    "rationaleBySite": {},
                }
            ]
        }
        rws_check = RwsCheck(
            rws_sites=json_dict,
            etlds=PublicSuffixList(psl_file="effective_tld_names.dat"),
            icanns=set(),
        )
        loaded_sets = rws_check.load_sets()
        rws_check.find_invalid_eTLD_Plus1(loaded_sets)
        self.assertEqual(rws_check.error_list, [])

    def test_valid_tld_plus1(self):
        json_dict = {
            "sets": [
                {"primary": "https://primary.com", "ccTLDs": {}, "rationaleBySite": {}}
            ]
        }
        rws_check = RwsCheck(
            rws_sites=json_dict,
            etlds=PublicSuffixList(psl_file="effective_tld_names.dat"),
            icanns=set(),
        )
        loaded_sets = rws_check.load_sets()
        rws_check.find_invalid_eTLD_Plus1(loaded_sets)
        self.assertEqual(rws_check.error_list, [])

    def test_just_suffix(self):
        json_dict = {"sets": [{"primary": "https://7.bg", "rationaleBySite": {}}]}
        rws_check = RwsCheck(
            rws_sites=json_dict,
            etlds=PublicSuffixList(psl_file="effective_tld_names.dat"),
            icanns=set(),
        )
        loaded_sets = rws_check.load_sets()
        rws_check.find_invalid_eTLD_Plus1(loaded_sets)
        self.assertEqual(
            rws_check.error_list,
            ["The provided primary site is not an eTLD+1: https://7.bg"],
        )


class TestFindInvalidESLDs(unittest.TestCase):
    def test_invalid_alias_name(self):
        json_dict = {
            "sets": [
                {
                    "primary": "https://primary.com",
                    "ccTLDs": {"https://primary.com": ["https://primary2.ca"]},
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set(["ca"]))
        loaded_sets = rws_check.load_sets()
        rws_check.find_invalid_alias_eSLDs(loaded_sets)
        self.assertEqual(
            rws_check.error_list,
            [
                "The following top level domain "
                + "must match: https://primary.com, but is instead: "
                + "https://primary2.ca"
            ],
        )

    def test_invalid_alias_ccTLD(self):
        json_dict = {
            "sets": [
                {
                    "primary": "https://primary.com",
                    "ccTLDs": {"https://primary.com": ["https://primary.gov"]},
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set(["ca"]))
        loaded_sets = rws_check.load_sets()
        rws_check.find_invalid_alias_eSLDs(loaded_sets)
        self.assertEqual(
            rws_check.error_list,
            [
                "The provided country code: gov, "
                + "in: https://primary.gov is not a ICANN registered country code"
            ],
        )

    def test_invalid_com_in_alias(self):
        json_dict = {
            "sets": [
                {
                    "primary": "https://primary.edu",
                    "ccTLDs": {"https://primary.edu": ["https://primary.com"]},
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set(["ca"]))
        loaded_sets = rws_check.load_sets()
        rws_check.find_invalid_alias_eSLDs(loaded_sets)
        self.assertEqual(
            rws_check.error_list,
            [
                "The provided country code: com, "
                + "in: https://primary.com is not a ICANN registered country code"
            ],
        )

    def test_valid_com_in_alias(self):
        json_dict = {
            "sets": [
                {
                    "primary": "https://primary.ca",
                    "ccTLDs": {"https://primary.ca": ["https://primary.com"]},
                },
                {
                    "primary": "https://primary2.co.uk",
                    "ccTLDs": {"https://primary2.co.uk": ["https://primary2.com"]},
                },
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set(["ca", "uk"]))
        loaded_sets = rws_check.load_sets()
        rws_check.find_invalid_alias_eSLDs(loaded_sets)
        self.assertEqual(rws_check.error_list, [])

    def test_invalid_associated_alias(self):
        json_dict = {
            "sets": [
                {
                    "primary": "https://primary.com",
                    "associatedSites": ["https://associated.com"],
                    "ccTLDs": {"https://associated.com": ["https://associated.gov"]},
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set(["ca"]))
        loaded_sets = rws_check.load_sets()
        rws_check.find_invalid_alias_eSLDs(loaded_sets)
        self.assertEqual(
            rws_check.error_list,
            [
                "The provided country code: gov, "
                + "in: https://associated.gov is not a ICANN registered country code"
            ],
        )

    def test_valid_associated_alias(self):
        json_dict = {
            "sets": [
                {
                    "primary": "https://primary.com",
                    "associatedSites": ["https://associated.com"],
                    "ccTLDs": {"https://associated.com": ["https://associated.ca"]},
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set(["ca"]))
        loaded_sets = rws_check.load_sets()
        rws_check.find_invalid_alias_eSLDs(loaded_sets)
        self.assertEqual(rws_check.error_list, [])

    def test_expected_esld(self):
        json_dict = {
            "sets": [
                {
                    "primary": "https://primary.com",
                    "ccTLDs": {"https://primary.com": ["https://primary.ca"]},
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set(["ca"]))
        loaded_sets = rws_check.load_sets()
        rws_check.find_invalid_alias_eSLDs(loaded_sets)
        self.assertEqual(rws_check.error_list, [])


class TestFindDiff(unittest.TestCase):
    def test_unchanged_sets(self):
        old_sets = {
            "https://primary.com": RwsSet(
                primary="https://primary.com",
                ccTLDs={"https://primary.com": ["https://primary.ca"]},
            )
        }
        new_sets = {
            "https://primary.com": RwsSet(
                primary="https://primary.com",
                ccTLDs={"https://primary.com": ["https://primary.ca"]},
            )
        }
        self.assertEqual(find_diff_sets(old_sets, new_sets), ({}, {}))

    def test_added_set(self):
        old_sets = {
            "https://primary.com": RwsSet(
                primary="https://primary.com",
                ccTLDs={"https://primary.com": ["https://primary.ca"]},
            )
        }
        new_sets = {
            "https://primary.com": RwsSet(
                primary="https://primary.com",
                ccTLDs={"https://primary.com": ["https://primary.ca"]},
            ),
            "https://primary2.com": RwsSet(
                primary="https://primary2.com",
                ccTLDs={"https://primary2.com": ["https://primary2.ca"]},
            ),
        }
        expected_diff_sets = {
            "https://primary2.com": RwsSet(
                primary="https://primary2.com",
                ccTLDs={"https://primary2.com": ["https://primary2.ca"]},
            )
        }
        self.assertEqual(find_diff_sets(old_sets, new_sets), (expected_diff_sets, {}))

    def test_removed_set(self):
        old_sets = {
            "https://primary.com": RwsSet(
                primary="https://primary.com",
                ccTLDs={"https://primary.com": ["https://primary.ca"]},
            ),
            "https://primary2.com": RwsSet(
                primary="https://primary2.com",
                ccTLDs={"https://primary2.com": ["https://primary2.ca"]},
            ),
        }
        new_sets = {
            "https://primary.com": RwsSet(
                primary="https://primary.com",
                ccTLDs={"https://primary.com": ["https://primary.ca"]},
            )
        }
        expected_subtracted_sets = {
            "https://primary2.com": RwsSet(
                primary="https://primary2.com",
                ccTLDs={"https://primary2.com": ["https://primary2.ca"]},
            )
        }
        self.assertEqual(
            find_diff_sets(old_sets, new_sets), ({}, expected_subtracted_sets)
        )

    def test_added_and_removed_set(self):
        old_sets = {
            "https://primary.com": RwsSet(
                primary="https://primary.com",
                ccTLDs={"https://primary.com": ["https://primary.ca"]},
            )
        }
        new_sets = {
            "https://primary2.com": RwsSet(
                primary="https://primary2.com",
                ccTLDs={"https://primary2.com": ["https://primary2.ca"]},
            )
        }
        self.assertEqual(find_diff_sets(old_sets, new_sets), (new_sets, old_sets))

    def test_modified_set(self):
        old_sets = {
            "https://primary.com": RwsSet(
                primary="https://primary.com",
                ccTLDs={"https://primary.com": ["https://primary.ca"]},
            )
        }
        new_sets = {
            "https://primary.com": RwsSet(
                primary="https://primary.com",
                ccTLDs={"https://primary.com": ["https://primary.co.uk"]},
            )
        }
        self.assertEqual(find_diff_sets(old_sets, new_sets), (new_sets, {}))

    def test_primary_to_member(self):
        old_sets = {
            "https://primary.com": RwsSet(
                primary="https://primary.com",
                ccTLDs={"https://primary.com": ["https://primary.ca"]},
            ),
            "https://primary2.com": RwsSet(primary="https://primary2.com", ccTLDs={}),
        }
        new_sets = {
            "https://primary.com": RwsSet(
                primary="https://primary.com",
                associated_sites=["https://primary2.com"],
                ccTLDs={"https://primary.com": ["https://primary.ca"]},
            )
        }
        self.assertEqual(find_diff_sets(old_sets, new_sets), (new_sets, {}))


# This method will be used in tests below to mock get requests
def mock_get(*args, **kwargs):
    class MockedGetResponse:
        def __init__(self, headers, status_code):
            self.headers = structures.CaseInsensitiveDict(headers)
            self.status_code = status_code
            self.url = args[0]

    if args[0] == "https://service1.com":
        return MockedGetResponse({}, 200)
    elif args[0] == "https://service2.com":
        return MockedGetResponse({"X-Robots-Tag": "foo"}, 200)
    elif args[0] == "https://service3.com":
        return MockedGetResponse({"X-Robots-Tag": "noindex"}, 200)
    elif args[0] == "https://service4.com":
        return MockedGetResponse({"X-Robots-Tag": "none"}, 200)
    elif args[0] == "https://service5.com/ads.txt":
        return MockedGetResponse({}, 400)
    elif args[0] == "https://service6.com":
        mgr = MockedGetResponse({}, 200)
        mgr.url = "https://example.com"
        return mgr
    elif args[0] == "https://service7.com":
        if "allow_redirects" in kwargs:
            if kwargs["allow_redirects"] != True:
                return MockedGetResponse({"X-Robots-Tag": "noindex"}, 200)
        return MockedGetResponse({"X-Robots-Tag": "foo"}, 200)
    elif args[0].startswith("https://service"):
        return MockedGetResponse({}, 200)
    elif args[0] == "https://primary1.com" + WELL_KNOWN:
        return MockedGetResponse({}, 200)

    return MockedGetResponse(None, 404)


def mock_open_and_load_json(*args, **kwargs):
    class MockedJsonResponse:
        def __init__(self, json):
            self.json = json

    if args[0] == "https://primary1.com" + WELL_KNOWN:
        return {
            "primary": "https://primary1.com",
            "associatedSites": ["https://not-in-list.com"],
        }
    elif args[0] == "https://expected-associated.com" + WELL_KNOWN:
        return {"primary": "https://primary1.com"}
    elif args[0] == "https://primary2.com" + WELL_KNOWN:
        return {
            "primary": "https://wrong-primary.com",
            "associatedSites": ["https://associated1.com"],
        }
    elif args[0] == "https://associated1.com" + WELL_KNOWN:
        return {"primary": "https://primary2.com"}
    elif args[0] == "https://primary3.com" + WELL_KNOWN:
        return {
            "primary": "https://primary3.com",
            "associatedSites": ["https://associated2.com"],
        }
    elif args[0] == "https://associated2.com" + WELL_KNOWN:
        return {"primary": "https://wrong-primary.com"}
    elif args[0] == "https://primary4.com" + WELL_KNOWN:
        return {
            "primary": "https://primary4.com",
            "associatedSites": ["https://associated3.com"],
        }
    elif args[0] == "https://associated3.com" + WELL_KNOWN:
        return {
            "primary": "https://primary4.com",
            "associatedSites": ["https://associated3.com"],
            "unchecked": "some unchecked field",
        }
    elif args[0] == "https://primary5.com" + WELL_KNOWN:
        return {"primary": "https://primary5.com", "unchecked": "An unchecked field"}
    return {"primary": None}


# Our test case class


class MockTestsClass(unittest.TestCase):
    # We patch requests.get with our mocked method. We'll pass
    # in the relevant urls, and get our responses for robots checks
    @mock.patch("requests.get", side_effect=mock_get)
    def test_robots(self, mock_get):
        # Assert requests.get calls
        json_dict = {
            "sets": [
                {
                    "primary": "https://primary.com",
                    "serviceSites": ["https://service1.com"],
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set())
        loaded_sets = rws_check.load_sets()
        rws_check.find_robots_tag(loaded_sets)
        self.assertEqual(
            rws_check.error_list,
            [
                "The service site "
                + "https://service1.com "
                + "does not have an X-Robots-Tag in its header"
            ],
        )

    @mock.patch("requests.get", side_effect=mock_get)
    def test_robots_wrong_tag(self, mock_get):
        # Assert requests.get calls
        json_dict = {
            "sets": [
                {
                    "primary": "https://primary.com",
                    "serviceSites": ["https://service2.com"],
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set())
        loaded_sets = rws_check.load_sets()
        rws_check.find_robots_tag(loaded_sets)
        self.assertEqual(
            rws_check.error_list,
            [
                "The service site "
                + "https://service2.com "
                + "does not have a 'noindex' or 'none' tag in its header"
            ],
        )

    @mock.patch("requests.get", side_effect=mock_get)
    def test_robots_expected_tag(self, mock_get):
        # Assert requests.get calls
        json_dict = {
            "sets": [
                {
                    "primary": "https://primary.com",
                    "serviceSites": ["https://service3.com"],
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set())
        loaded_sets = rws_check.load_sets()
        rws_check.find_robots_tag(loaded_sets)
        self.assertEqual(rws_check.error_list, [])

    @mock.patch("requests.get", side_effect=mock_get)
    def test_robots_none_tag(self, mock_get):
        # Assert requests.get calls
        json_dict = {
            "sets": [
                {
                    "primary": "https://primary.com",
                    "serviceSites": ["https://service4.com"],
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set())
        loaded_sets = rws_check.load_sets()
        rws_check.find_robots_tag(loaded_sets)
        self.assertEqual(rws_check.error_list, [])

    @mock.patch("requests.get", side_effect=mock_get)
    def test_robots_redirects(self, mock_get):
        json_dict = {
            "sets": [
                {
                    "primary": "https://primary.com",
                    "serviceSites": ["https://service7.com"],
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set())
        loaded_sets = rws_check.load_sets()
        rws_check.find_robots_tag(loaded_sets)
        self.assertEqual(rws_check.error_list, [])

    # We run a similar set of mock tests for ads.txt
    @mock.patch("requests.get", side_effect=mock_get)
    def test_ads(self, mock_get):
        # Assert requests.get calls
        json_dict = {
            "sets": [
                {
                    "primary": "https://primary.com",
                    "serviceSites": ["https://service1.com"],
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set())
        loaded_sets = rws_check.load_sets()
        rws_check.find_ads_txt(loaded_sets)
        self.assertEqual(
            rws_check.error_list,
            [
                "The service site "
                + "https://service1.com has an ads.txt file, this "
                + "violates the policies for service sites"
            ],
        )

    @mock.patch("requests.get", side_effect=mock_get)
    def test_ads(self, mock_get):
        # Assert requests.get calls
        json_dict = {
            "sets": [
                {
                    "primary": "https://primary.com",
                    "serviceSites": ["https://service5.com"],
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set())
        loaded_sets = rws_check.load_sets()
        rws_check.find_ads_txt(loaded_sets)
        self.assertEqual(rws_check.error_list, [])

    # We run a similar set of mock tests for redirect check
    @mock.patch("requests.get", side_effect=mock_get)
    def test_non_redirect(self, mock_get):
        # Assert requests.get calls
        json_dict = {
            "sets": [
                {
                    "primary": "https://primary.com",
                    "serviceSites": ["https://service1.com"],
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set())
        loaded_sets = rws_check.load_sets()
        rws_check.check_for_service_redirect(loaded_sets)
        self.assertEqual(
            rws_check.error_list,
            ["The service site " + "must not be an endpoint: https://service1.com"],
        )

    @mock.patch("requests.get", side_effect=mock_get)
    def test_proper_redirect(self, mock_get):
        # Assert requests.get calls
        json_dict = {
            "sets": [
                {
                    "primary": "https://primary.com",
                    "serviceSites": ["https://service6.com"],
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set())
        loaded_sets = rws_check.load_sets()
        rws_check.check_for_service_redirect(loaded_sets)
        self.assertEqual(rws_check.error_list, [])

    @mock.patch("requests.get", side_effect=mock_get)
    def test_404_redirect(self, mock_get):
        # Assert requests.get calls
        json_dict = {
            "sets": [
                {
                    "primary": "https://primary.com",
                    "serviceSites": ["https://no-such-service.com"],
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set())
        loaded_sets = rws_check.load_sets()
        rws_check.check_for_service_redirect(loaded_sets)
        self.assertEqual(rws_check.error_list, [])

    # Now we test check_invalid_removal by checking for an error 404
    @mock.patch("requests.get", side_effect=mock_get)
    def test_find_invalid_removal(self, mock_get):
        subtracted_sets = {
            "https://primary1.com": RwsSet(primary="https://primary1.com", ccTLDs={})
        }
        rws_check = RwsCheck(rws_sites={}, etlds=None, icanns=set())
        rws_check.find_invalid_removal(subtracted_sets)
        self.assertEqual(
            rws_check.error_list,
            [
                "The set associated with "
                + "https://primary1.com was removed from the list, but "
                + "https://primary1.com/.well-known/related-website-set.json does "
                + "not return error 404."
            ],
        )

    @mock.patch("requests.get", side_effect=mock_get)
    def test_find_valid_removal(self, mock_get):
        subtracted_sets = {
            "https://primary2.com": RwsSet(primary="https://primary2.com", ccTLDs={})
        }
        rws_check = RwsCheck(rws_sites={}, etlds=None, icanns=set())
        rws_check.find_invalid_removal(subtracted_sets)
        self.assertEqual(rws_check.error_list, [])

    # Now we test the mocked open_and_load_json to test the well-known checks
    @mock.patch(
        "RwsCheck.RwsCheck.open_and_load_json", side_effect=mock_open_and_load_json
    )
    def test_primary_page_differs(self, mock_open_and_load_json):
        json_dict = {
            "sets": [
                {
                    "primary": "https://primary1.com",
                    "associatedSites": ["https://expected-associated.com"],
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set())
        loaded_sets = rws_check.load_sets()
        rws_check.find_invalid_well_known(loaded_sets)
        self.assertEqual(
            rws_check.error_list,
            [
                "Encountered an inequality between the PR submission and the "
                + "/.well-known/related-website-set.json file:\n\tassociatedSites was "
                + "['https://expected-associated.com'] in the PR, and "
                + "['https://not-in-list.com'] in the well-known.\n\tDiff was: "
                + "['https://expected-associated.com', 'https://not-in-list.com']."
            ],
        )

    @mock.patch(
        "RwsCheck.RwsCheck.open_and_load_json", side_effect=mock_open_and_load_json
    )
    def test_wrong_primary_name(self, mock_open_and_load_json):
        json_dict = {
            "sets": [
                {
                    "primary": "https://primary2.com",
                    "associatedSites": ["https://associated1.com"],
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set())
        loaded_sets = rws_check.load_sets()
        rws_check.find_invalid_well_known(loaded_sets)
        self.assertEqual(
            rws_check.error_list,
            [
                "The /.well-known/related-website-set.json"
                + " set's primary (https://wrong-primary.com) did not equal the PR "
                + "set's primary (https://primary2.com)"
            ],
        )

    @mock.patch(
        "RwsCheck.RwsCheck.open_and_load_json", side_effect=mock_open_and_load_json
    )
    def test_associate_wrong_page(self, mock_open_and_load_json):
        json_dict = {
            "sets": [
                {
                    "primary": "https://primary3.com",
                    "associatedSites": ["https://associated2.com"],
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set())
        loaded_sets = rws_check.load_sets()
        rws_check.find_invalid_well_known(loaded_sets)
        self.assertEqual(
            rws_check.error_list,
            [
                "The listed associated site "
                + "did not have https://primary3.com listed as its primary: "
                + "https://associated2.com"
            ],
        )

    @mock.patch(
        "RwsCheck.RwsCheck.open_and_load_json", side_effect=mock_open_and_load_json
    )
    def test_expected_case(self, mock_open_and_load_json):
        json_dict = {
            "sets": [
                {
                    "primary": "https://primary4.com",
                    "associatedSites": ["https://associated3.com"],
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set())
        loaded_sets = rws_check.load_sets()
        rws_check.find_invalid_well_known(loaded_sets)
        self.assertEqual(rws_check.error_list, [])

    @mock.patch(
        "RwsCheck.RwsCheck.open_and_load_json", side_effect=mock_open_and_load_json
    )
    def test_absent_field(self, mock_open_and_load_json):
        json_dict = {"sets": [{"primary": "https://primary1.com"}]}
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set())
        loaded_sets = rws_check.load_sets()
        rws_check.find_invalid_well_known(loaded_sets)
        self.assertEqual(
            rws_check.error_list,
            [
                "Encountered an inequality between the PR submission and the "
                + "/.well-known/related-website-set.json file:\n\tassociatedSites was [] in "
                + "the PR, and ['https://not-in-list.com'] in the well-known.\n\tDiff "
                + "was: ['https://not-in-list.com']."
            ],
        )

    @mock.patch(
        "RwsCheck.RwsCheck.open_and_load_json", side_effect=mock_open_and_load_json
    )
    def test_differing_fields(self, mock_open_and_load_json):
        json_dict = {
            "sets": [
                {
                    "primary": "https://primary1.com",
                    "serviceSites": ["https://expected-associated.com"],
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set())
        loaded_sets = rws_check.load_sets()
        rws_check.find_invalid_well_known(loaded_sets)
        self.assertEqual(
            sorted(rws_check.error_list),
            [
                "Encountered an inequality between the PR submission and the "
                + "/.well-known/related-website-set.json file:\n\tassociatedSites was [] in "
                + "the PR, and ['https://not-in-list.com'] in the well-known.\n\tDiff "
                + "was: ['https://not-in-list.com'].",
                "Encountered an inequality between the PR submission and the "
                + "/.well-known/related-website-set.json file:\n\tserviceSites was "
                + "['https://expected-associated.com'] in the PR, and [] in the "
                + "well-known.\n\tDiff was: ['https://expected-associated.com'].",
            ],
        )

    @mock.patch(
        "RwsCheck.RwsCheck.open_and_load_json", side_effect=mock_open_and_load_json
    )
    def test_unchecked_field(self, mock_open_and_load_json):
        json_dict = {
            "sets": [
                {
                    "primary": "https://primary4.com",
                    "associatedSites": ["https://associated3.com"],
                    "rationaleBySite": {"https://associated3.com": "A rationale."},
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set())
        loaded_sets = rws_check.load_sets()
        rws_check.find_invalid_well_known(loaded_sets)
        self.assertEqual(sorted(rws_check.error_list), [])

    @mock.patch(
        "RwsCheck.RwsCheck.open_and_load_json", side_effect=mock_open_and_load_json
    )
    def test_unchecked_well_known_field(self, mock_open_and_load_json):
        json_dict = {
            "sets": [
                {
                    "primary": "https://primary5.com",
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set())
        loaded_sets = rws_check.load_sets()
        rws_check.find_invalid_well_known(loaded_sets)
        self.assertEqual(sorted(rws_check.error_list), [])

    @mock.patch(
        "RwsCheck.RwsCheck.open_and_load_json", side_effect=mock_open_and_load_json
    )
    def test_unexpteced_cctTLD(self, mock_open_and_load_json):
        json_dict = {
            "sets": [
                {
                    "primary": "https://primary4.com",
                    "associatedSites": ["https://associated3.com"],
                    "ccTLDs": {"https://associated3.com": ["https://associated3.ca"]},
                }
            ]
        }
        rws_check = RwsCheck(rws_sites=json_dict, etlds=None, icanns=set(["ca"]))
        loaded_sets = rws_check.load_sets()
        rws_check.find_invalid_well_known(loaded_sets)
        self.assertEqual(
            sorted(rws_check.error_list),
            [
                "Encountered an inequality between the PR submission and the "
                "/.well-known/related-website-set.json file:\n\t"
                + "https://associated3.com alias list was ['https://associated3.ca']"
                + " in the PR, and [] in the well-known.\n\tDiff was: "
                + "['https://associated3.ca'].",
                "The listed associated site did not have https://primary4.com "
                + "listed as its primary: https://associated3.ca",
            ],
        )


class TestRunNonbreakingChecks(unittest.TestCase):
    """A test suite for the run_nonbreaking_checks function.
    Uses mock_get and mock_open_and_load_json."""

    VALID_JSON_STRING = """{
  "sets": [
    {
      "primary": "https://primary4.com",
      "associatedSites": [
        "https://associated3.com"
      ],
      "rationaleBySite": {
        "https://associated3.com": "a rationale"
      }
    }
  ]
}
"""
    BAD_FORMAT_JSON_STRING = """{
  "sets":[
    {
      "primary": "https://primary4.com",
      "associatedSites": [
        "https://associated3.com"
      ],
      "rationaleBySite": {
        "https://associated3.com": "a rationale"
      }
    }
  ]
}
"""
    NO_RATIONALES_JSON_STRING = """{
  "sets": [
    {
      "primary": "https://primary4.com",
      "associatedSites": [
        "https://associated3.com"
      ],
      "rationaleBySite": {}
    }
  ]
}
"""
    BAD_FORMAT_NO_RATIONALES_JSON_STRING = """{
  "sets":[
    {
      "primary": "https://primary4.com",
      "associatedSites": [
        "https://associated3.com"
      ],
      "rationaleBySite": {}
    }
  ]
}
"""

    @mock.patch("requests.get", side_effect=mock_get)
    @mock.patch(
        "RwsCheck.RwsCheck.open_and_load_json", side_effect=mock_open_and_load_json
    )
    def testValidRWSJSONString(self, mock_get, mock_open_and_load_json):
        # Assert requests.get calls
        rws_check = RwsCheck(
            rws_sites=json.loads(self.VALID_JSON_STRING),
            etlds=PublicSuffixList(psl_file="effective_tld_names.dat"),
            icanns=set(),
        )
        error_texts = run_nonbreaking_checks(
            rws_check,
            self.VALID_JSON_STRING,
            strict_formatting=True,
            check_sets=rws_check.load_sets(),
        )
        self.assertEqual(error_texts + rws_check.error_list, [])

    @mock.patch("requests.get", side_effect=mock_get)
    @mock.patch(
        "RwsCheck.RwsCheck.open_and_load_json", side_effect=mock_open_and_load_json
    )
    def testFormatErrors(self, mock_get, mock_open_and_load_json):
        rws_check = RwsCheck(
            rws_sites=json.loads(self.BAD_FORMAT_JSON_STRING),
            etlds=PublicSuffixList(psl_file="effective_tld_names.dat"),
            icanns=set(),
        )
        error_texts = run_nonbreaking_checks(
            rws_check,
            self.BAD_FORMAT_JSON_STRING,
            strict_formatting=True,
            check_sets=rws_check.load_sets(),
        )
        self.assertEqual(
            error_texts + rws_check.error_list,
            [
                """Formatting for JSON is incorrect;
error was:
```diff
--- PR file
+++ expected
@@ -1,5 +1,5 @@
 {
-  "sets":[
+  "sets": [
     {
       "primary": "https://primary4.com",
       "associatedSites": [

```"""
            ],
        )

    @mock.patch("requests.get", side_effect=mock_get)
    @mock.patch(
        "RwsCheck.RwsCheck.open_and_load_json", side_effect=mock_open_and_load_json
    )
    def testTechnicalErrors(self, mock_get, mock_open_and_load_json):
        rws_check = RwsCheck(
            rws_sites=json.loads(self.NO_RATIONALES_JSON_STRING),
            etlds=PublicSuffixList(psl_file="effective_tld_names.dat"),
            icanns=set(),
        )
        error_texts = run_nonbreaking_checks(
            rws_check,
            self.NO_RATIONALES_JSON_STRING,
            strict_formatting=True,
            check_sets=rws_check.load_sets(),
        )
        self.assertEqual(
            error_texts + rws_check.error_list,
            ["There is no provided rationale for https://associated3.com"],
        )

    @mock.patch("requests.get", side_effect=mock_get)
    @mock.patch(
        "RwsCheck.RwsCheck.open_and_load_json", side_effect=mock_open_and_load_json
    )
    def testTechnicalAndFormatErrors(self, mock_get, mock_open_and_load_json):
        rws_check = RwsCheck(
            rws_sites=json.loads(self.BAD_FORMAT_NO_RATIONALES_JSON_STRING),
            etlds=PublicSuffixList(psl_file="effective_tld_names.dat"),
            icanns=set(),
        )
        error_texts = run_nonbreaking_checks(
            rws_check,
            self.BAD_FORMAT_NO_RATIONALES_JSON_STRING,
            strict_formatting=True,
            check_sets=rws_check.load_sets(),
        )
        self.assertEqual(
            error_texts + rws_check.error_list,
            [
                """Formatting for JSON is incorrect;
error was:
```diff
--- PR file
+++ expected
@@ -1,5 +1,5 @@
 {
-  "sets":[
+  "sets": [
     {
       "primary": "https://primary4.com",
       "associatedSites": [

```""",
                "There is no provided rationale for https://associated3.com",
            ],
        )

    @mock.patch("requests.get", side_effect=mock_get)
    @mock.patch(
        "RwsCheck.RwsCheck.open_and_load_json", side_effect=mock_open_and_load_json
    )
    def testNoStrictFormatting(self, mock_get, mock_open_and_load_json):
        rws_check = RwsCheck(
            rws_sites=json.loads(self.BAD_FORMAT_NO_RATIONALES_JSON_STRING),
            etlds=PublicSuffixList(psl_file="effective_tld_names.dat"),
            icanns=set(),
        )
        error_texts = run_nonbreaking_checks(
            rws_check,
            self.BAD_FORMAT_NO_RATIONALES_JSON_STRING,
            strict_formatting=False,
            check_sets=rws_check.load_sets(),
        )
        # Should only see technical errors.
        self.assertEqual(
            error_texts + rws_check.error_list,
            ["There is no provided rationale for https://associated3.com"],
        )


if __name__ == "__main__":
    unittest.main()