txgh-queue 2.1.0 → 3.0.0.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 182f92ae726c4dd56d50d53ae0f5cae3bcfae7f44ee675783a5153b2b084f4cf
-  data.tar.gz: 14bda789ede5a1f337c6c4bd708681b8f5958f279d5b01d71214f52fa737bfea
+  metadata.gz: 898748f4ec7487c2ae896e41379a004b090ec31ba2fa0aa974ab07d078a4fe10
+  data.tar.gz: 32426a63ef5e8d3f2ab102803576134d76ff17a1c84dff25dd2fd278a5dfb320
 SHA512:
-  metadata.gz: 11476fc78f162f70a3c4331aac64d4eec1d80101462cd30a29f1efd4e65af4cbd66be23aaafb80fc018347635789ab4dbc6ab95ba22b656c12769bc4265dcc1d
-  data.tar.gz: 6ac7cb8a9d890cb72407882fe2265b8abe9e2f61c958d7345c6d94ec1ea8b371545caa0afebec96c2ab19ccdf7c4db2db31d91673ec44b12c9a3fbf3089d8af9
+  metadata.gz: 44c5160910ca4c90831ccc14dd9060c8ea0200871f8b85a6c1345886e492bcf60eae1ee43f82ce30b204fad762399f83bef5483cf8c53104f3c8e2113c2c9929
+  data.tar.gz: f80f1c7446514a967f93b4a79669cfaadf0905207c8f1552a0b87bba2e2466dda8eea4b9c6e643929aea22ab325beb8d65a826b671244a2ee2d901da85dde343

data/lib/txgh-queue/application.rb

@@ -31,5 +31,11 @@ module TxghQueue
         Github::RequestHandler.handle_request(request, settings.logger)
       )
     end
+
+    post '/gitlab/enqueue' do
+      respond_with(
+        Gitlab::RequestHandler.handle_request(request, settings.logger)
+      )
+    end
   end
 end

data/lib/txgh-queue/error_handlers/gitlab.rb

@@ -0,0 +1,39 @@
+require 'gitlab'
+
+module TxghQueue
+  module ErrorHandlers
+    class Gitlab
+      # https://github.com/NARKOZ/gitlab/blob/master/lib/gitlab/error.rb
+      ERROR_CLASSES = {
+        ::Gitlab::Error::BadGateway          => Status.retry_without_delay,
+        ::Gitlab::Error::BadRequest          => Status.fail,
+        ::Gitlab::Error::Conflict            => Status.fail,
+        ::Gitlab::Error::Forbidden           => Status.fail,
+        ::Gitlab::Error::InternalServerError => Status.retry_with_delay,
+        ::Gitlab::Error::MethodNotAllowed    => Status.fail,
+        ::Gitlab::Error::NotAcceptable       => Status.fail,
+        ::Gitlab::Error::NotFound            => Status.fail,
+        ::Gitlab::Error::ServiceUnavailable  => Status.retry_with_delay,
+        ::Gitlab::Error::TooManyRequests     => Status.retry_with_delay,
+        ::Gitlab::Error::Unauthorized        => Status.fail,
+        ::Gitlab::Error::Unprocessable       => Status.fail
+      }
+
+      class << self
+        def can_handle?(error_or_response)
+          error_or_response.is_a?(::Gitlab::Error::Error)
+        end
+
+        def status_for(error)
+          ERROR_CLASSES.fetch(error.class) { handle_other(error) }
+        end
+
+        private
+
+        def handle_other(error)
+          Status.fail
+        end
+      end
+    end
+  end
+end

data/lib/txgh-queue/error_handlers.rb

@@ -1,6 +1,7 @@
 module TxghQueue
   module ErrorHandlers
     autoload :Github,         'txgh-queue/error_handlers/github'
+    autoload :Gitlab,         'txgh-queue/error_handlers/gitlab'
     autoload :NetworkErrors,  'txgh-queue/error_handlers/network_errors'
     autoload :ServerResponse, 'txgh-queue/error_handlers/server_response'
     autoload :StandardErrors, 'txgh-queue/error_handlers/standard_errors'

data/lib/txgh-queue/job.rb

@@ -4,6 +4,7 @@ require 'txgh-server'
 module TxghQueue
   class Job
     Github = TxghServer::Webhooks::Github
+    Gitlab = TxghServer::Webhooks::Gitlab
     Transifex = TxghServer::Webhooks::Transifex
     include TxghServer::ResponseHelpers
 
