mail_room 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9feac02c627c54d87da87bc73e1aec3587f43ff3
-  data.tar.gz: 55c2cd20c9e7b7036094c4d46c2efc93567f3e77
+  metadata.gz: 86c8cfc70ff25a195a9e59c4bc175eb68b107874
+  data.tar.gz: 3bc4c8778f7ff9e14233986a922033243482902e
 SHA512:
-  metadata.gz: 29476b7c9e48f064087b59cc869ad6fab364044ca5a8fbf0f8fdb2dadb6a0222cdb07c473f4d82f0b75ccf895c063b56599bb1fd1acfa906309844f85bca3fb8
-  data.tar.gz: 030b4c91c26c545d2103d2d6f7147606bfafa7998c3b31251356b8da4241614260210863c9ef8ce04423ec91f95a381cf23fcdc648fc397368d2d33e5e6039f1
+  metadata.gz: 1f84614429adeb0e94e6b22bc053861ad10f939e551d370cbfa8e091306737628616a999ce1c42c7a879d4b67f8bea3d58e6620657e0d01676e1c8fe673d9c5b
+  data.tar.gz: ce3e8a096c013bda86d20e86f31fae1753fb2fff7da7fb74b5db72e59bb76325086bce87505ceeb7b7927b9f49efdae28c88c0d8af9732a3f12f90eab328d73a

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## mail_room 0.8.0 ##
+
+* Rework the mailbox watcher and handler into a new Connection class to abstract away IMAP handling details
+
+    *Tony Pitale <@tpitale>*
+
 ## mail_room 0.7.0 ##
 
 * Backports idle timeout from ruby 2.3.0

data/lib/mail_room.rb

@@ -10,6 +10,6 @@ require "mail_room/backports/imap"
 require "mail_room/configuration"
 require "mail_room/mailbox"
 require "mail_room/mailbox_watcher"
-require "mail_room/mailbox_handler"
+require "mail_room/connection"
 require "mail_room/coordinator"
 require "mail_room/cli"

data/lib/mail_room/configuration.rb

@@ -4,7 +4,7 @@ module MailRoom
   # Wraps configuration for a set of individual mailboxes with global config
   # @author Tony Pitale
   class Configuration
-    attr_accessor :mailboxes, :daemonize, :log_path, :pid_path, :quiet
+    attr_accessor :mailboxes, :log_path, :quiet
 
     # Initialize a new configuration of mailboxes
     def initialize(options={})

data/lib/mail_room/connection.rb

