ad-framework 0.1.0

data/lib/ad-framework/utilities/transaction.rb

@@ -0,0 +1,32 @@
+module AD
+  module Framework
+    module Utilities
+
+      class Transaction
+        attr_accessor :callbacks, :entry, :block
+        
+        def initialize(action, entry, &block)
+          self.entry = entry
+          self.callbacks = (self.entry.schema.callbacks[action.to_sym] || {})
+          self.block = block
+        end
+        
+        def run
+          self.run_callbacks(self.callbacks[:before])
+          self.entry.instance_eval(&self.block)
+          self.run_callbacks(self.callbacks[:after])
+        end
+        
+        protected
+        
+        def run_callbacks(methods)
+          (methods || []).each do |method|
+            self.entry.send(method)
+          end
+        end
+        
+      end
+
+    end
+  end
+end

data/lib/ad-framework/utilities/validator.rb

@@ -0,0 +1,26 @@
+module AD
+  module Framework
+    module Utilities
+
+      class Validator
+        attr_accessor :entry
+
+        def initialize(entry)
+          self.entry = entry
+        end
+
+        def errors
+          self.entry.schema.mandatory.inject({}) do |errors, attribute_name|
+            attribute_type = self.entry.send("#{attribute_name}_attribute_type")
+            if !attribute_type.is_set?
+              errors[attribute_name.to_s] = "was not set"
+            end
+            errors
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/ad-framework/version.rb

@@ -0,0 +1,5 @@
+module Ad
+  module Framework
+    VERSION = "0.1.0"
+  end
+end

data/test/helper.rb

@@ -0,0 +1,71 @@
+if RUBY_VERSION =~ /^1.9/ && ENV["COVERAGE"]
+  require 'simplecov'
+  SimpleCov.start
+end
+
+require 'assert'
+require 'log4r'
+require 'mocha'
+require 'yaml'
+
+if RUBY_VERSION =~ /^1.9/
+  YAML::ENGINE.yamler= 'syck'
+end
+
+root_path = File.expand_path("../..", __FILE__)
+ldap_config = YAML.load(File.open(File.join(root_path, "test", "support", "ldap.yml")))
+
+FileUtils.mkdir_p(File.join(root_path, "log"))
+TEST_LOGGER = Log4r::Logger.new("AD::Framework")
+TEST_LOGGER.add(Log4r::FileOutputter.new('fileOutputter', {
+  :filename => File.join(root_path, "log", "test.log"),
+  :trunc => false,
+  :formatter => Log4r::PatternFormatter.new(:pattern => "[%l] %d :: %m")
+}))
+
+# add the current gem root path to the LOAD_PATH
+root_path = File.expand_path("../..", __FILE__)
+if !$LOAD_PATH.include?(root_path)
+  $LOAD_PATH.unshift(root_path)
+end
+require 'ad-framework'
+
+require 'test/support/schema/attributes'
+require 'test/support/schema/attribute_types'
+require 'test/support/schema/auxiliary_classes'
+require 'test/support/schema/structural_classes'
+
+require 'test/support/state'
+require 'test/support/factory'
+require 'test/support/seed'
+
+class Assert::Context
+  include Mocha::API
+end
+
+AD::Framework.configure do |config|
+  config.ldap do |ldap|
+    ldap.host = ldap_config[:host]
+    ldap.port = ldap_config[:port]
+    ldap.encryption = ldap_config[:encryption]
+    ldap.auth = ldap_config[:auth]
+  end
+  config.treebase = ldap_config[:base]
+  config.logger = TEST_LOGGER
+  config.search_size_supported = false
+  config.run_commands = true
+  config.ldap_prefix = "adtest-"
+end
+
+Assert.suite.setup do
+  puts "\nSeeding the ldap database..."
+  time = Benchmark.measure{ Seed.up }
+  puts ("Done (%.6f seconds)" % [ time.real ])
+end
+
+Assert.suite.teardown do
+  puts "\nCleaning up the ldap database..."
+  time = Benchmark.measure{ Seed.down }
+  puts ("Done (%.6f seconds)\n\n" % [ time.real ])
+end
+

