Merge pull request #599 from splitio/FME-10903-uograde-sdk

added tests

Author: chillaq

lib/splitclient-rb/sse/event_source/client.rb

@@ -38,7 +38,7 @@ def initialize(config,
 
         def close(status = nil)
           unless connected?
-            log_if_debug('SSEClient already disconected.', 3)
+            @config.logger.debug('SSEClient already disconected.')
             return
           end
 
@@ -76,10 +76,10 @@ def connected?
 
         def connect_thread(latch)
           @config.threads[:connect_stream] = Thread.new do
-            log_if_debug('Starting connect_stream thread ...', 2)
+            @config.logger.info('Starting connect_stream thread ...')
             new_status = connect_stream(latch)
             push_status(new_status)
-            log_if_debug('connect_stream thread finished.', 2)
+            @config.logger.info('connect_stream thread finished.')
           end
         end
 
@@ -93,37 +93,38 @@ def connect_stream(latch)
 
                 raise 'eof exception' if partial_data == :eof
               rescue IO::WaitReadable => e
-                log_if_debug("SSE client transient error: #{e.inspect}", 1)
+                @config.logger.debug("SSE client transient error: #{e.inspect}")
                 IO.select([@socket], nil, nil, @read_timeout)
                 retry
               rescue Errno::ETIMEDOUT => e
-                log_if_debug("SSE read operation timed out!: #{e.inspect}", 3)
+                @config.logger.error("SSE read operation timed out!: #{e.inspect}")
                 return Constants::PUSH_RETRYABLE_ERROR
               rescue EOFError => e
-                log_if_debug("SSE read operation EOF Exception!: #{e.inspect}", 3)
+                @config.logger.error("SSE read operation EOF Exception!: #{e.inspect}")
                 raise 'eof exception'
               rescue  Errno::EAGAIN => e
-                log_if_debug("SSE client transient error: #{e.inspect}", 1)
+                puts "transient error"
+                @config.logger.debug("SSE client transient error: #{e.inspect}")
                 IO.select([@socket], nil, nil, @read_timeout)
                 retry
               rescue Errno::EBADF, IOError => e
-                log_if_debug("SSE read operation EBADF or IOError: #{e.inspect}", 3)
+                @config.logger.error("SSE read operation EBADF or IOError: #{e.inspect}")
                 return nil
               rescue StandardError => e
-                log_if_debug("SSE read operation StandardError: #{e.inspect}", 3)
+                @config.logger.error("SSE read operation StandardError: #{e.inspect}")
                 return nil if ENV['SPLITCLIENT_ENV'] == 'test'
 
-                log_if_debug("Error reading partial data: #{e.inspect}", 3)
+                @config.logger.error("Error reading partial data: #{e.inspect}")
                 return Constants::PUSH_RETRYABLE_ERROR
               end
             else
-              @config.logger.debug("SSE read operation timed out, no data available.")
+              @config.logger.error("SSE read operation timed out, no data available.")
               return Constants::PUSH_RETRYABLE_ERROR
             end
 
             process_data(partial_data)
           end
-          log_if_debug("SSE read operation exited: #{connected?}", 1)
+          @config.logger.info("SSE read operation exited: #{connected?}")
 
           nil
         end
@@ -134,7 +135,7 @@ def socket_write(latch)
           @socket.puts(build_request(@uri))
           true
         rescue StandardError => e
-          log_if_debug("Error during connecting to #{@uri.host}. Error: #{e.inspect}", 3)
+          @config.logger.error("Error during connecting to #{@uri.host}. Error: #{e.inspect}")
           latch.count_down
           false
         end
@@ -189,7 +190,7 @@ def socket_connect
         end
 
         def process_data(partial_data)
-          log_if_debug("Event partial data: #{partial_data}", 1)
+          @config.logger.debug("Event partial data: #{partial_data}")
           return if partial_data.nil? || partial_data == KEEP_ALIVE_RESPONSE
 
           events = @event_parser.parse(partial_data)
@@ -207,7 +208,7 @@ def build_request(uri)
           req << "SplitSDKMachineName: #{@config.machine_name}\r\n"
           req << "SplitSDKClientKey: #{@api_key.split(//).last(4).join}\r\n" unless @api_key.nil?
           req << "Cache-Control: no-cache\r\n\r\n"
-          log_if_debug("Request info: #{req}", 1)
+          @config.logger.debug("Request info: #{req}")
           req
         end
 
@@ -245,19 +246,6 @@ def push_status(status)
           @config.logger.debug("Pushing new sse status: #{status}")
           @status_queue.push(status)
         end
-
-        def log_if_debug(text, level)
-          if @config.debug_enabled
-            case level
-            when 1
-              @config.logger.debug(text)
-            when 2
-              @config.logger.info(text)
-            else
-              @config.logger.error(text)
-            end
-          end
-        end
       end
     end
   end

spec/sse/event_source/client_spec.rb

@@ -2,6 +2,7 @@
 
 require 'spec_helper'
 require 'http_server_mock'
+require 'rspec/mocks'
 
 describe SplitIoClient::SSE::EventSource::Client do
   subject { SplitIoClient::SSE::EventSource::Client }
@@ -266,6 +267,72 @@
         stop_workers
       end
     end
+
+    it 'test exceptions' do
+      mock_server do |server|
+        server.setup_response('/') do |_, res|
+          send_stream_content(res, event_split_update)
+        end
+        start_workers
+
+        sse_client = subject.new(config, api_token, telemetry_runtime_producer, event_parser, notification_manager_keeper, notification_processor, push_status_queue)
+
+        sse_client.instance_variable_set(:@uri, URI(server.base_uri))
+        latch = Concurrent::CountDownLatch.new(1)
+
+        allow(sse_client).to receive(:read_first_event).and_raise(Errno::ETIMEDOUT)
+        sse_client.send(:connect_stream, latch)
+        expect(log.string).to include 'SSE read operation timed out!'
+
+        allow(sse_client).to receive(:read_first_event).and_raise(EOFError)
+        expect { sse_client.send(:connect_stream, latch) }.to raise_error(RuntimeError)
+        expect(log.string).to include 'SSE read operation EOF Exception!'
+
+        allow(sse_client).to receive(:read_first_event).and_raise(Errno::EBADF)
+        sse_client.send(:connect_stream, latch)
+        expect(log.string).to include 'SSE read operation EBADF or IOError'
+
+        allow(sse_client).to receive(:read_first_event).and_raise(IOError)
+        sse_client.send(:connect_stream, latch)
+        expect(log.string).to include 'SSE read operation EBADF or IOError'
+
+        allow(sse_client).to receive(:read_first_event).and_raise(StandardError)
+        sse_client.send(:connect_stream, latch)
+        expect(log.string).to include 'SSE read operation StandardError:'
+
+        stop_workers
+      end
+    end
+
+    it 'test retry with EAGAIN and IO::WaitReadable exceptions' do
+      mock_server do |server|
+        server.setup_response('/') do |_, res|
+          send_stream_content(res, event_split_update)
+        end
+        start_workers
+
+        sse_client = subject.new(config, api_token, telemetry_runtime_producer, event_parser, notification_manager_keeper, notification_processor, push_status_queue)
+
+        sse_client.instance_variable_set(:@uri, URI(server.base_uri))
+        latch = Concurrent::CountDownLatch.new(1)
+
+        allow(sse_client).to receive(:read_first_event).and_raise(Errno::EAGAIN)
+        thr1 = Thread.new do
+          sse_client.send(:connect_stream, latch)
+        end        
+        allow(sse_client).to receive(:read_first_event).and_return(true)
+        expect(thr1.status).to eq('run')
+        
+        allow(sse_client).to receive(:read_first_event).and_raise(IO::WaitReadable)
+        thr2 = Thread.new do
+          sse_client.send(:connect_stream, latch)
+        end        
+        allow(sse_client).to receive(:read_first_event).and_return(true)
+        expect(thr2.status).to eq('run')
+
+        stop_workers
+      end
+    end
   end
 
   private