celluloid_pubsub 1.1.2 → 2.0.0

data/spec/lib/celluloid_pubsub/base_actor_spec.rb

@@ -0,0 +1,78 @@
+# encoding:utf-8
+
+require 'spec_helper'
+
+describe CelluloidPubsub::BaseActor do
+  let(:actor) { TestActor.new }
+  subject { actor.own_self }
+
+  it 'returns the self' do
+    expect(actor.own_self.class.name).to eq('TestActor')
+    expect(actor.own_self).to_not respond_to(:mailbox)
+  end
+
+  it 'returns the actor' do
+    expect(actor.cell_actor).to respond_to(:mailbox)
+  end
+
+  it 'returns true if action subscribe' do
+    expect(subject.send(:action_subscribe?, 'subscribe')).to eq(true)
+  end
+
+  describe '#parse_options' do
+    it 'returns empty hash for null value' do
+      expect(subject.send(:parse_options, nil)).to eq({})
+    end
+    it 'returns empty hash for null value' do
+      expect(subject.send(:parse_options, [{ a: 1 }, { b: 2 }])).to eq('b' => 2)
+    end
+  end
+
+  describe 'booting up' do
+    it 'does not boot if already running' do
+      allow(Celluloid).to receive(:running?).and_return(true)
+      expect(Celluloid).to_not receive(:boot)
+      CelluloidPubsub::BaseActor.boot_up
+    end
+
+    it 'boos if not running' do
+      allow(Celluloid).to receive(:running?).and_return(false)
+      expect(Celluloid).to receive(:boot)
+      CelluloidPubsub::BaseActor.boot_up
+    end
+
+    it 'boos if running? returns error ' do
+      allow(Celluloid).to receive(:running?).and_raise(RuntimeError)
+      expect(Celluloid).to receive(:boot)
+      begin
+        CelluloidPubsub::BaseActor.boot_up
+      rescue RuntimeError => e
+      end
+    end
+  end
+
+  describe 'fetch_gem_version' do
+    let(:gem_name) { 'rails' }
+    let(:version) { '1.2.3' }
+
+    it 'returns the loaded gem version' do
+      expect(subject).to receive(:find_loaded_gem_property).with(gem_name).and_return(nil)
+      result = actor.send(:fetch_gem_version, gem_name)
+      expect(result).to eq(nil)
+    end
+
+    it 'returns the loaded gem version' do
+      expected = 1.2
+      expect(subject).to receive(:find_loaded_gem_property).with(gem_name).and_return(version)
+      expect(subject).to receive(:get_parsed_version).with(version).and_return(expected)
+      result = actor.send(:fetch_gem_version, gem_name)
+      expect(result).to eq(expected)
+    end
+  end
+  describe 'filtered_error?' do
+    it 'filters the interrupt exception' do
+      error = Interrupt.new
+      expect(actor.send(:filtered_error?, error)).to eq(true)
+    end
+  end
+end

data/spec/lib/celluloid_pubsub/client_pubsub_spec.rb

@@ -5,27 +5,29 @@ require 'spec_helper'
 describe CelluloidPubsub::Client do
   let(:blk) { proc { |a| puts a } }
   let(:options) { {} }
-  let(:actor) { mock }
-  let(:connection) { mock }
+  let(:actor) { double('actor') }
+  let(:connection) { double('connection') }
   let(:channel) { 'some_channel' }
+  let(:additional_options) { {} }
 
   before(:each) do
-    CelluloidPubsub::Client.any_instance.stubs(:supervise_actors).returns(true)
-    CelluloidPubsub::Client.any_instance.stubs(:connection).returns(connection)
-    @worker = CelluloidPubsub::Client.new(actor: actor, channel: channel, enable_debug: false)
-    @worker.stubs(:debug).returns(true)
-    @worker.stubs(:async).returns(@worker)
-    actor.stubs(:async).returns(actor)
-    actor.stubs(:respond_to?).returns(false)
-    actor.stubs(:terminate).returns(true)
-    connection.stubs(:terminate).returns(true)
-    connection.stubs(:text).returns(true)
+    allow_any_instance_of(CelluloidPubsub::Client).to receive(:supervise_actors).and_return(true)
+    allow_any_instance_of(CelluloidPubsub::Client).to receive(:connection).and_return(connection)
+    allow(actor).to receive(:async).and_return(actor)
+    allow(actor).to receive(:terminate).and_return(true)
+    allow(connection).to receive(:terminate).and_return(true)
+    allow(connection).to receive(:text).and_return(true)
+    allow(connection).to receive(:alive?).and_return(true)
+    @worker = CelluloidPubsub::Client.new(additional_options.merge(actor: actor, channel: channel, enable_debug: false))
+    @own_self = @worker.own_self
+    allow(@own_self).to receive(:debug).and_return(true)
+    allow(@own_self).to receive(:async).and_return(@worker)
   end
 
   describe '#initialize' do
     it 'creates a object' do
