jbox-gitolite 1.2.2 → 1.2.3

data/spec/dirty_proxy_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Gitolite::DirtyProxy do
 
   it "should create a new instance given valid attributes" do
-    Gitolite::DirtyProxy.new([]).should_not be_nil
+    expect(Gitolite::DirtyProxy.new([])).to_not be_nil
   end
 
 
@@ -13,11 +13,11 @@ describe Gitolite::DirtyProxy do
 
   describe 'delegating to the target object' do
     it 'should act as instance of the target' do
-      proxy.should be_instance_of target.class
+      expect(proxy).to be_instance_of target.class
     end
 
     it 'should respond to all methods of the target' do
-      proxy.should respond_to(*target.methods)
+      expect(proxy).to respond_to(*target.methods)
     end
 
     it 'should equal the target' do
@@ -28,27 +28,27 @@ describe Gitolite::DirtyProxy do
 
   describe 'dirty checking methods' do
     it 'should respond to clean_up!' do
-      proxy.respond_to?(:clean_up!).should be_true
+      expect(proxy.respond_to?(:clean_up!)).to be true
     end
 
     it 'should respond to dirty?' do
-      proxy.respond_to?(:dirty?).should be_true
+      expect(proxy.respond_to?(:dirty?)).to be true
     end
 
     context 'when just initialized' do
       it 'should be clean' do
-        proxy.dirty?.should be_false
+        expect(proxy.dirty?).to be false
       end
     end
 
     shared_examples 'dirty? clean_up!' do
       it 'should be dirty' do
-        proxy.dirty?.should be_true
+        expect(proxy.dirty?).to be true
       end
 
       it 'should be clean again after clean_up!' do
         proxy.clean_up!
-        proxy.dirty?.should be_false
+        expect(proxy.dirty?).to be false
       end
     end
 

data/spec/gitolite_admin_spec.rb

@@ -8,7 +8,7 @@ describe Gitolite::GitoliteAdmin do
 
   describe '#bootstrap' do
     it 'should bootstrap a gitolite-admin repository' do
-      test_dir = File.join(output_dir, 'gitolite-admin-test')
+      test_dir = File.join(output_dir, 'gitolite-admin-test1')
       opts = { :overwrite => false }
       gl_admin = GitoliteAdmin.bootstrap(test_dir, opts)
 
@@ -17,7 +17,7 @@ describe Gitolite::GitoliteAdmin do
     end
 
     it 'should bootstrap (overwrite) a gitolite-admin repository' do
-      test_dir = File.join(output_dir, 'gitolite-admin-test')
+      test_dir = File.join(output_dir, 'gitolite-admin-test1')
       opts = { :overwrite => true }
       gl_admin = GitoliteAdmin.bootstrap(test_dir, opts)
 
@@ -35,7 +35,7 @@ describe Gitolite::GitoliteAdmin do
 
   describe '#save' do
     it 'should commit file to gitolite-admin repository' do
-      test_dir = File.join(output_dir, 'gitolite-admin-test')
+      test_dir = File.join(output_dir, 'gitolite-admin-test2')
       opts = { :overwrite => true }
       gl_admin = GitoliteAdmin.bootstrap(test_dir, opts)
 

data/spec/group_spec.rb

@@ -4,14 +4,14 @@ describe Gitolite::Config::Group do
   describe "#new" do
     it "should create a new group with an empty list of users" do
       group = Gitolite::Config::Group.new("testgroup")
-      group.users.empty?.should be true
-      group.name.should == "testgroup"
+      expect(group.users.empty?).to be true
+      expect(group.name).to eq "testgroup"
     end
 
     it "should create a new group with a name containing #{Gitolite::Config::Group::PREPEND_CHAR}" do
       name = "#{Gitolite::Config::Group::PREPEND_CHAR}testgroup"
       group = Gitolite::Config::Group.new(name)
-      group.name.should == "testgroup"
+      expect(group.name).to eq "testgroup"
     end
   end
 
@@ -23,52 +23,52 @@ describe Gitolite::Config::Group do
     describe "#add_user" do
       it "should allow adding one user with a string" do
         @group.add_user("bob")
-        @group.size.should == 1
-        @group.users.first.should == "bob"
+        expect(@group.size).to eq 1
+        expect(@group.users.first).to eq "bob"
       end
 
       it "should allow adding one user with a symbol" do
         @group.add_user(:bob)
