pho 0.4 → 0.4.1

data/lib/pho/changeset_builder.rb

@@ -0,0 +1,118 @@
+module Pho
+      
+  require 'uri'
+  
+  #Module organizing classes related to Changeset handling.
+  module Update
+    
+    #Utility class providing methods for building Changesets from triple hashes
+    class ChangesetBuilder
+    
+      #Build a batch changeset
+      #
+      #This method is suitable for building an array of changesets that describe changes made to a
+      #number of different resources.
+      #
+      #Returns an array of Changeset objects
+      #
+      # before:: triple hash describing current state of the resource
+      # after:: triple hash describing updated state of the resource
+      # creator_name:: name of the creator of the changes
+      # change_reason:: description of why the changes are being made      
+      def ChangesetBuilder.build_batch(before, after, creator_name=nil, change_reason=nil)
+
+        removals = Pho::RDF_JSON::SetAlgebra.minus(before, after)
+        additions = Pho::RDF_JSON::SetAlgebra.minus(after, before)
+        
+        batch = Array.new
+        
+        removals.each do |uri, properties|
+          cs = Pho::Update::Changeset.new(uri, creator_name, change_reason) do |cs|
+              cs.add_removals( create_statements_for_uri(uri, properties) )
+              if additions.has_key?(uri)
+                cs.add_additions( create_statements_for_uri(uri, additions[uri] ) )
+                additions.delete(uri)
+              end      
+          end
+          batch << cs
+        end
+        
+        if !additions.empty?
+          additions.each do |uri, properties|
+            cs = Pho::Update::Changeset.new(uri, creator_name, change_reason) do |cs|
+                cs.add_additions( create_statements_for_uri(uri, properties) )
+            end
+            batch << cs            
+          end
+        end
+        
+        return batch
+        
+      end
+      
+      #Build a single changeset
+      #
+      #This method is suitable for building changesets that describe changes made to a single resource
+      #If the before/after hashes contain data for other subjects, then an error will be thrown.
+      #
+      #The method will return a single Changeset object.
+      #
+      # subject_of_change:: uri of the resource being updated
+      # before:: triple hash describing current state of the resource
+      # after:: triple hash describing updated state of the resource
+      # creator_name:: name of the creator of the changes
+      # change_reason:: description of why the changes are being made
+      def ChangesetBuilder.build(subject_of_change, before, after, creator_name=nil, change_reason=nil)
+        removals = Pho::RDF_JSON::SetAlgebra.minus(before, after)
+        additions = Pho::RDF_JSON::SetAlgebra.minus(after, before)
+        
+        cs = Pho::Update::Changeset.new(subject_of_change, creator_name, change_reason) do |cs|
+            cs.add_removals( create_statements(removals) )
+            cs.add_additions( create_statements(additions) )      
+        end
+        
+        return cs
+        
+      end  
+      
+      #Takes an triple hash and serializes it as an array of Pho::Update::Statement objects
+      #
+      # triples:: a hash of triples, conforming to RDF-in-JSON structure
+      def ChangesetBuilder.create_statements(triples)
+        statements = Array.new
+        triples.each do |uri, properties|
+           statements += create_statements_for_uri(uri, properties)
+        end
+        return statements
+      end
+
+      #Create statements for a specific uri, using predicate-object values in 
+      #the provided properties hash
+      #
+      # uri:: subject of change
+      # properties:: hash of predicate-object values
+      def ChangesetBuilder.create_statements_for_uri(uri, properties)
+        statements = Array.new
+        properties.each do |predicate, val_array|
+          val_array.each do |value|
+            s = nil
+            if value["type"] == "literal"
+                s = Pho::Update::Statement.create_literal(uri, predicate, value["value"], value["lang"], value["datatype"])
+            else
+                #TODO bnodes?
+                s = Pho::Update::Statement.create_resource(uri, predicate, value["value"])
+            end
+            if s != nil
+              statements << s
+            end
+          end
+        end
+        return statements        
+      end      
+      
+    end
+    
+  end
+  
+end
+  

data/lib/pho/job.rb

@@ -21,7 +21,7 @@ module Pho
       jobs = Array.new
       
       doc = REXML::Document.new(resp.content)
