sparkql 0.1.8 → 0.3.2

data/test/unit/function_resolver_test.rb

@@ -1,9 +1,18 @@
 require 'test_helper'
+require 'sparkql/geo'
 
 class ParserTest < Test::Unit::TestCase
   include Sparkql
 
-  def test_now
+  test "function parameters and name preserved" do
+    f = FunctionResolver.new('radius', [{:type => :character, 
+          :value => "35.12 -68.33"},{:type => :decimal, :value => 1.0}])
+    value = f.call
+    assert_equal 'radius', value[:function_name]
+    assert_equal(["35.12 -68.33", 1.0], value[:function_parameters])
+  end
+
+  test "now()" do
     start = Time.now
     f = FunctionResolver.new('now', [])
     f.validate
@@ -14,8 +23,9 @@ class ParserTest < Test::Unit::TestCase
     assert (-5 < test_time - start && 5 > test_time - start), "Time range off by more than five seconds #{test_time - start} '#{test_time} - #{start}'"
   end
   
-  def test_day
-    d = Date.today
+  test "days()" do
+    d = Date.new(2012,10,20)
+    Date.expects(:today).returns(d)
     dt = DateTime.new(d.year, d.month,d.day, 0,0,0, DateTime.now.offset)
     start = Time.parse(dt.to_s)
     f = FunctionResolver.new('days', [{:type=>:integer, :value =>7}])
@@ -24,10 +34,99 @@ class ParserTest < Test::Unit::TestCase
     value = f.call
     assert_equal :date, value[:type]
     test_time = Time.parse(value[:value])
