socialcast 1.3.8 → 1.3.9

data/spec/socialcast/command_line/provision_photo_spec.rb

@@ -1,100 +1,175 @@
 require 'spec_helper'
 
 describe Socialcast::CommandLine::ProvisionPhoto do
-  let(:ldap_with_profile_photo) { YAML.load_file(File.join(File.dirname(__FILE__), '..', '..', 'fixtures', 'ldap_with_profile_photo.yml')) }
+  let!(:ldap_with_profile_photo_config) { YAML.load_file(File.join(File.dirname(__FILE__), '..', '..', 'fixtures', 'ldap_with_profile_photo.yml')) }
+  let!(:ldap_multiple_connection_mapping_config) { YAML.load_file(File.join(File.dirname(__FILE__), '..', '..', 'fixtures', 'ldap_with_multiple_connection_mappings.yml')) }
+
+  let(:ldap) do
+    ldap_instance = double(Net::LDAP, :auth => nil, :encryption => nil)
+    ldap_instance.should_receive(:open).and_yield(ldap_instance)
+    Net::LDAP.should_receive(:new).and_return(ldap_instance)
+    ldap_instance
+  end
 
   context '#sync' do
-    let(:options) { {} }
-    subject(:sync_photos) { Socialcast::CommandLine::ProvisionPhoto.new(ldap_with_profile_photo, options).sync }
-    let(:user_search_resource) { double(:user_search_resource) }
-    let(:user_submit_resource) { double(:user_submit_resource) }
-    let(:is_community_default) { true }
-    let(:data_fingerprint) { '5d41402abc4b2a76b9719d911017c592' }
-    let(:search_api_response) do
-      {
-        'users' => [
-          {
-            'id' => 7,
-            'avatars' => {
-              'is_community_default' => is_community_default,
-              'data_fingerprint' => data_fingerprint
+    context "with a single ldap connection" do
+      let(:options) { {} }
+      subject(:sync_photos) { Socialcast::CommandLine::ProvisionPhoto.new(ldap_with_profile_photo_config, options).sync }
+      let(:user_search_resource) { double(:user_search_resource) }
+      let(:user_submit_resource) { double(:user_submit_resource) }
+      let(:is_community_default) { true }
+      let(:data_fingerprint) { '5d41402abc4b2a76b9719d911017c592' }
+      let(:search_api_response) do
+        {
+          'users' => [
+            {
+              'id' => 7,
+              'avatars' => {
+                'is_community_default' => is_community_default,
+                'data_fingerprint' => data_fingerprint
+              }
             }
-          }
-        ]
-      }
-    end
-    before do
-      entry = create_entry :mail => 'user@example.com', :givenName => 'first name', :sn => 'last name', :jpegPhoto => photo_data
-      Net::LDAP.any_instance.should_receive(:search).once.with(hash_including(:attributes => ['givenName', 'sn', 'mail', 'jpegPhoto', 'memberof'])).and_yield(entry)
-      Socialcast::CommandLine.stub(:resource_for_path).with('/api/users/search', anything).and_return(user_search_resource)
-    end
-
-    context 'for when it does successfully post the photo' do
+          ]
+        }
+      end
       before do
-        user_search_resource.should_receive(:get).and_return(search_api_response.to_json)
-        user_resource = double(:user_resource)
-        user_resource.should_receive(:put) do |data|
-          uploaded_data = data[:user][:profile_photo][:data]
-          uploaded_data.path.should =~ /\.png\Z/
-        end
-        Socialcast::CommandLine.stub(:resource_for_path).with('/api/users/7', anything).and_return(user_resource)
+        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)
       end
-      context 'for a binary file' do
-        let(:photo_data) { "\x89PNGabc" }
+
+      context 'for when it does successfully post the photo' do
         before do
-          RestClient.should_not_receive(:get)
-          sync_photos
+          user_search_resource.should_receive(:get).and_return(search_api_response.to_json)
+          user_resource = double(:user_resource)
+          user_resource.should_receive(:put) do |data|
+            uploaded_data = data[:user][:profile_photo][:data]
+            uploaded_data.path.should =~ /\.png\Z/
+          end
+          Socialcast::CommandLine.stub(: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)
+            sync_photos
+          end
+          it 'uses the original binary to upload the photo' do end
+        end
+        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")
+            sync_photos
+          end
+          it 'downloads the image form the web to upload the photo' do end
         end
