cangaroo 1.2.0 → 1.3.0

data/spec/jobs/cangaroo/{job_spec.rb → push_job_spec.rb}

@@ -1,21 +1,15 @@
 require 'rails_helper'
 
 module Cangaroo
-  RSpec.describe Job, type: :job do
-    class FakeJob < Cangaroo::Job
-      connection :store
-      path '/webhook_path'
-      parameters(email: 'info@nebulab.it')
-    end
-
-    let(:job_class) { FakeJob }
+  RSpec.describe PushJob, type: :job do
+    let(:job_class) { FakePushJob }
     let(:destination_connection) { create(:cangaroo_connection) }
     let(:type) { 'orders' }
     let(:payload) { { id: 'O123' } }
     let(:connection_response) { parse_fixture('json_payload_connection_response.json') }
 
     let(:options) do
-      { connection: destination_connection,
+      { source_connection: destination_connection,
         type: type,
         payload: payload }
     end
@@ -24,15 +18,17 @@ module Cangaroo
       Cangaroo::Webhook::Client.new(destination_connection, '/webhook_path')
     end
 
+    let(:fake_command) { double('fake perform flow command', success?: true) }
+
+    let(:job) { job_class.new(options) }
+
     before do
       allow(client).to receive(:post).and_return(connection_response)
       allow(Cangaroo::Webhook::Client).to receive(:new).and_return(client)
-      allow(Cangaroo::PerformFlow).to receive(:call)
+      allow(Cangaroo::PerformFlow).to receive(:call).and_return(fake_command)
     end
 
     describe '#perform' do
-      let(:job) { job_class.new(options) }
-
       it 'instantiates a Cangaroo::Webhook::Client' do
         expect(Cangaroo::Webhook::Client).to receive(:new)
           .with(destination_connection, '/webhook_path')
@@ -41,25 +37,34 @@ module Cangaroo
       end
 
       it 'calls post on client' do
-        job.perform
+        job.perform_now
         expect(client).to have_received(:post)
           .with(job.transform, job.job_id, email: 'info@nebulab.it')
       end
 
       it 'restart the flow' do
-        job.perform
+        job.class.process_response(true)
+        job.perform_now
         expect(Cangaroo::PerformFlow).to have_received(:call)
           .once
           .with(source_connection: destination_connection,
-                json_body: connection_response.to_json,
+                json_body: connection_response,
                 jobs: Rails.configuration.cangaroo.jobs)
       end
 
+      it 'should not restart the flow when disabled' do
+        job.class.process_response(false)
+
+        job.perform_now
+
+        expect(Cangaroo::PerformFlow).to_not have_received(:call)
+      end
+
       context 'endpoint provides a empty response' do
         it 'should not restart the flow' do
           allow(client).to receive(:post).and_return('')
 
-          job.perform
+          job.perform_now
 
           expect(Cangaroo::PerformFlow).to_not have_received(:call)
         end
@@ -71,7 +76,10 @@ module Cangaroo
     end
 
     describe '#transform' do
-      it { expect(job_class.new(options).transform).to eq('order' => payload) }
+      it 'return a single element hash with singularized type as key and payload as value' do
+        job.perform_now
+        expect(job.transform).to eq('order' => payload)
+      end
     end
   end
 end

data/spec/lib/cangaroo/logger_helper_spec.rb

@@ -0,0 +1,21 @@
+require 'rails_helper'
+
+describe Cangaroo::LoggerHelper do
+  describe '#job_tags' do
+    let(:job_class) { FakePushJob }
+    let(:type) { 'orders' }
+    let(:payload) { { id: 'O123' } }
+    let(:options) do
+      { connection: destination_connection,
+        type: type,
+        payload: payload }
+    end
+    let(:job) { job_class.new(options) }
+    let!(:destination_connection) { create(:cangaroo_connection) }
+    let(:extra_tags) { { tag1: 1, tag2: 2 } }
+
+    it 'merges given tags with job class name, job_id and connection name' do
+      expect(job.job_tags(extra_tags)).to eq(extra_tags.merge(job: 'FakePushJob', job_id: job.job_id, connection: destination_connection.name))
+    end
+  end
+end

data/spec/lib/cangaroo/logger_spec.rb

@@ -0,0 +1,83 @@
+require 'rails_helper'
+
+class CustomLogger
+  def log(_message); end
+
+  def unknown(_message, _opts = {}); end
+
+  def debug(_message, _opts = {}); end
+
+  def info(_message, _opts = {}); end
+
+  def warn(_message, _opts = {}); end
+
+  def error(_message, _opts = {}); end
+end
+
+describe Cangaroo::Logger do
+  let(:cangaroo_logger) { Cangaroo::Logger.send(:new) }
+  before { Rails.configuration.cangaroo.logger = logger }
+
+  describe '#logger' do
+    subject { cangaroo_logger.logger }
+
+    context 'when Rails.configuration.cangaroo.logger is set' do
+      let(:logger) { CustomLogger.new }
+
+      it { is_expected.to eq(logger) }
+    end
+
+    context 'when Rails.configuration.cangaroo.logger is not set' do
+      let(:logger) { nil }
+
+      it { is_expected.to eq(Rails.logger) }
+    end
+  end
+
+  context 'log methods' do
+    let(:message) { 'message' }
+    let(:opts) { { opt1: 1, opt2: 2 } }
+
+    describe '#log' do
+      after { cangaroo_logger.log(message, opts) }
+
+      context 'when logger can receive given parameters' do
+        let(:logger) { nil }
+
+        it 'calls the logger log method with the given params' do
+          expect(Rails.logger).to receive(:log).with(message, opts)
+        end
+      end
+
+      context 'when logger can not receive given parameters' do
+        let(:logger) { CustomLogger.new }
+
+        it 'calls the logger log method with an array of message and params' do
+          expect(logger).to receive(:log).with([message, opts])
+        end
+      end
+    end
+
+    %i(unknown debug info warn error).each do |log_method|
+      describe "##{log_method}" do
+        after { cangaroo_logger.send(log_method, message, opts) }
+
+        context 'when logger can receive given parameters' do
+          let(:logger) { CustomLogger.new }
+
+          it "calls the logger #{log_method} method with the given params" do
+            expect(logger).to receive(log_method).with(message, opts)
+          end
+        end
+
+        context 'when logger can not receive given parameters' do
+          let(:logger) { nil }
+
+          it "calls the logger #{log_method} method with an array of message and params" do
+            expect(Rails.logger).to receive(log_method).with([message, opts])
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/cangaroo/webhook/client_spec.rb

@@ -11,11 +11,12 @@ module Cangaroo
 
       let(:request_id) { '123456' }
       let(:parameters) { { email: 'info@nebulab.it' } }
-      let(:payload) { { order: { id: 'R12345', state: 'completed' } } }
+      let(:payload) do
+        { order: { id: 'R12345', state: 'completed' } }
+      end
 
       let(:response) do
-        { 'request_id': '52f367367575e449c3000001',
-          'summary': 'Successfully updated order for R12345' }
+        { 'request_id' => '52f367367575e449c3000001', 'summary' => 'Successfully updated order for R12345' }
       end
 
       before do
@@ -28,13 +29,12 @@ module Cangaroo
           client.post(payload, request_id, parameters)
           expect(WebMock).to have_requested(:post,
                                             'http://www.store.com/api_path')
-            .with(
-              headers: { 'X_HUB_TOKEN': connection.token },
-              body: {
-                request_id: request_id,
-                parameters: connection.parameters.deep_merge(parameters),
-                order: { id: 'R12345', state: 'completed' }
-              }.to_json)
+            .with(headers: { 'X_HUB_TOKEN' => connection.token },
+                  body: {
+                    request_id: request_id,
+                    parameters: connection.parameters.deep_merge(parameters),
+                    order: { id: 'R12345', state: 'completed' }
+                  }.to_json)
         end
 
         context 'when basic auth is enabled' do
@@ -42,16 +42,38 @@ module Cangaroo
 
           it 'sends key and token as basic auth username and password' do
             expect(client.class).to receive(:post)
-              .with(anything, hash_including(basic_auth: {
-                username: connection.key,
-                password: connection.token }
-              ))
+              .with(anything, hash_including(basic_auth: { username: connection.key, password: connection.token } ))
               .and_return(double(response: double(code: '200'), parsed_response: response))
 
             client.post(payload, request_id, parameters)
           end
         end
 
+        describe 'Rails.configuration.cangaroo.client_timeout' do
+
+          context 'when set' do
+            before { Rails.configuration.cangaroo.client_timeout = 120 }
+            it 'sets the timeout config on the client' do
+              expect(client.class).to receive(:post)
+                .with(anything, hash_including(timeout: 120 ))
+                .and_return(double(response: double(code: '200'), parsed_response: response))
+
+              client.post(payload, request_id, parameters)
+            end
+          end
+
+          context 'when not set' do
+            before { Rails.configuration.cangaroo.client_timeout = nil }
+            it 'does not set the timeout config on the client' do
+              allow(client.class).to receive(:post)
+                .with(anything, hash_excluding(:timeout))
+                .and_return(double(response: double(code: '200'), parsed_response: response))
+
+              client.post(payload, request_id, parameters)
+            end
+          end
+        end
+
         context 'when response code is 200 (success)' do
           it 'returns the parsed response' do
             expect(client.post(payload, request_id, parameters))
@@ -69,16 +91,11 @@ module Cangaroo
 
         context 'when response code is not 200 (success)' do
           let(:failure_response) do
-            {
-              'request_id': '52f367367575e449c3000001',
-              'summary': 'Cannot update order. Order R12345 not found in storefront.'
-            }
+            { 'request_id' => '52f367367575e449c3000001', 'summary' => 'Cannot update order. Order R12345 not found in storefront.' }
           end
 
           before do
-            stub_request(:post, /^#{url}.*/).to_return(
-              body: failure_response.to_json,
-              status: 500)
+            stub_request(:post, /^#{url}.*/).to_return(body: failure_response.to_json, status: 500)
           end
 
           it 'raises Cangaroo::Webhook::Error' do
@@ -91,9 +108,7 @@ module Cangaroo
           let(:failure_response) { 'i am not json' }
 
           before do
-            stub_request(:post, /^#{url}.*/).to_return(
-              body: failure_response,
-              status: 500)
+            stub_request(:post, /^#{url}.*/).to_return(body: failure_response, status: 500)
           end
 
           it 'raises Cangaroo::Webhook::Error' do

data/spec/rails_helper.rb

@@ -1,11 +1,10 @@
 require 'simplecov'
-require 'codeclimate-test-reporter'
 require 'pry-byebug'
 
 SimpleCov.start 'rails' do
   add_group 'Commands', 'app/commands'
+  add_filter 'lib/cangaroo/version'
 end
-CodeClimate::TestReporter.start
 
 # This file is copied to spec/ when you run 'rails generate rspec:install'
 ENV['RAILS_ENV'] ||= 'test'
@@ -31,6 +30,8 @@ require 'rspec/rails'
   spec_helpers
 ).each { |path| require File.expand_path("../support/#{path}.rb", __FILE__) }
 
+Dir[File.dirname(__FILE__) + '/support/jobs/*.rb'].each { |file| require file }
+
 # Checks for pending migrations before tests are run.
 # If you are not using ActiveRecord, you can remove this line.
 ActiveRecord::Migration.maintain_test_schema!
@@ -41,6 +42,7 @@ RSpec.configure do |config|
     Rails.configuration.cangaroo.basic_auth = false
     Rails.configuration.cangaroo.jobs = []
     Rails.configuration.cangaroo.poll_job = []
+    Rails.configuration.cangaroo.logger = nil
   end
 
   # The different available types are documented in the features, such as in

data/spec/{controllers/cangaroo/endpoint_controller_spec.rb → requests/cangaroo/endpoint_spec.rb}

@@ -1,51 +1,45 @@
 require 'rails_helper'
 
 module Cangaroo
-  RSpec.describe EndpointController, type: :controller do
-    routes { Cangaroo::Engine.routes }
+  RSpec.describe :Endpoint, type: :request do
     let(:connection) { create :cangaroo_connection }
-    let(:request_payload) { JSON.parse(load_fixture('json_payload_ok.json')) }
-
-    before do
-      request.headers['Content-Type'] = 'application/json'
-    end
+    let(:request_payload) { load_fixture('json_payload_ok.json') }
+    let(:headers) {
+      { 'Content-Type' => 'application/json',
+        'X-Hub-Store' => connection.key,
+        'X-Hub-Access-Token' => connection.token }
+    }
 
     context 'when wombat authentication is enabled' do
-      before do
-        request.headers['X-Hub-Store'] = connection.key
-        request.headers['X-Hub-Access-Token'] = connection.token
-      end
-
       describe '#create' do
         before do
-          post :create, request_payload
+          post endpoint_index_path, params: request_payload, headers: headers
         end
 
         it 'accepts only application/json requests' do
           expect(response.status).to eq(202)
 
-          request.headers['Content-Type'] = 'text/html'
-          post :create
+          headers['Content-Type'] = 'text/html'
+          post endpoint_index_path, params: {}, headers: headers
           expect(response.status).to eq(406)
         end
 
         context 'when success' do
-          let(:auth_headers) {}
-
           it 'responds with 200' do
             expect(response.status).to eq(202)
           end
 
           it 'responds with the number of objects received in payload' do
             res = JSON.parse(response.body)
-            expect(res).to eq('orders' => 2, 'shipments' => 2)
+            expect(res).to eq('orders' => 2, 'shipments' => 2,
+                              'line_items' => 0, 'line-items' => 0)
           end
         end
 
         context 'when error' do
           before do
-            request.headers['X-Hub-Access-Token'] = 'wrongtoken'
-            post :create, request_payload
+            headers['X-Hub-Access-Token'] = 'wrongtoken'
+            post endpoint_index_path, params: request_payload, headers: headers
           end
 
           it 'responds with the command error code' do
@@ -59,8 +53,8 @@ module Cangaroo
 
         context 'when an exception was raised' do
           before do
-            HandleRequest.stub(:call).and_raise('An error')
-            post :create, request_payload
+            allow(HandleRequest).to receive(:call).and_raise('An error')
+            post endpoint_index_path, params: request_payload, headers: headers
           end
 
           it 'responds with 500' do
@@ -81,10 +75,9 @@ module Cangaroo
 
       describe '#create' do
         it 'successfully authorized against a connection key and token' do
-          request.env['HTTP_AUTHORIZATION'] = ActionController::HttpAuthentication::Basic
-            .encode_credentials(connection.key, connection.token)
+          headers['HTTP_AUTHORIZATION'] = ActionController::HttpAuthentication::Basic.encode_credentials(connection.key, connection.token)
 
-          post :create, request_payload
+          post endpoint_index_path, params: request_payload, headers: headers
 
           expect(response.status).to eq(202)
         end
@@ -92,21 +85,19 @@ module Cangaroo
         it 'successfully authenticates against a connection token' do
           connection.update(key: '')
 
-          request.env['HTTP_AUTHORIZATION'] = ActionController::HttpAuthentication::Basic
-            .encode_credentials('', connection.token)
+          headers['HTTP_AUTHORIZATION'] = ActionController::HttpAuthentication::Basic.encode_credentials('', connection.token)
 
-          post :create, request_payload
+          post endpoint_index_path, params: request_payload, headers: headers
 
           expect(response.status).to eq(202)
         end
 
         it 'fails to authenticate when basic auth is not provided' do
-          post :create, request_payload
+          post endpoint_index_path, params: request_payload, headers: headers
 
           expect(response.status).to eq(401)
         end
       end
     end
-
   end
 end