pho 0.6.2 → 0.7

data/lib/pho.rb

@@ -24,6 +24,7 @@ require 'pho/command_line'
 #Following depend on redland
 require 'pho/converter'
 require 'pho/rdf'
+require 'pho/oai'
 
 if RUBY_VERSION < "1.8.7"
   class String
@@ -39,6 +40,8 @@ module Pho
   ACCEPT_JSON = { "Accept" => "application/json" }.freeze
   
   RDF_XML = {"Content-Type"=>"application/rdf+xml"}.freeze
+  TURTLE = {"Content-Type"=>"text/turtle"}.freeze
+  NTRIPLES = {"Content-Type"=>"text/plain"}.freeze
     
   class Namespaces
 

data/lib/pho/command_line.rb

@@ -3,20 +3,56 @@ module Pho
   #Class that implements the command-line behaviour
   class CommandLine
 
-    def initialize(store, opts)
-       @store = store      
-       @opts = opts
+    def initialize(opts, env, store=nil)
+     @opts = opts
+     @env = env          
+      
+     if username() == nil
+       raise "no <username>"
+     end
+     if password() == nil
+        raise "no <password>"
+     end
+     if storename() == nil && store == nil
+        raise "no <store>"
+     end
+
+     @store = Pho::Store.new(storename(), username(), password()) if store == nil
+     @store = store if store != nil
+           
+    end
+        
+    def username()
+     return @opts["username"] if @opts["username"]
+     return @env["TALIS_USER"] if @env["TALIS_USER"]
+     return nil  
+    end
+
+    def password()
+     return @opts["password"] if @opts["password"]
+     return @env["TALIS_PASS"] if @env["TALIS_PASS"]
+     return nil  
+    end
+    
+    def storename()      
+      store = nil
+      store = @env["TALIS_STORE"] if @env["TALIS_STORE"]
+      store = @opts["store"] if @opts["store"]
+      if store != nil && !store.start_with?("http")
+          store = "http://api.talis.com/stores/#{store}"  
+      end
+      return store      
     end
     
     def status()
       status = Pho::Status.read_from_store(@store)
-      puts "Store Status:\nReadable: #{status.readable?}\nWritable: #{status.writeable?}"      
+      puts "Status of Store #{@store.storeuri}:\nReadable: #{status.readable?}\nWritable: #{status.writeable?}"      
     end
     
     def backup()
-      puts "Submitting Snapshot Job"
+      puts "Submitting Snapshot Job to Store #{@store.storeuri}"
       resp = Pho::Jobs.submit_snapshot(@store, "Reindex", Time.now)
-      puts "Monitoring Job"
+      puts "Monitoring Snapshot Job: #{resp.header["Location"].first}"
       job = Pho::Jobs.wait_for_submitted(resp, @store) do |job, message, time|
          puts "#{time} #{message}"
       end 
@@ -29,9 +65,9 @@ module Pho
     end
     
     def snapshot()
-      puts "Submitting Snapshot Job"
+      puts "Submitting Snapshot Job to Store #{@store.storeuri}"
       resp = Pho::Jobs.submit_snapshot(@store, "Reindex", Time.now)
-      puts "Monitoring Job"
+      puts "Monitoring Snapshot Job #{resp.header["Location"].first}"
       job = Pho::Jobs.wait_for_submitted(resp, @store) do |job, message, time|
         puts "#{time} #{message}"
       end 
@@ -39,7 +75,7 @@ module Pho
     end
     
     def reindex()
-      puts "Submitting Reindex Job"
+      puts "Submitting Reindex Job to Store #{@store.storeuri}"
       resp = Pho::Jobs.submit_reindex(@store, "Reindex", Time.now)
       if resp.status == 201
           puts "Monitoring Reindex Job: #{resp.header["Location"].first}"
@@ -51,9 +87,9 @@ module Pho
     end
     
     def reset()
