celluloid_pubsub 0.0.12 → 0.0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e59fc206ccb8f5eb1a0420099429130b92944c17
-  data.tar.gz: ccb987b8132c80967805995ea6b96e61c3b864f7
+  metadata.gz: ee4d93361a3109e5377aa2434b32c9efba276870
+  data.tar.gz: 164fad715b42c791eca6c531720829a7dbb7a40a
 SHA512:
-  metadata.gz: 3570bd394410645d5ab706922d3e07c079d0cbd2f969db70c2cbc81fa6cda0c695daed1eba31212d4885927735706976e1a6d912979eca2afb3485d856a6dd74
-  data.tar.gz: 54b8958031e1bd0db10c3aabe06785a6e5e025a3c9d7700a3170ddaa6bc703ddb045aec1b6f18ac290a0c0f9d371cc33b15a579573df2c7e4d3cd9dc2981ba57
+  metadata.gz: ede77bfac90ac7dfc6bcbf2d814ede297fb9238f62729e783c438912a787238929520e9bf90cdec93e1ef97232be0d62236115f84edb868ca8e0ea165b13d535
+  data.tar.gz: afa3750ce0f42c6407e6ac58043815c72ce6f695c69829d609315017ee65b11aa248a8c2d6cec1f6b09535f6e4d4251b2274292e7bc58583e1746c6317cedbfe

data/.gitignore

@@ -17,3 +17,4 @@ Gemfile.lock
 .yardoc/
 doc/
 bin/
+examples/log/**/*

data/Rakefile

@@ -7,7 +7,7 @@ require 'yard-rspec'
 Coveralls::RakeTask.new
 
 RSpec::Core::RakeTask.new(:spec) do |spec|
-  spec.rspec_opts = ['--backtrace '] if ENV['DEBUG']
+  spec.rspec_opts = ['--backtrace', '--fail-fast'] if ENV['DEBUG']
 end
 
 # desc "Prepare dummy application"

data/examples/simple_test.rb

@@ -1,14 +1,25 @@
 require 'bundler/setup'
 require 'celluloid_pubsub'
+require 'logger'
+
+debug_enabled = ENV['DEBUG'].present? && ENV['DEBUG'].to_s == 'true'
+
+if debug_enabled == true
+  log_file_path = File.join(File.expand_path(File.dirname(__FILE__)), 'log', 'celluloid_pubsub.log')
+  puts log_file_path
+  FileUtils.mkdir_p(File.dirname(log_file_path))
+  log_file = File.open(log_file_path, 'w')
+  log_file.sync = true
+  Celluloid.logger = ::Logger.new(log_file_path)
+end
 
-ENV['DEBUG_CELLULOID'] = ARGV.map(&:downcase).include?('debug') ? 'true' : 'false'
 # actor that subscribes to a channel
 class Subscriber
   include Celluloid
   include Celluloid::Logger
 
-  def initialize
-    @client = CelluloidPubsub::Client.connect(actor: Actor.current) do |ws|
+  def initialize(options = {})
+    @client = CelluloidPubsub::Client.connect({ actor: Actor.current }.merge(options)) do |ws|
       ws.subscribe('test_channel') # this will execute after the connection is opened
     end
   end
@@ -19,7 +30,7 @@ class Subscriber
       @client.publish('test_channel2', 'data' => ' subscriber got successfull subscription') # the message needs to be a Hash
     else
       puts "subscriber got message #{message.inspect}"
-      @client.publish('test_channel2', 'data' => "subscriber got #{message}") # the message needs to be a Hash
+      @client.unsubscribe('test_channel')
     end
   end
 
@@ -34,17 +45,16 @@ class Publisher
   include Celluloid
   include Celluloid::Logger
 
-  def initialize
-    @client = CelluloidPubsub::Client.connect(actor: Actor.current) do |ws|
+  def initialize(options = {})
+    @client = CelluloidPubsub::Client.connect({ actor: Actor.current }.merge(options)) do |ws|
       ws.subscribe('test_channel2') # this will execute after the connection is opened
     end
     @client.publish('test_channel', 'data' => 'my_message') # the message needs to be a Hash
