brainstem 0.2.6.1 → 1.0.0.pre.1

data/spec/brainstem/controller_methods_spec.rb

@@ -1,8 +1,7 @@
 require 'spec_helper'
-require 'spec_helpers/presenters'
 
 describe Brainstem::ControllerMethods do
-  class FakeController
+  class TasksController
     include Brainstem::ControllerMethods
 
     attr_accessor :call_results
@@ -12,73 +11,62 @@ describe Brainstem::ControllerMethods do
     end
   end
 
-  before do
-    UserPresenter.presents User
-    TaskPresenter.presents Task
-    WorkspacePresenter.presents Workspace
-    PostPresenter.presents Post
-  end
-
   describe "#present_object" do
     before do
-      @controller = FakeController.new
+      @controller = TasksController.new
     end
 
     describe "calling #present with sensible params" do
       before do
-        def @controller.present(klass, options)
+        def @controller.brainstem_present(klass, options)
           @call_results = { :klass => klass, :options => options, :block_result => yield }
         end
       end
 
       it "works with arrays of ActiveRecord objects" do
-        @controller.present_object([Workspace.find(1), Workspace.find(3)])
+        @controller.brainstem_present_object([Workspace.find(1), Workspace.find(3)])
         expect(@controller.call_results[:klass]).to eq(Workspace)
-        expect(@controller.call_results[:options][:as]).to eq("workspaces")
         expect(@controller.call_results[:block_result].pluck(:id)).to eq([1, 3])
       end
 
       it "works with a Relation" do
-        @controller.present_object(Workspace.owned_by(1))
+        @controller.brainstem_present_object(Workspace.owned_by(1))
         expect(@controller.call_results[:klass]).to eq(Workspace)
-        expect(@controller.call_results[:options][:as]).to eq("workspaces")
         expect(@controller.call_results[:block_result].pluck(:id)).to eq([1, 2, 3, 4])
       end
 
       it "works with singleton objects" do
-        @controller.present_object(Workspace.find(1))
+        @controller.brainstem_present_object(Workspace.find(1))
         expect(@controller.call_results[:klass]).to eq(Workspace)
-        expect(@controller.call_results[:options][:as]).to eq("workspaces")
         expect(@controller.call_results[:block_result].pluck(:id)).to eq([1])
       end
 
-      it "accepts a key map" do
-        @controller.present_object(Workspace.find(1), :key_map => { "Workspace" => "your_workspaces" })
-        expect(@controller.call_results[:klass]).to eq(Workspace)
-        expect(@controller.call_results[:options][:as]).to eq("your_workspaces")
-        expect(@controller.call_results[:block_result].pluck(:id)).to eq([1])
+      it "raises an error when given a key_map" do
+        expect {
+          @controller.brainstem_present_object(Workspace.find(1), :key_map => { "Workspace" => "your_workspaces" })
+        }.to raise_error(/brainstem_key annotation/)
       end
 
       it "passes through the controller params" do
-        @controller.present_object(Workspace.find(1), :key_map => { "Workspace" => "your_workspaces" })
+        @controller.brainstem_present_object(Workspace.find(1))
         expect(@controller.call_results[:options][:params]).to eq(@controller.params.merge(:only => '1'))
       end
 
       it "passes through supplied options" do
-        @controller.present_object(Workspace.find(1), :foo => :bar)
+        @controller.brainstem_present_object(Workspace.find(1), :foo => :bar)
         expect(@controller.call_results[:options][:foo]).to eq(:bar)
       end
 
       it "adds an only param if there is only one object to present" do
-        @controller.present_object(Workspace.find(1))
+        @controller.brainstem_present_object(Workspace.find(1))
         expect(@controller.call_results[:options][:params][:only]).to eq("1")
 
-        @controller.present_object(Workspace.all)
+        @controller.brainstem_present_object(Workspace.all)
         expect(@controller.call_results[:options][:params][:only]).to be_nil
       end
 
       it "passes :apply_default_filters => false to the PresenterCollection so that filters are not applied by default" do
