pheme 0.0.8 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7162906c4cad8bbe5247f283c06f72ce881effb9
-  data.tar.gz: 78694ae2f9a59b2abacc2afc705780ca3190a406
+  metadata.gz: d38042f356beb16dc19336d1f8a7103264cd7fc9
+  data.tar.gz: aea9f789ac089d39c8d3645c31202c6e8d368894
 SHA512:
-  metadata.gz: a4f3c559ebf8db752207b441b43bdd264f1a5489b58719c9613272949cd0061ce11a05809593dacd0903821a303c727443315a82ddf0a7eaa48b0d09b59255a6
-  data.tar.gz: 4f99b81c78d8484949f0cdf480deb5434e2eb3716259662588a31aeee1d318f8325d37fcf1400168e2d38c25dfbf6c8a499f954e63d22f0da8607ab767a37616
+  metadata.gz: '0977af6e8deee4b1a19a69b86f2709055926bd18d925024b41979b292147066019a6a919652fb0063351c1b42278565eecea5986ee9f7f79d98e6f1fd42a292c'
+  data.tar.gz: 0c0e8351a7cda60992dcf6839b58edc0d87de7f7c5f056187773647a3e2a350423949d2bdbaf3923e4262a18e6bde0ba533297ed221f10c4b0a0cc5d9ecc2dde

data/.rubocop.yml

@@ -0,0 +1,143 @@
+AllCops:
+  DisplayCopNames: true
+
+  Exclude:
+    - 'vendor/**/*'
+    - 'log/**/*'
+    - 'public/**/*'
+    - 'data/**/*'
+    - 'tmp/**/*'
+    - 'bin/**/*'
+    - 'db/**/*'
+    - 'lib/tasks/circle_0.rake' # Ignore circleci code:
+    - 'node_modules/**/*'
+  TargetRubyVersion: 2.4
+
+Lint/AmbiguousOperator:
+  Enabled: false
+
+Naming/FileName:
+  Enabled: false
+
+Lint/IneffectiveAccessModifier:
+  Enabled: false
+
+Lint/UselessAccessModifier:
+  Enabled: false
+
+Layout/SpaceBeforeBlockBraces:
+  Enabled: false
+
+FrozenStringLiteralComment:
+  Enabled: false
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/LineLength:
+  Enabled: false
+  Max: 120
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Enabled: false
+
+Metrics/ParameterLists:
+  Enabled: false
+
+Style/For:
+  EnforcedStyle: each
+
+Style/HashSyntax:
+  EnforcedStyle: ruby19
+
+Layout/ExtraSpacing:
+  Enabled: false
+
+Layout/SpaceAroundEqualsInParameterDefault:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Layout/TrailingBlankLines:
+  EnforcedStyle: final_newline
+
+Style/VariableName:
+  EnforcedStyle: snake_case
+
+Style/MethodDefParentheses:
+  EnforcedStyle: require_parentheses
+
+Style/Semicolon:
+  AllowAsExpressionSeparator: false
+
+Style/TrailingCommaInLiteral:
+  EnforcedStyleForMultiline: comma
+
+Style/Alias:
+  EnforcedStyle: prefer_alias_method
+
+Style/AndOr:
+  EnforcedStyle: conditionals
+
+Style/StringLiterals:
+  Enabled: false
+
+Style/CollectionMethods:
+  PreferredMethods:
+    collect: 'map'
+    collect!: 'map!'
+    inject: 'reduce'
+    detect: 'find'
+    find_all: 'select'
+
+Layout/SpaceBeforeFirstArg:
+  Enabled: false
+
+Style/ClassVars:
+  Enabled: false
+
+Layout/MultilineMethodCallIndentation:
+  EnforcedStyle: indented
+
+Layout/DotPosition:
+  EnforcedStyle: trailing
+
+Style/NumericPredicate:
+  EnforcedStyle: comparison
+
+Layout/IndentHash:
+  EnforcedStyle: consistent
+
+Style/TrailingCommaInArguments:
+  EnforcedStyleForMultiline: comma
+
+Style/BracesAroundHashParameters:
+  Enabled: false
+
+Style/Lambda:
+  Enabled: false
+
+Style/SingleLineBlockParams:
+  Enabled: false
+
+Style/GuardClause:
+  Enabled: false
+
+Style/DoubleNegation:
+  Enabled: false
+
+Style/ClassAndModuleChildren:
+  Enabled: false

