ad-framework 0.1.0

data/test/unit/ad-framework/patterns/has_schema/class_methods_test.rb

@@ -0,0 +1,214 @@
+require 'assert'
+
+module AD::Framework::Patterns::HasSchema
+
+  class ClassMethodsTest < Assert::Context
+    desc "AD::Framework::Patterns::HasSchema class"
+    setup do
+      @module = AD::Framework::Patterns::HasSchema
+      @structural_class = Factory.structural_class do
+        attributes :name, :display_name
+      end
+    end
+    subject{ @structural_class }
+
+    should "return an instance of AD::Framework::Schema with #schema" do
+      assert_instance_of AD::Framework::Schema, subject.schema
+    end
+  end
+
+  class SetLdapNameTest < ClassMethodsTest
+    desc "setting ldap name"
+    setup do
+      @new_value = "awesomeness"
+      @structural_class.ldap_name(@new_value)
+    end
+
+    should "set the schema's ldap name" do
+      assert_match @new_value, subject.schema.ldap_name
+    end
+  end
+
+  class SetTreebaseTest < ClassMethodsTest
+    desc "setting treebase"
+    setup do
+      @new_value = "CN=container"
+      @structural_class.treebase(@new_value)
+    end
+
+    should "set the schema's treebase with a call to #treebase" do
+      assert_match @new_value, subject.schema.treebase
+    end
+  end
+
+  class SetRdnTest < ClassMethodsTest
+    desc "setting rdn"
+    setup do
+      @new_value = "name"
+      @structural_class.rdn(@new_value)
+    end
+
+    should "set the schema's rdn with a call to #rdn" do
+      assert_equal @new_value, subject.schema.rdn
+    end
+  end
+
+  class SetAttributesTest < ClassMethodsTest
+    desc "setting attributes"
+    setup do
+      @values = [ :name, :display_name ]
+      @structural_class.schema.expects(:add_attributes).with(@values)
+    end
+
+    should "add attributes to the schema" do
+      values = @values
+      assert_nothing_raised{ subject.attributes(*values) }
+    end
+  end
+
+  class SetReadAttributesTest < ClassMethodsTest
+    desc "setting read attributes"
+    setup do
+      @values = [ :name, :display_name ]
+      @structural_class.schema.expects(:add_read_attributes).with(@values)
+    end
+
+    should "add read attributes to the schema" do
+      values = @values
+      assert_nothing_raised{ subject.read_attributes(*values) }
+    end
+  end
+
+  class SetWriteAttributesTest < ClassMethodsTest
+    desc "setting write attributes"
+    setup do
+      @values = [ :name, :display_name ]
+      @structural_class.schema.expects(:add_write_attributes).with(@values)
+    end
+
+    should "add write attributes to the schema" do
+      values = @values
+      assert_nothing_raised{ subject.write_attributes(*values) }
+    end
+  end
+
+  class SetMustSetTest < ClassMethodsTest
+    desc "setting mandatory attributes"
+    setup do
+      @values = [ :name ]
+      @structural_class.schema.expects(:add_mandatory).with(@values)
+    end
+
+    should "add mandatory attributes to the schema" do
+      values = @values
+      assert_nothing_raised{ subject.must_set(*values) }
+    end
+  end
+
+  class BeforeCreateTest < ClassMethodsTest
+    desc "adding a before_create callback"
+    setup do
+      @values = [ :do_something_amazing, :another_amazing_thing ]
+      @structural_class.schema.expects(:add_callback).with(:before, :create, @values)
+    end
+
+    should "add callbacks to the schema" do
+      values = @values
+      assert_nothing_raised{ subject.before_create(*values) }
+    end
+  end
+
+  class BeforeUpdateTest < ClassMethodsTest
+    desc "adding a before_update callback"
+    setup do
+      @values = [ :do_something_amazing, :another_amazing_thing ]
+      @structural_class.schema.expects(:add_callback).with(:before, :update, @values)
+    end
+
+    should "add callbacks to the schema" do
+      values = @values
+      assert_nothing_raised{ subject.before_update(*values) }
+    end
+  end
+
+  class BeforeSaveTest < ClassMethodsTest
+    desc "adding a before_save callback"
+    setup do
+      @values = [ :do_something_amazing, :another_amazing_thing ]
+      @structural_class.schema.expects(:add_callback).with(:before, :create, @values)
+      @structural_class.schema.expects(:add_callback).with(:before, :update, @values)
+    end
+
+    should "add callbacks for create and update to the schema" do
+      values = @values
+      assert_nothing_raised{ subject.before_save(*values) }
+    end
+  end
+
+  class BeforeDestroyTest < ClassMethodsTest
+    desc "adding a before_destroy callback"
+    setup do
+      @values = [ :do_something_amazing, :another_amazing_thing ]
+      @structural_class.schema.expects(:add_callback).with(:before, :destroy, @values)
+    end
+
+    should "add callbacks to the schema" do
+      values = @values
+      assert_nothing_raised{ subject.before_destroy(*values) }
+    end
+  end
+  
+  class AfterCreateTest < ClassMethodsTest
+    desc "adding a after_create callback"
+    setup do
+      @values = [ :do_something_amazing, :another_amazing_thing ]
+      @structural_class.schema.expects(:add_callback).with(:after, :create, @values)
+    end
+
+    should "add callbacks to the schema" do
+      values = @values
+      assert_nothing_raised{ subject.after_create(*values) }
+    end
+  end
+
+  class AfterUpdateTest < ClassMethodsTest
+    desc "adding a after_update callback"
+    setup do
+      @values = [ :do_something_amazing, :another_amazing_thing ]
+      @structural_class.schema.expects(:add_callback).with(:after, :update, @values)
+    end
+
+    should "add callbacks to the schema" do
+      values = @values
+      assert_nothing_raised{ subject.after_update(*values) }
+    end
+  end
+
+  class AfterSaveTest < ClassMethodsTest
+    desc "adding a after_save callback"
+    setup do
+      @values = [ :do_something_amazing, :another_amazing_thing ]
+      @structural_class.schema.expects(:add_callback).with(:after, :create, @values)
+      @structural_class.schema.expects(:add_callback).with(:after, :update, @values)
+    end
+
+    should "add callbacks for create and update to the schema" do
+      values = @values
+      assert_nothing_raised{ subject.after_save(*values) }
+    end
+  end
+
+  class AfterDestroyTest < ClassMethodsTest
+    desc "adding a after_destroy callback"
+    setup do
+      @values = [ :do_something_amazing, :another_amazing_thing ]
+      @structural_class.schema.expects(:add_callback).with(:after, :destroy, @values)
+    end
+
+    should "add callbacks to the schema" do
+      values = @values
+      assert_nothing_raised{ subject.after_destroy(*values) }
+    end
+  end
+
+end

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