-        it 'uses the original binary to upload the photo' do end
       end
-      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")
-          sync_photos
+
+      context 'for when it does not successfully post the photo' 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)
+            sync_photos
+          end
+          it 'tries to download the image from the web and rescues 404' do end
         end
-        it 'downloads the image form the web to upload the photo' do end
       end
-    end
 
-    context 'for when it does not successfully post the photo' 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)
-          sync_photos
+      context 'when there is already a photo set' do
+        let(:is_community_default) { false }
+        let(:photo_data) { "\x89PNGabc" }
+        before { user_search_resource.should_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)
+          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)
+            sync_photos
+          end
+          it 'submits the photo anyways' do end
         end
-        it 'tries to download the image from the web and rescues 404' do end
       end
     end
 
-    context 'when their is already a photo set' do
-      let(:is_community_default) { false }
-      let(:photo_data) { "\x89PNGabc" }
-      before { user_search_resource.should_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)
-        end
-        it 'does not post the new photo' do end
+    context "with multiple ldap connections" do
+      let(:user_search_resource) { double(:user_search_resource) }
+      let(:search_api_response1) do
+        {
+          'users' => [
+            {
+              'id' => 7,
+              'avatars' => {
+                'is_community_default' => true
+              }
+            }
+          ]
+        }
       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)
-          sync_photos
+      let(:search_api_response2) do
+        {
+          'users' => [
+            {
+              'id' => 8,
+              'avatars' => {
+                'is_community_default' => true
+              }
+            }
+          ]
+        }
+      end
+
+      let(:sync_photos) { Socialcast::CommandLine::ProvisionPhoto.new(ldap_multiple_connection_mapping_config, {}).sync }
+      let(:binary_photo_data) { "\x89PNGabc".force_encoding('binary') }
+      before do
+        ldap_instance1 = double(Net::LDAP, :encryption => nil, :auth => nil)
+        ldap_instance1.should_receive(:open).and_yield(ldap_instance1)
+        Net::LDAP.should_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)
+
+        ldap_instance2 = double(Net::LDAP, :encryption => nil, :auth => nil)
+        ldap_instance2.should_receive(:open).and_yield(ldap_instance2)
+        Net::LDAP.should_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)
+
+        Socialcast::CommandLine.stub(:resource_for_path).with('/api/users/search', anything).and_return(user_search_resource)
+
+        user_search_resource.should_receive(:get).once.and_return(search_api_response1.to_json)
+        user_search_resource.should_receive(:get).once.and_return(search_api_response2.to_json)
+
+        user_resource1 = double(:user_resource)
+        user_resource1.should_receive(:put) do |data|
+          uploaded_data = data[:user][:profile_photo][:data]
+          uploaded_data.path.should =~ /\.png\Z/
+        end
+        Socialcast::CommandLine.stub(:resource_for_path).with('/api/users/7', anything).and_return(user_resource1)
+
+        user_resource2 = double(:user_resource)
+        user_resource2.should_receive(:put) do |data|
+          uploaded_data = data[:user][:profile_photo][:data]
+          uploaded_data.path.should =~ /\.png\Z/
         end
-        it 'submits the photo anyways' do end
+        Socialcast::CommandLine.stub(:resource_for_path).with('/api/users/8', anything).and_return(user_resource2)
+
+        sync_photos
       end
+      it 'uses attributes from each connection' do end
     end
   end
 
-
   context '.binary_to_content_type' do
-    subject { Socialcast::CommandLine::ProvisionPhoto.new(ldap_with_profile_photo, {}).send(:binary_to_content_type, binary_photo_data) }
+    subject { Socialcast::CommandLine::ProvisionPhoto.new(ldap_with_profile_photo_config, {}).send(:binary_to_content_type, binary_photo_data) }
     let(:file_dir) { File.join(File.dirname(__FILE__), '..', '..', 'fixtures', 'test_images') }
     let(:binary_photo_data) { File.open(File.join(file_dir, image_name), 'rb') { |file| file.read } }
     context 'with a jpg' do

