rroonga 9.0.2 → 10.0.6

data/test/test-exception.rb

@@ -108,11 +108,16 @@ class TooManyOpenFilesTest < Test::Unit::TestCase
   include GroongaTestUtils
 
   def setup
+    @sub_context = nil
+    unless Process.const_defined?(:RLIMIT_NOFILE)
+      omit("No Process::RLIMIT_NOFILE")
+    end
     setup_database
     @sub_context = create_sub_context
   end
 
   def teardown
+    return if @sub_context.nil?
     @sub_context.database.close
     @sub_context.close
   end

data/test/test-flushable.rb

@@ -18,32 +18,77 @@ class FlushableTest < Test::Unit::TestCase
 
   setup :setup_database
 
+  def normalize_query_log(log)
+    log.lines.collect do |line|
+      line.chomp.gsub(/\A.*?:\d+ /, "")
+    end
+  end
+
   def test_flush_table
     table = Groonga::Hash.create
-    assert_nothing_raised do
+    log = collect_query_log do
       table.flush
     end
+    assert_equal([
+                   "flush[(anonymous:table:hash_key)]",
+                 ],
+                 normalize_query_log(log))
   end
 
   def test_flush_column
     table = Groonga::Hash.create(:name => "Users")
     column = table.define_column("name", "ShortText")
-    assert_nothing_raised do
+    log = collect_query_log do
       column.flush
     end
+    assert_equal([
+                   "flush[Users.name]",
+                 ],
+                 normalize_query_log(log))
   end
 
   def test_flush_database
-    assert_nothing_raised do
+    table = Groonga::Hash.create(:name => "Users")
+    table.define_column("name", "ShortText")
+    log = collect_query_log do
       @database.flush
     end
+    assert_equal([
+                   "flush[Users.name]",
+                   "flush[Users]",
+                   "flush[(anonymous:table:dat_key)]",
+                   "flush[(anonymous:column:var_size)]",
+                   "flush[(anonymous:table:hash_key)]",
+                   "flush[(anonymous:column:var_size)]",
+                   "flush[(DB)]",
+                 ],
+                 normalize_query_log(log))
   end
 
   def test_flush_not_recursive
-    table = Groonga::Hash.create
-    table.extend(Groonga::Flushable)
-    assert_nothing_raised do
+    table = Groonga::Hash.create(:name => "Users")
+    table.define_column("name", "ShortText")
+    log = collect_query_log do
       table.flush(:recursive => false)
     end
+    assert_equal([
+                   "flush[Users]",
+                 ],
+                 normalize_query_log(log))
+  end
+
+  def test_flush_dependent
+    referenced_table = Groonga::Hash.create(name: "Names")
+    table = Groonga::Hash.create(:name => "Users")
+    table.define_column("name", referenced_table)
+    log = collect_query_log do
+      table.flush(:recursive => false, :dependent => true)
+    end
+    assert_equal([
+                   "flush[Names]",
+                   "flush[Users.name]",
+                   "flush[Users]",
+                 ],
+                 normalize_query_log(log))
   end
 end

data/test/test-index-column.rb

@@ -33,11 +33,11 @@ class IndexColumnTest < Test::Unit::TestCase
       articles = Groonga::Array.create(:name => "Articles")
       articles.define_column("content", "Text")
 
-      terms = Groonga::Hash.create(:name => "Terms",
-                                   :key_type => "ShortText",
-                                   :default_tokenizer => "TokenBigram")
-      @index = terms.define_index_column("content", articles,
-                                         :with_section => true)
+      @terms = Groonga::Hash.create(:name => "Terms",
+                                    :key_type => "ShortText",
+                                    :default_tokenizer => "TokenBigram")
+      @index = @terms.define_index_column("content", articles,
+                                          :with_section => true)
     end
 
     def test_index?
@@ -63,6 +63,20 @@ class IndexColumnTest < Test::Unit::TestCase
         not @index.data?
       end
     end
+
+    sub_test_case("#lexicon?") do
+      def test_true
+        assert do
+          @terms.lexicon?
+        end
+      end
+
+      def test_false
+        assert do
+          not @index.lexicon?
+        end
+      end
+    end
   end
 
   class CRUDTest < self
