rails-controller-testing 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b486570e7d0fa1e6cbd86cad49274c879bf19641
+  data.tar.gz: 9f4c782aa60594ab5972199e086f0bf3ddbeb144
+SHA512:
+  metadata.gz: 35d62afcdc8d780b29b335504e3de0af159fbf4e70c2495a3ce74bfa396e91cbf23968bab6c0ad7e4825a24bc7eb4364582488cec0a4c0ef586943c8014ed8b8
+  data.tar.gz: d88b18199421f8140160327b8e0525382863f2c4470632a61e1b3801d8d5bcf7d7fbaeeab288bcdb04e277067fa0e2ccebd4f0c5c7d472398afe443ff99c7a30

data/Rakefile

@@ -0,0 +1,18 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/lib/rails-controller-testing.rb

@@ -0,0 +1,15 @@
+module Rails
+  module Controller
+    module Testing
+      autoload :TemplateAssertions, 'rails/controller/testing/template_assertions'
+      autoload :Integration, 'rails/controller/testing/integration'
+      autoload :TestProcess, 'rails/controller/testing/test_process'
+
+      extend ActiveSupport::Concern
+
+      include TemplateAssertions
+      include Integration
+      include TestProcess
+    end
+  end
+end

data/lib/rails/controller/testing/integration.rb

@@ -0,0 +1,18 @@
+module Rails
+  module Controller
+    module Testing
+      module Integration
+        %w(
+          get post patch put head delete xml_http_request
+          xhr get_via_redirect post_via_redirect
+        ).each do |method|
+
+          define_method(method) do |*args|
+            reset_template_assertion
+            super(*args)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails/controller/testing/template_assertions.rb

