ultra-fast-box 0.0.1

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/action_controller/render_with_layout_matcher.rb

@@ -0,0 +1,145 @@
+module Shoulda
+  module Matchers
+    module ActionController
+      # The `render_with_layout` matcher asserts that an action is rendered with
+      # a particular layout.
+      #
+      #     class PostsController < ApplicationController
+      #       def show
+      #         render layout: 'posts'
+      #       end
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe PostsController, type: :controller do
+      #       describe 'GET #show' do
+      #         before { get :show }
+      #
+      #         it { should render_with_layout('posts') }
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class PostsControllerTest < ActionController::TestCase
+      #       context 'GET #show' do
+      #         setup { get :show }
+      #
+      #         should render_with_layout('posts')
+      #       end
+      #     end
+      #
+      # It can also be used to assert that the action is not rendered with a
+      # layout at all:
+      #
+      #     class PostsController < ApplicationController
+      #       def sidebar
+      #         render layout: false
+      #       end
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe PostsController, type: :controller do
+      #       describe 'GET #sidebar' do
+      #         before { get :sidebar }
+      #
+      #         it { should_not render_with_layout }
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class PostsControllerTest < ActionController::TestCase
+      #       context 'GET #sidebar' do
+      #         setup { get :sidebar }
+      #
+      #         should_not render_with_layout
+      #       end
+      #     end
+      #
+      # @return [RenderWithLayoutMatcher]
+      #
+      def render_with_layout(expected_layout = nil)
+        RenderWithLayoutMatcher.new(expected_layout).in_context(self)
+      end
+
+      # @private
+      class RenderWithLayoutMatcher
+        def initialize(expected_layout)
+          @expected_layout =
+            if expected_layout
+              expected_layout.to_s
+            else
+              nil
+            end
+          @controller = nil
+        end
+
+        # Used to provide access to layouts recorded by
+        # ActionController::TemplateAssertions in Rails 3
+        def in_context(context)
+          @context = context
+          self
+        end
+
+        def matches?(controller)
+          @controller = controller
+          rendered_with_layout? && rendered_with_expected_layout?
+        end
+
+        def failure_message
+          "Expected #{expectation}, but #{result}"
+        end
+
+        def failure_message_when_negated
+          "Did not expect #{expectation}, but #{result}"
+        end
+
+        def description
+          String.new('render with ').tap do |string|
+            string <<
+              if @expected_layout.nil?
+                'a layout'
+              else
+                "the #{@expected_layout.inspect} layout"
+              end
+          end
+        end
+
+        private
+
+        def rendered_with_layout?
+          !rendered_layouts.empty?
+        end
+
+        def rendered_with_expected_layout?
+          @expected_layout.nil? || rendered_layouts.include?(@expected_layout)
+        end
+
+        def rendered_layouts
+          recorded_layouts.keys.compact.map { |layout|
+            layout.sub(%r{^layouts/}, '')
+          }
+        end
+
+        def recorded_layouts
+          if @context
+            @context.instance_variable_get('@_layouts')
+          else
+            {}
+          end
+        end
+
+        def expectation
+          "to #{description}"
+        end
+
+        def result
+          if rendered_with_layout?
+            "rendered with #{rendered_layouts.map(&:inspect).join(', ')}"
+          else
+            'rendered without a layout'
+          end
+        end
+      end
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/action_controller/rescue_from_matcher.rb

