activefacts-api 0.8.9

data/lib/activefacts/api/vocabulary.rb

@@ -0,0 +1,82 @@
+#
+#       ActiveFacts Runtime API
+#       Vocabulary module (mixin for any Module that contains classes having ObjectType mixed in)
+#
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+# The methods of this module are extended into any module that contains
+# a ObjectType class (Entity type or Value type).
+#
+module ActiveFacts
+  module API
+    # Vocabulary is a mixin that adds methods to any Module which has any ObjectType classes (ValueType or EntityType).
+    # A Vocabulary knows all the ObjectType classes including forward-referenced ones,
+    # and can resolve the forward references when the class is finally defined.
+    # Construction of a Constellation requires a Vocabuary as argument.
+    module Vocabulary
+      # With a parameter, look up a object_type class by name.
+      # Without, return the hash (keyed by the class' basename) of all object_types in this vocabulary
+      def object_type(name = nil)
+        @object_type ||= {}
+        return @object_type unless name
+
+        return name if name.is_a? Class
+
+        # puts "Looking up object_type #{name} in #{self.name}"
+        camel = name.to_s.camelcase
+        if (c = @object_type[camel])
+          __bind(camel)
+          return c
+        end
+        return (const_get("#{name}::#{camel}") rescue nil)
+      end
+
+      # Create a new constellation over this vocabulary
+      def constellation
+        Constellation.new(self)
+      end
+
+      def populate &b
+        constellation.populate &b
+      end
+
+      def verbalise
+        "Vocabulary #{name}:\n\t" +
+          @object_type.keys.sort.map{|object_type|
+              c = @object_type[object_type]
+              __bind(c.basename)
+              c.verbalise + "\n\t\t// Roles played: " + c.roles.verbalise
+            }*"\n\t"
+      end
+
+      def __add_object_type(klass)  #:nodoc:
+        name = klass.basename
+        __bind(name)
+        # puts "Adding object_type #{name} to #{self.name}"
+        @object_type ||= {}
+        @object_type[klass.basename] = klass
+      end
+
+      def __delay(object_type_name, args, &block) #:nodoc:
+        # puts "Arranging for delayed binding on #{object_type_name.inspect}"
+        @delayed ||= Hash.new { |h,k| h[k] = [] }
+        @delayed[object_type_name] << [args, block]
+      end
+
+      # __bind raises an error if the named class doesn't exist yet.
+      def __bind(object_type_name)  #:nodoc:
+        object_type = const_get(object_type_name)
+        # puts "#{name}.__bind #{object_type_name} -> #{object_type.name}" if object_type
+        if (@delayed && @delayed.include?(object_type_name))
+          # $stderr.puts "#{object_type_name} was delayed, binding now"
+          d = @delayed[object_type_name]
+          d.each{|(a,b)|
+              b.call(object_type, *a)
+            }
+          @delayed.delete(object_type_name)
+        end
+      end
+
+    end
+  end
+end

data/spec/api/autocounter_spec.rb

@@ -0,0 +1,84 @@
+#
+# ActiveFacts tests: Value instances in the Runtime API
+# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
+#
+require 'activefacts/api'
+
+describe "AutoCounter Value Type instances" do
+  before :each do
+    Object.send :remove_const, :Mod if Object.const_defined?("Mod")
+    module Mod
+      class ThingId < AutoCounter
+        value_type
+      end
+      class Thing
+        identified_by :thing_id
+        has_one :thing_id
+      end
+      class Ordinal < Int
+        value_type
+      end
+      class ThingFacet
+        identified_by :thing, :ordinal
+        has_one :thing
+        has_one :ordinal
+      end
+    end
+    @constellation = ActiveFacts::API::Constellation.new(Mod)
+    @thing = Mod::Thing.new(:new)
+    @thing_id = Mod::ThingId.new
+  end
+
+  it "should respond to verbalise" do
+    @thing_id.respond_to?(:verbalise).should be_true
+  end
+
+  it "should verbalise correctly" do
+    @thing_id.verbalise.should =~ /ThingId 'new_[0-9]+'/
+  end
+
+  it "should respond to constellation" do
+    @thing_id.respond_to?(:constellation).should be_true
+  end
+
+  it "should respond to its roles" do
+    @thing_id.respond_to?(:all_thing).should be_true
+  end
+
+  it "should allow prevent invalid role assignment" do
+    lambda {
+        @thing.thing_id = "foo"
+      }.should raise_error
+  end
+
+  it "should not allow its identifying roles to be assigned" do
+    lambda {
+        @thing.thing_id = @thing_id
+      }.should raise_error
+  end
+
+  it "should allow an existing counter to be re-used" do
+    @new_thing = Mod::Thing.new(@thing_id)
+    @new_thing.thing_id.should == @thing_id
+  end
+
+  it "should return the ValueType in response to .class()" do
+    @thing_id.class.vocabulary.should == Mod
+  end
+
+  it "should not allow a counter to be cloned" do
+    lambda {
+      @thing_id.clone
+    }.should raise_error
+  end
+
+  it "should allow an existing counter-identified object to be re-used" do
+    thing = @constellation.Thing(:new)
+    facets = []
+    facets << @constellation.ThingFacet(thing, 0)
+    facets << @constellation.ThingFacet(thing, 1)
+    facets[0].thing.object_id.should == facets[1].thing.object_id
+    facets[0].thing.thing_id.object_id.should == facets[1].thing.thing_id.object_id
+  end
+
+end

