hawkei 1.0.0

data/spec/lib/hawkei/api_resource_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+describe Hawkei::APIResource do
+
+  describe '#request' do
+    subject(:resource) { Hawkei::APIResource.request(:post, '/test') }
+
+    context 'valid request' do
+      let(:response) { double('response', code: '200', code_type: Net::HTTPOK, body: {}.to_json) }
+
+      context 'default payload' do
+        let(:expected_payload) {{
+          method:  :post,
+          url:     'http://localhost:4003/test',
+          payload: match(''),
+          use_ssl: false,
+          headers: {
+            accept:             'application/json',
+            content_type:       'application/json',
+            x_api_key:    'acc_xx',
+            x_space_name:       'Hawkei',
+            x_environment_name: 'test'
+          },
+        }}
+
+        after { resource }
+
+        it { expect(Hawkei::Request).to receive(:execute).with(expected_payload).and_return(response)  }
+      end
+
+      context 'with body and post' do
+        let(:expected_payload) {{
+          method:  :post,
+          url:     'http://localhost:4003/test',
+          payload: match("\"test\":true"),
+          use_ssl: false,
+          headers: {
+            accept:             'application/json',
+            content_type:       'application/json',
+            x_api_key:    'acc_xx',
+            x_space_name:       'Hawkei',
+            x_environment_name: 'test'
+          }
+        }}
+
+        after { Hawkei::APIResource.request(:post, '/test', { test: true }) }
+
+        it { expect(Hawkei::Request).to receive(:execute).with(expected_payload).and_return(response)  }
+      end
+
+      context 'with body and get' do
+        let(:expected_payload) {{
+          method:  :get,
+          url:     match("http://localhost:4003/test\\?test=true"),
+          payload: match("\"test\":true"),
+          use_ssl: false,
+          headers: {
+            accept:             'application/json',
+            content_type:       'application/json',
+            x_api_key:    'acc_xx',
+            x_space_name:       'Hawkei',
+            x_environment_name: 'test'
+          }
+        }}
+
+        after { Hawkei::APIResource.request(:get, '/test', { test: true }) }
+
+        it { expect(Hawkei::Request).to receive(:execute).with(expected_payload).and_return(response)  }
+      end
+
+      context 'with overwrite headers tokens' do
+        let(:expected_payload) {{
+          method:  :post,
+          url:     match('http://localhost:4003/test'),
+          payload: match(''),
+          use_ssl: false,
+          headers: {
+            accept:             'application/json',
+            content_type:       'application/json',
+            x_api_key:    'acc_42',
+            x_space_name:       'MySpace',
+            x_environment_name: 'staging'
+          }
+        }}
+
+        after { Hawkei::APIResource.request(:post, '/test', {}, api_key: 'acc_42', space_name: 'MySpace', environment_name: 'staging') }
+
+        it { expect(Hawkei::Request).to receive(:execute).with(expected_payload).and_return(response)  }
+      end
+    end
+
+    context 'with errors' do
+      before { allow(Hawkei::Request).to receive(:execute).and_raise(Hawkei::RequestError.new(response)) }
+
+      context 'with Net::HTTPUnprocessableEntity' do
+        let(:response) { double('response', code: '422', code_type: Net::HTTPUnprocessableEntity, body: {}.to_json, message: 'failed') }
+
+        it { expect { resource }.to_not raise_error }
+      end
+
+      context 'with Net::HTTPBadRequest' do
+        let(:response) { double('response', code: '400', code_type: Net::HTTPBadRequest, body: {}.to_json, message: 'failed') }
+
+        it { expect { resource }.to raise_error(Hawkei::RequestError) }
+      end
+    end
+  end
+
+end

data/spec/lib/hawkei/batch_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Hawkei::Batch do
+
+  describe '.create' do
+    let(:response) { double('Hawkei::Request', body:  "{\"object\":\"batch\",\"id\":41}") }
+    before { allow(Hawkei::Request).to receive(:execute).and_return(response) }
+
+    subject(:create) { Hawkei::Batch.create(data: []) }
+
+    it { is_expected.to be_successful }
+  end
+
+end