data/test/integration/defined_array_test.rb

@@ -0,0 +1,49 @@
+require 'assert'
+
+class AD::Array
+
+  class BaseTest < Assert::Context
+    desc "AD::Array"
+    setup do
+      @attribute_type_class = AD::Array
+    end
+    subject{ @attribute_type_class }
+
+    should "return 'array' with it's key" do
+      assert_equal 'array', subject.key
+    end
+    should "be registered with AD::Framework" do
+      registered = AD::Framework.defined_attribute_types[subject.key]
+      assert_equal registered, subject
+    end
+  end
+
+  class InstanceTest < BaseTest
+    desc "instance"
+    setup do
+      @attr_name = "proxy_addresses"
+      @proxy_addresses = [ "a@example.com", "b@example.com" ]
+      mock_fields = { @attr_name => @proxy_addresses }
+      mock_object = mock()
+      mock_object.stubs(:fields).returns(mock_fields)
+      mock_object.stubs(:dn).returns("CN=something")
+      @array = @attribute_type_class.new(mock_object, @attr_name)
+    end
+    subject{ @array }
+
+    should "return the name with a call to value" do
+      assert_equal @proxy_addresses, subject.value
+      assert_equal @proxy_addresses, subject.ldap_value
+    end
+    should "return an empty array when setting value to nil" do
+      subject.value = nil
+      assert_empty subject.value
+      assert_empty subject.ldap_value
+    end
+
+    teardown do
+      @array.value = @proxy_addresses
+    end
+  end
+
+end

data/test/integration/defined_integer_test.rb

@@ -0,0 +1,48 @@
+require 'assert'
+
+class AD::Integer
+
+  class BaseTest < Assert::Context
+    desc "AD::Integer"
+    setup do
+      @attribute_type_class = AD::Integer
+    end
+    subject{ @attribute_type_class }
+
+    should "return 'integer' with it's key" do
+      assert_equal 'integer', subject.key
+    end
+    should "be registered with AD::Framework" do
+      registered = AD::Framework.defined_attribute_types[subject.key]
+      assert_equal registered, subject
+    end
+  end
+
+  class InstanceTest < BaseTest
+    desc "instance"
+    setup do
+      @attr_name = "system_flags"
+      @system_flags = 123456789
+      mock_fields = { @attr_name => [ @system_flags ] }
+      mock_object = mock()
+      mock_object.stubs(:fields).returns(mock_fields)
+      @integer = @attribute_type_class.new(mock_object, @attr_name)
+    end
+    subject{ @integer }
+
+    should "return the name with a call to value" do
+      assert_equal @system_flags, subject.value
+      assert_equal @system_flags, subject.ldap_value
+    end
+    should "return nil when setting value to nil" do
+      subject.value = nil
+      assert_nil subject.value
+      assert_nil subject.ldap_value
+    end
+
+    teardown do
+      @integer.value = @system_flags
+    end
+  end
+
+end

data/test/integration/defined_string_test.rb

@@ -0,0 +1,48 @@
+require 'assert'
+
+class AD::String
+
+  class BaseTest < Assert::Context
+    desc "AD::String"
+    setup do
+      @attribute_type_class = AD::String
+    end
+    subject{ @attribute_type_class }
+
+    should "return 'string' with it's key" do
+      assert_equal 'string', subject.key
+    end
+    should "be registered with AD::Framework" do
+      registered = AD::Framework.defined_attribute_types[subject.key]
+      assert_equal registered, subject
+    end
+  end
+
+  class InstanceTest < BaseTest
+    desc "instance"
+    setup do
+      @attr_name = "name"
+      @name = "someone"
+      mock_fields = { @attr_name => [ @name ] }
+      mock_object = mock()
+      mock_object.stubs(:fields).returns(mock_fields)
+      @string = @attribute_type_class.new(mock_object, @attr_name)
+    end
+    subject{ @string }
+
+    should "return the name with a call to value" do
+      assert_equal @name, subject.value
+      assert_equal @name, subject.ldap_value
+    end
+    should "return nil when setting value to nil" do
+      subject.value = nil
+      assert_nil subject.value
+      assert_nil subject.ldap_value
+    end
+
+    teardown do
+      @string.value = @name
+    end
+  end
+
+end

