ad-framework 0.1.0

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

@@ -0,0 +1,113 @@
+require 'assert'
+
+module AD::Framework::Patterns::Validations
+
+  class BaseTest < Assert::Context
+    desc "the validations pattern"
+    setup do
+      @structural_class = Factory.structural_class do
+        ldap_name "validationsTestObject"
+        attributes :name, :system_flags
+        must_set :name, :system_flags
+      end
+      @instance = @structural_class.new({ :name => "test", :system_flags => 1 })
+      @mock_connection = mock()
+      @instance.stubs(:connection).returns(@mock_connection)
+    end
+    subject{ @instance }
+
+    should have_accessors :errors
+    should have_instance_methods :valid?, :create, :update
+
+    should "default errors to a new hash" do
+      assert_equal({}, subject.errors)
+    end
+  end
+
+  class WithErrorsTest < BaseTest
+    desc "with errors"
+    setup do
+      @instance.attributes = { :name => nil, :system_flags => nil }
+      @instance.valid?
+    end
+
+    should "have added errors for the attributes to th errors hash" do
+      assert_not_empty subject.errors
+      subject.schema.attributes.each do |attribute_name|
+        assert_includes attribute_name.to_s, subject.errors.keys
+      end
+    end
+  end
+
+  class WithNoErrorsTest < BaseTest
+    desc "with no errors"
+    setup do
+      @instance.valid?
+    end
+
+    should "have no key/values in the errors hash" do
+      assert_empty subject.errors
+    end
+  end
+
+  class CreateInvalidTest < WithErrorsTest
+    desc "create method"
+    setup do
+      @instance.expects(:valid?)
+    end
+
+    should "check if the entry is valid and return if it added it" do
+      result = nil
+      assert_nothing_raised{ result = subject.create }
+      assert_equal false, result
+    end
+  end
+
+  class UpdateInvalidTest < WithErrorsTest
+    desc "update method"
+    setup do
+      @instance.expects(:valid?)
+    end
+
+    should "check if the entry is valid and return if it updated it" do
+      result = nil
+      assert_nothing_raised{ result = subject.update }
+      assert_equal false, result
+    end
+  end
+
+  class CreateValidTest < WithNoErrorsTest
+    desc "create method"
+    setup do
+      @mock_connection.expects(:add).with({
+        :dn => @instance.dn,
+        :attributes => @instance.fields
+      })
+      @instance.expects(:reload)
+    end
+
+    should "check if the entry is valid and return if it added it" do
+      result = nil
+      assert_nothing_raised{ result = subject.create }
+      assert_equal true, result
+    end
+  end
+
+  class UpdateValidTest < WithNoErrorsTest
+    desc "create 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
+      @instance.expects(:reload)
+    end
+
+    should "check if the entry is valid and return if it added it" do
+      result = nil
+      assert_nothing_raised{ result = subject.update }
+      assert_equal true, result
+    end
+  end
+
+end

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