-      expect(@worker.channel).to eq channel
-      expect(@worker.actor).to eq actor
+      expect(@own_self.channel).to eq channel
+      expect(@own_self.actor).to eq actor
     end
   end
 
@@ -63,30 +65,29 @@ describe CelluloidPubsub::Client do
   describe '#subscribe' do
     let(:channel) { 'some_channel' }
     it 'chats with the server' do
-      @worker.expects(:chat).with('client_action' => 'subscribe', 'channel' => channel)
+      expect(@own_self).to receive(:chat).with('client_action' => 'subscribe', 'channel' => channel)
       @worker.subscribe(channel)
     end
   end
 
   describe '#succesfull_subscription?' do
-    let(:message) { mock }
-    let(:action) { mock }
+    let(:message) { double(present?: true) }
+    let(:action) { double }
 
     before(:each) do
-      message.stubs(:present?).returns(true)
-      message.stubs(:[]).with('client_action').returns('successful_subscription')
+      allow(message).to receive(:[]).with('client_action').and_return('successful_subscription')
     end
 
     it 'checks the message and returns true' do
-      message.expects(:is_a?).with(Hash).returns(true)
-      message.stubs(:[]).with('client_action').returns('successful_subscription')
+      expect(message).to receive(:is_a?).with(Hash).and_return(true)
+      allow(message).to receive(:[]).with('client_action').and_return('successful_subscription')
       actual = @worker.succesfull_subscription?(message)
       expect(actual).to eq(true)
     end
 
     it 'checks the message and returns false' do
-      message.expects(:is_a?).with(Hash).returns(true)
-      message.stubs(:[]).with('client_action').returns('something_else')
+      expect(message).to receive(:is_a?).with(Hash).and_return(true)
+      allow(message).to receive(:[]).with('client_action').and_return('something_else')
       actual = @worker.succesfull_subscription?(message)
       expect(actual).to eq(false)
     end
@@ -96,16 +97,59 @@ describe CelluloidPubsub::Client do
     let(:channel) { 'some_channel' }
     let(:data) { 'some_message' }
     it 'chats with the server' do
-      @worker.expects(:send_action).with('publish', channel, data)
+      expect(@own_self).to receive(:send_action).with('publish', channel, data)
       @worker.publish(channel, data)
     end
   end
 
+  describe '#unsubscribe' do
+    let(:channel) { 'some_channel' }
+    it 'chats with the server' do
+      expect(@own_self).to receive(:send_action).with('unsubscribe', channel)
+      @worker.unsubscribe(channel)
+    end
+  end
+
+  describe '#unsubscribe_clients' do
+    let(:channel) { 'some_channel' }
+    it 'chats with the server' do
+      expect(@own_self).to receive(:send_action).with('unsubscribe_clients', channel)
+      @worker.unsubscribe_clients(channel)
+    end
+  end
+
+  describe '#unsubscribe_all' do
+    it 'chats with the server' do
+      expect(@own_self).to receive(:send_action).with('unsubscribe_all')
+      @worker.unsubscribe_all
+    end
+  end
+
+  describe '#supervise_actors' do
+    before do
+      allow_any_instance_of(CelluloidPubsub::Client).to receive(:supervise_actors).and_call_original
+    end
+
+    it 'supervises the actor' do
+      allow(actor).to receive(:respond_to?).with(:link).and_return(true)
+      expect(actor).to receive(:link).with(@worker)
+      expect(@worker).to receive(:link).with(connection)
+      @worker.supervise_actors
+    end
+
+    it 'does not link the actor if not possible' do
+      allow(actor).to receive(:respond_to?).with(:link).and_return(false)
+      expect(actor).to_not receive(:link).with(@worker)
+      expect(@worker).to receive(:link).with(connection)
+      @worker.supervise_actors
+    end
+  end
+
   describe '#on_open' do
     let(:channel) { 'some_channel' }
     let(:data) { 'some_message' }
     it 'chats with the server' do
-      @worker.expects(:subscribe).with(channel)
+      expect(@own_self).to receive(:subscribe).with(channel)
       @worker.on_open
     end
   end
@@ -114,17 +158,17 @@ describe CelluloidPubsub::Client do
     let(:channel) { 'some_channel' }
     let(:data) { 'some_message' }
     it 'chats with the server' do
