ldap_fluff 0.1.7 → 0.2.1

data/lib/ldap_fluff/active_directory.rb

@@ -2,18 +2,18 @@ class LdapFluff::ActiveDirectory
   attr_accessor :ldap, :member_service
 
   def initialize(config={})
-    @ldap = Net::LDAP.new :host => config.host,
-                         :base => config.base_dn,
-                         :port => config.port,
-                         :encryption => config.encryption
+    @ldap       = Net::LDAP.new :host       => config.host,
+                                :base       => config.base_dn,
+                                :port       => config.port,
+                                :encryption => config.encryption
     @group_base = config.group_base
     @group_base ||= config.base_dn
-    @ad_domain = config.ad_domain
-    @bind_user = config.service_user
-    @bind_pass = config.service_pass
-    @anon = config.anon_queries
+    @ad_domain  = config.ad_domain
+    @bind_user  = config.service_user
+    @bind_pass  = config.service_pass
+    @anon       = config.anon_queries
 
-    @member_service = MemberService.new(@ldap,@group_base)
+    @member_service = MemberService.new(@ldap, @group_base)
   end
 
   def bind?(uid=nil, password=nil)
@@ -46,7 +46,7 @@ class LdapFluff::ActiveDirectory
     service_bind
     return true if gids == []
     begin
-      groups = @member_service.find_user_groups(uid)
+      groups       = @member_service.find_user_groups(uid)
       intersection = gids & groups
       if all
         return intersection == gids

data/lib/ldap_fluff/ad_member_service.rb

@@ -5,8 +5,8 @@ class LdapFluff::ActiveDirectory::MemberService
 
   attr_accessor :ldap
 
-  def initialize(ldap,group_base)
-    @ldap = ldap
+  def initialize(ldap, group_base)
+    @ldap       = ldap
     @group_base = group_base
   end
 
@@ -33,9 +33,9 @@ class LdapFluff::ActiveDirectory::MemberService
   def _groups_from_ldap_data(payload)
     data = []
     if payload != nil
-      first_level = _group_names_from_cn(payload[:memberof])
+      first_level  = _group_names_from_cn(payload[:memberof])
       total_groups = _walk_group_ancestry(first_level)
-      data = (first_level + total_groups).uniq
+      data         = (first_level + total_groups).uniq
     end
     data
   end
@@ -48,8 +48,8 @@ class LdapFluff::ActiveDirectory::MemberService
       search = @ldap.search(:filter => filter, :base => @group_base)
       if search != nil && search.first != nil
         group = search.first
-        set += _group_names_from_cn(group[:memberof])
-        set += _walk_group_ancestry(set)
+        set   += _group_names_from_cn(group[:memberof])
+        set   += _walk_group_ancestry(set)
       end
     end
     set
@@ -60,11 +60,11 @@ class LdapFluff::ActiveDirectory::MemberService
   end
 
   def class_filter
-    Net::LDAP::Filter.eq("objectclass","group")
+    Net::LDAP::Filter.eq("objectclass", "group")
   end
 
   def name_filter(uid)
-    Net::LDAP::Filter.eq("samaccountname",uid)
+    Net::LDAP::Filter.eq("samaccountname", uid)
   end
 
   # extract the group names from the LDAP style response,

data/lib/ldap_fluff/config.rb

@@ -1,51 +1,17 @@
-require 'singleton'
 require 'yaml'
 
 class LdapFluff
-  ####################################################################
-  # Module constants
-  ####################################################################
-  CONFIG = "/etc/ldap_fluff.yml"
-  ####################################################################
-  # Module class definitions
-  ####################################################################
   class Config
-    include Singleton
-    attr_accessor :host,
-                  :port,
-                  :encryption,
-                  :base_dn,
-                  :group_base,
-                  :server_type,
-                  :ad_domain,
-                  :service_user,
-                  :service_pass,
-                  :anon_queries
+    ATTRIBUTES = [:host, :port, :encryption, :base_dn, :group_base, :server_type, :ad_domain, :service_user,
+                  :service_pass, :anon_queries]
+    ATTRIBUTES.each { |attr| attr_reader attr }
 
