rroonga 2.0.4 → 2.0.5

data/test/test-command-select.rb

@@ -0,0 +1,181 @@
+# Copyright (C) 2010-2012  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 CommandSelectTest < Test::Unit::TestCase
+  include GroongaTestUtils
+
+  setup :setup_database
+  setup
+  def setup_data
+    Groonga::Schema.define do |schema|
+      schema.create_table("Books",
+                          :type => :hash, :key_type => "ShortText") do |table|
+        table.time("published")
+      end
+
+      schema.create_table("Users",
+                          :type => :hash, :key_type => "ShortText") do |table|
+        table.reference("book", "Books")
+      end
+
+      schema.create_table("Bigram",
+                          :type => :patricia_trie,
+                          :key_type => "ShortText",
+                          :default_tokenizer => "TokenBigramSplitSymbolAlpha") do |table|
+        table.index("Books._key")
+      end
+    end
+
+    @books = Groonga["Books"]
+    @users = Groonga["Users"]
+
+    @books.add("the groonga book", :published => Time.parse("2010/04/01"))
+    @books.add("the groonga book (2)", :published => Time.parse("2011/04/01"))
+
+    @users.add("morita", :book => "the groonga book")
+    @users.add("gunyara-kun", :book => "the groonga book")
+    @users.add("yu")
+    @users.add("ryoqun", :book => "the groonga book (2)")
+  end
+
+  def test_no_option
+    result = context.select(@users)
+    assert_equal([4,
+                  [{"_id" => 1, "_key" => "morita",
+                     "book" => "the groonga book"},
+                   {"_id" => 2, "_key" => "gunyara-kun",
+                     "book" => "the groonga book"},
+                   {"_id" => 3, "_key" => "yu",
+                     "book" => ""},
+                   {"_id" => 4, "_key" => "ryoqun",
+                     "book" => "the groonga book (2)"}]],
+                 [result.n_hits, result.records])
+  end
+
+  def test_output_columns
+    result = context.select(@users, :output_columns => ["_key"])
+    assert_equal([4,
+                  [{"_key" => "morita"},
+                   {"_key" => "gunyara-kun"},
+                   {"_key" => "yu"},
+                   {"_key" => "ryoqun"}]],
+                 [result.n_hits, result.records])
+  end
+
+  def test_drill_down
+    result = context.select(@users,
+                            :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([4,
+                  [{"_key" => "morita"},
+                   {"_key" => "gunyara-kun"},
+                   {"_key" => "yu"},
+                   {"_key" => "ryoqun"}],
+                  {
+                    "_key" => [4, [{"_key" => "morita"},
+                                   {"_key" => "gunyara-kun"},
+                                   {"_key" => "yu"},
+                                   {"_key" => "ryoqun"}]],
+                    "book" => [2, [{"_key" => "the groonga book"},
+                                   {"_key" => "the groonga book (2)"}]],
+                  },
+                 ],
+                 [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
+    result = context.select(@books)
+    assert_equal([{
+                    "_id" => 1,
+                    "_key" => "the groonga book",
+                    "published" => Time.parse("2010/04/01"),
+                  },
+                  {
+                    "_id" => 2,
+                    "_key" => "the groonga book (2)",
+                    "published" => Time.parse("2011/04/01"),
+                  }],
+                 result.records)
+  end
+
+  def test_invalid
+    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
+
+  class EscapeTest < self
+    setup :setup_database
+
+    def test_backslash
+      key = "the \\ book"
+      @books.add(key, :published => Time.parse("2011/04/01"))
+
+      result = context.select(@books,
+                              :filter => "_key == \"the \\\\ book\"",
+                              :output_columns => ["_key", "published"])
+
+      assert_equal([{
+                     "_key" => key,
+                     "published" => Time.parse("2011/04/01"),
+                   }],
+                   result.records)
+    end
+
+    def test_double_quote
+      key = "the \"best\" book"
+      @books.add(key, :published => Time.parse("2011/04/01"))
+
+      result = context.select(@books,
+                              :filter => "_key == \"the \\\"best\\\" book\"",
+                              :output_columns => ["_key", "published"])
+
+      assert_equal([{
+                     "_key" => key,
+                     "published" => Time.parse("2011/04/01"),
+                   }],
+                   result.records)
+    end
+  end
+end

data/test/test-context.rb

@@ -0,0 +1,130 @@
+# Copyright (C) 2009-2011  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 ContextTest < Test::Unit::TestCase
+  include GroongaTestUtils
+
+  def test_default
+    context = Groonga::Context.default
+    assert_equal(Groonga::Encoding.default, context.encoding)
+  end
+
+  def test_default_options
+    Groonga::Context.default_options = {
+      :encoding => :utf8,
+    }
+    context = Groonga::Context.default
+    assert_equal(Groonga::Encoding::UTF8, context.encoding)
+  end
+
+  def test_create_database
+    db_path = @tmp_dir + "db"
+    assert_not_predicate(db_path, :exist?)
+    context = Groonga::Context.new
+    assert_equal(nil, context.database)
+    database = context.create_database(db_path.to_s)
+    assert_predicate(db_path, :exist?)
+    assert_not_predicate(database, :closed?)
+    assert_equal(database, context.database)
+  end
+
+  def test_create_temporary_database
+    before_files = @tmp_dir.children
+    context = Groonga::Context.new
+    database = context.create_database
+    assert_nil(database.name)
+    assert_equal(before_files, @tmp_dir.children)
+  end
+
+  def test_open_database
+    db_path = @tmp_dir + "db"
+    database = Groonga::Database.create(:path => db_path.to_s)
+    database.close
+
+    assert_predicate(database, :closed?)
+    called = false
+    context = Groonga::Context.new
+    context.open_database(db_path.to_s) do |_database|
+      database = _database
+      assert_not_predicate(database, :closed?)
+      called = true
+    end
+    assert_true(called)
+    assert_predicate(database, :closed?)
+  end
+
+  def test_encoding
+    context = Groonga::Context.new
+    assert_equal(Groonga::Encoding.default, context.encoding)
+
+    context = Groonga::Context.new(:encoding => :utf8)
+    assert_equal(Groonga::Encoding::UTF8, context.encoding)
+  end
+
+  def test_inspect
+    context = Groonga::Context.new(:encoding => Groonga::Encoding::UTF8)
+    assert_equal("#<Groonga::Context " +
+                 "encoding: <:utf8>, " +
+                 "database: <nil>>",
+                 context.inspect)
+  end
+
+  def test_inspect_with_database
+    db = Groonga::Database.create
+    context = Groonga::Context.default
+    assert_equal("#<Groonga::Context " +
+                 "encoding: <#{Groonga::Encoding.default.inspect}>, " +
+                 "database: <#{db.inspect}>>",
+                 context.inspect)
+  end
+
+  def test_array_reference_by_string
+    Groonga::Database.create
+    context = Groonga::Context.default
+    assert_equal("Int32", context["<int>"].name)
+  end
+
+  def test_array_reference_by_symbol
+    Groonga::Database.create
+    context = Groonga::Context.default
+    assert_equal("Bool", context[:Bool].name)
+  end
+
+  def test_shortcut_access
+    Groonga::Database.create
+    assert_equal("ShortText", Groonga["ShortText"].name)
+  end
+
+  def test_support_zlib?
+    assert_boolean(Groonga::Context.default.support_zlib?)
+  end
+
+  def test_support_lzo?
+    assert_boolean(Groonga::Context.default.support_lzo?)
+  end
+
+  def test_match_escalation_threshold
+    assert_equal(0, context.match_escalation_threshold)
+    context.match_escalation_threshold = -1
+    assert_equal(-1, context.match_escalation_threshold)
+  end
+
+  def test_close
+    context = Groonga::Context.new
+    assert_false(context.closed?)
+    context.close
+    assert_true(context.closed?)
+  end
+end

data/test/test-database-dumper.rb

@@ -0,0 +1,259 @@
+# Copyright (C) 2011  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 DatabaseDumperTest < Test::Unit::TestCase
+  include GroongaTestUtils
+
+  setup :setup_database, :before => :append
+
+  setup
+  def setup_tables
+    Groonga::Schema.define do |schema|
+      schema.create_table("Tags",
+                          :type => :hash,
+                          :key_type => :short_text,
+                          :default_tokenizer => :delimit) do |table|
+        table.text("name")
+      end
+
+      schema.create_table("Users",
+                          :type => :hash,
+                          :key_type => "ShortText") do |table|
+        table.text("name")
+      end
+
+      schema.create_table("Posts") do |table|
+        table.text("title")
+        table.reference("author", "Users")
+        table.integer("rank")
+        table.unsigned_integer("n_goods")
+        table.short_text("tag_text")
+        table.reference("tags", "Tags", :type => :vector)
+        table.boolean("published")
+        table.time("created_at")
+      end
+
+      schema.change_table("Users") do |table|
+        table.index("Posts.author")
+      end
+
+      schema.change_table("Tags") do |table|
+        table.index("Posts.tag_text")
+      end
+    end
+  end
+
+  private
+  def dump(options={})
+    Groonga::DatabaseDumper.new(options).dump
+  end
+
+  def posts
+    context["Posts"]
+  end
+
+  def dumped_schema
+    <<-EOS
+table_create Posts TABLE_NO_KEY
+column_create Posts created_at COLUMN_SCALAR Time
+column_create Posts n_goods COLUMN_SCALAR UInt32
+column_create Posts published COLUMN_SCALAR Bool
+column_create Posts rank COLUMN_SCALAR Int32
+column_create Posts tag_text COLUMN_SCALAR ShortText
+column_create Posts title COLUMN_SCALAR Text
+
+table_create Tags TABLE_HASH_KEY --key_type ShortText --default_tokenizer TokenDelimit
+column_create Tags name COLUMN_SCALAR Text
+
+table_create Users TABLE_HASH_KEY --key_type ShortText
+column_create Users name COLUMN_SCALAR Text
+
+column_create Posts author COLUMN_SCALAR Users
+column_create Posts tags COLUMN_VECTOR Tags
+
+column_create Tags Posts_tag_text COLUMN_INDEX Posts tag_text
+
+column_create Users Posts_author COLUMN_INDEX Posts author
+EOS
+  end
+
+  class EmptyTest < DatabaseDumperTest
+    def test_default
+      assert_equal(dumped_schema, dump)
+    end
+  end
+
+  class HaveDataTest < DatabaseDumperTest
+    setup
+    def setup_data
+      posts.add(:author => "mori",
+                :created_at => Time.parse("2010-03-08 16:52 +0900"),
+                :n_goods => 4,
+                :published => true,
+                :rank => 10,
+                :tag_text => "search mori",
+                :tags => ["search", "mori"],
+                :title => "Why search engine find?")
+    end
+
+    def test_default
+      assert_equal(<<-EOS, dump)
+#{dumped_schema.chomp}
+
+load --table Posts
+[
+["_id","author","created_at","n_goods","published","rank","tag_text","tags","title"],
+[1,"mori",1268034720.0,4,true,10,"search mori",["search","mori"],"Why search engine find?"]
+]
+
+load --table Tags
+[
+["_key","name"],
+["search",""],
+["mori",""]
+]
+
+load --table Users
+[
+["_key","name"],
+["mori",""]
+]
+EOS
+    end
+
+    def test_limit_tables
+      assert_equal(<<-EOS, dump(:tables => ["Posts"]))
+#{dumped_schema.chomp}
+
+load --table Posts
+[
+["_id","author","created_at","n_goods","published","rank","tag_text","tags","title"],
+[1,"mori",1268034720.0,4,true,10,"search mori",["search","mori"],"Why search engine find?"]
+]
+EOS
+    end
+
+    def test_limit_tables_with_regexp
+      assert_equal(<<-EOS, dump(:tables => [/Posts?/]))
+#{dumped_schema.chomp}
+
+load --table Posts
+[
+["_id","author","created_at","n_goods","published","rank","tag_text","tags","title"],
+[1,"mori",1268034720.0,4,true,10,"search mori",["search","mori"],"Why search engine find?"]
+]
+EOS
+    end
+
+    def test_exclude_tables
+      dump_options = {
+        :exclude_tables => ["Posts"],
+      }
+      assert_equal(<<-EOS, dump(dump_options))
+#{dumped_schema.chomp}
+
+load --table Tags
+[
+["_key","name"],
+["search",""],
+["mori",""]
+]
+
+load --table Users
+[
+["_key","name"],
+["mori",""]
+]
+EOS
+    end
+
+    def test_exclude_tables_with_regexp
+      dump_options = {
+        :exclude_tables => [/Posts?/],
+      }
+      assert_equal(<<-EOS, dump(dump_options))
+#{dumped_schema.chomp}
+
+load --table Tags
+[
+["_key","name"],
+["search",""],
+["mori",""]
+]
+
+load --table Users
+[
+["_key","name"],
+["mori",""]
+]
+EOS
+    end
+
+    def test_tables_combination
+      dump_options = {
+        :exclude_tables => ["Posts"],
+        :tables => ["Posts", "Users"],
+      }
+      assert_equal(<<-EOS, dump(dump_options))
+#{dumped_schema.chomp}
+
+load --table Users
+[
+["_key","name"],
+["mori",""]
+]
+EOS
+    end
+
+    def test_no_schema
+      assert_equal(<<-EOS, dump(:dump_schema => false))
+load --table Posts
+[
+["_id","author","created_at","n_goods","published","rank","tag_text","tags","title"],
+[1,"mori",1268034720.0,4,true,10,"search mori",["search","mori"],"Why search engine find?"]
+]
+
+load --table Tags
+[
+["_key","name"],
+["search",""],
+["mori",""]
+]
+
+load --table Users
+[
+["_key","name"],
+["mori",""]
+]
+EOS
+    end
+
+    def test_no_tables
+      assert_equal(<<-EOS, dump(:dump_tables => false))
+#{dumped_schema.chomp}
+EOS
+    end
+  end
+
+  class PluginTest < DatabaseDumperTest
+    def test_standard_plugin
+      Groonga::Plugin.register("suggest/suggest")
+      assert_equal("register suggest/suggest\n" +
+                   "\n" +
+                   dumped_schema,
+                   dump)
+    end
+  end
+end