maid 0.5.0 → 0.6.0.alpha.1

data/spec/lib/maid/tools_spec.rb

@@ -2,7 +2,7 @@
 require 'spec_helper'
 
 # Workaround for Ruby 2.1.0, remove after https://github.com/defunkt/fakefs/pull/209 is released
-if RUBY_VERSION == '2.1.0'
+if RUBY_VERSION == '2.1.0' || RUBY_VERSION == '2.1.1'
   module FakeFS
     class Dir
       def self.entries(dirname, opts = {})
@@ -25,7 +25,7 @@ module Maid
       @home = File.expand_path('~')
       @now = Time.now
 
-      Maid.ancestors.should include(Tools)
+      expect(Maid.ancestors).to include(Tools)
 
       @logger = double('Logger').as_null_object
       @maid = Maid.new(:logger => @logger)
@@ -45,24 +45,24 @@ module Maid
         FileUtils.mkdir_p(@dst_dir = '~/Destination/')
       end
 
-      it 'should move expanded paths, passing file_options' do
+      it 'moves expanded paths, passing file_options' do
         @maid.move(@src_file, @dst_dir)
-        File.exists?(@dst_dir + @file_name).should be_true
+        expect(File.exists?(@dst_dir + @file_name)).to be(true)
       end
 
-      it 'should log the move' do
-        @logger.should_receive(:info)
+      it 'logs the move' do
+        expect(@logger).to receive(:info)
         @maid.move(@src_file, @dst_dir)
       end
 
-      it 'should handle multiple from paths' do
+      it 'handles multiple from paths' do
         second_src_file = @src_dir + (second_file_name = 'bar.zip')
         FileUtils.touch(second_src_file)
         src_files = [@src_file, second_src_file]
 
         @maid.move(src_files, @dst_dir)
-        File.exist?(@dst_dir + @file_name).should be_true
-        File.exist?(@dst_dir + second_file_name).should be_true
+        expect(File.exist?(@dst_dir + @file_name)).to be(true)
+        expect(File.exist?(@dst_dir + second_file_name)).to be(true)
       end
 
       context 'given the destination directory does not exist' do
@@ -71,8 +71,8 @@ module Maid
         end
 
         it 'does not overwrite when moving' do
-          FileUtils.should_not_receive(:mv)
-          @logger.should_receive(:warn).once
+          expect(FileUtils).not_to receive(:mv)
+          expect(@logger).to receive(:warn).once
 
           another_file = "#@src_file.1"
           @maid.move([@src_file, another_file], @dst_dir)
@@ -93,17 +93,17 @@ module Maid
       end
 
       it 'creates needed directories' do
-        File.directory?(@expanded_dst_dir).should be_false
+        expect(File.directory?(@expanded_dst_dir)).to be(false)
         @maid.rename(@src_file, @dst_name)
-        File.directory?(@expanded_dst_dir).should be_true
+        expect(File.directory?(@expanded_dst_dir)).to be(true)
       end
 
       it 'moves the file from the source to the destination' do
-        File.exists?(@expanded_src_name).should be_true
-        File.exists?(@expanded_dst_name).should be_false
+        expect(File.exists?(@expanded_src_name)).to be(true)
+        expect(File.exists?(@expanded_dst_name)).to be(false)
         @maid.rename(@src_file, @dst_name)
-        File.exists?(@expanded_src_name).should be_false
-        File.exists?(@expanded_dst_name).should be_true
+        expect(File.exists?(@expanded_src_name)).to be(false)
+        expect(File.exists?(@expanded_dst_name)).to be(true)
       end
 
       context 'given the target already exists' do
@@ -113,7 +113,7 @@ module Maid
         end
 
         it 'does not move' do
-          @logger.should_receive(:warn)
+          expect(@logger).to receive(:warn)
 
           @maid.rename(@src_file, @dst_name)
         end
@@ -130,43 +130,43 @@ module Maid
         @trash_file = File.join(@trash_path, @file_name)
       end
 