data/spec/socialcast/command_line/provision_user_spec.rb

@@ -13,7 +13,16 @@ describe Socialcast::CommandLine::ProvisionUser do
   let!(:ldap_with_manager_attribute_config) { YAML.load_file(File.join(File.dirname(__FILE__), '..', '..', 'fixtures', 'ldap_with_manager_attribute.yml')) }
   let!(:ldap_with_roles_without_account_type_config) { YAML.load_file(File.join(File.dirname(__FILE__), '..', '..', 'fixtures', 'ldap_with_roles_without_account_type.yml')) }
   let!(:ldap_with_unique_identifier_config) { YAML.load_file(File.join(File.dirname(__FILE__), '..', '..', 'fixtures', 'ldap_with_unique_identifier.yml')) }
+  let!(:ldap_with_profile_photo_config) { YAML.load_file(File.join(File.dirname(__FILE__), '..', '..', 'fixtures', 'ldap_with_profile_photo.yml')) }
   let!(:ldap_without_account_type_or_roles_config) { YAML.load_file(File.join(File.dirname(__FILE__), '..', '..', 'fixtures', 'ldap_without_account_type_or_roles.yml')) }
+  let!(:ldap_without_options_config) { YAML.load_file(File.join(File.dirname(__FILE__), '..', '..', 'fixtures', 'ldap_without_options.yml')) }
+
+  let(:ldap) do
+    ldap_instance = double(Net::LDAP, :auth => nil, :encryption => nil)
+    ldap_instance.should_receive(:open).and_yield(ldap_instance)
+    Net::LDAP.should_receive(:new).and_return(ldap_instance)
+    ldap_instance
+  end
 
   describe "#provision" do
     let(:result) { '' }
@@ -26,8 +35,8 @@ describe Socialcast::CommandLine::ProvisionUser do
 
     context "when the entry has an email" do
       before do
-        entry = create_entry :mail => 'user@example.com', :givenName => 'first name', :sn => 'last name'
-        Net::LDAP.any_instance.should_receive(:search).once.with(hash_including(:attributes => ['givenName', 'sn', 'mail', 'isMemberOf'])).and_yield(entry)
+        entry = create_entry 'user', :mail => 'user@example.com', :givenName => 'first name', :sn => 'last name'
+        ldap.should_receive(:search).once.with(hash_including(:attributes => ['givenName', 'sn', 'mail', 'isMemberOf'])).and_yield(entry)
         RestClient::Resource.any_instance.should_receive(:post).once.with(hash_including(:file => result), { :accept => :json })
 
         Socialcast::CommandLine::ProvisionUser.new(ldap_default_config, {}).provision
@@ -38,8 +47,8 @@ describe Socialcast::CommandLine::ProvisionUser do
     end
     context "when the entry has a unique_identifier" do
       before do
-        entry = create_entry :uid => 'userID', :givenName => 'first name', :sn => 'last name'
-        Net::LDAP.any_instance.should_receive(:search).once.with(hash_including(:attributes => ['givenName', 'sn', 'uid', 'isMemberOf'])).and_yield(entry)
+        entry = create_entry 'user', :uid => 'userID', :givenName => 'first name', :sn => 'last name'
+        ldap.should_receive(:search).once.with(hash_including(:attributes => ['givenName', 'sn', 'uid', 'isMemberOf'])).and_yield(entry)
         RestClient::Resource.any_instance.should_receive(:post).once.with(hash_including(:file => result), { :accept => :json })
 
         Socialcast::CommandLine::ProvisionUser.new(ldap_with_unique_identifier_config, {}).provision
@@ -50,8 +59,8 @@ describe Socialcast::CommandLine::ProvisionUser do
     end
     context "when the entry has no email or unique_identifier" do
       before do
-        entry = create_entry :mail => '', :givenName => 'first name', :sn => 'last name'
-        Net::LDAP.any_instance.should_receive(:search).once.with(hash_including(:attributes => ['givenName', 'sn', 'mail', 'isMemberOf'])).and_yield(entry)
+        entry = create_entry 'user', :mail => '', :givenName => 'first name', :sn => 'last name'
+        ldap.should_receive(:search).once.with(hash_including(:attributes => ['givenName', 'sn', 'mail', 'isMemberOf'])).and_yield(entry)
         RestClient::Resource.any_instance.should_not_receive(:post)
       end
       it "does not put the user in the output file" do