-    @client.publish('test_channel', 'data' => 'my_message')
-    @client.publish('test_channel', 'data' => 'my_message')
   end
 
   def on_message(message)
     puts " publisher got #{message.inspect}"
+    @client.unsubscribe('test_channel2')
   end
 
   def on_close(code, reason)
@@ -53,7 +63,7 @@ class Publisher
   end
 end
 
-CelluloidPubsub::WebServer.supervise_as(:web_server)
-Subscriber.supervise_as(:subscriber)
-Publisher.supervise_as(:publisher)
+CelluloidPubsub::WebServer.supervise_as(:web_server, enable_debug: debug_enabled)
+Subscriber.supervise_as(:subscriber, enable_debug: debug_enabled)
+Publisher.supervise_as(:publisher, enable_debug: debug_enabled)
 sleep

data/lib/celluloid_pubsub/client_pubsub.rb

@@ -78,7 +78,7 @@ module CelluloidPubsub
       #
       # @api public
       def debug_enabled?
-        CelluloidPubsub::WebServer.debug_enabled?
+        @options.fetch('enable_debug', false).to_s == 'true'
       end
 
       # subscribes to a channel . need to be used inside the connect block passed to the actor
@@ -119,6 +119,42 @@ module CelluloidPubsub
         async.chat(publishing_data)
       end
 
+      # unsubscribes current client from a channel
+      #
+      # @param [string] channel
+      #
+      # @return [void]
+      #
+      # @api public
+      def unsubscribe(channel)
+        publishing_data = { 'client_action' => 'unsubscribe', 'channel' => channel }
+        debug(" #{self.class}  sends:  #{publishing_data}") if debug_enabled?
+        async.chat(publishing_data)
+      end
+
+      # unsubscribes all clients subscribed to a channel
+      #
+      # @param [string] channel
+      #
+      # @return [void]
+      #
+      # @api public
+      def unsubscribe_clients(channel)
+        publishing_data = { 'client_action' => 'unsubscribe_clients', 'channel' => channel }
+        debug(" #{self.class}  sends:  #{publishing_data}") if debug_enabled?
+        async.chat(publishing_data)
+      end
+
+      # unsubscribes all clients from all channels
+      #
+      # @return [void]
+      #
+      # @api public
+      def unsubscribe_all
+        publishing_data = { 'client_action' => 'unsubscribe_all' }
+        debug(" #{self.class}  sends:  #{publishing_data}") if debug_enabled?
+        async.chat(publishing_data)
+      end
       #  callback executes after connection is opened and delegates action to actor
       #
       # @return [void]

data/lib/celluloid_pubsub/reactor.rb

@@ -1,5 +1,6 @@
 require_relative './registry'
 module CelluloidPubsub
+  # rubocop:disable ClassLength
   # The reactor handles new connections. Based on what the client sends it either subscribes to a channel
   # or will publish to a channel or just dispatch to the server if command is neither subscribe, publish or unsubscribe
   #
@@ -44,10 +45,21 @@ module CelluloidPubsub
     #
     # :nocov:
     def run
-      while message = @websocket.read
+      while !@websocket.closed? && message = try_read_websocket
         handle_websocket_message(message)
       end
     end
+
+    def try_read_websocket
+      message = nil
+      begin
+        message = @websocket.read
+       rescue => e
+         debug(e) if @server.debug_enabled?
+      end
+      message
+    end
+
     # :nocov:
 
     # method used to parse a JSON object into a Hash object
@@ -136,8 +148,10 @@ module CelluloidPubsub
       case json_data['client_action']
         when 'unsubscribe_all'
           unsubscribe_all
+        when 'unsubscribe_clients'
+          async.unsubscribe_clients(json_data['channel'])
         when 'unsubscribe'
-          async.unsubscribe_client(json_data['channel'])
+          async.unsubscribe(json_data['channel'])
         when 'subscribe'
           async.start_subscriber(json_data['channel'], json_data)
         when 'publish'
@@ -168,7 +182,7 @@ module CelluloidPubsub
     # @return [void]
     #
     # @api public
-    def unsubscribe_client(channel)
+    def unsubscribe(channel)
       return unless channel.present?
       @channels.delete(channel) unless @channels.blank?
       @websocket.close if @channels.blank?