@@ -0,0 +1,175 @@
+module MailRoom
+  class Connection
+    def initialize(mailbox)
+      @mailbox = mailbox
+
+      # log in and set the mailbox
+      reset
+      setup
+    end
+
+    def on_new_message(&block)
+      @new_message_handler = block
+    end
+
+    # is the connection logged in?
+    # @return [Boolean]
+    def logged_in?
+      @logged_in
+    end
+
+    # is the connection blocked idling?
+    # @return [Boolean]
+    def idling?
+      @idling
+    end
+
+    # is the imap connection closed?
+    # @return [Boolean]
+    def disconnected?
+      @imap.disconnected?
+    end
+
+    # is the connection ready to idle?
+    # @return [Boolean]
+    def ready_to_idle?
+      logged_in? && !idling?
+    end
+
+    def quit
+      stop_idling
+      reset
+    end
+
+    def wait
+      begin
+        # in case we missed any between idles
+        process_mailbox
+
+        idle
+
+        process_mailbox
+      rescue Net::IMAP::Error, IOError
+        reset
+        setup
+      end
+    end
+
+    private
+
+    def reset
+      @imap = nil
+      @logged_in = false
+      @idling = false
+    end
+
+    def setup
+      start_tls
+      log_in
+      set_mailbox
+    end
+
+    # build a net/imap connection to google imap
+    def imap
+      @imap ||= MailRoom::IMAP.new(@mailbox.host, :port => @mailbox.port, :ssl => @mailbox.ssl_options)
+    end
+
+    # start a TLS session
+    def start_tls
+      imap.starttls if @mailbox.start_tls
+    end
+
+    # send the imap login command to google
+    def log_in
+      imap.login(@mailbox.email, @mailbox.password)
+      @logged_in = true
+    end
+
+    # select the mailbox name we want to use
+    def set_mailbox
+      imap.select(@mailbox.name) if logged_in?
+    end
+
+    # is the response for a new message?
+    # @param response [Net::IMAP::TaggedResponse] the imap response from idle
+    # @return [Boolean]
+    def message_exists?(response)
+      response.respond_to?(:name) && response.name == 'EXISTS'
+    end
+
+    # @private
+    def idle_handler
+      lambda {|response| imap.idle_done if message_exists?(response)}
+    end
+
+    # maintain an imap idle connection
+    def idle
+      return unless ready_to_idle?
+
+      @idling = true
+
+      imap.idle(@mailbox.idle_timeout, &idle_handler)
+    ensure
+      @idling = false
+    end
+
+    # trigger the idle to finish and wait for the thread to finish
+    def stop_idling
+      return unless idling?
+
+      imap.idle_done
+      
+      # idling_thread.join
+      # self.idling_thread = nil
+    end
+
+    def process_mailbox
+      return unless @new_message_handler
+
+      msgs = new_messages
+
+      msgs.
+        map(&@new_message_handler). # deliver each new message, collect success
+        zip(msgs). # include messages with success
+        select(&:first).map(&:last). # filter failed deliveries, collect message
+        each {|message| scrub(message)} # scrub delivered messages
+    end
+
+    def scrub(message)
+      if @mailbox.delete_after_delivery
+        imap.store(message.seqno, "+FLAGS", [Net::IMAP::DELETED])
+      end
+    end
+
+    # @private
+    # fetch all messages for the new message ids
+    def new_messages
+      # Both of these calls may results in
+      #   imap raising an EOFError, we handle
+      #   this exception in the watcher
+      messages_for_ids(new_message_ids)
+    end
+
+    # TODO: label messages?
+    #   @imap.store(id, "+X-GM-LABELS", [label])
+
+    # @private
+    # search for all new (unseen) message ids
+    # @return [Array<Integer>] message ids
+    def new_message_ids
+      # uid_search still leaves messages UNSEEN
+      imap.uid_search(@mailbox.search_command).select { |uid| @mailbox.deliver?(uid) }
+    end
+
+    # @private
+    # fetch the email for all given ids in RFC822 format
+    # @param ids [Array<Integer>] list of message ids
+    # @return [Array<Net::IMAP::FetchData>] the net/imap messages for the given ids
+    def messages_for_ids(uids)
+      return [] if uids.empty?
+
+      # uid_fetch marks as SEEN, will not be re-fetched for UNSEEN
+      imap.uid_fetch(uids, "RFC822")
+    end
+  end
+end

data/lib/mail_room/coordinator.rb

@@ -33,6 +33,8 @@ module MailRoom
     private
     # @private
     def sleep_while_running
+      # do we need to sweep for dead watchers?
+      # or do we let the mailbox rebuild connections
       while(running?) do; sleep 1; end
     end
   end

data/lib/mail_room/mailbox_watcher.rb

@@ -4,25 +4,15 @@ module MailRoom
   # Watch a Mailbox
   # @author Tony Pitale
   class MailboxWatcher
-    attr_accessor :idling_thread
+    attr_accessor :watching_thread
 
     # Watch a new mailbox
     # @param mailbox [MailRoom::Mailbox] the mailbox to watch
     def initialize(mailbox)
       @mailbox = mailbox
 
-      reset
       @running = false
-    end
-
-    # build a net/imap connection to google imap
-    def imap
-      @imap ||= MailRoom::IMAP.new(@mailbox.host, :port => @mailbox.port, :ssl => @mailbox.ssl_options)
-    end
-
-    # build a handler to process mailbox messages
-    def handler
-      @handler ||= MailboxHandler.new(@mailbox, imap)
+      @connection = nil
     end
 
     # are we running?
@@ -31,133 +21,38 @@ module MailRoom
       @running
     end
 
