active_event 0.5.2 → 0.5.3

data/lib/active_event/version.rb

@@ -1,7 +1,7 @@
 module ActiveEvent
   # Returns the version of the currently loaded ActiveEvent as a Gem::Version
   def self.version
-    Gem::Version.new '0.5.2'
+    Gem::Version.new '0.5.3'
   end
 
   module VERSION #:nodoc:

data/spec/factories/event_factory.rb

@@ -1,9 +1,9 @@
-require 'factory_girl'
-
-FactoryGirl.define do
-  factory :event, class: ActiveEvent::Event do
-    event 'TestEvent'
-    data name: 'Hello', r: 10, g: 20, b: 30
-    created_at DateTime.new(2012,12,24,11,11,11)
-  end
-end
+require 'factory_girl'
+
+FactoryGirl.define do
+  factory :event, class: ActiveEvent::Event do
+    event 'TestEvent'
+    data name: 'Hello', r: 10, g: 20, b: 30
+    created_at DateTime.new(2012, 12, 24, 11, 11, 11)
+  end
+end

data/spec/lib/command_spec.rb

@@ -1,14 +1,14 @@
-require_relative '../spec_helper'
-
-describe ActiveEvent::Command do
-  class TestCommand
-    include ActiveEvent::Command
-    attributes :r, :g, :b
-  end
-
-  describe 'create instance' do
-    it 'can create an instance' do
-      expect { TestCommand.new r: 10 }.to be
-    end
-  end
-end
+require_relative '../spec_helper'
+
+describe ActiveEvent::Command do
+  class TestCommand
+    include ActiveEvent::Command
+    attributes :r, :g, :b
+  end
+
+  describe 'create instance' do
+    it 'can create an instance' do
+      expect(TestCommand.new r: 10).to be
+    end
+  end
+end

data/spec/lib/domain_spec.rb

@@ -1,21 +1,21 @@
-require_relative '../spec_helper'
-
-describe ActiveEvent::Domain do
-  class TestDomain
-    include ActiveEvent::Domain
-  end
-
-  describe 'connect and run command' do
-    before :each do
-      @command = Object.new
-      @drb_object = double 'drb_object'
-    end
-
-    it 'sends command over instance' do
-      expect(DRbObject).to receive(:new_with_uri).with(TestDomain.server_uri).and_return(@drb_object)
-      expect(@command).to receive(:valid?).and_return(true)
-      expect(@drb_object).to receive(:run_command).with(@command)
-      TestDomain.run_command(@command)
-    end
-  end
-end
+require_relative '../spec_helper'
+
+describe ActiveEvent::Domain do
+  class TestDomain
+    include ActiveEvent::Domain
+  end
+
+  describe 'connect and run command' do
+    before :each do
+      @command = Object.new
+      @drb_object = double 'drb_object'
+    end
+
+    it 'sends command over instance' do
+      expect(DRbObject).to receive(:new_with_uri).with(TestDomain.server_uri).and_return(@drb_object)
+      expect(@command).to receive(:valid?).and_return(true)
+      expect(@drb_object).to receive(:run_command).with(@command)
+      TestDomain.run_command(@command)
+    end
+  end
+end

data/spec/lib/event_server_spec.rb

