required_scopes 1.0.0

data/spec/required_scopes/helpers/system_helpers.rb

@@ -0,0 +1,98 @@
+require 'active_record'
+require 'active_record/migration'
+
+module RequiredScopes
+  module Helpers
+    module SystemHelpers
+      def migrate(&block)
+        migration_class = Class.new(::ActiveRecord::Migration)
+        metaclass = migration_class.class_eval { class << self; self; end }
+        metaclass.instance_eval { define_method(:up, &block) }
+
+        ::ActiveRecord::Migration.suppress_messages do
+          migration_class.migrate(:up)
+        end
+      end
+
+      def define_model_class(name, table_name, &block)
+        model_class = Class.new(::ActiveRecord::Base)
+        ::Object.send(:remove_const, name) if ::Object.const_defined?(name)
+        ::Object.const_set(name, model_class)
+        model_class.table_name = table_name
+        model_class.class_eval(&block)
+      end
+
+      def create_standard_system_spec_tables!
+        migrate do
+          drop_table :rec_spec_users rescue nil
+          create_table :rec_spec_users do |t|
+            t.string :name, :null => false
+            t.string :favorite_color
+            t.string :favorite_taste
+          end
+        end
+      end
+
+      def define_color_and_taste_scopes!
+        ::User.class_eval do
+          must_scope_by :color, :taste
+
+          scope :red, lambda { where(:favorite_color => 'red') }, :satisfies => :color
+          scope :green, lambda { where(:favorite_color => 'green') }, :satisfies => :color
+
+          scope :salty, lambda { where(:favorite_taste => 'salty') }, :satisfies => :taste
+          scope :sweet, lambda { where(:favorite_taste => 'sweet') }, :satisfies => :taste
+
+          scope :red_and_salty, lambda { where(:favorite_color => 'red', :favorite_taste => 'salty') }, :satisfies => [ :color, :taste ]
+        end
+      end
+
+      def should_raise_missing_scopes(triggering_method, required, satisfied, options = { })
+        e = result = nil
+
+        begin
+          result = yield
+        rescue RequiredScopes::Errors::RequiredScopeCategoriesNotSatisfiedError => rscnse
+          e = rscnse
+        end
+
+        raise "Expected a scopes-not-satisfied error, but got none" unless e
+
+        expected_model_class = options[:model_class] || ::User
+
+        e.class.should == RequiredScopes::Errors::RequiredScopeCategoriesNotSatisfiedError
+        e.model_class.should == expected_model_class
+        e.current_relation.should be
+        e.current_relation.kind_of?(::ActiveRecord::Relation).should be
+        e.triggering_method.should == triggering_method
+        e.required_categories.sort_by(&:to_s).should == required.sort_by(&:to_s)
+        e.satisfied_categories.sort_by(&:to_s).should == satisfied.sort_by(&:to_s)
+
+        expected_missing_categories = required - satisfied
+        e.missing_categories.sort_by(&:to_s).should == expected_missing_categories.sort_by(&:to_s)
+
+        e.message.should match(/#{expected_model_class.name}/)
+        e.message.should match(/#{expected_missing_categories.sort_by(&:to_s).join(", ")}/)
+      end
+
+      def create_standard_system_spec_models!
+        define_model_class(:User, 'rec_spec_users') { }
+      end
+
+      def create_standard_system_spec_instances!
+        @red_salty = ::User.create!(:name => 'red-salty', :favorite_color => 'red', :favorite_taste => 'salty')
+        @green_salty = ::User.create!(:name => 'green-salty', :favorite_color => 'green', :favorite_taste => 'salty')
+        @blue_salty = ::User.create!(:name => 'blue-salty', :favorite_color => 'blue', :favorite_taste => 'salty')
+        @red_sweet = ::User.create!(:name => 'red-sweet', :favorite_color => 'red', :favorite_taste => 'sweet')
+        @green_sweet = ::User.create!(:name => 'green-sweet', :favorite_color => 'green', :favorite_taste => 'sweet')
+        @blue_sweet = ::User.create!(:name => 'blue-sweet', :favorite_color => 'blue', :favorite_taste => 'sweet')
+      end
+
+      def drop_standard_system_spec_tables!
+        migrate do
+          drop_table :rec_spec_users rescue nil
+        end
+      end
+    end
+  end
+end

data/spec/required_scopes/system/associations_system_spec.rb

@@ -0,0 +1,150 @@
+require 'required_scopes'
+require 'required_scopes/helpers/database_helper'
+require 'required_scopes/helpers/system_helpers'
+
+describe "RequiredScopes and associations" do
+  include RequiredScopes::Helpers::SystemHelpers
+
+  before :each do
+    @dh = RequiredScopes::Helpers::DatabaseHelper.new
+    @dh.setup_activerecord!
+
+    migrate do
+      drop_table :rec_spec_groups rescue nil
+      create_table :rec_spec_groups do |t|
+        t.string :name, :null => false
+      end
+
+      drop_table :rec_spec_users rescue nil
+      create_table :rec_spec_users do |t|
+        t.string :name, :null => false
+        t.integer :group_id
+        t.string :favorite_color
+      end
+
+      drop_table :rec_spec_user_preferences rescue nil
+      create_table :rec_spec_user_preferences do |t|
+        t.integer :user_id
+        t.string :preference
+      end
+
+      drop_table :rec_spec_categories rescue nil
+      create_table :rec_spec_categories do |t|
+        t.string :name
+      end
+
+      drop_table :rec_spec_categories_users rescue nil
+      create_table :rec_spec_categories_users, :id => false do |t|
+        t.integer :user_id
+        t.integer :category_id
+      end
+    end
+
+    define_model_class(:User, :rec_spec_users) do
+      must_scope_by :color
+      belongs_to :group
+      has_one :user_preference
+      has_and_belongs_to_many :categories, :join_table => :rec_spec_categories_users
+
+      scope :red, lambda { where(:favorite_color => :red) }, :satisfies => :color
+    end
+
+    define_model_class(:Group, :rec_spec_groups) do
+      has_many :users
+    end
+
+    define_model_class(:UserPreference, :rec_spec_user_preferences) do
+      belongs_to :user
+
+      must_scope_by :prefcolor
+    end
+
+    define_model_class(:Category, :rec_spec_categories) do
+      has_and_belongs_to_many :users, :join_table => :rec_spec_categories_users
+
+      must_scope_by :catcolor
+    end
+
+    @group1 = ::Group.create!(:name => 'Group 1')
+    @user1 = ::User.create!(:name => 'g1u1', :favorite_color => 'red', :group => @group1)
+    @user2 = ::User.create!(:name => 'g1u2', :favorite_color => 'green', :group => @group1)
+
+    @user1pref = ::UserPreference.create!(:user => @user1, :preference => 'u1p')
+    @user2pref = ::UserPreference.create!(:user => @user2, :preference => 'u2p')
+
+    @cat1 = ::Category.create!(:name => 'c1')
+    @cat2 = ::Category.create!(:name => 'c2')
+
+    @cat1.users << @user1
+    @cat1.users << @user2
+    @cat1.save!
+
+    @cat2.users << @user1
+    @cat2.users << @user2
+    @cat2.save!
+  end
+
+  after :each do
+    migrate do
+      drop_table :rec_spec_groups rescue nil
+      drop_table :rec_spec_users rescue nil
+      drop_table :rec_spec_user_preferences rescue nil
+      drop_table :rec_spec_categories rescue nil
+      drop_table :rec_spec_categories_users rescue nil
+    end
+  end
+
+  it "should require a scope when accessed directly" do
+    lambda { ::User.where(:group_id => @group1.id).to_a }.should raise_error(RequiredScopes::Errors::RequiredScopeCategoriesNotSatisfiedError)
+  end
+
+  it "should not require a scope when accessed via an association" do
+    @group1.users.map(&:id).sort.should == [ @user1, @user2 ].map(&:id).sort
+  end
+
+  it "should not require a scope when accessed via an association, with eager loading" do
+    Group.includes(:users).find(@group1.id).users.map(&:id).sort.should == [ @user1, @user2 ].map(&:id).sort
+  end
+
+  it "should not require a scope when accessed via #joins" do
+    Group.joins(:users).find(@group1.id).users.map(&:id).sort.should == [ @user1, @user2 ].map(&:id).sort
+  end
+
+  it "should not require a scope when accessed via #eager_load" do
+    Group.eager_load(:users).find(@group1.id).users.map(&:id).sort.should == [ @user1, @user2 ].map(&:id).sort
+  end
+
+  it "should not require a scope when accessed via #preload" do
+    Group.preload(:users).find(@group1.id).users.map(&:id).sort.should == [ @user1, @user2 ].map(&:id).sort
+  end
+
+  it "should not require a scope when accessed via #references" do
+    if ::RequiredScopes::ActiveRecord::VersionCompatibility.supports_references_method?
+      Group.references(:users).find(@group1.id).users.map(&:id).sort.should == [ @user1, @user2 ].map(&:id).sort
+    end
+  end
+
+  it "should not require a scope when accessed via has_one" do
+    @user1.user_preference.should == @user1pref
+  end
+
+  it "should not require a scope when accessed via has_one, with eager loading" do
+    User.includes(:user_preference).red.find(@user1.id).id.should == @user1pref.id
+  end
+
+  it "should not require a scope when accessed via belongs_to" do
+    @user1pref.user.should == @user1
+  end
+
+  it "should not require a scope when accessed via has_one, with eager loading" do
+    UserPreference.includes(:user).all_scope_categories_satisfied.find(@user1pref.id).id.should == @user1.id
+  end
+
+  it "should not require a scope when accessed via has_and_belongs_to_many" do
+    @user1.categories.map(&:id).sort.should == [ @cat1, @cat2 ].map(&:id).sort
+  end
+
+  it "should not require a scope when accessed via has_and_belongs_to_many, with eager loading" do
+    ::User.includes(:categories).all_scope_categories_satisfied.find(@user1).categories.map(&:id).should == [ @cat1, @cat2 ].map(&:id).sort
+  end
+end

data/spec/required_scopes/system/base_scope_system_spec.rb

@@ -0,0 +1,71 @@
+require 'required_scopes'
+require 'required_scopes/helpers/database_helper'
+require 'required_scopes/helpers/system_helpers'
+
+describe "RequiredScopes base scope operations" do
+  include RequiredScopes::Helpers::SystemHelpers
+
+  before :each do
+    @dh = RequiredScopes::Helpers::DatabaseHelper.new
+    @dh.setup_activerecord!
+
+    create_standard_system_spec_tables!
+    create_standard_system_spec_models!
+    create_standard_system_spec_instances!
+
+    ::User.class_eval do
+      base_scope_required!
+
+      base_scope :red, lambda { where(:favorite_color => 'red') }
+      base_scope :green, lambda { where(:favorite_color => 'green') }
+
+      scope :salty, lambda { where(:favorite_taste => 'salty') }
+
+      class << self
+        def blue
+          base_scope_satisfied.where(:favorite_color => 'blue')
+        end
+      end
+    end
+  end
+
+  after :each do
+    drop_standard_system_spec_tables!
+  end
+
+  it "should require the base scope" do
+    e = nil
+
+    begin
+      ::User.all.to_a
+    rescue RequiredScopes::Errors::BaseScopeNotSatisfiedError => bsnse
+      e = bsnse
+    end
+
+    e.should be
+    e.class.should == RequiredScopes::Errors::BaseScopeNotSatisfiedError
+    e.model_class.should == ::User
+
+    e.current_relation.should be
+    e.current_relation.kind_of?(::ActiveRecord::Relation).should be
+    e.triggering_method.should == :exec_queries
+
+    e.required_categories.should == [ :base ]
+    e.satisfied_categories.should == [ ]
+    e.missing_categories.should == [ :base ]
+
+    e.message.should match(/base scope/i)
+  end
+
+  it "should work if a base scope is used" do
+    ::User.red.to_a
+  end
+
+  it "should work if a class method satisfying the base scope is used" do
+    ::User.blue.to_a
+  end
+
+  it "should work if you manually tell it that the base scope is satisfied" do
+    ::User.base_scope_satisfied.to_a
+  end
+end

data/spec/required_scopes/system/basic_system_spec.rb

@@ -0,0 +1,121 @@
+require 'required_scopes'
+require 'required_scopes/helpers/database_helper'
+require 'required_scopes/helpers/system_helpers'
+
+describe "RequiredScopes basic operations" do
+  include RequiredScopes::Helpers::SystemHelpers
+
+  before :each do
+    @dh = RequiredScopes::Helpers::DatabaseHelper.new
+    @dh.setup_activerecord!
+
+    create_standard_system_spec_tables!
+    create_standard_system_spec_models!
+    create_standard_system_spec_instances!
+
+    define_color_and_taste_scopes!
+  end
+
+  after :each do
+    drop_standard_system_spec_tables!
+  end
+
+  describe "queries" do
+    it "should raise if no categories are applied" do
+      should_raise_missing_scopes(:exec_queries, [ :color, :taste ], [ ]) { ::User.all.to_a }
+    end
+
+    it "should raise if only one category is applied" do
+      should_raise_missing_scopes(:exec_queries, [ :color, :taste ], [ :color ]) { ::User.red.to_a }
+    end
+
+    it "should not raise if both categories are individually applied" do
+      ::User.red.salty.to_a.should == [ @red_salty ]
+    end
+
+    it "should not raise if both categories are satisfied by a single scope" do
+      ::User.red_and_salty.to_a.should == [ @red_salty ]
+    end
+
+    it "should allow further qualifying the scopes, and in the middle" do
+      ::User.where("name LIKE 'red%'").red.where("name LIKE '%salty'").salty.where("name LIKE '%d-s%'").to_a.should == [ @red_salty ]
+      ::User.where("name LIKE 'green%'").red.salty.to_a.should == [ ]
+      ::User.red.where("name LIKE '%sweet'").salty.to_a.should == [ ]
+      ::User.red.salty.where("name LIKE '%sweet'").to_a.should == [ ]
+    end
+
+    it "should automatically have a scope that includes all of each category" do
+      ::User.red.ignoring_taste.to_a.sort.should == [ @red_salty, @red_sweet ].sort
+      ::User.ignoring_color.sweet.to_a.sort.should == [ @red_sweet, @green_sweet, @blue_sweet ].sort
+    end
+
+    it "should still require scopes even if #unscoped is used" do
+      should_raise_missing_scopes(:exec_queries, [ :color, :taste ], [ ]) { ::User.unscoped.to_a }
+    end
+
+    it "should still require scopes even if #unscoped is used in a block form" do
+      should_raise_missing_scopes(:exec_queries, [ :color, :taste ], [ ]) { ::User.unscoped { ::User.all.to_a } }
+    end
+
+    it "should allow manually saying that categories are satisfied" do
+      ::User.red.scope_category_satisfied(:taste).to_a.sort.should == [ @red_salty, @red_sweet ].to_a
+      ::User.scope_category_satisfied(:color).sweet.to_a.sort.should == [ @red_sweet, @green_sweet, @blue_sweet ].to_a
+      ::User.scope_categories_satisfied(:color, :taste).to_a.sort.should ==
+        [ @red_sweet, @green_sweet, @blue_sweet, @red_salty, @green_salty, @blue_salty ].to_a.sort
+      ::User.scope_categories_satisfied(:color, :taste).sweet.to_a.sort.should ==
+        [ @red_sweet, @green_sweet, @blue_sweet ].to_a.sort
+    end
+
+    it "should allow manually saying that categories are satisfied, in a block" do
+      ran_block = false
+      ::User.scope_category_satisfied(:taste) do
+        ::User.red.to_a.sort.should == [ @red_salty, @red_sweet].to_a
+        ran_block = true
+      end
+      ran_block.should be
+
+      ran_block = false
+      ::User.scope_category_satisfied(:taste) do
+        should_raise_missing_scopes(:exec_queries, [ :color, :taste ], [ :taste ]) { ::User.all.to_a }
+        ran_block = true
+      end
+      ran_block.should be
+
+      ran_block = false
+      ::User.scope_category_satisfied(:taste) do
+        ::User.red.to_a.sort.should == [ @red_salty, @red_sweet ].sort
+        ran_block = true
+      end
+      ran_block.should be
+
+      ran_block = false
+      ::User.all_scope_categories_satisfied do
+        ::User.all.to_a.sort.should == [ @red_salty, @red_sweet, @green_salty, @green_sweet, @blue_salty, @blue_sweet ].sort
+        ran_block = true
+      end
+      ran_block.should be
+    end
+
+    it "should allow saying that categories are satisfied in a class method, in any position" do
+      ::User.class_eval do
+        class << self
+          def red_and_green
+            scope_category_satisfied(:color).where(:favorite_color => %w{red green})
+          end
+
+          def green_and_blue
+            where(:favorite_color => %w{green blue}).scope_category_satisfied(:color)
+          end
+
+          def red_and_blue
+            where(:favorite_color => %w{red blue}).scope_category_satisfied(:color).where(:favorite_taste => %w{salty sweet})
+          end
+        end
+      end
+
+      ::User.red_and_green.salty.to_a.sort.should == [ @red_salty, @green_salty ].sort
+      ::User.green_and_blue.salty.to_a.sort.should == [ @green_salty, @blue_salty ].sort
+      ::User.red_and_blue.salty.to_a.sort.should == [ @red_salty, @blue_salty ].sort
+    end
+  end
+end

data/spec/required_scopes/system/inheritance_system_spec.rb

@@ -0,0 +1,67 @@
+require 'required_scopes'
+require 'required_scopes/helpers/database_helper'
+require 'required_scopes/helpers/system_helpers'
+
+describe "RequiredScopes and inheritance" do
+  include RequiredScopes::Helpers::SystemHelpers
+
+  before :each do
+    @dh = RequiredScopes::Helpers::DatabaseHelper.new
+    @dh.setup_activerecord!
+
+    create_standard_system_spec_tables!
+    create_standard_system_spec_models!
+    create_standard_system_spec_instances!
+  end
+
+  after :each do
+    drop_standard_system_spec_tables!
+  end
+
+  it "should combine multiple #must_scope_by declarations" do
+    ::User.class_eval do
+      must_scope_by :color
+      must_scope_by :taste
+
+      scope :red, lambda { where(:favorite_color => 'red') }, :satisfies => :color
+      scope :salty, lambda { where(:favorite_taste => 'salty') }, :satisfies => :taste
+    end
+
+    should_raise_missing_scopes(:exec_queries, [ :color, :taste ], [ :taste ]) { ::User.salty.to_a }
+  end
+
+  it "should inherit #must_scope_by in child classes" do
+    ::User.class_eval do
+      must_scope_by :color
+      scope :red, lambda { where(:favorite_color => 'red') }, :satisfies => :color
+    end
+
+    class ::UserSub1 < ::User
+      self.table_name = ::User.table_name
+
+      must_scope_by :taste
+      scope :salty, lambda { where(:favorite_taste => 'salty') }, :satisfies => :taste
+    end
+
+    should_raise_missing_scopes(:exec_queries, [ :color, :taste ], [ :taste ], :model_class => ::UserSub1) { ::UserSub1.salty.to_a }
+  end
+
+  it "should allow ignoring a required scope in a subclass" do
+    ::User.class_eval do
+      must_scope_by :color
+      scope :red, lambda { where(:favorite_color => 'red') }, :satisfies => :color
+    end
+
+    class ::UserSub2 < ::User
+      self.table_name = ::User.table_name
+
+      must_scope_by :taste
+      scope :salty, lambda { where(:favorite_taste => 'salty') }, :satisfies => :taste
+
+      ignore_parent_scope_requirement :color
+    end
+
+    ::UserSub2.salty.to_a.should be
+    should_raise_missing_scopes(:exec_queries, [ :taste ], [ ], :model_class => ::UserSub2) { ::UserSub2.all.to_a }
+  end
+end