-    # is the connection logged in?
-    # @return [Boolean]
-    def logged_in?
-      @logged_in
-    end
-
-    # is the connection blocked idling?
-    # @return [Boolean]
-    def idling?
-      @idling
-    end
-
-    # is the imap connection closed?
-    # @return [Boolean]
-    def disconnected?
-      @imap.disconnected?
-    end
-
-    # is the connection ready to idle?
-    # @return [Boolean]
-    def ready_to_idle?
-      logged_in? && !idling?
-    end
-
-    # is the response for a new message?
-    # @param response [Net::IMAP::TaggedResponse] the imap response from idle
-    # @return [Boolean]
-    def message_exists?(response)
-      response.respond_to?(:name) && response.name == 'EXISTS'
-    end
-
-    # log in and set the mailbox
-    def setup
-      reset
-      start_tls
-      log_in
-      set_mailbox
-    end
-
-    # clear disconnected imap
-    # reset imap state
-    def reset
-      @imap = nil
-      @logged_in = false
-      @idling = false
-    end
-
-    # start a TLS session
-    def start_tls
-      imap.starttls if @mailbox.start_tls
-    end
-
-    # send the imap login command to google
-    def log_in
-      imap.login(@mailbox.email, @mailbox.password)
-      @logged_in = true
-    end
-
-    # select the mailbox name we want to use
-    def set_mailbox
-      imap.select(@mailbox.name) if logged_in?
-    end
-
-    # maintain an imap idle connection
-    def idle
-      return unless ready_to_idle?
-
-      @idling = true
-
-      imap.idle(@mailbox.idle_timeout, &idle_handler)
-    ensure
-      @idling = false
-    end
-
-    # trigger the idle to finish and wait for the thread to finish
-    def stop_idling
-      return unless idling?
-
-      imap.idle_done
-      
-      idling_thread.join
-      self.idling_thread = nil
-    end
-
     # run the mailbox watcher
     def run
-      setup
-
       @running = true
 
-      # prefetch messages before first idle
-      process_mailbox
+      connection.on_new_message do |message|
+        @mailbox.deliver(message)
+      end
 
-      self.idling_thread = Thread.start do
+      self.watching_thread = Thread.start do
         while(running?) do
-          begin
-            # block for idle_timeout until we stop idling
-            idle
-
-            # when new messages are ready
-            process_mailbox
-          rescue Net::IMAP::Error, IOError => e
-            # we've been disconnected, so re-setup
-            setup
-          end
+          connection.wait
         end
       end
 
-      idling_thread.abort_on_exception = true
+      watching_thread.abort_on_exception = true
     end
 
-    # stop running
+    # stop running, cleanup connection
     def quit
       @running = false
-      stop_idling
-      # disconnect
-    end
 
-    # trigger the handler to process this mailbox for new messages
-    def process_mailbox
-      handler.process
+      if @connection
+        @connection.quit
+        @connection = nil
+      end
+
+      watching_thread.join
     end
 
     private
-    # @private
-    def idle_handler
-      lambda {|response| imap.idle_done if message_exists?(response)}
+    def connection
+      @connection ||= Connection.new(@mailbox)
     end
   end
 end

data/lib/mail_room/version.rb

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

data/spec/lib/cli_spec.rb

@@ -14,13 +14,13 @@ describe MailRoom::CLI do
     end
 
     it 'parses arguments into configuration' do
-      MailRoom::CLI.new(args).configuration.should eq(configuration)
-      MailRoom::Configuration.should have_received(:new).with({:config_path => 'a path'})
+      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
-      MailRoom::CLI.new(args).coordinator.should eq(coordinator)
-      MailRoom::Coordinator.should have_received(:new).with(configuration.mailboxes)
+      expect(MailRoom::CLI.new(args).coordinator).to eq(coordinator)
+      expect(MailRoom::Coordinator).to have_received(:new).with(configuration.mailboxes)
     end
   end
 
@@ -35,7 +35,7 @@ describe MailRoom::CLI do
     it 'starts running the coordinator' do
       cli.start
 
-      coordinator.should have_received(:run)
+      expect(coordinator).to have_received(:run)
     end
   end
 end

data/spec/lib/configuration_spec.rb

@@ -9,7 +9,7 @@ describe MailRoom::Configuration do
 
       configuration = MailRoom::Configuration.new(:config_path => config_path)
 
-      configuration.mailboxes.should eq(['mailbox1', 'mailbox2'])
+      expect(configuration.mailboxes).to eq(['mailbox1', 'mailbox2'])
     end
 
     it 'sets mailboxes to an empty set when config_path is missing' do
@@ -17,9 +17,9 @@ describe MailRoom::Configuration do
 
       configuration = MailRoom::Configuration.new
 
-      configuration.mailboxes.should eq([])
+      expect(configuration.mailboxes).to eq([])
 
-      MailRoom::Mailbox.should have_received(:new).never
+      expect(MailRoom::Mailbox).to have_received(:new).never
     end
   end
 end