-      it 'should move the path to the trash' do
+      it 'moves the path to the trash' do
         @maid.trash(@src_file)
-        File.exist?(@trash_file).should be_true
+        expect(File.exist?(@trash_file)).to be(true)
       end
 
-      it 'should use a safe path if the target exists' do
+      it 'uses a safe path if the target exists' do
         # Without an offset, ISO8601 parses to local time, which is what we want here.
         Timecop.freeze(Time.parse('2011-05-22T16:53:52')) do
           FileUtils.touch(@trash_file)
           @maid.trash(@src_file)
           new_trash_file = File.join(@trash_path, @file_name + ' 2011-05-22-16-53-52')
-          File.exist?(new_trash_file).should be_true
+          expect(File.exist?(new_trash_file)).to be(true)
         end
       end
 
-      it 'should handle multiple paths' do
+      it 'handles multiple paths' do
         second_src_file = @src_dir + (second_file_name = 'bar.zip')
         FileUtils.touch(second_src_file)
         @src_files = [@src_file, second_src_file]
         @maid.trash(@src_files)
 
         second_trash_file = File.join(@trash_path, second_file_name)
-        File.exist?(@trash_file).should be_true
-        File.exist?(second_trash_file).should be_true
+        expect(File.exist?(@trash_file)).to be(true)
+        expect(File.exist?(second_trash_file)).to be(true)
       end
 
-      it 'should remove files greater then the remove option size' do
+      it 'removes files greater then the remove option size' do
         @maid.stub(:disk_usage) { 1025 }
         @maid.trash(@src_file, :remove_over => 1.mb)
-        File.exist?(@src_file).should_not be_true
-        File.exist?(@trash_file).should_not be_true
+        expect(File.exist?(@src_file)).not_to be(true)
+        expect(File.exist?(@trash_file)).not_to be(true)
       end
 
-      it 'should trash files less then the remove option size' do
+      it 'trashes files less then the remove option size' do
         @maid.stub(:disk_usage) { 1023 }
         @maid.trash(@src_file, :remove_over => 1.mb)
-        File.exist?(@trash_file).should be_true
+        expect(File.exist?(@trash_file)).to be(true)
       end
     end
 
@@ -179,36 +179,36 @@ module Maid
         @options = @maid.file_options
       end
 
-      it 'should remove expanded paths, passing options' do
+      it 'removes expanded paths, passing options' do
         @maid.remove(@src_file)
-        File.exist?(@src_file).should be_false
+        expect(File.exist?(@src_file)).to be(false)
       end
 
-      it 'should log the remove' do
-        @logger.should_receive(:info)
+      it 'logs the remove' do
+        expect(@logger).to receive(:info)
         @maid.remove(@src_file)
       end
 
-      it 'should set the secure option' do
+      it 'sets the secure option' do
         @options = @options.merge(:secure => true)
-        FileUtils.should_receive(:rm_r).with(@src_file_expand_path, @options)
+        expect(FileUtils).to receive(:rm_r).with(@src_file_expand_path, @options)
         @maid.remove(@src_file, :secure => true)
       end
 
-      it 'should set the force option' do
+      it 'sets the force option' do
         @options = @options.merge(:force => true)
-        FileUtils.should_receive(:rm_r).with(@src_file_expand_path, @options)
+        expect(FileUtils).to receive(:rm_r).with(@src_file_expand_path, @options)
         @maid.remove(@src_file, :force => true)
       end
 
-      it 'should handle multiple paths' do
+      it 'handles multiple paths' do
         second_src_file = "#@src_dir/bar.zip"
         FileUtils.touch(second_src_file)
         @src_files = [@src_file, second_src_file]
 
         @maid.remove(@src_files)
-        File.exist?(@src_file).should be_false
-        File.exist?(second_src_file).should be_false
+        expect(File.exist?(@src_file)).to be(false)
+        expect(File.exist?(second_src_file)).to be(false)
       end
     end
 
@@ -220,14 +220,14 @@ module Maid
 
       it 'lists files in a directory' do
         FileUtils.touch(@file)