-    def initialize
-      begin
-        config = YAML.load_file(LdapFluff::CONFIG)
-        @host = config["host"]
-        @port = config["port"]
-        if config["encryption"].respond_to? :to_sym
-          @encryption = config["encryption"].to_sym
-        else
-          @encryption = nil
-        end
-        @base_dn = config["base_dn"]
-        @group_base = config["group_base"]
-        @ad_domain = config["ad_domain"]
-        @service_user = config["service_user"]
-        @service_pass = config["service_pass"]
-        @anon_queries = config["anon_queries"]
-        @server_type = config["server_type"]
-      rescue Errno::ENOENT
-        $stderr.puts("The #{LdapFluff::CONFIG} config file you specified was not found")
-        exit
-      rescue Errno::EACCES
-        $stderr.puts("The #{LdapFluff::CONFIG} config file you specified is not readable")
-        exit
-      end
+    def initialize(options)
+      raise ArgumentError unless options.kind_of? Hash
+      options = options.inject({}) { |hash, (k, v)| hash.update k.to_s => v }
+      ATTRIBUTES.each { |attr| instance_variable_set :"@#{attr}", options[attr.to_s] }
+      @encryption = @encryption.to_sym if @encryption
+      @server_type = @server_type.to_sym if @server_type
     end
   end
 end

data/lib/ldap_fluff/freeipa.rb

@@ -3,18 +3,18 @@ class LdapFluff::FreeIPA
   attr_accessor :ldap, :member_service
 
   def initialize(config={})
-    @ldap = Net::LDAP.new :host => config.host,
-                         :base => config.base_dn,
-                         :port => config.port,
-                         :encryption => config.encryption
+    @ldap       = Net::LDAP.new :host       => config.host,
+                                :base       => config.base_dn,
+                                :port       => config.port,
+                                :encryption => config.encryption
     @group_base = config.group_base
     @group_base ||= config.base_dn
-    @base = config.base_dn
-    @bind_user = config.service_user
-    @bind_pass = config.service_pass
-    @anon = config.anon_queries
+    @base       = config.base_dn
+    @bind_user  = config.service_user
+    @bind_pass  = config.service_pass
+    @anon       = config.anon_queries
 
-    @member_service = MemberService.new(@ldap,@group_base)
+    @member_service = MemberService.new(@ldap, @group_base)
   end
 
   def bind?(uid=nil, password=nil)

data/lib/ldap_fluff/freeipa_member_service.rb

@@ -5,8 +5,8 @@ class LdapFluff::FreeIPA::MemberService
 
   attr_accessor :ldap
 
-  def initialize(ldap,group_base)
-    @ldap = ldap
+  def initialize(ldap, group_base)
+    @ldap       = ldap
     @group_base = group_base
   end
 
@@ -33,11 +33,11 @@ class LdapFluff::FreeIPA::MemberService
   end
 
   def name_filter(uid)
-    Net::LDAP::Filter.eq("uid",uid)
+    Net::LDAP::Filter.eq("uid", uid)
   end
 
   def group_filter(gid)
-    Net::LDAP::Filter.eq("cn",gid)
+    Net::LDAP::Filter.eq("cn", gid)
   end
 
   def _group_names_from_cn(grouplist)

data/lib/ldap_fluff/ldap_fluff.rb

@@ -2,23 +2,22 @@ require 'rubygems'
 require 'net/ldap'
 
 class LdapFluff
-  class ConfigError < StandardError; end
+  class ConfigError < StandardError
+  end
 
   attr_accessor :ldap
 
-  def initialize(config=nil)
-    config ||= LdapFluff::Config.instance
-    type = config.server_type
-    if type.respond_to? :to_sym
-      if type.to_sym == :posix
-        @ldap = Posix.new(config)
-      elsif type.to_sym == :active_directory
-        @ldap = ActiveDirectory.new(config)
-      elsif type.to_sym == :free_ipa
-        @ldap = FreeIPA.new(config)
-      else
-        raise ConfigError, "Unsupported connection type. Supported types = :active_directory, :posix, :free_ipa"
-      end
+  def initialize(config = {})
+    config = LdapFluff::Config.new(config)
+    case config.server_type
+    when :posix
+      @ldap = Posix.new(config)
+    when :active_directory
+      @ldap = ActiveDirectory.new(config)
+    when :free_ipa
+      @ldap = FreeIPA.new(config)
+    else
+      raise ConfigError, "Unsupported connection type #{config.server_type.inspect}. Supported types = :active_directory, :posix, :free_ipa"
     end
   end
 

