govuk_message_queue_consumer 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c236b54beb0a0440047c111caf390c175b9a6a67
-  data.tar.gz: 6064d29e67a5156cf20d111d8704045cb8816fac
+  metadata.gz: f3d0a2e8f69b4d555db92e1251f26b8238f1ad63
+  data.tar.gz: c97edff469050cfbf09031625ff3e22f2c573bee
 SHA512:
-  metadata.gz: bb3b285c4210e1cc9bd0c42395ab875391aaa1a94d795bcd1a53d005ddcdaea852bf3f0e59c4f846f63abe5a7d74961d6eb5c20d570e2ee4fdc56246c7afade8
-  data.tar.gz: b62511ec795ad7dcda904577f4f3ab2ba2943fbc27a2b2ba4be6c5c292f5f18c146c92d1390022aa3ba9d89096d7bdca6df2da7c198d2b6495ef365a968409d8
+  metadata.gz: 0ad7430c3ed9f12498a91b90c30050737809f0e2c0234e0892a417d7813004c306d68c95992c04def1fa23b987bc6f5652671472685a8a95dcc257f5ec5c15be
+  data.tar.gz: b719dadfe75138257d573f91ea758ebf6878ac076971a76dd49012b8de6dd2a35c9c68b559609e1a44148c6ced539c9d8d510c7ad59c95e38241a1903eebd0c6

data/README.md

@@ -1,73 +1,140 @@
-# GOV.UK Message queue consumer
+# GOV.UK Message Queue Consumer
 
