analytics-ruby 2.0.13 → 2.1.0

data/spec/segment/analytics/request_spec.rb

@@ -0,0 +1,191 @@
+require 'spec_helper'
+
+module Segment
+  class Analytics
+    describe Request do
+      before do
+        # Try and keep debug statements out of tests
+        allow(subject.logger).to receive(:error)
+        allow(subject.logger).to receive(:debug)
+      end
+
+      describe '#initialize' do
+        let!(:net_http) { Net::HTTP.new(anything, anything) }
+
+        before do
+          allow(Net::HTTP).to receive(:new) { net_http }
+        end
+
+        it 'sets an initalized Net::HTTP read_timeout' do
+          expect(net_http).to receive(:use_ssl=)
+          described_class.new
+        end
+
+        it 'sets an initalized Net::HTTP read_timeout' do
+          expect(net_http).to receive(:read_timeout=)
+          described_class.new
+        end
+
+        it 'sets an initalized Net::HTTP open_timeout' do
+          expect(net_http).to receive(:open_timeout=)
+          described_class.new
+        end
+
+        it 'sets the http client' do
+          expect(subject.instance_variable_get(:@http)).to_not be_nil
+        end
+
+        context 'no options are set' do
+          it 'sets a default path' do
+            expect(subject.instance_variable_get(:@path)).to eq(described_class::PATH)
+          end
+
+          it 'sets a default retries' do
+            expect(subject.instance_variable_get(:@retries)).to eq(described_class::RETRIES)
+          end
+
+          it 'sets a default backoff' do
+            expect(subject.instance_variable_get(:@backoff)).to eq(described_class::BACKOFF)
+          end
+
+          it 'initializes a new Net::HTTP with default host and port' do
+            expect(Net::HTTP).to receive(:new).with(described_class::HOST, described_class::PORT)
+            described_class.new
+          end
+        end
+
+        context 'options are given' do
+          let(:path) { 'my/cool/path' }
+          let(:retries) { 1234 }
+          let(:backoff) { 10 }
+          let(:host) { 'http://www.example.com' }
+          let(:port) { 8080 }
+          let(:options) do
+            {
+              path: path,
+              retries: retries,
+              backoff: backoff,
+              host: host,
+              port: port
+            }
+          end
+
+          subject { described_class.new(options) }
+
+          it 'sets passed in path' do
+            expect(subject.instance_variable_get(:@path)).to eq(path)
+          end
+
+          it 'sets passed in retries' do
+            expect(subject.instance_variable_get(:@retries)).to eq(retries)
+          end
+
+          it 'sets passed in backoff' do
+            expect(subject.instance_variable_get(:@backoff)).to eq(backoff)
+          end
+
+          it 'initializes a new Net::HTTP with passed in host and port' do
+            expect(Net::HTTP).to receive(:new).with(host, port)
+            described_class.new(options)
+          end
+        end
+      end
+
+      describe '#post' do
+        let(:response) { Net::HTTPResponse.new(http_version, status_code, response_body) }
+        let(:http_version) { 1.1 }
+        let(:status_code) { 200 }
+        let(:response_body) { {}.to_json }
+        let(:write_key) { 'abcdefg' }
+        let(:batch) { [] }
+
+        before do
+          allow(subject.instance_variable_get(:@http)).to receive(:request) { response }
+          allow(response).to receive(:body) { response_body }
+        end
+
+        it 'initalizes a new Net::HTTP::Post with path and default headers' do
+          path = subject.instance_variable_get(:@path)
+          default_headers = { 'Content-Type' => 'application/json', 'accept' => 'application/json' }
+          expect(Net::HTTP::Post).to receive(:new).with(path, default_headers).and_call_original
+          subject.post(write_key, batch)
+        end
+
+        it 'adds basic auth to the Net::HTTP::Post' do
+          expect_any_instance_of(Net::HTTP::Post).to receive(:basic_auth).with(write_key, nil)
+          subject.post(write_key, batch)
+        end
+
+        context 'with a stub' do
+          before do
+            allow(described_class).to receive(:stub) { true }
+          end
+
+          it 'returns a 200 response' do
+            expect(subject.post(write_key, batch).status).to eq(200)
+          end
+
+          it 'has a nil error' do
+            expect(subject.post(write_key, batch).error).to be_nil
+          end
+
+          it 'logs a debug statement' do
+            expect(subject.logger).to receive(:debug).with(/stubbed request to/)
+            subject.post(write_key, batch)
+          end
+        end
+
+        context 'a real request' do
+          context 'request is successful' do
+            let(:status_code) { 201 }
+            it 'returns a response code' do
+              expect(subject.post(write_key, batch).status).to eq(status_code)
+            end
+
+            it 'returns a nil error' do
+              expect(subject.post(write_key, batch).error).to be_nil
+            end
+          end
+
+          context 'request results in errorful response' do
+            let(:error) { 'this is an error' }
+            let(:response_body) { { error: error }.to_json }
+
+            it 'returns the parsed error' do
+              expect(subject.post(write_key, batch).error).to eq(error)
+            end
+          end
+
+          context 'request or parsing of response results in an exception' do
+            let(:response_body) { 'Malformed JSON ---' }
+
+            let(:backoff) { 0 }
+
+            subject { described_class.new(retries: retries, backoff: backoff) }
+
+            context 'remaining retries is > 1' do
+              let(:retries) { 2 }
+
+              it 'sleeps' do
+                expect(subject).to receive(:sleep).exactly(retries - 1).times
+                subject.post(write_key, batch)
+              end
+            end
+
+            context 'remaining retries is 1' do
+              let(:retries) { 1 }
+
+              it 'returns a -1 for status' do
+                expect(subject.post(write_key, batch).status).to eq(-1)
+              end
+
+              it 'has a connection error' do
+                expect(subject.post(write_key, batch).error).to match(/Connection error/)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/segment/analytics/response_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+module Segment
+  class Analytics
+    describe Response do
+      describe '#status' do
+        it { expect(subject).to respond_to(:status) }
+      end
+
+      describe '#error' do
+        it { expect(subject).to respond_to(:error) }
+      end
+
+      describe '#initialize' do
+        let(:status) { 404 }
+        let(:error) { 'Oh No' }
+
+        subject { described_class.new(status, error) }
+
+        it 'sets the instance variable status' do
+          expect(subject.instance_variable_get(:@status)).to eq(status)
+        end
+
+        it 'sets the instance variable error' do
+          expect(subject.instance_variable_get(:@error)).to eq(error)
+        end
+      end
+    end
+  end
+end

