activerdf_net7 1.6.11

data/test/objectmanager/test_literal.rb

@@ -0,0 +1,52 @@
+# Author:: Eyal Oren
+# Copyright:: (c) 2005-2006
+# License:: LGPL
+
+require 'test/unit'
+require 'active_rdf'
+require "#{File.dirname(__FILE__)}/../common"
+
+class TestLiteral < Test::Unit::TestCase
+  def setup
+		ConnectionPool.clear
+    @adapter = get_adapter
+  end
+
+  def teardown
+  end
+
+  def test_xsd_string
+    test = Literal.typed('test', XSD::string)
+    assert_equal '"test"^^<http://www.w3.org/2001/XMLSchema#string>', test.to_ntriple
+  end
+
+  def test_automatic_conversion
+    # infer string
+    test = 'test'
+    assert_equal '"test"^^<http://www.w3.org/2001/XMLSchema#string>', test.to_ntriple
+
+    # infer integer
+    test = 18
+    assert_equal '"18"^^<http://www.w3.org/2001/XMLSchema#integer>', test.to_ntriple
+
+    # infer boolean
+    test = true
+    assert_equal '"true"^^<http://www.w3.org/2001/XMLSchema#boolean>', test.to_ntriple
+  end
+  
+  def test_equality
+    test1 = 'test'
+    test2 = Literal.typed('test', XSD::string)  
+    assert_equal test2.to_ntriple, test1.to_ntriple
+  end
+  
+  def test_language_tag
+    cat = 'cat'
+    cat_en = LocalizedString.new('cat', '@en')
+    assert_equal '"cat"@en', cat_en.to_ntriple
+    assert_not_equal cat.to_ntriple, cat_en.to_ntriple
+
+    assert_equal '"dog"@en-GB', LocalizedString.new('dog', '@en-GB').to_ntriple
+    assert_equal '"dog"@en@test', LocalizedString.new('dog', '@en@test').to_ntriple
+  end
+end

data/test/objectmanager/test_namespace.rb

@@ -0,0 +1,83 @@
+# Author:: Eyal Oren
+# Copyright:: (c) 2005-2006
+# License:: LGPL
+
+require 'test/unit'
+require 'active_rdf'
+require 'objectmanager/namespace'
+require "#{File.dirname(__FILE__)}/../common"
+
+class TestNamespace < Test::Unit::TestCase
+  Rdf = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#'
+  Rdfs = 'http://www.w3.org/2000/01/rdf-schema#'
+  RdfType = RDFS::Resource.new('http://www.w3.org/1999/02/22-rdf-syntax-ns#type')
+  RdfsResource = RDFS::Resource.new('http://www.w3.org/2000/01/rdf-schema#Resource')
+
+  def setup
+  end
+
+  def teardown
+  end
+
+  def test_default_ns_expansion
+    rdftype = RdfType
+    rdfsresource = RdfsResource
+
+    assert_equal rdftype, RDF::type
+    assert_equal rdftype, Namespace.lookup(:rdf, :type)
+    assert_equal rdftype, Namespace.lookup(:rdf, 'type')
+    assert_equal rdftype, Namespace.lookup('rdf', :type)
+    assert_equal rdftype, Namespace.lookup('rdf', 'type')
+
+    assert_equal rdfsresource, RDFS::Resource
+    assert_equal rdfsresource, Namespace.lookup(:rdfs, :Resource)
+    assert_equal rdfsresource, Namespace.lookup(:rdfs, 'Resource')
+    assert_equal rdfsresource, Namespace.lookup('rdfs', :Resource)
+    assert_equal rdfsresource, Namespace.lookup('rdfs', 'Resource')
+  end
+
+  def test_registration_of_rdf_and_rdfs
+    rdftype = RDFS::Resource.new RdfType
+    rdfsresource = RDFS::Resource.new RdfsResource
+
+    assert_equal rdftype, RDF::type
+    assert_equal rdfsresource, RDFS::Resource
+  end
+
+  def test_find_prefix
+    assert_equal :rdf, Namespace.prefix(Namespace.lookup(:rdf, :type))
+    assert_equal :rdf, Namespace.prefix(Namespace.expand(:rdf, :type))
+
+    assert_equal :rdfs, Namespace.prefix(Namespace.lookup(:rdfs, :Resource))
+    assert_equal :rdfs, Namespace.prefix(Namespace.expand(:rdfs, :Resource))
+  end
+
+  def test_class_localname
+    assert_equal 'type', Namespace.lookup(:rdf, :type).localname
+    assert_equal 'type', RDF::type.localname
+
+    assert_equal 'Class', Namespace.lookup(:rdfs, :Class).localname
+    assert_equal 'Class', RDFS::Class.localname
+  end
+
+  def test_class_register
+    test = 'http://test.org/'
+    abc = RDFS::Resource.new("#{test}abc")
+    Namespace.register :test, test
+
+    assert_equal abc, Namespace.lookup(:test, :abc)
+    assert_equal abc, TEST::abc
+  end
+
+  def test_attributes
+    assert_nothing_raised { RDFS::domain }
+    assert_nothing_raised { RDF::type }
+    assert_raise(NameError) { FOAF::type }
+
+    foaf = 'http://xmlns.com/foaf/0.1/'
+    Namespace.register :foaf, foaf
+
+    foafname = RDFS::Resource.new(foaf + 'name')
+    assert_equal foafname, FOAF::name
+  end
+end