-      REXML::XPath.each(doc.root, "//bf:job", Pho::Namespaces::MAPPING).each do |el|
+      REXML::XPath.each(doc.root, "//bf:job", Pho::Namespaces::MAPPING) do |el|
         jobs << el.attributes["rdf:resource"]
       end
       return jobs

data/lib/pho/query_profile.rb

@@ -137,7 +137,7 @@ module Pho
       rdf << " <rdfs:label>#{@label}</rdfs:label> "
       
       @field_weights.each do |property|
-        rdf << " <frm:fieldWeight rdf:resource=\"#{property.uri}\"/> "
+        rdf << " <bf:fieldWeight rdf:resource=\"#{property.uri}\"/> "
       end
                   
       rdf << " </rdf:Description>"

data/lib/pho/rdf_json.rb

@@ -0,0 +1,81 @@
+module Pho
+
+  #TODO
+  #blank nodes
+  
+  #Module providing code for manipulating triple hashes structured according 
+  #to the RDF in JSON spec
+  module RDF_JSON
+    
+    #Class providing set algebra methods over triple hashes
+    class SetAlgebra
+      
+      #Accepts two triple hashes, expressed as RDF-in-JSON and returns a new
+      #Ruby data structure that constitutes the different between the two graphs
+      #
+      #i.e. the return value will be a hash containing the triples that are in the 
+      #first graph but which are not present in the second.
+      #
+      # first:: the first graph
+      # second:: the second graph.
+      def SetAlgebra.minus(first, second)
+        
+        difference = Hash.new        
+        first.each do |uri,properties|          
+          if second.has_key?(uri)           
+            properties.each do |predicate,value|              
+              if second[uri].has_key?(predicate)                
+                #second hash has same uri and predicate, so check value arrays                
+                second_value = second[uri][predicate]
+                value.each do |val|
+                  
+                  if !object_in_array?(second_value, val)
+
+                    difference[uri] ||= Hash.new
+                    difference[uri][predicate] ||= Array.new
+                    difference[uri][predicate] << val                      
+                  end
+                end
+                 
+              else                
+                #uri is in second, but not this property and value
+                difference[uri] ||= Hash.new
+                difference[uri][predicate] = value                
+              end              
+            end
+          else
+            #uri not in second, so pass all straight-through
+            difference[uri] = properties            
+          end
+          
+        end
+        
+        return difference
+        
+      end
+      
+      #Is there an object in the specified array, that matches the provided description
+      def SetAlgebra.object_in_array?(array, val)
+        array.each do |entry|
+
+          if entry["type"] == val["type"] 
+             if entry["value"] == val["value"]
+
+               if entry["type"] == "literal"
+                 if entry["datatype"] == val["datatype"] && 
+                    entry["lang"] = val["lang"]
+                    return true
+                 end                     
+               end
+               return true   
+             end
+            
+          end
+        end
+        return false
+      end
+    end
+    
+  end
+  
+end  

data/lib/pho/store.rb

@@ -2,14 +2,10 @@ module Pho
 
 #TODO:
 #
-# Make it work with Ruby < 1.8.7
-# Changesets
-# Multisparql
-#
 # Conditional deletions
 # If-Modified-Since support
 # Robustness in uri fetching
-
+# Etag Testing
   
   # The Store class acts as a lightweight client interface to the Talis Platform API  
   # (http://n2.talis.com/wiki/Platform_API). The class provides methods for interacting 
@@ -75,10 +71,19 @@ module Pho
     # METABOX
     #############
     
-    # Store some RDF in the Metabox associated with this store
+    # Store some RDF in the Metabox associated with this store. Default is to store the 
+    # data in the metabox, but a private graph name can also be specified.
+    
     # data:: a String containing the data to store
-    def store_data(data)
-      u = build_uri("/meta")
+    # graph_name:: name of a private graph in which to store the data. E.g. "1" or "private". Resolves to /meta/graphs/graph_name
+    def store_data(data, graph_name=nil)
+      u = nil
+      if graph_name == nil
+        u = build_uri("/meta")
+      else 
+        u = build_uri("/meta/graphs/#{graph_name}")  
+      end
+      
       response = @client.post(u, data, RDF_XML )
       return response
     end    
@@ -97,9 +102,14 @@ module Pho
     # An Accept header of "application/rdf+xml" will be sent in the request to support retrieval of RDF from
     # URLs that support Content Negotiation.
     #
