ldap_fluff 0.2.2 → 0.2.3

data/test/ad_test.rb

@@ -1,6 +1,6 @@
-require_relative './lib/ldap_test_helper'
+require 'lib/ldap_test_helper'
 
-class TestAD < MiniTest::Unit::TestCase
+class TestAD < MiniTest::Test
   include LdapTestHelper
 
   def setup
@@ -11,128 +11,131 @@ class TestAD < MiniTest::Unit::TestCase
 
   # default setup for service bind users
   def service_bind
-    @ldap.expect(:auth, nil, ["service@internet.com", "pass"])
+    @ldap.expect(:auth, nil, %w(service@internet.com pass))
     @ldap.expect(:bind, true)
     @ad.ldap = @ldap
   end
 
   def basic_user
     @md = MiniTest::Mock.new
-    @md.expect(:find_user_groups, ['bros'], ["john"])
+    @md.expect(:find_user_groups, %w(bros), %w(john))
     @ad.member_service = @md
   end
 
   def bigtime_user
     @md = MiniTest::Mock.new
-    @md.expect(:find_user_groups, ['bros', 'broskies'], ["john"])
+    @md.expect(:find_user_groups, %w(bros broskies), %w(john))
     @ad.member_service = @md
   end
 
   def test_good_bind
-    @ldap.expect(:auth, nil, ["internet@internet.com", "password"])
+    @ldap.expect(:auth, nil, %w(internet@internet.com password))
     @ldap.expect(:bind, true)
     @ad.ldap = @ldap
-    assert_equal @ad.bind?("internet", "password"), true
+    assert_equal(@ad.bind?("internet", "password"), true)
     @ldap.verify
   end
 
   def test_bad_bind
-    @ldap.expect(:auth, nil, ["internet@internet.com", "password"])
+    @ldap.expect(:auth, nil, %w(internet@internet.com password))
     @ldap.expect(:bind, false)
     @ad.ldap = @ldap
-    assert_equal @ad.bind?("internet", "password"), false
+    assert_equal(@ad.bind?("internet", "password"), false)
     @ldap.verify
   end
 
   def test_groups
     service_bind
     basic_user
-    assert_equal @ad.groups_for_uid('john'), ['bros']
+    assert_equal(@ad.groups_for_uid('john'), %w(bros))
   end
 
   def test_bad_user
     service_bind
     @md = MiniTest::Mock.new
-    @md.expect(:find_user_groups, nil, ["john"])
+    @md.expect(:find_user_groups, nil, %w(john))
     def @md.find_user_groups(*args)
       raise LdapFluff::ActiveDirectory::MemberService::UIDNotFoundException
     end
     @ad.member_service = @md
-    assert_equal @ad.groups_for_uid('john'), []
+    assert_equal(@ad.groups_for_uid('john'), [])
   end
 
   def test_bad_service_user
-    @ldap.expect(:auth, nil, ["service@internet.com", "pass"])
+    @ldap.expect(:auth, nil, %w(service@internet.com pass))
     @ldap.expect(:bind, false)
     @ad.ldap = @ldap
