treequel 1.0.4 → 1.1.0

data/spec/treequel/model_spec.rb

@@ -0,0 +1,433 @@
+#!/usr/bin/env ruby
+
+BEGIN {
+	require 'pathname'
+	basedir = Pathname.new( __FILE__ ).dirname.parent.parent
+
+	libdir = basedir + "lib"
+
+	$LOAD_PATH.unshift( basedir ) unless $LOAD_PATH.include?( basedir )
+	$LOAD_PATH.unshift( libdir ) unless $LOAD_PATH.include?( libdir )
+}
+
+require 'spec'
+require 'spec/lib/constants'
+require 'spec/lib/helpers'
+require 'spec/lib/matchers'
+
+require 'treequel/model'
+
+include Treequel::TestConstants
+include Treequel::Constants
+
+#####################################################################
+###	C O N T E X T S
+#####################################################################
+
+describe Treequel::Model do
+	include Treequel::SpecHelpers,
+	        Treequel::Matchers
+
+	before( :all ) do
+		setup_logging( :fatal )
+	end
+
+	after( :all ) do
+		reset_logging()
+	end
+
+	before( :each ) do
+		@top_oc    = mock( "top objectClass", :name => 'top' )
+		@iphost_oc = mock( "ipHost objectClass", :name => 'ipHost' )
+		@device_oc = mock( "device objectClass", :name => 'device' )
+
+		@iphost_oc.stub!( :ancestors ).and_return([ @iphost_oc, @top_oc ])
+		@device_oc.stub!( :ancestors ).and_return([ @device_oc, @top_oc ])
+
+		@simple_entry = {
+			'dn' => TEST_HOST_DN,
+			'objectClass' => ['ipHost', 'device']
+		}
+		@simple_entry.stub!( :object_classes ).and_return([ @iphost_oc, @device_oc ])
+		@directory = mock( "treequel directory", :get_entry => @simple_entry )
+	end
+
+	after( :each ) do
+		Treequel::Model.objectclass_registry.clear
+		Treequel::Model.base_registry.clear
+	end
+
+
+	it "knows which mixins should be applied for a single objectClass" do
+		mixin = Module.new
+		mixin.should_receive( :model_objectclasses ).at_least( :once ).
+			and_return( [:inetOrgPerson] )
+		mixin.should_receive( :model_bases ).at_least( :once ).
+			and_return( [] )
+		Treequel::Model.register_mixin( mixin )
+		Treequel::Model.mixins_for_objectclasses( :inetOrgPerson ).should include( mixin )
+	end
+
+	it "knows which mixins should be applied for multiple objectClasses" do
+		mixin = Module.new
+		mixin.should_receive( :model_objectclasses ).at_least( :once ).
+			and_return( [:inetOrgPerson, :organizationalPerson] )
+		mixin.should_receive( :model_bases ).at_least( :once ).
+			and_return( [] )
+		Treequel::Model.register_mixin( mixin )
+		Treequel::Model.mixins_for_objectclasses( :inetOrgPerson, :organizationalPerson ).
+			should include( mixin )
+	end
+
+	it "knows which mixins should be applied for a DN that exactly matches one that's registered" do
+		mixin = Module.new
+		mixin.should_receive( :model_objectclasses ).at_least( :once ).
+			and_return( [] )
+		mixin.should_receive( :model_bases ).at_least( :once ).
+			and_return( [TEST_PEOPLE_DN] )
+		Treequel::Model.register_mixin( mixin )
+		Treequel::Model.mixins_for_dn( TEST_PEOPLE_DN ).should include( mixin )
+	end
+
+	it "knows which mixins should be applied for a DN that is a child of one that's registered" do
+		mixin = mock( "module" )
+		mixin.should_receive( :model_objectclasses ).at_least( :once ).
+			and_return( [] )
+		mixin.should_receive( :model_bases ).at_least( :once ).
+			and_return( [TEST_PEOPLE_DN] )
+		Treequel::Model.register_mixin( mixin )
+		Treequel::Model.mixins_for_dn( TEST_PERSON_DN ).should include( mixin )
+	end
+
+	it "knows that mixins that don't have a base apply to all DNs" do
+		mixin = mock( "module" )
+		mixin.should_receive( :model_objectclasses ).at_least( :once ).
+			and_return( [:top] )
+		mixin.should_receive( :model_bases ).at_least( :once ).and_return( [] )
+
+		Treequel::Model.register_mixin( mixin )
+
+		Treequel::Model.mixins_for_dn( TEST_PERSON_DN ).should include( mixin )
+	end
+
+	it "adds new registries to subclasses" do
+		subclass = Class.new( Treequel::Model )
+
+		# The registry should have the same default proc, but be a distinct Hash
+		subclass.objectclass_registry.default_proc.
+			should equal( Treequel::Model::SET_HASH.default_proc )
+		subclass.objectclass_registry.should_not equal( Treequel::Model.objectclass_registry )
+
+		# Same with this one
+		subclass.base_registry.default_proc.
+			should equal( Treequel::Model::SET_HASH.default_proc )
+		subclass.base_registry.should_not equal( Treequel::Model.base_registry )
+	end
+
+	it "extends new instances with registered mixins which are applicable" do
+		mixin1 = Module.new do
+			extend Treequel::Model::ObjectClass
+			model_bases TEST_HOSTS_DN, TEST_SUBHOSTS_DN
+			model_objectclasses :ipHost
+		end
+		mixin2 = Module.new do
+			extend Treequel::Model::ObjectClass
+			model_bases TEST_HOSTS_DN
+			model_objectclasses :device
+		end
+		mixin3 = Module.new do
+			extend Treequel::Model::ObjectClass
+			model_objectclasses :person
+		end
+
+		obj = Treequel::Model.new( @directory, TEST_SUBHOST_DN, @simple_entry )
+
+		obj.should be_a( mixin1 )
+		obj.should_not be_a( mixin2 )
+		obj.should_not be_a( mixin3 )
+	end
+
+	it "extends new instances with mixins that are implied by objectClass SUP attributes, too" do
+		inherited_mixin = Module.new do
+			extend Treequel::Model::ObjectClass
+			model_objectclasses :top
+		end
+		mixin1 = Module.new do
+			extend Treequel::Model::ObjectClass
+			model_bases TEST_HOSTS_DN, TEST_SUBHOSTS_DN
+			model_objectclasses :ipHost
+		end
+
+		obj = Treequel::Model.new( @directory, TEST_SUBHOST_DN, @simple_entry )
+
+		obj.should be_a( mixin1 )
+		obj.should be_a( inherited_mixin )
+	end
+
+	it "applies applicable mixins to instances created before looking up the corresponding entry" do
+		mixin1 = Module.new do
+			extend Treequel::Model::ObjectClass
+			model_bases TEST_HOSTS_DN, TEST_SUBHOSTS_DN
+			model_objectclasses :ipHost
+		end
+		mixin2 = Module.new do
+			extend Treequel::Model::ObjectClass
+			model_bases TEST_HOSTS_DN
+			model_objectclasses :device
+		end
+		mixin3 = Module.new do
+			extend Treequel::Model::ObjectClass
+			model_objectclasses :person
+		end
+
+		obj = Treequel::Model.new( @directory, TEST_HOST_DN )
+		obj.exists? # Trigger the lookup
+
+		obj.should be_a( mixin1 )
+		obj.should be_a( mixin2 )
+		obj.should_not be_a( mixin3 )
+	end
+
+	it "doesn't try to apply objectclasses to non-existant entries" do
+		mixin1 = Module.new do
+			extend Treequel::Model::ObjectClass
+			model_bases TEST_HOSTS_DN, TEST_SUBHOSTS_DN
+			model_objectclasses :ipHost
+		end
+
+		@directory.stub!( :get_entry ).and_return( nil )
+		obj = Treequel::Model.new( @directory, TEST_HOST_DN )
+		obj.exists? # Trigger the lookup
+
+		obj.should_not be_a( mixin1 )
+	end
+
+	it "allows a mixin to be unregistered" do
+		mixin = Module.new
+		mixin.should_receive( :model_objectclasses ).at_least( :once ).
+			and_return( [:inetOrgPerson] )
+		mixin.should_receive( :model_bases ).at_least( :once ).
+			and_return( [] )
+		Treequel::Model.register_mixin( mixin )
+		Treequel::Model.unregister_mixin( mixin )
+		Treequel::Model.mixins_for_objectclasses( :inetOrgPerson ).should_not include( mixin )
+	end
+
+
+	describe "created from DNs" do
+		before( :all ) do
+			@entry = {
+				'dn'          => [TEST_PERSON_DN],
+				'cn'          => ['Slappy the Frog'],
+				'objectClass' => %w[
+					ipHost
+				],
+			}
+			schema_dumpfile = Pathname( __FILE__ ).dirname.parent + 'data' + 'schema.yml'
+			hash = YAML.load_file( schema_dumpfile )
+			schemahash = LDAP::Schema.new( hash )
+			@schema = Treequel::Schema.new( schemahash )
+		end
+
+		before( :each ) do
+			@mixin = Module.new do
+				extend Treequel::Model::ObjectClass
+				model_objectclasses :ipHost
+				def fqdn; "some.home.example.com"; end
+			end
+			@directory = mock( 'Treequel Directory', :schema => @schema )
+			@directory.stub!( :convert_to_object ).with( Treequel::OIDS::OID_SYNTAX, 'ipHost' ).
+				and_return( 'ipHost' )
+			@directory.stub!( :convert_to_object ).
+				with( Treequel::OIDS::DIRECTORY_STRING_SYNTAX, 'Slappy the Frog' ).
+				and_return( 'Slappy the Frog' )
+			@obj = Treequel::Model.new( @directory, TEST_PERSON_DN )
+			@entry.stub!( :object_classes ).and_return([ @schema.object_classes[:ipHost] ])
+		end
+
+		after( :each ) do
+			Treequel::Model.objectclass_registry.clear
+			Treequel::Model.base_registry.clear
+		end
+
+		it "correctly dispatches to methods added via extension that are called before its " +
+		     "entry is loaded" do
+			@directory.should_receive( :get_entry ).with( @obj ).and_return( @entry )
+			@obj.fqdn.should == 'some.home.example.com'
+		end
+
+		it "correctly falls through for methods not added by loading the entry" do
+			@directory.should_receive( :get_entry ).with( @obj ).and_return( @entry )
+			@obj.cn.should == ['Slappy the Frog']
+		end
+	end
+
+
+	describe "objects created from entries" do
+
+		before( :all ) do
+			@entry = {
+				'dn'          => ['uid=slappy,ou=people,dc=acme,dc=com'],
+				'uid'         => ['slappy'],
+				'cn'          => ['Slappy the Frog'],
+				'givenName'   => ['Slappy'],
+				'sn'          => ['Frog'],
+				'l'           => ['a forest in England'],
+				'title'       => ['Forest Fire Prevention Advocate'],
+				'displayName' => ['Slappy the Frog'],
+				'logonTime'   => 'a time string',
+				'objectClass' => %w[
+					top
+					person
+					organizationalPerson
+					inetOrgPerson
+					posixAccount
+					shadowAccount
+					apple-user
+				],
+			}
+
+			schema_dumpfile = Pathname( __FILE__ ).dirname.parent + 'data' + 'schema.yml'
+			hash = YAML.load_file( schema_dumpfile )
+			schemahash = LDAP::Schema.new( hash )
+			@schema = Treequel::Schema.new( schemahash )
+		end
+
+		before( :each ) do
+			@directory = mock( 'Treequel Directory', :schema => @schema )
+			@entry.stub!( :object_classes ).and_return([ @schema.object_classes[:ipHost] ])
+			@obj = Treequel::Model.new_from_entry( @entry, @directory )
+		end
+
+
+		it "provides readers for valid attributes" do
+			attrtype = stub( "Treequel attributeType object", :name => :uid )
+
+			@obj.should_receive( :valid_attribute_type ).with( :uid ).and_return( attrtype )
+			@obj.should_receive( :[] ).with( :uid ).and_return( ['slappy'] )
+
+			@obj.uid.should == ['slappy']
+		end
+
+		it "normalizes underbarred readers for camelCased attributes" do
+			attrtype = stub( "Treequel attributeType object", :name => :givenName )
+
+			@obj.should_receive( :valid_attribute_type ).with( :given_name ).and_return( nil )
+			@obj.should_receive( :valid_attribute_type ).with( :givenName ).and_return( attrtype )
+			@obj.should_receive( :[] ).with( :givenName ).and_return( ['Slappy'] )
+
+			@obj.given_name.should == ['Slappy']
+		end
+
+		it "falls through to branch-traversal for a reader with arguments" do
+			@obj.should_not_receive( :valid_attribute_type )
+			@obj.should_not_receive( :[] )
+
+			@obj.should_receive( :traverse_branch ).
+				with( :dc, :admin, {} ).and_return( :a_child_branch )
+
+			@obj.dc( :admin ).should == :a_child_branch
+		end
+
+		it "accommodates branch-traversal from its auto-generated readers" do
+			@obj.should_receive( :[] ).with( :uid ).and_return( ['slappy'] )
+			@obj.uid.should == ['slappy']
+
+			@obj.uid( :slappy ).should be_a( Treequel::Model )
+		end
+
+		it "provides writers for valid singular attributes" do
+			attrtype = stub( "Treequel attributeType object", :name => :logonTime, :single? => true )
+
+			@obj.should_receive( :valid_attribute_type ).with( :logonTime ).and_return( attrtype )
+			@obj.should_receive( :[]= ).with( :logonTime, 'stampley' )
+
+			@obj.logonTime = 'stampley'
+		end
+
+		it "provides writers for valid non-singular attributes that accept a non-array" do
+			attrtype = stub( "Treequel attributeType object", :name => :uid, :single? => false )
+
+			@obj.should_receive( :valid_attribute_type ).with( :uid ).and_return( attrtype )
+			@obj.should_receive( :[]= ).with( :uid, ['stampley'] )
+
+			@obj.uid = 'stampley'
+		end
+
+		it "provides a predicate that tests true for valid singular attributes that are set" do
+			attrtype = stub( "Treequel attributeType object", :name => :activated, :single? => true )
+
+			@obj.should_receive( :valid_attribute_type ).with( :activated ).and_return( attrtype )
+			@obj.should_receive( :[] ).with( :activated ).and_return( :a_time_object )
+
+			@obj.should be_activated()
+		end
+
+		it "provides a predicate that tests false for valid singular attributes that are not set" do
+			attrtype = stub( "Treequel attributeType object", :name => :deactivated, :single? => true )
+
+			@obj.should_receive( :valid_attribute_type ).with( :deactivated ).and_return( attrtype )
+			@obj.should_receive( :[] ).with( :deactivated ).and_return( nil )
+
+			@obj.should_not be_deactivated()
+		end
+
+		it "provides a predicate that tests true for valid non-singular attributes that have " +
+		   "at least one value" do
+			attrtype = stub( "Treequel attributeType object", :name => :description, :single? => false )
+
+			@obj.should_receive( :valid_attribute_type ).with( :description ).and_return( attrtype )
+			@obj.should_receive( :[] ).with( :description ).
+				and_return([ 'Racoon City', 'St-Michael Clock Tower' ])
+
+			@obj.should have_description()
+		end
+
+		it "provides a predicate that tests false for valid non-singular attributes that don't " +
+		   "have at least one value" do
+			attrtype = stub( "Treequel attributeType object", :name => :l, :single? => false )
+
+			@obj.should_receive( :valid_attribute_type ).with( :locality_name ).and_return( attrtype )
+			@obj.should_receive( :[] ).with( :l ).
+				and_return([])
+
+			@obj.should_not have_locality_name()
+		end
+
+		it "falls through to the default proxy method for invalid attributes" do
+			@obj.stub!( :valid_attribute_type ).and_return( nil )
+			@entry.should_not_receive( :[] )
+
+			expect {
+				@obj.nonexistant
+			}.to raise_exception( NoMethodError, /undefined method/i )
+		end
+
+		it "adds the objectClass attribute to the attribute list when executing a search that " +
+		   "contains a select" do
+			@directory.stub!( :convert_to_object ).and_return {|oid,str| str }
+			@directory.should_receive( :search ).
+				with( @obj, :scope, :filter, :selectattrs => ['cn', 'objectClass'] )
+			@obj.search( :scope, :filter, :selectattrs => ['cn'] )
+		end
+
+		it "doesn't add the objectClass attribute to the attribute list when the search " +
+		   "doesn't contain a select" do
+			@directory.stub!( :convert_to_object ).and_return {|oid,str| str }
+			@directory.should_receive( :search ).
+				with( @obj, :scope, :filter, :selectattrs => [] )
+			@obj.search( :scope, :filter, :selectattrs => [] )
+		end
+
+		it "knows which attribute methods it responds to" do
+			@directory.stub!( :convert_to_object ).and_return {|oid,str| str }
+			@obj.should respond_to( :cn )
+			@obj.should_not respond_to( :humpsize )
+		end
+
+	end
+
+end
+
+
+# vim: set nosta noet ts=4 sw=4:

