riveter 0.0.1

data/spec/riveter/enquiry_spec.rb

@@ -0,0 +1,299 @@
+require 'spec_helper'
+
+describe Riveter::Enquiry do
+  describe "class" do
+    subject { TestEnquiry }
+
+    describe ".enquiry_name" do
+      it { should respond_to(:enquiry_name) }
+      it { subject.enquiry_name.should be_a(ActiveModel::Name) }
+    end
+
+    describe ".i18n_scope" do
+      it { should respond_to(:i18n_scope) }
+      it { subject.i18n_scope.should eq(:enquiries) }
+    end
+
+    describe ".filter_with" do
+      subject {
+        Class.new(Riveter::Enquiry::Base).instance_eval do
+          def enquiry_name
+            ActiveModel::Name.new(self, nil, 'TestEnquiry')
+          end
+
+          self
+        end
+      }
+
+      it { should respond_to(:filter_with) }
+
+      describe "called without a class or block" do
+        it "raise an error" do
+          expect {
+            subject.filter_with
+          }.to raise_error(ArgumentError)
+        end
+      end
+
+      describe "called with a class" do
+        it {
+          klass = Class.new(Riveter::QueryFilter::Base)
+          subject.filter_with(klass)
+          subject.query_with {}
+          subject.new().query_filter_class.should eq(klass)
+        }
+      end
+
+      describe "called with a block" do
+        it "invokes the block" do
+          block = Mock::Block.new()
+          expect(block).to receive(:call).at_least(:once)
+          subject.filter_with do
+            block.call
+          end
+        end
+
+        it "creates an anonymous class" do
+          block = Mock::Block.new()
+          allow(block).to receive(:call)
+
+          subject.filter_with do
+            block.call
+          end
+
+          subject.query_with {}
+
+          subject.new().query_filter.should be_a_kind_of(Riveter::QueryFilter::Base)
+        end
+
+        it "adds a .model_name method" do
+          subject.filter_with {}
+
+          # for forms support
+          subject.query_filter_class.should respond_to(:model_name)
+          subject.query_filter_class.model_name.should eq(subject.enquiry_name)
+        end
+      end
+    end
+
+    describe ".query_filter_class" do
+      it { should respond_to(:query_filter_class) }
+      it { subject.query_filter_class.should eq(TestQueryFilter) }
+    end
+
+    describe ".query_filter_attributes" do
+      it { should respond_to(:query_filter_attributes) }
+      it { subject.query_filter_attributes.should eq(TestQueryFilter.attributes) }
+    end
+
+    describe ".query_with" do
+      subject {
+        Class.new(Riveter::Enquiry::Base).instance_eval do
+          def enquiry_name
+            ActiveModel::Name.new(self, nil, 'TestEnquiry')
+          end
+
+          filter_with {}
+
+          self
+        end
+      }
+
+      it { should respond_to(:query_with) }
+
+      describe "called without a class or block" do
+        it "raise an error" do
+          expect {
+            subject.query_with
+          }.to raise_error(ArgumentError)
+        end
+      end
+
+      describe "called with a class" do
+        it {
+          klass = Class.new(Riveter::Query::Base)
+          subject.query_with(klass)
+          subject.new().query_class.should eq(klass)
+        }
+      end
+
+      describe "called with a block" do
+        it "invokes the block" do
+          block = Mock::Block.new()
+          allow(subject).to receive(:create_query_filter) { OpenStruct.new(:valid? => true) }
+
+          expect(block).to receive(:call).at_least(:once)
+
+          subject.query_with do |filter|
+            block.call
+          end
+
+          subject.new().submit()
+        end
+
+        it "creates an anonymous class" do
+          block = Mock::Block.new()
+          allow(block).to receive(:call)
+
+          subject.query_with do |filter|
+            block.call
+          end
+
+          subject.new().query_class.new(:query_filter).should be_a_kind_of(Riveter::Query::Base)
+        end
+      end
+    end
+
+    describe ".query_class" do
+      it { should respond_to(:query_class) }
+      it { subject.query_class.should eq(TestQuery) }
+    end
+  end
+
+  describe "instance" do
+    context "with incorrectly configured" do
+      it "fails when no filter or query set" do
+        expect {
+          Class.new(Riveter::Enquiry::Base).new()
+        }.to raise_error
+      end
+
+      it "fails when no query set" do
+        expect {
+          Class.new(Riveter::Enquiry::Base).tap {|klass|
+            klass.filter_with TestQueryFilter
+          }.new()
+        }.to raise_error
+      end
+
+      it "fails when no filter set" do
+        expect {
+          Class.new(Riveter::Enquiry::Base).tap {|klass|
+            klass.query_with TestQuery
+          }.new()
+        }.to raise_error
+      end
+    end
+
+    context "with correctly configured" do
+      subject { TestEnquiry.new() }
+
+      describe "#query_filter_class" do
+        it { subject.query_filter_class.should eq(TestQueryFilter) }
+      end
+
+      describe "#query_class" do
+        it { subject.query_class.should eq(TestQuery) }
+      end
+
+      describe "#query_filter" do
+        it { should respond_to(:filter) }
+        it { subject.query_filter.should be_a(TestQueryFilter)}
+      end
+
+      describe "#query_filter_attributes" do
+        it { subject.query_filter_attributes.should eq(TestQueryFilter.attributes)}
+      end
+
+      describe "#submit" do
+        it "yields the query for a valid filter" do
+          query = Object.new()
+          expect(subject).to receive(:create_query_filter) { OpenStruct.new(:valid? => true) }
+          expect(subject).to receive(:create_query) { query }
+          subject.submit().should eq(query)
+        end
+
+        it "yields false for an invalid filter" do
+          expect(subject).to receive(:create_query_filter) { OpenStruct.new(:valid? => false) }
+          subject.submit().should eq(false)
+        end
+
+        it "assigns query" do
+          query = Object.new()
+          expect(subject).to receive(:create_query_filter) { OpenStruct.new(:valid? => true) }
+          expect(subject).to receive(:create_query) { query }
+          subject.submit()
+          subject.query.should eq(query)
+        end
+      end
+
+      describe "#query" do
+        it { should respond_to(:query) }
+      end
+
+      describe "#find_each" do
+        it "invokes the given block when data" do
+          allow(subject).to receive(:query) { [1] }
+          block = Mock::Block.new()
+          expect(block).to receive(:call).at_least(:once)
+          subject.find_each(&block)
+        end
+
+        it "does not invoke the given block when query nil" do
+          allow(subject).to receive(:query) { nil }
+          block = Mock::Block.new()
+          expect(block).to_not receive(:call)
+          subject.find_each(&block)
+        end
+
+        it "does not invoke the given block when no data" do
+          allow(subject).to receive(:query) { [] }
+          block = Mock::Block.new()
+          expect(block).to_not receive(:call)
+          subject.find_each(&block)
+        end
+      end
+
+      describe "#has_data?" do
+        it "yields false when query nil" do
+          allow(subject).to receive(:query) { nil }
+          subject.has_data?.should be_false
+        end
+
+        it "yields false when query empty" do
+          allow(subject).to receive(:query) { OpenStruct.new(:has_data? => false) }
+          subject.has_data?.should be_false
+        end
+
+        it "yields true when query data" do
+          allow(subject).to receive(:query) { OpenStruct.new(:has_data? => true) }
+          subject.has_data?.should be_true
+        end
+      end
+
+      describe "#query_results" do
+        it { should respond_to(:query_results) }
+
+        it "yield false when invalid query" do
+          subject.query_results.should be_nil
+        end
+
+        it "yield query relation for a valid query" do
+          allow(subject).to receive(:query) { OpenStruct.new(:has_data? => true, :relation => []) }
+
+          subject.query_results.should eq([])
+        end
+      end
+
+      describe "#create_query_filter" do
+        it "should create an instance" do
+          subject.send(:create_query_filter, {}).should be_a(TestQueryFilter)
+        end
+
+        it "should assign params" do
+          subject.send(:create_query_filter, {:name => 'test'}).name.should eq('test')
+        end
+      end
+
+      describe "#create_query" do
+        it "should create an instance" do
+          subject.send(:create_query, {}).should be_a(TestQuery)
+        end
+
+        it "should assign filter" do
+          subject.send(:create_query, 'test').query_filter.should eq('test')
+        end
+      end
+    end
+  end
+end

