gitlab-mail_room 0.0.7 → 0.0.12

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) {
@@ -30,10 +30,10 @@ describe MailRoom::Delivery::Postback do
 
     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'
         }
       })}
 
@@ -57,11 +57,11 @@ describe MailRoom::Delivery::Postback do
 
       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'
+          delivery_options: {
+            url: 'http://localhost/inbox',
+            username: 'user1',
+            password: 'password123abc',
+            content_type: 'text/plain'
           }
         })}
 

data/spec/lib/health_check_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe MailRoom::HealthCheck do
+  let(:address) { '127.0.0.1' }
+  let(:port) { 8000 }
+  let(:params) { { address: address, port: port } }
+  subject { described_class.new(params) }
+
+  describe '#initialize' do
+    context 'with valid parameters' do
+      it 'validates successfully' do
+        expect(subject).to be_a(described_class)
+      end
+    end
+
+    context 'with invalid address' do
+      let(:address) { nil }
+
+      it 'raises an error' do
+        expect { subject }.to raise_error('No health check address specified')
+      end
+    end
+
+    context 'with invalid port' do
+      let(:port) { nil }
+
+      it 'raises an error' do
+        expect { subject }.to raise_error('Health check port 0 is invalid')
+      end
+    end
+  end
+
+  describe '#run' do
+    it 'sets running to true' do
+      server = stub(start: true)
+      subject.stubs(:create_server).returns(server)
+
+      subject.run
+
+      expect(subject.running).to be true
+    end
+  end
+
+  describe '#quit' do
+    it 'sets running to false' do
+      server = stub(start: true, shutdown: true)
+      subject.stubs(:create_server).returns(server)
+
+      subject.run
+      subject.quit
+
+      expect(subject.running).to be false
+    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,19 +38,21 @@ 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
 
+      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([], [1])
-      imap.expects(:uid_fetch).with([1], "RFC822").returns([new_message])
-      mailbox.expects(:deliver?).with(1).returns(true)
-      imap.expects(:store).with(8, "+FLAGS", [Net::IMAP::DELETED])
+      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

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

@@ -5,6 +5,7 @@ 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
@@ -32,7 +33,7 @@ describe MailRoom::Logger::Structured do
       }
       expected = {
           severity: 'DEBUG',
-          time: now,
+          time: timestamp,
           additional_field: "some value"
       }
 
@@ -40,10 +41,41 @@ describe MailRoom::Logger::Structured do
     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: now
+        time: timestamp
     }.merge(message)
 
     as_regex(contents)

data/spec/lib/mailbox_spec.rb

@@ -1,14 +1,25 @@
 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
 
@@ -20,9 +31,9 @@ describe MailRoom::Mailbox do
 
     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)
 
@@ -32,49 +43,49 @@ describe MailRoom::Mailbox do
 
     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)
 
-        noop.expects(:deliver).with('a message')
+        noop.expects(:deliver).with(sample_message.body)
 
-        mailbox.deliver(stub(:attr => sample_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)
 
-        logger.expects(:deliver).with('a message')
+        logger.expects(:deliver).with(sample_message.body)
 
-        mailbox.deliver(stub(:attr => sample_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)
 
-        postback.expects(:deliver).with('a message')
+        postback.expects(:deliver).with(sample_message.body)
 
-        mailbox.deliver(stub(:attr => sample_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)
 
-        letter_opener.expects(:deliver).with('a message')
+        letter_opener.expects(:deliver).with(sample_message.body)
 
-        mailbox.deliver(stub(:attr => sample_message))
+        mailbox.deliver(sample_message)
       end
     end
 
@@ -82,18 +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)
+        MailRoom::Delivery['noop'].stubs(new: noop)
         noop.expects(:deliver).never
 
-        mailbox.deliver(stub(:attr => {'FLAGS' => [:Seen, :Recent]}))
+        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
 
@@ -121,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,61 +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
+      before :each do
+        Net::IMAP.stubs(:new).returns(imap) # prevent connection
+      end
 
-    it 'loops over wait while running' do
-      connection = MailRoom::Connection.new(mailbox)
+      it 'loops over wait while running' do
+        connection = MailRoom::IMAP::Connection.new(mailbox)
 
-      MailRoom::Connection.stubs(:new).returns(connection)
+        MailRoom::IMAP::Connection.stubs(:new).returns(connection)
 
-      watcher.expects(:running?).twice.returns(true, false)
-      connection.expects(:wait).once
-      connection.expects(:on_new_message).once
+        watcher.expects(:running?).twice.returns(true, false)
+        connection.expects(:wait).once
+        connection.expects(:on_new_message).once
 
-      watcher.run
-      watcher.watching_thread.join # wait for finishing run
+        watcher.run
+        watcher.watching_thread.join # wait for finishing run
+      end
     end
-  end
 
-  describe '#quit' do
-    let(:imap) {stub(:login => true, :select => true)}
-    let(:watcher) {MailRoom::MailboxWatcher.new(mailbox)}
+    describe '#quit' 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
+      before :each do
+        Net::IMAP.stubs(:new).returns(imap) # prevent connection
+      end
+
+      it 'closes and waits for the connection' do
+        connection = MailRoom::IMAP::Connection.new(mailbox)
+        connection.stubs(:wait)
+        connection.stubs(:quit)
 
-    it 'closes and waits for the connection' do
-      connection = MailRoom::Connection.new(mailbox)
-      connection.stubs(:wait)
-      connection.stubs(:quit)
+        MailRoom::IMAP::Connection.stubs(:new).returns(connection)
 
-      MailRoom::Connection.stubs(:new).returns(connection)
+        watcher.run
+
+        expect(watcher.running?).to eq(true)
+
+        connection.expects(:quit)
+
+        watcher.quit
+
+        expect(watcher.running?).to eq(false)
+      end
+    end
+  end
 
-      watcher.run
+  context 'with Microsoft Graph configured' do
+    let(:mailbox) { build_mailbox(REQUIRED_MICROSOFT_GRAPH_DEFAULTS) }
 
-      expect(watcher.running?).to eq(true)
+    subject { described_class.new(mailbox) }
 
-      connection.expects(:quit)
+    it 'initializes a Microsoft Graph connection' do
+      connection = stub(on_new_message: nil)
 
-      watcher.quit
+      MailRoom::MicrosoftGraph::Connection.stubs(:new).returns(connection)
 
-      expect(watcher.running?).to eq(false)
+      expect(subject.send(:connection)).to eq(connection)
     end
   end
 end