pho 0.2 → 0.3

data/lib/pho/status.rb

@@ -0,0 +1,65 @@
+module Pho
+
+  #Can only read data
+  READ_ONLY = "http://schemas.talis.com/2006/bigfoot/statuses#read-only".freeze
+  #Can read and write data
+  READ_WRITE = "http://schemas.talis.com/2006/bigfoot/statuses#read-write".freeze
+  #Cannot access the store
+  UNAVAILABLE = "http://schemas.talis.com/2006/bigfoot/statuses#unavailable".freeze
+        
+  #Captures status information relating to a store
+  class Status
+      
+    #Interval before status should be requested again.
+    attr_reader :retry_interval
+    
+    #Status message
+    attr_reader :status_message
+    
+    #Current access mode uri
+    #
+    #This will be one of Pho::READ_ONLY, Pho::READ_WRITE, or Pho::UNAVAILABLE. Use the 
+    #readable and writeable methods to test for the different modes
+    attr_reader :access_mode
+    
+    def initialize(retry_interval, status_message, access_mode)
+      @retry_interval = retry_interval
+      @status_message = status_message
+      @access_mode = access_mode
+    end
+    
+    #Create a Status object by reading the response from a store access status request
+    #
+    #The code parses the JSON output from the Platform API to create a Status object.
+    #
+    #store:: the store whose status is to be read
+    def Status.read_from_store(store)
+      response = store.get_status()
+      if (response.status != 200)
+        raise "Cannot read store status"
+      end
+      
+      u = store.build_uri("/config/access-status")
+      json = JSON.parse( response.content )
+      retry_interval = json[u]["http:\/\/schemas.talis.com\/2006\/bigfoot\/configuration#retryInterval"][0]["value"]
+      status_message = json[u]["http:\/\/schemas.talis.com\/2006\/bigfoot\/configuration#statusMessage"][0]["value"]
+      access_mode = json[u]["http:\/\/schemas.talis.com\/2006\/bigfoot\/configuration#accessMode"][0]["value"]
+      
+      state = Status.new(retry_interval.to_i, status_message, access_mode)
+      return state
+          
+    end
+    
+    #Is the store readable?
+    def readable?
+      return @access_mode != Pho::UNAVAILABLE
+    end
+
+    #Is the store writeable?
+    def writeable?
+      return @access_mode == Pho::READ_WRITE
+    end
+        
+  end
+  
+end

data/lib/pho/store.rb

@@ -2,16 +2,12 @@ module Pho
 
 #TODO:
 #
+# Make it work with Ruby < 1.8.7
 # Changesets
 # Multisparql
 #
 # Listing jobs
 # Retrieving single job
-# FP Map
-# Query Profile
-# List snapshots
-# Get snapshot
-#
 #
 # Conditional deletions
 # If-Modified-Since support
@@ -402,15 +398,10 @@ module Pho
     # ADMIN
     #############
     
-    def status()
+    def get_status()
       u = build_uri("/config/access-status")
-      response = @client.get_content(u, nil, ACCEPT_JSON )
-      json = JSON.parse( response )
-      state = Hash.new
-      state["retryInterval"] = json[u.to_s]["http:\/\/schemas.talis.com\/2006\/bigfoot\/configuration#retryInterval"][0]["value"]
-      state["statusMessage"] = json[u.to_s]["http:\/\/schemas.talis.com\/2006\/bigfoot\/configuration#statusMessage"][0]["value"]
-      state["accessMode"] = json[u.to_s]["http:\/\/schemas.talis.com\/2006\/bigfoot\/configuration#accessMode"][0]["value"]
-      return state
+      response = @client.get(u, nil, ACCEPT_JSON )
+      return response
     end
    
     # Retrieve the list of snapshots for this store
@@ -447,6 +438,28 @@ module Pho
       headers = {"Content-Type" => "application/rdf+xml"}
       return @client.put(u, data, headers)           
     end
+    
+    #Read the query profile configuration for this store. The config can be requested in any 
+    #format supported by the platform, but the default will return JSON. See QueryProfile.read_from_store 
+    #for a convenient way to quickly create a QueryProfile object based on a specific stores's configuration.
+    #
+    #output:: mimetype to use in request     
+    def get_query_profile(output=ACCEPT_JSON)
+      u = build_uri("/config/queryprofiles/1")
+      response = @client.get(u, nil, output)
+      return response                  
+    end
+
+    #Update/replace the current Query Profile configuration in the store. Assumes that the provided 
+    #data is valid RDF/XML. Use QueryProfile.upload as a convenience function
+    #
+    #data:: a string containing an RDF/XML document 
+    def put_query_profile(data)
+      u = build_uri("/config/queryprofiles/1")
+      headers = {"Content-Type" => "application/rdf+xml"}
+      return @client.put(u, data, headers)           
+    end        
+    
   end
 
 end

