ad-framework 0.1.0

data/test/irb.rb

@@ -0,0 +1,2 @@
+require 'ad-framework'
+require 'test/helper'

data/test/support/factory.rb

@@ -0,0 +1,67 @@
+module Factory
+  extend Mocha::API
+
+  class << self
+
+    def attribute_definition(args = {})
+      args[:name] ||= "test_attr"
+      args[:ldap_name] ||= "testattr"
+      args[:type] ||= "test_string"
+      AD::Framework::Config::AttributeDefinition.new(args)
+    end
+
+    def mock_attribute(methods = {})
+      attribute = mock()
+      methods[:name] ||= "test_attr"
+      methods[:ldap_name] ||= "testattr"
+      methods[:attribute_type] ||= self.mock_attribute_type
+      methods.each do |method, value|
+        attribute.stubs(method).returns(value)
+      end
+      attribute
+    end
+
+    def mock_attribute_type(methods = {})
+      attribute_type = mock()
+      methods[:key] ||= "test_string"
+      methods.each do |method, value|
+        attribute_type.stubs(method).returns(value)
+      end
+      attribute_type
+    end
+
+    def structural_class(methods = {}, &block)
+      block ||= ::Proc.new do
+        ldap_name "testObjectClass"
+      end
+      structural_class = Class.new(AD::Framework::StructuralClass, &block)
+      structural_class
+    end
+
+    def mock_structural_class_instance(methods = {})
+      structural_class = mock()
+      methods[:dn] ||= "CN=test object, DC=example, DC=com"
+      methods[:fields] ||= {}
+      methods.each do |method, value|
+        structural_class.stubs(method).returns(value)
+      end
+      structural_class
+    end
+
+    def attribute_type(methods = {}, &block)
+      block ||= ::Proc.new{}
+      attribute_type = Class.new(AD::Framework::AttributeType, &block)
+      attribute_type
+    end
+
+    def auxiliary_class(&block)
+      block ||= ::Proc.new{}
+      auxiliary_class = Module.new do
+        include AD::Framework::AuxiliaryClass
+      end
+      auxiliary_class.class_eval(&block)
+      auxiliary_class
+    end
+
+  end
+end

data/test/support/ldap.yml

@@ -0,0 +1,6 @@
+:host: "127.0.0.1"
+:port: 389
+:base: "DC=localhost"
+:auth:
+  :username: "CN=root,DC=localhost"
+  :password: "secret"

data/test/support/schema/attribute_types.rb

@@ -0,0 +1,67 @@
+module AD
+  class String < AD::Framework::AttributeType
+
+    key "string"
+
+    def value=(new_value)
+      super(new_value ? new_value.to_s : new_value)
+    end
+
+  end
+end
+AD::Framework.register_attribute_type(AD::String)
+
+module AD
+  class Integer < AD::Framework::AttributeType
+
+    key "integer"
+
+    def value=(new_value)
+      super(new_value ? new_value.to_i : new_value)
+    end
+
+  end
+end
+AD::Framework.register_attribute_type(AD::Integer)
+
+module AD
+  class Array < AD::Framework::AttributeType
+    key "array"
+    
+    attr_accessor :item_class
+
+    def initialize(object, attr_ldap_name)
+      self.item_class = AD::String
+      super
+    end
+
+    def value_from_field
+      (self.object.fields[self.attr_ldap_name] || [])
+    end
+
+    def value
+      self.get_items_values(@value)
+    end
+
+    def value=(new_value)
+      values = [*new_value].compact.collect do |value|
+        self.item_class.new(self.object, attr_ldap_name, value)
+      end
+      super(values)
+    end
+
+    def ldap_value=(new_value)
+      super(self.get_items_values(new_value))
+    end
+    
+    protected
+    
+    def get_items_values(items)
+      [*items].compact.collect(&:value)
+    end
+
+  end
+end
+
+AD::Framework.register_attribute_type(AD::Array)
+

data/test/support/schema/attributes.rb

