cancan-unit-test 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d6177faaa08bc88c1f286f8c76f68155b41f4f78
-  data.tar.gz: 6db7a439ae237ff7a0b349fa8804f218fd4a8d74
+  metadata.gz: aa942f63f5ef9c7e8d0e568d49fe7a6bc2781c14
+  data.tar.gz: e2814f79002bf4a8594ad1632fa2124bb1b970a6
 SHA512:
-  metadata.gz: 3b32f869d10ce6f4aa136d676e244a46800d8d6b7cf83043cbb86198a2b8cc7f754a300b5515fad5c45a09fbbed7184234def2e942865c879fe8fd7e45c1956a
-  data.tar.gz: 11414c0895523b948e26d3f081302e6ab433955ccdb2823defecb851f586b1d1a507b7bc3a7ea3492087bd66e09c25d232a8c86c38f8a88938e1f7027550762a
+  metadata.gz: abd119ec9e7292d3f1885c486422b667bbc5fb7ba4705695737c68e3537be602e429820f598b39430ebba12e62abb3b29e825f41920037c3759a4c2843ae8508
+  data.tar.gz: 92bd77b5b3813620e6f0f8fb0fe1157bc97dc94c4f3de8d8b39623db4b661f2b0bf7ea7392b4c57d609be28ac233e177b490a7b239825486a4a5302f2fb5f642

data/.gitignore