data/spec/api/constellation_spec.rb

@@ -0,0 +1,129 @@
+#
+# ActiveFacts tests: Constellation instances in the Runtime API
+# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
+#
+
+require 'activefacts/api'
+
+describe "A Constellation instance" do
+  before :each do
+    Object.send :remove_const, :Mod if Object.const_defined?("Mod")
+    module Mod
+      @base_types = [
+          Int, Real, AutoCounter, String, Date, DateTime
+        ]
+
+      # Create a value type and a subtype of that value type for each base type:
+      @base_types.each do |base_type|
+        eval %Q{
+          class #{base_type.name}Value < #{base_type.name}
+            value_type
+          end
+
+          class #{base_type.name}SubValue < #{base_type.name}Value
+            # Note no new "value_type" is required here, it comes through inheritance
+          end
+        }
+      end
+
+      class Name < StringValue
+        value_type
+        #has_one :attr, Name
+      end
+
+      class LegalEntity
+        identified_by :name
+        has_one :name
+      end
+
+      class SurrogateId
+        identified_by :auto_counter_value
+        has_one :auto_counter_value
+      end
+
+      class Company < LegalEntity
+        supertypes SurrogateId
+      end
+
+      class Person < LegalEntity
+        identified_by :name, :family_name     # REVISIT: want a way to role_alias :name, :given_name
+        supertypes SurrogateId
+
+        has_one :family_name, :class => Name
+      end
+    end
+    @constellation = ActiveFacts::API::Constellation.new(Mod)
+  end
+
+  it "should support fetching its vocabulary" do
+    @constellation.vocabulary.should == Mod
+  end
+
+#  it "should support fetching its query" do
+#    pending
+#    @constellation.query.should == Mod
+#  end
+
+  it "should support methods to construct instances of any object_type" do
+    name = foo = acme = fred_fly = nil
+    lambda {
+        name = @constellation.Name("foo")
+        foo = @constellation.LegalEntity("foo")
+        acme = @constellation.Company("Acme, Inc")
+        fred_fly = @constellation.Person("fred", "fly")
+      }.should_not raise_error
+    name.class.should == Mod::Name
+    name.constellation.should == @constellation
+    foo.class.should == Mod::LegalEntity
+    foo.constellation.should == @constellation
+    acme.class.should == Mod::Company
+    acme.constellation.should == @constellation
+    fred_fly.class.should == Mod::Person
+    fred_fly.constellation.should == @constellation
+  end
+
+  it "should re-use instances constructed the same way" do
+    name1 = @constellation.Name("foo")
+    foo1 = @constellation.LegalEntity("foo")
+    acme1 = @constellation.Company("Acme, Inc")
+    fred_fly1 = @constellation.Person("fred", "fly")
+
+    name2 = @constellation.Name("foo")
+    foo2 = @constellation.LegalEntity("foo")
+    acme2 = @constellation.Company("Acme, Inc")
+    fred_fly2 = @constellation.Person("fred", "fly")
+
+    name1.object_id.should == name2.object_id
+    foo1.object_id.should == foo2.object_id
+    acme1.object_id.should == acme2.object_id
+    fred_fly1.object_id.should == fred_fly2.object_id
+  end
+
+  it "should index value instances, including by its superclasses" do
+    baz = @constellation.Name("baz")
+    @constellation.Name.keys.sort.should == ["baz"]
+
+    @constellation.StringValue.keys.sort.should == ["baz"]
+  end
+
+  it "should index entity instances, including by its superclass and secondary supertypes" do
+    name = "Acme, Inc"
+    fred = "Fred"
+    fly = "Fly"
+    acme = @constellation.Company name, :auto_counter_value => :new
+    fred_fly = @constellation.Person fred, fly, :auto_counter_value => :new
+
+    # REVISIT: This should be illegal:
+    #fred_fly.auto_counter_value = :new
+
+    @constellation.Person.keys.sort.should == [[fred, fly]]
+    @constellation.Company.keys.sort.should == [[name]]
+
+    @constellation.LegalEntity.keys.sort.should be_include([name])
+    @constellation.LegalEntity.keys.sort.should be_include([fred])
+
+    @constellation.SurrogateId.values.should be_include(acme)
+    @constellation.SurrogateId.values.should be_include(fred_fly)
+  end
+
+end

