socialcast 1.3.16 → 1.3.17

data/spec/socialcast/command_line/ldap_connector_spec.rb

@@ -49,8 +49,8 @@ describe Socialcast::CommandLine::LDAPConnector do
   let(:ldap) { double(Net::LDAP, :open => nil, :encryption => nil, :auth => nil) }
 
   before do
-    ldap.stub(:open).and_yield
-    Net::LDAP.stub(:new).and_return(ldap)
+    allow(ldap).to receive(:open).and_yield
+    allow(Net::LDAP).to receive(:new).and_return(ldap)
   end
 
   def create_entry(cn, entry_attributes)
@@ -66,7 +66,7 @@ describe Socialcast::CommandLine::LDAPConnector do
       let(:connector) { Socialcast::CommandLine::LDAPConnector.new('connection_1', ldap_config) }
       let(:entry) { create_entry('user', :mail => 'user@example.com', :givenName => 'first name', :sn => 'last name') }
       before do
-        ldap.should_receive(:search).once.with(hash_including(:attributes => ['givenName', 'sn', 'mail', 'isMemberOf'])).and_yield(entry)
+        expect(ldap).to receive(:search).once.with(hash_including(:attributes => ['givenName', 'sn', 'mail', 'isMemberOf'])).and_yield(entry)
       end
       it do
         expect do |blk|
@@ -88,7 +88,7 @@ describe Socialcast::CommandLine::LDAPConnector do
       let(:connector) { Socialcast::CommandLine::LDAPConnector.new('connection_1', ldap_config) }
       let(:entry) { create_entry('user', :mail => nil, :givenName => 'first name', :sn => 'last name') }
       before do
-        ldap.should_receive(:search).once.with(hash_including(:attributes => ['givenName', 'sn', 'mail', 'isMemberOf'])).and_yield(entry)
+        expect(ldap).to receive(:search).once.with(hash_including(:attributes => ['givenName', 'sn', 'mail', 'isMemberOf'])).and_yield(entry)
       end
       it 'does not yield the entry' do
         expect do |blk|
@@ -108,7 +108,7 @@ describe Socialcast::CommandLine::LDAPConnector do
       let(:connector) { Socialcast::CommandLine::LDAPConnector.new('connection_1', ldap_config) }
       let(:entry) { create_entry('user', :uid => 'unique identifier', :givenName => 'first name', :sn => 'last name') }
       before do
-        ldap.should_receive(:search).once.with(hash_including(:attributes => ['givenName', 'sn', 'uid', 'isMemberOf'])).and_yield(entry)
+        expect(ldap).to receive(:search).once.with(hash_including(:attributes => ['givenName', 'sn', 'uid', 'isMemberOf'])).and_yield(entry)
       end
       it do
         expect do |blk|
@@ -137,7 +137,7 @@ describe Socialcast::CommandLine::LDAPConnector do
         }
       end
       before do
-        ldap.should_receive(:search).once.with(hash_including(:attributes => ['givenName', 'sn', 'mail', 'isMemberOf'])).and_yield(entry)
+        expect(ldap).to receive(:search).once.with(hash_including(:attributes => ['givenName', 'sn', 'mail', 'isMemberOf'])).and_yield(entry)
       end
       it "does not retrieve the profile photo data from ldap" do
         expect do |blk|
@@ -170,10 +170,10 @@ describe Socialcast::CommandLine::LDAPConnector do
         }
       end
       before do
-        ldap.should_receive(:search).once.ordered.with(hash_including(:attributes => ['mail']))
+        expect(ldap).to receive(:search).once.ordered.with(hash_including(:attributes => ['mail']))
           .and_yield(employee_mail_entry)
           .and_yield(manager_mail_entry)
-        ldap.should_receive(:search).once.ordered.with(hash_including(:attributes => ['givenName', 'sn', 'mail', 'manager_dn', 'isMemberOf']))
+        expect(ldap).to receive(:search).once.ordered.with(hash_including(:attributes => ['givenName', 'sn', 'mail', 'manager_dn', 'isMemberOf']))
           .and_yield(employee_entry)
           .and_yield(manager_entry)
       end
@@ -233,14 +233,14 @@ describe Socialcast::CommandLine::LDAPConnector do
         }
       end
       before do
