gitlab-mail_room 0.0.4 → 0.0.20

data/spec/lib/mailbox_spec.rb

@@ -1,82 +1,91 @@
 require 'spec_helper'
 
 describe MailRoom::Mailbox do
-  let(:sample_message) { {'RFC822' => 'a message', 'UID' => 123} }
+  let(:sample_message) { MailRoom::Message.new(uid: 123, body: 'a message') }
+
+  context 'with IMAP configuration' do
+    subject { build_mailbox }
+
+    describe '#imap?' do
+      it 'configured as an IMAP inbox' do
+        expect(subject.imap?).to be true
+        expect(subject.microsoft_graph?).to be false
+      end
+    end
+  end
 
   describe "#deliver" do
     context "with arbitration_method of noop" do
       it 'arbitrates with a Noop instance' do
-        mailbox = build_mailbox({:arbitration_method => 'noop'})
+        mailbox = build_mailbox({arbitration_method: 'noop'})
         noop = stub(:deliver?)
-        MailRoom::Arbitration['noop'].stubs(:new => noop)
+        MailRoom::Arbitration['noop'].stubs(new: noop)
 
         uid = 123
 
-        mailbox.deliver?(uid)
+        noop.expects(:deliver?).with(uid)
 
-        expect(noop).to have_received(:deliver?).with(uid)
+        mailbox.deliver?(uid)
       end
     end
 
     context "with arbitration_method of redis" do
       it 'arbitrates with a Redis instance' do
-        mailbox = build_mailbox({:arbitration_method => 'redis'})
+        mailbox = build_mailbox({arbitration_method: 'redis'})
         redis = stub(:deliver?)
-        MailRoom::Arbitration['redis'].stubs(:new => redis)
-
+        MailRoom::Arbitration['redis'].stubs(new: redis)
         uid = 123
+        redis.expects(:deliver?).with(uid)
 
         mailbox.deliver?(uid)
-
-        expect(redis).to have_received(:deliver?).with(uid)
       end
     end
 
     context "with delivery_method of noop" do
       it 'delivers with a Noop instance' do
-        mailbox = build_mailbox({:delivery_method => 'noop'})
+        mailbox = build_mailbox({delivery_method: 'noop'})
         noop = stub(:deliver)
-        MailRoom::Delivery['noop'].stubs(:new => noop)
+        MailRoom::Delivery['noop'].stubs(new: noop)
 
-        mailbox.deliver(stub(:attr => sample_message))
+        noop.expects(:deliver).with(sample_message.body)
 
-        expect(noop).to have_received(:deliver).with('a message')
+        mailbox.deliver(sample_message)
       end
     end
 
     context "with delivery_method of logger" do
       it 'delivers with a Logger instance' do
-        mailbox = build_mailbox({:delivery_method => 'logger'})
+        mailbox = build_mailbox({delivery_method: 'logger'})
         logger = stub(:deliver)
-        MailRoom::Delivery['logger'].stubs(:new => logger)
+        MailRoom::Delivery['logger'].stubs(new: logger)
 
-        mailbox.deliver(stub(:attr => sample_message))
+        logger.expects(:deliver).with(sample_message.body)
 
-        expect(logger).to have_received(:deliver).with('a message')
+        mailbox.deliver(sample_message)
       end
     end
 
     context "with delivery_method of postback" do
       it 'delivers with a Postback instance' do
-        mailbox = build_mailbox({:delivery_method => 'postback'})
+        mailbox = build_mailbox({delivery_method: 'postback'})
         postback = stub(:deliver)
-        MailRoom::Delivery['postback'].stubs(:new => postback)
+        MailRoom::Delivery['postback'].stubs(new: postback)
 
-        mailbox.deliver(stub(:attr => sample_message))
+        postback.expects(:deliver).with(sample_message.body)
 
-        expect(postback).to have_received(:deliver).with('a message')
+        mailbox.deliver(sample_message)
       end
     end
 
     context "with delivery_method of letter_opener" do
       it 'delivers with a LetterOpener instance' do
-        mailbox = build_mailbox({:delivery_method => 'letter_opener'})
+        mailbox = build_mailbox({delivery_method: 'letter_opener'})
         letter_opener = stub(:deliver)