data/spec/segment/analytics/worker_spec.rb

@@ -7,11 +7,11 @@ module Segment
         it 'accepts string keys' do
           queue = Queue.new
           worker = Segment::Analytics::Worker.new(queue, 'secret', 'batch_size' => 100)
-          worker.instance_variable_get(:@batch_size).should == 100
+          expect(worker.instance_variable_get(:@batch_size)).to eq(100)
         end
       end
 
-      describe '#flush' do
+      describe '#run' do
         before :all do
           Segment::Analytics::Defaults::Request::BACKOFF = 0.1
         end
@@ -20,75 +20,81 @@ module Segment
           Segment::Analytics::Defaults::Request::BACKOFF = 30.0
         end
 
-        it 'should not error if the endpoint is unreachable' do
-          Net::HTTP.any_instance.stub(:post).and_raise(Exception)
+        it 'does not error if the endpoint is unreachable' do
+          expect do
+            Net::HTTP.any_instance.stub(:post).and_raise(Exception)
 
-          queue = Queue.new
-          queue << {}
-          worker = Segment::Analytics::Worker.new(queue, 'secret')
-          worker.run
+            queue = Queue.new
+            queue << {}
+            worker = Segment::Analytics::Worker.new(queue, 'secret')
+            worker.run
 
-          queue.should be_empty
+            expect(queue).to be_empty
 
-          Net::HTTP.any_instance.unstub(:post)
+            Net::HTTP.any_instance.unstub(:post)
+          end.to_not raise_error
         end
 
-        it 'should execute the error handler if the request is invalid' do
+        it 'executes the error handler, before the request phase ends, if the request is invalid' do
           Segment::Analytics::Request.any_instance.stub(:post).and_return(Segment::Analytics::Response.new(400, "Some error"))
 
-          on_error = Proc.new do |status, error|
-            puts "#{status}, #{error}"
+          status = error = nil
+          on_error = Proc.new do |yielded_status, yielded_error|
+            sleep 0.2 # Make this take longer than thread spin-up (below)
+            status, error = yielded_status, yielded_error
           end
 
-          on_error.should_receive(:call).once
-
           queue = Queue.new
           queue << {}
           worker = Segment::Analytics::Worker.new queue, 'secret', :on_error => on_error
-          worker.run
+
+          # This is to ensure that Client#flush doesn’t finish before calling the error handler.
+          Thread.new { worker.run }
+          sleep 0.1 # First give thread time to spin-up.
+          sleep 0.01 while worker.is_requesting?
 
           Segment::Analytics::Request::any_instance.unstub(:post)
 
-          queue.should be_empty
+          expect(queue).to be_empty
+          expect(status).to eq(400)
+          expect(error).to eq('Some error')
         end
 
-        it 'should not call on_error if the request is good' do
-
+        it 'does not call on_error if the request is good' do
           on_error = Proc.new do |status, error|
             puts "#{status}, #{error}"
           end
 
-          on_error.should_receive(:call).at_most(0).times
+          expect(on_error).to_not receive(:call)
 
           queue = Queue.new
           queue << Requested::TRACK
           worker = Segment::Analytics::Worker.new queue, 'testsecret', :on_error => on_error
           worker.run
 