-        ldap.should_receive(:search).once.ordered.with(hash_including(:attributes => ['mail']))
+        expect(ldap).to receive(:search).once.ordered.with(hash_including(:attributes => ['mail']))
           .and_yield(employee_mail_entry1)
           .and_yield(employee_mail_entry2)
           .and_yield(employee_mail_entry3)
           .and_yield(manager_mail_entry1)
           .and_yield(manager_mail_entry2)
 
-        ldap.should_receive(:search).once.ordered.with(hash_including(:attributes => ['givenName', 'sn', 'mail', 'manager_dn', 'isMemberOf']))
+        expect(ldap).to receive(:search).once.ordered.with(hash_including(:attributes => ['givenName', 'sn', 'mail', 'manager_dn', 'isMemberOf']))
           .and_yield(employee_entry1)
           .and_yield(employee_entry2)
           .and_yield(employee_entry3)
@@ -329,7 +329,7 @@ describe Socialcast::CommandLine::LDAPConnector do
       before do
         connection.merge!({ "mappings" => { "email" => "mailConnection" } })
         entry = create_entry 'user', :mailConnection => 'user@example.com'
-        ldap.should_receive(:search).once.with(hash_including(:attributes => ['mailConnection', 'isMemberOf'])).and_yield(entry)
+        expect(ldap).to receive(:search).once.with(hash_including(:attributes => ['mailConnection', 'isMemberOf'])).and_yield(entry)
       end
       it do
         expect do |blk|
@@ -362,7 +362,7 @@ describe Socialcast::CommandLine::LDAPConnector do
           }
         })
         entry = create_entry 'user', :mail => 'user@example.com', :givenName => 'first name', :sn => 'last name', :memberOf => ldap_groups
-        ldap.should_receive(:search).once.with(hash_including(:attributes => ['givenName', 'sn', 'mail', 'memberOf'])).and_yield(entry)
+        expect(ldap).to receive(:search).once.with(hash_including(:attributes => ['givenName', 'sn', 'mail', 'memberOf'])).and_yield(entry)
       end
       it do
         expect do |blk|
@@ -388,7 +388,7 @@ describe Socialcast::CommandLine::LDAPConnector do
           :isMemberOf => ["cn=External,dc=example,dc=com", "cn=TownHallAdmins,dc=example,dc=com"])
       end
       before do
-        ldap.should_receive(:search).once.with(hash_including(:attributes => ['givenName', 'sn', 'mail', 'isMemberOf'])).and_yield(entry)
+        expect(ldap).to receive(:search).once.with(hash_including(:attributes => ['givenName', 'sn', 'mail', 'isMemberOf'])).and_yield(entry)
       end
       it "sets the account_type to 'external' and does not include roles" do
         expect do |blk|
@@ -413,7 +413,7 @@ describe Socialcast::CommandLine::LDAPConnector do
           :isMemberOf => ["cn=TownHallAdmins,dc=example,dc=com", "cn=SbiAdmins,dc=example,dc=com"])
       end
       before do
-        ldap.should_receive(:search).once.with(hash_including(:attributes => ['givenName', 'sn', 'mail', 'isMemberOf'])).and_yield(entry)
+        expect(ldap).to receive(:search).once.with(hash_including(:attributes => ['givenName', 'sn', 'mail', 'isMemberOf'])).and_yield(entry)
       end
       it "sets the account_type to 'member' and includes roles" do
         expect do |blk|
@@ -454,13 +454,13 @@ describe Socialcast::CommandLine::LDAPConnector do
           :isMemberOf => ["cn=SFOffice,dc=example,dc=com", "cn=Sales,dc=example,dc=com"])
       end
       before do