data/spec/lib/connection_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe MailRoom::Connection do
+  let(:imap) {stub}
+  let(:mailbox) {MailRoom::Mailbox.new(delete_after_delivery: true)}
+
+  before :each do
+    MailRoom::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)
+
+      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])
+    end
+  end
+end

data/spec/lib/coordinator_spec.rb

@@ -7,15 +7,15 @@ describe MailRoom::Coordinator do
 
       coordinator = MailRoom::Coordinator.new(['mailbox1', 'mailbox2'])
 
-      coordinator.watchers.should eq(['watcher1', 'watcher2'])
+      expect(coordinator.watchers).to eq(['watcher1', 'watcher2'])
 
-      MailRoom::MailboxWatcher.should have_received(:new).with('mailbox1')
-      MailRoom::MailboxWatcher.should have_received(:new).with('mailbox2')
+      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([])
-      coordinator.watchers.should eq([])
+      expect(coordinator.watchers).to eq([])
     end
   end
 
@@ -28,8 +28,8 @@ describe MailRoom::Coordinator do
       coordinator = MailRoom::Coordinator.new(['mailbox1'])
       coordinator.stubs(:sleep_while_running)
       coordinator.run
-      watcher.should have_received(:run)
-      watcher.should have_received(:quit)
+      expect(watcher).to have_received(:run)
+      expect(watcher).to have_received(:quit)
     end
     
     it 'should go to sleep after running watchers' do
@@ -37,15 +37,15 @@ describe MailRoom::Coordinator do
       coordinator.stubs(:running=)
       coordinator.stubs(:running?).returns(false)
       coordinator.run
-      coordinator.should have_received(:running=).with(true)
-      coordinator.should have_received(:running?)
+      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
-      coordinator.running.should eq(true)
+      expect(coordinator.running).to eq(true)
     end
   end
 
@@ -55,7 +55,7 @@ describe MailRoom::Coordinator do
       MailRoom::MailboxWatcher.stubs(:new).returns(watcher)
       coordinator = MailRoom::Coordinator.new(['mailbox1'])
       coordinator.quit
-      watcher.should have_received(:quit)
+      expect(watcher).to have_received(:quit)
     end
   end
 end

data/spec/lib/delivery/letter_opener_spec.rb

@@ -15,15 +15,15 @@ describe MailRoom::Delivery::LetterOpener do
     end
 
     it 'creates a new LetterOpener::DeliveryMethod' do
-      ::LetterOpener::DeliveryMethod.should have_received(:new).with(:location => '/tmp/somewhere')
+      expect(::LetterOpener::DeliveryMethod).to have_received(:new).with(:location => '/tmp/somewhere')
     end
 
     it 'parses the message string with Mail' do
-      ::Mail.should have_received(:read_from_string).with('a message')
+      expect(::Mail).to have_received(:read_from_string).with('a message')
     end
 
     it 'delivers the mail message' do
-      delivery_method.should have_received(:deliver!).with(mail)
+      expect(delivery_method).to have_received(:deliver!).with(mail)
     end
   end
 end

data/spec/lib/delivery/logger_spec.rb

@@ -11,7 +11,7 @@ describe MailRoom::Delivery::Logger do
 
         MailRoom::Delivery::Logger.new(mailbox)
 
-        ::Logger.should have_received(:new).with(STDOUT)
+        expect(::Logger).to have_received(:new).with(STDOUT)
       end
     end
 
@@ -25,8 +25,8 @@ describe MailRoom::Delivery::Logger do
 
         MailRoom::Delivery::Logger.new(mailbox)
 
-        File.should have_received(:open).with('/var/log/mail-room.log', 'a')
-        ::Logger.should have_received(:new).with(file)
+        expect(File).to have_received(:open).with('/var/log/mail-room.log', 'a')
+        expect(::Logger).to have_received(:new).with(file)
       end
     end
   end
@@ -40,7 +40,7 @@ describe MailRoom::Delivery::Logger do
 
       MailRoom::Delivery::Logger.new(mailbox).deliver('a message')
 
-      logger.should have_received(:info).with('a message')
+      expect(logger).to have_received(:info).with('a message')
     end
   end
 end

data/spec/lib/delivery/postback_spec.rb

@@ -21,11 +21,11 @@ describe MailRoom::Delivery::Postback do
 
       MailRoom::Delivery::Postback.new(mailbox).deliver('a message')
 