@@ -87,8 +96,8 @@ describe Socialcast::CommandLine::ProvisionUser do
 
       context "with mappings at the global level" do
         before do
-          entry = create_entry :mail => 'user@example.com', :givenName => 'first name', :sn => 'last name'
-          Net::LDAP.any_instance.should_receive(:search).once.with(hash_including(:attributes => ['givenName', 'sn', 'mail', 'isMemberOf'])).and_yield(entry)
+          entry = create_entry 'user', :mail => 'user@example.com', :givenName => 'first name', :sn => 'last name'
+          ldap.should_receive(:search).once.with(hash_including(:attributes => ['givenName', 'sn', 'mail', 'isMemberOf'])).and_yield(entry)
 
           Socialcast::CommandLine::ProvisionUser.new(ldap_default_config, {}).provision
         end
@@ -108,13 +117,15 @@ describe Socialcast::CommandLine::ProvisionUser do
           provision_instance = Socialcast::CommandLine::ProvisionUser.new(ldap_multiple_connection_mapping_config, {})
 
           ldap_instance1 = double(Net::LDAP, :encryption => nil, :auth => nil)
+          ldap_instance1.should_receive(:open).and_yield(ldap_instance1)
           Net::LDAP.should_receive(:new).once.ordered.and_return(ldap_instance1)
-          entry1 = create_entry :mailCon => 'user@example.com', :givenName => 'first name', :sn => 'last name'
+          entry1 = create_entry 'user', :mailCon => 'user@example.com', :givenName => 'first name', :sn => 'last name'
           ldap_instance1.should_receive(:search).once.with(hash_including(:attributes => ['mailCon', 'isMemberOf'])).and_yield(entry1)
 
           ldap_instance2 = double(Net::LDAP, :encryption => nil, :auth => nil)
+          ldap_instance2.should_receive(:open).and_yield(ldap_instance2)
           Net::LDAP.should_receive(:new).once.ordered.and_return(ldap_instance2)
-          entry2 = create_entry :mailCon2 => 'user2@example.com', :firstName => 'first name2', :sn => 'last name2'
+          entry2 = create_entry 'user', :mailCon2 => 'user2@example.com', :firstName => 'first name2', :sn => 'last name2'
           ldap_instance2.should_receive(:search).once.with(hash_including(:attributes => ['mailCon2', 'firstName', 'isMemberOf'])).and_yield(entry2)
 
           provision_instance.provision
@@ -136,8 +147,8 @@ describe Socialcast::CommandLine::ProvisionUser do
 
       context "with custom attribute mappings" do
         before do
-          entry = create_entry :mail => 'user@example.com', :custom_ldap1 => 'custom value 1', :custom_ldap2 => 'custom value 2'
-          Net::LDAP.any_instance.should_receive(:search).once.with(hash_including(:attributes => ['custom_ldap1', 'custom_ldap2', 'mail', 'isMemberOf'])).and_yield(entry)
+          entry = create_entry 'user', :mail => 'user@example.com', :custom_ldap1 => 'custom value 1', :custom_ldap2 => 'custom value 2'
+          ldap.should_receive(:search).once.with(hash_including(:attributes => ['custom_ldap1', 'custom_ldap2', 'mail', 'isMemberOf'])).and_yield(entry)
 
           Socialcast::CommandLine::ProvisionUser.new(ldap_with_custom_attributes_config, {}).provision
         end
@@ -166,17 +177,18 @@ describe Socialcast::CommandLine::ProvisionUser do
           provision_instance = Socialcast::CommandLine::ProvisionUser.new(ldap_with_manager_attribute_config, {})
 
           ldap_instance = double(Net::LDAP, :encryption => nil, :auth => nil)
+          ldap_instance.should_receive(:open).and_yield(ldap_instance)
           Net::LDAP.should_receive(:new).once.and_return(ldap_instance)
 
