rroonga 1.0.1-x86-mingw32 → 1.1.0-x86-mingw32

data/test/test-index-column.rb

@@ -22,6 +22,39 @@ class IndexColumnTest < Test::Unit::TestCase
     setup_database
   end
 
+  def test_index?
+    articles = Groonga::Array.create(:name => "Articles")
+    articles.define_column("content", "Text")
+
+    terms = Groonga::Hash.create(:name => "Terms",
+                                 :default_tokenizer => "TokenBigram")
+    content_index = terms.define_index_column("content", articles,
+                                              :with_section => true)
+    assert_predicate(content_index, :index?)
+  end
+
+  def test_vector?
+    articles = Groonga::Array.create(:name => "Articles")
+    articles.define_column("content", "Text")
+
+    terms = Groonga::Hash.create(:name => "Terms",
+                                 :default_tokenizer => "TokenBigram")
+    content_index = terms.define_index_column("content", articles,
+                                              :with_section => true)
+    assert_not_predicate(content_index, :vector?)
+  end
+
+  def test_scalar?
+    articles = Groonga::Array.create(:name => "Articles")
+    articles.define_column("content", "Text")
+
+    terms = Groonga::Hash.create(:name => "Terms",
+                                 :default_tokenizer => "TokenBigram")
+    content_index = terms.define_index_column("content", articles,
+                                              :with_section => true)
+    assert_not_predicate(content_index, :scalar?)
+  end
+
   def test_array_set_with_record
     articles = Groonga::Array.create(:name => "Articles")
     articles.define_column("content", "Text")

data/test/test-patricia-trie.rb

@@ -21,6 +21,12 @@ class PatriciaTrieTest < Test::Unit::TestCase
 
   setup :setup_database
 
+  def test_support_key?
+    assert_predicate(Groonga::PatriciaTrie.create(:name => "Users",
+                                                  :key_type => "ShortText"),
+                     :support_key?)
+  end
+
   def test_encoding
     assert_equal(Groonga::Encoding.default,
                  Groonga::PatriciaTrie.create.encoding)

data/test/test-plugin.rb

@@ -0,0 +1,29 @@
+# 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 PluginTest < Test::Unit::TestCase
+  include GroongaTestUtils
+
+  setup :setup_sandbox
+  setup :setup_database
+  teardown :teardown_sandbox
+
+  def test_register
+    context = Groonga::Context.default
+    assert_nil(context["suggest"])
+    context.register_plugin("suggest/suggest")
+    assert_not_nil(context["suggest"])
+  end
+end

data/test/test-record.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2009-2010  Kouhei Sutou <kou@clear-code.com>
+# 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
@@ -77,6 +77,39 @@ class RecordTest < Test::Unit::TestCase
     assert_false(groonga.have_column?(:nonexistent))
   end
 
+  def test_have_column_id
+    groonga = @bookmarks.add
+    assert_true(groonga.have_column?(:_id))
+  end
+
+  def test_have_column_key_hash
+    mori = @users.add("mori")
+    assert_true(mori.have_column?(:_key))
+  end
+
+  def test_have_column_key_array_with_value_type
+    groonga = @bookmarks.add
+    assert_true(groonga.have_column?(:_key))
+  end
+
+  def test_have_column_key_array_without_value_type
+    groonga_ml = @addresses.add
+    assert_false(groonga_ml.have_column?(:_key))
+  end
+
+  def test_have_column_nsubrecs_existent
+    @users.add("mori")
+    bookmarks = @users.select do |record|
+      record.key == "mori"
+    end
+    assert_true(bookmarks.to_a.first.have_column?(:_nsubrecs))
+  end
+
+  def test_have_column_nsubrecs_nonexistent
+    groonga = @bookmarks.add
+    assert_false(groonga.have_column?(:_nsubrecs))
+  end
+
   def test_get_nonexistent_column
     groonga = @bookmarks.add
     assert_raise(Groonga::NoSuchColumn) do
