spec\Subreality\Dilmun\Anshar\Http\RequestSpec

Complexity

Total Complexity

58

Size/Duplication

Total Lines	738
Duplicated Lines	16.8 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

<?php
class RequestSpec extends ObjectBehavior
{
    function it_is_initializable()
    {
        $this->shouldHaveType(Request::class);
    }

    /**
     * Retrieves the HTTP protocol version as a string.
     */
    function it_returns_its_protocol_version_as_a_string()
    {
        $this->getProtocolVersion()->shouldHaveType("string");
    }


    /**
     * The string MUST contain only the HTTP version number (e.g., "1.1", "1.0").
     */
    function it_returns_a_string_containing_only_the_http_version()
    {
        $this->getProtocolVersion()->shouldReturn("1.1");
    }

    /**
     * Return an instance with the specified HTTP protocol version.
     *
     * The version string MUST contain only the HTTP version number (e.g.,
     * "1.1", "1.0").
     *
     * This method MUST be implemented in such a way as to retain the
     * immutability of the message, and MUST return an instance that has the
     * new protocol version.
     */
    function it_returns_a_new_request_with_a_protocol_update()
    {
        $request = $this->withProtocolVersion("1.0");

        $request->shouldHaveType(Request::class);
        $request->getProtocolVersion()->shouldReturn("1.0");
    }

    function it_retains_the_original_protocol_version_when_a_new_protocol_version_is_set()
    {
        $request = $this->withProtocolVersion("1.0");

        $request->shouldHaveType(Request::class);
        $request->getProtocolVersion()->shouldReturn("1.0");

        $this->getProtocolVersion()->shouldReturn("1.1");
    }

    /**
     * Returns an associative array of the message's headers. Each key MUST be a
     * header name, and each value MUST be an array of strings for that header.
     *
     * The keys represent the header name as it will be sent over the wire, and
     * each value is an array of strings associated with the header.
     */
    function it_returns_its_headers_as_an_associative_array_of_arrays()
    {
        $headers = $this->getHeaders();

        $headers->shouldBeArray();

        if (!empty($headers)) {
            foreach ($headers as $header => $values) {
                $header->shouldHaveType("string");
                $values->shouldBeArray();

                if (!empty($values)) {
                    foreach ($values as $value) {
                        $value->shouldHaveType("string");
                    }
                }
            }
        }
    }

    /**
     * While header names are not case-sensitive, getHeaders() will preserve the
     * exact case in which headers were originally specified.
     */
    function it_preserves_the_case_of_returned_headers()
    {
        $spec_header = array(
            "fOo" => array(
                "baR"
            )
        );

        //TODO: Construct with new header

        $this->getHeaders()->shouldReturn($spec_header);
    }

    /**
     * Returns true if any header names match the given header
     */
    function it_reports_that_it_has_a_header()
    {
        $this->hasHeader("foo")->shouldBe(true);
    }

    /**
     * Checks if a header exists by the given case-insensitive name.
     */
    function it_determines_the_existence_of_a_header_in_a_case_insensitive_way()
    {
        $this->hasHeader("FOO")->shouldBe(true);
    }

    /**
     * Returns false if no matching header name is found in the message.
     */
    function it_reports_that_it_does_not_have_a_header()
    {
        $this->hasHeader("bar")->shouldBe(false);
    }

    /**
     * Returns an array of string values as provided for the given header.
     */
    function it_returns_an_existing_header_as_an_array_of_strings()
    {
        $spec_header = array(
            "fOo" => array(
                "baR"
            )
        );

        $this->getHeader("foo")->shouldReturn($spec_header);

        $header = $this->getHeader("foo");

        $header->shouldBeArray();

        foreach ($header as $value) {
            $value->shouldHaveType("string");
        }
    }

    function it_returns_an_existing_header_in_a_case_insensitive_way()
    {
        $spec_header = array(
            "fOo" => array(
                "baR"
            )
        );

        $this->getHeader("FOO")->shouldReturn($spec_header);
    }

    /**
     * If the header does not appear in the message, this method MUST return an
     * empty array.
     */
    function it_returns_an_empty_array_when_a_header_does_not_exist()
    {
        $header = $this->getHeader("bar");

        $header->shouldBeArray();
        $header->shouldHaveCount(0);
    }

