mailhandler 1.0.36 → 1.0.37

data/spec/unit/mailhandler/receiving/notification/console_spec.rb

@@ -1,29 +1,19 @@
 require 'spec_helper'
 
 describe MailHandler::Receiving::Notification::Console do
-
-  subject { MailHandler::Receiving::Notification::Console  }
+  subject { MailHandler::Receiving::Notification::Console }
 
   context 'notify of a delay' do
-
     it '.notify' do
-
-      search = double('Search', :started_at => Time.now - 10)
-      expect{ subject.new.notify(search) }.to output(/.+email delay: 0(9|1)0 seconds/).to_stdout
-
+      search = double('Search', started_at: Time.now - 10)
+      expect { subject.new.notify(search) }.to output(/.+email delay: 0(9|1)0 seconds/).to_stdout
     end
-
   end
 
   context 'not notify of a delay' do
-
     it '.notify' do
-
-      search = double('Search', :started_at => Time.now + 5)
-      expect{ subject.new.notify(search) }.to output('').to_stdout
-
+      search = double('Search', started_at: Time.now + 5)
+      expect { subject.new.notify(search) }.to output('').to_stdout
     end
-
   end
-
-end
+end

data/spec/unit/mailhandler/receiving/notification/email/content_spec.rb

@@ -1,105 +1,71 @@
 require 'spec_helper'
 
 describe MailHandler::Receiving::Notification::EmailContent do
-
   subject { MailHandler::Receiving::Notification::EmailContent.new }
 
   let(:to) { 'john@example.com' }
   let(:from) { 'igor@example.com' }
-  let(:options) {{ :test => 'test' } }
+  let(:options) { { test: 'test' } }
 
   context '.email_received' do
-
     it 'create email' do
-
       expect(subject.retrieve(:received, options, 60, from, to)).to be_kind_of Mail::Message
-
     end
 
     context 'email content' do
-
       it 'sender' do
-
         expect(subject.retrieve(:received, options, 60, from, to)[:from].to_s).to eq from
-
       end
 
       it 'single recipient' do
-
         expect(subject.retrieve(:received, options, 60, from, to)[:to].to_s).to eq to
-
       end
 
       it 'multiple recipients' do
-
         to = 'john1@example.com, john2@example.com'
         expect(subject.retrieve(:received, options, 60, from, to)[:to].to_s).to eq to
-
       end
 
       it 'subject - 1 minute delay' do
-
-        expect(subject.retrieve(:received, options, 60, from, to).subject).to eq "Received - delay was 1.0 minutes"
-
+        expect(subject.retrieve(:received, options, 60, from, to).subject).to eq 'Received - delay was 1.0 minutes'
       end
 
       it 'subject - 1.5 minute delay' do
-
-        expect(subject.retrieve(:received, options, 90, from, to).subject).to eq "Received - delay was 1.5 minutes"
-
+        expect(subject.retrieve(:received, options, 90, from, to).subject).to eq 'Received - delay was 1.5 minutes'
       end
 
       it 'body' do
-
-        expect(subject.retrieve(:received, options, 90, from, to).body.to_s).
-            to eq "Received - delay was 1.5 minutes - search by #{options}"
-
+        expect(subject.retrieve(:received, options, 90, from, to).body.to_s)
+          .to eq "Received - delay was 1.5 minutes - search by #{options}"
       end
-
     end
-
   end
 
   context '.email_delayed' do
-
     it 'sender' do
-
       expect(subject.retrieve(:delayed, options, 60, from, to)[:from].to_s).to eq from
-
     end
 
     it 'single recipient' do
-
       expect(subject.retrieve(:delayed, options, 60, from, to)[:to].to_s).to eq to
-
     end
 
     it 'multiple recipients' do
-
       to = 'john1@example.com, john2@example.com'
       expect(subject.retrieve(:delayed, options, 60, from, to)[:to].to_s).to eq to
-
     end
 
     it 'subject - 1 minute delay' do
-
-      expect(subject.retrieve(:delayed, options, 60, from, to).subject).to eq "Over 1.0 minutes delay"
-
+      expect(subject.retrieve(:delayed, options, 60, from, to).subject).to eq 'Over 1.0 minutes delay'
     end
 
     it 'subject - 1.5 minute delay' do
