hyper-mesh 0.6.0 → 1.0.0.lap22

data/spec/batch3/update_scopes_spec.rb

@@ -1,54 +0,0 @@
-require 'spec_helper'
-require 'test_components'
-require 'reactive_record_factory'
-require 'rspec-steps'
-
-RSpec::Steps.steps "updating scopes", js: true do
-
-  before(:all) do
-    seed_database
-  end
-
-  before(:step) do
-    # spec_helper resets the policy system after each test so we have to setup
-    # before each test
-    stub_const 'TestApplication', Class.new
-    stub_const 'TestApplicationPolicy', Class.new
-    TestApplicationPolicy.class_eval do
-      always_allow_connection
-      regulate_all_broadcasts { |policy| policy.send_all }
-      allow_change(to: :all, on: [:create, :update, :destroy]) { true }
-    end
-    size_window(:small, :portrait)
-  end
-
-  it "will update .all and rerender after saving a record" do
-    mount "TestComponent" do
-      class TestComponent < React::Component::Base
-        def render
-          #div do
-            "TodoItem.count = #{TodoItem.all.count}".span
-            #ul { TodoItem.each { |todo| li { todo.id.to_s } }}
-          #end
-        end
-      end
-    end
-    starting_count = TodoItem.count
-    expect(page).to have_content("TodoItem.count = #{starting_count}")
-    evaluate_ruby { TodoItem.new(title: "play it again sam").save }
-    expect(page).to have_content("TodoItem.count = #{starting_count+1}")
-  end
-
-  it "destroying records causes a rerender" do
-    count = TodoItem.count
-    while count > 0
-      expect(page).to have_content("TodoItem.count = #{count}")
-      evaluate_ruby do
-        ReactiveRecord.load { TodoItem.last }.then { |todo| todo.destroy }
-      end
-      count -= 1
-    end
-    expect(page).to have_content("TodoItem.count = 0")
-  end
-
-  end

data/spec/batch4/saving_during_commit_spec.rb

@@ -1,64 +0,0 @@
-require 'spec_helper'
-require 'test_components'
-require 'rspec-steps'
-
-describe "saving during commit", js: true do
-
-  before(:each) do
-    require 'pusher'
-    require 'pusher-fake'
-    Pusher.app_id = "MY_TEST_ID"
-    Pusher.key =    "MY_TEST_KEY"
-    Pusher.secret = "MY_TEST_SECRET"
-    require "pusher-fake/support/base"
-
-    Hyperloop.configuration do |config|
-      config.transport = :pusher
-      config.channel_prefix = "synchromesh"
-      config.opts = {app_id: Pusher.app_id, key: Pusher.key, secret: Pusher.secret}.merge(PusherFake.configuration.web_options)
-    end
-
-    class CommitIssue < ActiveRecord::Base
-      def self.build_tables
-        connection.create_table :commit_issues, force: true do |t|
-          t.string :name
-          t.timestamps
-        end
-      end
-    end
-
-    isomorphic do
-      class CommitIssue < ActiveRecord::Base
-        after_create :save_again
-        def save_again
-          save
-        end
-      end
-    end
-
-    CommitIssue.build_tables rescue nil
-
-    stub_const 'ApplicationPolicy', Class.new
-    ApplicationPolicy.class_eval do
-      always_allow_connection
-      regulate_all_broadcasts { |policy| policy.send_all }
-      allow_change(to: :all, on: [:create, :update, :destroy]) { true }
-    end
-    size_window(:small, :portrait)
-  end
-
-  it "broadcast even if saving during after_save" do
-    CommitIssue.create(name: 1)
-    mount "CommitIssueTest" do
-      class CommitIssueTest < React::Component::Base
-        render do
-          "all: [#{CommitIssue.all.pluck(:name)}]"
-        end
-      end
-    end
-    page.should have_content('all: [1]')
-    CommitIssue.create(name: 2)
-    page.should have_content('all: [1,2]')
-  end
-
-end

data/spec/batch4/scope_spec.rb