+    # NOTE: Currently this method doesn't properly handle base uris of retrieved data. i.e. the data isn't parsed
+    # and there is no way to pass a base uri to the Platform. Be warned!
+    #
+    # The default is to store the data in the Metabox. But a private graph name can also be specified
     # u:: the url of the data
     # parameters:: a Hash of url parameters to pass when requesting data from the specified URL
-    def store_url(u, parameters=nil)
+    # graph_name:: name of a private graph in which to store the data. E.g. "1" or "private". Resolves to /meta/graphs/graph_name    
+    def store_url(u, parameters=nil, graph_name=nil)
       
       headers = ACCEPT_RDF.clone()
       dataresp = @client.get(u, parameters, headers )
@@ -109,7 +119,7 @@ module Pho
           throw  
       end
       
-      return store_data(dataresp.content)
+      return store_data(dataresp.content, graph_name)
       
     end
   
@@ -133,7 +143,29 @@ module Pho
       record_etags("#{u}?about=#{uri}", etags, response)        
       return response
     end
-  
+
+    # Submit a Changeset to the Platform to update the metabox
+    #
+    # Default behaviour is to update the metabox with an unversioned name
+    # However using the optional parameters, changes can be made versioned, and
+    # can also be submitted to private graphs.
+    #
+    # rdf:: the RDF/XML describing the changes
+    # versioned:: true or false to indicate this is a versioned change
+    # graph_name:: name of private graph to update instead of metabox
+    def submit_changeset(rdf, versioned=false, graph_name=nil)
+      uri = "/meta"
+      if graph_name != nil
+        uri = uri + "/graphs/#{graph_name}"
+      end
+      uri = uri + "/changesets" if versioned
+                
+      u = self.build_uri( uri )
+      headers = {"Content-Type" => "application/vnd.talis.changeset+xml"}
+      response = @client.post(u, rdf, headers)
+      return response
+    end  
+    
     #############
     # SERVICES
     #############
@@ -142,40 +174,46 @@ module Pho
     #
     # query:: the SPARQL query
     # format:: the preferred response format
-    def sparql_describe(query, format="application/rdf+xml")
-      return sparql(query, format)
+    def sparql_describe(query, format="application/rdf+xml", multisparql=false)
+      return sparql(query, format, multisparql)
     end
 
     #Perform a SPARQL CONSTRUCT query.
     #
     # query:: the SPARQL query
     # format:: the preferred response format        
-    def sparql_construct(query, format="application/rdf+xml")
-      return sparql(query, format)
+    def sparql_construct(query, format="application/rdf+xml", multisparql=false)
+      return sparql(query, format, multisparql)
     end
     
     #Perform a SPARQL ASK query.
     #
     # query:: the SPARQL query
     # format:: the preferred response format    
-    def sparql_ask(query, format="application/sparql-results+xml")
-      return sparql(query, format)
+    def sparql_ask(query, format="application/sparql-results+xml", multisparql=false)
+      return sparql(query, format, multisparql)
     end
     
     #Perform a SPARQL SELECT query.
     #
     # query:: the SPARQL query
     # format:: the preferred response format    
-    def sparql_select(query, format="application/sparql-results+xml")
-      return sparql(query, format)
+    def sparql_select(query, format="application/sparql-results+xml", multisparql=false)
+      return sparql(query, format, multisparql)
     end
     
     #Perform a SPARQL query
     #
     # query:: the SPARQL query
-    # format:: the preferred response format    
-    def sparql(query, format=nil)
-      u = self.build_uri("/services/sparql")
+    # format:: the preferred response format
+    # multisparql:: use default sparql service or multisparql service
+    def sparql(query, format=nil, multisparql=false)
+      if multisparql
+        u = self.build_uri("/services/multisparql")
+      else
+        u = self.build_uri("/services/sparql")    
+      end
+      
       params = {}
       params["query"] = query
       headers = {}
@@ -203,7 +241,7 @@ module Pho
     def search(query, params=nil)
       u = self.build_uri("/items")
       search_params = get_search_params(u, query, params)
-      response = @client.get(u, search_params, nil)
+      response = @client.get(u, search_params)
       return response
       
     end
@@ -225,7 +263,7 @@ module Pho
       u = self.build_uri("/services/facet")      
       search_params = get_search_params(u, query, params)
       search_params["fields"] = facets.join(",")