@@ -0,0 +1,192 @@
+module Rails
+  module Controller
+    module Testing
+      module TemplateAssertions
+        extend ActiveSupport::Concern
+
+        included do
+          setup :setup_subscriptions
+          teardown :teardown_subscriptions
+        end
+
+        RENDER_TEMPLATE_INSTANCE_VARIABLES = %w{partials templates layouts files}.freeze
+
+        def setup_subscriptions
+          RENDER_TEMPLATE_INSTANCE_VARIABLES.each do |instance_variable|
+            instance_variable_set("@_#{instance_variable}", Hash.new(0))
+          end
+
+          @_subscribers = []
+
+          @_subscribers << ActiveSupport::Notifications.subscribe("render_template.action_view") do |_name, _start, _finish, _id, payload|
+            path = payload[:layout]
+            if path
+              @_layouts[path] += 1
+              if path =~ /^layouts\/(.*)/
+                @_layouts[$1] += 1
+              end
+            end
+          end
+
+          @_subscribers << ActiveSupport::Notifications.subscribe("!render_template.action_view") do |_name, _start, _finish, _id, payload|
+            if virtual_path = payload[:virtual_path]
+              partial = virtual_path =~ /^.*\/_[^\/]*$/
+
+              if partial
+                @_partials[virtual_path] += 1
+                @_partials[virtual_path.split("/").last] += 1
+              end
+
+              @_templates[virtual_path] += 1
+            else
+              path = payload[:identifier]
+              if path
+                @_files[path] += 1
+                @_files[path.split("/").last] += 1
+              end
+            end
+          end
+        end
+
+        def teardown_subscriptions
+          @_subscribers.each do |subscriber|
+            ActiveSupport::Notifications.unsubscribe(subscriber)
+          end
+        end
+
+        def process(*args)
+          reset_template_assertion
+          super
+        end
+
+        def reset_template_assertion
+          RENDER_TEMPLATE_INSTANCE_VARIABLES.each do |instance_variable|
+            ivar_name = "@_#{instance_variable}"
+            if instance_variable_defined?(ivar_name)
+              instance_variable_get(ivar_name).clear
+            end
+          end
+        end
+
+        # Asserts that the request was rendered with the appropriate template file or partials.
+        #
+        #   # assert that the "new" view template was rendered
+        #   assert_template "new"
+        #
+        #   # assert that the exact template "admin/posts/new" was rendered
+        #   assert_template %r{\Aadmin/posts/new\Z}
+        #
+        #   # assert that the layout 'admin' was rendered
+        #   assert_template layout: 'admin'
+        #   assert_template layout: 'layouts/admin'
+        #   assert_template layout: :admin
+        #
+        #   # assert that no layout was rendered
+        #   assert_template layout: nil
+        #   assert_template layout: false
+        #
+        #   # assert that the "_customer" partial was rendered twice
+        #   assert_template partial: '_customer', count: 2
+        #
+        #   # assert that no partials were rendered
+        #   assert_template partial: false
+        #
+        #   # assert that a file was rendered
+        #   assert_template file: "README.rdoc"
+        #
+        #   # assert that no file was rendered
+        #   assert_template file: nil
+        #   assert_template file: false
+        #
+        # In a view test case, you can also assert that specific locals are passed
+        # to partials:
+        #
+        #   # assert that the "_customer" partial was rendered with a specific object
+        #   assert_template partial: '_customer', locals: { customer: @customer }
+        def assert_template(options = {}, message = nil)
+          # Force body to be read in case the template is being streamed.
+          response.body
+
+          case options
+          when NilClass, Regexp, String, Symbol
+            options = options.to_s if Symbol === options
+            rendered = @_templates
+            msg = message || sprintf("expecting <%s> but rendering with <%s>",
+                    options.inspect, rendered.keys)
+            matches_template =
+              case options
+              when String
+                !options.empty? && rendered.any? do |t, num|
+                  options_splited = options.split(File::SEPARATOR)
+                  t_splited = t.split(File::SEPARATOR)
+                  t_splited.last(options_splited.size) == options_splited
+                end
+              when Regexp
+                rendered.any? { |t,num| t.match(options) }
+              when NilClass
+                rendered.blank?
+              end
+            assert matches_template, msg
+          when Hash
+            options.assert_valid_keys(:layout, :partial, :locals, :count, :file)
+
+            if options.key?(:layout)
+              expected_layout = options[:layout]
+              msg = message || sprintf("expecting layout <%s> but action rendered <%s>",
+                      expected_layout, @_layouts.keys)
+
+              case expected_layout
+              when String, Symbol
+                assert_includes @_layouts.keys, expected_layout.to_s, msg
+              when Regexp
+                assert(@_layouts.keys.any? {|l| l =~ expected_layout }, msg)
+              when nil, false
+                assert(@_layouts.empty?, msg)
+              else
+                raise ArgumentError, "assert_template only accepts a String, Symbol, Regexp, nil or false for :layout"
+              end
+            end
+
+            if options[:file]
+              assert_includes @_files.keys, options[:file]
+            elsif options.key?(:file)
+              assert @_files.blank?, "expected no files but #{@_files.keys} was rendered"
+            end
+
+            if expected_partial = options[:partial]
+              if expected_locals = options[:locals]
+                if defined?(@_rendered_views)
+                  view = expected_partial.to_s.sub(/^_/, '').sub(/\/_(?=[^\/]+\z)/, '/')
+
+                  partial_was_not_rendered_msg = "expected %s to be rendered but it was not." % view
+                  assert_includes @_rendered_views.rendered_views, view, partial_was_not_rendered_msg
+
+                  msg = 'expecting %s to be rendered with %s but was with %s' % [expected_partial,
+                                                                                 expected_locals,
+                                                                                 @_rendered_views.locals_for(view)]
+                  assert(@_rendered_views.view_rendered?(view, options[:locals]), msg)
+                else
+                  warn "the :locals option to #assert_template is only supported in a ActionView::TestCase"
+                end
+              elsif expected_count = options[:count]
+                actual_count = @_partials[expected_partial]
+                msg = message || sprintf("expecting %s to be rendered %s time(s) but rendered %s time(s)",
+                         expected_partial, expected_count, actual_count)
+                assert(actual_count == expected_count.to_i, msg)
+              else
+                msg = message || sprintf("expecting partial <%s> but action rendered <%s>",
+                        options[:partial], @_partials.keys)
+                assert_includes @_partials, expected_partial, msg
+              end
+            elsif options.key?(:partial)
+              assert @_partials.empty?,
+                "Expected no partials to be rendered"
+            end
+          else
+            raise ArgumentError, "assert_template only accepts a String, Symbol, Hash, Regexp, or nil"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails/controller/testing/test_process.rb