data/tests/tc_facet.rb

@@ -0,0 +1,91 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'pho'
+require 'test/unit'
+require 'mocha'
+require 'rexml/document'
+
+class FacetTest < Test::Unit::TestCase
+
+  RESULTS = <<-EOL
+  <facet-results xmlns="http://schemas.talis.com/2007/facet-results#">
+    <head>
+      <query>austen</query>
+      <fields>title,author,publisher</fields>
+    </head>
+  <fields>
+    <field name="title">
+      <term number="19" search-uri="http://api.talis.com/stores/testing/items?query=austen+title:%22Pride+and+prejudice%22">Pride and prejudice</term>
+      <term number="12" search-uri="http://api.talis.com/stores/testing/items?query=austen+title:%22Emma%22">Emma</term>
+      <term number="9" search-uri="http://api.talis.com/stores/testing/items?query=austen+title:%22Northanger+Abbey%22">Northanger Abbey</term>
+      <term number="8" search-uri="http://api.talis.com/stores/testing/items?query=austen+title:%22Mansfield+Park%22">Mansfield Park</term>
+    </field>
+    <field name="publisher"/>
+  
+  <field name="author">
+    <term number="91" search-uri="http://api.talis.com/stores/testing/items?query=austen+author:%22Austen,+Jane%22">Austen, Jane</term>
+    <term number="6" search-uri="http://api.talis.com/stores/testing/items?query=austen+author:%22Jane+Austen+Society.%22">Jane Austen Society.</term>
+    <term number="3" search-uri="http://api.talis.com/stores/testing/items?query=austen+author:%22Evans,+J.+M.+(Jessie+Maud)%22">Evans, J. M. (Jessie Maud)</term>
+    <term number="3" search-uri="http://api.talis.com/stores/testing/items?query=austen+author:%22Chapman,+R.+W.+(Robert+William)%22">Chapman, R. W. (Robert William)</term>
+  </field>
+
+  </fields>
+    
+  </facet-results>  
+EOL
+
+    def test_parse
+      
+      results = Pho::Facet::Results.parse(RESULTS)
+      
+      assert_equal("austen", results.query)
+      assert_equal("title,author,publisher", results.fields)
+      assert_equal(3, results.facets.size)
+      
+      assert_equal(4, results.facets["title"].length)
+      assert_expected_term(results.facets["title"][0], 
+        19, "http://api.talis.com/stores/testing/items?query=austen+title:%22Pride+and+prejudice%22", "Pride and prejudice")
+      assert_expected_term(results.facets["title"][1], 
+        12, "http://api.talis.com/stores/testing/items?query=austen+title:%22Emma%22", "Emma")
+      assert_expected_term(results.facets["title"][2], 
+        9, "http://api.talis.com/stores/testing/items?query=austen+title:%22Northanger+Abbey%22", "Northanger Abbey")              
+      assert_expected_term(results.facets["title"][3], 
+        8, "http://api.talis.com/stores/testing/items?query=austen+title:%22Mansfield+Park%22", "Mansfield Park")              
+                      
+      assert_equal(0, results.facets["publisher"].length)
+                  
+      assert_equal(4, results.facets["author"].length)
+      assert_expected_term(results.facets["author"][0], 
+        91, "http://api.talis.com/stores/testing/items?query=austen+author:%22Austen,+Jane%22", "Austen, Jane")
+      assert_expected_term(results.facets["author"][1], 
+        6, "http://api.talis.com/stores/testing/items?query=austen+author:%22Jane+Austen+Society.%22", "Jane Austen Society.")
+      assert_expected_term(results.facets["author"][2], 
+        3, "http://api.talis.com/stores/testing/items?query=austen+author:%22Evans,+J.+M.+(Jessie+Maud)%22", "Evans, J. M. (Jessie Maud)")
+      assert_expected_term(results.facets["author"][3], 
+        3, "http://api.talis.com/stores/testing/items?query=austen+author:%22Chapman,+R.+W.+(Robert+William)%22", "Chapman, R. W. (Robert William)")
+      
+    end
+   
+    def test_read_from_store
+      mc = mock()
+      mc.expects(:set_auth)
+      mc.expects(:get).with("http://api.talis.com/stores/testing/services/facet", 
+        {"query" => "austen", "fields" => "title,author,publisher", "output" => "xml"}, nil).returns(
+        HTTP::Message.new_response(RESULTS))
+      
+      store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass", mc)
+      
+      results = Pho::Facet::Results.read_from_store(store, "austen", ["title", "author", "publisher"]) 
+
+      assert_not_nil(results)
+      assert_equal("austen", results.query)
+      assert_equal("title,author,publisher", results.fields)
+      assert_equal(3, results.facets.size)
+        
+    end   
+    
+    def assert_expected_term(term, hits, search_uri, value)
+      assert_equal(hits, term.hits)
+      assert_equal(search_uri, term.search_uri)
+      assert_equal(value, term.value)
+    end
+end