data/lib/ldap_fluff/posix.rb

@@ -3,14 +3,13 @@ class LdapFluff::Posix
   attr_accessor :ldap, :member_service
 
   def initialize(config={})
-    @ldap = Net::LDAP.new :host => config.host,
-                         :base => config.base_dn,
-                         :port => config.port,
-                         :encryption => config.encryption
-    @group_base = config.group_base
-    @group_base ||= config.base
-    @base = config.base_dn
-    @member_service = MemberService.new(@ldap,@group_base)
+    @ldap           = Net::LDAP.new :host       => config.host,
+                                    :base       => config.base_dn,
+                                    :port       => config.port,
+                                    :encryption => config.encryption
+    @group_base     = config.group_base || config.base
+    @base           = config.base_dn
+    @member_service = MemberService.new(@ldap, @group_base)
   end
 
   def bind?(uid=nil, password=nil)

data/lib/ldap_fluff/posix_member_service.rb

@@ -5,8 +5,8 @@ class LdapFluff::Posix::MemberService
 
   attr_accessor :ldap
 
-  def initialize(ldap,group_base)
-    @ldap = ldap
+  def initialize(ldap, group_base)
+    @ldap       = ldap
     @group_base = group_base
   end
 
@@ -38,13 +38,13 @@ class LdapFluff::Posix::MemberService
     gids.each do |cn|
       filters << group_filter(cn)
     end
-    group_filters = merge_filters(filters,all)
-    filter = name_filter(uid) & group_filters
+    group_filters = merge_filters(filters, all)
+    filter        = name_filter(uid) & group_filters
     @ldap.search(:base => @group_base, :filter => filter).size
   end
 
   def name_filter(uid)
-    Net::LDAP::Filter.eq("memberUid",uid)
+    Net::LDAP::Filter.eq("memberUid", uid)
   end
 
   def group_filter(cn)

data/test/ad_member_services_test.rb

@@ -5,8 +5,8 @@ class TestADMemberService < MiniTest::Unit::TestCase
 
   def setup
     config
-    @ldap = MiniTest::Mock.new
-    @adms = LdapFluff::ActiveDirectory::MemberService.new(@ldap,@config.group_base)
+    @ldap    = MiniTest::Mock.new
+    @adms    = LdapFluff::ActiveDirectory::MemberService.new(@ldap, @config.group_base)
     @gfilter = group_filter('group') & group_class_filter
   end
 
@@ -26,7 +26,7 @@ class TestADMemberService < MiniTest::Unit::TestCase
       @ldap.expect(:search, ad_parent_payload(i+1), [:filter => gfilter_bros, :base => @config.group_base])
     end
     # terminate or we loop FOREVER
-    @ldap.expect(:search,[], [:filter => group_filter("bros#{n}") & group_class_filter, :base => @config.group_base])
+    @ldap.expect(:search, [], [:filter => group_filter("bros#{n}") & group_class_filter, :base => @config.group_base])
   end
 
   def double_nested(n)
@@ -36,10 +36,10 @@ class TestADMemberService < MiniTest::Unit::TestCase
       @ldap.expect(:search, ad_double_payload(i+1), [:filter => gfilter_bros, :base => @config.group_base])
     end
     # terminate or we loop FOREVER
-    @ldap.expect(:search,[], [:filter => group_filter("bros#{n}") & group_class_filter, :base => @config.group_base])
+    @ldap.expect(:search, [], [:filter => group_filter("bros#{n}") & group_class_filter, :base => @config.group_base])
     (n-1).downto(1) do |i|
       gfilter_bros = group_filter("broskies#{i+1}") & group_class_filter
-      @ldap.expect(:search,[], [:filter => gfilter_bros, :base => @config.group_base])
+      @ldap.expect(:search, [], [:filter => gfilter_bros, :base => @config.group_base])
     end
   end
 

data/test/ad_test.rb

@@ -5,13 +5,13 @@ class TestAD < MiniTest::Unit::TestCase
 
   def setup
     config
-    @ad = LdapFluff::ActiveDirectory.new(@config)
+    @ad   = LdapFluff::ActiveDirectory.new(@config)
     @ldap = MiniTest::Mock.new
   end
 
   # default setup for service bind users
   def service_bind
