segment 2.2.5

data/spec/segment/analytics/e2e_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+module Segment
+  # End-to-end tests that send events to a segment source and verifies that a
+  # webhook connected to the source (configured manually via the app) is able
+  # to receive the data sent by this library.
+  describe 'End-to-end tests', e2e: true do
+    # Segment write key for
+    # https://app.segment.com/segment-libraries/sources/analytics_ruby_e2e_test/overview.
+    #
+    # This source is configured to send events to the Runscope bucket used by
+    # this test.
+    WRITE_KEY = 'qhdMksLsQTi9MES3CHyzsWRRt4ub5VM6'
+
+    # Runscope bucket key for https://www.runscope.com/stream/umkvkgv7ndby
+    RUNSCOPE_BUCKET_KEY = 'umkvkgv7ndby'
+
+    let(:client) { Segment::Analytics.new(write_key: WRITE_KEY) }
+    let(:runscope_client) { RunscopeClient.new(ENV.fetch('RUNSCOPE_TOKEN')) }
+
+    it 'tracks events' do
+      id = SecureRandom.uuid
+      client.track(
+        user_id: 'dummy_user_id',
+        event: 'E2E Test',
+        properties: { id: id }
+      )
+      client.flush
+
+      # Allow events to propagate to runscope
+      eventually(timeout: 30) {
+        expect(has_matching_request?(id)).to eq(true)
+      }
+    end
+
+    def has_matching_request?(id)
+      captured_requests = runscope_client.requests(RUNSCOPE_BUCKET_KEY)
+      captured_requests.any? do |request|
+        begin
+          body = JSON.parse(request['body'])
+          body['properties'] && body['properties']['id'] == id
+        rescue JSON::ParserError
+          false
+        end
+      end
+    end
+  end
+end

data/spec/segment/analytics/message_batch_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+module Segment
+  class Analytics
+    describe MessageBatch do
+      subject { described_class.new(100) }
+
+      describe '#<<' do
+        it 'appends messages' do
+          subject << Message.new('a' => 'b')
+          expect(subject.length).to eq(1)
+        end
+
+        it 'rejects messages that exceed the maximum allowed size' do
+          max_bytes = Defaults::Message::MAX_BYTES
+          hash = { 'a' => 'b' * max_bytes }
+          message = Message.new(hash)
+
+          subject << message
+          expect(subject.length).to eq(0)
+        end
+      end
+
+      describe '#full?' do
+        it 'returns true once item count is exceeded' do
+          99.times { subject << Message.new(a: 'b') }
+          expect(subject.full?).to be(false)
+
+          subject << Message.new(a: 'b')
+          expect(subject.full?).to be(true)
+        end
+
+        it 'returns true once max size is almost exceeded' do
+          message = Message.new(a: 'b' * (Defaults::Message::MAX_BYTES - 10))
+
+          # Each message is under the individual limit
+          expect(message.json_size).to be < Defaults::Message::MAX_BYTES
+
+          # Size of the batch is over the limit
+          expect(50 * message.json_size).to be > Defaults::MessageBatch::MAX_BYTES
+
+          expect(subject.full?).to be(false)
+          50.times { subject << message }
+          expect(subject.full?).to be(true)
+        end
+      end
+    end
+  end
+end

data/spec/segment/analytics/message_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+module Segment
+  class Analytics
+    describe Message do
+      describe '#to_json' do
+        it 'caches JSON conversions' do
+          # Keeps track of the number of times to_json was called
+          nested_obj = Class.new do
+            attr_reader :to_json_call_count
+
+            def initialize
+              @to_json_call_count = 0
+            end
+
+            def to_json(*_)
+              @to_json_call_count += 1
+              '{}'
+            end
+          end.new
+
+          message = Message.new('some_key' => nested_obj)
+          expect(nested_obj.to_json_call_count).to eq(0)
+
+          message.to_json
+          expect(nested_obj.to_json_call_count).to eq(1)
+
+          # When called a second time, the call count shouldn't increase
+          message.to_json
+          expect(nested_obj.to_json_call_count).to eq(1)
+        end
+      end
+    end
+  end
+end

data/spec/segment/analytics/request_spec.rb