@@ -1,29 +1,29 @@
-require_relative '../spec_helper'
-describe ActiveEvent::EventServer do
-  class TestEvent
-  end
-  before :all do
-    @server = ActiveEvent::EventServer.instance
-    @event = TestEvent.new
-  end
-  describe 'resend_events_after' do
-    it 'starts the replay server if its not running' do
-      expect(ActiveEvent::ReplayServer).to receive(:start)
-      @server.resend_events_after(1).join
-    end
-
-    it 'updates the replay server if its running' do
-      @server.instance_variable_set(:@replay_server_thread, Thread.new {sleep 1})
-      expect(ActiveEvent::ReplayServer).to receive(:update)
-      @server.resend_events_after 1
-    end
-  end
-
-  it 'publishes an event' do
-    allow(@server).to receive(:event_exchange).and_return(Object)
-    expect(@server.event_exchange).to receive(:publish).with("Test2", {:type => "TestEvent", :headers => "Test"})
-    expect(@event).to receive(:store_infos).and_return('Test')
-    expect(@event).to receive(:to_json).and_return('Test2')
-    @server.class.publish(@event)
-  end
-end
+require_relative '../spec_helper'
+describe ActiveEvent::EventServer do
+  class TestEvent
+  end
+  before :all do
+    @server = ActiveEvent::EventServer.instance
+    @event = TestEvent.new
+  end
+  describe 'resend_events_after' do
+    it 'starts the replay server if its not running' do
+      expect(ActiveEvent::ReplayServer).to receive(:start)
+      @server.resend_events_after(1).join
+    end
+
+    it 'updates the replay server if its running' do
+      @server.instance_variable_set(:@replay_server_thread, Thread.new { sleep 1 })
+      expect(ActiveEvent::ReplayServer).to receive(:update)
+      @server.resend_events_after 1
+    end
+  end
+
+  it 'publishes an event' do
+    allow(@server).to receive(:event_exchange).and_return(Object)
+    expect(@server.event_exchange).to receive(:publish).with('Test2', type: 'TestEvent', headers: 'Test')
+    expect(@event).to receive(:store_infos).and_return('Test')
+    expect(@event).to receive(:to_json).and_return('Test2')
+    @server.class.publish(@event)
+  end
+end

data/spec/lib/event_type_spec.rb

@@ -1,38 +1,38 @@
-require_relative '../spec_helper'
-
-describe ActiveEvent::EventType do
-  class RgbColorEvent
-    include ActiveEvent::EventType
-    attributes :r, :g, :b
-  end
-
-  describe 'create instance' do
-    it 'can create an instance' do
-      expect { ActiveEvent::EventType.create_instance :RgbColorEvent, r: 10 }.to be
-    end
-
-    it 'can create events of any kind' do
-      expect { ActiveEvent::EventType.create_instance :RandomEvent, r: 10 }.to be
-    end
-  end
-
-  describe 'regular instance' do
-    before :all do
-      @color = RgbColorEvent.new r: 10, g: 20, b: 30
-    end
-
-    it 'can report type' do
-      @color.event_type.should == 'RgbColorEvent'
-    end
-  end
-
-  describe 'unknown instance' do
-    before :all do
-      @random = ActiveEvent::EventType.create_instance :RandomEvent, r: 10
-    end
-
-    it 'can report type' do
-      @random.event_type.should == 'RandomEvent'
-    end
-  end
-end
+require_relative '../spec_helper'
+
+describe ActiveEvent::EventType do
+  class RgbColorEvent
+    include ActiveEvent::EventType
+    attributes :r, :g, :b
+  end
+
+  describe 'create instance' do
+    it 'can create an instance' do
+      expect(ActiveEvent::EventType.create_instance :RgbColorEvent, r: 10).to be
+    end
+
+    it 'can create events of any kind' do
+      expect(ActiveEvent::EventType.create_instance :RandomEvent, r: 10).to be
+    end
+  end
+
+  describe 'regular instance' do
+    before :all do
+      @color = RgbColorEvent.new r: 10, g: 20, b: 30
+    end
+
+    it 'can report type' do
+      expect(@color.event_type).to eq('RgbColorEvent')
+    end
+  end
+
+  describe 'unknown instance' do
+    before :all do
+      @random = ActiveEvent::EventType.create_instance :RandomEvent, r: 10
+    end
+
+    it 'can report type' do
+      expect(@random.event_type).to eq('RandomEvent')
+    end
+  end
+end

data/spec/lib/replay_server_spec.rb

