mail_daemon 0.1.0 → 1.0.0

data/spec/mail_daemon/helpers_spec.rb

@@ -0,0 +1,144 @@
+require 'spec_helper'
+
+RSpec.describe MailDaemon::Helpers do
+  let(:test_class) do
+    Class.new do
+      include MailDaemon::Helpers
+    end
+  end
+
+  let(:instance) { test_class.new }
+
+  describe '#setup_options' do
+    it 'converts string keys to symbols' do
+      options = { 'key1' => 'value1', 'key2' => 'value2' }
+      instance.setup_options(options)
+
+      expect(instance.instance_variable_get(:@options)).to eq(
+        key1: 'value1',
+        key2: 'value2'
+      )
+    end
+
+    it 'preserves symbol keys' do
+      options = { key1: 'value1', key2: 'value2' }
+      instance.setup_options(options)
+
+      expect(instance.instance_variable_get(:@options)).to eq(
+        key1: 'value1',
+        key2: 'value2'
+      )
+    end
+
+    it 'handles mixed string and symbol keys' do
+      options = { 'string_key' => 'value1', symbol_key: 'value2' }
+      instance.setup_options(options)
+
+      expect(instance.instance_variable_get(:@options)).to include(
+        string_key: 'value1',
+        symbol_key: 'value2'
+      )
+    end
+
+    it 'handles empty hash' do
+      instance.setup_options({})
+      expect(instance.instance_variable_get(:@options)).to eq({})
+    end
+  end
+
+  describe '#reload_options' do
+    it 'merges new options with existing options' do
+      instance.setup_options({ key1: 'value1' })
+      instance.reload_options({ key2: 'value2' })
+
+      expect(instance.instance_variable_get(:@options)).to eq(
+        key1: 'value1',
+        key2: 'value2'
+      )
+    end
+
+    it 'overwrites existing keys' do
+      instance.setup_options({ key1: 'old_value' })
+      instance.reload_options({ key1: 'new_value' })
+
+      expect(instance.instance_variable_get(:@options)[:key1]).to eq('new_value')
+    end
+
+    it 'handles string keys in reload' do
+      instance.setup_options({ key1: 'value1' })
+      instance.reload_options({ 'key2' => 'value2' })
+
+      expect(instance.instance_variable_get(:@options)).to include(
+        key1: 'value1',
+        key2: 'value2'
+      )
+    end
+  end
+
+  describe '#default_option' do
+    it 'sets default value when option does not exist' do
+      instance.setup_options({})
+      instance.default_option(:new_key, 'default_value')
+
+      expect(instance.instance_variable_get(:@options)[:new_key]).to eq('default_value')
+    end
+
+    it 'does not overwrite existing option' do
+      instance.setup_options({ existing_key: 'existing_value' })
+      instance.default_option(:existing_key, 'default_value')
+
+      expect(instance.instance_variable_get(:@options)[:existing_key]).to eq('existing_value')
+    end
+
+    it 'handles string name' do
+      instance.setup_options({})
+      instance.default_option('string_key', 'value')
+
+      expect(instance.instance_variable_get(:@options)[:string_key]).to eq('value')
+    end
+
+    it 'handles symbol name' do
+      instance.setup_options({})
+      instance.default_option(:symbol_key, 'value')
+
+      expect(instance.instance_variable_get(:@options)[:symbol_key]).to eq('value')
+    end
+  end
+
+  describe '#required_option' do
+    it 'does not raise when required option exists' do
+      instance.setup_options({ required_key: 'value' })
+      expect { instance.required_option(:required_key) }.not_to raise_error
+    end
+
+    it 'raises error when required option is missing' do
+      instance.setup_options({})
+      expect { instance.required_option(:missing_key) }.to raise_error(/missing_key is a required option/)
+    end
+
+    it 'handles string name' do
+      instance.setup_options({ 'string_key' => 'value' })
+      expect { instance.required_option('string_key') }.not_to raise_error
+    end
+
+    it 'handles multiple required options' do
+      instance.setup_options({ key1: 'value1', key2: 'value2' })
+      expect { instance.required_option([:key1, :key2]) }.not_to raise_error
+    end
+
+    it 'raises error when any required option is missing' do
+      instance.setup_options({ key1: 'value1' })
+      expect { instance.required_option([:key1, :missing_key]) }.to raise_error(/missing_key is a required option/)
+    end
+
+    it 'handles single option as array' do
+      instance.setup_options({ key1: 'value1' })
+      expect { instance.required_option([:key1]) }.not_to raise_error
+    end
+
+    it 'handles single option as symbol' do
+      instance.setup_options({ key1: 'value1' })
+      expect { instance.required_option(:key1) }.not_to raise_error
+    end
+  end
+end