-      puts "Resetting Store"
+      puts "Resetting Store #{@store.storeuri}"
       resp = Pho::Jobs.submit_reset(@store, "Reset", Time.now)
-      puts "Monitoring Reset Job:"
+      puts "Monitoring Reset Job: #{resp.header["Location"].first}"
       job = Pho::Jobs.wait_for_submitted(resp, @store) do |job, message, time|
         puts "#{time} #{message}"
       end 
@@ -63,12 +99,13 @@ module Pho
     def restore()
       url = @opts["url"]     
       if url == nil
-        puts "Restore from latest snapshot"
+        puts "Restoring #{@store.storeuri} from latest snapshot"
         snapshot = Pho::Snapshot.read_from_store(@store)
         url = snapshot.url
       end
       puts "Restoring from #{url}"    
       resp = Pho::Jobs.submit_restore(@store, url, "Reset", Time.now)
+      puts "Monitoring Restore Job: #{resp.header["Location"].first}"
       job = Pho::Jobs.wait_for_submitted(resp, @store) do |job, message, time|
         puts "#{time} #{message}"
       end 
@@ -105,7 +142,9 @@ module Pho
         puts "Storing local file: #{@opts["file"]}"
         f = File.new( @opts["file"] )
         if File.extname( @opts["file"] ) == ".nt"
-          Pho::RDF::Parser.store_ntriples(f, @store)
+          resp = @store.store_file( f, nil, "text/plain" )
+        elsif File.extname( @opts["file"] ) == ".ttl"
+          resp = @store.store_file( f, nil, "text/turtle" )
         else
           resp = @store.store_file( f )  
         end          
@@ -133,7 +172,7 @@ module Pho
       if @opts["file"]
         f = File.new( @opts["file"] )
         uri = File.basename( @opts["file"] )
-        uri = "#{opts["base"]}/#{uri}" if @opts["base"]            
+        uri = "#{@opts["base"]}/#{uri}" if @opts["base"]            
         mime = MIME::Types.type_for( @opts["file"] )[0].to_s
         puts "Uploading file: #{ @opts["file"] } to /items/#{ uri } as #{mime}"
         resp = @store.upload_item( f , mime , uri )
@@ -160,7 +199,93 @@ module Pho
         end         
       end                
     end
+    
+    def fpmap(out=$stdout)
+      
+      if @opts["raw"]
+        resp = @store.get_field_predicate_map(Pho::ACCEPT_RDF)        
+        if resp.status != 200
+          out.puts "Unable to read Field Predicate Map from store. Response code was #{resp.status}"
+        else
+          out.puts resp.content
+        end
+      else  
+        fpmap = Pho::FieldPredicateMap.read_from_store(@store)
+        mappings = fpmap.datatype_properties.sort { |x,y| x.name <=> y.name }
+        mappings.each do |mapping|        
+          analyzer = mapping.analyzer
+          if analyzer != nil
+            Pho::Analyzers.constants.each do |c|
+              if analyzer == Pho::Analyzers.const_get(c)
+                analyzer = c
+              end
+            end
+          end
+          out.puts "#{mapping.name} -> #{mapping.property_uri}" if analyzer == nil
+          out.puts "#{mapping.name} -> #{mapping.property_uri} (#{mapping.analyzer})" if analyzer != nil
+        end 
+      
+      end
+            
+    end
+
+    def queryprofile(out=$stdout)
+
+      if @opts["raw"]
+        resp = @store.get_query_profile(Pho::ACCEPT_RDF)        
+        if resp.status != 200
+          out.puts "Unable to read Query Profile from store. Response code was #{resp.status}"
+        else
+          out.puts resp.content
+        end
+      else  
+        queryprofile = Pho::QueryProfile.read_from_store(@store)
+        field_weights = queryprofile.field_weights()
+        field_weights = field_weights.sort { |x,y| x.name <=> y.name }
+        field_weights.each do |weighting|
+          out.puts "#{weighting.name} -> #{weighting.weight}"
+        end      
+      end
+            
+    end
+
+    def add_mapping(out=$stdout)
+      fpmap = Pho::FieldPredicateMap.read_from_store(@store)
+      mapping = Pho::FieldPredicateMap.create_mapping(@store, @opts["predicate"], @opts["field"], @opts["analyzer"])
+
+      removed = fpmap.remove_by_name(@opts["field"])
+      if removed != nil
+        out.puts("Replacing mapping for #{@opts["field"]}")  
+      end      
+      fpmap << mapping
+      resp = fpmap.upload(@store)
+      if resp.status != 200
+        out.puts "Unable to update FieldPredicate map in store. Response code was #{resp.status}"
+      else
+        out.puts "FieldPredicate map successfully updated"
+      end
+    end
 