@@ -0,0 +1,96 @@
+require 'assert'
+
+module AD::Framework::Patterns::HasSchema
+
+  class BaseTest < Assert::Context
+    desc "AD::Framework::Patterns::HasSchema"
+    setup do
+      @structural_class = Factory.structural_class do
+        treebase "CN=Something, DC=example, DC=com"
+        attributes :name, :display_name
+      end
+      @instance = @structural_class.new({ :name => "someone", :display_name => "Someone" })
+    end
+    subject{ @instance }
+
+    should have_instance_methods :schema, :dn, :attributes, :attributes=
+    should have_class_methods :schema, :ldap_name, :treebase, :rdn, :attributes
+    should have_class_methods :read_attributes, :write_attributes, :must_set
+    should have_class_methods :before_create, :before_update, :before_save, :before_destroy
+    should have_class_methods :after_create, :after_update, :after_save, :after_destroy
+
+    should "return it's class's schema wtih a call to #schema" do
+      assert_equal subject.class.schema.klass, subject.schema.klass
+    end
+    should "return a hash of the attributes and their values with a call to #attributes" do
+      expected = subject.schema.attributes.inject({}) do |h, a|
+        h.merge({ a.to_sym => subject.send(a) })
+      end
+      assert_equal expected, subject.attributes
+    end
+  end
+
+  class DnTest < BaseTest
+    desc "dn method"
+    setup do
+      @distinguished_name = "CN=distinguishedname, #{subject.schema.treebase}"
+      @dn = "CN=dn, #{subject.schema.treebase}"
+      @built_dn = "CN=#{subject.send(subject.schema.rdn)}, #{subject.schema.treebase}"
+      @instance.fields[:distinguishedname] = @distinguished_name
+      @instance.fields[:dn] = @dn
+    end
+    subject{ @instance }
+
+    should "return the distinguished name field" do
+      assert_equal @distinguished_name, subject.dn
+    end
+  end
+
+  class DnWithoutDistinguishedNameTest < DnTest
+    desc "without the distinguishedname field"
+    setup do
+      @instance.fields[:distinguishedname] = nil
+    end
+
+    should "return the dn field" do
+      assert_equal @dn, subject.dn
+    end
+  end
+
+  class DnWithNoFieldsTest < DnWithoutDistinguishedNameTest
+    desc "and without the dn field"
+    setup do
+      @instance.fields[:dn] = nil
+    end
+
+    should "return a concatenation of the rdn field and the treebase" do
+      assert_equal @built_dn, subject.dn
+    end
+  end
+
+  class SetObjectAttributesTest < BaseTest
+    desc "setting attributes"
+    setup do
+      @new_attributes = { :name => "amazing", :display_name => "Amazing" }
+      @instance.attributes = @new_attributes
+    end
+
+    should "set multiple attributes" do
+      assert_equal @new_attributes[:name], subject.name
+      assert_equal @new_attributes[:display_name], subject.display_name
+    end
+  end
+
+  class SetAttributesWithInvalidTest < BaseTest
+    desc "setting attributes with ignored key/values"
+    setup do
+      @new_attributes = { :something => "something" }
+    end
+
+    should "be ignored" do
+      new_attributes = @new_attributes
+      assert_nothing_raised{ subject.attributes = new_attributes }
+    end
+  end
+
+end

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