data/spec/api/entity_type_spec.rb

@@ -0,0 +1,103 @@
+#
+# ActiveFacts tests: Entity classes in the Runtime API
+# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
+#
+require 'activefacts/api'
+
+describe "Entity Type class definitions" do
+  before :each do
+    Object.send :remove_const, :Mod if Object.const_defined?("Mod")
+    module Mod
+      class Name < String
+        value_type
+      end
+      class LegalEntity
+      end
+      class Person < LegalEntity
+        identified_by :name
+        has_one :name, :class => Name
+      end
+    end
+  end
+
+  it "should respond_to verbalise" do
+    Mod::Person.respond_to?(:verbalise).should be_true
+  end
+
+  it "should not pollute the superclass" do
+    Mod::LegalEntity.respond_to?(:verbalise).should_not be_true
+    Class.respond_to?(:verbalise).should_not be_true
+  end
+
+  it "should return a string from verbalise" do
+    v = Mod::Person.verbalise
+    v.should_not be_nil
+    v.should_not =~ /REVISIT/
+  end
+
+  it "should respond_to vocabulary" do
+    Mod::Person.respond_to?(:vocabulary).should be_true
+  end
+
+  it "should return the parent module as the vocabulary" do
+    vocabulary = Mod::Person.vocabulary
+    vocabulary.should == Mod
+  end
+
+  it "should return a vocabulary that knows about this object_type" do
+    vocabulary = Mod::Person.vocabulary
+    vocabulary.respond_to?(:object_type).should be_true
+    vocabulary.object_type.has_key?("Person").should be_true
+  end
+
+  it "should respond to roles()" do
+    Mod::Person.respond_to?(:roles).should be_true
+  end
+
+  it "should contain only the added role definition" do
+    Mod::Person.roles.size.should == 1
+  end
+
+  it "should return the role definition" do
+    # Check the role definition may be accessed by passing an index:
+    Mod::Person.roles(0).should be_nil
+
+    role = Mod::Person.roles(:name)
+    role.should_not be_nil
+
+    role = Mod::Person.roles("name")
+    role.should_not be_nil
+
+    # Check the role definition may be accessed by indexing the returned hash:
+    role = Mod::Person.roles[:name]
+    role.should_not be_nil
+
+    # Check the role definition array by .include?
+    Mod::Person.roles.include?(:name).should be_true
+  end
+
+  it "should fail on a ValueClass" do
+    lambda{
+      class SomeClass < String
+        identified_by
+      end
+    }.should raise_error
+  end
+
+  it "should return the identifying roles" do
+    Mod::Person.identifying_role_names.should == [:name]
+  end
+
+  it "should prevent a role name from matching a object_type that exists unless that object_type is the counterpart" do
+    lambda {
+        module Mod
+          class LegalEntity
+          end
+          class Bad
+            identified_by :name
+            has_one :name, LegalEntity
+          end
+        end
+      }.should raise_error
+  end
+end

