cangaroo 1.1.0 → 1.2.0

data/lib/cangaroo/version.rb

@@ -1,3 +1,3 @@
 module Cangaroo
-  VERSION = '1.1.0'
+  VERSION = '1.2.0'
 end

data/lib/cangaroo/webhook/client.rb

@@ -14,11 +14,29 @@ module Cangaroo
 
       def post(payload, request_id, parameters)
         request_body = body(payload, request_id, parameters).to_json
-        req = self.class.post(url, headers: headers, body: request_body)
+
+        request_options = {
+          headers: headers,
+          body: request_body
+        }
+
+        if Rails.configuration.cangaroo.basic_auth
+          request_options.merge!(
+            basic_auth: {
+              username: connection.key,
+              password: connection.token
+            }
+          )
+        end
+
+        req = self.class.post(url, request_options)
+
         if req.response.code == '200'
           req.parsed_response
+        elsif req.response.code == '204'
+          ''
         else
-          fail Cangaroo::Webhook::Error, req.parsed_response['summary']
+          fail Cangaroo::Webhook::Error, (req.parsed_response['summary'] rescue req.response)
         end
       end
 
@@ -32,7 +50,7 @@ module Cangaroo
 
       def headers
         {
-          'X_HUB_TOKEN' => connection.token,
+          'X_HUB_TOKEN' => connection.token || '',
           'Content-Type' => 'application/json',
           'Accept' => 'application/json'
         }

data/lib/tasks/cangaroo_tasks.rake

@@ -1,4 +1,7 @@
-# desc "Explaining what the task does"
-# task :cangaroo do
-#   # Task goes here
-# end
+namespace :cangaroo do
+  task poll: :environment do
+    Cangaroo::RunPolls.call(
+      jobs: Rails.configuration.cangaroo.poll_jobs
+    )
+  end
+end

data/spec/controllers/cangaroo/endpoint_controller_spec.rb

@@ -8,65 +8,105 @@ module Cangaroo
 
     before do
       request.headers['Content-Type'] = 'application/json'
-      request.headers['X-Hub-Store'] = connection.key
-      request.headers['X-Hub-Access-Token'] = connection.token
     end
 
-    describe '#create' do
+    context 'when wombat authentication is enabled' do
       before do
-        post :create, request_payload
+        request.headers['X-Hub-Store'] = connection.key
+        request.headers['X-Hub-Access-Token'] = connection.token
       end
 
-      it 'accepts only application/json requests' do
-        expect(response.status).to eq(202)
-
-        request.headers['Content-Type'] = 'application/text'
-        post :create
-        expect(response.status).to eq(406)
-      end
-
-      context 'when success' do
-        let(:auth_headers) {}
+      describe '#create' do
+        before do
+          post :create, request_payload
+        end
 
-        it 'responds with 200' do
+        it 'accepts only application/json requests' 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)
+          request.headers['Content-Type'] = 'text/html'
+          post :create
+          expect(response.status).to eq(406)
         end
-      end
 
-      context 'when error' do
-        before do
-          request.headers['X-Hub-Access-Token'] = 'wrongtoken'
-          post :create, request_payload
+        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)
+          end
         end
 
-        it 'responds with the command error code' do
-          expect(response.status).to eq(401)
+        context 'when error' do
+          before do
+            request.headers['X-Hub-Access-Token'] = 'wrongtoken'
+            post :create, request_payload
+          end
+
+          it 'responds with the command error code' do
+            expect(response.status).to eq(401)
+          end
+
+          it 'responds with error messages in the body' do
+            expect(JSON.parse(response.body)['error']).to be_present
+          end
         end
 
-        it 'responds with error messages in the body' do
-          expect(JSON.parse(response.body)['error']).to be_present
+        context 'when an exception was raised' do
+          before do
+            HandleRequest.stub(:call).and_raise('An error')
+            post :create, request_payload
+          end
+
+          it 'responds with 500' do
+            expect(response.status).to eq(500)
+          end
+
+          it 'responds with error messages in the body' do
+            expect(JSON.parse(response.body)['error']).to eq 'Something went wrong!'
+          end
         end
       end
+    end
+
+    context 'when basic auth is enabled' do
+      before do
+        Rails.configuration.cangaroo.basic_auth = true
+      end
+
+      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)
 
-      context 'when an exception was raised' do
-        before do
-          HandleRequest.stub(:call).and_raise('An error')
           post :create, request_payload
+
+          expect(response.status).to eq(202)
         end
 
-        it 'responds with 500' do
-          expect(response.status).to eq(500)
+        it 'successfully authenticates against a connection token' do
+          connection.update(key: '')
+
+          request.env['HTTP_AUTHORIZATION'] = ActionController::HttpAuthentication::Basic
+            .encode_credentials('', connection.token)
+
+          post :create, request_payload
+
+          expect(response.status).to eq(202)
         end
 