@@ -0,0 +1,15 @@
+require 'active_support/core_ext/hash/indifferent_access'
+
+module Rails
+  module Controller
+    module Testing
+      module TestProcess
+        def assigns(key = nil)
+          assigns = {}.with_indifferent_access
+          @controller.view_assigns.each { |k, v| assigns.regular_writer(k, v) }
+          key.nil? ? assigns : assigns[key]
+        end
+      end
+    end
+  end
+end

data/lib/rails/controller/testing/version.rb

@@ -0,0 +1,7 @@
+module Rails
+  module Controller
+    module Testing
+      VERSION = "0.0.2"
+    end
+  end
+end

data/test/controllers/assigns_test.rb

@@ -0,0 +1,30 @@
+require 'test_helper'
+require 'rails-controller-testing'
+
+class AssignsControllerTest < ActionController::TestCase
+  include Rails::Controller::Testing
+
+  def test_assigns
+    process :test_assigns
+    # assigns can be accessed using assigns(key)
+    # or assigns[key], where key is a string or
+    # a symbol
+    assert_equal "foo", assigns(:foo)
+    assert_equal "foo", assigns("foo")
+    assert_equal "foo", assigns[:foo]
+    assert_equal "foo", assigns["foo"]
+
+    # but the assigned variable should not have its own keys stringified
+    expected_hash = { foo: :bar }
+    assert_equal expected_hash, assigns(:foo_hash)
+  end
+
+  def test_view_assigns
+    @controller = ViewAssignsController.new
+    process :test_assigns
+    assert_equal nil, assigns(:foo)
+    assert_equal nil, assigns[:foo]
+    assert_equal "bar", assigns(:bar)
+    assert_equal "bar", assigns[:bar]
+  end
+end

data/test/controllers/template_assertions_test.rb

