mailhandler 1.0.38 → 1.0.39

data/spec/unit/mailhandler/receiving/folder_spec.rb

@@ -1,15 +1,14 @@
-
 require 'spec_helper'
 
 describe MailHandler::Receiving::FolderChecker do
-  subject { MailHandler::Receiving::FolderChecker.new }
+  subject(:folder_checker) { described_class.new }
 
   it '.create' do
-    is_expected.to be_kind_of MailHandler::Receiving::Checker
+    expect(folder_checker).to be_kind_of MailHandler::Receiving::Checker
   end
 
   context 'search emails' do
-    let(:checker) { MailHandler::Receiving::FolderChecker.new(data_folder, data_folder) }
+    let(:checker) { described_class.new(data_folder, data_folder) }
 
     context '.find email' do
       context 'search options' do
@@ -81,7 +80,7 @@ describe MailHandler::Receiving::FolderChecker do
           expect(checker.find(by_subject: 'test123')).to be false
         end
 
-        it 'by subject' do
+        it 'by folder_checker' do
           checker.find(by_subject: 'test123')
           expect(checker.found_emails).to be_empty
         end
@@ -121,7 +120,7 @@ describe MailHandler::Receiving::FolderChecker do
           expect(checker.find(by_subject: mail1.subject)).to be true
         end
 
-        it 'by subject - single' do
+        it 'by folder_checker - single' do
           checker.find(by_subject: mail1.subject)
 
           aggregate_failures 'found mail details' do
@@ -136,7 +135,7 @@ describe MailHandler::Receiving::FolderChecker do
           expect(checker.found_emails.size).to be 1
         end
 
-        it 'by subject - multiple' do
+        it 'by folder_checker - multiple' do
           checker.find(by_subject: 'test')
 
           aggregate_failures 'found mail details' do
@@ -156,22 +155,26 @@ describe MailHandler::Receiving::FolderChecker do
           expect(checker.found_emails.size).to be 4
         end
 
-        it 'by recipient' do
-          checker.find(by_recipient: { to: 'igor1@example.com' })
-          expect(checker.found_emails.size).to be 1
+        context 'by recipient' do
+          it 'check by one recipient' do
+            checker.find(by_recipient: { to: 'igor1@example.com' })
+            expect(checker.found_emails.size).to be 1
+          end
 
-          checker.find(by_recipient: { to: 'igor2@example.com' })
-          expect(checker.found_emails.size).to be 1
+          it 'check by other recipient' do
+            checker.find(by_recipient: { to: 'igor2@example.com' })
+            expect(checker.found_emails.size).to be 1
+          end
         end
 
         context 'unicode' do
-          it 'by subject - cyrillic' do
+          it 'by folder_checker - cyrillic' do
             skip
             checker.find(by_subject: 'Е-маил пример')
             expect(checker.found_emails.size).to be 1
           end
 
-          it 'by subject - german' do
+          it 'by folder_checker - german' do
             skip
             checker.find(by_subject: 'möglich')
             expect(checker.found_emails.size).to be 1
@@ -179,11 +182,11 @@ describe MailHandler::Receiving::FolderChecker do
         end
 
         context 'archiving emails' do
-          before(:each) do
+          before do
             FileUtils.mkdir "#{data_folder}/checked" unless Dir.exist? "#{data_folder}/checked"
           end
 
-          after(:each) do
+          after do
             FileUtils.rm_r "#{data_folder}/checked", force: false if Dir.exist? data_folder.to_s
           end
 
@@ -194,22 +197,32 @@ describe MailHandler::Receiving::FolderChecker do
             mail
           end
 
-          let(:checker_archive) { MailHandler::Receiving::FolderChecker.new(data_folder, "#{data_folder}/checked") }
+          let(:checker_archive) { described_class.new(data_folder, "#{data_folder}/checked") }
 
-          it 'to same folder - delete' do
-            checker.find(by_subject: mail.subject, archive: true)
-            expect(checker.found_emails.size).to be 1
+          context 'to same folder' do
+            it 'delete' do
+              checker.find(by_subject: mail.subject, archive: true)
+              expect(checker.found_emails.size).to be 1
+            end
 
-            checker.find(by_subject: mail.subject, archive: true)
-            expect(checker.found_emails).to be_empty
+            it 'delete all' do
+              checker.find(by_subject: mail.subject, archive: true)
+              checker.find(by_subject: mail.subject, archive: true)
+              expect(checker.found_emails).to be_empty
+            end
           end
 