-      response = @client.get(u, search_params, nil)
+      response = @client.get(u, search_params)
       return response                             
     end
         
@@ -244,7 +282,7 @@ module Pho
     # uri:: the URL for the RSS 1.0 feed
     def augment_uri(uri)
       u = self.build_uri("/services/augment")
-      response = @client.get(u, {"data-uri" => uri}, nil)
+      response = @client.get(u, {"data-uri" => uri})
       return response          
     end
     

data/tests/tc_changeset.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 ChangesetTest < Test::Unit::TestCase
+
+  def test_equality_resources
+    one = Pho::Update::Statement.create_resource("http://www.example.org/my-resource", "http://xmlns.com/foaf/0.1/homePage", "http://www.example.org/page1")
+    two = Pho::Update::Statement.create_resource("http://www.example.org/my-resource", "http://xmlns.com/foaf/0.1/homePage", "http://www.example.org/page2")
+    assert_equal(false, one == two)
+    assert_equal(true, one != two)
+    
+    two = Pho::Update::Statement.create_resource("http://www.example.org/my-resource", "http://xmlns.com/foaf/0.1/homePage", "http://www.example.org/page1")
+    assert_are_equal(one, two)      
+  end
+
+  def test_equality_literals
+    one = Pho::Update::Statement.create_literal("http://www.example.org/my-resource", "http://xmlns.com/foaf/0.1/homePage", "one")
+    two = Pho::Update::Statement.create_literal("http://www.example.org/my-resource", "http://xmlns.com/foaf/0.1/homePage", "two")
+    assert_equal(false, one == two)
+    assert_equal(true, one != two)
+    
+    two = Pho::Update::Statement.create_literal("http://www.example.org/my-resource", "http://xmlns.com/foaf/0.1/homePage", "one")
+    assert_are_equal(one, two)
+            
+  end
+  
+  def test_statement_constructor
+    s = Pho::Update::Statement.create_literal("http://www.example.org/my-resource", "http://xmlns.com/foaf/0.1/homePage", "one", "en")
+    s = Pho::Update::Statement.create_literal("http://www.example.org/my-resource", "http://xmlns.com/foaf/0.1/homePage", "one", nil, "http://www.example.org/datatype")
+    assert_raise RuntimeError do
+      s = Pho::Update::Statement.create_literal("http://www.example.org/my-resource", "http://xmlns.com/foaf/0.1/homePage", "one", "en", "http://www.example.org/datatype")
    end
+  end
+
+  def test_statement_constructor_visibility
+    assert_raise NoMethodError do 
+      s = Pho::Update::Statement.new("http://www.example.org/my-resource", "http://xmlns.com/foaf/0.1/homePage", "one", "en")  
+    end
+    
+  end
+  
+  #Test validation code in constructor
+  def test_must_pass_uri_to_constructor
+    
+    assert_raise URI::InvalidURIError do
+      cs = Pho::Update::Changeset.new(nil)
+    end
+    
+    assert_raise URI::InvalidURIError do
+      cs = Pho::Update::Changeset.new("literal")
+    end
+    cs = Pho::Update::Changeset.new("http://www.example.org/my-resource")
+    
+  end
+    
+  def assert_are_equal(one, two)
+    assert_equal(true, one == two)
+    assert_equal(false, one != two)
+
+    assert_equal(true, two == one)
+    assert_equal(false, two != one)    
+  end
+  
+  def test_cannot_add_with_wrong_subject()
+    cs = Pho::Update::Changeset.new("http://www.example.org")
+    assert_raise RuntimeError do
+      cs.add_addition( Pho::Update::Statement.create_literal("http://example.net", "http://example.net/predicate", "foo") )
    end
