mail_room 0.9.1 → 0.10.1

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) {MailRoom::Mailbox.new(: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

@@ -4,43 +4,41 @@ require 'mail_room/delivery/logger'
 describe MailRoom::Delivery::Logger do
   describe '#initialize' do
     context "without a log path" do
-      let(:mailbox) {MailRoom::Mailbox.new}
+      let(:mailbox) {build_mailbox}
 
       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) {MailRoom::Mailbox.new(: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
 
   describe '#deliver' do
-    let(:mailbox) {MailRoom::Mailbox.new}
+    let(:mailbox) {build_mailbox}
 
     it 'writes the message to info' 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

@@ -3,29 +3,89 @@ require 'mail_room/delivery/postback'
 
 describe MailRoom::Delivery::Postback do
   describe '#deliver' do
-    let(:mailbox) {MailRoom::Mailbox.new({
-      :delivery_url => 'http://localhost/inbox',
-      :delivery_token => 'abcdefg'
-    })}
+    context 'with token auth delivery' do
+      let(:mailbox) {build_mailbox({
+        delivery_url: 'http://localhost/inbox',
+        delivery_token: 'abcdefg'
+      })}
 
-    it 'posts the message with faraday' do
-      connection = stub
-      request = stub
-      Faraday.stubs(:new).returns(connection)
+      let(:delivery_options) {
+        MailRoom::Delivery::Postback::Options.new(mailbox)
+      }
 
-      connection.stubs(:token_auth)
-      connection.stubs(:post).yields(request)
+      it 'posts the message with faraday' do
+        connection = stub
+        request = stub
+        Faraday.stubs(:new).returns(connection)
 
-      request.stubs(:url)
-      request.stubs(:body=)
+        connection.expects(:token_auth).with('abcdefg')
+        connection.expects(:post).yields(request)
 
-      MailRoom::Delivery::Postback.new(mailbox).deliver('a message')
+        request.expects(:url).with('http://localhost/inbox')
+        request.expects(:body=).with('a message')
 
-      expect(connection).to have_received(:token_auth).with('abcdefg')
-      expect(connection).to have_received(:post)
+        MailRoom::Delivery::Postback.new(delivery_options).deliver('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'
+        }
+      })}
+
+      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(:basic_auth).with('user1', 'password123abc')
+        connection.expects(:post).yields(request)
+
+        request.expects(:url).with('http://localhost/inbox')
+        request.expects(:body=).with('a message')
+
+        MailRoom::Delivery::Postback.new(delivery_options).deliver('a message')
+      end
+
+      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')
 
-      expect(request).to have_received(:url).with('http://localhost/inbox')
-      expect(request).to have_received(:body=).with('a message')
+          MailRoom::Delivery::Postback.new(delivery_options).deliver('a message')
+          
+          expect(request.headers['Content-Type']).to eq('text/plain')
+        end
+      end
     end
   end
 end

data/spec/lib/delivery/que_spec.rb

@@ -3,7 +3,7 @@ require 'mail_room/delivery/que'
 
 describe MailRoom::Delivery::Que do
   describe '#deliver' do
