gitlab-mail_room 0.0.4 → 0.0.20

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,56 +46,94 @@ 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')
-
-        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')
       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'
+          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.stubs(:basic_auth)
-          connection.stubs(:post).yields(request)
-  
+
+          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(connection).to have_received(:basic_auth).with('user1', 'password123abc')
-          expect(connection).to have_received(:post)
-          
+
           expect(request.headers['Content-Type']).to eq('text/plain')
         end
       end
+
+      context 'with jwt token in the delivery options' do
+        let(:mailbox) {build_mailbox({
+          delivery_options: {
+            url: 'http://localhost/inbox',
+            jwt_auth_header: "Mailroom-Api-Request",
+            jwt_issuer: "mailroom",
+            jwt_algorithm: "HS256",
+            jwt_secret_path: "secret_path"
+          }
+        })}
+
+        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).twice
+          request.stubs(:url)
+          request.stubs(:body=)
+          request.stubs(:headers).returns({})
+
+          jwt = stub
+          MailRoom::JWT.expects(:new).with(
+            header: 'Mailroom-Api-Request',
+            issuer: 'mailroom',
+            algorithm: 'HS256',
+            secret_path: 'secret_path'
+          ).returns(jwt)
+          jwt.stubs(:valid?).returns(true)
+          jwt.stubs(:header).returns('Mailroom-Api-Request')
+          jwt.stubs(:token).returns('a_jwt_token')
+
+          delivery = MailRoom::Delivery::Postback.new(delivery_options)
+
+          delivery.deliver('a message')
+          expect(request.headers['Mailroom-Api-Request']).to eql('a_jwt_token')
+
+          # A different jwt token for the second time
+          jwt.stubs(:token).returns('another_jwt_token')
+
+          delivery.deliver('another message')
+          expect(request.headers['Mailroom-Api-Request']).to eql('another_jwt_token')
+        end
+      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

@@ -4,27 +4,49 @@ require 'mail_room/delivery/sidekiq'
 describe MailRoom::Delivery::Sidekiq do
   subject { described_class.new(options) }
   let(:redis) { subject.send(:client) }
+  let(:raw_client) { redis._client }
   let(:options) { MailRoom::Delivery::Sidekiq::Options.new(mailbox) }
 
   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(raw_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(raw_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
 
@@ -65,10 +87,10 @@ describe MailRoom::Delivery::Sidekiq do
       before { ::Redis::Client::Connector::Sentinel.any_instance.stubs(:resolve).returns(sentinels) }
 
       it 'client has same specified sentinel params' do
-        expect(redis.client.instance_variable_get(:@connector)).to be_a Redis::Client::Connector::Sentinel
-        expect(redis.client.options[:host]).to eq('sentinel-master')
-        expect(redis.client.options[:password]).to eq('mypassword')
-        expect(redis.client.options[:sentinels]).to eq(sentinels)
+        expect(raw_client.instance_variable_get(:@connector)).to be_a Redis::Client::Connector::Sentinel
+        expect(raw_client.options[:host]).to eq('sentinel-master')
+        expect(raw_client.options[:password]).to eq('mypassword')
+        expect(raw_client.options[:sentinels]).to eq(sentinels)
       end
     end
 

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,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

data/spec/lib/jwt_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+require 'mail_room/jwt'
+
+describe MailRoom::JWT do
+  let(:secret_path) { File.expand_path('../fixtures/jwt_secret', File.dirname(__FILE__)) }
+  let(:secret) { Base64.strict_decode64(File.read(secret_path).chomp) }
+
+  let(:standard_config) do
+    {
+      secret_path: secret_path,
+      issuer: 'mailroom',
+      header: 'Mailroom-Api-Request',
+      algorithm: 'HS256'
+    }
+  end
+
+  describe '#token' do
+    let(:jwt) { described_class.new(**standard_config) }
+
+    it 'generates a valid jwt token' do
+      token = jwt.token
+      expect(token).not_to be_empty
+
+      payload = nil
+      expect do
+        payload = JWT.decode(token, secret, true, iss: 'mailroom', verify_iat: true, verify_iss: true, algorithm: 'HS256')
+      end.not_to raise_error
+      expect(payload).to be_an(Array)
+      expect(payload).to match(
+        [
+          a_hash_including(
+            'iss' => 'mailroom',
+            'nonce' => be_a(String),
+            'iat' => be_a(Integer)
+          ),
+          { 'alg' => 'HS256' }
+        ]
+      )
+    end
+
+    it 'generates a different token for each invocation' do
+      expect(jwt.token).not_to eql(jwt.token)
+    end
+  end
+
+  describe '#valid?' do
+    it 'returns true if all essential components are present' do
+      jwt = described_class.new(**standard_config)
+      expect(jwt.valid?).to eql(true)
+    end
+
+    it 'returns true if header and secret path are present' do
+      jwt = described_class.new(
+        secret_path: secret_path,
+        header: 'Mailroom-Api-Request',
+        issuer: nil,
+        algorithm: nil
+      )
+      expect(jwt.valid?).to eql(true)
+      expect(jwt.issuer).to eql(described_class::DEFAULT_ISSUER)
+      expect(jwt.algorithm).to eql(described_class::DEFAULT_ALGORITHM)
+    end
+
+    it 'returns false if either header or secret_path are missing' do
+      expect(described_class.new(
+        secret_path: nil,
+        header: 'Mailroom-Api-Request',
+        issuer: nil,
+        algorithm: nil
+      ).valid?).to eql(false)
+      expect(described_class.new(
+        secret_path: secret_path,
+        header: nil,
+        issuer: nil,
+        algorithm: nil
+      ).valid?).to eql(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)