pho 0.4 → 0.4.1

data/tests/tc_changeset_builder.rb

@@ -0,0 +1,151 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'pho'
+require 'test/unit'
+require 'mocha'
+require 'rexml/document'
+require 'uri'
+
+class ChangesetBuilderTest < Test::Unit::TestCase
+  
+  SINGLE_TRIPLE_RESOURCE = <<-EOL
+  {
+    "http://www.example.org" : {
+      "http://www.example.org/ns/predicate" : [ { "value" : "http://www.example.org/page", "type" : "uri" } ]
+    }
+  }
+  EOL
+
+  SINGLE_TRIPLE_LITERAL = <<-EOL
+  {
+    "http://www.example.org" : {
+      "http://www.example.org/ns/predicate" : [ { "value" : "Title", "type" : "literal" } ]
+    }
+  }
+  EOL
+  
+  TWO_TRIPLES = <<-EOL
+  {
+    "http://www.example.org" : {
+      "http://www.example.org/ns/resource" : [ { "value" : "http://www.example.org/page", "type" : "uri" } ],
+      "http://www.example.org/ns/literal" : [ { "value" : "Title", "type" : "literal" } ]        
+    }
+  }
+  EOL
+
+  SOME_TRIPLES = <<-EOL
+  {
+    "http://www.example.org" : {
+      "http://www.example.org/ns/resource" : [ { "value" : "http://www.example.org/page", "type" : "uri" } ],
+      "http://www.example.org/ns/property" : [ { "value" : "Blah blah blah", "type" : "literal" } ]
+    },
+    "http://www.example.org/other" : {
+          "http://www.example.org/ns/property" : [ { "value" : "Something", "type" : "literal" } ]        
+    }      
+  }
+  EOL
+
+    
+    def test_build_with_single_triple1
+        
+      cs = Pho::Update::ChangesetBuilder.build("http://www.example.org", JSON.parse("{}"), JSON.parse( SINGLE_TRIPLE_RESOURCE ) )
+      assert_not_nil(cs)
+      assert_equal("http://www.example.org", cs.subject_of_change)
+      assert_equal(0, cs.removals.length)  
+      assert_equal(1, cs.additions.length)
+      s = cs.additions[0]
+      assert_equal("http://www.example.org", s.subject)
+      assert_equal("http://www.example.org/ns/predicate", s.predicate)
+      assert_equal("http://www.example.org/page", s.object)
+    end
+  
+    def test_build_with_single_triple2
+        
+      cs = Pho::Update::ChangesetBuilder.build("http://www.example.org", JSON.parse("{}"), JSON.parse( SINGLE_TRIPLE_LITERAL ) )
+      assert_not_nil(cs)
+      assert_equal("http://www.example.org", cs.subject_of_change)
+      assert_equal(0, cs.removals.length)  
+      assert_equal(1, cs.additions.length)
+      s = cs.additions[0]
+      assert_equal("http://www.example.org", s.subject)
+      assert_equal("http://www.example.org/ns/predicate", s.predicate)
+      assert_equal("Title", s.object)
+      
+    end
+
+  def test_build_with_additions_and_removals
+      
+    cs = Pho::Update::ChangesetBuilder.build("http://www.example.org", JSON.parse(SINGLE_TRIPLE_LITERAL), JSON.parse( TWO_TRIPLES ) )
+    assert_not_nil(cs)
+    assert_equal("http://www.example.org", cs.subject_of_change)
+    assert_equal(1, cs.removals.length)  
+    assert_equal(2, cs.additions.length)
+    s = cs.removals[0]
+    assert_equal("http://www.example.org", s.subject)
+    assert_equal("http://www.example.org/ns/predicate", s.predicate)
+    assert_equal("Title", s.object)
+    s = cs.additions[0]
+    assert_equal("http://www.example.org", s.subject)
+    assert_equal("http://www.example.org/ns/resource", s.predicate)
+    assert_equal("http://www.example.org/page", s.object)
+    s = cs.additions[1]
+    assert_equal("http://www.example.org", s.subject)
+    assert_equal("http://www.example.org/ns/literal", s.predicate)
+    assert_equal("Title", s.object)
+    
+  end
+          
+  def test_create_statements
+      statements = Pho::Update::ChangesetBuilder.create_statements( JSON.parse(SINGLE_TRIPLE_RESOURCE) )
+      assert_not_nil(statements)
+      assert(1, statements.length)
+   
+      s = statements[0]
+      
+      assert_equal("http://www.example.org", s.subject)
+      assert_equal("http://www.example.org/ns/predicate", s.predicate)
+      assert_equal("http://www.example.org/page", s.object)
+      
+  end
+
+  def test_create_statements2
+    statements = Pho::Update::ChangesetBuilder.create_statements( JSON.parse(TWO_TRIPLES) )
+    assert_not_nil(statements)
+    assert(2, statements.length)        
+  end
+  
+  def test_batch_changeset
+    changesets = Pho::Update::ChangesetBuilder.build_batch(JSON.parse( TWO_TRIPLES ), JSON.parse( SOME_TRIPLES ) )
+    assert_equal(2, changesets.length)
+    first_uri_changes = changesets[0]
+    assert_equal("http://www.example.org", first_uri_changes.subject_of_change)
+    assert_equal(nil, first_uri_changes.creator_name)  
+    assert_equal(nil, first_uri_changes.change_reason)
+    removals = first_uri_changes.removals
+    assert_equal(1, removals.length)
+    assert_equal("http://www.example.org/ns/literal", removals[0].predicate)
+    additions = first_uri_changes.additions
+    assert_equal(1, additions.length)
+    assert_equal("http://www.example.org/ns/property", additions[0].predicate)
+    
+    second_uri_changes = changesets[1]
+    assert_equal("http://www.example.org/other", second_uri_changes.subject_of_change)
+    assert_equal(nil, second_uri_changes.creator_name)  
+    assert_equal(nil, second_uri_changes.change_reason)
+    removals = second_uri_changes.removals
+    assert_equal(0, removals.length)
+    additions = second_uri_changes.additions
+    assert_equal(1, additions.length)
+    assert_equal("http://www.example.org/ns/property", additions[0].predicate)
+    
+  end
+  
+  def test_batch_changeset_with_change_description
+    changesets = Pho::Update::ChangesetBuilder.build_batch(JSON.parse( TWO_TRIPLES ), JSON.parse( SOME_TRIPLES ), "Bob Bobson", "Because I can" )
+    assert_equal(2, changesets.length)
+    first_uri_changes = changesets[0]
+    assert_equal("http://www.example.org", first_uri_changes.subject_of_change)
+    assert_equal("Bob Bobson", first_uri_changes.creator_name)  
+    assert_equal("Because I can", first_uri_changes.change_reason)
+    
+  end              
+end