@@ -177,6 +191,22 @@ module CelluloidPubsub
       end if @server.subscribers[channel].present?
     end
 
+    # the method will unsubscribe all  clients subscribed to a channel by closing the
+    #
+    # @param [String] channel
+    #
+    # @return [void]
+    #
+    # @api public
+    def unsubscribe_clients(channel)
+      return if channel.blank? || @server.subscribers[channel].blank?
+      @server.subscribers[channel].each do |hash|
+        hash[:reactor].websocket.close
+        Celluloid::Actor.kill(hash[:reactor])
+      end
+      @server.subscribers[channel] = []
+    end
+
     # the method will terminate the current actor
     #
     #
@@ -230,6 +260,7 @@ module CelluloidPubsub
       CelluloidPubsub::Registry.channels.map do |channel|
         @server.subscribers[channel].each do |hash|
           hash[:reactor].websocket.close
+          Celluloid::Actor.kill(hash[:reactor])
         end
         @server.subscribers[channel] = []
       end

data/lib/celluloid_pubsub/version.rb

@@ -17,7 +17,7 @@ module CelluloidPubsub
     # minor release version
     MINOR = 0
     # tiny release version
-    TINY = 12
+    TINY = 13
     # prelease version ( set this only if it is a prelease)
     PRE = nil
 

data/lib/celluloid_pubsub/web_server.rb

@@ -90,19 +90,10 @@ module CelluloidPubsub
     #
     # @api public
     def debug_enabled?
-      self.class.debug_enabled?
+      @options.fetch('enable_debug', false).to_s == 'true'
     end
 
-    #  checks if debug is enabled
-    #
-    # @return [boolean]
-    #
-    # @api public
-    def self.debug_enabled?
-      ENV['DEBUG_CELLULOID'].present? && (ENV['DEBUG_CELLULOID'] == 'true' || ENV['DEBUG_CELLULOID'] == true)
-    end
-
-    #  checks if debug is enabled
+    #  method for publishing data to a channel
     #
     # @param [String] current_topic The Channel to which the reactor instance {CelluloidPubsub::Rector} will publish the message to
     # @param [Object] message
@@ -112,8 +103,12 @@ module CelluloidPubsub
     # @api public
     def publish_event(current_topic, message)
       return if current_topic.blank? || message.blank? || @subscribers[current_topic].blank?
-      @subscribers[current_topic].each do |hash|
-        hash[:reactor].websocket << message
+      begin
+        @subscribers[current_topic].each do |hash|
+          hash[:reactor].websocket << message
+        end
+      rescue => e
+        debug("could not publish message #{message} into topic #{current_topic} because of #{e.inspect}") if debug_enabled?
       end
     end
 

data/spec/lib/celluloid_pubsub/client_pubsub_spec.rb

@@ -23,7 +23,7 @@ describe CelluloidPubsub::Client::PubSubWorker do
   before(:each) do
     Celluloid::WebSocket::Client.stubs(:new).returns(socket)
     socket.stubs(:text)
-    @worker = CelluloidPubsub::Client::PubSubWorker.new({ 'actor' => actor }, &blk)
+    @worker = CelluloidPubsub::Client::PubSubWorker.new({ 'actor' => actor, enable_debug: true }, &blk)
     @worker.stubs(:client).returns(socket)
     @worker.stubs(:debug)
     @worker.stubs(:async).returns(@worker)
@@ -63,7 +63,6 @@ describe CelluloidPubsub::Client::PubSubWorker do
 
   describe '#debug_enabled?' do
     it 'checks if debug is enabled' do
-      CelluloidPubsub::WebServer.expects(:debug_enabled?).returns(true)
       act = @worker.debug_enabled?
       act.should eq(true)
     end

data/spec/lib/celluloid_pubsub/reactor_spec.rb