@@ -16,7 +17,7 @@ module TxghQueue
     def process(payload)
       Supervisor.supervise do
         case payload.fetch('txgh_event')
-          when 'github.push', 'github.delete', 'transifex.hook'
+          when 'github.push', 'github.delete', 'gitlab.push', 'gitlab.delete', 'transifex.hook'
             handle_expected(payload)
           else
             handle_unexpected
@@ -29,13 +30,17 @@ module TxghQueue
     def handle_expected(payload)
       config = config_from(payload)
       project = config.transifex_project
-      repo = config.github_repo
+      repo = config.git_repo
 
       case payload.fetch('txgh_event')
         when 'github.push'
           handle_github_push(project, repo, payload)
         when 'github.delete'
           handle_github_delete(project, repo, payload)
+        when 'gitlab.push'
+          handle_gitlab_push(project, repo, payload)
+        when 'gitlab.delete'
+          handle_gitlab_delete(project, repo, payload)
         when 'transifex.hook'
           handle_transifex_hook(project, repo, payload)
       end
@@ -43,7 +48,7 @@ module TxghQueue
 
     def config_from(payload)
       case payload.fetch('txgh_event')
-        when 'github.push', 'github.delete'
+        when 'github.push', 'github.delete', 'gitlab.push', 'gitlab.delete'
           Txgh::Config::KeyManager.config_from_repo(payload.fetch('repo_name'))
         when 'transifex.hook'
           Txgh::Config::KeyManager.config_from_project(payload.fetch('project'))
@@ -62,6 +67,18 @@ module TxghQueue
       execute(handler)
     end
 
