activerdf_net7 1.6.16 → 1.7.0

data/test/objectmanager/test_property.rb

@@ -0,0 +1,261 @@
+require 'test/unit'
+require 'active_rdf'
+require 'set'
+require File.dirname(File.expand_path(__FILE__)) + '/../common'
+
+class TestProperty < Test::Unit::TestCase
+  include SetupAdapter
+
+  def test_to_ary
+    p = RDF::Property.new(TEST::age)
+    assert !p.respond_to?(:to_ary)
+
+    p = RDF::Property.new(TEST::age, TEST::eyal)
+    assert p.respond_to?(:to_ary)
+  end
+
+  def test_retrieve_a_triple_with_property
+    @adapter.load "#{File.dirname(__FILE__)}/../test_person_data.nt"
+    @adapter.load "#{File.dirname(__FILE__)}/../test_person2_data.nt"
+    eyal = TEST::eyal
+    age = 27
+    michael = TEST::michael
+    michael.age = age
+    benjamin = TEST::Person.new(TEST::benjamin)
+
+    eyal.test::member_of = ["A","B","C"]
+    michael.test::member_of = ["A","B"]
+    benjamin.test::member_of = ["B","C"]
+
+    s = Query.new.select(:s).where(:s,TEST::member_of,eyal.member_of).execute
+    assert_equal Set[eyal], Set.new(s)
+
+    s = Query.new.select(:s).where(:s,TEST::member_of,michael.member_of).execute
+    assert_equal Set[eyal,michael], Set.new(s)
+
+    s = Query.new.select(:s).where(:s,TEST::member_of,benjamin.member_of).execute
+    assert_equal Set[eyal,benjamin], Set.new(s)
+
+    p = RDF::Property.new(TEST::member_of, michael)
+    # Property will act as set of values in the object clause when @subject set
+    assert_equal Set[eyal,michael], Set.new(Query.new.distinct(:s).where(:s, p, p).execute)
+  end
+end
+
+class TestAssociatedProperty < Test::Unit::TestCase
+  include SetupAdapter
+
+  def setup
+    super
+    @adapter.load "#{File.dirname(__FILE__)}/../test_person_data.nt"
+    @email = RDF::Property.new(TEST::email,TEST::eyal)
+    @age = RDF::Property.new(TEST::age,TEST::eyal)
+  end
+
+  def test_to_a
+    assert_equal Set["eyal@cs.vu.nl", "eyal.oren@deri.org"], Set.new(@email)
+  end
+
+  def test_to_ary
+    assert @email.respond_to?(:to_ary)
+
+    # when comparing arrays, order matters
+    assert ["eyal@cs.vu.nl", "eyal.oren@deri.org"] != @email.to_ary
+
+    assert_equal Set["eyal@cs.vu.nl", "eyal.oren@deri.org"], Set.new(@email.to_ary)
+  end
+
+  def test_to_h
+    h = {"fe82da4f0b32cd8ca4f1e8eb7683fcb1"=>"eyal@cs.vu.nl", "48ba5c9312b3400d28a72b637b0b3748"=>"eyal.oren@deri.org"}
+    assert_equal h, @email.to_h
+  end
+
+  def test_add
+    @email.replace "eyal@cs.vu.nl"
+    assert_equal ["eyal@cs.vu.nl"], @email
+
+    @email.add "eyal.oren@deri.com"
+    assert_equal ["eyal@cs.vu.nl","eyal.oren@deri.com"], @email
+
+    @email.replace "eyal@cs.vu.nl"
+    @email.add ["eyal@cs.vu.nl","eyal.oren@deri.org"]
+    assert_equal ["eyal@cs.vu.nl","eyal.oren@deri.org"], @email
+
+    #  numbers (doesn't add them together, adds new value)
+    @age.replace 30
+    @age += 35
+    assert_equal [30, 35], @age
+  end
+
+  def test_remove
+    @email -= "eyal.oren@deri.org"
+    assert ["eyal@cs.vu.nl"], @email
+  end
+
+  def test_replace
+    # two ways to update values
+    # using an index
+    @email[@email.index("eyal.oren@deri.org")] = "eyal.oren@deri.net"
+    assert_equal ["eyal@cs.vu.nl","eyal.oren@deri.net"], @email
+
+    # using old value
+    @email["eyal.oren@deri.net"] = "eyal.oren@deri.org"
+    assert_equal ["eyal@cs.vu.nl","eyal.oren@deri.org"], @email
+
+    @age.replace 30
+    @age[30] += 5
+    assert_equal [35], @age
+  end
+
+  def test_delete
+    assert_equal "not found", @email.delete("nothing"){"not found"}
+
+    # two ways to delete
+    @email.delete(@email.index("eyal@cs.vu.nl"))
+    @email.delete("eyal.oren@deri.org")
+    assert_equal 0, @email.size
+
+    # delete numbers
+    assert_equal 1, @age.size
+    @age.delete(27)
+    assert @age.empty?
+  end
+
+  def test_clear
+    @email.clear
+    assert @email.empty?  # class predicates return empty RDF::Property
+  end
+
+  def test_collect!
+    @email.collect!{|email| email + "_XX"}
+    assert @email == ["eyal@cs.vu.nl_XX", "eyal.oren@deri.org_XX"]
+  end
+
+  def test_delete_if
+    @email.delete_if{|key, val| val == "eyal@cs.vu.nl"}
+    assert_equal ["eyal.oren@deri.org"], @email
+  end
+
+  def test_equals
+    assert TEST::eyal.eye == "blue"
+    # Order doesn't matter when comparing Property to Array
+    assert_equal @email, ["eyal@cs.vu.nl","eyal.oren@deri.org"]
+    assert_equal @email, ["eyal.oren@deri.org","eyal@cs.vu.nl"]
+    assert_equal ["eyal@cs.vu.nl","eyal.oren@deri.org"], @email
+    assert_equal ["eyal.oren@deri.org","eyal@cs.vu.nl"], @email
+
+    assert_equal @email, TEST::email
+    assert_equal TEST::email, @email
+    assert_equal TEST::eyal.eye, TEST::eye
+    assert_equal TEST::eye, TEST::eyal.eye
+
+    # test property w/o subject
+    assert_equal RDF::Property.new(TEST::email), TEST::email
+  end
+
+  def test_each_index
+    @email.each_key do |idx|
+      assert_not_nil @email[idx]
+    end
+  end
+
+  def test_fetch
+    idx = @email.index("eyal@cs.vu.nl")
+    assert_equal "eyal@cs.vu.nl", @email.fetch(idx)
+    @email.delete(idx)
+    assert_equal "default", @email.fetch(idx,"default")
+    assert_equal idx, @email.fetch(idx){|i| i}
+    assert_raise IndexError do
+      @email.fetch(idx)
+    end
+  end
+
+  def test_include?
+    assert @email.include?("eyal@cs.vu.nl")
+  end
+
+  def test_keys
+    assert_equal 2, @email.keys.size
+    assert @email.keys.include?("fe82da4f0b32cd8ca4f1e8eb7683fcb1")
+    assert @email.keys.include?("48ba5c9312b3400d28a72b637b0b3748")
+  end
+
+  def test_only
+    assert_equal "blue", TEST::eyal.eye.only
+    TEST::eyal.eye.add "white"
+    assert_raise ActiveRdfError do
+      TEST::eyal.eye.only
+    end
+  end
+
+  def test_lang
+    @adapter.load "#{File.dirname(__FILE__)}/../rdfs.nt"
+    ls_en = LocalizedString.new('ActiveRDF developer', '@en')
+    ls_de = LocalizedString.new('ActiveRDF entwickler', '@de')
+    TEST::eyal.comment = ls_en
+    TEST::eyal.comment.add ls_de
+
+    assert_equal ['en',true], TEST::eyal.comment.lang('@en').lang
+    assert_equal ['de',false], TEST::eyal.comment.lang('de', false).lang
+
+    assert_equal [ls_en], TEST::eyal.comment.lang('@en')
+    assert_equal TEST::eyal.comment.lang('@en'), TEST::eyal.comment.lang('en')   # @en and en should equate
+
+    assert_equal [ls_de], TEST::eyal.comment.lang('@de')
+    assert_equal [ls_en, ls_de], TEST::eyal.comment
+
+    TEST::eyal.comment.add LocalizedString.new('ActiveRDF developer', 'en')
+    assert_equal 1, TEST::eyal.comment.lang('en').size      # no duplicates
+  end
+
+  def test_datatype
+    @adapter.load "#{File.dirname(__FILE__)}/../rdfs.nt"
+    t = Time.parse("Tue Jan 20 12:00:00 -0800 2009")
+    TEST::eyal.comment = [1, LocalizedString.new('localized string', '@en'), "string", t]
+    assert_equal [1], TEST::eyal.comment.datatype(XSD::integer)
+    assert_equal XSD::integer, TEST::eyal.comment.datatype(XSD::integer).datatype
+    assert_equal ["string"], TEST::eyal.comment.datatype(XSD::string)   # LocalizedString != XSD::string
+    assert_equal [t], TEST::eyal.comment.datatype(XSD::time)
+  end
+
+  def test_context
+    if @adapter.contexts?
+      @adapter.load "#{File.dirname(__FILE__)}/../test_person2_data.nt"
+      context_one = RDFS::Resource.new("file:#{File.dirname(__FILE__)}/../test_person_data.nt")
+      context_two = RDFS::Resource.new("file:#{File.dirname(__FILE__)}/../test_person2_data.nt")
+      assert_equal [27], RDF::Property.new(TEST::age,TEST::eyal).context(context_one)
+      assert_equal   [], RDF::Property.new(TEST::age,TEST::eyal).context(context_two)
+      assert_equal [30], RDF::Property.new(TEST::age,TEST::michael).context(context_two)
+    end
+  end
+
+  def test_length
+    assert_equal 2, @email.length
+    assert_equal 2, @email.size
+  end
+
+  def test_values_at
+    idx1 = @email.index("eyal@cs.vu.nl")
+    idx2 = @email.index("eyal.oren@deri.org")
+    assert_equal ["eyal@cs.vu.nl", "eyal.oren@deri.org"], @email.values_at(idx1, idx2)
+    assert_equal ["eyal@cs.vu.nl"], @email.values_at(idx1)
+    assert_equal ["eyal.oren@deri.org"], @email.values_at(idx2)
+  end
+
+  def test_false_value
+    @email = false
+    assert @email == false
+  end
+
+  if $activerdf_internal_reasoning
+    def test_sub_super_properties
+      RDF::Property.new(TEST::relative).save
+      RDF::Property.new(TEST::ancestor).save.rdfs::subPropertyOf = TEST::relative
+      RDF::Property.new(TEST::parent).save.rdfs::subPropertyOf = TEST::ancestor
+      RDF::Property.new(TEST::sibling).save.rdfs::subPropertyOf = TEST::relative
+  
+      assert_equal Set[TEST::ancestor, TEST::parent, TEST::sibling], Set.new(TEST::relative.sub_properties)
+      assert_equal Set[TEST::relative, TEST::ancestor], Set.new(TEST::parent.super_properties) 
+    end
+  end
+end

