rroonga 0.9.4 → 0.9.5

data/test-unit/test/util/test_procwrapper.rb

@@ -0,0 +1,36 @@
+# Author:: Nathaniel Talbott.
+# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
+# License:: Ruby license.
+
+require 'test/unit'
+require 'test/unit/util/procwrapper'
+
+module Test
+  module Unit
+    module Util
+      class TC_ProcWrapper < TestCase
+        def munge_proc(&a_proc)
+          return a_proc
+        end
+        def setup
+          @original = proc {}
+          @munged = munge_proc(&@original)
+          @wrapped_original = ProcWrapper.new(@original)
+          @wrapped_munged = ProcWrapper.new(@munged)
+        end
+        def test_wrapping
+          assert_same(@original, @wrapped_original.to_proc, "The wrapper should return what was wrapped")
+        end
+        def test_hashing
+      
+          assert_equal(@wrapped_original.hash, @wrapped_munged.hash, "The original and munged should have the same hash when wrapped")
+          assert_equal(@wrapped_original, @wrapped_munged, "The wrappers should be equivalent")
+          
+          a_hash = {@wrapped_original => @original}
+          assert(a_hash[@wrapped_original], "Should be able to access the wrapper in the hash")
+          assert_equal(a_hash[@wrapped_original], @original, "Should be able to access the wrapper in the hash")
+        end
+      end
+    end
+  end
+end

data/test/groonga-test-utils.rb

@@ -126,9 +126,10 @@ module GroongaTestUtils
   end
 
   private
-  def assert_equal_select_result(expected, actual)
+  def assert_equal_select_result(expected, actual, &normalizer)
+    normalizer ||= Proc.new {|record| record.key}
     assert_equal(expected,
-                 actual.collect {|record| record.key},
+                 actual.collect(&normalizer),
                  actual.expression.inspect)
   end
 end

data/test/run-test.rb

@@ -22,6 +22,8 @@ $KCODE = "u" if RUBY_VERSION < "1.9"
 base_dir = File.expand_path(File.join(File.dirname(__FILE__), ".."))
 test_unit_dir = File.join(base_dir, "test-unit")
 test_unit_lib_dir = File.join(test_unit_dir, "lib")
+test_unit_notify_dir = File.join(base_dir, "test-unit-notify")
+test_unit_notify_lib_dir = File.join(test_unit_notify_dir, "lib")
 ext_dir = File.join(base_dir, "ext", "groonga")
 lib_dir = File.join(base_dir, "lib")
 test_dir = File.join(base_dir, "test")
@@ -36,16 +38,26 @@ if make
   system("cd #{base_dir.dump} && #{make} > /dev/null") or exit(false)
 end
 
+test_unit_repository_base = "http://test-unit.rubyforge.org/svn/"
 unless File.exist?(test_unit_dir)
-  test_unit_repository = "http://test-unit.rubyforge.org/svn/trunk/"
-  system("svn co #{test_unit_repository} #{test_unit_dir}") or exit(false)
+  test_unit_repository = "#{test_unit_repository_base}trunk/"
+  system("svn", "co", test_unit_repository, test_unit_dir) or exit(false)
+end
+
+unless File.exist?(test_unit_notify_dir)
+  test_unit_notify_repository = "#{test_unit_repository_base}/extensions/test-unit-notify/trunk/"
+  system("svn", "co", test_unit_notify_repository, test_unit_notify_dir) or exit(false)
+  system("svn", "up", test_unit_dir) or exit(false)
 end
 
 $LOAD_PATH.unshift(test_unit_lib_dir)
+$LOAD_PATH.unshift(test_unit_notify_lib_dir)
 
 require 'test/unit'
+require 'test/unit/notify'
 
 ARGV.unshift("--priority-mode")
+ARGV.unshift("--notify")
 
 $LOAD_PATH.unshift(ext_dir)
 $LOAD_PATH.unshift(lib_dir)

data/test/test-column.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2009  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2009-2010  Kouhei Sutou <kou@clear-code.com>
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -183,7 +183,7 @@ class ColumnTest < Test::Unit::TestCase
                  result.records.collect do |record|
                    record["body"]
                  end)
-    assert_equal("#<Groonga::Expression noname(?0:\"\")" +
+    assert_equal("#<Groonga::Expression noname($1:\"\")" +
                  "{2body GET_VALUE,0\"drive\",0MATCH}>",
                  result.expression.inspect)
   end
@@ -214,7 +214,7 @@ class ColumnTest < Test::Unit::TestCase
                  result.records.collect do |record|
                    record["body"]
                  end)