-        @maid.dir('~/Downloads/*.zip').should == [@file]
+        expect(@maid.dir('~/Downloads/*.zip')).to eq([@file])
       end
 
       it 'lists multiple files in alphabetical order' do
         # It doesn't occur with `FakeFS` as far as I can tell, but Ubuntu (and possibly OS X) can give the results out
         # of lexical order.  That makes using the `dry-run` output difficult to use.
         Dir.stub(:glob) { %w(/home/foo/b.zip /home/foo/a.zip /home/foo/c.zip) }
-        @maid.dir('~/Downloads/*.zip').should == %w(/home/foo/a.zip /home/foo/b.zip /home/foo/c.zip)
+        expect(@maid.dir('~/Downloads/*.zip')).to eq(%w(/home/foo/a.zip /home/foo/b.zip /home/foo/c.zip))
       end
 
       context 'with multiple files' do
@@ -238,11 +238,11 @@ module Maid
         end
 
         it 'list files in all provided globs' do
-          @maid.dir(%w(~/Downloads/*.tgz ~/Downloads/*.zip)).should == [@file, @other_file]
+          expect(@maid.dir(%w(~/Downloads/*.tgz ~/Downloads/*.zip))).to eq([@file, @other_file])
         end
 
         it 'lists files when using regexp-like glob patterns' do
-          @maid.dir('~/Downloads/*.{tgz,zip}').should == [@file, @other_file]
+          expect(@maid.dir('~/Downloads/*.{tgz,zip}')).to eq([@file, @other_file])
         end
       end
 
@@ -255,11 +255,11 @@ module Maid
         end
 
         it 'lists files in directories when using regexp-like glob patterns' do
-          @maid.dir('~/{Desktop,Downloads}/*.zip').should == [@other_file, @file]
+          expect(@maid.dir('~/{Desktop,Downloads}/*.zip')).to eq([@other_file, @file])
         end
 
         it 'lists files in directories when using recursive glob patterns' do
-          @maid.dir('~/**/*.zip').should == [@other_file, @file]
+          expect(@maid.dir('~/**/*.zip')).to eq([@other_file, @file])
         end
       end
     end
@@ -273,14 +273,14 @@ module Maid
 
       it 'lists only files in a directory' do
         FileUtils.touch(@file)
-        @maid.files('~/Downloads/*.zip').should == [@file]
+        expect(@maid.files('~/Downloads/*.zip')).to eq([@file])
       end
 
       it 'lists multiple files in alphabetical order' do
         # It doesn't occur with `FakeFS` as far as I can tell, but Ubuntu (and possibly OS X) can give the results out
         # of lexical order.  That makes using the `dry-run` output difficult to use.
         Dir.stub(:glob) { %w(/home/foo/b.zip /home/foo/a.zip /home/foo/c.zip) }
-        @maid.dir('~/Downloads/*.zip').should == %w(/home/foo/a.zip /home/foo/b.zip /home/foo/c.zip)
+        expect(@maid.dir('~/Downloads/*.zip')).to eq(%w(/home/foo/a.zip /home/foo/b.zip /home/foo/c.zip))
       end
 
       context 'with multiple files' do
@@ -291,11 +291,11 @@ module Maid
         end
 
         it 'list files in all provided globs' do
-          @maid.dir(%w(~/Downloads/*.tgz ~/Downloads/*.zip)).should == [@file, @other_file]
+          expect(@maid.dir(%w(~/Downloads/*.tgz ~/Downloads/*.zip))).to eq([@file, @other_file])
         end
 
         it 'lists files when using regexp-like glob patterns' do
-          @maid.dir('~/Downloads/*.{tgz,zip}').should == [@file, @other_file]
+          expect(@maid.dir('~/Downloads/*.{tgz,zip}')).to eq([@file, @other_file])
         end
       end
 
@@ -309,37 +309,37 @@ module Maid
         end
 
         it 'lists files in directories when using regexp-like glob patterns' do
-          @maid.dir('~/{Desktop,Downloads}/*.zip').should == [@other_file, @file]
+          expect(@maid.dir('~/{Desktop,Downloads}/*.zip')).to eq([@other_file, @file])
         end
       end
     end
 
     describe '#escape_glob' do
       it 'escapes characters that have special meanings in globs' do
-        @maid.escape_glob('test [tmp]').should == 'test \\[tmp\\]'
+        expect(@maid.escape_glob('test [tmp]')).to eq('test \\[tmp\\]')
       end
     end
 
     describe '#mkdir' do
-      it 'should create a directory successfully' do
+      it 'creates a directory successfully' do
         @maid.mkdir('~/Downloads/Music/Pink.Floyd')
-        File.exist?("#@home/Downloads/Music/Pink.Floyd").should be_true
+        expect(File.exist?("#@home/Downloads/Music/Pink.Floyd")).to be(true)
       end
 
-      it 'should log the creation of the directory' do
-        @logger.should_receive(:info)
+      it 'logs the creation of the directory' do
+        expect(@logger).to receive(:info)
         @maid.mkdir('~/Downloads/Music/Pink.Floyd')
       end
 
       it 'returns the path of the created directory' do
-        @maid.mkdir('~/Reference/Foo').should == "#@home/Reference/Foo"
+        expect(@maid.mkdir('~/Reference/Foo')).to eq("#@home/Reference/Foo")
       end
 
       # FIXME: FakeFS doesn't seem to report `File.exist?` properly.  However, this has been tested manually.
       #
-      #     it 'should respect the noop option' do
+      #     it 'respects the noop option' do
       #       @maid.mkdir('~/Downloads/Music/Pink.Floyd')
-      #       File.exist?("#@home/Downloads/Music/Pink.Floyd").should be_false
+      #       expect(File.exist?("#@home/Downloads/Music/Pink.Floyd")).to be(false)
       #     end
     end
 
@@ -352,21 +352,21 @@ module Maid
         @file_expand_path = File.expand_path(@file)
       end
 
-      it 'should delegate to Find.find with an expanded path' do
-        f = lambda { }
-        Find.should_receive(:find).with(@file_expand_path, &f)
+      it 'delegates to Find.find with an expanded path' do
+        f = lambda { |arg| }
+        expect(Find).to receive(:find).with(@file_expand_path, &f)
         @maid.find(@file, &f)
       end
 
-      it "should return an array of all the files' names when no block is given" do
-        @maid.find(@dir).should == [@dir_expand_path, @file_expand_path]
+      it "returns an array of all the files' names when no block is given" do
+        expect(@maid.find(@dir)).to eq([@dir_expand_path, @file_expand_path])
       end
     end
 
     describe '#locate' do
-      it 'should locate a file by name' do
-        @maid.should_receive(:cmd).and_return("/a/foo.zip\n/b/foo.zip\n")
-        @maid.locate('foo.zip').should == ['/a/foo.zip', '/b/foo.zip']
+      it 'locates a file by name' do
+        expect(@maid).to receive(:cmd).and_return("/a/foo.zip\n/b/foo.zip\n")
+        expect(@maid.locate('foo.zip')).to eq(['/a/foo.zip', '/b/foo.zip'])
       end
     end
 
@@ -375,52 +375,56 @@ module Maid
         Platform.stub(:osx?) { true }
       end
 
-      it 'should determine the download site' do
-        @maid.should_receive(:cmd).and_return(%((\n    "http://www.site.com/foo.zip",\n"http://www.site.com/"\n)))
-        @maid.downloaded_from('foo.zip').should == ['http://www.site.com/foo.zip', 'http://www.site.com/']
+      it 'determines the download site' do
+        expect(@maid).to receive(:cmd).and_return(%((\n    "http://www.site.com/foo.zip",\n"http://www.site.com/"\n)))
+        expect(@maid.downloaded_from('foo.zip')).to eq(['http://www.site.com/foo.zip', 'http://www.site.com/'])
       end
     end
 
     describe '#downloading?' do
       it 'detects a normal file as not being downloaded' do
-        @maid.downloading?('foo.zip').should be_false
+        expect(@maid.downloading?('foo.zip')).to be(false)
       end
 
       it 'detects when downloading in Firefox' do
-        @maid.downloading?('foo.zip.part').should be_true
+        expect(@maid.downloading?('foo.zip.part')).to be(true)
       end
 
       it 'detects when downloading in Chrome' do
-        @maid.downloading?('foo.zip.crdownload').should be_true
+        expect(@maid.downloading?('foo.zip.crdownload')).to be(true)
+      end
+
+      it 'detects when downloading in Safari' do
+        expect(@maid.downloading?('foo.zip.download')).to be (true)
       end
     end
 
     describe '#duration_s' do
-      it 'should determine audio length' do
-        @maid.should_receive(:cmd).and_return('235.705')
-        @maid.duration_s('foo.mp3').should == 235.705
+      it 'determines audio length' do
+        expect(@maid).to receive(:cmd).and_return('235.705')
+        expect(@maid.duration_s('foo.mp3')).to eq(235.705)
       end
     end
 
     describe '#zipfile_contents' do
-      it 'should inspect the contents of a .zip file' do
+      it 'inspects the contents of a .zip file' do
         entries = [double(:name => 'foo.exe'), double(:name => 'README.txt'), double(:name => 'subdir/anything.txt')]
         Zip::File.stub(:open).and_yield(entries)
 
-        @maid.zipfile_contents('foo.zip').should == ['README.txt', 'foo.exe', 'subdir/anything.txt']
+        expect(@maid.zipfile_contents('foo.zip')).to eq(['README.txt', 'foo.exe', 'subdir/anything.txt'])
       end
     end
 
     describe '#disk_usage' do
-      it 'should give the disk usage of a file' do
-        @maid.should_receive(:cmd).and_return('136     foo.zip')
-        @maid.disk_usage('foo.zip').should == 136
+      it 'gives the disk usage of a file' do
+        expect(@maid).to receive(:cmd).and_return('136     foo.zip')
+        expect(@maid.disk_usage('foo.zip')).to eq(136)
       end
 
       context 'when the file does not exist' do
         it 'raises an error' do
-          @maid.should_receive(:cmd).and_return('du: cannot access `foo.zip\': No such file or directory')
-          lambda { @maid.disk_usage('foo.zip') }.should raise_error(RuntimeError)
+          expect(@maid).to receive(:cmd).and_return('du: cannot access `foo.zip\': No such file or directory')
+          expect(lambda { @maid.disk_usage('foo.zip') }).to raise_error(RuntimeError)
         end
       end
     end
@@ -430,25 +434,25 @@ module Maid
         @path = "~/test.txt"
       end
 
-      it 'should give the created time of the file' do
+      it 'gives the created time of the file' do
         Timecop.freeze(@now) do
           FileUtils.touch(File.expand_path(@path))
-          @maid.created_at(@path).should == Time.now
+          expect(@maid.created_at(@path)).to eq(Time.now)
         end
       end
     end
 
     describe '#accessed_at' do
       # FakeFS does not implement atime.
-      it 'should give the last accessed time of the file' do
-        File.should_receive(:atime).with("#@home/foo.zip").and_return(@now)
-        @maid.accessed_at('~/foo.zip').should == @now
+      it 'gives the last accessed time of the file' do
+        expect(File).to receive(:atime).with("#@home/foo.zip").and_return(@now)
+        expect(@maid.accessed_at('~/foo.zip')).to eq(@now)
       end
 
-      it 'should trigger deprecation warning when last_accessed is used, but still run' do
-        File.should_receive(:atime).with("#@home/foo.zip").and_return(@now)
-        @maid.should have_deprecated_method(:last_accessed)
-        @maid.last_accessed('~/foo.zip').should == @now
+      it 'triggers deprecation warning when last_accessed is used, but still run' do
+        expect(File).to receive(:atime).with("#@home/foo.zip").and_return(@now)
+        expect(@maid).to have_deprecated_method(:last_accessed)
+        expect(@maid.last_accessed('~/foo.zip')).to eq(@now)
       end
     end
 
@@ -458,13 +462,13 @@ module Maid
         FileUtils.touch(File.expand_path(@path))
       end
 
-      it 'should give the modified time of the file' do
+      it 'gives the modified time of the file' do
         Timecop.freeze(@now) do
           File.open(@path, 'w') { |f| f.write('Test') }
         end
 
         # use to_i to ignore milliseconds during test
-        @maid.modified_at(@path).to_i.should == @now.to_i
+        expect(@maid.modified_at(@path).to_i).to eq(@now.to_i)
       end
     end
 
@@ -473,9 +477,9 @@ module Maid
         @file = '~/foo.zip'
       end
 
-      it 'should give the size of the file' do
-        File.should_receive(:size).with(@file).and_return(42)
-        @maid.size_of(@file).should == 42
+      it 'gives the size of the file' do
+        expect(File).to receive(:size).with(@file).and_return(42)
+        expect(@maid.size_of(@file)).to eq(42)
       end
     end
 
@@ -484,21 +488,21 @@ module Maid
         @file = '~/test.txt'
       end
 
-      it 'should return the checksum of the file' do
-        File.should_receive(:read).with(@file).and_return('contents')
-        @maid.checksum_of(@file).should == Digest::MD5.hexdigest('contents')
+      it 'returns the checksum of the file' do
+        expect(File).to receive(:read).with(@file).and_return('contents')
+        expect(@maid.checksum_of(@file)).to eq(Digest::SHA1.hexdigest('contents'))
       end
     end
 
     describe '#git_piston' do
       it 'is deprecated' do
-        @maid.should have_deprecated_method(:git_piston)
+        expect(@maid).to have_deprecated_method(:git_piston)
         @maid.git_piston('~/code/projectname')
       end
 
-      it 'should pull and push the given git repository, logging the action' do
-        @maid.should_receive(:cmd).with(%(cd #@home/code/projectname && git pull && git push 2>&1))
-        @logger.should_receive(:info)
+      it 'ands pushes the given git repository, logging the action' do
+        expect(@maid).to receive(:cmd).with(%(cd #@home/code/projectname && git pull && git push 2>&1))
+        expect(@logger).to receive(:info)
         @maid.git_piston('~/code/projectname')
       end
     end
@@ -509,36 +513,35 @@ module Maid
         @dst_dir = '~/Reference'
       end
 
-      it 'should sync the expanded paths, retaining backslash' do
-        @maid.should_receive(:cmd).with(%(rsync -a -u #@home/Downloads/ #@home/Reference 2>&1))
+      it 'syncs the expanded paths, retaining backslash' do
+        expect(@maid).to receive(:cmd).with(%(rsync -a -u #@home/Downloads/ #@home/Reference 2>&1))
         @maid.sync(@src_dir, @dst_dir)
       end
 
-      it 'should log the action' do
-        @logger.should_receive(:info)
+      it 'logs the action' do
+        expect(@logger).to receive(:info)
         @maid.sync(@src_dir, @dst_dir)
       end
 
-      it 'should have no options' do
-        @maid.should_receive(:cmd).with(%(rsync  #@home/Downloads/ #@home/Reference 2>&1))
+      it 'has no options' do
+        expect(@maid).to receive(:cmd).with(%(rsync  #@home/Downloads/ #@home/Reference 2>&1))
         @maid.sync(@src_dir, @dst_dir, :archive => false, :update => false)
       end
 
-      it 'should add all options' do
-        @maid.should_receive(:cmd).with(%(rsync -a -v -u -m --exclude=.git --delete #@home/Downloads/ #@home/Reference 2>&1))
+      it 'adds all options' do
+        expect(@maid).to receive(:cmd).with(%(rsync -a -v -u -m --exclude=.git --delete #@home/Downloads/ #@home/Reference 2>&1))
         @maid.sync(@src_dir, @dst_dir, :archive => true, :update => true, :delete => true, :verbose => true, :prune_empty => true, :exclude => '.git')
       end
 
-      it 'should add multiple exlcude options' do
-        @maid.
-          should_receive(:cmd).
+      it 'adds multiple exlcude options' do
+        expect(@maid).to receive(:cmd).
           with(%(rsync -a -u --exclude=.git --exclude=.rvmrc #@home/Downloads/ #@home/Reference 2>&1))
         @maid.sync(@src_dir, @dst_dir, :exclude => ['.git', '.rvmrc'])
       end
 
-      it 'should add noop option' do
+      it 'adds noop option' do
         @maid.file_options[:noop] = true
-        @maid.should_receive(:cmd).with(%(rsync -a -u -n #@home/Downloads/ #@home/Reference 2>&1))
+        expect(@maid).to receive(:cmd).with(%(rsync -a -u -n #@home/Downloads/ #@home/Reference 2>&1))
         @maid.sync(@src_dir, @dst_dir)
       end
     end
@@ -556,26 +559,26 @@ module Maid
     end
 
     describe '#dupes_in' do
-      it 'should list duplicate files in arrays' do
+      it 'lists duplicate files in arrays' do
         dupes = @maid.dupes_in(file_fixtures_glob)
-        dupes.first.should be_kind_of(Array)
+        expect(dupes.first).to be_kind_of(Array)
 
         basenames = dupes.flatten.map { |p| File.basename(p) }
-        basenames.should == %w(1.zip bar.zip foo.zip)
+        expect(basenames).to eq(%w(1.zip bar.zip foo.zip))
       end
     end
 
     describe '#verbose_dupes_in' do
-      it 'should list all but the shortest-named dupe' do
+      it 'lists all but the shortest-named dupe' do
         dupes = @maid.verbose_dupes_in(file_fixtures_glob)
 
         basenames = dupes.flatten.map { |p| File.basename(p) }
-        basenames.should == %w(bar.zip foo.zip)
+        expect(basenames).to eq(%w(bar.zip foo.zip))
       end
     end
 
     describe '#newest_dupes_in' do
-      it 'should list all but the oldest dupe' do
+      it 'lists all but the oldest dupe' do
         # FIXME: Broken on Ruby 2.1.0-preview2, maybe because of FakeFS
         #
         #     oldest_path = "#{file_fixtures_path}/foo.zip"
@@ -587,20 +590,20 @@ module Maid
         dupes = @maid.newest_dupes_in(file_fixtures_glob)
 
         basenames = dupes.flatten.map { |p| File.basename(p) }
-        basenames.should == %w(bar.zip 1.zip)
+        expect(basenames).to eq(%w(bar.zip 1.zip))
       end
     end
 
     describe '#mime_type' do
       context 'given a JPEG image' do
         it 'reports "image/jpeg"' do
-          @maid.mime_type(image_path).should == 'image/jpeg'
+          expect(@maid.mime_type(image_path)).to eq('image/jpeg')
         end
       end
 
       context 'given an unknown type' do
         it 'returns nil' do
-          @maid.mime_type(unknown_path).should be_nil
+          expect(@maid.mime_type(unknown_path)).to be_nil
         end
       end
     end
@@ -608,13 +611,13 @@ module Maid
     describe '#media_type' do
       context 'given a JPEG image' do
         it 'reports "image"' do
-          @maid.media_type(image_path).should == 'image'
+          expect(@maid.media_type(image_path)).to eq('image')
         end
       end
 
       context 'given an unknown type' do
         it 'returns nil' do
-          @maid.media_type(unknown_path).should be_nil
+          expect(@maid.media_type(unknown_path)).to be_nil
         end
       end
     end
@@ -624,8 +627,8 @@ module Maid
         it 'only lists the fixture JPEG' do
           matches = @maid.where_content_type(@maid.dir(file_fixtures_glob), 'image')
 
-          matches.length.should == 1
-          matches.first.should end_with('spec/fixtures/files/ruby.jpg')
+          expect(matches.length).to eq(1)
+          expect(matches.first).to end_with('spec/fixtures/files/ruby.jpg')
         end
       end
     end