data/test/objectmanager/test_resource_reading.rb

@@ -4,147 +4,239 @@
 
 require 'test/unit'
 require 'active_rdf'
-require 'federation/connection_pool'
+require 'set'
 require "#{File.dirname(__FILE__)}/../common"
 
 class TestResourceReading < Test::Unit::TestCase
-  def setup
-    ConnectionPool.clear
-    @adapter = get_adapter
-    @adapter.load "#{File.dirname(__FILE__)}/../test_person_data.nt"
-    Namespace.register(:test, 'http://activerdf.org/test/')
+  include SetupAdapter
 
-    @eyal = RDFS::Resource.new 'http://activerdf.org/test/eyal'
-  end
+  @@eyal = TEST::eyal
 
-  def teardown
+  def setup
+    super
+    test_dir = "#{File.dirname(__FILE__)}/.."
+    @adapter.load "#{test_dir}/rdf.nt"
+    @adapter.load "#{test_dir}/rdfs.nt"
+    @adapter.load "#{test_dir}/test_person_data.nt"
   end
 
-  def test_find_all_instances
-    assert_equal 7, RDFS::Resource.find_all.size
-    assert_equal [TEST::eyal, TEST::other], TEST::Person.find_all
+  def test_class_resource_equality
+    p = TEST::Person
+    r  = RDFS::Resource.new(p.uri)
+    assert_equal p, r
+    assert_equal r, p
+    assert p.eql?(r)
+    assert r.eql?(p)
   end
 
   def test_class_predicates