data/spec/mail_daemon/imap/connection_spec.rb

@@ -0,0 +1,306 @@
+require 'spec_helper'
+
+RSpec.describe MailDaemon::Imap::Connection do
+  let(:options) do
+    {
+      host: 'imap.example.com',
+      username: 'user@example.com',
+      password: 'password',
+      port: 993,
+      ssl: true,
+      folder: 'inbox',
+      search_command: 'UNSEEN',
+      debug: false
+    }
+  end
+
+  let(:imap_mock) { instance_double(Net::IMAP) }
+  let(:status_block) { proc { |status| } }
+
+  describe '#initialize' do
+    it 'sets up options' do
+      connection = described_class.new(options, &status_block)
+      expect(connection.instance_variable_get(:@options)).to include(
+        host: 'imap.example.com',
+        username: 'user@example.com',
+        password: 'password'
+      )
+    end
+
+    it 'requires host option' do
+      expect { described_class.new({ username: 'user', password: 'pass' }, &status_block) }.to raise_error(/host is a required option/)
+    end
+
+    it 'requires username option' do
+      expect { described_class.new({ host: 'host', password: 'pass' }, &status_block) }.to raise_error(/username is a required option/)
+    end
+
+    it 'requires password option' do
+      expect { described_class.new({ host: 'host', username: 'user' }, &status_block) }.to raise_error(/password is a required option/)
+    end
+
+    it 'defaults port to 143' do
+      # Remove port from options to test default
+      opts = options.dup
+      opts.delete(:port)
+      connection = described_class.new(opts, &status_block)
+      expect(connection.instance_variable_get(:@options)[:port]).to eq(143)
+    end
+
+    it 'defaults folder to inbox' do
+      connection = described_class.new(options, &status_block)
+      expect(connection.instance_variable_get(:@options)[:folder]).to eq('inbox')
+    end
+
+    it 'defaults ssl to false' do
+      # Remove ssl from options to test default
+      opts = options.dup
+      opts.delete(:ssl)
+      connection = described_class.new(opts, &status_block)
+      expect(connection.instance_variable_get(:@options)[:ssl]).to eq(false)
+    end
+
+    it 'defaults sleep_time to 30' do
+      connection = described_class.new(options, &status_block)
+      expect(connection.instance_variable_get(:@options)[:sleep_time]).to eq(30)
+    end
+
+    it 'sets initial status to INITIALIZING' do
+      connection = described_class.new(options, &status_block)
+      expect(connection.status[:status]).to eq(MailDaemon::Imap::Statuses::INITIALIZING)
+    end
+  end
+
+  describe '#login' do
+    before do
+      allow(Net::IMAP).to receive(:new).and_return(imap_mock)
+      allow(imap_mock).to receive(:capability).and_return(['IDLE', 'IMAP4rev1'])
+      allow(imap_mock).to receive(:login)
+      allow(imap_mock).to receive(:select)
+      allow(imap_mock).to receive(:disconnected?).and_return(false)
+    end
+
+    it 'creates IMAP connection' do
+      connection = described_class.new(options, &status_block)
+      # ssl_options defaults to false, so ssl: false is expected
+      expect(Net::IMAP).to receive(:new).with('imap.example.com', port: 993, ssl: false).and_return(imap_mock)
+      connection.login
+    end
+
+    it 'checks for IDLE capability' do
+      connection = described_class.new(options, &status_block)
+      expect(imap_mock).to receive(:capability)
+      connection.login
+    end
+
+    it 'sets idle_available when IDLE is supported' do
+      connection = described_class.new(options, &status_block)
+      connection.login
+      expect(connection.instance_variable_get(:@idle_available)).to be true
+    end
+
+    it 'sets idle_available to false when IDLE is not supported' do
+      allow(imap_mock).to receive(:capability).and_return(['IMAP4rev1'])
+      connection = described_class.new(options, &status_block)
+      connection.login
+      expect(connection.instance_variable_get(:@idle_available)).to be false
+    end
+
+    it 'logs in with username and password' do
+      connection = described_class.new(options, &status_block)
+      expect(imap_mock).to receive(:login).with('user@example.com', 'password')
+      connection.login
+    end
+
+    it 'selects the inbox folder' do
+      connection = described_class.new(options, &status_block)
+      expect(imap_mock).to receive(:select).with('INBOX')
+      connection.login
+    end
+
+    it 'sets status to LOGGED_ON after successful login' do
+      connection = described_class.new(options, &status_block)
+      connection.login
+      expect(connection.status[:status]).to eq(MailDaemon::Imap::Statuses::LOGGED_ON)
+    end
+
+    it 'uses SSL options when provided' do
+      ssl_options = { verify_mode: OpenSSL::SSL::VERIFY_NONE }
+      opts = options.merge(ssl_options: ssl_options)
+      connection = described_class.new(opts, &status_block)
+      expect(Net::IMAP).to receive(:new).with('imap.example.com', port: 993, ssl: ssl_options).and_return(imap_mock)
+      connection.login
+    end
+  end
+
+  describe '#wait_for_messages' do
+    before do
+      allow(Net::IMAP).to receive(:new).and_return(imap_mock)
+      allow(imap_mock).to receive(:capability).and_return(['IDLE', 'IMAP4rev1'])
+      allow(imap_mock).to receive(:login)
+      allow(imap_mock).to receive(:select)
+      allow(imap_mock).to receive(:disconnected?).and_return(false)
+    end
+
+    it 'fetches message IDs using search command' do
+      connection = described_class.new(options, &status_block)
+      connection.login
+
+      # Set idle_required to false BEFORE calling wait_for_messages to prevent infinite loop
+      connection.instance_variable_set(:@idle_required, false)
+      
+      allow(imap_mock).to receive(:uid_search).and_return([1, 2, 3])
+      # Mock the structure: envelope[0][:attr]["RFC822"]
+      fetch_data = { attr: { 'RFC822' => 'message body' } }
+      allow(imap_mock).to receive(:uid_fetch).and_return([fetch_data])
+      
+      # Mock idle to not block - it won't be called since idle_required is false, but just in case
+      allow(imap_mock).to receive(:idle) do |&block|
+        # Don't call the block to prevent blocking
+      end
+
+      expect(imap_mock).to receive(:uid_search).with('UNSEEN').at_least(:once)
+      connection.wait_for_messages { |msg| }
+    end
+
+    it 'yields fetched messages' do
+      connection = described_class.new(options, &status_block)
+      connection.login
+
+      # Set idle_required to false BEFORE calling wait_for_messages to prevent infinite loop
+      connection.instance_variable_set(:@idle_required, false)
+
+      message_body = 'email message content'
+      allow(imap_mock).to receive(:uid_search).and_return([1])
+      # Fix the structure to match what fetch_message expects: envelope[0][:attr]["RFC822"]
+      # The code does: envelope[0][:attr]["RFC822"]
+      # envelope is the return value of uid_fetch, which is an array
+      # envelope[0] is the first element, which should support [:attr] access
+      # envelope[0][:attr] should return a hash with "RFC822" key
+      fetch_data = { attr: { 'RFC822' => message_body } }
+      allow(imap_mock).to receive(:uid_fetch).with(1, ['RFC822']).and_return([fetch_data])
+      
+      # Mock idle to not block (won't be called since idle_required is false)
+      allow(imap_mock).to receive(:idle) do |&block|
+        # Don't call the block to prevent blocking
+      end
+
+      yielded_message = nil
+      connection.wait_for_messages { |msg| yielded_message = msg }
+      
+      expect(yielded_message).to eq(message_body)
+    end
+
+    it 'uses polling mode when IDLE is not available' do
+      allow(imap_mock).to receive(:capability).and_return(['IMAP4rev1'])
+      connection = described_class.new(options, &status_block)
+      connection.login
+
+      # Set idle_required to false BEFORE calling wait_for_messages to prevent infinite loop
+      connection.instance_variable_set(:@idle_required, false)
+      
+      allow(imap_mock).to receive(:uid_search).and_return([])
+
+      expect(imap_mock).to receive(:uid_search).at_least(:once)
+      connection.wait_for_messages { |msg| }
+    end
+  end
+
+  describe '#logout' do
+    before do
+      allow(Net::IMAP).to receive(:new).and_return(imap_mock)
+      allow(imap_mock).to receive(:capability).and_return(['IDLE', 'IMAP4rev1'])
+      allow(imap_mock).to receive(:login)
+      allow(imap_mock).to receive(:select)
+      allow(imap_mock).to receive(:disconnected?).and_return(false)
+      allow(imap_mock).to receive(:logout)
+    end
+
+    it 'logs out from IMAP server' do
+      connection = described_class.new(options, &status_block)
+      connection.login
+      expect(imap_mock).to receive(:logout)
+      connection.logout
+    end
+
+    it 'sets status to LOGGED_OFF' do
+      connection = described_class.new(options, &status_block)
+      connection.login
+      connection.logout
+      expect(connection.status[:status]).to eq(MailDaemon::Imap::Statuses::LOGGED_OFF)
+    end
+
+    it 'does not logout if already disconnected' do
+      connection = described_class.new(options, &status_block)
+      connection.login
+      allow(imap_mock).to receive(:disconnected?).and_return(true)
+      expect(imap_mock).not_to receive(:logout)
+      connection.logout
+    end
+  end
+
+  describe '#disconnect' do
+    before do
+      allow(Net::IMAP).to receive(:new).and_return(imap_mock)
+      allow(imap_mock).to receive(:capability).and_return(['IDLE', 'IMAP4rev1'])
+      allow(imap_mock).to receive(:login)
+      allow(imap_mock).to receive(:select)
+      allow(imap_mock).to receive(:disconnected?).and_return(false)
+      allow(imap_mock).to receive(:logout)
+      allow(imap_mock).to receive(:idle_done)
+      allow(imap_mock).to receive(:disconnect)
+    end
+
+    it 'disconnects from IMAP server' do
+      connection = described_class.new(options, &status_block)
+      connection.login
+      expect(imap_mock).to receive(:disconnect)
+      connection.disconnect
+    end
+
+    it 'sets status to DISCONNECTED' do
+      connection = described_class.new(options, &status_block)
+      connection.login
+      connection.disconnect
+      expect(connection.status[:status]).to eq(MailDaemon::Imap::Statuses::DISCONNECTED)
+    end
+
+    it 'handles errors during disconnect gracefully' do
+      connection = described_class.new(options, &status_block)
+      connection.login
+      allow(imap_mock).to receive(:disconnect).and_raise(StandardError.new('Connection error'))
+      
+      expect { connection.disconnect }.not_to raise_error
+      expect(connection.status[:status]).to eq(MailDaemon::Imap::Statuses::DISCONNECTED)
+    end
+  end
+
+  describe '#running?' do
+    it 'returns false when not connected' do
+      connection = described_class.new(options, &status_block)
+      # @imap is nil until login is called
+      expect(connection.running?).to be false
+    end
+
+    it 'returns true when connected' do
+      allow(Net::IMAP).to receive(:new).and_return(imap_mock)
+      allow(imap_mock).to receive(:capability).and_return(['IDLE', 'IMAP4rev1'])
+      allow(imap_mock).to receive(:login)
+      allow(imap_mock).to receive(:select)
+      allow(imap_mock).to receive(:disconnected?).and_return(false)
+
+      connection = described_class.new(options, &status_block)
+      connection.login
+      expect(connection.running?).to be true
+    end
+  end
+
+  describe '#status' do
+    it 'returns current status' do
+      connection = described_class.new(options, &status_block)
+      status = connection.status
+      expect(status).to have_key(:status)
+      expect(status[:status]).to eq(MailDaemon::Imap::Statuses::INITIALIZING)
+    end
+  end
+end

