socialcast 1.3.11 → 1.3.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a6def41c8c9fc333d5375b7e0ad9b403594663dd
-  data.tar.gz: 70370fc44d5b564bb69911a6b1919811bbf95b9f
+  metadata.gz: 610338f9bd0ce308510f29fe684fc4ed7f876fd4
+  data.tar.gz: 67eadbc1549337bbc9c0bafeaa4f934c8f9d1d70
 SHA512:
-  metadata.gz: 22d41b04fa02c612b5a4486a7f7c1898bda5647e690a5054bb28e42e0438613f3b0acb6478b5ec668cce3daf37e9f9f7a9278d2eb0a506b9e1cddb9880290020
-  data.tar.gz: a2738fb5abcfefe29222c4dd85dca607f114f99ff08cc89073205210dcc616caf8f395061191ddafd36c1b4ea6da4fc7210407bdb9734f6bba82014bfe8e2c81
+  metadata.gz: bbc659eefaace5269780c1052706eb9fe860f3e585bff2d23353b58924c331533e1005eb11d1546b98b5a30b403fd6e5593f943bf4b0da958c07247ec308692b
+  data.tar.gz: c85326a13ca5c7c637e70b474497a1827c05a9f5f370859b29eb311f52f171e922ca7c01161670f84d895be36d3800662eb32bbe20ecaed017ec78b25c56c4f4

data/lib/socialcast/command_line/ldap_connector.rb

@@ -5,6 +5,8 @@ require 'active_support/core_ext/array/wrap'
 module Socialcast
   module CommandLine
     class LDAPConnector
+      class ConcurrentSearchError < StandardError; end
+
       UNIQUE_IDENTIFIER_ATTRIBUTE = "unique_identifier"
       EMAIL_ATTRIBUTE = "email"
       MANAGER_ATTRIBUTE = "manager"
@@ -14,66 +16,65 @@ module Socialcast
 
       attr_reader :attribute_mappings, :connection_name
 
-      def self.with_connector(connection_name, config)
-        connection_config = config["connections"][connection_name]
-        ldap = Net::LDAP.new(:host => connection_config["host"], :port => connection_config["port"], :base => connection_config["basedn"]).tap do |ldap_instance|
-          ldap_instance.encryption connection_config['encryption'].to_sym if connection_config['encryption']
-          ldap_instance.auth connection_config["username"], connection_config["password"]
-        end
-
-        ldap.open do |connected_ldap_instance|
-          yield new(connection_name, config, connected_ldap_instance)
-        end
-      end
-
       def self.attribute_mappings_for(connection_name, config)
         config['connections'][connection_name]['mappings'] || config.fetch('mappings', {})
       end
 
-      def initialize(connection_name, config, ldap)
+      def initialize(connection_name, config)
         @connection_name = connection_name
         @config = config
-        @ldap = ldap
-        @group_unique_identifiers = fetch_group_unique_identifiers
-        @dn_to_email_hash = fetch_dn_to_email_hash
       end
 
       def each_user_hash
-        each_ldap_entry(ldap_user_search_attributes) do |entry|
-          yield build_user_hash_from_mappings(entry)
+        ldap.open do
+          fetch_group_unique_identifiers
+          fetch_dn_to_email_hash
+
+          each_ldap_entry(ldap_user_search_attributes) do |entry|
+            yield build_user_hash_from_mappings(entry)
+          end
         end
       end
 
       def each_photo_hash
-        each_ldap_entry(ldap_photo_search_attributes) do |entry|
-          photo_hash = build_photo_hash_from_mappings(entry)
-          yield photo_hash if photo_hash.present?
+        ldap.open do
+          each_ldap_entry(ldap_photo_search_attributes) do |entry|
+            photo_hash = build_photo_hash_from_mappings(entry)
+            yield photo_hash if photo_hash.present?
+          end
         end
       end
 
       def fetch_user_hash(identifier, options)
-        options = options.dup
-        identifying_field = options.delete(:identifying_field) || UNIQUE_IDENTIFIER_ATTRIBUTE
+        ldap.open do
+          fetch_group_unique_identifiers
+          fetch_dn_to_email_hash
 
