imap-backup 1.0.9 → 1.0.10

data/spec/unit/downloader_spec.rb

@@ -4,16 +4,16 @@ require 'spec_helper'
 describe Imap::Backup::Downloader do
   context 'with account and downloader' do
     let(:local_path) { '/base/path' }
-    let(:stat) { stub('File::Stat', :mode => 0700) }
+    let(:stat) { double('File::Stat', :mode => 0700) }
     let(:message) do
       {
         'RFC822' => 'the body',
         'other'  => 'xxx'
       }
     end
-    let(:folder) { stub('Imap::Backup::Account::Folder', :fetch => message) }
+    let(:folder) { double('Imap::Backup::Account::Folder', :fetch => message) }
     let(:serializer) do
-      stub(
+      double(
         'Imap::Backup::Serializer',
         :prepare => nil,
         :exist?  => true,
@@ -22,9 +22,9 @@ describe Imap::Backup::Downloader do
       )
     end
 
-    before { File.stub!(:stat).with(local_path).and_return(stat) }
+    before { allow(File).to receive(:stat).with(local_path).and_return(stat) }
 
-    subject { Imap::Backup::Downloader.new(folder, serializer) }
+    subject { described_class.new(folder, serializer) }
 
     context '#run' do
       context 'with folder' do
@@ -36,11 +36,11 @@ describe Imap::Backup::Downloader do
 
         context 'with messages' do
           before :each do
-            folder.stub!(:uids).and_return(['123', '999', '1234'])
+            allow(folder).to receive(:uids).and_return(['123', '999', '1234'])
           end
 
           it 'should skip messages that are downloaded' do
-            File.stub!(:exist?).and_return(true)
+            allow(File).to receive(:exist?).and_return(true)
 
             serializer.should_not_receive(:fetch)
 
@@ -56,7 +56,7 @@ describe Imap::Backup::Downloader do
 
           context 'to download' do
             before :each do
-              serializer.stub!(:exist?) do |uid|
+              allow(serializer).to receive(:exist?) do |uid|
                 if uid == '123'
                   true
                 else

data/spec/unit/email/mboxrd/message_spec.rb

@@ -5,34 +5,24 @@ require 'spec_helper'
 describe Email::Mboxrd::Message do
   let(:from) { 'me@example.com' }
   let(:date) { DateTime.new(2012, 12, 13, 18, 23, 45) }
-  let(:message_body) { "Foo\nBar\nFrom at the beginning of the line\n>>From quoted" }
-  subject { Email::Mboxrd::Message.new(message_body) }
+  let(:message_body) do
+    double('Body', :clone => cloned_message_body, :force_encoding => nil)
+  end
+  let(:cloned_message_body) { "Foo\nBar\nFrom at the beginning of the line\n>>From quoted" }
+
+  subject { described_class.new(message_body) }
 
   context '#to_s' do
-    let(:mail) do
-      mail = stub('Mail')
-      mail.stub(:from).and_return([from])
-      mail.stub(:date).and_return(date)
-      mail
-    end
+    let(:mail) { double('Mail', :from =>[from], :date => date) }
 
     before do
-      Mail.stub(:new).with(message_body).and_return(mail)
+      allow(Mail).to receive(:new).with(cloned_message_body).and_return(mail)
     end
 
     it 'does not modify the message' do
-      message_body2 = message_body.clone
-
-      message_body.should_receive(:clone).and_return(message_body2)
-      message_body.should_not_receive(:force_encoding).with('binary')
-
       subject.to_s
-    end
 
-    it 'parses the message' do
-      Mail.should_receive(:new).with(message_body).and_return(mail)
-
-      subject.to_s
+      expect(message_body).to_not have_received(:force_encoding).with('binary')
     end
 
     it "adds a 'From ' line at the start" do

data/spec/unit/serializer/base_spec.rb

@@ -4,14 +4,16 @@ require 'spec_helper'
 
 describe Imap::Backup::Serializer::Base do
   context '#initialize' do
-    let(:stat) { stub('File::Stat', :mode => 0345) }
+    let(:stat) { double('File::Stat', :mode => 0345) }
 
-    it 'should fail if file permissions are to lax' do
-      File.stub!(:exist?).with('/base/path').and_return(true)
-      File.should_receive(:stat).with('/base/path').and_return(stat)
+    before do
+      allow(File).to receive(:exist?).with('/base/path').and_return(true)
+      allow(File).to receive(:stat).with('/base/path').and_return(stat)
+    end
 
+    it 'should fail if file permissions are to lax' do
       expect do
-        Imap::Backup::Serializer::Base.new('/base/path', 'my_folder')
+        described_class.new('/base/path', 'my_folder')
       end.to raise_error(RuntimeError, "Permissions on '/base/path' should be 0700, not 0345")
     end
   end

data/spec/unit/serializer/directory_spec.rb

@@ -2,77 +2,69 @@
 require 'spec_helper'
 
 describe Imap::Backup::Serializer::Directory do
-  let(:stat) { stub('File::Stat', :mode => 0700) }
+  let(:stat) { double('File::Stat', :mode => 0700) }
   let(:files) { ['00000123.json', '000001.json'] }
+  let(:base) { '/base/path' }
+  let(:folder) { '/base/path/my_folder' }
+  let(:folder_exists) { true }
 
   before do
-    File.stub!(:stat).with('/base/path').and_return(stat)
-    FileUtils.stub!(:mkdir_p).with('/base/path/my_folder')
-    FileUtils.stub!(:chmod).with(0700, '/base/path/my_folder')
-    File.stub!(:exist?).with('/base/path').and_return(true)
+    allow(FileUtils).to receive(:mkdir_p)
+    allow(FileUtils).to receive(:chmod)
+    allow(File).to receive(:stat).with(base).and_return(stat)
+    allow(File).to receive(:exist?).with(base).and_return(true)
+    allow(File).to receive(:exist?).with(folder).and_return(folder_exists)
   end
 
-  subject { Imap::Backup::Serializer::Directory.new('/base/path', 'my_folder') }
+  subject { described_class.new(base, 'my_folder') }
 
   context '#uids' do
-    it 'should return the backed-up uids' do
-      File.should_receive(:exist?).with('/base/path/my_folder').and_return(true)
-      Dir.should_receive(:open).with('/base/path/my_folder').and_return(files)
+    before do
+      allow(Dir).to receive(:open).with(folder).and_return(files)
+    end
 
+    it 'returns the backed-up uids' do
       subject.uids.should == [1, 123]
     end
 
-    it 'should return an empty Array if the directory does not exist' do
-      File.should_receive(:exist?).with('/base/path/my_folder').and_return(false)
+    context 'if the directory does not exist' do
+      let(:folder_exists) { false }
 
-      subject.uids.should == []
+      it 'returns an empty array' do
+        subject.uids.should == []
+      end
     end
   end
 
   context '#exist?' do
-    it 'should check if the file exists' do
-      File.should_receive(:exist?).with(%r{/base/path/my_folder/0+123.json}).and_return(true)
+    it 'checks if the file exists' do
+      allow(File).to receive(:exist?).with(%r{/base/path/my_folder/0+123.json}).and_return(true)
 
       subject.exist?(123).should be_true
     end
   end
 
   context '#save' do
-    let(:message) do
-      {
-        'RFC822' => 'the body',
-        'other'  => 'xxx'
-      }
-    end
-    let(:file) { stub('File', :write => nil) }
+    let(:message) { {'RFC822' => 'the body', 'other'  => 'xxx'} }
+    let(:file) { double('File', :write => nil) }
 
     before do
-      File.stub!(:exist?).with(%r{/base/path/my_folder/0+1234.json}).and_return(true)
-      FileUtils.stub!(:chmod).with(0600, /0+1234.json$/)
-      File.stub!(:open) do |&block|
+      allow(File).to receive(:exist?).with(%r{/base/path/my_folder/0+1234.json}).and_return(true)
+      allow(File).to receive(:open) do |&block|
         block.call file
       end
     end
 
-    it 'should save messages' do
-      File.should_receive(:open) do |&block|
-        block.call file
-      end
-      file.should_receive(:write).with(/the body/)
-
+    it 'saves messages' do
       subject.save('1234', message)
-    end
-
-    it 'should JSON encode messages' do
-      message.should_receive(:to_json)
 
-      subject.save('1234', message)
+      expect(file).to have_received(:write).with(message.to_json)
     end
 
-    it 'should set file permissions' do
-      FileUtils.should_receive(:chmod).with(0600, /0+1234.json$/)
-
+    it 'sets file permissions' do
       subject.save(1234, message)
+
+      expect(FileUtils).to have_received(:chmod).with(0600, /0+1234.json$/)
     end
   end
 end

data/spec/unit/serializer/mbox_spec.rb

@@ -3,109 +3,115 @@
 require 'spec_helper'
 
 describe Imap::Backup::Serializer::Mbox do
-  let(:stat) { stub('File::Stat', :mode => 0700) }
+  let(:stat) { double('File::Stat', :mode => 0700) }
+  let(:base_path) { '/base/path' }
   let(:mbox_pathname) { '/base/path/my/folder.mbox' }
+  let(:mbox_exists) { true }
   let(:imap_pathname) { '/base/path/my/folder.imap' }
+  let(:imap_exists) { true }
 
   before do
-    File.stub(:exist?).with('/base/path').and_return(true)
-    File.stub!(:stat).with('/base/path').and_return(stat)
-    Imap::Backup::Utils.stub(:make_folder)
+    allow(Imap::Backup::Utils).to receive(:make_folder)
+    allow(File).to receive(:exist?).with(base_path).and_return(true)
+    allow(File).to receive(:stat).with(base_path).and_return(stat)
+    allow(File).to receive(:exist?).with(mbox_pathname).and_return(mbox_exists)
+    allow(File).to receive(:exist?).with(imap_pathname).and_return(imap_exists)
   end
 
   context '#initialize' do
-    before do
-      File.stub(:exist?).with(mbox_pathname).and_return(true)
-      File.stub(:exist?).with(imap_pathname).and_return(true)
-    end
-
     it 'creates the containing directory' do
-      Imap::Backup::Utils.should_receive(:make_folder).with('/base/path', 'my', 0700)
+      described_class.new(base_path, 'my/folder')
 
-      Imap::Backup::Serializer::Mbox.new('/base/path', 'my/folder')
+      expect(Imap::Backup::Utils).to have_received(:make_folder).with(base_path, 'my', 0700)
     end
 
     context 'mbox and imap files' do
-      it 'checks if they exist' do
-        File.should_receive(:exist?).with(mbox_pathname).and_return(true)
-        File.should_receive(:exist?).with(imap_pathname).and_return(true)
-
-        Imap::Backup::Serializer::Mbox.new('/base/path', 'my/folder')
+      context "if mbox exists and imap doesn't" do
+        let(:imap_exists) { false }
+
+        it 'fails' do
+          expect {
+            described_class.new(base_path, 'my/folder')
+          }.to raise_error(RuntimeError, '.imap file missing')
+        end
       end
 
-      it "fails if mbox exists and imap doesn't" do
-        File.stub(:exist?).with(imap_pathname).and_return(false)
+      context "if imap exists and mbox doesn't" do
+        let(:mbox_exists) { false }
 
-        expect {
-          Imap::Backup::Serializer::Mbox.new('/base/path', 'my/folder')
-        }.to raise_error(RuntimeError, '.imap file missing')
-      end
-
-      it "fails if imap exists and mbox doesn't" do
-        File.stub(:exist?).with(mbox_pathname).and_return(false)
-
-        expect {
-          Imap::Backup::Serializer::Mbox.new('/base/path', 'my/folder')
-        }.to raise_error(RuntimeError, '.mbox file missing')
+        it 'fails' do
+          expect {
+            described_class.new(base_path, 'my/folder')
+          }.to raise_error(RuntimeError, '.mbox file missing')
+        end
       end
     end
   end
 
   context 'instance methods' do
+    let(:ids) { %w(1 123) }
+
     before do
-      File.stub(:exist?).with(mbox_pathname).and_return(true)
-      File.stub(:exist?).with(imap_pathname).and_return(true)
-      CSV.stub(:foreach) do |&block|
-        block.call ['1']
-        block.call ['123']
-      end
+      allow(CSV).to receive(:foreach) { |&b| ids.each { |id| b.call [id] } }
     end
 
-    subject { Imap::Backup::Serializer::Mbox.new('/base/path', 'my/folder') }
+    subject { described_class.new(base_path, 'my/folder') }
 
     context '#uids' do
       it 'returns the backed-up uids' do
-        File.should_receive(:exist?).with(mbox_pathname).and_return(true)
-        File.should_receive(:exist?).with(imap_pathname).and_return(true)
-
-        expect(subject.uids).to eq(['1', '123'])
+        expect(subject.uids).to eq(ids)
       end
 
-      it 'returns an empty Array if the mbox does not exist' do
-        File.stub(:exist?).with(mbox_pathname).and_return(false)
-        File.stub(:exist?).with(imap_pathname).and_return(false)
-        File.should_receive(:exist?).with(mbox_pathname).and_return(false)
-        File.should_receive(:exist?).with(imap_pathname).and_return(false)
+      context 'if the mbox does not exist' do
+        let(:mbox_exists) { false }
+        let(:imap_exists) { false }
 
-        expect(subject.uids).to eq([])
+        it 'returns an empty Array' do
+          expect(subject.uids).to eq([])
+        end
       end
     end
 
     context '#save' do
       let(:mbox_formatted_message) { 'message in mbox format' }
       let(:message_uid) { '999' }
-      let(:message) { stub('Email::Mboxrd::Message', :to_s => mbox_formatted_message) }
-      let(:mbox_file) { stub('File - mbox', :close => nil) }
-      let(:imap_file) { stub('File - imap', :close => nil) }
+      let(:message) { double('Email::Mboxrd::Message', :to_s => mbox_formatted_message) }
+      let(:mbox_file) { double('File - mbox', :write => nil, :close => nil) }
+      let(:imap_file) { double('File - imap', :write => nil, :close => nil) }
 
       before do
-        Email::Mboxrd::Message.stub(:new => message)
-        File.stub(:open).with(mbox_pathname, 'ab').and_return(mbox_file)
-        File.stub(:open).with(imap_pathname, 'ab').and_return(imap_file)
-        mbox_file.stub(:write).with(mbox_formatted_message)
-        imap_file.stub(:write).with(message_uid + "\n")
+        allow(Email::Mboxrd::Message).to receive(:new).and_return(message)
+        allow(File).to receive(:open).with(mbox_pathname, 'ab').and_return(mbox_file)
+        allow(File).to receive(:open).with(imap_pathname, 'ab').and_return(imap_file)
       end
 
       it 'saves the message to the mbox' do
-        mbox_file.should_receive(:write).with(mbox_formatted_message)
-
         subject.save(message_uid, "The\nemail\n")
+
+        expect(mbox_file).to have_received(:write).with(mbox_formatted_message)
       end
 
       it 'saves the uid to the imap file' do
-        imap_file.should_receive(:write).with(message_uid + "\n")
-
         subject.save(message_uid, "The\nemail\n")
+
+        expect(imap_file).to have_received(:write).with(message_uid + "\n")
+      end
+
+      context 'when the message causes parsing errors' do
+        before do
+          allow(message).to receive(:to_s).and_raise(ArgumentError)
+        end
+
+        it 'skips the message' do
+          subject.save(message_uid, "The\nemail\n")
+          expect(mbox_file).to_not have_received(:write)
+        end
+
+        it 'does not fail' do
+          expect do
+            subject.save(message_uid, "The\nemail\n")
+          end.to_not raise_error
+        end
       end
     end
   end

data/spec/unit/utils_spec.rb

@@ -2,67 +2,93 @@
 require 'spec_helper'
 
 describe Imap::Backup::Utils do
-  context '#check_permissions' do
-    before :each do
-      File.stub!(:exist?).and_return(true)
-    end
-
-    it 'should stat the file' do
-      stat = stub('File::Stat', :mode => 0100)
-      File.should_receive(:stat).with('foobar').and_return(stat)
+  let(:filename) { 'foobar' }
+  let(:stat) { double('File::Stat', :mode => mode) }
+  let(:mode) { 0777 }
+  let(:exists) { true }
+
+  before do
+    allow(File).to receive(:stat).and_return(stat)
+    allow(File).to receive(:exist?).with(filename).and_return(exists)
+  end
 
-      Imap::Backup::Utils.check_permissions('foobar', 0345)
+  context '.check_permissions' do
+    let(:requested) { 0345 }
+
+    context 'with existing files' do
+      [
+        [0100, 'less than the limit', true],
+        [0345, 'equal to the limit', true],
+        [0777, 'over the limit', false],
+      ].each do |mode, description, success|
+        context "when permissions are #{description}" do
+          let(:mode) { mode }
+
+          if success
+            it 'succeeds' do
+              described_class.check_permissions(filename, requested)
+            end
+          else
+            it 'fails' do
+              expect do
+                described_class.check_permissions(filename, requested)
+              end.to raise_error(RuntimeError, format("Permissions on '%s' should be 0%o, not 0%o", filename, requested, mode))
+            end
+          end
+        end
+      end
     end
 
-    it 'should succeed if file permissions are less than limit' do
-      stat = stub('File::Stat', :mode => 0100)
-      File.stub!(:stat).and_return(stat)
+    context 'with non-existent files' do
+      let(:exists) { false }
+      let(:mode) { 0111 }
 
-      expect do
-        Imap::Backup::Utils.check_permissions('foobar', 0345)
-      end.to_not raise_error
+      it 'succeeds' do
+        described_class.check_permissions(filename, requested)
+      end
     end
+  end
 
-    it 'should succeed if file permissions are equal to limit' do
-      stat = stub('File::Stat', :mode => 0345)
-      File.stub!(:stat).and_return(stat)
+  context '.stat' do
+    context 'with existing files' do
+      let(:mode) { 02345 }
 
-      expect do
-        Imap::Backup::Utils.check_permissions('foobar', 0345)
-      end.to_not raise_error
+      it 'is the last 9 bits of the file mode' do
+        expect(described_class.stat(filename)).to eq(0345)
+      end
     end
 
-    it 'should fail if file permissions are over the limit' do
-      stat = stub('File::Stat', :mode => 0777)
-      File.stub!(:stat).and_return(stat)
+    context 'with non-existent files' do
+      let(:exists) { false }
 
-      expect do
-        Imap::Backup::Utils.check_permissions('foobar', 0345)
-      end.to raise_error(RuntimeError, "Permissions on 'foobar' should be 0345, not 0777")
+      it 'is nil' do
+        expect(described_class.stat(filename)).to be_nil
+      end
     end
   end
 
-  context '#make_folder' do
-    it 'should do nothing if an empty path is supplied' do
-      FileUtils.should_not_receive(:mkdir_p)
-
-      Imap::Backup::Utils.make_folder('aaa', '', 0222)
+  context '.make_folder' do
+    before do
+      allow(FileUtils).to receive(:mkdir_p)
+      allow(FileUtils).to receive(:chmod)
     end
 
-    it 'should create the path' do
-      FileUtils.stub!(:chmod)
-
-      FileUtils.should_receive(:mkdir_p).with('/base/path/new/folder')
+    it 'does nothing if an empty path is supplied' do
+      described_class.make_folder('aaa', '', 0222)
 
-      Imap::Backup::Utils.make_folder('/base/path', 'new/folder', 0222)
+      expect(FileUtils).to_not have_received(:mkdir_p)
     end
 
-    it 'should set permissions on the path' do
-      FileUtils.stub!(:mkdir_p)
+    it 'creates the path' do
+      described_class.make_folder('/base/path', 'new/folder', 0222)
+
+      expect(FileUtils).to have_received(:mkdir_p).with('/base/path/new/folder')
+    end
 
-      FileUtils.should_receive(:chmod).with(0222, '/base/path/new/folder')
+    it 'sets permissions on the path' do
+      described_class.make_folder('/base/path/new', 'folder', 0222)
 
-      Imap::Backup::Utils.make_folder('/base/path/new', 'folder', 0222)
+      expect(FileUtils).to have_received(:chmod).with(0222, '/base/path/new/folder')
     end
   end
 end