@@ -0,0 +1,268 @@
+require 'assert'
+
+class AD::Framework::Schema
+
+  class BaseTest < Assert::Context
+    desc "AD::Framework::Schema"
+    setup do
+      State.preserve
+      @structural_class = Factory.structural_class do
+        attributes :name
+        must_set :name
+        before_create :something_amazing
+      end
+      @schema = AD::Framework::Schema.new(@structural_class)
+    end
+    subject{ @schema }
+
+    should have_accessors :ldap_name, :rdn, :attributes, :auxiliary_classes, :klass
+    should have_accessors :structural_classes, :mandatory, :callbacks
+    should have_instance_methods :treebase, :treebase=, :add_attributes, :add_read_attributes
+    should have_instance_methods :add_write_attributes, :add_auxiliary_class
+
+    should "default the rdn to :name" do
+      assert_equal :name, subject.rdn
+    end
+    should "default auxiliary classes to a new array" do
+      assert_instance_of Array, subject.auxiliary_classes
+      assert_empty subject.auxiliary_classes
+    end
+    should "default structural classes to a new array" do
+      assert_instance_of Array, subject.structural_classes
+    end
+    should "default attributes to a new set" do
+      assert_instance_of Set, subject.attributes
+      assert_empty subject.attributes
+    end
+    should "default mandatory to a new set" do
+      assert_instance_of Set, subject.mandatory
+      assert_empty subject.mandatory
+    end
+    should "default callbacks to a new hash" do
+      assert_instance_of Hash, subject.callbacks
+    end
+
+    teardown do
+      State.restore
+    end
+  end
+
+  class LdapNameWithPrefixTest < BaseTest
+    desc "ldap_name method with an ldap prefix set"
+    setup do
+      @ldap_prefix = "something-"
+      @ldap_name = "amazing"
+      AD::Framework.config.ldap_prefix = @ldap_prefix
+      @schema.ldap_name = @ldap_name
+    end
+
+    should "use the ldap_prefix with ldap_name" do
+      assert_equal [ @ldap_prefix, @ldap_name ].join, subject.ldap_name
+    end
+  end
+
+  class LdapNameWithoutPrefixTest < LdapNameWithPrefixTest
+    desc "ldap_name method without ldap prefix set"
+    setup do
+      AD::Framework.config.ldap_prefix = nil
+    end
+
+    should "just be the ldap name" do
+      assert_equal @ldap_name, subject.ldap_name
+    end
+  end
+
+  class ObjectClassesTest < BaseTest
+    desc "object_classes method"
+    setup do
+      @structural_classes = [ "structural" ]
+      @auxiliary_classes = [ "auxiliary" ]
+      @schema.structural_classes = @structural_classes
+      @schema.auxiliary_classes = @auxiliary_classes
+    end
+
+    should "return all its object classes in the correct order" do
+      expected = [
+        subject.structural_classes,
+        subject.klass,
+        subject.auxiliary_classes
+      ].flatten
+      assert_equal expected, subject.object_classes
+    end
+  end
+
+  class WithASuperclassSchemaTest < BaseTest
+    desc "with a superclass schema"
+    setup do
+      @child_class = Class.new(@structural_class)
+      @schema = AD::Framework::Schema.new(@child_class)
+    end
+    subject{ @schema }
+
+    should "default attributes to it's parent schema's attributes" do
+      assert_equal @structural_class.schema.attributes, subject.attributes
+    end
+    should "default structural classes to an array with its parent" do
+      assert_instance_of Array, subject.structural_classes
+      @structural_class.schema.structural_classes.each do |object_class|
+        assert_includes object_class, subject.structural_classes
+      end
+      assert_includes @structural_class, subject.structural_classes
+    end
+    should "default mandatory to it's parents" do
+      assert_equal @structural_class.schema.mandatory, subject.mandatory
+    end
+  end
+
+  class TreebaseTest < BaseTest
+    desc "treebase method"
+    setup do
+      @schema.treebase = nil
+    end
+
+    should "default the treebase to what is configured" do
+      assert_equal AD::Framework.config.treebase, subject.treebase
+    end
+
+    teardown do
+      @schema.treebase = nil
+    end
+  end
+
+  class WithPartialTreebaseTest < TreebaseTest
+    desc "with a partial treebase set"
+    setup do
+      @treebase = "CN=Incomplete"
+      @schema.treebase = @treebase
+    end
+
+    should "contact the treebase with what is configured, if it is not included" do
+      expected = [ @treebase, AD::Framework.config.treebase ].compact.join(", ")
+      assert_equal expected, subject.treebase
+    end
+  end
+
+  class WithFullTreebaseTest < TreebaseTest
+    desc "with a full treebase set"
+    setup do
+      @treebase = [ "CN=Complete", AD::Framework.config.treebase ].compact.join(", ")
+      @schema.treebase = @treebase
+    end
+
+    should "return the full treebase" do
+      assert_equal @treebase, subject.treebase
+    end
+  end
+
+  class AttributesMethodTest < BaseTest
+    desc "adding attribute methods"
+    setup do
+      @schema.attributes.clear
+    end
+
+    teardown do
+      @schema.attributes.clear
+    end
+  end
+
+  class AddAttributesTest < AttributesMethodTest
+    desc "with the add_attributes method"
+    setup do
+      @attribute_names = [ :name, :display_name, :system_flags ]
+      @schema.expects(:add_read_attributes).with(@attribute_names)
+      @schema.expects(:add_write_attributes).with(@attribute_names)
+    end
+
+    should "call add read and write attributes" do
+      assert_nothing_raised{ subject.add_attributes(@attribute_names) }
+    end
+  end
+
+  class AddReadAttributesTest < AttributesMethodTest
+    desc "with the add_read_attributes method"
+    setup do
+      @attribute_names = [ :display_name ]
+      @schema.add_read_attributes(@attribute_names)
+      @instance = @structural_class.new
+    end
+
+    should "define the reader and then be stored" do
+      assert_respond_to :display_name_attribute_type, @instance
+      assert_respond_to :display_name, @instance
+      assert_includes :display_name, subject.attributes
+    end
+  end
+
+  class AddWriteAttributesTest < AttributesMethodTest
+    desc "with the add_write_attributes method"
+    setup do
+      @attribute_names = [ :description ]
+      @schema.add_read_attributes(@attribute_names)
+      @instance = @structural_class.new
+    end
+
+    should "define the reader and then be stored" do
+      assert_respond_to :description_attribute_type, @instance
+      assert_respond_to :description, @instance
+      assert_includes :description, subject.attributes
+    end
+  end
+
+  class AddAuxiliaryClassesTest < BaseTest
+    desc "adding auxiliary classes"
+    setup do
+      @schema.auxiliary_classes.clear
+      @auxiliary_class = Factory.auxiliary_class do
+        attributes :sam_account_name
+        must_set :sam_account_name
+        after_destroy :fix_it_all
+      end
+      @schema.add_auxiliary_class(@auxiliary_class)
+    end
+
+    should "merge the auxiliary classes attributes and store it" do
+      assert_includes @auxiliary_class, subject.auxiliary_classes
+      @auxiliary_class.schema.attributes.each do |name|
+        assert_includes name, subject.attributes
+      end
+      @auxiliary_class.schema.mandatory.each do |name|
+        assert_includes name, subject.mandatory
+      end
+    end
+
+    teardown do
+      @schema.auxiliary_classes.clear
+    end
+  end
+
+  class AddMandatoryTest < BaseTest
+    desc "adding mandatory attributes"
+    setup do
+      @attribute_names = [ :display_name ]
+      @schema.add_mandatory(@attribute_names)
+    end
+
+    should "store the attribute in the mandatory set" do
+      @attribute_names.each do |attribute_name|
+        assert_includes attribute_name, subject.mandatory
+      end
+    end
+  end
+
+  class AddCallbackTest < BaseTest
+    desc "adding a callback"
+    setup do
+      @timing = :before
+      @action = :create
+      @method_name = "something_amazing"
+      @schema.add_callback(@timing, @action, @method_name)
+    end
+
+    should "store the callback in the callbacks hash" do
+      assert_instance_of Hash, subject.callbacks[@action]
+      assert_instance_of Array, subject.callbacks[@action][@timing]
+      assert_includes @method_name, subject.callbacks[@action][@timing]
+    end
+  end
+
+end

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

