gitlab-mail_room 0.0.2

data/lib/mail_room/mailbox_watcher.rb

@@ -0,0 +1,62 @@
+module MailRoom
+  # TODO: split up between processing and idling?
+
+  # Watch a Mailbox
+  # @author Tony Pitale
+  class MailboxWatcher
+    attr_accessor :watching_thread
+
+    # Watch a new mailbox
+    # @param mailbox [MailRoom::Mailbox] the mailbox to watch
+    def initialize(mailbox)
+      @mailbox = mailbox
+
+      @running = false
+      @connection = nil
+    end
+
+    # are we running?
+    # @return [Boolean]
+    def running?
+      @running
+    end
+
+    # run the mailbox watcher
+    def run
+      @mailbox.logger.info({ context: @mailbox.context, action: "Setting up watcher" })
+      @running = true
+
+      connection.on_new_message do |message|
+        @mailbox.deliver(message)
+      end
+
+      self.watching_thread = Thread.start do
+        while(running?) do
+          connection.wait
+        end
+      end
+
+      watching_thread.abort_on_exception = true
+    end
+
+    # stop running, cleanup connection
+    def quit
+      @mailbox.logger.info({ context: @mailbox.context, action: "Quitting connection..." })
+      @running = false
+
+      if @connection
+        @connection.quit
+        @connection = nil
+      end
+
+      if self.watching_thread
+        self.watching_thread.join
+      end
+    end
+
+    private
+    def connection
+      @connection ||= Connection.new(@mailbox)
+    end
+  end
+end

data/lib/mail_room/version.rb

@@ -0,0 +1,4 @@
+module MailRoom
+  # Current version of MailRoom gem
+  VERSION = "0.0.2"
+end

data/logfile.log

@@ -0,0 +1 @@
+# Logfile created on 2019-09-26 08:59:35 -0500 by logger.rb/66358

data/mail_room.gemspec

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mail_room/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "gitlab-mail_room"
+  gem.version       = MailRoom::VERSION
+  gem.authors       = ["Tony Pitale"]
+  gem.email         = ["tpitale@gmail.com"]
+  gem.description   = %q{mail_room will proxy email (gmail) from IMAP to a delivery method}
+  gem.summary       = %q{mail_room will proxy email (gmail) from IMAP to a callback URL, logger, or letter_opener}
+  gem.homepage      = "http://github.com/tpitale/mail_room"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "mocha"
+  gem.add_development_dependency "bourne"
+  gem.add_development_dependency "simplecov"
+
+  # for testing delivery methods
+  gem.add_development_dependency "faraday"
+  gem.add_development_dependency "mail"
+  gem.add_development_dependency "letter_opener"
+  gem.add_development_dependency "redis", "~> 3.3.1"
+  gem.add_development_dependency "redis-namespace"
+  gem.add_development_dependency "pg"
+  gem.add_development_dependency "charlock_holmes"
+end

data/spec/fixtures/test_config.yml

@@ -0,0 +1,16 @@
+---
+:mailboxes:
+  -
+    :email: "user1@gmail.com"
+    :password: "password"
+    :name: "inbox"
+    :delivery_url: "http://localhost:3000/inbox"
+    :delivery_token: "abcdefg"
+    :logger:
+      :log_path: "logfile.log"
+  -
+    :email: "user2@gmail.com"
+    :password: "password"
+    :name: "inbox"
+    :delivery_url: "http://localhost:3000/inbox"
+    :delivery_token: "abcdefg"