data/test/objectmanager/test_object_manager.rb

@@ -0,0 +1,96 @@
+# Author:: Eyal Oren
+# Copyright:: (c) 2005-2006
+# License:: LGPL
+
+require 'test/unit'
+require 'active_rdf'
+require "#{File.dirname(__FILE__)}/../common"
+
+class TestObjectManager < Test::Unit::TestCase
+  def setup
+    ConnectionPool.clear
+  end
+
+  def teardown
+  end
+
+  def test_resource_creation
+    assert_nothing_raised { RDFS::Resource.new('abc') }
+
+    r1 = RDFS::Resource.new('abc')
+    r2 = RDFS::Resource.new('cde')
+    r3 = RDFS::Resource.new('cde')
+    assert_equal r3, RDFS::Resource.new(r3)
+    assert_equal r3, RDFS::Resource.new(r3.to_s)
+
+    assert_equal 'abc', r1.uri
+    assert_equal 'cde', r2.uri
+    assert_equal r3, r2
+  end
+
+  def test_class_construct_classes
+    adapter = get_write_adapter
+    adapter.load "#{File.dirname(__FILE__)}/../test_person_data.nt"
+
+    Namespace.register(:test, 'http://activerdf.org/test/')
+
+    assert_equal RDFS::Resource.new('http://activerdf.org/test/Person'), TEST::Person
+    assert_kind_of Class, TEST::Person
+    assert TEST::Person.ancestors.include?(RDFS::Resource)
+    assert_instance_of TEST::Person, TEST::Person.new('')
+    assert TEST::Person.new('').respond_to?(:uri)
+
+    assert_equal RDFS::Resource.new('http://www.w3.org/2000/01/rdf-schema#Class'), RDFS::Class
+    assert RDFS::Class.ancestors.include?(RDFS::Resource)
+    assert_kind_of Class, RDFS::Class
+    assert_instance_of RDFS::Resource, RDFS::Class.new('')
+    assert RDFS::Class.new('').respond_to?(:uri)
+  end
+
+  def test_custom_code
+    Namespace.register(:test, 'http://activerdf.org/test/')
+
+    TEST::Person.module_eval{ def hello; 'world'; end }
+    assert_respond_to TEST::Person.new(''), :hello
+    assert_equal 'world', TEST::Person.new('').hello
+  end
+
+  def test_class_uri
+    adapter = get_write_adapter
+    adapter.load "#{File.dirname(__FILE__)}/../test_person_data.nt"
+    Namespace.register(:test, 'http://activerdf.org/test/')
+
+    assert_equal RDFS::Resource.new('http://www.w3.org/1999/02/22-rdf-syntax-ns#type'), RDF::type
+    assert_equal RDF::type, RDFS::Resource.new('http://www.w3.org/1999/02/22-rdf-syntax-ns#type')
+    assert_equal TEST::Person, RDFS::Resource.new('http://activerdf.org/test/Person')
+    assert_equal RDFS::Resource.new('http://activerdf.org/test/Person'), TEST::Person
+  end
+
+  def test_to_xml
+    get_adapter.load "#{File.dirname(__FILE__)}/../test_person_data.nt"
+    Namespace.register(:test, 'http://activerdf.org/test/')
+
+    eyal = RDFS::Resource.new 'http://activerdf.org/test/eyal'
+    eyal.age = 29
+    assert_equal 29, eyal.age
+    snippet =
+    '<rdf:Description rdf:about="#eyal">
+    <test:age rdf:datatype="http://www.w3.org/2001/XMLSchema#integer">29</test:age>
+    <test:eye rdf:datatype="http://www.w3.org/2001/XMLSchema#string">blue</test:eye>
+    <rdf:type rdf:resource="http://activerdf.org/test/Person"/>
+    <rdf:type rdf:resource="http://www.w3.org/2000/01/rdf-schema#Resource"/>
+    </rdf:Description>
+    </rdf:RDF>'
+    # Ignore whitespaces in comparison
+    assert eyal.to_xml.gsub!(/\s+/, '').include?(snippet.gsub!(/\s+/, ''))
+
+    require 'net/http'
+    url = 'http://librdf.org/parse'
+    uri = URI.parse(url)
+    req = Net::HTTP::Post.new(url)
+    req.set_form_data('content'=>eyal.to_xml, 'language'=>'rdfxml')
+    res = Net::HTTP.new(uri.host,uri.port).start {|http| http.request(req) }
+    result = res.body.match(/Found.*triples/)[0]
+    assert_equal "Found 4 triples", result, 'invalid XML generated (according to online parser at librdf.org'
+  end
+end