-        @controller.present_object(Workspace.find(1))
+        @controller.brainstem_present_object(Workspace.find(1))
         expect(@controller.call_results[:options][:apply_default_filters]).to eq(false)
       end
     end

data/spec/brainstem/dsl/association_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+require 'brainstem/dsl/association'
+
+describe Brainstem::DSL::Association do
+  let(:name) { :user }
+  let(:target_class) { User }
+  let(:description) { "This object's user" }
+  let(:options) { { } }
+  let(:association) { Brainstem::DSL::Association.new(name, target_class, description, options) }
+
+  describe "#run_on" do
+    let(:context) { { } }
+
+    context 'with no special options' do
+      it 'calls the method by name on the model' do
+        object = Object.new
+        mock(object).user
+        association.run_on(object, context)
+      end
+    end
+
+    context 'when given a via' do
+      let(:options) { { via: :user2 } }
+
+      it 'calls the method named in :via on the model' do
+        object = Object.new
+        mock(object).user2
+        association.run_on(object, context)
+      end
+    end
+
+    context 'when given a dynamic lambda' do
+      let(:options) { { dynamic: lambda { |model| some_instance_method; :return_value } } }
+
+      it 'calls the lambda in the context of the given instance' do
+        instance = Object.new
+        mock(instance).some_instance_method
+        expect(association.run_on(:anything, context, instance)).to eq :return_value
+      end
+    end
+
+    context 'when given a lookup lambda' do
+      let(:options) { { lookup: lambda { |models| some_instance_method; Hash[models.map { |model| [model.id, model.username] }] } } }
+      let(:first_model) { target_class.create(username: 'Ben') }
+      let(:second_model) { target_class.create(username: 'Nate') }
+      let(:models) { [first_model, second_model] }
+      let(:context) {
+        {
+          lookup: Brainstem::Presenter.new.send(:empty_lookup_cache, [], [name.to_s]),
+          models: models
+        }
+      }
+      # {:lookup=>{:fields=>{}, :associations=>{"user"=>nil}}}
+
+      context 'The first model is ran' do
+        it 'builds lookup cache and returns the value for the first model' do
+          expect(context[:lookup][:associations][name.to_s]).to eq(nil)
+          instance = Object.new
+          mock(instance).some_instance_method
+          expect(association.run_on(first_model, context, instance)).to eq('Ben')
+          expect(context[:lookup][:associations][name.to_s]).to eq({ first_model.id => 'Ben', second_model.id => 'Nate' })
+        end
+      end
+
+      context 'The second model is ran after the first' do
+        it 'returns the value from the lookup cache and does not run the lookup' do
+          instance = Object.new
+          mock(instance).some_instance_method
+          association.run_on(first_model, context, instance)
+          expect(context[:lookup][:associations][name.to_s]).to eq({ first_model.id => 'Ben', second_model.id => 'Nate' })
+
+          mock(instance).some_instance_method.never
+          expect(association.run_on(second_model, context, instance)).to eq('Nate')
+        end
+      end
+
+      context 'with no lookup_fetch' do
+        context 'when the lookup returns on object which does not respond to []' do
+          let(:options) { { lookup: lambda { |models| nil } } }
+
+          it 'should raise error explaining the default lookup fetch relies on [] to access the model\'s value from the lookup' do
+            expect {
+              association.run_on(first_model, context)
+            }.to raise_error(StandardError, 'Brainstem expects the return result of the `lookup` to be a Hash since it must respond to [] in order to access the model\'s assocation(s). Default: lookup_fetch: lambda { |lookup, model| lookup[model.id] }`')
+          end
+        end
+      end
+
+      context 'with a dynamic lambda' do
+        let(:options) {
+          {
+            lookup: lambda { |models| lookup_instance_method; Hash[models.map { |model| [model.id, model.username] }] },
+            dynamic: lambda { |model| dynamic_instance_method; model.username }
+          }
+        }
+
+        it 'calls the lookup lambda and not the dynamic lambda' do
+          instance = Object.new
+          mock(instance).dynamic_instance_method.never
+          mock(instance).lookup_instance_method
+          expect(association.run_on(first_model, context, instance)).to eq 'Ben'
+        end
+      end
+
+      context 'when given a lookup_fetch' do
+        let(:options) {
+          {
+            lookup: lambda { |models| Hash[models.map { |model| [model.id, model.username] }] },
+            lookup_fetch: lambda { |lookup, model| some_instance_method; lookup[model.id] }
+          }
+        }
+
+        it 'returns the value from the lookup using the lookup_fetch lambda' do
+          context[:lookup][:associations][name.to_s] = {}
+          context[:lookup][:associations][name.to_s][first_model.id] = "Ben's stubbed out Name"
+          instance = Object.new
+          mock(instance).some_instance_method
+          expect(association.run_on(first_model, context, instance)).to eq("Ben's stubbed out Name")
+        end
+      end
+    end
+  end
+end