-        @group.size.should == 1
-        @group.users.first.should == "bob"
+        expect(@group.size).to eq 1
+        expect(@group.users.first).to eq "bob"
       end
 
       it "should not add the same user twice" do
         @group.add_user("bob")
-        @group.size.should == 1
+        expect(@group.size).to eq 1
         @group.add_user(:bob)
-        @group.size.should == 1
-        @group.users.first.should == "bob"
+        expect(@group.size).to eq 1
+        expect(@group.users.first).to eq "bob"
       end
 
       it "should maintain users in sorted order" do
         @group.add_user("susan")
         @group.add_user("peyton")
         @group.add_user("bob")
-        @group.users.first.should == "bob"
-        @group.users.last.should == "susan"
+        expect(@group.users.first).to eq "bob"
+        expect(@group.users.last).to eq "susan"
       end
     end
 
     describe "#add_users" do
       it "should allow adding multiple users at once" do
         @group.add_users("bob", "joe", "sue", "sam", "dan")
-        @group.size.should == 5
+        expect(@group.size).to eq 5
       end
 
       it "should allow adding multiple users in nested arrays" do
         @group.add_users(["bob", "joe", ["sam", "sue", "dan"]], "bill")
-        @group.size.should == 6
+        expect(@group.size).to eq 6
       end
 
       it "should allow adding users of symbols and strings" do
         @group.add_users("bob", :joe, :sue, "sam")
-        @group.size.should == 4
+        expect(@group.size).to eq 4
       end
 
       it "should not add the same user twice" do
         @group.add_users("bob", :bob, "bob", "sam")
-        @group.size.should == 2
+        expect(@group.size).to eq 2
       end
     end
 
@@ -79,40 +79,40 @@ describe Gitolite::Config::Group do
 
       it "should support removing a user via a String" do
         @group.rm_user("bob")
-        @group.size.should == 4
+        expect(@group.size).to eq 4
       end
 
       it "should support removing a user via a Symbol" do
         @group.rm_user(:bob)
-        @group.size.should == 4
+        expect(@group.size).to eq 4
       end
     end
 
     describe "#empty!" do
       it "should clear all users from the group" do
         @group.add_users("bob", "joe", "sue", "jim")
-        @group.size.should == 4
+        expect(@group.size).to eq 4
         @group.empty!
-        @group.size.should == 0
+        expect(@group.size).to eq 0
       end
     end
 
     describe "#size" do
       it "should reflect how many users are in the group" do
         @group.add_users("bob", "joe", "sue", "jim")
-        @group.users.length.should == @group.size
+        expect(@group.users.length).to eq @group.size
       end
     end
 
     describe "#has_user?" do
       it "should search for a user via a String" do
         @group.add_user("bob")
-        @group.has_user?("bob").should be true
+        expect(@group.has_user?("bob")).to be true
       end
 
       it "should search for a user via a Symbol" do
         @group.add_user(:bob)
-        @group.has_user?(:bob).should be true
+        expect(@group.has_user?(:bob)).to be true
       end
     end
   end
@@ -120,6 +120,8 @@ describe Gitolite::Config::Group do
   describe "#to_s" do
     group = Gitolite::Config::Group.new("testgroup")
     group.add_users("bob", "joe", "sam", "sue")
-    group.to_s.should == "@testgroup          = bob joe sam sue\n" #10 spaces after @testgroup
+    it {
+      expect(group.to_s).to eq "@testgroup          = bob joe sam sue\n" #10 spaces after @testgroup
+    }
   end
 end

data/spec/repo_spec.rb

@@ -7,7 +7,7 @@ describe Gitolite::Config::Repo do
 
   describe '#new' do
     it 'should create a repo called "CoolRepo"' do
-      @repo.name.should == "CoolRepo"
+      expect(@repo.name).to eq "CoolRepo"
     end
   end
 
@@ -19,36 +19,36 @@ describe Gitolite::Config::Repo do
       @repo.add_permission("RW", "refs/tags/test[0-9]", "@teachers", "bill", "todd")
       @repo.add_permission("R", "refs/tags/test[0-9]", "@profs")
 
-      @repo.permissions.length.should == 2
-      @repo.permissions[0].size.should == 2
-      @repo.permissions[1].size.should == 3
+      expect(@repo.permissions.length).to eq 2
+      expect(@repo.permissions[0].size).to eq 2
+      expect(@repo.permissions[1].size).to eq 3
     end
   end
 
   describe '#add_permission' do
     it 'should allow adding a permission to the permissions list' do
       @repo.add_permission("RW+")
