focused_controller 0.1.0

data/test/app/test/unit/controllers/posts_controller_test.rb

@@ -0,0 +1,67 @@
+require 'test_helper'
+
+class PostsController
+  class TestCase < ActiveSupport::TestCase
+    include FocusedController::TestHelper
+
+    setup do
+      @post = Post.create(:title => 'Hello', :body => 'Omg')
+    end
+  end
+
+  class IndexTest < TestCase
+    test "should get index" do
+      req
+      assert_response :success
+      assert_not_nil controller.posts
+    end
+  end
+
+  class NewTest < TestCase
+    test "should get new" do
+      req
+      assert_response :success
+    end
+  end
+
+  class CreateTest < TestCase
+    test "should create post" do
+      assert_difference('Post.count') do
+        req :post => @post.attributes
+      end
+
+      assert_redirected_to post_path(controller.post)
+    end
+  end
+
+  class ShowTest < TestCase
+    test "should show post" do
+      req :id => @post.id
+      assert_response :success
+    end
+  end
+
+  class EditTest < TestCase
+    test "should get edit" do
+      req :id => @post.id
+      assert_response :success
+    end
+  end
+
+  class UpdateTest < TestCase
+    test "should update post" do
+      req :id => @post.id
+      assert_redirected_to post_path(controller.post)
+    end
+  end
+
+  class DestroyTest < TestCase
+    test "should destroy post" do
+      assert_difference('Post.count', -1) do
+        req :id => @post.id
+      end
+
+      assert_redirected_to posts_path
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,33 @@
+require 'bundler/setup'
+require 'test/unit/testcase'
+require 'active_support/test_case'
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'focused_controller'
+require 'pathname'
+require 'ostruct'
+require 'rspec/core'
+
+TEST_ROOT = File.expand_path('..', __FILE__)
+
+# Don't want to actually use RSpec to run our tests
+module RSpec::Core::DSL
+  remove_method :describe
+end
+
+# Annoying monkey-patches. "require 'rspec/rails'" pulls in 'capybara/rails', if it
+# can, and capybara/rails assumes there is a full rails env present. So this is a
+# hack to make it not fail.
+module Rails
+  def self.version
+    '3.0'
+  end
+
+  def self.root
+    Pathname.new('')
+  end
+
+  def self.application
+    OpenStruct.new(:env_config => {}, :env_defaults => {})
+  end
+end

data/test/unit/functional_test_helper_test.rb

@@ -0,0 +1,65 @@
+require 'helper'
+require 'focused_controller/functional_test_helper'
+require 'action_controller'
+
+module FocusedController
+  module FunctionalTestHelper
+    class FakePostsController
+      class Action < ActionController::Base; end
+      class Index < Action; end
+      class Show < Action; end
+
+      class TestCase < ActionController::TestCase
+        include FocusedController::FunctionalTestHelper
+
+        def initialize(method_name = :foo)
+          super
+        end
+
+        def foo; end
+      end
+
+      class IndexTest < TestCase
+      end
+
+      class ShowTest < TestCase
+      end
+    end
+
+    describe FunctionalTestHelper do
+      subject { FakePostsController::IndexTest.new }
+
+      it 'automatically determines the controller class' do
+        FakePostsController::IndexTest.controller_class.
+          must_equal FakePostsController::Index
+        FakePostsController::ShowTest.controller_class.
+          must_equal FakePostsController::Show
+      end
+
+      it "doesn't require using the action name to dispatch the action" do
+        subject.singleton_class.class_eval do
+          attr_reader :last_process
+
+          def process(*args)
+            @last_process = args
+          end
+        end
+
+        subject.get :foo, :bar, :baz
+        subject.last_process.must_equal ['run', :foo, :bar, :baz, 'GET']
+
+        subject.post :foo, :bar, :baz
+        subject.last_process.must_equal ['run', :foo, :bar, :baz, 'POST']
+
+        subject.put :foo, :bar, :baz
+        subject.last_process.must_equal ['run', :foo, :bar, :baz, 'PUT']
+
+        subject.delete :foo, :bar, :baz
+        subject.last_process.must_equal ['run', :foo, :bar, :baz, 'DELETE']
+
+        subject.head :foo, :bar, :baz
+        subject.last_process.must_equal ['run', :foo, :bar, :baz, 'HEAD']
+      end
+    end
+  end
+end

data/test/unit/mixin_test.rb