+    assert_raise RuntimeError do
+      cs.add_removal( Pho::Update::Statement.create_literal("http://example.net", "http://example.net/predicate", "foo") )
+    end    
+  end
+  
+  def test_to_rdf_empty_changeset
+      cs = Pho::Update::Changeset.new("http://www.example.org/my-resource")
+      
+      rdf = cs.to_rdf()
+      assert_not_nil(rdf)
+  
+      cs_el = get_changeset(rdf)
+      soc = REXML::XPath.first(cs_el, "cs:subjectOfChange", Pho::Namespaces::MAPPING)
+      assert_equal("http://www.example.org/my-resource", soc.attributes["rdf:resource"] )
+      
+      el = REXML::XPath.first(cs_el, "cs:creatorName", Pho::Namespaces::MAPPING)
+      assert_nil(el)
+      el = REXML::XPath.first(cs_el, "cs:changeReason", Pho::Namespaces::MAPPING)
+      assert_nil(el) 
+       
+  end
+  
+  def test_to_rdf_empty_changeset_with_creator_and_reason
+      cs = Pho::Update::Changeset.new("http://www.example.org/my-resource", "creator", "reason")
+      
+      cs_el = get_changeset(cs.to_rdf)
+      soc = REXML::XPath.first(cs_el, "cs:subjectOfChange", Pho::Namespaces::MAPPING)
+      assert_equal("http://www.example.org/my-resource", soc.attributes["rdf:resource"] )
+      
+      el = REXML::XPath.first(cs_el, "cs:creatorName", Pho::Namespaces::MAPPING)
+      assert_equal("creator", el.text)
+      el = REXML::XPath.first(cs_el, "cs:changeReason", Pho::Namespaces::MAPPING)
+      assert_equal("reason", el.text)
+       
+  end    
+
+  def test_to_rdf_empty_changeset_with_block
+      cs = Pho::Update::Changeset.new("http://www.example.org/my-resource") do |obj|
+        obj.creator_name = "creator"
+        obj.change_reason = "reason"
+      end
+        
+      root = parse(cs.to_rdf)
+      cs_el = REXML::XPath.first(root, "cs:ChangeSet", Pho::Namespaces::MAPPING)
+      soc = REXML::XPath.first(cs_el, "cs:subjectOfChange", Pho::Namespaces::MAPPING)
+      assert_equal("http://www.example.org/my-resource", soc.attributes["rdf:resource"] )
+      
+      el = REXML::XPath.first(cs_el, "cs:creatorName", Pho::Namespaces::MAPPING)
+      assert_equal("creator", el.text)
+      el = REXML::XPath.first(cs_el, "cs:changeReason", Pho::Namespaces::MAPPING)
+      assert_equal("reason", el.text)
+       
+  end    
+  
+  def test_to_rdf_with_resource_addition
+    cs = Pho::Update::Changeset.new("http://www.example.org/my-resource") do |c|
+      c.add_addition( Pho::Update::Statement.create_resource("http://www.example.org/my-resource", "http://xmlns.com/foaf/0.1/homePage", "http://www.example.org/page") )
+    end        
+    assert_equal(1, cs.additions.length)
+    assert_equal(0, cs.removals.length)
+
+    cs_el = get_changeset(cs.to_rdf)
+    
+    addition = REXML::XPath.first(cs_el, "cs:addition", Pho::Namespaces::MAPPING)
+    assert_not_nil(addition)
+    statement = REXML::XPath.first(addition, "rdf:Statement", Pho::Namespaces::MAPPING)
+    assert_not_nil(statement)    
+    el = REXML::XPath.first(statement, "rdf:subject", Pho::Namespaces::MAPPING)
+    assert_equal("http://www.example.org/my-resource", el.attributes["rdf:resource"])
+    el = REXML::XPath.first(statement, "rdf:predicate", Pho::Namespaces::MAPPING)
+    assert_equal("http://xmlns.com/foaf/0.1/homePage", el.attributes["rdf:resource"])
+    el = REXML::XPath.first(statement, "rdf:object", Pho::Namespaces::MAPPING)
+    assert_equal("http://www.example.org/page", el.attributes["rdf:resource"])
+    assert_equal(nil, el.text)
+            
+  end  
+
+  def test_to_rdf_with_literal_addition
+    cs = Pho::Update::Changeset.new("http://www.example.org/my-resource") do |c|
+      c.add_addition( Pho::Update::Statement.create_literal("http://www.example.org/my-resource", "http://xmlns.com/foaf/0.1/homePage", "literal") )
+    end    
+    assert_equal(1, cs.additions.length)
+    
+    cs_el = get_changeset(cs.to_rdf)
+    
+    addition = REXML::XPath.first(cs_el, "cs:addition", Pho::Namespaces::MAPPING)
+    assert_not_nil(addition)
+    statement = REXML::XPath.first(addition, "rdf:Statement", Pho::Namespaces::MAPPING)
+    assert_not_nil(statement)
+    el = REXML::XPath.first(statement, "rdf:subject", Pho::Namespaces::MAPPING)
+    assert_equal("http://www.example.org/my-resource", el.attributes["rdf:resource"])
+    el = REXML::XPath.first(statement, "rdf:predicate", Pho::Namespaces::MAPPING)
+    assert_equal("http://xmlns.com/foaf/0.1/homePage", el.attributes["rdf:resource"])
+    el = REXML::XPath.first(statement, "rdf:object", Pho::Namespaces::MAPPING)
+    assert_equal(nil, el.attributes["rdf:resource"])
+    assert_equal("literal", el.text)
+            
+  end
+
+  def test_to_rdf_with_resource_removal
+    cs = 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    
+    assert_equal(0, cs.additions.length)
+    assert_equal(1, cs.removals.length)
+    
+    cs_el = get_changeset(cs.to_rdf)
+    
+    removal = REXML::XPath.first(cs_el, "cs:removal", Pho::Namespaces::MAPPING)
+    assert_not_nil(removal)
+    
+    statement = REXML::XPath.first(removal, "rdf:Statement", Pho::Namespaces::MAPPING)
+    assert_not_nil(statement)    
+    el = REXML::XPath.first(statement, "rdf:subject", Pho::Namespaces::MAPPING)
+    assert_equal("http://www.example.org/my-resource", el.attributes["rdf:resource"])
+    el = REXML::XPath.first(statement, "rdf:predicate", Pho::Namespaces::MAPPING)
+    assert_equal("http://xmlns.com/foaf/0.1/homePage", el.attributes["rdf:resource"])
+    el = REXML::XPath.first(statement, "rdf:object", Pho::Namespaces::MAPPING)
+    assert_equal("http://www.example.org/page", el.attributes["rdf:resource"])
+    assert_equal(nil, el.text)
+            
+  end  
+  
+  def test_submit_changeset
+    mc = mock()
+    mc.expects(:set_auth)
+    mc.expects(:post).with("http://api.talis.com/stores/testing/meta", "data", {"Content-Type" => "application/vnd.talis.changeset+xml"} )
+      
+    store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass", mc)
+    resp = store.submit_changeset("data")            
+  end  
+
+  def test_submit_changeset_to_graph
+    mc = mock()
+    mc.expects(:set_auth)
+    mc.expects(:post).with("http://api.talis.com/stores/testing/meta/graphs/1", "data", {"Content-Type" => "application/vnd.talis.changeset+xml"} )
+      
+    store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass", mc)
+    resp = store.submit_changeset("data", false, "1")
+                
+  end
+    
+  def test_submit_versioned_changeset
+    mc = mock()
+    mc.expects(:set_auth)
+    mc.expects(:post).with("http://api.talis.com/stores/testing/meta/changesets", "data", {"Content-Type" => "application/vnd.talis.changeset+xml"} )
+      
+    store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass", mc)
+    resp = store.submit_changeset("data", true)            
+  end  
+
+  def test_submit_versioned_changeset_to_graph
+    mc = mock()
+    mc.expects(:set_auth)
+    mc.expects(:post).with("http://api.talis.com/stores/testing/meta/graphs/1/changesets", "data", {"Content-Type" => "application/vnd.talis.changeset+xml"} )
+      
+    store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass", mc)
+    resp = store.submit_changeset("data", true, "1")            
+  end  
+
+          
+  def test_submit
+    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)
+    
+    cs = 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    
+    
+    resp = cs.submit(store)
+    
+  end
+
+  def test_submit_versioned
+    mc = mock()
+    mc.expects(:set_auth)
+    mc.expects(:post).with("http://api.talis.com/stores/testing/meta/changesets", anything, {"Content-Type" => "application/vnd.talis.changeset+xml"} )
+      
+    store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass", mc)
+    
+    cs = 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    
+    
+    resp = cs.submit(store, true)
+    
+  end
+    
+  #parse rdf, return root element
+  def parse(rdf)
+    doc = REXML::Document.new(rdf)
+    return doc.root()
+  end
+
+  #parse rdf/xml and retrieve the changeset element
+  def get_changeset(rdf)
+    root = parse(rdf)
+    return REXML::XPath.first(root, "cs:ChangeSet", Pho::Namespaces::MAPPING)
+  end     
+end