-    assert_equal("#<Groonga::Expression noname(?0:\"\")" +
+    assert_equal("#<Groonga::Expression noname($1:\"\")" +
                  "{2body GET_VALUE,0\"drive\",0MATCH}>",
                  result.expression.inspect)
   end
@@ -232,8 +232,8 @@ class ColumnTest < Test::Unit::TestCase
                  result.records.collect do |record|
                    record["body"]
                  end)
-    assert_equal("#<Groonga::Expression noname(?0:\"\")" +
-                 "{0?0,2body GET_VALUE,0\"drive\",0MATCH}>",
+    assert_equal("#<Groonga::Expression noname($1:\"\")" +
+                 "{0\"\",2body GET_VALUE,0\"drive\",0MATCH}>",
                  result.expression.inspect)
   end
 
@@ -247,8 +247,8 @@ class ColumnTest < Test::Unit::TestCase
                  result.records.collect do |record|
                    record["body"]
                  end)
-    assert_equal("#<Groonga::Expression noname(?0:\"\")" +
-                 "{1?0,2body GET_VALUE,0\"drive\",0MATCH}>",
+    assert_equal("#<Groonga::Expression noname($1:\"\")" +
+                 "{1\"\",2body GET_VALUE,0\"drive\",0MATCH}>",
                  result.expression.inspect)
   end
 

data/test/test-context-select.rb

@@ -42,12 +42,6 @@ class ContextSelectTest < Test::Unit::TestCase
                  [result.n_hits, result.records])
   end
 
-  def test_success
-    result = context.select(@users)
-    assert_equal([true, 0, nil],
-                 [result.success?, result.return_code, result.error_message])
-  end
-
   def test_output_columns
     result = context.select(@users, :output_columns => ["_key"])
     assert_equal([3,
@@ -63,10 +57,7 @@ class ContextSelectTest < Test::Unit::TestCase
                             :drill_down => ["_key", "book"],
                             :drill_down_output_columns => "_key",
                             :drill_down_limit => 10)
-    normalized_drill_down = {}
-    result.drill_down.each do |key, drill_down|
-      normalized_drill_down[key] = [drill_down.n_hits, drill_down.records]
-    end
+    drill_down = normalize_drill_down(result.drill_down)
     assert_equal([3,
                   [{"_key" => "morita"},
                    {"_key" => "gunyara-kun"},
@@ -78,7 +69,24 @@ class ContextSelectTest < Test::Unit::TestCase
                     "book" => [1, [{"_key" => "the groonga book"}]],
                   },
                  ],
-                 [result.n_hits, result.records, normalized_drill_down])
+                 [result.n_hits, result.records, drill_down])
+  end
+
+  def test_drill_down_with_no_hit
+    result = context.select(@users,
+                            :filter => "_key == \"no hit\"",
+                            :output_columns => ["_key"],
+                            :drill_down => ["_key", "book"],
+                            :drill_down_output_columns => "_key",
+                            :drill_down_limit => 10)
+    drill_down = normalize_drill_down(result.drill_down)
+    assert_equal([0, [],
+                  {
+                    "_key" => [0, []],
+                    "book" => [0, []],
+                  },
+                 ],
+                 [result.n_hits, result.records, drill_down])
   end
 
   def test_time
@@ -90,4 +98,19 @@ class ContextSelectTest < Test::Unit::TestCase
                   }],
                  result.records)
   end
+
+  def test_invalid_select
+    assert_raise(Groonga::SyntaxError) do
+      context.select(@books, :query => "<")
+    end
+  end
+
+  private
+  def normalize_drill_down(drill_down)
+    normalized_drill_down = {}
+    drill_down.each do |key, drill|
+      normalized_drill_down[key] = [drill.n_hits, drill.records]
+    end
+    normalized_drill_down
+  end
 end

data/test/test-exception.rb

@@ -89,5 +89,8 @@ class ExceptionTest < Test::Unit::TestCase
     assert_const_defined(Groonga, :RetryMax)
     assert_const_defined(Groonga, :IncompatibleFileFormat)
     assert_const_defined(Groonga, :UpdateNotAllowed)
+    assert_const_defined(Groonga, :TooSmallOffset)
+    assert_const_defined(Groonga, :TooLargeOffset)
+    assert_const_defined(Groonga, :TooSmallLimit)
   end
 end

data/test/test-expression-builder.rb

@@ -214,4 +214,15 @@ class ExpressionBuilderTest < Test::Unit::TestCase
     assert_equal(["yu"],
                  result.collect {|record| record["_key"]})
   end