data/spec/lib/hawkei/config_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Hawkei::Config do
+  subject(:config) { Hawkei::Config.new(params) }
+
+  describe  '#initialize' do
+    let(:params) {{ api_key: 'acc_xx', space_name: 'Hawkei', environment_name: 'test' }}
+
+    it { expect(config.valid!).to be_truthy }
+
+    %i[api_key environment_name api_host api_version].each do |field|
+      context "validate #{field}" do
+        let(:params) {
+          {
+            api_key: 'acc_xx',
+            space_name: 'Hawkei',
+            environment_name: 'test',
+            api_host: 'host',
+            api_version: 'v1',
+          }.merge(field => '')
+        }
+
+        it { expect { config.valid! }.to raise_error(Hawkei::ConfigurationError, "#{field} can't be blank") }
+      end
+    end
+
+    context 'format obfuscated_fields' do
+      let(:params) {{ api_key: 'acc_xx', space_name: 'Hawkei', environment_name: 'test', obfuscated_fields: %i[another_password password_confirmation] }}
+
+      before { config.valid! }
+
+      it { expect(config.obfuscated_fields).to match_array(%w[another_password password_confirmation password access_token api_key authenticity_token ccv credit_card_number cvv secret secret_token token]) }
+    end
+
+  end
+end

data/spec/lib/hawkei/formated_logger_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+describe Hawkei::FormatedLogger do
+  let(:default_logger) { Logger.new(STDOUT) }
+  let(:logger) { Hawkei::FormatedLogger.build(default_logger) }
+
+  describe 'debug' do
+
+    context 'active' do
+      before do
+        allow(default_logger).to receive(:debug)
+        logger.debug('test')
+      end
+
+      it { expect(default_logger).to have_received(:debug).with('[Hawkei] test') }
+    end
+
+    context 'inactive' do
+      before do
+        Hawkei.configurations.log = false
+        allow(default_logger).to receive(:debug)
+        logger.debug('test')
+      end
+
+      it { expect(default_logger).to_not have_received(:debug) }
+    end
+
+  end
+
+  describe 'info' do
+
+    context 'active' do
+      before do
+        allow(default_logger).to receive(:info)
+        logger.info('test')
+      end
+
+      it { expect(default_logger).to have_received(:info).with('[Hawkei] test') }
+    end
+
+    context 'inactive' do
+      before do
+        Hawkei.configurations.log = false
+        allow(default_logger).to receive(:info)
+        logger.info('test')
+      end
+
+      it { expect(default_logger).to_not have_received(:info) }
+    end
+
+  end
+
+  describe 'info' do
+
+    context 'active' do
+      before do
+        allow(default_logger).to receive(:info)
+        logger.info('test')
+      end
+
+      it { expect(default_logger).to have_received(:info).with('[Hawkei] test') }
+    end
+
+    context 'inactive' do
+      before do
+        Hawkei.configurations.log = false
+        allow(default_logger).to receive(:info)
+        logger.info('test')
+      end
+
+      it { expect(default_logger).to_not have_received(:info) }
+    end
+
+  end
+
+  describe 'error' do
+
+    context 'active' do
+      before do
+        allow(default_logger).to receive(:error)
+        logger.error('test')
+      end
+
+      it { expect(default_logger).to have_received(:error).with('[Hawkei] test') }
+    end
+
+    context 'inactive' do
+      before do
+        Hawkei.configurations.log = false
+        allow(default_logger).to receive(:error)
+        logger.error('test')
+      end
+
+      it { expect(default_logger).to_not have_received(:error) }
+    end
+
+  end
+
+end