data/tests/tc_query_profile.rb

@@ -0,0 +1,196 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'pho'
+require 'test/unit'
+require 'mocha'
+require 'rexml/document'
+
+class QueryProfileTest < Test::Unit::TestCase
+
+  QP_JSON = <<-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
+    @qp = Pho::QueryProfile.new("http://api.talis.com/stores/testing/config/queryprofiles/default", "test query profile")
+    
+    @qp << Pho::FieldWeighting.new("http://api.talis.com/stores/testing/config/queryprofiles/default#title","title", 10)
+    @qp << Pho::FieldWeighting.new("http://api.talis.com/stores/testing/config/queryprofiles/default#abstract", "abstract", 5)
+    @qp << Pho::FieldWeighting.new("http://api.talis.com/stores/testing/config/queryprofiles/default#body", "body", 1)
+        
+  end
+  
+  def test_field_weighting
+    
+    fw = Pho::FieldWeighting.new("http://api.talis.com/stores/testing/config/queryprofiles/default#title", "title", 10)
+
+    rdf = fw.to_rdf
+    
+    assert_equal(true, rdf != nil)
+    
+    #Check it parses
+    doc = nil
+    assert_nothing_raised {
+        doc = REXML::Document.new(rdf)
+    }    
+    
+    root = doc.root
+    assert_equal("http://api.talis.com/stores/testing/config/queryprofiles/default#title", root.attributes["about"])
+    
+    assert_has_single_property_with_literal(root, "frm:name", "title")
+    assert_has_single_property_with_literal(root, "bf:weight", "10")
+        
+  end
+    
+    
+  def assert_has_single_property_with_literal(el, property, value)
+
+    assert_equal(1, el.get_elements(property).length)    
+    child = el.get_elements(property)[0]
+    assert_equal(value, child.text)
+            
+  end
+  
+  def test_to_rdf
+    rdf = @qp.to_rdf
+    
+    assert_equal(true, rdf != nil)
+    
+    #Check it parses
+    doc = nil
+    assert_nothing_raised {
+        doc = REXML::Document.new(rdf)
+    }    
+    
+    root = doc.root
+    
+    children = root.get_elements("rdf:Description")
+    #fpmap + 3 mappings
+    assert_equal(4, children.length)
+    
+    fpmap = children[0]
+    assert_has_single_property_with_literal(fpmap, "rdfs:label", "test query profile")
+     
+  end  
+  
+  def test_get_query_profile_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"})
+     
+    store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass", mc)     
+    resp = store.get_query_profile()
+              
+  end
+
+  def test_get_query_profile_from_store_as_xml
+     mc = mock()
+     mc.expects(:set_auth)
+     mc.expects(:get).with("http://api.talis.com/stores/testing/config/queryprofiles/1", anything, {"Accept" => "application/rdf+xml"})
+     
+     store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass", mc)     
+     resp = store.get_query_profile(Pho::ACCEPT_RDF)              
+  end
+
+    
+  def test_read_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"}).returns( HTTP::Message.new_response(QP_JSON) )
+   
+    store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass", mc)
+    qp = Pho::QueryProfile.read_from_store(store)
+    
+    assert_not_nil(qp)
+    
+    assert_equal("http://api.talis.com/stores/testing/config/queryprofiles/1", qp.uri)
+    assert_equal("default query profile", qp.label)
+    
+    assert_equal(2, qp.field_weights.length)       
+    
+    sorted = qp.field_weights.sort { |x,y|
+      x.name <=> y.name
+    }
+    
+    assert_expected_field_weighting(sorted[0], "name", "http://api.talis.com/stores/testing/config/queryprofiles/1#name", "2.0")
+    assert_expected_field_weighting(sorted[1], "nick", "http://api.talis.com/stores/testing/config/queryprofiles/1#nick", "1.0")
+  end  
+  
+  def test_get_by_name
+        
+    assert_expected_field_weighting(@qp.get_by_name("abstract"), "abstract", "http://api.talis.com/stores/testing/config/queryprofiles/default#abstract", 5.0)     
+    assert_expected_field_weighting(@qp.get_by_name("title"), "title", "http://api.talis.com/stores/testing/config/queryprofiles/default#title", 10.0)
+    
+  end
+  
+  def test_create_weighting
+    
+    store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass")
+    weight = Pho::QueryProfile.create_weighting(store, "title", 2)
+
+    assert_expected_field_weighting(weight, "title", "http://api.talis.com/stores/testing/config/queryprofiles/1#title", 2)
+            
+  end
+  
+  def assert_expected_field_weighting(fw, name, uri, weight)
+    assert_equal(name, fw.name)
+    assert_equal(uri, fw.uri)
+    assert_equal(weight, fw.weight)    
+  end
+  
+  def test_remove
+    fw = @qp.get_by_name("title")
+    assert_not_nil(fw)
+    @qp.remove(fw)
+    fw = @qp.get_by_name("title")
+    assert_nil(fw)
+    
+    fw = @qp.get_by_name("abstract")
+    assert_not_nil(fw)
+    @qp.remove_by_name("abstract")
+    fw = @qp.get_by_name("abstract")
+    assert_nil(fw)
+   
+    assert_equal(false, @qp.mapped_name?("title"))
+    assert_equal(false, @qp.mapped_name?("abstract"))
+    assert_equal(true, @qp.mapped_name?("body"))
+    assert_equal(1, @qp.field_weights.length)     
+  end
+  
+  def test_put_query_profile
+      mc = mock()
+      mc.expects(:set_auth)
+      mc.expects(:put).with("http://api.talis.com/stores/testing/config/queryprofiles/1", anything, {"Content-Type" => "application/rdf+xml"} )
+      
+      store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass", mc)     
+      resp = store.put_query_profile(@qp)              
+  end  
+  
+  def test_upload_to_store
+    mc = mock()
+    mc.expects(:set_auth)
+    mc.expects(:put).with("http://api.talis.com/stores/testing/config/queryprofiles/1", anything, {"Content-Type" => "application/rdf+xml"} )
+    
+    store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass", mc)     
+    @qp.upload(store)
+        
+  end
+  
+end