-          queue.should be_empty
+          expect(queue).to be_empty
         end
       end
 
       describe '#is_requesting?' do
-        it 'should not return true if there isn\'t a current batch' do
-
+        it 'does not return true if there isn\'t a current batch' do
           queue = Queue.new
           worker = Segment::Analytics::Worker.new(queue, 'testsecret')
 
-          worker.is_requesting?.should == false
+          expect(worker.is_requesting?).to eq(false)
         end
 
-        it 'should return true if there is a current batch' do
+        it 'returns true if there is a current batch' do
           queue = Queue.new
           queue << Requested::TRACK
           worker = Segment::Analytics::Worker.new(queue, 'testsecret')
 
           Thread.new do
             worker.run
-            worker.is_requesting?.should == false
+            expect(worker.is_requesting?).to eq(false)
           end
 
-          eventually { worker.is_requesting?.should be_true }
+          eventually { expect(worker.is_requesting?).to eq(true) }
         end
       end
     end

data/spec/segment/analytics_spec.rb

@@ -6,88 +6,99 @@ module Segment
       let(:analytics) { Segment::Analytics.new :write_key => WRITE_KEY, :stub => true }
 
       describe '#track' do
-        it 'should error without an event' do
+        it 'errors without an event' do
           expect { analytics.track(:user_id => 'user') }.to raise_error(ArgumentError)
         end
 
-        it 'should error without a user_id' do
+        it 'errors without a user_id' do
           expect { analytics.track(:event => 'Event') }.to raise_error(ArgumentError)
         end
 
-        it 'should not error with the required options' do
-          analytics.track Queued::TRACK
-          sleep(1)
+        it 'does not error with the required options' do
+          expect do
+            analytics.track Queued::TRACK
+            sleep(1)
+          end.to_not raise_error
         end
       end
 
-
       describe '#identify' do
-        it 'should error without a user_id' do
+        it 'errors without a user_id' do
           expect { analytics.identify :traits => {} }.to raise_error(ArgumentError)
         end
 
-        it 'should not error with the required options' do
+        it 'does not error with the required options' do
           analytics.identify Queued::IDENTIFY
           sleep(1)
         end
       end
 
       describe '#alias' do
-        it 'should error without from' do
+        it 'errors without from' do
           expect { analytics.alias :user_id => 1234 }.to raise_error(ArgumentError)
         end
 
-        it 'should error without to' do
+        it 'errors without to' do
           expect { analytics.alias :previous_id => 1234 }.to raise_error(ArgumentError)
         end
 
-        it 'should not error with the required options' do
-          analytics.alias ALIAS
-          sleep(1)
+        it 'does not error with the required options' do
+          expect do
+            analytics.alias ALIAS
+            sleep(1)
+          end.to_not raise_error
         end
       end
 
       describe '#group' do
-        it 'should error without group_id' do
+        it 'errors without group_id' do
           expect { analytics.group :user_id => 'foo' }.to raise_error(ArgumentError)
         end
 
-        it 'should error without user_id or anonymous_id' do
+        it 'errors without user_id or anonymous_id' do
           expect { analytics.group :group_id => 'foo' }.to raise_error(ArgumentError)
         end
 
-        it 'should not error with the required options' do
-          analytics.group Queued::GROUP
-          sleep(1)
+        it 'does not error with the required options' do
+          expect do
+            analytics.group Queued::GROUP
+            sleep(1)
+          end.to_not raise_error
         end
       end
 
       describe '#page' do
-        it 'should error without user_id or anonymous_id' do
+        it 'errors without user_id or anonymous_id' do
           expect { analytics.page :name => 'foo' }.to raise_error(ArgumentError)
         end
 
-        it 'should not error with the required options' do
-          analytics.page Queued::PAGE
-          sleep(1)
+        it 'does not error with the required options' do
+          expect do
+            analytics.page Queued::PAGE
+            sleep(1)
+          end.to_not raise_error
         end
       end
 
       describe '#screen' do
-        it 'should error without user_id or anonymous_id' do
+        it 'errors without user_id or anonymous_id' do
           expect { analytics.screen :name => 'foo' }.to raise_error(ArgumentError)
         end
 
-        it 'should not error with the required options' do
-          analytics.screen Queued::SCREEN
-          sleep(1)
+        it 'does not error with the required options' do
+          expect do
+            analytics.screen Queued::SCREEN
+            sleep(1)
+          end.to_not raise_error
         end
       end
 
       describe '#flush' do
-        it 'should flush without error' do
-          analytics.identify Queued::IDENTIFY
-          analytics.flush
+        it 'flushes without error' do
+          expect do
+            analytics.identify Queued::IDENTIFY
+            analytics.flush
+          end.to_not raise_error
         end
       end
     end