data/lib/pheme/configuration.rb

@@ -16,11 +16,12 @@ module Pheme
   end
 
   class Configuration
-    ATTRIBUTES = [:sns_client, :sqs_client, :logger, :rollbar]
+    ATTRIBUTES = %i[sns_client sqs_client logger rollbar].freeze
     attr_accessor *ATTRIBUTES
 
     def initialize
       @logger ||= Logger.new(STDOUT)
+      @logger = ActiveSupport::TaggedLogging.new(@logger) unless @logger.respond_to?(:tagged)
     end
 
     def validate!

data/lib/pheme/logger.rb

@@ -4,4 +4,8 @@ module Pheme
     @tag ||= "pheme_#{SecureRandom.uuid}"
     @logger.tagged(@tag) { @logger.send(method, text) }
   end
+
+  def self.logger
+    configuration.logger
+  end
 end

data/lib/pheme/message_type/aws_event.rb

@@ -19,7 +19,7 @@ module Pheme
       end
 
       def parse_aws_event(message_contents)
-        RecursiveOpenStruct.new({wrapper: message_contents}, recurse_over_arrays: true).wrapper
+        RecursiveOpenStruct.new({ wrapper: message_contents }, recurse_over_arrays: true).wrapper
       end
     end
   end

data/lib/pheme/queue_poller.rb

@@ -7,10 +7,12 @@ module Pheme
       @queue_url = queue_url
       @queue_poller = Aws::SQS::QueuePoller.new(queue_url)
       @connection_pool_block = connection_pool_block
+      @messages_processed = 0
+      @messages_received = 0
       @format = format
       @max_messages = max_messages
       @poller_configuration = {
-        wait_time_seconds: 10, # amount of time a long polling receive call can wait for a mesage before receiving a empty response (which will trigger another polling request)
+        wait_time_seconds: 10, # amount of time a long polling receive call can wait for a message before receiving a empty response (which will trigger another polling request)
         idle_timeout: 20, # disconnects poller after 20 seconds of idle time
         skip_delete: true, # manually delete messages
       }.merge(poller_configuration || {})
@@ -23,38 +25,49 @@ module Pheme
     end
 
     def poll
-      Pheme.log(:info, "Long-polling for messages on #{queue_url}")
+      time_start = log_polling_start
       with_optional_connection_pool_block do
-        queue_poller.poll(poller_configuration) do |message|
-          data = parse_message(message)
-          begin
-            handle(data)
-            queue_poller.delete_message(message)
-          rescue SignalException => e
-            throw :stop_polling
-          rescue => e
-            Pheme.log(:error, "Exception: #{e.inspect}")
-            Pheme.log(:error, e.backtrace.join("\n"))
-            Pheme.rollbar(e, "#{self.class} failed to process message", data)
+        queue_poller.poll(poller_configuration) do |queue_message|
+          @messages_received += 1
+          Pheme.logger.tagged(queue_message.message_id) do
+            begin
+              content = parse_body(queue_message)
+              handle(content)
+              queue_poller.delete_message(queue_message)
+              log_delete(queue_message)
+              @messages_processed += 1
+            rescue SignalException
+              throw :stop_polling
+            rescue StandardError => e
+              Pheme.logger.error(e)
+              Pheme.rollbar(e, "#{self.class} failed to process message", content)
+            end
           end
         end
       end
-      Pheme.log(:info, "Finished long-polling after #{@poller_configuration[:idle_timeout]} seconds.")
+      log_polling_end(time_start)
     end
 
-    def parse_message(message)
-      Pheme.log(:info, "Received JSON payload: #{message.body}")
-      content = get_content(JSON.parse(message.body))
+    # returns queue_message.body as hash,
+    # stores and parses get_content to body[:content]
+    def parse_body(queue_message)
+      message_body = JSON.parse(queue_message.body)
+      raw_content = get_content(message_body)
+
       case format
       when :csv
-        parse_csv(content)
+        parsed_content = parse_csv(raw_content)
       when :json
-        parse_json(content)
+        parsed_content = parse_json(raw_content)
       else
         method_name = "parse_#{format}".to_sym
