mail_room 0.10.0 → 0.10.1

data/lib/mail_room.rb

@@ -9,7 +9,9 @@ require "mail_room/version"
 require "mail_room/configuration"
 require "mail_room/mailbox"
 require "mail_room/mailbox_watcher"
+require "mail_room/message"
 require "mail_room/connection"
 require "mail_room/coordinator"
 require "mail_room/cli"
 require 'mail_room/logger/structured'
+require 'mail_room/crash_handler'

data/mail_room.gemspec

@@ -17,10 +17,13 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
+  gem.add_dependency             "net-imap", ">= 0.2.1"
+  gem.add_dependency             "oauth2", "~> 1.4.4"
+
   gem.add_development_dependency "rake"
-  gem.add_development_dependency "rspec"
-  gem.add_development_dependency "mocha"
-  gem.add_development_dependency "bourne"
+  gem.add_development_dependency "rspec", "~> 3.9"
+  gem.add_development_dependency "rubocop", "~> 1.11"
+  gem.add_development_dependency "mocha", "~> 1.11"
   gem.add_development_dependency "simplecov"
 
   # for testing delivery methods
@@ -31,4 +34,5 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency "redis-namespace"
   gem.add_development_dependency "pg"
   gem.add_development_dependency "charlock_holmes"
+  gem.add_development_dependency "webmock"
 end

data/spec/lib/arbitration/redis_spec.rb

@@ -5,7 +5,8 @@ describe MailRoom::Arbitration::Redis do
   let(:mailbox) {
     build_mailbox(
       arbitration_options: {
-        namespace: "mail_room"
+        namespace: "mail_room",
+        redis_url: ENV['REDIS_URL']
       }
     )
   }
@@ -78,7 +79,7 @@ describe MailRoom::Arbitration::Redis do
 
   context 'redis client connection params' do
     context 'when only url is present' do
