client_for_poslynx 0.9.0 → 1.0.0.pre

data/spec/client_for_poslynx/net/em_session_spec.rb

@@ -0,0 +1,313 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+module ClientForPoslynx
+
+  describe Net::EM_Session do
+    subject {
+      described_class.new( connector, em_system: em_system )
+    }
+    let( :connector ) { double(
+      :connector,
+      request_pending?: false,
+      latest_request: nil,
+    ) }
+    let( :em_system ) { double(:em_system) }
+
+    it "allows making a request and returning the response" do
+      expect( connector ).to receive( :connect ) do |opts|
+        opts[:on_success].call
+      end
+      allow( connector ).to receive( :send_request ) do |data, opts|
+        opts[:on_response].call :the_response
+      end
+
+      response = nil
+      subject.execute do |s|
+        response = s.request( :the_request_data )
+      end
+
+      expect( response ).to eq( :the_response )
+    end
+
+    it "raises an exception when making a request with an initial connection failure" do
+      expect( connector ).to receive( :connect ) do |opts|
+        opts[:on_failure].call
+      end
+
+      exception = nil
+      subject.execute do |s|
+        begin
+          s.request( :the_request_data )
+        rescue => ex
+          exception = ex
+        end
+      end
+
+      expect( exception ).to be_kind_of( Net::EM_Session::RequestError )
+    end
+
+    it "raises an exception when making a request that fails" do
+      expect( connector ).to receive( :connect ) do |opts|
+        opts[:on_success].call
+      end
+      allow( connector ).to receive( :send_request ) do |data, opts|
+        opts[:on_failure].call
+      end
+
+      exception = nil
+      subject.execute do |s|
+        begin
+          s.request( :the_request_data )
+        rescue => ex
+          exception = ex
+        end
+      end
+
+      expect( exception ).to be_kind_of( Net::EM_Session::RequestError )
+    end
+
+    context "when an existing pin pad reset request is pending" do
+      before do
+        allow( connector ).to receive( :request_pending? ).and_return( true )
+        allow( connector ).to receive( :latest_request ).and_return(
+          Net::EMC.RequestCall(
+            prev_request_data, { on_failure: prev_on_failure}
+          )
+        )
+      end
+
+      let( :prev_request_data ) {
+        Data::Requests::PinPadReset.new
+      }
+      let( :prev_on_failure ) { double(:prev_on_failure, call: nil) }
+
+      it "usurps the pending request when making a new pin pad reset request" do
+        allow( connector ).to receive( :get_response ) do |opts|
+          opts[:on_response].call :the_response
+        end
+
+        response = nil
+        subject.execute do |s|
+          response = s.request( Data::Requests::PinPadReset.new )
+        end
+
+        expect( prev_on_failure ).to have_received( :call )
+        expect( response ).to eq( :the_response )
+      end
+    end
+
+    context "when a request is pending" do
+      before do
+        allow( connector ).to receive( :connection_status ).and_return( :connected )
+        allow( connector ).to receive( :request_pending? ).and_return( true )
+        allow( connector ).to receive( :latest_request ).and_return(
+          Net::EMC.RequestCall(
+            prev_request_data,
+            {
+              on_response: prev_on_response,
+              on_failure:  prev_on_failure,
+              on_detached: prev_on_detached,
+            }
+          )
+        )
+      end
+      let( :prev_request_data ) { Data::Requests::PinPadInitialize.new }
+      let( :prev_on_response   ) { double(:prev_on_response,   call: nil) }
+      let( :prev_on_failure    ) { double(:prev_on_failure,    call: nil) }
+      let( :prev_on_detached ) { double(:prev_on_detached, call: nil) }
+
+      context "making a new request of the same type" do
+        it "raises an appropriate exception" do
+          request_data = Data::Requests::PinPadInitialize.new
+
+          exception = nil
+          subject.execute do |s|
+            begin
+              s.request( request_data )
+            rescue => ex
+              exception = ex
+            end
+          end
+
+          expect( exception ).to be_kind_of( Net::EM_Session::ConflictingRequestError )
+        end
+      end
+
+      context "making a new request of a different type" do
+        it "supplants the pending request if possible" do
+          request_data = Data::Requests::PinPadDisplayMessage.new
+          response_data = Data::Responses::PinPadDisplayMessage.new
+          allow( connector ).to receive( :connect ) do |opts|
+            opts[:on_success].call
+          end
+          allow( connector ).to receive( :send_request ).with( request_data, anything ) do |data, opts|
+            opts[:on_response].call response_data
+          end
+
+          response = nil
+          subject.execute do |s|
+            response = s.request( request_data )
+          end
+
+          expect( prev_on_failure ).to have_received( :call )
+          expect( response ).to eq( response_data )
+        end
+
+        it "detaches the other event chain if supplanting the pending request is unsuccessful" do
+          # FIXME: This is awfully convoluted, even by comparison
+          #        with other examples in this spec file.
+          allow( connector ).to receive( :connect ) do |opts|
+            opts[:on_success].call
+          end
+
+          request_data = Data::Requests::PinPadDisplayMessage.new
+          first_response_data = Data::Responses::PinPadInitialize.new
+          second_response_data = Data::Responses::PinPadDisplayMessage.new
+
+          expect( connector ).to receive( :send_request ).ordered.with( request_data, anything ) do |data, opts|
+            opts[:on_response].call first_response_data
+          end
+          expect( prev_on_detached ).to receive( :call ).ordered
+          expect( prev_on_response   ).to receive( :call ).ordered.with( first_response_data )
+          expect( connector ).to receive( :get_response ).ordered do |opts|
+            opts[:on_response].call second_response_data
+          end
+
+          response = nil
+          subject.execute do |s|
+            response = s.request( request_data )
+          end
+
+          expect( prev_on_failure ).not_to have_received( :call )
+          expect( response ).to eq( second_response_data )
+        end
+
+        it "fails both the new and previously pending requests on request failure without response" do
+          request_data = Data::Requests::PinPadDisplayMessage.new
+          response_data = Data::Responses::PinPadInitialize.new
+          allow( connector ).to receive( :connect ) do |opts|
+            opts[:on_success].call
+          end
+          allow( connector ).to receive( :send_request ).with( request_data, anything ) do |data, opts|
+            opts[:on_failure].call
+          end
+
+          exception = nil
+          subject.execute do |s|
+            begin
+              s.request( request_data )
+            rescue => ex
+              exception = ex
+            end
+          end
+
+          expect( prev_on_failure ).to have_received( :call )
+          expect( exception ).to be_kind_of( Net::EM_Session::RequestError )
+        end
+
+      end
+
+      context "when its event chain is detached during successful receipt of response" do
+        it "continues to run and receives the returned response" do
+          expect( connector ).to receive( :connect ) do |opts|
+            opts[:on_success].call
+          end
+          allow( connector ).to receive( :send_request ) do |data, opts|
+            opts[:on_detached].call
+            opts[:on_response].call :the_response
+          end
+
+          response = nil
+          subject.execute do |s|
+            response = s.request( :the_request_data )
+          end
+
+          expect( response ).to eq( :the_response )
+        end
+
+        it "is blocked from making additional requests" do
+          expect( connector ).to receive( :connect ) do |opts|
+            opts[:on_success].call
+          end
+          allow( connector ).to receive( :send_request ) do |data, opts|
+            opts[:on_detached].call
+            opts[:on_response].call :the_response
+          end
+
+          exception = nil
+          subject.execute do |s|
+            s.request( :the_request_data )
+            begin
+              s.request( :the_request_data )
+            rescue Net::EM_Session::RequestError => ex
+              exception = ex
+            end
+          end
+
+          expect( prev_on_failure ).to have_received( :call )
+          expect( exception ).to be_kind_of( Net::EM_Session::RequestError )
+        end
+      end
+    end
+
+    context "executing a dissociated code" do
+      before do
+        allow( em_system ).to receive( :defer ) do |block, callback|
+          result = block.call
+          callback.call result
+        end
+      end
+
+      it "gets the value returned from the code execution" do
+        exec_result = nil
+        subject.execute do |s|
+          exec_result = subject.exec_dissociated {
+            :the_result
+          }
+        end
+        expect( exec_result ).to eq( :the_result )
+      end
+
+      it "gets the exception raised during the code execution" do
+        exception = nil
+        subject.execute do |s|
+          begin
+            subject.exec_dissociated do
+              raise 'the error'
+            end
+          rescue => e
+            exception = e
+          end
+        end
+        expect( exception ).to be_kind_of( StandardError )
+        expect( exception.message ).to eq( 'the error' )
+      end
+    end
+
+    context "sleeping" do
+      before do
+        @run_sequence = []
+        allow( em_system ).to receive( :add_timer ) do |delay_time, callback|
+          @run_sequence << [:add_timer, delay_time]
+          callback.call
+        end
+      end
+
+      it "adds an EM timer, and resumes after the timer callback fires" do
+        subject.execute do |s|
+          s.sleep 5.5
+          @run_sequence << :after_timer
+        end
+
+        expect( @run_sequence ).to eq( [
+          [:add_timer, 5.5],
+          :after_timer
+        ] )
+      end
+    end
+
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: client_for_poslynx
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 1.0.0.pre
 platform: ruby
 authors:
 - Steve Jorgensen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-03 00:00:00.000000000 Z