data/test/integration/defined_top_test.rb

@@ -0,0 +1,101 @@
+require 'assert'
+
+class AD::Top
+
+  class BaseTest < Assert::Context
+    desc "top"
+    setup do
+      @structural_class = AD::Top
+    end
+    subject{ @structural_class }
+
+    should "be registered with AD::Framework's config" do
+      assert_equal AD::Framework.config.object_classes[subject.ldap_name], subject
+    end
+  end
+  
+  class SchemaTest < BaseTest
+    desc "schema"
+    setup do
+      @ldap_name = "top"
+      @rdn = :name
+      @attrs = [ :name, :system_flags, :display_name, :description ]
+      @schema = @structural_class.schema
+    end
+    subject{ @schema }
+
+    should "store the ldap name defined on the class" do
+      expected = [ AD::Framework.config.ldap_prefix, @ldap_name ].compact.join
+      assert_equal expected, subject.ldap_name
+    end
+    should "store the rdn defined on the class" do
+      assert_equal @rdn, subject.rdn
+    end
+    should "contain all the attributes defined on the class" do
+      @attrs.each do |attr|
+        assert_includes attr, subject.attributes
+      end
+    end
+  end
+
+  class InstanceTest < BaseTest
+    desc "instance"
+    setup do
+      @name = "joe test"
+      @system_flags = 123456789
+      @display_name = "Joe Test"
+      @description = "A relevant description."
+      @dn = [ "CN=#{@name}", @structural_class.treebase ].join(", ")
+      @top = @structural_class.new({ :name => @name, :system_flags => @system_flags,
+        :display_name => @display_name, :description => @description
+      })
+    end
+    subject{ @top }
+
+    should have_readers :dn
+    should have_accessors :name, :system_flags, :display_name, :description
+
+    should "return it's rdn with its treebase in it's dn" do
+      assert_equal @dn, subject.dn
+    end
+    should "return the name set on it" do
+      assert_equal @name, subject.name
+      assert_equal [ @name ], subject.fields[:cn]
+    end
+    should "return the system_flags set on it" do
+      assert_equal @system_flags, subject.system_flags
+      assert_equal [ @system_flags.to_s ], subject.fields[:systemflags]
+    end
+    should "return the display_name set on it" do
+      assert_equal @display_name, subject.display_name
+      assert_equal [ @display_name ], subject.fields[:displayname]
+    end
+    should "return the description set on it" do
+      assert_equal @description, subject.description
+      assert_equal [ @description ], subject.fields[:description]
+    end
+  end
+  
+  class SearchingTest < BaseTest
+    desc "searching for an entry"
+    setup do
+      @current = @structural_class.schema.treebase
+      @structural_class.schema.treebase = nil
+      @top = @structural_class.find("CN=joe test, #{AD::User.schema.treebase}")
+    end
+    subject{ @top }
+
+    should "find the user" do
+      assert subject
+      assert_kind_of AD::User, subject
+    end
+    should "set his name correctly" do
+      assert_equal "joe test", subject.name
+    end
+    
+    teardown do
+      @structural_class.schema.treebase = @current
+    end
+  end
+
+end

data/test/integration/defined_user_test.rb

