activefacts-api 1.8.1 → 1.8.3

data/spec/fact_type/role_values_spec.rb

@@ -1,439 +0,0 @@
-#
-# ActiveFacts tests: Value instances in the Runtime API
-# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
-#
-
-VALUE_TYPES = Int, Real, AutoCounter, String, Date, DateTime, Decimal, Guid
-RAW_VALUES = [2, 3.0, 4, "5", Date.new(2008, 04, 20), DateTime.new(2008, 04, 20, 10, 28, 14), '43210.98765', '01234567-89ab-cdef-0123-456789abcdef']
-ALT_VALUES = [3, 4.0, 5, "6", Date.new(2009, 04, 20), DateTime.new(2009, 04, 20, 10, 28, 14), '56789.01234', 'fedcba987654-3210-fedc-ba98-76543210']
-VALUE_SUB_FOR_VALUE = {}
-VALUES_FOR_TYPE = VALUE_TYPES.zip(RAW_VALUES, ALT_VALUES).inject({}) do |h, (vt, v1, v2)|
-    next h unless v1 and v2
-    h[vt] = [v1, v2]
-    h
-  end
-VALUE_TYPE_FOR_OBJECT_TYPE = {}
-OBJECT_TYPES = []
-
-module TestValueTypesModule
-  class ESCID < AutoCounter
-    value_type
-  end
-  BASE_VALUE_TYPE_ROLE_NAMES = VALUE_TYPES.map { |base_type| base_type.name.snakecase }
-  VALUE_TYPE_ROLE_NAMES = BASE_VALUE_TYPE_ROLE_NAMES.map { |n| [ :"#{n}_val", :"#{n}_sub_val" ] }.flatten
-
-  TestValueTypesModule.module_eval <<-END
-    class Extra < String
-      value_type
-    end
-  END
-
-  VALUE_TYPES.each do |value_type|
-    code = <<-END
-      class #{value_type.name}Val < #{value_type.name}
-        value_type
-	has_one :extra
-      end
-
-      class #{value_type.name}ValSub < #{value_type.name}Val
-        # Note no new "value_type" is required here, it comes through inheritance
-      end
-
-      class #{value_type.name}Entity
-        identified_by :#{identifying_role_name = "id_#{value_type.name.snakecase}_val"}
-        one_to_one :#{identifying_role_name}, :class => #{value_type.name}Val
-	has_one :extra
-      end
-
-      class #{value_type.name}EntitySub < #{value_type.name}Entity
-      end
-
-      class #{value_type.name}EntitySubCtr < #{value_type.name}Entity
-        identified_by :counter
-        one_to_one :counter, :class => "ESCID"
-      end
-
-      VALUE_SUB_FOR_VALUE[#{value_type.name}Val] = #{value_type.name}ValSub
-      classes = [
-          #{value_type.name}Val,
-          #{value_type.name}ValSub,
-          #{value_type.name}Entity,
-          #{value_type.name}EntitySub,
-          #{value_type.name}EntitySubCtr,
-        ]
-      OBJECT_TYPES.concat(classes)
-      classes.each { |klass| VALUE_TYPE_FOR_OBJECT_TYPE[klass] = value_type }
-    END
-    TestValueTypesModule.module_eval code
-  end
-  OBJECT_TYPE_NAMES = OBJECT_TYPES.map{|object_type| object_type.basename}
-
-  class Octopus
-    identified_by :zero
-    one_to_one :zero, :class => IntVal
-    maybe :has_a_unary
-    OBJECT_TYPE_NAMES.each do |object_type_name|
-      has_one object_type_name.snakecase.to_sym
-      one_to_one ("one_"+object_type_name.snakecase).to_sym, :class => object_type_name
-    end
-  end
-end
-
-describe "Roles of an Object Type" do
-
-  it "should return a roles collection" do
-    roles = TestValueTypesModule::Octopus.all_role
-    roles.should_not be_nil
-    roles.size.should == 2+VALUE_TYPES.size*5*2
-
-    # Quick check of role metadata:
-    roles.each do |role_name, role|
-      role.object_type.modspace.should == TestValueTypesModule
-      if !role.counterpart
-        role.should be_unary
-      else
-        role.counterpart.object_type.modspace.should == TestValueTypesModule
-      end
-    end
-  end
-end
-
-describe "Object type role values" do
-  def object_identifying_parameters object_type_name, value
-    if object_type_name =~ /^(.*)EntitySubCtr$/
-      [{ :"id_#{$1.snakecase}_val" => value, :counter => :new}]
-    else
-      [value]
-    end
-  end
-
-=begin
-  describe "Instantiating bare objects" do
-    OBJECT_TYPES.each do |object_type|
-      required_value_type = VALUE_TYPE_FOR_OBJECT_TYPE[object_type]
-      object_type_name = object_type.basename
-      values = VALUES_FOR_TYPE[required_value_type]
-      next unless values
-
-      it "should allow instantiation of a bare #{object_type_name}" do
-        object_identifying_parameters =
-          if object_type_name =~ /^(.*)EntitySubCtr$/
-            [{ :"id_#{$1.snakecase}_val" => values[0], :counter => :new}]
-          else
-            [values[0]]
-          end
-        object = object_type.new(*object_identifying_parameters)
-        object.class.should == object_type
-        object.constellation.should be_nil
-      end
-    end
-  end
-=end
-
-  describe "A constellation" do
-    before :each do
-      @constellation = ActiveFacts::API::Constellation.new(TestValueTypesModule)
-    end
-
-    OBJECT_TYPES.each do |object_type|
-      required_value_type = VALUE_TYPE_FOR_OBJECT_TYPE[object_type]
-      object_type_name = object_type.basename
-      values = VALUES_FOR_TYPE[required_value_type]
-
-      it "should return an initially empty instance index collection for #{object_type_name}" do
-        @constellation.send(object_type_name).should be_empty
-      end
-
-      next unless values
-
-      it "should allow assertion of an #{object_type_name} instance using #{values[0].inspect}" do
-        # REVISIT: Assertion of a subtype having the same identifier as a supertype is... dodgey.
-        # What should it do? Migrate the previous object to its subtype?
-        object = @constellation.send(object_type_name, *object_identifying_parameters(object_type_name, values[0]))
-
-        # Make sure we got what we expected:
-        object.class.should == object_type
-
-        # Make sure the instance index contains this single object:
-        instances = @constellation.send(object_type_name)
-        instances.size.should == 1
-        instances.map{|k,o| o}.first.should == object
-        unless object.class.is_entity_type
-          # Look up value types using the value instance, not just the raw value:
-          instances[object.identifying_role_values].should == object
-        end
-
-        # Make sure all the identifying roles are populated correctly:
-        if object_type.respond_to?(:identifying_roles)
-          object.class.identifying_roles.each do |identifying_role|
-            identifying_value = object.send(identifying_role.name)
-            identifying_value.should_not be_nil
-
-            counterpart_object_type = identifying_role.counterpart.object_type
-            role_superclasses = [ counterpart_object_type.superclass, counterpart_object_type.superclass.superclass ]
-            # Autocounter values do not compare to Integers:
-            unless role_superclasses.include?(AutoCounter) or identifying_role.object_type.basename =~ /Entity/
-              identifying_value.should == identifying_role.object_type.new(*values[0])
-            end
-          end
-        end
-      end
-
-      if object_type.is_entity_type
-        it "should allow re-assigning a #{object_type_name} entity's identifying role value from #{values[0]} to #{values[1]}" do
-          object = @constellation.send(object_type_name, *object_identifying_parameters(object_type_name, values[0]))
-          object.class.identifying_roles.each do |identifying_role|
-            next if identifying_role.name == :counter
-            lambda {
-              object.send(:"#{identifying_role.name}=", values[1])
-            }.should_not raise_error
-          end
-        end
-
-        it "should allow nullifying and reassigning a #{object_type_name} entity's identifying role value" do
-          object = @constellation.send(object_type_name, *object_identifying_parameters(object_type_name, values[0]))
-          object.class.identifying_roles.each do |identifying_role|
-            next if [:counter, :id_guid_val].include?(identifying_role.name)
-            assigned = object.send(:"#{identifying_role.name}=", nil)
-            assigned.should be_nil
-            object.send(:"#{identifying_role.name}=", values[1])
-          end
-        end
-      else
-        it "should allow initialising value type #{object_type.name} with an instance of that value type" do
-	  params = object_identifying_parameters(object_type_name, values[0])
-	  if object_type.respond_to?(:civil)
-	    # Handle Date/Time specially:
-	    bare_value = object_type.civil(params[0].year)
-	  else
-	    bare_value = object_type.new(*params)
-	  end
-          object = @constellation.send(object_type_name, bare_value)
-	  # Here, the bare_value is not the same object which has been added to the constellatiom
-
-          # Now link the bare value to an Octopus:
-          octopus = @constellation.Octopus(0)
-          octopus_role_name = :"octopus_as_one_#{object_type_name.snakecase}"
-          object.send(:"#{octopus_role_name}=", octopus)
-          counterpart_name = object.class.all_role[octopus_role_name].counterpart.name
-
-          # Create a reference by assigning the object from a RoleProxy:
-          proxy = octopus.send(counterpart_name)
-
-          #proxy.should be_respond_to(:__getobj__)
-	  object2 = @constellation.send(object_type_name, proxy)
-          object2.should == object
-        end
-
-	it "should allow adding extra role assignments when asserting an instance" do
-          object = @constellation.send(object_type_name, *(object_identifying_parameters(object_type_name, values[0]) + [{:extra => 'foo'}]))
-	  object.extra.should == 'foo'
-	end
-
-      end
-    end
-
-  end
-
-  describe "Role values" do
-    before :each do
-      @constellation = ActiveFacts::API::Constellation.new(TestValueTypesModule)
-      @object = @constellation.Octopus(0)
-      @roles = @object.class.all_role
-    end
-
-    it "should return its constellation and vocabulary" do
-      # Strictly, these are not role value tests
-      @object.constellation.should == @constellation
-      @object.constellation.vocabulary.should == TestValueTypesModule
-      @object.class.vocabulary.should == TestValueTypesModule
-    end
-
-    TestValueTypesModule::Octopus.all_role.each do |role_name, role|
-      next if role_name == :zero
-
-      it "should respond to getting its #{role_name} role" do
-        @object.should be_respond_to role.name
-      end
-
-      it "should respond to setting its #{role_name} role" do
-        @object.should be_respond_to :"#{role.name}="
-      end
-
-      if role.unary?
-        it "should allow its #{role_name} unary role to be assigned and reassigned" do
-          @object.has_a_unary.should be_nil
-          @object.has_a_unary = true
-          @object.has_a_unary.should == true
-          @object.has_a_unary = 23
-          @object.has_a_unary.should == true
-          @object.has_a_unary = false
-          @object.has_a_unary.should be false
-          @object.has_a_unary = nil
-          @object.has_a_unary.should be_nil
-        end
-      else
-        it "should allow its #{role_name} role to be assigned and reassigned a base value" do
-          object_type = role.counterpart.object_type
-          required_value_type = VALUE_TYPE_FOR_OBJECT_TYPE[object_type]
-          values = VALUES_FOR_TYPE[required_value_type]
-          next unless values
-          value = object_identifying_parameters(object_type.basename, values[0])
-
-          # Set the role to the first value:
-          assigned = @object.send(:"#{role_name}=", value)
-          assigned.class.should == object_type
-          fetched = @object.send(role_name)
-          fetched.should == assigned
-
-          if role.counterpart.unique      # A one-to-one
-            # The counterpart should point back at us
-            assigned.send(role.counterpart.name).should == @object
-          else                                            # A many-to-one
-            # The counterpart should include us in its RoleValues
-            reflection = assigned.send(role.counterpart.name)
-            reflection.should_not be_empty
-            reflection.size.should == 1
-            reflection.should include @object
-          end
-
-          # Update the role to the second value:
-          value = object_identifying_parameters(object_type.basename, values[1])
-          assigned2 = @object.send(:"#{role_name}=", value)
-          assigned2.class.should == object_type
-          fetched = @object.send(role_name)
-          fetched.should == assigned2
-
-          if role.counterpart.unique                      # A one-to-one
-            # REVISIT: The old counterpart role should be nullified
-            #assigned.send(role.counterpart.name).should be_nil
-
-            # The counterpart should point back at us
-            assigned2.send(role.counterpart.name).should == @object
-          else                                            # A many-to-one
-            # REVISIT: The old counterpart RoleValues should be empty
-            reflection = assigned2.send(role.counterpart.name)
-            #reflection.size.should == 0
-
-            # The counterpart should include us in its RoleValues
-            reflection2 = assigned2.send(role.counterpart.name)
-            reflection2.size.should == 1
-            reflection2.should include @object
-          end
-
-          # Nullify the role
-          nullified = @object.send(:"#{role_name}=", nil)
-          nullified.should be_nil
-          if role.counterpart.unique                      # A one-to-one
-            assigned2.send(role.counterpart.name).should be_nil
-          else                                            # A many-to-one
-            reflection3 = assigned2.send(role.counterpart.name)
-            reflection3.size.should == 0
-          end
-        end
-
-        it "should allow its #{role_name} role to be assigned and reassigned a base value" do
-          object_type = role.counterpart.object_type
-          required_value_type = VALUE_TYPE_FOR_OBJECT_TYPE[object_type]
-          values = VALUES_FOR_TYPE[required_value_type]
-          next unless values
-          value = object_identifying_parameters(object_type.basename, values[0])
-
-          # Set the role to the first value:
-          assigned = @object.send(:"#{role_name}=", value)
-          fetched = @object.send(role_name)
-          fetched.class.should == object_type
-        end
-
-        it "should allow its #{role_name} role to be assigned a value instance" do
-          object_type = role.counterpart.object_type
-          required_value_type = VALUE_TYPE_FOR_OBJECT_TYPE[object_type]
-          values = VALUES_FOR_TYPE[required_value_type]
-          next unless values
-          value = @constellation.send(object_type.basename, *object_identifying_parameters(object_type.basename, values[0]))
-
-          assigned = @object.send(:"#{role_name}=", value)
-          assigned.class.should == object_type
-          fetched = @object.send(role_name)
-          fetched.should == assigned
-
-          # Nullify the role
-          nullified = @object.send(:"#{role_name}=", nil)
-          nullified.should be_nil
-        end
-
-        it "should allow its #{role_name} role to be assigned a value subtype instance, retaining the subtype" do
-          object_type = role.counterpart.object_type
-          required_value_type = VALUE_TYPE_FOR_OBJECT_TYPE[object_type] # The raw value type
-          values = VALUES_FOR_TYPE[required_value_type]
-          object_type = VALUE_SUB_FOR_VALUE[object_type]  # The value type subtype
-          next unless values and object_type
-          value = @constellation.send(object_type.basename, *object_identifying_parameters(object_type.basename, values[0]))
-          assigned = @object.send(:"#{role_name}=", value)
-          # This requires the declared type, not the subtype:
-          # assigned.class.should == role.counterpart.object_type
-          # This requires the subtype, as the test implies:
-          assigned.class.should == object_type
-          fetched = @object.send(role_name)
-          fetched.should == assigned
-        end
-      end
-
-      unless !role.counterpart or         # A unary
-          role.counterpart.unique or      # A one-to-one
-          VALUES_FOR_TYPE[VALUE_TYPE_FOR_OBJECT_TYPE[role.counterpart.object_type]] == nil
-        describe "Operations on #{role.counterpart.object_type.basename} RoleValues collections" do
-          before :each do
-            object_type = role.counterpart.object_type
-            required_value_type = VALUE_TYPE_FOR_OBJECT_TYPE[object_type]
-            values = VALUES_FOR_TYPE[required_value_type]
-            return unless values
-            value = object_identifying_parameters(object_type.basename, values[0])
-            assigned = @object.send(:"#{role_name}=", value)
-            @role_values = assigned.send(role.counterpart.name)
-          end
-
-          it "should support Array addition" do
-            added = @role_values + ["foo"]
-            added.class.should == Array
-            added.size.should == 2
-          end
-
-          it "should support Array subtraction" do
-            # We only added one value, so subtracting it leaves us empty
-            counterpart_value = @role_values.single
-            (@role_values - [counterpart_value]).should be_empty
-          end
-
-          it "should support each" do
-            count = 0
-            @role_values.each do |v, *a|
-              a.size.should == 0
-              v.should_not be_nil
-              count += 1
-            end
-            count.should == 1
-          end
-
-          it "should support detect" do
-            count = 0
-            @role_values.detect do |v, *a|
-              a.size.should == 0
-              v.should_not be_nil
-              count += 1
-              false
-            end
-            count.should == 1
-          end
-
-          it "should verbalise" do
-            @role_values.verbalise.should =~ /Octopus.*Zero '0'/
-          end
-
-        end
-      end
-
-    end
-
-  end
-end

data/spec/fact_type/roles_spec.rb

@@ -1,283 +0,0 @@
-#
-# ActiveFacts tests: Roles of object_type classes in the Runtime API
-# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
-#
-
-describe "Roles" do
-  before :each do
-    Object.send :remove_const, :Mod if Object.const_defined?("Mod")
-    module Mod
-      class Name < String
-        value_type :length => 40, :scale => 0, :restrict => /^[A-Z][a-z0-9]*/
-      end
-      class Identifier
-        identified_by :name
-        one_to_one :name
-      end
-      class LegalEntity
-        identified_by :name
-        one_to_one :name
-      end
-      class Contract
-        identified_by :first, :second
-        has_one :first, :class => LegalEntity
-        has_one :second, :class => LegalEntity
-      end
-      class Person < LegalEntity
-        # identified_by         # No identifier needed, inherit from superclass
-        # New identifier:
-        identified_by :family, :name
-        has_one :family, :class => Name
-        alias :given :name
-        alias :given= :name=
-        has_one :related_to, :class => LegalEntity
-      end
-      class Employee
-        identified_by :name
-        one_to_one :identifier
-        one_to_one :name
-      end
-    end
-    # print "object_type: "; p Mod.object_type
-  end
-
-  it "should associate a role name with a matching existing object_type" do
-    module Mod
-      class Existing1 < String
-        value_type
-        has_one :name
-      end
-    end
-    role = Mod::Existing1.all_role(:name)
-    role.should_not be_nil
-    role.inspect.class.should == String
-    role.counterpart.object_type.should == Mod::Name
-  end
-
-  it "should prevent association of a role name with an object_type from the wrong module" do
-    lambda {
-      module Mod2
-        class Unrelated
-        end
-      end
-
-      module Mod
-        class Existing1 < String
-          value_type
-          has_one :unrelated, :class => Mod2::Unrelated
-        end
-      end
-    }.should raise_error(ActiveFacts::API::CrossVocabularyRoleException)
-  end
-
-  it "should prevent association of a role name with a non-object_type" do
-    lambda {
-      module Mod
-        class NonObject
-        end
-        class Existing1 < String
-          value_type
-          has_one :non_object, :class => NonObject
-        end
-      end
-    }.should raise_error(ActiveFacts::API::CrossVocabularyRoleException)
-  end
-
-  it "should prevent association of a role name with an implied non-object_type" do
-    lambda {
-      module Mod
-        class NonObject
-        end
-        class Existing1 < String
-          value_type
-          has_one :non_object
-        end
-      end
-    }.should raise_error(ActiveFacts::API::CrossVocabularyRoleException)
-  end
-
-  it "should prevent usage of undefined options on a role" do
-    lambda {
-      module Mod
-        class Existing1 < String
-          value_type
-          has_one :name, :foo => :anything
-        end
-      end
-    }.should raise_error(ActiveFacts::API::UnrecognisedOptionsException)
-
-    lambda {
-      module Mod
-        class Existing1 < String
-          value_type
-          one_to_one :name, :foo => :anything
-        end
-      end
-    }.should raise_error(ActiveFacts::API::UnrecognisedOptionsException)
-
-    lambda {
-      module Mod
-        class Existing1 < String
-          value_type
-          maybe :is_broken, :foo => :anything
-        end
-      end
-    }.should raise_error(ActiveFacts::API::UnrecognisedOptionsException)
-  end
-
-  it "should provide value type metadata" do
-    Mod::Name.length.should == 40
-    Mod::Name.scale.should == 0
-  end
-
-  it "should inject the respective role name into the matching object_type" do
-    module Mod
-      class Existing1 < String
-        value_type
-        has_one :name
-      end
-    end
-    # REVISIT: need to make more tests for the class's role accessor methods:
-    Mod::Name.all_role(:all_existing1).should == Mod::Name.all_existing1_role
-
-    Mod::Name.all_role(:all_existing1).should_not be_nil
-    Mod::LegalEntity.all_role(:all_contract_as_first).should_not be_nil
-  end
-
-  it "should associate a role name with a matching object_type after it's created" do
-    module Mod
-      class Existing2 < String
-        value_type
-        has_one :given_name
-      end
-    end
-    # print "Mod::Existing2.all_role = "; p Mod::Existing2.all_role
-    r = Mod::Existing2.all_role(:given_name)
-    r.should_not be_nil
-    r.counterpart.should be_nil
-    module Mod
-      class GivenName < String
-        value_type
-      end
-    end
-    # puts "Should resolve now:"
-    r = Mod::Existing2.all_role(:given_name)
-    r.should_not be_nil
-    r.counterpart.object_type.should == Mod::GivenName
-  end
-
-  it "should handle subtyping a value type" do
-    module Mod
-      class FamilyName < Name
-        value_type
-        one_to_one :patriarch, :class => Person
-      end
-    end
-    r = Mod::FamilyName.all_role(:patriarch)
-    r.should_not be_nil
-    r.counterpart.object_type.should == Mod::Person
-    r.counterpart.object_type.all_role(:family_name_as_patriarch).counterpart.object_type.should == Mod::FamilyName
-  end
-
-  it "should instantiate the matching object_type on assignment" do
-    c = ActiveFacts::API::Constellation.new(Mod)
-    bloggs = c.LegalEntity("Bloggs")
-    acme = c.LegalEntity("Acme, Inc")
-    contract = c.Contract("Bloggs", acme)
-    #contract = c.Contract("Bloggs", "Acme, Inc")
-    contract.first.should == bloggs
-    contract.second.should == acme
-    end
-
-  it "should append the counterpart into the respective role array in the matching object_type" do
-    c = ActiveFacts::API::Constellation.new(Mod)
-    foo = c.Name("Foo")
-    le = c.LegalEntity(foo)
-    le.respond_to?(:name).should be true
-    name = le.name
-    name.respond_to?(:legal_entity).should be true
-
-    #pending
-    [name.legal_entity].should === [le]
-  end
-
-  it "should instantiate subclasses sensibly" do
-    c = ActiveFacts::API::Constellation.new(Mod)
-    bloggs = c.LegalEntity("Bloggs & Co")
-    p = c.Person("Fred", "Bloggs")
-    p.related_to = "Bloggs & Co"
-    p.related_to.should be_an_instance_of Mod::LegalEntity
-    p.related_to.should == bloggs
-
-    # REVISIT: The raw instance doesn't override == to compare itself to a RoleProxy unfortunately...
-    # So this test succeeds when we'd like it to fail
-    #bloggs.should_not == p.related_to
-  end
-
-  it "should forward missing methods on the role proxies" do
-   c = ActiveFacts::API::Constellation.new(Mod)
-   p = c.Person("Fred", "Bloggs")
-   lambda {p.family.foo}.should raise_error(NoMethodError)
-  end
-
-  it "should forward re-raise exceptions from missing methods on the role proxies" do
-    c = ActiveFacts::API::Constellation.new(Mod)
-    p = c.Person("Fred", "Bloggs")
-    class String
-      def foo
-        raise "Yawning"
-      end
-    end
-
-    lambda {p.family.foo}.should raise_error(RuntimeError)
-  end
-
-  it "should be able to import an entity from another constellation" do
-    c1 = ActiveFacts::API::Constellation.new(Mod)
-    c2 = ActiveFacts::API::Constellation.new(Mod)
-
-    e = c1.Employee("PuppetMaster")
-    identifier = c2.Identifier "Project2501", :employee => e
-    identifier.employee.name.should == "PuppetMaster"
-  end
-
-  it "should create TypeInheritance fact type and roles" do
-    module Mod
-      class GivenName < Name
-      end
-      class Document
-	identified_by :name
-	one_to_one :name
-      end
-      class Contract
-	supertypes Document
-      end
-    end
-    [Mod::GivenName, Mod::Person, Mod::Contract].each do |subtype|
-      subtype.supertypes.each do |supertype|
-	# Get the role names:
-	supertype_role_name = supertype.name.gsub(/.*::/,'').to_sym
-	subtype_role_name = subtype.name.gsub(/.*::/,'').to_sym
-
-	# Check that the roles are indexed:
-	subtype.all_role.should include(supertype_role_name)
-	supertype.all_role.should include(subtype_role_name)
-
-	# Get the role objects:
-	supertype_role = subtype.all_role[supertype_role_name]
-	subtype_role = supertype.all_role[subtype_role_name]
-
-	# Check uniqueness and mandatory:
-	supertype_role.unique.should be true
-	subtype_role.unique.should be true
-	supertype_role.mandatory.should be true
-	subtype_role.mandatory.should be false
-
-	# Check they belong to the same TypeInheritanceFactType:
-	subtype_role.fact_type.class.should be(ActiveFacts::API::TypeInheritanceFactType)
-	subtype_role.fact_type.should == supertype_role.fact_type
-      end
-    end
-  end
-
-end