data/spec/api/instance_spec.rb

@@ -0,0 +1,462 @@
+#
+# ActiveFacts tests: Value instances in the Runtime API
+# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
+#
+require 'activefacts/api'
+
+describe "An instance of every type of ObjectType" do
+  before :each do
+    Object.send :remove_const, :Mod if Object.const_defined?("Mod")
+    module Mod
+      # These are the base value types we're going to test:
+      @base_types = [
+          Int, Real, AutoCounter, String, Date, DateTime, Decimal
+        ]
+
+      # Construct the names of the roles they play:
+      @base_type_roles = @base_types.map do |t|
+        t.name.snakecase
+      end
+      @role_names = @base_type_roles.inject([]) {|a, t|
+          a << :"#{t}_value"
+        } +
+        @base_type_roles.inject([]) {|a, t|
+          a << :"#{t}_sub_value"
+        }
+
+      # Create a value type and a subtype of that value type for each base type:
+      @base_types.each do |base_type|
+        eval %Q{
+          class #{base_type.name}Value < #{base_type.name}
+            value_type
+          end
+
+          class #{base_type.name}SubValue < #{base_type.name}Value
+            # Note no new "value_type" is required here, it comes through inheritance
+          end
+        }
+      end
+
+      # Create a TestByX, TestByXSub, and TestSubByX class for all base types X
+      # Each class has a has_one and a one_to_one for all roles.
+      # and is identified by the has_one :x role
+      @base_types.each do |base_type|
+        code = %Q{
+          class TestBy#{base_type.name}
+            identified_by :#{base_type.name.snakecase}_value#{
+              @role_names.map do |role_name|
+                %Q{
+            has_one :#{role_name}
+            one_to_one :one_#{role_name}, :class => #{role_name.to_s.camelcase}}
+              end*""
+            }
+          end
+
+          class TestBy#{base_type.name}Sub
+            identified_by :#{base_type.name.snakecase}_sub_value#{
+              @role_names.map do |role_name|
+                %Q{
+            has_one :#{role_name}
+            one_to_one :one_#{role_name}, :class => #{role_name.to_s.camelcase}}
+              end*""
+            }
+          end
+
+          class TestSubBy#{base_type.name} < TestBy#{base_type.name}
+            # Entity subtypes, inherit identification and all roles
+          end
+
+          class TestBy#{base_type.name}Entity
+            identified_by :test_by_#{base_type.name.snakecase}
+            one_to_one :test_by_#{base_type.name.snakecase}
+          end}
+          eval code
+      end
+    end
+
+    # Simple Values
+    @int = 0
+    @real = 0.0
+    @auto_counter = 0
+    @new_auto_counter = :new
+    @string = "zero"
+    @date = [2008, 04, 19]
+    @date_time = [2008, 04, 19, 10, 28, 14]
+
+    # Value Type instances
+    @int_value = Mod::IntValue.new(1)
+    @real_value = Mod::RealValue.new(1.0)
+    @auto_counter_value = Mod::AutoCounterValue.new(1)
+    @new_auto_counter_value = Mod::AutoCounterValue.new(:new)
+    @string_value = Mod::StringValue.new("one")
+    @date_value = Mod::DateValue.new(2008, 04, 20)
+    @date_time_value = Mod::DateTimeValue.new(2008, 04, 20, 10, 28, 14)
+
+    # Value SubType instances
+    @int_sub_value = Mod::IntSubValue.new(4)
+    @real_sub_value = Mod::RealSubValue.new(4.0)
+    @auto_counter_sub_value = Mod::AutoCounterSubValue.new(4)
+    @auto_counter_sub_value_new = Mod::AutoCounterSubValue.new(:new)
+    @string_sub_value = Mod::StringSubValue.new("five")
+    @date_sub_value = Mod::DateSubValue.new(2008, 04, 25)
+    @date_time_sub_value = Mod::DateTimeSubValue.new(2008, 04, 26, 10, 28, 14)
+
+    # Entities identified by Value Type, SubType and Entity-by-value-type instances
+    @test_by_int = Mod::TestByInt.new(2)
+    @test_by_real = Mod::TestByReal.new(2.0)
+    @test_by_auto_counter = Mod::TestByAutoCounter.new(2)
+    @test_by_auto_counter_new = Mod::TestByAutoCounter.new(:new)
+    @test_by_string = Mod::TestByString.new("two")
+    @test_by_date = Mod::TestByDate.new(Date.new(2008,04,28))
+    #@test_by_date = Mod::TestByDate.new(2008,04,28)
+    @test_by_date_time = Mod::TestByDateTime.new(2008,04,28,10,28,15)
+    #@test_by_date_time = Mod::TestByDateTime.new(DateTime.new(2008,04,28,10,28,15))
+
+    @test_by_int_sub = Mod::TestByIntSub.new(2)
+    @test_by_real_sub = Mod::TestByRealSub.new(5.0)
+    @test_by_auto_counter_sub = Mod::TestByAutoCounterSub.new(6)
+    @test_by_auto_counter_new_sub = Mod::TestByAutoCounterSub.new(:new)
+    @test_by_string_sub = Mod::TestByStringSub.new("six")
+    @test_by_date_sub = Mod::TestByDateSub.new(Date.new(2008,04,27))
+    @test_by_date_time_sub = Mod::TestByDateTimeSub.new(2008,04,29,10,28,15)
+
+    @test_by_int_entity = Mod::TestByIntEntity.new(@test_by_int)
+    @test_by_real_entity = Mod::TestByRealEntity.new(@test_by_real)
+    @test_by_auto_counter_entity = Mod::TestByAutoCounterEntity.new(@test_by_auto_counter)
+    @test_by_auto_counter_new_entity = Mod::TestByAutoCounterEntity.new(@test_by_auto_counter_new)
+    @test_by_string_entity = Mod::TestByStringEntity.new(@test_by_string)
+    @test_by_date_entity = Mod::TestByDateEntity.new(@test_by_date)
+    @test_by_date_time_entity = Mod::TestByDateTimeEntity.new(@test_by_date_time)
+
+    # Entity subtypes
+    @test_sub_by_int = Mod::TestSubByInt.new(2)
+    @test_sub_by_real = Mod::TestSubByReal.new(2.0)
+    @test_sub_by_auto_counter = Mod::TestSubByAutoCounter.new(2)
+    @test_sub_by_auto_counter_new = Mod::TestSubByAutoCounter.new(:new)
+    @test_sub_by_string = Mod::TestSubByString.new("two")
+    @test_sub_by_date = Mod::TestSubByDate.new(Date.new(2008,04,28))
+    @test_sub_by_date_time = Mod::TestSubByDateTime.new(2008,04,28,10,28,15)
+
+    # These arrays get zipped together in various ways. Keep them aligned.
+    @values = [
+        @int, @real, @auto_counter, @new_auto_counter,
+        @string, @date, @date_time,
+      ]
+    @classes = [
+        Int, Real, AutoCounter, AutoCounter,
+        String, Date, DateTime,
+      ]
+    @value_types = [
+        Mod::IntValue, Mod::RealValue, Mod::AutoCounterValue, Mod::AutoCounterValue,
+        Mod::StringValue, Mod::DateValue, Mod::DateTimeValue,
+        Mod::IntSubValue, Mod::RealSubValue, Mod::AutoCounterSubValue, Mod::AutoCounterSubValue,
+        Mod::StringSubValue, Mod::DateSubValue, Mod::DateTimeSubValue,
+        ]
+    @value_instances = [
+        @int_value, @real_value, @auto_counter_value, @new_auto_counter_value,
+        @string_value, @date_value, @date_time_value,
+        @int_sub_value, @real_sub_value, @auto_counter_sub_value, @auto_counter_sub_value_new,
+        @string_sub_value, @date_sub_value, @date_time_sub_value,
+        @int_value, @real_value, @auto_counter_value, @new_auto_counter_value,
+        @string_value, @date_value, @date_time_value,
+      ]
+    @entity_types = [
+        Mod::TestByInt, Mod::TestByReal, Mod::TestByAutoCounter, Mod::TestByAutoCounter,
+        Mod::TestByString, Mod::TestByDate, Mod::TestByDateTime,
+        Mod::TestByIntSub, Mod::TestByRealSub, Mod::TestByAutoCounterSub, Mod::TestByAutoCounterSub,
+        Mod::TestByStringSub, Mod::TestByDateSub, Mod::TestByDateTimeSub,
+        Mod::TestSubByInt, Mod::TestSubByReal, Mod::TestSubByAutoCounter, Mod::TestSubByAutoCounter,
+        Mod::TestSubByString, Mod::TestSubByDate, Mod::TestSubByDateTime,
+      ]
+    @entities = [
+        @test_by_int, @test_by_real, @test_by_auto_counter, @test_by_auto_counter_new,
+        @test_by_string, @test_by_date, @test_by_date_time,
+        @test_by_int_sub, @test_by_real_sub, @test_by_auto_counter_sub, @test_by_auto_counter_new_sub,
+        @test_by_string_sub, @test_by_date_sub, @test_by_date_time_sub,
+        @test_sub_by_int, @test_sub_by_real, @test_sub_by_auto_counter, @test_sub_by_auto_counter_new,
+        @test_sub_by_string, @test_sub_by_date, @test_sub_by_date_time,
+      ]
+    @entities_by_entity = [
+        @test_by_int_entity,
+        @test_by_real_entity,
+        @test_by_auto_counter_entity,
+        @test_by_auto_counter_new_entity,
+        @test_by_string_entity,
+        @test_by_date_entity,
+        @test_by_date_time_entity,
+      ]
+    @entities_by_entity_types = [
+        Mod::TestByIntEntity, Mod::TestByRealEntity, Mod::TestByAutoCounterEntity, Mod::TestByAutoCounterEntity,
+        Mod::TestByStringEntity, Mod::TestByDateEntity, Mod::TestByDateTimeEntity,
+      ]
+    @test_role_names = [
+        :int_value, :real_value, :auto_counter_value, :auto_counter_value,
+        :string_value, :date_value, :date_time_value,
+        :int_sub_value, :real_sub_value, :auto_counter_sub_value, :auto_counter_sub_value,
+        :string_sub_value, :date_sub_value, :date_time_sub_value,
+        :int_value, :real_value, :auto_counter_value, :auto_counter_value,
+        :string_value, :date_value, :date_time_value,
+      ]
+    @role_values = [
+        3, 3.0, 6, 7,
+        "three", Date.new(2008,4,21), DateTime.new(2008,4,22,10,28,16),
+      ]
+    @subtype_role_instances = [
+        Mod::IntSubValue.new(6), Mod::RealSubValue.new(6.0),
+        Mod::AutoCounterSubValue.new(:new), Mod::AutoCounterSubValue.new(8),
+        Mod::StringSubValue.new("seven"),
+        Mod::DateSubValue.new(2008,4,29), Mod::DateTimeSubValue.new(2008,4,30,10,28,16)
+      ]
+  end
+
+  it "if a value type, should verbalise" do
+    @value_types.each do |value_type|
+      #puts "#{value_type} verbalises as #{value_type.verbalise}"
+      value_type.respond_to?(:verbalise).should be_true
+      verbalisation = value_type.verbalise
+      verbalisation.should =~ %r{\b#{value_type.basename}\b}
+      verbalisation.should =~ %r{\b#{value_type.superclass.basename}\b}
+    end
+  end
+
+  it "if an entity type, should verbalise" do
+    @entity_types.each do |entity_type|
+      #puts entity_type.verbalise
+      entity_type.respond_to?(:verbalise).should be_true
+      verbalisation = entity_type.verbalise
+      verbalisation.should =~ %r{\b#{entity_type.basename}\b}
+
+      # All identifying roles should be in the verbalisation.
+      # Strictly this should be the role name, but we don't set names here.
+      entity_type.identifying_role_names.each do |ir|
+          role = entity_type.roles(ir)
+          role.should_not be_nil
+          counterpart_object_type = role.counterpart_object_type
+          verbalisation.should =~ %r{\b#{counterpart_object_type.basename}\b}
+        end
+    end
+  end
+
+  it "if a value, should verbalise" do
+    @value_instances.each do |value|
+      #puts value.verbalise
+      value.respond_to?(:verbalise).should be_true
+      verbalisation = value.verbalise
+      verbalisation.should =~ %r{\b#{value.class.basename}\b}
+    end
+  end
+
+  it "if an entity, should respond to verbalise" do
+    (@entities+@entities_by_entity).each do |entity|
+      #puts entity.verbalise
+      entity.respond_to?(:verbalise).should be_true
+      verbalisation = entity.verbalise
+      verbalisation.should =~ %r{\b#{entity.class.basename}\b}
+      entity.class.identifying_role_names.each do |ir|
+          role = entity.class.roles(ir)
+          role.should_not be_nil
+          counterpart_object_type = role.counterpart_object_type
+          verbalisation.should =~ %r{\b#{counterpart_object_type.basename}\b}
+        end
+    end
+  end
+
+  it "should respond to constellation" do
+    (@value_instances+@entities+@entities_by_entity).each do |instance|
+      instance.respond_to?(:constellation).should be_true
+    end
+  end
+
+  it "should respond to all its roles" do
+    @entities.each do |entity|
+      @test_role_names.each do |role_name|
+        entity.respond_to?(role_name).should be_true
+        entity.respond_to?(:"#{role_name}=").should be_true
+        entity.respond_to?(:"one_#{role_name}").should be_true
+        entity.respond_to?(:"one_#{role_name}=").should be_true
+      end
+    end
+    @entities_by_entity.each do |entity|
+      role = entity.class.roles(entity.class.identifying_role_names[0])
+      role_name = role.name
+      entity.respond_to?(role_name).should be_true
+      entity.respond_to?(:"#{role_name}=").should be_true
+    end
+  end
+
+  it "should return the ObjectType in response to .class()" do
+    @value_types.zip(@value_instances).each do |object_type, instance|
+      instance.class.should == object_type
+    end
+    @entity_types.zip(@entities).each do |object_type, instance|
+      instance.class.should == object_type
+      end
+    @entities_by_entity_types.zip(@entities_by_entity).each do |object_type, instance|
+      instance.class.should == object_type
+    end
+  end
+
+  it "should return the module in response to .vocabulary()" do
+    (@value_types+@entity_types).zip((@value_instances+@entities+@entities_by_entity)).each do |object_type, instance|
+      instance.class.vocabulary.should == Mod
+    end
+  end
+
+  it "each entity type should be able to be constructed using simple values" do
+    @entity_types.zip(@values+@values+@values, @classes+@classes+@classes).each do |entity_type, value, klass|
+      # An identifier parameter can be an array containing a simple value too
+      [ value,
+        Array === value ? nil : [value],
+#        entity_type.new(value) # REVISIT: It's not yet the case that an instance of the correct type can be used as a constructor parameter
+      ].compact.each do |value|
+        e = nil
+        lambda {
+            #puts "Constructing #{entity_type} using #{value.class} #{value.inspect}:"
+            e = entity_type.new(value)
+          }.should_not raise_error
+        # Verify that the identifying role has a equivalent value (except AutoCounter):
+        role_name = entity_type.identifying_role_names[0]
+        role = entity_type.roles(role_name)
+        counterpart_object_type = role.counterpart_object_type
+        player_superclasses = [ counterpart_object_type.superclass, counterpart_object_type.superclass.superclass ]
+        e.send(role_name).should == klass.new(*value) unless player_superclasses.include?(AutoCounter)
+      end
+    end
+  end
+
+  it "should allow its non-identifying roles to be assigned values" do
+    @entities.zip(@test_role_names).each do |entity, identifying_role|
+      @test_role_names.zip(@role_values).each do |role_name, value|
+        # No roles of ValueType instances are tested in this file:
+        raise hell unless entity.class.included_modules.include?(ActiveFacts::API::Entity)
+        next if entity.class.identifying_role_names.include?(role_name)
+        lambda {
+            begin
+              entity.send(:"#{role_name}=", value)
+            rescue => e
+              raise
+            end
+          }.should_not raise_error
+        lambda {
+            entity.send(:"one_#{role_name}=", value)
+          }.should_not raise_error
+      end
+    end
+  end
+
+  it "that is an entity type should not allow its identifying roles to be re-assigned" do
+    @entities.zip(@test_role_names).each do |entity, identifying_role|
+      @test_role_names.zip(@role_values).each do |role_name, value|
+        if entity.class.identifying_role_names.include?(role_name) && entity.send(role_name) != nil && value != nil
+          lambda {
+              entity.send(:"#{role_name}=", value)
+            }.should raise_error
+        end
+        one_role = :"one_#{role_name}"
+        if entity.class.identifying_role_names.include?(one_role) && entity.send(one_role) != nil
+          lambda {
+              entity.send(:"one_#{role_name}=", value)
+            }.should raise_error
+        end
+      end
+    end
+  end
+
+  it "that is an entity type should allow its identifying roles to be assigned to and from nil" do
+    @entities.zip(@test_role_names).each do |entity, identifying_role|
+      @test_role_names.zip(@role_values).each do |role_name, value|
+        if entity.class.identifying_role_names.include?(role_name)
+          # Nullify the value first:
+          entity.send(:"#{role_name}=", nil)
+          lambda {
+              entity.send(:"#{role_name}=", value)
+            }.should_not raise_error
+        end
+        one_role = :"one_#{role_name}"
+        if entity.class.identifying_role_names.include?(one_role) && entity.send(one_role) == nil
+          entity.send(one_role, nil)
+          lambda {
+              entity.send(one_role, value)
+            }.should_not raise_error
+        end
+      end
+    end
+  end
+
+  it "should allow its non-identifying roles to be assigned instances" do
+    @entities.zip(@test_role_names).each do |entity, identifying_role|
+      @test_role_names.zip(@value_types, @role_values).each do |role_name, klass, value|
+        next unless value
+        next if role_name == identifying_role
+        instance = klass.new(value)
+        lambda {
+            entity.send(:"#{role_name}=", instance)
+          }.should_not raise_error
+        entity.send(role_name).class.should == klass
+        lambda {
+            entity.send(:"one_#{role_name}=", instance)
+          }.should_not raise_error
+        entity.send(:"one_#{role_name}").class.should == klass
+      end
+    end
+  end
+
+  it "should allow its non-identifying roles to be assigned instances of value subtypes, retaining the subtype" do
+    @entities.zip(@test_role_names).each do |entity, identifying_role|
+      @test_role_names.zip(@subtype_role_instances).each do |role_name, instance|
+        next unless instance
+        next if role_name == identifying_role
+        lambda {
+            entity.send(:"#{role_name}=", instance)
+          }.should_not raise_error
+        entity.send(role_name).class.should == instance.class
+        lambda {
+            entity.send(:"one_#{role_name}=", instance)
+          }.should_not raise_error
+        entity.send(:"one_#{role_name}").class.should == instance.class
+      end
+    end
+  end
+
+  it "should add to has_one's counterpart role when non-identifying roles are assigned values" do
+    @entities.zip(@test_role_names).each do |entity, identifying_role|
+      @test_role_names.zip(@role_values).each do |role_name, value|
+        next if role_name == identifying_role or !value
+
+        # Test the has_one role:
+        role = entity.class.roles(role_name)
+        old_counterpart = entity.send(:"#{role_name}")
+        entity.send(:"#{role_name}=", value)
+        counterpart = entity.send(:"#{role_name}")
+        old_counterpart.should_not == counterpart
+        counterpart.send(role.counterpart.name).should be_include(entity)
+        old_counterpart.send(role.counterpart.name).should_not be_include(entity) if old_counterpart
+
+        # Test the one_to_one role:
+        role = entity.class.roles(:"one_#{role_name}")
+        old_counterpart = entity.send(:"one_#{role_name}")
+        entity.send(:"one_#{role_name}=", value)
+        counterpart = entity.send(:"one_#{role_name}")
+        old_counterpart.should_not == counterpart   # Make sure we changed it!
+        counterpart.send(role.counterpart.name).should == entity
+        old_counterpart.send(role.counterpart.name).should be_nil if old_counterpart
+      end
+    end
+  end
+
+  it "should allow its non-identifying roles to be assigned nil" do
+    @entities.zip(@test_role_names).each do |entity, identifying_role|
+      @test_role_names.zip(@role_values).each do |role_name, value|
+        next if role_name == identifying_role
+        entity.send(:"#{role_name}=", value)
+        lambda {
+            entity.send(:"#{role_name}=", nil)
+          }.should_not raise_error
+        lambda {
+            entity.send(:"one_#{role_name}=", nil)
+          }.should_not raise_error
+      end
+    end
+  end
+
+end