@@ -438,11 +452,35 @@ class IndexColumnTest < Test::Unit::TestCase
                      ])
       end
 
+      def test_large
+        Groonga::Schema.define do |schema|
+          schema.create_table("Tags",
+                              :type => :patricia_trie,
+                              :key_type => "ShortText") do |table|
+            table.index("Articles.tags",
+                        :name => "large",
+                        :size => :large)
+            table.index("Articles.tags",
+                        :name => "default")
+          end
+        end
+
+        assert_equal([
+                       true,
+                       false,
+                     ],
+                     [
+                       context["Tags.large"].large?,
+                       context["Tags.default"].large?,
+                     ])
+      end
+
       def test_invalid
         Groonga::Schema.create_table("Tags",
                                      :type => :patricia_trie,
                                      :key_type => "ShortText")
-        message = ":size must be nil, :small or :medium: <invalid>"
+        message =
+          ":size must be nil, :small, :medium or :large: <invalid>"
         assert_raise(ArgumentError.new(message)) do
           tags = context["Tags"]
           tags.define_index_column("small",
@@ -818,5 +856,28 @@ class IndexColumnTest < Test::Unit::TestCase
                    ">",
                    index.inspect)
     end
+
+    def test_large_size
+      Groonga::Schema.define do |schema|
+        schema.create_table("Tags",
+                            :type => :hash,
+                            :key_type => "ShortText") do |tags|
+          tags.index("Articles.tag", :size => :large)
+        end
+      end
+
+      index = context["Tags.Articles_tag"]
+      source_column_names = index.sources.collect(&:local_name).join(",")
+      assert_equal("\#<Groonga::IndexColumn " +
+                   "id: <#{index.id}>, " +
+                   "name: <#{index.name}>, " +
+                   "path: <#{index.path}>, " +
+                   "domain: <#{index.domain.name}>, " +
+                   "range: <#{index.range.name}>, " +
+                   "flags: <LARGE>, " +
+                   "sources: <#{source_column_names}>" +
+                   ">",
+                   index.inspect)
+    end
   end
 end

data/test/test-index-cursor.rb

@@ -1,4 +1,5 @@
 # Copyright (C) 2012-2017  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2019  Horimoto Yasuhiro <horimoto@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
@@ -155,6 +156,31 @@ class IndexCursorTest < Test::Unit::TestCase
     assert_equal("l", term.key)
   end
 
+  sub_test_case(".set_min?") do
+    def setup
+      default_set_min = Groonga::IndexCursor.set_min?
+      begin
+        yield
+      ensure
+        Groonga::IndexCursor.set_min = default_set_min
+      end
+    end
+
+    def test_true
+      Groonga::IndexCursor.set_min = true
+      assert do
+        Groonga::IndexCursor.set_min?
+      end
+    end
+
+    def test_false
+      Groonga::IndexCursor.set_min = false
+      assert do
+        not Groonga::IndexCursor.set_min?
+      end
+    end
+  end
+
   private
   def create_hashes(keys, values)
     hashes = []

data/test/test-logger.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2010-2018  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2010-2019  Kouhei Sutou <kou@clear-code.com>
 # Copyright (C) 2016  Masafumi Yokoyama <yokoyama@clear-code.com>
 #
 # This library is free software; you can redistribute it and/or
@@ -21,15 +21,18 @@ class LoggerTest < Test::Unit::TestCase
     @default_log_path = Groonga::Logger.path
     @default_log_max_level = Groonga::Logger.max_level
     @default_rotate_threshold_size = Groonga::Logger.rotate_threshold_size
+    @default_flags = Groonga::Logger.flags
   end
 
   def teardown
     Groonga::Logger.path = @default_log_path
     Groonga::Logger.max_level = @default_log_max_level
     Groonga::Logger.rotate_threshold_size = @default_rotate_threshold_size
+    Groonga::Logger.flags = @default_flags
   end
 
   def test_reopen
+    only_not_windows
     Groonga::Logger.unregister
     Groonga::Logger.path = @log_path.to_s
     if @log_path.exist?
@@ -46,12 +49,22 @@ class LoggerTest < Test::Unit::TestCase
     assert_equal(:debug, Groonga::Logger.max_level)
   end
 