data/spec/brainstem/dsl/conditional_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+require 'brainstem/dsl/conditional'
+
+describe Brainstem::DSL::Conditional do
+  let(:conditional) { Brainstem::DSL::Conditional.new(name, type, action, description) }
+  let(:model) { Workspace.first }
+
+  describe '.matches?' do
+    context 'as a :model conditional' do
+      let(:name) { :title_is_hello }
+      let(:type) { :model }
+      let(:action) { lambda { |model| model.title == 'hello' } }
+      let(:description) { 'visible when the title is hello' }
+
+      it 'calls the action and passes in the given model' do
+        model.title = 'not hello'
+        expect(conditional.matches?(model)).to be false
+        model.title = 'hello'
+        expect(conditional.matches?(model)).to be true
+      end
+
+      describe 'when given a helper instance' do
+        let(:action) { lambda { |model| some_method == 5 } }
+
+        it 'calls the action in the context of the given helper' do
+          helper_class = Class.new do
+            def some_method
+              5
+            end
+          end
+          expect(conditional.matches?(model, helper_class.new)).to be true
+        end
+      end
+
+      it 'caches in the model conditional cache' do
+        hash = { model: {}, request: {} }
+        expect(conditional.matches?(model, Object.new, hash)).to be false
+        expect(hash).to eq({ model: { title_is_hello: false }, request: {} })
+
+        model.title = 'hello'
+        expect(conditional.matches?(model, Object.new, hash)).to be false
+
+        hash = { model: {}, request: {} }
+        expect(conditional.matches?(model, Object.new, hash)).to be true
+      end
+    end
+
+    context 'as a :request conditional' do
+      let(:name) { :user_is_bob }
+      let(:type) { :request }
+      let(:action) { lambda { current_user == 'bob' } }
+      let(:description) { 'visible only to bob' }
+
+      it 'calls the action in the helper context, without passing in any arguments' do
+        helper_class = Class.new do
+          def current_user
+            'jane'
+          end
+        end
+        expect(conditional.matches?(model, helper_class.new)).to be false
+
+        helper_class = Class.new do
+          def current_user
+            'bob'
+          end
+        end
+        expect(conditional.matches?(model, helper_class.new)).to be true
+      end
+
+      it 'performs caching' do
+        cache = { model: {}, request: {} }
+
+        helper_class = Class.new do
+          def current_user
+            'jane'
+          end
+        end
+        expect(conditional.matches?(model, helper_class.new, cache)).to be false
+        expect(cache[:request][:user_is_bob]).to be false
+
+        helper_class = Class.new do
+          def current_user
+            'bob'
+          end
+        end
+        expect(conditional.matches?(model, helper_class.new, cache)).to be false
+
+        cache = { model: {}, request: {} }
+        expect(conditional.matches?(model, helper_class.new, cache)).to be true
+      end
+    end
+  end
+end

data/spec/brainstem/dsl/configuration_spec.rb