data/spec/lib/hawkei/hawkei_object_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+describe Hawkei::HawkeiObject do
+
+  let(:klass) { Class.new(Hawkei::HawkeiObject) }
+  subject(:instance) { klass.new(id: 42, name: 'test', test: true) }
+
+  let(:api_response) {{
+    object: 'event',
+    id:     42,
+    other:  'other test'
+  }}
+
+  let(:api_responses) {{
+    object: 'list',
+    currentPage: 10,
+    data: [{
+      object: 'watcher',
+      id: 42,
+      other: 'other test'
+    }],
+    links: {
+      self: 'http://www.hawkei.io/test'
+    }
+  }}
+
+  describe 'add attribute accessors' do
+    it { expect(instance.id).to eq(42) }
+    it { expect(instance.name).to eq('test') }
+    it { expect(instance.test).to be_truthy }
+    it { expect(instance.test?).to be_truthy }
+  end
+
+  describe 'add array attribute' do
+    it { expect(instance[:id]).to eq(42) }
+    it { expect(instance[:name]).to eq('test') }
+    it { expect(instance[:test]).to be_truthy }
+  end
+
+  describe 'set array attribute' do
+    before { instance[:id] = 84 }
+
+    it { expect(instance.id).to eq(84) }
+    it { expect(instance[:id]).to eq(84) }
+  end
+
+  describe 'method missing' do
+    before { instance.card = '42' }
+
+    it { expect(instance.card).to eq('42') }
+    it { expect { instance.other }.to raise_error(NameError) }
+  end
+
+  describe '#keys' do
+    it { expect(instance.keys).to match_array([:id, :name, :test]) }
+  end
+
+  describe '#to_hash' do
+    it { expect(instance.to_hash).to eq(id: 42, name: 'test', test: true) }
+  end
+
+  describe '#to_json' do
+    it { expect(instance.to_json).to eq(JSON.generate(id: 42, name: 'test', test: true)) }
+  end
+
+  describe '#add_data' do
+    before { instance.add_data(:test) }
+
+    it { expect(instance.data).to match_array([:test]) }
+  end
+
+  describe '#update_attributes' do
+    before { instance.update_attributes(id: 84, other: 'other test') }
+
+    it { expect(instance.id).to eq(84) }
+    it { expect(instance.other).to eq('other test') }
+    it { expect(instance.name).to eq('test') }
+  end
+
+  describe '.initialize_from' do
+    context 'with single object' do
+      subject(:instance) { klass.initialize_from(api_response.to_json) }
+
+      it { is_expected.to be_successful }
+      it { expect(instance.id).to eq(42) }
+      it { expect(instance.other).to eq('other test') }
+      it { expect { instance.name }.to raise_error(NameError) }
+    end
+
+    context 'with array' do
+      subject(:instance) { klass.initialize_from(api_responses.to_json) }
+
+      it { is_expected.to be_successful }
+      it { expect(instance.data.size).to eq(1) }
+      it { expect(instance.data.first).to be_a(Hawkei::Watcher) }
+      it { expect(instance.current_page).to eq(10) }
+      it { expect(instance.links[:self]).to eq('http://www.hawkei.io/test') }
+    end
+
+    context 'with empty string' do
+      subject(:instance) { klass.initialize_from('') }
+
+      it { is_expected.to be_successful }
+    end
+
+    context 'with nil' do
+      subject(:instance) { klass.initialize_from(nil) }
+
+      it { is_expected.to be_successful }
+    end
+  end
+
+  describe '#update_from' do
+    before { instance.update_from(api_response) }
+
+    it { is_expected.to be_successful }
+    it { expect(instance.id).to eq(42) }
+    it { expect(instance.other).to eq('other test') }
+    it { expect { instance.name }.to raise_error(NameError) }
+  end
+
+
+end

data/spec/lib/hawkei/message_spec.rb