-  def test_flags
-    default_flags = Groonga::Logger::Flags::TIME |
-                      Groonga::Logger::Flags::MESSAGE
-    assert_equal(default_flags, Groonga::Logger.flags)
-    Groonga::Logger.flags = Groonga::Logger::Flags::LOCATION
-    assert_equal(Groonga::Logger::Flags::LOCATION, Groonga::Logger.flags)
+  sub_test_case ".flags" do
+    def test_default
+      assert_equal(Groonga::Logger::Flags::TIME |
+                   Groonga::Logger::Flags::MESSAGE,
+                   Groonga::Logger.flags)
+    end
+
+    def test_location
+      Groonga::Logger.flags = Groonga::Logger::Flags::LOCATION
+      assert_equal(Groonga::Logger::Flags::LOCATION, Groonga::Logger.flags)
+    end
+
+    def test_thread_id
+      Groonga::Logger.flags = Groonga::Logger::Flags::THREAD_ID
+      assert_equal(Groonga::Logger::Flags::THREAD_ID, Groonga::Logger.flags)
+    end
   end
 
   sub_test_case ".log" do
@@ -89,7 +102,8 @@ class LoggerTest < Test::Unit::TestCase
 
     test "default location" do
       locations = []
-      Groonga::Logger.register do |event, level, time, title, message, location|
+      Groonga::Logger.register(thread_id: false) do |*args|
+        location = args[5]
         locations << location
       end
       Groonga::Logger.log("message"); line = __LINE__
@@ -102,7 +116,8 @@ class LoggerTest < Test::Unit::TestCase
 
     test ":file" do
       locations = []
-      Groonga::Logger.register do |event, level, time, title, message, location|
+      Groonga::Logger.register(thread_id: false) do |*args|
+        location = args[5]
         locations << location
       end
       Groonga::Logger.log("message", :file => "file.rb")
@@ -118,7 +133,8 @@ class LoggerTest < Test::Unit::TestCase
 
     test ":line" do
       locations = []
-      Groonga::Logger.register do |event, level, time, title, message, location|
+      Groonga::Logger.register(thread_id: false) do |*args|
+        location = args[5]
         locations << location
       end
       Groonga::Logger.log("message", :line => 100)
@@ -134,7 +150,8 @@ class LoggerTest < Test::Unit::TestCase
 
     test ":function" do
       locations = []
-      Groonga::Logger.register do |event, level, time, title, message, location|
+      Groonga::Logger.register(thread_id: false) do |*args|
+        location = args[5]
         locations << location
       end
       Groonga::Logger.log("message", :function => "method_name")
@@ -149,6 +166,34 @@ class LoggerTest < Test::Unit::TestCase
     end
   end
 
+  sub_test_case ".register" do
+    setup do
+      GC.disable
+    end
+
+    teardown do
+      Groonga::Logger.unregister
+      GC.enable
+    end
+
+    test ":thread_id" do
+      locations = []
+      Groonga::Logger.register(location: false,
+                               thread_id: true) do |*args|
+        location = args[5]
+        locations << location
+      end
+      Groonga::Logger.log("message")
+      locations = locations.collect do |location|
+        location.gsub(/\A([a-f\d]+)\z/, "THREAD_ID")
+      end
+      assert_equal([
+                     "THREAD_ID",
+                   ],
+                   locations)
+    end
+  end
+
   def test_rotate_threshold_size
     Groonga::Logger.unregister
     Groonga::Logger.path = @log_path.to_s

data/test/test-plugin.rb

@@ -48,6 +48,7 @@ class PluginTest < Test::Unit::TestCase
     end
 
     def test_by_path
+      only_not_windows # TODO: We can remove this with Groonga 9.0.3
       context.register_plugin("token_filters/stop_word")
       assert_not_nil(context["TokenFilterStopWord"])
       plugin_path = "#{Groonga::Plugin.system_plugins_dir}/"

data/test/test-query-logger.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2015-2018  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2015-2019  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
@@ -29,6 +29,7 @@ class QueryLoggerTest < Test::Unit::TestCase
   end
 
   def test_reopen
+    only_not_windows
     Groonga::QueryLogger.unregister
     Groonga::QueryLogger.path = @query_log_path.to_s
     if @query_log_path.exist?
