astronomer 2.0.14

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

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+module Segment
+  class Analytics
+    describe Worker do
+      describe "#init" do
+        it 'accepts string keys' do
+          queue = Queue.new
+          worker = Segment::Analytics::Worker.new(queue, 'secret', 'batch_size' => 100)
+          expect(worker.instance_variable_get(:@batch_size)).to eq(100)
+        end
+      end
+
+      describe '#flush' do
+        before :all do
+          Segment::Analytics::Defaults::Request::BACKOFF = 0.1
+        end
+
+        after :all do
+          Segment::Analytics::Defaults::Request::BACKOFF = 30.0
+        end
+
+        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
+
+            expect(queue).to be_empty
+
+            Net::HTTP.any_instance.unstub(:post)
+          end.to_not raise_error
+        end
+
+        it 'executes the error handler 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}"
+          end
+
+          expect(on_error).to receive(:call).once
+
+          queue = Queue.new
+          queue << {}
+          worker = Segment::Analytics::Worker.new queue, 'secret', :on_error => on_error
+          worker.run
+
+          Segment::Analytics::Request::any_instance.unstub(:post)
+
+          expect(queue).to be_empty
+        end
+
+        it 'does not call on_error if the request is good' do
+          on_error = Proc.new do |status, error|
+            puts "#{status}, #{error}"
+          end
+
+          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
+
+          expect(queue).to be_empty
+        end
+      end
+
+      describe '#is_requesting?' do
+        it 'does not return true if there isn\'t a current batch' do
+          queue = Queue.new
+          worker = Segment::Analytics::Worker.new(queue, 'testsecret')
+
+          expect(worker.is_requesting?).to eq(false)
+        end
+
+        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
+            expect(worker.is_requesting?).to eq(false)
+          end
+
+          eventually { expect(worker.is_requesting?).to eq(true) }
+        end
+      end
+    end
+  end
+end

data/spec/segment/analytics_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+module Segment
+  class Analytics
+    describe Analytics do
+      let(:analytics) { Segment::Analytics.new :write_key => WRITE_KEY, :stub => true }
+
+      describe '#track' do
+        it 'errors without an event' do
+          expect { analytics.track(:user_id => 'user') }.to raise_error(ArgumentError)
+        end
+
+        it 'errors without a user_id' do
+          expect { analytics.track(:event => 'Event') }.to raise_error(ArgumentError)
+        end
+
+        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 'errors without a user_id' do
+          expect { analytics.identify :traits => {} }.to raise_error(ArgumentError)
+        end
+
+        it 'does not error with the required options' do
+          analytics.identify Queued::IDENTIFY
+          sleep(1)
+        end
+      end
+
+      describe '#alias' do
+        it 'errors without from' do
+          expect { analytics.alias :user_id => 1234 }.to raise_error(ArgumentError)
+        end
+
+        it 'errors without to' do
+          expect { analytics.alias :previous_id => 1234 }.to raise_error(ArgumentError)
+        end
+
+        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 'errors without group_id' do
+          expect { analytics.group :user_id => 'foo' }.to raise_error(ArgumentError)
+        end
+
+        it 'errors without user_id or anonymous_id' do
+          expect { analytics.group :group_id => 'foo' }.to raise_error(ArgumentError)
+        end
+
+        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 'errors without user_id or anonymous_id' do
+          expect { analytics.page :name => 'foo' }.to raise_error(ArgumentError)
+        end
+
+        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 'errors without user_id or anonymous_id' do
+          expect { analytics.screen :name => 'foo' }.to raise_error(ArgumentError)
+        end
+
+        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 'flushes without error' do
+          expect do
+            analytics.identify Queued::IDENTIFY
+            analytics.flush
+          end.to_not raise_error
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,81 @@
+require 'segment/analytics'
+require 'wrong'
+require 'active_support/time'
+
+include Wrong
+
+# Setting timezone for ActiveSupport::TimeWithZone to UTC
+Time.zone = 'UTC'
+
+module Segment
+  class Analytics
+    WRITE_KEY = 'testsecret'
+
+    TRACK = {
+      :event => 'Ruby Library test event',
+      :properties => {
+        :type => 'Chocolate',
+        :is_a_lie => true,
+        :layers => 20,
+        :created =>  Time.new
+      }
+    }
+
+    IDENTIFY =  {
+      :traits => {
+        :likes_animals => true,
+        :instrument => 'Guitar',
+        :age => 25
+      }
+    }
+
+    ALIAS = {
+      :previous_id => 1234,
+      :user_id => 'abcd'
+    }
+
+    GROUP = {}
+
+    PAGE = {
+      :name => 'home'
+    }
+
+    SCREEN = {
+      :name => 'main'
+    }
+
+    USER_ID = 1234
+    GROUP_ID = 1234
+
+    # Hashes sent to the client, snake_case
+    module Queued
+      TRACK = TRACK.merge :user_id => USER_ID
+      IDENTIFY = IDENTIFY.merge :user_id => USER_ID
+      GROUP = GROUP.merge :group_id => GROUP_ID, :user_id => USER_ID
+      PAGE = PAGE.merge :user_id => USER_ID
+      SCREEN = SCREEN.merge :user_id => USER_ID
+    end
+
+    # Hashes which are sent from the worker, camel_cased
+    module Requested
+      TRACK = TRACK.merge({
+        :userId => USER_ID,
+        :type => 'track'
+      })
+
+      IDENTIFY = IDENTIFY.merge({
+        :userId => USER_ID,
+        :type => 'identify'
+      })
+
+      GROUP = GROUP.merge({
+        :groupId => GROUP_ID,
+        :userId => USER_ID,
+        :type => 'group'
+      })
+
+      PAGE = PAGE.merge :userId => USER_ID
+      SCREEN = SCREEN.merge :userId => USER_ID
+    end
+  end
+end