@@ -0,0 +1 @@
+# This is tested in concerns/inheritable_configuration_spec.rb

data/spec/brainstem/dsl/field_spec.rb

@@ -0,0 +1,212 @@
+require 'spec_helper'
+require 'brainstem/dsl/field'
+
+describe Brainstem::DSL::Field do
+  let(:name) { :title }
+  let(:type) { :string }
+  let(:description) { 'the title of this model' }
+  let(:options) { { } }
+  let(:field) { Brainstem::DSL::Field.new(name, type, description, options) }
+  let(:model) { Workspace.first }
+
+  describe '#method_name' do
+    describe 'by default' do
+      it 'returns the name' do
+        expect(field.method_name).to eq 'title'
+      end
+    end
+
+    describe 'on dynamic fields' do
+      let(:options) { { dynamic: lambda { 2 } } }
+
+      it 'returns nil' do
+        expect(field.method_name).to be_nil
+      end
+    end
+
+    describe 'when :via is present' do
+      let(:options) { { via: :description } }
+
+      it 'uses the :via method name' do
+        expect(field.method_name).to eq 'description'
+      end
+    end
+  end
+
+  describe '#run_on' do
+    let(:context) { { } }
+
+    context 'on :dynamic fields' do
+      let(:options) { { dynamic: lambda { some_instance_method } } }
+
+      it 'calls the :dynamic lambda in the context of the given instance' do
+        do_not_allow(model).title
+        instance = Object.new
+        mock(instance).some_instance_method
+        field.run_on(model, context, instance)
+      end
+    end
+
+    context 'on :lookup fields' do
+      let(:options) { { lookup: lambda { |models| some_instance_method; Hash[models.map { |model| [model.id, model.title] }] } } }
+      let(:first_model) { Workspace.create(title: "Ben's Project") }
+      let(:second_model) { Workspace.create(title: "Nate's Project") }
+      let(:models) { [first_model, second_model] }
+      let(:context) {
+        {
+          lookup: Brainstem::Presenter.new.send(:empty_lookup_cache, [name.to_s], []),
+          models: models
+        }
+      }
+      # {:lookup=>{:fields=>{"title"=>nil}, :associations=>{}}
+
+      context 'The first model is ran' do
+        it 'builds lookup cache and returns the value for the first model' do
+          expect(context[:lookup][:fields][name.to_s]).to eq(nil)
+          instance = Object.new
+          mock(instance).some_instance_method
+          expect(field.run_on(first_model, context, instance)).to eq("Ben's Project")
+          expect(context[:lookup][:fields][name.to_s]).to eq({ first_model.id => "Ben's Project", second_model.id => "Nate's Project" })
+        end
+      end
+
+      context 'The second model is ran after the first' do
+        it 'returns the value from the lookup cache and does not run the lookup' do
+          instance = Object.new
+          mock(instance).some_instance_method
+          field.run_on(first_model, context, instance)
+          expect(context[:lookup][:fields][name.to_s]).to eq({ first_model.id => "Ben's Project", second_model.id => "Nate's Project" })
+
+          mock(instance).some_instance_method.never
+          expect(field.run_on(second_model, context, instance)).to eq("Nate's Project")
+        end
+      end
+
+      context 'with no lookup_fetch' do
+        context 'when the lookup returns on object which does not respond to []' do
+          let(:options) { { lookup: lambda { |models| nil } } }
+
+          it 'should raise error explaining the default lookup fetch relies on [] to access the model\'s value from the lookup' do
+            expect {
+              field.run_on(first_model, context)
+            }.to raise_error(StandardError, 'Brainstem expects the return result of the `lookup` to be a Hash since it must respond to [] in order to access the model\'s assocation(s). Default: lookup_fetch: lambda { |lookup, model| lookup[model.id] }`')
+          end
+        end
+      end
+
+      context 'with a dynamic lambda' do
+        let(:options) {
+          {
+            lookup: lambda { |models| lookup_instance_method; Hash[models.map { |model| [model.id, model.title] }] },
+            dynamic: lambda { |model| dynamic_instance_method; model.title }
+          }
+        }
+
+        it 'does not use the dynamic lambda' do
+          instance = Object.new
+          mock(instance).dynamic_instance_method.never
+          mock(instance).lookup_instance_method
+          expect(field.run_on(first_model, context, instance)).to eq "Ben's Project"
+        end
+      end
+
+      context 'on :lookup_fetch' do
+        let(:options) {
+          {
+            lookup: lambda { |models| Hash[models.map { |model| [model.id, model.title] }] },
+            lookup_fetch: lambda { |lookup, model| some_instance_method; lookup[model.id] }
+          }
+        }
+
+        it 'returns the value from the lookup using the lookup_fetch lambda' do
+          context[:lookup][:fields][name.to_s] = {}
+          context[:lookup][:fields][name.to_s][first_model.id] = "Ben's stubbed out Project"
+          instance = Object.new
+          mock(instance).some_instance_method
+          expect(field.run_on(first_model, context, instance)).to eq("Ben's stubbed out Project")
+        end
+      end
+    end
+
+    context 'on non-:dynamic fields' do
+      it 'calls method_name on the model' do
+        mock(model).foo
+        mock(field).method_name { 'foo' }
+        field.run_on(model, context)
+      end
+    end
+  end
+
+  describe '#conditionals_match?' do
+    let(:fake_conditional) do
+      Class.new do
+        def initialize(result)
+          @result = result
+        end
+
+        def matches?(model, helper_instance, conditional_cache)
+          @result
+        end
+      end
+    end
+
+    context 'when no :if option has been set on the field' do
+      it 'returns true when there are no conditions' do
+        expect(field.conditionals_match?(model, WorkspacePresenter.configuration[:conditionals])).to eq true
+      end
+    end
+
+    context 'when a single :if has been set' do
+      let(:options) { { if: :title_is_hello } }
+
+      it 'returns true if the conditional matches' do
+        expect(field.conditionals_match?(model, title_is_hello: fake_conditional.new(true))).to eq true
+      end
+
+      it 'returns false if the conditional does not match' do
+        expect(field.conditionals_match?(model, title_is_hello: fake_conditional.new(false))).to eq false
+      end
+    end
+
+    context 'when multiple :if options have been passed' do
+      let(:options) { { if: [:title_is_hello, :user_is_bob] } }
+
+      it 'returns true if all of the conditionals match' do
+        expect(field.conditionals_match?(model, title_is_hello: fake_conditional.new(true), user_is_bob: fake_conditional.new(false))).to eq false
+        expect(field.conditionals_match?(model, title_is_hello: fake_conditional.new(false), user_is_bob: fake_conditional.new(true))).to eq false
+        expect(field.conditionals_match?(model, title_is_hello: fake_conditional.new(true), user_is_bob: fake_conditional.new(true))).to eq true
+        expect(field.conditionals_match?(model,
+                                         unknown: fake_conditional.new(false),
+                                         title_is_hello: fake_conditional.new(true),
+                                         user_is_bob: fake_conditional.new(true))).to eq true
+      end
+    end
+  end
+
+  describe "#optioned?" do
+    context "when is not an optional field" do
+      it 'returns true' do
+        expect(field.optioned?(['some_optional_field', 'some_other_optional_field'])).to eq true
+      end
+    end
+
+    context "when is an optional field" do
+      let(:name) { :expensive_title }
+      let(:type) { :string }
+      let(:options) { { optional: true } }
+      let(:description) { 'the optional expensive title field' }
+
+      context "when not requested" do
+        it 'returns false' do
+          expect(field.optioned?([])).to eq false
+        end
+      end
+
+      context "when requested" do
+        it 'returns true' do
+          expect(field.optioned?(['expensive_title', 'some_other_optional_field'])).to eq true
+        end
+      end
+    end
+  end
+end