@@ -1,214 +1,215 @@
-# encoding:utf-8
-
-require 'spec_helper'
-
-describe CelluloidPubsub::Reactor do
-  let(:websocket) { mock }
-  let(:server) { mock }
-
-  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({})
-    websocket.stubs(:read)
-    subject.stubs(:inspect).returns(subject)
-    subject.stubs(:run)
-    subject.work(websocket, server)
-  end
-
-  describe '#work' do
-    it 'works ' do
-      subject.expects(:run)
-      subject.work(websocket, server)
-      subject.websocket.should eq websocket
-      subject.server.should eq server
-      subject.channels.should eq []
-    end
-  end
-
-  #  describe '#rub' 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
-  #    end
-  #  end
-
-  describe '#parse_json_data' do
-    let(:data) { 'some message' }
-    let(:expected) { data.to_json }
-
-    it 'works with hash ' do
-      JSON.expects(:parse).with(data).returns(expected)
-      actual = subject.parse_json_data(data)
-      actual.should eq expected
-    end
-
-    it 'works with exception parsing  ' do
-      JSON.expects(:parse).with(data).raises(StandardError)
-      actual = subject.parse_json_data(data)
-      actual.should eq data
-    end
-  end
-
-  describe '#handle_websocket_message' do
-    let(:data) { 'some message' }
-    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)
-    end
-  end
-
-  describe '#handle_parsed_websocket_message' do
-    it 'handle_websocket_message with a hash' do
-      data = { 'client_action' => 'b' }
-      data.expects(:stringify_keys).returns(data)
-      subject.expects(:delegate_action).with(data)
-      subject.handle_parsed_websocket_message(data)
-    end
-
-    it 'handle_websocket_message with something else than a hash' do
-      data = 'some message'
-      subject.expects(:handle_unknown_action).with(data)
-      subject.handle_parsed_websocket_message(data)
-    end
-  end
-
-  describe '#delegate_action' do
-    it 'unsubscribes all' do
-      data = { 'client_action' => 'unsubscribe_all' }
-      subject.expects(:unsubscribe_all).returns('bla')
-      subject.delegate_action(data)
-    end
-
-    it 'unsubscribes all' do
-      data = { 'client_action' => 'unsubscribe', 'channel' => 'some channel' }
-      subject.expects(:unsubscribe_client).with(data['channel'])
-      subject.delegate_action(data)
-    end
-
-    it 'subscribes to channell' do
-      data = { 'client_action' => 'subscribe', 'channel' => 'some channel' }
-      subject.expects(:start_subscriber).with(data['channel'], data)
-      subject.delegate_action(data)
-    end
-
-    it 'publish' do
-      data = { 'client_action' => 'publish', 'channel' => 'some channel', 'data' => 'some data' }
-      server.expects(:publish_event).with(data['channel'], data['data'].to_json)
-      subject.delegate_action(data)
-    end
-
-    it 'handles unknown' do
-      data = { 'client_action' => 'some action', 'channel' => 'some channel' }
-      subject.expects(:handle_unknown_action).with(data)
-      subject.delegate_action(data)
-    end
-  end
-
-  describe '#handle_unknown_action' do
-    it 'handles unknown' do
-      data = 'some data'
-      server.expects(:handle_dispatched_message)
-      subject.handle_unknown_action(data)
-    end
-  end
-
-  describe '#unsubscribe_client' do
-    let(:channel) { 'some channel' }
-    it 'returns nil' do
-      act = subject.unsubscribe_client('')
-      act.should eq(nil)
-    end
-
-    it 'unsubscribes' do
-      subject.channels.stubs(:blank?).returns(false)
-      subject.channels.expects(:delete).with(channel)
-      act = subject.unsubscribe_client(channel)
-      act.should eq(nil)
-    end
-
-    it 'unsubscribes' do
-      subject.channels.stubs(:blank?).returns(true)
-      subject.websocket.expects(:close)
-      act = subject.unsubscribe_client(channel)
-      act.should eq(nil)
-    end
-
-    it 'unsubscribes' do
-      subject.channels.stubs(:blank?).returns(false)
-      subject.channels.stubs(:delete)
-      server.stubs(:subscribers).returns("#{channel}" => [{ reactor: subject }])
-      subject.unsubscribe_client(channel)
-      server.subscribers[channel].should eq([])
-    end
-  end
-
-  describe '#shutdown' do
-    it 'shutdowns' do
-      subject.expects(:terminate)
-      subject.shutdown
-    end
-  end
-
-  describe '#start_subscriber' do
-    let(:channel) { 'some channel' }
-    let(:message) { { a: 'b' } }
-
-    it 'subscribes ' do
-      act = subject.start_subscriber('', message)
-      act.should eq(nil)
-    end
-
-    it 'subscribes ' do
-      subject.stubs(:add_subscriber_to_channel).with(channel, message)
-      subject.websocket.expects(:<<).with(message.merge('client_action' => 'successful_subscription', 'channel' => channel).to_json)
-      subject.start_subscriber(channel, message)
-    end
-
-    #    it 'raises error' do
-    #      subject.stubs(:add_subscriber_to_channel).raises(StandardError)
-    #
-    #      expect do
-    #        subject.start_subscriber(channel, message)
-    #      end.to raise_error(StandardError) { |e|
-    #        expect(e.message).to include(channel)
-    #      }
-    #    end
-  end
-
-  describe '#add_subscriber_to_channel' do
-    let(:channel) { 'some channel' }
-    let(:message) { { a: 'b' } }
-
-    it 'adds subscribed' do
-      CelluloidPubsub::Registry.channels.stubs(:include?).with(channel).returns(false)
-      CelluloidPubsub::Registry.channels.expects(:<<).with(channel)
-      server.subscribers[channel] = []
-      server.subscribers[channel].expects(:<<).with(reactor: subject, message: message)
-      subject.add_subscriber_to_channel(channel, message)
-      subject.channels.should include(channel)
-    end
-  end
-
-  describe '#unsubscribe_all' do
-    let(:channel) { 'some channel' }
-    let(:message) { { a: 'b' } }
-
-    it 'adds subscribed' do
-      CelluloidPubsub::Registry.stubs(:channels).returns([channel])
-      server.subscribers.stubs(:[]).with(channel).returns([{ reactor: subject, message: message }])
-      subject.websocket.expects(:close)
-      subject.expects(:shutdown)
-      subject.unsubscribe_all
-    end
-  end
-end
+ # encoding:utf-8
+
+ require 'spec_helper'
+
+ describe CelluloidPubsub::Reactor do
+   let(:websocket) { mock }
+   let(:server) { mock }
+
+   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({})
+     websocket.stubs(:read)
+     subject.stubs(:inspect).returns(subject)
+     subject.stubs(:run)
+     subject.work(websocket, server)
+   end
+
+   describe '#work' do
+     it 'works ' do
+       subject.expects(:run)
+       subject.work(websocket, server)
+       subject.websocket.should eq websocket
+       subject.server.should eq server
+       subject.channels.should eq []
+     end
+   end
+
+   #  describe '#rub' 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
+   #    end
+   #  end
+
+   describe '#parse_json_data' do
+     let(:data) { 'some message' }
+     let(:expected) { data.to_json }
+
+     it 'works with hash ' do
+       JSON.expects(:parse).with(data).returns(expected)
+       actual = subject.parse_json_data(data)
+       actual.should eq expected
+     end
+
+     it 'works with exception parsing  ' do
+       JSON.expects(:parse).with(data).raises(StandardError)
+       actual = subject.parse_json_data(data)
+       actual.should eq data
+     end
+   end
+
+   describe '#handle_websocket_message' do
+     let(:data) { 'some message' }
+     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)
+     end
+   end
+
+   describe '#handle_parsed_websocket_message' do
+     it 'handle_websocket_message with a hash' do
+       data = { 'client_action' => 'b' }
+       data.expects(:stringify_keys).returns(data)
+       subject.expects(:delegate_action).with(data)
+       subject.handle_parsed_websocket_message(data)
+     end
+
+     it 'handle_websocket_message with something else than a hash' do
+       data = 'some message'
+       subject.expects(:handle_unknown_action).with(data)
+       subject.handle_parsed_websocket_message(data)
+     end
+   end
+
+   describe '#delegate_action' do
+     it 'unsubscribes all' do
+       data = { 'client_action' => 'unsubscribe_all' }
+       subject.expects(:unsubscribe_all).returns('bla')
+       subject.delegate_action(data)
+     end
+
+     it 'unsubscribes all' do
+       data = { 'client_action' => 'unsubscribe', 'channel' => 'some channel' }
+       subject.expects(:unsubscribe).with(data['channel'])
+       subject.delegate_action(data)
+     end
+
+     it 'subscribes to channell' do
+       data = { 'client_action' => 'subscribe', 'channel' => 'some channel' }
+       subject.expects(:start_subscriber).with(data['channel'], data)
+       subject.delegate_action(data)
+     end
+
+     it 'publish' do
+       data = { 'client_action' => 'publish', 'channel' => 'some channel', 'data' => 'some data' }
+       server.expects(:publish_event).with(data['channel'], data['data'].to_json)
+       subject.delegate_action(data)
+     end
+
+     it 'handles unknown' do
+       data = { 'client_action' => 'some action', 'channel' => 'some channel' }
+       subject.expects(:handle_unknown_action).with(data)
+       subject.delegate_action(data)
+     end
+   end
+
+   describe '#handle_unknown_action' do
+     it 'handles unknown' do
+       data = 'some data'
+       server.expects(:handle_dispatched_message)
+       subject.handle_unknown_action(data)
+     end
+   end
+
+   describe '#unsubscribe_client' do
+     let(:channel) { 'some channel' }
+     it 'returns nil' do
+       act = subject.unsubscribe('')
+       act.should eq(nil)
+     end
+
+     it 'unsubscribes' do
+       subject.channels.stubs(:blank?).returns(false)
+       subject.channels.expects(:delete).with(channel)
+       act = subject.unsubscribe(channel)
+       act.should eq(nil)
+     end
+
+     it 'unsubscribes' do
+       subject.channels.stubs(:blank?).returns(true)
+       subject.websocket.expects(:close)
+       act = subject.unsubscribe(channel)
+       act.should eq(nil)
+     end
+
+     it 'unsubscribes' do
+       subject.channels.stubs(:blank?).returns(false)
+       subject.channels.stubs(:delete)
+       server.stubs(:subscribers).returns("#{channel}" => [{ reactor: subject }])
+       subject.unsubscribe(channel)
+       server.subscribers[channel].should eq([])
+     end
+   end
+
+   describe '#shutdown' do
+     it 'shutdowns' do
+       subject.expects(:terminate)
+       subject.shutdown
+     end
+   end
+
+   describe '#start_subscriber' do
+     let(:channel) { 'some channel' }
+     let(:message) { { a: 'b' } }
+
+     it 'subscribes ' do
+       act = subject.start_subscriber('', message)
+       act.should eq(nil)
+     end
+
+     it 'subscribes ' do
+       subject.stubs(:add_subscriber_to_channel).with(channel, message)
+       subject.websocket.expects(:<<).with(message.merge('client_action' => 'successful_subscription', 'channel' => channel).to_json)
+       subject.start_subscriber(channel, message)
+     end
+
+     #    it 'raises error' do
+     #      subject.stubs(:add_subscriber_to_channel).raises(StandardError)
+     #
+     #      expect do
+     #        subject.start_subscriber(channel, message)
+     #      end.to raise_error(StandardError) { |e|
+     #        expect(e.message).to include(channel)
+     #      }
+     #    end
+   end
+
+   describe '#add_subscriber_to_channel' do
+     let(:channel) { 'some channel' }
+     let(:message) { { a: 'b' } }
+
+     it 'adds subscribed' do
+       CelluloidPubsub::Registry.channels.stubs(:include?).with(channel).returns(false)
+       CelluloidPubsub::Registry.channels.expects(:<<).with(channel)
+       server.subscribers[channel] = []
+       server.subscribers[channel].expects(:<<).with(reactor: subject, message: message)
+       subject.add_subscriber_to_channel(channel, message)
+       subject.channels.should include(channel)
+     end
+   end
+
+   describe '#unsubscribe_all' do
+     let(:channel) { 'some channel' }
+     let(:message) { { a: 'b' } }
+
+     it 'adds subscribed' do
+       Celluloid::Actor.stubs(:kill).returns(true)
+       CelluloidPubsub::Registry.stubs(:channels).returns([channel])
+       server.subscribers.stubs(:[]).with(channel).returns([{ reactor: subject, message: message }])
+       subject.websocket.expects(:close)
+       subject.expects(:shutdown)
+       subject.unsubscribe_all
+     end
+   end
+ end