-          user_entry = create_entry :mail => 'user@example.com', :ldap_manager => 'cn=theboss,dc=example,dc=com'
-          manager_entry = create_entry :mail => 'boss@example.com'
-          ldap_instance.should_receive(:search).once.ordered.with(hash_including(:attributes => ['mail', 'ldap_manager', 'isMemberOf'])).and_yield(user_entry)
-          ldap_instance.should_receive(:search).once.ordered.and_yield(manager_entry)
+          user_entry = create_entry 'user', :mail => 'user@example.com', :ldap_manager => 'cn=theboss,dc=example,dc=com'
+          manager_entry = create_entry 'theboss', :mail => 'boss@example.com'
+          ldap_instance.should_receive(:search).once.ordered.and_yield(user_entry).and_yield(manager_entry)
+          ldap_instance.should_receive(:search).once.ordered.and_yield(user_entry).and_yield(manager_entry)
 
           provision_instance.provision
         end
         let(:expected_attribute_xml) do
-          %Q[<contact-info>
+          [%Q[<contact-info>
                <email>user@example.com</email>
               </contact-info>
               <custom-fields type="array">
@@ -185,7 +197,17 @@ describe Socialcast::CommandLine::ProvisionUser do
                   <label>manager_email</label>
                   <value>boss@example.com</value>
                 </custom-field>
-              </custom-fields>]
+              </custom-fields>],
+          %Q[<contact-info>
+               <email>boss@example.com</email>
+              </contact-info>
+              <custom-fields type="array">
+                <custom-field>
+                  <id>manager_email</id>
+                  <label>manager_email</label>
+                  <value nil="true"/>
+                </custom-field>
+              </custom-fields>]]
         end
         it_behaves_like "attributes are mapped properly"
       end
@@ -193,8 +215,8 @@ describe Socialcast::CommandLine::ProvisionUser do
       context "with an ldap mapping that has the same name as a class" do
         before do
           module TestLdapAttributeMapping end
-          entry = create_entry :test_ldap_attribute_mapping => 'user@example.com'
-          Net::LDAP.any_instance.should_receive(:search).once.with(hash_including(:attributes => ['test_ldap_attribute_mapping', 'isMemberOf'])).and_yield(entry)
+          entry = create_entry 'user', :test_ldap_attribute_mapping => 'user@example.com'
+          ldap.should_receive(:search).once.with(hash_including(:attributes => ['test_ldap_attribute_mapping', 'isMemberOf'])).and_yield(entry)
 
           Socialcast::CommandLine::ProvisionUser.new(ldap_with_class_ldap_attribute_config, {}).provision
         end
@@ -209,6 +231,42 @@ describe Socialcast::CommandLine::ProvisionUser do
         end
         it_behaves_like "attributes are mapped properly"
       end
+
+      context "without options specified" do
+        before do
+          entry = create_entry 'user', :mail => 'user@example.com', :givenName => 'first name', :sn => 'last name'
+          ldap.should_receive(:search).once.with(hash_including(:attributes => ['givenName', 'sn', 'mail', 'isMemberOf'])).and_yield(entry)
+
+          Socialcast::CommandLine::ProvisionUser.new(ldap_without_options_config, {}).provision
+        end
+        let(:expected_attribute_xml) do
+          %Q[<first-name>first name</first-name>
+              <last-name>last name</last-name>
+              <contact-info>
+               <email>user@example.com</email>
+              </contact-info>
+              <custom-fields type="array"/>]
+        end
+        it_behaves_like "attributes are mapped properly"
+      end
+
+      context "with profile_photo attribute mappings" do
+        before do
+          entry = create_entry 'user', :mail => 'user@example.com', :givenName => 'first name', :sn => 'last name'
+          ldap.should_receive(:search).once.with(hash_including(:attributes => ['givenName', 'sn', 'mail', 'memberof'])).and_yield(entry)
+
+          Socialcast::CommandLine::ProvisionUser.new(ldap_with_profile_photo_config, {}).provision
+        end
+        let(:expected_attribute_xml) do
+          %Q[<first-name>first name</first-name>
+             <last-name>last name</last-name>
+             <contact-info>
+               <email>user@example.com</email>
+             </contact-info>
+             <custom-fields type="array"/>]
+        end
+        it_behaves_like "attributes are mapped properly"
+      end
     end
     context "permission attribute mappings" do
       shared_examples "permission attributes are mapped properly" do