-      connection.should have_received(:token_auth).with('abcdefg')
-      connection.should have_received(:post)
+      expect(connection).to have_received(:token_auth).with('abcdefg')
+      expect(connection).to have_received(:post)
 
-      request.should have_received(:url).with('http://localhost/inbox')
-      request.should have_received(:body=).with('a message')
+      expect(request).to have_received(:url).with('http://localhost/inbox')
+      expect(request).to have_received(:body=).with('a message')
     end
   end
 end

data/spec/lib/mailbox_spec.rb

@@ -12,7 +12,7 @@ describe MailRoom::Mailbox do
 
         mailbox.deliver?(uid)
 
-        noop.should have_received(:deliver?).with(uid)
+        expect(noop).to have_received(:deliver?).with(uid)
       end
     end
 
@@ -26,7 +26,7 @@ describe MailRoom::Mailbox do
         
         mailbox.deliver?(uid)
 
-        redis.should have_received(:deliver?).with(uid)
+        expect(redis).to have_received(:deliver?).with(uid)
       end
     end
 
@@ -38,7 +38,7 @@ describe MailRoom::Mailbox do
 
         mailbox.deliver(stub(:attr => {'RFC822' => 'a message'}))
 
-        noop.should have_received(:deliver).with('a message')
+        expect(noop).to have_received(:deliver).with('a message')
       end
     end
 
@@ -50,7 +50,7 @@ describe MailRoom::Mailbox do
 
         mailbox.deliver(stub(:attr => {'RFC822' => 'a message'}))
 
-        logger.should have_received(:deliver).with('a message')
+        expect(logger).to have_received(:deliver).with('a message')
       end
     end
 
@@ -62,7 +62,7 @@ describe MailRoom::Mailbox do
 
         mailbox.deliver(stub(:attr => {'RFC822' => 'a message'}))
 
-        postback.should have_received(:deliver).with('a message')
+        expect(postback).to have_received(:deliver).with('a message')
       end
     end
 
@@ -74,7 +74,7 @@ describe MailRoom::Mailbox do
 
         mailbox.deliver(stub(:attr => {'RFC822' => 'a message'}))
 
-        letter_opener.should have_received(:deliver).with('a message')
+        expect(letter_opener).to have_received(:deliver).with('a message')
       end
     end
 
@@ -86,7 +86,7 @@ describe MailRoom::Mailbox do
 
         mailbox.deliver(stub(:attr => {'FLAGS' => [:Seen, :Recent]}))
 
-        noop.should have_received(:deliver).never
+        expect(noop).to have_received(:deliver).never
       end
     end
 

data/spec/lib/mailbox_watcher_spec.rb

@@ -6,245 +6,59 @@ describe MailRoom::MailboxWatcher do
   describe '#running?' do
     it 'is false by default' do
       watcher = MailRoom::MailboxWatcher.new(mailbox)
-      watcher.running?.should eq(false)
+      expect(watcher.running?).to eq(false)
     end
   end
 
-  describe '#logged_in?' do
-    it 'is false by default' do
-      watcher = MailRoom::MailboxWatcher.new(mailbox)
-      watcher.logged_in?.should eq(false)
-    end
-  end
-
-  describe '#idling?' do
-    it 'is false by default' do
-      watcher = MailRoom::MailboxWatcher.new(mailbox)
-      watcher.idling?.should eq(false)
-    end
-  end
-
-  describe '#imap' do
-    it 'builds a new Net::IMAP object' do
-      MailRoom::IMAP.stubs(:new).returns('imap')
-
-      MailRoom::MailboxWatcher.new(mailbox).imap.should eq('imap')
-
-      MailRoom::IMAP.should have_received(:new).with('imap.gmail.com', :port => 993, :ssl => true)
-    end
-  end
-
-  describe '#setup' do
+  describe '#run' do
     let(:imap) {stub(:login => true, :select => true)}