-    @ldap.expect(:auth, nil, ["service@internet.com","pass"])
+    @ldap.expect(:auth, nil, ["service@internet.com", "pass"])
     @ldap.expect(:bind, true)
     @ad.ldap = @ldap
   end
@@ -24,12 +24,12 @@ class TestAD < MiniTest::Unit::TestCase
 
   def bigtime_user
     @md = MiniTest::Mock.new
-    @md.expect(:find_user_groups, ['bros','broskies'], ["john"])
+    @md.expect(:find_user_groups, ['bros', 'broskies'], ["john"])
     @ad.member_service = @md
   end
 
   def test_good_bind
-    @ldap.expect(:auth, nil, ["internet@internet.com","password"])
+    @ldap.expect(:auth, nil, ["internet@internet.com", "password"])
     @ldap.expect(:bind, true)
     @ad.ldap = @ldap
     assert_equal @ad.bind?("internet", "password"), true
@@ -37,7 +37,7 @@ class TestAD < MiniTest::Unit::TestCase
   end
 
   def test_bad_bind
-    @ldap.expect(:auth, nil, ["internet@internet.com","password"])
+    @ldap.expect(:auth, nil, ["internet@internet.com", "password"])
     @ldap.expect(:bind, false)
     @ad.ldap = @ldap
     assert_equal @ad.bind?("internet", "password"), false
@@ -62,7 +62,7 @@ class TestAD < MiniTest::Unit::TestCase
   end
 
   def test_bad_service_user
-    @ldap.expect(:auth, nil, ["service@internet.com","pass"])
+    @ldap.expect(:auth, nil, ["service@internet.com", "pass"])
     @ldap.expect(:bind, false)
     @ad.ldap = @ldap
     assert_raises(LdapFluff::ActiveDirectory::UnauthenticatedActiveDirectoryException) { @ad.groups_for_uid('john') }
@@ -71,31 +71,31 @@ class TestAD < MiniTest::Unit::TestCase
   def test_is_in_groups
     service_bind
     basic_user
-    assert_equal @ad.is_in_groups("john",["bros"],false), true
+    assert_equal @ad.is_in_groups("john", ["bros"], false), true
   end
 
   def test_is_some_groups
     service_bind
     basic_user
-    assert_equal @ad.is_in_groups("john",["bros","buds"],false), true
+    assert_equal @ad.is_in_groups("john", ["bros", "buds"], false), true
   end
 
   def test_isnt_in_all_groups
     service_bind
     basic_user
-    assert_equal @ad.is_in_groups("john",["bros","buds"],true), false
+    assert_equal @ad.is_in_groups("john", ["bros", "buds"], true), false
   end
 
   def test_isnt_in_groups
     service_bind
     basic_user
-    assert_equal @ad.is_in_groups("john", ["broskies"],false), false
+    assert_equal @ad.is_in_groups("john", ["broskies"], false), false
   end
 
   def test_group_subset
     service_bind
     bigtime_user
-    assert_equal @ad.is_in_groups("john", ["broskies"],true), true
+    assert_equal @ad.is_in_groups("john", ["broskies"], true), true
   end
 
   def test_user_exists

data/test/config_test.rb

@@ -3,31 +3,23 @@ require_relative './lib/ldap_test_helper'
 class ConfigTest < MiniTest::Unit::TestCase
   include LdapTestHelper
 
-  def setup
-    config
-  end
-
   def test_unsupported_type
-    @config.server_type = "inactive_directory"
-    assert_raises(LdapFluff::ConfigError) { LdapFluff.new(@config) }
+    assert_raises(LdapFluff::ConfigError) { LdapFluff.new(config_hash.update :server_type => 'inactive_directory') }
   end
 
   def test_load_posix
-    @config.server_type = "posix"
-    l = LdapFluff.new(@config)
-    assert_instance_of LdapFluff::Posix, l.ldap
+    ldap = LdapFluff.new(config_hash.update :server_type => 'posix')
+    assert_instance_of LdapFluff::Posix, ldap.ldap
   end
 
   def test_load_ad