-    assert (605000 > test_time - start && 604000 < test_time - start), "Time range off by more than five seconds #{test_time - start} '#{test_time} - #{start}'"
+    assert (615000 > test_time - start && 600000 < test_time - start), "Time range off by more than five seconds #{test_time - start} '#{test_time} - #{start}'"
+  end
+
+  test "months()" do
+    dt = DateTime.new(2014, 1, 6, 0, 0, 0, 0)
+    DateTime.expects(:now).once.returns(dt)
+
+    f = FunctionResolver.new('months', [{:type=>:integer, :value =>3}])
+    f.validate
+    assert !f.errors?, "Errors resolving months(): #{f.errors.inspect}"
+    value = f.call
+    assert_equal :date, value[:type]
+
+    assert_equal "2014-04-06", value[:value]
+  end
+  
+  test "years()" do
+    dt = DateTime.new(2014, 1, 6, 0, 0, 0, 0)
+    DateTime.expects(:now).once.returns(dt)
+    f = FunctionResolver.new('years', [{:type=>:integer, :value =>-4}])
+    f.validate
+    assert !f.errors?, "Errors resolving years(): #{f.errors.inspect}"
+    value = f.call
+    assert_equal :date, value[:type]
+    assert_equal '2010-01-06', value[:value], "negative values should go back in time"
+  end
+
+
+
+  # Polygon searches
+  
+  test "radius()" do
+    f = FunctionResolver.new('radius', [{:type => :character, :value => "35.12 -68.33"},{:type => :decimal, :value => 1.0}])
+    f.validate
+    assert !f.errors?, "Errors #{f.errors.inspect}"
+    value = f.call
+    assert_equal :shape, value[:type]
+    assert_equal GeoRuby::SimpleFeatures::Circle, value[:value].class
+    assert_equal [-68.33, 35.12], value[:value].center.to_coordinates, "#{value[:value].inspect} "
+    assert_equal 1.0, value[:value].radius, "#{value[:value].inspect} "
+  end
+
+  test "radius() can be overloaded with a ListingKey" do
+    f = FunctionResolver.new('radius', [{:type => :character, :value => "20100000000000000000000000"},
+                {:type => :decimal, :value => 1.0}])
+    f.validate
+    assert !f.errors?, "Errors #{f.errors.inspect}"
+    value = f.call
+    assert_equal :shape, value[:type]
+    assert_equal Sparkql::Geo::RecordRadius, value[:value].class
+    assert_equal "20100000000000000000000000", value[:value].record_id, "#{value[:value].inspect} "
+    assert_equal 1.0, value[:value].radius, "#{value[:value].inspect} "
+  end
+
+  test "radius() fails if not given coords or a flex ID" do
+    f = FunctionResolver.new('radius', [{:type => :character, :value => "35.12,-68.33"},
+                {:type => :decimal, :value => 1.0}])
+    f.validate
+    value = f.call
+    assert f.errors?
+  end
+
+  test "polygon()" do
+    f = FunctionResolver.new('polygon', [{:type => :character, :value => "35.12 -68.33,35.12 -68.32, 35.13 -68.32,35.13 -68.33"}])
+    f.validate
+    assert !f.errors?, "Errors #{f.errors.inspect}"
+    value = f.call
+    assert_equal :shape, value[:type]
+    assert_equal GeoRuby::SimpleFeatures::Polygon, value[:value].class
+    assert_equal [[-68.33, 35.12], [-68.32, 35.12], [-68.32, 35.13], [-68.33, 35.13], [-68.33, 35.12]], value[:value].to_coordinates.first, "#{value[:value].inspect} "
+  end
+ 
+  test "linestring()" do
+    f = FunctionResolver.new('linestring', [{:type => :character, :value => "35.12 -68.33,35.12 -68.32"}])
+    f.validate
+    assert !f.errors?, "Errors #{f.errors.inspect}"
+    value = f.call
+    assert_equal :shape, value[:type]
+    assert_equal GeoRuby::SimpleFeatures::LineString, value[:value].class
+    assert_equal [[-68.33, 35.12], [-68.32, 35.12]], value[:value].to_coordinates, "#{value[:value].inspect} "
+  end
+
+  test "rectangle()" do
+    f = FunctionResolver.new('rectangle', [{:type => :character, :value => "35.12 -68.33, 35.13 -68.32"}])
+    f.validate
+    assert !f.errors?, "Errors #{f.errors.inspect}"
+    value = f.call
+    assert_equal :shape, value[:type]
+    assert_equal GeoRuby::SimpleFeatures::Polygon, value[:value].class
+    assert_equal [[-68.33,35.12], [-68.32,35.12], [-68.32,35.13], [-68.33,35.13], [-68.33,35.12]], value[:value].to_coordinates.first, "#{value[:value].inspect} "
   end
   
-  def test_invalid_param
+  test "invalid params" do
     f = FunctionResolver.new('now', [{:type => :character, :value=>'bad value'}])
     f.validate
     assert f.errors?, "'now' function does not support parameters"
@@ -40,8 +139,15 @@ class ParserTest < Test::Unit::TestCase
     f.validate
     assert f.errors?, "'days' function needs integer parameter"
   end
+
+  test "assert nil returned when function called with errors" do
+    f = FunctionResolver.new('radius', [{:type => :character, 
+        :value => "35.12 -68.33, 35.13 -68.34"},{:type => :decimal, 
+        :value => 1.0}])
+    assert_nil f.call
+  end
   
-  def test_invalid_function
+  test "invalid function" do
     f = FunctionResolver.new('then', [])
     f.validate
     assert f.errors?, "'then' is not a function"

data/test/unit/geo/record_circle_test.rb

@@ -0,0 +1,15 @@
+require 'test_helper'
+
+class Sparkql::Geo::RecordRadiusTest < Test::Unit::TestCase
+  def test_valid_record_id
+    assert Sparkql::Geo::RecordRadius.valid_record_id?("20100000000000000000000000")
+
+    ["2010000000000000000000000",
+     "201000000000000000000000000",
+     "test",
+     "12.45,-96.5"].each do |bad_record_id|
+        assert !Sparkql::Geo::RecordRadius.valid_record_id?(bad_record_id),
+          "'#{bad_record_id}' should not be a valid record_id"
+     end
+  end
+end

data/test/unit/lexer_test.rb