@@ -0,0 +1,70 @@
+require 'helper'
+require 'action_controller'
+
+module FocusedController
+  module Test
+    class MixinTestBaseController
+      def view_assigns
+        {'some' => 'var'}
+      end
+    end
+
+    class MixinTestController < ActionController::Base
+      include FocusedController::Mixin
+
+      class << self
+        attr_accessor :name
+      end
+    end
+  end
+end
+
+module FocusedController
+  describe Mixin do
+    describe "with a PostsController::Show class" do
+      let(:klass) do
+        klass = Class.new(FocusedController::Test::MixinTestController)
+        klass.name = "PostsController::Show"
+        klass
+      end
+
+      subject { klass.new }
+
+      it "has a .controller_path of 'posts'" do
+        klass.controller_path.must_equal 'posts'
+      end
+
+      it "has a .call which dispatches the #run action" do
+        def klass.action(name)
+          if name.to_s == 'run'
+            proc { |env| "omg" }
+          end
+        end
+
+        klass.call(nil).must_equal "omg"
+      end
+
+      it "has an #action_name of 'show'" do
+        subject.action_name.must_equal 'show'
+      end
+
+      it "uses the run method for the action" do
+        subject.method_for_action('whatever').must_equal 'run'
+      end
+
+      it "removes all view assigns by default" do
+        subject.view_assigns.must_equal({})
+      end
+
+      it "can be configured to allow view assigns" do
+        subject.class.allow_view_assigns = true
+        subject.instance_variable_set('@foo', 'bar')
+        subject.view_assigns['foo'].must_equal('bar')
+      end
+
+      it "has a #run method by default" do
+        subject.run.must_equal nil
+      end
+    end
+  end
+end

data/test/unit/route_mapper_test.rb

@@ -0,0 +1,73 @@
+require 'helper'
+
+# RouteSet is missing some requires
+require 'active_support/core_ext/uri'
+require 'active_support/core_ext/enumerable'
+
+module FocusedController
+  describe RouteMapper do
+    let(:route_set) { ActionDispatch::Routing::RouteSet.new }
+
+    def recognize(path, environment = {})
+      method = (environment[:method] || "GET").to_s.upcase
+      env    = Rack::MockRequest.env_for(path, {:method => method})
+      req    = route_set.request_class.new(env)
+
+      if route_set.respond_to?(:router)
+        router = route_set.router # Rails 3.2+
+      else
+        router = route_set.set    # Rails 3.0, 3.1
+      end
+
+      router.recognize(req) do |route, matches, params|
+        return route
+      end
+    end
+
+    it 'creates routes that map to focused controllers' do
+      route_set.draw do
+        focused_controller_routes do
+          match 'posts' => 'PostsController::Index'
+
+          resources :comments do
+            resources :replies
+          end
+
+          resource :account
+
+          namespace :admin do
+            resources :comments
+          end
+        end
+      end
+
+      mappings = {
+        [:get, '/posts']              => 'PostsController::Index',
+        [:get, '/comments']           => 'CommentsController::Index',
+        [:get, '/comments/4']         => 'CommentsController::Show',
+        [:put, '/comments/4']         => 'CommentsController::Update',
+        [:get, '/account']            => 'AccountsController::Show',
+        [:get, '/comments/4/replies'] => 'RepliesController::Index',
+        [:get, '/admin/comments']     => 'Admin::CommentsController::Index'
+      }
+
+      mappings.each do |(method, path), controller|
+        route = recognize(path, :method => method)
+        route.app.name.must_equal controller
+        route.defaults[:action].must_equal 'run'
+      end
+    end
+
+    it "doesn't mess with callable routes" do
+      app = Object.new
+      def app.call; end
+
+      route_set.draw do
+        focused_controller_routes do
+          match 'posts' => app
+        end
+      end
+      recognize('/posts').app.must_equal app
+    end
+  end
+end

data/test/unit/route_test.rb

@@ -0,0 +1,39 @@
+require 'helper'
+
+module FocusedController
+  module Test
+  end
+
+  describe Route do
+    let(:controller) { Object.new }
+    subject { Route.new('FocusedController::Test::RouteTestController') }
+
+    before do
+      Test.const_set(:RouteTestController, controller)
+    end
+
+    after do
+      Test.send(:remove_const, :RouteTestController)
+    end
+
+    describe '#call' do
+      it 'constantizes the name and invokes #call on the constant' do
+        env, resp = Object.new, Object.new
+
+        # Not using MiniTest::Mock for this because it caused problems
+        # with Rubinius
+        controller.singleton_class.send :define_method, :call do |call_env|
+          resp if call_env == env
+        end
+
+        subject.call(env).must_equal resp
+      end
+    end
+
+    describe '#to_s' do
+      it "returns the the name" do
+        subject.to_s.must_equal 'FocusedController::Test::RouteTestController'
+      end
+    end
+  end
+end