data/spec/treequel/monkeypatches_spec.rb

@@ -0,0 +1,118 @@
+#!/usr/bin/env ruby
+
+BEGIN {
+	require 'pathname'
+	basedir = Pathname.new( __FILE__ ).dirname.parent.parent
+
+	libdir = basedir + "lib"
+
+	$LOAD_PATH.unshift( libdir ) unless $LOAD_PATH.include?( libdir )
+}
+
+require 'time'
+
+require 'spec'
+require 'spec/lib/constants'
+require 'spec/lib/helpers'
+
+require 'treequel'
+require 'treequel/utils'
+
+
+include Treequel::TestConstants
+# include Treequel::Constants
+
+#####################################################################
+###	C O N T E X T S
+#####################################################################
+
+describe Treequel::LDAPControlExtensions do
+	describe "equality operator method" do
+
+		it "causes LDAP::Controls with the same class, OID, value, and criticality to " +
+		   "compare as equal" do
+			control1 = LDAP::Control.new( CONTROL_OIDS[:sync], "0\003\n\001\003", true )
+			control2 = LDAP::Control.new( CONTROL_OIDS[:sync], "0\003\n\001\003", true )
+
+			control1.should == control2
+		end
+
+		it "causes LDAP::Controls with different classes to compare as inequal" do
+			control_subclass = Class.new( LDAP::Control )
+			control1 = control_subclass.new( CONTROL_OIDS[:sync], "0\003\n\001\003", true )
+			control2 = LDAP::Control.new( CONTROL_OIDS[:sync], "0\003\n\001\003", true )
+
+			control1.should_not == control2
+		end
+
+		it "causes LDAP::Controls with different OIDs to compare as inequal" do
+			control1 = LDAP::Control.new( CONTROL_OIDS[:sync], "0\003\n\001\003", true )
+			control2 = LDAP::Control.new( CONTROL_OIDS[:incremental_values], "0\003\n\001\003", true )
+
+			control1.should_not == control2
+		end
+
+		it "causes LDAP::Controls with different values to compare as inequal" do
+			control1 = LDAP::Control.new( CONTROL_OIDS[:sync], "0\003\n\001\003", true )
+			control2 = LDAP::Control.new( CONTROL_OIDS[:sync], "0\003\n\001\001", true )
+
+			control1.should_not == control2
+		end
+
+		it "causes LDAP::Controls with different criticality to compare as inequal" do
+			control1 = LDAP::Control.new( CONTROL_OIDS[:sync], "0\003\n\001\003", true )
+			control2 = LDAP::Control.new( CONTROL_OIDS[:sync], "0\003\n\001\003", false )
+
+			control1.should_not == control2
+		end
+
+	end
+end # module Treequel::LDAPControlExtensions
+
+
+describe Treequel::TimeExtensions do
+
+	before( :each ) do
+		@time = Time.parse( "Fri Aug 20 08:21:35.1876455 -0700 2010" )
+	end
+
+	describe "RFC4517 LDAP Generalized Time method" do
+
+		it "returns the time in 'Generalized Time' format" do
+			@time.ldap_generalized.should == "20100820082135-0700"
+		end
+
+		it "can include fractional seconds if the optional fractional digits argument is given" do
+			@time.ldap_generalized( 3 ).should == "20100820082135.187-0700"
+		end
+
+		it "doesn't include the decimal if fractional digits is specified but zero" do
+			@time.ldap_generalized( 0 ).should == "20100820082135-0700"
+		end
+
+		it "zero-fills any digits after six in the fractional digits" do
+			@time.ldap_generalized( 11 ).should == "20100820082135.18764500000-0700"
+		end
+
+		it "uses 'Z' for the timezone of times in UTC" do
+			@time.utc.ldap_generalized.should == "20100820152135Z"
+		end
+
+	end
+
+	describe "RFC4517 UTC Time method" do
+
+		it "returns the time in 'UTC Time' format" do
+			@time.ldap_utc.should == "100820082135-0700"
+		end
+
+		it "uses 'Z' for the timezone of times in UTC" do
+			@time.utc.ldap_utc.should == "100820152135Z"
+		end
+
+	end
+
+end
+
+
+# vim: set nosta noet ts=4 sw=4:

