ad-framework 0.1.0

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

@@ -0,0 +1,114 @@
+require 'assert'
+
+class AD::Framework::AttributeType
+
+  class BaseTest < Assert::Context
+    desc "AD::Framework::AttributeType"
+    setup do
+      @class = AD::Framework::AttributeType
+      @ldap_name = "some"
+      @fields = { @ldap_name => [ "value" ] }
+      @object = Factory.mock_structural_class_instance({ :fields => @fields })
+      @attribute_type = @class.new(@object, @ldap_name)
+    end
+    subject{ @attribute_type }
+
+    should have_accessors :object, :attr_ldap_name, :value, :ldap_value
+    should have_instance_methods :value_from_field, :is_set?, :inspect
+    should have_class_methods :key, :define_attribute_type, :attribute_type_method
+    should have_class_methods :define_reader, :reader_method, :define_writer, :writer_method
+
+    should "have set the object correctly" do
+      assert_equal @object, subject.object
+    end
+    should "have set the attr_ldap_name correctly" do
+      assert_equal @ldap_name, subject.attr_ldap_name
+    end
+    should "have set the value correctly" do
+      assert_equal subject.value_from_field, subject.value
+    end
+    should "return the value from the object's fields with #value_from_field" do
+      assert_equal @fields[@ldap_name].first, subject.value_from_field
+    end
+
+    should "return a custom inspect" do
+      expected = "#<#{subject.class} attr_ldap_name: #{subject.attr_ldap_name.inspect}, "
+      expected += "ldap_value: #{subject.ldap_value.inspect}, "
+      expected += "object: #{@object.class} - #{@object.dn.inspect}, "
+      expected += "value: #{subject.value.inspect}>"
+      assert_equal expected, subject.inspect
+    end
+  end
+
+  class CreatedWithAValueTest < BaseTest
+    desc "created with a value"
+    setup do
+      @value = "amazing"
+      @attribute_type = @class.new(@object, @ldap_name, @value)
+    end
+
+    should "set the value from that arg" do
+      assert_equal @value, subject.value
+    end
+  end
+
+  class SetValueTest < BaseTest
+    desc "setting the value"
+    setup do
+      @value = "amazing"
+      @attribute_type.value = "amazing"
+    end
+
+    should "set the value and ldap_value" do
+      assert_equal @value, subject.value
+      assert_equal @value, subject.ldap_value
+    end
+  end
+
+  class SetLdapValueTest < BaseTest
+    desc "setting the ldap value"
+    setup do
+      @ldap_value = "amazing"
+      @attribute_type.ldap_value = @ldap_value
+    end
+
+    should "set the ldap value and the object's fields" do
+      assert_equal @ldap_value, subject.ldap_value
+      assert_equal [ @ldap_value ], subject.object.fields[subject.attr_ldap_name]
+    end
+  end
+
+  class SetLdapValueWithArrayTest < BaseTest
+    desc "setting the ldap value with an array"
+    setup do
+      @ldap_value = [ 1, "2" ]
+      @attribute_type.ldap_value = @ldap_value
+    end
+
+    should "convert all objects to strings for object's fields with a call to #ldap_value=" do
+      assert_equal @ldap_value, subject.ldap_value
+      expected = @ldap_value.collect(&:to_s)
+      assert_equal expected, subject.object.fields[subject.attr_ldap_name]
+    end
+  end
+
+  class IsSetTest < SetValueTest
+    desc "is_set with a non-nil value"
+
+    should "return true" do
+      assert subject.is_set?
+    end
+  end
+
+  class IsNotSetTest < BaseTest
+    desc "is_set with a nil value"
+    setup do
+      @attribute_type.value = nil
+    end
+
+    should "return false" do
+      assert_not subject.is_set?
+    end
+  end
+
+end

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

@@ -0,0 +1,39 @@
+require 'assert'
+
+module AD::Framework::AuxiliaryClass
+
+  class BaseTest < Assert::Context
+    desc "AD::Framework::AuxiliaryClass"
+    setup do
+      @module = AD::Framework::AuxiliaryClass
+    end
+    subject{ @module }
+
+  end
+
+  class IncludedTest < BaseTest
+    setup_once do
+      RandomAuxiliaryClass = Factory.auxiliary_class do
+        ldap_name "testAuxiliaryClass"
+      end
+    end
+    setup do
+      included_module = @included_module = RandomAuxiliaryClass
+      @class = Factory.structural_class do
+        include included_module
+      end
+    end
+    subject{ @included_module }
+
+    should have_instance_methods :schema, :ldap_name, :treebase, :rdn, :attributes, :read_attributes
+    should have_instance_methods :write_attributes
+
+    should "have defined an included method on the class it was included on" do
+      assert_respond_to :included, subject
+    end
+    should "have added the included module to the class's schema it was included on" do
+      assert_includes subject, @class.schema.auxiliary_classes
+    end
+  end
+
+end

data/test/unit/ad-framework/config/attribute_definition_test.rb