+date: 2015-04-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -113,6 +113,9 @@ files:
 - TODO.txt
 - bin/fake_pos_terminal
 - client_for_poslynx.gemspec
+- examples/em_protocol_example.rb
+- examples/em_session_basic_example.rb
+- examples/em_session_interrupt_example.rb
 - lib/client_for_poslynx.rb
 - lib/client_for_poslynx/bit_sequence.rb
 - lib/client_for_poslynx/data.rb
@@ -176,9 +179,15 @@ files:
 - lib/client_for_poslynx/message_handling/xml_extractor.rb
 - lib/client_for_poslynx/message_handling/xml_lines_buffer.rb
 - lib/client_for_poslynx/net.rb
+- lib/client_for_poslynx/net/em_connector.rb
+- lib/client_for_poslynx/net/em_connector/callback_map.rb
+- lib/client_for_poslynx/net/em_connector/connection_handler.rb
+- lib/client_for_poslynx/net/em_connector/connector_state.rb
+- lib/client_for_poslynx/net/em_connector/event_dispatcher.rb
+- lib/client_for_poslynx/net/em_connector/handles_connection.rb
+- lib/client_for_poslynx/net/em_connector/request_call.rb
 - lib/client_for_poslynx/net/em_protocol.rb
-- lib/client_for_poslynx/net/structured_client.rb
-- lib/client_for_poslynx/net/structured_client/em_connection.rb
+- lib/client_for_poslynx/net/em_session.rb
 - lib/client_for_poslynx/signature_image.rb
 - lib/client_for_poslynx/signature_image/draw.rb
 - lib/client_for_poslynx/signature_image/metrics.rb