-
-      expect(subject.retrieve(:delayed, options, 90, from, to).subject).to eq "Over 1.5 minutes delay"
-
+      expect(subject.retrieve(:delayed, options, 90, from, to).subject).to eq 'Over 1.5 minutes delay'
     end
 
     it 'body' do
-
-      expect(subject.retrieve(:delayed, options, 90, from, to).body.to_s).
-          to eq "Over 1.5 minutes delay - search by #{options}"
-
+      expect(subject.retrieve(:delayed, options, 90, from, to).body.to_s)
+        .to eq "Over 1.5 minutes delay - search by #{options}"
     end
-
   end
-
-end
+end

data/spec/unit/mailhandler/receiving/notification/email_spec.rb

@@ -1,10 +1,9 @@
 require 'spec_helper'
 
 describe MailHandler::Receiving::Notification::Email do
-
   let(:search) { double('search') }
   let(:sender) { double('sender') }
-  let(:notification) { MailHandler::Receiving::Notification::Email.new(sender, 'from@example.com', 'igor@example.com',1) }
+  let(:notification) { MailHandler::Receiving::Notification::Email.new(sender, 'from@example.com', 'igor@example.com', 1) }
 
   before(:each) do
     allow(sender).to receive(:send_email) { true }
@@ -12,14 +11,12 @@ describe MailHandler::Receiving::Notification::Email do
   end
 
   it '.create' do
-
-    aggregate_failures "init details" do
+    aggregate_failures 'init details' do
       expect(notification.min_time_to_notify).to eq 1
       expect(notification.max_time_to_notify).to eq nil
       expect(notification.contacts).to eq 'igor@example.com'
       expect(notification.sender).to eq sender
     end
-
   end
 
   it '.notify' do
@@ -29,7 +26,6 @@ describe MailHandler::Receiving::Notification::Email do
   end
 
   context 'states' do
-
     it 'no delay' do
       allow(search).to receive(:started_at) { Time.now }
       notification.notify(search)
@@ -37,29 +33,27 @@ describe MailHandler::Receiving::Notification::Email do
     end
 
     it 'delayed' do
-      allow(search).to receive(:started_at) { Time.now - 2}
+      allow(search).to receive(:started_at) { Time.now - 2 }
       allow(search).to receive(:result) { false }
-      allow(notification).to receive(:send_email) { }
+      allow(notification).to receive(:send_email) {}
       notification.notify(search)
       expect(notification.current_state).to be_kind_of MailHandler::Receiving::Notification::Delay
     end
 
     it 'received' do
-      allow(search).to receive(:started_at) { Time.now - 2}
+      allow(search).to receive(:started_at) { Time.now - 2 }
       allow(search).to receive(:result) { true }
-      allow(notification).to receive(:send_email) { }
+      allow(notification).to receive(:send_email) {}
       notification.notify(search)
       expect(notification.current_state).to be_kind_of MailHandler::Receiving::Notification::Received
     end
 
     it 'max delayed' do
-      allow(search).to receive(:started_at) { Time.now - 10}
+      allow(search).to receive(:started_at) { Time.now - 10 }
       allow(search).to receive(:result) { false }
-      allow(notification).to receive(:send_email) { }
+      allow(notification).to receive(:send_email) {}
       notification.notify(search)
       expect(notification.current_state).to be_kind_of MailHandler::Receiving::Notification::MaxDelay
     end
-
   end
-
-end
+end

data/spec/unit/mailhandler/sender_spec.rb

@@ -1,60 +1,49 @@
 require 'spec_helper'
 
 describe MailHandler::Sender do
-
   subject { MailHandler::Sender }
 
   let(:send_duration) { 3 }
-  let(:dispatcher) {
+  let(:dispatcher) do
     dispatcher = double('Dispatcher')
 
-    allow(dispatcher).to receive(:send) { sleep send_duration ; 'Sent' }
+    allow(dispatcher).to receive(:send) { sleep send_duration; 'Sent' }
     dispatcher
-
-  }
-  let(:mail) {
-
+  end
+  let(:mail) do
     Mail.new do
-      from "sheldon@bigbangtheory.com"
-      to "lenard@bigbangtheory.com"
-      subject "Hello!"
-      body "Hello Sheldon!"
+      from 'sheldon@bigbangtheory.com'
+      to 'lenard@bigbangtheory.com'
+      subject 'Hello!'
+      body 'Hello Sheldon!'
     end
-
-  }
+  end
 
   let(:sender) { subject.new(dispatcher) }
 
   it 'create' do