@@ -10,12 +10,34 @@ class LexerTest < Test::Unit::TestCase
       assert_equal :STANDARD_FIELD, token.first, standard_field
     end
   end
+
+  def test_standard_field_formats
+    ["City", "PostalCodePlus4", "Inb4ParserError"].each do |standard_field|
+      @lexer = Lexer.new("#{standard_field} Eq true")
+      token = @lexer.shift
+      assert_equal :STANDARD_FIELD, token.first, standard_field
+      assert_equal token[1], standard_field
+    end
+  end
+
+  def test_bad_standard_field_formats
+    @lexer = Lexer.new("4PostalCodePlus4 Eq true")
+    token = @lexer.shift
+    assert_equal :INTEGER, token.first
+    assert_equal token[1][:value], "4" 
+  end
+
   def test_check_reserved_words_conjunctions
     ['And Derp', 'Or 123'].each do |conjunction|
       @lexer = Lexer.new(conjunction)
       token = @lexer.shift
       assert_equal :CONJUNCTION, token.first, conjunction
     end
+    ['Not Lol'].each do |conjunction|
+      @lexer = Lexer.new(conjunction)
+      token = @lexer.shift
+      assert_equal :UNARY_CONJUNCTION, token.first, conjunction
+    end
   end
 
   def test_check_reserved_words_operators
@@ -24,6 +46,27 @@ class LexerTest < Test::Unit::TestCase
       token = @lexer.shift
       assert_equal :OPERATOR, token.first, op
     end
+
+    ['Bt 1234','Bt 1234,12345'].each do |op|
+      @lexer = Lexer.new(op)
+      token = @lexer.shift
+      assert_equal :RANGE_OPERATOR, token.first, op
+    end
+  end
+
+  def test_datetimes_matches
+    ['2013-07-26T10:22:15.422804', '2013-07-26T10:22:15'].each do |op|
+      @lexer = Lexer.new(op)
+      token = @lexer.shift
+      assert_equal :DATETIME, token.first, op
+    end
+  end
+
+  def test_utc_offsets
+    ['2013-07-26T10:22:15.422804-0300', '2013-07-26T10:22:15+0400'].each do |op|
+      @lexer = Lexer.new(op)
+      token = @lexer.shift
+      assert_equal :DATETIME, token.first, op
+    end
   end
-      
 end

data/test/unit/parser_compatability_test.rb

@@ -72,6 +72,11 @@ class ParserCompatabilityTest < Test::Unit::TestCase
         :type => :decimal,
         :operator => "In"
       },