-        ldap.should_receive(:search).once.ordered.with(
+        expect(ldap).to receive(:search).once.ordered.with(
           :return_result => false,
           :filter => "(objectClass=groupOfUniqueNames)",
           :base => "dc=example,dc=com",
           :attributes => ["gid"]).and_yield(group_entry1).and_yield(group_entry2).and_yield(group_entry3)
 
-        ldap.should_receive(:search).once.ordered.with(
+        expect(ldap).to receive(:search).once.ordered.with(
           :return_result => false,
           :filter => "(mail=*)",
           :base => "dc=example,dc=com",
@@ -486,7 +486,7 @@ describe Socialcast::CommandLine::LDAPConnector do
     context "calling when a search is already being performed" do
       let(:connector) { Socialcast::CommandLine::LDAPConnector.new('connection_1', ldap_config) }
       before do
-        ldap.should_receive(:search).and_yield(create_entry('user', :mail => 'user@example.com'))
+        expect(ldap).to receive(:search).and_yield(create_entry('user', :mail => 'user@example.com'))
       end
       it "raises an error" do
         expect do
@@ -502,7 +502,7 @@ describe Socialcast::CommandLine::LDAPConnector do
     context "calling when a search is already being performed, rescuing, then calling again" do
       let(:connector) { Socialcast::CommandLine::LDAPConnector.new('connection_1', ldap_config) }
       before do
-        ldap.should_receive(:search).and_yield(create_entry('user', :mail => 'user@example.com'))
+        expect(ldap).to receive(:search).and_yield(create_entry('user', :mail => 'user@example.com'))
       end
       it "raises an error" do
         expect do
@@ -535,7 +535,7 @@ describe Socialcast::CommandLine::LDAPConnector do
         }
       end
       before do
-        ldap.should_receive(:search).once.with(hash_including(:attributes => ['mail', 'jpegPhoto'])).and_yield(entry)
+        expect(ldap).to receive(:search).once.with(hash_including(:attributes => ['mail', 'jpegPhoto'])).and_yield(entry)
       end
       it do
         expect do |blk|
@@ -559,7 +559,7 @@ describe Socialcast::CommandLine::LDAPConnector do
         }
       end
       before do
-        ldap.should_receive(:search).once.with(hash_including(:attributes => ['mail', 'jpegPhoto'])).and_yield(entry)
+        expect(ldap).to receive(:search).once.with(hash_including(:attributes => ['mail', 'jpegPhoto'])).and_yield(entry)
       end
       it 'does not yield' do
         expect do |blk|
@@ -581,7 +581,7 @@ describe Socialcast::CommandLine::LDAPConnector do
         }
       end
       before do
-        ldap.should_receive(:search).once.with(hash_including(:attributes => ['mail', 'jpegPhoto'])).and_yield(entry)
+        expect(ldap).to receive(:search).once.with(hash_including(:attributes => ['mail', 'jpegPhoto'])).and_yield(entry)
       end
       it 'does not yield' do
         expect do |blk|
@@ -602,7 +602,7 @@ describe Socialcast::CommandLine::LDAPConnector do
         }
       end
       before do
-        ldap.should_receive(:search).once.with(hash_including(:attributes => ['mail', 'jpegPhoto'])).and_yield(entry)
+        expect(ldap).to receive(:search).once.with(hash_including(:attributes => ['mail', 'jpegPhoto'])).and_yield(entry)
       end
       it "does not raise an error" do
         expect do |blk|
@@ -628,12 +628,12 @@ describe Socialcast::CommandLine::LDAPConnector do
       let(:entry) { create_entry 'user', :uid => 'unique identifier', :givenName => 'first name', :sn => 'last name' }
       before do
         filter = Net::LDAP::Filter.construct('(&(mail=*)(uid=unique identifier))')
-        ldap.should_receive(:search).once
+        expect(ldap).to receive(:search).once
           .with(hash_including(:attributes => ['givenName', 'sn', 'uid', 'isMemberOf'], :filter => filter))
           .and_yield(entry)
       end
       it do
-        connector.fetch_user_hash('unique identifier', {}).should == {
+        expect(connector.fetch_user_hash('unique identifier', {})).to eq({
           'account_type' => 'member',
           'contact_info' => {},
           'custom_fields' => [],
@@ -641,7 +641,7 @@ describe Socialcast::CommandLine::LDAPConnector do
           'last_name' => 'last name',
           'roles' => [],
           'unique_identifier' => 'unique identifier'
-        }
+        })
       end
     end
 
@@ -650,12 +650,12 @@ describe Socialcast::CommandLine::LDAPConnector do
       let(:entry) { create_entry 'user', :mail => 'user@example.com', :givenName => 'first name', :sn => 'last name' }
       before do
         filter = Net::LDAP::Filter.construct('(&(mail=*)(mail=user@example.com))')
-        ldap.should_receive(:search).once
+        expect(ldap).to receive(:search).once
           .with(hash_including(:attributes => ['givenName', 'sn', 'mail', 'isMemberOf'], :filter => filter))
           .and_yield(entry)
       end
       it do
