scope_chain 0.0.3 → 0.0.6

data/README.md

@@ -1,62 +1,107 @@
 # ScopeChain
 
-ScopeChain is a tiny help class useful for testing ActiveRecord model scope usage
+ScopeChain is a tiny helper class useful for testing ActiveRecord model scope usage
 and scope chaining
 
 # Usage
 
 For example, say you have:
-
-    class User < ActiveRecord::Base
-    end
+```ruby
+class User < ActiveRecord::Base
+end
+```
 
 And you use that model:
+```ruby
+def some_method
+  User.where(active: 1).order("created_at desc")
+end
+```
 
-    def some_method
-      User.where(active: 1).order("created_at desc")
-    end
-
-And you want to test that method, but without setting creating data in your database,
+And you want to test that method, but without creating data in your database,
 or actually using the data base.
 
 Using ScopeChain, you do:
-
-    context "my method" do
-      it "gets the right users" do
-        ScopeChain.for(User).where(active: 1).order("created_at desc")
-
-        some_method
-      end
-    end
+```ruby
+context "my method" do
+  it "gets the right users" do
+    ScopeChain.for(User).where(active: 1).order("created_at desc")
+    some_method
+  end
+end
+```
 
 What this will do is setup some expectations that make sure those scope methods are called.
 
 You can do "manual" scopes:
+```ruby
+def manual_scopes
+  User.scoped.where("something = else")
+end
 
-    def manual_scopes
-      User.scoped.where("somethign = else")
-    end
+it "does the right thing" do
+  ScopeChain.for(User).where("something = else")
+  manual_scopes
+end
+```
 
-    it "does the right thing" do
-      ScopeChain.for(User).where("something = else")
+You can test return values:
+```ruby
+def return_values
+  User.where("thing = 1")
+end
 
-      manual_scopes
-    end
+it "returns properly" do
+  ScopeChain.for(User).where("thing = 1").returns(5)
 
-You can test return values:
+  return_values.should eq(5)
+end
+```
+
+You can test associations on individual model instances:
+
+```ruby
+class Model < ActiveRecord::Base
+end
+
+class Owner < ActiveRecord::Base
+  has_many :models
+
+  def my_method
+    models.create(column: 5)
+  end
+end
+
+def test_my_method
+  owner = Owner.new
+  ScopeChain.on(owner).as(:models).create(column: 5)
+
+  owner.my_method
+end
+```
+
+You can test named scopes (for execution, not for what they do):
+
+```ruby
+class Model < ActiveRecord::Base
+  scope :active, where("1 = 1")
+
+  def self.my_method
+    active.order("id")
+end
 
-    def return_values
-      User.where("thing = 1")
-    end
+it "should be ordered" do
+  ScopeChain.for(Model).active.order("id").returns("abc")
 
-    it "returns properly" do
-      ScopeChain.for(User).where("thing = 1").returns(5)
+  Model.active.should eq("abc")
+end
+```
 
-      return_values.should eq(5)
-    end
+Note that the named scope support does dirty things to the ActiveRecord namespace,
+which means you *really should* have "require: false" in your Gemfile.  
 
+Like, for reals.
 
-Not in order, but called, which is something, right?
 
 ## Known Issues
 

data/lib/scope_chain/version.rb

@@ -1,3 +1,3 @@
 module ScopeChain
-  VERSION = "0.0.3"
+  VERSION = "0.0.6"
 end

data/lib/scope_chain.rb

@@ -5,14 +5,50 @@ module ScopeChain
     Chain.new klass, &block
   end
 
+  def self.on(instance)
+    AssociationChain.new instance
+  end
+
+  class AssociationChain
+    attr_accessor :instance, :association
+
+    def initialize(instance)
+      self.instance = instance
+    end
+
+    def as(association_name)
+      self.association = instance.class.reflect_on_association(association_name)
+
+      chain
+    end
+
+    private
+    def association_name(klass)
+      klass.name.underscore.pluralize
+    end
+
+    def chain
+      ScopeChain::Chain.new(association.klass).tap do |chain|
+        instance.stubs(association.name => association.klass)
+      end
+    end
+  end
+
   class Chain
-    LINKS = [:select, :where, :includes, :order]
+    LINKS = [:select, :where, :includes, :order, :find, :sum, :new, :create, :create!]
+    ALIASES = {} 
+
+    class ConflictedExistenceError < StandardError
+    end
 
-    attr_accessor :klass, :expectations
+    attr_accessor :klass
     def initialize(klass, &block)
       self.klass = klass
-      self.expectations = []
-      self.klass.stubs(scoped: klass) # Handle manual scope building
+      @expectations = []
+      @exists_condition = false
+
+      link_manual_scopes
+      link_named_scopes
 
       yield self if block_given?
     end
@@ -23,6 +59,12 @@ module ScopeChain
       end
     end
 
+    ALIASES.each do |source, dest|
+      define_method(source) do |*arguments|
+        add_link dest, *arguments
+      end
+    end
+
     def all(returned)
       add_link :all
       returns returned