@@ -17,6 +17,7 @@ tmp
 integration/fixtures/dummy/log
 integration/fixtures/dummy/*.gem
 integration/fixtures/dummy/*.rbc
+integration/fixtures/dummy/db/*.sqlite3
 integration/fixtures/dummy/.bundle
 integration/fixtures/dummy/.config
 integration/fixtures/dummy/.yardoc

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    cancan-unit-test (0.0.1)
+    cancan-unit-test (0.0.2)
       activesupport
       cancan
 

data/README.md

@@ -20,7 +20,8 @@ Or install it yourself as:
 
 ## Usage
 
-stub_load_and_authorize_resource(:model_name, options_hash)
+stub_load_and_authorize_singleton_resource(:model_name, options_hash)
+stub_load_and_authorize_collection_resource(:model_name, options_hash)
 
 ## Contributing
 

data/integration/controllers/comments_controller_spec.rb

@@ -0,0 +1,36 @@
+require 'integration_helper'
+
+describe CommentsController do
+
+  context "stubbing with incorrect resource instance or collection" do
+    let_double(:post_object)
+    let_double(:post_id)
+    let_double(:post_author)
+    let_double(:comments)
+
+    before do
+      stub_load_and_authorize_singleton_resource(:post) { post_object }
+      stub_load_and_authorize_collection_resource(:comment) { comments }
+      stub_load_and_authorize_singleton_resource(:author, instance_name: :post_author, through: :post, parent: false) { post_author }
+    end
+
+    describe "index" do
+      it "assigns the post" do
+        get :index, post_id: post_id
+        assigns(:post).should == post_object
+      end
+
+      it "assigns the comments" do
+        get :index, post_id: post_id
+        assigns(:comments).should == comments
+      end
+
+      it "assigns the post's author" do
+        get :index, post_id: post_id
+        assigns(:post_author).should == post_author
+      end
+    end
+
+  end
+
+end

data/integration/controllers/posts_controller_spec.rb

@@ -0,0 +1,36 @@
+require 'integration_helper'
+
+describe PostsController do
+  context "not stubbing" do
+    it "uses can can" do
+      post :create
+      assigns(:post).should be_a Post
+    end
+  end
+
+  context "stubbing load and authorize with a singleton" do
+    let_double(:article)
+
+    before do
+      stub_load_and_authorize_singleton_resource(:post) { article }
+    end
+
+    it "uses the stub" do
+      post :create
+      assigns(:post).should == article
+    end
+  end
+
+  context "stubbing with incorrect matchers" do
+    let_double(:article)
+
+    before do
+      stub_load_and_authorize_singleton_resource(:post, instance_method: :i_am_not_right) { article }
+    end
+
+    it "warns that there was no stub found" do
+      STDOUT.should_receive(:puts).with("\e[33mCancanUnitTest Warning:\e[0m no stub found for 'load_and_authorize_resource :post'")
+      post :create
+    end
+  end
+end

data/integration/fixtures/dummy/app/controllers/comments_controller.rb

@@ -0,0 +1,11 @@
+class CommentsController < ApplicationController
+  load_and_authorize_resource :post
+  load_and_authorize_resource
+  load_and_authorize_resource :author, instance_name: :post_author, through: :post, parent: false
+
+  def index
+    head :ok
+  end
+
+end
+

data/integration/fixtures/dummy/app/controllers/posts_controller.rb

@@ -1,5 +1,5 @@
 class PostsController < ApplicationController
-  load_and_authorize_resource
+  load_and_authorize_resource :post
 
   def create
     render :index

data/integration/fixtures/dummy/app/models/author.rb

@@ -0,0 +1,3 @@
+class Author < ActiveRecord::Base
+  attr_accessible :name
+end

data/integration/fixtures/dummy/app/models/comment.rb

@@ -0,0 +1,3 @@
+class Comment < ActiveRecord::Base
+  attr_accessible :content
+end

data/integration/fixtures/dummy/config/routes.rb

@@ -1,61 +1,7 @@
 Dummy::Application.routes.draw do
 
-  resources :posts
+  resources :posts do
+    resources :comments
+  end
 
-  # The priority is based upon order of creation:
-  # first created -> highest priority.
-
-  # Sample of regular route:
-  #   match 'products/:id' => 'catalog#view'
-  # Keep in mind you can assign values other than :controller and :action
-
-  # Sample of named route:
-  #   match 'products/:id/purchase' => 'catalog#purchase', :as => :purchase
-  # This route can be invoked with purchase_url(:id => product.id)
-
-  # Sample resource route (maps HTTP verbs to controller actions automatically):
-  #   resources :products
-
-  # Sample resource route with options:
-  #   resources :products do
-  #     member do
-  #       get 'short'
-  #       post 'toggle'
-  #     end
-  #
-  #     collection do
-  #       get 'sold'
-  #     end
-  #   end
-
-  # Sample resource route with sub-resources:
-  #   resources :products do
-  #     resources :comments, :sales
-  #     resource :seller
-  #   end
-
-  # Sample resource route with more complex sub-resources
-  #   resources :products do
-  #     resources :comments
-  #     resources :sales do
-  #       get 'recent', :on => :collection
-  #     end
-  #   end
-
-  # Sample resource route within a namespace:
-  #   namespace :admin do
-  #     # Directs /admin/products/* to Admin::ProductsController
-  #     # (app/controllers/admin/products_controller.rb)
-  #     resources :products
-  #   end
-
-  # You can have the root of your site routed with "root"
-  # just remember to delete public/index.html.
-  # root :to => 'welcome#index'
-
-  # See how all your routes lay out with "rake routes"
-
-  # This is a legacy wild controller route that's not recommended for RESTful applications.
-  # Note: This route will make all actions in every controller accessible via GET requests.
-  # match ':controller(/:action(/:id))(.:format)'
 end

data/integration/fixtures/dummy/db/migrate/20130709143526_create_posts.rb

@@ -1,6 +1,7 @@
 class CreatePosts < ActiveRecord::Migration
   def change
     create_table :posts do |t|
+      t.references :author
       t.string :title
       t.text :content
 

data/integration/fixtures/dummy/db/migrate/20130712144534_create_authors.rb

@@ -0,0 +1,9 @@
+class CreateAuthors < ActiveRecord::Migration
+  def change
+    create_table :authors do |t|
+      t.string :name
+
+      t.timestamps
+    end
+  end
+end

data/integration/fixtures/dummy/db/migrate/20130712144551_create_comments.rb

@@ -0,0 +1,10 @@
+class CreateComments < ActiveRecord::Migration
+  def change
+    create_table :comments do |t|
+      t.references :post
+      t.string :content
+
+      t.timestamps
+    end
+  end
+end

data/integration/fixtures/dummy/db/schema.rb

@@ -11,9 +11,23 @@
 #
 # It's strongly recommended to check this file into your version control system.
 
-ActiveRecord::Schema.define(:version => 20130709143526) do
+ActiveRecord::Schema.define(:version => 20130712144551) do
+
+  create_table "authors", :force => true do |t|
+    t.string   "name"
+    t.datetime "created_at", :null => false
+    t.datetime "updated_at", :null => false
+  end
+
+  create_table "comments", :force => true do |t|
+    t.integer  "post_id"
+    t.string   "content"
+    t.datetime "created_at", :null => false
+    t.datetime "updated_at", :null => false
+  end
 
   create_table "posts", :force => true do |t|
+    t.integer  "author_id"
     t.string   "title"
     t.text     "content"
     t.datetime "created_at", :null => false

data/lib/cancan_unit_test/action_controller/stub_registry.rb

@@ -2,13 +2,13 @@ module CancanUnitTest
   module ActionController
     module StubRegistry
 
-      def _add_cancan_unit_test_stub(method, model, options, &block)
-        method_list = cancan_unit_test_stubs[method] ||= []
-        method_list << { model: model, options: options, block: block }
+      def _add_cancan_unit_test_stub(method, resource_type, model, options, &block)
+        method_list = _get_cancan_unit_test_stubs(method)
+        method_list << { resource_type: resource_type, model: model, options: options, block: block }
       end
 
       def _get_cancan_unit_test_stubs(method)
-        cancan_unit_test_stubs[method] || []
+        cancan_unit_test_stubs[method] ||= []
       end
 
       private

data/lib/cancan_unit_test/cancan/controller_resource.rb

@@ -7,17 +7,19 @@ module CancanUnitTest
       extend ::ActiveSupport::Concern
 
       def _shim_load_and_authorize_resource
+        model_name = resource_class.model_name.underscore
+
         stub_finder = StubFinder.new(@controller, :load_and_authorize_resource)
-        stub = stub_finder.find(resource_class.model_name.underscore.to_sym, @options)
 
-        if stub.nil?
-          _original_load_and_authorize_resource
+        singleton_stub = stub_finder.find_by_singleton(model_name.to_sym, @options)
+        collection_stub = stub_finder.find_by_collection(model_name.to_sym, @options)
+
+        if (singleton_stub || collection_stub)
+          self.resource_instance = singleton_stub.call if singleton_stub
+          self.collection_instance = collection_stub.call if collection_stub
         else
-          if load_instance?
-            self.resource_instance = stub.call
-          elsif load_collection?
-            self.collection_instance = stub.call
-          end
+          puts("\e[33mCancanUnitTest Warning:\e[0m no stub found for 'load_and_authorize_resource :#{model_name}'")
+          _original_load_and_authorize_resource
         end
       end
 

data/lib/cancan_unit_test/mocks.rb

@@ -1,9 +1,12 @@
 module CancanUnitTest
   module Mocks
 
-    def stub_load_and_authorize_resource(model, options={}, &block)
-      controller._add_cancan_unit_test_stub(:load_and_authorize_resource, model, options, &block)
+    def stub_load_and_authorize_singleton_resource(model, options={}, &block)
+      controller._add_cancan_unit_test_stub(:load_and_authorize_resource, :singleton, model, options, &block)
     end
 
+    def stub_load_and_authorize_collection_resource(model, options={}, &block)
+      controller._add_cancan_unit_test_stub(:load_and_authorize_resource, :collection, model, options, &block)
+    end
   end
 end

data/lib/cancan_unit_test/stub_finder.rb

@@ -5,22 +5,31 @@ module CancanUnitTest
       @stub_list = controller._get_cancan_unit_test_stubs(method)
     end
 
-    def find(model, options)
-      stub_list = filter_stub_list(model, options)
-
-      return nil if stub_list.empty?
-
-      raise "Ambiguous match in CanCan:Mocks" if stub_list.count > 1
+    def find_by_singleton(model, options)
+      find_by_resource_type(model, :singleton, options)
+    end
 
-      stub_list.first[:block]
+    def find_by_collection(model, options)
+      find_by_resource_type(model, :collection, options)
     end
 
     private
 
-    def filter_stub_list(model, options)
+    def find_by_resource_type(model, resource_type, options)
+      filtered_stub_list = filter_stub_list(model, resource_type, options)
+
+      return nil if filtered_stub_list.empty?
+
+      raise "Ambiguous match in CanCan:Mocks" if filtered_stub_list.count > 1
+
+      filtered_stub_list.first[:block]
+    end
+
+    def filter_stub_list(model, resource_type, options)
       stub_list.select do |stub|
-        stub[:model] == model &&
-          stub[:options] == options
+        stub[:resource_type] == resource_type &&
+          stub[:model] == model &&
+          stub[:options] == options 
       end
     end
 

data/lib/cancan_unit_test/version.rb

@@ -1,3 +1,3 @@
 module CancanUnitTest
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/cancan/controller_resource_spec.rb

@@ -5,7 +5,6 @@ module CancanUnitTest
     describe ControllerResource do
 
       class TestControllerResource
-
         def initialize(model_name, options, controller)
           @options = options
           @model_name = model_name
@@ -28,88 +27,70 @@ module CancanUnitTest
       end
 
       describe "#load_and_authorize_resource" do
+
         let(:controller_resource) { TestControllerResource.new(model_name, options, controller) }
-        let_double(:stub_finder)
-        let_double(:method)
         let(:model_name) { "TheModelName" }
+        let_double(:controller)
         let_double(:options)
+
         let_double(:block_result)
-        let_double(:controller)
         let(:block) { double(:block, call: block_result) }
 
+        let_double(:stub_finder)
+
         before do
           StubFinder.stub(:new).with(controller, :load_and_authorize_resource) { stub_finder }
-          stub_finder.stub(:find).with(:the_model_name, options) { stub_finder_results }
-          controller_resource.stub(:load_instance?) { load_instance }
+          stub_finder.stub(:find_by_singleton).with(:the_model_name, options) { singleton_results }
+          stub_finder.stub(:find_by_collection).with(:the_model_name, options) { collection_results }
         end
 
         context "when a stub doesn't exist for the resource" do
-          let(:stub_finder_results) { nil }
-          let(:load_instance) { true }
+          let(:singleton_results) { nil }
+          let(:collection_results) { nil }
 
           it "calls through to the original method" do
             expect { controller_resource.load_and_authorize_resource }.to raise_error "original called"
           end
-        end
-
-        context "when a stub exists for the resource" do
-          let(:stub_finder_results) { block }
-          let(:load_instance) { true }
-
-          context "when loading a single resource instance" do
-            let(:load_instance) { true }
-
-            it "calls the stub" do
-              block.should_receive(:call)
-              controller_resource.load_and_authorize_resource
-            end
 
-            it "assigns the stub to resource_instance" do
-              controller_resource.should_receive(:resource_instance=).with(block_result)
+          it "warns that there was no stub found" do
+            STDOUT.should_receive(:puts).with("\e[33mCancanUnitTest Warning:\e[0m no stub found for 'load_and_authorize_resource :the_model_name'")
+            begin
               controller_resource.load_and_authorize_resource
+            rescue
             end
           end
+        end
 
-          context "when loading a collection of resource instances" do
-            let(:load_instance) { false }
-
-            before do
-              controller_resource.stub(:load_collection?) { true }
-            end
-
-            it "calls the stub" do
-              block.should_receive(:call)
-              controller_resource.load_and_authorize_resource
-            end
+        context "when a singleton stub for the resource exists" do
+          let(:singleton_results) { block }
+          let(:collection_results) { nil }
 
-            it "assigns the stub to collection_instance" do
-              controller_resource.should_receive(:collection_instance=).with(block_result)
-              controller_resource.load_and_authorize_resource
-            end
+          it "calls the stub" do
+            block.should_receive(:call)
+            controller_resource.load_and_authorize_resource
           end
 
-          context "when loading neither an instance, nor a collection, however that may happen?" do
-            let(:load_instance) { false }
+          it "assigns the stub to resource_instance" do
+            controller_resource.should_receive(:resource_instance=).with(block_result)
+            controller_resource.load_and_authorize_resource
+          end
+        end
 
-            before do
-              controller_resource.stub(:load_collection?) { false }
-            end
+        context "when a collection stub for the resource exists" do
+          let(:singleton_results) { nil }
+          let(:collection_results) { block }
 
-            it "does not call the stub" do
-              block.should_not_receive(:call)
-              controller_resource.load_and_authorize_resource
-            end
+          it "calls the stub" do
+            block.should_receive(:call)
+            controller_resource.load_and_authorize_resource
+          end
 
-            it "does not assign the stub to anything" do
-              controller_resource.should_not_receive(:resource_instance=).with(block_result)
-              controller_resource.should_not_receive(:collection_instance=).with(block_result)
-              controller_resource.load_and_authorize_resource
-            end
+          it "assigns the stub to collection_instance" do
+            controller_resource.should_receive(:collection_instance=).with(block_result)
+            controller_resource.load_and_authorize_resource
           end
         end
-
       end
-
     end
   end
 end

data/spec/mocks_spec.rb

@@ -15,25 +15,38 @@ module CancanUnitTest
 
     subject(:rspec_test) { TestClass.new(controller) }
 
-    describe "#stub_load_and_authorize_resource" do
-      let(:controller) { double(:controller).as_null_object }
-      let(:options) { double(:options) }
-      let(:block) { -> {} }
+    let(:controller) { double(:controller).as_null_object }
+    let(:options) { double(:options) }
+    let(:block) { -> {} }
+
+    describe "#stub_load_and_authorize_singleton_resource" do
 
       it "adds the stubbed resource to the controller" do
         controller.
           should_receive(:_add_cancan_unit_test_stub).
-          with(:load_and_authorize_resource, :model, options, &block)
+          with(:load_and_authorize_resource, :singleton, :model, options, &block)
 
         rspec_test.
-          stub_load_and_authorize_resource(:model, options, &block)
+          stub_load_and_authorize_singleton_resource(:model, options, &block)
       end
 
       it "does not require options" do
-        expect { rspec_test.  stub_load_and_authorize_resource(:model, &block) }.to_not raise_error
+        expect do
+          rspec_test.
+            stub_load_and_authorize_singleton_resource(:model, &block)
+        end.to_not raise_error
       end
     end
 
+    describe "#stub_load_and_authorize_collection_resource" do
+      it "adds the stubed resource collection to the controller" do
+        controller.should_receive(:_add_cancan_unit_test_stub).
+          with(:load_and_authorize_resource, :collection, :model, options, &block)
+
+        rspec_test.
+          stub_load_and_authorize_collection_resource(:model, options, &block)
+      end
+    end
   end
 end
 

data/spec/rails/action_controller/stub_registry_spec.rb

@@ -15,59 +15,84 @@ module CancanUnitTest
       let(:options) { double(:options) }
       let(:block) { ->{} }
 
-      let(:expected_stub_definition) do
+      let(:expected_singleton_definition) do
         {
+          resource_type: :singleton,
           model: model,
           options: options,
           block: block
         }
       end
 
+      let(:expected_collection_definition) do
+        {
+          resource_type: :collection,
+          model: model,
+          options: options,
+          block: block
+        }
+      end
       describe "retrieving a stored stub definition" do
         context "no stubs added" do
           it "returns an empty array" do
-           test_controller._get_cancan_unit_test_stubs(:mango).should == []
+            test_controller._get_cancan_unit_test_stubs(:mango).should == []
           end
 
           it "does not raise an error" do
-           expect { test_controller._get_cancan_unit_test_stubs(:mango) }.not_to raise_error
+            expect { test_controller._get_cancan_unit_test_stubs(:mango) }.not_to raise_error
           end
         end
 
         context "added one stub" do
           before do
-            test_controller._add_cancan_unit_test_stub(:falaffel, model, options, &block)
+            test_controller._add_cancan_unit_test_stub(:falaffel, :singleton, model, options, &block)
           end
 
           it "should be possible to find the stub with a matching key" do
-            test_controller._get_cancan_unit_test_stubs(:falaffel).should == [expected_stub_definition]
+            test_controller._get_cancan_unit_test_stubs(:falaffel).should == [expected_singleton_definition]
           end
 
           context "adding another with the same model name" do
-            let(:another_falaffel_model) { double(:model) }
-            let(:another_falaffel_stub_definition) do
+            let(:another_singleton_definition) do
               {
-                model: another_falaffel_model,
-                options: options,
-                block: block
+                resource_type: :singleton,
+                model: model,
+                  options: options,
+                  block: block
               }
             end
 
-            before do
-              test_controller._add_cancan_unit_test_stub(:falaffel, another_falaffel_model, options, &block)
+            context "and the same resource type" do
+              before do
+                test_controller._add_cancan_unit_test_stub(:falaffel, :singleton, model, options, &block)
+              end
+
+              it "returns both stubs" do
+                test_controller._get_cancan_unit_test_stubs(:falaffel).should ==
+                  [expected_singleton_definition,
+                   another_singleton_definition]
+              end
             end
 
-            it "returns both stubs" do
-              test_controller._get_cancan_unit_test_stubs(:falaffel).should ==
-                [expected_stub_definition,
-                 another_falaffel_stub_definition]
+            context "and a different resource type" do
+              before do
+                test_controller._add_cancan_unit_test_stub(:falaffel, :collection, model, options, &block)
+              end
+
+              it "returns both stubs" do
+                test_controller._get_cancan_unit_test_stubs(:falaffel).should ==
+                  [expected_singleton_definition,
+                   expected_collection_definition]
+              end
             end
           end
 
+
           context "adding another with a different model name" do
             let(:waffle_options) { { syrup: :maple } }
             let(:waffle_stub_definition) do
               {
+                resource_type: :singleton,
                 model: model,
                 options: waffle_options,
                 block: block
@@ -75,7 +100,7 @@ module CancanUnitTest
             end
 
             before do
-              test_controller._add_cancan_unit_test_stub(:waffle, model, waffle_options, &block)
+              test_controller._add_cancan_unit_test_stub(:waffle, :singleton, model, waffle_options, &block)
             end
 
             it "return the other definition" do

data/spec/stub_finder_spec.rb

@@ -10,8 +10,8 @@ module CancanUnitTest
 
     let(:finder) { StubFinder.new(controller, method) }
 
-    describe "#find" do
-      subject { finder.find(model, options) }
+    describe "#find_by_singleton" do
+      subject { finder.find_by_singleton(model, options) }
 
       before do
         controller.
@@ -27,32 +27,68 @@ module CancanUnitTest
 
       context "the controller has a stub for the method" do
         context "with no matching model" do
-          let(:results) { [{ model: double(:other_model), options: options, block: block }] }
+          let(:results) { [{ resource_type: :singleton, model: double(:other_model), options: options, block: block }] }
           it { should be_nil }
         end
 
         context "with no matching options" do
-          let(:results) { [{ model: model, options: double(:other_options), block: block }] }
+          let(:results) { [{ resource_type: :singleton, model: model, options: double(:other_options), block: block }] }
           it { should be_nil }
         end
 
         context "with matching model and options" do
-          let(:results) { [{ model: model, options: options, block: block }] }
+          let(:results) { [{ resource_type: :singleton, model: model, options: options, block: block }] }
           it { should == block }
         end
       end
 
       context "the controller has more than one matching stub" do
+        context "with a different resource type" do
+          let(:results) do
+            [
+              { resource_type: :collection, model: model, options: options, block: -> {} },
+              { resource_type: :singleton, model: model, options: options, block: block }
+            ]
+          end
+
+          it { should == block }
+        end
+
+        context "with the same resource type" do
+          let(:results) do
+            [
+              { resource_type: :singleton, model: model, options: options, block: block },
+              { resource_type: :singleton, model: model, options: options, block: block }
+            ]
+          end
+
+          it "raises an exception" do
+            expect { finder.find_by_singleton(model, options) }.to raise_error
+          end
+        end
+      end
+
+    end
+
+    describe "#find_by_collection" do
+      subject { finder.find_by_collection(model, options) }
+
+      before do
+        controller.
+          stub(:_get_cancan_unit_test_stubs).
+          with(method).
+          and_return(results)
+      end
+
+      context "with a different resource type" do
         let(:results) do
           [
-            { model: model, options: options, block: block },
-            { model: model, options: options, block: block }
+            { resource_type: :singleton, model: model, options: options, block: -> {} },
+            { resource_type: :collection, model: model, options: options, block: block }
           ]
         end
 
-        it "raises an exception" do
-          expect { finder.find(model, options) }.to raise_error
-        end
+        it { should == block }
       end
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cancan-unit-test
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Todd Mohney, Rasheed Abdul-Aziz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-11 00:00:00.000000000 Z
+date: 2013-07-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cancan
@@ -153,17 +153,21 @@ files:
 - README.md
 - Rakefile
 - cancan_unit_test.gemspec
-- integration/controllers/mocks_spec.rb
+- integration/controllers/comments_controller_spec.rb
+- integration/controllers/posts_controller_spec.rb
 - integration/fixtures/dummy/README.rdoc
 - integration/fixtures/dummy/Rakefile
 - integration/fixtures/dummy/app/assets/javascripts/application.js
 - integration/fixtures/dummy/app/assets/stylesheets/application.css
 - integration/fixtures/dummy/app/controllers/application_controller.rb
+- integration/fixtures/dummy/app/controllers/comments_controller.rb
 - integration/fixtures/dummy/app/controllers/posts_controller.rb
 - integration/fixtures/dummy/app/helpers/application_helper.rb
 - integration/fixtures/dummy/app/mailers/.gitkeep
 - integration/fixtures/dummy/app/models/.gitkeep
 - integration/fixtures/dummy/app/models/ability.rb
+- integration/fixtures/dummy/app/models/author.rb
+- integration/fixtures/dummy/app/models/comment.rb
 - integration/fixtures/dummy/app/models/post.rb
 - integration/fixtures/dummy/app/views/layouts/application.html.erb
 - integration/fixtures/dummy/app/views/posts/index.erb
@@ -183,11 +187,10 @@ files:
 - integration/fixtures/dummy/config/initializers/wrap_parameters.rb
 - integration/fixtures/dummy/config/locales/en.yml
 - integration/fixtures/dummy/config/routes.rb
-- integration/fixtures/dummy/db/development.sqlite3
 - integration/fixtures/dummy/db/migrate/20130709143526_create_posts.rb
+- integration/fixtures/dummy/db/migrate/20130712144534_create_authors.rb
+- integration/fixtures/dummy/db/migrate/20130712144551_create_comments.rb
 - integration/fixtures/dummy/db/schema.rb
-- integration/fixtures/dummy/db/structure.sql
-- integration/fixtures/dummy/db/test.sqlite3
 - integration/fixtures/dummy/lib/assets/.gitkeep
 - integration/fixtures/dummy/log/.gitkeep
 - integration/fixtures/dummy/public/404.html

data/integration/controllers/mocks_spec.rb

@@ -1,25 +0,0 @@
-require 'integration_helper'
-
-describe PostsController do
-
-  context "not stubbing" do
-    it "uses can can" do
-      post :create
-      assigns(:post).should be_a Post
-    end
-  end
-
-  context "stubbing" do
-    let_double(:article)
-
-    before do
-      stub_load_and_authorize_resource(:post) { article }
-    end
-
-    it "uses the stub" do
-      post :create
-      assigns(:post).should == article
-    end
-  end
-
-end

data/integration/fixtures/dummy/db/structure.sql

@@ -1 +0,0 @@
-INSERT INTO schema_migrations (version) VALUES ('20130709143526');