+    def add_weight(out=$stdout)
+      qp = Pho::QueryProfile.read_from_store(@store)
+      weight = Pho::QueryProfile.create_weighting(@store, @opts["field"], @opts["weight"])
+      
+      removed = qp.remove_by_name( @opts["field"] )
+      if removed != nil
+          out.puts("Replacing weighting for #{@opts["field"]}")        
+      end
+      qp << weight
+      resp = qp.upload(@store)
+      if resp.status != 200
+        out.puts "Unable to update QueryProfile in store. Response code was #{resp.status}"
+      else
+        out.puts "QueryProfile successfully updated"
+      end      
+    end
+    
+    #TODO remove_mapping
+    
+  #End CommandLine      
   end
   
 end

data/lib/pho/field_predicate_map.rb

@@ -113,9 +113,8 @@ module Pho
         end
 
         fpmap_uri = store.build_uri("/config/fpmaps/1")
-        
+      
         json = JSON.parse( resp.content )
-        
         labels = json[fpmap_uri]["http:\/\/www.w3.org\/2000\/01\/rdf-schema#label"]
         label = ""
         if labels != nil

data/lib/pho/oai.rb

@@ -0,0 +1,58 @@
+module Pho
+
+  #OAI-PMH Support
+  module OAI
+  
+    class Record
+      
+        attr_reader :identifier
+        attr_reader :timestamp
+        
+        def initialize(identifier, timestamp)
+          @identifier = identifier
+          @timestamp = timestamp
+        end  
+        
+    end
+    
+    #Collection of records
+    class Records
+    
+      attr_reader :responseDate, :from, :to, :records, :token
+      
+      def initialize(responseDate, token, from, to, records=[])
+        @responseDate = responseDate
+        @token = token
+        @from = from
+        @to = to
+        @records = records
+      end
+      
+      def Records.parse(response)
+        doc = REXML::Document.new(response)
+        records = []
+        REXML::XPath.each( doc.root,  "//oai:header", {"oai" => "http://www.openarchives.org/OAI/2.0/"} ) do |header|
+         uri = header.get_elements("identifier")[0].text
+         datestamp = header.get_elements("datestamp")[0].text
+         records << Record.new(uri, datestamp)
+        end
+        #FIXME
+        return Records.new(nil, nil, nil, nil, records)   
+      end
+      
+      #List records from a store
+      #TODO support for from/to dates
+      #TODO support for resumption tokens
+      def Records.read_from_store(store)
+        resp = store.list_records
+        if resp.status != 200
+          raise "Unable to list records"
+        end
+        return parse(resp.content)
+      end
+        
+    end
+    
+  end  
+  
+end

data/lib/pho/rdf.rb

@@ -51,6 +51,7 @@ module Pho
       # store:: the store to receive the data
       # base_uri:: base uri against which the data is parsed
       # graph_name:: uri of graph in store
+      # TODO: can now be submitted as turtle
       def Parser.store_ntriples(file, store, base_uri=nil, graph_name=nil)
          data = Parser.parse_ntriples(file, base_uri)
          return store.store_data(data, graph_name)       