-      let(:redis_url) { "redis://localhost:6379" }
+      let(:redis_url) { ENV.fetch('REDIS_URL', 'redis://localhost:6379') }
       let(:mailbox) {
         build_mailbox(
           arbitration_options: {

data/spec/lib/cli_spec.rb

@@ -2,25 +2,37 @@ require 'spec_helper'
 
 describe MailRoom::CLI do
   let(:config_path) {File.expand_path('../fixtures/test_config.yml', File.dirname(__FILE__))}
-  let!(:configuration) {MailRoom::Configuration.new({:config_path => config_path})}
-  let(:coordinator) {stub(:run => true, :quit => true)}
+  let!(:configuration) {MailRoom::Configuration.new({config_path: config_path})}
+  let(:coordinator) {stub(run: true, quit: true)}
+  let(:configuration_args) { anything }
+  let(:coordinator_args) { anything }
 
   describe '.new' do
     let(:args) {["-c", "a path"]}
 
     before :each do
-      MailRoom::Configuration.stubs(:new).returns(configuration)
-      MailRoom::Coordinator.stubs(:new).returns(coordinator)
+      MailRoom::Configuration.expects(:new).with(configuration_args).returns(configuration)
+      MailRoom::Coordinator.stubs(:new).with(coordinator_args).returns(coordinator)
     end
 
-    it 'parses arguments into configuration' do
-      expect(MailRoom::CLI.new(args).configuration).to eq(configuration)
-      expect(MailRoom::Configuration).to have_received(:new).with({:config_path => 'a path'})
+    context 'with configuration args' do
+      let(:configuration_args) do
+        {config_path: 'a path'}
+      end
+
+      it 'parses arguments into configuration' do
+        expect(MailRoom::CLI.new(args).configuration).to eq configuration
+      end
     end
 
-    it 'creates a new coordinator with configuration' do
-      expect(MailRoom::CLI.new(args).coordinator).to eq(coordinator)
-      expect(MailRoom::Coordinator).to have_received(:new).with(configuration.mailboxes)
+    context 'with coordinator args' do
+      let(:coordinator_args) do
+        configuration.mailboxes
+      end
+
+      it 'creates a new coordinator with configuration' do
+        expect(MailRoom::CLI.new(args).coordinator).to eq(coordinator)
+      end
     end
   end
 
@@ -30,12 +42,35 @@ describe MailRoom::CLI do
     before :each do
       cli.configuration = configuration
       cli.coordinator = coordinator
+      cli.stubs(:exit)
     end
 
     it 'starts running the coordinator' do
+      coordinator.expects(:run)
+
       cli.start
+    end
+
+    context 'on error' do
+      let(:error) { RuntimeError.new("oh noes!") }
+      let(:coordinator) { stub(run: true, quit: true) }
+      let(:crash_handler) { stub(handle: nil) }
+
+      before do
+        cli.instance_variable_set(:@options, {exit_error_format: error_format})
+        coordinator.stubs(:run).raises(error)
+        MailRoom::CrashHandler.stubs(:new).returns(crash_handler)
+      end
+
+      context 'json format provided' do
+        let(:error_format) { 'json' }
+
+        it 'passes onto CrashHandler' do
+          crash_handler.expects(:handle).with(error, error_format)
 
-      expect(coordinator).to have_received(:run)
+          cli.start
+        end
+      end
     end
   end
 end

data/spec/lib/configuration_spec.rb

@@ -5,7 +5,7 @@ describe MailRoom::Configuration do
 
   describe 'set_mailboxes' do
     context 'with config_path' do
-      let(:configuration) { MailRoom::Configuration.new(:config_path => config_path) }
+      let(:configuration) { MailRoom::Configuration.new(config_path: config_path) }
 
       it 'parses yaml into mailbox objects' do
         MailRoom::Mailbox.stubs(:new).returns('mailbox1', 'mailbox2')
@@ -19,10 +19,9 @@ describe MailRoom::Configuration do
 
       it 'sets mailboxes to an empty set' do
         MailRoom::Mailbox.stubs(:new)
+        MailRoom::Mailbox.expects(:new).never
 
         expect(configuration.mailboxes).to eq([])
-
-        expect(MailRoom::Mailbox).to have_received(:new).never
       end
     end
   end

data/spec/lib/coordinator_spec.rb

@@ -3,14 +3,12 @@ require 'spec_helper'
 describe MailRoom::Coordinator do
   describe '#initialize' do
     it 'builds a watcher for each mailbox' do
-      MailRoom::MailboxWatcher.stubs(:new).returns('watcher1', 'watcher2')
+      MailRoom::MailboxWatcher.expects(:new).with('mailbox1').returns('watcher1')
+      MailRoom::MailboxWatcher.expects(:new).with('mailbox2').returns('watcher2')
 
       coordinator = MailRoom::Coordinator.new(['mailbox1', 'mailbox2'])
 
       expect(coordinator.watchers).to eq(['watcher1', 'watcher2'])
-
-      expect(MailRoom::MailboxWatcher).to have_received(:new).with('mailbox1')
-      expect(MailRoom::MailboxWatcher).to have_received(:new).with('mailbox2')
     end
 
     it 'makes no watchers when mailboxes is empty' do
@@ -27,24 +25,27 @@ describe MailRoom::Coordinator do
       MailRoom::MailboxWatcher.stubs(:new).returns(watcher)
       coordinator = MailRoom::Coordinator.new(['mailbox1'])
       coordinator.stubs(:sleep_while_running)
+      watcher.expects(:run)
+      watcher.expects(:quit)
+
       coordinator.run
-      expect(watcher).to have_received(:run)
-      expect(watcher).to have_received(:quit)
     end
     
     it 'should go to sleep after running watchers' do
       coordinator = MailRoom::Coordinator.new([])
       coordinator.stubs(:running=)
       coordinator.stubs(:running?).returns(false)
+      coordinator.expects(:running=).with(true)
+      coordinator.expects(:running?)
+
       coordinator.run
-      expect(coordinator).to have_received(:running=).with(true)
-      expect(coordinator).to have_received(:running?)
     end
 
     it 'should set attribute running to true' do
       coordinator = MailRoom::Coordinator.new([])
       coordinator.stubs(:sleep_while_running)
       coordinator.run
+
       expect(coordinator.running).to eq(true)
     end
   end
@@ -54,8 +55,9 @@ describe MailRoom::Coordinator do
       watcher = stub(:quit)
       MailRoom::MailboxWatcher.stubs(:new).returns(watcher)
       coordinator = MailRoom::Coordinator.new(['mailbox1'])
+      watcher.expects(:quit)
+
       coordinator.quit
-      expect(watcher).to have_received(:quit)
     end
   end
 end

data/spec/lib/crash_handler_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe MailRoom::CrashHandler do
+
+  let(:error_message) { "oh noes!" }
+  let(:error) { RuntimeError.new(error_message) }
+  let(:stdout) { StringIO.new }
+
+  describe '#handle' do
+
+    subject{ described_class.new(stdout).handle(error, format) }
+
+    context 'when given a json format' do
+      let(:format) { 'json' }
+
+      it 'writes a json message to stdout' do
+        subject
+        stdout.rewind
+        output = stdout.read
+
+        expect(output).to end_with("\n")
+        expect(JSON.parse(output)['message']).to eq(error_message)
+      end
+    end
+
+    context 'when given a blank format' do
+      let(:format) { "" }
+
+      it 'raises an error as designed' do
+        expect{ subject }.to raise_error(error.class, error_message)
+      end
+    end
+
+    context 'when given a nonexistent format' do
+      let(:format) { "nonsense" }
+
+      it 'raises an error as designed' do
+        expect{ subject }.to raise_error(error.class, error_message)
+      end
+    end
+  end
+end

data/spec/lib/delivery/letter_opener_spec.rb

@@ -3,27 +3,31 @@ require 'mail_room/delivery/letter_opener'
 
 describe MailRoom::Delivery::LetterOpener do
   describe '#deliver' do
-    let(:mailbox) {build_mailbox(:location => '/tmp/somewhere')}
+    let(:mailbox) {build_mailbox(location: '/tmp/somewhere')}
     let(:delivery_method) {stub(:deliver!)}
     let(:mail) {stub}
 
     before :each do
       Mail.stubs(:read_from_string).returns(mail)
       ::LetterOpener::DeliveryMethod.stubs(:new).returns(delivery_method)
-
-      MailRoom::Delivery::LetterOpener.new(mailbox).deliver('a message')
     end
 
     it 'creates a new LetterOpener::DeliveryMethod' do
-      expect(::LetterOpener::DeliveryMethod).to have_received(:new).with(:location => '/tmp/somewhere')
+      ::LetterOpener::DeliveryMethod.expects(:new).with(location: '/tmp/somewhere').returns(delivery_method)
+
+      MailRoom::Delivery::LetterOpener.new(mailbox).deliver('a message')
     end
 
     it 'parses the message string with Mail' do
-      expect(::Mail).to have_received(:read_from_string).with('a message')
+      ::Mail.expects(:read_from_string).with('a message')
+
+      MailRoom::Delivery::LetterOpener.new(mailbox).deliver('a message')
     end
 
     it 'delivers the mail message' do
-      expect(delivery_method).to have_received(:deliver!).with(mail)
+      delivery_method.expects(:deliver!).with(mail)
+
+      MailRoom::Delivery::LetterOpener.new(mailbox).deliver('a message')
     end
   end
 end

data/spec/lib/delivery/logger_spec.rb

@@ -9,24 +9,22 @@ describe MailRoom::Delivery::Logger do
       it 'creates a new ruby logger' do
         ::Logger.stubs(:new)
 
-        MailRoom::Delivery::Logger.new(mailbox)
+        ::Logger.expects(:new).with(STDOUT)
 
-        expect(::Logger).to have_received(:new).with(STDOUT)
+        MailRoom::Delivery::Logger.new(mailbox)
       end
     end
 
     context "with a log path" do
-      let(:mailbox) {build_mailbox(:log_path => '/var/log/mail-room.log')}
+      let(:mailbox) {build_mailbox(log_path: '/var/log/mail-room.log')}
 
       it 'creates a new file to append to' do
-        ::Logger.stubs(:new)
         file = stub(:sync=)
-        ::File.stubs(:open).returns(file)
 
-        MailRoom::Delivery::Logger.new(mailbox)
+        File.expects(:open).with('/var/log/mail-room.log', 'a').returns(file)
+        ::Logger.stubs(:new).with(file)
 
-        expect(File).to have_received(:open).with('/var/log/mail-room.log', 'a')
-        expect(::Logger).to have_received(:new).with(file)
+        MailRoom::Delivery::Logger.new(mailbox)
       end
     end
   end
@@ -38,9 +36,9 @@ describe MailRoom::Delivery::Logger do
       logger = stub(:info)
       ::Logger.stubs(:new).returns(logger)
 
-      MailRoom::Delivery::Logger.new(mailbox).deliver('a message')
+      logger.expects(:info).with('a message')
 
-      expect(logger).to have_received(:info).with('a message')
+      MailRoom::Delivery::Logger.new(mailbox).deliver('a message')
     end
   end
 end

data/spec/lib/delivery/postback_spec.rb

@@ -5,8 +5,8 @@ describe MailRoom::Delivery::Postback do
   describe '#deliver' do
     context 'with token auth delivery' do
       let(:mailbox) {build_mailbox({
-        :delivery_url => 'http://localhost/inbox',
-        :delivery_token => 'abcdefg'
+        delivery_url: 'http://localhost/inbox',
+        delivery_token: 'abcdefg'
       })}
 
       let(:delivery_options) {
@@ -18,28 +18,22 @@ describe MailRoom::Delivery::Postback do
         request = stub
         Faraday.stubs(:new).returns(connection)
 
-        connection.stubs(:token_auth)
-        connection.stubs(:post).yields(request)
+        connection.expects(:token_auth).with('abcdefg')
+        connection.expects(:post).yields(request)
 
-        request.stubs(:url)
-        request.stubs(:body=)
+        request.expects(:url).with('http://localhost/inbox')
+        request.expects(:body=).with('a message')
 
         MailRoom::Delivery::Postback.new(delivery_options).deliver('a message')
-
-        expect(connection).to have_received(:token_auth).with('abcdefg')
-        expect(connection).to have_received(:post)
-
-        expect(request).to have_received(:url).with('http://localhost/inbox')
-        expect(request).to have_received(:body=).with('a message')
       end
     end
 
     context 'with basic auth delivery options' do
       let(:mailbox) {build_mailbox({
-        :delivery_options => {
-          :url => 'http://localhost/inbox',
-          :username => 'user1',
-          :password => 'password123abc'
+        delivery_options: {
+          url: 'http://localhost/inbox',
+          username: 'user1',
+          password: 'password123abc'
         }
       })}
 
@@ -52,19 +46,45 @@ describe MailRoom::Delivery::Postback do
         request = stub
         Faraday.stubs(:new).returns(connection)
 
-        connection.stubs(:basic_auth)
-        connection.stubs(:post).yields(request)
+        connection.expects(:basic_auth).with('user1', 'password123abc')
+        connection.expects(:post).yields(request)
 
-        request.stubs(:url)
-        request.stubs(:body=)
+        request.expects(:url).with('http://localhost/inbox')
+        request.expects(:body=).with('a message')
 
         MailRoom::Delivery::Postback.new(delivery_options).deliver('a message')
+      end
 
-        expect(connection).to have_received(:basic_auth).with('user1', 'password123abc')
-        expect(connection).to have_received(:post)
-
-        expect(request).to have_received(:url).with('http://localhost/inbox')
-        expect(request).to have_received(:body=).with('a message')
+      context 'with content type in the delivery options' do
+        let(:mailbox) {build_mailbox({
+          delivery_options: {
+            url: 'http://localhost/inbox',
+            username: 'user1',
+            password: 'password123abc',
+            content_type: 'text/plain'
+          }
+        })}
+
+  
+        let(:delivery_options) {
+          MailRoom::Delivery::Postback::Options.new(mailbox)
+        }
+  
+        it 'posts the message with faraday' do
+          connection = stub
+          request = stub
+          Faraday.stubs(:new).returns(connection)
+
+          connection.expects(:post).yields(request)
+          request.stubs(:url)
+          request.stubs(:body=)
+          request.stubs(:headers).returns({})
+          connection.expects(:basic_auth).with('user1', 'password123abc')
+
+          MailRoom::Delivery::Postback.new(delivery_options).deliver('a message')
+          
+          expect(request.headers['Content-Type']).to eq('text/plain')
+        end
       end
     end
   end

data/spec/lib/delivery/que_spec.rb

@@ -18,20 +18,15 @@ describe MailRoom::Delivery::Que do
     let(:options) {MailRoom::Delivery::Que::Options.new(mailbox)}
 
     it 'stores the message in que_jobs table' do
-      PG.stubs(:connect).returns(connection)
-      connection.stubs(:exec)
-
-      MailRoom::Delivery::Que.new(options).deliver('email')
-
-      expect(PG).to have_received(:connect).with({
+      PG.expects(:connect).with({
         host: 'localhost',
         port: 5432,
         dbname: 'delivery_test',
         user: 'postgres',
         password: ''
-      })
+      }).returns(connection)
 
-      expect(connection).to have_received(:exec).with(
+      connection.expects(:exec).with(
         "INSERT INTO que_jobs (priority, job_class, queue, args) VALUES ($1, $2, $3, $4)",
         [
           5,
@@ -40,6 +35,8 @@ describe MailRoom::Delivery::Que do
           JSON.dump(['email'])
         ]
       )
+
+      MailRoom::Delivery::Que.new(options).deliver('email')
     end
   end
 end

data/spec/lib/delivery/sidekiq_spec.rb

@@ -8,23 +8,45 @@ describe MailRoom::Delivery::Sidekiq do
 
   describe '#options' do
     let(:redis_url) { 'redis://localhost' }
+    let(:redis_options) { { redis_url: redis_url } }
 
     context 'when only redis_url is specified' do
       let(:mailbox) {
         build_mailbox(
           delivery_method: :sidekiq,
-          delivery_options: {
-            redis_url: redis_url
-          }
+          delivery_options: redis_options
         )
       }
 
-      it 'client has same specified redis_url' do
-        expect(redis.client.options[:url]).to eq(redis_url)
+      context 'with simple redis url' do
+        it 'client has same specified redis_url' do
+          expect(redis.client.options[:url]).to eq(redis_url)
+        end
+
+        it 'client is a instance of RedisNamespace class' do
+          expect(redis).to be_a ::Redis
+        end
+
+        it 'connection has correct values' do
+          expect(redis.connection[:host]).to eq('localhost')
+          expect(redis.connection[:db]).to eq(0)
+        end
       end
 
-      it 'client is a instance of RedisNamespace class' do
-        expect(redis).to be_a ::Redis
+      context 'with redis_db specified in options' do
+        before do
+          redis_options[:redis_db] = 4
+        end
+
+        it 'client has correct redis_url' do
+          expect(redis.client.options[:url]).to eq(redis_url)
+        end
+
+
+        it 'connection has correct values' do
+          expect(redis.connection[:host]).to eq('localhost')
+          expect(redis.connection[:db]).to eq(4)
+        end
       end
     end
 

data/spec/lib/{connection_spec.rb → imap/connection_spec.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe MailRoom::Connection do
+describe MailRoom::IMAP::Connection do
   let(:imap) {stub}
   let(:mailbox) {build_mailbox(delete_after_delivery: true, expunge_deleted: true)}
 
@@ -9,7 +9,9 @@ describe MailRoom::Connection do
   end
 
   context "with imap set up" do
-    let(:connection) {MailRoom::Connection.new(mailbox)}
+    let(:connection) {MailRoom::IMAP::Connection.new(mailbox)}
+    let(:uid) { 1 }
+    let(:seqno) { 8 }
 
     before :each do
       imap.stubs(:starttls)
@@ -36,30 +38,24 @@ describe MailRoom::Connection do
     end
 
     it "waits for a message to process" do
-      new_message = 'a message'
-      new_message.stubs(:seqno).returns(8)
+      new_message = MailRoom::IMAP::Message.new(uid: uid, body: 'a message', seqno: seqno)
 
       connection.on_new_message do |message|
         expect(message).to eq(new_message)
         true
       end
 
-      mailbox.stubs(:deliver?).returns(true)
+      attr = { 'UID' => uid, 'RFC822' => new_message.body }
+      fetch_data = Net::IMAP::FetchData.new(seqno, attr)
 
-      imap.stubs(:idle)
-      imap.stubs(:uid_search).returns([]).then.returns([1])
-      imap.stubs(:uid_fetch).returns([new_message])
-      imap.stubs(:store)
-      imap.stubs(:expunge)
+      imap.expects(:idle)
+      imap.stubs(:uid_search).with(mailbox.search_command).returns([], [uid])
+      imap.expects(:uid_fetch).with([uid], "RFC822").returns([fetch_data])
+      mailbox.expects(:deliver?).with(uid).returns(true)
+      imap.expects(:store).with(seqno, "+FLAGS", [Net::IMAP::DELETED])
+      imap.expects(:expunge).once
 
       connection.wait
-
-      expect(imap).to have_received(:idle)
-      expect(imap).to have_received(:uid_search).with(mailbox.search_command).twice
-      expect(imap).to have_received(:uid_fetch).with([1], "RFC822")
-      expect(mailbox).to have_received(:deliver?).with(1)
-      expect(imap).to have_received(:store).with(8, "+FLAGS", [Net::IMAP::DELETED])
-      expect(imap).to have_received(:expunge).once
     end
   end
 end

data/spec/lib/imap/message_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal:true
+
+require 'spec_helper'
+require 'securerandom'
+
+describe MailRoom::IMAP::Message do
+  let(:uid) { SecureRandom.hex }
+  let(:body) { 'hello world' }
+  let(:seqno) { 5 }
+
+  subject { described_class.new(uid: uid, body: body, seqno: seqno) }
+
+  describe '#initalize' do
+    it 'initializes with required parameters' do
+      subject
+
+      expect(subject.uid).to eq(uid)
+      expect(subject.body).to eq(body)
+      expect(subject.seqno).to eq(seqno)
+    end
+  end
+
+  describe '#==' do
+    let(:dup) { described_class.new(uid: uid, body: body, seqno: seqno) }
+    let(:base_msg) { MailRoom::Message.new(uid: uid, body: body) }
+
+    it 'matches an equivalent message' do
+      expect(dup == subject).to be true
+    end
+
+    it 'does not match a base message' do
+      expect(subject == base_msg).to be false
+      expect(base_msg == subject).to be false
+    end
+  end
+end