@@ -1,68 +1,71 @@
-require_relative '../spec_helper'
-describe ActiveEvent::ReplayServer do
-  class TestEvent
-  end
-  before :all do
-    @server = ActiveEvent::ReplayServer.instance
-    @event = TestEvent.new
-  end
-
-  it 'republishes an event' do
-    date = DateTime.now.utc
-    allow(@server).to receive(:resend_exchange).and_return(Object)
-    expect(@server.resend_exchange).to receive(:publish).with("{\"bla\":\"Test2\"}", {:type => "TestEvent", :headers => {id: 0, created_at: date.to_s, replayed: true}})
-    expect(@event).to receive(:event).and_return(@event.class.name)
-    expect(@event).to receive(:data).and_return(bla: 'Test2')
-    expect(@event).to receive(:id).and_return(0)
-    expect(@event).to receive(:created_at).and_return(date.to_s)
-    @server.republish(@event)
-  end
-
-  it 'starts and stop republishing events' do
-    expect(ActiveEvent::EventRepository).to receive(:after_id).and_return([1, 2, 3, 4], [])
-    expect(@server).to receive(:republish_events).once
-    @server.start_republishing
-  end
-
-  it 'republish all found events' do
-    @server.instance_variable_set(:@events, [1, 2, 3, 4])
-    expect(Thread).to receive(:pass).exactly(4).times
-    expect(@server).to receive(:next_event).exactly(4).times { @server.instance_variable_get(:@events).shift }
-    expect(@server).to receive(:republish).exactly(4).times
-    @server.republish_events
-  end
-
-  describe 'new_id?' do
-    before :each do
-      @server.instance_variable_set(:@last_id, 4)
-    end
-
-    it 'overrides id if smaller' do
-      @server.queue << 1
-      expect(@server.new_id?).to be_true
-      expect(@server.instance_variable_get(:@last_id)).to eq 1
-    end
-
-    it 'does nothing if id is greater' do
-      @server.queue << 5
-      expect(@server.new_id?).to be_false
-      expect(@server.instance_variable_get(:@last_id)).not_to eq 5
-    end
-
-    it 'does nothing if queue is empty' do
-      @server.queue.clear
-      expect(@server.new_id?).to be_false
-    end
-  end
-
-  it 'can update start id while running' do
-    expect(ActiveEvent::EventRepository).to receive(:after_id).with(1).and_return([2, 3, 4], [])
-    expect(ActiveEvent::EventRepository).to receive(:after_id).with(2).and_return([3, 4])
-    expect(@server).to receive(:next_event).exactly(3).times { @server.instance_variable_get(:@events).shift }
-    expect(@server).to receive(:republish).exactly(3).times
-    expect(Thread).to receive(:pass).exactly(3).times
-    @server.instance_variable_set(:@last_id, 2)
-    @server.queue << 1
-    @server.start_republishing
-  end
-end
+require_relative '../spec_helper'
+describe ActiveEvent::ReplayServer do
+  class TestEvent
+  end
+  before :all do
+    @server = ActiveEvent::ReplayServer.instance
+    @event = TestEvent.new
+  end
+
+  it 'republishes an event' do
+    date = DateTime.now.utc
+    allow(@server).to receive(:resend_exchange).and_return(Object)
+    expect(@server.resend_exchange).to receive(:publish).with('{"bla":"Test2"}',
+                                                              type: 'TestEvent',
+                                                              headers: {id: 0, created_at: date.to_s, replayed: true},
+                                       )
+    expect(@event).to receive(:event).and_return(@event.class.name)
+    expect(@event).to receive(:data).and_return(bla: 'Test2')
+    expect(@event).to receive(:id).and_return(0)
+    expect(@event).to receive(:created_at).and_return(date.to_s)
+    @server.republish(@event)
+  end
+
+  it 'starts and stop republishing events' do
+    expect(ActiveEvent::EventRepository).to receive(:after_id).and_return([1, 2, 3, 4], [])
+    expect(@server).to receive(:republish_events).once
+    @server.start_republishing
+  end
+
+  it 'republish all found events' do
+    @server.instance_variable_set(:@events, [1, 2, 3, 4])
+    expect(Thread).to receive(:pass).exactly(4).times
+    expect(@server).to receive(:next_event).exactly(4).times { @server.instance_variable_get(:@events).shift }
+    expect(@server).to receive(:republish).exactly(4).times
+    @server.republish_events
+  end
+
+  describe 'new_id?' do
+    before :each do
+      @server.instance_variable_set(:@last_id, 4)
+    end
+
+    it 'overrides id if smaller' do
+      @server.queue << 1
+      expect(@server.new_id?).to be_truthy
+      expect(@server.instance_variable_get(:@last_id)).to eq 1
+    end
+
+    it 'does nothing if id is greater' do
+      @server.queue << 5
+      expect(@server.new_id?).to be_falsy
+      expect(@server.instance_variable_get(:@last_id)).not_to eq 5
+    end
+
+    it 'does nothing if queue is empty' do
+      @server.queue.clear
+      expect(@server.new_id?).to be_falsy
+    end
+  end
+
+  it 'can update start id while running' do
+    expect(ActiveEvent::EventRepository).to receive(:after_id).with(1).and_return([2, 3, 4], [])
+    expect(ActiveEvent::EventRepository).to receive(:after_id).with(2).and_return([3, 4])
+    expect(@server).to receive(:next_event).exactly(3).times { @server.instance_variable_get(:@events).shift }
+    expect(@server).to receive(:republish).exactly(3).times
+    expect(Thread).to receive(:pass).exactly(3).times
+    @server.instance_variable_set(:@last_id, 2)
+    @server.queue << 1
+    @server.start_republishing
+  end
+end