-      JSON.expects(:parse).with(data).returns(data)
-       @worker.actor.expects(:respond_to?).returns(true)
-      @worker.actor.expects(:async).returns(actor)
-      @worker.actor.expects(:on_message).with(data)
+      expect(JSON).to receive(:parse).with(data).and_return(data)
+      expect(@own_self.actor).to receive(:respond_to?).and_return(true)
+      expect(@own_self.actor).to receive(:async).and_return(actor)
+      expect(@own_self.actor).to receive(:on_message).with(data)
       @worker.on_message(data)
     end
 
     it 'chats with the server without async' do
-      JSON.expects(:parse).with(data).returns(data)
-       @worker.actor.expects(:respond_to?).returns(false)
-       @worker.actor.expects(:on_message).with(data)
+      expect(JSON).to receive(:parse).with(data).and_return(data)
+      expect(@own_self.actor).to receive(:respond_to?).and_return(false)
+      expect(@own_self.actor).to receive(:on_message).with(data)
       @worker.on_message(data)
     end
   end
@@ -135,7 +179,13 @@ describe CelluloidPubsub::Client do
     let(:reason) { 'some_reason' }
 
     it 'chats with the server' do
-      actor.expects(:on_close).with(code, reason).returns(true)
+      expect(actor).to receive(:on_close).with(code, reason).and_return(true)
+      @worker.on_close(code, reason)
+    end
+
+    it 'chats with the server' do
+      expect(actor).to receive(:respond_to?).with(:async).and_return(false)
+      expect(actor).to receive(:on_close).with(code, reason).and_return(true)
       @worker.on_close(code, reason)
     end
   end
@@ -145,15 +195,96 @@ describe CelluloidPubsub::Client do
     let(:data) { 'some_message' }
     let(:data_hash) { { a: 'some mesage ' } }
     let(:json) { { action: 'message', message: data } }
-    it 'chats witout hash' do
-      JSON.expects(:dump).with(json).returns(json)
-      connection.expects(:text).with(json)
+    it 'chats without hash' do
+      expect(JSON).to receive(:dump).with(json).and_return(json)
+      expect(connection).to receive(:text).with(json)
       @worker.send(:chat, data)
     end
 
     it 'chats with a hash' do
-      connection.expects(:text).with(data_hash.to_json)
+      expect(connection).to receive(:text).with(data_hash.to_json)
       @worker.send(:chat, data_hash)
     end
   end
+
+  describe 'shutting_down?' do
+    it 'returns false by default' do
+      expect(@worker.shutting_down?).to eq(false)
+    end
+
+    it 'returns true' do
+      allow(@own_self).to receive(:terminate).and_return(true)
+      expect { @worker.shutdown }.to change(@worker, :shutting_down?).from(false).to(true)
+    end
+
+    it 'returns true when actor dies' do
+      allow(@own_self).to receive(:shutdown).and_return(true)
+      allow(@worker).to receive(:hostname).and_raise(RuntimeError)
+      begin
+        expect { @worker.hostname }.to change(@worker, :shutting_down?).from(false).to(true)
+      rescue RuntimeError => e
+        # do nothing
+      end
+    end
+  end
+
+  describe 'log_file_path' do
+    it 'returns nil by default' do
+      expect(@worker.log_file_path).to eq(nil)
+    end
+
+    context 'when log file path is defined' do
+      let(:path) { '/some-path-here' }
+      let(:additional_options) { { log_file_path: path } }
+
+      it 'returns the path' do
+        expect(@worker.log_file_path).to eq(path)
+      end
+    end
+  end
+
+  describe 'log_level' do
+    it 'returns info by default' do
+      expect(@worker.log_level).to eq(::Logger::Severity::INFO)
+    end
+
+    context 'when log level is defined' do
+      let(:level) { Logger::Severity::DEBUG }
+      let(:additional_options) { { log_level: level } }
+
+      it 'returns the path' do
+        expect(@worker.log_level).to eq(level)
+      end
+    end
+  end
+
+  describe 'path' do
+    it 'returns the path of the server' do
+      expect(@worker.path).to eq(CelluloidPubsub::WebServer::PATH)
+    end
+
+    context 'when path is defined' do
+      let(:path) { '/demo' }
+      let(:additional_options) { { path: path } }
+
+      it 'returns the path' do
+        expect(@worker.path).to eq(path)
+      end
+    end
+  end
+
+  describe 'connection' do
+    it 'returns the path of the server' do
+      allow_any_instance_of(CelluloidPubsub::Client).to receive(:connection).and_call_original
+      expect(CelluloidPubsub::ClientConnection).to receive(:new).with("ws://#{@worker.hostname}:#{@worker.port}#{@worker.path}", @worker).and_return(connection)
+      result = @worker.connection
+      expect(result).to eq(connection)
+    end
+  end
+
+  describe 'actor_died' do
+    it 'sets the shutting down' do
+      expect { @worker.send(:actor_died, @worker, nil) }.to change(@worker, :shutting_down?).from(false).to(true)
+    end
+  end
 end