-
-    let(:mailbox) {
-      MailRoom::Mailbox.new(:email => 'user1@gmail.com', :password => 'password', :name => 'inbox')
-    }
-
-    let(:watcher) {
-      MailRoom::MailboxWatcher.new(mailbox)
-    }
-
-    it 'logs in and sets the mailbox to watch' do
-      watcher.stubs(:imap).returns(imap)
-
-      watcher.setup
-
-      imap.should have_received(:login).with('user1@gmail.com', 'password')
-      watcher.logged_in?.should eq(true)
-      imap.should have_received(:select).with('inbox')
-    end
-
-    context 'with start_tls configured as true' do
-      before(:each) do
-        mailbox.start_tls = true
-        imap.stubs(:starttls)
-        watcher.stubs(:imap).returns(imap)
-      end
-
-      it 'sets up tls session on imap setup' do
-        watcher.setup
-
-        imap.should have_received(:starttls)
-      end
-    end
-  end
-
-  describe '#idle' do
-    let(:imap) {stub}
     let(:watcher) {MailRoom::MailboxWatcher.new(mailbox)}
 
     before :each do
-      watcher.stubs(:imap).returns(imap)
-    end
-
-    it 'returns if not logged in' do
-      watcher.stubs(:logged_in?).returns(false)
-
-      watcher.idle
-
-      imap.should have_received(:idle).never
-    end
-
-    context "when logged in" do
-      before :each do
-        imap.stubs(:idle_done)
-
-        watcher.stubs(:logged_in?).returns(true)
-      end
-
-      it 'handles any response with a name of EXISTS and stops idling' do
-        response = stub(:name => 'EXISTS')
-        imap.stubs(:idle).yields(response)
-
-        watcher.idle
-
-        imap.should have_received(:idle)
-        imap.should have_received(:idle_done)
-      end
-
-      it 'does not finish idling when response is not EXISTS' do
-        response = stub(:name => 'DESTROY')
-        imap.stubs(:idle).yields(response)
-
-        watcher.idle
-
-        imap.should have_received(:idle)
-        imap.should have_received(:idle_done).never
-      end
+      Net::IMAP.stubs(:new).returns(imap) # prevent connection
     end
-  end
 
-  describe 'process_mailbox' do
-    let(:imap) {stub}
-    let(:mailbox) {MailRoom::Mailbox.new}
-    let(:watcher) {MailRoom::MailboxWatcher.new(mailbox)}
+    it 'loops over wait while running' do
+      connection = MailRoom::Connection.new(mailbox)
+      connection.stubs(:on_new_message)
+      connection.stubs(:wait)
 
-    it 'builds a new mailbox handler if none exists' do
-      MailRoom::MailboxHandler.stubs(:new).returns(stub(:process))
-      watcher.stubs(:imap).returns(imap)
+      MailRoom::Connection.stubs(:new).returns(connection)
 
-      watcher.process_mailbox
-
-      MailRoom::MailboxHandler.should have_received(:new).with(mailbox, imap)
-    end
+      watcher.stubs(:running?).returns(true).then.returns(false)
 
-    it 'processes with the handler' do
-      handler = stub(:process)
-      watcher.stubs(:handler).returns(handler)
-
-      watcher.process_mailbox
-
-      handler.should have_received(:process)
-    end
-  end
-
-  describe '#stop_idling' do
-    let(:imap) {stub}
-    let(:idling_thread) {stub(:abort_on_exception=)}
-    let(:watcher) {MailRoom::MailboxWatcher.new(nil)}
-
-    before :each do
-      watcher.stubs(:imap).returns(imap)
-      watcher.stubs(:idling_thread).returns(idling_thread)
-    end
-
-    it "returns unless imap is idling" do
-      imap.stubs(:idle_done)
-      idling_thread.stubs(:join)
-      watcher.stubs(:idling?).returns(false)
-
-      watcher.stop_idling
-
-      imap.should have_received(:idle_done).never
-      idling_thread.should have_received(:join).never
-    end
+      watcher.run
+      watcher.watching_thread.join # wait for finishing run
 
-    context "when idling" do
-      before :each do
-        imap.stubs(:idle_done)
-        idling_thread.stubs(:join)
-        watcher.stubs(:idling?).returns(true)
-      end
-
-      it 'stops the idle' do
-        watcher.stop_idling
-        imap.should have_received(:idle_done)
-      end
-
-      it 'waits on the idling_thread to finish' do
-        watcher.stop_idling
-        idling_thread.should have_received(:join)
-      end
+      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
 
-  describe '#run' do
+  describe '#quit' do
+    let(:imap) {stub(:login => true, :select => true)}
     let(:watcher) {MailRoom::MailboxWatcher.new(mailbox)}
 
     before :each do
