hyper-mesh 0.5.3 → 0.5.4

data/spec/synchromesh/policies/auto_connect_spec.rb

@@ -1,60 +0,0 @@
-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

data/spec/synchromesh/policies/auto_loader_spec.rb

@@ -1,34 +0,0 @@
-
-require 'spec_helper'
-
-describe 'rails autoloader' do
-
-  # can't figure out how to get rails to dump class cache between tests so
-  # we define two different class policy pairs...
-
-  context "when using const_set" do
-
-    it 'will find the policy class file if available' do
-      stub_const "AutoLoaderTestClassa", Class.new
-      expect(HyperMesh::AutoConnect.channels(0, nil)).to eq(["AutoLoaderTestClassa"])
-    end
-
-    it 'will raise a load error if file does not define the class' do
-      expect { stub_const "AutoLoaderTestClassc", Class.new }.to raise_error(LoadError)
-    end
-  end
-
-  context "when defining a new class" do
-
-    it 'will find the policy class if available' do
-      class AutoLoaderTestClassb
-      end
-      expect(HyperMesh::AutoConnect.channels(0, nil)).to eq(["AutoLoaderTestClassb"])
-    end
-
-    it 'will raise a load error if file does not define the class' do
-      expect { class AutoLoaderTestClassd; end }.to raise_error(LoadError)
-    end
-  end
-
-end

data/spec/synchromesh/policies/policy_methods_spec.rb

@@ -1,85 +0,0 @@
-require 'spec_helper'
-#require 'synchromesh/test_components'
-
-describe "including HyperMesh::PolicyMethods" do
-
-  before(:each) do
-    stub_const "TestClass", Class.new
-    TestClass.class_eval do
-      include HyperMesh::PolicyMethods
-    end
-  end
-
-  it "defines the regulate_class_connection method" do
-    expect(TestClass).to respond_to(:regulate_class_connection)
-  end
-
-
-  it "defines the regulate_instance_connections method" do
-    expect(TestClass).to respond_to(:regulate_instance_connections)
-  end
-
-  it "defines the always_allow_connection method" do
-    expect(TestClass).to respond_to(:always_allow_connection)
-  end
-
-  it "defines the regulate_all_broadcasts method" do
-    expect(TestClass).to respond_to(:regulate_all_broadcasts)
-  end
-
-  it "defines the regulate_broadcast method" do
-    expect(TestClass).to respond_to(:regulate_broadcast)
-  end
-
-  it "sets the correct regulated class" do
-    expect(TestClass.synchromesh_internal_policy_object.instance_variable_get("@regulated_klass")).to eq("TestClass")
-  end
-
-  it "exposes the underlying regulate_class_connection method" do
-    expect(TestClass.synchromesh_internal_policy_object).to respond_to(:regulate_class_connection)
-  end
-
-
-  it "exposes the underlying regulate_instance_connections method" do
-    expect(TestClass.synchromesh_internal_policy_object).to respond_to(:regulate_instance_connections)
-  end
-
-  it "exposes the underlying always_allow_connection method" do
-    expect(TestClass.synchromesh_internal_policy_object).to respond_to(:always_allow_connection)
-  end
-
-  it "exposes the underlying regulate_all_broadcasts method" do
-    expect(TestClass.synchromesh_internal_policy_object).to respond_to(:regulate_all_broadcasts)
-  end
-
-  it "exposes the underlying regulate_broadcast method" do
-    expect(TestClass.synchromesh_internal_policy_object).to respond_to(:regulate_broadcast)
-  end
-
-  it "defines the send_all instance method" do
-    expect(TestClass.new).to respond_to(:send_all)
-  end
-
-  it "defines the send_all_but instance method" do
-    expect(TestClass.new).to respond_to(:send_all_but)
-  end
-
-  it "defines the send_only instance method" do
-    expect(TestClass.new).to respond_to(:send_only)
-  end
-
-  it "defines the obj instance method" do
-    expect(TestClass.new).to respond_to(:obj)
-  end
-
-  it "will automatically create an empty Application class if needed" do
-    expect(defined? Application).to be_falsy
-    stub_const 'ApplicationPolicy', Class.new
-    ApplicationPolicy.class_eval do
-      regulate_class_connection { true }
-    end
-    HyperMesh.configuration {}
-    expect(Application).to be_a(Class)
-  end
-
-end

data/spec/synchromesh/policies/regulate_class_connection_spec.rb