@@ -62,6 +63,7 @@ module Pho
       # store:: the store to receive the data
       # base_uri:: base uri against which the data is parsed
       # graph_name:: uri of graph in store
+      # TODO: can now be submitted as turtle      
       def Parser.store_ntriples_from_string(string, store, base_uri, graph_name=nil)
          data = Parser.parse_ntriples_from_string(string, base_uri)
          return store.store_data(data, graph_name)       

data/lib/pho/rdf_collection.rb

@@ -9,21 +9,33 @@ module Pho
       class RDFManager < AbstractFileManager
       
         RDF = "rdf".freeze
+        TTL = "ttl".freeze
+        NT = "nt".freeze
         
-        def initialize(store, dir, rdf_suffix=RDF, ok_suffix=OK, fail_suffix=FAIL, sleep=1)
+        ALL_RDF = [RDF, TTL, NT]
+        
+        def initialize(store, dir, rdf_suffixes=ALL_RDF, ok_suffix=OK, fail_suffix=FAIL, sleep=1)
           super(store, dir, ok_suffix, fail_suffix, sleep)
-          @rdf_suffix = rdf_suffix
+          @rdf_suffixes = rdf_suffixes
         end
                     
         #List files being managed
         def list(recursive=false)
-            return Dir.glob( File.join(@dir, "*.#{@rdf_suffix}") )  
+            return Dir.glob( File.join(@dir, "*.\{#{ @rdf_suffixes.join(",") }\}") )  
         end
          
         protected
     
         def store_file(file, filename)
-          response = @store.store_file(file)
+          ext = File.extname(filename)
+          if ext == ".ttl"
+            response = @store.store_file(file, nil, "text/turtle")
+          elsif ext == ".nt" 
+            response = @store.store_file(file, nil, "text/turtle")
+          else
+            response = @store.store_file(file)
+          end
+                    
           if (response.status < 300 )
             File.open(get_ok_file_for(filename), "w") do |file|
               file.print( "OK" )            

data/lib/pho/store.rb

@@ -78,7 +78,8 @@ module Pho
     
     # data:: a String containing the data to store
     # 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)
+    # format:: mimetype of RDF serialization
+    def store_data(data, graph_name=nil, format="application/rdf+xml")
       u = nil
       if graph_name == nil
         u = build_uri("/meta")
@@ -86,17 +87,24 @@ module Pho
         u = build_uri("/meta/graphs/#{graph_name}")  
       end
       
-      response = @client.post(u, data, RDF_XML )
+      if format == "text/plain"
+        format = "text/turtle"
+      end
+      
+      content_type = {"Content-Type"=> format }
+      response = @client.post(u, data, content_type )
       return response
     end    
     
     # Store the contents of a File (or any IO stream) in the Metabox associated with this store
     # The client does not support streaming submissions of data, so the stream will be fully read before data is submitted to the platform
-    # file:: an IO object      
-    def store_file(file)
+    # file:: an IO object  
+    # graph_name:: name of a private graph in which to store teh data. E.g. "1" or "private". Resolves to /meta/graphs/graph_name
+    # format:: mimetype of RDF serialization
+    def store_file(file, graph_name=nil, format="application/rdf+xml")      
       data = file.read()
       file.close()
-      return store_data(data)
+      return store_data(data, graph_name, format)
     end
     
     # Retrieve RDF data from the specified URL and store it in the Store Metabox
@@ -431,6 +439,16 @@ module Pho
       return response      
     end              
 
+    #############
+    # OAI
+    #############
+    
+    def list_records
+      u = build_uri("/services/oai-pmh")
+      response = @client.get(u, {"verb" => "ListRecords", "metadataPrefix" => "oai_dc"})
+      return response
+    end
+        
     #############
     # CONFIG
     #############

data/tests/tc_command_line.rb