-        raise ArgumentError.new("Unknown format #{format}") unless self.respond_to?(method_name)
-        self.__send__(method_name, content)
+        raise ArgumentError, "Unknown format #{format}" unless respond_to?(method_name)
+        parsed_content = __send__(method_name, raw_content)
       end
+
+      body = format == :csv ? raw_content : parsed_content
+      log_message_received(queue_message, body)
+      parsed_content
     end
 
     def get_content(body)
@@ -68,21 +81,67 @@ module Pheme
 
     def parse_json(message_contents)
       parsed_body = JSON.parse(message_contents)
-      RecursiveOpenStruct.new({wrapper: parsed_body}, recurse_over_arrays: true).wrapper
+      RecursiveOpenStruct.new({ wrapper: parsed_body }, recurse_over_arrays: true).wrapper
     end
 
-    def handle(message)
+    def handle(_message)
       raise NotImplementedError
     end
 
-  private
+    private
 
-    def with_optional_connection_pool_block(&blk)
+    def with_optional_connection_pool_block
       if connection_pool_block
-        ActiveRecord::Base.connection_pool.with_connection { blk.call }
+        ActiveRecord::Base.connection_pool.with_connection { yield }
       else
-        blk.call
+        yield
       end
     end
+
+    def log_polling_start
+      time_start = Time.now
+      Pheme.logger.info({
+        message: "Start long-polling #{queue_url}",
+        type: self.class.name,
+        queue_url: queue_url,
+        format: format,
+        max_messages: max_messages,
+        connection_pool_block: connection_pool_block,
+        poller_configuration: poller_configuration,
+      }.to_json)
+      time_start
+    end
+
+    def log_polling_end(time_start)
+      time_end = Time.now
+      elapsed = time_end - time_start
+      Pheme.logger.info({
+        message: "Finished long-polling #{queue_url}, duration: #{elapsed.round(2)} seconds.",
+        queue_url: queue_url,
+        format: format,
+        messages_received: @messages_received,
+        messages_processed: @messages_processed,
+        duration: elapsed.round(2),
+        start_time: time_start.utc.iso8601,
+        end_time: time_end.utc.iso8601,
+      }.to_json)
+    end
+
+    def log_delete(queue_message)
+      Pheme.logger.info({
+        message: "Deleted message #{queue_message.message_id}",
+        message_id: queue_message.message_id,
+        queue_url: queue_url,
+      }.to_json)
+    end
+
+    def log_message_received(queue_message, body)
+      Pheme.logger.info({
+        message: "Received message #{queue_message.message_id}",
+        message_id: queue_message.message_id,
+        queue_url: queue_url,
+        body: body,
+      }.to_json)
+    end
   end
 end

data/lib/pheme/version.rb

@@ -1,3 +1,3 @@
 module Pheme
-  VERSION = "0.0.8"
+  VERSION = "0.0.9".freeze
 end

data/pheme.gemspec

@@ -1,4 +1,4 @@
-# -*- encoding: utf-8 -*-
+
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
@@ -9,22 +9,25 @@ Gem::Specification.new do |gem|
   gem.version       = Pheme::VERSION
   gem.authors       = ["Peter Graham"]
   gem.email         = ["peter@wealthsimple.com"]
-  gem.description   = %q{Ruby AWS SNS publisher + SQS poller & message handler}
-  gem.summary       = %q{Ruby SNS publisher + SQS poller & message handler}
+  gem.description   = 'Ruby AWS SNS publisher + SQS poller & message handler'
+  gem.summary       = 'Ruby SNS publisher + SQS poller & message handler'
   gem.homepage      = "https://github.com/wealthsimple/pheme"
 
-  gem.files         = `git ls-files`.split($/)
+  gem.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
   gem.licenses      = ["MIT"]
   gem.required_ruby_version = ">= 2.1.0"
 
-  gem.add_dependency "aws-sdk", ">= 2", "< 4"
   gem.add_dependency "activesupport", ">= 4"
+  gem.add_dependency "aws-sdk", ">= 2", "< 4"
   gem.add_dependency "recursive-open-struct", "~> 1"
   gem.add_dependency "smarter_csv", "~> 1"
 