@@ -164,6 +197,27 @@ class RecordTest < Test::Unit::TestCase
     assert_true(bookmark.reference_column?("user"))
   end
 
+  def test_index_column?
+    bookmark = @bookmarks.add
+    assert_false(bookmark.index_column?("uri"))
+    index = @bookmarks_index.add("token")
+    assert_true(index.index_column?("content"))
+  end
+
+  def test_vector_column?
+    bookmark = @bookmarks.add
+    assert_false(bookmark.vector_column?("uri"))
+    morita = @users.add("morita")
+    assert_true(morita.vector_column?("addresses"))
+  end
+
+  def test_scalar_column?
+    bookmark = @bookmarks.add
+    assert_true(bookmark.scalar_column?("uri"))
+    morita = @users.add("morita")
+    assert_false(morita.scalar_column?("addresses"))
+  end
+
   def test_score
     groonga = @bookmarks.add
     groonga["content"] = "full text search search search engine."
@@ -275,4 +329,33 @@ class RecordTest < Test::Unit::TestCase
     users = @users.select {|record| record.key == "morita"}
     assert_predicate(users.to_a[0], :support_sub_records?)
   end
+
+  def test_set_record_like_object
+    kou_at_clear_code = @addresses.add(:mail => "kou@clear-code.com")
+    record_like_class = Class.new do
+      attr_reader :record_raw_id
+      def initialize(record_raw_id)
+        @record_raw_id = record_raw_id
+      end
+    end
+    record_like_object = record_like_class.new(kou_at_clear_code.record_raw_id)
+    kou = @users.add("kou")
+    kou.addresses = [record_like_object]
+  end
+
+  def test_set_array_like_records
+    kou_at_clear_code = @addresses.add(:mail => "kou@clear-code.com")
+    array_like_class = Class.new do
+      def initialize(records)
+        @records = records
+      end
+
+      def to_ary
+        @records
+      end
+    end
+    array_like_object = array_like_class.new([kou_at_clear_code])
+    kou = @users.add("kou")
+    kou.addresses = array_like_object
+  end
 end

data/test/test-remote.rb

@@ -47,8 +47,9 @@ class RemoteTest < Test::Unit::TestCase
     id, result = _context.receive
     assert_equal(0, id)
     values = JSON.load(result)