data/spec/lib/arbitration/redis_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+require 'mail_room/arbitration/redis'
+
+describe MailRoom::Arbitration::Redis do
+  let(:mailbox) {
+    build_mailbox(
+      arbitration_options: {
+        namespace: "mail_room"
+      }
+    )
+  }
+  let(:options) { described_class::Options.new(mailbox) }
+  subject       { described_class.new(options) }
+
+  # Private, but we don't care.
+  let(:redis) { subject.send(:client) }
+
+  describe '#deliver?' do
+    context "when called the first time" do
+      after do
+        redis.del("delivered:123")
+      end
+
+      it "returns true" do
+        expect(subject.deliver?(123)).to be_truthy
+      end
+
+      it "increments the delivered flag" do
+        subject.deliver?(123)
+
+        expect(redis.get("delivered:123")).to eq("1")
+      end
+
+      it "sets an expiration on the delivered flag" do
+        subject.deliver?(123)
+
+        expect(redis.ttl("delivered:123")).to be > 0
+      end
+    end
+
+    context "when called the second time" do
+      before do
+        #Short expiration, 1 second, for testing
+        subject.deliver?(123, 1)
+      end
+
+      after do
+        redis.del("delivered:123")
+      end
+
+      it "returns false" do
+        expect(subject.deliver?(123, 1)).to be_falsey
+      end
+
+      it "after expiration returns true" do
+        # Fails locally because fakeredis returns 0, not false
+        expect(subject.deliver?(123, 1)).to be_falsey
+        sleep(redis.ttl("delivered:123")+1)
+        expect(subject.deliver?(123, 1)).to be_truthy
+      end
+    end
+
+    context "when called for another uid" do
+      before do
+        subject.deliver?(123)
+      end
+
+      after do
+        redis.del("delivered:123")
+        redis.del("delivered:124")
+      end
+
+      it "returns true" do
+        expect(subject.deliver?(124)).to be_truthy
+      end
+    end
+  end
+
+  context 'redis client connection params' do
+    context 'when only url is present' do
+      let(:redis_url) { "redis://localhost:6379" }
+      let(:mailbox) {
+        build_mailbox(
+          arbitration_options: {
+            redis_url: redis_url
+          }
+        )
+      }
+
+      after do
+        redis.del("delivered:123")
+      end
+
+      it 'client has same specified url' do
+        subject.deliver?(123)
+
+        expect(redis.client.options[:url]).to eq redis_url
+      end
+
+      it 'client is a instance of Redis class' do
+        expect(redis).to be_a Redis
+      end
+    end
+
+    context 'when namespace is present' do
+      let(:namespace) { 'mail_room' }
+      let(:mailbox) {
+        build_mailbox(
+          arbitration_options: {
+            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 present' do
+      let(:redis_url) { 'redis://:mypassword@sentinel-master:6379' }
+      let(:sentinels) { [{ host: '10.0.0.1', port: '26379' }] }
+      let(:mailbox) {
+        build_mailbox(
+          arbitration_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/cli_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe MailRoom::CLI do
+  let(:config_path) {File.expand_path('../fixtures/test_config.yml', File.dirname(__FILE__))}
+  let!(:configuration) {MailRoom::Configuration.new({:config_path => config_path})}
+  let(:coordinator) {stub(:run => true, :quit => true)}
+
+  describe '.new' do
+    let(:args) {["-c", "a path"]}
+
+    before :each do
+      MailRoom::Configuration.stubs(:new).returns(configuration)
+      MailRoom::Coordinator.stubs(:new).returns(coordinator)
+    end
+
+    it 'parses arguments into configuration' do
+      expect(MailRoom::CLI.new(args).configuration).to eq(configuration)
+      expect(MailRoom::Configuration).to have_received(:new).with({:config_path => 'a path'})
+    end
+
+    it 'creates a new coordinator with configuration' do
+      expect(MailRoom::CLI.new(args).coordinator).to eq(coordinator)
+      expect(MailRoom::Coordinator).to have_received(:new).with(configuration.mailboxes)
+    end
+  end
+
+  describe '#start' do
+    let(:cli) {MailRoom::CLI.new([])}
+
+    before :each do
+      cli.configuration = configuration
+      cli.coordinator = coordinator
+    end
+
+    it 'starts running the coordinator' do
+      cli.start
+
+      expect(coordinator).to have_received(:run)
+    end
+
+    context 'on error' do
+      let(:error_message) { "oh noes!" }
+      let(:coordinator) { OpenStruct.new(run: true, quit: true) }
+
+      before do
+        cli.instance_variable_set(:@options, {exit_error_format: error_format})
+        coordinator.stubs(:run).raises(RuntimeError, error_message)
+      end
+
+      context 'json format provided' do
+        let(:error_format) { 'json' }
+
+        it 'passes onto CrashHandler' do
+          cli.start
+
+          expect(MailRoom::CrashHandler).to have_received(:new).with a_hash_including({format: error_format})
+        end
+      end
+    end
+  end
+end

data/spec/lib/configuration_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe MailRoom::Configuration do
+  let(:config_path) {File.expand_path('../fixtures/test_config.yml', File.dirname(__FILE__))}
+
+  describe 'set_mailboxes' do
+    context 'with config_path' do
+      let(:configuration) { MailRoom::Configuration.new(:config_path => config_path) }
+
+      it 'parses yaml into mailbox objects' do
+        MailRoom::Mailbox.stubs(:new).returns('mailbox1', 'mailbox2')
+
+        expect(configuration.mailboxes).to eq(['mailbox1', 'mailbox2'])
+      end
+    end
+
+    context 'without config_path' do
+      let(:configuration) { MailRoom::Configuration.new }
+
+      it 'sets mailboxes to an empty set' do
+        MailRoom::Mailbox.stubs(:new)
+
+        expect(configuration.mailboxes).to eq([])
+
+        expect(MailRoom::Mailbox).to have_received(:new).never
+      end
+    end
+  end
+end

data/spec/lib/connection_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe MailRoom::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::Connection.new(mailbox)}
+
+    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 = 'a message'
+      new_message.stubs(:seqno).returns(8)
+
+      connection.on_new_message do |message|
+        expect(message).to eq(new_message)
+        true
+      end
+
+      mailbox.stubs(:deliver?).returns(true)
+
+      imap.stubs(:idle)
+      imap.stubs(:uid_search).returns([]).then.returns([1])
+      imap.stubs(:uid_fetch).returns([new_message])
+      imap.stubs(:store)
+      imap.stubs(:expunge)
+
+      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/coordinator_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe MailRoom::Coordinator do
+  describe '#initialize' do
+    it 'builds a watcher for each mailbox' do
+      MailRoom::MailboxWatcher.stubs(:new).returns('watcher1', 'watcher2')
+
+      coordinator = MailRoom::Coordinator.new(['mailbox1', 'mailbox2'])
+
+      expect(coordinator.watchers).to eq(['watcher1', 'watcher2'])
+
+      expect(MailRoom::MailboxWatcher).to have_received(:new).with('mailbox1')
+      expect(MailRoom::MailboxWatcher).to have_received(:new).with('mailbox2')
+    end
+
+    it 'makes no watchers when mailboxes is empty' do
+      coordinator = MailRoom::Coordinator.new([])
+      expect(coordinator.watchers).to eq([])
+    end
+  end
+
+  describe '#run' do
+    it 'runs each watcher' do
+      watcher = stub
+      watcher.stubs(:run)
+      watcher.stubs(:quit)
+      MailRoom::MailboxWatcher.stubs(:new).returns(watcher)
+      coordinator = MailRoom::Coordinator.new(['mailbox1'])
+      coordinator.stubs(:sleep_while_running)
+      coordinator.run
+      expect(watcher).to have_received(:run)
+      expect(watcher).to have_received(:quit)
+    end
+    
+    it 'should go to sleep after running watchers' do
+      coordinator = MailRoom::Coordinator.new([])
+      coordinator.stubs(:running=)
+      coordinator.stubs(:running?).returns(false)
+      coordinator.run
+      expect(coordinator).to have_received(:running=).with(true)
+      expect(coordinator).to have_received(:running?)
+    end
+
+    it 'should set attribute running to true' do
+      coordinator = MailRoom::Coordinator.new([])
+      coordinator.stubs(:sleep_while_running)
+      coordinator.run
+      expect(coordinator.running).to eq(true)
+    end
+  end
+
+  describe '#quit' do
+    it 'quits each watcher' do
+      watcher = stub(:quit)
+      MailRoom::MailboxWatcher.stubs(:new).returns(watcher)
+      coordinator = MailRoom::Coordinator.new(['mailbox1'])
+      coordinator.quit
+      expect(watcher).to have_received(:quit)
+    end
+  end
+end