data/spec/lib/celluloid_pubsub/reactor_spec.rb

@@ -3,39 +3,62 @@
 require 'spec_helper'
 
 describe CelluloidPubsub::Reactor do
-  let(:websocket) { mock }
-  let(:server) { mock }
-  let(:mutex) { mock }
-  let(:synchronizer) { mock }
+  let(:websocket) do
+    double(
+      'websocket',
+      url: nil,
+      read: nil,
+      close: nil,
+      closed?: false,
+      present?: false
+    )
+  end
+  let(:server_options) { {}.with_indifferent_access }
+  let(:server) do
+    double(
+      'server',
+      debug_enabled?: false,
+      adapter: CelluloidPubsub::WebServer::CLASSIC_ADAPTER,
+      server_options: server_options,
+      dead?: false,
+      subscribers: {},
+      handle_dispatched_message: nil,
+      mutex: mutex,
+      timers_mutex: timers_mutex, 
+      reactors: []
+    )
+  end
+  let(:mutex) { double('mutex') }
+  let(:synchronizer) { double('synchronizer') }
+  let(:timers_mutex) { double('timers_mutex') }
+  let(:timers_synchronizer) { double('timers_synchronizer') }
 
   before(:each) do
-    subject.stubs(:async).returns(subject)
-    server.stubs(:debug_enabled?).returns(false)
-    server.stubs(:async).returns(server)
-    server.stubs(:handle_dispatched_message)
-    server.stubs(:subscribers).returns({})
-    server.stubs(:adapter).returns(CelluloidPubsub::WebServer::CLASSIC_ADAPTER)
-    websocket.stubs(:read)
-    websocket.stubs(:url)
-    websocket.stubs(:close)
-    websocket.stubs(:closed?).returns(false)
-    server.stubs(:dead?).returns(false)
-    subject.stubs(:inspect).returns(subject)
-    subject.stubs(:run)
-    subject.work(websocket, server)
-    subject.stubs(:unsubscribe_from_channel).returns(true)
-    server.stubs(:mutex).returns(mutex)
-    mutex.stubs(:synchronize).yields(server)
-    Celluloid::Actor.stubs(:kill).returns(true)
+    allow(server).to receive(:async).and_return(server)
+    allow(actor).to receive(:async).and_return(actor)
+    allow(actor).to receive(:inspect).and_return(actor)
+    allow(actor).to receive(:run)
+    allow(actor).to receive(:unsubscribe_from_channel).and_return(true)
+    allow(mutex).to receive(:synchronize).and_yield
+    allow(timers_mutex).to receive(:synchronize).and_yield
+    allow(Celluloid::Actor).to receive(:kill).and_return(true)
+    allow_any_instance_of(CelluloidPubsub::Reactor).to receive(:shutdown).and_return(true)
+  end
+
+  after(:each) do
+    Celluloid.shutdown
   end
 
+  let(:actor) { CelluloidPubsub::Reactor.new.initialize_data(websocket, server) }
+  subject { actor.own_self }
+
   describe '#work' do
     it 'works ' do
-      subject.expects(:run)
-      subject.work(websocket, server)
-      expect(subject.websocket).to eq websocket
-      expect(subject.server).to eq server
-      expect(subject.channels).to eq []
+      expect(actor).to receive(:run)
+      actor.work(websocket, server)
+      expect(actor.websocket).to eq(websocket)
+      expect(actor.server).to eq(server)
+      expect(actor.channels).to eq([])
     end
   end
 
@@ -43,10 +66,10 @@ describe CelluloidPubsub::Reactor do
   #    let(:data) { 'some message' }
   #
   #    it 'works ' do
-  #      subject.unstub(:run)
-  #      websocket.stubs(:read).returns(data)
-  #        subject.expects(:handle_websocket_message).with(data)
-  #      subject.run
+  #      actor.unstub(:run)
+  #      allow(websocket).to receive(:read).and_return(data)
+  #        expect(subject).to receive(:handle_websocket_message).with(data)
+  #      actor.run
   #    end
   #  end
 
@@ -55,14 +78,14 @@ describe CelluloidPubsub::Reactor do
     let(:expected) { data.to_json }
 
     it 'works with hash ' do
-      JSON.expects(:parse).with(data).returns(expected)
-      actual = subject.parse_json_data(data)
+      expect(JSON).to receive(:parse).with(data).and_return(expected)
+      actual = actor.parse_json_data(data)
       expect(actual).to eq expected
     end
 
     it 'works with exception parsing  ' do
