txgh-queue 1.0.0

data/spec/error_handlers/standard_errors_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+include TxghQueue
+
+describe ErrorHandlers::StandardErrors do
+  describe '.can_handle?' do
+    it 'can reply to StandardError' do
+      expect(described_class.can_handle?(StandardError.new)).to eq(true)
+    end
+
+    it 'can reply to things that inherit from StandardError' do
+      expect(described_class.can_handle?(RuntimeError.new)).to eq(true)
+    end
+  end
+
+  describe '.status_for' do
+    it 'always responds with fail' do
+      expect(described_class.status_for(StandardError.new)).to eq(Status.fail)
+      expect(described_class.status_for('foo')).to eq(Status.fail)
+    end
+  end
+end

data/spec/error_handlers/transifex_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+include TxghQueue
+
+describe ErrorHandlers::Transifex do
+  describe '.can_handle?' do
+    it 'can reply to transifex api errors' do
+      error = Txgh::TransifexApiError.new(500, 'Internal error')
+      expect(described_class.can_handle?(error)).to eq(true)
+    end
+
+    it 'can reply to transifex not found errors' do
+      error = Txgh::TransifexNotFoundError.new
+      expect(described_class.can_handle?(error)).to eq(true)
+    end
+
+    it 'can reply to transifex unauthorized errors' do
+      error = Txgh::TransifexUnauthorizedError.new
+      expect(described_class.can_handle?(error)).to eq(true)
+    end
+
+    it "can't reply to unsupported error classes" do
+      expect(described_class.can_handle?(StandardError.new)).to eq(false)
+    end
+  end
+
+  describe '.status_for' do
+    it 'retries with delay on api error' do
+      error = Txgh::TransifexApiError.new(500, 'Internal error')
+      expect(described_class.status_for(error)).to eq(Status.retry_with_delay)
+    end
+
+    it 'fails on not found error' do
+      error = Txgh::TransifexNotFoundError.new
+      expect(described_class.status_for(error)).to eq(Status.fail)
+    end
+
+    it 'fails on unauthorized error' do
+      error = Txgh::TransifexUnauthorizedError.new
+      expect(described_class.status_for(error)).to eq(Status.fail)
+    end
+  end
+end

data/spec/error_handlers/txgh_errors_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+include TxghQueue
+
+describe ErrorHandlers::TxghErrors do
+  describe '.can_handle?' do
+    it 'can reply to all configured error classes' do
+      described_class::ERROR_CLASSES.keys.each do |klass|
+        expect(described_class.can_handle?(klass.new)).to eq(true)
+      end
+    end
+
+    it "can't reply to unsupported error classes" do
+      expect(described_class.can_handle?(StandardError.new)).to eq(false)
+    end
+  end
+
+  describe '.status_for' do
+    it 'replies to all configured errors correctly' do
+      described_class::ERROR_CLASSES.each_pair do |klass, expected_response|
+        expect(described_class.status_for(klass.new)).to eq(expected_response)
+      end
+    end
+  end
+end

data/spec/helpers/env_helpers.rb

@@ -0,0 +1,13 @@
+module EnvHelpers
+  def with_env(env)
+    # ENV can't be duped, so use select instead to make a copy
+    old_env = ENV.select { true }
+    env.each_pair { |k, v| ENV[k] = v }
+    yield
+  ensure
+    # reset back to old vars
+    env.each_pair { |k, _| ENV[k] = old_env[k] }
+  end
+end
+
+EnvHelpers.extend(EnvHelpers)

data/spec/helpers/nil_logger.rb

@@ -0,0 +1,10 @@
+class NilLogger
+  def info(*args)
+  end
+
+  def warn(*args)
+  end
+
+  def error(*args)
+  end
+end

data/spec/helpers/sqs/sqs_test_message.rb

