low_card_tables 1.0.0

data/spec/low_card_tables/unit/has_low_card_table/low_card_associations_manager_spec.rb

@@ -0,0 +1,190 @@
+require 'low_card_tables'
+
+describe LowCardTables::HasLowCardTable::LowCardAssociationsManager do
+  describe "instantiation" do
+    it "should require a Class that descends from ActiveRecord::Base" do
+      klass = Class.new(String)
+
+      lambda do
+        LowCardTables::HasLowCardTable::LowCardAssociationsManager.new(klass)
+      end.should raise_error(ArgumentError)
+    end
+
+    it "should require a Class that is not itself a low-card class" do
+      klass = Class.new(::ActiveRecord::Base)
+      allow(klass).to receive(:is_low_card_table?).and_return(true)
+
+      lambda do
+        LowCardTables::HasLowCardTable::LowCardAssociationsManager.new(klass)
+      end.should raise_error(ArgumentError)
+    end
+  end
+
+  context "with a normal model class" do
+    before :each do
+      @model_class = Class.new
+      allow(@model_class).to receive(:superclass).and_return(::ActiveRecord::Base)
+      allow(@model_class).to receive(:is_low_card_table?).and_return(false)
+      expect(@model_class).to receive(:before_save).once.with(:low_card_update_foreign_keys!)
+
+      @manager = LowCardTables::HasLowCardTable::LowCardAssociationsManager.new(@model_class)
+    end
+
+    it "should have no associations by default" do
+      @manager.associations.should == [ ]
+    end
+
+    it "should have a default :low_card_value_collapsing_update_scheme" do
+      @manager.low_card_value_collapsing_update_scheme.should == :default
+    end
+
+    describe "#low_card_value_collapsing_update_scheme" do
+      it "should return :default by default" do
+        @manager.low_card_value_collapsing_update_scheme.should == :default
+      end
+
+      it "should be settable to :none or :default" do
+        @manager.low_card_value_collapsing_update_scheme :none
+        @manager.low_card_value_collapsing_update_scheme.should == :none
+        @manager.low_card_value_collapsing_update_scheme :default
+        @manager.low_card_value_collapsing_update_scheme.should == :default
+      end
+
+      it "should be settable to a positive integer" do
+        @manager.low_card_value_collapsing_update_scheme 1
+        @manager.low_card_value_collapsing_update_scheme.should == 1
+        @manager.low_card_value_collapsing_update_scheme 345
+        @manager.low_card_value_collapsing_update_scheme.should == 345
+
+        lambda { @manager.low_card_value_collapsing_update_scheme 0 }.should raise_error(ArgumentError)
+        lambda { @manager.low_card_value_collapsing_update_scheme -27 }.should raise_error(ArgumentError)
+      end
+
+      it "should be settable to something that responds to :call" do
+        callable = double("callable")
+        allow(callable).to receive(:call)
+
+        @manager.low_card_value_collapsing_update_scheme callable
+        @manager.low_card_value_collapsing_update_scheme.should be(callable)
+      end
+
+      it "should not be settable to anything else" do
+        lambda { @manager.low_card_value_collapsing_update_scheme "foo" }.should raise_error(ArgumentError)
+      end
+    end
+
+    describe "#has_low_card_table" do
+      it "should require a non-blank association name" do
+        lambda { @manager.has_low_card_table(nil) }.should raise_error(ArgumentError)
+        lambda { @manager.has_low_card_table("") }.should raise_error(ArgumentError)
+        lambda { @manager.has_low_card_table("   ") }.should raise_error(ArgumentError)
+      end
+
+      context "with one association" do
+        before :each do
+          options = { :a => :b, :c => :d }
+
+          @association = double("low_card_association")
+          expect(LowCardTables::HasLowCardTable::LowCardAssociation).to receive(:new).once.with(@model_class, 'foo', options).and_return(@association)
+
+          lcdmm = double("low_card_dynamic_method_manager")
+          expect(@model_class).to receive(:_low_card_dynamic_method_manager).at_least(:once).and_return(lcdmm)
+
+          expect(lcdmm).to receive(:sync_methods!).at_least(:once)
+
+          @manager.has_low_card_table(:foo, options)
+        end
+
+        it "should create a new association and add it to the list" do
+          @manager.associations.should == [ @association ]
+        end
+
+        it "should remove any previous associations with the same name" do
+          new_options = { :x => :y, :z => :a }
+          allow(@association).to receive(:association_name).and_return("foo")
+
+          association2 = double("association2")
+
+          expect(LowCardTables::HasLowCardTable::LowCardAssociation).to receive(:new).once.with(@model_class, 'foo', new_options).and_return(association2)
+
+          @manager.has_low_card_table('foo', new_options)
+          @manager.associations.should == [ association2 ]
+        end
+
+        context "and another association" do
+          before :each do
+            new_options = { :x => :y, :z => :a }
+            allow(@association).to receive(:association_name).and_return("foo")
+
+            @association2 = double("association2")
+            allow(@association2).to receive(:association_name).and_return("bar")
+
+            expect(LowCardTables::HasLowCardTable::LowCardAssociation).to receive(:new).once.with(@model_class, 'bar', new_options).and_return(@association2)
+
+            @manager.has_low_card_table('bar', new_options)
+            @manager.associations.should == [ @association, @association2 ]
+          end
+
+          it "should retrieve them by name" do
+            @manager._low_card_association("foo").should == @association
+            @manager._low_card_association("bar").should == @association2
+            @manager.maybe_low_card_association("foo").should == @association
+            @manager.maybe_low_card_association("bar").should == @association2
+          end
+
+          it "should do the right thing when they're not found" do
+            @manager.maybe_low_card_association("baz").should_not be
+            lambda { @manager._low_card_association("baz") }.should raise_error(LowCardTables::Errors::LowCardAssociationNotFoundError, /bar[\s,]+foo/)
+          end
+
+          it "should update all foreign keys on #low_card_update_foreign_keys!" do
+            model_instance = double("model_instance")
+            allow(model_instance).to receive(:kind_of?).with(@model_class).and_return(true)
+
+            @association.should receive(:update_foreign_key!).once.with(model_instance)
+            @association2.should receive(:update_foreign_key!).once.with(model_instance)
+
+            @manager.low_card_update_foreign_keys!(model_instance)
+          end
+
+          it "should blow up if passed something that isn't of the correct class to #low_card_update_foreign_keys!" do
+            model_instance = double("model_instance")
+            allow(model_instance).to receive(:kind_of?).with(@model_class).and_return(false)
+
+            lambda { @manager.low_card_update_foreign_keys!(model_instance) }.should raise_error(ArgumentError)
+          end
+
+          describe "_low_card_update_collapsed_rows" do
+            it "should call #update_collapsed_rows on associations that match the low-card model class passed" do
+              @manager.low_card_value_collapsing_update_scheme 345
+
+              low_card_class = double("low_card_class")
+              other_low_card_class = double("other_low_card_class")
+
+              collapse_map = double("collapse_map")
+
+              allow(@association).to receive(:low_card_class).and_return(other_low_card_class)
+              allow(@association2).to receive(:low_card_class).and_return(low_card_class)
+
+              expect(@association2).to receive(:update_collapsed_rows).with(collapse_map, 345).once
+
+              @manager._low_card_update_collapsed_rows(low_card_class, collapse_map)
+            end
+          end
+        end
+      end
+    end
+
+    describe "#low_card_column_information_reset!" do
+      it "should call through to the model class" do
+        low_card_model = double("low_card_model")
+
+        lcdmm = double("low_card_dynamic_method_manager")
+        expect(@model_class).to receive(:_low_card_dynamic_method_manager).and_return(lcdmm)
+        expect(lcdmm).to receive(:sync_methods!).once
+
+        @manager.low_card_column_information_reset!(low_card_model)
+      end
+    end
+  end
+end