@@ -0,0 +1,115 @@
+module Shoulda
+  module Matchers
+    module ActionController
+      # The `rescue_from` matcher tests usage of the `rescue_from` macro. It
+      # asserts that an exception and method are present in the list of
+      # exception handlers, and that the handler method exists.
+      #
+      #     class ApplicationController < ActionController::Base
+      #       rescue_from ActiveRecord::RecordNotFound, with: :handle_not_found
+      #
+      #       private
+      #
+      #       def handle_not_found
+      #         # ...
+      #       end
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe ApplicationController, type: :controller do
+      #       it do
+      #         should rescue_from(ActiveRecord::RecordNotFound).
+      #           with(:handle_not_found)
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class ApplicationControllerTest < ActionController::TestCase
+      #       should rescue_from(ActiveRecord::RecordNotFound).
+      #         with(:handle_not_found)
+      #     end
+      #
+      # @return [RescueFromMatcher]
+      #
+      def rescue_from(exception)
+        RescueFromMatcher.new exception
+      end
+
+      # @private
+      class RescueFromMatcher
+        def initialize(exception)
+          @exception = exception
+          @expected_method = nil
+          @controller = nil
+        end
+
+        def with(method)
+          @expected_method = method
+          self
+        end
+
+        def matches?(controller)
+          @controller = controller
+          rescues_from_exception? && method_name_matches? && handler_exists?
+        end
+
+        def description
+          description = "rescue from #{exception}"
+          description << " with ##{expected_method}" if expected_method
+          description
+        end
+
+        def failure_message
+          "Expected #{expectation}"
+        end
+
+        def failure_message_when_negated
+          "Did not expect #{expectation}"
+        end
+
+        protected
+
+        attr_reader :controller, :exception, :expected_method, :handlers
+
+        def expectation
+          expectation = "#{controller} to rescue from #{exception}"
+
+          if expected_method && !method_name_matches?
+            expectation << " with ##{expected_method}"
+          end
+
+          unless handler_exists?
+            expectation << " but #{controller} does not respond to"\
+              " #{expected_method}"
+          end
+          expectation
+        end
+
+        def rescues_from_exception?
+          @handlers = controller.rescue_handlers.select do |handler|
+            handler.first == exception.to_s
+          end
+          handlers.any?
+        end
+
+        def method_name_matches?
+          if expected_method.present?
+            handlers.any? do |handler|
+              handler.last == expected_method
+            end
+          else
+            true
+          end
+        end
+
+        def handler_exists?
+          if expected_method.present?
+            controller.respond_to? expected_method, true
+          else
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/action_controller/respond_with_matcher.rb

@@ -0,0 +1,148 @@
+module Shoulda
+  module Matchers
+    module ActionController
+      # The `respond_with` matcher tests that an action responds with a certain
+      # status code.
+      #
+      # You can specify that the status should be a number:
+      #
+      #     class PostsController < ApplicationController
+      #       def index
+      #         render status: 403
+      #       end
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe PostsController, type: :controller do
+      #       describe 'GET #index' do
+      #         before { get :index }
+      #
+      #         it { should respond_with(403) }
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class PostsControllerTest < ActionController::TestCase
+      #       context 'GET #index' do
+      #         setup { get :index }
+      #
+      #         should respond_with(403)
+      #       end
+      #     end
+      #
+      # You can specify that the status should be within a range of numbers:
+      #
+      #     class PostsController < ApplicationController
+      #       def destroy
+      #         render status: 508
+      #       end
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe PostsController, type: :controller do
+      #       describe 'DELETE #destroy' do
+      #         before { delete :destroy }
+      #
+      #         it { should respond_with(500..600) }
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class PostsControllerTest < ActionController::TestCase
+      #       context 'DELETE #destroy' do
+      #         setup { delete :destroy }
+      #
+      #         should respond_with(500..600)
+      #       end
+      #     end
+      #
+      # Finally, you can specify that the status should be a symbol:
+      #
+      #     class PostsController < ApplicationController
+      #       def show
+      #         render status: :locked
+      #       end
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe PostsController, type: :controller do
+      #       describe 'GET #show' do
+      #         before { get :show }
+      #
+      #         it { should respond_with(:locked) }
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class PostsControllerTest < ActionController::TestCase
+      #       context 'GET #show' do
+      #         setup { get :show }
+      #
+      #         should respond_with(:locked)
+      #       end
+      #     end
+      #
+      # @return [RespondWithMatcher]
+      #
+      def respond_with(status)
+        RespondWithMatcher.new(status)
+      end
+
+      # @private
+      class RespondWithMatcher
+        def initialize(status)
+          @status = symbol_to_status_code(status)
+        end
+
+        def matches?(controller)
+          @controller = controller
+          correct_status_code? || correct_status_code_range?
+        end
+
+        def failure_message
+          "Expected #{expectation}"
+        end
+
+        def failure_message_when_negated
+          "Did not expect #{expectation}"
+        end
+
+        def description
+          "respond with #{@status}"
+        end
+
+        protected
+
+        def correct_status_code?
+          response_code == @status
+        end
+
+        def correct_status_code_range?
+          @status.is_a?(Range) &&
+            @status.include?(response_code)
+        end
+
+        def response_code
+          @controller.response.response_code
+        end
+
+        def symbol_to_status_code(potential_symbol)
+          case potential_symbol
+          when :success  then 200
+          when :redirect then 300..399
+          when :missing  then 404
+          when :error    then 500..599
+          when Symbol
+            ::Rack::Utils.status_code(potential_symbol)
+          else
+            potential_symbol
+          end
+        end
+
+        def expectation
+          "response to be a #{@status}, but was #{response_code}"
+        end
+      end
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/action_controller/route_matcher.rb