-
     expect(sender).not_to be nil
-
   end
 
   it 'init details' do
-
-    aggregate_failures "sending details" do
+    aggregate_failures 'sending details' do
       expect(sender.sending.started_at).to be nil
       expect(sender.sending.finished_at).to be nil
       expect(sender.sending.duration).to be nil
       expect(sender.sending.response).to be nil
       expect(sender.sending.email).to be nil
     end
-
   end
 
   it '.send_email' do
-
     sender.send_email(mail)
 
-    aggregate_failures "sending details" do
+    aggregate_failures 'sending details' do
       expect(sender.sending.started_at).to be_within(1).of(Time.now - send_duration)
       expect(sender.sending.finished_at).to be_within(1).of(Time.now)
       expect(sender.sending.duration).to be_within(0.5).of(send_duration)
       expect(sender.sending.response).to eq 'Sent'
       expect(sender.sending.email).to be mail
     end
-
   end
-
-end
+end

data/spec/unit/mailhandler/sending/sender_api_batch_spec.rb

@@ -1,49 +1,37 @@
 require 'spec_helper'
 
 describe MailHandler::Sending::PostmarkBatchAPISender do
-
   subject { MailHandler::Sending::PostmarkBatchAPISender }
 
   let(:api_token) { '122878782' }
 
   it 'create' do
-
     sender = subject.new(api_token)
 
-    aggregate_failures "init details" do
+    aggregate_failures 'init details' do
       expect(sender.api_token).to eq api_token
       expect(sender.type).to eq :postmark_api
       expect(sender.use_ssl).to be false
       expect(sender.host).to eq 'api.postmarkapp.com'
     end
-
   end
 
   it '.send - invalid auth' do
-
     sender = subject.new(api_token)
-    expect{sender.send([Mail.new])}.to raise_error Postmark::InvalidApiKeyError
-
+    expect { sender.send([Mail.new]) }.to raise_error Postmark::InvalidApiKeyError
   end
 
   context 'invalid sending object' do
-
     it '.send with string parameter' do
-
       sender = subject.new(api_token)
-      expect{sender.send('test')}.
-          to raise_error MailHandler::TypeError, 'Invalid type error, only Array of Mail::Message object types for sending allowed'
-
+      expect { sender.send('test') }
+        .to raise_error MailHandler::TypeError, 'Invalid type error, only Array of Mail::Message object types for sending allowed'
     end
 
     it '.send with incorrect array parameter' do
-
       sender = subject.new(api_token)
-      expect{sender.send([1,2,2])}.
-          to raise_error MailHandler::TypeError, 'Invalid type error, only Array of Mail::Message object types for sending allowed'
-
+      expect { sender.send([1, 2, 2]) }
+        .to raise_error MailHandler::TypeError, 'Invalid type error, only Array of Mail::Message object types for sending allowed'
     end
-
   end
-
-end
+end

data/spec/unit/mailhandler/sending/sender_api_spec.rb

@@ -1,40 +1,30 @@
 require 'spec_helper'
 
 describe MailHandler::Sending::PostmarkAPISender do
-
   subject { MailHandler::Sending::PostmarkAPISender }
 
   let(:api_token) { '122878782' }
 
   it 'create' do
-
     sender = subject.new(api_token)
 
-    aggregate_failures "init details" do
+    aggregate_failures 'init details' do
       expect(sender.api_token).to eq api_token
       expect(sender.type).to eq :postmark_api
       expect(sender.use_ssl).to be false
       expect(sender.host).to eq 'api.postmarkapp.com'
     end
-
   end
 
   it '.send - invalid auth' do
-
     sender = subject.new(api_token)
-    expect{sender.send(Mail.new)}.to raise_error Postmark::InvalidApiKeyError
-
+    expect { sender.send(Mail.new) }.to raise_error Postmark::InvalidApiKeyError
   end
 
   context 'invalid sending object' do