    /**
     * Retrieves a comma-separated string of the values for a single header.
     */
    function it_returns_a_string_of_values_for_an_existing_header()
    {
        $this->getHeaderLine("foo")->shouldBe("bar,baz");
    }

    /**
     * This method returns all of the header values of the given
     * case-insensitive header name as a string concatenated together using
     * a comma.
     */
    function it_returns_a_string_of_values_for_an_existing_header_in_a_case_insensitive_way()
    {
        $this->getHeaderLine("FOO")->shouldBe("bar,baz");
    }

    /**
     * If the header does not appear in the message, this method MUST return
     * an empty string.
     */
    function it_returns_an_empty_string_for_a_header_that_does_not_exist()
    {
        $this->getHeaderLine("bar")->shouldBe("");
    }

    /**
     * Return an instance with the provided value replacing the specified header.
     */
    function it_returns_a_new_request_with_a_header_update_with_a_single_value()
    {
        $header = "foo";
        $value = "qux";

        $request = $this->withHeader($header, $value);

        $request->getHeaderLine($header)->shouldBe($value);
    }

    /**
     * While header names are case-insensitive, the casing of the header will
     * be preserved by this function, and returned from getHeaders().
     */
    function it_returns_a_new_request_with_a_header_update_in_a_case_insensitive_way()
    {
        $header = "FOO";
        $value = "qux";

        $request = $this->withHeader($header, $value);

        $request->getHeaderLine("foo")->shouldBe($value);
    }

    /**
     * Return an instance with the provided value replacing the specified header.
     */
    function it_returns_a_new_request_with_a_header_update_with_an_array_of_values()
    {
        $header = "foo";
        $values = array("qux", "quux");

        $request = $this->withHeader($header, $values);

        $request->getHeaderLine($header)->shouldBe("qux,quux");
    }

    /**
     * This method MUST be implemented in such a way as to retain the
     * immutability of the message, and MUST return an instance that has the
     * new and/or updated header and value.
     */
    function it_retains_its_original_header_when_it_replaces_a_header()
    {
        $spec_header = array(
            "fOo" => array(
                "baR"
            )
        );

        $header = "foo";
        $values = array("qux", "quux");

        $request = $this->withHeader($header, $values);

        $request->getHeaderLine($header)->shouldBe("qux,quux");

        $this->getHeaders()->shouldReturn($spec_header);
    }

    /**
     * Throws \InvalidArgumentException for invalid header names or values.
     */
    function it_throws_an_exception_with_a_header_update_with_invalid_header_name()
    {
        $header = array();
        $value = "qux";

        $arguments = array($header, $value);

        $this->shouldThrow('\InvalidArgumentException')->during("withHeader", $arguments);
    }

    /**
     * Throws \InvalidArgumentException for invalid header names or values.
     */
    function it_throws_an_exception_with_a_header_update_with_invalid_value()
    {
        $header = "foo";
        $value = array();

        $arguments = array($header, $value);

        $this->shouldThrow('\InvalidArgumentException')->during("withHeader", $arguments);
    }

    /**
     * Existing values for the specified header will be maintained. The new
     * value(s) will be appended to the existing list.
     */
    function it_returns_a_new_request_with_a_header_added_with_a_single_value()
    {
        $header = "foo";
        $value = "qux";

        $request = $this->withAddedHeader($header, $value);

        $request->getHeaderLine($header)->shouldBe("bar,baz,qux");
    }

    /**
     * While header names are case-insensitive, the casing of the header will
     * be preserved by this function, and returned from getHeaders().
     */
    function it_returns_a_new_request_with_a_header_added_in_a_case_insensitive_way()
    {
        $header = "FOO";
        $value = "qux";

        $request = $this->withAddedHeader($header, $value);

        $request->getHeaderLine("foo")->shouldBe("bar,baz,qux");
    }

    /**
     * Existing values for the specified header will be maintained. The new
     * value(s) will be appended to the existing list.
     */
    function it_returns_a_new_request_with_a_header_added_with_an_array_of_values()
    {
        $header = "foo";
        $values = array("qux", "quux");

        $request = $this->withAddedHeader($header, $values);

        $request->getHeaderLine($header)->shouldBe("bar,baz,qux,quux");
    }