data/test/unit/rspec_functional_helper.rb

@@ -0,0 +1,42 @@
+require 'helper'
+require 'focused_controller/rspec_functional_helper'
+
+module FocusedController
+  module RSpecFunctionalHelper
+    class FakePostsController
+      class Action < ActionController::Base; end
+      class Index < Action; end
+      class Show < Action; end
+    end
+
+    index_spec = RSpec::Core::ExampleGroup.describe FakePostsController::Index do
+      include RSpec::Rails::ControllerExampleGroup
+      include FocusedController::RSpecFunctionalHelper
+    end
+
+    show_spec = nil
+    inner_show_spec = nil
+    RSpec::Core::ExampleGroup.describe FakePostsController do
+      include RSpec::Rails::ControllerExampleGroup
+      include FocusedController::RSpecFunctionalHelper
+
+      show_spec = describe(FakePostsController::Show) do
+        inner_show_spec = describe('foo') { }
+      end
+    end
+
+    describe RSpecFunctionalHelper do
+      subject { index_spec.new }
+
+      it 'automatically determines the controller class' do
+        index_spec.controller_class.must_equal FakePostsController::Index
+        show_spec.controller_class.must_equal FakePostsController::Show
+        inner_show_spec.controller_class.must_equal FakePostsController::Show
+      end
+
+      it 'includes the FocusedController::FunctionalTestHelper' do
+        subject.is_a?(FocusedController::FunctionalTestHelper).must_equal true
+      end
+    end
+  end
+end

data/test/unit/rspec_helper_test.rb

@@ -0,0 +1,91 @@
+require 'helper'
+require 'action_controller'
+require 'focused_controller/rspec_helper'
+
+module FocusedController
+  module RSpecHelper
+    module FakePostsController
+      class Action < ActionController::Base
+      end
+
+      class Index < Action
+      end
+
+      class Show < Action
+      end
+
+      class Edit < Action
+      end
+
+      class Destroy < Action
+      end
+    end
+
+    index_spec = RSpec::Core::ExampleGroup.describe FakePostsController::Index do
+      include FocusedController::RSpecHelper
+    end
+
+    show_spec = nil
+    inner_show_spec = nil
+    RSpec::Core::ExampleGroup.describe FakePostsController do
+      show_spec = describe FakePostsController::Show do
+        include FocusedController::RSpecHelper
+
+        inner_show_spec = describe 'foo' do
+        end
+      end
+    end
+
+    edit_spec = RSpec::Core::ExampleGroup.describe "the edit action" do
+      include FocusedController::RSpecHelper
+      self.controller_class = FakePostsController::Edit
+    end
+
+    describe RSpecHelper do
+      it 'finds the correct controller class' do
+        index_spec.controller_class.must_equal FakePostsController::Index
+        show_spec.controller_class.must_equal FakePostsController::Show
+        inner_show_spec.controller_class.must_equal FakePostsController::Show
+        edit_spec.controller_class.must_equal FakePostsController::Edit
+      end
+
+      subject { index_spec.new }
+
+      def must_fail(&block)
+        block.must_raise RSpec::Expectations::ExpectationNotMetError
+      end
+
+      def must_succeed(&block)
+        block.call
+        true.must_equal true # to count the assertion
+      end
+
+      it 'has a redirect_to matcher' do
+        must_fail { subject.should subject.redirect_to('/foo') }
+        subject.controller.redirect_to('/foo')
+        must_succeed { subject.should subject.redirect_to('/foo') }
+      end
+
+      it 'matches response type' do
+        must_succeed { subject.response.should subject.be_success }
+        must_fail    { subject.response.should subject.be_error }
+
+        subject.controller.render :status => :not_found
+
+        must_fail    { subject.response.should subject.be_success }
+        must_succeed { subject.response.should subject.be_missing }
+      end
+
+      it 'has a render_template matcher' do
+        subject.controller.render :foo
+
+        must_succeed { subject.response.should subject.render_template(:foo) }
+        must_fail    { subject.response.should subject.render_template(:bar) }
+      end
+
+      it 'sets the subject to be the controller instance' do
+        subject.subject.must_equal subject.controller
+      end
+    end
+  end
+end