imap_guard 1.0.0 → 2.0.0

data/spec/imap_guard/guard_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
 module ImapGuard
   describe Guard do
@@ -12,21 +12,21 @@ module ImapGuard
 
     let(:settings) do
       {
-        host: 'localhost',
+        host: "localhost",
         port: 993,
-        username: 'bob',
-        password: 'PASS',
+        username: "bob",
+        password: "PASS",
       }
     end
 
     let(:imap) do
-      double('Net::IMAP', search: [7, 28], expunge: nil, select: nil, list: [])
+      instance_double(Net::IMAP, search: [7, 28], expunge: nil, select: nil, list: [])
     end
 
-    def guard_instance custom_settings = {}
+    def guard_instance(custom_settings = {})
       guard = Guard.new(settings.merge(custom_settings))
       guard.instance_variable_set(:@imap, imap)
-      guard.stub(:fetch_mail)
+      allow(guard).to receive(:fetch_mail)
       guard
     end
 
@@ -35,7 +35,7 @@ module ImapGuard
         let(:guard) { guard_instance(read_only: true) }
 
         it "opens the mailbox in read-only" do
-          imap.should_receive(:examine)
+          expect(imap).to receive(:examine)
           guard.select nil
         end
       end
@@ -44,7 +44,7 @@ module ImapGuard
         let(:guard) { guard_instance(read_only: false) }
 
         it "opens the mailbox in read-write" do
-          imap.should_receive(:select)
+          expect(imap).to receive(:select)
           guard.select nil
         end
       end
@@ -52,46 +52,46 @@ module ImapGuard
 
     describe "#mailbox" do
       it "returns nil when no mailbox has been selected" do
-        guard_instance.mailbox.should be_nil
+        expect(guard_instance.mailbox).to be_nil
       end
 
       it "returns the currently selected mailbox" do
         guard = guard_instance
 
-        guard.select 'Sent'
-        guard.mailbox.should eq 'Sent'
+        guard.select "Sent"
+        expect(guard.mailbox).to eq "Sent"
       end
     end
 
     describe "#list" do
       it "returns the list of mailboxes" do
-        imap.should_receive(:list)
-        guard_instance.list.should eq []
+        expect(imap).to receive(:list)
+        expect(guard_instance.list).to eq []
       end
     end
 
     describe "#search" do
       before do
-        imap.should_receive(:search) do |arg|
-          [13, 37] if [['ALL'], 'ALL'].include? arg
+        expect(imap).to receive(:search) do |arg|
+          [13, 37] if [["ALL"], "ALL"].include? arg
         end
       end
 
       it "accepts arrays" do
-        expect {
-          guard_instance.send(:search, ['ALL'])
-        }.to_not raise_error
+        expect do
+          guard_instance.send(:search, ["ALL"])
+        end.not_to raise_error
       end
 
       it "accepts strings" do
-        expect {
-          guard_instance.send(:search, 'ALL')
-        }.to_not raise_error
+        expect do
+          guard_instance.send(:search, "ALL")
+        end.not_to raise_error
       end
 
       it "returns results" do
-        messages = guard_instance.send(:search, 'ALL')
-        messages.should eq [13, 37]
+        messages = guard_instance.send(:search, "ALL")
+        expect(messages).to eq [13, 37]
       end
     end
 
@@ -101,49 +101,49 @@ module ImapGuard
 
       context "without a filter block" do
         it "does perform the operation" do
-          opeartion.should_receive(:call).with(7)
-          opeartion.should_receive(:call).with(28)
+          expect(opeartion).to receive(:call).with(7)
+          expect(opeartion).to receive(:call).with(28)
 
-          guard.send(:process, 'ALL', opeartion)
+          guard.send(:process, "ALL", opeartion)
         end
 
         it "does not execute the filter block" do
-          guard.should_not_receive(:fetch_mail)
+          expect(guard).not_to receive(:fetch_mail)
 
-          guard.send(:process, 'ALL', opeartion)
+          guard.send(:process, "ALL", opeartion)
         end
 
         context "with a debug proc" do
           it "calls the proc" do
             block = ->(mail) {}
             guard.debug = block
-            block.should_receive(:call).twice
+            expect(block).to receive(:call).twice
 
-            guard.send(:process, 'ALL', opeartion)
+            guard.send(:process, "ALL", opeartion)
           end
         end
       end
 
       context "with a filter block" do
         it "executes the filter block" do
-          guard.should_receive(:fetch_mail).twice
+          expect(guard).to receive(:fetch_mail).twice
 
-          guard.send(:process, 'ALL', opeartion) { }
+          guard.send(:process, "ALL", opeartion) { nil }
         end
 
-        context "returning false" do
+        context "when returning false" do
           it "does not perform the operation" do
-            opeartion.should_not_receive(:call)
+            expect(opeartion).not_to receive(:call)
 
-            guard.send(:process, 'ALL', opeartion) { false }
+            guard.send(:process, "ALL", opeartion) { false }
           end
         end
 