-      @repo.permissions.length.should == 1
-      @repo.permissions.first.keys.first.should == "RW+"
+      expect(@repo.permissions.length).to eq 1
+      expect(@repo.permissions.first.keys.first).to eq "RW+"
     end
 
     it 'should allow adding a permission while specifying a refex' do
       @repo.add_permission("RW+", "refs/heads/master")
-      @repo.permissions.length.should == 1
-      @repo.permissions.first.keys.first.should == "RW+"
-      @repo.permissions.first.values.last.first.first.should == "refs/heads/master"
+      expect(@repo.permissions.length).to eq 1
+      expect(@repo.permissions.first.keys.first).to eq "RW+"
+      expect(@repo.permissions.first.values.last.first.first).to eq "refs/heads/master"
     end
 
     it 'should allow specifying users individually' do
       @repo.add_permission("RW+", "", "bob", "joe", "susan", "sam", "bill")
-      @repo.permissions.first["RW+"][""].should == %w[bob joe susan sam bill]
+      expect(@repo.permissions.first["RW+"][""]).to eq %w[bob joe susan sam bill]
     end
 
     it 'should allow specifying users as an array' do
       users = %w[bob joe susan sam bill]
 
       @repo.add_permission("RW+", "", users)
-      @repo.permissions.first["RW+"][""].should == users
+      expect(@repo.permissions.first["RW+"][""]).to eq users
     end
 
     it 'should not allow adding an invalid permission via an InvalidPermissionError' do
@@ -145,13 +145,13 @@ describe Gitolite::Config::Repo do
   describe 'git config options' do
     it 'should allow setting a git configuration option' do
       email = "bob@zilla.com"
-      @repo.set_git_config("email", email).should == email
+      expect(@repo.set_git_config("email", email)).to eq email
     end
 
     it 'should allow deletion of an existing git configuration option' do
       email = "bob@zilla.com"
       @repo.set_git_config("email", email)
-      @repo.unset_git_config("email").should == email
+      expect(@repo.unset_git_config("email")).to eq email
     end
 
   end
@@ -160,9 +160,9 @@ describe Gitolite::Config::Repo do
     it 'should allow setting a gitolite option' do
       master = "kenobi"
       slaves = "one"
-      @repo.set_gitolite_option("mirror.master", master).should == master
-      @repo.set_gitolite_option("mirror.slaves", slaves).should == slaves
-      @repo.options.length.should == 2
+      expect(@repo.set_gitolite_option("mirror.master", master)).to eq master
+      expect(@repo.set_gitolite_option("mirror.slaves", slaves)).to eq slaves
+      expect(@repo.options.length).to eq 2
     end
 
     it 'should allow deletion of an existing gitolite option' do
@@ -170,9 +170,9 @@ describe Gitolite::Config::Repo do
       slaves = "one"
       @repo.set_gitolite_option("mirror.master", master)
       @repo.set_gitolite_option("mirror.slaves", slaves)
-      @repo.options.length.should == 2
-      @repo.unset_gitolite_option("mirror.master").should == master
-      @repo.options.length.should == 1
+      expect(@repo.options.length).to eq 2
+      expect(@repo.unset_gitolite_option("mirror.master")).to eq master
+      expect(@repo.options.length).to eq 1
     end
   end
 
@@ -183,8 +183,8 @@ describe Gitolite::Config::Repo do
 
       @repo.add_permission("RW+", "", users)
       @repo.add_permission("RW+", "", more_users)
-      @repo.permissions.first["RW+"][""].should == users.concat(more_users)
-      @repo.permissions.first["RW+"][""].length.should == 9
+      expect(@repo.permissions.first["RW+"][""]).to eq users.concat(more_users)
+      expect(@repo.permissions.first["RW+"][""].length).to eq 9
     end
 
     it 'should not list the same users twice for the same permission level' do
@@ -195,8 +195,8 @@ describe Gitolite::Config::Repo do
       @repo.add_permission("RW+", "", users)
       @repo.add_permission("RW+", "", more_users)
       @repo.add_permission("RW+", "", even_more_users)
-      @repo.permissions.first["RW+"][""].should == users.concat(more_users).concat(even_more_users).uniq!
-      @repo.permissions.first["RW+"][""].length.should == 11
+      expect(@repo.permissions.first["RW+"][""]).to eq users.concat(more_users).concat(even_more_users).uniq!
+      expect(@repo.permissions.first["RW+"][""].length).to eq 11
     end
   end
 end

data/spec/ssh_key_spec.rb