    /**
     * If the header did not exist previously, it will be added.
     */
    function it_returns_a_new_request_with_a_header_created_given_a_nonexistent_header()
    {
        $header = "bar";
        $values = array("qux", "quux");

        $request = $this->withAddedHeader($header, $values);

        $request->getHeaderLine($header)->shouldBe("qux,quux");
    }

    /**
     * This method MUST be implemented in such a way as to retain the
     * immutability of the message, and MUST return an instance that has the
     * new and/or updated header and value.
     */
    function it_retains_its_original_header_when_adding_a_header()
    {
        $header = "foo";
        $value = "qux";

        $request = $this->withAddedHeader($header, $value);

        $request->getHeaderLine($header)->shouldReturn("bar,baz,qux");
        $this->getHeaderLine($header)->shouldReturn("bar,baz");
    }

    /**
     * Throws \InvalidArgumentException for invalid header names or values.
     */
    function it_throws_an_exception_with_a_header_added_with_invalid_header_name()
    {
        $header = array();
        $value = "qux";

        $arguments = array($header, $value);

        $this->shouldThrow('\InvalidArgumentException')->during("withAddedHeader", $arguments);
    }

    /**
     * Throws \InvalidArgumentException for invalid header names or values.
     */
    function it_throws_an_exception_with_a_header_added_with_invalid_value()
    {
        $header = "foo";
        $value = array();

        $arguments = array($header, $value);

        $this->shouldThrow('\InvalidArgumentException')->during("withAddedHeader", $arguments);
    }

    /**
     * Return an instance without the specified header.
     */
    function it_returns_a_new_request_without_a_header()
    {
        $request = $this->withoutHeader("foo");

        $request->getHeaderLine("foo")->shouldBe("");
    }

    /**
     * Header resolution MUST be done without case-sensitivity.
     */
    function it_returns_a_new_request_without_a_header_in_a_case_insensitive_way()
    {
        $request = $this->withoutHeader("FOO");

        $request->getHeaderLine("foo")->shouldBe("");
    }

    /**
     * This method MUST be implemented in such a way as to retain the
     * immutability of the message, and MUST return an instance that removes
     * the named header.
     */
    function it_retains_its_header_when_returning_a_new_request_without_a_header()
    {
        $request = $this->withoutHeader("FOO");

        $request->getHeaderLine("foo")->shouldBe("");

        $this->getHeaderLine("foo")->shouldReturn("bar,baz");
    }

    /**
     * Gets the body of the message.
     */
    function it_returns_the_body_of_its_message_as_a_stream()
    {
        $this->getBody()->shouldBeAnInstanceOf("StreamInterface");
    }

    /**
     * Return an instance with the specified message body.
     *
     * @param \PhpSpec\Wrapper\Collaborator|StreamInterface $body
     */
    function it_returns_a_new_request_with_a_body(StreamInterface $body)
    {
        $body->getContents()->willReturn("I'm a stream!");

        $request = $this->withBody($body);

        $request->getBody()->getContents()->shouldBe("I'm a stream!");
    }

    /**
     * This method MUST be implemented in such a way as to retain the
     * immutability of the message, and MUST return a new instance that has the
     * new body stream.
     *
     * @param \PhpSpec\Wrapper\Collaborator|StreamInterface $old_body
     * @param \PhpSpec\Wrapper\Collaborator|StreamInterface $new_body
     */
    function it_retains_its_body_when_returning_a_new_request_with_a_body(StreamInterface $old_body,
                                                                          StreamInterface $new_body)
    {
        $old_body->getContents()->willReturn("I'm the original stream!");
        $new_body->getContents()->willReturn("I'm the new stream!");

        $request = $this->withBody($new_body);

        $request->getBody()->getContents()->shouldReturn("I'm the new stream!");

        $this->getBody()->getContents()->shouldReturn("I'm the original stream!");
    }