-        filter = if connection_config['filter'].present?
-                   Net::LDAP::Filter.construct(connection_config['filter'])
-                 else
-                   Net::LDAP::Filter.pres("objectclass")
-                 end
+          options = options.dup
+          identifying_field = options.delete(:identifying_field) || UNIQUE_IDENTIFIER_ATTRIBUTE
 
-        filter = filter & Net::LDAP::Filter.construct("#{attribute_mappings[identifying_field]}=#{identifier}")
+          filter = if connection_config['filter'].present?
+                     Net::LDAP::Filter.construct(connection_config['filter'])
+                   else
+                     Net::LDAP::Filter.pres("objectclass")
+                   end
 
-        search(:base => connection_config['basedn'], :filter => filter, :attributes => ldap_user_search_attributes, :size => 1) do |entry|
-          return build_user_hash_from_mappings(entry)
-        end
+          filter = filter & Net::LDAP::Filter.construct("#{attribute_mappings[identifying_field]}=#{identifier}")
 
-        nil
+          search(:base => connection_config['basedn'], :filter => filter, :attributes => ldap_user_search_attributes, :size => 1) do |entry|
+            return build_user_hash_from_mappings(entry)
+          end
+
+          nil
+        end
       end
 
       def attribute_mappings
         @attribute_mappings ||= LDAPConnector.attribute_mappings_for(@connection_name, @config)
       end
 
+      private
+
       # grab a *single* value of an attribute
       # abstracts away ldap multivalue attributes
       def grab(entry, attribute)
@@ -99,7 +100,16 @@ module Socialcast
         end
       end
 
-      private
+      def ldap
+        @ldap ||= Net::LDAP.new(:host => connection_config["host"], :port => connection_config["port"], :base => connection_config["basedn"]).tap do |ldap_instance|
+          ldap_instance.encryption connection_config['encryption'].to_sym if connection_config['encryption']
+          ldap_instance.auth connection_config["username"], connection_config["password"]
+        end
+      end
+
+      def root_namingcontexts
+        @root_naming_contexts ||= Array.wrap(@ldap.search_root_dse.namingcontexts)
+      end
 
       def each_ldap_entry(attributes)
         search(:return_result => false, :filter => connection_config["filter"], :base => connection_config["basedn"], :attributes => attributes) do |entry|
@@ -156,17 +166,24 @@ module Socialcast
       end
 
       def search(search_options)
-        options_for_search = if search_options[:base].present?
-                               Array.wrap(search_options)
-                             else
-                               distinguished_names = Array.wrap(@ldap.search_root_dse.namingcontexts)
-                               options_for_search = distinguished_names.map { |dn| search_options.merge(:base => dn ) }
-                             end
-
-        options_for_search.each do |options|
-          @ldap.search(options) do |entry|
-            yield(entry)
+        raise ConcurrentSearchError.new "Cannot perform concurrent searches on an open ldap connection" if @search_in_progress
+        begin
+          options_for_search = if search_options[:base].present?
+                                 Array.wrap(search_options)
+                               else
+                                 options_for_search = root_namingcontexts.map { |dn| search_options.merge(:base => dn ) }
+                               end
+
+          options_for_search.each do |options|
+            @search_in_progress = true
+
+            @ldap.search(options) do |entry|
+              yield(entry)
+            end
+
           end
+        ensure
+          @search_in_progress = false
         end
       end
 
@@ -190,30 +207,34 @@ module Socialcast
       end
 
       def fetch_group_unique_identifiers
-        return nil unless group_membership_mappings.present?
-
-        {}.tap do |groups|
-          search_options = {
-            :return_result => false,
-            :filter => group_membership_mappings["filter"],
-            :base => connection_config["basedn"],
-            :attributes => [group_membership_mappings[UNIQUE_IDENTIFIER_ATTRIBUTE]]
-          }
-
-          search(search_options) do |entry|
-            groups[grab(entry, "dn")] = grab(entry, group_membership_mappings[UNIQUE_IDENTIFIER_ATTRIBUTE])
-          end
-        end
+        @group_unique_identifiers ||= if group_membership_mappings.present?
+                                        {}.tap do |groups|
+                                          search_options = {
+                                            :return_result => false,
+                                            :filter => group_membership_mappings["filter"],
+                                            :base => connection_config["basedn"],
+                                            :attributes => [group_membership_mappings[UNIQUE_IDENTIFIER_ATTRIBUTE]]
+                                          }
+
+                                          search(search_options) do |entry|
+                                            groups[grab(entry, "dn")] = grab(entry, group_membership_mappings[UNIQUE_IDENTIFIER_ATTRIBUTE])
+                                          end
+                                        end
+                                      else
+                                        {}
+                                      end
       end
 
       def fetch_dn_to_email_hash