-      JSON.expects(:parse).with(data).raises(StandardError)
-      actual = subject.parse_json_data(data)
+      expect(JSON).to receive(:parse).with(data).and_raise(StandardError)
+      actual = actor.parse_json_data(data)
       expect(actual).to eq data
     end
   end
@@ -72,96 +95,91 @@ describe CelluloidPubsub::Reactor do
     let(:json_data) { { a: 'b' } }
 
     it 'handle_websocket_message' do
-      subject.expects(:parse_json_data).with(data).returns(json_data)
-      subject.expects(:handle_parsed_websocket_message).with(json_data)
-      subject.handle_websocket_message(data)
+      expect(subject).to receive(:parse_json_data).with(data).and_return(json_data)
+      expect(subject).to receive(:handle_parsed_websocket_message).with(json_data)
+      actor.handle_websocket_message(data)
     end
   end
 
   describe '#handle_parsed_websocket_message' do
     it 'handle_websocket_message with a hash' do
-      data = { 'client_action' => 'subscribe' }
-      data.expects(:stringify_keys).returns(data)
-      subject.expects(:delegate_action).with(data)
-      subject.handle_parsed_websocket_message(data)
+      data = { 'client_action' => 'subscribe', 'channel' => 'test' }
+      expect(data).to receive(:stringify_keys).and_return(data)
+      expect(subject).to receive(:delegate_action).with(data).and_return(true)
+      actor.handle_parsed_websocket_message(data)
     end
 
     it 'handle_websocket_message with something else than a hash' do
-      data = { 'message'=> 'some message' }
-      subject.expects(:handle_unknown_action).with(data['channel'], data)
-      subject.handle_parsed_websocket_message(data)
+      data = { 'message' => 'some message' }
+      expect(subject).to receive(:handle_unknown_action).with(data['channel'], data).and_return(true)
+      actor.handle_parsed_websocket_message(data)
     end
   end
 
   describe '#delegate_action' do
-
     before(:each) do
-      subject.stubs(:unsubscribe_clients).returns(true)
-      subject.stubs(:shutdown).returns(true)
+      allow(subject).to receive(:unsubscribe_clients).and_return(true)
+      allow(subject).to receive(:shutdown).and_return(true)
     end
 
     it 'unsubscribes all' do
       data = { 'client_action' => 'unsubscribe_all', 'channel' => '' }
-      subject.expects(:send).with(data['client_action'], data['channel'], data).returns('bla')
-      subject.delegate_action(data)
+      expect(subject).to receive(:send).with(data['client_action'], data['channel'], data).and_return('bla')
+      actor.delegate_action(data)
     end
 
     it 'unsubscribes all' do
       data = { 'client_action' => 'unsubscribe', 'channel' => 'some channel' }
-      subject.expects(:send).with(data['client_action'], data['channel'], data)
-      subject.delegate_action(data)
+      expect(subject).to receive(:send).with(data['client_action'], data['channel'], data)
+      actor.delegate_action(data)
     end
-    #
     it 'subscribes to channell' do
       data = { 'client_action' => 'subscribe', 'channel' => 'some channel' }
-      subject.expects(:send).with(data['client_action'], data['channel'], data)
-      subject.delegate_action(data)
+      expect(subject).to receive(:send).with(data['client_action'], data['channel'], data)
+      actor.delegate_action(data)
     end
 
     it 'publish' do
       data = { 'client_action' => 'publish', 'channel' => 'some channel', 'data' => 'some data' }
-      subject.expects(:send).with(data['client_action'], data['channel'], data)
-      subject.delegate_action(data)
+      expect(subject).to receive(:send).with(data['client_action'], data['channel'], data)
+      actor.delegate_action(data)
     end
   end
-  #
   describe '#handle_unknown_action' do
     it 'handles unknown' do
       data = 'some data'
-      channel = "some_channel"
-      server.expects(:handle_dispatched_message)
-      subject.handle_unknown_action(channel, data)
+      channel = 'some_channel'
+      expect(server).to receive(:handle_dispatched_message)
+      actor.handle_unknown_action(channel, data)
     end
   end
 
   describe '#unsubscribe_client' do
     let(:channel) { 'some channel' }
-    let(:data) { {'client_action' => 'unsubscribe', 'channel' => channel } }
+    let(:data) { { 'client_action' => 'unsubscribe', 'channel' => channel } }
     it 'returns nil' do
-      act = subject.unsubscribe('', data)
+      act = actor.unsubscribe('', data)
       expect(act).to eq(nil)
     end
 
     it 'unsubscribes' do