@@ -0,0 +1,140 @@
+require 'assert'
+
+class AD::User
+
+  class BaseTest < Assert::Context
+    desc "user"
+    setup do
+      @structural_class = AD::User
+    end
+    subject{ @structural_class }
+
+    should "be registered with AD::Framework's config" do
+      assert_equal AD::Framework.config.object_classes[subject.ldap_name], subject
+    end
+  end
+
+  class SchemaTest < BaseTest
+    desc "schema"
+    setup do
+      @ldap_name = "user"
+      @rdn = :name
+      @treebase = [ "CN=Users, CN=AD Framework Tests", AD::Framework.config.treebase ].join(", ")
+      @attrs = [ :name, :system_flags, :display_name, :description, :proxy_addresses,
+        :sam_account_name ]
+      @schema = @structural_class.schema
+    end
+    subject{ @schema }
+
+    should "store the ldap name defined on the class" do
+      expected = [ AD::Framework.config.ldap_prefix, @ldap_name ].compact.join
+      assert_equal expected, subject.ldap_name
+    end
+    should "store the rdn defined on the class" do
+      assert_equal @rdn, subject.rdn
+    end
+    should "store the treebase defined on the class" do
+      assert_equal @treebase, subject.treebase
+    end
+    should "contain all the attributes defined on the class" do
+      @attrs.each do |attr|
+        assert_includes attr, subject.attributes
+      end
+    end
+  end
+
+  class InstanceTest < BaseTest
+    desc "instance"
+    setup do
+      @proxy_addresses = [ "developer@example.com", "dev@example.com" ]
+      @sam_account_name = "dev"
+      @user = @structural_class.new({
+        :proxy_addresses => @proxy_addresses,
+        :sam_account_name => @sam_account_name
+      })
+    end
+    subject{ @user }
+
+    should have_readers :dn
+    should have_accessors :name, :system_flags, :display_name, :description
+    should have_accessors :proxy_addresses, :sam_account_name
+
+    should "return the proxy addresses set on it" do
+      assert_equal @proxy_addresses, subject.proxy_addresses
+      assert_equal @proxy_addresses, subject.fields[:proxyaddresses]
+    end
+    should "return the sam account name set on it" do
+      assert_equal @sam_account_name, subject.sam_account_name
+      assert_equal [ @sam_account_name ], subject.fields[:samaccountname]
+    end
+  end
+
+  class SearchingTest < BaseTest
+    desc "searching for an entry"
+    subject{ @structural_class }
+
+    should "find the user from his dn with a call to #find" do
+      name = "joe test"
+      @user = subject.find("CN=#{name}, #{subject.schema.treebase}")
+
+      assert @user
+      assert_equal name, @user.name
+    end
+    should "find the user from his rdn with a call to #find" do
+      name = "joe test"
+      @user = subject.find(name)
+
+      assert @user
+      assert_equal name, @user.name
+    end
+    should "find the first matching user with a call to #first" do
+      name = "joe test"
+      @user = subject.first({ :name => name })
+
+      assert @user
+      assert_equal name, @user.name
+    end
+    should "find the first matching user using a ldap attribute with a call to #first" do
+      user_name = "jtest"
+      @user = subject.first({ :sam_account_name => user_name })
+
+      assert @user
+      assert_equal user_name, @user.sam_account_name
+    end
+    should "return a collection of matching users with a call to #all" do
+      name = "*test*"
+      @users = subject.all({ :where => { :name => name }, :size => 5 })
+
+      assert_not_empty @users
+      @users.each do |user|
+        assert_match user.name, /test/
+      end
+    end
+    should "return a collection of matching users with complicated filters with a call to #all" do
+      system_flags = 500
+      objectclass = "adtest-securityPrincipal"
+      @users = subject.all({
+        :where => { :systemflags__ge => system_flags, :objectclass__eq => objectclass },
+        :limit => 5
+      })
+
+      assert_not_empty @users
+      @users.each do |user|
+        assert user.fields[:systemflags].first.to_i >= system_flags
+      end
+    end
+    should "reload the user's fields and attributes with a call to #reload" do
+      name = "joe test"
+      new_name = "yo test"
+      @user = subject.find(name)
+
+      assert @user
+      @user.name = new_name
+      assert_equal new_name, @user.name
+      @user.reload
+      assert_not_equal new_name, @user.name
+      assert_equal name, @user.name
+    end
+  end
+
+end