@@ -0,0 +1,244 @@
+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
+            path = subject.instance_variable_get(:@path)
+            expect(path).to eq(described_class::PATH)
+          end
+
+          it 'sets a default retries' do
+            retries = subject.instance_variable_get(:@retries)
+            expect(retries).to eq(described_class::RETRIES)
+          end
+
+          it 'sets a default backoff policy' do
+            backoff_policy = subject.instance_variable_get(:@backoff_policy)
+            expect(backoff_policy).to be_a(Segment::Analytics::BackoffPolicy)
+          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_policy) { FakeBackoffPolicy.new([1, 2, 3]) }
+          let(:host) { 'http://www.example.com' }
+          let(:port) { 8080 }
+          let(:options) do
+            {
+              path: path,
+              retries: retries,
+              backoff_policy: backoff_policy,
+              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 backoff policy' do
+            expect(subject.instance_variable_get(:@backoff_policy))
+              .to eq(backoff_policy)
+          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
+          http = subject.instance_variable_get(:@http)
+          allow(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',
+            'User-Agent' => "analytics-ruby/#{Analytics::VERSION}"
+          }
+          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
+          RSpec.shared_examples('retried request') do |status_code, body|
+            let(:status_code) { status_code }
+            let(:body) { body }
+            let(:retries) { 4 }
+            let(:backoff_policy) { FakeBackoffPolicy.new([1000, 1000, 1000]) }
+            subject {
+              described_class.new(retries: retries,
+                                  backoff_policy: backoff_policy)
+            }
+
+            it 'retries the request' do
+              expect(subject)
+                .to receive(:sleep)
+                .exactly(retries - 1).times
+                .with(1)
+                .and_return(nil)
+              subject.post(write_key, batch)
+            end
+          end
+
+          RSpec.shared_examples('non-retried request') do |status_code, body|
+            let(:status_code) { status_code }
+            let(:body) { body }
+            let(:retries) { 4 }
+            let(:backoff) { 1 }
+            subject { described_class.new(retries: retries, backoff: backoff) }
+
+            it 'does not retry the request' do
+              expect(subject)
+                .to receive(:sleep)
+                .never
+              subject.post(write_key, batch)
+            end
+          end
+
+          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 'a request returns a failure status code' do
+            # Server errors must be retried
+            it_behaves_like('retried request', 500, '{}')
+            it_behaves_like('retried request', 503, '{}')
+
+            # All 4xx errors other than 429 (rate limited) must be retried
+            it_behaves_like('retried request', 429, '{}')
+            it_behaves_like('non-retried request', 404, '{}')
+            it_behaves_like('non-retried request', 400, '{}')
+          end
+
+          context 'request or parsing of response results in an exception' do
+            let(:response_body) { 'Malformed JSON ---' }
+
+            subject { described_class.new(retries: 0) }
+
+            it 'returns a -1 for status' do
+              expect(subject.post(write_key, batch).status).to eq(-1)
+            end
+
+            it 'has a connection error' do
+              error = subject.post(write_key, batch).error
+              expect(error).to match(/Connection error/)
+            end
+
+            it_behaves_like('retried request', 200, 'Malformed JSON ---')
+          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,110 @@
+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)
+          batch = worker.instance_variable_get(:@batch)
+          expect(batch.instance_variable_get(:@max_message_count)).to eq(100)
+        end
+      end
+
+      describe '#run' 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'))
+
+          status = error = nil
+          on_error = proc do |yielded_status, yielded_error|
+            sleep 0.2 # Make this take longer than thread spin-up (below)
+            status, error = yielded_status, yielded_error
+          end
+
+          queue = Queue.new
+          queue << {}
+          worker = described_class.new(queue, 'secret', :on_error => on_error)
+
+          # 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)
+
+          expect(queue).to be_empty
+          expect(status).to eq(400)
+          expect(error).to eq('Some error')
+        end
+
+        it 'does not call on_error if the request is good' do
+          on_error = proc do |status, error|
+            puts "#{status}, #{error}"
+          end
+
+          expect(on_error).to_not receive(:call)
+
+          queue = Queue.new
+          queue << Requested::TRACK
+          worker = described_class.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')
+
+          worker_thread = Thread.new { worker.run }
+          eventually { expect(worker.is_requesting?).to eq(true) }
+
+          worker_thread.join
+          expect(worker.is_requesting?).to eq(false)
+        end
+      end
+    end
+  end
+end