brainstem 0.2.6.1 → 1.0.0.pre.1

data/spec/brainstem/presenter_validator_spec.rb

@@ -0,0 +1,209 @@
+require 'spec_helper'
+require 'brainstem/presenter_validator'
+
+describe Brainstem::PresenterValidator do
+  let(:presenter_class) do
+    Class.new(Brainstem::Presenter) do
+      presents Workspace
+
+      preload :lead_user
+
+      conditionals do
+        model :title_is_hello, lambda { |model| model.title == 'hello' }, 'visible when the title is hello'
+        request :user_is_bob, lambda { current_user == 'bob' }, 'visible only to bob'
+      end
+
+      fields do
+        field :title, :string
+        field :description, :string
+        field :updated_at, :datetime
+        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
+      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') }
+      end
+    end
+  end
+
+  let(:validator) { Brainstem::PresenterValidator.new(presenter_class) }
+
+  it 'should be valid' do
+    expect(presenter_class.configuration[:preloads]).not_to be_empty
+    expect(presenter_class.configuration[:fields]).not_to be_empty
+    expect(presenter_class.configuration[:associations]).not_to be_empty
+    expect(validator).to be_valid
+  end
+
+  describe 'validating preload' do
+    it 'adds an error if the requested preload does not exist on the presented class' do
+      presenter_class.preload :foo
+      expect(validator).not_to be_valid
+      expect(validator.errors[:preload]).to eq ["not all presented classes respond to 'foo'"]
+    end
+
+    it 'adds an error if the requested preload does not exist on only one of the presented classes' do
+      presenter_class.presents User
+      expect(validator).not_to be_valid
+      expect(validator.errors[:preload]).to eq ["not all presented classes respond to 'lead_user'"]
+    end
+
+    it 'supports nested preloads' do
+      presenter_class.preload foo: :bar
+      expect(validator).not_to be_valid
+      expect(validator.errors[:preload]).to eq ["not all presented classes respond to 'foo'"]
+    end
+  end
+
+  describe 'validating associations' do
+    it 'adds an error for any field that is not on all presented classes' do
+      presenter_class.associations do
+        association :foo, Workspace
+        association :bar, Workspace
+      end
+
+      expect(validator).not_to be_valid
+      expect(validator.errors[:associations]).to eq ["'foo' is not valid because not all presented classes respond to 'foo'",
+                                                     "'bar' is not valid because not all presented classes respond to 'bar'"]
+    end
+
+    it 'adds an error for any association that does not have a known presenter' do
+      class NewConcept; end
+
+      presenter_class.associations do
+        association :tasks, NewConcept
+      end
+
+      expect(validator).not_to be_valid
+      expect(validator.errors[:associations]).to eq ["'tasks' is not valid because no presenter could be found for the NewConcept class"]
+    end
+  end
+
+  describe 'validating fields' do
+    it 'adds an error for any field that is not on all presented classes' do
+      presenter_class.fields do
+        field :foo, :string
+        field :bar, :integer
+      end
+
+      expect(validator).not_to be_valid
+      expect(validator.errors[:fields]).to eq ["'foo' is not valid because not all presented classes respond to 'foo'",
+                                               "'bar' is not valid because not all presented classes respond to 'bar'"]
+    end
+
+    it 'errors when one of the presented classes is missing a field' do
+      presenter_class.presents User
+      expect(validator).not_to be_valid
+      expect(validator.errors[:fields]).to be_present
+    end
+
+    it 'supports :via' do
+      presenter_class.fields do
+        field :foo, :string, via: :title
+      end
+
+      expect(validator).to be_valid
+    end
+
+    it 'supports dynamic fields' do
+      presenter_class.fields do
+        field :foo, :string, dynamic: lambda { 2 }
+      end
+
+      expect(validator).to be_valid
+    end
+
+    it 'supports nested fields' do
+      presenter_class.fields do
+        fields :permissions do
+          field :title, :string
+        end
+      end
+
+      expect(validator).to be_valid
+
+      presenter_class.fields do
+        fields :permissions do
+          field :missing, :string
+        end
+      end
+
+      expect(validator).not_to be_valid
+      expect(validator.errors[:fields]).to eq ["'missing' is not valid because not all presented classes respond to 'missing'"]
+    end
+
+    it "checks that any 'if' option has a matching conditional(s)" do
+      expect(presenter_class.configuration[:conditionals][:title_is_hello]).to be_present
+
+      presenter_class.fields do
+        field :title, :string, if: :title_is_hello
+      end
+
+      expect(validator).to be_valid
+
+      presenter_class.fields do
+        field :title, :string, if: [:title_is_hello, :wat]
+      end
+
+      expect(validator).not_to be_valid
+      expect(validator.errors[:fields]).to eq ["'title' is not valid because one or more of the specified conditionals does not exist"]
+    end
+
+    it "checks conditionals on nested fields too" do
+      presenter_class.fields do
+        fields :permissions do
+          field :title, :string, if: [:title_is_hello, :wat]
+        end
+      end
+
+      expect(validator).not_to be_valid
+      expect(validator.errors[:fields]).to eq ["'title' is not valid because one or more of the specified conditionals does not exist"]
+    end
+  end
+
+  describe 'validating sort_orders' do
+    it 'checks that a default is selected if any sort_orders are defined' do
+      presenter_class.sort_order :alphabetical, "workspaces.title"
+      expect(validator).not_to be_valid
+      expect(validator.errors[:default_sort_order]).to eq ["A default_sort_order is highly recommended if any sort_orders are declared"]
+
+      presenter_class.default_sort_order "alphabetical:desc"
+      expect(validator).to be_valid
+    end
+
+    it 'checks that a default matches an existing sort_order' do
+      presenter_class.default_sort_order "alphabetical:desc"
+
+      expect(validator).not_to be_valid
+      expect(validator.errors[:default_sort_order]).to eq ["The declared default_sort_order ('alphabetical') does not match an existing sort_order"]
+
+      presenter_class.sort_order :alphabetical, "workspaces.title"
+      expect(validator).to be_valid
+    end
+  end
+
+  describe 'validating presence of brainstem_key' do
+    it 'requires a brainstem_key to be defined when more than one object is being presented' do
+      presenter_class.presents Task
+      expect(validator).not_to be_valid
+      expect(validator.errors[:brainstem_key]).to eq ["a brainstem_key must be provided when multiple classes are presented."]
+    end
+  end
+
+  specify 'all spec presenters should be valid' do
+    Brainstem.presenter_collection.presenters.each do |name, klass|
+      expect(Brainstem::PresenterValidator.new(klass)).to be_valid
+    end
+  end
+end