data/spec/mail_daemon/imap/statuses_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+RSpec.describe MailDaemon::Imap::Statuses do
+  it 'defines INITIALIZING constant' do
+    expect(MailDaemon::Imap::Statuses::INITIALIZING).to eq('initializing')
+  end
+
+  it 'defines CONNECTING constant' do
+    expect(MailDaemon::Imap::Statuses::CONNECTING).to eq('connecting')
+  end
+
+  it 'defines CONNECTED constant' do
+    expect(MailDaemon::Imap::Statuses::CONNECTED).to eq('connected')
+  end
+
+  it 'defines LOGGING_ON constant' do
+    expect(MailDaemon::Imap::Statuses::LOGGING_ON).to eq('logging_on')
+  end
+
+  it 'defines LOGGED_ON constant' do
+    expect(MailDaemon::Imap::Statuses::LOGGED_ON).to eq('logged_on')
+  end
+
+  it 'defines LOGGING_OFF constant' do
+    expect(MailDaemon::Imap::Statuses::LOGGING_OFF).to eq('logging_off')
+  end
+
+  it 'defines LOGGED_OFF constant' do
+    expect(MailDaemon::Imap::Statuses::LOGGED_OFF).to eq('logged_off')
+  end
+
+  it 'defines IDLEING constant' do
+    expect(MailDaemon::Imap::Statuses::IDLEING).to eq('ready')
+  end
+
+  it 'defines POLLING constant' do
+    expect(MailDaemon::Imap::Statuses::POLLING).to eq('ready')
+  end
+
+  it 'defines DISCONNECTING constant' do
+    expect(MailDaemon::Imap::Statuses::DISCONNECTING).to eq('disconnecting')
+  end
+
+  it 'defines DISCONNECTED constant' do
+    expect(MailDaemon::Imap::Statuses::DISCONNECTED).to eq('disconnected')
+  end
+end