-    @config.server_type = "active_directory"
-    l = LdapFluff.new(@config)
-    assert_instance_of LdapFluff::ActiveDirectory, l.ldap
+    ldap = LdapFluff.new(config_hash.update :server_type => 'active_directory')
+    assert_instance_of LdapFluff::ActiveDirectory, ldap.ldap
   end
 
-  def test_load_ad
-    @config.server_type = "free_ipa"
-    l = LdapFluff.new(@config)
-    assert_instance_of LdapFluff::FreeIPA, l.ldap
+  def test_load_free_ipa
+    ldap = LdapFluff.new(config_hash.update :server_type => 'free_ipa')
+    assert_instance_of LdapFluff::FreeIPA, ldap.ldap
   end
 
 end

data/test/ipa_member_services_test.rb

@@ -5,8 +5,8 @@ class TestIPAMemberService < MiniTest::Unit::TestCase
 
   def setup
     config
-    @ldap = MiniTest::Mock.new
-    @ipams = LdapFluff::FreeIPA::MemberService.new(@ldap,@config.group_base)
+    @ldap  = MiniTest::Mock.new
+    @ipams = LdapFluff::FreeIPA::MemberService.new(@ldap, @config.group_base)
   end
 
   def basic_user
@@ -32,7 +32,7 @@ class TestIPAMemberService < MiniTest::Unit::TestCase
   end
 
   def test_no_groups
-    @ldap.expect(:search, ['',{:memberof=>[]}], [:filter => ipa_name_filter("john")])
+    @ldap.expect(:search, ['', { :memberof => [] }], [:filter => ipa_name_filter("john")])
     @ipams.ldap = @ldap
     assert_equal [], @ipams.find_user_groups('john')
     @ldap.verify

data/test/ipa_test.rb

@@ -5,13 +5,13 @@ class TestIPA < MiniTest::Unit::TestCase
 
   def setup
     config
-    @ipa = LdapFluff::FreeIPA.new(@config)
+    @ipa  = LdapFluff::FreeIPA.new(@config)
     @ldap = MiniTest::Mock.new
   end
 
   # default setup for service bind users
   def service_bind
-    @ldap.expect(:auth, nil, [ipa_user_bind('service'),"pass"])
+    @ldap.expect(:auth, nil, [ipa_user_bind('service'), "pass"])
     @ldap.expect(:bind, true)
     @ipa.ldap = @ldap
   end
@@ -24,12 +24,12 @@ class TestIPA < MiniTest::Unit::TestCase
 
   def bigtime_user
     @md = MiniTest::Mock.new
-    @md.expect(:find_user_groups, ['bros','broskies'], ["john"])
+    @md.expect(:find_user_groups, ['bros', 'broskies'], ["john"])
     @ipa.member_service = @md
   end
 
   def test_good_bind
-    @ldap.expect(:auth, nil, [ipa_user_bind('internet'),"password"])
+    @ldap.expect(:auth, nil, [ipa_user_bind('internet'), "password"])
     @ldap.expect(:bind, true)
     @ipa.ldap = @ldap
     assert_equal @ipa.bind?("internet", "password"), true
@@ -37,7 +37,7 @@ class TestIPA < MiniTest::Unit::TestCase
   end
 
   def test_bad_bind
-    @ldap.expect(:auth, nil, [ipa_user_bind('internet'),"password"])
+    @ldap.expect(:auth, nil, [ipa_user_bind('internet'), "password"])
     @ldap.expect(:bind, false)
     @ipa.ldap = @ldap
     assert_equal @ipa.bind?("internet", "password"), false
@@ -62,7 +62,7 @@ class TestIPA < MiniTest::Unit::TestCase
   end
 
   def test_bad_service_user
-    @ldap.expect(:auth, nil, [ipa_user_bind('service'),"pass"])
+    @ldap.expect(:auth, nil, [ipa_user_bind('service'), "pass"])
     @ldap.expect(:bind, false)
     @ipa.ldap = @ldap
     assert_raises(LdapFluff::FreeIPA::UnauthenticatedFreeIPAException) { @ipa.groups_for_uid('john') }
@@ -71,31 +71,31 @@ class TestIPA < MiniTest::Unit::TestCase
   def test_is_in_groups
     service_bind
     basic_user
-    assert_equal @ipa.is_in_groups("john",["bros"],false), true
+    assert_equal @ipa.is_in_groups("john", ["bros"], false), true
   end
 
   def test_is_some_groups
     service_bind
     basic_user