@@ -30,20 +72,68 @@ module ScopeChain
 
     def returns(object)
       # DON'T LOOK
-      expectations.last.instance_variable_set(:@return_values, Mocha::ReturnValues.build(object))
+      @expectations.last.instance_variable_set(:@return_values, Mocha::ReturnValues.build(object))
       
       self
     end
 
+    def exists!
+      set_exists true
+    end
+
+    def missing!
+      set_exists false
+    end
+
     private
     def add_link(name, *arguments)
       expectation = klass.expects(name)
       expectation.with(*arguments) if arguments.size > 0
       expectation.returns(klass)
 
-      expectations << expectation
+      @expectations << expectation
 
       self
     end
+
+    def set_exists(value)
+      if @exists_condition
+        raise ConflictedExistenceError.new("Can only set one 'exists' conditions, #missing! or #exists!")
+      end
+
+      klass.expects(exists?: value)
+      @exists_condition = true
+
+      self
+    end
+
+    def link_manual_scopes
+      klass.stubs(scoped: klass) # Handle manual scope building
+    end
+
+    def link_named_scopes
+      return unless klass.respond_to?(:scopes)
+
+      klass.scopes[klass.name].each do |named|
+        self.define_singleton_method(named) do |*arguments|
+          add_link named, *arguments
+        end
+      end
+    end
+
   end
 end
+
+# Hooks so named scopes are sane
+class ActiveRecord::Base
+  cattr_reader :scopes
+  def self.scope_with_tracking(*args, &block)
+    (@@scopes ||= Hash.new {|hash, key| hash[key] = [] })[self.name].push args.first
+    scope_without_tracking *args, &block
+  end
+
+  class << self
+    alias_method_chain :scope, :tracking
+  end
+
+end

data/scope_chain.gemspec

@@ -18,7 +18,8 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
 
   gem.add_dependency 'mocha'
+  gem.add_dependency 'activerecord', '~> 3.1.0'
 
   gem.add_development_dependency 'rspec'
-  gem.add_development_dependency 'activerecord', '~> 3.1.11'
+  gem.add_development_dependency 'sqlite3'
 end

data/spec/scope_chain_spec.rb

@@ -5,10 +5,27 @@ require 'active_record'
 require 'mocha/api'
 require 'scope_chain'
 
+ActiveRecord::Base.establish_connection({
+  adapter: 'sqlite3',
+  database: ":memory:",
+  verbosity: 'quiet'
+})
+
+ActiveRecord::Base.connection.create_table :models do |table|
+  table.belongs_to :owners
+  table.integer :column
+end
+
+ActiveRecord::Base.connection.create_table :owners
+
 class Model < ActiveRecord::Base
   scope :active, where("column = value")
 end
 
+class Owner < ActiveRecord::Base
+  has_many :models
+end
+
 describe ScopeChain do
   let(:klass) { Class.new }
 
@@ -54,6 +71,12 @@ describe ScopeChain::Chain do
     klass.scoped.select("id")
   end
 
+  it "works with the alias scopes" do
+    subject.new(5)
+
+    klass.new(5)
+  end
+
   describe "#returns" do
     it "modifies the last expectation" do
       subject.select("id").where("5").returns("9")
@@ -83,6 +106,22 @@ describe ScopeChain::Chain do
     end
   end
 
+  describe "#exists!" do
+    it "exists" do
+      subject.exists!
+
+      klass.should be_exists
+    end
+  end
+
+  describe "#missing!" do
+    it "does not exist" do
+      subject.missing!
+
+      klass.should_not be_exists
+    end
+  end
+
   describe "with a custom scopes" do
     it "fails properly" do
       pending
@@ -99,6 +138,23 @@ describe ScopeChain::Chain do
 
       Model.active.to_a
     end
+
+    it "sets expectations on the named scope" do
+      ScopeChain.for(Model).active.returns(:active)
+
+      Model.active.should eq(:active)
+    end
+  end
+
+  context "with associations" do
+    describe "has_many" do
+      it "properly sets stuff up" do
+        source = Owner.new
+        ScopeChain.on(source).as(:models).new(column: 5).returns(:abc)
+
+        source.models.new(column: 5).should eq(:abc)
+      end
+    end
   end
 
 end

metadata

@@ -2,7 +2,7 @@
 name: scope_chain
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.3
+  version: 0.0.6
 platform: ruby
 authors: 
 - Jon Moses
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-03-15 00:00:00 Z
+date: 2013-03-18 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: mocha
@@ -24,27 +24,38 @@ dependencies:
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: rspec
+  name: activerecord
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
-        version: "0"
-  type: :development
+        version: 3.1.0
+  type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: activerecord
+  name: rspec
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version 
-        version: 3.1.11
+        version: "0"
   type: :development
   version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: sqlite3
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id004
 description: Easy testing of scope usage
 email: 
 - jon@burningbush.us