brainstem 0.2.6.1 → 1.0.0.pre.1

data/spec/brainstem/concerns/controller_param_management_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require 'brainstem/concerns/controller_param_management'
+
+describe Brainstem::Concerns::ControllerParamManagement do
+  class TasksController
+    include Brainstem::Concerns::ControllerParamManagement
+
+    def controller_name
+      'tasks'
+    end
+  end
+
+  before do
+    TasksController.brainstem_model_name = nil
+    TasksController.brainstem_plural_model_name = nil
+  end
+
+  describe '.brainstem_model_name' do
+    it 'is settable on the controller' do
+      TasksController.brainstem_model_name = 'thingy'
+      expect(TasksController.new.brainstem_model_name).to eq 'thingy'
+    end
+
+    it 'has good defaults' do
+      expect(TasksController.new.brainstem_model_name).to eq 'task'
+      expect(TasksController.new.brainstem_plural_model_name).to eq 'tasks'
+    end
+  end
+
+  describe '.brainstem_plural_model_name' do
+    it 'is infered from the singular model name' do
+      TasksController.brainstem_model_name = 'thingy'
+      expect(TasksController.new.brainstem_plural_model_name).to eq 'thingies'
+    end
+
+    it 'can be overridden' do
+      TasksController.brainstem_model_name = 'thingy'
+      TasksController.brainstem_plural_model_name = 'thingzees'
+      expect(TasksController.new.brainstem_plural_model_name).to eq 'thingzees'
+    end
+  end
+end

data/spec/brainstem/concerns/error_presentation_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+require 'brainstem/concerns/error_presentation'
+
+describe Brainstem::Concerns::ErrorPresentation do
+  class ErrorsController
+    include Brainstem::Concerns::ErrorPresentation
+  end
+
+  let(:controller) { ErrorsController.new }
+
+  describe "#brainstem_system_error" do
+    let(:options) { { type: :other } }
+
+    it "accepts a list of messages" do
+      error_response = {errors: [{type: :system, message: "error1"}, {type: :system, message: "error2"}]}
+      expect(controller.brainstem_system_error("error1", "error2")).to eq(error_response)
+      expect(controller.brainstem_system_error(["error1", "error2"])).to eq(error_response)
+    end
+
+    it "accepts an options hash as last argument" do
+      error_response = {errors: [{type: :other, message: "error1"}, {type: :other, message: "error2"}]}
+      expect(controller.brainstem_system_error("error1", "error2", options)).to eq(error_response)
+      expect(controller.brainstem_system_error(["error1", "error2"], options)).to eq(error_response)
+    end
+  end
+
+  describe "#brainstem_model_error" do
+    context 'with a Hash or Hashes' do
+      it 'has a default type' do
+        expect(controller.brainstem_model_error({ message: 'hello', field: 'some_field' })).to eq({ errors: [ { message: 'hello', type: 'validation', field: 'some_field' } ] })
+        expect(controller.brainstem_model_error([{ message: 'hello1', field: 'some_field1' }, { message: 'hello2', field: 'some_field2' }])).to eq({
+          errors: [
+            { message: 'hello1', type: 'validation', field: 'some_field1' },
+            { message: 'hello2', type: 'validation', field: 'some_field2' }
+          ]
+        })
+      end
+
+      it 'can override the type' do
+        expect(controller.brainstem_model_error({ message: 'something', type: 'foo' })[:errors].first[:type]).to eq 'foo'
+      end
+
+      it 'raises an ArgumentError when no message is given' do
+        expect { controller.brainstem_model_error({ type: 'foo' }) }.to raise_error(ArgumentError, /message required/)
+      end
+    end
+
+    it 'can handle a String' do
+      expect(controller.brainstem_model_error("hello")).to eq({ errors: [ { message: 'hello', type: 'validation', field: :base } ] })
+      expect(controller.brainstem_model_error(["hello", "world"])).to eq({
+        errors: [
+          { message: 'hello', type: 'validation', field: :base },
+          { message: 'world', type: 'validation', field: :base }
+        ]
+      })
+    end
+
+    context 'with models' do
+      class Model
+        include ActiveModel::Validations
+      end
+
+      it 'can handle a single Model' do
+        model = Model.new
+        model.errors.add(:title, 'must be present')
+        expect(controller.brainstem_model_error(model)).to eq({ errors: [ { message: 'Title must be present', type: 'validation', field: :title, index: 0 } ] })
+      end
+  
+      it 'can handle an array of Models' do
+        model1 = Model.new
+        model1.errors.add(:title, 'must be present')
+        model2 = Model.new
+        model2.errors.add(:foo, 'cannot be blank')
+        model2.errors.add(:base, 'This model is invalid')
+        
+        expect(controller.brainstem_model_error([model1, model2])).to eq({
+          errors: [
+            { message: 'Title must be present', type: 'validation', field: :title, index: 0 },
+            { message: 'Foo cannot be blank', type: 'validation', field: :foo, index: 1 },
+            { message: 'This model is invalid', type: 'validation', field: :base, index: 1 },
+          ]
+        })
+      end
+  
+      it 'can rewrite from internal to external field names' do
+        model = Model.new
+        model.errors.add(:title, 'must be present')
+        model.errors.add(:foo, 'cannot be blank')
+        
+        expect(controller.brainstem_model_error(model, rewrite_params: { external_title: :title })).to eq({
+          errors: [
+            { message: 'Title must be present', type: 'validation', field: :external_title, index: 0 },
+            { message: 'Foo cannot be blank', type: 'validation', field: :foo, index: 0 },
+          ]
+        })
+      end
+
+      it 'handles magic ^ in error message' do
+        model = Model.new
+        model.errors.add(:title, '^Your thing must have a title')
+
+        expect(controller.brainstem_model_error(model)).to eq({
+          errors: [
+            message:  'Your thing must have a title',
+            type:     'validation',
+            field:    :title,
+            index:    0,
+          ]
+        })
+      end
+    end
+  end
+end