@@ -0,0 +1,229 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'pho'
+require 'test/unit'
+require 'mocha'
+
+class CommandLineTest < Test::Unit::TestCase
+  
+  TEST_FPMAP = <<-EOL
+  {
+    "http:\/\/api.talis.com\/stores\/testing\/config\/fpmaps\/1#description" : {
+      "http:\/\/schemas.talis.com\/2006\/frame\/schema#property" : [ { "value" : "http:\/\/purl.org\/dc\/elements\/1.1\/description", "type" : "uri" } ],
+      "http:\/\/schemas.talis.com\/2006\/frame\/schema#name" : [ { "value" : "description", "type" : "literal" } ]
+    },
+    "http:\/\/api.talis.com\/stores\/testing\/config\/fpmaps\/1" : {
+      "http:\/\/www.w3.org\/2000\/01\/rdf-schema#label" : [ { "value" : "default field\/predicate map", "type" : "literal" } ],
+      "http:\/\/www.w3.org\/1999\/02\/22-rdf-syntax-ns#type" : [ { "value" : "http:\/\/schemas.talis.com\/2006\/bigfoot\/configuration#FieldPredicateMap", "type" : "uri" } ],
+      "http:\/\/schemas.talis.com\/2006\/frame\/schema#mappedDatatypeProperty" : [ 
+        { "value" : "http:\/\/api.talis.com\/stores\/testing\/config\/fpmaps\/1#name", "type" : "uri" },
+        { "value" : "http:\/\/api.talis.com\/stores\/testing\/config\/fpmaps\/1#title", "type" : "uri" },
+        { "value" : "http:\/\/api.talis.com\/stores\/testing\/config\/fpmaps\/1#description", "type" : "uri" }
+      ]
+    },
+    "http:\/\/api.talis.com\/stores\/testing\/config\/fpmaps\/1#title" : {
+      "http:\/\/schemas.talis.com\/2006\/frame\/schema#property" : [ { "value" : "http:\/\/purl.org\/dc\/elements\/1.1\/title", "type" : "uri" } ],
+      "http:\/\/schemas.talis.com\/2006\/frame\/schema#name" : [ { "value" : "title", "type" : "literal" } ]
+    },
+    "http:\/\/api.talis.com\/stores\/testing\/config\/fpmaps\/1#name" : {
+      "http:\/\/schemas.talis.com\/2006\/frame\/schema#property" : [ { "value" : "http:\/\/xmlns.com\/foaf\/0.1\/name", "type" : "uri" } ],
+      "http:\/\/schemas.talis.com\/2006\/frame\/schema#name" : [ { "value" : "name", "type" : "literal" } ]
+    }
+  }  
+EOL
+  
+  TEST_QP = <<-EOL
+  {
+    "http:\/\/api.talis.com\/stores\/testing\/config\/queryprofiles\/1" : {
+      "http:\/\/www.w3.org\/2000\/01\/rdf-schema#label" : [ { "value" : "default query profile", "type" : "literal" } ],
+      "http:\/\/www.w3.org\/1999\/02\/22-rdf-syntax-ns#type" : [ { "value" : "http:\/\/schemas.talis.com\/2006\/bigfoot\/configuration#QueryProfile", "type" : "uri" } ],
+      "http:\/\/schemas.talis.com\/2006\/bigfoot\/configuration#fieldWeight" : [ 
+        { "value" : "http:\/\/api.talis.com\/stores\/testing\/config\/queryprofiles\/1#name", "type" : "uri" },
+        { "value" : "http:\/\/api.talis.com\/stores\/testing\/config\/queryprofiles\/1#nick", "type" : "uri" }
+      ]
+    },
+    "http:\/\/api.talis.com\/stores\/testing\/config\/queryprofiles\/1#nick" : {
+      "http:\/\/schemas.talis.com\/2006\/bigfoot\/configuration#weight" : [ { "value" : "1.0", "type" : "literal" } ],
+      "http:\/\/schemas.talis.com\/2006\/frame\/schema#name" : [ { "value" : "nick", "type" : "literal" } ]
+    },
+    "http:\/\/api.talis.com\/stores\/testing\/config\/queryprofiles\/1#name" : {
+      "http:\/\/schemas.talis.com\/2006\/bigfoot\/configuration#weight" : [ { "value" : "2.0", "type" : "literal" } ],
+      "http:\/\/schemas.talis.com\/2006\/frame\/schema#name" : [ { "value" : "name", "type" : "literal" } ]
+    }
+  }  
+EOL
+
+  def setup
+    @opts = {}
+    @opts["username"] = "tester"
+    @opts["password"] = "pass"
+    @opts["store"] = "testing"
+    
+  end
+  
+  def teardown
+  end
+  
+  def test_fpmap()
+    mc = mock()
+    mc.expects(:build_uri).returns( "http://api.talis.com/stores/testing/config/fpmaps/1" )
+    mc.expects(:get_field_predicate_map).returns( HTTP::Message.new_response(TEST_FPMAP) )
+    
+    s = StringIO.new()
+    cmdline = Pho::CommandLine.new(@opts, {}, mc)
+    cmdline.fpmap(s)
+    
+    lines = s.string().split("\n")
+    assert_equal("description -> http://purl.org/dc/elements/1.1/description", lines[0])
+    assert_equal("name -> http://xmlns.com/foaf/0.1/name", lines[1])
+    assert_equal("title -> http://purl.org/dc/elements/1.1/title", lines[2])
+  end
+
+  def test_fpmap_raw()
+    mc = mock()
+    mc.expects(:get_field_predicate_map).returns( HTTP::Message.new_response(TEST_FPMAP) )
+    
+    s = StringIO.new()
+    @opts["raw"] = ""
+    cmdline = Pho::CommandLine.new(@opts, {}, mc)
+    cmdline.fpmap(s)
+    assert_equal(TEST_FPMAP, s.string)    
+  end
+  
+  def test_queryprofile_raw()
+    mc = mock()
+    mc.expects(:get_query_profile).returns( HTTP::Message.new_response(TEST_QP) )
+    
+    s = StringIO.new()
+    @opts["raw"] = ""    
+    cmdline = Pho::CommandLine.new(@opts, {}, mc )
+    cmdline.queryprofile(s)
+    assert_equal(TEST_QP, s.string)      
+  end
+  
+  def test_queryprofile()
+    mc = mock()
+    mc.expects(:build_uri).returns( "http://api.talis.com/stores/testing/config/queryprofiles/1" )
+    mc.expects(:get_query_profile).returns( HTTP::Message.new_response(TEST_QP) )
+    
+    s = StringIO.new()
+    cmdline = Pho::CommandLine.new(@opts,  {}, mc)
+    cmdline.queryprofile(s)
+    
+    lines = s.string().split("\n")
+    assert_equal("name -> 2.0", lines[0])
+    assert_equal("nick -> 1.0", lines[1])  
+  end
+
+  def test_username()
+    opts = {}
+    env = {}
+    
+    assert_raise RuntimeError do
+      cmdline = Pho::CommandLine.new(opts, env, mock())  
    end