@@ -0,0 +1,126 @@
+require 'assert'
+
+module AD::Framework::Patterns::Persistence
+
+  class BaseTest < Assert::Context
+    desc "the persistence pattern"
+    setup do
+      @structural_class = Factory.structural_class do
+        ldap_name "persistenceTestObject"
+        attributes :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_instance_methods :new_entry?, :save, :create, :update, :destroy
+    should have_class_methods :create
+
+    should "return true with #new_entry?" do
+      assert_equal true, subject.new_entry?
+    end
+    should "call #create with #save" do
+      subject.expects(:create)
+      assert_nothing_raised{ subject.save }
+    end
+  end
+
+  class WithDistinguishedNameFieldTest < BaseTest
+    desc "with a distinguishedname field set"
+    setup do
+      @instance.fields[:distinguishedname] = "distinguishedname"
+    end
+
+    should "return false with #new_entry?" do
+      assert_equal false, subject.new_entry?
+    end
+    should "call #create with #save" do
+      subject.expects(:update)
+      assert_nothing_raised{ subject.save }
+    end
+  end
+
+  class WithDnFieldTest < BaseTest
+    desc "with a dn field set"
+    setup do
+      @instance.fields[:dn] = "dn"
+    end
+
+    should "return false with #new_entry?" do
+      assert_equal false, subject.new_entry?
+    end
+    should "call #create with #save" do
+      subject.expects(:update)
+      assert_nothing_raised{ subject.save }
+    end
+  end
+
+  class CreateObjectTest < BaseTest
+    desc "create method"
+    setup do
+      @set_dn = @instance.dn
+      fields = @instance.fields.dup
+      fields[:objectclass] = @instance.schema.object_classes.collect(&:ldap_name).compact
+      fields[:distinguishedname] = @set_dn
+      @set_attributes = fields.to_hash
+      @mock_connection.expects(:add).with({ :dn => @set_dn, :attributes => @set_attributes })
+      @instance.expects(:reload)
+    end
+
+    should "call add on it's connection with the fields, including dn and objectclass" do
+      assert_nothing_raised{ @instance.create }
+    end
+  end
+
+  class UpdateObjectTest < BaseTest
+    desc "update method"
+    setup do
+      @instance.fields[:dn] = @instance.dn
+      @instance.attributes = { :name => "new name", :system_flags => 12 }
+      @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 "call replace attribute for every changed field" do
+      assert_nothing_raised{ subject.update }
+    end
+  end
+
+  class DestroyObjectTest < BaseTest
+    desc "destroy method"
+    setup do
+      @instance.fields[:dn] = @instance.dn
+      @mock_connection.expects(:delete).with(@instance.dn)
+    end
+
+    should "call delete on the connection" do
+      assert_nothing_raised{ subject.destroy }
+    end
+  end
+
+  class CreateClassMethodTest < Assert::Context
+    desc "create on the class"
+    setup do
+      @structural_class = Factory.structural_class do
+        ldap_name "persistenceClassTestObject"
+        attributes :name, :system_flags
+      end
+      @attributes = { :name => "from class", :system_flags => 5 }
+      mock_entry = mock()
+      @structural_class.expects(:new).returns(mock_entry).with(@attributes)
+      mock_entry.expects(:create)
+    end
+    subject{ @structural_class }
+
+    should "call create on a new entry build with attributes passed to it" do
+      attributes = @attributes
+      assert_nothing_raised{ subject.create(attributes) }
+    end
+  end
+
+end

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