@@ -1,50 +0,0 @@
-require 'spec_helper'
-
-describe "regulate class connections" do
-
-  before(:each) do
-    stub_const "ApplicationPolicy", Class.new
-  end
-
-  it "will fail if there is no connection policy for a class" do
-    ApplicationPolicy.regulate_instance_connections { self }
-    expect { HyperMesh::InternalPolicy.regulate_connection(nil, "Application") }.to raise_error('connection failed')
-  end
-
-  it "will succeed if there is a connection policy for a class" do
-    ApplicationPolicy.regulate_class_connection { true }
-    expect { HyperMesh::InternalPolicy.regulate_connection(nil, "Application") }.not_to raise_error
-  end
-
-  it "the class connection policy ignores the acting_user object" do
-    ApplicationPolicy.regulate_class_connection { true }
-    expect { HyperMesh::InternalPolicy.regulate_connection("acting_user", "Application") }.not_to raise_error
-  end
-
-  it "can be applied to a different class" do
-    stub_const "Class1", Class.new
-    stub_const "Class2", Class.new
-    ApplicationPolicy.regulate_class_connection(Class1, Class2) { true }
-    expect { HyperMesh::InternalPolicy.regulate_connection(nil, "Class1") }.not_to raise_error
-    expect { HyperMesh::InternalPolicy.regulate_connection(nil, "Class2") }.not_to raise_error
-    expect { HyperMesh::InternalPolicy.regulate_connection(nil, "Application") }.to raise_error('connection failed')
-  end
-
-  it "can be simplified using the always_allow_connection method" do
-    ApplicationPolicy.always_allow_connection
-    expect { HyperMesh::InternalPolicy.regulate_connection(nil, "Application") }.not_to raise_error
-  end
-
-  it "can conditionally regulate the connection" do
-    ApplicationPolicy.regulate_class_connection { self }
-    expect { HyperMesh::InternalPolicy.regulate_connection(true, "Application") }.not_to raise_error
-    expect { HyperMesh::InternalPolicy.regulate_connection(nil, "Application") }.to raise_error('connection failed')
-  end
-
-  it "can conditionally regulate the connection by raising an error" do
-    ApplicationPolicy.regulate_class_connection { raise "POW" unless self=="okay"; true }
-    expect { HyperMesh::InternalPolicy.regulate_connection("okay", "Application") }.not_to raise_error
-    expect { HyperMesh::InternalPolicy.regulate_connection("dokey", "Application") }.to raise_error('connection failed')
-  end
-
-end

data/spec/synchromesh/policies/regulate_instance_connection_spec.rb

@@ -1,66 +0,0 @@
-require 'spec_helper'
-
-describe "regulate_instance_connections" do
-
-  before(:each) do
-    stub_const "ApplicationPolicy", Class.new
-    stub_const "Application", Class.new
-    Application.class_eval do
-      def initialize(id)
-        @id = id
-      end
-      def ==(other)
-        id == other.id
-      end
-      def self.find(id)
-        new(id)
-      end
-      def id
-        @id.to_s
-      end
-    end
-  end
-
-  it "will fail for an instance connection if the connection policy does not support instances" do
-    ApplicationPolicy.always_allow_connection
-    expect { HyperMesh::InternalPolicy.regulate_connection(Application.find(123), "Application-123") }.to raise_error('connection failed')
-  end
-
-  it "will succeed for an instance connection if the connection policy does support instances" do
-    ApplicationPolicy.always_allow_connection
-    ApplicationPolicy.regulate_instance_connections { self }
-    expect { HyperMesh::InternalPolicy.regulate_connection(Application.find(123), "Application-123") }.not_to raise_error
-  end
-
-  it "will succeed only if the user id is correct" do
-    ApplicationPolicy.regulate_instance_connections { Application.find('baz') }
-    expect { HyperMesh::InternalPolicy.regulate_connection(nil, "Application-baz") }.not_to raise_error
-  end
-
-  it "can be applied to a different class" do
-    stub_const "Class1", Class.new(Application)
-    stub_const "Class2", Class.new(Application)
-    ApplicationPolicy.regulate_instance_connections(Class1, Class2) { self }
-    expect { HyperMesh::InternalPolicy.regulate_connection(Class1.find('baz'), "Class1-baz") }.not_to raise_error
-    expect { HyperMesh::InternalPolicy.regulate_connection(Class2.find('baz-2'), "Class2-baz-2") }.not_to raise_error
-    expect { HyperMesh::InternalPolicy.regulate_connection(Application.find('baz'), "Application-baz") }.to raise_error('connection failed')
-  end
-
-  it "can return an array objects" do
-    ApplicationPolicy.regulate_instance_connections { [Application.find(1), Application.find(2)] }
-    expect { HyperMesh::InternalPolicy.regulate_connection("foo", "Application-1") }.not_to raise_error
-    expect { HyperMesh::InternalPolicy.regulate_connection("foo", "Application-2") }.not_to raise_error
-  end
-
-  it "can conditionally regulate the connection" do
-    ApplicationPolicy.regulate_instance_connections { id == '1' && self }
-    expect { HyperMesh::InternalPolicy.regulate_connection(Application.new(1), "Application-1") }.not_to raise_error
-    expect { HyperMesh::InternalPolicy.regulate_connection(Application.new(2), "Application-2") }.to raise_error('connection failed')
-  end
-
-  it "can regulate the connection by raising an error" do
-    ApplicationPolicy.regulate_instance_connections { raise "POW" unless id == '1'; self}
-    expect { HyperMesh::InternalPolicy.regulate_connection(Application.new(1), "Application-1") }.not_to raise_error
-    expect { HyperMesh::InternalPolicy.regulate_connection(Application.new(2), "Application-2") }.to raise_error('connection failed')
-  end
-end