data/spec/riveter/enumerated_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe Riveter::Enumerated do
+  subject { TestEnum }
+
+  describe "#human" do
+    it {
+      subject.human.should be_present
+    }
+  end
+
+  describe "#names" do
+    it { subject.names.should eq(%i{Member1 Member2}) }
+  end
+
+  describe "#all" do
+    it { subject.all.should eq([1, 2]) }
+  end
+
+  describe "#name_for" do
+    it { subject.name_for(1).should be_present }
+  end
+
+  describe "#human_name_for" do
+    it { subject.name_for(1).should be_present }
+    it { subject.name_for(1).should eq(:Member1) }
+  end
+
+  describe "#value_for" do
+    it { subject.value_for('Member1').should eq(1) }
+    it { subject.value_for(:Member1).should eq(1) }
+  end
+
+  describe "#collection" do
+    it { subject.collection.should be_present }
+    it { subject.collection.length.should eq(2) }
+  end
+
+  describe "::All" do
+    it { subject::All.should be_present }
+    it { subject::All.length.should eq(2) }
+  end
+
+  # TODO: scenario for a member value of nil
+  # TODO: scenario for a member value of a Class
+
+end

data/spec/riveter/form_builder_extensions_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+require 'riveter/form_builder_extensions'
+
+describe Riveter::FormBuilderExtensions do
+  describe "instance" do
+    subject { TestFormBuilder.new }
+
+    describe "#search" do
+      it { should respond_to(:search) }
+
+      it "should render a submit HTML element" do
+        expect(subject).to receive(:submit)
+
+        subject.search
+      end
+    end
+
+    describe "#reset" do
+      it { should respond_to(:reset) }
+
+      it "should render a submit HTML element" do
+        expect(subject).to receive(:submit)
+
+        subject.reset
+      end
+    end
+  end
+end