-    assert_raises(LdapFluff::ActiveDirectory::UnauthenticatedActiveDirectoryException) { @ad.groups_for_uid('john') }
+    assert_raises(LdapFluff::ActiveDirectory::UnauthenticatedActiveDirectoryException) do
+      @ad.groups_for_uid('john')
+    end
   end
 
   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", %w(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", %w(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", %w(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", %w(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", %w(broskies), true), true)
   end
 
   def test_user_exists
     @md = MiniTest::Mock.new
-    @md.expect(:find_user, 'notnilluser', ["john"])
+    @md.expect(:find_user, 'notnilluser', %w(john))
     @ad.member_service = @md
     service_bind
-    assert @ad.user_exists?('john')
+    assert(@ad.user_exists?('john'))
   end
 
   def test_missing_user
     @md = MiniTest::Mock.new
-    @md.expect(:find_user, nil, ['john'])
-    def @md.find_user uid
+    @md.expect(:find_user, nil, %w(john))
+    def @md.find_user(uid)
       raise LdapFluff::ActiveDirectory::MemberService::UIDNotFoundException
     end
     @ad.member_service = @md
     service_bind
-    assert !@ad.user_exists?('john')
+    refute(@ad.user_exists?('john'))
   end
 
   def test_group_exists
     @md = MiniTest::Mock.new
-    @md.expect(:find_group, 'notnillgroup', ["broskies"])
+    @md.expect(:find_group, 'notnillgroup', %w(broskies))
     @ad.member_service = @md
     service_bind
-    assert @ad.group_exists?('broskies')
+    assert(@ad.group_exists?('broskies'))
   end
 
   def test_missing_group
     @md = MiniTest::Mock.new
-    @md.expect(:find_group, nil, ['broskies'])
-    def @md.find_group uid
+    @md.expect(:find_group, nil, %w(broskies))
+    def @md.find_group(uid)
       raise LdapFluff::ActiveDirectory::MemberService::GIDNotFoundException
     end
     @ad.member_service = @md
     service_bind
-    assert !@ad.group_exists?('broskies')
+    refute(@ad.group_exists?('broskies'))
   end
+
 end

data/test/config_test.rb

@@ -1,6 +1,6 @@
-require_relative './lib/ldap_test_helper'
+require 'lib/ldap_test_helper'
 
-class ConfigTest < MiniTest::Unit::TestCase
+class ConfigTest < MiniTest::Test
   include LdapTestHelper
 
   def test_unsupported_type

data/test/ipa_member_services_test.rb

@@ -1,6 +1,6 @@
-require_relative './lib/ldap_test_helper'
+require 'lib/ldap_test_helper'
 
-class TestIPAMemberService < MiniTest::Unit::TestCase
+class TestIPAMemberService < MiniTest::Test
   include LdapTestHelper
 
   def setup
@@ -20,45 +20,52 @@ class TestIPAMemberService < MiniTest::Unit::TestCase
   def test_find_user
     basic_user
     @ipams.ldap = @ldap
-    assert_equal ['group', 'bros'], @ipams.find_user_groups("john")
+    assert_equal(%w(group bros), @ipams.find_user_groups("john"))
     @ldap.verify
   end
 
   def test_missing_user
     @ldap.expect(:search, nil, [:filter => ipa_name_filter("john")])
     @ipams.ldap = @ldap
-    assert_raises(LdapFluff::FreeIPA::MemberService::UIDNotFoundException) { @ipams.find_user_groups("john").data }
+    assert_raises(LdapFluff::FreeIPA::MemberService::UIDNotFoundException) do
+      @ipams.find_user_groups("john").data
+    end
     @ldap.verify
   end
 
   def test_no_groups
     @ldap.expect(:search, ['', { :memberof => [] }], [:filter => ipa_name_filter("john")])
     @ipams.ldap = @ldap
-    assert_equal [], @ipams.find_user_groups('john')
+    assert_equal([], @ipams.find_user_groups('john'))
     @ldap.verify
   end
 
   def test_find_good_user
     basic_user
     @ipams.ldap = @ldap
-    assert_equal ipa_user_payload, @ipams.find_user('john')
+    assert_equal(ipa_user_payload, @ipams.find_user('john'))
   end
 
   def test_find_missing_user
     @ldap.expect(:search, nil, [:filter => ipa_name_filter("john")])
     @ipams.ldap = @ldap
-    assert_raises(LdapFluff::FreeIPA::MemberService::UIDNotFoundException) { @ipams.find_user('john') }
+    assert_raises(LdapFluff::FreeIPA::MemberService::UIDNotFoundException) do
+      @ipams.find_user('john')
+    end
   end
 
   def test_find_good_group
     basic_group
     @ipams.ldap = @ldap
-    assert_equal ipa_group_payload, @ipams.find_group('broze')
+    assert_equal(ipa_group_payload, @ipams.find_group('broze'))
   end
 
   def test_find_missing_group
     @ldap.expect(:search, nil, [:filter => ipa_group_filter("broze"), :base => @config.group_base])
     @ipams.ldap = @ldap
-    assert_raises(LdapFluff::FreeIPA::MemberService::GIDNotFoundException) { @ipams.find_group('broze') }
+    assert_raises(LdapFluff::FreeIPA::MemberService::GIDNotFoundException) do
+      @ipams.find_group('broze')
+    end
   end
+
 end

data/test/ipa_test.rb

@@ -1,6 +1,6 @@
-require_relative './lib/ldap_test_helper'
+require 'lib/ldap_test_helper'
 
-class TestIPA < MiniTest::Unit::TestCase
+class TestIPA < MiniTest::Test
   include LdapTestHelper
 
   def setup
@@ -18,13 +18,13 @@ class TestIPA < MiniTest::Unit::TestCase
 
   def basic_user
     @md = MiniTest::Mock.new
-    @md.expect(:find_user_groups, ['bros'], ["john"])
+    @md.expect(:find_user_groups, %w(bros), %w(john))
     @ipa.member_service = @md
   end
 
   def bigtime_user
     @md = MiniTest::Mock.new
-    @md.expect(:find_user_groups, ['bros', 'broskies'], ["john"])
+    @md.expect(:find_user_groups, %w(bros broskies), %w(john))
     @ipa.member_service = @md
   end
 
@@ -32,7 +32,7 @@ class TestIPA < MiniTest::Unit::TestCase
     @ldap.expect(:auth, nil, [ipa_user_bind('internet'), "password"])
     @ldap.expect(:bind, true)
     @ipa.ldap = @ldap
-    assert_equal @ipa.bind?("internet", "password"), true
+    assert_equal(@ipa.bind?("internet", "password"), true)
     @ldap.verify
   end
 
@@ -40,100 +40,103 @@ class TestIPA < MiniTest::Unit::TestCase
     @ldap.expect(:auth, nil, [ipa_user_bind('internet'), "password"])
     @ldap.expect(:bind, false)
     @ipa.ldap = @ldap
-    assert_equal @ipa.bind?("internet", "password"), false
+    assert_equal(@ipa.bind?("internet", "password"), false)
     @ldap.verify
   end
 
   def test_groups
     service_bind
     basic_user
-    assert_equal @ipa.groups_for_uid('john'), ['bros']
+    assert_equal(@ipa.groups_for_uid('john'), %w(bros))
   end
 
   def test_bad_user
     service_bind
     @md = MiniTest::Mock.new
-    @md.expect(:find_user_groups, nil, ["john"])
+    @md.expect(:find_user_groups, nil, %w(john))
     def @md.find_user_groups(*args)
       raise LdapFluff::FreeIPA::MemberService::UIDNotFoundException
     end
     @ipa.member_service = @md
-    assert_equal @ipa.groups_for_uid('john'), []
+    assert_equal(@ipa.groups_for_uid('john'), [])
   end
 
   def test_bad_service_user
     @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') }
+    assert_raises(LdapFluff::FreeIPA::UnauthenticatedFreeIPAException) do
+      @ipa.groups_for_uid('john')
+    end
   end
 
   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", %w(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", %w(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", %w(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", %w(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', %w(broskies), true), true)
   end
 
   def test_user_exists
     @md = MiniTest::Mock.new
-    @md.expect(:find_user, 'notnilluser', ["john"])
+    @md.expect(:find_user, 'notnilluser', %w(john))
     @ipa.member_service = @md
     service_bind
-    assert @ipa.user_exists?('john')
+    assert(@ipa.user_exists?('john'))
   end
 
   def test_missing_user
     @md = MiniTest::Mock.new
-    @md.expect(:find_user, nil, ['john'])
-    def @md.find_user uid
+    @md.expect(:find_user, nil, %w(john))
+    def @md.find_user(uid)
       raise LdapFluff::FreeIPA::MemberService::UIDNotFoundException
     end
     @ipa.member_service = @md
     service_bind
-    assert !@ipa.user_exists?('john')
+    refute(@ipa.user_exists?('john'))
   end
 
   def test_group_exists
     @md = MiniTest::Mock.new
-    @md.expect(:find_group, 'notnillgroup', ["broskies"])
+    @md.expect(:find_group, 'notnillgroup', %w(broskies))
     @ipa.member_service = @md
     service_bind
-    assert @ipa.group_exists?('broskies')
+    assert(@ipa.group_exists?('broskies'))
   end
 
   def test_missing_group
     @md = MiniTest::Mock.new
-    @md.expect(:find_group, nil, ['broskies'])
-    def @md.find_group uid
+    @md.expect(:find_group, nil, %w(broskies))
+    def @md.find_group(uid)
       raise LdapFluff::FreeIPA::MemberService::GIDNotFoundException
     end
     @ipa.member_service = @md
     service_bind
-    assert !@ipa.group_exists?('broskies')
+    refute(@ipa.group_exists?('broskies'))
   end
+
 end
 

data/test/ldap_test.rb

@@ -1,6 +1,6 @@
-require_relative './lib/ldap_test_helper'
+require 'lib/ldap_test_helper'
 
-class TestLDAP < MiniTest::Unit::TestCase
+class TestLDAP < MiniTest::Test
   include LdapTestHelper
 
   def setup
@@ -10,53 +10,54 @@ class TestLDAP < MiniTest::Unit::TestCase
   end
 
   def test_bind
-    @ldap.expect(:bind?, true, ['john', 'password'])
+    @ldap.expect(:bind?, true, %w(john password))
     @fluff.ldap = @ldap
-    assert_equal @fluff.authenticate?("john", "password"), true
+    assert_equal(@fluff.authenticate?("john", "password"), true)
     @ldap.verify
   end
 
   def test_groups
-    @ldap.expect(:groups_for_uid, ['bros'], ['john'])
+    @ldap.expect(:groups_for_uid, %w(bros), %w(john))
     @fluff.ldap = @ldap
-    assert_equal @fluff.group_list('john'), ['bros']
+    assert_equal(@fluff.group_list('john'), %w(bros))
     @ldap.verify
   end
 
   def test_group_membership
-    @ldap.expect(:is_in_groups, false, ['john', ['broskies', 'girlfriends'], true])
+    @ldap.expect(:is_in_groups, false, ['john', %w(broskies girlfriends), true])
     @fluff.ldap = @ldap
-    assert_equal @fluff.is_in_groups?('john', ['broskies', 'girlfriends']), false
+    assert_equal(@fluff.is_in_groups?('john', %w(broskies girlfriends)), false)
     @ldap.verify
   end
 
   def test_valid_user
-    @ldap.expect(:user_exists?, true, ['john'])
+    @ldap.expect(:user_exists?, true, %w(john))
     @fluff.ldap = @ldap
-    assert @fluff.valid_user? 'john'
+    assert(@fluff.valid_user?('john'))
     @ldap.verify
   end
 
   def test_valid_group
-    @ldap.expect(:group_exists?, true, ['broskies'])
+    @ldap.expect(:group_exists?, true, %w(broskies))
     @fluff.ldap = @ldap
-    assert @fluff.valid_group? 'broskies'
+    assert(@fluff.valid_group?('broskies'))
     @ldap.verify
   end
 
   def test_invalid_group
-    @ldap.expect(:group_exists?, false, ['broskerinos'])
+    @ldap.expect(:group_exists?, false, %w(broskerinos))
     @fluff.ldap = @ldap
-    assert !@fluff.valid_group?('broskerinos')
+    refute(@fluff.valid_group?('broskerinos'))
     @ldap.verify
   end
 
   def test_invalid_user
     @ldap.expect(:user_exists?, false, ['johnny rotten'])
     @fluff.ldap = @ldap
-    assert !@fluff.valid_user?('johnny rotten')
+    refute(@fluff.valid_user?('johnny rotten'))
     @ldap.verify
   end
+
 end
 
 

data/test/lib/ldap_test_helper.rb

@@ -1,4 +1,4 @@
-require_relative '../../lib/ldap_fluff'
+require 'ldap_fluff'
 require 'ostruct'
 require 'net/ldap'
 require 'minitest/autorun'
@@ -20,7 +20,7 @@ module LdapTestHelper
   end
 
   def config
-    @config ||= OpenStruct.new config_hash
+    @config ||= LdapFluff::Config.new config_hash
   end
 
   def ad_name_filter(name)

data/test/posix_member_services_test.rb

@@ -1,6 +1,6 @@
-require_relative './lib/ldap_test_helper'
+require 'lib/ldap_test_helper'
 
-class TestPosixMemberService < MiniTest::Unit::TestCase
+class TestPosixMemberService < MiniTest::Test
   include LdapTestHelper
 
   def setup

data/test/posix_test.rb

@@ -1,6 +1,6 @@
-require_relative './lib/ldap_test_helper'
+require 'lib/ldap_test_helper'
 
-class TestPosix < MiniTest::Unit::TestCase
+class TestPosix < MiniTest::Test
   include LdapTestHelper
 
   def setup
@@ -11,88 +11,86 @@ class TestPosix < MiniTest::Unit::TestCase
 
   def basic_user
     @md = MiniTest::Mock.new
-    @md.expect(:find_user_groups, ['bros'], ["john"])
+    @md.expect(:find_user_groups, %w(bros), %w(john))
     @posix.member_service = @md
   end
 
   def test_groups
     basic_user
-    assert_equal @posix.groups_for_uid("john"), ['bros']
+    assert_equal(@posix.groups_for_uid("john"), %w(bros))
   end
 
   def test_missing_user
     @md = MiniTest::Mock.new
-    @md.expect(:find_user_groups, [], ['john'])
+    @md.expect(:find_user_groups, [], %w(john))
     @posix.member_service = @md
-    assert_equal [], @posix.groups_for_uid('john')
+    assert_equal([], @posix.groups_for_uid('john'))
   end
 
   def test_isnt_in_groups
     basic_user
     @md = MiniTest::Mock.new
-    @md.expect(:times_in_groups, 0, ['john', ['bros'], true])
+    @md.expect(:times_in_groups, 0, ['john', %w(bros), true])
     @posix.member_service = @md
-    assert_equal @posix.is_in_groups('john', ['bros'], true), false
+    assert_equal(@posix.is_in_groups('john', %w(bros), true), false)
   end
 
   def test_is_in_groups
     basic_user
     @md = MiniTest::Mock.new
-    @md.expect(:times_in_groups, 1, ['john', ['bros'], true])
+    @md.expect(:times_in_groups, 1, ['john', %w(bros), true])
     @posix.member_service = @md
-    assert_equal @posix.is_in_groups('john', ['bros'], true), true
+    assert_equal(@posix.is_in_groups('john', %w(bros), true), true)
   end
 
   def test_is_in_no_groups
     basic_user
-    assert_equal @posix.is_in_groups('john', [], true), true
+    assert_equal(@posix.is_in_groups('john', [], true), true)
   end
 
   def test_good_bind
-    @ldap.expect(:auth, nil, ["uid=internet,dc=internet,dc=com", "password"])
-    @ldap.expect(:bind, true)
+    @ldap.expect(:bind_as, true, [:filter => "(uid=internet)", :password => "password"])
     @posix.ldap = @ldap
-    assert_equal @posix.bind?("internet", "password"), true
+    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(:bind, false)
+    @ldap.expect(:bind_as, false, [:filter => "(uid=internet)", :password => "password"])
     @posix.ldap = @ldap
-    assert_equal @posix.bind?("internet", "password"), false
+    assert_equal(@posix.bind?("internet", "password"), false)
   end
 
   def test_user_exists
     @md = MiniTest::Mock.new
-    @md.expect(:find_user, 'notnilluser', ["john"])
+    @md.expect(:find_user, 'notnilluser', %w(john))
     @posix.member_service = @md
-    assert @posix.user_exists?('john')
+    assert(@posix.user_exists?('john'))
   end
 
   def test_missing_user
     @md = MiniTest::Mock.new
-    @md.expect(:find_user, nil, ['john'])
-    def @md.find_user uid
+    @md.expect(:find_user, nil, %w(john))
+    def @md.find_user(uid)
       raise LdapFluff::Posix::MemberService::UIDNotFoundException
     end
     @posix.member_service = @md
-    assert !@posix.user_exists?('john')
+    refute(@posix.user_exists?('john'))
   end
 
   def test_group_exists
     @md = MiniTest::Mock.new
-    @md.expect(:find_group, 'notnillgroup', ["broskies"])
+    @md.expect(:find_group, 'notnillgroup', %w(broskies))
     @posix.member_service = @md
-    assert @posix.group_exists?('broskies')
+    assert(@posix.group_exists?('broskies'))
   end
 
   def test_missing_group
     @md = MiniTest::Mock.new
-    @md.expect(:find_group, nil, ['broskies'])
-    def @md.find_group uid
+    @md.expect(:find_group, nil, %w(broskies))
+    def @md.find_group(uid)
       raise LdapFluff::Posix::MemberService::GIDNotFoundException
     end
     @posix.member_service = @md
-    assert !@posix.group_exists?('broskies')
+    refute(@posix.group_exists?('broskies'))
   end
 end