-        it 'responds with error messages in the body' do
-          expect(JSON.parse(response.body)['error']).to eq 'Something went wrong!'
+        it 'fails to authenticate when basic auth is not provided' do
+          post :create, request_payload
+
+          expect(response.status).to eq(401)
         end
       end
     end
+
   end
 end

data/spec/fixtures/json_payload_connection_response.json

@@ -1,6 +1,7 @@
 {
   "request_id": "c143e548-afed-44ab-9997-43614d6c762b",
   "summary": "Product added with Shopify ID of 5775282183 was added.",
+  "parameters": {},
   "products": [
     {
       "id": "SKUPRODUCT",

data/spec/fixtures/json_payload_empty.json

@@ -0,0 +1,3 @@
+{
+   "orders": []
+ }

data/spec/interactors/cangaroo/perform_jobs_spec.rb

@@ -18,25 +18,40 @@ describe Cangaroo::PerformJobs do
   end
 
   describe '.call' do
-    let(:json_body) { load_fixture('json_payload_ok.json') }
-
     let(:job_a) { double('job_a', perform?: true, enqueue: nil) }
     let(:job_b) { double('job_b', perform?: false, enqueue: nil) }
 
-    it 'instantiates jobs' do
-      context
-      expect(JobA).to have_received(:new).exactly(4).times
-      expect(JobB).to have_received(:new).exactly(4).times
-    end
+    context 'payload with objects' do
+      let(:json_body) { load_fixture('json_payload_ok.json') }
+
+      it 'instantiates jobs' do
+        context
+        expect(JobA).to have_received(:new).exactly(4).times
+        expect(JobB).to have_received(:new).exactly(4).times
+      end
+
+      it 'enqueues only cangaroo jobs that can perform' do
+        context
+        expect(job_a).to have_received(:enqueue).exactly(4).times
+        expect(job_b).to_not have_received(:enqueue)
+      end
 
-    it 'enqueues only cangaroo jobs that can perform' do
-      context
-      expect(job_a).to have_received(:enqueue).exactly(4).times
-      expect(job_b).to_not have_received(:enqueue)
+      it 'succeeds' do
+        expect(context).to be_a_success
+      end
     end
 
-    it 'succeeds' do
-      expect(context).to be_a_success
+    context 'payload with no objects' do
+      let(:json_body) { load_fixture('json_payload_empty.json') }
+
+      it 'succeeds' do
+        context
+
+        expect(context).to be_a_success
+        expect(job_a).to_not have_received(:enqueue)
+        expect(job_b).to_not have_received(:enqueue)
+      end
     end
+
   end
 end

data/spec/interactors/cangaroo/run_polls_spec.rb

@@ -0,0 +1,18 @@
+require 'rails_helper'
+
+class PollJobA < Cangaroo::PollJob; end
+class PollJobB < Cangaroo::PollJob; end
+
+describe Cangaroo::RunPolls do
+  let(:connection) { create(:cangaroo_connection) }
+
+  # let(:job_a) { double('job_a', enqueue: nil) }
+  # let(:job_b) { double('job_b', enqueue: nil) }
+
+  it 'enques all polling jobs' do
+    expect_any_instance_of(PollJobA).to receive(:enqueue).once
+    expect_any_instance_of(PollJobB).to receive(:enqueue).once
+
+    Cangaroo::RunPolls.call(jobs: [PollJobA, PollJobB])
+  end
+end

data/spec/interactors/cangaroo/validate_json_schema_spec.rb

@@ -12,6 +12,14 @@ describe Cangaroo::ValidateJsonSchema do
       end
     end
 
+    context 'when json is well formatted and empty' do
+      let(:json_body) { parse_fixture('json_payload_empty.json') }
+
+      it 'succeeds' do
+        expect(context).to be_a_success
+      end
+    end
+
     context 'when json is well formatted and come from a connection' do
       let(:json_body) { parse_fixture('json_payload_connection_response.json') }
 

data/spec/jobs/cangaroo/job_spec.rb

@@ -25,7 +25,7 @@ module Cangaroo
     end
 
     before do
-      client.stub(:post).and_return(connection_response)
+      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)
     end
@@ -49,10 +49,21 @@ module Cangaroo
       it 'restart the flow' do
         job.perform
         expect(Cangaroo::PerformFlow).to have_received(:call)
+          .once
           .with(source_connection: destination_connection,
                 json_body: connection_response.to_json,
                 jobs: Rails.configuration.cangaroo.jobs)
       end
+
+      context 'endpoint provides a empty response' do
+        it 'should not restart the flow' do
+          allow(client).to receive(:post).and_return('')
+
+          job.perform
+
+          expect(Cangaroo::PerformFlow).to_not have_received(:call)
+        end
+      end
     end
 
     describe '#perform?' do

data/spec/jobs/cangaroo/poll_job_spec.rb

@@ -0,0 +1,107 @@
+require 'rails_helper'
+
+RSpec.describe Cangaroo::PollJob, type: :job do
+  class FakePollJob < Cangaroo::PollJob
+    connection :store
+    path '/webhook_path'
+    parameters(email: 'info@nebulab.it')
+  end
+
+  let(:job_class) { FakePollJob }
+  let(:job) { job_class.new({ last_poll: Time.now.to_i }) }
+  let(:successful_pull_payload) { parse_fixture('json_payload_ok.json') }
+
+  before do
+    create(:cangaroo_connection)
+  end
+
+  describe '#perform?' do
+    before do
+      allow_any_instance_of(Cangaroo::Webhook::Client).to receive(:post)
+        .and_return(successful_pull_payload)
+
+      allow(Cangaroo::HandleRequest).to receive(:call).
+        and_return(double(success?: true))
+    end
+
+    it 'runs a poll if one has never been run' do
+      expect(FakePollJob.new.perform?(DateTime.now)).to eq(true)
+    end
+
+    it 'runs a poll if the poll frequency delta is reached' do
+      last_poll = Cangaroo::PollTimestamp.for_class(FakePollJob)
+      last_poll.value = DateTime.now - FakePollJob.frequency - 1.second
+      last_poll.save
+
+      expect(FakePollJob.new.perform?(DateTime.now)).to eq(true)
+    end
+
+    it 'does not run a poll if the time passed is less than the frequency' do
+      last_poll = Cangaroo::PollTimestamp.for_class(FakePollJob)
+      last_poll.value = DateTime.now - FakePollJob.frequency + 1.second
+      last_poll.save
+
+      expect(FakePollJob.new.perform?(DateTime.now)).to eq(false)
+    end
+  end
+
+  describe '#perform' do
+
+    context 'pull is successful' do
+
+      before do
+        allow(Cangaroo::HandleRequest).to receive(:call).
+          and_return(double(success?: true))
+
+        allow_any_instance_of(Cangaroo::PollJob).to receive(:perform?)
+          .and_return(true)
+      end
+
+      it 'updates the poll timestamp' do
+        Cangaroo::Webhook::Client.any_instance.stub(:post).and_return(successful_pull_payload)
+
+        job.perform
+
+        last_poll_timestamp = Cangaroo::PollTimestamp.for_class(FakePollJob)
+        expect(last_poll_timestamp.job).to eq(job.class.to_s)
+        expect(last_poll_timestamp.connection.name).to eq(job.class.connection.to_s)
+        expect(last_poll_timestamp.value).to be <= DateTime.now
+      end
+
+      it 'handles a empty response' do
+        Cangaroo::Webhook::Client.any_instance.stub(:post).and_return('')
+
+        job.perform
+      end
+
+      it 'handles a response with a empty array' do
+        Cangaroo::Webhook::Client.any_instance.stub(:post).and_return(
+          parse_fixture('json_payload_empty.json')
+        )
+
+        job.perform
+      end
+
+    end
+
+    context 'pull fails' do
+
+      before do
+        Cangaroo::Webhook::Client.any_instance.stub(:post).and_return(parse_fixture('json_payload_ok.json'))
+
+        allow(Cangaroo::HandleRequest).to receive(:call).and_return(double(
+          success?: false,
+          message: 'bad failure'
+        ))
+      end
+
+      it 'does not update timestamp if pull fails' do
+        expect { job.perform }.to raise_error(Cangaroo::Webhook::Error)
+
+        expect(Cangaroo::PollTimestamp.for_class(FakePollJob).id).to be_nil
+      end
+
+    end
+  end
+
+end

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

@@ -37,6 +37,21 @@ module Cangaroo
               }.to_json)
         end
 