-    assert_equal @ipa.is_in_groups("john",["bros","buds"],false), true
+    assert_equal @ipa.is_in_groups("john", ["bros", "buds"], false), true
   end
 
   def test_isnt_in_all_groups
     service_bind
     basic_user
-    assert_equal @ipa.is_in_groups("john",["bros","buds"],true), false
+    assert_equal @ipa.is_in_groups("john", ["bros", "buds"], true), false
   end
 
   def test_isnt_in_groups
     service_bind
     basic_user
-    assert_equal @ipa.is_in_groups("john", ["broskies"],false), false
+    assert_equal @ipa.is_in_groups("john", ["broskies"], false), false
   end
 
   def test_group_subset
     service_bind
     bigtime_user
-    assert_equal @ipa.is_in_groups('john',["broskies"],true), true
+    assert_equal @ipa.is_in_groups('john', ["broskies"], true), true
   end
 
   def test_user_exists

data/test/ldap_test.rb

@@ -5,14 +5,14 @@ class TestLDAP < MiniTest::Unit::TestCase
 
   def setup
     config
-    @ldap = MiniTest::Mock.new
-    @fluff = LdapFluff.new(@config)
+    @ldap  = MiniTest::Mock.new
+    @fluff = LdapFluff.new(config_hash)
   end
 
   def test_bind
-    @ldap.expect(:bind?, true, ['john','password'])
+    @ldap.expect(:bind?, true, ['john', 'password'])
     @fluff.ldap = @ldap
-    assert_equal @fluff.authenticate?("john","password"), true
+    assert_equal @fluff.authenticate?("john", "password"), true
     @ldap.verify
   end
 
@@ -24,9 +24,9 @@ class TestLDAP < MiniTest::Unit::TestCase
   end
 
   def test_group_membership
-    @ldap.expect(:is_in_groups, false, ['john',['broskies','girlfriends'],true])
+    @ldap.expect(:is_in_groups, false, ['john', ['broskies', 'girlfriends'], true])
     @fluff.ldap = @ldap
-    assert_equal @fluff.is_in_groups?('john',['broskies','girlfriends']), false
+    assert_equal @fluff.is_in_groups?('john', ['broskies', 'girlfriends']), false
     @ldap.verify
   end
 

data/test/lib/ldap_test_helper.rb

@@ -6,33 +6,37 @@ require 'minitest/autorun'
 module LdapTestHelper
   attr_accessor :group_base, :class_filter, :user
 
+  def config_hash
+    { :host         => "internet.com",
+      :port         => "387",
+      :encryption   => :start_tls,
+      :base_dn      => "dc=internet,dc=com",
+      :group_base   => "ou=group,dc=internet,dc=com",
+      :service_user => "service",
+      :service_pass => "pass",
+      :ad_domain    => "internet.com",
+      :server_type  => :free_ipa
+    }
+  end
+
   def config
-    @config = OpenStruct.new(
-        :host => "internet.com",
-        :port => "387",
-        :encryption => :start_tls,
-        :base_dn => "dc=internet,dc=com",
-        :group_base => "ou=group,dc=internet,dc=com",
-        :service_user => "service",
-        :service_pass => "pass",
-        :ad_domain => "internet.com"
-      )
+    @config ||= OpenStruct.new config_hash
   end
 
   def ad_name_filter(name)
-    Net::LDAP::Filter.eq("samaccountname",name)
+    Net::LDAP::Filter.eq("samaccountname", name)
   end
 
   def ad_group_filter(name)
-    Net::LDAP::Filter.eq("cn",name)
+    Net::LDAP::Filter.eq("cn", name)
   end
 
   def ipa_name_filter(name)
-    Net::LDAP::Filter.eq("uid",name)
+    Net::LDAP::Filter.eq("uid", name)
   end
 
   def ipa_group_filter(name)
-    Net::LDAP::Filter.eq("cn",name)
+    Net::LDAP::Filter.eq("cn", name)
   end
 
   def group_filter(g)
@@ -40,7 +44,7 @@ module LdapTestHelper
   end
 
   def group_class_filter
-    Net::LDAP::Filter.eq("objectclass","group")
+    Net::LDAP::Filter.eq("objectclass", "group")
   end
 
   def ipa_user_bind(uid)