@@ -0,0 +1,26 @@
+require 'assert'
+
+class AD::Framework::Config::AttributeDefinition
+
+  class BaseTest < Assert::Context
+    desc "AD::Framework::Config::AttributeDefinition"
+    setup do
+      @attr = { :name => "something", :ldap_name => "some", :type => "string" }
+      @definition = AD::Framework::Config::AttributeDefinition.new(@attr)
+    end
+    subject{ @definition }
+
+    should have_accessors :name, :ldap_name, :type
+
+    should "have set the name correctly" do
+      assert_equal @attr[:name], subject.name
+    end
+    should "have set the ldap_name correctly" do
+      assert_equal @attr[:ldap_name], subject.ldap_name
+    end
+    should "have set the type correctly" do
+      assert_equal @attr[:type], subject.type
+    end
+  end
+
+end

data/test/unit/ad-framework/config/mapping_test.rb

@@ -0,0 +1,41 @@
+require 'assert'
+
+class AD::Framework::Config::Mapping
+
+  class BaseTest < Assert::Context
+    desc "AD::Framework::Config::Mapping"
+    setup do
+      @mapping = AD::Framework::Config::Mapping.new
+    end
+    subject{ @mapping }
+
+    should have_instance_methods :[], :[]=, :find, :add
+
+    should "be a kind of Hash" do
+      assert_kind_of Hash, subject
+    end
+
+    should "lookup an item with it's sym with a call to #[]" do
+      subject[:third] = true
+      assert_equal true, subject["third"]
+      assert_equal true, subject[:third]
+    end
+    should "lookup an item with it's sym with a call to #find" do
+      subject[:fourth] = false
+      assert_equal false, subject.find("fourth")
+      assert_equal false, subject.find(:fourth)
+    end
+
+    should "add an item to it's collection with a call to #[]=" do
+      subject["first"] = true
+      assert_equal true, subject["first"]
+      assert_equal true, subject[:first]
+    end
+    should "add an item to it's collection with a call to #add" do
+      subject.add(:second, false)
+      assert_equal false, subject["second"]
+      assert_equal false, subject[:second]
+    end
+  end
+
+end

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

@@ -0,0 +1,121 @@
+require 'assert'
+
+class AD::Framework::Config
+
+  class BaseTest < Assert::Context
+    desc "AD::Frameowrk::Config"
+    setup do
+      State.preserve
+      @config = AD::Framework::Config.new
+      @logger = mock()
+      @config.adapter.config.logger = @logger
+    end
+    subject{ @config }
+
+    should have_accessors :attributes, :attribute_types, :object_classes, :ldap_prefix
+    should have_accessors :logger, :search_size_supported, :mappings, :run_commands, :treebase
+    should have_instance_methods :ldap, :adapter, :add_attribute, :add_attribute_type
+    should have_instance_methods :add_object_class
+
+    [ :mappings, :attributes, :attribute_types, :object_classes ].each do |attr|
+      should "return a mapping with a call to ##{attr}" do
+        assert_instance_of AD::Framework::Config::Mapping, subject.send(attr)
+      end
+    end
+    should "include a basic mapping for dn" do
+      assert_equal subject.mappings[:dn], "distinguishedname"
+    end
+    should "return AD::LDAP with a call to #ldap" do
+      assert_equal AD::LDAP, subject.ldap
+    end
+
+    should "return the adapter's logger with a call to #logger" do
+      assert_equal subject.adapter.logger, subject.logger
+    end
+    should "set the adapter's logger with a call to #logger=" do
+      assert_equal @logger, subject.adapter.config.logger
+    end
+
+    [ :search_size_supported, :mappings, :run_commands, :treebase ].each do |attr|
+      should "return the adapter's config value for #{attr.inspect} with a call to ##{attr}" do
+        subject.adapter.config.send("#{attr}=", mock())
+        assert_equal subject.adapter.config.send(attr), subject.send(attr)
+      end
+      should "set the adapter's config value for #{attr.inspect} with a call to ##{attr}=" do
+        value = mock()
+        subject.send("#{attr}=", value)
+        assert_equal value, subject.adapter.config.send(attr)
+      end
+    end
+
+    teardown do
+      State.restore
+    end
+  end
+
+  class LdapTest < BaseTest
+    desc "ldap method"
+    setup do
+      @ldap_block = ::Proc.new{ true }
+      AD::LDAP.expects(:configure).with(&@ldap_block)
+    end
+
+    should "pass a block to AD::LDAP configure" do
+      assert_nothing_raised{ subject.ldap(&@ldap_block) }
+    end
+  end
+
+  class LdapPrefixTest < BaseTest
+    desc "setting the ldap prefix"
+    setup do
+      @prefix = "something-"
+      @structural_class = Factory.structural_class
+      @config.add_object_class(@structural_class)
+      @config.ldap_prefix = @prefix
+    end
+
+    should "re-register any object classes" do
+
+      stored = subject.object_classes["#{@prefix}#{@structural_class.ldap_name}"]
+      assert_equal @structural_class, stored
+    end
+  end
+
+  class AddAttributeTest < BaseTest
+    desc "add_attribute method"
+    setup do
+      @definition = { :name => "test_attr", :ldap_name => "testattr", :type => "string" }
+      @config.add_attribute(@definition)
+    end
+
+    should "add an attribute definition to the attributes" do
+      assert_equal @definition[:ldap_name], subject.mappings[@definition[:name]]
+      assert @definition, subject.attributes[@definition[:name]]
+    end
+  end
+
+  class AddAttributeTypeTest < BaseTest
+    desc "add_attribute_type method"
+    setup do
+      @attribute_type = Factory.mock_attribute_type
+      @config.add_attribute_type(@attribute_type)
+    end
+
+    should "add an attribute type to the attribute_types" do
+      assert_equal @attribute_type, subject.attribute_types[@attribute_type.key]
+    end
+  end
+
+  class AddObjectClass < BaseTest
+    desc "add_object_class method"
+    setup do
+      @object_class = Factory.structural_class
+      @config.add_object_class(@object_class)
+    end
+
+    should "add an object class to the object_classes" do
+      assert_equal @object_class, subject.object_classes[@object_class.ldap_name]
+    end
+  end
+
+end

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