-        context "returning true" do
+        context "when returning true" do
           it "does perform the operation" do
-            opeartion.should_receive(:call).twice
+            expect(opeartion).to receive(:call).twice
 
-            guard.send(:process, 'ALL', opeartion) { true }
+            guard.send(:process, "ALL", opeartion) { true }
           end
         end
       end
@@ -151,51 +151,53 @@ module ImapGuard
 
     describe "#move" do
       it "copies emails before adding the :Deleted flag" do
-        imap.should_receive(:search)
-        imap.should_receive(:copy).with(7, 'destination').ordered
-        imap.should_receive(:store).with(7, '+FLAGS', [:Deleted]).ordered
-        imap.should_receive(:copy).with(28, 'destination').ordered
-        imap.should_receive(:store).with(28, '+FLAGS', [:Deleted]).ordered
+        expect(imap).to receive(:search)
+        expect(imap).to receive(:copy).with(7, "destination").ordered
+        expect(imap).to receive(:store).with(7, "+FLAGS", [:Deleted]).ordered
+        expect(imap).to receive(:copy).with(28, "destination").ordered
+        expect(imap).to receive(:store).with(28, "+FLAGS", [:Deleted]).ordered
 
-        guard_instance.move 'ALL', 'destination'
+        guard_instance.move "ALL", "destination"
       end
     end
 
     describe "#delete" do
       it "adds the :Deleted flag" do
-        imap.should_receive(:search)
-        imap.should_receive(:store).with(7, '+FLAGS', [:Deleted])
-        imap.should_receive(:store).with(28, '+FLAGS', [:Deleted])
+        expect(imap).to receive(:search)
+        expect(imap).to receive(:store).with(7, "+FLAGS", [:Deleted])
+        expect(imap).to receive(:store).with(28, "+FLAGS", [:Deleted])
 
-        guard_instance.delete 'ALL'
+        guard_instance.delete "ALL"
       end
     end
 
     describe "#each" do
       it "iterates over messages without errors" do
-        guard_instance.each 'ALL' do |message_id|
-          # noop
-        end
+        expect do
+          guard_instance.each "ALL" do |message_id|
+            # noop
+          end
+        end.not_to raise_error
       end
     end
 
     describe "#expunge" do
       it "expunges the folder" do
-        imap.should_receive(:expunge)
+        expect(imap).to receive(:expunge)
         guard_instance.expunge
       end
     end
 
     describe "#close" do
       it "closes the IMAP connection" do
-        imap.should_receive(:close)
+        expect(imap).to receive(:close)
         guard_instance.close
       end
     end
 
     describe "#disconnect" do
       it "disconnects from the server" do
-        imap.should_receive(:disconnect)
+        expect(imap).to receive(:disconnect)
         guard_instance.disconnect
       end
     end
@@ -205,7 +207,7 @@ module ImapGuard
         let(:guard) { guard_instance(verbose: true) }
 
         it "does output to $stdout" do
-          $stdout.should_receive(:write).with("ham")
+          expect($stdout).to receive(:write).with("ham")
           guard.send(:verbose).print "ham"
         end
       end
@@ -214,7 +216,7 @@ module ImapGuard
         let(:guard) { guard_instance(verbose: false) }
 
         it "does not output to $stdout" do
-          $stdout.should_not_receive(:write)
+          expect($stdout).not_to receive(:write)
           guard.send(:verbose).print "ham"
         end
       end
@@ -222,27 +224,26 @@ module ImapGuard
 
     describe "#settings=" do
       it "freezes the settings" do
-        guard = Guard.new(settings)
+        guard = described_class.new(settings)
 
         exception = (RUBY_VERSION >= "2.1.0" ? RuntimeError : TypeError)
 
-        expect {
-          guard.settings.host = 'example.net'
-        }.to raise_error(exception, /frozen/)
+        expect do
+          guard.settings.host = "example.net"
+        end.to raise_error(exception, /frozen/)
       end
 
       it "raises ArgumentError if any required key is missing" do
-        expect {
-          Guard.new({})
-        }.to raise_error ArgumentError, /missing/i
+        expect do
+          described_class.new({})
+        end.to raise_error ArgumentError, /missing/i
       end
 
       it "raises ArgumentError if any key is unknown" do
-        expect {
-          Guard.new(settings.merge(coffee: true))
-        }.to raise_error ArgumentError, /unknown/i
+        expect do
+          described_class.new(settings.merge(coffee: true))
+        end.to raise_error ArgumentError, /unknown/i
       end
     end
   end
 end
-

data/spec/imap_guard/query_spec.rb

@@ -1,43 +1,43 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
 module ImapGuard
   describe Query do
     describe "#initialize" do
-      it { should be_empty }
+      it { is_expected.to be_empty }
     end
 
     describe "#seen" do
       it "adds 'SEEN'" do
         subject.seen
-        subject.last.should eq 'SEEN'
+        expect(subject.last).to eq "SEEN"
       end
     end
 
     describe "#unseen" do
       it "adds 'UNSEEN'" do
         subject.unseen