-
     it '.send' do
-
       sender = subject.new(api_token)
-      expect{sender.send('test')}.to raise_error StandardError
-
+      expect { sender.send('test') }.to raise_error StandardError
     end
-
   end
-
-end
+end

data/spec/unit/mailhandler/sending/sender_smtp_spec.rb

@@ -1,22 +1,40 @@
 require 'spec_helper'
 
 describe MailHandler::Sending::SMTPSender do
-
   subject { MailHandler::Sending::SMTPSender }
 
   context '.send' do
-
     context 'invalid' do
-
       it 'incorrect mail type' do
-
         sender = subject.new
         expect { sender.send('Test') }.to raise_error MailHandler::TypeError
+      end
+    end
+  end
+
+  context '.new' do
+    context 'smtp timeouts' do
+      it 'open' do
+        sender = subject.new
+        expect(sender.open_timeout).to be > 0
+      end
 
+      it 'read' do
+        sender = subject.new
+        expect(sender.read_timeout).to be > 0
       end
+    end
 
+    it 'save response' do
+      expect(subject.new.save_response).to be false
     end
 
-  end
+    it 'use ssl' do
+      expect(subject.new.use_ssl).to be false
+    end
 
-end
+    it 'authentication' do
+      expect(subject.new.authentication).to eq 'plain'
+    end
+  end
+end

data/spec/unit/mailhandler_spec.rb

@@ -1,59 +1,67 @@
 require 'spec_helper'
 
 describe MailHandler::Handler do
-
   subject { MailHandler::Handler.new }
 
   context 'receiver' do
-
     it 'create - invalid type' do
-
-      expect { subject.init_receiver(:test) }.
-          to raise_error(MailHandler::TypeError, 'Unknown type - test, possible options: [:folder, :imap].')
-
+      expect { subject.init_receiver(:test) }
+        .to raise_error(MailHandler::TypeError, 'Unknown type - test, possible options: [:folder, :imap].')
     end
 
     it 'create - folder' do
-
       expect(subject.init_receiver(:folder)).to be_kind_of MailHandler::Receiver
-
     end
 
     it 'create - imap' do
-
       expect(subject.init_receiver(:imap)).to be_kind_of MailHandler::Receiver
-
     end
-
   end
 
   context 'init_sender' do
-
     it 'create - invalid type' do
-
-      expect { subject.init_sender(:test) }.
-          to raise_error(MailHandler::TypeError, 'Unknown type - test, possible options: [:postmark_api, :postmark_batch_api, :smtp].')
-
+      expect { subject.init_sender(:test) }
+        .to raise_error(MailHandler::TypeError, 'Unknown type - test, possible options: [:postmark_api, :postmark_batch_api, :smtp].')
     end
 
     it 'create - postmark api' do
-
       expect(subject.init_sender(:postmark_api)).to be_kind_of MailHandler::Sender
-
     end
 
     it 'create - postmark batch api' do
-
       expect(subject.init_sender(:postmark_batch_api)).to be_kind_of MailHandler::Sender
-
     end
 
-    it 'create - smtp' do
+    context 'smtp' do
+      it 'create - smtp' do
+        expect(subject.init_sender(:smtp)).to be_kind_of MailHandler::Sender
+      end
 
-      expect(subject.init_sender(:smtp)).to be_kind_of MailHandler::Sender
+      context 'set delivery methods' do
+        it 'save response' do
+          sender = MailHandler.sender(:smtp) do |dispatcher|
+            dispatcher.save_response = true
+          end
 
-    end
+          expect(sender.dispatcher.save_response).to be true
+        end
 
-  end
+        it 'open timeout' do
+          sender = MailHandler.sender(:smtp) do |dispatcher|
+            dispatcher.open_timeout = 30
+          end
+
+          expect(sender.dispatcher.open_timeout).to be 30
+        end
+
+        it 'read timeout' do
+          sender = MailHandler.sender(:smtp) do |dispatcher|
+            dispatcher.read_timeout = 30
+          end
 
-end
+          expect(sender.dispatcher.read_timeout).to be 30
+        end
+      end
+    end
+  end
+end