@@ -207,8 +216,9 @@ files:
 - spec/client_for_poslynx/message_handling/data_extractor_spec.rb
 - spec/client_for_poslynx/message_handling/xml_extractor_spec.rb
 - spec/client_for_poslynx/message_handling_spec.rb
+- spec/client_for_poslynx/net/em_connector_spec.rb
 - spec/client_for_poslynx/net/em_protocol_spec.rb
-- spec/client_for_poslynx/net/structured_client_spec.rb
+- spec/client_for_poslynx/net/em_session_spec.rb
 - spec/client_for_poslynx/signature_image/to_svg_converter_spec.rb
 - spec/client_for_poslynx/signature_image_spec.rb
 - spec/client_for_poslynx_spec.rb
@@ -230,9 +240,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.2.2
@@ -262,8 +272,9 @@ test_files:
 - spec/client_for_poslynx/message_handling/data_extractor_spec.rb
 - spec/client_for_poslynx/message_handling/xml_extractor_spec.rb
 - spec/client_for_poslynx/message_handling_spec.rb
+- spec/client_for_poslynx/net/em_connector_spec.rb
 - spec/client_for_poslynx/net/em_protocol_spec.rb
-- spec/client_for_poslynx/net/structured_client_spec.rb
+- spec/client_for_poslynx/net/em_session_spec.rb
 - spec/client_for_poslynx/signature_image/to_svg_converter_spec.rb
 - spec/client_for_poslynx/signature_image_spec.rb
 - spec/client_for_poslynx_spec.rb

