gitlab-mail_room 0.0.2

data/spec/lib/crash_handler_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe MailRoom::CrashHandler do
+
+  let(:error_message) { "oh noes!" }
+  let(:error) { RuntimeError.new(error_message) }
+
+  describe '#handle' do
+
+    subject{ described_class.new(error: error, format: format) }
+
+    context 'when given a json format' do
+      let(:format) { 'json' }
+      let(:fake_json) do
+        { message: error_message }.to_json
+      end
+
+      it 'outputs the result of json to stdout' do
+        subject.stubs(:json).returns(fake_json)
+
+        expect{ subject.handle }.to output(/\"message\":\"#{error_message}\"/).to_stdout
+      end
+    end
+
+    context 'when given a blank format' do
+      let(:format) { "" }
+
+      it 'raises an error as designed' do
+        expect{ subject.handle }.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.handle }.to raise_error(error.class, error_message)
+      end
+    end
+  end
+end

data/spec/lib/delivery/letter_opener_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require 'mail_room/delivery/letter_opener'
+
+describe MailRoom::Delivery::LetterOpener do
+  describe '#deliver' do
+    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')
+    end
+
+    it 'parses the message string with Mail' do
+      expect(::Mail).to have_received(:read_from_string).with('a message')
+    end
+
+    it 'delivers the mail message' do
+      expect(delivery_method).to have_received(:deliver!).with(mail)
+    end
+  end
+end

data/spec/lib/delivery/logger_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'mail_room/delivery/logger'
+
+describe MailRoom::Delivery::Logger do
+  describe '#initialize' do
+    context "without a log path" do
+      let(:mailbox) {build_mailbox}
+
+      it 'creates a new ruby logger' do
+        ::Logger.stubs(:new)
+
+        MailRoom::Delivery::Logger.new(mailbox)
+
+        expect(::Logger).to have_received(:new).with(STDOUT)
+      end
+    end
+
+    context "with a log path" do
+      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)
+
+        expect(File).to have_received(:open).with('/var/log/mail-room.log', 'a')
+        expect(::Logger).to have_received(:new).with(file)
+      end
+    end
+  end
+
+  describe '#deliver' do
+    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')
+
+      expect(logger).to have_received(:info).with('a message')
+    end
+  end
+end

data/spec/lib/delivery/postback_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+require 'mail_room/delivery/postback'
+
+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'
+      })}
+
+      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(:token_auth)
+        connection.stubs(:post).yields(request)
+
+        request.stubs(:url)
+        request.stubs(:body=)
+
+        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'
+        }
+      })}
+
+      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)
+
+        request.stubs(:url)
+        request.stubs(:body=)
+
+        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'
+          }
+        })}
+
+  
+        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)
+  
+          request.stubs(:url)
+          request.stubs(:body=)
+          request.stubs(:headers).returns({})
+
+          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
+    end
+  end
+end

data/spec/lib/delivery/que_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+require 'mail_room/delivery/que'
+
+describe MailRoom::Delivery::Que do
+  describe '#deliver' do
+    let(:mailbox) {build_mailbox({
+      delivery_options: {
+        database: 'delivery_test',
+        username: 'postgres',
+        password: '',
+        queue: 'default',
+        priority: 5,
+        job_class: 'ParseMailJob'
+      }
+    })}
+
+    let(:connection) {stub}
+    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({
+        host: 'localhost',
+        port: 5432,
+        dbname: 'delivery_test',
+        user: 'postgres',
+        password: ''
+      })
+
+      expect(connection).to have_received(:exec).with(
+        "INSERT INTO que_jobs (priority, job_class, queue, args) VALUES ($1, $2, $3, $4)",
+        [
+          5,
+          'ParseMailJob',
+          'default',
+          JSON.dump(['email'])
+        ]
+      )
+    end
+  end
+end

data/spec/lib/delivery/sidekiq_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+require 'mail_room/delivery/sidekiq'
+
+describe MailRoom::Delivery::Sidekiq do
+  subject { described_class.new(options) }
+  let(:redis) { subject.send(:client) }
+  let(:options) { MailRoom::Delivery::Sidekiq::Options.new(mailbox) }
+
+  describe '#options' do
+    let(:redis_url) { 'redis://localhost' }
+
+    context 'when only redis_url is specified' do
+      let(:mailbox) {
+        build_mailbox(
+          delivery_method: :sidekiq,
+          delivery_options: {
+            redis_url: redis_url
+          }
+        )
+      }
+
+      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
+    end
+
+    context 'when namespace is specified' do
+      let(:namespace) { 'sidekiq_mailman' }
+      let(:mailbox) {
+        build_mailbox(
+          delivery_method: :sidekiq,
+          delivery_options: {
+            redis_url: redis_url,
+            namespace: namespace
+          }
+        )
+      }
+
+      it 'client has same specified namespace' do
+        expect(redis.namespace).to eq(namespace)
+      end
+
+      it 'client is a instance of RedisNamespace class' do
+        expect(redis).to be_a ::Redis::Namespace
+      end
+    end
+
+    context 'when sentinel is specified' do
+      let(:redis_url) { 'redis://:mypassword@sentinel-master:6379' }
+      let(:sentinels) { [{ host: '10.0.0.1', port: '26379' }] }
+      let(:mailbox) {
+        build_mailbox(
+          delivery_method: :sidekiq,
+          delivery_options: {
+            redis_url: redis_url,
+            sentinels: sentinels
+          }
+        )
+      }
+
+      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)
+      end
+    end
+
+  end
+end