@@ -0,0 +1,44 @@
+require 'assert'
+
+class AD::Framework::Fields
+
+  class BaseTest < Assert::Context
+    desc "AD::Framework::Fields"
+    setup do
+      @fields = AD::Framework::Fields.new({
+        :a => "a", :b => "b", :c => "c", :d => "d"
+      })
+    end
+    subject{ @fields }
+
+    should "be a kind of Hash" do
+      assert_kind_of Hash, subject
+    end
+    should "return an instance of a hash with a call to #to_hash" do
+      assert_instance_of Hash, subject.to_hash
+      assert_not_instance_of Hash, subject
+      assert_equal subject, subject.to_hash
+    end
+    should "lookup an item with the key as a string with a call to #[]" do
+      subject[:a] = true
+      assert_equal true, subject["a"]
+      assert_equal true, subject[:a]
+    end
+    should "add an item to it's collection with a call to #[]=" do
+      subject["b"] = true
+      assert_equal true, subject["b"]
+      assert_equal true, subject[:b]
+    end
+
+    should "have a custom inspect" do
+      key_len = subject.keys.collect(&:size).max + 1
+      expected = subject.collect do |(k, v)|
+        label = "#{k}:".rjust(key_len, ' ')
+        [ label, v.inspect ].join("  ")
+      end.join("\n")
+      expected = "\n#{expected}"
+      assert_equal expected, subject.inspect
+    end
+  end
+
+end

data/test/unit/ad-framework/patterns/callbacks_test.rb

@@ -0,0 +1,90 @@
+require 'assert'
+
+module AD::Framework::Patterns::Callbacks
+
+  class BaseTest < Assert::Context
+    desc "callbacks pattern"
+    setup do
+      @structural_class = Factory.structural_class do
+        ldap_name "callbacksTestObject"
+        attributes :name, :system_flags
+        attr_accessor :has_saved
+
+        before_save :set_has_saved_before
+        after_save :set_has_saved_after
+        before_destroy :set_has_saved_before
+        after_destroy :set_has_saved_after
+        
+        def initialize(*args)
+          super
+          self.has_saved = nil
+        end
+
+        protected
+
+        def set_has_saved_before
+          self.has_saved = false
+          self.system_flags = 1
+        end
+        def set_has_saved_after
+          self.has_saved = true
+        end
+      end
+      @instance = @structural_class.new({ :name => "test" })
+      @mock_connection = mock()
+      @instance.stubs(:connection).returns(@mock_connection)
+    end
+    subject{ @instance }
+
+    should have_instance_methods :create, :update, :destroy
+
+  end
+
+  class CreateTest < BaseTest
+    desc "create method"
+    setup do
+      @instance.fields[:distinguishedname] = @instance.dn
+      @instance.fields[:objectclass] = @instance.schema.object_classes.collect(&:ldap_name).compact
+      @mock_connection.expects(:add).with({
+        :dn => @instance.dn,
+        :attributes => @instance.fields.merge({ 'systemflags' => [ "1" ] })
+      })
+      @instance.expects(:reload)
+    end
+
+    should "run the callbacks" do
+      assert_nothing_raised{ subject.create }
+      assert subject.has_saved
+    end
+  end
+
+  class UpdateTest < BaseTest
+    desc "update method"
+    setup do
+      @mock_connection.expects(:open).yields(@mock_connection)
+      @instance.fields.changes.each do |name, value|
+        @mock_connection.expects(:replace_attribute).with(@instance.dn, name, value)
+      end
+      @mock_connection.expects(:replace_attribute).with(@instance.dn, "systemflags", [ "1" ])
+      @instance.expects(:reload)
+    end
+
+    should "run the callbacks" do
+      assert_nothing_raised{ subject.update }
+      assert subject.has_saved
+    end
+  end
+
+  class DestroyTest < BaseTest
+    desc "destroy method"
+    setup do
+      @mock_connection.expects(:delete).with(@instance.dn)
+    end
+
+    should "run the callbacks" do
+      assert_nothing_raised{ subject.destroy }
+      assert subject.has_saved
+    end
+  end
+
+end