    /**
     * The body MUST be a StreamInterface object.
     *
     * Throws \InvalidArgumentException When the body is not valid.
     */
    function it_throws_an_exception_with_an_invalid_body()
    {
        $body = "I'm not a stream!";

        $argument = array($body);

        $this->shouldThrow('\InvalidArgumentException')->during("withBody", $argument);
    }

    /**
     * Retrieves the message's request target.
     *
     * Retrieves the message's request-target either as it will appear (for
     * clients), as it appeared at request (for servers), or as it was
     * specified for the instance (see withRequestTarget()).
     *
     * In most cases, this will be the origin-form of the composed URI,
     * unless a value was provided to the concrete implementation (see
     * withRequestTarget() below).
     */
    function it_returns_the_request_target_from_a_uri_path()
    {
        $this->getRequestTarget()->shouldReturn("/baz/qux.html");
    }

    /**
     * Retrieves the message's request target.
     *
     * Retrieves the message's request-target either as it will appear (for
     * clients), as it appeared at request (for servers), or as it was
     * specified for the instance (see withRequestTarget()).
     *
     * In most cases, this will be the origin-form of the composed URI,
     * unless a value was provided to the concrete implementation (see
     * withRequestTarget() below).
     */
    function it_returns_the_request_target_explicitly_set()
    {
        $this->getRequestTarget()->shouldReturn("*");
    }

    /**
     * If no URI is available, and no request-target has been specifically
     * provided, this method MUST return the string "/".
     */
    function it_returns_an_empty_path_when_no_request_target_and_no_uri_exists()
    {
        $this->getRequestTarget()->shouldReturn("/");
    }

    /**
     * Return an instance with the specific request-target.
     */
    function it_returns_a_new_request_with_a_request_target()
    {
        $target = "https://www.foo.bar/baz/qux.html";

        $request = $this->withRequestTarget($target);

        $request->getRequestTarget()->shouldReturn($target);
    }

    /**
     * This method MUST be implemented in such a way as to retain the
     * immutability of the message, and MUST return an instance that has the
     * changed request target.
     */
    function it_retains_its_request_target_when_creating_a_request_with_a_new_request_target()
    {
        $target = "https://www.foo.bar/baz/qux.html";

        $request = $this->withRequestTarget($target);

        $request->getRequestTarget()->shouldReturn($target);
        $this->getRequestTarget()->shouldReturn("/baz/qux.html");
    }

    /**
     * $requestTarget parameter type may be mixed.
     */
    function it_returns_a_new_request_with_an_empty_request_target_with_a_null_request_target()
    {
        $target = null;

        $request = $this->withRequestTarget($target);

        $request->getRequestTarget()->shouldReturn("/");
    }

    /**
     * Retrieves the HTTP method of the request.
     */
    function it_returns_its_method()
    {
        $this->getMethod()->shouldReturn("HEAD");
    }

    /**
     * Return an instance with the provided HTTP method.
     *
     * While HTTP method names are typically all uppercase characters, HTTP
     * method names are case-sensitive and thus implementations SHOULD NOT
     * modify the given string.
     */
    function it_returns_a_new_request_with_a_method()
    {
        $method = "GET";

        $request = $this->withMethod($method);

        $request->getMethod()->shouldReturn($method);
    }

    /**
     * This method MUST be implemented in such a way as to retain the
     * immutability of the message, and MUST return an instance that has the
     * changed request method.
     */
    function it_retains_its_method_when_creating_a_request_with_a_new_method()
    {
        $method = "GET";

        $request = $this->withMethod($method);

        $request->getMethod()->shouldReturn($method);
        $this->getMethod()->shouldReturn("HEAD");
    }

    /**
     * Throws \InvalidArgumentException for invalid HTTP methods.
     */
    function it_throws_an_exception_with_an_invalid_method()
    {
        $method = "FOO";

        $arguments = array($method);

        $this->shouldThrow('\InvalidArgumentException')->during("withMethod", $arguments);
    }

    /**
     * This method MUST return a UriInterface instance.
     */
    function it_returns_its_uri()
    {
        $this->getUri()->shouldReturnAnInstanceOf("UriInterface");
    }