-          it 'to separate folder' do
-            checker_archive.find(by_subject: mail.subject, archive: true)
-            expect(checker_archive.found_emails.size).to be 1
+          context 'to separate folder' do
+            it 'delete' do
+              checker_archive.find(by_subject: mail.subject, archive: true)
+              expect(checker_archive.found_emails.size).to be 1
+            end
 
-            checker_archive.find(by_subject: mail.subject, archive: true)
-            expect(checker_archive.found_emails).to be_empty
+            it 'delete all' do
+              checker_archive.find(by_subject: mail.subject, archive: true)
+              checker_archive.find(by_subject: mail.subject, archive: true)
+              expect(checker_archive.found_emails).to be_empty
+            end
           end
         end
       end
@@ -218,12 +231,12 @@ describe MailHandler::Receiving::FolderChecker do
 
   context 'invalid folders' do
     it 'inbox folder' do
-      checker = MailHandler::Receiving::FolderChecker.new('test', data_folder)
+      checker = described_class.new('test', data_folder)
       expect { checker.find count: 1 }.to raise_error MailHandler::FileError
     end
 
     it 'archive folder' do
-      checker = MailHandler::Receiving::FolderChecker.new(data_folder, 'test')
+      checker = described_class.new(data_folder, 'test')
       expect { checker.find count: 1 }.to raise_error MailHandler::FileError
     end
   end

data/spec/unit/mailhandler/receiving/imap_spec.rb

@@ -1,8 +1,7 @@
-
 require 'spec_helper'
 
 describe MailHandler::Receiving::IMAPChecker do
-  let(:checker) { MailHandler::Receiving::IMAPChecker.new }
+  let(:checker) { described_class.new }
 
   it '.create' do
     expect(checker).to be_kind_of MailHandler::Receiving::Checker
@@ -13,9 +12,9 @@ describe MailHandler::Receiving::IMAPChecker do
   end
 
   context 'search options' do
-    before(:each) do
-      allow(checker).to receive(:init_retriever) { true }
-      allow(checker).to receive(:find_emails) { [] }
+    before do
+      allow(checker).to receive(:init_retriever).and_return(true)
+      allow(checker).to receive(:find_emails).and_return([])
     end
 
     it 'by multiple search options' do

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

@@ -1,19 +1,19 @@
 require 'spec_helper'
 
 describe MailHandler::Receiving::Notification::Console do
-  subject { MailHandler::Receiving::Notification::Console }
+  subject(:notification_console) { described_class }
 
   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 = instance_double('Search', started_at: Time.now - 10)