@@ -0,0 +1,207 @@
+module Shoulda
+  module Matchers
+    module ActionController
+      # The `route` matcher tests that a route resolves to a controller,
+      # action, and params; and that the controller, action, and params
+      # generates the same route. For an RSpec suite, this is like using a
+      # combination of `route_to` and `be_routable`. In a test suite using
+      # Minitest + Shoulda, it provides a more expressive syntax over
+      # `assert_routing`.
+      #
+      # You can use this matcher either in a controller test case or in a
+      # routing test case. For instance, given these routes:
+      #
+      #     My::Application.routes.draw do
+      #       get '/posts', to: 'posts#index'
+      #       get '/posts/:id', to: 'posts#show'
+      #     end
+      #
+      # You could choose to write tests for these routes alongside other tests
+      # for PostsController:
+      #
+      #     class PostsController < ApplicationController
+      #       # ...
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe PostsController, type: :controller do
+      #       it { should route(:get, '/posts').to(action: :index) }
+      #       it { should route(:get, '/posts/1').to(action: :show, id: 1) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class PostsControllerTest < ActionController::TestCase
+      #       should route(:get, '/posts').to(action: 'index')
+      #       should route(:get, '/posts/1').to(action: :show, id: 1)
+      #     end
+      #
+      # Or you could place the tests along with other route tests:
+      #
+      #     # RSpec
+      #     describe 'Routing', type: :routing do
+      #       it do
+      #         should route(:get, '/posts').
+      #           to(controller: :posts, action: :index)
+      #       end
+      #
+      #       it do
+      #         should route(:get, '/posts/1').
+      #           to('posts#show', id: 1)
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class RoutesTest < ActionController::IntegrationTest
+      #       should route(:get, '/posts').
+      #         to(controller: :posts, action: :index)
+      #
+      #       should route(:get, '/posts/1').
+      #         to('posts#show', id: 1)
+      #     end
+      #
+      # Notice that in the former case, as we are inside of a test case for
+      # PostsController, we do not have to specify that the routes resolve to
+      # this controller. In the latter case we specify this using the
+      # `controller` key passed to the `to` qualifier.
+      #
+      # #### Specifying a port
+      #
+      # If the route you're testing has a constraint on it that limits the route
+      # to a particular port, you can specify it by passing a `port` option to
+      # the matcher:
+      #
+      #     class PortConstraint
+      #       def initialize(port)
+      #         @port = port
+      #       end
+      #
+      #       def matches?(request)
+      #         request.port == @port
+      #       end
+      #     end
+      #
+      #     My::Application.routes.draw do
+      #       get '/posts',
+      #         to: 'posts#index',
+      #         constraints: PortConstraint.new(12345)
+      #     end
+      #
+      #     # RSpec
+      #     describe 'Routing', type: :routing do
+      #       it do
+      #         should route(:get, '/posts', port: 12345).
+      #           to('posts#index')
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class RoutesTest < ActionController::IntegrationTest
+      #       should route(:get, '/posts', port: 12345).
+      #         to('posts#index')
+      #     end
+      #
+      # #### Qualifiers
+      #
+      # ##### to
+      #
+      # Use `to` to specify the action (along with the controller, if needed)
+      # that the route resolves to.
+      #
+      # `to` takes either keyword arguments (`controller` and `action`) or a
+      # string that represents the controller/action pair:
+      #
+      #     route(:get, '/posts').to(action: index)
+      #     route(:get, '/posts').to(controller: :posts, action: index)
+      #     route(:get, '/posts').to('posts#index')
+      #
+      # If there are parameters in your route, then specify those too:
+      #
+      #     route(:get, '/posts/1').to('posts#show', id: 1)
+      #
+      # You may also specify special parameters such as `:format`:
+      #
+      #     route(:get, '/posts').to('posts#index', format: :json)
+      #
+      # @return [RouteMatcher]
+      #
+      def route(method, path, port: nil)
+        RouteMatcher.new(self, method, path, port:)
+      end
+
+      # @private
+      class RouteMatcher
+        def initialize(context, method, path, port: nil)
+          @context = context
+          @method = method
+          @path = add_port_to_path(normalize_path(path), port)
+          @params = {}
+        end
+
+        attr_reader :failure_message
+
+        def to(*args)
+          @params = RouteParams.new(args).normalize
+          self
+        end
+
+        def in_context(context)
+          @context = context
+          self
+        end
+
+        def matches?(controller)
+          guess_controller_if_necessary(controller)
+
+          route_recognized?
+        end
+
+        def description
+          "route #{method.to_s.upcase} #{path} to/from #{params.inspect}"
+        end
+
+        def failure_message_when_negated
+          "Didn't expect to #{description}"
+        end
+
+        private
+
+        attr_reader :context, :method, :path, :params
+
+        def normalize_path(path)
+          if path.start_with?('/')
+            path
+          else
+            "/#{path}"
+          end
+        end
+
+        def add_port_to_path(path, port)
+          if port
+            "https://example.com:#{port}" + path
+          else
+            path
+          end
+        end
+
+        def guess_controller_if_necessary(controller)
+          params[:controller] ||= controller.controller_path
+        end
+
+        def route_recognized?
+          context.send(
+            :assert_routing,
+            { method:, path: },
+            params,
+          )
+          true
+        rescue ::ActionController::RoutingError => e
+          @failure_message = e.message
+          false
+        rescue Shoulda::Matchers.assertion_exception_class => e
+          @failure_message = e.message
+          false
+        end
+      end
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/action_controller/route_params.rb