data/tests/tc_changesets.rb

@@ -0,0 +1,96 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'pho'
+require 'test/unit'
+require 'mocha'
+require 'rexml/document'
+require 'uri'
+
+class ChangesetsTest < Test::Unit::TestCase
+  SINGLE_TRIPLE_RESOURCE = <<-EOL
+  {
+    "http://www.example.org" : {
+      "http://www.example.org/ns/predicate" : [ { "value" : "http://www.example.org/page", "type" : "uri" } ]
+    }
+  }
+  EOL
+
+  SINGLE_TRIPLE_LITERAL = <<-EOL
+  {
+    "http://www.example.org" : {
+      "http://www.example.org/ns/predicate" : [ { "value" : "Title", "type" : "literal" } ]
+    }
+  }
+  EOL
+  
+  def test_submit_all
+    mc = mock()
+    mc.expects(:set_auth)
+    mc.expects(:post).with("http://api.talis.com/stores/testing/meta", anything, {"Content-Type" => "application/vnd.talis.changeset+xml"} )
+      
+    store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass", mc)
+    
+    changesets = Array.new
+    changesets << Pho::Update::Changeset.new("http://www.example.org/my-resource") do |c|
+      c.add_removal( Pho::Update::Statement.create_resource("http://www.example.org/my-resource", "http://xmlns.com/foaf/0.1/homePage", "http://www.example.org/page") )
+    end    
+
+    changesets << Pho::Update::Changeset.new("http://www.example.org/my-resource") do |c|
+      c.add_removal( Pho::Update::Statement.create_resource("http://www.example.org/my-resource", "http://xmlns.com/foaf/0.1/name", "Name") )
+    end    
+        
+    resp = Pho::Update::Changesets.submit_all(changesets, store)
+    
+  end  
+  
+  def test_all_to_rdf
+    
+    changesets = Array.new
+    changesets << Pho::Update::Changeset.new("http://www.example.org/my-resource") do |c|
+      c.add_removal( Pho::Update::Statement.create_resource("http://www.example.org/my-resource", "http://xmlns.com/foaf/0.1/homePage", "http://www.example.org/page") )
+    end    
+
+    changesets << Pho::Update::Changeset.new("http://www.example.org/my-resource") do |c|
+      c.add_removal( Pho::Update::Statement.create_resource("http://www.example.org/my-resource", "http://xmlns.com/foaf/0.1/name", "Name") )
+    end    
+    
+    rdf = Pho::Update::Changesets.all_to_rdf(changesets)
+    
+    doc = REXML::Document.new(rdf)
+    root = doc.root
+    assert_equal("RDF", root.name)
+    assert_equal("http://www.w3.org/1999/02/22-rdf-syntax-ns#", root.namespace)
+    count = 0
+    REXML::XPath.each(root, "cs:ChangeSet", Pho::Namespaces::MAPPING) do |cs|
+      count += 1 
+    end
+    assert_equal(2, count)
+  end
+  
+#  def test_build_with_single_triple1
+#      
+#    cs = Pho::Update::Changesets.build(nil, SINGLE_TRIPLE_RESOURCE)
+#    assert_not_nil(cs)
+#    assert_equal("http://www.example.org", cs.subject_of_change)
+#    assert_nil(cs.removal)  
+#    assert_not_nil(cs.addition)
+#    s = cs.addition
+#    assert_equal("http://www.example.org", s.subject)
+#    assert_equal("http://www.example.org/predicate", s.predicate)
+#    assert_equal("http://www.example.org/page", s.object)
+#  end
+#
+#  def test_build_with_single_triple2
+#      
+#    cs = Pho::Update::Changesets.build(nil, SINGLE_TRIPLE_LITERAL)
+#    assert_not_nil(cs)
+#    assert_equal("http://www.example.org", cs.subject_of_change)
+#    assert_nil(cs.removal)  
+#    assert_not_nil(cs.addition)
+#    s = cs.addition
+#    assert_equal("http://www.example.org", s.subject)
+#    assert_equal("http://www.example.org/predicate", s.predicate)
+#    assert_equal("Title", s.object)
+#    
+#  end
+    
+end