data/spec/lib/support/attr_initializer_spec.rb

@@ -1,55 +1,55 @@
-require_relative '../../spec_helper'
-
-describe ActiveEvent::Support::AttrInitializer do
-  class RgbColor
-    include ActiveEvent::Support::AttrInitializer
-    attributes :r, :g, :b
-  end
-
-  describe 'constructor' do
-    it 'works for no args' do
-      expect { RgbColor.new }.to be
-    end
-
-    it 'works for defined attributes' do
-      expect { RgbColor.new r: 10, g: 20 }.to be
-    end
-
-    it 'fails for undeclared attributes' do
-      expect { RgbColor.new z: 10 }.to raise_error(ActiveEvent::Support::UnknownAttributeError)
-    end
-
-    it 'fails for unauthorized hash' do
-      class CheckedHash < Hash
-        def permitted?
-          false
-        end
-      end
-      expect { RgbColor.new(CheckedHash.new.merge! r: 1) }.to raise_error(ActiveEvent::Support::ForbiddenAttributesError)
-    end
-  end
-
-  describe 'instance' do
-    before :all do
-      @color = RgbColor.new r: 10, g: 20
-    end
-
-    it 'can retrieve attributes' do
-      @color.r.should == 10
-      @color.g.should == 20
-      @color.b.should be_nil
-    end
-
-    it 'can filter attributes' do
-      @color.attributes_except(:r).should eq(g: 20)
-    end
-
-    it 'can convert to hash' do
-      @color.to_hash.should eq(r: 10, g: 20)
-    end
-
-    it 'is read only' do
-      expect { @color.r = 20 }.to raise_error
-    end
-  end
-end
+require_relative '../../spec_helper'
+
+describe ActiveEvent::Support::AttrInitializer do
+  class RgbColor
+    include ActiveEvent::Support::AttrInitializer
+    attributes :r, :g, :b
+  end
+
+  describe 'constructor' do
+    it 'works for no args' do
+      expect(RgbColor.new).to be
+    end
+
+    it 'works for defined attributes' do
+      expect(RgbColor.new r: 10, g: 20).to be
+    end
+
+    it 'fails for undeclared attributes' do
+      expect { RgbColor.new z: 10 }.to raise_error(ActiveEvent::Support::UnknownAttributeError)
+    end
+
+    it 'fails for unauthorized hash' do
+      class CheckedHash < Hash
+        def permitted?
+          false
+        end
+      end
+      expect { RgbColor.new(CheckedHash.new.merge! r: 1) }.to raise_error(ActiveEvent::Support::ForbiddenAttributesError)
+    end
+  end
+
+  describe 'instance' do
+    before :all do
+      @color = RgbColor.new r: 10, g: 20
+    end
+
+    it 'can retrieve attributes' do
+      expect(@color.r).to eq(10)
+      expect(@color.g).to eq(20)
+      expect(@color.b).to be_nil
+    end
+
+    it 'can filter attributes' do
+      expect(@color.attributes_except(:r)).to eq(g: 20)
+    end
+
+    it 'can convert to hash' do
+      expect(@color.to_hash).to eq(r: 10, g: 20)
+    end
+
+    it 'is read only' do
+      expect { @color.r = 20 }.to raise_error
+    end
+  end
+end