hyper-mesh 0.6.0 → 1.0.0.lap22

data/spec/batch1/misc/access_like_hash_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-require 'test_components'
-require 'rspec-steps'
-
-
-RSpec::Steps.steps "access like a hash", js: true do
-
-  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)
-    FactoryGirl.create(:user, first_name: 'Lily', last_name: 'DaDog')
-  end
-
-  it "can access attributes using the [] operator" do
-    expect_promise do
-      HyperMesh.load do
-        User.find_by_first_name('Lily')
-      end.then do |lily|
-        lily[:first_name]
-      end
-    end.to eq('Lily')
-  end
-
-  it "can update attributes using the []= operator" do
-    expect_promise do
-      HyperMesh.load do
-        User.find_by_first_name('Lily')
-      end.then do |lily|
-        lily[:last_name] = 'DerDog'
-        lily.save
-      end
-    end.to be_truthy
-    expect(User.find_by_first_name('Lily')[:last_name]).to eq('DerDog')
-  end
-end

data/spec/batch1/misc/while_loading_spec.rb

@@ -1,196 +0,0 @@
-require 'spec_helper'
-require 'test_components'
-require 'rspec-steps'
-
-
-describe "while loading", js: true do
-
-  before(:all) do
-    class ReactiveRecord::Operations::Fetch < Hyperloop::ServerOp
-      def self.semaphore
-        @semaphore ||= Mutex.new
-      end
-      validate { self.class.semaphore.synchronize { true } }
-    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"
-
-    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(: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 '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)
-    FactoryGirl.create(:user, first_name: 'Lily', last_name: 'DaDog')
-
-  end
-
-  it "will display the while loading message" do
-    ReactiveRecord::Operations::Fetch.semaphore.synchronize do
-      mount "WhileLoadingTester", {}, no_wait: true do
-        class MyNestedGuy < Hyperloop::Component
-          render(SPAN) do
-            User.find_by_first_name('Lily').last_name
-          end
-        end
-        class WhileLoadingTester < Hyperloop::Component
-          render do
-            DIV do
-              MyNestedGuy {}
-            end.while_loading do
-              SPAN { 'loading...' }
-            end
-          end
-        end
-      end
-      expect(page).to have_content('loading...')
-      expect(page).not_to have_content('DaDog', wait: 0)
-    end
-    expect(page).to have_content('DaDog')
-    expect(page).not_to have_content('loading...', wait: 0)
-  end
-
-  it "loading and loaded blocks can return strings" do
-    ReactiveRecord::Operations::Fetch.semaphore.synchronize do
-      mount "WhileLoadingTester", {}, no_wait: true do
-        class WhileLoadingTester < Hyperloop::Component
-          render do
-            DIV do
-              User.find_by_first_name('Lily').last_name
-            end.while_loading do
-              'loading...'
-            end
-          end
-        end
-      end
-      expect(page).to have_content('loading...')
-      expect(page).not_to have_content('DaDog', wait: 0)
-      sleep 1
-    end
-    expect(page).to have_content('DaDog')
-    expect(page).not_to have_content('loading...', wait: 0)
-    sleep 1
-  end
-
-  it "The inner most while_loading will display only" do
-    ReactiveRecord::Operations::Fetch.semaphore.synchronize do
-      mount "WhileLoadingTester", {}, no_wait: true do
-        class MyNestedGuy < Hyperloop::Component
-          render do
-            DIV { User.find_by_first_name('Lily').last_name }
-            .while_loading { SPAN { 'loading...' } }
-          end
-        end
-        class WhileLoadingTester < Hyperloop::Component
-          render do
-            DIV do
-              MyNestedGuy {}
-            end.while_loading do
-              SPAN { 'i should not display' }
-            end
-          end
-        end
-      end
-      expect(page).to have_content('loading...')
-      expect(page).not_to have_content('DaDog', wait: 0)
-    end
-    expect(page).to have_content('DaDog')
-    expect(page).not_to have_content('loading...', wait: 0)
-  end
-
-  it "while loading can take a string param instead of a block" do
-    ReactiveRecord::Operations::Fetch.semaphore.synchronize do
-      mount "WhileLoadingTester", {}, no_wait: true do
-        class WhileLoadingTester < Hyperloop::Component
-          render do
-            DIV do
-              User.find_by_first_name('Lily').last_name
-            end
-            .while_loading 'loading...'
-          end
-        end
-      end
-      expect(page).to have_content('loading...')
-      expect(page).not_to have_content('DaDog', wait: 0)
-    end
-    expect(page).to have_content('DaDog')
-    expect(page).not_to have_content('loading...', wait: 0)
-  end
-
-  it "while loading can take an element param instead of a block" do
-    ReactiveRecord::Operations::Fetch.semaphore.synchronize do
-      mount "WhileLoadingTester", {}, no_wait: true do
-        class WhileLoadingTester < Hyperloop::Component
-          render do
-            DIV do
-              User.find_by_first_name('Lily').last_name
-            end
-            .while_loading(DIV { 'loading...' })
-          end
-        end
-      end
-      expect(page).to have_content('loading...')
-      expect(page).not_to have_content('DaDog', wait: 0)
-    end
-    expect(page).to have_content('DaDog')
-    expect(page).not_to have_content('loading...', wait: 0)
-  end
-
-  it "will display the while loading message" do
-    isomorphic do
-      class FetchNow < Hyperloop::ServerOp
-        dispatch_to { TestApplication }
-      end
-    end
-    mount "WhileLoadingTester", {}, no_wait: true do
-      class MyNestedGuy < Hyperloop::Component
-        state fetch: false, scope: :shared
-        FetchNow.on_dispatch { mutate.fetch(true) }
-        render(SPAN) do
-          if state.fetch
-            User.find_by_first_name('Lily').last_name
-          else
-            'no fetch yet chet'
-          end
-        end
-      end
-      class WhileLoadingTester < Hyperloop::Component
-        render do
-          DIV do
-            MyNestedGuy {}
-          end.while_loading do
-            SPAN { 'loading...' }
-          end
-        end
-      end
-    end
-    expect(page).to have_content('no fetch yet chet')
-    expect(page).not_to have_content('loading...', wait: 0)
-    expect(page).not_to have_content('DaDog', wait: 0)
-    ReactiveRecord::Operations::Fetch.semaphore.synchronize do
-      FetchNow.run
-      expect(page).to have_content('loading...')
-      expect(page).not_to have_content('DaDog', wait: 0)
-      expect(page).not_to have_content('no fetch yet chet', wait: 0)
-    end
-    expect(page).to have_content('DaDog')
-    expect(page).not_to have_content('loading...', wait: 0)
-    expect(page).not_to have_content('no fetch yet chet', wait: 0)
-  end
-
-end

data/spec/batch1/policies/regulate_all_broadcasts_spec.rb

@@ -1,315 +0,0 @@
-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(Hyperloop::InternalPolicy).to receive(:id).and_return(:unique_broadcast_id)
-    allow(Hyperloop::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| Hyperloop::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| Hyperloop::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| Hyperloop::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| Hyperloop::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| Hyperloop::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| Hyperloop::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| Hyperloop::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| Hyperloop::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| Hyperloop::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| Hyperloop::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