data/spec/treequel/schema/attributetype_spec.rb

@@ -6,6 +6,7 @@ BEGIN {
 
 	libdir = basedir + "lib"
 
+	$LOAD_PATH.unshift( basedir ) unless $LOAD_PATH.include?( basedir )
 	$LOAD_PATH.unshift( libdir ) unless $LOAD_PATH.include?( libdir )
 }
 
@@ -105,7 +106,29 @@ describe Treequel::Schema::AttributeType do
 			@attrtype.syntax.should == :the_syntax
 		end
 
+		it "can remake its own schema description" do
+			@attrtype.to_s.sub( /USAGE \w+\s*/i, '' ).should == OBJECTCLASS_ATTRTYPE
+		end
+
+		it "knows that it's a user application attribute type" do
+			@attrtype.should be_user()
+		end
+
+		it "knows that it's not an operational attribute type" do
+			@attrtype.should_not be_operational()
+		end
+
+		it "knows that it's not a directory operational attribute type" do
+			@attrtype.should_not be_directory_operational()
+		end
+
+		it "knows that it's not a distributed attribute type" do
+			@attrtype.should_not be_distributed_operational()
+		end
 
+		it "knows that it's not a DSA attribute type" do
+			@attrtype.should_not be_dsa_operational()
+		end
 	end
 
 