@@ -0,0 +1,47 @@
+require 'securerandom'
+
+class SqsTestMessage
+  attr_reader :message_id, :body, :message_attributes
+  attr_reader :receipt_handle
+
+  def initialize(message_id, body, message_attributes = {})
+    @message_id = message_id
+    @body = body
+    @message_attributes = SqsTestMessageAttributes.new(message_attributes)
+    @receipt_handle = SecureRandom.hex
+  end
+
+  def to_bundle
+    SqsTestMessageBundle.new([self])
+  end
+end
+
+class SqsTestMessageBundle
+  attr_reader :messages
+
+  def initialize(messages)
+    @messages = messages
+  end
+end
+
+class SqsTestMessageAttributes
+  attr_reader :attributes
+
+  def initialize(attributes)
+    @attributes = attributes
+  end
+
+  def [](key)
+    if attribute = attributes[key]
+      SqsTestMessageAttribute.new(attribute)
+    end
+  end
+end
+
+class SqsTestMessageAttribute
+  attr_reader :string_value
+
+  def initialize(attribute)
+    @string_value = attribute['string_value']
+  end
+end

data/spec/helpers/test_backend.rb

@@ -0,0 +1,54 @@
+module TxghQueue
+  class TestBackend
+    class << self
+      def producer_for(event, logger = Txgh::TxLogger.logger)
+        producers[event] ||= TestProducer.new(event, logger)
+      end
+
+      def consumer_for(event, logger = Txgh::TxLogger.logger)
+        consumers[event] ||= TestConsumer.new(event, logger)
+      end
+
+      def reset!
+        @producers = nil
+        @consumers = nil
+      end
+
+      private
+
+      def producers
+        @producers ||= {}
+      end
+
+      def consumers
+        @consumers ||= {}
+      end
+    end
+  end
+
+  class TestProducer
+    attr_reader :queue_names, :logger, :enqueued_jobs
+
+    def initialize(event, logger)
+      @event = event
+      @logger = logger
+      @enqueued_jobs = []
+    end
+
+    def enqueue(payload, options = {})
+      enqueued_jobs << { payload: payload, options: options }
+    end
+  end
+
+  class TestConsumer
+    attr_reader :queue_names, :logger
+
+    def initialize(event, logger)
+      @event = event
+      @logger = logger
+    end
+
+    def work
+    end
+  end
+end

data/spec/job_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+include TxghQueue
+
+describe Job, auto_configure: true do
+  let(:logger) { NilLogger.new }
+  let(:repo_name) { 'my_repo' }
+  let(:txgh_config) { Txgh::Config::ConfigPair.new(:github_repo, :transifex_project) }
+  let(:job) { described_class.new(logger) }
+
+  before(:each) do
+    allow(Txgh::Config::KeyManager).to(
+      receive(:config_from_repo).with(repo_name).and_return(txgh_config)
+    )
+  end
+
+  shared_examples 'a payload processor' do
+    it 'processes the payload' do
+      server_response = TxghServer::Response.new(200, 'Ok')
+      expect(handler).to receive(:execute).and_return(server_response)
+      result = job.process(payload)
+      expect(result.status).to eq(Status.ok)
+      expect(result.response).to eq(server_response)
+    end
+
+    it 'responds appropriately when an error is raised' do
+      expect(handler).to receive(:execute).and_raise(StandardError)
+      result = job.process(payload)
+      expect(result.status).to eq(Status.fail)
+      expect(result.error).to be_a(StandardError)
+    end
+
+    it 'responds appropriately when an error response is returned' do
+      server_response = TxghServer::Response.new(404, 'Not found')
+      expect(handler).to receive(:execute).and_return(server_response)
+      result = job.process(payload)
+      expect(result.status).to eq(Status.fail)
+      expect(result.response).to eq(server_response)
+    end
+  end
+
+  context 'with a push payload' do
+    let(:payload) do
+      {
+        'repo_name' => repo_name,
+        'event' => 'push',
+        'txgh_event' => 'github.push',
+        'ref' => 'heads/master',
+        'before' => 'abc123',
+        'after' => 'def456',
+        'added_files' => [],
+        'modified_files' => [],
+        'author' => 'Bugs Bunny'
+      }
+    end
+
+    describe '#process' do
+      let(:handler) { double(:handler) }
+
+      before(:each) do
+        expect(TxghServer::Webhooks::Github::PushHandler).to(
+          receive(:new).and_return(handler)
+        )
+      end
+
+      it_behaves_like 'a payload processor'
+    end
+  end
+
+  context 'with a delete payload' do
+    let(:payload) do
+      {
+        'repo_name' => repo_name,
+        'event' => 'delete',
+        'txgh_event' => 'github.delete',
+        'ref' => 'heads/master',
+        'ref_type' => 'branch'
+      }
+    end
+
+    describe '#process' do
+      let(:handler) { double(:handler) }
+
+      before(:each) do
+        expect(TxghServer::Webhooks::Github::DeleteHandler).to(
+          receive(:new).and_return(handler)
+        )
+      end
+
+      it_behaves_like 'a payload processor'
+    end
+  end
+
+  context 'with a payload with an unrecognized event type' do
+    let(:payload) do
+      {
+        'repo_name' => repo_name,
+        'txgh_event' => 'foobarbazboo'
+      }
+    end
+
+    describe '#process' do
+      it 'responds with fail' do
+        result = job.process(payload)
+        expect(result.status).to eq(Status.fail)
+        expect(result.response.status).to eq(400)
+        expect(result.response.body).to eq([error: 'Unexpected event type'])
+      end
+    end
+  end
+end