-        MailRoom::Delivery['letter_opener'].stubs(:new => letter_opener)
+        MailRoom::Delivery['letter_opener'].stubs(new: letter_opener)
 
-        mailbox.deliver(stub(:attr => sample_message))
+        letter_opener.expects(:deliver).with(sample_message.body)
 
-        expect(letter_opener).to have_received(:deliver).with('a message')
+        mailbox.deliver(sample_message)
       end
     end
 
@@ -84,19 +93,18 @@ describe MailRoom::Mailbox do
       it "doesn't deliver the message" do
         mailbox = build_mailbox({ name: "magic mailbox", delivery_method: 'noop' })
         noop = stub(:deliver)
-        MailRoom::Delivery['noop'].stubs(:new => noop)
-
-        mailbox.deliver(stub(:attr => {'FLAGS' => [:Seen, :Recent]}))
+        MailRoom::Delivery['noop'].stubs(new: noop)
+        noop.expects(:deliver).never
 
-        expect(noop).to have_received(:deliver).never
+        mailbox.deliver(MailRoom::Message.new(uid: 1234, body: nil))
       end
     end
 
     context "with ssl options hash" do
       it 'replaces verify mode with constant' do
-        mailbox = build_mailbox({:ssl => {:verify_mode => :none}})
+        mailbox = build_mailbox({ssl: {verify_mode: :none}})
 
-        expect(mailbox.ssl_options).to eq({:verify_mode => OpenSSL::SSL::VERIFY_NONE})
+        expect(mailbox.ssl_options).to eq({verify_mode: OpenSSL::SSL::VERIFY_NONE})
       end
     end
 
@@ -124,8 +132,45 @@ describe MailRoom::Mailbox do
   describe "#validate!" do
     context "with missing configuration" do
       it 'raises an error' do
-        expect { build_mailbox({:name => nil}) }.to raise_error(MailRoom::ConfigurationError)
-        expect { build_mailbox({:host => nil}) }.to raise_error(MailRoom::ConfigurationError)
+        expect { build_mailbox({name: nil}) }.to raise_error(MailRoom::ConfigurationError)
+        expect { build_mailbox({host: nil}) }.to raise_error(MailRoom::ConfigurationError)
+      end
+    end
+
+    context "with Microsoft Graph configuration" do
+      let(:options) do
+        {
+          arbitration_method: 'redis',
+        }.merge(REQUIRED_MICROSOFT_GRAPH_DEFAULTS)
+      end
+
+      subject { build_mailbox(options) }
+
+      def delete_inbox_option(key)
+        options[:inbox_options] = options[:inbox_options].dup.delete(key)
+      end
+
+      it 'allows password omission' do
+        expect { subject }.not_to raise_error
+      end
+
+      it 'configured as a Microsoft Graph inbox' do
+        expect(subject.imap?).to be false
+        expect(subject.microsoft_graph?).to be true
+      end
+
+      it 'raises an error when the inbox options are not present' do
+        options.delete(:inbox_options)
+
+        expect { subject }.to raise_error(MailRoom::ConfigurationError)
+      end
+
+      %i[tenant_id client_id client_secret].each do |item|
+        it "raises an error when the #{item} is not present" do
+          delete_inbox_option(item)
+
+          expect { subject }.to raise_error(MailRoom::ConfigurationError)
+        end
       end
     end
   end

data/spec/lib/mailbox_watcher_spec.rb

@@ -1,64 +1,77 @@
 require 'spec_helper'
 
 describe MailRoom::MailboxWatcher do
-  let(:mailbox) {build_mailbox}
-
-  describe '#running?' do
-    it 'is false by default' do
-      watcher = MailRoom::MailboxWatcher.new(mailbox)
-      expect(watcher.running?).to eq(false)
+  context 'with IMAP configured' do
+    let(:mailbox) {build_mailbox}
+
+    describe '#running?' do
+      it 'is false by default' do
+        watcher = MailRoom::MailboxWatcher.new(mailbox)
+        expect(watcher.running?).to eq(false)
+      end
     end
-  end
 