-        return nil unless attribute_mappings[MANAGER_ATTRIBUTE].present?
-
-        {}.tap do |dn_to_email_hash|
-          each_ldap_entry(ldap_mail_search_attributes) do |entry|
-            dn_to_email_hash[entry.dn] = grab(entry, attribute_mappings[EMAIL_ATTRIBUTE])
-          end
-        end
+        @dn_to_email_hash ||= if attribute_mappings[MANAGER_ATTRIBUTE].present?
+                                {}.tap do |dn_to_email_hash|
+                                  each_ldap_entry(ldap_mail_search_attributes) do |entry|
+                                    dn_to_email_hash[entry.dn] = grab(entry, attribute_mappings[EMAIL_ATTRIBUTE])
+                                  end
+                                end
+                              else
+                                {}
+                              end
       end
 
       def add_primary_attributes(entry, user_hash)

data/lib/socialcast/command_line/provisioner.rb

@@ -18,11 +18,15 @@ module Socialcast
         @http_config ||= @ldap_config.fetch 'http', {}
       end
 
+      def ldap_connectors
+        @ldap_connectors ||= @ldap_config['connections'].map do |connection_name, _|
+          LDAPConnector.new(connection_name, @ldap_config)
+        end
+      end
+
       def each_ldap_connector
-        @ldap_config['connections'].keys.each do |connection_name|
-          LDAPConnector.with_connector(connection_name, @ldap_config) do |ldap_connector|
-            yield ldap_connector
-          end
+        ldap_connectors.each do |ldap_connector|
+          yield ldap_connector
         end
       end
 

data/lib/socialcast/command_line/version.rb

@@ -1,5 +1,5 @@
 module Socialcast
   module CommandLine
-    VERSION = "1.3.11"
+    VERSION = "1.3.12"
   end
 end

data/spec/socialcast/command_line/cli_spec.rb

@@ -21,7 +21,7 @@ describe Socialcast::CommandLine::CLI do
 
   let(:ldap) do
     ldap_instance = double(Net::LDAP, :auth => nil, :encryption => nil)
-    ldap_instance.should_receive(:open).and_yield(ldap_instance)
+    ldap_instance.should_receive(:open).and_yield
     Net::LDAP.should_receive(:new).and_return(ldap_instance)
     ldap_instance
   end

data/spec/socialcast/command_line/ldap_connector_spec.rb

@@ -49,6 +49,7 @@ 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)
   end
 
@@ -62,7 +63,7 @@ describe Socialcast::CommandLine::LDAPConnector do
 
   describe "#each_user_hash" do
     context "when the entry has an email" do
-      let(:connector) { Socialcast::CommandLine::LDAPConnector.new('connection_1', ldap_config, ldap) }
+      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)
@@ -84,7 +85,7 @@ describe Socialcast::CommandLine::LDAPConnector do
     end
 
     context("when the entry does not have a unique_identifier or email") do
-      let(:connector) { Socialcast::CommandLine::LDAPConnector.new('connection_1', ldap_config, ldap) }
+      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)
@@ -104,7 +105,7 @@ describe Socialcast::CommandLine::LDAPConnector do
           "unique_identifier" => "uid"
         }
       end
-      let(:connector) { Socialcast::CommandLine::LDAPConnector.new('connection_1', ldap_config, ldap) }
+      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)
@@ -125,7 +126,7 @@ describe Socialcast::CommandLine::LDAPConnector do
     end
 
     context "when the entry has a profile photo" do