-Standardise the way GOV.UK consumes messages from RabbitMQ.
+Standardises the way GOV.UK consumes messages from [RabbitMQ](https://www.rabbitmq.com/).
+RabbitMQ is a messaging framework that allows applications to broadcast messages
+that can be picked up by other applications.
 
+On GOV.UK, [publishing-api](https://github.com/alphagov/publishing-api) publishes
+the content-items it receives, so that applications such as
+[email-alert-service](https://github.com/alphagov/email-alert-service) can be
+notified of changes in content.
 
 ## Nomenclature
 
-- **Message queue**: a method of providing asynchronous interprocess
-  communication
-
+![A graph showing the message flow](docs/graph.png)
+
+- **Producer**: an application that sends messages RabbitMQ. On GOV.UK this could
+  be [publishing-api](https://github.com/alphagov/publishing-api).
+- **Message**: an object sent over RabbitMQ. It consists of a _payload_ and
+  _headers_. In the case of the publishing-api the payload is a
+  [content item](https://github.com/alphagov/govuk-content-schemas).
+- **Consumer**: the app that receives the messages and does something with them.
+  On GOV.UK, these could be [email-alert-service](https://github.com/alphagov/email-alert-service)
+  and [content-register](https://github.com/alphagov/content-register).
+- **Exchange**: in RabbitMQ's model, producers send messages to an _exchange_.
+  Consumers can create a Queue that listens to the exchange, instead of
+  subscribing to the exchange directly. This is done so that the queue can buffer
+  any messages and we can make sure all messages get delivered to the consumer.
+- **Queue**: a queue listens to an exchange. In most cases the queue will listen
+  to all messages, but it's also possible to listen to a specific pattern.
+- **Processor**: the specific class that processes a message.
 
 ## Technical documentation
 
-This is a ruby gem that deals with the boiler plate code of connecting,
-subscribing, etc, to [RabbitMQ](https://www.rabbitmq.com/).
-
-The user of this gem is left the task of supplying their rabbitmq infrastructure
-configuration and an instance of a class that processes messages.
+This is a ruby gem that deals with the boiler plate code of communicating with
+[RabbitMQ](https://www.rabbitmq.com/). The user of this gem is left the task of
+supplying the configuration and a class that processes messages.
 
-The message format received by the message processor is found in
-`lib/govuk_message_queue_consumer/message.rb`
+This gem is auto-released with [gem_publisher](https://github.com/alphagov/gem_publisher).
+To release a new version, simply raise a pull request with the version number
+incremented.
 
 ### Dependencies
 
-- **bunny**: to interact with RabbitMQ
-- **activesupport**: use `with_indifferent_access` for Bunny
+- The [Bunny](https://github.com/ruby-amqp/bunny) gem: to interact with RabbitMQ.
+
+## Usage
 
+For an example on how to implement a message queue consumer, see [alphagov/panopticon#307](https://github.com/alphagov/panopticon/pull/307/files).
 
-### Running the application
+Add the gem:
+
+```ruby
+# Gemfile
+gem "govuk_message_queue_consumer", "~> 2.0.0"
+```
 
-We recommend creating a rake task like the following example:
+Add a rake task like the following example:
 
 ```ruby
+# lib/tasks/message_queue.rake
 namespace :message_queue do
   desc "Run worker to consume messages from rabbitmq"
   task consumer: :environment do
-    config = get_rabbitmq_configuration_hash
-    # ^ eg YAML.load_file(Rails.root.join('config', 'rabbitmq.yml'))[Rails.env]
-    GovukMessageQueueConsumer::Consumer.new(config, MyProcessor.new).run
+    GovukMessageQueueConsumer::Consumer.new(
+      queue_name: "some-queue",
+      exchange_name: "some-exchange",
+      processor: MyProcessor.new
+    ).run
   end
 end
 ```
 
-`govuk_message_queue_consumer` expects configuration and a processor to be supplied:
+The consumer expects a number of environment variables to be present. On GOV.UK,
+these should be set up in puppet.
+
+```
+RABBITMQ_HOSTS=rabbitmq1.example.com,rabbitmq2.example.com
+RABBITMQ_VHOST=/
+RABBITMQ_USER=a_user
+RABBITMQ_PASSWORD=a_super_secret
+```
+
+Define a class that will process the messages:
 
 ```ruby
-# example configuration. Could be stored in YAML if preferred
-config = {
-    host: 'localhost',
-    port: 5672,
-    user: rabbitmq_user,
-    pass: rabbitmq_pass,
-    recover_from_connection_close: true,
-    exchange: my_exchange,
-    queue: my_queue,
-}
-
-# example message processor
+# eg. app/queue_consumers/my_processor.rb
 class MyProcessor
   def process(message)
-    message.ack
+    # do something cool
   end
 end
 ```
 
-#### Testing your processor
+The worker should also be added to the Procfile to run in production:
+
+```
+# Procfile
+worker: bundle exec rake message_queue:consumer
+```
+
+Because you need the environment variables when running the consumer, you should use
+`govuk_setenv` to run your app in development:
+
+```
+$ govuk_setenv app-name bundle exec rake message_queue:consumer
+```
+
+### Processing a message
+
+Once you receive a message, you *must* tell RabbitMQ once you've processed it. This
+is called _acking_. You can also _discard_ the message, or _retry_ it.
+
+```ruby
+class MyProcessor
+  def process(message)
+    result = do_something_with(message)
+
+    if result.ok?
+      # Ack the message when it has been processed correctly.
+      message.ack
+    elsif result.failed_temporarily?
+      # Retry the message to make RabbitMQ send the message again later.
+      message.retry
+    elsif result.failed_permanently?
+      # Discard the message when it can't be processed.
+      message.discard
+    end
+  end
+end
+```
+
+### Testing your processor
 
 This gem provides a test helper for your processor.
 
 ```ruby
+# eg. spec/queue_consumers/my_processor_spec.rb
 require 'test_helper'
 require 'govuk_message_queue_consumer/test_helpers'
 
@@ -76,7 +143,28 @@ describe MyProcessor do
 end
 ```
 
-This will verify that your processor class implements the correct methods. You should add your own tests to verify its behaviour.
+This will verify that your processor class implements the correct methods. You
+should add your own tests to verify its behaviour.
+
+You can use `GovukMessageQueueConsumer::MockMessage` to test the processor
+behaviour. When using the mock, you can verify it acknowledged, retried or
+discarded. For example, with `MyProcessor` above:
+
+```ruby
+it "acks incoming messages" do
+  message = GovukMessageQueueConsumer::MockMessage.new
+
+  MyProcessor.new.process(message)
+
+  expect(message).to be_acked
+
+  # or if you use minitest:
+  assert message.acked?
+end
+```
+
+For more test cases [see the spec for the mock itself](/spec/mock_message_spec.rb).
+
 
 ### Running the test suite
 
@@ -84,12 +172,19 @@ This will verify that your processor class implements the correct methods. You s
 bundle exec rake spec
 ```
 
+## Further reading
+
+- [Bunny](https://github.com/ruby-amqp/bunny) is the RabbitMQ client we use.
+- [The Bunny Guides](http://rubybunny.info/articles/guides.html) explain all
+  AMQP concepts really well.
+- The [Opsmanual](https://github.gds/pages/gds/opsmanual/2nd-line/nagios.html?highlight=rabbitmq#rabbitmq-checks)
+  documents the usage of "heartbeat" messages, which this gem also supports.
 
 ## Licence
 
 [MIT License](LICENCE)
 
-
 ## Versioning policy
 
-[Semantic versioning](http://semver.org/spec/v2.0.0.html)
+We follow [Semantic versioning](http://semver.org/spec/v2.0.0.html). Check the
+[CHANGELOG](CHANGELOG.md) for changes.

data/lib/govuk_message_queue_consumer/consumer.rb

@@ -1,22 +1,28 @@
-require 'active_support/core_ext/hash/indifferent_access'
 require 'bunny'
 
 module GovukMessageQueueConsumer
   class Consumer
-    def initialize(config, processor)
-      @processor = HeartbeatProcessor.new(processor)
-
-      @config = config.with_indifferent_access
-      @queue_name = @config.fetch(:queue)
-      @bindings = { @config.fetch(:exchange) => "#" }
-      @connection = Bunny.new(@config[:connection].symbolize_keys)
-      @connection.start
+    # Only fetch one message at a time on the channel.
+    #
+    # By default, queues will grab messages eagerly, which reduces latency.
+    # However, that also means that if multiple workers are running one worker
+    # can starve another of work.  We're not expecting a high throughput on this
+    # queue, and a small bit of latency isn't a problem, so we fetch one at a
+    # time to share the work evenly.
+    NUMBER_OF_MESSAGES_TO_PREFETCH = 1
+
+    def initialize(queue_name:, exchange_name:, processor:, routing_key: '#')
+      @queue_name = queue_name
+      @exchange_name = exchange_name
+      @processor = processor
+      @routing_key = routing_key
     end
 
     def run
-      queue.subscribe(:block => true, :manual_ack => true) do |delivery_info, headers, payload|
+      queue.subscribe(block: true, manual_ack: true) do |delivery_info, headers, payload|
         begin
-          @processor.process(Message.new(delivery_info, headers, payload))
+          message = Message.new(payload, headers, delivery_info)
+          processor_chain.process(message)
         rescue Exception => e
           $stderr.puts "rabbitmq_consumer: aborting due to unhandled exception in processor #{e.class}: #{e.message}"
           exit(1) # ensure rabbitmq requeues outstanding messages
@@ -24,21 +30,35 @@ module GovukMessageQueueConsumer
       end
     end
 
-    private
+  private
+
+    def processor_chain
+      @processor_chain ||= HeartbeatProcessor.new(JSONProcessor.new(@processor))
+    end
 
     def queue
-      @queue ||= setup_queue
+      @queue ||= begin
+        channel.prefetch(NUMBER_OF_MESSAGES_TO_PREFETCH)
+        queue = channel.queue(@queue_name, durable: true)
+        queue.bind(exchange, routing_key: @routing_key)
+        queue
+      end
+    end
+
+    def exchange
+      @exchange ||= channel.topic(@exchange_name, passive: true)
+    end
+
+    def channel
+      @channel ||= connection.create_channel
     end
 
-    def setup_queue
-      @channel = @connection.create_channel
-      @channel.prefetch(1) # only one unacked message at a time
-      queue = @channel.queue(@queue_name, :durable => true)
-      @bindings.each do |exchange_name, routing_key|
-        exchange = @channel.topic(exchange_name, :passive => true)
-        queue.bind(exchange, :routing_key => routing_key)
+    def connection
+      @connection ||= begin
+        new_connection = Bunny.new(RabbitMQConfig.new.from_environment)
+        new_connection.start
+        new_connection
       end
-      queue
     end
   end
 end

data/lib/govuk_message_queue_consumer/json_processor.rb

@@ -0,0 +1,20 @@
+module GovukMessageQueueConsumer
+  class JSONProcessor
+    JSON_FORMAT = "application/json".freeze
+
+    def initialize(next_processor)
+      @next_processor = next_processor
+    end
+
+    def process(message)
+      if message.headers.content_type == JSON_FORMAT
+        message.payload = JSON.parse(message.payload)
+      end
+
+      @next_processor.process(message)
+    rescue JSON::ParserError => e
+      Airbrake.notify_or_ignore(e) if defined?(Airbrake)
+      message.discard
+    end
+  end
+end

data/lib/govuk_message_queue_consumer/message.rb

@@ -3,16 +3,12 @@ require 'json'
 module GovukMessageQueueConsumer
   # Client code will receive an instance of this
   class Message
-    def initialize(delivery_info, headers, payload)
-      @delivery_info = delivery_info
-      @headers = headers
-      @body = payload
-    end
+    attr_accessor :delivery_info, :headers, :payload
 
-    attr_reader :delivery_info, :headers, :body
-
-    def body_data
-      @body_data ||= JSON.parse(@body)
+    def initialize(payload, headers, delivery_info)
+      @payload = payload
+      @headers = headers
+      @delivery_info = delivery_info
     end
 
     def ack

data/lib/govuk_message_queue_consumer/rabbitmq_config.rb

@@ -0,0 +1,29 @@
+class RabbitMQConfig
+  class ConfigurationError < StandardError
+  end
+
+  def from_environment
+    {
+      hosts: fetch("RABBITMQ_HOSTS").split(','),
+      vhost: fetch("RABBITMQ_VHOST"),
+      user: fetch("RABBITMQ_USER"),
+      pass: fetch("RABBITMQ_PASSWORD"),
+      recover_from_connection_close: true,
+    }
+  end
+
+private
+
+  def fetch(variable_name)
+    ENV[variable_name] || raise_error(variable_name)
+  end
+
+  def raise_error(variable_name)
+    raise ConfigurationError, <<-err
+      The environment variable #{variable_name} is not set. If you are in test
+      mode, make sure you set the correct vars in your helpers. If you get this
+      error in development, make sure you run rails or rake with `govuk_setenv`
+      and puppet is up to date.
+    err
+  end
+end

data/lib/govuk_message_queue_consumer/test_helpers/mock_message.rb

@@ -0,0 +1,27 @@
+module GovukMessageQueueConsumer
+  class MockMessage < Message
+    attr_reader :acked, :retried, :discarded
+
+    alias :acked? :acked
+    alias :discarded? :discarded
+    alias :retried? :retried
+
+    def initialize(payload = {}, headers = {}, delivery_info = {})
+      @payload = payload
+      @headers = OpenStruct.new(headers)
+      @delivery_info = OpenStruct.new(delivery_info)
+    end
+
+    def ack
+      @acked = true
+    end
+
+    def retry
+      @retried = true
+    end
+
+    def discard
+      @discarded = true
+    end
+  end
+end

data/lib/govuk_message_queue_consumer/test_helpers/shared_examples.rb

@@ -1,9 +1,11 @@
-RSpec.shared_examples "a message queue processor" do
-  it "implements #process" do
-    expect(subject).to respond_to(:process)
-  end
+if defined?(RSpec)
+  RSpec.shared_examples "a message queue processor" do
+    it "implements #process" do
+      expect(subject).to respond_to(:process)
+    end
 
-  it "accepts 1 argument for #process" do
-    expect(subject.method(:process).arity).to eq(1)
+    it "accepts 1 argument for #process" do
+      expect(subject.method(:process).arity).to eq(1)
+    end
   end
 end

data/lib/govuk_message_queue_consumer/test_helpers/test_consumer.rb

@@ -0,0 +1,12 @@
+module GovukMessageQueueConsumer
+  class TestConsumer < Consumer
+    def publish_message(payload, options)
+      exchange.publish(payload, options)
+    end
+
+    # call after integration tests finish
+    def delete_queue
+      queue.delete
+    end
+  end
+end

data/lib/govuk_message_queue_consumer/test_helpers.rb

@@ -1 +1,3 @@
 require 'govuk_message_queue_consumer/test_helpers/shared_examples'
+require 'govuk_message_queue_consumer/test_helpers/mock_message'
+require 'govuk_message_queue_consumer/test_helpers/test_consumer'

data/lib/govuk_message_queue_consumer/version.rb

@@ -1,3 +1,3 @@
 module GovukMessageQueueConsumer
-  VERSION = '1.0.0'
+  VERSION = '2.0.0'
 end

data/lib/govuk_message_queue_consumer.rb

@@ -1,4 +1,6 @@
 require 'govuk_message_queue_consumer/version'
 require 'govuk_message_queue_consumer/heartbeat_processor'
+require 'govuk_message_queue_consumer/json_processor'
 require 'govuk_message_queue_consumer/message'
 require 'govuk_message_queue_consumer/consumer'
+require 'govuk_message_queue_consumer/rabbitmq_config'

data/spec/consumer_spec.rb

@@ -1,48 +1,35 @@
 require_relative 'spec_helper'
 
 describe Consumer do
-
-  let(:queue) { instance_double('Bunny::Queue', bind: nil, subscribe: message_values) }
+  let(:queue) { instance_double('Bunny::Queue', bind: nil, subscribe: '') }
   let(:channel) { instance_double('Bunny::Channel', queue: queue, prefetch: nil, topic: nil) }
   let(:rabbitmq_connecton) { instance_double("Bunny::Session", start: nil, create_channel: channel) }
   let(:client_processor) { instance_double('Client::Processor') }
 
   before do
+    stub_environment_variables!
     allow(Bunny).to receive(:new).and_return(rabbitmq_connecton)
   end
 
-  describe "constructing an instance" do
-    let(:rabbitmq_connecton) { instance_double("Bunny::Session", start: nil, create_channel: channel) }
-    let(:client_processor) { instance_double('Client::Processor') }
-
-    it "passes the client processor to the Heartbeat Processor" do
-      expect(HeartbeatProcessor).to receive(:new).with(client_processor)
-
-      Consumer.new(rabbitmq_config, client_processor)
-    end
-
-    it "connects to rabbitmq" do
-      expected_options = rabbitmq_config['connection'].symbolize_keys # Bunny requires the keys to be symbols
-      expect(Bunny).to receive(:new).with(expected_options).and_return(rabbitmq_connecton)
-      expect(rabbitmq_connecton).to receive(:start)
+  describe "running the consumer" do
+    it "binds the queue to the all-routing key" do
+      expect(queue).to receive(:bind).with(nil, { routing_key: "#" })
 
-      Consumer.new(rabbitmq_config, client_processor)
+      Consumer.new(queue_name: "some-queue", exchange_name: "my-exchange", processor: client_processor).run
     end
-  end
 
-  describe "running the consumer" do
-    it "binds the queue" do
-      expect(queue).to receive(:bind)
+    it "binds the queue to a custom routing key" do
+      expect(queue).to receive(:bind).with(nil, { routing_key: "*.major" })
 
-      Consumer.new(rabbitmq_config, client_processor).run
+      Consumer.new(queue_name: "some-queue", exchange_name: "my-exchange", processor: client_processor, routing_key: "*.major").run
     end
 
     it "calls the heartbeat processor when subscribing to messages" do
-      expect(queue).to receive(:subscribe).and_yield(*message_values)
-      expect(Message).to receive(:new).with(*message_values)
+      expect(queue).to receive(:subscribe).and_yield(:delivery_info_object, :headers, "payload")
+      expect(Message).to receive(:new).with("payload", :headers, :delivery_info_object)
       expect_any_instance_of(HeartbeatProcessor).to receive(:process)
 
-      Consumer.new(rabbitmq_config, client_processor).run
+      Consumer.new(queue_name: "some-queue", exchange_name: "my-exchange", processor: client_processor).run
     end
   end
 end

data/spec/json_processor_spec.rb

@@ -0,0 +1,33 @@
+require_relative 'spec_helper'
+
+describe JSONProcessor do
+  describe "#process" do
+    it "parses the payload string" do
+      next_processor = double("next_processor", process: "ha")
+      message = MockMessage.new('{"some":"json"}', { content_type: "application/json" })
+
+      JSONProcessor.new(next_processor).process(message)
+
+      expect(message.payload).to eql({ "some" => "json" })
+      expect(next_processor).to have_received(:process)
+    end
+
+    it "discards messages with JSON errors" do
+      message = MockMessage.new('{"some" "json"}', { content_type: "application/json" })
+
+      JSONProcessor.new(double).process(message)
+
+      expect(message).to be_discarded
+    end
+
+    it "doesn't parse non-JSON message" do
+      next_processor = double("next_processor", process: "ha")
+      message = MockMessage.new('<SomeXML></SomeXML>', { content_type: "application/xml" })
+
+      JSONProcessor.new(next_processor).process(message)
+
+      expect(message.payload).to eql('<SomeXML></SomeXML>')
+      expect(next_processor).to have_received(:process)
+    end
+  end
+end

data/spec/message_spec.rb

@@ -4,25 +4,23 @@ describe Message do
   let(:mock_channel) { instance_double("Channel") }
   let(:delivery_info) { instance_double("DeliveryInfo", :channel => mock_channel, :delivery_tag => "a_tag") }
   let(:headers) { instance_double("Headers") }
-  let(:body) { {"foo" => "bar"}.to_json }
-  let(:message) { Message.new(delivery_info, headers, body) }
-
-  it "json decodes the body" do
-    expect(message.body_data).to eq("foo" => "bar")
-  end
+  let(:message) { Message.new({ "a" => "payload" }, headers, delivery_info) }
 
   it "ack sends an ack to the channel" do
     expect(mock_channel).to receive(:ack).with("a_tag")
+
     message.ack
   end
 
   it "retry sends a reject to the channel with requeue set" do
     expect(mock_channel).to receive(:reject).with("a_tag", true)
+
     message.retry
   end
 
   it "reject sends a reject to the channel without requeue set" do
     expect(mock_channel).to receive(:reject).with("a_tag", false)
+
     message.discard
   end
 end

data/spec/mock_message_spec.rb

@@ -0,0 +1,43 @@
+require_relative 'spec_helper'
+require_relative '../lib/govuk_message_queue_consumer/test_helpers/mock_message'
+
+describe GovukMessageQueueConsumer::MockMessage do
+  describe '#methods' do
+    it "implements the same methods as Message" do
+      mock = MockMessage.new
+      real = Message.new(double, double, double)
+
+      expect(real.methods - mock.methods).to be_empty
+    end
+  end
+
+  describe '#ack' do
+    it "marks the message as acked" do
+      message = MockMessage.new
+
+      message.ack
+
+      expect(message).to be_acked
+    end
+  end
+
+  describe '#retry' do
+    it "marks the message as retried" do
+      message = MockMessage.new
+
+      message.retry
+
+      expect(message).to be_retried
+    end
+  end
+
+  describe '#discard' do
+    it "marks the message as discarded" do
+      message = MockMessage.new
+
+      message.discard
+
+      expect(message).to be_discarded
+    end
+  end
+end

data/spec/rabbitmq_config_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+RSpec.describe RabbitMQConfig do
+  describe ".from_environment" do
+    it "connects to rabbitmq with the correct environment variables" do
+      ENV["RABBITMQ_HOSTS"] = "server-one,server-two"
+      ENV["RABBITMQ_VHOST"] = "/"
+      ENV["RABBITMQ_USER"] = "my_user"
+      ENV["RABBITMQ_PASSWORD"] = "my_pass"
+
+      expect(RabbitMQConfig.new.from_environment).to eql({
+        hosts: ["server-one", "server-two"],
+        vhost: "/",
+        user: "my_user",
+        pass: "my_pass",
+        recover_from_connection_close: true,
+      })
+    end
+
+    it "provides a friendly error message when a variable is missing" do
+      ENV["RABBITMQ_HOSTS"] = nil
+
+      expect { RabbitMQConfig.new.from_environment }.to raise_error(RabbitMQConfig::ConfigurationError)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -3,23 +3,11 @@ require_relative '../lib/govuk_message_queue_consumer'
 include GovukMessageQueueConsumer
 
 module TestHelpers
-  def rabbitmq_config
-    {
-      "connection" => {
-        "hosts" => ["rabbitmq1.example.com", "rabbitmq2.example.com"],
-        "port" => 5672,
-        "vhost" => "/",
-        "user" => "a_user",
-        "pass" => "super secret",
-        "recover_from_connection_close" => true,
-      },
-      "queue" => "content_register",
-      "exchange" => "published_documents",
-    }
-  end
-
-  def message_values
-    [:delivery_info1, :headers1, "message1_body"]
+  def stub_environment_variables!
+    ENV["RABBITMQ_HOSTS"] ||= ""
+    ENV["RABBITMQ_VHOST"] ||= "/"
+    ENV["RABBITMQ_USER"] ||= "/"
+    ENV["RABBITMQ_PASSWORD"] ||= "/"
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: govuk_message_queue_consumer
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - GOV.UK Dev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-21 00:00:00.000000000 Z
+date: 2015-11-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny
@@ -24,20 +24,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 2.2.0
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: gem_publisher
   requirement: !ruby/object:Gem::Requirement
@@ -93,13 +79,20 @@ files:
 - lib/govuk_message_queue_consumer.rb
 - lib/govuk_message_queue_consumer/consumer.rb
 - lib/govuk_message_queue_consumer/heartbeat_processor.rb
+- lib/govuk_message_queue_consumer/json_processor.rb
 - lib/govuk_message_queue_consumer/message.rb
+- lib/govuk_message_queue_consumer/rabbitmq_config.rb
 - lib/govuk_message_queue_consumer/test_helpers.rb
+- lib/govuk_message_queue_consumer/test_helpers/mock_message.rb
 - lib/govuk_message_queue_consumer/test_helpers/shared_examples.rb
+- lib/govuk_message_queue_consumer/test_helpers/test_consumer.rb
 - lib/govuk_message_queue_consumer/version.rb
 - spec/consumer_spec.rb
 - spec/heartbeat_processor_spec.rb
+- spec/json_processor_spec.rb
 - spec/message_spec.rb
+- spec/mock_message_spec.rb
+- spec/rabbitmq_config_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/alphagov/govuk_message_queue_consumer
 licenses: []
@@ -129,3 +122,6 @@ test_files:
 - spec/spec_helper.rb
 - spec/message_spec.rb
 - spec/consumer_spec.rb
+- spec/mock_message_spec.rb
+- spec/json_processor_spec.rb
+- spec/rabbitmq_config_spec.rb