+
+  def test_array_result
+    result = @users.select do |record|
+      conditions = []
+      conditions << (record.hp > 100)
+      conditions << (record.hp < 200)
+      conditions
+    end
+    assert_equal(["gunyara-kun"],
+                 result.collect {|record| record.key.key})
+  end
 end

data/test/test-expression.rb

@@ -45,8 +45,7 @@ class ExpressionTest < Test::Unit::TestCase
     expression.append_constant("name")
     expression.append_operation(Groonga::Operation::GET_VALUE, 2)
     expression.compile
-    expression.execute
-    assert_equal("mori daijiro", context.pop)
+    assert_equal("mori daijiro", expression.execute)
   end
 
   def test_get_value_with_variable
@@ -63,12 +62,10 @@ class ExpressionTest < Test::Unit::TestCase
     expression.append_constant("name")
     expression.append_operation(Groonga::Operation::GET_VALUE, 2)
     expression.compile
-    expression.execute
-    assert_equal("mori daijiro", context.pop)
+    assert_equal("mori daijiro", expression.execute)
 
     variable.value = gunyara_kun.id
-    expression.execute
-    assert_equal("Tasuku SUENAGA", context.pop)
+    assert_equal("Tasuku SUENAGA", expression.execute)
   end
 
   def test_inspect

data/test/test-gqtp.rb

@@ -50,13 +50,13 @@ class GQTPTest < Test::Unit::TestCase
   end
 
   def test_select_filter_by_existent_user