data/spec/result_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+include TxghQueue
+
+describe Result do
+  context 'with a response' do
+    let(:response) { TxghServer::Response.new(200, 'Ok') }
+    let(:result) { Result.new(Status.ok, response) }
+
+    describe 'has_response?' do
+      it 'does have a response' do
+        expect(result.has_response?).to eq(true)
+      end
+    end
+
+    describe 'has_error?' do
+      it 'does not have an error' do
+        expect(result.has_error?).to eq(false)
+      end
+    end
+
+    describe '#response' do
+      it 'returns the response' do
+        expect(result.response).to eq(response)
+      end
+    end
+
+    describe '#error' do
+      it 'returns nil' do
+        expect(result.error).to eq(nil)
+      end
+    end
+  end
+
+  context 'with an error' do
+    let(:error) { StandardError.new }
+    let(:result) { Result.new(Status.fail, error) }
+
+    describe 'has_response?' do
+      it 'does not have a response' do
+        expect(result.has_response?).to eq(false)
+      end
+    end
+
+    describe 'has_error?' do
+      it 'does have an error' do
+        expect(result.has_error?).to eq(true)
+      end
+    end
+
+    describe '#response' do
+      it 'returns nil' do
+        expect(result.response).to eq(nil)
+      end
+    end
+
+    describe '#error' do
+      it 'returns nil' do
+        expect(result.error).to eq(error)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,66 @@
+$:.push(File.join(Gem.loaded_specs['txgh'].full_gem_path, 'spec'))
+$:.push(File.join(Gem.loaded_specs['txgh-server'].full_gem_path, 'spec'))
+
+require 'pry-byebug'
+require 'rake'
+require 'rspec'
+require 'txgh'
+require 'txgh-queue'
+require 'txgh-server'
+
+require 'helpers/env_helpers'
+require 'helpers/nil_logger'
+require 'helpers/test_backend'
+
+RSpec.configure do |config|
+  module GlobalLets
+    extend RSpec::SharedContext
+
+    # default config, override in specs if you wanna customize
+    let(:queue_config) do
+      {
+        backend: 'test',
+        options: {
+          queues: %w(test-queue)
+        }
+      }
+    end
+
+    # default sqs config; override queue_config with this when working with the
+    # sqs backend, i.e. let(:queue_config) { sqs_queue_config }
+    let(:sqs_queue_config) do
+      {
+        backend: 'sqs',
+        options: {
+          queues: [
+            { name: 'test-queue', region: 'us-east-1', events: %w(a b c) },
+            { name: 'test-queue-2', region: 'us-west-1', events: %w(c d e) }
+          ],
+
+          failure_queue: {
+            name: 'test-failure-queue', region: 'us-east-1'
+          }
+        }
+      }
+    end
+  end
+
+  config.include(GlobalLets)
+  config.include(EnvHelpers)
+
+  config.around(:each) do |example|
+    if example.metadata[:auto_configure]
+      env_vars = { 'TXGH_QUEUE_CONFIG' => "raw://#{YAML.dump(queue_config)}" }
+      with_env(env_vars) { example.run }
+
+      # reset global config
+      TxghQueue::Config.reset!
+      TxghQueue::TestBackend.reset!
+      TxghQueue::Backends::Sqs::Config.reset!
+    else
+      example.run
+    end
+  end
+end
+
+TxghQueue::Backends.register('test', TxghQueue::TestBackend)