-      let(:connector) { Socialcast::CommandLine::LDAPConnector.new('connection_1', ldap_config, ldap) }
+      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') }
       let(:mappings) do
         {
@@ -155,7 +156,7 @@ describe Socialcast::CommandLine::LDAPConnector do
     end
 
     context "when the entry has a manager" do
-      let(:connector) { Socialcast::CommandLine::LDAPConnector.new('connection_1', ldap_config, ldap) }
+      let(:connector) { Socialcast::CommandLine::LDAPConnector.new('connection_1', ldap_config) }
       let(:employee_entry) { create_entry('user', :mail => 'user@example.com', :givenName => 'first name', :sn => 'last name', :manager_dn => 'cn=manager,dc=example,dc=com') }
       let(:manager_entry) { create_entry('manager', :mail => 'manager@example.com', :givenName => 'manager first name', :sn => 'manager last name') }
       let(:employee_mail_entry) { create_entry('user', :mail => 'user@example.com') }
@@ -212,7 +213,7 @@ describe Socialcast::CommandLine::LDAPConnector do
     end
 
     context "with multiple manager entries" do
-      let(:connector) { Socialcast::CommandLine::LDAPConnector.new('connection_1', ldap_config, ldap) }
+      let(:connector) { Socialcast::CommandLine::LDAPConnector.new('connection_1', ldap_config) }
       let(:employee_entry1) { create_entry('user1', :mail => 'user1@example.com', :givenName => 'first name1', :sn => 'last name1', :manager_dn => 'cn=manager1,dc=example,dc=com') }
       let(:employee_entry2) { create_entry('user2', :mail => 'user2@example.com', :givenName => 'first name2', :sn => 'last name2', :manager_dn => 'cn=manager2,dc=example,dc=com') }
       let(:employee_entry3) { create_entry('user3', :mail => 'user3@example.com', :givenName => 'first name3', :sn => 'last name3', :manager_dn => 'cn=manager1,dc=example,dc=com') }
@@ -324,7 +325,7 @@ describe Socialcast::CommandLine::LDAPConnector do
     end
 
     context "with attribute mappings at the connection level" do
-      let(:connector) { Socialcast::CommandLine::LDAPConnector.new('connection_1', ldap_config, ldap) }
+      let(:connector) { Socialcast::CommandLine::LDAPConnector.new('connection_1', ldap_config) }
       before do
         connection.merge!({ "mappings" => { "email" => "mailConnection" } })
         entry = create_entry 'user', :mailConnection => 'user@example.com'
@@ -344,7 +345,7 @@ describe Socialcast::CommandLine::LDAPConnector do
       end
     end
     context "with permission mappings at the connection level" do
-      let(:connector) { Socialcast::CommandLine::LDAPConnector.new('connection_1', ldap_config, ldap) }
+      let(:connector) { Socialcast::CommandLine::LDAPConnector.new('connection_1', ldap_config) }
       let(:ldap_groups) { ["cn=External,dc=example,dc=com", "cn=BizAdmins,dc=example,dc=com", "cn=TownHallAdmins,dc=example,dc=com"] }
       before do
         connection.merge!({
@@ -379,7 +380,7 @@ describe Socialcast::CommandLine::LDAPConnector do
       end
     end
     context "with external ldap group memberships" do
-      let(:connector) { Socialcast::CommandLine::LDAPConnector.new('connection_1', ldap_config, ldap) }
+      let(:connector) { Socialcast::CommandLine::LDAPConnector.new('connection_1', ldap_config) }
       let(:entry) do
         create_entry('user', :mail => 'user@example.com',
           :givenName => 'first name',
@@ -404,7 +405,7 @@ describe Socialcast::CommandLine::LDAPConnector do
       end
     end
     context "with role ldap group memberships" do
-      let(:connector) { Socialcast::CommandLine::LDAPConnector.new('connection_1', ldap_config, ldap) }
+      let(:connector) { Socialcast::CommandLine::LDAPConnector.new('connection_1', ldap_config) }
       let(:entry) do
         create_entry('user', :mail => 'user@example.com',
           :givenName => 'first name',
@@ -436,7 +437,7 @@ describe Socialcast::CommandLine::LDAPConnector do
           "unique_identifier" => "gid"
         }
       end
-      let(:connector) { Socialcast::CommandLine::LDAPConnector.new('connection_1', ldap_config, ldap) }
+      let(:connector) { Socialcast::CommandLine::LDAPConnector.new('connection_1', ldap_config) }
       let(:group_entry1) do
         create_entry('group1', :dn => "cn=Sales,dc=example,dc=com", :gid => "sales_group_id")
       end
@@ -481,11 +482,49 @@ describe Socialcast::CommandLine::LDAPConnector do
         }))
       end
     end
+
+    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'))
+      end
+      it "raises an error" do
+        expect do
+          connector.each_user_hash do |user_hash|
+            connector.each_user_hash do |another_user_hash|
+              # connection already open
+            end
+          end
+        end.to raise_error Socialcast::CommandLine::LDAPConnector::ConcurrentSearchError
+      end
+    end
+
+    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'))
+      end
+      it "raises an error" do
+        expect do
+          connector.each_user_hash do |user_hash|
+            begin
+              connector.each_user_hash do |another_user_hash|
+                # connection already open
+              end
+            rescue Socialcast::CommandLine::LDAPConnector::ConcurrentSearchError
+            end
+            connector.each_user_hash do |another_user_hash|
+              # connection already open
+            end
+          end
+        end.to raise_error Socialcast::CommandLine::LDAPConnector::ConcurrentSearchError
+      end
+    end
   end
 
   describe "#each_photo_hash" do
     context "when the entry has an email and photo" do
-      let(:connector) { Socialcast::CommandLine::LDAPConnector.new('connection_1', ldap_config, ldap) }
+      let(:connector) { Socialcast::CommandLine::LDAPConnector.new('connection_1', ldap_config) }
       let(:entry) { create_entry('user', :mail => 'user@example.com', :jpegPhoto => "photo") }
       let(:mappings) do
         {
@@ -508,7 +547,7 @@ describe Socialcast::CommandLine::LDAPConnector do
       end
     end
     context "when the entry does not have an email" do
-      let(:connector) { Socialcast::CommandLine::LDAPConnector.new('connection_1', ldap_config, ldap) }
+      let(:connector) { Socialcast::CommandLine::LDAPConnector.new('connection_1', ldap_config) }
       let(:entry) { create_entry('user', :mail => '', :jpegPhoto => "photo") }
       let(:mappings) do
         {
@@ -530,7 +569,7 @@ describe Socialcast::CommandLine::LDAPConnector do
     end
 
     context "when the entry does not have a photo" do
-      let(:connector) { Socialcast::CommandLine::LDAPConnector.new('connection_1', ldap_config, ldap) }
+      let(:connector) { Socialcast::CommandLine::LDAPConnector.new('connection_1', ldap_config) }
       let(:entry) { create_entry('user', :mail => 'user@example.com', :jpegPhoto => "") }
       let(:mappings) do
         {
@@ -552,7 +591,7 @@ describe Socialcast::CommandLine::LDAPConnector do
     end
 
     context "when the entry has a binary photo with incorrect encoding" do
-      let(:connector) { Socialcast::CommandLine::LDAPConnector.new('connection_1', ldap_config, ldap) }
+      let(:connector) { Socialcast::CommandLine::LDAPConnector.new('connection_1', ldap_config) }
       let(:entry) { create_entry('user', :mail => 'user@example.com', :jpegPhoto => "\x89PNGabc") }
       let(:mappings) do
         {
@@ -585,7 +624,7 @@ describe Socialcast::CommandLine::LDAPConnector do
           "unique_identifier" => "uid"
         }
       end
-      let(:connector) { Socialcast::CommandLine::LDAPConnector.new('connection_1', ldap_config, ldap) }
+      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
         filter = Net::LDAP::Filter.construct('(&(mail=*)(uid=unique identifier))')
@@ -605,8 +644,9 @@ describe Socialcast::CommandLine::LDAPConnector do
         }
       end
     end
+
     context "specifying an identifying field" do
-      let(:connector) { Socialcast::CommandLine::LDAPConnector.new('connection_1', ldap_config, ldap) }
+      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
         filter = Net::LDAP::Filter.construct('(&(mail=*)(mail=user@example.com))')
@@ -630,7 +670,7 @@ describe Socialcast::CommandLine::LDAPConnector do
 
     context "without a filter specified" do
       let(:filter) { "" }
-      let(:connector) { Socialcast::CommandLine::LDAPConnector.new('connection_1', ldap_config, ldap) }
+      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
         filter = Net::LDAP::Filter.construct('(&(objectclass=*)(mail=user@example.com))')
@@ -651,6 +691,76 @@ describe Socialcast::CommandLine::LDAPConnector do
         }
       end
     end
+
+    context "calling more than once with managers and groups configured" do
+      let(:connector) { Socialcast::CommandLine::LDAPConnector.new('connection_1', ldap_config) }
+      let(:manager) { create_entry('manager', :mail => 'manager@example.com', :givenName => 'manager first name', :sn => 'manager last name') }
+      let(:user1) { create_entry 'user1', :mail => 'user1@example.com', :givenName => 'first name 1', :sn => 'last name 1', :isMemberOf => [] }
+      let(:user2) { create_entry 'user2', :mail => 'user2@example.com', :givenName => 'first name 2', :sn => 'last name 2', :isMemberOf => ["cn=Sales,dc=example,dc=com"] }
+      let(:group) { create_entry('group', :dn => "cn=Sales,dc=example,dc=com", :gid => "sales_group_id") }
+      let(:mappings) do
+        {
+          "first_name" => "givenName",
+          "last_name" => "sn",
+          "email" => "mail",
+          "manager" => "manager_dn"
+        }
+      end
+      let(:group_membership_mappings) do
+        {
+          "filter" => "(objectClass=groupOfUniqueNames)",
+          "unique_identifier" => "gid"
+        }
+      end
+      before do
+        ldap.should_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(
+          :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
+          .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
+          .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 == {
+          'account_type' => 'member',
+          'contact_info' => {
+            'email' => 'user1@example.com'
+          },
+          'custom_fields' => [{ 'id' => 'manager_email', 'label' => 'manager_email', 'value' => nil }],
+          'first_name' => 'first name 1',
+          'last_name' => 'last name 1',
+          'groups' => [],
+          'roles' => []
+        }
+
+        connector.fetch_user_hash('user2@example.com', :identifying_field => 'email').should == {
+          'account_type' => 'member',
+          'contact_info' => {
+            'email' => 'user2@example.com'
+          },
+          'custom_fields' => [{ 'id' => 'manager_email', 'label' => 'manager_email', 'value' => nil }],
+          'first_name' => 'first name 2',
+          'last_name' => 'last name 2',
+          'groups' => ['sales_group_id'],
+          'roles' => []
+        }
+      end
+    end
   end
 
   describe "#grab" do
@@ -661,7 +771,7 @@ describe Socialcast::CommandLine::LDAPConnector do
         "email" => "mail"
       }
     end
-    let(:connector) { Socialcast::CommandLine::LDAPConnector.new('connection_1', ldap_config, ldap) }
+    let(:connector) { Socialcast::CommandLine::LDAPConnector.new('connection_1', ldap_config) }
     let(:entry) do
       Net::LDAP::Entry.new("cn=sean,dc=example,dc=com").tap do |e|
         e[:mail] = 'sean@example.com'
@@ -670,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.grab(entry, { "value" => "123%{mail}", "mail" => "mail" }).should == "123sean@example.com"
+        connector.send(:grab, entry, { "value" => "123%{mail}", "mail" => "mail" }).should == "123sean@example.com"
       end
     end
     context "passed string for attribute" do
       it "returns exact string stored in entry" do
-        connector.grab(entry, "mail").should == "sean@example.com"
+        connector.send(:grab, entry, "mail").should == "sean@example.com"
       end
     end
     context "passed string that can be constantized and the resulting Class responds to run" do
@@ -687,7 +797,7 @@ describe Socialcast::CommandLine::LDAPConnector do
             end
           end
         end
-        connector.grab(entry, "Socialcast::CommandLine::FakeAttributeMap").should == "sebn@exbmple.com"
+        connector.send(:grab, entry, "Socialcast::CommandLine::FakeAttributeMap").should == "sebn@exbmple.com"
       end
     end
     context "passed string that must be classified and the resulting Class responds to run" do
@@ -699,7 +809,7 @@ describe Socialcast::CommandLine::LDAPConnector do
             end
           end
         end
-        connector.grab(entry, "socialcast/command_line/fake_attribute_map").should == "sebn@exbmple.com"
+        connector.send(:grab, entry, "socialcast/command_line/fake_attribute_map").should == "sebn@exbmple.com"
       end
     end
     context "attribute passed has a collision between string and Class" do
@@ -714,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.grab(entry, "mail").should == "sebn@exbmple.com"
+        connector.send(:grab, entry, "mail").should == "sebn@exbmple.com"
       end
     end
     context "attribute passed constantizes to a module instead of a class" do
@@ -724,7 +834,7 @@ describe Socialcast::CommandLine::LDAPConnector do
             return "#{entry[:mail].first.gsub(/a/,'b')}"
           end
         end
-        connector.grab(entry, "FakeAttributeMap").should == "sebn@exbmple.com"
+        connector.send(:grab, entry, "FakeAttributeMap").should == "sebn@exbmple.com"
       end
     end
   end

data/spec/socialcast/command_line/provision_photo_spec.rb

@@ -12,7 +12,7 @@ describe Socialcast::CommandLine::ProvisionPhoto do
 
   let(:ldap) do
     ldap_instance = double(Net::LDAP, :auth => nil, :encryption => nil)
-    ldap_instance.should_receive(:open).and_yield(ldap_instance)
+    ldap_instance.should_receive(:open).and_yield
     Net::LDAP.should_receive(:new).and_return(ldap_instance)
     ldap_instance
   end
@@ -143,13 +143,13 @@ describe Socialcast::CommandLine::ProvisionPhoto do
         stub_const("Socialcast::CommandLine::ProvisionPhoto::MAX_BATCH_SIZE", 2)
 
         ldap_instance1 = double(Net::LDAP, :encryption => nil, :auth => nil)
-        ldap_instance1.should_receive(:open).and_yield(ldap_instance1)
+        ldap_instance1.should_receive(:open).and_yield
         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)
+        ldap_instance2.should_receive(:open).and_yield
         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)