data/spec/lib/celluloid_pubsub/web_server_spec.rb

@@ -1,49 +1,49 @@
-# encoding:utf-8
+ # encoding:utf-8
 
-require 'spec_helper'
+ require 'spec_helper'
 
-describe CelluloidPubsub::WebServer do
-  it 'should have host constant' do
-    CelluloidPubsub::WebServer::HOST.should eq('0.0.0.0')
-  end
+ describe CelluloidPubsub::WebServer do
+   it 'should have host constant' do
+     CelluloidPubsub::WebServer::HOST.should eq('0.0.0.0')
+   end
 
-  it 'should have host constant' do
-    CelluloidPubsub::WebServer::PORT.should eq(1234)
-  end
+   it 'should have host constant' do
+     CelluloidPubsub::WebServer::PORT.should eq(1234)
+   end
 
-  it 'should have host constant' do
-    CelluloidPubsub::WebServer::PATH.should eq('/ws')
-  end
-  let(:options) { {} }
-  let(:web_server) { mock }
+   it 'should have host constant' do
+     CelluloidPubsub::WebServer::PATH.should eq('/ws')
+   end
+   let(:options) { {} }
+   let(:web_server) { mock }
 
-  before(:each) do
-    CelluloidPubsub::WebServer.stubs(:new).returns(web_server)
-  end
+   before(:each) do
+     CelluloidPubsub::WebServer.stubs(:new).returns(web_server)
+   end
 