+        
+    opts["username"] = "tester"
+    opts["password"] = "pass"
+    cmdline = Pho::CommandLine.new(opts, env, mock())
+    assert_equal("tester", cmdline.username)
+    
+    opts = {}
+    opts["password"] = "pass"
+    env["TALIS_USER"] = "tester"
+    cmdline = Pho::CommandLine.new(opts, env, mock())
+    assert_equal("tester", cmdline.username)
+    
+    opts["username"] = "override"
+    cmdline = Pho::CommandLine.new(opts, env, mock())
+    assert_equal("override", cmdline.username)    
+  end
+
+  def test_password()
+    opts = {}
+    env = {}
+    
+    opts["username"] = "tester"
+    assert_raise RuntimeError do
+     cmdline = Pho::CommandLine.new(opts, env, mock())
+    end
+        
+    opts["password"] = "pass"
+    cmdline = Pho::CommandLine.new(opts, env, mock())
+    assert_equal("pass", cmdline.password)
+    
+    opts = {}
+    opts["username"] = "tester"
+    env["TALIS_PASS"] = "pass"
+    cmdline = Pho::CommandLine.new(opts, env, mock())
+    assert_equal("pass", cmdline.password)
+    
+    opts["password"] = "override"
+    cmdline = Pho::CommandLine.new(opts, env, mock())
+    assert_equal("override", cmdline.password)    
+   end
+   
+   def test_store()
+     opts = {}
+     env = {}
+     opts["username"] = "tester"
+     opts["password"] = "pass"
+     cmdline = Pho::CommandLine.new(opts, env, mock())
+     assert_equal(nil, cmdline.storename)
+     
+     opts["store"] = "http://api.talis.com/stores/testing"
+     cmdline = Pho::CommandLine.new(opts, env, mock())
+     assert_equal("http://api.talis.com/stores/testing", cmdline.storename)
+
+     opts["store"] = "testing"
+     cmdline = Pho::CommandLine.new(opts, env, mock())
+     assert_equal("http://api.talis.com/stores/testing", cmdline.storename)
+     
+     opts = {}
+     opts["username"] = "tester"
+     opts["password"] = "pass"
+     env["TALIS_STORE"] = "http://api.talis.com/stores/testing"
+     cmdline = Pho::CommandLine.new(opts, env, mock())
+     assert_equal("http://api.talis.com/stores/testing", cmdline.storename)
+    
+     env["TALIS_STORE"] = "testing"
+     cmdline = Pho::CommandLine.new(opts, env, mock())
+     assert_equal("http://api.talis.com/stores/testing", cmdline.storename)
+     
+     opts["store"] = "override"
+     cmdline = Pho::CommandLine.new(opts, env, mock())
+     assert_equal("http://api.talis.com/stores/override", cmdline.storename)
+
+   end
+
+   def test_add_mapping()
+      mc = mock()
+      mc.expects(:build_uri).with("/config/fpmaps/1").returns( "http://api.talis.com/stores/testing/config/fpmaps/1" )
+      mc.expects(:get_field_predicate_map).returns( HTTP::Message.new_response(TEST_FPMAP) )
+      mc.expects(:build_uri).with("/config/fpmaps/1#test").returns( "http://api.talis.com/stores/testing/config/fpmaps/1#test" )
+      mc.expects(:put_field_predicate_map).returns( HTTP::Message.new_response("") )
+      
+      @opts["field"] = "test"
+      @opts["predicate"] = "http://www.example.org/test"
+      
+      s = StringIO.new()
+      cmdline = Pho::CommandLine.new(@opts, {}, mc)
+      cmdline.add_mapping(s)
+      assert_equal("FieldPredicate map successfully updated\n", s.string)      
+   end
+   
+   def test_add_weight()
+      mc = mock()
+      mc.expects(:build_uri).with("/config/queryprofiles/1").returns( "http://api.talis.com/stores/testing/config/queryprofiles/1")
+      mc.expects(:get_query_profile).returns( HTTP::Message.new_response(TEST_QP) )
+      mc.expects(:build_uri).with("/config/queryprofiles/1#test").returns("http://api.talis.com/stores/testing/config/queryprofiles/1#test" )
+      mc.expects(:put_query_profile).returns( HTTP::Message.new_response("") )
+      
+      @opts["field"] = "test"
+      @opts["weight"] = "10.0"
+      
+      s = StringIO.new()
+      cmdline = Pho::CommandLine.new(@opts, {}, mc)
+      cmdline.add_weight(s)
+      assert_equal("QueryProfile successfully updated\n", s.string)     
+   end
+   
+end