hyper-mesh 0.4.0

data/spec/synchromesh/policies/auto_loader_spec.rb

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

@@ -0,0 +1,85 @@
+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_all_broadcasts_spec.rb

@@ -0,0 +1,315 @@
+require 'spec_helper'
+
+describe "regulate_all_broadcasts" do
+
+  before(:each) do
+    stub_const "TestModel1", Class.new
+    TestModel1.class_eval do
+      include ActiveModel::Model
+      def react_serializer
+        as_json # does not include type: xxx as per reactive-record
+      end
+      def previous_changes
+        Hash[*as_json.keys.collect { |attr| [attr, send(attr)] }.flatten(1)]
+      end
+      def attribute_names
+        [:attr1, :attr2, :attr3, :attr4, :attr5]
+      end
+      attr_accessor :attr1, :attr2, :attr3, :attr4, :attr5
+    end
+    stub_const "TestModel2", Class.new
+    TestModel2.class_eval do
+      include ActiveModel::Model
+      def react_serializer
+        as_json # does not include type: xxx as per reactive-record
+      end
+      def previous_changes
+        Hash[*as_json.keys.collect { |attr| [attr, send(attr)] }.flatten(1)]
+      end
+      def attribute_names
+        [:attrA, :attrB, :attrC, :attrD, :attrE]
+      end
+      attr_accessor :attrA, :attrB, :attrC, :attrD, :attrE
+    end
+    allow_any_instance_of(HyperMesh::InternalPolicy).to receive(:id).and_return(:unique_broadcast_id)
+    allow(HyperMesh::Connection).to receive(:active).and_return(['Application', 'AnotherApplication', 'Class1', 'Class2'])
+  end
+
+  it "will broadcast to a single channel" do
+    stub_const "ApplicationPolicy", Class.new
+    ApplicationPolicy.class_eval do
+      regulate_all_broadcasts do | policy |
+        policy.send_all
+      end
+    end
+    model = TestModel1.new(attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5)
+    expect { |b| HyperMesh::InternalPolicy.regulate_broadcast(model, &b) }.to yield_successive_args(
+      {
+        broadcast_id: :unique_broadcast_id,
+        channel: 'Application',
+        channels: ['Application'],
+        klass: 'TestModel1',
+        record: {attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5},
+        previous_changes: {attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5}
+      }
+    )
+  end
+
+  it "will broadcast to a multiple channels" do
+    stub_const "ApplicationPolicy", Class.new
+    ApplicationPolicy.class_eval do
+      regulate_all_broadcasts do | policy |
+        policy.send_all
+      end
+    end
+    stub_const "AnotherApplicationPolicy", Class.new
+    AnotherApplicationPolicy.class_eval do
+      regulate_all_broadcasts do | policy |
+        policy.send_all
+      end
+    end
+    model = TestModel1.new(attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5)
+    expect { |b| HyperMesh::InternalPolicy.regulate_broadcast(model, &b) }.to yield_successive_args(
+      {
+        broadcast_id: :unique_broadcast_id,
+        channel: 'Application',
+        channels: ['Application', 'AnotherApplication'],
+        klass: 'TestModel1',
+        record: {attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5},
+        previous_changes: {attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5}
+      },
+      {
+        broadcast_id: :unique_broadcast_id,
+        channel: 'AnotherApplication',
+        channels: ['Application', 'AnotherApplication'],
+        klass: 'TestModel1',
+        record: {attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5},
+        previous_changes: {attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5}
+      }
+    )
+  end
+
+  it "will broadcast to a multiple channels with different attributes" do
+    stub_const "ApplicationPolicy", Class.new
+    ApplicationPolicy.class_eval do
+      regulate_all_broadcasts do | policy |
+        policy.send_only(:attr1)
+      end
+    end
+    stub_const "AnotherApplicationPolicy", Class.new
+    AnotherApplicationPolicy.class_eval do
+      regulate_all_broadcasts do | policy |
+        policy.send_all_but(:attr1)
+      end
+    end
+    model = TestModel1.new(attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5)
+    expect { |b| HyperMesh::InternalPolicy.regulate_broadcast(model, &b) }.to yield_successive_args(
+      {
+        broadcast_id: :unique_broadcast_id,
+        channel: 'Application',
+        channels: ['Application', 'AnotherApplication'],
+        klass: 'TestModel1',
+        record: {attr1: 1},
+        previous_changes: {attr1: 1}
+      },
+      {
+        broadcast_id: :unique_broadcast_id,
+        channel: 'AnotherApplication',
+        channels: ['Application', 'AnotherApplication'],
+        klass: 'TestModel1',
+        record: {attr2: 2, attr3: 3, attr4: 4, attr5: 5},
+        previous_changes: {attr2: 2, attr3: 3, attr4: 4, attr5: 5}
+      }
+    )
+  end
+
+  it "can override the default channel using the 'to' method" do
+    stub_const "ApplicationPolicy", Class.new
+    stub_const "AnotherApplicationPolicy", Class.new
+    stub_const "Application", Class.new
+    stub_const "AnotherApplication", Class.new
+    ApplicationPolicy.class_eval do
+      regulate_all_broadcasts do | policy |
+        policy.send_only(:attr1).to(AnotherApplication)
+      end
+    end
+    AnotherApplicationPolicy.class_eval do
+      regulate_all_broadcasts do | policy |
+        policy.send_all_but(:attr1).to(Application)
+      end
+    end
+    model = TestModel1.new(attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5)
+    expect { |b| HyperMesh::InternalPolicy.regulate_broadcast(model, &b) }.to yield_successive_args(
+      {
+        broadcast_id: :unique_broadcast_id,
+        channel: 'AnotherApplication',
+        channels: ['AnotherApplication', 'Application'],
+        klass: 'TestModel1',
+        record: {attr1: 1},
+        previous_changes: {attr1: 1}
+      },
+      {
+        broadcast_id: :unique_broadcast_id,
+        channel: 'Application',
+        channels: ['AnotherApplication', 'Application'],
+        klass: 'TestModel1',
+        record: {attr2: 2, attr3: 3, attr4: 4, attr5: 5},
+        previous_changes: {attr2: 2, attr3: 3, attr4: 4, attr5: 5}
+      }
+    )
+  end
+
+  it "can have multiple polcies" do
+    stub_const "ApplicationPolicy", Class.new
+    stub_const "AnotherApplicationPolicy", Class.new
+    stub_const "Application", Class.new
+    stub_const "AnotherApplication", Class.new
+    ApplicationPolicy.class_eval do
+      regulate_all_broadcasts do | policy |
+        policy.send_only(:attr1, :attr2, :attr3).to(AnotherApplication)
+      end
+    end
+    AnotherApplicationPolicy.class_eval do
+      regulate_all_broadcasts do | policy |
+        policy.send_all_but(:attr1).to(AnotherApplication, Application)
+      end
+    end
+    model = TestModel1.new(attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5)
+    expect { |b| HyperMesh::InternalPolicy.regulate_broadcast(model, &b) }.to yield_successive_args(
+      {
+        broadcast_id: :unique_broadcast_id,
+        channel: 'AnotherApplication',
+        channels: ['AnotherApplication', 'Application'],
+        klass: 'TestModel1',
+        record: {attr2: 2, attr3: 3},
+        previous_changes: {attr2: 2, attr3: 3}
+      },
+      {
+        broadcast_id: :unique_broadcast_id,
+        channel: 'Application',
+        channels: ['AnotherApplication', 'Application'],
+        klass: 'TestModel1',
+        record: {attr2: 2, attr3: 3, attr4: 4, attr5: 5},
+        previous_changes: {attr2: 2, attr3: 3, attr4: 4, attr5: 5}
+      }
+    )
+  end
+
+  it "can have multiple polcies defined by separate send policies" do
+    stub_const "ApplicationPolicy", Class.new
+    stub_const "AnotherApplicationPolicy", Class.new
+    stub_const "Application", Class.new
+    stub_const "AnotherApplication", Class.new
+    ApplicationPolicy.class_eval do
+      regulate_all_broadcasts do | policy |
+        policy.send_only(:attr1, :attr2, :attr3).to(AnotherApplication)
+      end
+    end
+    AnotherApplicationPolicy.class_eval do
+      regulate_all_broadcasts do | policy |
+        policy.send_all_but(:attr1).to(Application)
+        policy.send_all_but(:attr1)
+      end
+    end
+    model = TestModel1.new(attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5)
+    expect { |b| HyperMesh::InternalPolicy.regulate_broadcast(model, &b) }.to yield_successive_args(
+      {
+        broadcast_id: :unique_broadcast_id,
+        channel: 'AnotherApplication',
+        channels: ['AnotherApplication', 'Application'],
+        klass: 'TestModel1',
+        record: {attr2: 2, attr3: 3},
+        previous_changes: {attr2: 2, attr3: 3}
+      },
+      {
+        broadcast_id: :unique_broadcast_id,
+        channel: 'Application',
+        channels: ['AnotherApplication', 'Application'],
+        klass: 'TestModel1',
+        record: {attr2: 2, attr3: 3, attr4: 4, attr5: 5},
+        previous_changes: {attr2: 2, attr3: 3, attr4: 4, attr5: 5}
+      }
+    )
+  end
+
+  it "can have multiple policies without any to method and will intersect the results" do
+    stub_const "ApplicationPolicy", Class.new
+    ApplicationPolicy.class_eval do
+      regulate_all_broadcasts do | policy |
+        policy.send_only(:attr1, :attr2)
+        policy.send_only(:attr2, :attr3)
+      end
+    end
+    model = TestModel1.new(attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5)
+    expect { |b| HyperMesh::InternalPolicy.regulate_broadcast(model, &b) }.to yield_successive_args(
+      {
+        broadcast_id: :unique_broadcast_id,
+        channel: 'Application',
+        channels: ['Application'],
+        klass: 'TestModel1',
+        record: {attr2: 2},
+        previous_changes: {attr2: 2}
+      }
+    )
+  end
+
+  it "can have apply the same policies to different models" do
+    stub_const "ApplicationPolicy", Class.new
+    ApplicationPolicy.class_eval do
+      regulate_all_broadcasts do | policy |
+        policy.send_only(:attr1, :attrA)
+      end
+    end
+    model = TestModel1.new(attr1: 1)
+    expect { |b| HyperMesh::InternalPolicy.regulate_broadcast(model, &b) }.to yield_successive_args(
+      {
+        broadcast_id: :unique_broadcast_id,
+        channel: 'Application',
+        channels: ['Application'],
+        klass: 'TestModel1',
+        record: {attr1: 1},
+        previous_changes: {attr1: 1}
+      }
+    )
+    model = TestModel2.new(attrA: "A")
+    expect { |b| HyperMesh::InternalPolicy.regulate_broadcast(model, &b) }.to yield_successive_args(
+      {
+        broadcast_id: :unique_broadcast_id,
+        channel: 'Application',
+        channels: ['Application'],
+        klass: 'TestModel2',
+        record: {attrA: "A"},
+        previous_changes: {attrA: "A"}
+      }
+    )
+  end
+  it "will accept a list of classes to apply the policy to" do
+    stub_const "ApplicationPolicy", Class.new
+    stub_const "Class1", Class.new
+    stub_const "Class2", Class.new
+    ApplicationPolicy.class_eval do
+      regulate_all_broadcasts(Class1, Class2) do | policy |
+        policy.send_all
+      end
+    end
+    model = TestModel1.new(attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5)
+    expect { |b| HyperMesh::InternalPolicy.regulate_broadcast(model, &b) }.to yield_successive_args(
+      {
+        broadcast_id: :unique_broadcast_id,
+        channel: 'Class1',
+        channels: ['Class1', 'Class2'],
+        klass: 'TestModel1',
+        record: {attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5},
+        previous_changes: {attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5}
+      },
+      {
+        broadcast_id: :unique_broadcast_id,
+        channel: 'Class2',
+        channels: ['Class1', 'Class2'],
+        klass: 'TestModel1',
+        record: {attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5},
+        previous_changes: {attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5}
+      }
+    )
+  end
+end