@@ -0,0 +1,178 @@
+require 'spec_helper'
+
+describe Hawkei::Message do
+  subject(:base) { Hawkei::Message }
+
+  describe '#base' do
+    let(:expected_hash) {{
+      message_id: kind_of(String),
+      timestamp: kind_of(String),
+      session_tracker_id: kind_of(String),
+    }}
+
+    it { expect(base.base).to match(expected_hash) }
+
+    context 'with store' do
+      before do
+       Hawkei::Store.set(:session_tracker_id, 'hello')
+     end
+
+      let(:expected_hash) {{
+        message_id: kind_of(String),
+        timestamp: kind_of(String),
+        session_tracker_id: 'hello',
+      }}
+
+      it { expect(base.base).to match(expected_hash) }
+    end
+  end
+
+  describe '#extended' do
+    let(:expected_hash) {{
+      message_id: kind_of(String),
+      timestamp: kind_of(String),
+      session_tracker_id: kind_of(String),
+      environment: 'test',
+      library: {
+        name: "hawkei",
+        language: "ruby",
+        version: kind_of(String)
+      },
+      server: {
+        host: kind_of(String),
+        pid: kind_of(Numeric),
+        software: 'rspec'
+      }
+    }}
+
+    it { expect(base.extended).to match(expected_hash) }
+
+    context 'with store' do
+      before do
+       Hawkei::Store.set(:session_tracker_id, 'hello')
+       Hawkei::Store.set(:request,
+        url:        'http://www.test.com/',
+        ssl:        true,
+        host:       'www.test.com',
+        port:       4242,
+        path:       '/',
+        referrer:   'http://www.google.com/',
+        method:     'GET',
+        xhr:        false,
+        user_agent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.94 Safari/537.36',
+        ip:         '127.0.0.1',
+      )
+      Hawkei::Store.set(:worker,
+        name: 'sidekiq',
+        version: '5.0.4',
+        queue: 'chameleon',
+        class: 'Hawkei::AsyncHandlers::Sidekiq',
+        id: '106a61579bc0e7e3d18e3b1c',
+        created_at: '2017-12-15T03:45:10Z',
+        process_at: '2017-12-15T03:45:10Z',
+        args: ['Hawkei::Event']
+      )
+
+      Hawkei::Store.bulk_set(
+        environment:    'production',
+        server_software: 'WEBrick/1.3.1 (Ruby/2.2.7/2017-03-28)'
+      )
+     end
+
+      let(:expected_hash) {{
+        message_id: kind_of(String),
+        timestamp: kind_of(String),
+        session_tracker_id: 'hello',
+        library: {
+          name: 'hawkei',
+          language: 'ruby',
+          version: kind_of(String)
+        },
+        server: {
+          host: kind_of(String),
+          pid: kind_of(Numeric),
+          software: 'WEBrick/1.3.1 (Ruby/2.2.7/2017-03-28)'
+        },
+        request: {
+          url:        'http://www.test.com/',
+          ssl:        true,
+          host:       'www.test.com',
+          port:       4242,
+          path:       '/',
+          referrer:   'http://www.google.com/',
+          method:     'GET',
+          xhr:        false,
+          user_agent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.94 Safari/537.36',
+          ip:         '127.0.0.1',
+        },
+        worker: {
+          name: 'sidekiq',
+          version: '5.0.4',
+          queue: 'chameleon',
+          class: 'Hawkei::AsyncHandlers::Sidekiq',
+          id: '106a61579bc0e7e3d18e3b1c',
+          created_at: '2017-12-15T03:45:10Z',
+          process_at: '2017-12-15T03:45:10Z',
+          args: ['Hawkei::Event']
+        },
+        environment: 'production'
+      }}
+
+      it { expect(base.extended).to match(expected_hash) }
+    end
+
+    context 'with metadata' do
+      let(:expected_hash) {{
+        message_id: kind_of(String),
+        timestamp: kind_of(String),
+        session_tracker_id: kind_of(String),
+        environment: 'test',
+        library: {
+          name: "hawkei",
+          language: "ruby",
+          version: kind_of(String)
+        },
+        server: {
+          host: kind_of(String),
+          pid: kind_of(Numeric),
+          software: 'rspec'
+        },
+        metadata: {
+          deployment_id: 42
+        },
+      }}
+
+      context 'hash type' do
+        before do
+          Hawkei.configurations.metadata = {
+            deployment_id: 42
+          }
+        end
+
+        it { expect(base.extended).to match(expected_hash) }
+      end
+
+      context 'proc type' do
+        before do
+          Hawkei.configurations.metadata = {
+            deployment_id: lambda { 84 / 2 }
+          }
+        end
+
+        it { expect(base.extended).to match(expected_hash) }
+      end
+
+      context 'proc & raise type' do
+        before do
+          Hawkei.configurations.metadata = {
+            deployment_id: -> { 84 / 2 },
+            other_id: -> { hello }
+          }
+        end
+
+        it { expect(base.extended).to match(expected_hash) }
+      end
+    end
+  end
+
+end