data/spec/status_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+include TxghQueue
+
+describe Status do
+  describe '.retry_without_delay' do
+    it 'returns the same object' do
+      expect(described_class.retry_without_delay.object_id).to eq(
+        described_class.retry_without_delay.object_id
+      )
+    end
+  end
+
+  describe '.retry_with_delay' do
+    it 'returns the same object' do
+      expect(described_class.retry_with_delay.object_id).to eq(
+        described_class.retry_with_delay.object_id
+      )
+    end
+  end
+
+  describe '.fail' do
+    it 'returns the same object' do
+      expect(described_class.fail.object_id).to eq(described_class.fail.object_id)
+    end
+  end
+
+  describe '.ok' do
+    it 'returns the same object' do
+      expect(described_class.ok.object_id).to eq(described_class.ok.object_id)
+    end
+  end
+
+  describe '#retry_without_delay?' do
+    it 'returns true if the response matches, false otherwise' do
+      expect(described_class.retry_without_delay.retry_without_delay?).to eq(true)
+      expect(described_class.ok.retry_without_delay?).to eq(false)
+    end
+  end
+
+  describe '#retry_with_delay?' do
+    it 'returns true if the response matches, false otherwise' do
+      expect(described_class.retry_with_delay.retry_with_delay?).to eq(true)
+      expect(described_class.ok.retry_with_delay?).to eq(false)
+    end
+  end
+
+  describe '#fail?' do
+    it 'returns true if the response matches, false otherwise' do
+      expect(described_class.fail.fail?).to eq(true)
+      expect(described_class.ok.fail?).to eq(false)
+    end
+  end
+
+  describe '#ok?' do
+    it 'returns true if the response matches, false otherwise' do
+      expect(described_class.ok.ok?).to eq(true)
+      expect(described_class.fail.ok?).to eq(false)
+    end
+  end
+
+  describe '#to_s' do
+    it 'converts the status into a string' do
+      expect(described_class.fail.to_s).to eq('fail')
+      expect(described_class.ok.to_s).to eq('ok')
+    end
+  end
+end

data/spec/supervisor_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+include TxghQueue
+
+describe Supervisor do
+  describe '.supervise' do
+    it 'provides a handy shortcut to wrap a block with supervising' do
+      response = described_class.supervise { raise StandardError }
+      expect(response.status).to eq(Status.fail)
+    end
+  end
+
+  describe '#execute' do
+    it 'handles errors generated by the given block' do
+      responder = described_class.new { raise StandardError }
+      expect(responder.execute.status).to eq(Status.fail)
+    end
+
+    it 'handles error responses generated by the given block' do
+      responder = described_class.new do
+        TxghServer::Response.new(401, 'Unauthorized')
+      end
+
+      expect(responder.execute.status).to eq(Status.fail)
+    end
+
+    it 'handles non-error responses generated by the given block' do
+      responder = described_class.new do
+        TxghServer::Response.new(200, 'Ok')
+      end
+
+      expect(responder.execute.status).to eq(Status.ok)
+    end
+
+    it "raises an error if error handling logic can't be determined" do
+      responder = described_class.new { 'unexpected response' }
+      expect { responder.execute }.to raise_error(UnexpectedResponse)
+    end
+  end
+end