data/spec/brainstem/concerns/inheritable_configuration_spec.rb

@@ -0,0 +1,210 @@
+require 'spec_helper'
+require 'brainstem/concerns/inheritable_configuration'
+
+describe Brainstem::Concerns::InheritableConfiguration do
+  let(:parent_class) do
+    Class.new do
+      include Brainstem::Concerns::InheritableConfiguration
+    end
+  end
+
+  describe '.configuration' do
+    it 'is inherited' do
+      expect(parent_class.configuration['empty']).to be_nil
+      parent_class.configuration['two'] = 2
+      parent_class.configuration['five'] = 5
+      expect(parent_class.configuration['two']).to eq 2
+      expect(parent_class.configuration['five']).to eq 5
+
+      subclass = Class.new(parent_class)
+      expect(subclass.configuration['empty']).to be_nil
+      expect(subclass.configuration['two']).to eq 2
+      expect(subclass.configuration['five']).to eq 5
+
+      subclass.configuration['two'] = 3
+      subclass.configuration['ten'] = 10
+      expect(subclass.configuration['empty']).to be_nil
+      expect(subclass.configuration['two']).to eq 3
+      expect(subclass.configuration['five']).to eq 5
+      expect(subclass.configuration['ten']).to eq 10
+
+      expect(parent_class.configuration['two']).to eq 2
+      expect(parent_class.configuration['five']).to eq 5
+      expect(parent_class.configuration['ten']).to be_nil
+    end
+
+    describe '#keys' do
+      it "returns the union of this class's keys with any parent keys" do
+        parent_class.configuration['1'] = :a
+        parent_class.configuration['2'] = :b
+
+        subclass = Class.new(parent_class)
+        subclass.configuration['2'] = :c
+        subclass.configuration['3'] = :d
+
+        subsubclass = Class.new(subclass)
+        subsubclass.configuration['3'] = :e
+        subsubclass.configuration['4'] = :f
+
+        expect(parent_class.configuration.keys).to eq ['1', '2']
+        expect(subclass.configuration.keys).to eq ['1', '2', '3']
+        expect(subsubclass.configuration.keys).to eq ['1', '2', '3', '4']
+
+        expect(parent_class.configuration['1']).to eq :a
+        expect(parent_class.configuration['2']).to eq :b
+        expect(parent_class.configuration['3']).to be_nil
+        expect(subclass.configuration['1']).to eq :a
+        expect(subclass.configuration['2']).to eq :c
+        expect(subclass.configuration['3']).to eq :d
+        expect(subclass.configuration['4']).to be_nil
+        expect(subsubclass.configuration['1']).to eq :a
+        expect(subsubclass.configuration['2']).to eq :c
+        expect(subsubclass.configuration['3']).to eq :e
+        expect(subsubclass.configuration['4']).to eq :f
+      end
+    end
+
+    describe '#nest!' do
+      it 'builds nested objects' do
+        parent_class.configuration.nest!('top_level')
+        expect(parent_class.configuration['top_level']).to be_a(Brainstem::DSL::Configuration)
+        parent_class.configuration.nest!('top_level').nest!('next_level')
+        expect(parent_class.configuration['top_level']['next_level']).to be_a(Brainstem::DSL::Configuration)
+      end
+
+      it 'is chainable' do
+        parent_class.configuration.nest!('top_level').nest!('sub_one')
+        sub_two = parent_class.configuration.nest!('top_level').nest!('sub_two')
+        expect(parent_class.configuration['top_level']['sub_one']).to be_a(Brainstem::DSL::Configuration)
+        expect(parent_class.configuration['top_level']['sub_two']).to be_a(Brainstem::DSL::Configuration)
+        expect(parent_class.configuration['top_level']['sub_two']).to be sub_two
+      end
+
+      it 'inherits nested values' do
+        parent_class.configuration.nest!('top_level').nest!('sub_one')
+        parent_class.configuration.nest!('top_level').nest!('sub_two')
+        parent_class.configuration['top_level']['key'] = 'value'
+        parent_class.configuration['top_level']['key2'] = 'value2'
+        parent_class.configuration['top_level']['sub_one']['sub_one_key1'] = 'sub_one_value1'
+        parent_class.configuration['top_level']['sub_one']['sub_one_key2'] = 'sub_one_value2'
+        parent_class.configuration['top_level']['sub_two']['sub_two_key'] = 'sub_two_value'
+
+        expect(parent_class.configuration['top_level']['key']).to eq 'value'
+        expect(parent_class.configuration['top_level']['sub_one']['sub_one_key1']).to eq 'sub_one_value1'
+
+        subclass = Class.new(parent_class)
+        expect(subclass.configuration['top_level']['key']).to eq 'value'
+        expect(subclass.configuration['top_level']['key2']).to eq 'value2'
+        expect(subclass.configuration['top_level']['sub_one']['sub_one_key1']).to eq 'sub_one_value1'
+        expect(subclass.configuration['top_level']['sub_one']['sub_one_key2']).to eq 'sub_one_value2'
+        expect(subclass.configuration['top_level']['sub_two']['sub_two_key']).to eq 'sub_two_value'
+
+        # These should have no affect
+        subclass.configuration['top_level'].nest!('sub_one')
+        subclass.configuration['top_level'].nest!('sub_two')
+
+        # This should add a new nested configuration
+        subclass.configuration['top_level'].nest!('new_nesting')['key'] = 'hello'
+
+        subclass.configuration['top_level']['key'] = 'overriden value'
+        subclass.configuration['top_level']['new_key'] = 'new value'
+        subclass.configuration['top_level']['sub_one']['sub_one_key1'] = 'overriden nested value'
+        subclass.configuration['top_level']['sub_one']['new_key'] = 'new nested value'
+
+        expect(subclass.configuration['top_level']['key']).to eq 'overriden value'
+        expect(subclass.configuration['top_level']['key2']).to eq 'value2'
+        expect(subclass.configuration['top_level']['new_key']).to eq 'new value'
+        expect(subclass.configuration['top_level']['sub_one']['sub_one_key1']).to eq 'overriden nested value'
+        expect(subclass.configuration['top_level']['sub_one']['sub_one_key2']).to eq 'sub_one_value2'
+        expect(subclass.configuration['top_level']['sub_one']['new_key']).to eq 'new nested value'
+        expect(subclass.configuration['top_level']['sub_two']['sub_two_key']).to eq 'sub_two_value'
+        expect(subclass.configuration['top_level']['new_nesting']['key']).to eq 'hello'
+
+        expect(parent_class.configuration['top_level']['key']).to eq 'value'
+        expect(parent_class.configuration['top_level']['key2']).to eq 'value2'
+        expect(parent_class.configuration['top_level']['new_key']).to be_nil
+        expect(parent_class.configuration['top_level']['sub_one']['sub_one_key1']).to eq 'sub_one_value1'
+        expect(parent_class.configuration['top_level']['sub_one']['sub_one_key2']).to eq 'sub_one_value2'
+        expect(parent_class.configuration['top_level']['sub_one']['new_key']).to be_nil
+        expect(parent_class.configuration['top_level']['sub_two']['sub_two_key']).to eq 'sub_two_value'
+        expect(parent_class.configuration['top_level']['new_nesting']).to be_nil
+
+        # Adding an attribute to parent later will show up in sub
+        parent_class.configuration['top_level']['added_later'] = 5
+        expect(parent_class.configuration['top_level']['added_later']).to eq 5
+        expect(subclass.configuration['top_level']['added_later']).to eq 5
+
+        # Changing an attribute to parent later will show up in sub
+        parent_class.configuration['top_level']['added_later'] = 6
+        expect(parent_class.configuration['top_level']['added_later']).to eq 6
+        expect(subclass.configuration['top_level']['added_later']).to eq 6
+
+        # Overriding an attribute in sub only affects sub.
+        subclass.configuration['top_level']['added_later'] = 5
+        expect(parent_class.configuration['top_level']['added_later']).to eq 6
+        expect(subclass.configuration['top_level']['added_later']).to eq 5
+
+        # Can add nesting to sub only
+        subclass.configuration['top_level'].nest!('only_sub')
+        subclass.configuration['top_level']['only_sub']['two'] = 2
+        expect(subclass.configuration['top_level']['only_sub']['two']).to eq 2
+        expect(parent_class.configuration['top_level']['only_sub']).to be_nil
+
+        # Go even deeper
+        subsubclass = Class.new(subclass)
+        expect(subsubclass.configuration['top_level']['only_sub']['two']).to eq 2
+        subsubclass.configuration['top_level']['only_sub']['two'] = 3
+        expect(subsubclass.configuration['top_level']['only_sub']['two']).to eq 3
+        expect(subclass.configuration['top_level']['only_sub']['two']).to eq 2
+      end
+
+      it 'will not override nested values' do
+        parent_class.configuration.nest!('top_level').nest!('sub_one')
+        subclass = Class.new(parent_class)
+        expect(lambda { subclass.configuration['top_level']['sub_one'] = 2 }).to raise_error('You cannot override a nested value')
+      end
+    end
+
+    describe '#array!' do
+      let!(:array) { parent_class.configuration.array!('list') }
+
+      it 'builds an InheritableAppendSet' do
+        expect(array).to be_a(Brainstem::DSL::Configuration::InheritableAppendSet)
+        expect(parent_class.configuration.array!('list')).to be array
+      end
+
+      it 'is inherited' do
+        parent_class.configuration['list'] << '2'
+        parent_class.configuration['list'].push 3
+
+        subclass = Class.new(parent_class)
+        expect(parent_class.configuration['list'].to_a).to eq ['2', 3]
+        expect(subclass.configuration['list'].to_a).to eq ['2', 3]
+
+        parent_class.configuration['list'].push 4
+        expect(parent_class.configuration['list'].to_a).to eq ['2', 3, 4]
+        expect(subclass.configuration['list'].to_a).to eq ['2', 3, 4]
+
+        subclass.configuration['list'].push 5
+        expect(parent_class.configuration['list'].to_a).to eq ['2', 3, 4]
+        expect(subclass.configuration['list'].to_a).to eq ['2', 3, 4, 5]
+
+        parent_class.configuration['list'].push 6
+        expect(parent_class.configuration['list'].to_a).to eq ['2', 3, 4, 6]
+        expect(subclass.configuration['list'].to_a).to eq ['2', 3, 4, 6, 5]
+      end
+
+      it 'will not override arrays' do
+        subclass = Class.new(parent_class)
+        expect(lambda { subclass.configuration['list'] = 2 }).to raise_error('You cannot override an inheritable array once set')
+      end
+    end
+  end
+
+  describe '#configuration' do
+    it 'is available on the instance' do
+      parent_class.configuration['two'] = 2
+      expect(parent_class.new.configuration['two']).to eq 2
+    end
+  end
+end

