riveter 0.0.1

data/spec/riveter/core_extensions_spec.rb

@@ -0,0 +1,209 @@
+require 'spec_helper'
+require 'riveter/spec_helper'
+require 'riveter/core_extensions'
+
+describe Riveter::CoreExtensions do
+  describe Riveter::CoreExtensions::BooleanSupport do
+    it { Object.should respond_to(:boolean?) }
+    it { Object.should respond_to(:to_b) }
+
+    it { true.boolean?.should be_true }
+    it { false.boolean?.should be_true }
+    it { Object.new().boolean?.should be_false }
+
+    [true, 1, 'yes', 'on', 'y', '1'].each do |value|
+      it { value.to_b.should be_true }
+    end
+
+    [false, 0, 'no', 'off', 'n', '0'].each do |value|
+      it { value.to_b.should be_false }
+    end
+  end
+
+  describe Riveter::CoreExtensions::DateExtensions do
+    it { Date.should respond_to(:system_start_date) }
+    it { Date.should respond_to(:from_utc_ticks) }
+    it { Date.new().should respond_to(:to_utc_ticks) }
+
+    it { Date.system_start_date.should eq(Date.new(1970, 1, 1)) }
+    it { Date.from_utc_ticks(0).should eq(Date.new(1970, 1, 1)) }
+    it { Date.from_utc_ticks(86_400_000).should eq(Date.new(1970, 1, 2)) }
+    it { Date.new(1970, 1, 1).to_utc_ticks.should eq(0) }
+  end
+
+  describe Riveter::CoreExtensions::ArrayExtensions do
+    subject { [1, 2, 3, 4] }
+
+    describe "#cumulative_sum" do
+      it { should respond_to(:cumulative_sum) }
+
+      it { subject.cumulative_sum.should eq([1, 3, 6, 10]) }
+    end
+
+    describe "#nil_sum" do
+      it { should respond_to(:nil_sum) }
+
+      it { subject.nil_sum.should eq(10) }
+      it { [1, 2, nil, 4].nil_sum.should eq(7) }
+    end
+
+    describe "#average" do
+      it { should respond_to(:average) }
+
+      it { subject.average.should eq(2.5) }
+    end
+
+    describe "#variance" do
+      it { should respond_to(:variance) }
+
+      it { subject.variance.should eq(1.6666666666666667) }
+    end
+
+    describe "#standard_deviation" do
+      it { should respond_to(:standard_deviation) }
+
+      it { subject.standard_deviation.should eq(1.2909944487358056) }
+    end
+
+    describe "#to_hash_for" do
+      it { should respond_to(:to_hash_for) }
+
+      it { subject.to_hash_for.should eq({1 => 1, 2 => 2, 3 => 3, 4 => 4}) }
+      it { subject.to_hash_for(&:to_s).should eq({'1' => 1, '2' => 2, '3' => 3, '4' => 4}) }
+    end
+
+    describe "#round" do
+      it { should respond_to(:round) }
+
+      it { subject.round(6).should eq([1, 2, 3, 4]) }
+      it { [1.456789, 2.987654].round(2).should eq([1.46, 2.99]) }
+    end
+
+    describe "#find_each_with_order" do
+      it { should respond_to(:find_each_with_order) }
+      it { should respond_to(:find_each) }
+
+      it "should invoke block" do
+        block = Mock::Block.new()
+        expect(block).to receive(:call).exactly(4).times
+        subject.find_each_with_order &block
+      end
+
+      it "should not invoke block" do
+        block = Mock::Block.new()
+        expect(block).to_not receive(:call)
+        [].find_each_with_order &block
+      end
+    end
+  end
+
+  describe Riveter::CoreExtensions::HashExtensions do
+    describe "#rmerge" do
+      pending
+    end
+
+    describe "#rmerge!" do
+      pending
+    end
+  end
+
+  describe Riveter::CoreExtensions::ChainedQuerySupport do
+    subject do
+      Class.new().class_eval do
+        include Riveter::CoreExtensions::ChainedQuerySupport
+      end.new()
+    end
+
+    it { should respond_to(:where?) }
+    it { subject.where?(false, {}).should eq(subject) }
+    it {
+      expect(subject).to receive(:where).with({:a => 'v'})
+      subject.where?(true, {:a => 'v'})
+    }
+  end
+
+  describe Riveter::CoreExtensions::BatchFinderSupport do
+    subject do
+      Class.new(Array).class_eval do
+        include Riveter::CoreExtensions::BatchFinderSupport
+
+        def limit(*args)
+          @limit = args.first
+          self
+        end
+
+        def offset(*args)
+          self.shift(@limit)
+        end
+
+        self
+      end.new().concat((1..2000).to_a)
+    end
+
+    describe "#find_each_with_order" do
+      it { should respond_to(:find_each_with_order) }
+
+      it "should invoke block for each element" do
+        block = Mock::Block.new()
+        expect(block).to receive(:call).exactly(subject.length).times
+        subject.find_each_with_order(&block)
+      end
+
+      it "should return enumerator if no block given" do
+        block = Mock::Block.new()
+        expect(block).to receive(:call).exactly(subject.length).times
+        subject.find_each_with_order.each(&block)
+      end
+
+      context "with overridden batch size" do
+        let(:batch_size) { 10 }
+
+        it "should invoke block for each element" do
+          block = Mock::Block.new()
+          expect(block).to receive(:call).exactly(subject.length).times
+          expect(subject).to receive(:find_in_batches_with_order).with(:batch_size => batch_size).and_call_original
+          subject.find_each_with_order(:batch_size => batch_size, &block)
+        end
+
+        it "should return enumerator if no block given" do
+          block = Mock::Block.new()
+          expect(block).to receive(:call).exactly(subject.length).times
+          expect(subject).to receive(:find_in_batches_with_order).with(:batch_size => batch_size).and_call_original
+          subject.find_each_with_order(:batch_size => batch_size).each(&block)
+        end
+      end
+    end
+
+    describe "#find_in_batches_with_order" do
+      it { should respond_to(:find_in_batches_with_order) }
+
+      it "should invoke block for each element" do
+        block = Mock::Block.new()
+        expect(block).to receive(:call).exactly(subject.length / 1000).times
+        subject.find_in_batches_with_order(&block)
+      end
+
+      it "should return enumerator if no block given" do
+        block = Mock::Block.new()
+        expect(block).to receive(:call).exactly(subject.length / 1000).times
+        subject.find_in_batches_with_order.each(&block)
+      end
+
+      context "with overridden batch size" do
+        let(:batch_size) { 10 }
+
+        it "should invoke block for each element" do
+          block = Mock::Block.new()
+          expect(block).to receive(:call).exactly(subject.length / batch_size).times
+          subject.find_in_batches_with_order(:batch_size => batch_size, &block)
+        end
+
+        it "should return enumerator if no block given" do
+          block = Mock::Block.new()
+          expect(block).to receive(:call).exactly(subject.length / batch_size).times
+          subject.find_in_batches_with_order(:batch_size => batch_size).each(&block)
+        end
+      end
+    end
+  end
+end