@@ -235,7 +293,7 @@ describe Socialcast::CommandLine::ProvisionUser do
         end
       end
 
-      let(:entry) { create_entry :mail => 'user@example.com', :givenName => 'first name', :sn => 'last name', :isMemberOf => ldap_groups }
+      let(:entry) { create_entry 'user', :mail => 'user@example.com', :givenName => 'first name', :sn => 'last name', :isMemberOf => ldap_groups }
       let(:ldap_group_attribute) { 'isMemberOf' }
 
       before do
@@ -245,7 +303,7 @@ describe Socialcast::CommandLine::ProvisionUser do
       context "with roles for an external contributor" do
         let(:ldap_groups) { ["cn=External,dc=example,dc=com", "cn=SbiAdmins,dc=example,dc=com", "cn=TownHallAdmins,dc=example,dc=com"] }
         before do
-          Net::LDAP.any_instance.should_receive(:search).once.with(hash_including(:attributes => ['givenName', 'sn', 'mail', ldap_group_attribute])).and_yield(entry)
+          ldap.should_receive(:search).once.with(hash_including(:attributes => ['givenName', 'sn', 'mail', ldap_group_attribute])).and_yield(entry)
           Socialcast::CommandLine::ProvisionUser.new(ldap_default_config, {}).provision
         end
         let(:expected_permission_xml) do
@@ -257,7 +315,7 @@ describe Socialcast::CommandLine::ProvisionUser do
       context "with roles for a member" do
         let(:ldap_groups) { ["cn=SbiAdmins,dc=example,dc=com", "cn=TownHallAdmins,dc=example,dc=com"] }
         before do
-          Net::LDAP.any_instance.should_receive(:search).once.with(hash_including(:attributes => ['givenName', 'sn', 'mail', ldap_group_attribute])).and_yield(entry)
+          ldap.should_receive(:search).once.with(hash_including(:attributes => ['givenName', 'sn', 'mail', ldap_group_attribute])).and_yield(entry)
           Socialcast::CommandLine::ProvisionUser.new(ldap_default_config, {}).provision
         end
         let(:expected_permission_xml) do
@@ -273,7 +331,7 @@ describe Socialcast::CommandLine::ProvisionUser do
       context "with account_types mapping and no role mappings" do
         let(:ldap_groups) { ["cn=SbiAdmins,dc=example,dc=com", "cn=TownHallAdmins,dc=example,dc=com"] }
         before do
-          Net::LDAP.any_instance.should_receive(:search).once.with(hash_including(:attributes => ['givenName', 'sn', 'mail', ldap_group_attribute])).and_yield(entry)
+          ldap.should_receive(:search).once.with(hash_including(:attributes => ['givenName', 'sn', 'mail', ldap_group_attribute])).and_yield(entry)
           Socialcast::CommandLine::ProvisionUser.new(ldap_with_account_type_without_roles_config, {}).provision
         end
         let(:expected_permission_xml) do
@@ -285,7 +343,7 @@ describe Socialcast::CommandLine::ProvisionUser do
       context "with role mappings and no account_type mapping" do
         let(:ldap_groups) { ["cn=SbiAdmins,dc=example,dc=com", "cn=TownHallAdmins,dc=example,dc=com"] }
         before do
-          Net::LDAP.any_instance.should_receive(:search).once.with(hash_including(:attributes => ['givenName', 'sn', 'mail', ldap_group_attribute])).and_yield(entry)
+          ldap.should_receive(:search).once.with(hash_including(:attributes => ['givenName', 'sn', 'mail', ldap_group_attribute])).and_yield(entry)
           Socialcast::CommandLine::ProvisionUser.new(ldap_with_roles_without_account_type_config, {}).provision
         end
         let(:expected_permission_xml) do
@@ -301,7 +359,7 @@ describe Socialcast::CommandLine::ProvisionUser do
       context "without account_type or roles mappings" do
         let(:ldap_groups) { ["cn=SbiAdmins,dc=example,dc=com", "cn=TownHallAdmins,dc=example,dc=com"] }
         before do