@@ -233,6 +256,99 @@ describe Treequel::Schema::AttributeType do
 
 	end
 
+	describe "parsed from an attributeType that has the 'directoryOperation' USAGE attribute" do
+
+		DIRECTORY_OPERATIONAL_ATTRIBUTETYPE = %{( 1.1.1.1 USAGE directoryOperation )}
+
+		before( :each ) do
+			@attrtype = Treequel::Schema::AttributeType.
+				parse( @schema, DIRECTORY_OPERATIONAL_ATTRIBUTETYPE )
+		end
+
+		it "knows that it's not a user-application attribute type" do
+			@attrtype.should_not be_user()
+		end
+
+		it "knows that it's an operational attribute type" do
+			@attrtype.should be_operational()
+		end
+
+		it "knows that it's a directory operational attribute type" do
+			@attrtype.should be_directory_operational()
+		end
+
+		it "knows that it's NOT a distributed operational attribute type" do
+			@attrtype.should_not be_distributed_operational()
+		end
+
+		it "knows that it's NOT a DSA-specific operational attribute type" do
+			@attrtype.should_not be_dsa_operational()
+		end
+
+	end
+
+	describe "parsed from an attributeType that has the 'distributedOperation' USAGE attribute" do
+
+		DISTRIBUTED_OPERATIONAL_ATTRIBUTETYPE = %{( 1.1.1.1 USAGE distributedOperation )}
+
+		before( :each ) do
+			@attrtype = Treequel::Schema::AttributeType.
+				parse( @schema, DISTRIBUTED_OPERATIONAL_ATTRIBUTETYPE )
+		end
+
+		it "knows that it's not a user-application attribute type" do
+			@attrtype.should_not be_user()
+		end
+
+		it "knows that it's an operational attribute type" do
+			@attrtype.should be_operational()
+		end
+
+		it "knows that it's NOT a directory operational attribute type" do
+			@attrtype.should_not be_directory_operational()
+		end
+
+		it "knows that it's a distributed operational attribute type" do
+			@attrtype.should be_distributed_operational()
+		end
+
+		it "knows that it's NOT a DSA-specific operational attribute type" do
+			@attrtype.should_not be_dsa_operational()
+		end
+
+	end
+
+	describe "parsed from an attributeType that has the 'dSAOperation' USAGE attribute" do
+
+		DSASPECIFIC_OPERATIONAL_ATTRIBUTETYPE = %{( 1.1.1.1 USAGE dSAOperation )}
+
+		before( :each ) do
+			@attrtype = Treequel::Schema::AttributeType.
+				parse( @schema, DSASPECIFIC_OPERATIONAL_ATTRIBUTETYPE )
+		end
+
+		it "knows that it's not a user-application attribute type" do
+			@attrtype.should_not be_user()
+		end
+
+		it "knows that it's an operational attribute type" do
+			@attrtype.should be_operational()
+		end
+
+		it "knows that it's NOT a directory operational attribute type" do
+			@attrtype.should_not be_directory_operational()
+		end
+
+		it "knows that it's NOT a distributed operational attribute type" do
+			@attrtype.should_not be_distributed_operational()
+		end
+
+		it "knows that it's a DSA-specific operational attribute type" do
+			@attrtype.should be_dsa_operational()
+		end
+
+	end
+
 end