data/tests/tc_metabox.rb

@@ -21,7 +21,15 @@ class MetaboxTest < Test::Unit::TestCase
      store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass", mc)
      store.store_data("data")
   end
-  
+
+  def test_store_data_in_graph
+     mc = mock()
+     mc.expects(:set_auth)
+     mc.expects(:post).with("http://api.talis.com/stores/testing/meta/graphs/1", "data", {"Content-Type" => "application/rdf+xml"} )
+     store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass", mc)
+     store.store_data("data", "1")     
+  end
+      
   def test_store_file
      mc = mock()
      mc.expects(:set_auth)
@@ -42,7 +50,17 @@ class MetaboxTest < Test::Unit::TestCase
     store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass", mc)
     store.store_url( "http://www.example.org" )
   end
-  
+
+  def test_store_url_in_graph
+    mc = mock()
+    mc.expects(:set_auth)
+    mc.expects(:get).with("http://www.example.org", nil, {"Accept" => "application/rdf+xml"}).returns( HTTP::Message.new_response("data") )
+    mc.expects(:post).with("http://api.talis.com/stores/testing/meta/graphs/1", "data", {"Content-Type" => "application/rdf+xml"} )  
+    
+    store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass", mc)
+    store.store_url( "http://www.example.org", nil, "1" )
+  end
+      
   def test_describe_with_default_mimetype
      mc = mock()
      mc.expects(:set_auth)

data/tests/tc_query_profile.rb

@@ -55,7 +55,7 @@ EOL
     
     assert_has_single_property_with_literal(root, "frm:name", "title")
     assert_has_single_property_with_literal(root, "bf:weight", "10")