@@ -0,0 +1,10 @@
+AD::Framework.register_attributes([
+  { :name => "name",              :ldap_name => "cn",                   :type => "string" },
+  { :name => "system_flags",      :ldap_name => "systemflags",          :type => "integer" },
+  { :name => "display_name",      :ldap_name => "displayname",          :type => "string" },
+  { :name => "description",       :ldap_name => "description",          :type => "string" },
+  { :name => "proxy_addresses",   :ldap_name => "proxyaddresses",       :type => "array" },
+  { :name => "unix_member_of",    :ldap_name => "mssfu30posixmemberof", :type => "array" },
+  { :name => "sam_account_name",  :ldap_name => "samaccountname",       :type => "string" },
+  { :name => "object_sid",        :ldap_name => "objectsid",            :type => "integer" }
+])

data/test/support/schema/auxiliary_classes.rb

@@ -0,0 +1,12 @@
+module AD
+  module SecurityPrincipal
+    include AD::Framework::AuxiliaryClass
+
+    ldap_name "securityPrincipal"
+    attributes :sam_account_name, :object_sid
+
+    must_set :sam_account_name, :object_sid
+
+  end
+end
+AD::Framework.register_auxiliary_class(AD::SecurityPrincipal)

data/test/support/schema/structural_classes.rb

@@ -0,0 +1,46 @@
+module AD
+  class Top < AD::Framework::StructuralClass
+
+    ldap_name "top"
+    rdn :name
+    attributes :name, :system_flags, :display_name, :description
+
+    must_set :name
+
+  end
+end
+AD::Framework.register_structural_class(AD::Top)
+
+module AD
+  class Container < AD::Top
+    ldap_name "container"
+  end
+end
+AD::Framework.register_structural_class(AD::Container)
+
+module AD
+  class Person < AD::Top
+    ldap_name "person"
+  end
+end
+AD::Framework.register_structural_class(AD::Person)
+
+module AD
+  class OrganizationalPerson < AD::Person
+    ldap_name "organizationalPerson"
+  end
+end
+AD::Framework.register_structural_class(AD::OrganizationalPerson)
+
+module AD
+  class User < AD::OrganizationalPerson
+    include AD::SecurityPrincipal
+
+    ldap_name "user"
+    treebase "CN=Users, CN=AD Framework Tests"
+    rdn :name
+    attributes :proxy_addresses
+
+  end
+end
+AD::Framework.register_structural_class(AD::User)

data/test/support/seed.rb

@@ -0,0 +1,28 @@
+module Seed
+  class << self
+
+    def up
+      self.down
+      container = AD::Container.create({ :name => "AD Framework Tests" })
+      users_container = AD::Container.create({
+        :name => "Users", :treebase => "CN=AD Framework Tests"
+      })
+      user = AD::User.create({
+        :name => "joe test", :system_flags => 1000, :sam_account_name => "jtest", 
+        :object_sid => 1
+      })
+    end
+
+    def down
+      container = AD::Container.first({ :name => "AD Framework Tests" })
+      dn = "CN=Users, CN=AD Framework Tests, #{AD::Container.treebase}"
+      users_container = AD::Container.first({ :dn => dn }) if container
+      user = AD::User.first({ :name => "joe test" }) if users_container
+
+      user.destroy if user
+      users_container.destroy if users_container
+      container.destroy if container
+    end
+
+  end
+end

data/test/support/state.rb

@@ -0,0 +1,29 @@
+module State
+  class << self
+    attr_accessor :current_framework_config, :current_ldap_config
+
+    def preserve
+      self.current_framework_config = AD::Framework.config.dup
+      self.current_ldap_config = AD::LDAP.config.dup
+      self.nullify
+      load("test/support/schema/attribute_types.rb")
+      load("test/support/schema/attributes.rb")
+    end
+
+    def restore
+      self.nullify
+      AD::LDAP.instance_variable_set("@config", self.current_ldap_config)
+      AD::Framework.instance_variable_set("@config", self.current_framework_config)
+    end
+
+    protected
+
+    def nullify
+      AD::Framework.instance_variable_set("@config", nil)
+      AD::LDAP.instance_variable_set("@logger", nil)
+      AD::LDAP.instance_variable_set("@adapter", nil)
+      AD::LDAP.instance_variable_set("@config", nil)
+    end
+
+  end
+end

