langrove 0.0.4.5 → 0.0.5.3

data/spec/langrove/handler/socket_multiplexer_spec.rb

@@ -0,0 +1,480 @@
+require 'spec_helper'
+
+DEMUX = {
+  :proxy_to => {
+    :handler => {
+      :class => 'Base'
+    }
+  },
+  :proxy_by   => :hostname
+}
+
+describe LanGrove::Handler::SocketMultiplexer do
+  
+  before :each do
+    
+    LOG.off
+    
+    @palindrome1 = 'a man, a plan, a canal, panama'
+    @palindrome2 = 'able was i, ere i saw elba'
+    
+    #
+    # palindrome |noun| ~ magic carpet port
+    #
+    # eg. Until learning of the palindrome on the outskirts 
+    #     of town - new residents of Constantinople were want
+    #     to frequently report unidentified flying carpets to 
+    #     the sultanate. Etanatlus eht ot steprac gniylf deif-
+    #     itnedinu troper yltneuqerf ot tnaw erew elponitnat-
+    #     snoC fo stnediser wen - nwot fo striktuo eht no 
+    #     emordnilap eht fo gninrael litnU
+    # 
+    
+    #
+    # replace the demux routing keyname
+    #
+    DEMUX[:proxy_by] = :unique
+    
+    @protocol_config = { :too => 'ALSO' } 
+    
+    class FakeProtocol < LanGrove::Protocol::Base
+      
+      #
+      # Live replica Protocol 
+      # 
+      # So that the handing in of @protocol_config into the 
+      # demultipled handlers can be tested.
+      #
+      
+      def decode( data )
+        
+        if data.split(',')[-1] == ' panama'
+          
+          return {
+            #
+            # palindrome1 generates a proxyable decode
+            #
+            :unique => 'this will become the @handlers key',
+            :data => data
+          }
+          
+        end
+        
+        return {
+          #
+          # palindrome2 generates problematic decode
+          #
+          
+          # missing unique key
+          :data => data
+          
+        }
+        
+      end
+      
+    end
+    
+    #
+    # Pending 3rd arg - Protcol has the last initializer 
+    # with a non standard signature... 
+    #
+    @protocol = FakeProtocol.new( ROOT, @protocol_config, nil )
+    # @protocol = FakeProtocol.new( @protocol_config, nil, LOG )
+    
+    #
+    # Server for the bind 
+    # 
+    @server = double( 'Server' )
+    
+  end
+  
+  subject {
+    
+    test = LanGrove::Handler::SocketMultiplexer.new nil
+    
+    #
+    # Handlers dont share the LanGrove::Base superclass,
+    # so that they can be extended with functionality
+    # from the EventMachine::connection superclass.
+    # 
+    # This means that they need the root inserted 
+    # alternatively.
+    #
+    
+    test.instance_variable_set( :@root, ROOT )
+    test.instance_variable_set( :@logger, ROOT.logger )
+    
+    test
+    
+  }
+  
+  it 'recalls each Handler already being de-multiplexed' do
+    
+    subject.config = DEMUX
+    subject.server = @server
+    subject.start_handler
+    
+    subject.instance_variable_get( 
+    
+      :@handlers 
+    
+    ).should be_a(
+    
+      Hash
+    
+    )
+    
+  end
+  
+  it 'allows access to the handlers by attribute' do
+    
+    subject.config = DEMUX
+    subject.server = @server
+    subject.start_handler
+    subject.handlers.should be_a(
+    
+      Hash
+    
+    )
+    
+  end
+  
+  it 'triggers the multiplexer_start event' do
+    
+    subject.config = DEMUX
+    subject.server = @server
+    
+    ROOT.should_receive(
+    
+      :trigger
+    
+    ).with( 
+      
+      subject, :multiplexer, :start
+    
+    )
+    
+    subject.start_handler
+    
+  end
+  
+  it 'triggers the handler_stop event' do
+    
+    subject.config = DEMUX
+    subject.server = @server
+    subject.start_handler
+    
+    ROOT.should_receive(
+    
+      :trigger
+    
+    ).with( 
+      
+      subject, :multiplexer, :stop
+    
+    )
+    
+    subject.stop_handler
+    
+  end
+  
+  it 'should raise and error if started without required config' do
+  
+    badconfig = DEMUX.clone
+    badconfig.delete :proxy_by
+    
+    subject.protocol = @protocol
+    subject.config = badconfig
+    subject.logger = LOG
+    
+    expect {
+    
+      subject.start_handler
+      
+    }.to raise_error( 
+    
+      LanGrove::DaemonConfigException,
+      
+      /requires :proxy_by: subconfig/
+    
+    )
+    
+  end
+  
+  context 'demultiplexes' do
+    
+    before :each do
+      
+      subject.protocol = @protocol
+      subject.config = DEMUX
+      subject.logger = LOG
+      subject.server = @server
+      subject.start_handler
+      
+    end
+    
+    
+    it 'by pre decoding data to collect :proxy_by: value' do
+      
+      subject.protocol = @protocol
+      subject.config = DEMUX
+      subject.logger = LOG
+      subject.start_handler
+      
+      @server.should_receive( :connect )
+      
+      subject.protocol.should_receive( 
+      
+        :decode 
+        
+      ).with( 
+        
+        @palindrome1
+        
+      ).and_return(
+      
+        { :unique => 'key' }
+      
+      )
+      
+      subject.receive_data( @palindrome1 )
+      
+    end
+    
+    
+    it 'with error logging on receiving data missing the :proxy_by: item' do
+      
+      LOG.should_receive( :warn ).with( 
+      
+        "Malformed data received. Missing value for 'unique' in message: #{@palindrome2}"
+        
+      )
+      
+      subject.receive_data( @palindrome2 )
+      
+    end
+  
+  end
+  
+  context 'creates handlers' do
+    
+    before :each do
+      
+      subject.protocol = @protocol
+      subject.logger = LOG
+      subject.server = @server
+      
+    end
+    
+    it 'according to config' do
+      
+      DEMUX[:proxy_to][:handler][:class] = 'TroyTroyAgain'
+      subject.config = DEMUX
+      
+      expect {
+        
+        subject.start_handler
+      
+      }.to raise_error(
+      
+        LanGrove::ClassLoaderException, 
+
+        "no such file to load -- handler/troy_troy_again.rb" 
+      
+      )
+      
+    end
+    
+    it 'as Handler::Base if unspecified' do
+      
+      @server.should_receive( :connect )
+    
+      DEMUX[:proxy_to].delete :handler
+      subject.config = DEMUX
+      subject.server = @server
+      subject.start_handler
+      subject.receive_data( @palindrome1 )
+      
+      handler = subject.instance_variable_get(
+      
+        :@handlers
+      
+      )['this will become the @handlers key']
+      
+      handler.should be_a( LanGrove::Handler::Base )
+      
+    end
+    
+    context 'routes message to the handlers' do
+    
+      before :each do
+        
+        @server.should_receive( :connect )
+
+        subject.config = DEMUX
+        subject.logger = LOG
+        subject.server = @server
+        subject.start_handler
+        subject.receive_data( @palindrome1 )
+        @handler = subject.instance_variable_get(
+
+          :@handlers
+
+        )['this will become the @handlers key']
+
+      end
+      
+      it 'sends to the existing handler if already present' do
+        
+        @handler.should_receive( :receive ).exactly(2).times
+        
+        subject.receive_data( @palindrome1 )
+        subject.receive_data( @palindrome2 )
+        subject.receive_data( @palindrome1 )
+        
+      end
+      
+      it 'does not create handler on missing key' do
+        
+        subject.receive_data( @palindrome1 )
+        subject.receive_data( @palindrome2 )
+        subject.receive_data( @palindrome1 )
+        
+        subject.instance_variable_get(
+
+          :@handlers
+
+        ).size.should == 1
+        
+      end
+    
+    end 
+    
+  end
+  
+  context 'it multiplexes' do
+    
+    #
+    # thus far only DE-multiplexing, 
+    # 
+    # acting on inbound - receive_data()
+    # 
+    
+    # 
+    # Exactly the same pattern would apply in the inverse.
+    # 
+    
+    # 
+    # There will be no need for multiplexing until there are 
+    # protocols at play that require ACK/NAC/REPLY type stuff. 
+    # 
+    
+  end
+  
+  context 'a multiplexed handler' do
+    
+    #
+    # The same things as a direcly socket 
+    # attached Handler
+    # 
+    before :each do
+      
+      @server.should_receive( :connect )
+
+      subject.config = DEMUX
+      subject.logger = LOG
+      subject.protocol = @protocol
+      subject.server = @server
+      subject.start_handler
+      subject.receive_data( @palindrome1 )
+      @handler = subject.instance_variable_get(
+
+        :@handlers
+
+      )['this will become the @handlers key']
+    
+    end
+    
+    #
+    # These are normally performed by the adaptor 
+    # after connect, best to make that thread path
+    # more accessable, so that it can be used here. 
+    # 
+    it 'has the bind to server' do
+      
+      #
+      # Bypassing this transparrent multiplexing layer.
+      #
+      
+      @handler.server.should == @server
+      
+    end
+    
+    it 'has its config subtree' do
+      
+      @handler.config.should == DEMUX[:proxy_to][:handler]
+      
+    end
+    
+    it 'has the logger' do
+      
+      @handler.logger.should == LOG
+      
+    end
+    
+    it 'has the protocol and config' do
+       
+      @handler.protocol.instance_variable_get( 
+
+          :@config
+
+      )[  :too   ].should == 'ALSO'   #B  .there()
+      
+    end
+    
+    it 'posses a data capsule' do
+      
+      @handler.capsule.should be_a( Hash )
+      
+    end
+    
+  end
+  
+  context 'fires events on behalf of the demultiplexed handler' do
+    
+    before :each do
+      
+      @server.should_receive( :connect )
+
+      subject.config = DEMUX
+      subject.logger = LOG
+      subject.protocol = @protocol
+      subject.server = @server
+      subject.instance_variable_set(
+      
+        :@root, ROOT
+      
+      )
+      subject.start_handler
+      
+    end
+    
+    it '[Dunno why...] first_message event (does not fire in test)' do
+      
+      ROOT.should_receive( 
+      
+        :trigger 
+        
+      ).with( 
+      
+        anything(), :handler, :start
+      
+      )
+      
+      subject.receive_data( @palindrome1 )
+      
+    end
+
+  end
+  
+end

data/spec/langrove/handler/socket_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe LanGrove::Handler::Socket do
+  
+  
+end

data/spec/langrove/handler/web_socket_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe LanGrove::Handler::WebSocket do
+
+  subject {
+
+    LanGrove::Handler::WebSocket.new( {}, {} )
+
+  }
+
+  it 'inbound messages are passed into the receive pipeline' do
+
+    subject.should_receive( :handle_receive_data )
+
+    subject.trigger_on_message( "DATA" )
+
+  end
+
+end