data/spec/brainstem/query_strategies/filter_and_search_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Brainstem::QueryStrategies::FilterAndSearch do
+  let(:bob) { User.find_by_username('bob') }
+
+  let(:params) { {
+    "owned_by" => bob.id.to_s,
+    per_page: 7,
+    page: 1,
+    search: 'toot, otto, toot',
+  } }
+
+  let(:options) { {
+    primary_presenter: CheesePresenter.new,
+    table_name: 'cheeses',
+    default_per_page: 20,
+    default_max_per_page: 200,
+    default_max_filter_and_search_page: 500,
+    params: params
+  } }
+
+  describe '#execute' do
+    before do
+      CheesePresenter.search do |string, options|
+        [[2,3,4,5,6,8,9,10,11,12], 11]
+      end
+
+      CheesePresenter.filter(:owned_by) { |scope, user_id| scope.owned_by(user_id.to_i) }
+      CheesePresenter.sort_order(:id)   { |scope, direction| scope.order("cheeses.id #{direction}") }
+    end
+
+    it 'takes the intersection of the search and filter results' do
+      results, count = described_class.new(options).execute(Cheese.unscoped)
+      expect(count).to eq(8)
+      expect(results.map(&:id)).to eq([2,3,4,5,8,10,11])
+    end
+
+    it "applies ordering to the scope" do
+      options[:params]["order"] = 'id:desc'
+      proxy.instance_of(Brainstem::Presenter).apply_ordering_to_scope(anything, anything).times(1)
+      results, count = described_class.new(options).execute(Cheese.unscoped)
+      expect(count).to eq(8)
+      expect(results.map(&:id)).to eq([12,11,10,8,5,4,3])
+    end
+  end
+end