    /**
     * This method MUST update the Host header of the returned request by
     * default if the URI contains a host component.
     *
     * @param \PhpSpec\Wrapper\Collaborator|UriInterface $uri
     */
    function it_returns_a_new_request_with_a_uri_with_host_replacement(UriInterface $uri)
    {
        $host = "www.baz.qux";

        $uri->getHost()->willReturn($host);

        $request = $this->withUri($uri);

        $request->getUri()->getHost()->shouldReturn($host);
        $request->getHeaderLine("host")->shouldReturn($host);
    }

    /**
     * You can opt-in to preserving the original state of the Host header by
     * setting `$preserveHost` to `true`.
     *
     * When `$preserveHost` is set to `true`, this method interacts with the
     * Host header in the following ways:
     *
     * - If a Host header is present and non-empty, this method MUST NOT update
     *   the Host header in the returned request.
     *
     * @param \PhpSpec\Wrapper\Collaborator|UriInterface $uri
     */
    function it_returns_a_new_request_with_a_uri_without_host_replacement(UriInterface $uri)
    {
        $old_host = $this->getHeaderLine("host");
        $new_host = "www.baz.qux";

        $uri->getHost()->willReturn($new_host);

        $request = $this->withUri($uri, true);

        $request->getHeaderLine("host")->shouldReturn($old_host);
        $request->getUri()->getHost()->shouldReturn($new_host);
    }

    /**
     * When `$preserveHost` is set to `true`, this method interacts with the
     * Host header in the following ways:
     *
     * - If the Host header is missing or empty, and the new URI contains
     *   a host component, this method MUST update the Host header in the returned
     *   request.
     *
     * @param \PhpSpec\Wrapper\Collaborator|UriInterface $uri
     */
    function it_returns_a_new_request_with_a_host_when_no_host_set(UriInterface $uri)
    {
        $host = "www.baz.qux";

        $uri->getHost()->willReturn($host);

        $no_host = $this->withoutHeader("host");

        $request = $no_host->withUri($uri, true);

        $request->getHeaderLine("host")->shouldReturn($host);
    }

    /**
     * When `$preserveHost` is set to `true`, this method interacts with the
     * Host header in the following ways:
     *
     * - If the Host header is missing or empty, and the new URI contains
     *   a host component, this method MUST update the Host header in the returned
     *   request.
     *
     * @param \PhpSpec\Wrapper\Collaborator|UriInterface $uri
     */
    function it_returns_a_new_request_with_a_host_when_empty_host_set(UriInterface $uri)
    {
        $host = "www.baz.qux";

        $uri->getHost()->willReturn($host);

        $empty_host = $this->withHeader("host","");

        $request = $empty_host->withUri($uri, true);

        $request->getHeaderLine("host")->shouldReturn($host);
    }

    /**
     * When `$preserveHost` is set to `true`, this method interacts with the
     * Host header in the following ways:
     *
     * - If the Host header is missing or empty, and the new URI does not contain a
     *   host component, this method MUST NOT update the Host header in the returned
     *   request.
     *
     * @param \PhpSpec\Wrapper\Collaborator|UriInterface $uri
     */
    function it_preserves_its_original_empty_host_with_a_hostless_uri(UriInterface $uri)
    {
        $uri->getHost()->willReturn(null);

        $empty_host = $this->withHeader("host","");

        $request = $empty_host->withUri($uri);

        $request->getHeaderLine("host")->shouldReturn("");
    }

    /**
     * This method MUST be implemented in such a way as to retain the
     * immutability of the message, and MUST return an instance that has the
     * new UriInterface instance.
     *
     * @param \PhpSpec\Wrapper\Collaborator|UriInterface $old_uri
     * @param \PhpSpec\Wrapper\Collaborator|UriInterface $new_uri
     */
    function it_retains_its_uri_when_returning_a_new_request_with_a_uri(UriInterface $old_uri,
                                                                        UriInterface $new_uri)
    {
        $old_uri->getHost()->willReturn("www.foo.bar");
        $new_uri->getHost()->willReturn("www.baz.qux");

        $request = $this->withUri($new_uri);

        $request->getUri()->getHost()->shouldReturn("www.baz.qux");
        $this->getUri()->getHost()->shouldReturn("www.foo.bar");
    }
}