@@ -0,0 +1,64 @@
+require 'assert'
+
+class AD::Framework::StructuralClass
+
+  class BaseTest < Assert::Context
+    desc "AD::Framework::StructuralClass"
+    setup do
+      @structural_class = AD::Framework::StructuralClass
+      @instance = @structural_class.new
+    end
+    subject{ @instance }
+
+    should have_accessors :meta_class, :fields
+    should have_instance_methods :connection, :treebase, :treebase=
+    should have_class_methods :connection
+
+    should have_instance_methods :schema
+    should have_class_methods :schema
+
+    should have_instance_methods :reload
+    should have_class_methods :find, :first, :all
+
+    should have_instance_methods :create, :update, :save, :destroy
+    should have_class_methods :create
+
+    should have_instance_methods :errors, :valid?
+
+    should "set fields to an instance of AD::Framework::Fields" do
+      assert_instance_of AD::Framework::Fields, subject.fields
+    end
+    should "return the framework's connection with a call to #connection" do
+      assert_equal AD::Framework.connection, subject.class.connection
+      assert_equal subject.class.connection, subject.connection
+    end
+  end
+
+  class InheritedTest < Assert::Context
+    desc "a structural class"
+    setup do
+      @treebase = "CN=somewhere"
+      @structural_class = Factory.structural_class do
+        ldap_name "something"
+        rdn :name
+        attributes :name
+      end
+      @instance = @structural_class.new({ :treebase => @treebase })
+    end
+    subject{ @instance }
+
+    should "have set it's treebase" do
+      expected = [ @treebase, AD::Framework.config.treebase ].join(", ")
+      assert_equal expected, subject.treebase
+    end
+    should "have a custom inspect" do
+      expected = "#<#{subject.class} "
+      attrs = subject.attributes.collect{|k, v| "#{k}: #{v.inspect}" }
+      attrs << "treebase: #{subject.treebase.inspect}"
+      expected += attrs.sort.join(", ")
+      expected += ">"
+      assert_equal expected, subject.inspect
+    end
+  end
+
+end