-          Net::LDAP.any_instance.should_receive(:search).once.with(hash_including(:attributes => ['givenName', 'sn', 'mail', ldap_group_attribute])).and_yield(entry)
+          ldap.should_receive(:search).once.with(hash_including(:attributes => ['givenName', 'sn', 'mail', ldap_group_attribute])).and_yield(entry)
           Socialcast::CommandLine::ProvisionUser.new(ldap_without_account_type_or_roles_config, {}).provision
         end
         let(:expected_permission_xml) do
@@ -317,13 +375,15 @@ describe Socialcast::CommandLine::ProvisionUser do
           provision_instance = Socialcast::CommandLine::ProvisionUser.new(ldap_multiple_connection_permission_mapping_config, {})
 
           ldap_instance1 = double(Net::LDAP, :encryption => nil, :auth => nil)
+          ldap_instance1.should_receive(:open).and_yield(ldap_instance1)
           Net::LDAP.should_receive(:new).once.ordered.and_return(ldap_instance1)
-          entry1 = create_entry :mail => 'user@example.com', :givenName => 'first name', :sn => 'last name', :memberOf => ["cn=External,dc=example,dc=com", "cn=SbiAdmins,dc=example,dc=com", "cn=TownHallAdmins,dc=example,dc=com"]
+          entry1 = create_entry 'user', :mail => 'user@example.com', :givenName => 'first name', :sn => 'last name', :memberOf => ["cn=External,dc=example,dc=com", "cn=SbiAdmins,dc=example,dc=com", "cn=TownHallAdmins,dc=example,dc=com"]
           ldap_instance1.should_receive(:search).once.with(hash_including(:attributes => ['givenName', 'sn', 'mail', 'memberOf'])).and_yield(entry1)
 
           ldap_instance2 = double(Net::LDAP, :encryption => nil, :auth => nil)
+          ldap_instance2.should_receive(:open).and_yield(ldap_instance2)
           Net::LDAP.should_receive(:new).once.ordered.and_return(ldap_instance2)
-          entry2 = create_entry :mail => 'user@example.com', :givenName => 'first name', :sn => 'last name', :member => ["cn=Contractors,dc=example,dc=com", "cn=SbiAdmins,dc=example,dc=com", "cn=TownHallAdmins,dc=example,dc=com"]
+          entry2 = create_entry 'user', :mail => 'user@example.com', :givenName => 'first name', :sn => 'last name', :member => ["cn=Contractors,dc=example,dc=com", "cn=SbiAdmins,dc=example,dc=com", "cn=TownHallAdmins,dc=example,dc=com"]
           ldap_instance2.should_receive(:search).once.with(hash_including(:attributes => ['givenName', 'sn', 'mail', 'member'])).and_yield(entry2)
 
           provision_instance.provision
@@ -348,12 +408,13 @@ describe Socialcast::CommandLine::ProvisionUser do
 
         provision_instance = Socialcast::CommandLine::ProvisionUser.new(ldap_blank_basedn_config, {})
 
-        root_entry = create_entry(:namingcontexts => ['dc=foo,dc=com', 'dc=bar,dc=com'])
+        root_entry = create_entry('domain', :namingcontexts => ['dc=foo,dc=com', 'dc=bar,dc=com'])
         ldap_instance = double(Net::LDAP, :encryption => nil, :auth => nil)
         ldap_instance.should_receive(:search_root_dse).once.and_return(root_entry)
+        ldap_instance.should_receive(:open).and_yield(ldap_instance)
         Net::LDAP.should_receive(:new).once.and_return(ldap_instance)
 
-        user_entry = create_entry :mail => 'user@example.com', :givenName => 'first name', :sn => 'last name'
+        user_entry = create_entry 'user', :mail => 'user@example.com', :givenName => 'first name', :sn => 'last name'
         ldap_instance.should_receive(:search).once.ordered.with(hash_including(:base => 'dc=foo,dc=com', :attributes => ['givenName', 'sn', 'mail', 'isMemberOf']))
         ldap_instance.should_receive(:search).once.ordered.with(hash_including(:base => 'dc=bar,dc=com', :attributes => ['givenName', 'sn', 'mail', 'isMemberOf'])).and_yield(user_entry)
 