@@ -52,7 +56,7 @@ module LdapTestHelper
   end
 
   def ad_group_payload
-    [{:cn => "broze",  :memberof => ["CN=group,dc=internet,dc=com"] }]
+    [{ :cn => "broze", :memberof => ["CN=group,dc=internet,dc=com"] }]
   end
 
   def ad_parent_payload(num)
@@ -64,18 +68,18 @@ module LdapTestHelper
   end
 
   def posix_user_payload
-    [{:cn => ["bros"]}]
+    [{ :cn => ["bros"] }]
   end
 
   def posix_group_payload
-    [{:cn => ["broze"]}]
+    [{ :cn => ["broze"] }]
   end
 
   def ipa_user_payload
-    [{:cn => 'john'},{:memberof => ['cn=group,dc=internet,dc=com','cn=bros,dc=internet,dc=com']}]
+    [{ :cn => 'john' }, { :memberof => ['cn=group,dc=internet,dc=com', 'cn=bros,dc=internet,dc=com'] }]
   end
 
   def ipa_group_payload
-    [{:cn => 'group'},{:memberof => ['cn=group,dc=internet,dc=com','cn=bros,dc=internet,dc=com']}]
+    [{ :cn => 'group' }, { :memberof => ['cn=group,dc=internet,dc=com', 'cn=bros,dc=internet,dc=com'] }]
   end
 end

data/test/posix_member_services_test.rb

@@ -6,18 +6,13 @@ class TestPosixMemberService < MiniTest::Unit::TestCase
   def setup
     config
     @ldap = MiniTest::Mock.new
-    @ms = LdapFluff::Posix::MemberService.new(@ldap, @config.group_base)
+    @ms   = LdapFluff::Posix::MemberService.new(@ldap, @config.group_base)
   end
 
   def test_find_user
     user = posix_user_payload
-    @ldap.expect(:search,
-                 user,
-                 [
-                   :filter => @ms.name_filter('john'),
-                  :base =>config.group_base
-                 ]
-                )
+    @ldap.expect(:search, user, [:filter => @ms.name_filter('john'),
+                                 :base   => config.group_base])
     @ms.ldap = @ldap
     assert_equal ['bros'], @ms.find_user_groups('john')
     @ldap.verify
@@ -25,26 +20,16 @@ class TestPosixMemberService < MiniTest::Unit::TestCase
 
   def test_user_exists
     user = posix_user_payload
-    @ldap.expect(:search,
-                 user,
-                 [
-                   :filter => @ms.name_filter('john'),
-                  :base =>config.group_base
-                 ]
-                )
+    @ldap.expect(:search, user, [:filter => @ms.name_filter('john'),
+                                 :base   => config.group_base])
     @ms.ldap = @ldap
     assert @ms.find_user('john')
     @ldap.verify
   end
 
   def test_user_doesnt_exists
-    @ldap.expect(:search,
-                 nil,
-                 [
-                   :filter => @ms.name_filter('john'),
-                  :base =>config.group_base
-                 ]
-                )
+    @ldap.expect(:search, nil, [:filter => @ms.name_filter('john'),
+                                :base   => config.group_base])
     @ms.ldap = @ldap
     assert_raises(LdapFluff::Posix::MemberService::UIDNotFoundException) { @ms.find_user('john') }
     @ldap.verify
@@ -52,26 +37,16 @@ class TestPosixMemberService < MiniTest::Unit::TestCase
 
   def test_group_exists
     group = posix_group_payload
-    @ldap.expect(:search,
-                 group,
-                 [
-                   :filter => @ms.group_filter('broze'),
-                  :base =>config.group_base
-                 ]
-                )
+    @ldap.expect(:search, group, [:filter => @ms.group_filter('broze'),
+                                  :base   => config.group_base])
     @ms.ldap = @ldap
     assert @ms.find_group('broze')
     @ldap.verify
   end
 
   def test_group_doesnt_exists
-    @ldap.expect(:search,
-                 nil,
-                 [
-                   :filter => @ms.group_filter('broze'),
-                  :base =>config.group_base
-                 ]
-                )
+    @ldap.expect(:search, nil, [:filter => @ms.group_filter('broze'),
+                                :base   => config.group_base])
     @ms.ldap = @ldap
     assert_raises(LdapFluff::Posix::MemberService::GIDNotFoundException) { @ms.find_group('broze') }
     @ldap.verify