@@ -0,0 +1,62 @@
+module Shoulda
+  module Matchers
+    module ActionController
+      # @private
+      class RouteParams
+        PARAMS_TO_SYMBOLIZE = %i{format}.freeze
+
+        def initialize(args)
+          @args = args
+        end
+
+        def normalize
+          if controller_and_action_given_as_string?
+            extract_params_from_string
+          else
+            stringify_params
+          end
+        end
+
+        protected
+
+        attr_reader :args
+
+        def controller_and_action_given_as_string?
+          args[0].is_a?(String)
+        end
+
+        def extract_params_from_string
+          controller, action = args[0].split('#')
+          params = (args[1] || {}).merge!(controller:, action:)
+          normalize_values(params)
+        end
+
+        def stringify_params
+          normalize_values(args[0])
+        end
+
+        def normalize_values(hash)
+          hash.each_with_object({}) do |(key, value), hash_copy|
+            hash_copy[key] = symbolize_or_stringify(key, value)
+          end
+        end
+
+        def symbolize_or_stringify(key, value)
+          if PARAMS_TO_SYMBOLIZE.include?(key)
+            value.to_sym
+          else
+            stringify(value)
+          end
+        end
+
+        def stringify(value)
+          if value.is_a?(Array)
+            value.map(&:to_param)
+          else
+            value.to_param
+          end
+        end
+      end
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/action_controller/session_store.rb

@@ -0,0 +1,34 @@
+module Shoulda
+  module Matchers
+    module ActionController
+      # @private
+      class SessionStore
+        attr_accessor :controller
+
+        def name
+          'session'
+        end
+
+        def has_key?(key)
+          session.key?(key)
+        end
+
+        def has_value?(expected_value)
+          session.values.any? do |actual_value|
+            expected_value === actual_value
+          end
+        end
+
+        def empty?
+          session.empty?
+        end
+
+        private
+
+        def session
+          controller.session
+        end
+      end
+    end
+  end
+end