summon 1.0.0

data/spec/summon/schema/facet_spec.rb

@@ -0,0 +1,115 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Summon::Facet do
+
+  it "should map" do
+    facet = Summon::Facet.new(JSON.parse(EXAMPLE_FACET_JSON))
+    facet.remove_src
+    facet.counts.each {|f| f.remove_src }
+    facet.to_yaml.should == EXPECTED_FACET_YAML
+
+    first = facet.counts.first
+    first.apply_command.should == "addFacetValueFilter(ContentType_sfacet,Book,false)"
+    first.apply_negated_command.should == "addFacetValueFilter(ContentType_sfacet,Book,true)"
+    first.remove_command.should == "eatMyShorts()"
+  end
+  
+  it "should now how to escape values" do
+    count = Summon::FacetCount.new(:value => "the quick, brown, fox")
+    count.value.should == "the quick, brown, fox"
+    count.escaped_value.should == 'the quick\, brown\, fox'
+    
+    Summon::FacetCount.new(:value => ': everything (else) and $1 or {is} it\ ').escaped_value.should == 
+                                     '\: everything \(else\) and \$1 or \{is\} it\\ '
+  end
+  
+  EXAMPLE_FACET_JSON = <<-JSON
+  {
+    "pageSize": 10,
+    "displayName": "ContentType",
+    "combineMode": "or",
+    "pageNumber": 1,
+    "listValuesCommand": "listFacetValues(ContentType_sfacet,or)",
+    "hasAppliedValue": false,
+    "fieldName": "ContentType_sfacet",
+    "hasLimitingValue": true,
+    "removeCommand": "removeFacetField(ContentType_sfacet)",
+    "removeValueFiltersCommand": "removeFacetValueFilters(ContentType)",
+    "counts": [
+      {
+        "isFurtherLimiting": true,
+        "isNegated": false,
+        "value": "Book",
+        "count": 799602,
+        "applyCommand": "addFacetValueFilter(ContentType_sfacet,Book,false)",
+        "removeCommand": "eatMyShorts()",
+        "applyNegatedCommand": "addFacetValueFilter(ContentType_sfacet,Book,true)",
+        "isApplied": false
+      },
+      {
+        "isFurtherLimiting": true,
+        "isNegated": false,
+        "value": "JournalArticle",
+        "count": 49765,
+        "applyCommand": "addFacetValueFilter(ContentType_sfacet,JournalArticle,false)",
+        "removeCommand": "eatMyShorts()",
+        "applyNegatedCommand": "addFacetValueFilter(ContentType_sfacet,JournalArticle,true)",
+        "isApplied": false
+      },
+      {
+        "isFurtherLimiting": true,
+        "isNegated": false,
+        "value": "Journal Article",
+        "count": 179002,
+        "removeCommand": "eatMyShorts()",
+        "applyCommand": "addFacetValueFilter(ContentType_sfacet,Journal Article,false)",
+        "applyNegatedCommand": "addFacetValueFilter(ContentType_sfacet,Journal Article,true)",
+        "isApplied": false
+      }
+    ]
+  }
+  JSON
+  
+  EXPECTED_FACET_YAML = <<-YAML
+--- !ruby/object:Summon::Facet 
+combine_mode: or
+counts: 
+- !ruby/object:Summon::FacetCount 
+  applied: false
+  apply_command: addFacetValueFilter(ContentType_sfacet,Book,false)
+  apply_negated_command: addFacetValueFilter(ContentType_sfacet,Book,true)
+  count: 799602
+  further_limiting: true
+  negated: false
+  remove_command: eatMyShorts()
+  src: 
+  value: Book
+- !ruby/object:Summon::FacetCount 
+  applied: false
+  apply_command: addFacetValueFilter(ContentType_sfacet,JournalArticle,false)
+  apply_negated_command: addFacetValueFilter(ContentType_sfacet,JournalArticle,true)
+  count: 49765
+  further_limiting: true
+  negated: false
+  remove_command: eatMyShorts()
+  src: 
+  value: JournalArticle
+- !ruby/object:Summon::FacetCount 
+  applied: false
+  apply_command: addFacetValueFilter(ContentType_sfacet,Journal Article,false)
+  apply_negated_command: addFacetValueFilter(ContentType_sfacet,Journal Article,true)
+  count: 179002
+  further_limiting: true
+  negated: false
+  remove_command: eatMyShorts()
+  src: 
+  value: Journal Article
+display_name: ContentType
+field_name: ContentType_sfacet
+page_number: 1
+page_size: 10
+remove_command: removeFacetField(ContentType_sfacet)
+remove_value_filters_command: removeFacetValueFilters(ContentType)
+src: 
+  YAML
+end