data/lib/client_for_poslynx/net/structured_client.rb

@@ -1,104 +0,0 @@
-# coding: utf-8
-
-require_relative 'structured_client/em_connection'
-
-module ClientForPoslynx
-  module Net
-
-    # A network client API suitable for use in a Structured (as
-    # oppoesed to Event-Driven) context such as from within an
-    # irb console session.
-    class StructuredClient
-
-      class SessionEndedError  < StandardError ; end
-      class SessionEndingError < StandardError ; end
-
-      # Initializes a new instance, given a host name or address
-      # and a host IP port number. If an SSL connection is
-      # required, then supply true for the use_ssl argument.
-      def initialize(host, port, use_ssl = false)
-        @directive_queue = Queue.new
-        @activity_queue  = Queue.new
-        @em_thread = Thread.new do
-          EM.run do
-            EM.connect host, port, EM_Connection, use_ssl, directive_queue, activity_queue
-            EM.error_handler do |e|
-              raise e
-            end
-          end
-        end
-      end
-
-      # Close the server connection if it is open and end the
-      # session managed by the receiving instance.
-      def end_session
-        return unless em_thread.status
-        directive_queue << :end_session
-        self.session_end_initiated = true
-        em_thread.join
-        nil
-      end
-
-      # Sends a request to the POSLynx system and returns
-      # immediately.
-      # The request object is expected to behave like an
-      # instance of a descendant class of
-      # ClientForPoslynx::Data::Requests::AbstractRequest.
-      def send_request(request_data)
-        if session_ended?
-          raise SessionEndedError, "The session has been closed and cannot be used to send requests"
-        elsif session_ending?
-          raise SessionEndingError, "The session is ending and cannot be used to send requests"
-        end
-        directive_queue << [ :send_request, request_data ]
-        nil
-      end
-
-      # Returns the next available received response, if any.
-      # Returns nil is there are no remaining received responses
-      # to get.
-      # Each response will be an instance of a descendent class
-      # of
-      # ClientForPoslynx::Data::Responses::AbstractResponse.
-      def get_response
-        process_new_activity
-        received_responses.shift
-      end
-
-      # Returns true if the managed session has ended, either
-      # as a result of a call to #end_session or because the
-      # connection was closed by the server or otherwise lost.
-      def session_ended?
-        ! em_thread.status
-      end
-
-      private
-
-      attr_reader :em_thread, :directive_queue, :activity_queue
-      attr_accessor :session_end_initiated
-
-      def session_ending?
-        session_end_initiated && ! session_ended?
-      end
-
-      def process_new_activity
-        until activity_queue.empty?
-          process_activity_entry *activity_queue.shift
-        end
-      end
-
-      def process_activity_entry(kind, data=nil)
-        case kind
-        when :received_response
-          received_responses << data
-        end
-      end
-
-      def received_responses
-        @received_responses ||= []
-      end
-
-    end
-
-  end
-end