data/test/objectmanager/test_ordered_set.rb

@@ -0,0 +1,110 @@
+# 
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+ 
+
+require 'test/unit'
+require 'active_rdf'
+require "#{File.dirname(__FILE__)}/../common"
+require 'objectmanager/ordered_set'
+
+class TestOrderedSet < Test::Unit::TestCase
+
+  def setup
+    ConnectionPool.clear
+    
+    adapter = get_write_adapter
+    adapter.load "#{File.dirname(__FILE__)}/../test_person_data.nt"
+    adapter.load "#{File.dirname(__FILE__)}/../test_rdf_data.nt"
+    ObjectManager.construct_classes
+   
+    @ordered_set = OrderedSet.new('http://activerdf.org/test/ordered_set')
+      
+    @item_1 = RDFS::Resource.new 'http://activerdf.org/test/item_1'
+    @item_2 = RDFS::Resource.new 'http://activerdf.org/test/item_2'
+    @item_3 = RDFS::Resource.new 'http://activerdf.org/test/item_3'      
+  end
+    
+  def test_resource_type
+    assert_kind_of OrderedSet, @ordered_set
+  end
+
+  def test_query
+    # add items to container
+    @ordered_set.add @item_1
+    @ordered_set.add @item_2
+    @ordered_set.add @item_3
+    
+    # check if all items are inserted
+    assert_equal 3, @ordered_set.elements.size
+    
+    # check elements array
+    assert @ordered_set.elements.include?(@item_1)
+    assert @ordered_set.elements.include?(@item_2)
+    assert @ordered_set.elements.include?(@item_3)
+  end
+  
+    def test_at
+    # add items to container
+    @ordered_set.add @item_1
+    @ordered_set.add @item_2
+    @ordered_set.add @item_3
+    
+    # check if all items are inserted
+    assert_equal 3, @ordered_set.elements.size
+    
+    # check item for each position
+    assert_equal @item_1.uri, @ordered_set.at(1).uri
+    assert_equal @item_2.uri, @ordered_set.at(2).uri
+    assert_equal @item_3.uri, @ordered_set.at(3).uri
+  end
+  
+  def test_order
+    # add items to container
+    @ordered_set.add @item_1
+    @ordered_set.add @item_2
+    @ordered_set.add @item_3
+    
+    # check if container include each item
+    assert_equal @ordered_set.elements[0].uri, @item_1.uri
+    assert_equal @ordered_set.elements[1].uri, @item_2.uri
+    assert_equal @ordered_set.elements[2].uri, @item_3.uri
+  end
+  
+  def test_delete
+    # add items to container
+    @ordered_set.add @item_1
+    @ordered_set.add @item_2
+    @ordered_set.add @item_3
+    
+    # check item number
+    assert_equal 3, @ordered_set.elements.size
+    
+    # delete item 2
+    @ordered_set.delete(2)
+    assert_equal 2, @ordered_set.elements.size
+    assert_equal @ordered_set.elements[0].uri, @item_1.uri
+    assert_equal @ordered_set.elements[1].uri, @item_3.uri 
+    
+    # delete all items
+    @ordered_set.delete_all
+    assert_equal 0, @ordered_set.elements.size
+  end
+  
+  def test_replace
+    # add items to container
+    @ordered_set.add @item_1
+    @ordered_set.add @item_2
+    
+    assert_equal 2, @ordered_set.elements.size
+    
+    # replace item 2
+    @ordered_set.replace(2, @item_3)
+    
+    # check if item 2 is replaced
+    assert_equal 2, @ordered_set.elements.size
+    assert_equal @ordered_set.elements[0].uri, @item_1.uri
+    assert_equal @ordered_set.elements[1].uri, @item_3.uri
+  end
+    
+end