data/spec/synchromesh/policies/regulate_broadcast_spec.rb

@@ -0,0 +1,370 @@
+require 'spec_helper'
+#require 'synchromesh/test_components'
+
+describe "regulate_broadcast" do
+
+  before(:each) do
+    stub_const "TestModel1", Class.new
+    TestModel1.class_eval do
+      include ActiveModel::Model
+      def react_serializer
+        as_json # does not include type: xxx as per reactive-record
+      end
+      def attribute_names
+        [:id, :attr1, :attr2, :attr3, :attr4, :attr5]
+      end
+      def previous_changes
+        Hash[*as_json.keys.collect { |attr| [attr, send(attr)] }.flatten(1)]
+      end
+      attr_accessor :id, :attr1, :attr2, :attr3, :attr4, :attr5
+    end
+    stub_const "TestModel2", Class.new
+    TestModel2.class_eval do
+      include ActiveModel::Model
+      def react_serializer
+        as_json # does not include type: xxx as per reactive-record
+      end
+      def attribute_names
+        [:id, :attrA, :attrB, :attrC, :attrD, :attrE]
+      end
+      def previous_changes
+        Hash[*as_json.keys.collect { |attr| [attr, send(attr)] }.flatten(1)]
+      end
+      attr_accessor :id, :attrA, :attrB, :attrC, :attrD, :attrE
+    end
+    allow(HyperMesh::Connection).to receive(:active).and_return(['Application', 'TestModel1-1', 'TestModel1-7', 'TestModel2-8'])
+    allow_any_instance_of(HyperMesh::InternalPolicy).to receive(:id).and_return(:unique_broadcast_id)
+  end
+
+  it "will broadcast the instance policies for a model" do
+    stub_const "TestModel1Policy", Class.new
+    TestModel1Policy.class_eval do
+      regulate_broadcast do | policy |
+        policy.send_all.to(self)
+      end
+    end
+    model = TestModel1.new(id: 1, attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5)
+    expect { |b| HyperMesh::InternalPolicy.regulate_broadcast(model, &b) }.to yield_successive_args(
+      {
+        broadcast_id: :unique_broadcast_id,
+        channel: 'TestModel1-1',
+        channels: ['TestModel1-1'],
+        klass: 'TestModel1',
+        record: {id: 1, attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5},
+        previous_changes: {id: 1, attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5}
+      }
+    )
+  end
+
+  it "will raise an error if the policy is not sent" do
+    stub_const "TestModel1Policy", Class.new
+    TestModel1Policy.class_eval do
+      regulate_broadcast do | policy |
+        policy.send_all
+      end
+    end
+    model = TestModel1.new(id: 1, attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5)
+    expect { |b| HyperMesh::InternalPolicy.regulate_broadcast(model, &b) }.
+    to raise_error("TestModel1 instance broadcast policy not sent to any channel")
+  end
+
+  it "will intersect all policies for the same channel" do
+    stub_const "TestModel1Policy", Class.new
+    TestModel1Policy.class_eval do
+      regulate_broadcast do | policy |
+        policy.send_only(:attr1, :attr2).to(self)
+        policy.send_only(:attr2, :attr3).to(self)
+      end
+    end
+    model = TestModel1.new(id: 1, attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5)
+    expect { |b| HyperMesh::InternalPolicy.regulate_broadcast(model, &b) }.to yield_successive_args(
+      {
+        broadcast_id: :unique_broadcast_id,
+        channel: 'TestModel1-1',
+        channels: ['TestModel1-1'],
+        klass: 'TestModel1',
+        record: {id: 1, attr2: 2},
+        previous_changes: {id: 1, attr2: 2}
+      }
+    )
+  end
+
+  it "will broadcast the instance policies for a model and on a class channel" do
+    stub_const "TestModel1Policy", Class.new
+    stub_const "Application", Class.new
+    TestModel1Policy.class_eval do
+      regulate_broadcast do | policy |
+        policy.send_all.to(self, Application)
+      end
+    end
+    model = TestModel1.new(id: 1, attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5)
+    expect { |b| HyperMesh::InternalPolicy.regulate_broadcast(model, &b) }.to yield_successive_args(
+      {
+        broadcast_id: :unique_broadcast_id,
+        channel: 'TestModel1-1',
+        channels: ['TestModel1-1', 'Application'],
+        klass: 'TestModel1',
+        record: {id: 1, attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5},
+        previous_changes: {id: 1, attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5}
+      },
+      {
+        broadcast_id: :unique_broadcast_id,
+        channel: 'Application',
+        channels: ['TestModel1-1', 'Application'],
+        klass: 'TestModel1',
+        record: {id: 1, attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5},
+        previous_changes: {id: 1, attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5}
+      }
+    )
+  end
+
+  it "will handle arrays and falsy values in the to method" do
+    stub_const "TestModel1Policy", Class.new
+    stub_const "Application", Class.new
+    TestModel1Policy.class_eval do
+      regulate_broadcast do | policy |
+        policy.send_all.to(false, [self, Application], nil)
+      end
+    end
+    model = TestModel1.new(id: 1, attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5)
+    expect { |b| HyperMesh::InternalPolicy.regulate_broadcast(model, &b) }.to yield_successive_args(
+      {
+        broadcast_id: :unique_broadcast_id,
+        channel: 'TestModel1-1',
+        channels: ['TestModel1-1', 'Application'],
+        klass: 'TestModel1',
+        record: {id: 1, attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5},
+        previous_changes: {id: 1, attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5}
+      },
+      {
+        broadcast_id: :unique_broadcast_id,
+        channel: 'Application',
+        channels: ['TestModel1-1', 'Application'],
+        klass: 'TestModel1',
+        record: {id: 1, attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5},
+        previous_changes: {id: 1, attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5}
+      }
+    )
+  end
+
+  it "will broadcast different instance policies on different channels" do
+    stub_const "TestModel1Policy", Class.new
+    stub_const "Application", Class.new
+    TestModel1Policy.class_eval do
+      regulate_broadcast do | policy |
+        policy.send_all.to(self)
+        policy.send_only(:id).to(Application)
+      end
+    end
+    model = TestModel1.new(id: 1, attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5)
+    expect { |b| HyperMesh::InternalPolicy.regulate_broadcast(model, &b) }.to yield_successive_args(
+      {
+        broadcast_id: :unique_broadcast_id,
+        channel: 'TestModel1-1',
+        channels: ['TestModel1-1', 'Application'],
+        klass: 'TestModel1',
+        record: {id: 1, attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5},
+        previous_changes: {id: 1, attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5}
+      },
+      {
+        broadcast_id: :unique_broadcast_id,
+        channel: 'Application',
+        channels: ['TestModel1-1', 'Application'],
+        klass: 'TestModel1',
+        record: {id: 1},
+        previous_changes: {id: 1}
+      }
+    )
+  end
+
+  it "will pass the proper policy object" do
+    stub_const "TestModel1Policy", Class.new
+    stub_const "Application", Class.new
+    TestModel1Policy.class_eval do
+      def public_attributes
+        [:id]
+      end
+      regulate_broadcast do | policy |
+        policy.send_all.to(self)
+        policy.send_only(*policy.public_attributes).to(Application)
+      end
+    end
+    model = TestModel1.new(id: 1, attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5)
+    expect { |b| HyperMesh::InternalPolicy.regulate_broadcast(model, &b) }.to yield_successive_args(
+      {
+        broadcast_id: :unique_broadcast_id,
+        channel: 'TestModel1-1',
+        channels: ['TestModel1-1', 'Application'],
+        klass: 'TestModel1',
+        record: {id: 1, attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5},
+        previous_changes: {id: 1, attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5}
+      },
+      {
+        broadcast_id: :unique_broadcast_id,
+        channel: 'Application',
+        channels: ['TestModel1-1', 'Application'],
+        klass: 'TestModel1',
+        record: {id: 1},
+        previous_changes: {id: 1}
+      }
+    )
+  end
+
+  it "will evaluates the regulation in the context of model being broadcast" do
+    stub_const "TestModel1Policy", Class.new
+    stub_const "Application", Class.new
+    TestModel1Policy.class_eval do
+      def public_attributes
+        [:id]
+      end
+      regulate_broadcast do | policy |
+        policy.send_all_but(:attr2).to(self) if attr2 == "YES"
+      end
+    end
+    model = TestModel1.new(id: 1, attr1: 1, attr2: "YES", attr3: 3, attr4: 4, attr5: 5)
+    expect { |b| HyperMesh::InternalPolicy.regulate_broadcast(model, &b) }.to yield_successive_args(
+      {
+        broadcast_id: :unique_broadcast_id,
+        channel: 'TestModel1-1',
+        channels: ['TestModel1-1'],
+        klass: 'TestModel1',
+        record: {id: 1, attr1: 1, attr3: 3, attr4: 4, attr5: 5},
+        previous_changes: {id: 1, attr1: 1, attr3: 3, attr4: 4, attr5: 5}
+      }
+    )
+    model = TestModel1.new(id: 1, attr1: 1, attr2: "NO", attr3: 3, attr4: 4, attr5: 5)
+    expect { |b| HyperMesh::InternalPolicy.regulate_broadcast(model, &b) }.not_to yield_control
+  end
+
+  it "will adds the obj method to the policy which points back to the model being broadcast" do
+    stub_const "TestModel1Policy", Class.new
+    stub_const "Application", Class.new
+    TestModel1Policy.class_eval do
+      def send?
+        obj.attr2 == "YES"
+      end
+      regulate_broadcast do | policy |
+        policy.send_all_but(:attr2).to(self) if policy.send?
+      end
+    end
+    model = TestModel1.new(id: 1, attr1: 1, attr2: "YES", attr3: 3, attr4: 4, attr5: 5)
+    expect { |b| HyperMesh::InternalPolicy.regulate_broadcast(model, &b) }.to yield_successive_args(
+      {
+        broadcast_id: :unique_broadcast_id,
+        channel: 'TestModel1-1',
+        channels: ['TestModel1-1'],
+        klass: 'TestModel1',
+        record: {id: 1, attr1: 1, attr3: 3, attr4: 4, attr5: 5},
+        previous_changes: {id: 1, attr1: 1, attr3: 3, attr4: 4, attr5: 5}
+      }
+    )
+    model = TestModel1.new(id: 1, attr1: 1, attr2: "NO", attr3: 3, attr4: 4, attr5: 5)
+    expect { |b| HyperMesh::InternalPolicy.regulate_broadcast(model, &b) }.not_to yield_control
+  end
+  it "will not broadcast an empty record" do
+    stub_const "TestModel1Policy", Class.new
+    stub_const "Application", Class.new
+    TestModel1Policy.class_eval do
+      def attributes_to_send
+        [:attr1] if obj.attr2 == "YES"
+      end
+      regulate_broadcast do | policy |
+        policy.send_only(*policy.attributes_to_send).to(self)
+      end
+    end
+    model = TestModel1.new(id: 1, attr1: 1, attr2: "YES", attr3: 3, attr4: 4, attr5: 5)
+    expect { |b| HyperMesh::InternalPolicy.regulate_broadcast(model, &b) }.to yield_successive_args(
+      {
+        broadcast_id: :unique_broadcast_id,
+        channel: 'TestModel1-1',
+        channels: ['TestModel1-1'],
+        klass: 'TestModel1',
+        record: {id: 1, attr1: 1},
+        previous_changes: {id: 1, attr1: 1}
+      }
+    )
+    model = TestModel1.new(id: 1, attr1: 1, attr2: "NO", attr3: 3, attr4: 4, attr5: 5)
+    expect { |b| HyperMesh::InternalPolicy.regulate_broadcast(model, &b) }.not_to yield_control
+  end
+  it "will apply the same policy to several models" do
+    stub_const "ApplicationPolicy", Class.new
+    ApplicationPolicy.class_eval do
+      regulate_broadcast(TestModel1, TestModel2) do |policy|
+        policy.send_all_but(:attr1).to(self)
+      end
+    end
+    model1 = TestModel1.new(id: 7, attr1: 1)
+    model2 = TestModel2.new(id: 8, attrA: 1)
+    expect { |b| HyperMesh::InternalPolicy.regulate_broadcast(model1, &b) }.to yield_successive_args(
+      {
+        broadcast_id: :unique_broadcast_id,
+        channel: 'TestModel1-7',
+        channels: ['TestModel1-7'],
+        klass: 'TestModel1',
+        record: {id: 7},
+        previous_changes: {id: 7}
+      }
+    )
+    expect { |b| HyperMesh::InternalPolicy.regulate_broadcast(model2, &b) }.to yield_successive_args(
+      {
+        broadcast_id: :unique_broadcast_id,
+        channel: 'TestModel2-8',
+        channels: ['TestModel2-8'],
+        klass: 'TestModel2',
+        record: {id: 8, attrA: 1},
+        previous_changes: {id: 8, attrA: 1}
+      }
+    )
+
+  end
+
+  it "exposes the policy methods on the synchromesh_internal_policy_object" do
+    stub_const "TestModel1Policy", Class.new
+    stub_const "Application", Class.new
+    TestModel1Policy.class_eval do
+      regulate_broadcast do | policy |
+        case policy.synchromesh_internal_policy_object.obj.attr1
+        when "send_all"
+          policy.synchromesh_internal_policy_object.send_all.to(self)
+        when "send_all_but"
+          policy.synchromesh_internal_policy_object.send_all_but(:attr2).to(self)
+        when "send_only"
+          policy.synchromesh_internal_policy_object.send_only(:attr2).to(self)
+        end
+      end
+    end
+    model = TestModel1.new(id: 1, attr1: "send_all", attr2: "YES", attr3: 3, attr4: 4, attr5: 5)
+    expect { |b| HyperMesh::InternalPolicy.regulate_broadcast(model, &b) }.to yield_successive_args(
+      {
+        broadcast_id: :unique_broadcast_id,
+        channel: 'TestModel1-1',
+        channels: ['TestModel1-1'],
+        klass: 'TestModel1',
+        record: {id: 1, attr1: "send_all", attr2: "YES", attr3: 3, attr4: 4, attr5: 5},
+        previous_changes: {id: 1, attr1: "send_all", attr2: "YES", attr3: 3, attr4: 4, attr5: 5}
+      }
+    )
+    model = TestModel1.new(id: 1, attr1: "send_all_but", attr2: "YES", attr3: 3, attr4: 4, attr5: 5)
+    expect { |b| HyperMesh::InternalPolicy.regulate_broadcast(model, &b) }.to yield_successive_args(
+      {
+        broadcast_id: :unique_broadcast_id,
+        channel: 'TestModel1-1',
+        channels: ['TestModel1-1'],
+        klass: 'TestModel1',
+        record: {id: 1, attr1: "send_all_but", attr3: 3, attr4: 4, attr5: 5},
+        previous_changes: {id: 1, attr1: "send_all_but", attr3: 3, attr4: 4, attr5: 5}
+      }
+    )
+    model = TestModel1.new(id: 1, attr1: "send_only", attr2: "YES", attr3: 3, attr4: 4, attr5: 5)
+    expect { |b| HyperMesh::InternalPolicy.regulate_broadcast(model, &b) }.to yield_successive_args(
+      {
+        broadcast_id: :unique_broadcast_id,
+        channel: 'TestModel1-1',
+        channels: ['TestModel1-1'],
+        klass: 'TestModel1',
+        record: {id: 1, attr2: "YES"},
+        previous_changes: {id: 1, attr2: "YES"}
+      }
+    )
+  end
+end