data/spec/low_card_tables/unit/has_low_card_table/low_card_dynamic_method_manager_spec.rb

@@ -0,0 +1,234 @@
+require 'low_card_tables'
+
+describe LowCardTables::HasLowCardTable::LowCardDynamicMethodManager do
+  before :each do
+    @model_class = double("model_class")
+    @lcam = double("low_card_associations_manager")
+    allow(@model_class).to receive(:_low_card_associations_manager).and_return(@lcam)
+
+    @methods_module = Module.new
+    allow(@model_class).to receive(:_low_card_dynamic_methods_module).and_return(@methods_module)
+
+    @manager = LowCardTables::HasLowCardTable::LowCardDynamicMethodManager.new(@model_class)
+  end
+
+  context "with two associations and installed methods" do
+    before :each do
+      @association1 = double("association1")
+      allow(@association1).to receive(:association_name).and_return("foo")
+      allow(@association1).to receive(:foreign_key_column_name).and_return("a1fk")
+      allow(@association1).to receive(:class_method_name_to_low_card_method_name_map).and_return({
+        'cm1' => 'lc1m1', 'cm2' => 'lc1m2' })
+
+      @association2 = double("association2")
+      allow(@association2).to receive(:association_name).and_return("bar")
+      allow(@association2).to receive(:foreign_key_column_name).and_return("a2fk")
+      allow(@association2).to receive(:class_method_name_to_low_card_method_name_map).and_return({
+        'cm2' => 'lc2m1', 'cm3' => 'lc2m2' })
+
+      allow(@lcam).to receive(:associations).and_return([ @association1, @association2 ])
+
+      @manager.sync_methods!
+    end
+
+    describe "#scope_from_query" do
+      before :each do
+        @base_scope = double("base_scope")
+        @end_scope = double("end_scope")
+      end
+
+      it "should pass through non-low-card constraints" do
+        expect(@base_scope).to receive(:where).once.with({ :name => 'bonk', :_low_card_direct => true }).and_return(@end_scope)
+        @manager.scope_from_query(@base_scope, { :name => 'bonk' }).should be(@end_scope)
+      end
+
+      it "should apply low-card constraints" do
+        low_card_class_1 = double("low_card_class_1")
+        allow(@association1).to receive(:low_card_class).and_return(low_card_class_1)
+        expect(low_card_class_1).to receive(:low_card_ids_matching).with({ 'lc1m1' => false }).and_return([ 3, 9, 12 ])
+
+        expect(@base_scope).to receive(:where).once.with("a1fk IN (:ids)", { :ids => [ 3, 9, 12 ] }).and_return(@end_scope)
+        @manager.scope_from_query(@base_scope, { :cm1 => false }).should be(@end_scope)
+      end
+
+      it "should apply multiple low-card constraints combined with non-low-card constraints" do
+        low_card_class_1 = double("low_card_class_1")
+        allow(@association1).to receive(:low_card_class).and_return(low_card_class_1)
+        expect(low_card_class_1).to receive(:low_card_ids_matching).with({ 'lc1m1' => false }).and_return([ 3, 9, 12 ])
+
+        low_card_class_2 = double("low_card_class_2")
+        allow(@association2).to receive(:low_card_class).and_return(low_card_class_2)
+        expect(low_card_class_2).to receive(:low_card_ids_matching).with({ 'lc2m2' => [ :a, :b ], 'lc2m1' => 'yohoho' }).and_return([ 4, 6, 8 ])
+
+        mid_scope = double("mid_scope")
+
+        # expect(@base_scope).to receive(:where).once.with("a1fk IN (:ids)", { :ids => [ 3, 9, 12 ] }).and_return(mid_scope)
+        # expect(mid_scope).to receive(:where).once.with("a2fk IN (:ids)", { :ids => [ 4, 6, 8 ] }).and_return(@end_scope)
+
+        base_args = mid_args = nil
+
+        expect(@base_scope).to receive(:where).once { |*args| base_args = args; mid_scope }
+        expect(mid_scope).to receive(:where).once { |*args| mid_args = args; @end_scope }
+
+        @manager.scope_from_query(@base_scope, { :cm1 => false, :cm3 => [ :a, :b ], :bar => { 'lc2m1' => "yohoho" } }).should be(@end_scope)
+
+        # Perfectly valid for this to happen in either order
+        if base_args[0] =~ /^a1fk/
+          base_args.should == [ 'a1fk IN (:ids)', { :ids => [ 3, 9, 12 ]}]
+          mid_args.should == [ 'a2fk IN (:ids)', { :ids => [ 4, 6, 8 ]}]
+        else
+          base_args.should == [ 'a2fk IN (:ids)', { :ids => [ 4, 6, 8 ]}]
+          mid_args.should == [ 'a1fk IN (:ids)', { :ids => [ 3, 9, 12 ]}]
+        end
+      end
+
+      it "should apply low-card constraints in combination with direct foreign-key constraints" do
+        low_card_class_1 = double("low_card_class_1")
+        allow(@association1).to receive(:low_card_class).and_return(low_card_class_1)
+        expect(low_card_class_1).to receive(:low_card_ids_matching).with({ 'lc1m1' => false }).and_return([ 3, 9, 12 ])
+
+        mid_scope = double("mid_scope")
+
+        expect(@base_scope).to receive(:where).once.with({ :a2fk => [ 1, 3, 12 ], :_low_card_direct => true }).and_return(mid_scope)
+        expect(mid_scope).to receive(:where).once.with("a1fk IN (:ids)", { :ids => [ 3, 9, 12 ] }).and_return(@end_scope)
+
+        @manager.scope_from_query(@base_scope, { :cm1 => false, :a2fk => [ 1, 3, 12] }).should be(@end_scope)
+      end
+    end
+
+    describe "method delegation and invocation" do
+      before :each do
+        @invoked_object = double("invoked_object")
+        @low_card_object = double("low_card_object")
+        @args = double("args")
+        @rv = double("rv")
+
+        allow(@invoked_object).to receive(:kind_of?).with(@model_class).and_return(true)
+      end
+
+      def check_invocation(method_name, association_name, low_card_method_name)
+        expect(@invoked_object).to receive(association_name).and_return(@low_card_object)
+        expect(@low_card_object).to receive(low_card_method_name).with(@args).and_return(@rv)
+
+        @methods_module.instance_methods.map(&:to_s).include?(method_name.to_s).should be
+
+        @manager.run_low_card_method(@invoked_object, method_name, @args).should be(@rv)
+      end
+
+      context "after changing associations" do
+        before :each do
+          @manager.sync_methods!
+
+          @association3 = double("association3")
+          allow(@association3).to receive(:association_name).and_return("baz")
+          allow(@association3).to receive(:foreign_key_column_name).and_return("a3fk")
+          allow(@association3).to receive(:class_method_name_to_low_card_method_name_map).and_return({
+            'cm2' => 'lc3m1', 'cm4' => 'lc3m2' })
+
+          allow(@lcam).to receive(:associations).and_return([ @association1, @association3 ])
+
+          @manager.sync_methods!
+        end
+
+        it "should run the right method for cm1" do
+          check_invocation("cm1", "foo", "lc1m1")
+        end
+
+        it "should run the right method for cm2" do
+          check_invocation("cm2", "baz", "lc3m1")
+        end
+
+        it "should run the right method for cm3" do
+          @methods_module.instance_methods.map(&:to_s).include?("cm3").should_not be
+
+          lambda { @manager.run_low_card_method(@invoked_object, "cm3", @args) }.should raise_error(NameError, /cm3/)
+        end
+
+        it "should run the right method for cm4" do
+          check_invocation("cm4", "baz", "lc3m2")
+        end
+      end
+
+      it "should run the right method for cm1" do
+        check_invocation("cm1", "foo", "lc1m1")
+      end
+
+      it "should run the right method for cm2" do
+        check_invocation("cm2", "bar", "lc2m1")
+      end
+
+      it "should run the right method for cm3" do
+        check_invocation("cm3", "bar", "lc2m2")
+      end
+
+      def check_association(method_name, association)
+        lcom = double("low_card_objects_manager")
+        expect(@invoked_object).to receive(:_low_card_objects_manager).and_return(lcom)
+        expect(lcom).to receive(:object_for).with(association).and_return(@low_card_object)
+
+        @methods_module.instance_methods.map(&:to_s).include?(method_name).should be
+
+        @manager.run_low_card_method(@invoked_object, method_name, [ ]).should be(@low_card_object)
+      end
+
+      it "should return the right association for foo" do
+        check_association("foo", @association1)
+      end
+
+      it "should return the right association for bar" do
+        check_association("bar", @association2)
+      end
+
+      def check_foreign_key_get(method_name, association)
+        lcom = double("low_card_objects_manager")
+        expect(@invoked_object).to receive(:_low_card_objects_manager).and_return(lcom)
+        expect(lcom).to receive(:foreign_key_for).with(association).and_return(12345)
+
+        @methods_module.instance_methods.map(&:to_s).include?(method_name).should be
+
+        @manager.run_low_card_method(@invoked_object, method_name, [ ]).should == 12345
+      end
+
+      it "should return the right foreign key for a1fk" do
+        check_foreign_key_get("a1fk", @association1)
+      end
+
+      it "should return the right foreign key for a2fk" do
+        check_foreign_key_get("a2fk", @association2)
+      end
+
+      def check_foreign_key_set(method_name, association)
+        args = double("args")
+        lcom = double("low_card_objects_manager")
+        expect(@invoked_object).to receive(:_low_card_objects_manager).and_return(lcom)
+        expect(lcom).to receive(:set_foreign_key_for).with(association, args)
+
+        @methods_module.instance_methods.map(&:to_s).include?(method_name).should be
+
+        @manager.run_low_card_method(@invoked_object, method_name, args)
+      end
+
+      it "should set the right foreign key for a1fk" do
+        check_foreign_key_set("a1fk=", @association1)
+      end
+
+      it "should set the right foreign key for a2fk" do
+        check_foreign_key_set("a2fk=", @association2)
+      end
+
+      it "should blow up if asked to invoke a method that doesn't exist" do
+        lambda do
+          @manager.run_low_card_method(@invoked_object, "quux", [ ])
+        end.should raise_error(/quux/i)
+      end
+
+      it "should blow up if given an object of the wrong class" do
+        allow(@invoked_object).to receive(:kind_of?).with(@model_class).and_return(false)
+
+        lambda do
+          @manager.run_low_card_method(@invoked_object, "foo", [ ])
+        end.should raise_error(ArgumentError)
+      end
+    end
+  end
+end