+        context 'when basic auth is enabled' do
+          before { Rails.configuration.cangaroo.basic_auth = true }
+
+          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 }
+              ))
+              .and_return(double(response: double(code: '200'), parsed_response: response))
+
+            client.post(payload, request_id, parameters)
+          end
+        end
+
         context 'when response code is 200 (success)' do
           it 'returns the parsed response' do
             expect(client.post(payload, request_id, parameters))
@@ -44,6 +59,14 @@ module Cangaroo
           end
         end
 
+        context 'when response code is 204 (no content)' do
+          it 'returns an empty string' do
+            stub_request(:post, /^#{url}.*/).to_return(status: 204, body: '')
+
+            expect(client.post(payload, request_id, parameters)).to eq('')
+          end
+        end
+
         context 'when response code is not 200 (success)' do
           let(:failure_response) do
             {
@@ -63,6 +86,21 @@ module Cangaroo
               .to raise_error(Cangaroo::Webhook::Error)
           end
         end
+
+        context 'when response code is not 200 and response is not json' do
+          let(:failure_response) { 'i am not json' }
+
+          before do
+            stub_request(:post, /^#{url}.*/).to_return(
+              body: failure_response,
+              status: 500)
+          end
+
+          it 'raises Cangaroo::Webhook::Error' do
+            expect { client.post(payload, request_id, parameters) }
+              .to raise_error(Cangaroo::Webhook::Error)
+          end
+        end
       end
     end
   end