hawkei 1.0.0

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

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'rails'
+require 'hawkei/plugins/rails/middleware_data'
+
+describe Hawkei::Plugins::Rails::MiddlewareData do
+
+  let(:middleware) { Hawkei::Plugins::Rails::MiddlewareData }
+
+  describe '#store_data' do
+    let(:request) do
+      double('request',
+        env: {
+          'action_dispatch.request_id' => '42a'
+        }
+      )
+    end
+
+    context 'blank store' do
+      before { middleware.store_data(request) }
+
+      let(:expected) {{
+        request: {
+          id: '42a'
+        }
+      }}
+
+      it { expect(Hawkei::Store.store).to match(expected) }
+    end
+
+    context 'update the store' do
+      before do
+        Hawkei::Store.set(:request, { xhr: false })
+      end
+      before { middleware.store_data(request) }
+
+      let(:expected) {{
+        request: {
+          id: '42a',
+          xhr: false
+        }
+      }}
+
+      it { expect(Hawkei::Store.store).to match(expected) }
+    end
+  end
+end

data/spec/lib/hawkei/plugins/sidekiq/client_middleware_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+require 'sidekiq'
+require 'hawkei/plugins/sidekiq/client_middleware'
+
+describe Hawkei::Plugins::Sidekiq::ClientMiddleware do
+
+  let(:middleware) { Hawkei::Plugins::Sidekiq::ClientMiddleware.new }
+
+  describe '#call' do
+    before { Hawkei::Store.set(:tracker_id, 1) }
+
+    it { expect { middleware.call('MyWorker', {}, 'default', {}) {} }.to_not raise_error }
+  end
+
+end

data/spec/lib/hawkei/plugins/sidekiq/server_middleware_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+require 'sidekiq'
+require 'hawkei/plugins/sidekiq/server_middleware'
+
+describe Hawkei::Plugins::Sidekiq::ServerMiddleware do
+
+  let(:middleware) { Hawkei::Plugins::Sidekiq::ServerMiddleware.new }
+
+  describe '#call' do
+    let(:job_attr) {{
+       'class' => 'MyWorker',
+       'args' => ['42'],
+       'retry' => 3,
+       'queue' => 'default',
+       'jid' => '24cc849f71325b62ef470901',
+       'created_at' => 1513299839.2563882,
+       '_hawkei_stid' => '06a09f70-6219-4860-babc-18aa47a62f7f',
+       'enqueued_at' => 1513300328.8271549,
+       'error_message' => 'exit',
+       'error_class' => 'SystemExit',
+       'failed_at' => 1513300166.646098,
+       'retry_count' => 1,
+       'retried_at' => 1513300238.6037261
+    }}
+
+    context 'expected to be clean at the end' do
+      before { middleware.call('MyWorker', job_attr, 'default') {} }
+
+      it { expect(Hawkei::Store.store).to be_empty }
+    end
+
+    context 'expected to be clean at the end' do
+      before { allow(Hawkei::Store).to receive(:clear!).and_return(true) }
+      before { middleware.call('MyWorker', job_attr, 'default') {} }
+
+      let(:expected) {{
+        session_tracker_id: '06a09f70-6219-4860-babc-18aa47a62f7f',
+        server_software: include("Sidekiq"),
+        worker:  {
+          name: 'sidekiq',
+          version: kind_of(String),
+          queue: 'default',
+          class: 'MyWorker',
+          id: '24cc849f71325b62ef470901',
+          created_at: '2017-12-15T01:03:59.256Z',
+          process_at: '2017-12-15T01:12:08.827Z',
+          args: ['42'],
+          retried: true,
+          retry_number: 1,
+          failed_at: '2017-12-15T01:09:26.646Z'
+        },
+      }}
+
+      it { expect(Hawkei::Store.store).to match(expected) }
+    end
+  end
+
+end