+    def handle_gitlab_push(project, repo, payload)
+      attributes = TxghServer::Webhooks::Gitlab::PushAttributes.new(payload)
+      handler = TxghServer::Webhooks::Gitlab::PushHandler.new(project, repo, logger, attributes)
+      execute(handler)
+    end
+
+    def handle_gitlab_delete(project, repo, payload)
+      attributes = Gitlab::DeleteAttributes.new(payload)
+      handler = Gitlab::DeleteHandler.new(project, repo, logger, attributes)
+      execute(handler)
+    end
+
     def handle_transifex_hook(project, repo, payload)
       handler = Transifex::HookHandler.new(
         project: project,

data/lib/txgh-queue/supervisor.rb

@@ -11,6 +11,7 @@ module TxghQueue
     ERROR_HANDLERS = [
       ErrorHandlers::ServerResponse,
       ErrorHandlers::Github,
+      ErrorHandlers::Gitlab,
       ErrorHandlers::Transifex,
       ErrorHandlers::TxghErrors,
       ErrorHandlers::StandardErrors,

data/lib/txgh-queue/version.rb

@@ -1,3 +1,3 @@
 module TxghQueue
-  VERSION = '2.1.0'
+  VERSION = '3.0.0.beta'
 end

data/lib/txgh-queue/webhooks/gitlab/request_handler.rb

@@ -0,0 +1,26 @@
+require 'txgh-server'
+
+module TxghQueue
+  module Webhooks
+    module Gitlab
+      class RequestHandler < ::TxghServer::Webhooks::Gitlab::RequestHandler
+        def handle_request
+          handle_safely do
+            case gitlab_event
+              when 'Push Hook'
+                txgh_event = delete_event? ? 'gitlab.delete' : 'gitlab.push'
+
+                result = ::TxghQueue::Config.backend
+                  .producer_for(txgh_event, logger)
+                  .enqueue(attributes.to_h.merge(txgh_event: txgh_event))
+
+                respond_with(202, result.to_json)
+              else
+                respond_with_error(400, "Event '#{gitlab_event}' cannot be enqueued")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/txgh-queue/webhooks/gitlab.rb

@@ -0,0 +1,7 @@
+module TxghQueue
+  module Webhooks
+    module Gitlab
+      autoload :RequestHandler, 'txgh-queue/webhooks/gitlab/request_handler'
+    end
+  end
+end

data/lib/txgh-queue/webhooks.rb

@@ -1,6 +1,7 @@
 module TxghQueue
   module Webhooks
     autoload :Github,    'txgh-queue/webhooks/github'
+    autoload :Gitlab,    'txgh-queue/webhooks/gitlab'
     autoload :Transifex, 'txgh-queue/webhooks/transifex'
   end
 end

data/spec/application_spec.rb

@@ -2,6 +2,7 @@ require 'spec_helper'
 require 'rack/test'
 
 require 'helpers/github_payload_builder'
+require 'helpers/gitlab_payload_builder'
 require 'helpers/standard_txgh_setup'
 
 describe TxghQueue::WebhookEndpoints, auto_configure: true do
@@ -14,7 +15,7 @@ describe TxghQueue::WebhookEndpoints, auto_configure: true do
   end
 
   let(:config) do
-    Txgh::Config::ConfigPair.new(project_config, repo_config)
+    Txgh::Config::ConfigPair.new(project_config, github_config)
   end
 
   let(:backend) { TxghQueue::Config.backend }
@@ -75,7 +76,7 @@ describe TxghQueue::WebhookEndpoints, auto_configure: true do
       header(
         TxghServer::GithubRequestAuth::GITHUB_HEADER,
         TxghServer::GithubRequestAuth.compute_signature(
-          body, config.github_repo.webhook_secret
+          body, config.git_repo.webhook_secret
         )
       )
     end
@@ -83,7 +84,7 @@ describe TxghQueue::WebhookEndpoints, auto_configure: true do
     let(:producer) { backend.producer_for('github.push') }
 
     it 'enqueues a new job' do
-      payload = GithubPayloadBuilder.push_payload(repo_name, ref)
+      payload = GithubPayloadBuilder.push_payload(github_repo_name, ref)
       payload.add_commit
 
       sign_with payload.to_json
@@ -99,7 +100,36 @@ describe TxghQueue::WebhookEndpoints, auto_configure: true do
       expect(job[:payload]).to include(
         event: 'push',
         txgh_event: 'github.push',
-        repo_name: repo_name,
+        repo_name: github_repo_name,
+        ref: "refs/#{ref}"
+      )
+    end
+  end
+
+  describe '/gitlab/enqueue' do
+    let(:producer) { backend.producer_for('gitlab.push') }
+    let(:config) do
+      Txgh::Config::ConfigPair.new(project_config, gitlab_config)
+    end
+
+    it 'enqueues a new job' do
+      payload = GitlabPayloadBuilder.push_payload(gitlab_repo_name, ref)
+      payload.add_commit
+
+      header 'X-GitLab-Event', 'Push Hook'
+      header 'X-Gitlab-Token', config.git_repo.webhook_secret
+
+      expect { post '/gitlab/enqueue', payload.to_json }.to(
+        change { producer.enqueued_jobs.size }.from(0).to(1)
+      )
+
+      expect(last_response).to be_accepted
+
+      job = producer.enqueued_jobs.first
+      expect(job[:payload]).to include(
+        event: 'push',
+        txgh_event: 'gitlab.push',
+        repo_name: gitlab_repo_name.split('/').last,
         ref: "refs/#{ref}"
       )
     end

data/spec/backends/sqs/config_spec.rb

@@ -1,21 +1,19 @@
 require 'spec_helper'
 
-include TxghQueue::Backends
-
-describe Sqs::Config, auto_configure: true do
+describe TxghQueue::Backends::Sqs::Config, auto_configure: true do
   let(:queue_config) { sqs_queue_config }
 
   describe '.queues' do
     it 'lists all queues' do
       queues = described_class.queues
-      queues.each { |q| expect(q).to be_a(Sqs::Queue) }
+      queues.each { |q| expect(q).to be_a(TxghQueue::Backends::Sqs::Queue) }
       expect(queues.map(&:name).sort).to eq(%w(test-queue test-queue-2))
     end
   end
 
   describe '.failure_queue' do
     it 'returns the failure queue' do
-      expect(described_class.failure_queue).to be_a(Sqs::Queue)
+      expect(described_class.failure_queue).to be_a(TxghQueue::Backends::Sqs::Queue)
       expect(described_class.failure_queue.name).to eq('test-failure-queue')
     end
   end
@@ -23,7 +21,7 @@ describe Sqs::Config, auto_configure: true do
   describe '.get_queue' do
     it 'pulls out a single queue object' do
       queue = described_class.get_queue('test-queue')
-      expect(queue).to be_a(Sqs::Queue)
+      expect(queue).to be_a(TxghQueue::Backends::Sqs::Queue)
       expect(queue.name).to eq('test-queue')
     end
   end

data/spec/backends/sqs/consumer_spec.rb

@@ -1,12 +1,9 @@
 require 'spec_helper'
 require 'helpers/sqs/sqs_test_message'
 
-include TxghQueue
-include TxghQueue::Backends
-
-describe Sqs::Consumer, auto_configure: true do
+describe TxghQueue::Backends::Sqs::Consumer, auto_configure: true do
   let(:queue_config) { sqs_queue_config }
-  let(:queues) { Sqs::Config.queues }
+  let(:queues) { TxghQueue::Backends::Sqs::Config.queues }
   let(:logger) { NilLogger.new }
   let(:message) { SqsTestMessage.new('abc123', '{}') }
   let(:consumer) { described_class.new(queues, logger) }
@@ -16,7 +13,7 @@ describe Sqs::Consumer, auto_configure: true do
       job = double(:Job)
       expect(queue).to receive(:receive_message).and_return(message.to_bundle)
       expect(job).to receive(:complete)
-      expect(Sqs::Job).to(
+      expect(TxghQueue::Backends::Sqs::Job).to(
         receive(:new).with(message, queue, logger).and_return(job)
       )
     end

data/spec/backends/sqs/history_sequence_spec.rb

@@ -1,10 +1,7 @@
 require 'spec_helper'
 require 'helpers/sqs/sqs_test_message'
 
-include TxghQueue
-include TxghQueue::Backends
-
-describe Sqs::HistorySequence do
+describe TxghQueue::Backends::Sqs::HistorySequence do
   let(:message) { SqsTestMessage.new('abc123', '{}', attributes_hash) }
   let(:attributes_hash) do
     {

data/spec/backends/sqs/job_spec.rb

@@ -1,13 +1,10 @@
 require 'spec_helper'
 require 'helpers/sqs/sqs_test_message'
 
-include TxghQueue
-include TxghQueue::Backends
-
-describe Sqs::Job, auto_configure: true do
+describe TxghQueue::Backends::Sqs::Job, auto_configure: true do
   let(:queue_config) { sqs_queue_config }
-  let(:queue) { Sqs::Config.queues.first }
-  let(:failure_queue) { Sqs::Config.failure_queue }
+  let(:queue) { TxghQueue::Backends::Sqs::Config.queues.first }
+  let(:failure_queue) { TxghQueue::Backends::Sqs::Config.failure_queue }
   let(:logger) { NilLogger.new }
   let(:body) { { 'foo' => 'bar' } }
   let(:message) { SqsTestMessage.new('123abc', body.to_json) }
@@ -18,12 +15,12 @@ describe Sqs::Job, auto_configure: true do
     it 'updates the history sequence with failure details for an exception' do
       error = StandardError.new('foobar')
       error.set_backtrace('path/to/file.rb:10')
-      result = Result.new(status, error)
+      result = TxghQueue::Result.new(status, error)
       expect(job).to receive(:process).with(body).and_return(result)
 
       # this call to send_message signifies a retry
       expect(send(queue_sym)).to receive(:send_message) do |body, attributes|
-        message_attributes = Sqs::MessageAttributes.from_h(attributes[:message_attributes])
+        message_attributes = TxghQueue::Backends::Sqs::MessageAttributes.from_h(attributes[:message_attributes])
         current_retry = message_attributes.history_sequence.current
         expect(current_retry).to include(
           response_type: 'error',
@@ -40,12 +37,12 @@ describe Sqs::Job, auto_configure: true do
 
     it 'updates the history sequence with failure details for a txgh response' do
       response = TxghServer::Response.new(502, 'Bad gateway')
-      result = Result.new(status, response)
+      result = TxghQueue::Result.new(status, response)
       expect(job).to receive(:process).with(body).and_return(result)
 
       # this call to send_message signifies a retry
       expect(send(queue_sym)).to receive(:send_message) do |body, attributes|
-        message_attributes = Sqs::MessageAttributes.from_h(attributes[:message_attributes])
+        message_attributes = TxghQueue::Backends::Sqs::MessageAttributes.from_h(attributes[:message_attributes])
         current_retry = message_attributes.history_sequence.current
         expect(current_retry).to include(
           response_type: 'response',
@@ -62,7 +59,7 @@ describe Sqs::Job, auto_configure: true do
 
   describe '#complete' do
     it 'processes a single job and deletes the message' do
-      result = Result.new(Status.ok, TxghServer::Response.new(200, 'Ok'))
+      result = TxghQueue::Result.new(TxghQueue::Status.ok, TxghServer::Response.new(200, 'Ok'))
       expect(queue).to receive(:delete_message).with(message.receipt_handle)
       expect(job).to receive(:process).with(body).and_return(result)
       job.complete
@@ -70,7 +67,7 @@ describe Sqs::Job, auto_configure: true do
 
     context 'error reporting' do
       let(:error) { StandardError.new('jelly beans') }
-      let(:result) { Result.new(Status.fail, error) }
+      let(:result) { TxghQueue::Result.new(TxghQueue::Status.fail, error) }
 
       before(:each) do
         expect(job).to receive(:process).and_return(result)
@@ -93,7 +90,7 @@ describe Sqs::Job, auto_configure: true do
       it 'includes error tracking details returned from publishing the event' do
         expect(Txgh.events).to receive(:publish_error).and_return(foo: 'bar')
         expect(failure_queue).to receive(:send_message) do |body, attributes|
-          message_attributes = Sqs::MessageAttributes.from_h(attributes[:message_attributes])
+          message_attributes = TxghQueue::Backends::Sqs::MessageAttributes.from_h(attributes[:message_attributes])
           current_retry = message_attributes.history_sequence.current
           expect(current_retry).to include(error_tracking: { foo: 'bar' })
         end
@@ -112,12 +109,12 @@ describe Sqs::Job, auto_configure: true do
 
       it 're-enqueues the message if told to retry' do
         response = TxghServer::Response.new(502, 'Bad gateway')
-        result = Result.new(Status.retry_without_delay, response)
+        result = TxghQueue::Result.new(TxghQueue::Status.retry_without_delay, response)
         expect(job).to receive(:process).with(body).and_return(result)
 
         # this call to send_message signifies a retry
         expect(queue).to receive(:send_message) do |body, attributes|
-          message_attributes = Sqs::MessageAttributes.from_h(attributes[:message_attributes])
+          message_attributes = TxghQueue::Backends::Sqs::MessageAttributes.from_h(attributes[:message_attributes])
           history_sequence = message_attributes.history_sequence.sequence.map { |elem| elem[:status] }
           expect(history_sequence).to eq(%w(retry_without_delay))
           new_message
@@ -128,17 +125,17 @@ describe Sqs::Job, auto_configure: true do
 
       it 're-enqueues with delay if told to do so' do
         response = TxghServer::Response.new(502, 'Bad gateway')
-        result = Result.new(Status.retry_with_delay, response)
+        result = TxghQueue::Result.new(TxghQueue::Status.retry_with_delay, response)
         expect(job).to receive(:process).with(body).and_return(result)
 
         # this call to send_message signifies a retry
         expect(queue).to receive(:send_message) do |body, attributes|
-          message_attributes = Sqs::MessageAttributes.from_h(attributes[:message_attributes])
+          message_attributes = TxghQueue::Backends::Sqs::MessageAttributes.from_h(attributes[:message_attributes])
           history_sequence = message_attributes.history_sequence.sequence.map { |elem| elem[:status] }
           expect(history_sequence).to eq(%w(retry_with_delay))
 
           expect(attributes[:delay_seconds]).to eq(
-            Sqs::RetryLogic::DELAY_INTERVALS.first
+            TxghQueue::Backends::Sqs::RetryLogic::DELAY_INTERVALS.first
           )
 
           new_message
@@ -151,7 +148,7 @@ describe Sqs::Job, auto_configure: true do
         let(:message) do
           SqsTestMessage.new('123abc', body.to_json, {
             'history_sequence' => {
-              'string_value' => (Sqs::RetryLogic::OVERALL_MAX_RETRIES - 1).times.map do
+              'string_value' => (TxghQueue::Backends::Sqs::RetryLogic::OVERALL_MAX_RETRIES - 1).times.map do
                 { status: 'retry_without_delay' }
               end.to_json
             }
@@ -160,15 +157,15 @@ describe Sqs::Job, auto_configure: true do
 
         it 'deletes the message and adds it to the failure queue' do
           response = TxghServer::Response.new(502, 'Bad gateway')
-          result = Result.new(Status.retry_with_delay, response)
+          result = TxghQueue::Result.new(TxghQueue::Status.retry_with_delay, response)
           expect(job).to receive(:process).with(body).and_return(result)
           expect(failure_queue).to receive(:send_message).and_return(new_message)
           job.complete
         end
       end
 
-      it_behaves_like "it updates the message's history sequence", Status.retry_without_delay, :queue
-      it_behaves_like "it updates the message's history sequence", Status.retry_with_delay, :queue
+      it_behaves_like "it updates the message's history sequence", TxghQueue::Status.retry_without_delay, :queue
+      it_behaves_like "it updates the message's history sequence", TxghQueue::Status.retry_with_delay, :queue
     end
 
     context 'failures' do
@@ -177,13 +174,13 @@ describe Sqs::Job, auto_configure: true do
       end
 
       it 'sends the message to the failure queue' do
-        result = Result.new(Status.fail, TxghServer::Response.new(500, '💩'))
+        result = TxghQueue::Result.new(TxghQueue::Status.fail, TxghServer::Response.new(500, '💩'))
         expect(failure_queue).to receive(:send_message).with(body.to_json, anything)
         expect(job).to receive(:process).with(body).and_return(result)
         job.complete
       end
 
-      it_behaves_like "it updates the message's history sequence", Status.fail, :failure_queue
+      it_behaves_like "it updates the message's history sequence", TxghQueue::Status.fail, :failure_queue
     end
   end
 end

data/spec/backends/sqs/message_attributes_spec.rb

@@ -2,10 +2,7 @@ require 'spec_helper'
 require 'helpers/sqs/sqs_test_message'
 require 'json'
 
-include TxghQueue
-include TxghQueue::Backends
-
-describe Sqs::MessageAttributes do
+describe TxghQueue::Backends::Sqs::MessageAttributes do
   let(:message) { SqsTestMessage.new('abc123', '{}', attributes_hash) }
   let(:attributes_hash) do
     {
@@ -20,7 +17,7 @@ describe Sqs::MessageAttributes do
   describe '.from_message' do
     it 'extracts the history sequence from the message attributes' do
       attributes = described_class.from_message(message)
-      expect(attributes.history_sequence).to be_a(Sqs::HistorySequence)
+      expect(attributes.history_sequence).to be_a(TxghQueue::Backends::Sqs::HistorySequence)
       expect(attributes.history_sequence.sequence.first[:status]).to(
         eq('retry_without_delay')
       )
@@ -30,7 +27,7 @@ describe Sqs::MessageAttributes do
   describe '.from_h' do
     it 'creates the history sequence from the hash elements' do
       attributes = described_class.from_h(attributes_hash)
-      expect(attributes.history_sequence).to be_a(Sqs::HistorySequence)
+      expect(attributes.history_sequence).to be_a(TxghQueue::Backends::Sqs::HistorySequence)
       expect(attributes.history_sequence.sequence.first[:status]).to(
         eq('retry_without_delay')
       )

data/spec/backends/sqs/producer_spec.rb

@@ -1,9 +1,7 @@
 require 'spec_helper'
 require 'securerandom'
 
-include TxghQueue::Backends
-
-describe Sqs::Producer, auto_configure: true do
+describe TxghQueue::Backends::Sqs::Producer, auto_configure: true do
   let(:queue_config) { sqs_queue_config }
   let(:logger) { NilLogger.new }
   let(:queues) { TxghQueue::Backends::Sqs::Config.queues }

data/spec/backends/sqs/queue_spec.rb

@@ -1,8 +1,6 @@
 require 'spec_helper'
 
-include TxghQueue::Backends
-
-describe Sqs::Queue do
+describe TxghQueue::Backends::Sqs::Queue do
   let(:options) { { name: 'test-queue', region: 'us-east-1', events: %w(a b c) } }
   let(:queue) { described_class.new(options) }
 

data/spec/backends/sqs/retry_logic_spec.rb

@@ -1,16 +1,13 @@
 require 'spec_helper'
 require 'helpers/sqs/sqs_test_message'
 
-include TxghQueue
-include TxghQueue::Backends
-
-describe Sqs::RetryLogic do
+describe TxghQueue::Backends::Sqs::RetryLogic do
   context 'with overall retries exceeded' do
     let(:logic) { described_class.new(message_attributes, current_status) }
-    let(:current_status) { Status.retry_without_delay }
+    let(:current_status) { TxghQueue::Status.retry_without_delay }
     let(:message) { SqsTestMessage.new('abc123', '{}', message_attributes.to_h) }
     let(:message_attributes) do
-      Sqs::MessageAttributes.from_h(
+      TxghQueue::Backends::Sqs::MessageAttributes.from_h(
         history_sequence: {
           string_value: described_class::OVERALL_MAX_RETRIES.times.map do
             { status: 'retry_without_delay' }
@@ -33,23 +30,23 @@ describe Sqs::RetryLogic do
 
     describe '#next_delay_seconds' do
       it 'raises an error' do
-        expect { logic.next_delay_seconds }.to raise_error(Sqs::RetriesExceededError)
+        expect { logic.next_delay_seconds }.to raise_error(TxghQueue::Backends::Sqs::RetriesExceededError)
       end
     end
 
     describe '#sqs_retry_params' do
       it 'raises an error' do
-        expect { logic.sqs_retry_params }.to raise_error(Sqs::RetriesExceededError)
+        expect { logic.sqs_retry_params }.to raise_error(TxghQueue::Backends::Sqs::RetriesExceededError)
       end
     end
   end
 
   context 'with a run of no-delay retries' do
     let(:logic) { described_class.new(message_attributes, current_status) }
-    let(:current_status) { Status.retry_without_delay }
+    let(:current_status) { TxghQueue::Status.retry_without_delay }
     let(:message) { SqsTestMessage.new('abc123', '{}', message_attributes.to_h) }
     let(:message_attributes) do
-      Sqs::MessageAttributes.from_h(
+      TxghQueue::Backends::Sqs::MessageAttributes.from_h(
         history_sequence: {
           string_value: [
             { status: 'retry_without_delay' },
@@ -87,7 +84,7 @@ describe Sqs::RetryLogic do
     end
 
     context 'and a delayed current status' do
-      let(:current_status) { Status.retry_with_delay }
+      let(:current_status) { TxghQueue::Status.retry_with_delay }
 
       describe '#next_delay_seconds' do
         it 'indicates a first-stage delay' do
@@ -101,10 +98,10 @@ describe Sqs::RetryLogic do
 
   context 'with a run of delayed retries' do
     let(:logic) { described_class.new(message_attributes, current_status) }
-    let(:current_status) { Status.retry_with_delay }
+    let(:current_status) { TxghQueue::Status.retry_with_delay }
     let(:message) { SqsTestMessage.new('abc123', '{}', message_attributes.to_h) }
     let(:message_attributes) do
-      Sqs::MessageAttributes.from_h(
+      TxghQueue::Backends::Sqs::MessageAttributes.from_h(
         history_sequence: {
           string_value: [
             { status: 'retry_with_delay' },
@@ -145,7 +142,7 @@ describe Sqs::RetryLogic do
     end
 
     context 'and a non-delayed current status' do
-      let(:current_status) { Status.retry_without_delay }
+      let(:current_status) { TxghQueue::Status.retry_without_delay }
 
       describe '#next_delay_seconds' do
         it 'indicates no delay' do

data/spec/backends/sqs_spec.rb

@@ -1,16 +1,14 @@
 require 'spec_helper'
 
-include TxghQueue::Backends
-
-describe Sqs, auto_configure: true do
+describe TxghQueue::Backends::Sqs, auto_configure: true do
   let(:queue_config) { sqs_queue_config }
 
   describe '.producer_for' do
     it 'looks up the queues for the given event and returns a producer object' do
       producer = described_class.producer_for('a')
-      expect(producer).to be_a(Sqs::Producer)
+      expect(producer).to be_a(TxghQueue::Backends::Sqs::Producer)
       expect(producer.queues.size).to eq(1)
-      expect(producer.queues.first).to be_a(Sqs::Queue)
+      expect(producer.queues.first).to be_a(TxghQueue::Backends::Sqs::Queue)
       expect(producer.queues.first.name).to eq('test-queue')
     end
 
@@ -30,9 +28,9 @@ describe Sqs, auto_configure: true do
   describe '.consumer_for' do
     it 'looks up the queue for the given event and returns a consumer object' do
       consumer = described_class.consumer_for('b')
-      expect(consumer).to be_a(Sqs::Consumer)
+      expect(consumer).to be_a(TxghQueue::Backends::Sqs::Consumer)
       expect(consumer.queues.size).to eq(1)
-      expect(consumer.queues.first).to be_a(Sqs::Queue)
+      expect(consumer.queues.first).to be_a(TxghQueue::Backends::Sqs::Queue)
       expect(consumer.queues.first.name).to eq('test-queue')
     end