data/spec/riveter/presenter_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+describe Riveter::Presenter do
+  describe "#to_presenter" do
+    subject { Object.new() }
+
+    it { should respond_to(:to_presenter) }
+
+    it {
+      expect {
+        subject.to_presenter(nil)
+      }.to raise_error(ArgumentError)
+    }
+
+    it {
+      expect {
+        subject.to_presenter(Object)
+      }.to raise_error(ArgumentError)
+    }
+
+    it { subject.to_presenter(TestPresenter).should_not be_nil }
+    it { subject.to_presenter(TestPresenter).should be_instance_of(TestPresenter) }
+
+    it { OpenStruct.new(:name => :test).to_presenter(TestPresenter).should respond_to(:name) }
+    it { OpenStruct.new(:name => :test).to_presenter(TestPresenter).name.should eq(:test) }
+  end
+
+  describe "#with_presenter" do
+    subject { [1, 2, 3].each }
+
+    it { should respond_to(:with_presenter) }
+
+    it {
+      expect {
+        subject.with_presenter(nil)
+      }.to raise_error(ArgumentError)
+    }
+
+    it {
+      expect {
+        subject.with_presenter(Object)
+      }.to raise_error(ArgumentError)
+    }
+
+    it { subject.with_presenter(TestPresenter).should_not be_nil }
+
+    it "should yield to block for each item" do
+      block = Mock::Block.new()
+      expect(block).to receive(:call).exactly(subject.count).times
+      subject.with_presenter(TestPresenter, &block)
+    end
+
+    it "should yield to block with the presenter for each item" do
+      subject.with_presenter(TestPresenter) do |item|
+        item.should be_instance_of(TestPresenter)
+      end
+    end
+
+    it "should return enumerator if no block given" do
+      block = Mock::Block.new()
+      expect(block).to receive(:call).exactly(subject.count).times
+      subject.with_presenter(TestPresenter).each(&block)
+    end
+  end
+
+  describe "instance" do
+    describe "#item" do
+      subject { TestPresenter.new(:item) }
+      it { should respond_to(:item) }
+      it { subject.item.should eq(:item) }
+    end
+
+    describe "#method_missing" do
+      let!(:item) {
+        Class.new().class_eval do
+          def some_method
+          end
+
+          self
+        end.new()
+      }
+
+      describe "methods on item" do
+        subject { TestPresenter.new(item) }
+
+        it "respond_to? yields true" do
+          should respond_to(:some_method)
+        end
+
+        it "delegates to item" do
+          expect(item).to receive(:some_method)
+          subject.some_method
+        end
+      end
+
+      describe "methods on view" do
+        let!(:view) {
+          Class.new().class_eval do
+            def some_other_method
+            end
+
+            self
+          end.new()
+        }
+
+        subject { TestPresenter.new(item, view) }
+
+        it "respond_to? yields true" do
+          should respond_to(:some_other_method)
+        end
+
+        it "delegates to item" do
+          expect(item).to receive(:some_method)
+          subject.some_method
+        end
+
+        it "delegates to view" do
+          expect(view).to receive(:some_other_method)
+
+          subject.some_other_method
+        end
+
+        it "raise error if no method" do
+          expect {
+            subject.non_existent_method
+          }.to raise_error
+        end
+      end
+    end
+  end
+end

data/spec/riveter/query_filter_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Riveter::QueryFilter do
+  it_should_behave_like "a class with attributes", TestQueryFilter
+
+  describe "class" do
+    subject { TestQueryFilter }
+
+    describe ".filter_name" do
+      it { should respond_to(:filter_name) }
+      it { subject.filter_name.should be_a(ActiveModel::Name) }
+    end
+
+    describe ".i18n_scope" do
+      it { should respond_to(:i18n_scope) }
+      it { subject.i18n_scope.should eq(:query_filters) }
+    end
+  end
+end