-        connector.fetch_user_hash('user@example.com', :identifying_field => 'email').should == {
+        expect(connector.fetch_user_hash('user@example.com', :identifying_field => 'email')).to eq({
           'account_type' => 'member',
           'contact_info' => {
             'email' => 'user@example.com'
@@ -664,7 +664,7 @@ describe Socialcast::CommandLine::LDAPConnector do
           'first_name' => 'first name',
           'last_name' => 'last name',
           'roles' => []
-        }
+        })
       end
     end
 
@@ -674,12 +674,12 @@ describe Socialcast::CommandLine::LDAPConnector do
       let(:entry) { create_entry 'user', :mail => 'user@example.com', :givenName => 'first name', :sn => 'last name' }
       before do
         filter = Net::LDAP::Filter.construct('(&(objectclass=*)(mail=user@example.com))')
-        ldap.should_receive(:search).once
+        expect(ldap).to receive(:search).once
           .with(hash_including(:attributes => ['givenName', 'sn', 'mail', 'isMemberOf'], :filter => filter))
           .and_yield(entry)
       end
       it do
-        connector.fetch_user_hash('user@example.com', :identifying_field => 'email').should == {
+        expect(connector.fetch_user_hash('user@example.com', :identifying_field => 'email')).to eq({
           'account_type' => 'member',
           'contact_info' => {
             'email' => 'user@example.com'
@@ -688,7 +688,7 @@ describe Socialcast::CommandLine::LDAPConnector do
           'first_name' => 'first name',
           'last_name' => 'last name',
           'roles' => []
-        }
+        })
       end
     end
 
@@ -713,30 +713,30 @@ describe Socialcast::CommandLine::LDAPConnector do
         }
       end
       before do
-        ldap.should_receive(:search).once.ordered.with(
+        expect(ldap).to receive(:search).once.ordered.with(
           :return_result => false,
           :filter => "(objectClass=groupOfUniqueNames)",
           :base => "dc=example,dc=com",
           :attributes => ["gid"]).and_yield(group)
 
-        ldap.should_receive(:search).once.ordered.with(
+        expect(ldap).to receive(:search).once.ordered.with(
           :return_result => false,
           :filter => "(mail=*)",
           :base => "dc=example,dc=com",
           :attributes => ["mail"]).and_yield(manager)
 
         filter1 = Net::LDAP::Filter.construct('(&(mail=*)(mail=user1@example.com))')
-        ldap.should_receive(:search).once.ordered
+        expect(ldap).to receive(:search).once.ordered
           .with(hash_including(:attributes => ['givenName', 'sn', 'mail', 'manager_dn', 'isMemberOf'], :filter => filter1))
           .and_yield(user1)
 
         filter2 = Net::LDAP::Filter.construct('(&(mail=*)(mail=user2@example.com))')
-        ldap.should_receive(:search).once.ordered
+        expect(ldap).to receive(:search).once.ordered
           .with(hash_including(:attributes => ['givenName', 'sn', 'mail', 'manager_dn', 'isMemberOf'], :filter => filter2))
           .and_yield(user2)
       end
       it "caches managers and groups" do
-        connector.fetch_user_hash('user1@example.com', :identifying_field => 'email').should == {
+        expect(connector.fetch_user_hash('user1@example.com', :identifying_field => 'email')).to eq({
           'account_type' => 'member',
           'contact_info' => {
             'email' => 'user1@example.com'
@@ -746,9 +746,9 @@ describe Socialcast::CommandLine::LDAPConnector do
           'last_name' => 'last name 1',
           'groups' => [],
           'roles' => []
-        }
+        })
 
-        connector.fetch_user_hash('user2@example.com', :identifying_field => 'email').should == {
+        expect(connector.fetch_user_hash('user2@example.com', :identifying_field => 'email')).to eq({
           'account_type' => 'member',
           'contact_info' => {
             'email' => 'user2@example.com'
@@ -758,7 +758,7 @@ describe Socialcast::CommandLine::LDAPConnector do
           'last_name' => 'last name 2',
           'groups' => ['sales_group_id'],
           'roles' => []
-        }
+        })
       end
     end
   end
@@ -780,12 +780,12 @@ describe Socialcast::CommandLine::LDAPConnector do
     let(:ldap_instance) { double(Net::LDAP, :encryption => nil, :auth => nil) }
     context "passed hash for attribute" do
       it "returns a string that used defined string template" do
-        connector.send(:grab, entry, { "value" => "123%{mail}", "mail" => "mail" }).should == "123sean@example.com"
+        expect(connector.send(:grab, entry, { "value" => "123%{mail}", "mail" => "mail" })).to eq("123sean@example.com")
       end
     end
     context "passed string for attribute" do
       it "returns exact string stored in entry" do
-        connector.send(:grab, entry, "mail").should == "sean@example.com"
+        expect(connector.send(:grab, entry, "mail")).to eq("sean@example.com")
       end
     end
     context "passed string that can be constantized and the resulting Class responds to run" do
@@ -797,7 +797,7 @@ describe Socialcast::CommandLine::LDAPConnector do
             end
           end
         end
-        connector.send(:grab, entry, "Socialcast::CommandLine::FakeAttributeMap").should == "sebn@exbmple.com"
+        expect(connector.send(:grab, entry, "Socialcast::CommandLine::FakeAttributeMap")).to eq("sebn@exbmple.com")
       end
     end
     context "passed string that must be classified and the resulting Class responds to run" do
@@ -809,7 +809,7 @@ describe Socialcast::CommandLine::LDAPConnector do
             end
           end
         end
-        connector.send(:grab, entry, "socialcast/command_line/fake_attribute_map").should == "sebn@exbmple.com"
+        expect(connector.send(:grab, entry, "socialcast/command_line/fake_attribute_map")).to eq("sebn@exbmple.com")
       end
     end
     context "attribute passed has a collision between string and Class" do
@@ -824,7 +824,7 @@ describe Socialcast::CommandLine::LDAPConnector do
         Object.send(:remove_const, :Mail)
       end
       it "returns the result of the Class run method" do
-        connector.send(:grab, entry, "mail").should == "sebn@exbmple.com"
+        expect(connector.send(:grab, entry, "mail")).to eq("sebn@exbmple.com")
       end
     end
     context "attribute passed constantizes to a module instead of a class" do
@@ -834,7 +834,7 @@ describe Socialcast::CommandLine::LDAPConnector do
             return "#{entry[:mail].first.gsub(/a/,'b')}"
           end
         end
-        connector.send(:grab, entry, "FakeAttributeMap").should == "sebn@exbmple.com"
+        expect(connector.send(:grab, entry, "FakeAttributeMap")).to eq("sebn@exbmple.com")
       end
     end
   end

data/spec/socialcast/command_line/provision_photo_spec.rb

@@ -8,13 +8,13 @@ describe Socialcast::CommandLine::ProvisionPhoto do
   let(:another_profile_photo_id) { 4 }
 
   before do
-    Socialcast::CommandLine::ProvisionPhoto.any_instance.stub(:default_profile_photo_id).and_return(default_profile_photo_id)
+    allow_any_instance_of(Socialcast::CommandLine::ProvisionPhoto).to receive(:default_profile_photo_id).and_return(default_profile_photo_id)
   end
 
   let(:ldap) do
     ldap_instance = double(Net::LDAP, :auth => nil, :encryption => nil)
-    ldap_instance.should_receive(:open).and_yield
-    Net::LDAP.should_receive(:new).and_return(ldap_instance)
+    expect(ldap_instance).to receive(:open).and_yield
+    expect(Net::LDAP).to receive(:new).and_return(ldap_instance)
     ldap_instance
   end
 
@@ -43,24 +43,24 @@ describe Socialcast::CommandLine::ProvisionPhoto do
       end
       before do
         entry = create_entry 'user', :mail => 'user@example.com', :jpegPhoto => photo_data
-        ldap.should_receive(:search).once.with(hash_including(:attributes => ['mail', 'jpegPhoto'])).and_yield(entry)
-        Socialcast::CommandLine.stub(:resource_for_path).with('/api/users/search', anything).and_return(user_search_resource)
+        expect(ldap).to receive(:search).once.with(hash_including(:attributes => ['mail', 'jpegPhoto'])).and_yield(entry)
+        allow(Socialcast::CommandLine).to receive(:resource_for_path).with('/api/users/search', anything).and_return(user_search_resource)
       end
 
       context 'for when it does successfully post the photo' do
         before do
-          user_search_resource.should_receive(:get).and_return(search_api_response.to_json)
+          expect(user_search_resource).to receive(:get).and_return(search_api_response.to_json)
           user_resource = double(:user_resource)
-          user_resource.should_receive(:put) do |data|
+          expect(user_resource).to receive(:put) do |data|
             uploaded_data = data[:user][:profile_photo][:data]
-            uploaded_data.path.should =~ /\.png\Z/
+            expect(uploaded_data.path).to match(/\.png\Z/)
           end
-          Socialcast::CommandLine.stub(:resource_for_path).with('/api/users/7', anything).and_return(user_resource)
+          allow(Socialcast::CommandLine).to receive(:resource_for_path).with('/api/users/7', anything).and_return(user_resource)
         end
         context 'for a binary file' do
           let(:photo_data) { "\x89PNGabc" }
           before do
-            RestClient.should_not_receive(:get)
+            expect(RestClient).not_to receive(:get)
             sync_photos
           end
           it 'uses the original binary to upload the photo' do end
@@ -68,7 +68,7 @@ describe Socialcast::CommandLine::ProvisionPhoto do
         context 'for an image file' do
           let(:photo_data) { "http://socialcast.com/someimage.png" }
           before do
-            RestClient.should_receive(:get).with(photo_data).and_return("\x89PNGabc")
+            expect(RestClient).to receive(:get).with(photo_data).and_return("\x89PNGabc")
             sync_photos
           end
           it 'downloads the image form the web to upload the photo' do end
@@ -79,8 +79,8 @@ describe Socialcast::CommandLine::ProvisionPhoto do
         context 'for an image file' do
           let(:photo_data) { "http://socialcast.com/someimage.png" }
           before do
-            user_search_resource.should_receive(:get).and_return(search_api_response.to_json)
-            RestClient.should_receive(:get).with(photo_data).and_raise(RestClient::ResourceNotFound)
+            expect(user_search_resource).to receive(:get).and_return(search_api_response.to_json)
+            expect(RestClient).to receive(:get).with(photo_data).and_raise(RestClient::ResourceNotFound)
             sync_photos
           end
           it 'tries to download the image from the web and rescues 404' do end
@@ -89,22 +89,22 @@ describe Socialcast::CommandLine::ProvisionPhoto do
 
       context 'when there is already a photo set' do
         before do
-          Socialcast::CommandLine::ProvisionPhoto.any_instance.stub(:default_profile_photo_id).and_return(another_profile_photo_id)
+          allow_any_instance_of(Socialcast::CommandLine::ProvisionPhoto).to receive(:default_profile_photo_id).and_return(another_profile_photo_id)
         end
         let(:photo_data) { "\x89PNGabc" }
-        before { user_search_resource.should_receive(:get).and_return(search_api_response.to_json) }
+        before { expect(user_search_resource).to receive(:get).and_return(search_api_response.to_json) }
         context 'for a regular sync' do
           before do
             sync_photos
-            Socialcast::CommandLine.should_not_receive(:resource_for_path)
+            expect(Socialcast::CommandLine).not_to receive(:resource_for_path)
           end
           it 'does not post the new photo' do end
         end
         context 'when they do a force sync' do
           let(:options) { { :force_sync => true } }
           before do
-            Socialcast::CommandLine.should_receive(:resource_for_path).with('/api/users/7', {}).and_return(user_submit_resource)
-            user_submit_resource.should_receive(:put).and_return(true)
+            expect(Socialcast::CommandLine).to receive(:resource_for_path).with('/api/users/7', {}).and_return(user_submit_resource)
+            expect(user_submit_resource).to receive(:put).and_return(true)
             sync_photos
           end
           it 'submits the photo anyways' do end
@@ -142,43 +142,43 @@ describe Socialcast::CommandLine::ProvisionPhoto do
       let(:sync_photos) { provisioner.sync }
       let(:binary_photo_data) { "\x89PNGabc".force_encoding('binary') }
       before do
-        Socialcast::CommandLine::ProvisionPhoto::ApiSyncStrategy.any_instance.stub(:batch_size).and_return(2)
+        allow_any_instance_of(Socialcast::CommandLine::ProvisionPhoto::ApiSyncStrategy).to receive(:batch_size).and_return(2)
 
         ldap_instance1 = double(Net::LDAP, :encryption => nil, :auth => nil)
-        ldap_instance1.should_receive(:open).and_yield
-        Net::LDAP.should_receive(:new).once.ordered.and_return(ldap_instance1)
+        expect(ldap_instance1).to receive(:open).and_yield
+        expect(Net::LDAP).to receive(:new).once.ordered.and_return(ldap_instance1)
         entry1 = create_entry 'user', :mailCon => 'user@example.com', :photoCon => binary_photo_data
-        ldap_instance1.should_receive(:search).once.with(hash_including(:attributes => ['mailCon', 'photoCon'])).and_yield(entry1)
+        expect(ldap_instance1).to receive(:search).once.with(hash_including(:attributes => ['mailCon', 'photoCon'])).and_yield(entry1)
 
         ldap_instance2 = double(Net::LDAP, :encryption => nil, :auth => nil)
-        ldap_instance2.should_receive(:open).and_yield
-        Net::LDAP.should_receive(:new).once.ordered.and_return(ldap_instance2)
+        expect(ldap_instance2).to receive(:open).and_yield
+        expect(Net::LDAP).to receive(:new).once.ordered.and_return(ldap_instance2)
         entry2 = create_entry 'user', :mailCon2 => 'user2@example.com', :photoCon2 => binary_photo_data
-        ldap_instance2.should_receive(:search).once.with(hash_including(:attributes => ['mailCon2', 'photoCon2'])).and_yield(entry2)
+        expect(ldap_instance2).to receive(:search).once.with(hash_including(:attributes => ['mailCon2', 'photoCon2'])).and_yield(entry2)
 
-        Socialcast::CommandLine.stub(:resource_for_path).with('/api/users/search', anything).and_return(user_search_resource)
+        allow(Socialcast::CommandLine).to receive(:resource_for_path).with('/api/users/search', anything).and_return(user_search_resource)
 
-        user_search_resource.should_receive(:get).once.with({:params => { :q => "\"user@example.com\" OR \"user2@example.com\"", :per_page => 2}, :accept => :json}).and_return(search_api_response.to_json)
+        expect(user_search_resource).to receive(:get).once.with({:params => { :q => "\"user@example.com\" OR \"user2@example.com\"", :per_page => 2}, :accept => :json}).and_return(search_api_response.to_json)
 
         user_resource1 = double(:user_resource)
-        user_resource1.should_receive(:put) do |data|
+        expect(user_resource1).to receive(:put) do |data|
           uploaded_data = data[:user][:profile_photo][:data]
-          uploaded_data.path.should =~ /\.png\Z/
+          expect(uploaded_data.path).to match(/\.png\Z/)
         end
-        Socialcast::CommandLine.stub(:resource_for_path).with('/api/users/7', anything).and_return(user_resource1)
+        allow(Socialcast::CommandLine).to receive(:resource_for_path).with('/api/users/7', anything).and_return(user_resource1)
 
         user_resource2 = double(:user_resource)
-        user_resource2.should_receive(:put) do |data|
+        expect(user_resource2).to receive(:put) do |data|
           uploaded_data = data[:user][:profile_photo][:data]
-          uploaded_data.path.should =~ /\.png\Z/
+          expect(uploaded_data.path).to match(/\.png\Z/)
         end
-        Socialcast::CommandLine.stub(:resource_for_path).with('/api/users/8', anything).and_return(user_resource2)
+        allow(Socialcast::CommandLine).to receive(:resource_for_path).with('/api/users/8', anything).and_return(user_resource2)
 
         sync_photos
       end
       it 'uses attributes from each connection' do end
       it 'is considered fully configured' do
-        expect(provisioner.configured?).to be_true
+        expect(provisioner.configured?).to be_truthy
       end
     end
     context "with multiple incompletely configured ldap connections" do
@@ -188,7 +188,7 @@ describe Socialcast::CommandLine::ProvisionPhoto do
         expect { sync_photos }.to raise_error Socialcast::CommandLine::Provisioner::ProvisionError
       end
       it 'is not considered fully configured' do
-        expect(provisioner.configured?).to be_false
+        expect(provisioner.configured?).to be_falsy
       end
       it 'provides a list of incomplete configurations' do
         expect(provisioner.unsupported_configurations).to eq(['example_connection_2'])