-  gem.add_development_dependency "rspec", "~> 3.4"
-  gem.add_development_dependency "rspec_junit_formatter", "~> 0.2"
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "rspec-collection_matchers"
+  gem.add_development_dependency "rspec-its"
+  gem.add_development_dependency "rspec_junit_formatter"
+  gem.add_development_dependency "rubocop"
 end

data/spec/message_handler_spec.rb

@@ -5,7 +5,7 @@ describe Pheme::MessageHandler do
 
   describe "#handle" do
     it "handles the message correctly" do
-      expect(Pheme).to receive(:log).with(:info, "Done")
+      expect(Pheme.logger).to receive(:info).with("Done")
       subject.handle
     end
   end

data/spec/message_type/aws_event_spec.rb

@@ -1,26 +1,21 @@
 describe Pheme::MessageType::AwsEvent do
-  subject { ExampleAwsEventQueuePoller.new }
-
-  let(:poller) do
-    poller = double
-    allow(poller).to receive(:poll).with(kind_of(Hash))
-    allow(poller).to receive(:parse_message)
-    allow(poller).to receive(:before_request)
-    poller
+  let(:poller) { ExampleAwsEventQueuePoller.new }
+  let(:message_id) { SecureRandom.uuid }
+  let(:queue_url) { 'http://queue_url' }
+  let(:queue_message) do
+    OpenStruct.new(
+      message_id: message_id,
+      body: { 'Records' => records }.to_json,
+      queue_url: queue_url,
+    )
   end
 
-  before(:each) do
-    use_default_configuration!
-    allow(Aws::SQS::QueuePoller).to receive(:new) { poller }
-  end
+  describe "#parse_body" do
+    subject { poller.parse_body(queue_message) }
 
-  describe "#parse_message" do
     context "with JSON message" do
-      let!(:message) { OpenStruct.new({ body: "{\"Records\":[{\"eventVersion\":\"2.0\"}]}" }) }
-
-      it 'should parse the message correctly' do
-        expect(subject.parse_message(message).first.eventVersion).to eq("2.0")
-      end
+      let!(:records) { [{ 'eventVersion' => '2.0' }] }
+      its('first.eventVersion') { is_expected.to eq('2.0') }
     end
   end
 end

data/spec/message_type/sns_message_spec.rb

@@ -14,7 +14,7 @@ describe Pheme::MessageType::SnsMessage do
     allow(poller).to receive(:before_request)
     poller
   end
-  
+
   before(:each) do
     use_default_configuration!
     allow(Aws::SQS::QueuePoller).to receive(:new) { poller }
@@ -25,7 +25,7 @@ describe Pheme::MessageType::SnsMessage do
       let!(:message) { OpenStruct.new({ body: '{"Message":"{\"test\":\"test\"}"}' }) }
 
       it 'should parse the message correctly' do
-        expect(subject.parse_message(message).test).to eq("test")
+        expect(subject.parse_body(message).test).to eq("test")
       end
     end
   end

data/spec/queue_poller_spec.rb

@@ -1,16 +1,5 @@
 describe Pheme::QueuePoller do
   let(:queue_url) { "https://sqs.us-east-1.amazonaws.com/whatever" }
-  let(:poller) do
-    poller = double
-    allow(poller).to receive(:poll).with(kind_of(Hash))
-    allow(poller).to receive(:parse_message)
-    allow(poller).to receive(:before_request)
-    poller
-  end
-  before(:each) do
-    use_default_configuration!
-    allow(Aws::SQS::QueuePoller).to receive(:new) { poller }
-  end
 
   describe ".new" do
     context "when initialized with valid params" do
@@ -32,54 +21,63 @@ describe Pheme::QueuePoller do
     end
   end
 
-  describe "#parse_message" do
-    context "with JSON message" do
-      subject { ExampleQueuePoller.new(queue_url: queue_url) }
+  let(:poller) { ExampleQueuePoller.new(queue_url: queue_url, format: format) }
+  let(:message_id) { SecureRandom.uuid }
+  let(:message) { nil }
+  let!(:queue_message) do
+    OpenStruct.new(
+      body: { Message: message }.to_json,
+      message_id: message_id,
+    )
+  end
 
-      let!(:message) { OpenStruct.new({
-        body: '{"Message":"{\"test\":\"test\"}"}'
-      })}
+  describe "#parse_body" do
+    subject { poller.parse_body(queue_message) }
 