data/spec/lib/logger/structured_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe MailRoom::Logger::Structured do
+
+  subject { described_class.new $stdout }
+
+  let!(:now) { Time.now }
+  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: now,
+          additional_field: "some value"
+      }
+
+      expect { subject.debug(input) }.to output(as_regex(expected)).to_stdout_from_any_process
+    end
+  end
+
+  def json_matching(level, message)
+    contents = {
+        severity: level,
+        time: now
+    }.merge(message)
+
+    as_regex(contents)
+  end
+
+  def as_regex(contents)
+    /#{Regexp.quote(contents.to_json)}/
+  end
+end

data/spec/lib/mailbox_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+describe MailRoom::Mailbox do
+  let(:sample_message) { {'RFC822' => 'a message', 'UID' => 123} }
+
+  describe "#deliver" do
+    context "with arbitration_method of noop" do
+      it 'arbitrates with a Noop instance' do
+        mailbox = build_mailbox({:arbitration_method => 'noop'})
+        noop = stub(:deliver?)
+        MailRoom::Arbitration['noop'].stubs(:new => noop)
+
+        uid = 123
+
+        mailbox.deliver?(uid)
+
+        expect(noop).to have_received(:deliver?).with(uid)
+      end
+    end
+
+    context "with arbitration_method of redis" do
+      it 'arbitrates with a Redis instance' do
+        mailbox = build_mailbox({:arbitration_method => 'redis'})
+        redis = stub(:deliver?)
+        MailRoom::Arbitration['redis'].stubs(:new => redis)
+
+        uid = 123
+
+        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'})
+        noop = stub(:deliver)
+        MailRoom::Delivery['noop'].stubs(:new => noop)
+
+        mailbox.deliver(stub(:attr => sample_message))
+
+        expect(noop).to have_received(:deliver).with('a message')
+      end
+    end
+
+    context "with delivery_method of logger" do
+      it 'delivers with a Logger instance' do
+        mailbox = build_mailbox({:delivery_method => 'logger'})
+        logger = stub(:deliver)
+        MailRoom::Delivery['logger'].stubs(:new => logger)
+
+        mailbox.deliver(stub(:attr => sample_message))
+
+        expect(logger).to have_received(:deliver).with('a message')
+      end
+    end
+
+    context "with delivery_method of postback" do
+      it 'delivers with a Postback instance' do
+        mailbox = build_mailbox({:delivery_method => 'postback'})
+        postback = stub(:deliver)
+        MailRoom::Delivery['postback'].stubs(:new => postback)
+
+        mailbox.deliver(stub(:attr => sample_message))
+
+        expect(postback).to have_received(:deliver).with('a 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'})
+        letter_opener = stub(:deliver)
+        MailRoom::Delivery['letter_opener'].stubs(:new => letter_opener)
+
+        mailbox.deliver(stub(:attr => sample_message))
+
+        expect(letter_opener).to have_received(:deliver).with('a message')
+      end
+    end
+
+    context "without an RFC822 attribute" 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]}))
+
+        expect(noop).to have_received(:deliver).never
+      end
+    end
+
+    context "with ssl options hash" do
+      it 'replaces verify mode with constant' do
+        mailbox = build_mailbox({:ssl => {:verify_mode => :none}})
+
+        expect(mailbox.ssl_options).to eq({:verify_mode => OpenSSL::SSL::VERIFY_NONE})
+      end
+    end
+
+    context 'structured logger setup' do
+      it 'sets up the logger correctly and does not error' do
+        mailbox = build_mailbox({ name: "magic mailbox", logger: { log_path: '/dev/null' } })
+
+        expect{ mailbox.logger.info(message: "asdf") }.not_to raise_error
+      end
+
+      it 'accepts stdout symbol to mean STDOUT' do
+        mailbox = build_mailbox({ name: "magic mailbox", logger: { log_path: :stdout } })
+
+        expect{ mailbox.logger.info(message: "asdf") }.not_to raise_error
+      end
+
+      it 'sets up the noop logger correctly and does not error' do
+        mailbox = build_mailbox({ name: "magic mailbox" })
+
+        expect{ mailbox.logger.info(message: "asdf") }.not_to raise_error
+      end
+    end
+  end
+
+  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)
+      end
+    end
+  end
+end