data/spec/brainstem/concerns/presenter_dsl_spec.rb

@@ -0,0 +1,412 @@
+require 'spec_helper'
+require 'brainstem/concerns/presenter_dsl'
+
+# preload :lead_user
+#
+# brainstem_key :projects
+#
+# conditionals do
+#   model   :title_is_hello, lambda { workspace.title == 'hello' }, 'visible when the title is hello'
+#   request :user_is_bob, lambda { current_user.username == 'bob' }, 'visible only to bob'
+# end
+#
+# fields do
+#   field :title, :string
+#   field :description, :string
+#   field :updated_at, :datetime
+#   field :dynamic_title, :string, dynamic: lambda { |model| model.title }
+#   field :secret, :string, 'a secret, via secret_info',
+#         via: :secret_info,
+#         if: [:user_is_bob, :title_is_hello]
+#
+#   with_options if: :user_is_bob do
+#     field :bob_title, :string, 'another name for the title, only for Bob',
+#           via: :title
+#   end
+#   fields :nested_permissions do
+#     field :something_title, :string, via: :title
+#     field :random, :number, dynamic: lambda { rand }
+#   end
+# end
+#
+# associations do
+#   association :tasks, Task, 'The Tasks in this Workspace',
+#               restrict_to_only: true
+#   association :lead_user, User, 'The user who runs this Workspace'
+#   association :subtasks, Task, 'Only Tasks in this Workspace that are subtasks',
+#               dynamic: lambda { |workspace| workspace.tasks.where('parent_id IS NOT NULL') }
+#   association :something, :polymorphic
+# end
+
+describe Brainstem::Concerns::PresenterDSL do
+  let(:presenter_class) do
+    Class.new do
+      include Brainstem::Concerns::PresenterDSL
+    end
+  end
+
+  describe '#preload directive' do
+    it 'builds a list of associations to preload' do
+      presenter_class.preload :tasks
+      expect(presenter_class.configuration[:preloads].to_a).to eq [:tasks]
+      presenter_class.preload(lead_user: { workspaces: [:lead_user, :tasks] })
+      expect(presenter_class.configuration[:preloads].to_a).to eq [ :tasks, lead_user: { workspaces: [:lead_user, :tasks] } ]
+    end
+
+    it 'is inherited' do
+      presenter_class.preload :tasks
+      subclass = Class.new(presenter_class)
+      subclass.preload :lead_user
+      expect(presenter_class.configuration[:preloads].to_a).to eq [:tasks]
+      expect(subclass.configuration[:preloads].to_a).to eq [:tasks, :lead_user]
+    end
+  end
+
+  describe 'the conditional block' do
+    before do
+      presenter_class.conditionals do
+        model      :title_is_hello, lambda { |workspace| workspace.title == 'hello' }, 'visible when the title is hello'
+        request    :user_is_bob, lambda { current_user == 'bob' }, 'visible only to bob'
+      end
+    end
+
+    it 'is stored in the configuration' do
+      expect(presenter_class.configuration[:conditionals].keys).to eq %w[title_is_hello user_is_bob]
+      expect(presenter_class.configuration[:conditionals][:title_is_hello].action).to be_present
+      expect(presenter_class.configuration[:conditionals][:title_is_hello].type).to eq :model
+      expect(presenter_class.configuration[:conditionals][:title_is_hello].description).to eq 'visible when the title is hello'
+      expect(presenter_class.configuration[:conditionals][:user_is_bob].action).to be_present
+      expect(presenter_class.configuration[:conditionals][:user_is_bob].type).to eq :request
+      expect(presenter_class.configuration[:conditionals][:user_is_bob].description).to eq 'visible only to bob'
+    end
+
+    it 'is inherited and overridable' do
+      subclass = Class.new(presenter_class)
+      subclass.conditionals do
+        model :silly_conditional, lambda { rand > 0.5 }, 'visible half the time'
+        model :title_is_hello, lambda { |workspace| workspace.title == 'HELLO' }, 'visible when the title is hello (in all caps)'
+      end
+      expect(presenter_class.configuration[:conditionals].keys).to eq %w[title_is_hello user_is_bob]
+      expect(subclass.configuration[:conditionals].keys).to eq %w[title_is_hello user_is_bob silly_conditional]
+      expect(presenter_class.configuration[:conditionals][:title_is_hello].description).to eq "visible when the title is hello"
+      expect(subclass.configuration[:conditionals][:title_is_hello].description).to eq "visible when the title is hello (in all caps)"
+    end
+  end
+
+  describe 'the fields block' do
+    before do
+      presenter_class.fields do
+        field :updated_at, :datetime
+        field :dynamic_title, :string, dynamic: lambda { |model| model.title }
+        field :secret, :string,
+              via: :secret_info,
+              if: [:user_is_bob, :title_is_hello]
+
+        with_options if: :user_is_bob do
+          field :bob_title, :string, 'another name for the title, only for Bob',
+                via: :title
+        end
+        fields :nested_permissions do
+          field :something_title, :string, via: :title
+          field :random, :number, dynamic: lambda { rand }
+        end
+      end
+    end
+
+    it 'is stored in the configuration' do
+      expect(presenter_class.configuration[:fields].keys).to match_array %w[updated_at dynamic_title secret bob_title nested_permissions]
+      expect(presenter_class.configuration[:fields][:updated_at].type).to eq :datetime
+      expect(presenter_class.configuration[:fields][:updated_at].description).to be_nil
+      expect(presenter_class.configuration[:fields][:dynamic_title].type).to eq :string
+      expect(presenter_class.configuration[:fields][:dynamic_title].description).to be_nil
+      expect(presenter_class.configuration[:fields][:dynamic_title].options[:dynamic]).to be_a(Proc)
+      expect(presenter_class.configuration[:fields][:secret].type).to eq :string
+      expect(presenter_class.configuration[:fields][:secret].description).to be_nil
+      expect(presenter_class.configuration[:fields][:secret].options).to eq({ via: :secret_info, if: [:user_is_bob, :title_is_hello] })
+      expect(presenter_class.configuration[:fields][:bob_title].type).to eq :string
+      expect(presenter_class.configuration[:fields][:bob_title].description).to eq 'another name for the title, only for Bob'
+      expect(presenter_class.configuration[:fields][:bob_title].options).to eq({ via: :title, if: [:user_is_bob] })
+    end
+
+    it 'handles nesting' do
+      expect(presenter_class.configuration[:fields][:nested_permissions][:something_title].type).to eq :string
+      expect(presenter_class.configuration[:fields][:nested_permissions][:something_title].options[:via]).to eq :title
+      expect(presenter_class.configuration[:fields][:nested_permissions][:random].options[:dynamic]).to be_a(Proc)
+    end
+
+    it 'is inherited and overridable' do
+      subclass = Class.new(presenter_class)
+      subclass.fields do
+        field :title, :string
+        with_options if: [:some_condition, :some_other_condition] do
+          field :updated_at, :datetime, 'this time I have a description and condition'
+        end
+      end
+      expect(presenter_class.configuration[:fields].keys).to match_array %w[updated_at dynamic_title secret bob_title nested_permissions]
+      expect(subclass.configuration[:fields].keys).to match_array %w[updated_at dynamic_title secret bob_title title nested_permissions]
+      expect(presenter_class.configuration[:fields][:updated_at].description).to be_nil
+      expect(presenter_class.configuration[:fields][:updated_at].options).to eq({})
+      expect(subclass.configuration[:fields][:updated_at].description).to eq 'this time I have a description and condition'
+      expect(subclass.configuration[:fields][:updated_at].options).to eq({ if: [:some_condition, :some_other_condition] })
+    end
+
+    it 'any :if options are combined and inherited using with_options' do
+      presenter_class.fields do
+        with_options if: :user_is_bob do
+          field :bob_title, :string, 'another name for the title, only for Bob',
+                via: :title, if: :another_condition
+          field :bob_title2, :string, 'another name for the title, only for Bob',
+                via: :title, if: :another_condition
+        end
+      end
+      subclass = Class.new(presenter_class)
+      subclass.fields do
+        with_options if: [:user_is_bob, :more_specific] do
+          field :bob_title, :string, 'another name for the title, only for Bob',
+                via: :title, if: [:another_condition]
+          field :bob_title2, :string, 'another name for the title, only for Bob',
+                via: :title
+        end
+      end
+
+      expect(presenter_class.configuration[:fields][:bob_title].options[:if]).to eq([:user_is_bob, :another_condition])
+      expect(subclass.configuration[:fields][:bob_title].options[:if]).to eq([:user_is_bob, :more_specific, :another_condition])
+
+      expect(presenter_class.configuration[:fields][:bob_title2].options[:if]).to eq([:user_is_bob, :another_condition])
+      expect(subclass.configuration[:fields][:bob_title2].options[:if]).to eq([:user_is_bob, :more_specific])
+    end
+
+    it 'allows nesting to be inherited and overridden too' do
+      subclass = Class.new(presenter_class)
+      subclass.fields do
+        fields :nested_permissions do
+          field :something_title, :number, via: :title
+          field :new, :string, via: :title
+          fields :deeper do
+            field :something, :string, via: :title
+          end
+        end
+
+        fields :new_nested_permissions do
+          field :something, :string, via: :title
+        end
+      end
+      expect(presenter_class.configuration[:fields].keys).to match_array %w[updated_at dynamic_title secret bob_title nested_permissions]
+      expect(subclass.configuration[:fields].keys).to match_array %w[updated_at dynamic_title secret bob_title nested_permissions new_nested_permissions]
+
+      expect(presenter_class.configuration[:fields][:nested_permissions][:something_title].type).to eq :string
+      expect(presenter_class.configuration[:fields][:nested_permissions][:random].type).to eq :number
+      expect(presenter_class.configuration[:fields][:nested_permissions][:new]).to be_nil
+      expect(presenter_class.configuration[:fields][:nested_permissions][:deeper]).to be_nil
+      expect(presenter_class.configuration[:fields][:new_nested_permissions]).to be_nil
+
+      expect(subclass.configuration[:fields][:nested_permissions][:something_title].type).to eq :number # changed this
+      expect(subclass.configuration[:fields][:nested_permissions][:random].type).to eq :number
+      expect(subclass.configuration[:fields][:nested_permissions][:new].type).to eq :string
+      expect(subclass.configuration[:fields][:nested_permissions][:deeper][:something]).to be_present
+      expect(subclass.configuration[:fields][:new_nested_permissions]).to be_present
+    end
+  end
+
+  describe 'the associations block' do
+    before do
+      presenter_class.associations do
+        association :tasks, Task, 'The Tasks in this Workspace',
+                    restrict_to_only: true
+        association :subtasks, Task, 'Only Tasks in this Workspace that are subtasks',
+                    dynamic: lambda { |workspace| workspace.tasks.where('parent_id IS NOT NULL') }
+        association :something, :polymorphic
+      end
+    end
+
+    it 'is stored in the configuration' do
+      expect(presenter_class.configuration[:associations].keys).to match_array %w[tasks subtasks something]
+      expect(presenter_class.configuration[:associations][:tasks].target_class).to eq Task
+      expect(presenter_class.configuration[:associations][:tasks].description).to eq 'The Tasks in this Workspace'
+      expect(presenter_class.configuration[:associations][:tasks].options).to eq({ restrict_to_only: true })
+      expect(presenter_class.configuration[:associations][:subtasks].target_class).to eq Task
+      expect(presenter_class.configuration[:associations][:subtasks].description).to eq 'Only Tasks in this Workspace that are subtasks'
+      expect(presenter_class.configuration[:associations][:subtasks].options.keys).to eq [:dynamic]
+      expect(presenter_class.configuration[:associations][:something].target_class).to eq :polymorphic
+      expect(presenter_class.configuration[:associations][:something].description).to be_nil
+    end
+
+    it 'is inherited and overridable' do
+      subclass = Class.new(presenter_class)
+      subclass.associations do
+        association :tasks, Task, 'The Tasks in this Workspace'
+        association :lead_user, User, 'The user who runs this Workspace'
+      end
+
+      expect(presenter_class.configuration[:associations].keys).to match_array %w[tasks subtasks something]
+      expect(subclass.configuration[:associations].keys).to match_array %w[tasks subtasks lead_user something]
+
+      expect(presenter_class.configuration[:associations][:tasks].options).to eq({ restrict_to_only: true })
+      expect(presenter_class.configuration[:associations][:lead_user]).to be_nil
+
+      expect(subclass.configuration[:associations][:tasks].options).to eq({})
+      expect(subclass.configuration[:associations][:lead_user].target_class).to eq User
+      expect(subclass.configuration[:associations][:lead_user].description).to eq 'The user who runs this Workspace'
+    end
+  end
+
+  describe ".helper" do
+    let(:model) { Workspace.first }
+
+    let(:presenter) do
+      Class.new(Brainstem::Presenter) do
+        helper do
+          def method_in_block
+            'method_in_block'
+          end
+
+          def block_to_module
+            'i am in a block, but can see ' + method_in_module
+          end
+        end
+
+        fields do
+          field :from_module, :string, dynamic: lambda { method_in_module }
+          field :from_block, :string, dynamic: lambda { method_in_block }
+          field :block_to_module, :string, dynamic: lambda { block_to_module }
+          field :module_to_block, :string, dynamic: lambda { module_to_block }
+        end
+      end
+    end
+
+    let(:sub_presenter) do
+      Class.new(presenter) do
+        helper do
+          def method_in_block
+            'overridden method_in_block'
+          end
+        end
+      end
+    end
+
+    let(:helper_module) do
+      Module.new do
+        def method_in_module
+          'method_in_module'
+        end
+
+        def module_to_block
+          'i am in a module, but can see ' + method_in_block
+        end
+      end
+    end
+
+    let(:sub_helper_module) do
+      Module.new do
+        def method_in_module
+          'overridden method_in_module'
+        end
+      end
+    end
+
+    it 'provides any methods from given blocks to the lambda' do
+      presenter.helper helper_module
+      expect(presenter.new.group_present([model]).first['from_block']).to eq 'method_in_block'
+    end
+
+    it 'provides any methods from given Modules to the lambda' do
+      presenter.helper helper_module
+      expect(presenter.new.group_present([model]).first['from_module']).to eq 'method_in_module'
+    end
+
+    it 'allows methods in modules and blocks to see each other' do
+      presenter.helper helper_module
+      expect(presenter.new.group_present([model]).first['block_to_module']).to eq 'i am in a block, but can see method_in_module'
+      expect(presenter.new.group_present([model]).first['module_to_block']).to eq 'i am in a module, but can see method_in_block'
+    end
+
+    it 'merges the blocks and modules into a combined helper' do
+      presenter.helper helper_module
+      expect(presenter.merged_helper_class.instance_methods).to include(:method_in_module, :module_to_block, :method_in_block, :block_to_module)
+    end
+
+    it 'can be cleaned up' do
+      expect(presenter.merged_helper_class.instance_methods).to include(:method_in_block)
+      expect(presenter.merged_helper_class.instance_methods).to_not include(:method_in_module)
+      presenter.helper helper_module
+      expect(presenter.merged_helper_class.instance_methods).to include(:method_in_block, :method_in_module)
+      presenter.reset!
+      expect(presenter.merged_helper_class.instance_methods).to_not include(:method_in_block)
+      expect(presenter.merged_helper_class.instance_methods).to_not include(:method_in_module)
+    end
+
+    it 'caches the generated class' do
+      class1 = presenter.merged_helper_class
+      class2 = presenter.merged_helper_class
+      expect(class1).to eq class2
+      presenter.helper helper_module
+      class3 = presenter.merged_helper_class
+      class4 = presenter.merged_helper_class
+      expect(class1).not_to eq class3
+      expect(class3).to eq class4
+    end
+
+    it 'is inheritable' do
+      presenter.helper helper_module
+      expect(sub_presenter.new.group_present([model]).first['from_block']).to eq 'overridden method_in_block'
+      expect(sub_presenter.new.group_present([model]).first['from_module']).to eq 'method_in_module'
+      expect(sub_presenter.new.group_present([model]).first['block_to_module']).to eq 'i am in a block, but can see method_in_module'
+      expect(sub_presenter.new.group_present([model]).first['module_to_block']).to eq 'i am in a module, but can see overridden method_in_block'
+      sub_presenter.helper sub_helper_module
+      expect(sub_presenter.new.group_present([model]).first['from_module']).to eq 'overridden method_in_module'
+      expect(sub_presenter.new.group_present([model]).first['block_to_module']).to eq 'i am in a block, but can see overridden method_in_module'
+      expect(presenter.new.group_present([model]).first['from_module']).to eq 'method_in_module'
+      expect(presenter.new.group_present([model]).first['block_to_module']).to eq 'i am in a block, but can see method_in_module'
+    end
+
+    it 'caches the generated classes with inheritance' do
+      class1 = presenter.merged_helper_class
+      class2 = sub_presenter.merged_helper_class
+      expect(presenter.merged_helper_class).to eq class1
+      expect(sub_presenter.merged_helper_class).to eq class2
+
+      presenter.helper helper_module
+
+      expect(presenter.merged_helper_class).not_to eq class1
+      expect(sub_presenter.merged_helper_class).not_to eq class2
+    end
+  end
+
+  describe ".filter" do
+    it "creates an entry in the filters configuration" do
+      presenter_class.filter(:foo, :default => true) { 1 }
+      expect(presenter_class.configuration[:filters][:foo][0]).to eq({"default" => true})
+      expect(presenter_class.configuration[:filters][:foo][1]).to be_a(Proc)
+    end
+
+    it "accepts names without blocks" do
+      presenter_class.filter(:foo)
+      expect(presenter_class.configuration[:filters][:foo][1]).to be_nil
+    end
+  end
+
+  describe ".search" do
+    it "creates an entry in the search configuration" do
+      presenter_class.search do end
+      expect(presenter_class.configuration[:search]).to be_a(Proc)
+    end
+  end
+
+  describe ".brainstem_key" do
+    before do
+      presenter_class.brainstem_key(:foo)
+    end
+
+    it "creates an entry in the brainstem_key configuration" do
+      expect(presenter_class.configuration[:brainstem_key]).to eq('foo')
+    end
+
+    it 'is inherited and overridable' do
+      subclass = Class.new(presenter_class)
+      expect(subclass.configuration[:brainstem_key]).to eq('foo')
+      subclass.brainstem_key(:bar)
+      expect(subclass.configuration[:brainstem_key]).to eq('bar')
+      expect(presenter_class.configuration[:brainstem_key]).to eq('foo')
+    end
+  end
+end