data/spec/lib/hawkei/plugins/rack/middleware_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+require 'rack'
+require 'hawkei/plugins/rack/middleware'
+
+describe Hawkei::Plugins::Rack::Middleware do
+
+  let(:app) { lambda { |env| [200, {'Content-Type' => 'text/plain'}, ['All responses are OK']] } }
+  let(:middleware) { Hawkei::Plugins::Rack::Middleware.new(app) }
+
+  context 'reset the store' do
+    before do
+      2.times { middleware.call({}) }
+    end
+
+    it { expect(Hawkei::Store.store).to eq({}) }
+  end
+
+  it 'reset the store with error' do
+    allow(middleware).to receive(:call).and_raise(RuntimeError)
+    expect { middleware.call(error: true) }.to raise_error(RuntimeError)
+
+    expect(Hawkei::Store.store).to eq({})
+  end
+
+  it 'set correct value for cookies' do
+    _status, headers, _body = middleware.call({})
+
+    expect(headers['Set-Cookie']).to match(%r{path=/})
+    expect(headers['Set-Cookie']).to match(%r{max-age=315360000})
+    expect(headers['Set-Cookie']).to_not match(%r{domain})
+  end
+
+  it 'set correct value for cookies with domain' do
+    Hawkei.configurations.domain = "hawkei.io"
+    _status, headers, _body = middleware.call({})
+
+    expect(headers['Set-Cookie']).to match(%r{path=/})
+    expect(headers['Set-Cookie']).to match(%r{max-age=315360000})
+    expect(headers['Set-Cookie']).to match(%r{domain=hawkei.io})
+  end
+
+  it 'store the request' do
+    _status, headers, _body = middleware.call({
+      'hawkei_test' => true,
+      'HTTP_HOST' => '127.0.0.1:3000',
+      'HTTP_REFERER' => 'http://127.0.0.1:3000/?hello=test&password=1234',
+      'HTTP_COOKIE' => 'other',
+      'HTTP_ACCEPT' => 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8',
+      'HTTP_VERSION' => 'HTTP/1.1',
+      'HTTP_USER_AGENT' => 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36',
+      'HTTP_CONTENT_TYPE' => 'application/x-www-form-urlencoded',
+      'HTTP_CACHE_CONTROL' => 'max-age=0',
+      'HTTP_CONTENT_LENGTH' => '190',
+      'HTTP_ACCEPT_ENCODING' => 'gzip, deflate, br',
+      'HTTP_ACCEPT_LANGUAGE' => 'en-US,en;q=0.9,fr;q=0.8,ru;q=0.7',
+    })
+
+    expected = {
+      :url => "",
+      :ssl => false,
+      :host => "127.0.0.1",
+      :port => 3000,
+      :path => "",
+      :referrer => "http://127.0.0.1:3000/?hello=test&password=HIDDEN",
+      :method => nil,
+      :xhr => false,
+      :user_agent => "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36",
+      :ip => nil,
+      :get_params => {},
+      :post_params => {},
+      :headers => {
+        "Accept" => "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8",
+        "Accept-Encoding" => "gzip, deflate, br",
+        "Accept-Language" => "en-US,en;q=0.9,fr;q=0.8,ru;q=0.7",
+        "Cache-Control" => "max-age=0",
+        "Content-Length" => "190",
+        "Content-Type" => "application/x-www-form-urlencoded",
+        "Host" => "127.0.0.1:3000",
+        "Referer" => "http://127.0.0.1:3000/?hello=test&password=1234",
+        "User-Agent" => "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36",
+        "Version" => "HTTP/1.1"
+      }
+    }
+
+    expect(Hawkei::Store.store[:request]).to include(expected)
+  end
+
+end

data/spec/lib/hawkei/plugins/rails/data_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+require 'rails'
+require 'hawkei/plugins/rails/data'
+
+describe Hawkei::Plugins::Rails::Data do
+
+  let(:middleware) { Hawkei::Plugins::Rails::Data }
+
+  describe '#store_data' do
+
+    context 'blank store' do
+      before { middleware.store_data }
+
+      let(:expected) {{
+        environment: kind_of(String)
+      }}
+
+      it { expect(Hawkei::Store.store).to match(expected) }
+    end
+
+  end
+end