-    let(:mailbox) {MailRoom::Mailbox.new({
+    let(:mailbox) {build_mailbox({
       delivery_options: {
         database: 'delivery_test',
         username: 'postgres',
@@ -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

@@ -7,31 +7,53 @@ describe MailRoom::Delivery::Sidekiq do
   let(:options) { MailRoom::Delivery::Sidekiq::Options.new(mailbox) }
 
   describe '#options' do
-    let(:redis_url) { 'redis://redis.example.com' }
+    let(:redis_url) { 'redis://localhost' }
+    let(:redis_options) { { redis_url: redis_url } }
 
     context 'when only redis_url is specified' do
       let(:mailbox) {
-        MailRoom::Mailbox.new(
+        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.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
 
     context 'when namespace is specified' do
       let(:namespace) { 'sidekiq_mailman' }
       let(:mailbox) {
-        MailRoom::Mailbox.new(
+        build_mailbox(
           delivery_method: :sidekiq,
           delivery_options: {
             redis_url: redis_url,
@@ -53,7 +75,7 @@ describe MailRoom::Delivery::Sidekiq do
       let(:redis_url) { 'redis://:mypassword@sentinel-master:6379' }
       let(:sentinels) { [{ host: '10.0.0.1', port: '26379' }] }
       let(:mailbox) {
-        MailRoom::Mailbox.new(
+        build_mailbox(
           delivery_method: :sidekiq,
           delivery_options: {
             redis_url: redis_url,

data/spec/lib/imap/connection_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe MailRoom::IMAP::Connection do
+  let(:imap) {stub}
+  let(:mailbox) {build_mailbox(delete_after_delivery: true, expunge_deleted: true)}
+
+  before :each do
+    Net::IMAP.stubs(:new).returns(imap)
+  end
+
+  context "with imap set up" do
+    let(:connection) {MailRoom::IMAP::Connection.new(mailbox)}
+    let(:uid) { 1 }
+    let(:seqno) { 8 }
+
+    before :each do
+      imap.stubs(:starttls)
+      imap.stubs(:login)
+      imap.stubs(:select)
+    end
+
+    it "is logged in" do
+      expect(connection.logged_in?).to eq(true)
+    end
+
+    it "is not idling" do
+      expect(connection.idling?).to eq(false)
+    end
+
+    it "is not disconnected" do
+      imap.stubs(:disconnected?).returns(false)
+
+      expect(connection.disconnected?).to eq(false)
+    end
+
+    it "is ready to idle" do
+      expect(connection.ready_to_idle?).to eq(true)
+    end
+
+    it "waits for a message to process" do
+      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
+
+      attr = { 'UID' => uid, 'RFC822' => new_message.body }
+      fetch_data = Net::IMAP::FetchData.new(seqno, attr)
+
+      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
+    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

data/spec/lib/logger/structured_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+describe MailRoom::Logger::Structured do
+
+  subject { described_class.new $stdout }
+
+  let!(:now) { Time.now }
+  let(:timestamp) { now.to_datetime.iso8601(3) }
+  let(:message) { { action: 'exciting development', message: 'testing 123' } }
+
+  before do
+    Time.stubs(:now).returns(now)
+  end
+
+  [:debug, :info, :warn, :error, :fatal].each do |level|
+    it "logs #{level}" do
+      expect { subject.send(level, message) }.to output(json_matching(level.to_s.upcase, message)).to_stdout_from_any_process
+    end
+  end
+
+  it 'logs unknown' do
+    expect { subject.unknown(message) }.to output(json_matching("ANY", message)).to_stdout_from_any_process
+  end
+
+  it 'only accepts hashes' do
+    expect { subject.unknown("just a string!") }.to raise_error(ArgumentError, /must be a Hash/)
+  end
+
+  context 'logging a hash as a message' do
+    it 'merges the contents' do
+      input = {
+          additional_field: "some value"
+      }
+      expected = {
+          severity: 'DEBUG',
+          time: timestamp,
+          additional_field: "some value"
+      }
+
+      expect { subject.debug(input) }.to output(as_regex(expected)).to_stdout_from_any_process
+    end
+  end
+
+  describe '#format_message' do
+    shared_examples 'timestamp formatting' do
+      it 'outputs ISO8601 timestamps' do
+        data = JSON.parse(subject.format_message('debug', input_timestamp, 'test', { message: 'hello' } ))
+
+        expect(data['time']).to eq(expected_timestamp)
+      end
+    end
+
+    context 'with no timestamp' do
+      let(:input_timestamp) { nil }
+      let(:expected_timestamp) { timestamp }
+
+      it_behaves_like 'timestamp formatting'
+    end
+
+    context 'with DateTime' do
+      let(:input_timestamp) { now.to_datetime }
+      let(:expected_timestamp) { timestamp }
+
+      it_behaves_like 'timestamp formatting'
+    end
+
+    context 'with string' do
+      let(:input_timestamp) { now.to_s }
+      let(:expected_timestamp) { input_timestamp }
+
+      it_behaves_like 'timestamp formatting'
+    end
+  end
+
+  def json_matching(level, message)
+    contents = {
+        severity: level,
+        time: timestamp
+    }.merge(message)
+
+    as_regex(contents)
+  end
+
+  def as_regex(contents)
+    /#{Regexp.quote(contents.to_json)}/
+  end
+end