-  #  it '#initialize with default values ' do
-  #    web_server.parse_options({})
-  #    web_server.hostname.should eq(CelluloidPubsub::WebServer::HOST)
-  #    web_server.port.should eq(CelluloidPubsub::WebServer::PORT)
-  #    web_server.path.should eq(CelluloidPubsub::WebServer::PATH)
-  #    web_server.backlog.should eq(1024)
-  #    web_server.spy.should eq(false)
-  #  end
-  #
-  #  describe '#with custom values' do
-  #    let(:hostname) { '192.0.0.1' }
-  #    let(:port) { 13_456 }
-  #    let(:path) { '/pathy' }
-  #    let(:backlog) { 2048 }
-  #    let(:spy) { true }
-  #
-  #    it '#initialize with custom values ' do
-  #      web_server.parse_options(hostname: hostname, port: port, path: path, spy: spy, backlog: backlog)
-  #      web_server.hostname.should eq(hostname)
-  #      web_server.port.should eq(port)
-  #      web_server.path.should eq(path)
-  #      web_server.backlog.should eq(backlog)
-  #      web_server.spy.should eq(spy)
-  #    end
-  #  end
-end
+   #  it '#initialize with default values ' do
+   #    web_server.parse_options({})
+   #    web_server.hostname.should eq(CelluloidPubsub::WebServer::HOST)
+   #    web_server.port.should eq(CelluloidPubsub::WebServer::PORT)
+   #    web_server.path.should eq(CelluloidPubsub::WebServer::PATH)
+   #    web_server.backlog.should eq(1024)
+   #    web_server.spy.should eq(false)
+   #  end
+   #
+   #  describe '#with custom values' do
+   #    let(:hostname) { '192.0.0.1' }
+   #    let(:port) { 13_456 }
+   #    let(:path) { '/pathy' }
+   #    let(:backlog) { 2048 }
+   #    let(:spy) { true }
+   #
+   #    it '#initialize with custom values ' do
+   #      web_server.parse_options(hostname: hostname, port: port, path: path, spy: spy, backlog: backlog)
+   #      web_server.hostname.should eq(hostname)
+   #      web_server.port.should eq(port)
+   #      web_server.path.should eq(path)
+   #      web_server.backlog.should eq(backlog)
+   #      web_server.spy.should eq(spy)
+   #    end
+   #  end
+ end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: celluloid_pubsub
 version: !ruby/object:Gem::Version
-  version: 0.0.12
+  version: 0.0.13
 platform: ruby
 authors:
 - bogdanRada
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-15 00:00:00.000000000 Z
+date: 2015-04-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: celluloid