"""
The tool to check the availability or syntax of domain, IP or URL.

::


    ██████╗ ██╗   ██╗███████╗██╗   ██╗███╗   ██╗ ██████╗███████╗██████╗ ██╗     ███████╗
    ██╔══██╗╚██╗ ██╔╝██╔════╝██║   ██║████╗  ██║██╔════╝██╔════╝██╔══██╗██║     ██╔════╝
    ██████╔╝ ╚████╔╝ █████╗  ██║   ██║██╔██╗ ██║██║     █████╗  ██████╔╝██║     █████╗
    ██╔═══╝   ╚██╔╝  ██╔══╝  ██║   ██║██║╚██╗██║██║     ██╔══╝  ██╔══██╗██║     ██╔══╝
    ██║        ██║   ██║     ╚██████╔╝██║ ╚████║╚██████╗███████╗██████╔╝███████╗███████╗
    ╚═╝        ╚═╝   ╚═╝      ╚═════╝ ╚═╝  ╚═══╝ ╚═════╝╚══════╝╚═════╝ ╚══════╝╚══════╝

Tests of the HTTP status code query tool.

Author:
    Nissar Chababy, @funilrys, contactTATAfunilrysTODTODcom

Special thanks:
    https://pyfunceble.github.io/special-thanks.html

Contributors:
    https://pyfunceble.github.io/contributors.html

Project link:
    https://github.com/funilrys/PyFunceble

Project documentation:
    https://docs.pyfunceble.com

Project homepage:
    https://pyfunceble.github.io/

License:
::


    Copyright 2017, 2018, 2019, 2020, 2022, 2023, 2024, 2025 Nissar Chababy

    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 unittest
import unittest.mock

import requests
import requests.models

from PyFunceble.config.loader import ConfigLoader
from PyFunceble.query.http_status_code import HTTPStatusCode
from PyFunceble.query.requests.requester import Requester


class TestHTTPStatusCode(unittest.TestCase):
    """
    Tests the HTTP status code query tool.
    """

    def setUp(self) -> None:
        """
        Sets everything needed by the tests.
        """

        self.query_tool = HTTPStatusCode()

        return super().setUp()

    def tearDown(self) -> None:
        """
        Destroys everything needed by the tests.
        """

        del self.query_tool

    def test_set_subject_return(self) -> None:
        """
        Tests the response from the method which let us set the subject
        to work with.
        """

        given = "example.org"

        actual = self.query_tool.set_subject(given)

        self.assertIsInstance(actual, HTTPStatusCode)

    def test_set_subject_method(self) -> None:
        """
        Tests the method which let us set the subject to work with.
        """

        given = "example.org"
        expected = "example.org"

        self.query_tool.set_subject(given)

        actual = self.query_tool.subject

        self.assertEqual(expected, actual)

    def test_set_subject_attribute(self) -> None:
        """
        Tests overwritting of the :code:`subject` attribute.
        """

        given = "example.org"
        expected = "example.org"

        self.query_tool.subject = given
        actual = self.query_tool.subject

        self.assertEqual(expected, actual)

    def test_set_subject_through_init(self) -> None:
        """
        Tests the overwritting of the subject to work through the class
        constructor.
        """

        given = "example.org"
        expected = "example.org"

        query_tool = HTTPStatusCode(subject=given)
        actual = query_tool.subject

        self.assertEqual(expected, actual)

    def test_set_subject_not_str(self) -> None:
        """
        Tests the method which let us set the subject to work with for the case
        that the given subject is not a :py:class:`str`.
        """

        given = ["Hello", "World!"]

        self.assertRaises(TypeError, lambda: self.query_tool.set_subject(given))

    def test_set_subject_empty_str(self) -> None:
        """
        Tests the method which let us set the subject to work with for the case
        that the given subject is an empty :py:class:`str`.
        """

        given = ""

        self.assertRaises(ValueError, lambda: self.query_tool.set_subject(given))

    def test_set_timeout_return(self) -> None:
        """
        Tests the response from the method which let us set the timeout
        to work with.
        """

        given = 15.0

        actual = self.query_tool.set_timeout(given)

        self.assertIsInstance(actual, HTTPStatusCode)

    def test_set_timeout_method(self) -> None:
        """
        Tests the method which let us set the timeout to work with.
        """

        given = 15.0
        expected = 15.0

        self.query_tool.set_timeout(given)

        actual = self.query_tool.timeout

        self.assertEqual(expected, actual)

    def test_set_timeout_attribute(self) -> None:
        """
        Tests overwritting of the :code:`timeout` attribute.
        """

        given = 15.0
        expected = 15.0

        self.query_tool.timeout = given
        actual = self.query_tool.timeout

        self.assertEqual(expected, actual)

    def test_set_timeout_through_init(self) -> None:
        """
        Tests the overwritting of the timeout to work through the class
        constructor.
        """

        given = 15.0
        expected = 15.0

        query_tool = HTTPStatusCode(timeout=given)
        actual = query_tool.timeout

        self.assertEqual(expected, actual)

    def test_set_timeout_not_int_nor_float(self) -> None:
        """
        Tests the method which let us set the timeout to work with for the case
        that the given timeout is not a :py:class:`int`.
        """

        given = ["Hello", "World!"]

        self.assertRaises(TypeError, lambda: self.query_tool.set_timeout(given))

    def test_set_timeout_lower_than_1(self) -> None:
        """
        Tests the method which let us set the timeout to work with for the case
        that the given timeout is less than 1.
        """

        given = 0.5
        expected = 0.5

        query_tool = HTTPStatusCode(timeout=given)
        actual = query_tool.timeout

        self.assertEqual(expected, actual)

    def test_set_timeout_equal_0(self) -> None:
        """
        Tests the method which let us set the timeout to work with for the case
        that the given timeout is equal to 0.
        """

        given = 0
        expected = 0.0

        query_tool = HTTPStatusCode(timeout=given)
        actual = query_tool.timeout

        self.assertEqual(expected, actual)

    def test_set_timeout_lower_0(self) -> None:
        """
        Tests the method which let us set the timeout to work with for the case
        that the given timeout is lower then 0.
        """

        given = -3

        self.assertRaises(ValueError, lambda: self.query_tool.set_timeout(given))

    def test_guess_and_set_timeout(self) -> None:
        """
        Tests the method which let us guess and set the timeout from the
        configuration file.
        """

        config_loader = ConfigLoader()
        config_loader.set_custom_config({"lookup": {"timeout": 15.0}}).start()

        self.query_tool.guess_and_set_timeout()

        expected = 15.0
        actual = self.query_tool.timeout

        self.assertEqual(expected, actual)

        del config_loader

    def test_guess_and_set_timeout_config_not_loaded(self) -> None:
        """
        Tests the method which let us guess and set the timeout from the
        configuration file.
        """

        self.query_tool.guess_and_set_timeout()

        expected = self.query_tool.STD_TIMEOUT
        actual = self.query_tool.timeout

        self.assertEqual(expected, actual)

    def test_set_verify_certificate_return(self) -> None:
        """
        Tests the response from the method which let us activate or disable
        the certificate verification.
        """

        given = True

        actual = self.query_tool.set_verify_certificate(given)

        self.assertIsInstance(actual, HTTPStatusCode)

    def test_set_verify_certificate_method(self) -> None:
        """
        Tests the method which let us activate or disable the certificate
        verification.
        """

        given = True
        expected = True

        self.query_tool.set_verify_certificate(given)

        actual = self.query_tool.verify_certificate

        self.assertEqual(expected, actual)

    def test_set_verify_certificate_attribute(self) -> None:
        """
        Tests overwritting of the :code:`verify_certificate` attribute.
        """

        given = True
        expected = True

        self.query_tool.verify_certificate = given
        actual = self.query_tool.verify_certificate

        self.assertEqual(expected, actual)

    def test_set_verify_certificate_through_init(self) -> None:
        """
        Tests the overwritting of the value of the certificate validation
        through the class constructor.
        """

        given = True
        expected = True

        query_tool = HTTPStatusCode(verify_certificate=given)
        actual = query_tool.verify_certificate

        self.assertEqual(expected, actual)

    def test_set_verify_certificate_not_bool(self) -> None:
        """
        Tests the method which let us activate or disable the certificate
        validation for the case that the given value is not a :py:class`bool`.
        """

        given = ["Hello", "World!"]

        self.assertRaises(
            TypeError, lambda: self.query_tool.set_verify_certificate(given)
        )

    def test_guess_and_set_verify_certificate(self) -> None:
        """
        Tests the method which let us guess and set the certificate verification
        attribute from the configuration file.
        """

        config_loader = ConfigLoader()
        config_loader.set_custom_config({"verify_ssl_certificate": True}).start()

        self.query_tool.guess_and_set_verify_certificate()

        expected = True
        actual = self.query_tool.verify_certificate

        self.assertEqual(expected, actual)

        del config_loader

    def test_guess_and_set_certificate_verification_config_not_loaded(self) -> None:
        """
        Tests the method which let us guess and set the certificate
        verification from the configuration file.
        """

        self.query_tool.guess_and_set_verify_certificate()

        expected = self.query_tool.STD_VERIFY_CERTIFICATE
        actual = self.query_tool.verify_certificate

        self.assertEqual(expected, actual)

    def test_set_allow_redirects_return(self) -> None:
        """
        Tests the response from the method which let us allow the redirection.
        """

        given = True

        actual = self.query_tool.set_allow_redirects(given)

        self.assertIsInstance(actual, HTTPStatusCode)

    def test_set_allow_redirects_method(self) -> None:
        """
        Tests the method which let us allow the redirection.
        """

        given = True
        expected = True

        self.query_tool.set_allow_redirects(given)

        actual = self.query_tool.allow_redirects

        self.assertEqual(expected, actual)

    def test_set_allow_redirects_not_bool(self) -> None:
        """
        Tests the method which let us allow the redirection for the case that
        the given value is not a boolean.
        """

        given = ["Hello", "World!"]

        self.assertRaises(TypeError, lambda: self.query_tool.set_allow_redirects(given))

    def test_set_allow_redirects_attribute(self) -> None:
        """
        Tests overwritting of the :code:`allow_redirects` attribute.
        """

        given = True
        expected = True

        self.query_tool.allow_redirects = given
        actual = self.query_tool.allow_redirects

        self.assertEqual(expected, actual)

    def test_set_allow_redirects_through_init(self) -> None:
        """
        Tests the overwritting of the attribute which let us allow the
        redirection.
        """

        given = True
        expected = True

        query_tool = HTTPStatusCode(allow_redirects=given)
        actual = query_tool.allow_redirects

        self.assertEqual(expected, actual)

    def test_get_status_code_no_subject(self) -> None:
        """
        Tests the method which let us get the status code of the given subject
        for the case that no subject is actually given.
        """

        # pylint: disable=unnecessary-lambda
        self.assertRaises(TypeError, lambda: self.query_tool.get_status_code())

    @unittest.mock.patch.object(Requester, "get")
    def test_get_status_code(self, request_mock) -> None:
        """
        Tests the method which let us get the status code of the given subject.
        """

        def mocking(*args, **kwargs):  # pylint: disable=unused-argument
            response_content = "I'm a teapot."

            response = requests.models.Response()
            response.url = "https://example.org"
            response.status_code = 418

            # pylint: disable=protected-access
            response._content = str.encode(response_content)

            response.history = [response]

            return response

        self.query_tool.subject = "https://example.org"

        request_mock.side_effect = mocking

        expected = 418
        actual = self.query_tool.get_status_code()

        self.assertEqual(expected, actual)

    @unittest.mock.patch.object(Requester, "get")
    def test_get_status_code_error(self, request_mock) -> None:
        """
        Tests the method which let us get the status code of the given subject
        for the case that an error happened during the request.
        """

        def mocking(*args, **kwargs):  # pylint: disable=unused-argument
            raise Requester.exceptions.ConnectionError("I'm a teapot.")

        self.query_tool.subject = "https://example.org"

        request_mock.side_effect = mocking

        expected = self.query_tool.STD_UNKNOWN_STATUS_CODE
        actual = self.query_tool.get_status_code()

        self.assertEqual(expected, actual)

    @unittest.mock.patch.object(Requester, "get")
    def test_get_status_code_too_many_redirects(self, request_mock) -> None:
        """
        Tests the method which let us get the status code of the given subject
        for the case that too many redirects happened during the request.
        """

        def mocking(*args, **kwargs):  # pylint: disable=unused-argument
            raise Requester.exceptions.TooManyRedirects("Exceeded 30 redirects.")

        self.query_tool.subject = "https://example.org"

        request_mock.side_effect = mocking

        expected = self.query_tool.STD_UNKNOWN_STATUS_CODE
        actual = self.query_tool.get_status_code()

        self.assertEqual(expected, actual)

    @unittest.mock.patch.object(Requester, "get")
    def test_get_status_code_http_to_https(self, request_mock) -> None:
        """
        Tests the method which let us get the status code of the given subject
        for the case that a redirection from HTTP to HTTPS is done.
        """

        def mocking(*args, **kwargs):  # pylint: disable=unused-argument
            first_response = requests.models.Response()
            first_response.headers = {"Location": "https://example.org"}
            first_response.url = "http://example.org"
            first_response.status_code = 302

            final_response = requests.models.Response()
            final_response.url = "https://example.org"
            final_response.status_code = 200

            # pylint: disable=protected-access
            final_response._content = "Hello, World!".encode("utf-8")

            final_response.history = [first_response]

            return final_response

        self.query_tool.subject = "http://example.org"

        request_mock.side_effect = mocking

        expected = 200
        actual = self.query_tool.get_status_code()

        self.assertEqual(expected, actual)

    @unittest.mock.patch.object(Requester, "get")
    def test_get_status_code_http_to_https_different_subject(
        self, request_mock
    ) -> None:
        """
        Tests the method which let us get the status code of the given subject
        for the case that a redirection from HTTP to HTTPS is done but the
        subject of the HTTPS query is different from the original one.
        """

        def mocking(*args, **kwargs):  # pylint: disable=unused-argument
            first_response = requests.models.Response()
            first_response.headers = {"Location": "https://test.example.org"}
            first_response.url = "http://example.org"
            first_response.status_code = 302

            final_response = requests.models.Response()
            final_response.url = "https://test.example.org"
            final_response.status_code = 200

            # pylint: disable=protected-access
            final_response._content = "Hello, World!".encode("utf-8")

            final_response.history = [first_response]

            return final_response

        self.query_tool.subject = "http://example.org"

        request_mock.side_effect = mocking

        expected = 302
        actual = self.query_tool.get_status_code()

        self.assertEqual(expected, actual)

    @unittest.mock.patch.object(Requester, "get")
    def test_get_status_code_http_to_https_different_subject_allow_redirects(
        self, request_mock
    ) -> None:
        """
        Tests the method which let us get the status code of the given subject
        for the case that a redirection from HTTP to HTTPS is done but the
        subject of the HTTPS query is different from the original one.

        In this case, we forces the interface to follow the redirect. Meaning
        that the status code of the final one should be always returned.
        """

        def mocking(*args, **kwargs):  # pylint: disable=unused-argument
            first_response = requests.models.Response()
            first_response.headers = {"Location": "https://test.example.org"}
            first_response.url = "http://example.org"
            first_response.status_code = 302

            final_response = requests.models.Response()
            final_response.url = "https://test.example.org"
            final_response.status_code = 200

            # pylint: disable=protected-access
            final_response._content = "Hello, World!".encode("utf-8")

            final_response.history = [first_response]

            return final_response

        self.query_tool.allow_redirects = True
        self.query_tool.subject = "http://example.org"

        request_mock.side_effect = mocking

        expected = 200
        actual = self.query_tool.get_status_code()

        self.assertEqual(expected, actual)

    @unittest.mock.patch.object(Requester, "get")
    def test_get_status_code_http_to_https_multiple_jump(self, request_mock) -> None:
        """
        Tests the method which let us get the status code of the given subject
        for the case that a redirection from HTTP to HTTPS is done but other
        redirect came along the route.

        In this case, only the first one (in the row) should be provided.
        """

        def mocking(*args, **kwargs):  # pylint: disable=unused-argument
            first_response = requests.models.Response()
            first_response.headers = {"Location": "https://test.example.org"}
            first_response.url = "http://example.org"
            first_response.status_code = 301

            second_response = requests.models.Response()
            second_response.headers = {"Location": "https://test2.example.org"}
            second_response.url = "https://test.example.org"
            second_response.status_code = 302

            third_response = requests.models.Response()
            third_response.headers = {"Location": "https://example.org"}
            third_response.url = "https://test2.example.org"
            third_response.status_code = 302

            final_response = requests.models.Response()
            final_response.url = "https://test.example.org"
            final_response.status_code = 200

            # pylint: disable=protected-access
            final_response._content = "Hello, World!".encode("utf-8")

            final_response.history = [first_response, second_response, third_response]

            return final_response

        self.query_tool.subject = "http://example.org"

        request_mock.side_effect = mocking

        expected = 301
        actual = self.query_tool.get_status_code()

        self.assertEqual(expected, actual)

    @unittest.mock.patch.object(Requester, "get")
    def test_get_status_code_http_to_https_multiple_jump_allow_redirects(
        self, request_mock
    ) -> None:
        """
        Tests the method which let us get the status code of the given subject
        for the case that a redirection from HTTP to HTTPS is done but other
        redirect came along the route.

        In this case we force the interface to follow the redirect. Meaning that
        the final status code should be provided.
        """

        def mocking(*args, **kwargs):  # pylint: disable=unused-argument
            first_response = requests.models.Response()
            first_response.headers = {"Location": "https://test.example.org"}
            first_response.url = "http://example.org"
            first_response.status_code = 301

            second_response = requests.models.Response()
            second_response.headers = {"Location": "https://test2.example.org"}
            second_response.url = "https://test.example.org"
            second_response.status_code = 302

            third_response = requests.models.Response()
            third_response.headers = {"Location": "https://example.org"}
            third_response.url = "https://test2.example.org"
            third_response.status_code = 302

            final_response = requests.models.Response()
            final_response.url = "https://test.example.org"
            final_response.status_code = 200

            # pylint: disable=protected-access
            final_response._content = "Hello, World!".encode("utf-8")

            final_response.history = [first_response, second_response, third_response]

            return final_response

        self.query_tool.allow_redirects = True
        self.query_tool.subject = "http://example.org"

        request_mock.side_effect = mocking

        expected = 200
        actual = self.query_tool.get_status_code()

        self.assertEqual(expected, actual)


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