data/test/unit/ad-framework/attribute_test.rb

@@ -0,0 +1,84 @@
+require 'assert'
+
+class AD::Framework::Attribute
+
+  class BaseTest < Assert::Context
+    desc "AD::Framework::Attribute"
+    setup do
+      @class = AD::Framework::Attribute
+      @definition = Factory.attribute_definition
+      AD::Framework.config.attributes[@definition.name] = @definition
+      @attribute_type = Factory.mock_attribute_type
+      AD::Framework.config.attribute_types[@attribute_type.key] = @attribute_type
+      @attribute = @class.new(@definition.name.to_s)
+    end
+    subject{ @attribute }
+
+    should have_accessors :name, :ldap_name, :attribute_type
+    should have_instance_methods :define_reader, :define_writer
+
+    should "set the name correctly" do
+      assert_equal @definition.name, subject.name
+    end
+    should "set the ldap name correctly" do
+      assert_equal @definition.ldap_name, subject.ldap_name
+    end
+    should "set the attribute type correctly" do
+      assert_equal @attribute_type, subject.attribute_type
+    end
+
+    teardown do
+      AD::Framework.config.attribute_types.delete(@attribute_type.key.to_sym)
+      AD::Framework.config.attributes.delete(@definition.name.to_sym)
+    end
+  end
+
+  class DefineReaderTest < BaseTest
+    desc "define_reader method"
+    setup do
+      @structural_class = Factory.structural_class
+      @attribute.attribute_type.expects(:define_reader).with(@attribute, @structural_class)
+    end
+
+    should "call define_reader on it's attribute type" do
+      assert_nothing_raised{ subject.define_reader(@structural_class) }
+    end
+  end
+
+  class DefineWriterTest < BaseTest
+    desc "define_writer method"
+    setup do
+      @structural_class = Factory.structural_class
+      @attribute.attribute_type.expects(:define_writer).with(@attribute, @structural_class)
+    end
+
+    should "call define_writer on it's attribute type with a call to #define_writer" do
+      assert_nothing_raised{ subject.define_writer(@structural_class) }
+    end
+  end
+
+  class CreatedWithoutADefinitionTest < BaseTest
+    desc "created without a definition"
+
+    should "raise an exception" do
+      assert_raises(AD::Framework::AttributeNotDefined){ @class.new("not_defined") }
+    end
+  end
+
+  class CreatedWithABadAttributeTypeTest < BaseTest
+    desc "created with a bad attribute type test"
+    setup do
+      @definition = Factory.attribute_definition({ :type => "not_defined" })
+      AD::Framework.config.attributes[@definition.name] = @definition
+    end
+
+    should "raise an exception" do
+      assert_raises(AD::Framework::AttributeTypeNotDefined){ @class.new(@definition.name) }
+    end
+
+    teardown do
+      AD::Framework.config.attributes.delete(@definition.name.to_sym)
+    end
+  end
+
+end

data/test/unit/ad-framework/attribute_type/class_methods_test.rb