data/spec/summon/schema/query_spec.rb

@@ -0,0 +1,163 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Summon::Query do
+  it "maps" do
+    raw = JSON.parse(<<-JSON)
+    {
+      "searchTerms": [1],
+      "facetValueGroupFilters": [],
+      "queryString": "4",
+      "facetValueFilters": [],
+      "textQueries": [6],
+      "textFilters": [7],
+      "rangeFilters": [],
+      "facetFields": [8],
+      "rangeFacetFields": [9],
+      "sort": [
+      {
+        "fieldName": "PublicationDate_dt",
+        "sortOrder": "desc"
+      }
+    ],
+      "params": [11]
+    }
+    JSON
+    
+    
+    query(raw).with {
+      search_terms.should == [1]
+      range_filters.should == []
+      facet_value_group_filters.should == []
+      query_string.should == "4"
+      facet_value_filters.should == []
+      text_queries.should == [6]
+      text_filters.should == [7]
+      facet_fields.should == [8]
+      sorts.length.should == 1
+      sort.field_name.should == "PublicationDate_dt"
+      sort.sort_order.should == "desc"
+    }
+  end
+  
+  it "should map facet value fields and facet group fields" do
+    q = query(
+      "searchTerms"=>[], "rangeFilters"=>[], 
+      "facetValueGroupFilters"=>[
+        {
+          "combineMode"=>"or", "tag"=>"3", 
+          "values"=>[
+            {"value"=>"history", "removeCommand"=>"removeFacetValueGroupFilter(3,history)"}, 
+            {"value"=>"uk", "removeCommand"=>"removeFacetValueGroupFilter(3,uk)"}
+          ], 
+          "removeCommand"=>"removeFacetValueGroupFilter(3)", 
+          "fieldName"=>"SubjectTerms"
+        }
+      ], 
+      "facetValueFilters"=>[
+        {
+          "isNegated"=>false, 
+          "value"=>"law", 
+          "removeCommand"=>"removeFacetValueFilter(SubjectTerms,law)", 
+          "fieldName"=>"SubjectTerms", 
+          "negateCommand"=>"negateFacetValueFilter(SubjectTerms,law)"
+        }
+      ], 
+      "queryString"=>"s.fvgf%3A3=SubjectTerms%2Cor%2Chistory%2Cuk&s.ff=SubjectTerms%2Cand%2C1%2C10&s.fvf=SubjectTerms%2Claw%2Cfalse", 
+      "facetFields"=>[{
+          "pageSize"=>10, "pageNumber"=>1, "combineMode"=>"and", "removeCommand"=>"removeFacetField(SubjectTerms)", "fieldName"=>"SubjectTerms"
+      }], 
+      "textFilters"=>[], "textQueries"=>[], "sort"=>[], "rangeFacetFields"=>[]
+    )
+    filter = q.facet_value_filters[0]
+    filter.should_not be_negated
+    filter.remove_command.should == "removeFacetValueFilter(SubjectTerms,law)"
+    filter.field_name.should == "SubjectTerms"
+    filter.negate_command.should == "negateFacetValueFilter(SubjectTerms,law)"
+    
+    group = q.facet_value_group_filters[0]
+    group.combine_mode.should == "or"
+    group.tag.should == "3"
+    group.remove_command.should == "removeFacetValueGroupFilter(3)"
+    group.field_name.should == "SubjectTerms"
+    
+    group.values[0].value.should == "history"
+    group.values[0].remove_command.should == "removeFacetValueGroupFilter(3,history)"
+  end
+  
+  it "should be able to deescape a string" do      
+    query_hash("").should == {}
+    query_hash("s.fq=Author_t%3A%28Linster%2C+Richard+L%29").should == {"s.fq" => "Author_t:(Linster, Richard L)"}
+    query_hash("s.fq=Balthazar&s.fq=Author_t%3A%28Linster%2C+Richard+L%29").should == {"s.fq" => ["Balthazar", "Author_t:(Linster, Richard L)"]}
+    query_hash("s.fq=Author_t%3A%28Linster%2C+Richard+L%29&s.q=Probability+models+of+recidivism%5C%3A+an+exploration").should == 
+      {"s.fq" => "Author_t:(Linster, Richard L)", "s.q" => "Probability models of recidivism\\: an exploration"}
+  end
+  
+  it "has params" do
+    query({
+      :params => [
+        {
+          "key" => "holdingsOnly",
+          "value" => "t",
+          "removeCommand" => "removeParameter(holdingsOnly)"
+        }
+      ]
+    }).tap do |q|
+      q.params.should_not be(nil)
+      # what's the deal w/ holdings??? should we delete this test? - jl
+      # q.should be_holdings_only_enabled
+    end      
+  end
+  
+  it "knows it's own date_min and date_max" do
+    query({
+      :rangeFilters => [
+        {
+          "fieldName" => "PublicationDate",
+          "range" => {
+            "minValue" => "2000",
+            "maxValue" => "2008"
+          }
+        }
+      ]
+    }).tap do |q|
+      q.date_min.should == 2000
+      q.date_max.should == 2008
+    end
+  end
+  
+  it "doesn't get phased when one of the ranges in unbounded" do
+    query({
+      :rangeFilters => [
+        {
+          "fieldName" => "PublicationDate",
+          "range" => {
+            "minValue" => "*",
+            "maxValue" => "2008"
+          }
+        }
+      ]
+    }).tap do |q|
+      q.date_min.should be_nil
+      q.date_max.should == 2008
+    end
+  end
+  
+  it "should know about holdings only" do
+    query({}).should_not be_holdings_only_enabled
+    query(:isHoldingsOnlyEnabled => true).should be_holdings_only_enabled
+    query(:isHoldingsOnlyEnabled => false).should_not be_holdings_only_enabled
+  end
+  
+  def query_hash(str)
+    query(:queryString => str).to_hash
+  end
+  
+  def query(params)
+    Summon::Query.new(params)
+  end
+  
+end
+
+class Object
+  alias_method :with, :instance_eval
+end