-      it 'should parse the message correctly' do
-        expect(subject.parse_message(message).test).to eq("test")
-      end
+    context "message is JSON string" do
+      let(:format) { :json }
+      let!(:message) { { test: 'test' }.to_json }
+      its([:test]) { is_expected.to eq('test') }
     end
 
-    context "with CSV message" do
-      subject { ExampleQueuePoller.new(queue_url: queue_url, format: :csv) }
-
-      let!(:message) { OpenStruct.new({
-        body:'{"Message":"test,test2\nvalue,value2\nvalue3,value4"}'
-      })}
-
-      it 'should parse the message correctly' do
-        expect(subject.parse_message(message)).to be_a(Array)
-        expect(subject.parse_message(message).count).to eq(2)
+    context "message is CSV string" do
+      let(:format) { :csv }
+      let(:expected_message) do
+        [
+          { test1: 'value1', test2: 'value2' },
+          { test1: 'value3', test2: 'value4' },
+        ]
+      end
+      let(:message) do
+        [
+          %w[test1 test2].join(','),
+          %w[value1 value2].join(','),
+          %w[value3 value4].join(','),
+        ].join("\n")
       end
+
+      it { is_expected.to have(2).items }
+      it { is_expected.to eq(RecursiveOpenStruct.new({ wrapper: expected_message }, recurse_over_arrays: true).wrapper) }
     end
 
     context "with unknown message format" do
-      subject { ExampleQueuePoller.new(queue_url: queue_url, format: :invalid_format) }
-
-      let!(:message) { OpenStruct.new({
-        body:'{"Message":"test,test2\nvalue,value2\nvalue3,value4"}'
-      })}
+      let(:format) { :invalid_format }
+      let(:message) { 'unkonwn' }
 
-      it 'should raise an error' do
-        expect{ subject.parse_message(message) }.to raise_error
+      it "should raise error" do
+        expect{ subject }.to raise_error(ArgumentError)
       end
     end
 
     context "with array JSON message" do
-      subject { ExampleQueuePoller.new(queue_url: queue_url).parse_message(message) }
-      let!(:message) { OpenStruct.new({
-        body: '{"Message":"[[{\"test\":\"test\"}]]"}'
-      })}
-      it 'should parse the message correctly' do
-        expect(subject.first.first.test).to eq("test")
-        expect(subject).to be_a Array
-        expect(subject.first).to be_a Array
-        expect(subject.first.first).to be_a RecursiveOpenStruct
+      let(:format) { :json }
+      let(:message) { [[{ test: 'test' }]].to_json }
+
+      it { is_expected.to be_a(Array) }
+      its(:first) { is_expected.to be_a(Array) }
+      its('first.first') { is_expected.to be_a(RecursiveOpenStruct) }
+      it "parses the nested object" do
+        expect(subject.first.first.test).to eq('test')
       end
     end
   end
@@ -88,22 +86,30 @@ describe Pheme::QueuePoller do
     before(:each) do
       module ActiveRecord
         class Base
-          def self.connection_pool
-          end
+          def self.connection_pool; end
         end
       end
     end
 
     context "with connection pool block" do
       let(:mock_connection_pool) { double }
+      subject { ExampleQueuePoller.new(queue_url: queue_url, connection_pool_block: true) }
+      let(:message) { { status: 'complete' } }
+      let(:notification) { { 'MessageId' => SecureRandom.uuid, 'Message' => message.to_json, 'Type' => 'Notification' } }
+      let!(:queue_message) do
+        OpenStruct.new(
+          body: notification.to_json,
+          message_id: message_id,
+        )
+      end
 
       before(:each) do
         allow(ActiveRecord::Base).to receive(:connection_pool) { mock_connection_pool }
         allow(mock_connection_pool).to receive(:with_connection).and_yield
+        allow(subject.queue_poller).to receive(:poll).and_yield(queue_message)
+        allow(subject.queue_poller).to receive(:delete_message).with(queue_message)
       end
 
-      subject { ExampleQueuePoller.new(queue_url: queue_url, connection_pool_block: true) }
-
       it "uses the connection pool block" do
         expect(mock_connection_pool).to receive(:with_connection)
         subject.poll