@@ -109,7 +110,7 @@ class QueryLoggerTest < Test::Unit::TestCase
       Groonga::QueryLogger.log("default")
       Groonga::QueryLogger.log("flags", :flags => "command")
       normalized_infos = infos.collect do |info|
-        info = info.gsub(/\A0x[a-f\d]+\|/,
+        info = info.gsub(/\A[a-zA-Z\d]+\|/,
                          "context_id|")
         info.gsub(/\|[\d]+ \z/,
                   "|timestamp ")
@@ -129,7 +130,7 @@ class QueryLoggerTest < Test::Unit::TestCase
       Groonga::QueryLogger.log("default")
       Groonga::QueryLogger.log("mark", :mark => ":")
       normalized_infos = infos.collect do |info|
-        info.gsub(/\A0x[a-f\d]+\|([^\d])?[\d]+ \z/,
+        info.gsub(/\A[a-zA-Z\d]+\|([^\d])?[\d]+ \z/,
                   "context_id|\\1timestamp ")
       end
       assert_equal([

data/test/test-record.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2009-2013  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2009-2019  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
@@ -647,6 +647,7 @@ class RecordTest < Test::Unit::TestCase
     end
 
     def test_to_json
+      only_not_windows
       ENV["TZ"] = "Japan"
       created_at = Time.parse("2013-05-16T16:57:34+09:00")
       values = {

data/test/test-remote.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2009-2010  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2009-2019  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
@@ -20,24 +20,69 @@ class RemoteTest < Test::Unit::TestCase
   def setup_remote_connection
     @process_id = nil
 
-    package_config = PKGConfig.package_config("groonga")
-    groonga = package_config.variable("groonga")
+    vendor_local_bin = File.join(__dir__, "..", "vendor", "local", "bin")
+    if File.exist?(vendor_local_bin)
+      groonga = File.join(vendor_local_bin, "groonga")
+    else
+      package_config = PKGConfig.package_config("groonga")
+      groonga = package_config.variable("groonga")
+      groonga = normalize_groonga_path(groonga)
+      groonga = "groonga" unless File.exist?(groonga)
+    end
 
     @host = "127.0.0.1"
     @port = 12345
     @remote_database_path = @tmp_dir + "remote-database"
-    @process_id = Process.fork do
-      exec(groonga,
-           "-i", @host,
-           "-p", @port.to_s,
-           "-s", "-n", @remote_database_path.to_s)
+    @process_id = spawn(groonga,
+                        "-i", @host,
+                        "-p", @port.to_s,
+                        "-s",
+                        "-n", @remote_database_path.to_s)
+    Timeout.timeout(5) do
+      loop do
+        begin
+          open_client do |client|
+            client.status
+          end
+        rescue Groonga::Client::Error
+        else
+          break
+        end
+      end
+    end
+  end
+
+  def normalize_groonga_path(groonga)
+    return groonga unless groonga
+    return groonga unless Object.const_defined?(:RubyInstaller)
+
+    msys2_installation = RubyInstaller::Runtime.msys2_installation
+    mingw_prefix = msys2_installation.mingw_prefix
+    mingw_bin_path = "#{mingw_prefix}/bin/"
+    mingw_bin_path_windows = "#{msys2_installation.mingw_bin_path}\\"
+    groonga.gsub(/\A#{Regexp.escape(mingw_bin_path)}/) do
+      mingw_bin_path_windows
     end
-    sleep(1)
   end
 
   teardown
   def teardown_remote_connection
-    Process.kill(:TERM, @process_id) if @process_id
+    if @process_id
+      begin
+        open_client do |client|
+          client.shutdown
+        end
+      rescue Groonga::Client::Error
+      end
+      Process.waitpid(@process_id)
+    end
+  end
+
+  def open_client(&block)
+    Groonga::Client.open(host: @host,
+                         port: @port,
+                         protocol: :gqtp,
+                         &block)
   end
 
   def test_send
@@ -53,6 +98,7 @@ class RemoteTest < Test::Unit::TestCase
                    "command_version",
                    "default_command_version",
                    "max_command_version",
+                   "n_jobs",
                    "n_queries",
                    "start_time",
                    "starttime",