data/spec/summon/schema/range_spec.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Summon::RangeFacet do
+  it "maps" do
+    range = Summon::RangeFacet.new(JSON.parse(<<-JSON))
+    {
+      "displayName": "PublicationDate",
+      "removeCommand": "removeFacetField(PublicationDate)",
+      "fieldName": "PublicationDate_dt",
+      "counts": [
+        {
+          "count": 119795,
+          "applyCommand": "addRangeFilter(PublicationDate,1999:1999)",
+          "range": {
+            "minValue": "1999",
+            "maxValue": "2000"
+          },
+          "isApplied": true
+        },
+        {
+          "count": 122712,
+          "applyCommand": "addRangeFilter(PublicationDate,2000:2000)",
+          "range": {
+            "minValue": "2000",
+            "maxValue": "2001"
+          },
+          "isApplied": false
+        }
+      ]
+    }
+    JSON
+    range.display_name.should == "PublicationDate"
+    range.remove_command.should == "removeFacetField(PublicationDate)"
+    range.field_name.should == "PublicationDate_dt"
+    range.counts.should_not be_nil
+    range.counts.length.should be(2)
+    range.counts[0].tap do |c|
+      c.count.should == 119795
+      c.apply_command.should == "addRangeFilter(PublicationDate,1999:1999)"
+      c.min.should == "1999"
+      c.max.should == "2000"
+      c.should be_applied
+    end
+  end
+end

data/spec/summon/schema/search_spec.rb

@@ -0,0 +1,62 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Summon::Search do
+  it "maps" do
+    search = Summon::Search.new(JSON.parse(<<-JSON))
+    {
+      "pageCount": 0,
+      "didYouMeanSuggestions": [
+
+      ],
+      "fullTextCount": 0,
+      "queryTime": 124,
+      "documents": [],
+      "totalRequestTime": 129,
+      "elapsedQueryTime": 126,
+      "version": "1.0.0",
+      "facetFields": [
+      ],
+      "rangeFacetFields": [
+
+      ],
+      "recordCount": 4589937,
+      "sessionId": "cfaa4020-1abe-4a9d-ae6e-e433a36c1069",
+      "query": {}
+    }
+JSON
+    search.page_count.should == 0
+    search.record_count.should == 4589937
+    search.query_time.should == 124
+    search.session_id.should == "cfaa4020-1abe-4a9d-ae6e-e433a36c1069"
+    search.documents.should == []
+    search.version.should == "1.0.0"
+    search.query.should be_kind_of(Summon::Query)
+  end
+  
+  it "should handle an error case" do
+    search = Summon::Search.new(
+      "version" => "1.0.0", 
+      "errors" => [
+        {
+          "suggestion" => {
+            "applySuggestionCommand" => "removeTextQuery(foo\:bar) addTextQuery(foo\\\:bar)",
+            "suggestedQuery" => "foo\:bar",
+            "originalQuery" => "foo:bar"
+          },
+          "message" => "Unknown search field(s): foo."
+        }])
+    search.version.should == "1.0.0"
+    search.record_count.should == 0
+    search.errors.size.should == 1
+    search.errors.first.message.should == "Unknown search field(s): foo."
+    search.errors.first.suggestion.apply_suggestion_command.should == "removeTextQuery(foo\:bar) addTextQuery(foo\\\:bar)"
+    search.errors.first.suggestion.suggested_query.should == "foo\:bar"
+    search.errors.first.suggestion.original_query.should == "foo:bar"
+  end
+  
+  it "should be empty w/ no docs" do
+    Summon::Search.new({}).should be_empty
+    Summon::Search.new({"documents" => [{}]}).should_not be_empty
+  end
+    
+end

