minitest-rack 0.2.0

data/lib/minitest/rack/headers.rb

@@ -0,0 +1,298 @@
+# frozen_string_literal: true
+
+require 'minitest/assertions'
+require 'minitest/spec'
+
+# reopening to add validations functionality
+module Minitest
+  # add support for Assert syntax
+  module Assertions
+    # Test if a specific response header has an expected value
+    # Essentially, a shortcut for testing the `last_response.header` value
+    #
+    # @param [String] header The name of the HTTP header to check
+    # @param [String] contents The expected value of the header
+    #
+    # @return [Boolean] True if header matches expected value
+    #
+    # Example:
+    #    assert_header('Accept', 'text/plain')
+    #
+    def assert_header(header, contents)
+      msg = "Expected response header '#{header}' to be '#{contents}', "
+      msg << "but was '#{last_response.headers[header]}'"
+
+      assert_equal(contents, last_response.headers[header], msg)
+    end
+
+    # Tests that a header contains the Accept content-type
+    # Accept indicates which content-types the client can process
+    #
+    # @param [String] type The content-type to check for
+    #
+    # @return [Boolean] True if Accept header matches the specified type
+    #
+    # Example:
+    #    assert_header_accept("text/plain")
+    #
+    def assert_header_accept(type)
+      assert_header('Accept', type)
+    end
+
+    # Test for the `application/` type header via `Content-Type`
+    # Valid application types include pdf, json, xml, etc.
+    #
+    # @param [String] type The application content-type suffix (e.g. "pdf", "json")
+    #
+    # @return [Boolean] True if Content-Type header matches "application/type"
+    #
+    # Example:
+    #   assert_header_application_type('pdf')
+    #   # Tests Content-Type equals 'application/pdf'
+    #
+    def assert_header_application_type(type)
+      assert_header('Content-Type', "application/#{type}")
+    end
+
+    # Test if Content-Encoding header matches expected value
+    # Content-Encoding specifies what encodings have been applied to the payload.
+    # Common encoding types include gzip, compress, deflate, br
+    #
+    # @param [String] encoding_str The expected content encoding value
+    #
+    # @return [Boolean] True if Content-Encoding matches expected value
+    #
+    # Example:
+    #   assert_header_content_encoding('gzip')
+    #
+    #   assert_header_encoding('gzip')
+    #
+    def assert_header_content_encoding(encoding_str)
+      assert_header('Content-Encoding', encoding_str)
+    end
+    alias assert_header_encoding assert_header_content_encoding
+
+    # Tests that the Content-Language header matches an expected value
+    # Content-Language indicates the language of the content returned by the server
+    #
+    # @param [String] lang The expected language value
+    #
+    # @return [Boolean] True if Content-Language matches the expected value
+    #
+    # Example:
+    #   assert_header_content_language('en')
+    #   assert_header_content_language('fr')
+    #
+    def assert_header_content_language(lang)
+      assert_header('Content-Language', lang)
+    end
+    alias assert_header_language assert_header_content_language
+
+    # Tests that the Content-Length header matches the expected value
+    # Content-Length specifies the size of the response body in bytes
+    #
+    # @param [String, Integer] length The expected content length value
+    #
+    # @return [Boolean] True if Content-Length matches the expected value
+    #
+    # Example:
+    #   assert_header_content_length(348)
+    #   assert_header_content_length("348")
+    #
+    def assert_header_content_length(length)
+      assert_header('Content-Length', length.to_s)
+    end
+
+    # Test if Content-Location header matches expected value
+    # Content-Location indicates an alternate location for the returned data
+    #
+    # @param [String] url The expected alternate URL value
+    #
+    # @return [Boolean] True if Content-Location matches expected value
+    #
+    # Example:
+    #   assert_header_content_location('/index.htm')
+    #
+    def assert_header_content_location(url)
+      assert_header('Content-Location', url.to_s)
+    end
+
+    # Tests that the Content-Type header matches an expected value
+    # Content-Type specifies the MIME type of the content being sent
+    #
+    # @param [String] type The expected MIME type
+    #
+    # @return [Boolean] True if Content-Type matches expected value
+    #
+    # Example:
+    #   assert_header_content_type('text/html; charset=utf-8')
+    #
+    def assert_header_content_type(type)
+      assert_header('Content-Type', type)
+    end
+
+    # Tests that the ETag header matches an expected value
+    # ETag is a unique identifier for a specific version of a resource, often a hash
+    #
+    # @param [String] tag The expected ETag value
+    #
+    # @return [Boolean] True if ETag matches expected value
+    #
+    # Example:
+    #   assert_header_etag('"737060cd8c284d8af7ad3082f209582d"')
+    #
+    def assert_header_etag(tag)
+      assert_header('ETag', tag)
+    end
+
+    # Tests that the Expires header matches an expected timestamp
+    # Expires defines when the response should be considered stale
+    #
+    # @param [String] timestamp The expected expiration date in HTTP-date format
+    #
+    # @return [Boolean] True if Expires matches expected timestamp
+    #
+    # Example:
+    #   assert_header_expires('Thu, 01 Dec 1994 16:00:00 GMT')
+    #
+    def assert_header_expires(timestamp)
+      assert_header('Expires', timestamp)
+    end
+
+    # Tests that the Content-Type header matches an image MIME type
+    # Validates that content is an image with the specified format
+    #
+    # @param [String, Symbol] type The expected image format (bmp, gif, jpg, jpeg, png, tiff)
+    #
+    # @return [Boolean] True if Content-Type matches "image/type"
+    #
+    # Example:
+    #   assert_header_image_type('png')
+    #   # Tests Content-Type equals 'image/png'
+    #
+    def assert_header_image_type(type)
+      assert_header('Content-Type', "image/#{type}")
+    end
+
+    # Tests that the Last-Modified header matches an expected timestamp
+    # Last-Modified indicates when the resource was last changed
+    #
+    # @param [String] timestamp The expected last modified date in HTTP-date format
+    #
+    # @return [Boolean] True if Last-Modified matches expected timestamp
+    #
+    # Example:
+    #   assert_header_last_modified('Tue, 15 Nov 1994 12:45:26 GMT')
+    #
+    def assert_header_last_modified(timestamp)
+      assert_header('Last-Modified', timestamp)
+    end
+
+    # Tests that the Server header matches an expected value
+    # Server specifies information about the software used by the origin server
+    #
+    # @param [String] server_str The expected server identification string
+    #
+    # @return [Boolean] True if Server header matches expected value
+    #
+    # Example:
+    #   assert_header_server('Apache/2.4.1 (Unix)')
+    #
+    def assert_header_server(server_str)
+      assert_header('Server', server_str)
+    end
+
+    # Test for the `text/` type header via `Content-Type`
+    # Tests that the Content-Type header matches a text/* MIME type
+    #
+    # @param [String] type The text content-type suffix (e.g. "plain", "html")
+    #
+    # @return [Boolean] True if Content-Type header matches "text/type"
+    #
+    # Example:
+    #   assert_header_text_type('plain')
+    #   # Tests Content-Type equals 'text/plain'
+    #
+    def assert_header_text_type(type)
+      assert_header('Content-Type', "text/#{type}")
+    end
+
+    # Tests that the WWW-Authenticate header matches an expected value
+    # WWW-Authenticate indicates the authentication scheme that should be used
+    # to access the requested resource
+    #
+    # @param [String] auth_str The expected authentication scheme value
+    #
+    # @return [Boolean] True if WWW-Authenticate matches expected value
+    #
+    # Example:
+    #   assert_header_www_authenticate('Basic')
+    #   assert_header_www_authenticate('Bearer realm="example"')
+    #
+    def assert_header_www_authenticate(auth_str)
+      assert_header('WWW-Authenticate', auth_str)
+    end
+
+    # Tests that the Content-Disposition header indicates an attachment download
+    # Content-Disposition suggests whether content should be displayed inline or downloaded
+    # as an attachment with an optional filename
+    #
+    # Raise a "File Download" dialogue box for a known MIME type with binary format or suggest
+    # a filename for dynamic content. Quotes are necessary with special characters
+    #
+    # @param [String] filename The suggested filename for the attachment
+    #
+    # @return [Boolean] True if Content-Disposition matches expected attachment format
+    #
+    # Example:
+    #   assert_header_attachment('document.pdf')
+    #   # Tests Content-Disposition equals 'attachment; filename="document.pdf"'
+    #
+    def assert_header_attachment(filename)
+      assert_header('Content-Disposition', "attachment; filename=\"#{filename}\"")
+    end
+
+    # Tests that the Content-Type header is set to "application/json"
+    # Validates that the response is formatted as JSON data
+    #
+    # @return [Boolean] True if Content-Type matches "application/json"
+    #
+    # Example:
+    #   assert_header_type_is_json
+    #   # Tests Content-Type equals 'application/json'
+    #
+    def assert_header_type_is_json
+      assert_header('Content-Type', 'application/json')
+    end
+  end
+  # /module Assertions
+
+  # add support for Spec syntax
+  module Expectations
+    infect_an_assertion :assert_header_accept, :must_have_header_accept, :reverse
+    infect_an_assertion :assert_header_application_type, :must_have_header_application_type,
+                        :reverse
+    infect_an_assertion :assert_header_content_encoding, :must_have_header_content_encoding,
+                        :reverse
+    infect_an_assertion :assert_header_content_language, :must_have_header_content_language,
+                        :reverse
+    infect_an_assertion :assert_header_content_length, :must_have_header_content_length,
+                        :reverse
+    infect_an_assertion :assert_header_content_location, :must_have_header_content_location,
+                        :reverse
+    infect_an_assertion :assert_header_content_type, :must_have_header_content_type,
+                        :reverse
+    infect_an_assertion :assert_header_etag, :must_have_header_etag, :reverse
+    infect_an_assertion :assert_header_expires, :must_have_header_expires, :reverse
+    infect_an_assertion :assert_header_image_type, :must_have_header_image_type,
+                        :reverse
+    infect_an_assertion :assert_header_last_modified, :must_have_header_last_modified,
+                        :reverse
+    infect_an_assertion :assert_header_server, :must_have_header_server, :reverse
+    infect_an_assertion :assert_header_text_type, :must_have_header_text_type, :reverse
+    infect_an_assertion :assert_header_www_authenticate, :must_have_header_www_authenticate,
+                        :reverse
+    infect_an_assertion :assert_header_attachment, :must_have_header_attachment, :reverse
+    infect_an_assertion :assert_header_type_is_json, :must_have_header_type_as_json, :reverse
+  end
+end