data/spec/riveter/query_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+require 'riveter/spec_helper'
+
+describe Riveter::Query do
+  describe "#initialize" do
+    it "should call #build_relation" do
+      expect_any_instance_of(TestQuery).to receive(:build_relation).with(:filter)
+      TestQuery.new(:filter)
+    end
+
+    it "should assign the filter" do
+      TestQuery.new(:filter).query_filter.should eq(:filter)
+    end
+
+    it "should assign the options" do
+      TestQuery.new(:filter, :key => :value).options.should eq({:key => :value})
+    end
+
+    it "should assign the relation" do
+      query = TestQuery.new(nil)
+      query.relation.should eq(query.build_relation(:filter))
+    end
+  end
+
+  describe "#build_relation" do
+    it "should raise NotImplementedError if not implemented" do
+      klass = Class.new(Riveter::Query::Base)
+      expect {
+        klass.new(:filter)
+      }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe "#find_each" do
+    it "should enumerate relation" do
+      # Note: Array implements `find_each_with_order`
+      allow_any_instance_of(TestQuery).to receive(:build_relation) { [1] }
+      query = TestQuery.new(nil)
+      expect(query.relation).to receive(:find_each_with_order)
+      query.find_each {}
+    end
+
+    it "should invoke block" do
+      block = Mock::Block.new()
+      expect(block).to receive(:call).at_least(:once)
+
+      fake_relation = [1]
+      allow(fake_relation).to receive(:find_each_with_order) do |*args, &block|
+        block.call(*args)
+      end
+      allow_any_instance_of(TestQuery).to receive(:relation) { fake_relation }
+
+      query = TestQuery.new(nil)
+      query.find_each &block
+    end
+  end
+
+  describe "#has_data?" do
+    it "should yield true when data available" do
+      allow_any_instance_of(TestQuery).to receive(:relation) { [1] }
+      query = TestQuery.new(nil)
+      query.has_data?.should be_true
+    end
+
+    it "should yield false when no data available" do
+      allow_any_instance_of(TestQuery).to receive(:relation) { [] }
+      query = TestQuery.new(nil)
+      query.has_data?.should be_false
+    end
+  end
+
+end

data/spec/riveter/service_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Riveter::Service do
+  describe "class" do
+    subject { TestService }
+
+    it "automatically registers as handler for TestCommand" do
+      Riveter::Service::Base.resolve(:test_command).should eq(subject)
+    end
+
+    describe ".register_as_handler_for" do
+      let(:command_class) { TestCommand }
+
+      it { should respond_to(:register_as_handler_for) }
+
+      it "registers as handler for given command" do
+        expect(subject).to receive(:register_type).with(subject, command_class)
+        subject.register_as_handler_for(command_class)
+      end
+
+      it "allows for more than one registration" do
+        my_test_command_class = Class.new(Riveter::Command::Base)
+        allow(my_test_command_class).to receive(:name) { 'MyTestCommand' } # anonymous classes need a name!
+
+        TestService.register_as_handler_for my_test_command_class
+        Riveter::Service::Base.resolve(:my_test_command).should eq(subject)
+      end
+    end
+  end
+
+  describe "instance" do
+    subject { TestService.new() }
+
+    describe "#perform" do
+      it { should respond_to(:perform) }
+
+      it "should raise NotImplementedError if not implemented" do
+        expect {
+          subject.perform(nil)
+        }.to raise_error(NotImplementedError)
+      end
+
+      it "should invoke" do
+        expect(subject).to receive(:perform) { true }
+        subject.perform(TestCommand.new()).should be_true
+      end
+    end
+  end
+end

data/spec/riveter/spec_helper_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+require 'riveter/spec_helper'
+
+describe "Spec Helper" do
+  describe Mock::Block do
+    it "yields a proc object" do
+      Mock::Block.new().to_proc.should be_a(Proc)
+    end
+
+    it "the proc invokes the call method" do
+      expect_any_instance_of(Mock::Block).to receive(:call).at_least(:once)
+      Mock::Block.new().to_proc.call
+    end
+
+    it "default call method raises an error" do
+      expect {
+        Mock::Block.new().call
+      }.to raise_error(NotImplementedError)
+    end
+  end
+end

data/spec/riveter/worker_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Riveter::Worker do
+  describe "class" do
+    pending "TODO"
+  end
+
+  describe "instance" do
+    pending "TODO"
+  end
+end