data/test/posix_test.rb

@@ -6,7 +6,7 @@ class TestPosix < MiniTest::Unit::TestCase
   def setup
     config
     @posix = LdapFluff::Posix.new(@config)
-    @ldap = MiniTest::Mock.new
+    @ldap  = MiniTest::Mock.new
   end
 
   def basic_user
@@ -49,14 +49,14 @@ class TestPosix < MiniTest::Unit::TestCase
   end
 
   def test_good_bind
-    @ldap.expect(:auth, nil, ["uid=internet,dc=internet,dc=com","password"])
+    @ldap.expect(:auth, nil, ["uid=internet,dc=internet,dc=com", "password"])
     @ldap.expect(:bind, true)
     @posix.ldap = @ldap
     assert_equal @posix.bind?("internet", "password"), true
   end
 
   def test_bad_bind
-    @ldap.expect(:auth, nil, ["uid=internet,dc=internet,dc=com","password"])
+    @ldap.expect(:auth, nil, ["uid=internet,dc=internet,dc=com", "password"])
     @ldap.expect(:bind, false)
     @posix.ldap = @ldap
     assert_equal @posix.bind?("internet", "password"), false

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ldap_fluff
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.2.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-11 00:00:00.000000000 Z
+date: 2013-05-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: net-ldap
@@ -18,9 +18,25 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.3.1
   type: :runtime
   prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.3.1
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -43,35 +59,31 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: ! 'Simple library for binding & group querying on top of various ldap
-  implementations
-
-'
+description: Simple library for binding & group querying on top of various ldap implementations
 email: jomara@redhat.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- etc/ldap_fluff.yml
 - lib/ldap_fluff.rb
-- lib/ldap_fluff/active_directory.rb
-- lib/ldap_fluff/ad_member_service.rb
-- lib/ldap_fluff/config.rb
 - lib/ldap_fluff/freeipa.rb
 - lib/ldap_fluff/freeipa_member_service.rb
 - lib/ldap_fluff/ldap_fluff.rb
-- lib/ldap_fluff/posix.rb
+- lib/ldap_fluff/active_directory.rb
 - lib/ldap_fluff/posix_member_service.rb
+- lib/ldap_fluff/config.rb
+- lib/ldap_fluff/posix.rb
+- lib/ldap_fluff/ad_member_service.rb
 - test/ad_member_services_test.rb
-- test/ad_test.rb
 - test/config_test.rb
-- test/ipa_member_services_test.rb
-- test/ipa_test.rb
 - test/ldap_test.rb
-- test/lib/ldap_test_helper.rb
 - test/posix_member_services_test.rb
+- test/ad_test.rb
+- test/ipa_test.rb
+- test/ipa_member_services_test.rb
+- test/lib/ldap_test_helper.rb
 - test/posix_test.rb
-homepage: http://www.redhat.com
+homepage: https://github.com/Katello/ldap_fluff
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -91,8 +103,18 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: LDAP Querying tools for Active Directory, FreeIPA and Posix-style
-test_files: []
+test_files:
+- test/ad_member_services_test.rb
+- test/config_test.rb
+- test/ldap_test.rb
+- test/posix_member_services_test.rb
+- test/ad_test.rb
+- test/ipa_test.rb
+- test/ipa_member_services_test.rb
+- test/lib/ldap_test_helper.rb
+- test/posix_test.rb
+has_rdoc: true

data/etc/ldap_fluff.yml

@@ -1,11 +0,0 @@
----
-host: ## ip address or hostname
-port: ## ip address or hostname
-encryption: ## blank or :start_tls
-base_dn: ## baseDN for ldap auth, eg dc=redhat,dc=com
-group_base: ##baseDN for your ldap groups, eg ou=Groups,dc=redhat,dc=com
-server_type: ## type of server. default == posix. :active_directory, :posix, :free_ipa
-ad_domain: ## domain for your users if using active directory, eg redhat.com
-service_user: ## service account for authenticating ldap calls in active directory or ipa
-service_pass: ## service password for authenticating ldap calls in active directory or ipa
-anon_queries: ## allow anonymous queries for AD or FreeIPA