data/lib/minitest/rack/json.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: false
+
+require 'rack/test'
+require 'json'
+require 'minitest/assertions'
+require 'minitest/spec'
+
+# reopening to add validations functionality
+module Minitest
+  # add support for Assert syntax
+  module Assertions
+    # Parse the response body of the last response as JSON using the native Ruby
+    # JSON parser. This method helps in quickly grabbing the JSON data from the
+    # response to verify in assertions.
+    #
+    # @return [Hash] parsed JSON data from the response body
+    #
+    def json_data
+      ::JSON.parse(last_response.body)
+    end
+
+    # Asserts against the presence of specific key/value pairs in the response JSON data. When
+    # testing endpoint responses for JSON data conformity, it ensures the response matches the
+    # expected data exactly. Takes a hash of expected data and validates it against the parsed
+    # JSON response.
+    #
+    # @param res [Hash] hash containing the expected key/value pairs that should be
+    # present in the JSON response data
+    #
+    # @return [Boolean] true when response data matches expected data
+    #
+    # @example
+    #   # Response body contains: {"id": 1, "name": "test"}
+    #   assert_json_data({id: 1, name: "test"}) # => true
+    #
+    def assert_json_data(res)
+      data = json_data
+
+      msg = "Expected response JSON data to be '#{res}', but was '#{data}'"
+
+      assert_equal(res, data, msg)
+    end
+
+    # Verify if the response JSON data contains a success attribute with specified truth value.
+    # This method specifically checks for the presence of a "success" key and validates its
+    # value against the expected boolean. By default, it expects true unless otherwise specified.
+    #
+    # @param bool [Boolean] the expected value of success attribute (defaults to true)
+    #
+    # @return [Boolean] true when the success value matches the expected boolean
+    #
+    def assert_json_success(bool: true)
+      data = json_data
+
+      msg = "Expected response JSON data to include '\"success\": #{bool}', "
+      msg << "but was '#{data.inspect}'"
+
+      assert_equal(bool, data['success'], msg)
+    end
+
+    # Asserts that the response JSON data contains an 'error' attribute with the specified
+    # error code and validates that its value matches the expected error code string.
+    # Default error code is "404" if none specified.
+    #
+    # @param errno [String] the expected error code value (defaults to "404")
+    #
+    # @return [Boolean] true when the error value matches the expected error code
+    #
+    def assert_json_error(errno = '404')
+      data = json_data
+
+      msg = "Expected response JSON data to include '\"error\": #{errno}', "
+      msg << "but was '#{data.inspect}'"
+
+      assert_equal(errno.to_s, data['error'].to_s, msg)
+    end
+
+    # Verifies that the response JSON data contains a message attribute with the
+    # specified message string.
+    # This method checks for the presence of a "message" key and validates that its
+    # value matches the expected message text.
+    #
+    # @param msg [String] the expected message value to check for in the response
+    #
+    # @return [Boolean] true when the message value matches the expected message string
+    #
+    def assert_json_message(message)
+      data = json_data
+
+      msg = "Expected response JSON data to include '\"message\": #{message}', "
+      msg << "but was '#{data.inspect}'"
+
+      assert_equal(message, data['message'], msg)
+    end
+
+    # Verifies that the response JSON data contains a specific model attribute with
+    # the expected model data.
+    # This method checks if the response contains a key matching the provided model name and
+    # validates that its JSON representation matches the expected model object.
+    #
+    # @param key [String, Symbol] the model key to check for in the response
+    # @param model [Object] the model object whose JSON representation matches the response data
+    #
+    # @return [Boolean] true when the model JSON matches the response data for the given key
+    #
+    # @example
+    #   # Response body contains: {"user": {"id": 1, "name": "Bob"}}
+    #   user = User.new(id: 1, name: "Bob")
+    #   assert_json_model('user', user) # => true
+    #
+    def assert_json_model(key, model)
+      data = json_data
+      key = key.to_s
+
+      msg = 'Expected response JSON data to include '
+
+      # handle wrong key value being passed
+      if data.key?(key)
+        msg << "'#{key}: #{model.to_json}', but was '#{data[key].to_json}'"
+
+        assert_equal(model.values.to_json, data[key].to_json, msg)
+      else
+        msg << "key: '#{key}', but JSON is: '#{data}'"
+
+        assert_has_key data, key, msg
+      end
+    end
+
+    # Verifies that the response JSON data contains the specified key with a non-empty value.
+    # This method checks for the presence of a given key in the response and validates that
+    # its value is not empty, ensuring the expected data field exists and has content.
+    #
+    # @param key [String, Symbol] the key to check for in the response
+    #
+    # @return [Boolean] true when the key exists and has a non-empty value
+    #
+    def assert_json_key(key)
+      data = json_data
+      key = key.to_s
+
+      msg = 'Expected response JSON data to include '
+      msg << "key: '#{key}', but JSON is '#{data}'"
+
+      # handle the model being present
+      if data.key?(key)
+        refute_empty(data[key], msg)
+      else
+        assert_has_key data, key, msg
+      end
+    end
+
+    # Verifies that the response JSON data contains a nested key within a model attribute
+    # and that the key's value is not empty.
+    # This method checks if the response contains a model key and a nested key within it,
+    # validating that the nested key's value exists and is not empty.
+    #
+    # @param model [String, Symbol] the model key to check for in the response
+    # @param key [String, Symbol] the nested key to check within the model object
+    #
+    # @return [Boolean] true when the nested key exists and has a non-empty value
+    #
+    # rubocop:disable Metrics/MethodLength
+    def assert_json_model_key(model, key)
+      data = json_data
+      model = model.to_s
+      key = key.to_s
+
+      msg = 'Expected response JSON data to include '
+
+      # handle the model being present
+      if data.key?(model)
+        if data[model].key?(key)
+          msg = 'life is great'
+
+          refute_empty(data[model][key], msg)
+        else
+          msg << "model.key: '#{model}.#{key}', but it did not"
+
+          assert_has_key data, "#{model}.#{key}", msg
+        end
+      else
+        msg << "model: '#{model}', but it did not"
+
+        assert_has_key data, model, msg
+      end
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    # Shortcut for sending GET requests as JSON
+    #
+    #     get_json("/api/users")
+    #
+    def get_json(path, params = {}, headers = {})
+      json_request(:get, path, params, headers)
+    end
+
+    # Shortcut for sending POST requests as JSON
+    #
+    #     post_json("/api/users", {name: "Joe"})
+    #
+    def post_json(path, params = {}, headers = {})
+      json_request(:post, path, params, headers)
+    end
+
+    # Shortcut for sending PUT requests as JSON
+    #
+    #     put_json("/api/users/1234", {id: 1, name: "Joe"})
+    #
+    def put_json(path, params = {}, headers = {})
+      json_request(:put, path, params, headers)
+    end
+
+    # Shortcut for sending DELETE requests as JSON
+    #
+    #     delete_json("/api/users/1234")
+    #
+    def delete_json(path, params = {}, headers = {})
+      json_request(:delete, path, params, headers)
+    end
+
+    private
+
+    # Makes an HTTP request with JSON data. This helper method is used by the HTTP verb shortcuts
+    # (get_json, post_json, etc) to standardize JSON request handling. It converts the params
+    # to JSON and sets the appropriate content type header.
+    #
+    # @param verb [Symbol] the HTTP verb to use (:get, :post, :put, :delete)
+    # @param path [String] the URL path for the request
+    # @param params [Hash] parameters to be converted to JSON and sent with request (default: {})
+    # @param headers [Hash] HTTP headers to include with request (default: {})
+    #
+    # @return [Response] the response from the HTTP request
+    #
+    def json_request(verb, path, params = {}, headers = {})
+      send(verb, path, params.to_json, headers.merge({ 'Content-Type' => 'application/json' }))
+    end
+  end
+  # /module Assertions
+
+  # add support for Spec syntax
+  module Expectations
+    infect_an_assertion :assert_json_data, :must_have_json_data, :reverse
+    infect_an_assertion :assert_json_success, :must_have_json_success, :reverse
+    infect_an_assertion :assert_json_error, :must_have_json_error, :reverse
+    infect_an_assertion :assert_json_message, :must_have_json_message, :reverse
+    infect_an_assertion :assert_json_key, :must_have_json_key, :reverse
+    infect_an_assertion :assert_json_model, :must_have_json_model, :reverse
+    infect_an_assertion :assert_json_model_key, :must_have_json_model_key, :reverse
+  end
+end