-  describe '#run' do
-    let(:imap) {stub(:login => true, :select => true)}
-    let(:watcher) {MailRoom::MailboxWatcher.new(mailbox)}
+    describe '#run' do
+      let(:imap) {stub(login: true, select: true)}
+      let(:watcher) {MailRoom::MailboxWatcher.new(mailbox)}
+
+      before :each do
+        Net::IMAP.stubs(:new).returns(imap) # prevent connection
+      end
+
+      it 'loops over wait while running' do
+        connection = MailRoom::IMAP::Connection.new(mailbox)
+
+        MailRoom::IMAP::Connection.stubs(:new).returns(connection)
+
+        watcher.expects(:running?).twice.returns(true, false)
+        connection.expects(:wait).once
+        connection.expects(:on_new_message).once
 
-    before :each do
-      Net::IMAP.stubs(:new).returns(imap) # prevent connection
+        watcher.run
+        watcher.watching_thread.join # wait for finishing run
+      end
     end
 
-    it 'loops over wait while running' do
-      connection = MailRoom::Connection.new(mailbox)
-      connection.stubs(:on_new_message)
-      connection.stubs(:wait)
+    describe '#quit' do
+      let(:imap) {stub(login: true, select: true)}
+      let(:watcher) {MailRoom::MailboxWatcher.new(mailbox)}
 
-      MailRoom::Connection.stubs(:new).returns(connection)
+      before :each do
+        Net::IMAP.stubs(:new).returns(imap) # prevent connection
+      end
 
-      watcher.stubs(:running?).returns(true).then.returns(false)
+      it 'closes and waits for the connection' do
+        connection = MailRoom::IMAP::Connection.new(mailbox)
+        connection.stubs(:wait)
+        connection.stubs(:quit)
 
-      watcher.run
-      watcher.watching_thread.join # wait for finishing run
+        MailRoom::IMAP::Connection.stubs(:new).returns(connection)
 
-      expect(watcher).to have_received(:running?).times(2)
-      expect(connection).to have_received(:wait).once
-      expect(connection).to have_received(:on_new_message).once
-    end
-  end
+        watcher.run
 
-  describe '#quit' do
-    let(:imap) {stub(:login => true, :select => true)}
-    let(:watcher) {MailRoom::MailboxWatcher.new(mailbox)}
+        expect(watcher.running?).to eq(true)
 
-    before :each do
-      Net::IMAP.stubs(:new).returns(imap) # prevent connection
-    end
+        connection.expects(:quit)
 
-    it 'closes and waits for the connection' do
-      connection = MailRoom::Connection.new(mailbox)
-      connection.stubs(:wait)
-      connection.stubs(:quit)
+        watcher.quit
+
+        expect(watcher.running?).to eq(false)
+      end
+    end
+  end
 
-      MailRoom::Connection.stubs(:new).returns(connection)
+  context 'with Microsoft Graph configured' do
+    let(:mailbox) { build_mailbox(REQUIRED_MICROSOFT_GRAPH_DEFAULTS) }
 
-      watcher.run
+    subject { described_class.new(mailbox) }
 
-      expect(watcher.running?).to eq(true)
+    it 'initializes a Microsoft Graph connection' do
+      connection = stub(on_new_message: nil)
 
-      watcher.quit
+      MailRoom::MicrosoftGraph::Connection.stubs(:new).returns(connection)
 
-      expect(connection).to have_received(:quit)
-      expect(watcher.running?).to eq(false)
+      expect(subject.send(:connection)).to eq(connection)
     end
   end
 end

data/spec/lib/message_spec.rb

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