data/spec/lib/hawkei/processor/async_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Hawkei::Processor::Async do
+
+  let(:processor) { Hawkei::Processor::Async.new }
+
+  context 'enqueue a message' do
+    before do
+      allow(processor).to receive(:ensure_worker_running)
+      processor.enqueue({ test: 'hello' })
+    end
+
+    it { expect(processor).to have_received(:ensure_worker_running) }
+    it { expect(processor.instance_variable_get(:@queue).length).to eq(1) }
+  end
+
+  context 'shutting down worker' do
+    before do
+      allow_message_expectations_on_nil
+
+      allow(processor.instance_variable_get(:@state_worker)).to receive(:make_false)
+      allow(processor.instance_variable_get(:@worker_thread)).to receive(:wait)
+      allow(Concurrent.global_io_executor).to receive(:shutdown)
+      allow(Concurrent.global_io_executor).to receive(:wait_for_termination)
+
+      processor.send(:shutdown_worker)
+    end
+
+    it { expect(processor.instance_variable_get(:@state_worker)).to have_received(:make_false) }
+    it { expect(processor.instance_variable_get(:@worker_thread)).to have_received(:wait) }
+    it { expect(Concurrent.global_io_executor).to have_received(:shutdown) }
+    it { expect(Concurrent.global_io_executor).to have_received(:wait_for_termination) }
+    it { expect(processor.instance_variable_get(:@queue).length).to eq(1) }
+  end
+
+end

data/spec/lib/hawkei/processor/batch_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Hawkei::Processor::Batch do
+  let(:batch) { Hawkei::Processor::Batch.new }
+
+  context 'set defaults' do
+    it { expect(batch.messages).to eq([]) }
+    it { expect(batch.can_retry?).to be_truthy }
+    it { expect(batch.full?).to be_falsey }
+    it { expect(batch.empty?).to be_truthy }
+  end
+
+  context 'add message' do
+    before { batch << { test: 'hello' }}
+
+    it { expect(batch.messages).to eq([{ test: 'hello' }]) }
+    it { expect(batch.full?).to be_falsey }
+    it { expect(batch.empty?).to be_falsey }
+  end
+
+  context 'with extended task' do
+    before { batch.update_retry }
+
+    it { expect(batch.can_retry?).to be_truthy }
+    it { expect(batch.next_retry).to eq(2) }
+  end
+
+  context 'with extended task' do
+    before do
+      11.times { batch.update_retry }
+    end
+
+    it { expect(batch.can_retry?).to be_falsey }
+    it { expect(batch.next_retry).to eq(60) }
+  end
+
+  context 'with max number of messages reached' do
+    before { 100.times { batch << { test: 'hello' }}}
+
+    it { expect(batch.full?).to be_truthy }
+    it { expect(batch.empty?).to be_falsey }
+  end
+
+  context 'with max size reached' do
+    before { 20.times { batch << 1000.times.map {{ test: 'hello' }}}}
+
+    it { expect(batch.full?).to be_truthy }
+    it { expect(batch.empty?).to be_falsey }
+  end
+
+end

data/spec/lib/hawkei/processor/worker_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+describe Hawkei::Processor::Worker do
+  let(:state_worker) { Concurrent::AtomicBoolean.new(true) }
+  let(:queue) { Queue.new }
+  let(:worker) { Hawkei::Processor::Worker.new(queue, state_worker) }
+  let!(:current_batch) { worker.instance_variable_get(:@batch) }
+
+  describe 'private#add_message_to_batch' do
+    context 'add to batch' do
+      let(:message) { Object.new }
+      before { worker.send(:add_message_to_batch, message) }
+
+      it { expect(current_batch.messages).to eq([message]) }
+    end
+
+    context 'with batch full' do
+      before do
+        allow(current_batch).to receive(:full?).and_return(true)
+        allow(worker).to receive(:flush)
+        worker.send(:add_message_to_batch, Object.new)
+      end
+
+      it { expect(worker).to have_received(:flush) }
+    end
+
+    context 'call flush' do
+      before do
+        allow(worker).to receive(:flush)
+        worker.send(:add_message_to_batch, Hawkei::Processor::Worker::FLUSH_MESSAGE)
+      end
+
+      it { expect(worker).to have_received(:flush) }
+    end
+  end
+
+  describe 'private#flush' do
+    before do
+      allow(current_batch).to receive(:empty?).and_return(batch_status)
+      allow(worker).to receive(:send_batch)
+      worker.send(:flush)
+    end
+
+    context 'with not empty batch' do
+      let(:batch_status) { false }
+
+      it { expect(worker).to have_received(:send_batch).with(current_batch) }
+      it { expect(current_batch).to_not eq(worker.instance_variable_get(:@batch)) }
+    end
+
+    context 'with empty batch' do
+      let(:batch_status) { true }
+
+      it { expect(worker).to_not have_received(:send_batch) }
+      it { expect(current_batch).to eq(worker.instance_variable_get(:@batch)) }
+    end
+  end
+
+  describe 'private#send_batch' do
+    let(:batch) { Hawkei::Processor::Batch.new }
+    let(:batch_can_retry) { true }
+
+    before do
+      allow(Hawkei::Request).to receive(:execute).and_return(response)
+      allow(batch).to receive(:update_retry)
+      allow(batch).to receive(:can_retry?).and_return(batch_can_retry)
+      allow(Concurrent::ScheduledTask).to receive(:new)
+      worker.send(:send_batch, batch)
+      sleep(0.1)
+    end
+
+    context 'with valid request' do
+      let(:response) { double('Hawkei::Request', body: "{\"object\":\"batch\",\"id\":41}") }
+
+      it { expect(Hawkei::Request).to have_received(:execute) }
+      it { expect(batch).to_not have_received(:update_retry) }
+      it { expect(worker.instance_variable_get(:@promises).size).to eq(0) }
+    end
+
+    context 'with invalid request' do
+      let(:response) { nil }
+
+      it { expect(Hawkei::Request).to have_received(:execute) }
+      it { expect(batch).to have_received(:update_retry) }
+      it { expect(Concurrent::ScheduledTask).to have_received(:new) }
+      it { expect(worker.instance_variable_get(:@promises).size).to eq(1) }
+    end
+
+    context 'with batch exhausted request' do
+      let(:batch_can_retry) { false }
+      let(:response) { nil }
+
+      it { expect(Hawkei::Request).to have_received(:execute) }
+      it { expect(batch).to have_received(:update_retry) }
+      it { expect(Concurrent::ScheduledTask).to_not have_received(:new) }
+      it { expect(worker.instance_variable_get(:@promises).size).to eq(0) }
+    end
+  end
+
+end