data/spec/riveter/enquiry_controller_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+describe Riveter::EnquiryController do
+  context "when not configured" do
+    describe "class" do
+      subject { TestEnquiryController }
+
+      it { should respond_to(:enquiry_controller_for) }
+      it { should_not respond_to(:enquiry_class) }
+      it { should_not respond_to(:enquiry_options) }
+    end
+
+    describe "instance" do
+      subject { TestEnquiryController.new }
+
+      it { should_not respond_to(:index) }
+    end
+  end
+
+  context "when configured" do
+    describe "class" do
+      subject { TestTestEnquiryController }
+
+      it { should respond_to(:enquiry_controller_for) }
+    end
+
+    describe "instance" do
+      subject { TestTestEnquiryController.new }
+
+      it { should respond_to(:enquiry_class) }
+      it { should respond_to(:enquiry_options) }
+      it { should respond_to(:index) }
+
+      describe "#enquiry_class" do
+        it { subject.enquiry_class.should eq(TestEnquiry) }
+      end
+
+      describe "#enquiry_options" do
+        it { subject.enquiry_options.should have_key(:as) }
+        it { subject.enquiry_options.should have_key(:attributes) }
+
+        it { subject.enquiry_options[:as].should eq('test') }
+        it { subject.enquiry_options[:attributes].should eq(TestEnquiry.query_filter_attributes) }
+      end
+
+      describe "controller action" do
+        describe "#index" do
+          context "without params" do
+            before do
+              allow(subject).to receive(:params) { ActionController::Parameters.new({}) }
+            end
+
+            it "assigns @enquiry" do
+              subject.index
+              subject.send(:eval, '@enquiry').should_not be_nil
+            end
+          end
+
+          context "with params" do
+            before do
+              allow(subject).to receive(:params) { ActionController::Parameters.new({:test => {:name => 'test'}}) }
+            end
+
+            it "assigns @enquiry" do
+              subject.index
+              subject.send(:eval, '@enquiry').should_not be_nil
+            end
+
+            it "assigns attributes" do
+              subject.index
+              enquiry = subject.send(:eval, '@enquiry')
+              enquiry.filter.name.should eq('test')
+            end
+
+            context "for a valid enquiry" do
+              before do
+                allow_any_instance_of(TestEnquiry).to receive(:submit) { true }
+              end
+
+              it "assigns @enquiry" do
+                subject.index
+                subject.send(:eval, '@enquiry').should_not be_nil
+              end
+
+              it "invokes 'on_success' if defined" do
+                expect(subject).to receive(:on_success).with(kind_of(TestEnquiry))
+                subject.index
+              end
+            end
+
+            context "for an invalid enquiry" do
+              before do
+                allow_any_instance_of(TestEnquiry).to receive(:submit) { false }
+              end
+
+              it "assigns @enquiry" do
+                subject.index
+                subject.send(:eval, '@enquiry').should_not be_nil
+              end
+
+              it "invokes 'on_failure' if defined" do
+                expect(subject).to receive(:on_failure).with(kind_of(TestEnquiry))
+                subject.index
+              end
+            end
+          end
+
+          context "with reset param" do
+            before do
+              allow(subject).to receive(:params) { ActionController::Parameters.new({:reset => 'reset', :test => {:name => 'test'}}) }
+            end
+
+            it "assigns @enquiry" do
+              subject.index
+              subject.send(:eval, '@enquiry').should_not be_nil
+            end
+
+            it "clears attributes" do
+              subject.index
+              enquiry = subject.send(:eval, '@enquiry')
+              enquiry.filter.name.should be_blank
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/riveter/enquiry_routes_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+require 'riveter/enquiry_routes'
+
+describe Riveter::EnquiryRoutes do
+  describe "instance" do
+    subject { TestEnquiryRoutes.new() }
+
+    describe "#enquiry" do
+      it { should respond_to(:enquiry) }
+
+      it "should define a GET and POST route" do
+        expect(subject).to receive(:get)
+        expect(subject).to receive(:post)
+
+        subject.enquiry :test_enquiry
+      end
+
+      it "should define a GET route for the :index action" do
+        expect(subject).to receive(:get).with('test', {
+          :controller => :test_enquiry,
+          :as => :test_enquiry,
+          :action => :index
+        })
+        allow(subject).to receive(:post)
+
+        subject.enquiry :test
+      end
+
+      it "should define a POST route for the :index action" do
+        allow(subject).to receive(:get)
+        expect(subject).to receive(:post).with('test', {
+          :controller => :test_enquiry,
+          :as => nil,
+          :action => :index
+        })
+
+        subject.enquiry :test
+      end
+
+      it "should allow overriding the controller" do
+        expect(subject).to receive(:get).with('test', {
+          :controller => :my_controller,
+          :as => :test_enquiry,
+          :action => :index
+        })
+        expect(subject).to receive(:post).with('test', {
+          :controller => :my_controller,
+          :as => nil,
+          :action => :index
+        })
+
+        subject.enquiry :test, :controller => :my_controller
+      end
+
+      it "should allow overriding the path" do
+        expect(subject).to receive(:get).with('do_some_thing', {
+          :controller => :test_enquiry,
+          :as => :test_enquiry,
+          :action => :index
+        })
+        expect(subject).to receive(:post).with('do_some_thing', {
+          :controller => :test_enquiry,
+          :as => nil,
+          :action => :index
+        })
+
+        subject.enquiry :test, :path => 'do_some_thing'
+      end
+
+      it "should allow overriding the path helper name" do
+        expect(subject).to receive(:get).with('test', {
+          :controller => :test_enquiry,
+          :as => :path_name,
+          :action => :index
+        })
+        expect(subject).to receive(:post).with('test', {
+          :controller => :test_enquiry,
+          :as => nil,
+          :action => :index
+        })
+
+        subject.enquiry :test, :as => :path_name
+      end
+
+      it "should allow overriding the index action" do
+        expect(subject).to receive(:get).with('test', {
+          :controller => :test_enquiry,
+          :as => :test_enquiry,
+          :action => :my_new_action
+        })
+        expect(subject).to receive(:post).with('test', {
+          :controller => :test_enquiry,
+          :as => nil,
+          :action => :my_new_action
+        })
+
+        subject.enquiry :test, :action => :my_new_action
+      end
+    end
+  end
+end