+      {
+        :string => "FloatField Eq 100.1,2,3.4",
+        :type => :decimal,
+        :operator => "In"
+      },
       {
         :string => "DateField Eq 2010-10-10",
         :type => :date,
@@ -155,7 +160,7 @@ class ParserCompatabilityTest < Test::Unit::TestCase
     @test_filters.each do |elem|
       parser = Parser.new
       expressions = parser.tokenize( elem[:string] )
-      assert !parser.errors?, "Query: #{elem.inspect}"
+      assert !parser.errors?, "Query: #{elem.inspect} #{parser.errors.inspect}"
       assert_equal elem[:operator], expressions.first[:operator]
     end
   end
@@ -286,31 +291,50 @@ class ParserCompatabilityTest < Test::Unit::TestCase
       assert_nil ex
     end
   end
+  
+  test "mulitples shouldn't restrict based on string size(OMG LOL THAT WAS FUNNYWTF)" do 
+    parser = Parser.new
+    ex = parser.tokenize("ListAgentId Eq '20110000000000000000000000'")
+    assert !parser.errors?, parser.inspect
+  end
 
   test "max out values" do
-      parser = Parser.new
-      to_the_max = []
-      35.times do |x|
-        to_the_max << x
-      end
-      ex = parser.tokenize("City Eq #{to_the_max.join(',')}")
-      vals = ex.first[:value]
-      assert_equal 25, vals.size
+    parser = Parser.new
+    to_the_max = []
+    210.times do |x|
+      to_the_max << x
+    end
+    ex = parser.tokenize("City Eq #{to_the_max.join(',')}")
+    vals = ex.first[:value]
+    assert_equal 200, vals.size
+    assert parser.errors?
   end
 
   test "max out expressions" do
-      parser = Parser.new
-      to_the_max = []
-      60.times do |x|
-        to_the_max << "City Eq 'Fargo'"
-      end
-      vals = parser.tokenize(to_the_max.join(" And "))
-      assert_equal 50, vals.size
+    parser = Parser.new
+    to_the_max = []
+    60.times do |x|
+      to_the_max << "City Eq 'Fargo'"
+    end
+    vals = parser.tokenize(to_the_max.join(" And "))
+    assert_equal 50, vals.size
+    assert parser.errors?
+  end
+
+  test "max out function args" do
+    parser = Parser.new
+    to_the_max = []
+    201.times do |x|
+      to_the_max << "1"
+    end
+    vals = parser.tokenize("Args Eq myfunc(#{to_the_max.join(",")})")
+    assert parser.errors?
+    assert parser.errors.first.constraint?
   end
 
   test "API-107 And/Or in string spiel" do
       search_strings = ['Tom And Jerry', 'Tom Or Jerry', 'And Or Eq', 'City Eq \\\'Fargo\\\'',
-        ' And Eq Or ', 'Or And Or']
+        ' And Eq Or ', 'Or And Not']
       search_strings.each do |s|
         parser = Parser.new
         parser.tokenize("City Eq '#{s}' And PropertyType Eq 'A'")
@@ -433,5 +457,52 @@ class ParserCompatabilityTest < Test::Unit::TestCase
     expressions = parser.tokenize( "BooleanField Eq true" )
     assert_equal true, parser.escape_value(expressions.first)
   end
+
+  test "Between" do
+    ["BathsFull Bt 10,20", "DateField Bt 2012-12-31,2013-01-31"].each do |f|
+      parser = Parser.new
+      expressions = parser.tokenize f
+      assert !parser.errors?, "should successfully parse proper between values, but #{parser.errors.first}"
+    end
+
+    # truckload of fail
+    ["BathsFull Bt 2012-12-31,1", "DateField Bt 10,2012-12-31"].each do |f|
+      parser = Parser.new
+      expressions = parser.tokenize f
+      assert parser.errors?, "should have a type mismatch: #{parser.errors.first}"
+      assert_match /Type mismatch/, parser.errors.first.message
+    end
+    
+  end
+  
+  test "integer type coercion" do
+    parser = Parser.new
+    expression = parser.tokenize( "DecimalField Eq 100").first
+    assert parser.send(:check_type!, expression, :decimal)
+    assert_equal 100.0, parser.escape_value(expression)
+  end
+
+  test "datetime->date type coercion" do
+    t = Time.now
+    parser = Parser.new
+    expression = parser.tokenize( "DateField Eq now()").first
+    assert !parser.errors?
+    assert parser.send(:check_type!, expression, :date)
+    assert_equal t.strftime(Sparkql::FunctionResolver::STRFTIME_FORMAT), 
+                 parser.escape_value(expression).strftime(Sparkql::FunctionResolver::STRFTIME_FORMAT)
+  end
+  
+  test "datetime->date type coercion array" do
+    today = Time.now
+    parser = Parser.new
+    expression = parser.tokenize('"Custom"."DateField" Bt days(-1),now()').first
+    assert !parser.errors?
+    assert parser.send(:check_type!, expression, :date)
+    yesterday = today - 3600 * 24
+    assert_equal [ yesterday.strftime(Sparkql::FunctionResolver::STRFTIME_FORMAT),
+                   today.strftime(Sparkql::FunctionResolver::STRFTIME_FORMAT)], 
+                 parser.escape_value(expression).map { |i| i.strftime(Sparkql::FunctionResolver::STRFTIME_FORMAT)}
+  end
+
   
 end