data/test/unit/ad-framework/utilities/entry_builder_test.rb

@@ -0,0 +1,107 @@
+require 'assert'
+
+class AD::Framework::Utilities::EntryBuilder
+
+  class BaseTest < Assert::Context
+    desc "AD::Framework::Utilities::EntryBuilder"
+    setup do
+      State.preserve
+      @structural_class = Factory.structural_class do
+        ldap_name "somethingAmazing"
+        attributes :name
+      end
+      AD::Framework.register_structural_class(@structural_class)
+      @ldap_entry = { "objectclass" => [ @structural_class.ldap_name ] }
+      @entry_builder = AD::Framework::Utilities::EntryBuilder.new(@ldap_entry)
+    end
+    subject{ @entry_builder }
+
+    should have_accessors :ldap_entry, :entry, :fields
+    should have_instance_methods :reload, :build
+
+    should "have build a fields object from the ldap entry" do
+      assert_instance_of AD::Framework::Fields, subject.fields
+    end
+
+    teardown do
+      State.restore
+    end
+  end
+
+  class BuildTest < BaseTest
+    desc "entry builder building a new entry"
+    subject{ @entry_builder.entry }
+
+    should "be a kind of the class in its object class" do
+      assert_instance_of @structural_class, subject
+    end
+    should "have set the fields on the entry to its" do
+      assert_equal @entry_builder.fields, subject.fields
+    end
+  end
+
+  class ReloadTest < BaseTest
+    desc "entry builder reloading an entry"
+    setup do
+      @entry = @entry_builder.entry
+      @entry.fields["something"] = "amazing"
+      @entry.name = "something new"
+      @entry_builder = AD::Framework::Utilities::EntryBuilder.new(@ldap_entry, {
+        :reload => @entry
+      })
+    end
+    subject{ @entry }
+
+    should "have reset it's fields" do
+      assert_not_equal "amazing", subject.fields["something"]
+      assert_nil subject.fields["something"]
+    end
+    should "have reset it's attributes" do
+      assert_not_equal "something new", subject.name
+      assert_nil subject.name
+    end
+  end
+
+  class WithLinkedAuxiliaryClassesTest < BaseTest
+    desc "entry builder building a new entry with linked aux classes"
+    setup do
+      @auxiliary_class = Factory.auxiliary_class do
+        ldap_name "displayIt"
+        attributes :display_name
+      end
+      AD::Framework.register_auxiliary_class(@auxiliary_class)
+      @ldap_entry = {
+        "objectclass" => [ @auxiliary_class.ldap_name, @structural_class.ldap_name ]
+      }
+      @entry_builder = AD::Framework::Utilities::EntryBuilder.new(@ldap_entry)
+    end
+    subject{ @entry_builder.entry }
+
+    should "be a kind of the class in its object class" do
+      assert_instance_of @structural_class, subject
+    end
+    should "have set the fields on the entry to its" do
+      assert_equal @entry_builder.fields, subject.fields
+    end
+    should "have add the auxiliary class to the entry" do
+      assert_includes @auxiliary_class, subject.schema.auxiliary_classes
+      assert_includes :display_name, subject.schema.attributes
+      assert_respond_to :display_name, subject
+    end
+  end
+
+  class UndefinedObjectClassTest < Assert::Context
+    desc "AD::Framework::Utilities::EntryBuilder"
+    setup do
+      @ldap_entry = { "objectclass" => [ "notdefinedatall" ] }
+    end
+    subject{ @ldap_entry }
+
+    should "raise an object class not defined exception" do
+      assert_raises(AD::Framework::ObjectClassNotDefined) do
+        AD::Framework::Utilities::EntryBuilder.new(@ldap_entry)
+      end
+    end
+  end
+
+end