+      expect { notification_console.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 = instance_double('Search', started_at: Time.now + 5)
+      expect { notification_console.new.notify(search) }.to output('').to_stdout
     end
   end
 end

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe MailHandler::Receiving::Notification::EmailContent do
-  subject { MailHandler::Receiving::Notification::EmailContent.new }
+  subject(:notification_email_content) { described_class.new }
 
   let(:to) { 'john@example.com' }
   let(:from) { 'igor@example.com' }
@@ -9,33 +9,35 @@ describe MailHandler::Receiving::Notification::EmailContent do
 
   context '.email_received' do
     it 'create email' do
-      expect(subject.retrieve(:received, options, 60, from, to)).to be_kind_of Mail::Message
+      expect(notification_email_content.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
+        expect(notification_email_content.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
+        expect(notification_email_content.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
+        expect(notification_email_content.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'
+      it 'notification_email_content - 1 minute delay' do
+        expect(notification_email_content.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'
+      it 'notification_email_content - 1.5 minute delay' do
+        expect(notification_email_content.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)
+        expect(notification_email_content.retrieve(:received, options, 90, from, to).body.to_s)
           .to eq "Received - delay was 1.5 minutes - search by #{options}"
       end
     end
@@ -43,28 +45,30 @@ describe MailHandler::Receiving::Notification::EmailContent do
 
   context '.email_delayed' do
     it 'sender' do
-      expect(subject.retrieve(:delayed, options, 60, from, to)[:from].to_s).to eq from
+      expect(notification_email_content.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
+      expect(notification_email_content.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
+      expect(notification_email_content.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'
+    it 'notification_email_content - 1 minute delay' do
+      expect(notification_email_content.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'
+    it 'notification_email_content - 1.5 minute delay' do
+      expect(notification_email_content.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)
+      expect(notification_email_content.retrieve(:delayed, options, 90, from, to).body.to_s)
         .to eq "Over 1.5 minutes delay - search by #{options}"
     end
   end

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

@@ -1,13 +1,13 @@
 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(:search) { instance_double('search') }
+  let(:sender) { instance_double('sender') }
+  let(:notification) { described_class.new(sender, 'from@example.com', 'igor@example.com', 1) }
 
-  before(:each) do
-    allow(sender).to receive(:send_email) { true }
-    allow(search).to receive(:max_duration) { 5 }
+  before do
+    allow(sender).to receive(:send_email).and_return(true)
+    allow(search).to receive(:max_duration).and_return(5)
   end
 
   it '.create' do
@@ -34,24 +34,24 @@ describe MailHandler::Receiving::Notification::Email do
 
     it 'delayed' do
       allow(search).to receive(:started_at) { Time.now - 2 }
-      allow(search).to receive(:result) { false }
-      allow(notification).to receive(:send_email) {}
+      allow(search).to receive(:result).and_return(false)
+      allow(notification).to receive(:send_email).and_return(nil)
       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(:result) { true }
-      allow(notification).to receive(:send_email) {}
+      allow(search).to receive(:result).and_return(true)
+      allow(notification).to receive(:send_email).and_return(nil)
       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(:result) { false }
-      allow(notification).to receive(:send_email) {}
+      allow(search).to receive(:result).and_return(false)
+      allow(notification).to receive(:send_email).and_return(nil)
       notification.notify(search)
       expect(notification.current_state).to be_kind_of MailHandler::Receiving::Notification::MaxDelay
     end

data/spec/unit/mailhandler/sender_spec.rb

@@ -1,13 +1,17 @@
 require 'spec_helper'
 
 describe MailHandler::Sender do
-  subject { MailHandler::Sender }
+  subject { described_class }
 
   let(:send_duration) { 3 }
   let(:dispatcher) do
-    dispatcher = double('Dispatcher')
+    dispatcher = instance_double('Dispatcher')
+
+    allow(dispatcher).to receive(:send) do
+      sleep send_duration
+      'Sent'
+    end
 
-    allow(dispatcher).to receive(:send) { sleep send_duration; 'Sent' }
     dispatcher
   end
   let(:mail) do

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

@@ -1,12 +1,12 @@
 require 'spec_helper'
 
 describe MailHandler::Sending::PostmarkBatchAPISender do
-  subject { MailHandler::Sending::PostmarkBatchAPISender }
+  subject(:postmark_api_batch_sender) { described_class }
 
   let(:api_token) { '122878782' }
 
   it 'create' do
-    sender = subject.new(api_token)
+    sender = postmark_api_batch_sender.new(api_token)
 
     aggregate_failures 'init details' do
       expect(sender.api_token).to eq api_token
@@ -17,21 +17,23 @@ describe MailHandler::Sending::PostmarkBatchAPISender do
   end
 
   it '.send - invalid auth' do
-    sender = subject.new(api_token)
+    sender = postmark_api_batch_sender.new(api_token)
     expect { sender.send([Mail.new]) }.to raise_error Postmark::InvalidApiKeyError
   end
 
   context 'invalid sending object' do
+    let(:error_message) { 'Invalid type error, only Array of Mail::Message object types for sending allowed' }
+
     it '.send with string parameter' do
-      sender = subject.new(api_token)
+      sender = postmark_api_batch_sender.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'
+        .to raise_error MailHandler::TypeError, error_message
     end
 
     it '.send with incorrect array parameter' do
-      sender = subject.new(api_token)
+      sender = postmark_api_batch_sender.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'
+        .to raise_error MailHandler::TypeError, error_message
     end
   end
 end

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

@@ -1,12 +1,12 @@
 require 'spec_helper'
 
 describe MailHandler::Sending::PostmarkAPISender do
-  subject { MailHandler::Sending::PostmarkAPISender }
+  subject(:postmark_api_sender) { described_class }
 
   let(:api_token) { '122878782' }
 
   it 'create' do
-    sender = subject.new(api_token)
+    sender = postmark_api_sender.new(api_token)
 
     aggregate_failures 'init details' do
       expect(sender.api_token).to eq api_token
@@ -17,13 +17,13 @@ describe MailHandler::Sending::PostmarkAPISender do
   end
 
   it '.send - invalid auth' do
-    sender = subject.new(api_token)
+    sender = postmark_api_sender.new(api_token)
     expect { sender.send(Mail.new) }.to raise_error Postmark::InvalidApiKeyError
   end
 
   context 'invalid sending object' do
     it '.send' do
-      sender = subject.new(api_token)
+      sender = postmark_api_sender.new(api_token)
       expect { sender.send('test') }.to raise_error StandardError
     end
   end

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

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