@@ -0,0 +1,214 @@
+require 'test_helper'
+require 'rails-controller-testing'
+
+class TemplateAssertionsControllerTest < ActionController::TestCase
+  include Rails::Controller::Testing
+
+  def test_with_invalid_hash_keys_raises_argument_error
+    assert_raise(ArgumentError) do
+      assert_template foo: "bar"
+    end
+  end
+
+  def test_with_partial
+    get :render_with_partial
+    assert_template partial: '_partial'
+  end
+
+  def test_file_with_absolute_path_success
+    get :render_file_absolute_path
+    assert_template file: File.expand_path('../../dummy/README.rdoc', __FILE__)
+  end
+
+  def test_file_with_relative_path_success
+    get :render_file_relative_path
+    assert_template file: 'README.rdoc'
+  end
+
+  def test_with_file_failure
+    get :render_file_absolute_path
+
+    assert_raise(ActiveSupport::TestCase::Assertion) do
+      assert_template :file => 'test/hello_world'
+    end
+
+    get :render_file_absolute_path
+
+    assert_raise(ActiveSupport::TestCase::Assertion) do
+      assert_template file: nil
+    end
+  end
+
+  def test_with_nil_passes_when_no_template_rendered
+    get :render_nothing
+    assert_template nil
+  end
+
+  def test_with_nil_fails_when_template_rendered
+    get :render_with_template
+
+    assert_raise(ActiveSupport::TestCase::Assertion) do
+      assert_template nil
+    end
+  end
+
+  def test_with_empty_string_fails_when_template_rendered
+    get :render_with_template
+
+    assert_raise(ActiveSupport::TestCase::Assertion) do
+      assert_template ""
+    end
+  end
+
+  def test_with_empty_string_fails_when_no_template_rendered
+    get :render_nothing
+
+    assert_raise(ActiveSupport::TestCase::Assertion) do
+      assert_template ""
+    end
+  end
+
+  def test_passes_with_correct_string
+    get :render_with_template
+    assert_template 'hello_world'
+    assert_template 'test/hello_world'
+  end
+
+  def test_passes_with_correct_symbol
+    get :render_with_template
+    assert_template :hello_world
+  end
+
+  def test_fails_with_incorrect_string
+    get :render_with_template
+
+    assert_raise(ActiveSupport::TestCase::Assertion) do
+      assert_template 'hello_planet'
+    end
+  end
+
+  def test_fails_with_incorrect_string_that_matches
+    get :render_with_template
+
+    assert_raise(ActiveSupport::TestCase::Assertion) do
+      assert_template 'est/he'
+    end
+  end
+
+  def test_fails_with_repeated_name_in_path
+    get :render_with_template_repeating_in_path
+
+    assert_raise(ActiveSupport::TestCase::Assertion) do
+      assert_template 'test/hello'
+    end
+  end
+
+  def test_fails_with_incorrect_symbol
+    get :render_with_template
+
+    assert_raise(ActiveSupport::TestCase::Assertion) do
+      assert_template :hello_planet
+    end
+  end
+
+  def test_fails_with_incorrect_symbol_that_matches
+    get :render_with_template
+
+    assert_raise(ActiveSupport::TestCase::Assertion) do
+      assert_template :"est/he"
+    end
+  end
+
+  def test_fails_with_wrong_layout
+    get :render_with_layout
+
+    assert_raise(ActiveSupport::TestCase::Assertion) do
+      assert_template layout: "application"
+    end
+  end
+
+  def test_fails_expecting_no_layout
+    get :render_with_layout
+
+    assert_raise(ActiveSupport::TestCase::Assertion) do
+      assert_template layout: nil
+    end
+  end
+
+  def test_fails_expecting_not_known_layout
+    get :render_with_layout
+
+    assert_raise(ArgumentError) do
+      assert_template layout: 1
+    end
+  end
+
+  def test_passes_with_correct_layout
+    get :render_with_layout
+    assert_template layout: "layouts/standard"
+  end
+
+  def test_passes_with_layout_and_partial
+    get :render_with_layout_and_partial
+    assert_template layout: "layouts/standard"
+    assert_template partial: "test/_partial"
+  end
+
+  def test_passed_with_no_layout
+    get :render_with_template
+    assert_template layout: nil
+  end
+
+  def test_passed_with_no_layout_false
+    get :render_with_template
+    assert_template layout: false
+  end
+
+  def test_passes_with_correct_layout_without_layouts_prefix
+    get :render_with_layout
+    assert_template layout: "standard"
+  end
+
+  def test_passes_with_correct_layout_symbol
+    get :render_with_layout
+    assert_template layout: :standard
+  end
+
+  def test_assert_template_reset_between_requests
+    get :render_with_template
+    assert_template 'test/hello_world'
+
+    get :render_nothing
+    assert_template nil
+
+    get :render_with_partial
+    assert_template partial: 'test/_partial'
+
+    get :render_nothing
+    assert_template partial: nil
+
+    get :render_with_layout
+    assert_template layout: 'layouts/standard'
+
+    get :render_nothing
+    assert_template layout: nil
+
+    get :render_file_relative_path
+    assert_template file: 'README.rdoc'
+
+    get :render_nothing
+    assert_template file: nil
+  end
+
+  def test_locals_option_to_assert_template_is_not_supported
+    get :render_nothing
+
+    warning_buffer = StringIO.new
+    $stderr = warning_buffer
+
+    assert_template partial: 'customer_greeting', locals: { greeting: 'Bonjour' }
+    assert_includes warning_buffer.string, "the :locals option to #assert_template is only supported in a ActionView::TestCase\n"
+  ensure
+    $stderr = STDERR
+  end
+end