data/test/objectmanager/test_resource_reading.rb

@@ -0,0 +1,150 @@
+# Author:: Eyal Oren
+# Copyright:: (c) 2005-2006
+# License:: LGPL
+
+require 'test/unit'
+require 'active_rdf'
+require 'federation/connection_pool'
+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/')
+
+    @eyal = RDFS::Resource.new 'http://activerdf.org/test/eyal'
+  end
+
+  def teardown
+  end
+
+  def test_find_all_instances
+    assert_equal 7, RDFS::Resource.find_all.size
+    assert_equal [TEST::eyal, TEST::other], TEST::Person.find_all
+  end
+
+  def test_class_predicates
+    assert_equal 5, RDFS::Resource.predicates.size
+  end
+
+  def test_eyal_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
+
+    # 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
+  end
+
+  def test_eyal_types
+    types = @eyal.type
+    assert_equal 2, types.size
+    assert types.include?(TEST::Person)
+    assert types.include?(RDFS::Resource)
+  end
+
+  def test_eyal_age
+    # triple exists '<eyal> age 27'
+    assert_equal 27, @eyal.age
+    assert_equal 27, @eyal.test::age
+    assert_equal [27], @eyal.all_age
+
+    # 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
+
+    # non-existent method should throw error
+    assert_equal nil, @eyal.non_existing_method
+  end
+
+  def test_eyal_type
+    assert_instance_of RDFS::Resource, @eyal
+    assert_instance_of TEST::Person, @eyal
+  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
+  end
+
+  def test_find_methods
+    assert_equal [@eyal], RDFS::Resource.find_by_eye('blue')
+    assert_equal [@eyal], RDFS::Resource.find_by_test::eye('blue')
+
+    assert_equal [@eyal], RDFS::Resource.find_by_age(27)
+    assert_equal [@eyal], RDFS::Resource.find_by_test::age(27)
+
+    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
+
+  # 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
+
+  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)
+    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}
+  end
+end