@@ -0,0 +1,146 @@
+require 'assert'
+
+class AD::Framework::AttributeType
+
+  class ClassMethodsTest < Assert::Context
+    desc "AD::Framework::AttributeType class"
+    setup do
+      @class = AD::Framework::AttributeType
+      @key = "some key"
+      @class.key(@key)
+    end
+    subject{ @class }
+
+    should "set the class's key" do
+      assert_equal @key, subject.key
+    end
+  end
+
+  class DefineMethodsTest < ClassMethodsTest
+    setup do
+      @attribute = Factory.mock_attribute({ :attribute_type => @class })
+      @fields = { @attribute.ldap_name => [ "some value" ] }
+      @structural_class = Factory.structural_class
+      @instance = @structural_class.new({ :fields => @fields })
+
+      @defined_attr_type_method = "#{@attribute.name}_attribute_type"
+      @defined_reader_method = @attribute.name
+      @defined_writer_method = "#{@attribute.name}="
+    end
+    subject{ @instance }
+  end
+
+  class DefineAttributeTypeTest < DefineMethodsTest
+    desc "define_attribute_type method"
+    setup do
+      @class.define_attribute_type(@attribute, @instance.class)
+      @attribute_type = subject.send(@defined_attr_type_method)
+    end
+
+    should "respond to the defined method" do
+      assert_respond_to @defined_attr_type_method, subject
+    end
+    should "return an instance of the attribute type with a call to the defined method" do
+      assert_instance_of @class, @attribute_type
+      assert_equal subject, @attribute_type.object
+      assert_equal @attribute.ldap_name, @attribute_type.attr_ldap_name
+    end
+  end
+
+  class DefineReaderTest < DefineMethodsTest
+    desc "define_reader method"
+    setup do
+      @class.define_reader(@attribute, @instance.class)
+      @reader = subject.send(@defined_reader_method)
+      @attribute_type = subject.send(@defined_attr_type_method)
+    end
+
+    should "respond to the defined method" do
+      assert_respond_to @defined_reader_method, subject
+    end
+    should "return the attribute type value with a call to the defined method" do
+      assert_equal @attribute_type.value, @reader
+    end
+  end
+
+  class DefineWriterTest < DefineMethodsTest
+    desc "define_writer method"
+    setup do
+      @class.define_writer(@attribute, @instance.class)
+      @new_value = "a new value"
+      subject.send(@defined_writer_method, @new_value)
+      @attribute_type = subject.send(@defined_attr_type_method)
+    end
+
+    should "respond to the defined method" do
+      assert_respond_to @defined_writer_method, subject
+    end
+    should "set the attribute type value with a call to the defined method" do
+      assert_equal @new_value, @attribute_type.value
+    end
+  end
+
+  class DefineMethodsAsProcTest < DefineMethodsTest
+    setup do
+      @class = Factory.attribute_type do
+        def self.attribute_type_method(a, n)
+          Proc.new{ define_method(n){ true } }
+        end
+        def self.reader_method(a)
+          Proc.new{ define_method(a.name){ true } }
+        end
+        def self.writer_method(a)
+          Proc.new{ define_method("#{a.name}="){|value| value } }
+        end
+      end
+    end
+  end
+
+  class AttributeTypeMethodAsProcTest < DefineMethodsAsProcTest
+    desc "with an attribute type method as a proc"
+    setup do
+      @class.define_attribute_type(@attribute, @instance.class)
+      @attribute_type = subject.send(@defined_attr_type_method)
+    end
+
+    should "respond to the defined method" do
+      assert_respond_to @defined_attr_type_method, subject
+    end
+    should "return true with a call to the defined method" do
+      assert_equal true, @attribute_type
+    end
+  end
+
+  class ReaderMethodAsProcTest < DefineMethodsAsProcTest
+    desc "with a reader method as a proc"
+    setup do
+      @class.define_reader(@attribute, @instance.class)
+      @reader = subject.send(@defined_reader_method)
+    end
+    subject{ @instance }
+
+    should "respond to the defined method" do
+      assert_respond_to @defined_reader_method, subject
+    end
+    should "return true with a call to the defined method" do
+      assert_equal true, @reader
+    end
+  end
+
+  class WriterMethodAsProcTest < DefineMethodsAsProcTest
+    desc "with a writer method as a proc"
+    setup do
+      @class.define_writer(@attribute, @instance.class)
+      @writer = subject.send(@defined_writer_method, true)
+    end
+    subject{ @instance }
+
+    should "respond to the defined method" do
+      assert_respond_to @defined_writer_method, subject
+    end
+    should "return true with a call to the defined method" do
+      assert_equal true, @writer
+    end
+  end
+
+end