hyper-mesh 0.4.0

data/spec/synchromesh/column_types/column_type_spec.rb

@@ -0,0 +1,302 @@
+require 'spec_helper'
+require 'synchromesh/integration/test_components'
+require 'rspec-steps'
+
+describe "column types on client", js: true do
+
+  before(:all) do
+    # TimeXternal - lets us easily get back time values
+    # that will look like client json strings.
+    class Timex
+
+      def initialize(time = nil)
+        if time.is_a? Time
+          @time = time
+        elsif time.is_a? Timex
+          @time = time.time.dup
+        elsif time
+          @time = Time.new(time.localtime)
+        else
+          @time = Time.new
+        end
+      end
+
+      def method_missing(m, *args, &b)
+        val = time.send(m, *args, &b)
+        val = Timex.new(val) if val.is_a? Time
+        val
+      end
+
+      def as_json
+        strftime("%Y-%m-%dT%H:%M:%S%z")
+      end
+
+      attr_reader :time
+
+      def time_only
+        utc_time = Timex.new(self).utc
+        start_time = Time.parse('2000-01-01T00:00:00.000-00:00').utc
+        Timex.new (start_time+(utc_time-utc_time.beginning_of_day.to_i).to_i).localtime
+      end
+
+      class << self
+        def at(x)
+          Timex.new(Time.at(x))
+        end
+        def sqlmin
+          Timex.new(Time.parse('2001-01-01T00:00:00.000-00:00').localtime)
+        end
+        def parse(s)
+          Timex.new(Time.parse(s))
+        end
+      end
+    end
+
+    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
+
+    class TypeTest < ActiveRecord::Base
+      def self.build_tables
+        connection.create_table :type_tests, force: true do |t|
+          t.binary :binary
+          t.boolean :boolean
+          t.date :date
+          t.datetime :datetime
+          t.decimal :decimal, precision: 5, scale: 2
+          t.float :float
+          t.integer :integer
+          t.bigint :bigint
+          t.string :string
+          t.text :text
+          t.time :time
+          t.timestamp :timestamp
+        end
+      end
+    end
+
+    class DefaultTest < ActiveRecord::Base
+      def self.build_tables
+        connection.create_table :default_tests, force: true do |t|
+          t.string :string, default: "I'm a string!"
+          t.date :date, default: Date.today
+          t.datetime :datetime, default: Time.now
+        end
+      end
+    end
+
+    isomorphic do
+      class TypeTest < ActiveRecord::Base
+      end
+      class DefaultTest < ActiveRecord::Base
+      end
+    end
+
+    TypeTest.build_tables rescue nil
+    DefaultTest.build_tables rescue nil
+
+    ActiveRecord::Base.instance_variable_set(:@public_columns_hash, nil)
+
+  end
+
+  before(:each) do
+    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 'transfers the columns hash to the client' do
+    expect_evaluate_ruby do
+      TypeTest.columns_hash
+    end.to eq(TypeTest.columns_hash.as_json)
+  end
+
+  it 'creates a dummy value of the appropriate type' do
+    t = Time.now
+    TypeTest.create(
+      boolean: true,
+      date: t,
+      datetime: t,
+      decimal: 12.2,
+      float: 13.2,
+      integer: 14,
+      bigint: 15,
+      string: "hello",
+      text: "goodby",
+      time: t,
+      timestamp: t
+    )
+    expect_evaluate_ruby do
+      TypeTest.columns_hash.collect do |attr, _info|
+        TypeTest.find(1).send(attr).class
+      end
+    end.to eq([
+      'Number', 'NilClass', 'Boolean', 'Date', 'Time', 'Number', 'Number', 'Number',
+      'Number', 'String', 'String', 'Time', 'Time'
+    ])
+  end
+
+  it 'loads and converts the value' do
+    t = Timex.parse('1/2/2003')
+    r = TypeTest.create(
+      boolean: true,
+      date: t.time,
+      datetime: t.time,
+      decimal: 12.2,
+      float: 13.2,
+      integer: 14,
+      bigint: 15,
+      string: "hello",
+      text: "goodby",
+      time: t.time,
+      timestamp: t.time
+    )
+    r.reload
+    expect_promise do
+      ReactiveRecord.load do
+        TypeTest.columns_hash.collect do |attr, _info|
+          [TypeTest.find(1).send(attr).class, TypeTest.find(1).send(attr)]
+        end.flatten
+      end
+    end.to eq([
+      'Number', 1,
+      'NilClass', nil,
+      'Boolean', true,
+      'Date', t.to_date.as_json,
+      'Time', t.as_json,
+      'Number', 12.2,
+      'Number', 13.2,
+      'Number', 14,
+      'Number', 15,
+      'String', 'hello',
+      'String', 'goodby',
+      'Time', t.time_only.as_json, # date is indeterminate for active record time
+      'Time', t.as_json
+    ])
+  end
+
+  it 'while loading the dummy value delegates the correct type with operators etc' do
+    t = Time.parse('1/2/2003')
+    TypeTest.create(
+      boolean: true,
+      date: t,
+      datetime: t,
+      decimal: 12.2,
+      float: 13.2,
+      integer: 14,
+      bigint: 15,
+      string: "hello",
+      text: "goodby",
+      time: t,
+      timestamp: t
+    )
+    expect_evaluate_ruby do
+      t = TypeTest.find(1)
+      [
+        !t.boolean, t.date+1, t.datetime+2.days, t.decimal + 5, t.float + 6, t.integer + 7,
+        t.bigint + 8, t.string.length, t.text.length, t.time+3.days, t.timestamp+4.days
+      ]
+    end.to eq([
+      true, "2001-01-02", (Timex.sqlmin+2.days).as_json, 5, 6, 7,
+      8, 0, 0, (Timex.sqlmin+3.days).as_json, (Timex.sqlmin+4.days).as_json
+    ])
+  end
+
+  it 'converts a time string to a time on writing' do
+    expect_evaluate_ruby do
+      test = TypeTest.new
+      test.datetime = "1/1/2001"
+      (test.datetime + 1.minute)
+    end.to eq((Timex.parse("1/1/2001") + 1.minute).as_json)
+  end
+
+  it 'converts a integer to a time on writing' do
+    expect_evaluate_ruby do
+      test = TypeTest.new
+      test.datetime = 12
+      test.datetime + 60.seconds
+    end.to eq((Timex.at(12)+60.seconds).as_json)
+  end
+
+  it 'converts a float to a time on writing' do
+    expect_evaluate_ruby do
+      test = TypeTest.new
+      test.datetime = 12.2
+      test.datetime + 60.9
+    end.to eq((Timex.at(12.2)+60.9).as_json)
+  end
+
+  it 'converts a 0, "false" false and nil to a boolean false, everything else is true' do
+    expect_evaluate_ruby do
+      [0, 'false', false, nil, 'hi', 17, [], true].collect do |val|
+        TypeTest.new(boolean: val).boolean
+      end
+    end.to eq([false, false, false, false, true, true, true, true])
+  end
+
+  it 'converts other dates just like time' do
+    expect_evaluate_ruby do
+      [:datetime, :time, :timestamp].collect do |attr|
+        TypeTest.new(attr => 12).send(attr)
+      end.uniq
+    end.to eq([Timex.at(12).as_json])
+  end
+
+  it 'converts floats, decimals, integers and bigints' do
+    expect_evaluate_ruby do
+      [:float, :decimal, :integer, :bigint].collect do |attr|
+        TypeTest.new(attr => 12.5).send(attr) +
+        TypeTest.new(attr => "12.2").send(attr) +
+        TypeTest.new(attr => -12.2).send(attr)
+      end.uniq
+    end.to eq([12.5, 12])
+  end
+
+  it 'converts strings and text' do
+    expect_evaluate_ruby do
+      [:string, :text].collect do |attr|
+        [TypeTest.new(attr => 12).send(attr), TypeTest.new(attr => '12').send(attr)]
+      end.flatten.uniq
+    end.to eq(['12'])
+  end
+
+  it 'uses the default value if specified for the dummy value' do
+    r = DefaultTest.create(string: "no no no")
+    expect_evaluate_ruby do
+      t = DefaultTest.find(1)
+      [t.string, t.date, t.datetime]
+    end.to eq(["I'm a string!", r.date.as_json, Timex.new(r.datetime.localtime).as_json])
+  end
+
+  it 'uses the default value if specified when initializing a new record' do
+    expect_evaluate_ruby do
+      DefaultTest.new.string
+    end.to eq("I'm a string!")
+  end
+
+  it 'uses the default value when initializing a new record & can be saved' do
+    starting_fetch_time = evaluate_ruby("ReactiveRecord::Base.last_fetch_at")
+    expect_promise do
+      record = DefaultTest.new
+      record.string = record.string.reverse
+      record.save
+    end.to be_truthy
+    expect(DefaultTest.find(1).string).to eq("!gnirts a m'I")
+    expect_evaluate_ruby("ReactiveRecord::Base.last_fetch_at").to eq(starting_fetch_time)
+  end
+
+end