data/spec/low_card_tables/unit/has_low_card_table/low_card_objects_manager_spec.rb

@@ -0,0 +1,70 @@
+require 'low_card_tables'
+
+describe LowCardTables::HasLowCardTable::LowCardObjectsManager do
+  before :each do
+    @model_instance = double("model_instance")
+    @manager = LowCardTables::HasLowCardTable::LowCardObjectsManager.new(@model_instance)
+
+    @model_class = double("model_class")
+    allow(@model_instance).to receive(:class).and_return(@model_class)
+
+    @lcam = double("low_card_associations_manager")
+    allow(@model_class).to receive(:_low_card_associations_manager).and_return(@lcam)
+
+    @association1 = double("LowCardAssociation")
+    allow(@association1).to receive(:association_name).and_return("foo")
+    allow(@association1).to receive(:foreign_key_column_name).and_return("blahblah_id")
+  end
+
+  describe "#object_for" do
+    it "should call through to the association to create the object, and only once" do
+      associated_object = double("associated_object")
+
+      expect(@lcam).to receive(:_low_card_association).with("foo").and_return(@association1)
+      expect(@association1).to receive(:create_low_card_object_for).once.with(@model_instance).and_return(associated_object)
+
+      @manager.object_for(@association1).should be(associated_object)
+      @manager.object_for(@association1).should be(associated_object)
+    end
+
+    it "should maintain multiple associcated objects separately" do
+      associated_object_1 = double("associated_object_1")
+      associated_object_2 = double("associated_object_2")
+
+      @association2 = double("LowCardAssociation2")
+      allow(@association2).to receive(:association_name).and_return("bar")
+
+      expect(@lcam).to receive(:_low_card_association).with("foo").and_return(@association1)
+      expect(@association1).to receive(:create_low_card_object_for).once.with(@model_instance).and_return(associated_object_1)
+
+      expect(@lcam).to receive(:_low_card_association).with("bar").and_return(@association2)
+      expect(@association2).to receive(:create_low_card_object_for).once.with(@model_instance).and_return(associated_object_2)
+
+      @manager.object_for(@association1).should be(associated_object_1)
+      @manager.object_for(@association2).should be(associated_object_2)
+      @manager.object_for(@association1).should be(associated_object_1)
+      @manager.object_for(@association2).should be(associated_object_2)
+    end
+  end
+
+  describe "foreign-key support" do
+    it "should call through to the model instance on get" do
+      expect(@model_instance).to receive(:[]).with("blahblah_id").and_return(12345)
+      @manager.foreign_key_for(@association1).should == 12345
+    end
+
+    it "should call through to the model instance on set, invalidate the object, and return the new value" do
+      associated_object_1 = double("associated_object_1")
+      expect(@lcam).to receive(:_low_card_association).with("foo").at_least(:once).and_return(@association1)
+      expect(@association1).to receive(:create_low_card_object_for).once.with(@model_instance).and_return(associated_object_1)
+      @manager.object_for(@association1).should be(associated_object_1)
+
+      expect(@model_instance).to receive(:[]=).with("blahblah_id", 23456)
+      @manager.set_foreign_key_for(@association1, 23456).should == 23456
+
+      associated_object_2 = double("associated_object_2")
+      expect(@association1).to receive(:create_low_card_object_for).once.with(@model_instance).and_return(associated_object_2)
+      @manager.object_for(@association1).should be(associated_object_2)
+    end
+  end
+end