-      channel.stubs(:present?).returns(true)
-      subject.expects(:forget_channel).with(channel)
-      subject.expects(:delete_server_subscribers).with(channel)
-      act = subject.unsubscribe(channel, data)
+      allow(channel).to receive(:present?).and_return(true)
+      expect(subject).to receive(:forget_channel).with(channel)
+      expect(subject).to receive(:delete_server_subscribers).with(channel)
+      act = actor.unsubscribe(channel, data)
       expect(act).to eq(nil)
     end
-
-
   end
 
   describe '#delete_server_subscribers' do
     let(:channel) { 'some channel' }
 
     before(:each) do
-      server.stubs(:subscribers).returns("#{channel}" => [{ reactor: subject }])
+      allow(server).to receive(:subscribers).and_return(channel.to_s => [{ reactor: actor }])
     end
 
     it 'unsubscribes' do
-      act = subject.delete_server_subscribers(channel)
+      act = actor.delete_server_subscribers(channel)
       expect(server.subscribers[channel]).to eq([])
     end
   end
@@ -170,25 +188,29 @@ describe CelluloidPubsub::Reactor do
     let(:channel) { 'some channel' }
 
     it 'unsubscribes' do
-      subject.channels.stubs(:blank?).returns(true)
-      subject.websocket.expects(:close)
-      act = subject.forget_channel(channel)
+      allow(actor.channels).to receive(:blank?).and_return(true)
+      expect(actor.websocket).to receive(:close)
+      act = actor.forget_channel(channel)
       expect(act).to eq(nil)
     end
 
     it 'unsubscribes' do
-      subject.channels.stubs(:blank?).returns(false)
-      subject.channels.expects(:delete).with(channel)
-    #  server.stubs(:subscribers).returns("#{channel}" => [{ reactor: subject }])
-      subject.forget_channel(channel)
-    #  expect(server.subscribers[channel]).to eq([])
+      allow(actor.channels).to receive(:blank?).and_return(false)
+      expect(actor.channels).to receive(:delete).with(channel)
+      #  allow(server).to receive(:subscribers).and_return("#{channel}" => [{ reactor: subject }])
+      actor.forget_channel(channel)
+      #  expect(server.subscribers[channel]).to eq([])
     end
   end
 
   describe '#shutdown' do
+    before(:each)  do
+      allow_any_instance_of(CelluloidPubsub::Reactor).to receive(:shutdown).and_call_original
+    end
+
     it 'shutdowns' do
-      subject.expects(:terminate)
-      subject.shutdown
+      expect(subject).to receive(:terminate).at_least(:once)
+      actor.shutdown
     end
   end
 
@@ -197,22 +219,22 @@ describe CelluloidPubsub::Reactor do
     let(:message) { { a: 'b' } }
 
     it 'subscribes ' do
-      act = subject.subscribe('', message)
+      act = actor.subscribe('', message)
       expect(act).to eq(nil)
     end
 
     it 'subscribes ' do
-      subject.stubs(:add_subscriber_to_channel).with(channel, message)
-      server.stubs(:redis_enabled?).returns(false)
-      subject.websocket.expects(:<<).with(message.merge('client_action' => 'successful_subscription', 'channel' => channel).to_json)
-      subject.subscribe(channel, message)
+      allow(subject).to receive(:add_subscriber_to_channel).with(channel, message)
+      allow(server).to receive(:redis_enabled?).and_return(false)
+      expect(actor.websocket).to receive(:<<).with(message.merge('client_action' => 'successful_subscription', 'channel' => channel).to_json)
+      actor.subscribe(channel, message)
     end
 
     #    it 'raises error' do
-    #      subject.stubs(:add_subscriber_to_channel).raises(StandardError)
+    #      subject).to receive(:add_subscriber_to_channel).raises(StandardError)
     #
     #      expect do
-    #        subject.start_subscriber(channel, message)
+    #        actor.start_subscriber(channel, message)
     #      end.to raise_error(StandardError) { |e|
     #        expect(e.message).to include(channel)
     #      }
@@ -222,15 +244,15 @@ describe CelluloidPubsub::Reactor do
   describe '#add_subscriber_to_channel' do
     let(:channel) { 'some channel' }
     let(:message) { { a: 'b' } }
-    let(:subscribers) { mock }
+    let(:subscribers) { double }
 
     it 'adds subscribed' do