-        
+            
   end
     
     
@@ -86,10 +86,12 @@ EOL
     
     fpmap = children[0]
     assert_has_single_property_with_literal(fpmap, "rdfs:label", "test query profile")
+    
+    assert_equal(3, fpmap.get_elements("bf:fieldWeight").length )
      
   end  
   
-  def test_get_query_profile_from_store
+  def test_get_queryprofile_from_store
      mc = mock()
      mc.expects(:set_auth)
      mc.expects(:get).with("http://api.talis.com/stores/testing/config/queryprofiles/1", anything, {"Accept" => "application/json"})

data/tests/tc_rdf_json.rb

@@ -0,0 +1,273 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'pho'
+require 'test/unit'
+require 'mocha'
+require 'rexml/document'
+require 'uri'
+
+class RDFJSONTest < Test::Unit::TestCase
+  SINGLE_TRIPLE_RESOURCE = <<-EOL
+  {
+    "http://www.example.org" : {
+      "http://www.example.org/ns/resource" : [ { "value" : "http://www.example.org/page", "type" : "uri" } ]
+    }
+  }
+  EOL
+
+  SINGLE_TRIPLE_RESOURCE2 = <<-EOL
+  {
+    "http://www.example.org" : {
+      "http://www.example.org/ns/resource" : [ { "value" : "http://www.example.org/other-page", "type" : "uri" } ]
+    }
+  }
+  EOL
+    
+  SINGLE_TRIPLE_LITERAL = <<-EOL
+  {
+    "http://www.example.org" : {
+      "http://www.example.org/ns/literal" : [ { "value" : "Title", "type" : "literal" } ]
+    }
+  }
+  EOL
+
+  SINGLE_TRIPLE_LITERAL2 = <<-EOL
+  {
+    "http://www.example.org" : {
+      "http://www.example.org/ns/literal" : [ { "value" : "Other Title", "type" : "literal" } ]
+    }
+  }
+  EOL
+
+    
+  SINGLE_TRIPLE_DIFF_TYPE = <<-EOL
+  {
+    "http://www.example.org" : {
+      "http://www.example.org/ns/literal" : [ { "value" : "http://www.example.com", "type" : "uri" } ]
+    }
+  }
+  EOL
+
+  TWO_TRIPLES = <<-EOL
+  {
+    "http://www.example.org" : {
+      "http://www.example.org/ns/resource" : [ { "value" : "http://www.example.org/page", "type" : "uri" } ],
+      "http://www.example.org/ns/literal" : [ { "value" : "Title", "type" : "literal" } ]        
+    }
+  }
+  EOL
+
+  REPEATED_TRIPLES = <<-EOL
+  {
+    "http://www.example.org" : {
+      "http://www.example.org/ns/literal" : [ { "value" : "Title", "type" : "literal" }, { "value" : "Other Title", "type" : "literal" } ]        
+    }
+  }
+  EOL
+
+  SINGLE_TRIPLE_LITERAL_ENGLISH = <<-EOL
+  {
+    "http://www.example.org" : {
+      "http://www.example.org/ns/literal" : [ { "value" : "English", "type" : "literal", "lang" : "en" } ]
+    }
+  }
+  EOL
+
+  SINGLE_TRIPLE_LITERAL_FRENCH = <<-EOL
+  {
+    "http://www.example.org" : {
+      "http://www.example.org/ns/literal" : [ { "value" : "French", "type" : "literal", "lang" : "fr" } ]
+    }
+  }
+  EOL
+
+  SINGLE_TYPED_TRIPLE_INT = <<-EOL
+  {
+    "http://www.example.org" : {
+      "http://www.example.org/ns/literal" : [ { "value" : "1", "type" : "literal", "datatype" : "http://www.w3.org/2001/XMLSchema#int" } ]
+    }
+  }
+  EOL
+
+  SINGLE_TYPED_TRIPLE_FLOAT = <<-EOL
+  {
+    "http://www.example.org" : {
+      "http://www.example.org/ns/literal" : [ { "value" : "2.5", "type" : "literal", "datatype" : "http://www.w3.org/2001/XMLSchema#float" } ]
+    }
+  }
+  EOL
+  
+            
+  def test_minus_with_iso_graphs()
+  
+    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_RESOURCE), JSON.parse(SINGLE_TRIPLE_RESOURCE) )
+    assert_not_nil(difference)        
+    assert_equal(0, difference.keys.length)
+                
+  end
+    
+  def test_minus_with_single_resource_value_change()
+  
+    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_RESOURCE), JSON.parse(SINGLE_TRIPLE_RESOURCE2) )
+    assert_not_nil(difference)    
+    assert_equal(1, difference.keys.length)    
+    assert_equal( "http://www.example.org/page",
+      difference["http://www.example.org"]["http://www.example.org/ns/resource"][0]["value"] )
+
+    #reverse
+          
+    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_RESOURCE2), JSON.parse(SINGLE_TRIPLE_RESOURCE) )
+    assert_not_nil(difference)    
+    assert_equal(1, difference.keys.length)    
+    assert_equal( "http://www.example.org/other-page",
+      difference["http://www.example.org"]["http://www.example.org/ns/resource"][0]["value"] )
+            
+  end
+
+  def test_minus_with_single_literal_value_change()
+  
+    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_LITERAL), JSON.parse(SINGLE_TRIPLE_LITERAL2) )
+    assert_not_nil(difference)    
+    assert_equal(1, difference.keys.length)    
+    assert_equal( "Title",
+      difference["http://www.example.org"]["http://www.example.org/ns/literal"][0]["value"] )
+
+    #reverse          
+    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_LITERAL2), JSON.parse(SINGLE_TRIPLE_LITERAL) )
+    assert_not_nil(difference)    
+    assert_equal(1, difference.keys.length)    
+    assert_equal( "Other Title",
+      difference["http://www.example.org"]["http://www.example.org/ns/literal"][0]["value"] )
+            
+  end
+  
+  def test_minus_with_different_typed_predicate_values()
+  
+    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_LITERAL), JSON.parse(SINGLE_TRIPLE_DIFF_TYPE) )
+    assert_not_nil(difference)    
+    assert_equal(1, difference.keys.length)    
+    assert_equal( "Title",
+      difference["http://www.example.org"]["http://www.example.org/ns/literal"][0]["value"] )
+
+    #reverse
+    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_DIFF_TYPE), JSON.parse(SINGLE_TRIPLE_LITERAL) )
+    assert_not_nil(difference)    
+    assert_equal(1, difference.keys.length)    
+    assert_equal( "http://www.example.com",
+      difference["http://www.example.org"]["http://www.example.org/ns/literal"][0]["value"] )
+            
+  end
+
+  def test_minus_with_different_size_graphs()
+  
+    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_RESOURCE), JSON.parse(TWO_TRIPLES) )
+    assert_not_nil(difference)    
+    assert_equal(0, difference.keys.length)    
+
+    #reverse
+    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(TWO_TRIPLES), JSON.parse(SINGLE_TRIPLE_RESOURCE) )
+    assert_not_nil(difference)    
+    assert_equal(1, difference.keys.length)    
+    assert_equal( "Title",
+      difference["http://www.example.org"]["http://www.example.org/ns/literal"][0]["value"] )
+            
+  end      
+
+  def test_minus_with_repeated_properties()
+  
+    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_LITERAL), JSON.parse(REPEATED_TRIPLES) )
+    assert_not_nil(difference)    
+    assert_equal(0, difference.keys.length)    
+
+    #reverse
+    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(REPEATED_TRIPLES), JSON.parse(SINGLE_TRIPLE_LITERAL) )
+    assert_not_nil(difference)    
+    assert_equal(1, difference.keys.length)    
+    assert_equal( "Other Title",
+      difference["http://www.example.org"]["http://www.example.org/ns/literal"][0]["value"] )
+            
+  end      
+  
+  def test_minus_with_language_qualified_literals()
+    
+    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_LITERAL), JSON.parse(SINGLE_TRIPLE_LITERAL) )
+    assert_not_nil(difference)    
+    assert_equal(0, difference.keys.length)    
+
+    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_LITERAL_ENGLISH), JSON.parse(SINGLE_TRIPLE_LITERAL_ENGLISH) )
+    assert_not_nil(difference)    
+    assert_equal(0, difference.keys.length)
+    
+    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_LITERAL), JSON.parse(SINGLE_TRIPLE_LITERAL_ENGLISH) )
+    assert_not_nil(difference)    
+    assert_equal(1, difference.keys.length)
+    assert_equal( "Title",
+      difference["http://www.example.org"]["http://www.example.org/ns/literal"][0]["value"] )
+
+    #reverse no lang and english
+    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_LITERAL_ENGLISH), JSON.parse(SINGLE_TRIPLE_LITERAL) )
+    assert_not_nil(difference)    
+    assert_equal(1, difference.keys.length)
+    assert_equal( "English",
+      difference["http://www.example.org"]["http://www.example.org/ns/literal"][0]["value"] )
+    assert_equal( "en",
+      difference["http://www.example.org"]["http://www.example.org/ns/literal"][0]["lang"] )
+
+    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_LITERAL_ENGLISH), JSON.parse(SINGLE_TRIPLE_LITERAL_FRENCH) )
+    assert_not_nil(difference)    
+    assert_equal(1, difference.keys.length)
+    assert_equal( "English",
+      difference["http://www.example.org"]["http://www.example.org/ns/literal"][0]["value"] )
+    assert_equal( "en",
+      difference["http://www.example.org"]["http://www.example.org/ns/literal"][0]["lang"] )
+
+    #reverse no lang and english
+    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_LITERAL_FRENCH), JSON.parse(SINGLE_TRIPLE_LITERAL_ENGLISH) )
+    assert_not_nil(difference)    
+    assert_equal(1, difference.keys.length)
+    assert_equal( "French",
+      difference["http://www.example.org"]["http://www.example.org/ns/literal"][0]["value"] )
+    assert_equal( "fr",
+      difference["http://www.example.org"]["http://www.example.org/ns/literal"][0]["lang"] )
+                            
+  end        
+
+  def test_minus_with_typed_literals()
+    
+    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TYPED_TRIPLE_INT), JSON.parse(SINGLE_TYPED_TRIPLE_INT) )
+    assert_not_nil(difference)    
+    assert_equal(0, difference.keys.length)
+    
+    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_LITERAL), JSON.parse(SINGLE_TYPED_TRIPLE_INT) )
+    assert_not_nil(difference)    
+    assert_equal(1, difference.keys.length)
+    assert_equal( "Title",
+      difference["http://www.example.org"]["http://www.example.org/ns/literal"][0]["value"] )
+
+    #reverse no type and int
+    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TYPED_TRIPLE_INT), JSON.parse(SINGLE_TRIPLE_LITERAL) )
+    assert_not_nil(difference)    
+    assert_equal(1, difference.keys.length)
+    assert_equal( "1",
+      difference["http://www.example.org"]["http://www.example.org/ns/literal"][0]["value"] )
+    assert_equal( "http://www.w3.org/2001/XMLSchema#int",
+      difference["http://www.example.org"]["http://www.example.org/ns/literal"][0]["datatype"] )
+
+    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TYPED_TRIPLE_INT), JSON.parse(SINGLE_TYPED_TRIPLE_FLOAT) )
+    assert_not_nil(difference)    
+    assert_equal(1, difference.keys.length)
+    assert_equal( "1",
+      difference["http://www.example.org"]["http://www.example.org/ns/literal"][0]["value"] )
+    assert_equal( "http://www.w3.org/2001/XMLSchema#int",
+      difference["http://www.example.org"]["http://www.example.org/ns/literal"][0]["datatype"] )
+      
+    #reverse float and int
+    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TYPED_TRIPLE_FLOAT), JSON.parse(SINGLE_TYPED_TRIPLE_INT) )
+    assert_not_nil(difference)    
+    assert_equal(1, difference.keys.length)
+    assert_equal( "2.5",
+      difference["http://www.example.org"]["http://www.example.org/ns/literal"][0]["value"] )
+    assert_equal( "http://www.w3.org/2001/XMLSchema#float",
+      difference["http://www.example.org"]["http://www.example.org/ns/literal"][0]["datatype"] )
+                                  
+  end    
+end