@@ -12,14 +12,14 @@ describe Gitolite::SSHKey do
       key_string = File.read(key)
       s = SSHKey.from_string(key_string, "bob")
 
-      s.owner.should == 'bob'
-      s.location.should == ""
-      s.blob.should == key_string.split[1]
+      expect(s.owner).to eq 'bob'
+      expect(s.location).to eq ""
+      expect(s.blob).to eq key_string.split[1]
     end
 
     it 'should raise an ArgumentError when an owner isnt specified' do
       key_string = "not_a_real_key"
-      lambda { SSHKey.from_string(key_string) }.should raise_error
+      expect(lambda { SSHKey.from_string(key_string) }).to raise_error
     end
 
     it 'should have a location when one is specified' do
@@ -27,17 +27,17 @@ describe Gitolite::SSHKey do
       key_string = File.read(key)
       s = SSHKey.from_string(key_string, "bob", "kansas")
 
-      s.owner.should == 'bob'
-      s.location.should == "kansas"
-      s.blob.should == key_string.split[1]
+      expect(s.owner).to eq 'bob'
+      expect(s.location).to eq "kansas"
+      expect(s.blob).to eq key_string.split[1]
     end
 
     it 'should raise an ArgumentError when owner is nil' do
-      lambda { SSHKey.from_string("bad_string", nil) }.should raise_error
+      expect(lambda { SSHKey.from_string("bad_string", nil) }).to raise_error
     end
 
     it 'should raise an ArgumentError when we get an invalid SSHKey string' do
-      lambda { SSHKey.from_string("bad_string", "bob") }.should raise_error
+      expect(lambda { SSHKey.from_string("bad_string", "bob") }).to raise_error
     end
   end
 
@@ -47,22 +47,22 @@ describe Gitolite::SSHKey do
       s = SSHKey.from_file(key)
       key_string = File.read(key).split
 
-      s.owner.should == "bob"
-      s.blob.should == key_string[1]
+      expect(s.owner).to eq "bob"
+      expect(s.blob).to eq key_string[1]
     end
 
     it 'should load a key with a location from a file' do
       key = File.join(key_dir, 'bob@desktop.pub')
       s = SSHKey.from_file(key)
-      s.owner.should == 'bob'
-      s.location.should == 'desktop'
+      expect(s.owner).to eq 'bob'
+      expect(s.location).to eq 'desktop'
     end
 
     it 'should load a key with owner and location from a file' do
       key = File.join(key_dir, 'joe-bob@god-zilla.com@desktop.pub')
       s = SSHKey.from_file(key)
-      s.owner.should == 'joe-bob@god-zilla.com'
-      s.location.should == 'desktop'
+      expect(s.owner).to eq 'joe-bob@god-zilla.com'
+      expect(s.location).to eq 'desktop'
     end
   end
 
@@ -70,67 +70,67 @@ describe Gitolite::SSHKey do
     it 'owner should be bob for bob.pub' do
       key = File.join(key_dir, 'bob.pub')
       s = SSHKey.from_file(key)
-      s.owner.should == 'bob'
+      expect(s.owner).to eq 'bob'
     end
 
     it 'owner should be bob for bob@desktop.pub' do
       key = File.join(key_dir, 'bob@desktop.pub')
       s = SSHKey.from_file(key)
-      s.owner.should == 'bob'
+      expect(s.owner).to eq 'bob'
     end
 
     it 'owner should be bob@zilla.com for bob@zilla.com.pub' do
       key = File.join(key_dir, 'bob@zilla.com.pub')
       s = SSHKey.from_file(key)
-      s.owner.should == 'bob@zilla.com'
+      expect(s.owner).to eq 'bob@zilla.com'
     end
 
     it "owner should be joe-bob@god-zilla.com for joe-bob@god-zilla.com@desktop.pub" do
       key = File.join(key_dir, 'joe-bob@god-zilla.com@desktop.pub')
       s = SSHKey.from_file(key)
-      s.owner.should == 'joe-bob@god-zilla.com'
+      expect(s.owner).to eq 'joe-bob@god-zilla.com'
     end
 
     it "owner should be bob.joe@test.zilla.com for bob.joe@test.zilla.com@desktop.pub" do
       key = File.join(key_dir, 'bob.joe@test.zilla.com@desktop.pub')
       s = SSHKey.from_file(key)
-      s.owner.should == 'bob.joe@test.zilla.com'
+      expect(s.owner).to eq 'bob.joe@test.zilla.com'
     end
 
     it "owner should be bob+joe@test.zilla.com for bob+joe@test.zilla.com@desktop.pub" do
       key = File.join(key_dir, 'bob+joe@test.zilla.com@desktop.pub')
       s = SSHKey.from_file(key)
