hyper-mesh 0.4.0

data/spec/synchromesh/integration/synchromesh_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+require 'synchromesh/integration/test_components'
+
+describe "HyperMesh", 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"
+
+    HyperMesh.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(: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 "will synchronize on an attribute update" do
+    mount "TestComponent"
+    FactoryGirl.create(:test_model, test_attribute: "hello")
+    page.should have_content("hello")
+    TestModel.first.update_attribute(:test_attribute, 'goodby')
+    page.should have_content("goodby")
+  end
+
+  describe "the .all method" do
+    before(:each) do
+      mount "TestComponent"
+      5.times { |i| FactoryGirl.create(:test_model, test_attribute: "I am item #{i}") }
+      page.should have_content("5 items")
+    end
+
+    it "will synchronize on create" do
+      TestModel.new(test_attribute: "I'm new here!").save
+      page.should have_content("6 items")
+    end
+
+    it "will synchronize on destroy" do
+      TestModel.first.destroy
+      page.should have_content("4 items")
+    end
+  end
+
+  describe "scopes" do
+    before(:each) do
+      mount "TestComponent", scope: :active
+      5.times { |i| FactoryGirl.create(:test_model, test_attribute: "I am item #{i}", completed: false) }
+      page.should have_content("5 items")
+    end
+
+    it "will synchronize on create" do
+      TestModel.new(test_attribute: "I'm new here!", completed: false).save
+      page.should have_content("6 items")
+    end
+
+    it "will synchronize on destroy" do
+      TestModel.first.destroy
+      page.should have_content("4 items")
+    end
+
+    it "will syncronize on an update" do
+      TestModel.first.update_attribute(:completed, true)
+      page.should have_content("4 items")
+    end
+  end
+end

data/spec/synchromesh/integration/test_components.rb

@@ -0,0 +1,18 @@
+RSpec.configure do |config|
+  config.before(:all) do
+    on_client do
+      class TestComponent < React::Component::Base
+        param scope: :all
+        render(:div) do
+          div { "#{TestModel.send(params.scope).count} items" }
+          ul { TestModel.send(params.scope).each { |model| li { model.test_attribute }}}
+        end
+      end
+      class TestComponent2 < React::Component::Base
+        render do
+          "hello"
+        end
+      end
+    end
+  end
+end

data/spec/synchromesh/integration/transports_spec.rb

@@ -0,0 +1,308 @@
+require 'spec_helper'
+require 'synchromesh/integration/test_components'
+
+SKIP_MESSAGE = 'Pusher credentials not specified. '\
+ 'To run set env variable PUSHER=xxxx-yyy-zzz (app id - key - secret)'
+
+def pusher_credentials
+  Hash[*[:app_id, :key, :secret].zip(ENV['PUSHER'].split('-')).flatten]
+rescue
+  nil
+end
+
+describe "Transport Tests", js: true do
+
+  before(:each) do
+    5.times { |i| FactoryGirl.create(:test_model, test_attribute: "I am item #{i}") }
+  end
+
+  before(:each) do
+    ApplicationController.acting_user = nil
+    # 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
+      regulate_class_connection { !self }
+      regulate_all_broadcasts { |policy| policy.send_all }
+    end
+    size_window(:small, :portrait)
+    on_client do
+      # patch HyperMesh.connect so it doesn't execute until we say so
+      # this is NOT used by the polling connection FYI
+      module HyperMesh
+        class << self
+          alias old_connect connect
+          def go_ahead_and_connect
+            old_connect(*@connect_args)
+          end
+          def connect(*args)
+            @connect_args = args
+          end
+        end
+      end
+    end
+  end
+
+  after(:each) do
+    Timecop.return
+    wait_for_ajax
+  end
+
+  context "Pusher-Fake" 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"
+
+      HyperMesh.configuration do |config|
+        config.transport = :pusher
+        config.channel_prefix = "synchromesh"
+        config.opts = {
+          app_id: Pusher.app_id,
+          key: Pusher.key,
+          secret: Pusher.secret,
+          auth: {headers: {'X-CSRF-Token': "123"}},
+          authEndpoint: "rr/synchromesh-pusher-auth"
+        }.merge(PusherFake.configuration.web_options)
+      end
+    end
+
+    it "opens the connection" do
+      mount "TestComponent"
+      evaluate_ruby "HyperMesh.go_ahead_and_connect"
+      Timecop.travel(Time.now+HyperMesh::Connection.transport.expire_new_connection_in)
+      wait_for { HyperMesh::Connection.active }.to eq(['TestApplication'])
+    end
+
+    it "will not keep the temporary polled connection open" do
+      mount "TestComponent"
+      HyperMesh::Connection.active.should =~ ['TestApplication']
+      Timecop.travel(Time.now+HyperMesh::Connection.transport.expire_new_connection_in)
+      wait_for { HyperMesh::Connection.active }.to eq([])
+    end
+
+    it "sees the connection going offline" do
+      mount "TestComponent"
+      evaluate_ruby "HyperMesh.go_ahead_and_connect"
+      Timecop.travel(Time.now+HyperMesh::Connection.transport.expire_new_connection_in)
+      wait_for { HyperMesh::Connection.active }.to eq(['TestApplication'])
+      ApplicationController.acting_user = true
+      mount "TestComponent"
+      evaluate_ruby "HyperMesh.go_ahead_and_connect"
+      Timecop.travel(Time.now+HyperMesh::Connection.transport.refresh_channels_every)
+      wait_for { HyperMesh::Connection.active }.to eq([])
+    end
+
+    it "receives change notifications" do
+      # one tricky thing about synchromesh is that we want to capture all
+      # changes to the database that might be made while the client connections
+      # is still being initialized.  To do this we establish a server side
+      # queue of all messages sent between the time the page begins rendering
+      # until the connection is established.
+
+      # mount our test component
+      mount "TestComponent"
+      # add a model
+      TestModel.new(test_attribute: "I'm new here!").save
+      # until we connect there should only be 5 items
+      page.should have_content("5 items")
+      # okay now we can go ahead and connect (this runs on the client)
+      evaluate_ruby "HyperMesh.go_ahead_and_connect"
+      # once we connect it should change to 6
+      page.should have_content("6 items")
+      # now that we are connected the UI should keep updating
+      TestModel.new(test_attribute: "I'm also new here!").save
+      page.should have_content("7 items")
+    end
+
+    it "receives destroy notifications" do
+      mount "TestComponent"
+      TestModel.first.destroy
+      page.should have_content("5 items")
+      evaluate_ruby "HyperMesh.go_ahead_and_connect"
+      page.should have_content("4 items")
+    end
+  end
+
+  context "Simple Polling" do
+
+    before(:all) do
+      HyperMesh.configuration do |config|
+        config.transport = :simple_poller
+        # slow down the polling so wait_for_ajax works
+        config.opts = { seconds_between_poll: 2 }
+      end
+    end
+
+    it "opens the connection" do
+      mount "TestComponent"
+      HyperMesh::Connection.active.should =~ ['TestApplication']
+    end
+
+    it "sees the connection going offline" do
+      mount "TestComponent"
+      wait_for_ajax
+      ApplicationController.acting_user = true
+      mount "TestComponent"
+      HyperMesh::Connection.active.should =~ ['TestApplication']
+      Timecop.travel(Time.now+HyperMesh.expire_polled_connection_in)
+      wait(10.seconds).for { HyperMesh::Connection.active }.to eq([])
+    end
+
+    it "receives change notifications" do
+      mount "TestComponent"
+      TestModel.new(test_attribute: "I'm new here!").save
+      HyperMesh::Connection.active.should =~ ['TestApplication']
+      page.should have_content("6 items")
+      HyperMesh::Connection.active.should =~ ['TestApplication']
+    end
+
+    it "receives destroy notifications" do
+      mount "TestComponent"
+      TestModel.first.destroy
+      page.should have_content("4 items")
+    end
+
+  end
+
+  context "Real Pusher Account", skip: (pusher_credentials ? false : SKIP_MESSAGE) do
+
+    before(:each) do
+      require 'pusher'
+      Object.send(:remove_const, :PusherFake) if defined?(PusherFake)
+
+      HyperMesh.configuration do |config|
+        config.transport = :pusher
+        config.channel_prefix = "synchromesh"
+        config.opts = pusher_credentials
+      end
+    end
+
+    it "opens the connection" do
+      mount "TestComponent"
+      evaluate_ruby "HyperMesh.go_ahead_and_connect"
+      Timecop.travel(Time.now+HyperMesh::Connection.transport.expire_new_connection_in)
+      wait_for { HyperMesh::Connection.active }.to eq(['TestApplication'])
+    end
+
+    it "will not keep the temporary polled connection open" do
+      mount "TestComponent"
+      HyperMesh::Connection.active.should =~ ['TestApplication']
+      Timecop.travel(Time.now+HyperMesh::Connection.transport.expire_new_connection_in)
+      wait_for { HyperMesh::Connection.active }.to eq([])
+    end
+
+    it "sees the connection going offline" do
+      mount "TestComponent"
+      evaluate_ruby "HyperMesh.go_ahead_and_connect"
+      Timecop.travel(Time.now+HyperMesh::Connection.transport.expire_new_connection_in)
+      wait_for { HyperMesh::Connection.active }.to eq(['TestApplication'])
+      ApplicationController.acting_user = true
+      mount "TestComponent"
+      evaluate_ruby "HyperMesh.go_ahead_and_connect"
+      Timecop.travel(Time.now+HyperMesh::Connection.transport.refresh_channels_every)
+      wait_for { HyperMesh::Connection.active }.to eq([])
+    end
+
+    it "receives change notifications" do
+      # one tricky thing about synchromesh is that we want to capture all
+      # changes to the database that might be made while the client connections
+      # is still being initialized.  To do this we establish a server side
+      # queue of all messages sent between the time the page begins rendering
+      # until the connection is established.
+
+      # mount our test component
+      mount "TestComponent"
+      # add a model
+      TestModel.new(test_attribute: "I'm new here!").save
+      # until we connect there should only be 5 items
+      page.should have_content("5 items")
+      # okay now we can go ahead and connect (this runs on the client)
+      evaluate_ruby "HyperMesh.go_ahead_and_connect"
+      # once we connect it should change to 6
+      page.should have_content("6 items")
+      # now that we are connected the UI should keep updating
+      TestModel.new(test_attribute: "I'm also new here!").save
+      page.should have_content("7 items")
+    end
+
+    it "receives destroy notifications" do
+      mount "TestComponent"
+      TestModel.first.destroy
+      page.should have_content("5 items")
+      evaluate_ruby "HyperMesh.go_ahead_and_connect"
+      page.should have_content("4 items")
+    end
+
+  end
+
+  context "Action Cable" do
+
+    before(:each) do
+      HyperMesh.configuration do |config|
+        config.transport = :action_cable
+        config.channel_prefix = "synchromesh"
+      end
+    end
+
+    it "opens the connection" do
+      mount "TestComponent"
+      evaluate_ruby "HyperMesh.go_ahead_and_connect"
+      Timecop.travel(Time.now+HyperMesh::Connection.transport.expire_new_connection_in)
+      wait_for { HyperMesh::Connection.active }.to eq(['TestApplication'])
+    end
+
+    it "will not keep the temporary polled connection open" do
+      mount "TestComponent"
+      HyperMesh::Connection.active.should =~ ['TestApplication']
+      Timecop.travel(Time.now+HyperMesh::Connection.transport.expire_new_connection_in)
+      wait_for { HyperMesh::Connection.active }.to eq([])
+    end
+
+    it "sees the connection going offline" do
+      mount "TestComponent"
+      evaluate_ruby "HyperMesh.go_ahead_and_connect"
+      Timecop.travel(Time.now+HyperMesh::Connection.transport.expire_new_connection_in)
+      wait_for { HyperMesh::Connection.active }.to eq(['TestApplication'])
+      ApplicationController.acting_user = true
+      mount "TestComponent"
+      evaluate_ruby "HyperMesh.go_ahead_and_connect"
+      wait_for { HyperMesh::Connection.active }.to eq([])
+    end
+
+    it "receives change notifications" do
+      # one tricky thing about synchromesh is that we want to capture all
+      # changes to the database that might be made while the client connections
+      # is still being initialized.  To do this we establish a server side
+      # queue of all messages sent between the time the page begins rendering
+      # until the connection is established.
+
+      # mount our test component
+      mount "TestComponent"
+      # add a model
+      TestModel.new(test_attribute: "I'm new here!").save
+      # until we connect there should only be 5 items
+      page.should have_content("5 items")
+      # okay now we can go ahead and connect (this runs on the client)
+      evaluate_ruby "HyperMesh.go_ahead_and_connect"
+      # once we connect it should change to 6
+      page.should have_content("6 items")
+      # now that we are connected the UI should keep updating
+      TestModel.new(test_attribute: "I'm also new here!").save
+      page.should have_content("7 items")
+    end
+
+    it "receives destroy notifications" do
+      mount "TestComponent"
+      TestModel.first.destroy
+      page.should have_content("5 items")
+      evaluate_ruby "HyperMesh.go_ahead_and_connect"
+      page.should have_content("4 items")
+    end
+
+  end
+end

data/spec/synchromesh/policies/auto_connect_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe 'channel auto connect' do
+
+  before(:each) do
+    stub_const 'ApplicationPolicy', Class.new
+    stub_const 'TestModelPolicy', Class.new
+    stub_const 'TestModel', Class.new
+    TestModel.class_eval do
+      def initialize(id)
+        @id = id
+      end
+      def self.find(id)
+        new(id)
+      end
+      def id
+        @id
+      end
+    end
+  end
+
+  it 'will autoconnect' do
+    ApplicationPolicy.always_allow_connection
+    expect(HyperMesh::AutoConnect.channels(0, nil)).to eq(["Application"])
+  end
+
+  it 'will autoconnect to multiple channels' do
+    ApplicationPolicy.regulate_class_connection { true }
+    ApplicationPolicy.regulate_class_connection('AnotherChannel') { true }
+    expect(HyperMesh::AutoConnect.channels(0, nil)).to eq(['Application', 'AnotherChannel'])
+  end
+
+  it 'will not autoconnect a class channel if disabled' do
+    ApplicationPolicy.regulate_class_connection(auto_connect: false) { true }
+    ApplicationPolicy.regulate_instance_connections(TestModel) { self }
+    expect(HyperMesh::AutoConnect.channels(0, TestModel.find(1))).to eq([['TestModel',1]])
+  end
+
+  it 'will not autoconnect an instance channel if disabled' do
+    ApplicationPolicy.regulate_class_connection { true }
+    ApplicationPolicy.regulate_instance_connections(TestModel, auto_connect: false) { self }
+    expect(HyperMesh::AutoConnect.channels(0, TestModel.find(1))).to eq(['Application'])
+  end
+
+  it 'can autoconnect to an instance' do
+    TestModelPolicy.regulate_instance_connections { self }
+    expect(HyperMesh::AutoConnect.channels(0, TestModel.find(1))).to eq([['TestModel', 1]])
+  end
+
+  it 'can autoconnect to an instance and class' do
+    TestModelPolicy.always_allow_connection
+    TestModelPolicy.regulate_instance_connections { self }
+    expect(HyperMesh::AutoConnect.channels(0, TestModel.find(1))).to eq(['TestModel', ['TestModel', 1]])
+  end
+
+  it 'can autoconnect to multiple instances' do
+    TestModelPolicy.regulate_instance_connections { [TestModel.find(1), TestModel.find(2)] if self == 'acting_user'}
+    expect(HyperMesh::AutoConnect.channels(0, 'acting_user')).to eq([['TestModel', 1], ['TestModel', 2]])
+  end
+end