data/spec/lib/hawkei/store_spec.rb

@@ -0,0 +1,82 @@
+
+require 'spec_helper'
+
+describe Hawkei::Store do
+
+  subject(:store) { Hawkei::Store }
+
+  describe '.store' do
+    it { expect(store.store).to eq({})}
+  end
+
+  describe '.store' do
+    before { store.clear! }
+    it { expect(store.store).to eq({})}
+
+    context 'with values' do
+      before { store.set(:test, 'value') }
+      before { store.clear! }
+
+      it { expect(store.store).to eq({}) }
+    end
+  end
+
+  describe '.load_from_hash' do
+    context 'with hash' do
+      before { store.load_from_hash('test' => 'value', another: 'another_value') }
+
+      it { expect(store.store).to match(test: 'value', another: 'another_value') }
+    end
+
+    it { expect { store.load_from_hash(nil) }.to_not raise_error }
+  end
+
+  describe '.set' do
+    before { store.set(:test, 'value') }
+
+    it { expect(store.store).to eq(test: 'value') }
+  end
+
+  describe '[]=' do
+    before { store[:test] = 'value' }
+
+    it { expect(store.store).to eq(test: 'value') }
+  end
+
+  describe '.get' do
+    before { store.set(:test, 'value') }
+
+    it { expect(store.get(:test)).to eq('value') }
+  end
+
+  describe '[]' do
+    before { store[:test] = 'value' }
+
+    it { expect(store[:test]).to eq('value') }
+  end
+
+  describe '.bulk_set' do
+    before { store[:test] = 'value' }
+    before { store.bulk_set(new_test: 'value', another: 'another_value') }
+
+    it { expect(store.store).to match(test: 'value', new_test: 'value', another: 'another_value') }
+  end
+
+  describe '.exist?' do
+    before { store.set(:test, 'value') }
+
+    it { expect(store.exist?(:test)).to be_truthy }
+    it { expect(store.exist?(:something)).to be_falsey }
+  end
+
+  describe '.exist?' do
+    before { store.set(:test, 'value') }
+    before { store.delete(:test)}
+
+    it { expect(store.exist?(:test)).to be_falsey }
+
+    context 'value does not exist' do
+      it { expect { store.delete(:something) }.to_not raise_error }
+    end
+  end
+end