-    assert_equal([[0, 0.0, 0.0], [[[1], [["user", "Users"]], ["darashi"]]]],
+    assert_equal([[[1], [["user", "Users"]], ["darashi"]]],
                  process("select Comments --output_columns user " +
                          "--filter 'user == \"darashi\"'"))
   end
 
   def test_select_filter_by_nonexistent_user
-    assert_equal([[0, 0.0, 0.0], [[[0], [["user", "Users"]]]]],
+    assert_equal([[[0], [["user", "Users"]]]],
                  process("select Comments --output_columns user " +
                          "--filter 'user == \"yu\"'"))
   end
@@ -65,8 +65,6 @@ class GQTPTest < Test::Unit::TestCase
   def process(gqtp)
     context.send(gqtp)
     id, result = context.receive
-    result = JSON.parse(result)
-    result[0][1..2] = [0.0, 0.0] if result[0][0].zero?
-    result
+    JSON.parse(result)
   end
 end

data/test/test-pagination.rb

@@ -0,0 +1,249 @@
+# Copyright (C) 2010  Kouhei Sutou <kou@clear-code.com>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License version 2.1 as published by the Free Software Foundation.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+class PaginationTest < Test::Unit::TestCase
+  include GroongaTestUtils
+
+  setup :setup_database
+
+  setup
+  def setup_data
+    Groonga::Schema.define do |schema|
+      schema.create_table("Users",
+                          :type => :hash,
+                          :key_type => "ShortText") do |table|
+        table.uint32(:number)
+      end
+    end
+    @users = context["Users"]
+    150.times do |i|
+      @users.add("user#{i + 1}", :number => i + 1)
+    end
+  end
+
+  def test_default
+    assert_paginate({
+                      :current_page => 1,
+                      :page_size => 10,
+                      :n_pages => 15,
+                      :n_records => 150,
+                      :start_offset => 1,
+                      :end_offset => 10,
+                      :have_previous_page? => false,
+                      :previous_page => nil,
+                      :have_next_page? => true,
+                      :next_page => 2,
+                      :first_page? => true,
+                      :last_page? => false,
+                      :have_pages? => true,
+                    })
+  end
+
+  def test_no_entries
+    @users.each do |user|
+      user.delete
+    end
+    assert_paginate({
+                      :current_page => 1,
+                      :page_size => 10,
+                      :n_pages => 1,
+                      :n_records => 0,
+                      :start_offset => nil,
+                      :end_offset => nil,
+                      :have_previous_page? => false,
+                      :previous_page => nil,
+                      :have_next_page? => false,
+                      :next_page => nil,
+                      :first_page? => true,
+                      :last_page? => true,
+                      :have_pages? => false,
+                      :keys => [],
+                    })
+  end
+
+  def test_page
+    assert_paginate({
+                      :current_page => 6,
+                      :page_size => 10,
+                      :n_pages => 15,
+                      :n_records => 150,
+                      :start_offset => 51,
+                      :end_offset => 60,
+                      :have_previous_page? => true,
+                      :previous_page => 5,
+                      :have_next_page? => true,
+                      :next_page => 7,
+                      :first_page? => false,
+                      :last_page? => false,
+                      :have_pages? => true,
+                    },
+                    :page => 6)
+  end
+
+  def test_max_page
+    assert_paginate({
+                      :current_page => 15,
+                      :page_size => 10,
+                      :n_pages => 15,
+                      :n_records => 150,
+                      :start_offset => 141,
+                      :end_offset => 150,
+                      :have_previous_page? => true,
+                      :previous_page => 14,
+                      :have_next_page? => false,
+                      :next_page => nil,
+                      :first_page? => false,
+                      :last_page? => true,
+                      :have_pages? => true,
+                    },
+                    :page => 15)
+  end
+
+  def test_too_large_page
+    assert_raise(Groonga::TooLargePage) do
+      assert_paginate({},
+                      :page => 16)
+    end
+  end
+
+  def test_zero_page
+    assert_raise(Groonga::TooSmallPage) do
+      assert_paginate({},
+                      :page => 0)
+    end
+  end
+
+  def test_negative_page
+    assert_raise(Groonga::TooSmallPage) do
+      assert_paginate({},
+                      :page => -1)
+    end
+  end
+
+  def test_size
+    assert_paginate({
+                      :current_page => 1,
+                      :page_size => 7,
+                      :n_pages => 22,
+                      :n_records => 150,
+                      :start_offset => 1,
+                      :end_offset => 7,
+                      :have_previous_page? => false,
+                      :previous_page => nil,
+                      :have_next_page? => true,
+                      :next_page => 2,
+                      :first_page? => true,
+                      :last_page? => false,
+                      :have_pages? => true,
+                    },
+                    :size => 7)
+  end
+
+  def test_max_size
+    assert_paginate({
+                      :current_page => 1,
+                      :page_size => 150,
+                      :n_pages => 1,
+                      :n_records => 150,
+                      :start_offset => 1,
+                      :end_offset => 150,
+                      :have_previous_page? => false,
+                      :previous_page => nil,
+                      :have_next_page? => false,
+                      :next_page => nil,
+                      :first_page? => true,
+                      :last_page? => true,
+                      :have_pages? => false,
+                    },
+                    :size => 150)
+  end
+
+  def test_too_large_size
+    assert_paginate({
+                      :current_page => 1,
+                      :page_size => 151,
+                      :n_pages => 1,
+                      :n_records => 150,
+                      :start_offset => 1,
+                      :end_offset => 150,
+                      :have_previous_page? => false,
+                      :previous_page => nil,
+                      :have_next_page? => false,
+                      :next_page => nil,
+                      :first_page? => true,
+                      :last_page? => true,
+                      :have_pages? => false,
+                    },
+                    :size => 151)
+  end
+
+  def test_zero_size
+    assert_raise(Groonga::TooSmallPageSize) do
+      assert_paginate({},
+                      :size => 0)
+    end
+  end
+
+  def test_negative_size
+    assert_raise(Groonga::TooSmallPageSize) do
+      assert_paginate({},
+                      :size => -1)
+    end
+  end
+
+  def test_full
+    assert_paginate({
+                      :current_page => 2,
+                      :page_size => 50,
+                      :n_pages => 3,
+                      :n_records => 150,
+                      :start_offset => 51,
+                      :end_offset => 100,
+                      :have_previous_page? => true,
+                      :previous_page => 1,
+                      :have_next_page? => true,
+                      :next_page => 3,
+                      :first_page? => false,
+                      :last_page? => false,
+                      :have_pages? => true,
+                    },
+                    :page => 2,
+                    :size => 50)
+  end
+
+  private
+  def assert_paginate(expected, options={})
+    users = @users.paginate([["number"]], options)
+    if expected[:keys].nil?
+      range = (expected[:start_offset]..expected[:end_offset])
+      expected[:keys] = range.collect {|i| "user#{i}"}
+    end
+    assert_equal(expected,
+                 :current_page => users.current_page,
+                 :page_size => users.page_size,
+                 :n_pages => users.n_pages,
+                 :n_records => users.n_records,
+                 :start_offset => users.start_offset,
+                 :end_offset => users.end_offset,
+                 :previous_page => users.previous_page,
+                 :have_previous_page? => users.have_previous_page?,
+                 :next_page => users.next_page,
+                 :have_next_page? => users.have_next_page?,
+                 :first_page? => users.first_page?,
+                 :last_page? => users.last_page?,
+                 :have_pages? => users.have_pages?,
+                 :keys => users.collect(&:key))
+  end
+end