@@ -112,6 +118,19 @@ describe Pheme::QueuePoller do
 
     context "without connection pool block" do
       subject { ExampleQueuePoller.new(queue_url: queue_url) }
+      let(:message) { { status: 'complete' } }
+      let(:notification) { { 'MessageId' => SecureRandom.uuid, 'Message' => message.to_json, 'Type' => 'Notification' } }
+      let!(:queue_message) do
+        OpenStruct.new(
+          body: notification.to_json,
+          message_id: message_id,
+        )
+      end
+
+      before(:each) do
+        allow(subject.queue_poller).to receive(:poll).and_yield(queue_message)
+        allow(subject.queue_poller).to receive(:delete_message).with(queue_message)
+      end
 
       it "does not call ActiveRecord" do
         expect(ActiveRecord::Base).not_to receive(:connection_pool)
@@ -120,64 +139,87 @@ describe Pheme::QueuePoller do
     end
 
     context "when a valid message is yielded" do
-      let(:message_body) do
+      subject { ExampleQueuePoller.new(queue_url: queue_url) }
+      let(:message) { { id: "id-123", status: "complete" } }
+      let(:notification) do
         {
-          id: "id-123",
-          status: "complete",
+          'MessageId' => SecureRandom.uuid,
+          'Message' => message.to_json,
+          'Type' => 'Notification',
         }
       end
-      let(:message) do
-        message = double
-        allow(message).to receive(:body) do
-          {Message: message_body.to_json,}.to_json
-        end
-        message
+      let!(:queue_message) do
+        OpenStruct.new(
+          body: notification.to_json,
+          message_id: message_id,
+        )
       end
+
       before(:each) do
-        allow(poller).to receive(:poll).and_yield(message)
+        allow(subject.queue_poller).to receive(:poll).and_yield(queue_message)
+        allow(subject.queue_poller).to receive(:delete_message).with(queue_message)
       end
 
-      subject { ExampleQueuePoller.new(queue_url: queue_url) }
-
       it "handles the message" do
-        expect(ExampleMessageHandler).to receive(:new).with(message: RecursiveOpenStruct.new(message_body))
+        expect(ExampleMessageHandler).to receive(:new).with(message: RecursiveOpenStruct.new(message))
         subject.poll
       end
 
       it "deletes the message from the queue" do
-        expect(poller).to receive(:delete_message).with(message)
+        expect(subject.queue_poller).to receive(:delete_message).with(queue_message)
         subject.poll
       end
     end
 
     context "when an invalid message is yielded" do
-      let(:message_body) do
+      subject { ExampleQueuePoller.new(queue_url: queue_url) }
+      let(:message) { { id: "id-123", status: "unknown-abc" } }
+      let(:notification) do
         {
-          id: "id-123",
-          status: "unknown-abc",
+          'MessageId' => SecureRandom.uuid,
+          'Message' => message.to_json,
+          'Type' => 'Notification',
         }
       end
-      let(:message) do
-        message = double
-        allow(message).to receive(:body) do
-          {Message: message_body.to_json}.to_json
-        end
-        message
+      let!(:queue_message) do
+        OpenStruct.new(
+          body: notification.to_json,
+          message_id: message_id,
+        )
       end
+
       before(:each) do
-        allow(poller).to receive(:poll).and_yield(message)
-        allow(Pheme).to receive(:log)
+        allow(subject.queue_poller).to receive(:poll).and_yield(queue_message)
+        allow(subject.queue_poller).to receive(:delete).with(queue_message)
+        allow(Pheme.logger).to receive(:error)
       end
 
-      subject { ExampleQueuePoller.new(queue_url: queue_url) }
-
       it "logs the error" do
         subject.poll
-        expect(Pheme).to have_received(:log).with(:error, "Exception: #<ArgumentError: Unknown message status: unknown-abc>")
+        expect(Pheme.logger).to have_received(:error) do |error|
+          expect(error).to be_a(ArgumentError)
+          expect(error.message).to eq('Unknown message status: unknown-abc')
+        end
       end
 
       it "does not delete the message from the queue" do