data/spec/summon/schema_spec.rb

@@ -0,0 +1,143 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Summon::Schema do
+  
+  before(:each) do
+    @class = Class.new(Summon::Schema)
+  end
+
+  def class_eval(&block)
+    @class.class_eval(&block)
+  end
+  
+  def init(values)
+    @class.new(values)
+  end
+  
+  it "pulls its attributes from a hash" do
+    class_eval do
+      attr :foo 
+      attr :baz
+    end
+    
+    init(:foo => "bar", :baz => "bang").foo.should == "bar"
+  end
+  
+  it "can pull its attributes from string keys as well as symbol keys" do
+    class_eval do
+      attr :foo
+    end
+    
+    init("foo" => "bar").foo.should == "bar"
+  end
+  
+  it "knows how to atomagically map between camel case and perl case" do
+    class_eval do
+      attr :foo_bar_baz
+    end
+    
+    init("fooBarBaz" => "Hello").foo_bar_baz.should == "Hello"
+  end
+  
+  it "can also magically convert from Pascal case as well" do
+    class_eval do
+      attr :foo_bar_baz
+    end
+    init("FooBarBaz" => "Hello").foo_bar_baz.should == "Hello"
+  end
+  
+  it "can have an overridden field name for names that don't map so cleanly" do
+    class_eval do
+      attr :isbn, :json_name => "ISBN"
+      attr :eissn, :json_name => "eISSN"
+    end
+    
+    o = init("ISBN" => 123456, "eISSN" => 98765)
+    o.isbn.should == 123456
+    o.eissn.should == 98765    
+  end
+
+  describe "transforms" do
+    it "can transform subobjects" do
+      class Summon::DogPile < Summon::Schema
+        attr :type
+      end
+      class_eval do
+        attr :steaming, :transform => :DogPile
+      end
+
+      o = init("steaming" => {:type => "swirled"})
+      o.steaming.should_not be_nil
+      o.steaming.type.should == "swirled"
+    end
+  
+    it "will apply a transform across an array if the field is an array" do
+      class Summon::DogPatch < Summon::Schema
+        attr :foo
+      end
+      class_eval do
+        attr :patches, :transform => :DogPatch
+      end
+      patches = init("patches" => [{:foo => 'bar'},{:foo => 'baz'}, {:foo => 'bang'}]).patches
+      patches.should_not be_nil
+      patches.should be_kind_of(Array)
+      patches.collect{|p| p.foo}.should == ['bar', 'baz', 'bang']
+    end
+  
+    it "will ignore a transform if the element is not present" do
+      class Summon::DogFood < Summon::Schema
+        attr :foo
+      end
+      class_eval do
+        attr :kibbles, :transform => :DogPatch
+        attr :bits, :single => true, :transform => :DogPatch
+      end
+      foo = init({})
+      foo.kibbles.should == []
+      foo.bits.should == nil
+    end
+  end
+  
+  it "will create a predicate if the field is marked as boolean" do
+    class_eval do
+      attr :boollocks, :boolean => true
+    end
+    
+    init("isBoollocks" => true).boollocks?.should be(true)
+  end
+  
+  it "will automatically do a bean styles lookup on attributes that end in a question mark" do
+    class_eval do
+      attr :awesome?
+    end
+    init("isAwesome" => true).should be_awesome
+    init("isAwesome" => false).should_not be_awesome
+  end
+  
+  it "automatically unwraps arrays from values if the value is marked as being single" do
+    class_eval do
+      attr :just_one, :single => true
+    end
+    init(:justOne => ["foo"]).just_one.should == 'foo'
+  end
+  
+  it "defaults to automatically unwrap arrays if the field doesn't end in s" do
+    class_eval do
+      attr :foo
+      attr :foos
+    end
+    o = init(:foo => ["bar"], :foos => ["bar"])
+    o.foo.should == "bar"
+    o.foos.should == ["bar"]
+  end
+  
+  it "initializes multi-valued fields to the empty array if it is not present" do
+    class_eval do
+      attr :foos
+    end
+    init({}).foos.should == []
+  end
+  
+  
+  
+end