data/spec/brainstem/query_strategies/filter_or_search_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+# The functionality of this is mainly tested in more integration-y tests in presenter_collection_spec.rb
+
+describe Brainstem::QueryStrategies::FilterOrSearch do
+  describe '#execute' do
+    context 'we are searching' do
+      let(:subject) { described_class.new(@options) }
+
+      before do
+        @options = { primary_presenter: WorkspacePresenter.new,
+                     table_name: 'workspaces',
+                     default_per_page: 20,
+                     default_max_per_page: 200,
+                     params: { search: "cheese" } }
+
+        @results = [Workspace.first, Workspace.second]
+
+        WorkspacePresenter.search do |string|
+          [[1,2], 2]
+        end
+      end
+
+      it 'returns the primary models and count' do
+        expect(subject.execute(Workspace.unscoped)).to eq([@results, 2])
+      end
+    end
+
+    context 'we are not searching' do
+      let(:subject) { described_class.new(@options) }
+
+      before do
+        @options = { primary_presenter: WorkspacePresenter.new,
+                     table_name: 'workspaces',
+                     default_per_page: 20,
+                     default_max_per_page: 200,
+                     params: { } }
+      end
+
+      it 'returns the primary models and count' do
+        expect(subject.execute(Workspace.unscoped)).to eq([Workspace.unscoped.to_a, Workspace.count])
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -3,20 +3,28 @@ require 'logger'
 require 'rr'
 require 'rspec'
 require 'sqlite3'
+require 'database_cleaner'
+require 'pry'
+require 'pry-nav'
 
 require 'brainstem'
+require_relative 'spec_helpers/schema'
 require_relative 'spec_helpers/db'
-require_relative 'spec_helpers/cleanup'
+require_relative 'spec_helpers/rr'
+
+DatabaseCleaner.strategy = :transaction
 
 RSpec.configure do |config|
   config.mock_with :rr
 
   config.before(:each) do
     Brainstem.logger = Logger.new(StringIO.new)
+    Brainstem.reset!
+    load File.join(File.dirname(__FILE__), 'spec_helpers', 'presenters.rb')
+    DatabaseCleaner.start
   end
 
   config.after(:each) do
-    Brainstem.clear_collections!
-    Brainstem.default_namespace = nil
+    DatabaseCleaner.clean
   end
 end

data/spec/spec_helpers/db.rb

@@ -1,65 +1,3 @@
-ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
-ActiveRecord::Schema.define do
-  self.verbose = false
-
-  create_table :users, :force => true do |t|
-    t.string :username
-    t.timestamps null: true
-  end
-
-  create_table :workspaces, :force => true do |t|
-    t.string :title
-    t.string :description
-    t.belongs_to :user
-    t.timestamps null: true
-  end
-
-  create_table :tasks, :force => true do |t|
-    t.string :name
-    t.integer :parent_id
-    t.belongs_to :workspace
-    t.timestamps null: true
-  end
-
-  create_table :posts, :force => true do |t|
-    t.string :body
-    t.integer :subject_id
-    t.string :subject_type
-    t.timestamps null: true
-  end
-end
-
-class User < ActiveRecord::Base
-  has_many :workspaces
-end
-
-class Task < ActiveRecord::Base
-  belongs_to :workspace
-  has_many :sub_tasks, :foreign_key => :parent_id, :class_name => "Task"
-  has_many :posts
-
-  def tags
-    %w[some tags]
-  end
-end
-
-class Workspace < ActiveRecord::Base
-  belongs_to :user
-  has_many :tasks
-  has_many :posts
-
-  scope :owned_by, -> id { where(:user_id => id) }
-  scope :numeric_description, -> description { where(:description => ["1", "2", "3"]) }
-
-  def lead_user
-    user
-  end
-end
-
-class Post < ActiveRecord::Base
-  belongs_to :subject, :polymorphic => true
-end
-
 User.create!(:id => 1, :username => "bob")
 User.create!(:id => 2, :username => "jane")
 