data/spec/synchromesh/connection_spec.rb

@@ -0,0 +1,144 @@
+require 'spec_helper'
+
+describe HyperMesh::Connection do
+
+  before(:all) do
+    HyperMesh.configuration do |config|
+    end
+  end
+
+  before(:each) do
+    Timecop.return
+  end
+
+  it 'creates the tables' do
+    ActiveRecord::Base.connection.tables.should include('synchromesh_connections')
+    ActiveRecord::Base.connection.tables.should include('synchromesh_queued_messages')
+    described_class.column_names.should =~ ['id', 'channel', 'session', 'created_at', 'expires_at', 'refresh_at']
+  end
+
+  it 'creates the messages queue' do
+    channel = described_class.new
+    channel.messages << HyperMesh::Connection::QueuedMessage.new
+    channel.save
+    channel.reload
+    channel.messages.should eq(HyperMesh::Connection::QueuedMessage.all)
+  end
+
+  it 'can set the root path' do
+    described_class.root_path = 'foobar'
+    expect(described_class.root_path).to eq('foobar')
+  end
+
+  it 'adding new connection' do
+    described_class.open('TestChannel', 0)
+    expect(described_class.active).to eq(['TestChannel'])
+  end
+
+  it 'new connections expire' do
+    described_class.open('TestChannel', 0)
+    expect(described_class.active).to eq(['TestChannel'])
+    Timecop.travel(Time.now+described_class.transport.expire_new_connection_in)
+    expect(described_class.active).to eq([])
+  end
+
+  it 'can send and read data from a channel' do
+    described_class.open('TestChannel', 0)
+    described_class.open('TestChannel', 1)
+    described_class.open('AnotherChannel', 0)
+    described_class.send_to_channel('TestChannel', 'data')
+    expect(described_class.read(0, 'path')).to eq(['data'])
+    expect(described_class.read(0, 'path')).to eq([])
+    expect(described_class.read(1, 'path')).to eq(['data'])
+    expect(described_class.read(1, 'path')).to eq([])
+    expect(described_class.read(0, 'path')).to eq([])
+  end
+
+  it 'will update the expiration time after reading' do
+    described_class.open('TestChannel', 0)
+    described_class.send_to_channel('TestChannel', 'data')
+    described_class.read(0, 'path')
+    Timecop.travel(Time.now+described_class.transport.expire_new_connection_in)
+    expect(described_class.active).to eq(['TestChannel'])
+  end
+
+  it 'will expire a polled connection' do
+    described_class.open('TestChannel', 0)
+    described_class.send_to_channel('TestChannel', 'data')
+    described_class.read(0, 'path')
+    Timecop.travel(Time.now+described_class.transport.expire_polled_connection_in)
+    expect(described_class.active).to eq([])
+  end
+
+  context 'after connecting to the transport' do
+    before(:each) do
+      described_class.open('TestChannel', 0)
+      described_class.open('TestChannel', 1)
+      described_class.send_to_channel('TestChannel', 'data')
+    end
+
+    it "will pass any pending data back" do
+      expect(described_class.connect_to_transport('TestChannel', 0, nil)).to eq(['data'])
+    end
+
+    it "will have the root path set for console access" do
+      described_class.connect_to_transport('TestChannel', 0, "some_path")
+      expect(HyperMesh::Connection.root_path).to eq("some_path")
+    end
+
+    it "the channel will still be active even after initial connection time is expired" do
+      described_class.connect_to_transport('TestChannel', 0, nil)
+      Timecop.travel(Time.now+described_class.transport.expire_new_connection_in)
+      expect(described_class.active).to eq(['TestChannel'])
+    end
+
+    it "will only effect the session being connected" do
+      described_class.connect_to_transport('TestChannel', 0, nil)
+      expect(described_class.read(1, 'path')).to eq(['data'])
+    end
+
+    it "will begin refreshing the channel list" do
+      allow(HyperMesh).to receive(:refresh_channels) {['AnotherChannel']}
+      described_class.open('AnotherChannel', 0)
+      described_class.connect_to_transport('TestChannel', 0, nil)
+      described_class.connect_to_transport('AnotherChannel', 0, nil)
+      expect(described_class.active).to eq(['TestChannel', 'AnotherChannel'])
+      Timecop.travel(Time.now+described_class.transport.refresh_channels_every)
+      expect(described_class.active).to eq(['AnotherChannel'])
+    end
+
+    it "refreshing will not effect channels not connected to the transport" do
+      allow(HyperMesh).to receive(:refresh_channels) {['AnotherChannel']}
+      described_class.open('AnotherChannel', 0)
+      described_class.connect_to_transport('TestChannel', 0, nil)
+      Timecop.travel(Time.now+described_class.transport.refresh_channels_every-1)
+      described_class.read(1, 'path')
+      described_class.connect_to_transport('AnotherChannel', 0, nil)
+      expect(described_class.active).to eq(['TestChannel', 'AnotherChannel'])
+      Timecop.travel(Time.now+1)
+      described_class.active
+      expect(described_class.active).to eq(['TestChannel', 'AnotherChannel'])
+    end
+
+    it "refreshing will not effect channels added during the refresh" do
+      allow(HyperMesh).to receive(:refresh_channels) do
+        described_class.connect_to_transport('TestChannel', 0, nil)
+        ['AnotherChannel']
+      end
+      described_class.open('AnotherChannel', 0)
+      Timecop.travel(Time.now+described_class.transport.refresh_channels_every)
+      described_class.read(0, 'path')
+      described_class.connect_to_transport('AnotherChannel', 0, nil)
+      expect(described_class.active).to eq(['TestChannel', 'AnotherChannel'])
+      described_class.open('TestChannel', 2)
+      expect(described_class.active).to eq(['TestChannel', 'AnotherChannel'])
+    end
+
+    it "sends messages to the transport as well as open channels" do
+      expect(HyperMesh).to receive(:send).with('TestChannel', 'data2')
+      described_class.connect_to_transport('TestChannel', 0, nil)
+      described_class.send_to_channel('TestChannel', 'data2')
+      expect(described_class.read(1, 'path')).to eq(['data', 'data2'])
+    end
+  end
+end