-      s.owner.should == 'bob+joe@test.zilla.com'
+      expect(s.owner).to eq 'bob+joe@test.zilla.com'
     end
 
     it 'owner should be bob@zilla.com for bob@zilla.com@desktop.pub' do
       key = File.join(key_dir, 'bob@zilla.com@desktop.pub')
       s = SSHKey.from_file(key)
-      s.owner.should == 'bob@zilla.com'
+      expect(s.owner).to eq 'bob@zilla.com'
     end
 
     it 'owner should be jakub123 for jakub123.pub' do
       key = File.join(key_dir, 'jakub123.pub')
       s = SSHKey.from_file(key)
-      s.owner.should == 'jakub123'
+      expect(s.owner).to eq 'jakub123'
     end
 
     it 'owner should be jakub123@foo.net for jakub123@foo.net.pub' do
       key = File.join(key_dir, 'jakub123@foo.net.pub')
       s = SSHKey.from_file(key)
-      s.owner.should == 'jakub123@foo.net'
+      expect(s.owner).to eq 'jakub123@foo.net'
     end
 
     it 'owner should be joe@sch.ool.edu for joe@sch.ool.edu' do
       key = File.join(key_dir, 'joe@sch.ool.edu.pub')
       s = SSHKey.from_file(key)
-      s.owner.should == 'joe@sch.ool.edu'
+      expect(s.owner).to eq 'joe@sch.ool.edu'
     end
 
     it 'owner should be joe@sch.ool.edu for joe@sch.ool.edu@desktop.pub' do
       key = File.join(key_dir, 'joe@sch.ool.edu@desktop.pub')
       s = SSHKey.from_file(key)
-      s.owner.should == 'joe@sch.ool.edu'
+      expect(s.owner).to eq 'joe@sch.ool.edu'
     end
   end
 
@@ -138,55 +138,55 @@ describe Gitolite::SSHKey do
     it 'location should be "" for bob.pub' do
       key = File.join(key_dir, 'bob.pub')
       s = SSHKey.from_file(key)
-      s.location.should == ''
+      expect(s.location).to eq ''
     end
 
     it 'location should be "desktop" for bob@desktop.pub' do
       key = File.join(key_dir, 'bob@desktop.pub')
       s = SSHKey.from_file(key)
-      s.location.should == 'desktop'
+      expect(s.location).to eq 'desktop'
     end
 
     it 'location should be "" for bob@zilla.com.pub' do
       key = File.join(key_dir, 'bob@zilla.com.pub')
       s = SSHKey.from_file(key)
-      s.location.should == ''
+      expect(s.location).to eq ''
     end
 
     it 'location should be "desktop" for bob@zilla.com@desktop.pub' do
       key = File.join(key_dir, 'bob@zilla.com@desktop.pub')
       s = SSHKey.from_file(key)
-      s.location.should == 'desktop'
+      expect(s.location).to eq 'desktop'
     end
 
     it 'location should be "" for jakub123.pub' do
       key = File.join(key_dir, 'jakub123.pub')
       s = SSHKey.from_file(key)
-      s.location.should == ''
+      expect(s.location).to eq ''
     end
 
     it 'location should be "" for jakub123@foo.net.pub' do
       key = File.join(key_dir, 'jakub123@foo.net.pub')
       s = SSHKey.from_file(key)
-      s.location.should == ''
+      expect(s.location).to eq ''
     end
 
     it 'location should be "" for joe@sch.ool.edu' do
       key = File.join(key_dir, 'joe@sch.ool.edu.pub')
       s = SSHKey.from_file(key)
-      s.location.should == ''
+      expect(s.location).to eq ''
     end
 
     it 'location should be "desktop" for joe@sch.ool.edu@desktop.pub' do
       key = File.join(key_dir, 'joe@sch.ool.edu@desktop.pub')
       s = SSHKey.from_file(key)
-      s.location.should == 'desktop'
+      expect(s.location).to eq 'desktop'
     end
 
     it 'location should be "foo-bar" for bob@foo-bar.pub' do
       key = File.join(key_dir, 'bob@foo-bar.pub')
       s = SSHKey.from_file(key)
-      s.location.should == 'foo-bar'
+      expect(s.location).to eq 'foo-bar'
     end
   end
 