@@ -0,0 +1,201 @@
+require 'assert'
+
+module AD::Framework::Patterns::Searchable
+
+  class BaseTest < Assert::Context
+    desc "AD::Framework::Searchable"
+    setup do
+      @structural_class = Factory.structural_class do
+        ldap_name "searchableTestObject"
+        treebase "OU=Random"
+      end
+      AD::Framework.register_structural_class(@structural_class)
+      @fields = { "objectclass" => [ @structural_class.schema.ldap_name ] }
+      instance_fields = @fields.dup.merge({ "dn" => "CN=something, DC=example, DC=com" })
+      @instance = @structural_class.new({ :fields => instance_fields })
+    end
+    subject{ @instance }
+
+    should have_instance_methods :reload
+    should have_class_methods :find, :first, :all
+
+    teardown do
+      AD::Framework.defined_object_classes.delete(@structural_class.ldap_name.to_sym)
+    end
+  end
+
+  class ReloadTest < BaseTest
+    desc "reload method"
+    setup do
+      @search_args = {
+        :objectclass__eq => @instance.class.ldap_name, :base => @instance.treebase, :size => 1
+      }
+      @distinguishedname = "distinguishedname test"
+      @dn = "dn test"
+      @instance.fields[:distinguishedname] = @distinguishedname
+      @instance.fields[:dn] = @dn
+      @mock_connection = mock()
+      @instance.expects(:connection).returns(@mock_connection)
+    end
+  end
+
+  class WithDistinguishedNameTest < ReloadTest
+    desc "with distinguishedname field set"
+    setup do
+      @search_args[:dn__eq] = @instance.fields[:distinguishedname]
+      @mock_connection.expects(:search).with(@search_args).returns([ @fields ])
+    end
+
+    should "call search on it's connection with the distinguishedname field" do
+      assert_nothing_raised{ subject.reload }
+    end
+  end
+
+  class WithDnTest < ReloadTest
+    desc "without distinguishedname and with dn field set"
+    setup do
+      @instance.fields[:distinguishedname] = nil
+      @search_args[:dn__eq] = @instance.fields[:dn]
+      @mock_connection.expects(:search).with(@search_args).returns([ @fields ])
+    end
+
+    should "call search on it's connection with the dn field" do
+      assert_nothing_raised{ subject.reload }
+    end
+  end
+
+  class WithInvalidDnTest < ReloadTest
+    desc "with an invalid dn"
+    setup do
+      @instance.fields[:distinguishedname] = @instance.fields[:dn] = nil
+      @search_args[:dn__eq] = nil
+      @mock_connection.expects(:search).with(@search_args).returns([])
+    end
+    should "raise a not found exception if the search returns no entries" do
+      assert_raises(AD::Framework::EntryNotFound){ subject.reload }
+    end
+  end
+
+  class FirstMethodTest < BaseTest
+    desc "first method"
+    setup do
+      @structural_class = Factory.structural_class do
+        ldap_name "firstSearchableTestObject"
+      end
+      @first_args = { :name => "someone" }
+      @search_args = {
+        :name => @first_args[:name], :objectclass__eq => @structural_class.ldap_name,
+        :base => @structural_class.treebase, :size => 1
+      }
+      @mock_connection = mock()
+      @structural_class.expects(:connection).returns(@mock_connection)
+      @mock_connection.expects(:search).with(@search_args).returns([ @fields ])
+    end
+    subject{ @structural_class }
+
+    should "search with the args passed and return a single entry" do
+      found = nil
+      assert_nothing_raised{ found = subject.first(@first_args) }
+      assert found
+      assert_equal @fields, found.fields
+    end
+  end
+
+  class AllMethodTest < BaseTest
+    desc "all method"
+    setup do
+      @structural_class = Factory.structural_class do
+        ldap_name "allSearchableTestObject"
+      end
+      @all_args = { :where => { :name => "*some*" } }
+      @search_args = {
+        :name => @all_args[:where][:name], :objectclass__eq => @structural_class.ldap_name,
+        :base => @structural_class.treebase
+      }
+      @mock_connection = mock()
+      @structural_class.expects(:connection).returns(@mock_connection)
+      @mock_connection.expects(:search).with(@search_args).returns([ @fields.dup, @fields.dup ])
+    end
+    subject{ @structural_class }
+
+    should "search with the args passed and return multiple entries" do
+      all = nil
+      assert_nothing_raised{ all = subject.all(@all_args) }
+      assert_instance_of Array, all
+      all.each{|found| assert_equal(@fields, found.fields) }
+    end
+  end
+
+  class FindMethodWithDnTest < BaseTest
+    desc "find method with a dn"
+    setup do
+      @structural_class = Factory.structural_class do
+        ldap_name "findWithDNSearchableTestObject"
+      end
+      @dn = "CN=someone, #{@structural_class.treebase}"
+      @search_args = {
+        :dn__eq => @dn, :objectclass__eq => @structural_class.ldap_name,
+        :base => @structural_class.treebase, :size => 1
+      }
+      @mock_connection = mock()
+      @structural_class.expects(:connection).returns(@mock_connection)
+      @mock_connection.expects(:search).with(@search_args).returns([ @fields ])
+    end
+    subject{ @structural_class }
+
+    should "return an entry with a matching dn" do
+      found = nil
+      assert_nothing_raised{ found = subject.find(@dn) }
+      assert found
+      assert_equal(@fields, found.fields)
+    end
+  end
+
+  class FindMethodWithRdnTest < BaseTest
+    desc "find method with a rdn"
+    setup do
+      @structural_class = Factory.structural_class do
+        ldap_name "findWithRDNSearchableTestObject"
+      end
+      @rdn = "someone"
+      @search_args = {
+        :dn__eq => "CN=#{@rdn}, #{@structural_class.treebase}", :base => @structural_class.treebase,
+        :objectclass__eq => @structural_class.ldap_name, :size => 1
+      }
+      @mock_connection = mock()
+      @structural_class.expects(:connection).returns(@mock_connection)
+      @mock_connection.expects(:search).with(@search_args).returns([ @fields ])
+    end
+    subject{ @structural_class }
+
+    should "return an entry with a matching rdn" do
+      found = nil
+      assert_nothing_raised{ found = subject.find(@rdn) }
+      assert found
+      assert_equal(@fields, found.fields)
+    end
+  end
+
+  class FindMethodWithNotResultTest < BaseTest
+    desc "find method that returns no result"
+    setup do
+      @structural_class = Factory.structural_class do
+        ldap_name "findWithDNSearchableTestObject"
+      end
+      @dn = "CN=someone, #{@structural_class.treebase}"
+      @search_args = {
+        :dn__eq => @dn, :objectclass__eq => @structural_class.ldap_name,
+        :base => @structural_class.treebase, :size => 1
+      }
+      @mock_connection = mock()
+      @structural_class.expects(:connection).returns(@mock_connection)
+      @mock_connection.expects(:search).with(@search_args).returns([])
+    end
+    subject{ @structural_class }
+
+    should "raise an error when no entry is found" do
+      assert_raises(AD::Framework::EntryNotFound){ subject.find(@dn) }
+    end
+  end
+
+end