-      Net::IMAP.stubs(:new).returns(stub)
-      Thread.stubs(:start).yields.returns(stub(:abort_on_exception=))
-      watcher.stubs(:setup)
-      watcher.handler.stubs(:process)
-    end
-
-    it 'sets up' do
-      watcher.stubs(:running?).returns(false)
-
-      watcher.run
-
-      watcher.should have_received(:setup)
-    end
-
-    it 'starts a thread for idling' do
-      watcher.stubs(:running?).returns(false)
-
-      watcher.run
-
-      Thread.should have_received(:start)
-    end
-
-    it 'loops while running' do
-      watcher.stubs(:running?).returns(true, false)
-
-      watcher.stubs(:idle)
-
-      watcher.run
-
-      watcher.should have_received(:running?).times(2)
-    end
-
-    it 'idles' do
-      watcher.stubs(:running?).returns(true, false)
-
-      watcher.stubs(:idle)
-
-      watcher.run
-
-      watcher.should have_received(:idle).once
+      Net::IMAP.stubs(:new).returns(imap) # prevent connection
     end
 
-    it 'processes messages' do
-      watcher.stubs(:running?).returns(true, false)
+    it 'closes and waits for the connection' do
+      connection = MailRoom::Connection.new(mailbox)
+      connection.stubs(:wait)
+      connection.stubs(:quit)
 
-      watcher.stubs(:idle)
+      MailRoom::Connection.stubs(:new).returns(connection)
 
       watcher.run
 
-      watcher.handler.should have_received(:process).times(2)
-    end
-  end
-
-  describe '#quit' do
-    let(:watcher) {MailRoom::MailboxWatcher.new(mailbox)}
-
-    it 'stops idling' do
-      watcher.stubs(:stop_idling)
+      expect(watcher.running?).to eq(true)
 
       watcher.quit
 
-      watcher.should have_received(:stop_idling)
+      expect(connection).to have_received(:quit)
+      expect(watcher.running?).to eq(false)
     end
   end
 end

data/spec/spec_helper.rb

@@ -12,7 +12,6 @@ require File.expand_path('../../lib/mail_room', __FILE__)
 
 RSpec.configure do |config|
   config.mock_with :mocha
-  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mail_room
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Tony Pitale
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-30 00:00:00.000000000 Z
+date: 2016-06-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -203,6 +203,7 @@ files:
 - lib/mail_room/backports/imap.rb
 - lib/mail_room/cli.rb
 - lib/mail_room/configuration.rb
+- lib/mail_room/connection.rb
 - lib/mail_room/coordinator.rb
 - lib/mail_room/delivery.rb
 - lib/mail_room/delivery/letter_opener.rb
@@ -212,7 +213,6 @@ files:
 - lib/mail_room/delivery/que.rb
 - lib/mail_room/delivery/sidekiq.rb
 - lib/mail_room/mailbox.rb
-- lib/mail_room/mailbox_handler.rb
 - lib/mail_room/mailbox_watcher.rb
 - lib/mail_room/version.rb
 - mail_room.gemspec
@@ -220,12 +220,12 @@ files:
 - spec/lib/arbitration/redis_spec.rb
 - spec/lib/cli_spec.rb
 - spec/lib/configuration_spec.rb
+- spec/lib/connection_spec.rb
 - spec/lib/coordinator_spec.rb
 - spec/lib/delivery/letter_opener_spec.rb
 - spec/lib/delivery/logger_spec.rb
 - spec/lib/delivery/postback_spec.rb
 - spec/lib/delivery/que_spec.rb
-- spec/lib/mailbox_handler_spec.rb
 - spec/lib/mailbox_spec.rb
 - spec/lib/mailbox_watcher_spec.rb
 - spec/spec_helper.rb
@@ -258,12 +258,12 @@ test_files:
 - spec/lib/arbitration/redis_spec.rb
 - spec/lib/cli_spec.rb
 - spec/lib/configuration_spec.rb
+- spec/lib/connection_spec.rb
 - spec/lib/coordinator_spec.rb
 - spec/lib/delivery/letter_opener_spec.rb
 - spec/lib/delivery/logger_spec.rb
 - spec/lib/delivery/postback_spec.rb
 - spec/lib/delivery/que_spec.rb
-- spec/lib/mailbox_handler_spec.rb
 - spec/lib/mailbox_spec.rb
 - spec/lib/mailbox_watcher_spec.rb
 - spec/spec_helper.rb

data/lib/mail_room/mailbox_handler.rb