@@ -196,9 +196,9 @@ describe Gitolite::SSHKey do
       s = SSHKey.from_file(key)
       parts = File.read(key).split #should get type, blob, email
 
-      s.type.should == parts[0]
-      s.blob.should == parts[1]
-      s.email.should == parts[2]
+      expect(s.type).to eq parts[0]
+      expect(s.blob).to eq parts[1]
+      expect(s.email).to eq parts[2]
     end
   end
 
@@ -206,7 +206,7 @@ describe Gitolite::SSHKey do
     it 'should use owner if email is missing' do
       key = File.join(key_dir, 'jakub123@foo.net.pub')
       s = SSHKey.from_file(key)
-      s.owner.should == s.email
+      expect(s.owner).to eq s.email
     end
   end
 
@@ -218,8 +218,8 @@ describe Gitolite::SSHKey do
 
       s = SSHKey.new(type, blob, email)
 
-      s.to_s.should == [type, blob, email].join(' ')
-      s.owner.should == email
+      expect(s.to_s).to eq [type, blob, email].join(' ')
+      expect(s.owner).to eq email
     end
 
     it 'should create a valid ssh key while specifying an owner' do
@@ -230,8 +230,8 @@ describe Gitolite::SSHKey do
 
       s = SSHKey.new(type, blob, email, owner)
 
-      s.to_s.should == [type, blob, email].join(' ')
-      s.owner.should == owner
+      expect(s.to_s).to eq [type, blob, email].join(' ')
+      expect(s.owner).to eq owner
     end
 
     it 'should create a valid ssh key while specifying an owner and location' do
@@ -243,9 +243,9 @@ describe Gitolite::SSHKey do
 
       s = SSHKey.new(type, blob, email, owner, location)
 
-      s.to_s.should == [type, blob, email].join(' ')
-      s.owner.should == owner
-      s.location.should == location
+      expect(s.to_s).to eq [type, blob, email].join(' ')
+      expect(s.owner).to eq owner
+      expect(s.location).to eq location
     end
   end
 
@@ -260,7 +260,7 @@ describe Gitolite::SSHKey do
       hash_test = [owner, location, type, blob, email].hash
       s = SSHKey.new(type, blob, email, owner, location)
 
-      s.hash.should == hash_test
+      expect(s.hash).to eq hash_test
     end
   end
 
@@ -272,7 +272,7 @@ describe Gitolite::SSHKey do
 
       s = SSHKey.new(type, blob, email)
 
-      s.filename.should == "#{email}.pub"
+      expect(s.filename).to eq "#{email}.pub"
     end
 
     it 'should create a filename that is the <owner>.pub' do
@@ -283,7 +283,7 @@ describe Gitolite::SSHKey do
 
       s = SSHKey.new(type, blob, email, owner)
 
-      s.filename.should == "#{owner}.pub"
+      expect(s.filename).to eq "#{owner}.pub"
     end
 
     it 'should create a filename that is the <email>@<location>.pub' do
@@ -294,7 +294,7 @@ describe Gitolite::SSHKey do
 
       s = SSHKey.new(type, blob, email, nil, location)
 
-      s.filename.should == "#{email}@#{location}.pub"
+      expect(s.filename).to eq "#{email}@#{location}.pub"
     end
 
     it 'should create a filename that is the <owner>@<location>.pub' do
@@ -306,7 +306,7 @@ describe Gitolite::SSHKey do
 
       s = SSHKey.new(type, blob, email, owner, location)
 
-      s.filename.should == "#{owner}@#{location}.pub"
+      expect(s.filename).to eq "#{owner}@#{location}.pub"
     end
   end
 
@@ -324,7 +324,7 @@ describe Gitolite::SSHKey do
       s.to_file(output_dir)
 
       ## compare raw string with written file
-      s.to_s.should == File.read(File.join(output_dir, s.filename))
+      expect(s.to_s).to eq File.read(File.join(output_dir, s.filename))
     end
 
     it 'should return the filename written' do
@@ -336,7 +336,7 @@ describe Gitolite::SSHKey do
 
       s = SSHKey.new(type, blob, email, owner, location)
 
-      s.to_file(output_dir).should == File.join(output_dir, s.filename)
+      expect(s.to_file(output_dir)).to eq File.join(output_dir, s.filename)
     end
   end
 
@@ -349,7 +349,7 @@ describe Gitolite::SSHKey do
       s1 = SSHKey.new(type, blob, email)
       s2 = SSHKey.new(type, blob, email)
 
-      s1.should == s2
+      expect(s1).to eq s2
     end
   end
 end