data/spec/lib/hawkei/util_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+describe Hawkei::Util do
+
+  describe '#camelize' do
+    it { expect(Hawkei::Util.except_keys({ a: 1, b: 2 }, :b)).to eq({ a: 1 }) }
+  end
+
+  describe '#camelize' do
+    it { expect(Hawkei::Util.camelize('model')).to eq("Model") }
+    it { expect(Hawkei::Util.camelize('my_model')).to eq("MyModel") }
+  end
+
+  describe '#compact' do
+    it { expect(Hawkei::Util.compact(test: nil, other: 'test')).to eq(other: 'test') }
+  end
+
+  describe '#deep_compact' do
+    let(:payload) {{
+      my_key: 'test',
+      empty_key: nil,
+      another_key: {
+        last_key: 42,
+        valid_key: 'test',
+        empty_key: nil,
+        yet_another_key: {
+          empty_key: nil
+        }
+      }
+    }}
+
+    let(:expected) {{
+      my_key: 'test',
+      another_key: {
+        last_key: 42,
+        valid_key: 'test'
+      }
+    }}
+    it { expect(Hawkei::Util.deep_compact(payload)).to eq(expected) }
+  end
+
+  describe '#encode_parameters' do
+    it { expect(Hawkei::Util.encode_parameters(id: 42, other: 'test')).to eq("id=42&other=test") }
+  end
+
+  describe '#underscore' do
+    it { expect(Hawkei::Util.underscore('Model')).to eq("model") }
+    it { expect(Hawkei::Util.underscore('MyModel')).to eq("my_model") }
+  end
+
+  describe '#deep_underscore_key' do
+    let(:payload) {{
+      'MyKey' => 'test',
+      'anotherKey' => {
+        'lastKey' => 'test',
+        'valid_key' => 'test'
+      }
+    }}
+
+    let(:expected) {{
+      my_key: 'test',
+      another_key: {
+        last_key: 'test',
+        valid_key: 'test'
+      }
+    }}
+
+    it { expect(Hawkei::Util.deep_underscore_key(payload)).to eq(expected) }
+  end
+
+  describe '#deep_stringify_key' do
+    let(:payload) {{
+      my_key: 'test',
+      another_key: {
+        last_key: 'test',
+        valid_key: 'test'
+      }
+    }}
+
+    let(:expected) {{
+      'my_key' => 'test',
+      'another_key' => {
+        'last_key' => 'test',
+        'valid_key' => 'test'
+      }
+    }}
+
+    it { expect(Hawkei::Util.deep_stringify_key(payload)).to eq(expected) }
+  end
+
+  describe '#deep_symbolize_key' do
+    let(:payload) {{
+      'my_key' => 'test',
+      'another_key' => {
+        'last_key' => 'test',
+        'valid_key' => 'test'
+      }
+    }}
+
+    let(:expected) {{
+      my_key: 'test',
+      another_key: {
+        last_key: 'test',
+        valid_key: 'test'
+      }
+    }}
+
+    it { expect(Hawkei::Util.deep_symbolize_key(payload)).to eq(expected) }
+  end
+
+  describe '#deep_obfuscate_value' do
+    let(:fields) { ['password', 'credit_card'] }
+    let(:payload) {{
+      password: 'test',
+      another_key: {
+        credit_card: '41111111',
+        valid_key: 'test'
+      }
+    }}
+
+    let(:expected) {{
+      password: '[HIDDEN]',
+      another_key: {
+        credit_card: '[HIDDEN]',
+        valid_key: 'test'
+      }
+    }}
+
+    it { expect(Hawkei::Util.deep_obfuscate_value(payload, fields)).to eq(expected) }
+  end
+
+end

data/spec/lib/hawkei/watcher_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Hawkei::Watcher do
+
+  describe '#create' do
+    let(:response) { double('Hawkei::Request', body: "{\"object\":\"watcher\",\"id\":1}") }
+    before { expect(Hawkei::Request).to receive(:execute).and_return(response) }
+
+    subject(:create) { Hawkei::Watcher.create(template_flow: 'My Hawkei', expected_times: 42) }
+
+    it { is_expected.to be_successful }
+    it { expect(create.id).to eq(1) }
+  end
+
+  describe '#delete' do
+    let(:response) { double('Hawkei::Request', body: "{\"object\":\"watcher\",\"id\":1}") }
+    before { expect(Hawkei::Request).to receive(:execute).and_return(response) }
+
+    subject(:delete) { Hawkei::Watcher.delete(1) }
+
+    it { is_expected.to be_successful }
+    it { expect(delete.id).to eq(1) }
+  end
+
+end