@@ -1,581 +0,0 @@
-require 'spec_helper'
-require 'test_components'
-
-describe "synchronized scopes", js: true do
-
-  before(:all) do
-    require 'pusher'
-    require 'pusher-fake'
-    Pusher.app_id = "MY_TEST_ID"
-    Pusher.key =    "MY_TEST_KEY"
-    Pusher.secret = "MY_TEST_SECRET"
-    require "pusher-fake/support/base"
-
-    Hyperloop.configuration do |config|
-      config.transport = :pusher
-      config.channel_prefix = "synchromesh"
-      config.opts = {app_id: Pusher.app_id, key: Pusher.key, secret: Pusher.secret}.merge(PusherFake.configuration.web_options)
-    end
-  end
-
-  before(:all) do
-    TestModel.class_eval do
-      class << self
-        alias pretest_scope scope
-        def scope(name, *args, &block)
-          opts = _synchromesh_scope_args_check(args)
-          self.class.class_eval do
-            attr_reader "#{name}_count".to_sym
-          end
-          instance_variable_set("@#{name}_count", 0)
-          original_proc = opts[:server]
-          opts[:server] = lambda do |*args|
-            instance_variable_set("@#{name}_count", send("#{name}_count")+1); original_proc.call(*args, &block)
-          end
-          pretest_scope name, opts, &block
-        end
-      end
-    end
-  end
-
-  before(:each) do
-    # spec_helper resets the policy system after each test so we have to setup
-    # before each test
-    stub_const 'TestApplicationPolicy', Class.new
-    TestApplicationPolicy.class_eval do
-      always_allow_connection
-      regulate_all_broadcasts { |policy| policy.send_all }
-    end
-    size_window(:small, :portrait)
-  end
-
-  it "can use the all scope" do
-    mount "TestComponent2" do
-      class TestComponent2 < React::Component::Base
-        render do
-          "count = #{TestModel.all.count}"
-        end
-      end
-    end
-    page.should have_content("count = 0")
-    m = FactoryGirl.create(:test_model)
-    page.should have_content("count = 1")
-    m.destroy
-    page.should have_content("count = 0")
-  end
-
-  it "will be updated only when needed" do
-    isomorphic do
-      TestModel.class_eval do
-        scope :scope1, -> { where(completed: true) }
-        scope :scope2, -> { where(completed: true) }
-      end
-    end
-    mount "TestComponent2" do
-      class TestComponent2 < React::Component::Base
-        before_mount do
-          @render_count = 1
-        end
-        before_update do
-          @render_count = @render_count + 1
-        end
-        render(:div) do
-          div { "rendered #{@render_count} times"}
-          div { "scope1 count = #{TestModel.scope1.count}" }
-          div { "scope2 count = #{TestModel.scope2.count}"} if TestModel.scope1.count < 2
-          TestModel.scope1.each do |model|
-            div { model.test_attribute }
-          end
-        end
-      end
-    end
-    page.should have_content('rendered 2 times')
-    page.should have_content('scope1 count = 0')
-    page.should have_content('scope2 count = 0')
-    TestModel.scope1_count.should eq(2)  # once for scope1.count and once for scope1.each { .test_attribute }
-    TestModel.scope2_count.should eq(1)
-    m1 = FactoryGirl.create(:test_model, test_attribute: "model 1", completed: true)
-    page.should have_content('rendered 3 times')
-    page.should have_content('scope1 count = 1')
-    page.should have_content('scope2 count = 1')
-    page.should have_content('model 1')
-    TestModel.scope1_count.should eq(3)
-    TestModel.scope2_count.should eq(2)
-    m2 = FactoryGirl.create(:test_model, test_attribute: "model 2", completed: false)
-    page.should have_content('rendered 4 times')
-    page.should have_content('scope1 count = 1')
-    page.should have_content('scope2 count = 1')
-    page.should have_content('model 1')
-    TestModel.scope1_count.should eq(4)
-    TestModel.scope2_count.should eq(3)
-    FactoryGirl.create(:test_model, test_attribute: "model 3", completed: true)
-    page.should have_content('rendered 5 times')
-    page.should have_content('scope1 count = 2')
-    page.should_not have_content('scope2', wait: 0)
-    page.should have_content('model 1')
-    page.should have_content('model 3')
-    TestModel.scope1_count.should eq(5)
-    TestModel.scope2_count.should eq(4)
-    m2.update_attribute(:completed, true)
-    page.should have_content('rendered 6 times')
-    page.should have_content('scope1 count = 3')
-    page.should have_content('model 1')
-    page.should have_content('model 2')
-    page.should have_content('model 3')
-    TestModel.scope1_count.should eq(6)
-    TestModel.scope2_count.should eq(4)  # will not change because nothing is viewing it
-    m2.update_attribute(:completed, false)
-    page.should have_content('rendered 7 times')
-    TestModel.scope1_count.should eq(7)
-    m1.update_attribute(:completed, false)
-    page.should have_content('rendered 9 times')
-    page.should have_content('scope1 count = 1')
-    page.should have_content('scope2 count = 1')
-    page.should have_content('model 3')
-    TestModel.scope1_count.should eq(8)
-    TestModel.scope2_count.should eq(5)
-  end
-
-  it "can have params" do
-    isomorphic do
-      TestModel.class_eval do
-        scope :with_args, ->(match, match2) { where(test_attribute: match) }
-      end
-    end
-    m1 = FactoryGirl.create(:test_model, test_attribute: "123")
-    mount "TestComponent2", m: m1 do
-      class TestComponent2 < React::Component::Base
-        param :m, type: TestModel
-        before_mount do
-          @render_count = 1
-        end
-        before_update do
-          @render_count = @render_count + 1
-        end
-        render(:div) do
-          div { "rendered #{@render_count} times"}
-          div { "with_args('match').count = #{TestModel.with_args(params.m.test_attribute, :foo).count}" }
-        end
-      end
-    end
-    m2 = FactoryGirl.create(:test_model)
-    page.should have_content('.count = 1')
-    m2.update_attribute(:test_attribute, m1.test_attribute)
-    page.should have_content('.count = 2')
-    m1.update_attribute(:test_attribute, '456')
-    page.should have_content('.count = 1')
-  end
-
-  it "scopes with params can be nested" do
-    isomorphic do
-      TestModel.class_eval do
-        scope :scope1, -> { where(completed: true) }
-        scope :with_args, -> (match) { where(test_attribute: match) }
-      end
-    end
-    mount "TestComponent2" do
-      class TestComponent2 < React::Component::Base
-        render(:div) do
-          div { "scope1.scope2.count = #{TestModel.scope1.with_args(:foo).count}" }
-        end
-      end
-    end
-    page.should have_content('scope1.scope2.count = 0')
-    FactoryGirl.create(:test_model, test_attribute: "foo", completed: true)
-    page.should have_content('scope1.scope2.count = 1')
-  end
-
-  it 'collections passed from server will not interfere with client associations' do
-    user = FactoryGirl.create(:user)
-    5.times do
-      FactoryGirl.create(:todo, title: 'active', created_by_id: user.id)
-    end
-
-    isomorphic do
-      Todo.class_eval do
-        scope :active, -> { where('title LIKE ?', 'active') }
-      end
-    end
-
-    todos = user.authored_todos.active
-
-    mount 'TestComponent2', todos: todos do
-      class TestComponent2 < React::Component::Base
-        param :todos, type: [Todo]
-        render(:div) do
-          P { "params.todos = #{params.todos.count}" }
-          P { "params.user.authored_todos.active = #{User.find(1).authored_todos.active.count}" }
-        end
-      end
-    end
-
-    page.should have_content('params.todos = 5')
-    page.should have_content('params.user.authored_todos.active = 5')
-  end
-
-  context 'basic joins' do
-
-    it 'will not update a joined scope without a joins option' do
-      isomorphic do
-        TestModel.class_eval do
-          scope :joined,
-                -> { joins(:child_models).where("child_attribute = 'WHAAA'") }
-        end
-      end
-      mount 'TestComponent2' do
-        class TestComponent2 < React::Component::Base
-          render { "TestModel.joined.count = #{TestModel.joined.count}" }
-        end
-      end
-      parent = FactoryGirl.create(:test_model)
-      child = FactoryGirl.create(:child_model, test_model: parent )
-      page.should have_content('.count = 0')
-      child.update_attribute(:child_attribute, 'WHAAA')
-      page.should have_content('.count = 0')
-    end
-
-    it 'can have a joins option' do
-      isomorphic do
-        TestModel.class_eval do
-          scope :joined,
-                -> { joins(:child_models).where("child_attribute = 'WHAAA'") },
-                joins: 'child_models'
-        end
-      end
-      mount 'TestComponent2' do
-        class TestComponent2 < React::Component::Base
-          render { "TestModel.joined.count = #{TestModel.joined.count}" }
-        end
-      end
-      parent = FactoryGirl.create(:test_model)
-      child = FactoryGirl.create(:child_model, test_model: parent )
-      page.should have_content('.count = 0')
-      child.update_attribute(:child_attribute, 'WHAAA')
-      page.should have_content('.count = 1')
-    end
-  end
-
-  it 'can have a client filter method' do
-
-    isomorphic do
-      TestModel.class_eval do
-        scope :quicker, -> { where(completed: true) }, client: -> { completed }
-      end
-    end
-
-    mount 'TestComponent2' do
-      class TestComponent2 < React::Component::Base
-        before_mount do
-          @render_count = 1
-        end
-        before_update do
-          @render_count = @render_count + 1
-        end
-        render(:div) do
-          div { "rendered #{@render_count} times"}
-          div { "quicker.count = #{TestModel.quicker.count}" }
-        end
-      end
-    end
-    m1 = FactoryGirl.create(:test_model)
-    page.should have_content('.count = 0')
-    page.should have_content('rendered 2 times')
-    TestModel.quicker_count.should eq(1)
-    m1.update_attribute(:test_attribute, 'new_value')
-    wait_for_ajax
-    page.should have_content('.count = 0')
-    page.should have_content('rendered 2 times')
-    TestModel.quicker_count.should eq(1)
-    m1.update_attribute(:completed, true)
-    page.should have_content('.count = 1')
-    page.should have_content('rendered 3 times')
-    TestModel.quicker_count.should eq(1)
-    m2 = FactoryGirl.create(:test_model, completed: true)
-    page.should have_content('.count = 2')
-    page.should have_content('rendered 4 times')
-    TestModel.quicker_count.should eq(1)
-    m1.destroy
-    page.should have_content('.count = 1')
-    page.should have_content('rendered 5 times')
-    TestModel.quicker_count.should eq(1)
-  end
-
-  it 'can have a client collector method' do
-
-    isomorphic do
-      TestModel.class_eval do
-        def <=>(other); self.test_attribute <=> other.test_attribute; end
-        scope :filter_and_sort, -> { where(completed: true).order('test_attribute ASC') },
-              select: -> { select { |r| r.completed }.sort }
-      end
-    end
-
-    mount 'TestComponent2' do
-      class TestComponent2 < React::Component::Base
-        before_mount do
-          @render_count = 1
-        end
-        before_update do
-          @render_count = @render_count + 1
-        end
-        render(:div) do
-          div { "rendered #{@render_count} times"}
-          div { "filter_and_sort.count = #{TestModel.filter_and_sort.count}" }
-          if TestModel.filter_and_sort.any?
-            div { "test attributes: #{TestModel.filter_and_sort.collect { |r| r.test_attribute }.join(', ')}" }
-          else
-            div { "no test attributes" }
-          end
-        end
-      end
-    end
-    TestModel.filter_and_sort_count.should eq(2)
-    m1 = FactoryGirl.create(:test_model)
-    page.should have_content('.count = 0')
-    page.should have_content('rendered 2 times')
-    page.should have_content('no test attributes')
-    TestModel.filter_and_sort_count.should eq(2)
-    m1.update_attribute(:test_attribute, 'N')
-    wait_for_ajax
-    page.should have_content('.count = 0')
-    page.should have_content('rendered 2 times')
-    page.should have_content('no test attributes')
-    TestModel.filter_and_sort_count.should eq(2)
-    m1.update_attribute(:completed, true)
-    page.should have_content('.count = 1')
-    page.should have_content('rendered 3 times')
-    page.should have_content('test attributes: N')
-    TestModel.filter_and_sort_count.should eq(2)
-    m2 = FactoryGirl.create(:test_model, test_attribute: 'A', completed: true)
-    page.should have_content('.count = 2')
-    page.should have_content('rendered 4 times')
-    page.should have_content('test attributes: A, N')
-    TestModel.filter_and_sort_count.should eq(2)
-    m3 = FactoryGirl.create(:test_model, test_attribute: 'Z', completed: true)
-    page.should have_content('.count = 3')
-    page.should have_content('rendered 5 times')
-    page.should have_content('test attributes: A, N, Z')
-    TestModel.filter_and_sort_count.should eq(2)
-    m1.destroy
-    page.should have_content('.count = 2')
-    page.should have_content('rendered 6 times')
-    page.should have_content('test attributes: A, Z')
-    TestModel.filter_and_sort_count.should eq(2)
-    m3.update_attribute(:completed, false)
-    page.should have_content('.count = 1')
-    page.should have_content('rendered 7 times')
-    page.should have_content('test attributes: A')
-    TestModel.filter_and_sort_count.should eq(2)
-  end
-
-  it 'client side scoping methods can take args' do
-
-    isomorphic do
-      TestModel.class_eval do
-        def to_s
-          "<TestModel id: #{id} test_attribute: #{test_attribute}>"
-        end
-        def <=>(other)
-          (test_attribute || '') <=> (other.test_attribute || '')
-        end
-        scope :matches, -> (s) { where(['test_attribute LIKE ?', "%#{s}%"])},
-              client: -> (s) { puts "test_attribute =~ /#{s}/ is #{!!(test_attribute =~ /#{s}/)}"; test_attribute =~ /#{s}/ }
-        scope :sorted, -> (dir) { order("test_attribute #{dir==:asc ? 'ASC' : 'DESC'}") },
-              select: -> (dir) { sort { |a, b| dir == :asc ? a <=> b : b <=> a }.tap {|r| puts "sorted(#{dir==:asc}) as [#{r}]"} }
-      end
-    end
-
-    mount 'TestComponent2' do
-      class TestComponent2 < React::Component::Base
-        export_state pat: :foo
-        export_state dir: :asc
-        before_mount do
-          @render_count = 1
-        end
-        before_update do
-          @render_count = @render_count + 1
-        end
-        def scoped
-          puts "scoping: #{TestComponent2.pat}, #{TestComponent2.dir}"
-          TestModel.matches(TestComponent2.pat).sorted(TestComponent2.dir)
-        end
-        render(:div) do
-          div { "rendered #{@render_count} times"}
-          div { "matches(#{TestComponent2.pat}).count = #{TestModel.matches(TestComponent2.pat).count}" }
-          if scoped.any?
-            div { "test attributes: #{scoped.collect { |r| r.test_attribute[0] }.join(', ')}" }
-          else
-            div { "no test attributes" }
-          end
-        end
-      end
-    end
-    starting_fetch_time = evaluate_ruby("ReactiveRecord::Base.last_fetch_at")
-    m1 = FactoryGirl.create(:test_model)
-    page.should have_content('.count = 0')
-    page.should have_content('rendered 2 times')
-    page.should have_content('no test attributes')
-    m1.update_attribute(:test_attribute, 'N')
-    page.should have_content('rendered 2 times')
-    page.should have_content('.count = 0')
-    page.should have_content('no test attributes')
-    m1.update_attribute(:test_attribute, 'N - foobar')
-    page.should have_content('.count = 1')
-    page.should have_content('rendered 3 times')
-    page.should have_content('test attributes: N')
-    m2 = FactoryGirl.create(:test_model, test_attribute: 'A - is a foo')
-    page.should have_content('.count = 2')
-    page.should have_content('rendered 4 times')
-    page.should have_content('test attributes: A, N')
-    m3 = FactoryGirl.create(:test_model, test_attribute: 'Z - is also a foo')
-    page.should have_content('.count = 3')
-    page.should have_content('rendered 5 times')
-    page.should have_content('test attributes: A, N, Z')
-    evaluate_ruby("ReactiveRecord::Base.last_fetch_at").should eq(starting_fetch_time)
-    evaluate_ruby("TestComponent2.dir! :desc")
-    page.should have_content('test attributes: Z, N, A')
-    page.should have_content('rendered 7 times')
-    starting_fetch_time = evaluate_ruby("ReactiveRecord::Base.last_fetch_at")
-    m1.destroy
-    page.should have_content('.count = 2')
-    page.should have_content('rendered 8 times')
-    page.should have_content('test attributes: Z, A')
-    m3.update_attribute(:test_attribute, 'Z - is a bar')
-    page.should have_content('.count = 1')
-    page.should have_content('rendered 9 times')
-    page.should have_content('test attributes: A')
-    evaluate_ruby("ReactiveRecord::Base.last_fetch_at").should eq(starting_fetch_time)
-    evaluate_ruby('TestComponent2.pat! :bar')
-    page.should have_content('.count = 1')
-    page.should have_content('test attributes: Z')
-    page.should have_content('rendered 11 times')
-    starting_fetch_time = evaluate_ruby("ReactiveRecord::Base.last_fetch_at")
-    m2.update_attribute(:test_attribute, 'A is also a bar')
-    page.should have_content('.count = 2')
-    page.should have_content('rendered 12 times')
-    page.should have_content('test attributes: Z, A')
-    evaluate_ruby("ReactiveRecord::Base.last_fetch_at").should eq(starting_fetch_time)
-  end
-
-  it 'the joins array can be combined with the client proc' do
-    isomorphic do
-      TestModel.class_eval do
-        scope :has_children,
-              joins: 'child_models',
-              server: -> { joins(:child_models).distinct },
-              client: -> { child_models.count > 0 }
-      end
-    end
-    mount 'TestComponent2' do
-      class TestComponent2 < React::Component::Base
-        render { "TestModel.has_children.count = #{TestModel.has_children.count}" }
-      end
-    end
-    TestModel.has_children_count.should eq(1)
-    parent = FactoryGirl.create(:test_model)
-    page.should have_content('.count = 0')
-    child = FactoryGirl.create(:child_model)
-    page.should have_content('.count = 0')
-    child.update_attribute(:test_model, parent)
-    page.should have_content('.count = 1')
-    child.update_attribute(:child_attribute, 'WHAAA')
-    page.should have_content('.count = 1')
-    child.update_attribute(:test_model, nil)
-    page.should have_content('.count = 0')
-    child.update_attribute(:test_model, parent)
-    page.should have_content('.count = 1')
-    child.destroy
-    page.should have_content('.count = 0')
-    parent.destroy
-    page.should have_content('.count = 0')
-    TestModel.has_children_count.should eq(1)
-  end
-
-  it 'the joins option can join with all or no models' do
-    isomorphic do
-      TestModel.class_eval do
-        scope :has_children_joins_all,
-              joins: :all,
-              server: -> { joins(:child_models).distinct }
-        scope :has_children_no_joins,
-              joins: [],
-              server: -> { joins(:child_models).distinct }
-      end
-    end
-    mount 'TestComponent2' do
-      class TestComponent2 < React::Component::Base
-        render(DIV) do
-          DIV { "TestModel.has_children_joins_all.count = #{TestModel.has_children_joins_all.count}" }
-          DIV { "TestModel.has_children_no_joins.count = #{TestModel.has_children_no_joins.count}" }
-        end
-      end
-    end
-    TestModel.has_children_joins_all_count.should eq(1)
-    TestModel.has_children_no_joins_count.should eq(1)
-    parent = FactoryGirl.create(:test_model)
-    wait_for_ajax
-    TestModel.has_children_no_joins_count.should eq(1)
-    wait_for { TestModel.has_children_joins_all_count }.to eq(2)
-    child = FactoryGirl.create(:child_model)
-    wait_for { TestModel.has_children_joins_all_count }.to eq(3)
-    parent.child_models << child
-    wait_for { TestModel.has_children_joins_all_count }.to eq(4)
-    TestModel.has_children_no_joins_count.should eq(1)
-    page.should have_content('all.count = 1')
-    page.should have_content('joins.count = 0')
-    parent.update_attribute(:test_attribute, 'hello')
-    page.should have_content('joins.count = 0')
-    TestModel.has_children_no_joins_count.should eq(1)
-  end
-
-  it 'server side scopes can be procs returning arrays of elements' do
-    isomorphic do
-      TestModel.class_eval do
-        scope :rev,
-              server: -> { all.reverse }
-      end
-    end
-    mount 'TestComponent2' do
-      class TestComponent2 < React::Component::Base
-        render do
-          "test attributes: #{TestModel.rev.collect { |r| r.test_attribute }.join(', ')}"
-        end
-      end
-    end
-    FactoryGirl.create(:test_model, test_attribute: 1)
-    page.should have_content('test attributes: 1')
-    FactoryGirl.create(:test_model, test_attribute: 2)
-    page.should have_content('test attributes: 2, 1')
-  end
-
-  it 'can force reload using the ! suffix' do
-    isomorphic do
-      TestModel.class_eval do
-        scope :rev,
-              joins: [],
-              server: -> { all.reverse }
-      end
-    end
-    mount 'TestComponent2' do
-
-      class TestComponent2 < React::Component::Base
-        before_mount do
-          @reverse_collection = []
-        end
-        render do
-          if @current_count != TestModel.all.count # this forces a rerender...
-            puts "asking for reverse collection"
-            @reverse_collection = TestModel.rev!
-            @current_count = TestModel.all.count
-          end
-          puts "rendering #{@reverse_collection}"
-          "test attributes: #{@reverse_collection.collect { |r| r.test_attribute }.join(', ')}"
-        end
-      end
-    end
-    FactoryGirl.create(:test_model, test_attribute: 1)
-    page.should have_content('test attributes: 1')
-    FactoryGirl.create(:test_model, test_attribute: 2)
-    page.should have_content('test attributes: 2, 1')
-  end
-end