analytics-ruby 2.2.5 → 2.4.0

data/spec/segment/analytics/e2e_spec.rb

@@ -1,48 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,244 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,110 +0,0 @@
-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

data/spec/segment/analytics_spec.rb

@@ -1,120 +0,0 @@
-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
-
-      describe '#respond_to?' do
-        it 'responds to all public instance methods of Segment::Analytics::Client' do
-          expect(analytics).to respond_to(*Segment::Analytics::Client.public_instance_methods(false))
-        end
-      end
-
-      describe '#method' do
-        Segment::Analytics::Client.public_instance_methods(false).each do |public_method|
-          it "returns a Method object with '#{public_method}' as argument" do
-            expect(analytics.method(public_method).class).to eq(Method)
-          end
-        end
-      end
-    end
-  end
-end