data/spec/mail_daemon/imap/watcher_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+RSpec.describe MailDaemon::Imap::Watcher do
+  let(:options) do
+    {
+      host: 'imap.example.com',
+      username: 'user@example.com',
+      password: 'password',
+      account_code: 'test_account',
+      debug: false
+    }
+  end
+
+  describe '#initialize' do
+    it 'sets options' do
+      watcher = described_class.new(options)
+      expect(watcher.instance_variable_get(:@options)).to eq(options)
+    end
+  end
+
+  describe '#start' do
+    let(:connection) { instance_double(MailDaemon::Imap::Connection) }
+
+    it 'creates and logs in to connection' do
+      watcher = described_class.new(options)
+      # Connection.new receives options and a status notification block (the block passed to start)
+      expect(MailDaemon::Imap::Connection).to receive(:new).and_return(connection)
+      expect(connection).to receive(:login)
+      # Mock wait_for_messages to yield once then return to prevent infinite loop
+      # Note: wait_for_messages receives a block that yields messages
+      allow(connection).to receive(:wait_for_messages) do |&message_block|
+        message_block.call('message content') if message_block
+        # Set idle_required to false to exit any loops
+        connection.instance_variable_set(:@idle_required, false) if connection.respond_to?(:instance_variable_set)
+      end
+
+      # Run in a thread with timeout to prevent hanging
+      thread = Thread.new do
+        watcher.start { |msg| }
+      end
+      
+      sleep 0.1
+      thread.kill if thread.alive?
+      thread.join(0.1)
+    end
+
+    it 'yields messages with type and mailbox info' do
+      watcher = described_class.new(options)
+      allow(MailDaemon::Imap::Connection).to receive(:new).and_return(connection)
+      allow(connection).to receive(:login)
+      # Mock wait_for_messages to yield once then return
+      allow(connection).to receive(:wait_for_messages) do |&block|
+        block.call('message content') if block
+        connection.instance_variable_set(:@idle_required, false) if connection.respond_to?(:instance_variable_set)
+      end
+
+      yielded_data = nil
+      
+      thread = Thread.new do
+        watcher.start do |data|
+          yielded_data = data
+        end
+      end
+      
+      sleep 0.1
+      thread.kill if thread.alive?
+      thread.join(0.1)
+
+      expect(yielded_data).to include(
+        type: 'incoming_email',
+        mailbox: options,
+        inbound_message: 'message content'
+      )
+    end
+  end
+
+  describe '#stop' do
+    it 'disconnects the connection' do
+      watcher = described_class.new(options)
+      connection = instance_double(MailDaemon::Imap::Connection)
+      watcher.instance_variable_set(:@connection, connection)
+
+      expect(connection).to receive(:disconnect)
+      watcher.stop
+    end
+  end
+
+  describe '#restart' do
+    it 'stops and starts the connection' do
+      watcher = described_class.new(options)
+      connection = instance_double(MailDaemon::Imap::Connection)
+      watcher.instance_variable_set(:@connection, connection)
+
+      expect(watcher).to receive(:stop)
+      expect(watcher).to receive(:start)
+      watcher.restart
+    end
+  end
+
+  describe '#running?' do
+    it 'returns false when connection is nil' do
+      watcher = described_class.new(options)
+      expect(watcher.running?).to be false
+    end
+
+    it 'delegates to connection running? method' do
+      watcher = described_class.new(options)
+      connection = instance_double(MailDaemon::Imap::Connection, running?: true)
+      watcher.instance_variable_set(:@connection, connection)
+
+      expect(watcher.running?).to be true
+    end
+  end
+
+  describe '#mailbox' do
+    it 'returns mailbox from options' do
+      watcher = described_class.new(options.merge(mailbox: { name: 'inbox' }))
+      expect(watcher.mailbox).to eq({ name: 'inbox' })
+    end
+  end
+
+  describe '#to_s' do
+    it 'returns account_code and username' do
+      watcher = described_class.new(options)
+      expect(watcher.to_s).to eq('test_account/user@example.com')
+    end
+  end
+end