data/spec/socialcast/command_line/provision_user_spec.rb

@@ -19,7 +19,7 @@ describe Socialcast::CommandLine::ProvisionUser do
 
   let(:ldap) do
     ldap_instance = double(Net::LDAP, :auth => nil, :encryption => nil)
-    ldap_instance.should_receive(:open).and_yield(ldap_instance)
+    ldap_instance.should_receive(:open).and_yield
     Net::LDAP.should_receive(:new).and_return(ldap_instance)
     ldap_instance
   end
@@ -117,13 +117,13 @@ 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)
+          ldap_instance1.should_receive(:open).and_yield
           Net::LDAP.should_receive(:new).once.ordered.and_return(ldap_instance1)
           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)
+          ldap_instance2.should_receive(:open).and_yield
           Net::LDAP.should_receive(:new).once.ordered.and_return(ldap_instance2)
           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)
@@ -177,7 +177,7 @@ 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)
+          ldap_instance.should_receive(:open).and_yield
           Net::LDAP.should_receive(:new).once.and_return(ldap_instance)
 
           user_entry = create_entry 'user', :mail => 'user@example.com', :ldap_manager => 'cn=theboss,dc=example,dc=com'
@@ -375,13 +375,13 @@ 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)
+          ldap_instance1.should_receive(:open).and_yield
           Net::LDAP.should_receive(:new).once.ordered.and_return(ldap_instance1)
           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)
+          ldap_instance2.should_receive(:open).and_yield
           Net::LDAP.should_receive(:new).once.ordered.and_return(ldap_instance2)
           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)
@@ -411,7 +411,7 @@ describe Socialcast::CommandLine::ProvisionUser do
         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)
+        ldap_instance.should_receive(:open).and_yield
         Net::LDAP.should_receive(:new).once.and_return(ldap_instance)
 
         user_entry = create_entry 'user', :mail => 'user@example.com', :givenName => 'first name', :sn => 'last name'
@@ -474,14 +474,14 @@ describe Socialcast::CommandLine::ProvisionUser do
       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)
+        ldap_instance1.should_receive(:open).and_yield
         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)
+        ldap_instance2.should_receive(:open).and_yield
         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
@@ -505,14 +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)
+        ldap_instance1.should_receive(:open).and_yield
         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)
+        ldap_instance2.should_receive(:open).and_yield
         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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: socialcast
 version: !ruby/object:Gem::Version
-  version: 1.3.11
+  version: 1.3.12
 platform: ruby
 authors:
 - Ryan Sonnek
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-11 00:00:00.000000000 Z
+date: 2014-06-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client