-      CelluloidPubsub::Registry.channels.stubs(:include?).with(channel).returns(false)
-      CelluloidPubsub::Registry.channels.expects(:<<).with(channel)
-      subject.expects(:channel_subscribers).with(channel).returns(subscribers)
-      subscribers.expects(:push).with(reactor: subject, message: message)
-      subject.add_subscriber_to_channel(channel, message)
-      expect(subject.channels).to include(channel)
+      allow(CelluloidPubsub::Registry.channels).to receive(:include?).with(channel).and_return(false)
+      expect(CelluloidPubsub::Registry.channels).to receive(:<<).with(channel)
+      expect(subject).to receive(:channel_subscribers).with(channel).and_return(subscribers)
+      expect(subscribers).to receive(:push).with(reactor: actor, message: message)
+      actor.add_subscriber_to_channel(channel, message)
+      expect(actor.channels).to include(channel)
     end
   end
 
@@ -239,9 +261,262 @@ describe CelluloidPubsub::Reactor do
     let(:message) { { a: 'b' } }
 
     it 'adds subscribed' do
-      CelluloidPubsub::Registry.stubs(:channels).returns([channel])
-      subject.expects(:unsubscribe_from_channel).with(channel).returns(true)
-      subject.unsubscribe_all(channel, message)
+      allow(CelluloidPubsub::Registry).to receive(:channels).and_return([channel])
+      expect(subject).to receive(:unsubscribe_from_channel).with(channel).and_return(true)
+      actor.unsubscribe_all(channel, message)
+    end
+  end
+
+  describe 'log_file_path' do
+    it 'returns nil by default' do
+      expect(actor.log_file_path).to eq(nil)
+    end
+
+    context 'when log file path is defined' do
+      let(:path) { '/some-path-here' }
+      let(:server_options) { { log_file_path: path }.with_indifferent_access }
+
+      it 'returns the path' do
+        expect(actor.log_file_path).to eq(path)
+      end
+    end
+  end
+
+  describe 'log_level' do
+    it 'returns info by default' do
+      expect(actor.log_level).to eq(::Logger::Severity::INFO)
+    end
+
+    context 'when log level is defined' do
+      let(:level) { Logger::Severity::DEBUG }
+      let(:server_options) { { log_level: level }.with_indifferent_access }
+
+      it 'returns the path' do
+        expect(actor.log_level).to eq(level)
+      end
+    end
+  end
+
+  describe 'adapter options' do
+    it 'returns info by default' do
+      expect(actor.adapter_options).to eq({})
+    end
+
+    context 'when log level is defined' do
+      let(:adapter_options) { { something: :here, another: { key: :value } } }
+      let(:server_options) { { adapter_options: adapter_options }.with_indifferent_access }
+
+      it 'returns the path' do
+        expect(actor.adapter_options).to eq(adapter_options.deep_stringify_keys)
+      end
+    end
+  end
+
+  describe 'shutting_down?' do
+    before(:each)  do
+      allow_any_instance_of(CelluloidPubsub::Reactor).to receive(:shutdown).and_call_original
+    end
+
+    it 'returns false by default' do
+      expect(actor.shutting_down?).to eq(false)
+    end
+
+    it 'returns true' do
+      allow(subject).to receive(:terminate).and_return(true)
+      expect { actor.shutdown }.to change(actor, :shutting_down?).from(false).to(true)
+    end
+
+    it 'returns true when actor dies' do
+      allow(subject).to receive(:shutdown).and_return(true)
+      allow(actor).to receive(:log_level).and_raise(RuntimeError)
+      begin
+        expect { actor.log_level }.to change(actor, :shutting_down?).from(false).to(true)
+      rescue RuntimeError => e
+        # do nothing
+      end
+    end
+  end
+
+  describe 'try_read_websocket' do
+    it 'returns nil if socket closed' do
+      allow(websocket).to receive(:closed?).and_return(true)
+      expect(websocket).to_not receive(:read)
+      result = actor.try_read_websocket
+      expect(result).to eq(nil)
+    end
+
+    it 'reads the socket' do
+      expected = 'something'
+      allow(websocket).to receive(:closed?).and_return(false)
+      expect(websocket).to receive(:read).and_return(expected)
+      result = actor.try_read_websocket
+      expect(result).to eq(expected)
+    end
+
+    it 'returns nil if socket closed' do
+      allow(websocket).to receive(:closed?).and_return(false)
+      expect(websocket).to receive(:read).and_raise(StandardError)
+      result = actor.try_read_websocket
+      expect(result).to eq(nil)
+    end
+  end
+
+  describe 'send_unpublshed' do
+    let(:channel) { 'test' }
+    let(:messages) { [1, 2, 3] }
+
+    it 'does not send if no messages' do
+      allow(subject).to receive(:unpublished_messages).with(channel).and_return(nil)
+      expect(websocket).to_not receive(:<<)
+      subject.send_unpublished(channel)
+    end
+
+    it 'sends the messages' do
+      allow(subject).to receive(:unpublished_messages).with(channel).and_return(messages)
+      messages.each do |msg|
+        expect(websocket).to receive(:<<).ordered.with(msg.to_json)
+      end
+      subject.send_unpublished(channel)
+    end
+  end
+
+  describe 'clears the messages' do
+    let(:channel) { 'test' }
+    let(:messages) { [1, 2, 3] }
+
+    before do
+      CelluloidPubsub::Registry.messages[channel] = messages
+    end
+
+    after do
+      CelluloidPubsub::Registry.messages = {}
+    end
+
+    it 'clears the messages' do
+      actor.clear_unpublished_messages(channel)
+      expect(CelluloidPubsub::Registry.messages).to eq(channel => [])
+    end
+  end
+
+  describe 'unpublished_messages' do
+    let(:channel) { 'test' }
+    let(:messages) { [1, 2, 3] }
+
+    before do
+      CelluloidPubsub::Registry.messages[channel] = messages
+    end
+
+    after do
+      CelluloidPubsub::Registry.messages = {}
+    end
+
+    it 'retrieves the messages' do
+      result = actor.unpublished_messages(channel)
+      expect(result).to eq(messages)
+    end
+
+    it 'returns empty array for non existing channel' do
+      result = actor.unpublished_messages('something-here')
+      expect(result).to eq([])
+    end
+  end
+
+  describe 'subscribers' do
+    let(:channel) { 'test' }
+    before do
+      server.subscribers[channel] = [{ reactor: actor }]
+    end
+
+    it 'returns empty array' do
+      result = actor.channel_subscribers('some-channel')
+      expect(result).to eq([])
+    end
+
+    it 'returns the subscribers' do
+      result = actor.channel_subscribers(channel)
+      expect(result).to eq([{ reactor: actor }])
+    end
+  end
+
+  describe 'publish' do
+    let(:channel) { 'test' }
+    let(:data) { { 'client_action' => 'publish', 'channel' => 'test_channel', 'data' => { 'data' => ' my_message' } } }
+
+    it 'publishes the message' do
+      expect(subject).to receive(:server_publish_event).with(channel, data['data'].to_json)
+      actor.publish(channel, data)
+    end
+
+    it 'does not publish if channel is blank' do
+      expect(subject).to_not receive(:server_publish_event)
+      actor.publish(nil, data)
+    end
+
+    it 'publishes null' do
+      expect(subject).to receive(:server_publish_event).with(channel, 'null')
+      actor.publish(channel, data.except('data'))
+    end
+
+    it 'catches error' do
+      expect(subject).to receive(:server_publish_event).and_raise(StandardError)
+      expect(subject).to receive(:log_debug)
+      actor.publish(channel, data.except('data'))
+    end
+  end
+
+  describe 'server_publish_event' do
+    let(:actor2) { CelluloidPubsub::Reactor.new.initialize_data(websocket, server) }
+    let(:subject2) { actor2.own_self }
+
+    let(:channel) { 'test' }
+    let(:message) { '1' }
+    before do
+      server.subscribers[channel] = [{ reactor: actor }, { reactor: actor2 }]
+    end
+
+    it 'published message to channel' do
+      server.subscribers[channel].each do |hash|
+        expect(hash[:reactor].websocket).to receive(:<<).with(message)
+      end
+      actor.server_publish_event(channel, message)
+    end
+
+    it 'saves the mesages if no subscribers' do
+      channel2 = 'some-channel'
+      expect(subject).to receive(:save_unpublished_message).with(channel2, message).and_call_original
+      actor.server_publish_event(channel2, message)
+      expect(CelluloidPubsub::Registry.messages).to eq(channel2 => [message])
+    end
+  end
+  describe 'unsubscribe_from_channel' do
+    let(:channel) { 'test' }
+    it 'kills the reactors' do
+      expect(subject).to receive(:server_kill_reactors).with(channel)
+      subject.unsubscribe_from_channel(channel)
+    end
+  end
+
+  describe 'server_kill_reactors' do
+    let(:actor2) { CelluloidPubsub::Reactor.new.initialize_data(websocket, server) }
+    let(:subject2) { actor2.own_self }
+
+    let(:channel) { 'test' }
+
+    before do
+      server.subscribers[channel] = [{ reactor: actor }, { reactor: actor2 }]
+    end
+
+    it 'kills the reactors' do
+      server.subscribers[channel].each do |hash|
+        expect(hash[:reactor].websocket).to receive(:close)
+        expect(Celluloid::Actor).to receive(:kill).ordered.with(hash[:reactor])
+      end
+      actor.server_kill_reactors(channel)
+    end
+  end
+  describe 'actor_died' do
+    it 'sets the shutting down' do
+      expect { actor.send(:actor_died, actor, nil) }.to change(actor, :shutting_down?).from(false).to(true)
     end
   end
 end