-        subject.last.should eq 'UNSEEN'
+        expect(subject.last).to eq "UNSEEN"
       end
     end
 
     describe "#unanswered" do
       it "adds 'UNANSWERED'" do
         subject.unanswered
-        subject.last.should eq 'UNANSWERED'
+        expect(subject.last).to eq "UNANSWERED"
       end
     end
 
     describe "#unflagged" do
       it "adds 'UNFLAGGED'" do
         subject.unflagged
-        subject.last.should eq 'UNFLAGGED'
+        expect(subject.last).to eq "UNFLAGGED"
       end
     end
 
     describe "#deleted" do
       it "adds 'DELETED'" do
         subject.deleted
-        subject.last.should eq 'DELETED'
+        expect(subject.last).to eq "DELETED"
       end
     end
 
@@ -45,26 +45,26 @@ module ImapGuard
       context "without a search key" do
         it "adds 'OR'" do
           subject.or
-          subject.last.should eq 'OR'
+          expect(subject.last).to eq "OR"
         end
       end
 
       context "with search keys" do
         it "adds 'OR UNANSWERED UNFLAGGED '" do
           subject.or(:unanswered, :unflagged)
-          subject.last(3).should eq ["OR", "UNANSWERED", "UNFLAGGED"]
+          expect(subject.last(3)).to eq %w[OR UNANSWERED UNFLAGGED]
         end
       end
 
       context "with only one non-nil search key" do
         it "raises ArgumentError" do
-          expect {
+          expect do
             subject.or(:whatever)
-          }.to raise_error(ArgumentError)
+          end.to raise_error(ArgumentError)
 
-          expect {
+          expect do
             subject.or(nil, :whatever)
-          }.to raise_error(ArgumentError)
+          end.to raise_error(ArgumentError)
         end
       end
     end
@@ -72,28 +72,28 @@ module ImapGuard
     describe "#subject" do
       it "adds the search value" do
         subject.subject("Hey you")
-        subject.last.should eq "Hey you"
+        expect(subject.last).to eq "Hey you"
       end
     end
 
     describe "#from" do
       it "adds the search value" do
         subject.from("root@example.net")
-        subject.last.should eq "root@example.net"
+        expect(subject.last).to eq "root@example.net"
       end
     end
 
     describe "#to" do
       it "adds the search value" do
         subject.to("root@example.net")
-        subject.last.should eq "root@example.net"
+        expect(subject.last).to eq "root@example.net"
       end
     end
 
     describe "#cc" do
       it "adds the search value" do
         subject.cc("root@example.net")
-        subject.last.should eq "root@example.net"
+        expect(subject.last).to eq "root@example.net"
       end
     end
 
@@ -101,14 +101,14 @@ module ImapGuard
       context "without a search key" do
         it "adds 'NOT'" do
           subject.not.deleted
-          subject.last(2).should eq ["NOT", "DELETED"]
+          expect(subject.last(2)).to eq %w[NOT DELETED]
         end
       end
 
       context "with a search key" do
         it "adds 'NOT DELETED'" do
           subject.not(:deleted)
-          subject.last(2).should eq ["NOT", "DELETED"]
+          expect(subject.last(2)).to eq %w[NOT DELETED]
         end
       end
     end
@@ -116,40 +116,39 @@ module ImapGuard
     describe "#before" do
       context "when I pass 'nil' as an argument" do
         it "raises" do
-          expect {
+          expect do
             subject.before(nil)
-          }.to raise_error ArgumentError
+          end.to raise_error ArgumentError
         end
       end
 
       context "when I pass '1' as an argument" do
         it "returns yesterday" do
           subject.before(1)
-          Date.parse(subject.last).should eq Date.today.prev_day
+          expect(Date.parse(subject.last)).to eq Date.today.prev_day
         end
       end
 
       context "when I pass an integer" do
         it "uses it as a negative offset in days" do
           subject.before(3)
-          (Date.today - Date.parse(subject.last)).should eq 3
+          expect((Date.today - Date.parse(subject.last))).to eq 3
         end
       end
 
       context "when I pass '18-Mar-2013' as an argument" do
         it "uses it as is" do
-          subject.before('18-Mar-2013')
-          subject.last.should eq '18-Mar-2013'
+          subject.before("18-Mar-2013")
+          expect(subject.last).to eq "18-Mar-2013"
         end
       end
 
       context "when I pass an instance of Date as an argument" do
         it "extracts the date" do
           subject.before(Date.today)
-          Date.parse(subject.last).should eq Date.today
+          expect(Date.parse(subject.last)).to eq Date.today
         end
       end
     end
   end
 end
-

data/spec/spec_helper.rb

@@ -1,11 +1,12 @@
-require 'simplecov'
+# frozen_string_literal: true
+
+require "simplecov"
 SimpleCov.start do
-  minimum_coverage 90
+  minimum_coverage 95
   add_group "Sources", "lib"
   add_group "Tests", "spec"
 end
 
-require 'imap_guard'
+require "imap_guard"
 
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |file| require file }
-