-    assert_equal(["alloc_count", "cache_hit_rate", "n_queries",
-                  "starttime", "uptime", "version"],
+    assert_equal(["alloc_count", "cache_hit_rate", "command_version",
+                  "default_command_version", "max_command_version",
+                  "n_queries", "starttime", "uptime", "version"],
                  values.keys.sort)
   end
 

data/test/test-schema-create-table.rb

@@ -87,7 +87,7 @@ module SchemaCreateTableTests
     assert_true(context["Posts"].support_sub_records?)
   end
 
-  def test_differnt_sub_records
+  def test_different_sub_records
     Groonga::Schema.create_table("Posts",
                                  options(:sub_records => true)) do |table|
     end
@@ -99,6 +99,35 @@ module SchemaCreateTableTests
     end
   end
 
+  def test_same_path
+    path = (@tmp_dir + "posts.groonga").to_s
+    Groonga::Schema.create_table("Posts", options(:path => path)) do |table|
+    end
+
+    Groonga::Schema.create_table("Posts", options(:path => path)) do |table|
+    end
+    assert_equal(path, context["Posts"].path)
+  end
+
+  def test_different_path
+    path = (@tmp_dir + "posts.groonga").to_s
+    Groonga::Schema.create_table("Posts", options(:path => path)) do |table|
+    end
+
+    assert_raise(Groonga::Schema::TableCreationWithDifferentOptions) do
+      path = (@tmp_dir + "posts.grn").to_s
+      Groonga::Schema.create_table("Posts", options(:path => path)) do |table|
+      end
+    end
+  end
+
+  def test_default_path
+    Groonga::Schema.create_table("Posts", options) do |table|
+    end
+    assert_equal("#{@database_path}.tables/Posts",
+                 context["Posts"].path)
+  end
+
   private
   def options(addional_options={})
     default_options.merge(addional_options)
@@ -118,7 +147,8 @@ module SchemaCreateTableWithKeyTests
   end
 
   def test_differnt_key_type
-    Groonga::Schema.create_table("Posts", options) do |table|
+    Groonga::Schema.create_table("Posts",
+                                 options(:key_type => "Int32")) do |table|
     end
 
     assert_raise(Groonga::Schema::TableCreationWithDifferentOptions) do

data/test/test-schema-type.rb

@@ -0,0 +1,167 @@
+# 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 SchemaTypeTest < Test::Unit::TestCase
+  include GroongaTestUtils
+
+  def test_normalize_short_text
+    assert_normalize_type("ShortText", "short_text")
+    assert_normalize_type("ShortText", "string")
+    assert_normalize_type("ShortText", "ShortText")
+  end
+
+  def test_normalize_text
+    assert_normalize_type("Text", "text")
+    assert_normalize_type("Text", "Text")
+  end
+
+  def test_normalize_long_text
+    assert_normalize_type("LongText", "binary")
+    assert_normalize_type("LongText", "long_text")
+    assert_normalize_type("LongText", "LongText")
+  end
+
+  def test_normalize_integer32
+    assert_normalize_type("Int32", "int")
+    assert_normalize_type("Int32", "integer")
+    assert_normalize_type("Int32", "int32")
+    assert_normalize_type("Int32", "integer32")
+    assert_normalize_type("Int32", "Int32")
+  end
+
+  def test_normalize_integer64
+    assert_normalize_type("Int64", "int64")
+    assert_normalize_type("Int64", "integer64")
+    assert_normalize_type("Int64", "Int64")
+  end
+
+  def test_normalize_unsigned_integer32
+    assert_normalize_type("UInt32", "uint")
+    assert_normalize_type("UInt32", "unsigned_integer")
+    assert_normalize_type("UInt32", "uint32")
+    assert_normalize_type("UInt32", "unsigned_integer32")
+    assert_normalize_type("UInt32", "UInt32")
+  end
+
+  def test_normalize_unsigned_integer64
+    assert_normalize_type("UInt64", "uint64")
+    assert_normalize_type("UInt64", "unsigned_integer64")
+    assert_normalize_type("UInt64", "UInt64")
+  end
+
+  def test_normalize_float
+    assert_normalize_type("Float", "float")
+    assert_normalize_type("Float", "Float")
+  end
+
+  def test_normalize_time
+    assert_normalize_type("Time", "datetime")
+    assert_normalize_type("Time", "timestamp")
+    assert_normalize_type("Time", "time")
+    assert_normalize_type("Time", "date")
+    assert_normalize_type("Time", "Time")
+  end
+
+  def test_normalize_boolean
+    assert_normalize_type("Bool", "boolean")
+    assert_normalize_type("Bool", "Bool")
+  end
+
+  def test_normalize_unigram
+    assert_normalize_type("TokenUnigram", "unigram")
+    assert_normalize_type("TokenUnigram", "token_unigram")
+    assert_normalize_type("TokenUnigram", "TokenUnigram")
+  end
+
+  def test_normalize_bigram
+    assert_normalize_type("TokenBigram", "bigram")
+    assert_normalize_type("TokenBigram", "token_bigram")
+    assert_normalize_type("TokenBigram", "TokenBigram")
+  end
+
+  def test_normalize_bigram_split_symbol
+    assert_normalize_type("TokenBigramSplitSymbol", "bigram_split_symbol")
+    assert_normalize_type("TokenBigramSplitSymbol", "token_bigram_split_symbol")
+    assert_normalize_type("TokenBigramSplitSymbol", "TokenBigramSplitSymbol")
+  end
+
+  def test_normalize_bigram_split_symbol_alpha
+    assert_normalize_type("TokenBigramSplitSymbolAlpha",
+                          "bigram_split_symbol_alpha")
+    assert_normalize_type("TokenBigramSplitSymbolAlpha",
+                          "token_bigram_split_symbol_alpha")
+    assert_normalize_type("TokenBigramSplitSymbolAlpha",
+                          "TokenBigramSplitSymbolAlpha")
+  end
+
+  def test_normalize_bigram_split_symbol_alpha_digit
+    assert_normalize_type("TokenBigramSplitSymbolAlphaDigit",
+                          "bigram_split_symbol_alpha_digit")
+    assert_normalize_type("TokenBigramSplitSymbolAlphaDigit",
+                          "token_bigram_split_symbol_alpha_digit")
+    assert_normalize_type("TokenBigramSplitSymbolAlphaDigit",
+                          "TokenBigramSplitSymbolAlphaDigit")
+  end
+
+  def test_normalize_bigram_ignore_blank
+    assert_normalize_type("TokenBigramIgnoreBlank", "bigram_ignore_blank")
+    assert_normalize_type("TokenBigramIgnoreBlank", "token_bigram_ignore_blank")
+    assert_normalize_type("TokenBigramIgnoreBlank", "TokenBigramIgnoreBlank")
+  end
+
+  def test_normalize_bigram_ignore_blank_split_symbol
+    assert_normalize_type("TokenBigramIgnoreBlankSplitSymbol",
+                          "bigram_ignore_blank_split_symbol")
+    assert_normalize_type("TokenBigramIgnoreBlankSplitSymbol",
+                          "token_bigram_ignore_blank_split_symbol")
+    assert_normalize_type("TokenBigramIgnoreBlankSplitSymbol",
+                          "TokenBigramIgnoreBlankSplitSymbol")
+  end
+
+  def test_normalize_bigram_ignore_blank_split_symbol_alpha
+    assert_normalize_type("TokenBigramIgnoreBlankSplitSymbolAlpha",
+                          "bigram_ignore_blank_split_symbol_alpha")
+    assert_normalize_type("TokenBigramIgnoreBlankSplitSymbolAlpha",
+                          "token_bigram_ignore_blank_split_symbol_alpha")
+    assert_normalize_type("TokenBigramIgnoreBlankSplitSymbolAlpha",
+                          "TokenBigramIgnoreBlankSplitSymbolAlpha")
+  end
+
+  def test_normalize_bigram_ignore_blank_split_symbol_alpha_digit
+    assert_normalize_type("TokenBigramIgnoreBlankSplitSymbolAlphaDigit",
+                          "bigram_ignore_blank_split_symbol_alpha_digit")
+    assert_normalize_type("TokenBigramIgnoreBlankSplitSymbolAlphaDigit",
+                          "token_bigram_ignore_blank_split_symbol_alpha_digit")
+    assert_normalize_type("TokenBigramIgnoreBlankSplitSymbolAlphaDigit",
+                          "TokenBigramIgnoreBlankSplitSymbolAlphaDigit")
+  end
+
+  def test_normalize_trigram
+    assert_normalize_type("TokenTrigram", "trigram")
+    assert_normalize_type("TokenTrigram", "token_trigram")
+    assert_normalize_type("TokenTrigram", "TokenTrigram")
+  end
+
+  def test_normalize_mecab
+    assert_normalize_type("TokenMecab", "mecab")
+    assert_normalize_type("TokenMecab", "token_mecab")
+    assert_normalize_type("TokenMecab", "TokenMecab")
+  end
+
+  private
+  def assert_normalize_type(expected, type)
+    assert_equal(expected, Groonga::Schema.normalize_type(type))
+  end
+end

data/test/test-schema.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2009-2010  Kouhei Sutou <kou@clear-code.com>
+# 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
@@ -28,7 +28,9 @@ class SchemaTest < Test::Unit::TestCase
   def test_define_hash
     Groonga::Schema.create_table("Posts", :type => :hash) do |table|
     end
-    assert_kind_of(Groonga::Hash, context["Posts"])
+    posts = context["Posts"]
+    assert_kind_of(Groonga::Hash, posts)
+    assert_equal("#{@database_path}.tables/Posts", posts.path)
   end
 
   def test_define_hash_with_full_option
@@ -58,7 +60,9 @@ class SchemaTest < Test::Unit::TestCase
   def test_define_patricia_trie
     Groonga::Schema.create_table("Posts", :type => :patricia_trie) do |table|
     end
-    assert_kind_of(Groonga::PatriciaTrie, context["Posts"])
+    posts = context["Posts"]
+    assert_kind_of(Groonga::PatriciaTrie, posts)
+    assert_equal("#{@database_path}.tables/Posts", posts.path)
   end
 
   def test_define_patricia_trie_with_full_option
@@ -89,7 +93,9 @@ class SchemaTest < Test::Unit::TestCase
   def test_define_array
     Groonga::Schema.create_table("Posts", :type => :array) do |table|
     end
-    assert_kind_of(Groonga::Array, context["Posts"])
+    posts = context["Posts"]
+    assert_kind_of(Groonga::Array, posts)
+    assert_equal("#{@database_path}.tables/Posts", posts.path)
   end
 
   def test_define_array_with_full_option
@@ -183,6 +189,16 @@ class SchemaTest < Test::Unit::TestCase
     assert_equal(context["Time"], context["Posts.last_modified"].range)
   end
 
+  def test_timestamps
+    assert_nil(context["Posts.created_at"])
+    assert_nil(context["Posts.updated_at"])
+    Groonga::Schema.create_table("Posts") do |table|
+      table.timestamps
+    end
+    assert_equal(context["Time"], context["Posts.created_at"].range)
+    assert_equal(context["Time"], context["Posts.updated_at"].range)
+  end
+
   def test_short_text_column
     assert_nil(context["Posts.title"])
     Groonga::Schema.create_table("Posts") do |table|
@@ -221,9 +237,7 @@ class SchemaTest < Test::Unit::TestCase
     end
     assert_not_nil(context["Posts.content"])
 
-    Groonga::Schema.change_table("Posts") do |table|
-      table.remove_column("content")
-    end
+    Groonga::Schema.remove_column("Posts", "content")
     assert_nil(context["Posts.content"])
   end
 
@@ -363,6 +377,48 @@ class SchemaTest < Test::Unit::TestCase
     end
   end
 
+  def test_remove_index
+    Groonga::Schema.create_table("Posts") do |table|
+      table.long_text :content
+    end
+    Groonga::Schema.create_table("Terms") do |table|
+      table.index "Posts.content"
+    end
+    assert_equal([context["Posts.content"]],
+                 context["Terms.Posts_content"].sources)
+    Groonga::Schema.change_table("Terms") do |table|
+      table.remove_index("Posts.content")
+    end
+    assert_nil(context["Terms.Posts_content"])
+  end
+
+  def test_reference_guess
+    Groonga::Schema.define do |schema|
+      schema.create_table("Items", :type => :hash) do |table|
+        table.short_text("title")
+      end
+
+      schema.create_table("Users", :type => :hash) do |table|
+        table.reference("item")
+      end
+    end
+
+    assert_equal(context["Items"], context["Users.item"].range)
+  end
+
+  def test_reference_ungeussable
+    candidates = ["item", "items", "Items"]
+    exception =
+      Groonga::Schema::UnguessableReferenceTable.new("item", candidates)
+    assert_raise(exception) do
+      Groonga::Schema.define do |schema|
+        schema.create_table("Users", :type => :hash) do |table|
+          table.reference("item")
+        end
+      end
+    end
+  end
+
   def test_dump
     Groonga::Schema.define do |schema|
       schema.create_table("Posts") do |table|
@@ -370,13 +426,14 @@ class SchemaTest < Test::Unit::TestCase
       end
     end
     assert_equal(<<-EOS, Groonga::Schema.dump)
-create_table("Posts") do |table|
+create_table("Posts",
+             :force => true) do |table|
   table.short_text("title")
 end
 EOS
   end
 
-  def test_reference_dump
+  def test_dump_reference
     Groonga::Schema.define do |schema|
       schema.create_table("Items") do |table|
         table.short_text("title")
@@ -395,16 +452,19 @@ EOS
     end
 
     assert_equal(<<-EOS, Groonga::Schema.dump)
-create_table("Comments") do |table|
+create_table("Comments",
+             :force => true) do |table|
   table.text("content")
   table.time("issued")
 end
 
-create_table("Items") do |table|
+create_table("Items",
+             :force => true) do |table|
   table.short_text("title")
 end
 
-create_table("Users") do |table|
+create_table("Users",
+             :force => true) do |table|
   table.short_text("name")
 end
 
@@ -415,6 +475,47 @@ end
 EOS
   end
 
+  def test_dump_index
+    Groonga::Schema.define do |schema|
+      schema.create_table("Items",
+                          :type => :patricia_trie,
+                          :key_type => "ShortText") do |table|
+        table.short_text("title")
+      end
+
+      schema.create_table("Terms",
+                          :type => :patricia_trie,
+                          :key_type => "ShortText",
+                          :key_normalize => true,
+                          :default_tokenizer => "TokenBigram") do |table|
+        table.index("Items", "_key")
+        table.index("Items", "title")
+      end
+    end
+
+    assert_equal(<<-EOS, Groonga::Schema.dump)
+create_table("Items",
+             :type => :patricia_trie,
+             :key_type => "ShortText",
+             :force => true) do |table|
+  table.short_text("title")
+end
+
+create_table("Terms",
+             :type => :patricia_trie,
+             :key_type => "ShortText",
+             :key_normalize => true,
+             :default_tokenizer => "TokenBigram",
+             :force => true) do |table|
+end
+
+change_table("Terms") do |table|
+  table.index("Items", "_key", :name => "Items__key")
+  table.index("Items", "title", :name => "Items_title")
+end
+EOS
+  end
+
   def test_explicit_context_create_table
     context = Groonga::Context.default
     Groonga::Context.default = nil
@@ -436,4 +537,50 @@ EOS
     assert_nil(Groonga::Context.default["Items.text"])
     assert_nil(Groonga::Context.default["TermsText.Items_text"])
   end
+
+  def test_columns_directory_removed
+    table = "Posts"
+    dir = create_table_with_column(table)
+
+    Groonga::Schema.remove_table(table)
+
+    assert_table_removed(table)
+    assert_directory_removed(dir)
+  end
+
+  def test_columns_directory_not_removed
+    table = "Posts"
+    dir = create_table_with_column(table)
+
+    Groonga::Context.default[table].remove
+
+    assert_table_removed(table)
+    assert_directory_not_removed(dir)
+  end
+
+  private
+  def columns_directory_path(table)
+    "#{table.path}.columns"
+  end
+
+  def create_table_with_column(name)
+    Groonga::Schema.create_table(name) do |table|
+      table.integer64 :rate
+    end
+    context = Groonga::Context.default
+    columns_directory_path(context[name])
+  end
+
+  def assert_directory_removed(dir)
+    assert_false(File.exist?(dir))
+  end
+
+  def assert_directory_not_removed(dir)
+    assert_true(File.exist?(dir))
+  end
+
+  def assert_table_removed(name)
+    context = Groonga::Context.default
+    assert_nil(context[name])
+  end
 end