data/spec/lib/microsoft_graph/connection_spec.rb

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'spec_helper'
+require 'json'
+require 'webmock/rspec'
+
+describe MailRoom::MicrosoftGraph::Connection do
+  let(:tenant_id) { options[:inbox_options][:tenant_id] }
+  let(:options) do
+    {
+      delete_after_delivery: true,
+      expunge_deleted: true
+    }.merge(REQUIRED_MICROSOFT_GRAPH_DEFAULTS)
+  end
+  let(:mailbox) { build_mailbox(options) }
+  let(:graph_endpoint) { 'https://graph.microsoft.com' }
+  let(:azure_ad_endpoint) { 'https://login.microsoftonline.com' }
+  let(:base_url) { "#{graph_endpoint}/v1.0/users/user@example.com/mailFolders/inbox/messages" }
+  let(:message_base_url) { "#{graph_endpoint}/v1.0/users/user@example.com/messages" }
+
+  let(:connection) { described_class.new(mailbox) }
+  let(:uid) { 1 }
+  let(:access_token) { SecureRandom.hex }
+  let(:refresh_token) { SecureRandom.hex }
+  let(:expires_in) { Time.now + 3600 }
+  let(:unread_messages_body) { '' }
+  let(:status) { 200 }
+  let!(:stub_token) do
+    stub_request(:post, "#{azure_ad_endpoint}/#{tenant_id}/oauth2/v2.0/token").to_return(
+      body: { 'access_token' => access_token, 'refresh_token' => refresh_token, 'expires_in' => expires_in }.to_json,
+      headers: { 'Content-Type' => 'application/json' }
+    )
+  end
+  let!(:stub_unread_messages_request) do
+    stub_request(:get, "#{base_url}?$filter=isRead%20eq%20false").to_return(
+      status: status,
+      body: unread_messages_body.to_json,
+      headers: { 'Content-Type' => 'application/json' }
+    )
+  end
+
+  before do
+    WebMock.enable!
+  end
+
+  context '#quit' do
+    it 'returns false' do
+      expect(connection.stopped?).to be_falsey
+    end
+
+    it 'returns true' do
+      connection.quit
+
+      expect(connection.stopped?).to be_truthy
+    end
+
+    it 'does not attempt to process the mailbox' do
+      connection.quit
+
+      connection.expects(:process_mailbox).times(0)
+      connection.wait
+    end
+  end
+
+  context '#wait' do
+    before do
+      connection.stubs(:do_sleep)
+    end
+
+    describe 'poll interval' do
+      it 'defaults to 60 seconds' do
+        expect(connection.send(:poll_interval)).to eq(60)
+      end
+
+      it 'calls do_sleep 60 times' do
+        connection.expects(:do_sleep).with(1).times(60)
+
+        connection.wait
+      end
+
+      context 'interval set to 10' do
+        let(:options) do
+          {
+            inbox_method: :microsoft_graph,
+            inbox_options: {
+              tenant_id: '98776',
+              client_id: '12345',
+              client_secret: 'MY-SECRET',
+              poll_interval: '10'
+            }
+          }
+        end
+
+        it 'sets the poll interval to 10' do
+          expect(connection.send(:poll_interval)).to eq(10)
+        end
+
+        it 'calls do_sleep 10 times' do
+          connection.expects(:do_sleep).with(1).times(10)
+
+          connection.wait
+        end
+      end
+    end
+
+    shared_examples 'with a single message' do
+      let(:message_id) { SecureRandom.hex }
+      let(:unread_messages_body) { { value: ['id' => message_id] } }
+      let(:message_url) { "#{message_base_url}/#{message_id}" }
+      let(:message_body) { 'hello world' }
+
+      it 'requests message ID' do
+        stub_get = stub_request(:get, "#{message_url}/$value").to_return(
+          status: 200,
+          body: message_body
+        )
+        stub_patch = stub_request(:patch, message_url).with(body: { "isRead": true }.to_json)
+        stub_delete = stub_request(:delete, message_url)
+        message_count = 0
+
+        connection.on_new_message do |message|
+          message_count += 1
+          expect(message.uid).to eq(message_id)
+          expect(message.body).to eq(message_body)
+        end
+
+        connection.wait
+
+        assert_requested(stub_token)
+        assert_requested(stub_unread_messages_request)
+        assert_requested(stub_get)
+        assert_requested(stub_patch)
+        assert_requested(stub_delete)
+        expect(message_count).to eq(1)
+      end
+    end
+
+    context 'with default Azure settings' do
+      before do
+        puts options
+      end
+      it_behaves_like 'with a single message'
+    end
+
+    # https://docs.microsoft.com/en-us/graph/deployments
+    context 'with an alternative Azure deployment' do
+      let(:graph_endpoint) { 'https://graph.microsoft.us' }
+      let(:azure_ad_endpoint) { 'https://login.microsoftonline.us' }
+      let(:options) do
+        {
+          inbox_method: :microsoft_graph,
+          delete_after_delivery: true,
+          expunge_deleted: true,
+          inbox_options: {
+            tenant_id: '98776',
+            client_id: '12345',
+            client_secret: 'MY-SECRET',
+            graph_endpoint: 'https://graph.microsoft.us',
+            azure_ad_endpoint: 'https://login.microsoftonline.us'
+          }
+        }
+      end
+
+      it_behaves_like 'with a single message'
+    end
+
+    context 'with multiple pages of messages' do
+      let(:message_ids) { [SecureRandom.hex, SecureRandom.hex] }
+      let(:next_page_url) { "#{graph_endpoint}/v1.0/nextPage" }
+      let(:unread_messages_body) { { value: ['id' => message_ids.first], '@odata.nextLink' => next_page_url } }
+      let(:message_body) { 'hello world' }
+
+      it 'requests message ID' do
+        stub_request(:get, next_page_url).to_return(
+          status: 200,
+          body: { value: ['id' => message_ids[1]] }.to_json
+        )
+
+        stubs = []
+        message_ids.each do |message_id|
+          rfc822_msg_url = "#{message_base_url}/#{message_id}/$value"
+          stubs << stub_request(:get, rfc822_msg_url).to_return(
+            status: 200,
+            body: message_body
+          )
+
+          msg_url = "#{message_base_url}/#{message_id}"
+          stubs << stub_request(:patch, msg_url).with(body: { "isRead": true }.to_json)
+          stubs << stub_request(:delete, msg_url)
+        end
+
+        message_count = 0
+
+        connection.on_new_message do |message|
+          expect(message.uid).to eq(message_ids[message_count])
+          expect(message.body).to eq(message_body)
+          message_count += 1
+        end
+
+        connection.wait
+
+        stubs.each { |stub| assert_requested(stub) }
+        expect(message_count).to eq(2)
+      end
+    end
+
+    shared_examples 'request backoff' do
+      it 'backs off' do
+        connection.expects(:backoff)
+
+        connection.on_new_message {}
+        connection.wait
+
+        expect(connection.throttled_count).to eq(1)
+      end
+    end
+
+    context 'too many requests' do
+      let(:status) { 429 }
+
+      it_behaves_like 'request backoff'
+    end
+
+    context 'too much bandwidth' do
+      let(:status) { 509 }
+
+      it_behaves_like 'request backoff'
+    end
+
+    context 'invalid JSON response' do
+      let(:body) { 'this is something' }
+
+      it 'ignores the message and logs a warning' do
+        mailbox.logger.expects(:warn)
+
+        connection.on_new_message {}
+        connection.wait
+      end
+    end
+
+    context '500 error' do
+      let(:status) { 500 }
+
+      it 'terminates due to error' do
+        connection.on_new_message {}
+
+        expect { connection.wait }.to raise_error(OAuth2::Error)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -2,10 +2,10 @@ require 'simplecov'
 SimpleCov.start
 
 require 'bundler/setup'
+require 'date'
 
 require 'rspec'
 require 'mocha/api'
-require 'bourne'
 
 require File.expand_path('../../lib/mail_room', __FILE__)
 
@@ -22,11 +22,21 @@ RSpec.configure do |config|
 end
 
 REQUIRED_MAILBOX_DEFAULTS = {
-  :name => "inbox",
-  :email => "user@example.com",
-  :password => "password123"
+  name: "inbox",
+  email: "user@example.com",
+  password: "password123"
 }
 
+REQUIRED_MICROSOFT_GRAPH_DEFAULTS = {
+  password: nil,
+  inbox_method: :microsoft_graph,
+  inbox_options: {
+    tenant_id: '98776',
+    client_id: '12345',
+    client_secret: 'MY-SECRET',
+  }.freeze
+}.freeze
+
 def build_mailbox(options = {})
   MailRoom::Mailbox.new(REQUIRED_MAILBOX_DEFAULTS.merge(options))
 end