data/tests/tc_status.rb

@@ -0,0 +1,56 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'pho'
+require 'test/unit'
+
+class StatusTest < Test::Unit::TestCase
+
+  STATUS = <<-EOL
+  {
+    "http:\/\/api.talis.com\/stores\/testing\/config\/access-status" : {
+      "http:\/\/schemas.talis.com\/2006\/bigfoot\/configuration#accessMode" : [ { "value" : "http:\/\/schemas.talis.com\/2006\/bigfoot\/statuses#read-write", "type" : "uri" } ],
+      "http:\/\/schemas.talis.com\/2006\/bigfoot\/configuration#retryInterval" : [ { "value" : "0", "type" : "literal" } ],
+      "http:\/\/schemas.talis.com\/2006\/bigfoot\/configuration#statusMessage" : [ { "value" : "message", "type" : "literal" } ]
+    }
+  }  
+EOL
+    
+  def test_store_status
+    mc = mock()
+    mc.expects(:set_auth)
+    mc.expects(:get).with("http://api.talis.com/stores/testing/config/access-status", nil, {"Accept" => "application/json"}) 
+   
+    store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass", mc)
+    
+    store.get_status()
+    
+  end  
+  
+  def test_read_from_store
+    mc = mock()
+    mc.expects(:set_auth)
+    mc.expects(:get).with("http://api.talis.com/stores/testing/config/access-status", nil, {"Accept" => "application/json"}).returns( HTTP::Message.new_response(STATUS) ) 
+   
+    store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass", mc)
+    
+    status = Pho::Status.read_from_store(store)
+    
+    assert_equal(Pho::READ_WRITE, status.access_mode)
+    assert_equal(0, status.retry_interval)
+    assert_equal("message", status.status_message)
+  end
+  
+  def test_read_write
+    status = Pho::Status.new(0, "test", Pho::UNAVAILABLE)
+    assert_equal(false, status.readable?)
+    assert_equal(false, status.writeable?)
+    
+    status = Pho::Status.new(0, "test", Pho::READ_ONLY)
+    assert_equal(true, status.readable?)
+    assert_equal(false, status.writeable?)
+
+    status = Pho::Status.new(0, "test", Pho::READ_WRITE)
+    assert_equal(true, status.readable?)
+    assert_equal(true, status.writeable?)
+        
+  end
+end