@@ -368,8 +429,8 @@ describe Socialcast::CommandLine::ProvisionUser do
   describe "#each_user_hash" do
     let(:provision_instance) { Socialcast::CommandLine::ProvisionUser.new(ldap_default_config) }
     before do
-      entry = create_entry :mail => 'user@example.com', :givenName => 'first name', :sn => 'last name'
-      Net::LDAP.any_instance.should_receive(:search).once.with(hash_including(:attributes => ['givenName', 'sn', 'mail', 'isMemberOf'])).and_yield(entry)
+      entry = create_entry 'user', :mail => 'user@example.com', :givenName => 'first name', :sn => 'last name'
+      ldap.should_receive(:search).once.with(hash_including(:attributes => ['givenName', 'sn', 'mail', 'isMemberOf'])).and_yield(entry)
     end
     it do
       expect do |blk|
@@ -390,10 +451,10 @@ describe Socialcast::CommandLine::ProvisionUser do
   describe "#fetch_user_hash" do
     context "when the first connector returns the entry" do
       let(:provision_instance) { Socialcast::CommandLine::ProvisionUser.new(ldap_multiple_connection_mapping_config, {}) }
-      let(:entry) { create_entry :mailCon => 'user@example.com' }
+      let(:entry) { create_entry 'user', :mailCon => 'user@example.com' }
       before do
         filter = Net::LDAP::Filter.construct('(&(mail=*)(mailCon=user@example.com))')
-        Net::LDAP.any_instance.should_receive(:search).once
+        ldap.should_receive(:search).once
           .with(hash_including(:attributes => ['mailCon', 'isMemberOf'], :filter => filter))
           .and_yield(entry)
       end
@@ -410,15 +471,17 @@ describe Socialcast::CommandLine::ProvisionUser do
     end
     context "when another connector returns the entry" do
       let(:provision_instance) { Socialcast::CommandLine::ProvisionUser.new(ldap_multiple_connection_mapping_config, {}) }
-      let(:entry) { create_entry :mailCon2 => 'user@example.com', :firstName => 'first name' }
+      let(:entry) { create_entry 'user', :mailCon2 => 'user@example.com', :firstName => 'first name' }
       before do
         ldap_instance1 = double(Net::LDAP, :auth => nil)
+        ldap_instance1.should_receive(:open).and_yield(ldap_instance1)
         Net::LDAP.should_receive(:new).once.ordered.and_return(ldap_instance1)
         filter1 = Net::LDAP::Filter.construct('(&(mail=*)(mailCon=user@example.com))')
         ldap_instance1.should_receive(:search).once.ordered
           .with(hash_including(:attributes => ['mailCon', 'isMemberOf'], :filter => filter1))
 
         ldap_instance2 = double(Net::LDAP, :auth => nil)
+        ldap_instance2.should_receive(:open).and_yield(ldap_instance2)
         Net::LDAP.should_receive(:new).once.ordered.and_return(ldap_instance2)
         filter2 = Net::LDAP::Filter.construct('(&(mail=*)(mailCon2=user@example.com))')
         ldap_instance2.should_receive(:search).once.ordered
@@ -442,12 +505,14 @@ describe Socialcast::CommandLine::ProvisionUser do
       let(:provision_instance) { Socialcast::CommandLine::ProvisionUser.new(ldap_multiple_connection_mapping_config, {}) }
       before do
         ldap_instance1 = double(Net::LDAP, :auth => nil)
+        ldap_instance1.should_receive(:open).and_yield(ldap_instance1)
         Net::LDAP.should_receive(:new).once.ordered.and_return(ldap_instance1)
         filter1 = Net::LDAP::Filter.construct('(&(mail=*)(mailCon=user@example.com))')
         ldap_instance1.should_receive(:search)
           .with(hash_including(:attributes => ['mailCon', 'isMemberOf'], :filter => filter1))
 
         ldap_instance2 = double(Net::LDAP, :auth => nil)
+        ldap_instance2.should_receive(:open).and_yield(ldap_instance2)
         Net::LDAP.should_receive(:new).once.ordered.and_return(ldap_instance2)
         filter2 = Net::LDAP::Filter.construct('(&(mail=*)(mailCon2=user@example.com))')
         ldap_instance2.should_receive(:search).once.ordered