data/spec/synchromesh/crud_access_regulation/broadcast_controls_access_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+require 'synchromesh/integration/test_components'
+
+describe "regulate access allowed" do
+
+  before(:all) do
+    HyperMesh.configuration do |config|
+      config.transport = :none
+    end
+  end
+
+  context "basic tests" do
+    before(:each) 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 'C2', Class.new
+      stub_const 'TestApplicationPolicy', Class.new
+      TestApplicationPolicy.class_eval do
+        regulate_class_connection { self }
+        regulate_class_connection(C2) { self }
+        regulate_instance_connections(TestModel) { self if self.is_a? TestModel }
+        regulate_all_broadcasts(C2) { |policy| policy.send_all_but(:created_at) }
+        regulate_broadcast(TestModel) do |policy|
+          policy.send_all.to(TestApplication) unless test_attribute == "bogus"
+          policy.send_all.to(self)
+        end
+      end
+    end
+
+    it "will allow access if the broadcast policy allows access" do
+      m = FactoryGirl.create(:test_model, test_attribute: "hello")
+      expect { m.check_permission_with_acting_user("user", :view_permitted?, :test_attribute) }.
+      not_to raise_error
+      expect { m.check_permission_with_acting_user("user", :view_permitted?, :created_at) }.
+      not_to raise_error
+    end
+
+    it "will disallow access if acting_user is not allowed to connect" do
+      m = FactoryGirl.create(:test_model, test_attribute: "hello")
+      expect { m.check_permission_with_acting_user(nil, :view_permitted?, :test_attribute) }.
+      to raise_error(ReactiveRecord::AccessViolation)
+      expect { m.check_permission_with_acting_user(nil, :view_permitted?, :created_at) }.
+      to raise_error(ReactiveRecord::AccessViolation)
+    end
+
+    it "will disallow access to attributes not broadcast by the model" do
+      m = FactoryGirl.create(:test_model, test_attribute: "bogus")
+      expect { m.check_permission_with_acting_user("user", :view_permitted?, :test_attribute) }.
+      not_to raise_error
+      expect { m.check_permission_with_acting_user("user", :view_permitted?, :created_at) }.
+      to raise_error(ReactiveRecord::AccessViolation)
+    end
+
+    it "will allow access to attributes broadcast over an instance channel" do
+      m = FactoryGirl.create(:test_model, test_attribute: "bogus")
+      expect { m.check_permission_with_acting_user(m, :view_permitted?, :test_attribute) }.
+      not_to raise_error
+      expect { m.check_permission_with_acting_user(m, :view_permitted?, :created_at) }.
+      not_to raise_error
+    end
+  end
+
+  it "will include :id as read attribute as long as any other attribute is readable" do
+    stub_const 'TestApplication', Class.new
+    stub_const 'TestApplicationPolicy', Class.new
+    TestApplicationPolicy.class_eval do
+      always_allow_connection
+      regulate_all_broadcasts { |policy| policy.send_only(:test_attribute) }
+    end
+    m = FactoryGirl.create(:test_model)
+    expect { m.check_permission_with_acting_user(nil, :view_permitted?, :id) }.
+    not_to raise_error
+  end
+
+  it "will not include :id as read attribute if no other attributes are readable" do
+    stub_const 'TestApplication', Class.new
+    stub_const 'TestApplicationPolicy', Class.new
+    TestApplicationPolicy.class_eval do
+      always_allow_connection
+    end
+    m = FactoryGirl.create(:test_model)
+    expect { m.check_permission_with_acting_user(nil, :view_permitted?, :id) }.
+    to raise_error(ReactiveRecord::AccessViolation)
+  end
+
+  it "will ignore auto_connect: false " do
+    stub_const 'TestApplication', Class.new
+    stub_const 'TestApplicationPolicy', Class.new
+    TestApplicationPolicy.class_eval do
+      regulate_class_connection(auto_connect: false) { true }
+      regulate_instance_connections(TestModel, auto_connect: false) { self }
+      regulate_all_broadcasts { |policy| policy.send_only(:test_attribute) }
+      regulate_broadcast(TestModel) { |policy| policy.send_only(:created_at).to(self) }
+    end
+    m = FactoryGirl.create(:test_model)
+    expect { m.check_permission_with_acting_user(m, :view_permitted?, :id) }.
+    not_to raise_error
+    expect { m.check_permission_with_acting_user(m, :view_permitted?, :test_attribute) }.
+    not_to raise_error
+    expect { m.check_permission_with_acting_user(m, :view_permitted?, :created_at) }.
+    not_to raise_error
+  end
+
+end