-        expect(poller).not_to receive(:delete_message)
+        expect(subject.queue_poller).not_to receive(:delete_message)
+        subject.poll
+      end
+    end
+
+    context "AWS-event message" do
+      subject { ExampleAwsEventQueuePoller.new(queue_url: queue_url) }
+      let(:queue_message) { OpenStruct.new(body: { 'Records' => records }.to_json) }
+      let(:records) do
+        [{ 'eventVersion' => '2.0', 'eventSource': 'aws:s3' }]
+      end
+      before(:each) do
+        allow(subject.queue_poller).to receive(:poll).and_yield(queue_message)
+        allow(subject.queue_poller).to receive(:delete).with(queue_message)
+      end
+
+      it "logs the message" do
         subject.poll
       end
     end

data/spec/spec_helper.rb

@@ -1,4 +1,7 @@
 require 'rspec'
+require 'rspec/its'
+require 'rspec/collection_matchers'
+require 'pp'
 
 require './lib/pheme'
 
@@ -8,6 +11,8 @@ RSpec.configure do |config|
   config.filter_run :focus
   config.run_all_when_everything_filtered = true
 
+  ENV['AWS_REGION'] = 'us-east-1'
+
   config.before(:each) do
     Pheme.reset_configuration!
   end

data/spec/support/example_message_handler.rb

@@ -2,9 +2,9 @@ class ExampleMessageHandler < Pheme::MessageHandler
   def handle
     case message.status
     when "complete"
-      Pheme.log(:info, "Done")
+      Pheme.logger.info("Done")
     when "rejected"
-      Pheme.log(:error, "Oops")
+      Pheme.logger.error("Oops")
     end
   end
 end

data/spec/topic_publisher_spec.rb

@@ -21,11 +21,11 @@ describe Pheme::TopicPublisher do
     it "publishes the correct events" do
       expect(Pheme.configuration.sns_client).to receive(:publish).with({
         topic_arn: "arn:aws:sns:whatever",
-        message: {id: "id-0", status: "complete"}.to_json,
+        message: { id: "id-0", status: "complete" }.to_json,
       })
       expect(Pheme.configuration.sns_client).to receive(:publish).with({
         topic_arn: "arn:aws:sns:whatever",
-        message: {id: "id-1", status: "complete"}.to_json,
+        message: { id: "id-1", status: "complete" }.to_json,
       })
       subject.publish_events
     end
@@ -34,13 +34,13 @@ describe Pheme::TopicPublisher do
       let(:topic_arn) { "arn:aws:sns:anything" }
       let(:message) { "don't touch my string" }
 
-      subject {Pheme::TopicPublisher.new(topic_arn: topic_arn)}
+      subject { Pheme::TopicPublisher.new(topic_arn: topic_arn) }
 
       it "publishes unchanged message" do
         expect(Pheme.configuration.sns_client).to receive(:publish).with({
-                                                                           topic_arn: topic_arn,
-                                                                           message: message,
-                                                                         })
+          topic_arn: topic_arn,
+          message: message,
+        })
         subject.publish(message)
       end
     end

metadata

@@ -1,23 +1,20 @@
 --- !ruby/object:Gem::Specification
 name: pheme
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.9
 platform: ruby
 authors:
 - Peter Graham
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-23 00:00:00.000000000 Z
+date: 2017-11-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: aws-sdk
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
-      - !ruby/object:Gem::Version
-        version: '2'
-    - - "<"
       - !ruby/object:Gem::Version
         version: '4'
   type: :runtime
@@ -25,16 +22,16 @@ dependencies:
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
-      - !ruby/object:Gem::Version
-        version: '2'
-    - - "<"
       - !ruby/object:Gem::Version
         version: '4'
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: aws-sdk
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
+      - !ruby/object:Gem::Version
+        version: '2'
+    - - "<"
       - !ruby/object:Gem::Version
         version: '4'
   type: :runtime
@@ -42,6 +39,9 @@ dependencies:
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
+      - !ruby/object:Gem::Version
+        version: '2'
+    - - "<"
       - !ruby/object:Gem::Version
         version: '4'
 - !ruby/object:Gem::Dependency
@@ -76,30 +76,72 @@ dependencies:
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.4'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.4'
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-collection_matchers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec_junit_formatter
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0'
 description: Ruby AWS SNS publisher + SQS poller & message handler
 email:
 - peter@wealthsimple.com
@@ -109,6 +151,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".rubocop.yml"
 - Gemfile
 - LICENSE
 - README.md