@@ -70,11 +8,40 @@ Workspace.create!(:id => 4, :user_id => 1, :title => "bob workspace 4", :descrip
 Workspace.create!(:id => 5, :user_id => 2, :title => "jane workspace 1", :description => "c")
 Workspace.create!(:id => 6, :user_id => 2, :title => "jane workspace 2", :description => "3")
 
+
+Cheese.create!(id: 1, user_id: 1, flavor: 'colby jack' )
+Cheese.create!(id: 2, user_id: 1, flavor: 'swiss' )
+Cheese.create!(id: 3, user_id: 1, flavor: 'cheese curds' )
+Cheese.create!(id: 4, user_id: 1, flavor: 'bleu' )
+Cheese.create!(id: 5, user_id: 1, flavor: 'cheddar' )
+Cheese.create!(id: 6, user_id: 2, flavor: 'gorgonzola' )
+Cheese.create!(id: 7, user_id: 1, flavor: 'search text' )
+Cheese.create!(id: 8, user_id: 1, flavor: 'search text' )
+Cheese.create!(id: 9, user_id: 2, flavor: 'provologne')
+Cheese.create!(id: 10, user_id: 1, flavor: 'old amsterdam' )
+Cheese.create!(id: 11, user_id: 1, flavor: 'brie' )
+Cheese.create!(id: 12, user_id: 1, flavor: 'wensleydale' )
+# Group.create!(:id => 7, :user_id => 2, :title => "a group", :description => "this is a group")
+
 Task.create!(:id => 1, :workspace_id => 1, :name => "Buy milk")
 Task.create!(:id => 2, :workspace_id => 1, :name => "Buy bananas")
 Task.create!(:id => 3, :workspace_id => 1, :parent_id => 2, :name => "Green preferred")
 Task.create!(:id => 4, :workspace_id => 1, :parent_id => 2, :name => "One bunch")
+Task.create!(:id => 5, :workspace_id => 6, :name => "In another Workspace")
+
+Post.create!(:id => 1, :user_id => 1, :subject => Workspace.first, :body => "first post!")
+Post.create!(:id => 2, :user_id => 1, :subject => Task.first, :body => "this is important. get on it!")
+Post.create!(:id => 3, :user_id => 2, :body => "Post without subject")
+
+Attachments::PostAttachment.create!(id: 1, subject: Post.first, filename: 'I am an attachment on a post')
+Attachments::TaskAttachment.create!(id: 2, subject: Task.first, filename: 'I am an attachment on a task')
+
+# TODO:
+# user can group all of an STI structure into the brainstem_keys, of their choice
+# user can put STI classes into seperate brainstem_keys
+# inheriting presenters and showing that they work
+# Spec presents attachments, including their subjects, shows that right presenters are used.
+# Show that the base class is always used as the brainstem_key for attachments as polymorphic association targets
 
-Post.create!(:id => 1, :subject => Workspace.first, :body => "first post!")
-Post.create!(:id => 2, :subject => Task.first, :body => "this is important. get on it!")
-Post.create!(:id => 3, :body => "Post without subject")
+# Use Group / Workspace as the polymorphic target of an association where we do not
+# want the baseclass to be used as the brainstem_key (like line_items0)

data/spec/spec_helpers/presenters.rb

@@ -1,43 +1,138 @@
 class WorkspacePresenter < Brainstem::Presenter
-  def present(model)
-    {
-      :title        => model.title,
-      :description  => model.description,
-      :updated_at   => model.updated_at,
-      :tasks        => association(:tasks),
-      :lead_user    => association(:lead_user, :json_name => "users")
-    }
+  presents Workspace
+
+  helper do
+    def current_user
+      'jane'
+    end
+  end
+
+  preload :lead_user
+
+  conditionals do
+    model   :title_is_hello, lambda { |model| model.title == 'hello' }, 'visible when the title is hello'
+    request :user_is_bob, lambda { current_user == '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| "title: #{model.title}" }
+    field :lookup_title, :string, lookup: lambda { |models| Hash[models.map { |model| [model.id, "lookup_title: #{model.title}"] }] }
+    field :lookup_fetch_title, :string,
+          lookup: lambda { |models| Hash[models.map { |model| [model.id, model.title] }] },
+          lookup_fetch: lambda { |lookup, model| "lookup_fetch_title: #{lookup[model.id]}" }
+    field :expensive_title, :string, via: :title, optional: true
+    field :expensive_title2, :string, via: :title, optional: true
+    field :expensive_title3, :string, via: :title, optional: true
+    field :conditional_expensive_title, :string, via: :title, optional: true, if: :title_is_hello
+
+    fields :permissions do
+      field :access_level, :integer, dynamic: lambda { 2 }
+    end
+
+    field :hello_title, :string, 'the title, when hello',
+          dynamic: lambda { 'title is hello' },
+          if: :title_is_hello
+
+    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
+  end
+
+  associations do
+    association :tasks, Task, 'The Tasks in this Workspace'
+    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') },
+    #             brainstem_key: 'sub_tasks'
+  end
+end
+
+class CheesePresenter < Brainstem::Presenter
+  presents Cheese
+
+  fields do
+    field :flavor, :string
+  end
+
+  associations do
+    association :user, User, 'The owner of the cheese'
+  end
+end
+
+class GroupPresenter < Brainstem::Presenter
+  presents Group
+
+  fields do
+    field :title, :string
+  end
+
+  associations do
+    association :tasks, Task, 'The Tasks in this Group'
   end
 end
 
 class TaskPresenter < Brainstem::Presenter
-  def present(model)
-    {
-      :name         => model.name,
-      :sub_tasks    => association(:sub_tasks),
-      :other_tasks  => association(:sub_tasks, :json_name => "other_tasks"),
-      :workspace    => association(:workspace),
-      :restricted   => association(:json_name => "restricted_association", :restrict_to_only => true) { |model| model }
-    }
+  presents Task
+
+  fields do
+    field :name, :string
+  end
+
+  associations do
+    association :sub_tasks, Task
+    association :other_tasks, Task, 'another copy of the sub_tasks association',
+                via: :sub_tasks
+    association :workspace, Workspace
+    association :restricted, Task, 'only available on only / show requests',
+                dynamic: lambda { |task| Task.last },
+                restrict_to_only: true
   end
 end
 
 class UserPresenter < Brainstem::Presenter
-  def present(model)
-    {
-      :username => model.username,
-      :odd_workspaces => association(:json_name => "odd_workspaces") { |user|
-        user.workspaces.select { |workspace| workspace.id % 2 == 1 }
-      }
-    }
+  presents User
+
+  fields do
+    field :username, :string
+  end
+
+  associations do
+    association :odd_workspaces, Workspace, 'only the odd numbered workspaces',
+                dynamic: lambda { |user| user.workspaces.select { |workspace| workspace.id % 2 == 1 } }
   end
 end
-  
+
 class PostPresenter < Brainstem::Presenter
-  def present(model)
-    {
-      :body => model.body,
-      :subject => association(:subject)
-    }
+  presents Post
+
+  fields do
+    field :body, :string
+  end
+
+  associations do
+    association :subject, :polymorphic
+    association :attachments, Attachments::PostAttachment
   end
 end
+
+class AttachmentPresenter < Brainstem::Presenter
+  presents Attachments::TaskAttachment, Attachments::PostAttachment
+
+  brainstem_key :attachments
+
+  fields do
+    field :filename, :string
+  end
+
+  associations do
+    association :subject, :polymorphic
+  end
+end