@@ -1,59 +0,0 @@
-module MailRoom
-  # Fetches new email messages for delivery
-  # @author Tony Pitale
-  class MailboxHandler
-    # build a handler for this mailbox and our imap connection
-    # @param mailbox [MailRoom::Mailbox] the mailbox configuration
-    # @param imap [Net::IMAP::Connection] the open connection to gmail
-    def initialize(mailbox, imap)
-      @mailbox = mailbox
-      @imap = imap
-    end
-
-    # deliver each of the new messages
-    def process
-      # return if idling? || !running?
-
-      new_messages.each do |message|
-        # loop over delivery methods and deliver each
-        delivered = @mailbox.deliver(message)
-
-        if delivered && @mailbox.delete_after_delivery
-          @imap.store(message.seqno, "+FLAGS", [Net::IMAP::DELETED])
-        end
-      end
-
-      @imap.expunge if @mailbox.delete_after_delivery
-    end
-
-    private
-    # @private
-    # fetch all messages for the new message ids
-    def new_messages
-      # Both of these calls may results in
-      #   imap raising an EOFError, we handle
-      #   this exception in the watcher
-      messages_for_ids(new_message_ids)
-    end
-
-    # TODO: label messages?
-    #   @imap.store(id, "+X-GM-LABELS", [label])
-
-    # @private
-    # search for all new (unseen) message ids
-    # @return [Array<Integer>] message ids
-    def new_message_ids
-      @imap.uid_search(@mailbox.search_command).select { |uid| @mailbox.deliver?(uid) }
-    end
-
-    # @private
-    # fetch the email for all given ids in RFC822 format
-    # @param ids [Array<Integer>] list of message ids
-    # @return [Array<Net::IMAP::FetchData>] the net/imap messages for the given ids
-    def messages_for_ids(uids)
-      return [] if uids.empty?
-
-      @imap.uid_fetch(uids, "RFC822")
-    end
-  end
-end

data/spec/lib/mailbox_handler_spec.rb

@@ -1,57 +0,0 @@
-require 'spec_helper'
-
-describe MailRoom::MailboxHandler do
-  describe 'process mailbox' do
-    let(:imap) {stub}
-    let(:mailbox) {MailRoom::Mailbox.new}
-
-    it 'fetches and delivers all new messages from ids' do
-      imap.stubs(:uid_search).returns([1,2])
-      message1 = stub(:attr => {'RFC822' => 'message1'})
-      message2 = stub(:attr => {'RFC822' => 'message2'})
-      imap.stubs(:uid_fetch).returns([message1, message2])
-      mailbox.stubs(:deliver)
-
-      handler = MailRoom::MailboxHandler.new(mailbox, imap)
-      handler.process
-
-      imap.should have_received(:uid_search).with('UNSEEN')
-      imap.should have_received(:uid_fetch).with([1,2], 'RFC822')
-      mailbox.should have_received(:deliver).with(message1)
-      mailbox.should have_received(:deliver).with(message2)
-    end
-
-    it "fetches and delivers all new messages from ids that haven't been processed yet" do
-      imap.stubs(:uid_search).returns([1,2])
-      message1 = stub(:attr => {'RFC822' => 'message1'})
-      message2 = stub(:attr => {'RFC822' => 'message2'})
-      imap.stubs(:uid_fetch).returns([message2])
-      mailbox.stubs(:deliver)
-      mailbox.stubs(:deliver?).with(1).returns(false)
-      mailbox.stubs(:deliver?).with(2).returns(true)
-
-      handler = MailRoom::MailboxHandler.new(mailbox, imap)
-      handler.process
-
-      imap.should have_received(:uid_search).with('UNSEEN')
-      imap.should have_received(:uid_fetch).with([2], 'RFC822')
-
-      mailbox.should have_received(:deliver).with(message1).never
-      mailbox.should have_received(:deliver).with(message2)
-    end
-
-    it 'returns no messages if there are no ids' do
-      imap.stubs(:uid_search).returns([])
-      imap.stubs(:uid_fetch)
-      mailbox.search_command = 'NEW'
-      mailbox.stubs(:deliver)
-
-      handler = MailRoom::MailboxHandler.new(mailbox, imap)
-      handler.process
-
-      imap.should have_received(:uid_search).with('NEW')
-      imap.should have_received(:uid_fetch).never
-      mailbox.should have_received(:deliver).never
-    end
-  end
-end