-    assert_equal 5, RDFS::Resource.predicates.size
+    assert_equal Set[RDF::type,RDF::value,RDFS::comment,RDFS::label,RDFS::seeAlso,RDFS::isDefinedBy,RDFS::member],
+                 Set.new(RDFS::Resource.predicates)
+    assert_equal Set[TEST::age, TEST::eye, TEST::car],
+                 Set.new(TEST::Person.predicates - RDFS::Resource.predicates)
   end
 
-  def test_eyal_predicates
+  def test_resource_predicates
     # assert that eyal's three direct predicates are eye, age, and type
-    preds = @eyal.direct_predicates.collect {|p| p.uri }
-    assert_equal 3, preds.size
-    ['age', 'eye', 'type'].each do |pr|
-      assert preds.any? {|uri| uri =~ /.*#{pr}$/ }, "Eyal should have predicate #{pr}"
-    end
+    assert_equal Set[RDF::type, TEST::age, TEST::eye, TEST::email],
+                 Set.new(@@eyal.direct_predicates)
+  end
+
+  def test_resource_type
+    assert_instance_of RDFS::Resource, @@eyal
+    assert_instance_of TEST::Person, @@eyal
+  end
 
-    # test class level predicates
-    class_preds = @eyal.class_level_predicates.collect {|p| p.uri }
-    # eyal.type: person and resource, has predicates age, eye
-    # not default rdfs:label, rdfs:comment, etc. because not using rdfs reasoning
-    assert_equal 5, class_preds.size
+  def test_resource_types
+    assert_equal Set[TEST::Person.class_uri, RDFS::Resource.class_uri],
+                 Set.new(@@eyal.type)
   end
 
-  def test_eyal_types
-    types = @eyal.type
-    assert_equal 2, types.size
-    assert types.include?(TEST::Person)
-    assert types.include?(RDFS::Resource)
+  def test_resource_classes
+    assert_equal Set[TEST::Person, RDFS::Resource],
+                 Set.new(@@eyal.classes)
   end
 
-  def test_eyal_age
+  def test_resource_values
     # triple exists '<eyal> age 27'
-    assert_equal 27, @eyal.age
-    assert_equal 27, @eyal.test::age
-    assert_equal [27], @eyal.all_age
+    assert_kind_of RDF::Property, @@eyal.age
+    assert_equal 1, @@eyal.age.size
+    assert_equal 27, @@eyal.age.to_a.first
+    assert_equal @@eyal.age.to_a.first, 27
+    assert_equal [27], @@eyal.age
+    assert_equal @@eyal.age, [27]
+    assert_kind_of RDF::Property, @@eyal.test::age
+    assert_equal 1, @@eyal.test::age.size
+    assert_equal 27, @@eyal.test::age.to_a.first
+    assert_equal @@eyal.test::age.to_a.first, 27
+
+    assert_equal 27, @@eyal.age[27]
 
     # Person has property car, but eyal has no value for it
-    assert_equal nil, @eyal.car
-    assert_equal nil, @eyal.test::car
-    assert_equal [], @eyal.all_test::car
+    assert @@eyal.car.empty?
+    assert_equal [], @@eyal.car
+    assert @@eyal.test::car.empty?
+    assert_equal [], @@eyal.test::car
+
+    # non-existent property returns nil
+    assert_nil @@eyal.non_existing_property
 
-    # non-existent method should throw error
-    assert_equal nil, @eyal.non_existing_method
+    # non-existent properties thrown errors on assignment
+    assert_raise ActiveRdfError do
+      @@eyal.non_existing_property = "value"
+    end
   end
 
-  def test_eyal_type
-    assert_instance_of RDFS::Resource, @eyal
-    assert_instance_of TEST::Person, @eyal
+  def test_predicate_management
+    @adapter.add(TEST::hair,RDF::type,RDF::Property)
+    @adapter.add(TEST::hair,RDFS::domain,TEST::Person)
+    assert TEST::Person.predicates.include?(TEST::hair)
   end
 
-  def test_find_options
-    all = [Namespace.lookup(:test,:Person), Namespace.lookup(:rdfs, :Class), Namespace.lookup(:rdf, :Property), @eyal, TEST::car, TEST::age, TEST::eye]
-    found = RDFS::Resource.find
-    assert_equal all.sort, found.sort
-    
-    properties = [TEST::car, TEST::age, TEST::eye]
-    found = RDFS::Resource.find(:where => {RDFS::domain => RDFS::Resource})
-    assert_equal properties.sort, found.sort
-    
-    found = RDFS::Resource.find(:where => {RDFS::domain => RDFS::Resource, :prop => :any})
-    assert_equal properties.sort, found.sort
-    
-    found = TEST::Person.find(:order => TEST::age)
-    assert_equal [TEST::other, TEST::eyal].sort, found.sort
+  def test_custom_method
+    TEST::Person.class_eval{def foo; "foo"; end}
+    assert_equal "foo", @@eyal.foo
+    TEST::Graduate.class_eval{def bar; "bar"; end}
+    assert_nil @@eyal.bar
+    @@eyal.type += TEST::Graduate
+    assert_equal "bar", @@eyal.bar
+  end
+
+  def test_find_all
+    assert_equal Set[@@eyal, TEST::other], Set.new(TEST::Person.find_all)
   end
 
   def test_find_methods
-    assert_equal [@eyal], RDFS::Resource.find_by_eye('blue')
-    assert_equal [@eyal], RDFS::Resource.find_by_test::eye('blue')
+    blue = LocalizedString.new('blue','en')
+    nl_blauw = LocalizedString.new('blauw','nl')
+    @adapter.add(TEST::eyal,TEST::eye, nl_blauw)
+    @adapter.add(TEST::other,TEST::eye,LocalizedString.new('rot','de'))
+
+    # find all TEST::Person resources
+    assert_equal Set[@@eyal, TEST::other], Set.new(TEST::Person.find_all)
+
+    # find TEST::Person resources that having the property specified
+    assert_equal Set[@@eyal, TEST::other], Set.new(TEST::Person.find_by.age.execute)
+    assert_equal [@@eyal], TEST::Person.find_by.test::email.execute
+
+    # find TEST::Person resources with property matching the supplied value(s)
+    assert_equal [@@eyal], TEST::Person.find_by.age(27).execute
+    assert_equal [@@eyal], TEST::Person.find_by.test::age(27).execute
+    assert_equal [@@eyal], TEST::Person.find_by.test::email('eyal@cs.vu.nl','eyal.oren@deri.org').execute
+    assert_equal [@@eyal], TEST::Person.find_by.test::email(['eyal@cs.vu.nl','eyal.oren@deri.org']).execute
+    assert_equal [@@eyal], TEST::Person.find_by.eye(blue).execute
+
+    # find TEST::Person resources with property matching the supplied value ignoring lang/datatypes
+    assert_equal [@@eyal], TEST::Person.find_by.eye('blue').execute(:all_types => true)
+    assert_equal       [], TEST::Person.find_by.eye('blue').execute
+
+    # find RDFS::Resources having property matching the supplied value ignoring lang/datatypes
+    assert_equal [@@eyal], RDFS::Resource.find_by.test::eye('blue').execute(:all_types => true)
+    assert_equal       [], RDFS::Resource.find_by.test::eye('blue').execute
+
+    # find TEST::Person resources with property having the specified language
+    assert_equal [@@eyal], TEST::Person.find_by.eye(:lang => '@en').execute
+    assert_equal [@@eyal], TEST::Person.find_by.eye(:lang => '@nl').execute
+    assert_equal [TEST::other], TEST::Person.find_by.eye(:lang => '@de').execute
+
+    # find TEST::Person resources with property having the specified datatype
+    assert_equal Set[@@eyal, TEST::other], Set.new(TEST::Person.find_by.age(:datatype => XSD::integer).execute)
+    TEST::other.age = "twenty"
+    assert_equal [@@eyal], TEST::Person.find_by.age(:datatype => XSD::integer).execute
+
+    # combining lang/datatype specifiers with all_types is prohibited
+    assert_raise ActiveRdfError do
+      TEST::Person.find_by.eye(:lang => '@en').execute(:all_types => true)
+    end
+    assert_raise ActiveRdfError do
+      TEST::Person.find_by.age(:datatype => XSD::integer).execute(:all_types => true)
+    end
 
-    assert_equal [@eyal], RDFS::Resource.find_by_age(27)
-    assert_equal [@eyal], RDFS::Resource.find_by_test::age(27)
+    # chain multiple properties together, ANDing restrictions
+    assert_equal [@@eyal], TEST::Person.find_by.age(27).eye(blue).execute
 
-    assert_equal [@eyal], RDFS::Resource.find_by_age_and_eye(27, 'blue')
-    assert_equal [@eyal], RDFS::Resource.find_by_test::age_and_test::eye(27, 'blue')
-    assert_equal [@eyal], RDFS::Resource.find_by_test::age_and_eye(27, 'blue')
-    assert_equal [@eyal], RDFS::Resource.find_by_age_and_test::eye(27, 'blue')
-  end
+    # raise error for properties not in domain (fully qualified name required)
+    assert_raise ActiveRdfError do
+      RDFS::Resource.find_by.age(27).execute
+    end
 
-  # test for writing if no write adapter is defined (like only sparqls)
-  def test_write_without_write_adapter
-    ConnectionPool.clear
-    get_read_only_adapter
-    assert_raises(ActiveRdfError) { @eyal.test::age = 18 }
+    # find RDFS::Resources having the fully qualified property
+    assert_equal [@@eyal], RDFS::Resource.find_by.test::email.execute
+
+    # find RDFS::Resources having the fully qualified property and value
+    assert_equal [@@eyal], RDFS::Resource.find_by.test::age(27).execute
+    assert_equal [@@eyal], RDFS::Resource.find_by.test::eye(blue).execute
+
+    # find RDFS::Resources with multiple chained properties
+    assert_equal [@@eyal], TEST::Person.find_by.age(27).eye(blue).execute
+    assert_equal [@@eyal], TEST::Person.find_by.age(27).test::eye(blue).execute
+    assert_equal [@@eyal], TEST::Person.find_by.test::age(27).eye(blue).execute
+    assert_equal [@@eyal], TEST::Person.find_by.test::age(27).test::eye(blue).execute
+
+    # bug 62481
+    camelCaseProperty = RDF::Property.new(TEST::camelCaseProperty).save
+    camelCaseProperty.domain = TEST::Person
+    @@eyal.camelCaseProperty = "a CamelCase property name"
+    assert_equal [@@eyal], TEST::Person.find_by.camelCaseProperty.execute
+    assert_equal [@@eyal], TEST::Person.find_by.test::camelCaseProperty.execute
+    assert_equal [@@eyal], TEST::Person.find_by.camelCaseProperty("a CamelCase property name").execute
+
+    underscored_property = RDF::Property.new(TEST::underscored_property).save
+    underscored_property.domain = TEST::Person
+    @@eyal.underscored_property = "an underscored property name"
+    assert_equal [@@eyal], TEST::Person.find_by.underscored_property.execute
+    assert_equal [@@eyal], TEST::Person.find_by.test::underscored_property.execute
+    assert_equal [@@eyal], TEST::Person.find_by.underscored_property("an underscored property name").execute
+
+    mixedCamelCase_underscored_property = RDF::Property.new(TEST::mixedCamelCase_underscored_property).save
+    mixedCamelCase_underscored_property.domain = TEST::Person
+    @@eyal.mixedCamelCase_underscored_property = "a mixed CamelCase and underscored property"
+    assert_equal [@@eyal], TEST::Person.find_by.mixedCamelCase_underscored_property.execute
+    assert_equal [@@eyal], TEST::Person.find_by.test::mixedCamelCase_underscored_property.execute
+    assert_equal [@@eyal], TEST::Person.find_by.mixedCamelCase_underscored_property("a mixed CamelCase and underscored property").execute
+
+    # Sqlite doesn't support regular expressions by default
+    unless ConnectionPool.write_adapter.class == ActiveRDF::RDFLite
+      # find TEST::Person resources with property matching the specified regex
+      assert_equal [@@eyal], TEST::Person.find_by.age(:regex => /7/).execute
+      assert_equal [@@eyal], TEST::Person.find_by.eye(:regex => /lu/).execute
+      assert_equal [TEST::other], TEST::Person.find_by.eye(:regex => /ot/).execute
+    end
   end
 
+
   def test_finders_with_options
-    ConnectionPool.clear
-    adapter = get_adapter
-    file_one = "#{File.dirname(__FILE__)}/../small-one.nt"
-    file_two = "#{File.dirname(__FILE__)}/../small-two.nt"
-    one = RDFS::Resource.new("file:#{file_one}")
-    two = RDFS::Resource.new("file:#{file_two}")
-
-    if (adapter.class.to_s != "SesameAdapter")
-      adapter.load file_one
-      adapter.load file_two
-    else
-      adapter.load(file_one, 'ntriples', one)
-      adapter.load(file_two, 'ntriples', two)
+    blue = LocalizedString.new('blue','en')
+
+    assert_equal Set[TEST::car, TEST::age, TEST::eye], Set.new(RDF::Property.find_by.rdfs::domain(TEST::Person).execute)
+
+    assert_equal 2, RDFS::Resource.find_all.size
+    assert_equal 2, RDFS::Resource.find_all(:limit => 10).size
+    assert_equal 1, RDFS::Resource.find_all(:limit => 1).size
+
+    if @adapter.contexts?
+      file = "#{File.dirname(__FILE__)}/../test_person2_data.nt"
+      @adapter.load(file)
+      context_one = RDFS::Resource.new("file:#{File.dirname(__FILE__)}/../test_person_data.nt")
+      context_two = RDFS::Resource.new("file:#{file}")
+
+      assert_equal 2, RDFS::Resource.find_all(:context => context_one).size
+      assert_equal 1, RDFS::Resource.find_all(:context => context_two).size
+      assert_equal 1, RDFS::Resource.find_all(:context => context_one, :limit => 1).size
+
+      # Redland doesn't support querying more than one context at a time as of Feb 2009
+      assert_equal [@@eyal], TEST::Person.find_by.age(27,:context => context_one).execute
+      assert_equal       [], TEST::Person.find_by.eye('blue', :context => context_one).execute
+      assert_equal [@@eyal], TEST::Person.find_by.eye('blue', :context => context_one).execute(:all_types => true)
+      assert_equal [@@eyal], TEST::Person.find_by.eye(blue, :context => context_one).execute
+      assert_equal       [], TEST::Person.find_by.eye(blue, :context => context_two).execute
     end
-
-    assert_equal 2, RDFS::Resource.find.size
-    assert_equal 2, RDFS::Resource.find(:all).size
-    assert_equal 2, RDFS::Resource.find(:all, :limit => 10).size
-    assert_equal 1, RDFS::Resource.find(:all, :limit => 1).size
-    assert_equal 1, RDFS::Resource.find(:all, :context => one).size
-    assert_equal 1, RDFS::Resource.find(:all, :context => one, :limit => 1).size
-    assert_equal 0, RDFS::Resource.find(:all, :context => one, :limit => 0).size
-
-    assert_equal 1, RDFS::Resource.find_by_eye('blue').size
-    assert_equal 1, RDFS::Resource.find_by_eye('blue', :context => one).size
-    assert_equal 0, RDFS::Resource.find_by_eye('blue', :context => two).size
-
-    assert_equal 2, RDFS::Resource.find_by_rdf::type(RDFS::Resource).size
-    assert_equal 1, RDFS::Resource.find_by_rdf::type(RDFS::Resource, :context => one).size
-    assert_equal 1, RDFS::Resource.find_by_eye_and_rdf::type('blue', RDFS::Resource, :context => one).size
   end
 
-  def test_reading_with_block
-    qs=<<EOF
-SELECT DISTINCT ?o WHERE { <http://activerdf.org/test/eyal> 
-<http://activerdf.org/test/age> ?o . FILTER (regex(lang(?o), '^nl$'))}
-EOF
-    @eyal.age {|query, obj| query.lang(obj, "nl"); assert_equal qs.gsub("\n",'').strip, query.to_sp.strip}
+  # test for writing if no write adapter is defined (like only sparqls)
+  def test_write_without_write_adapter
+    ConnectionPool.clear
+    get_read_only_adapter
+    assert_raises(ActiveRdfError) { @@eyal.test::age = 18 }
   end
 end

data/test/objectmanager/test_resource_reasoning.rb

@@ -0,0 +1,26 @@
+require 'active_rdf'
+if $activerdf_internal_reasoning
+  require 'test/unit'
+  require 'set'
+  require "#{File.dirname(__FILE__)}/../common"
+
+  class TestResourceReasoning < Test::Unit::TestCase
+    include SetupAdapter
+
+    def setup
+      super
+      test_dir = "#{File.dirname(__FILE__)}/.."
+      @adapter.load "#{test_dir}/rdf.nt"
+      @adapter.load "#{test_dir}/rdfs.nt"
+      @adapter.load "#{test_dir}/test_person_data.nt"
+      @adapter.load "#{test_dir}/test_relations.nt"
+    end
+
+    def test_person
+      assert_equal Set[TEST::age, TEST::car, TEST::eye, TEST::ancestor, TEST::child, TEST::parent, TEST::relative, TEST::sibling] | RDFS::Resource.predicates,
+                   Set.new(TEST::Person.predicates)
+    end
+
+    # TODO: add more tests
+  end
+end