rroonga 0.9.4-x86-mingw32 → 0.9.5-x86-mingw32

data/test/test-record.rb

@@ -31,8 +31,8 @@ class RecordTest < Test::Unit::TestCase
   end
 
   def setup_users_table
-    @users = Groonga::Array.create(:name => "Users")
-    @users.define_column("name", "ShortText")
+    @users = Groonga::Hash.create(:name => "Users",
+                                  :key_type => "ShortText")
     @users.define_column("addresses", @addresses, :type => "vector")
   end
 
@@ -93,19 +93,47 @@ class RecordTest < Test::Unit::TestCase
 
   def test_set_object_id
     groonga = @bookmarks.add
-    daijiro = @users.add
-    daijiro["name"] = "daijiro"
+    daijiro = @users.add("daijiro")
     assert_nil(groonga["user"])
-    groonga["user"] = daijiro.id
+    groonga["user"] = daijiro
     assert_equal(daijiro, groonga["user"])
   end
 
   def test_set_nil
-    groonga = @bookmarks.add
+    groonga = @bookmarks.add(:content => "groonga")
+    assert_equal("groonga", groonga["content"])
     groonga["content"] = nil
     assert_nil(groonga["content"])
   end
 
+  def test_set_empty_string
+    groonga = @bookmarks.add(:content => "groonga")
+    assert_equal("groonga", groonga["content"])
+    groonga["content"] = ""
+    assert_nil(groonga["content"])
+  end
+
+  def test_set_nil_reference
+    groonga = @bookmarks.add(:user => "daijiro",
+                             :uri => "http://groonga.org/")
+    groonga.user = nil
+    assert_nil(groonga.user)
+  end
+
+  def test_set_empty_key_reference
+    groonga = @bookmarks.add(:user => "daijiro",
+                             :uri => "http://groonga.org/")
+    assert_equal(@users["daijiro"], groonga.user)
+    groonga["user"] = ""
+    assert_nil(groonga.user)
+  end
+
+  def test_set_string_to_integer_column
+    groonga = @bookmarks.add(:content => "groonga")
+    groonga.rate = "100"
+    assert_equal(100, groonga.rate)
+  end
+
   def test_delete
     bookmark1 = @bookmarks.add
     bookmark2 = @bookmarks.add
@@ -236,8 +264,8 @@ class RecordTest < Test::Unit::TestCase
   end
 
   def test_method_chain
-    morita = @users.add(:name => "morita")
+    morita = @users.add("morita")
     groonga = @bookmarks.add(:user => morita, :uri => "http://groonga.org")
-    assert_equal("morita", groonga.user.name)
+    assert_equal("morita", groonga.user.key)
   end
 end

data/test/test-remote.rb

@@ -46,9 +46,16 @@ class RemoteTest < Test::Unit::TestCase
     assert_equal(0, _context.send("status"))
     id, result = _context.receive
     assert_equal(0, id)
-    status, values = JSON.load(result)
-    return_code, start_time, elapsed,  = status
-    assert_equal([0, ["alloc_count", "starttime", "uptime", "version"]],
-                 [return_code, values.keys.sort])
+    values = JSON.load(result)
+    assert_equal(["alloc_count", "starttime", "uptime", "version"],
+                 values.keys.sort)
+  end
+
+  def test_invalid_select
+    context.connect(:host => @host, :port => @port)
+
+    assert_raise(Groonga::InvalidArgument) do
+      context.select("bogus", :query => "()()")
+    end
   end
 end

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

@@ -0,0 +1,251 @@
+# 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
+# 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
+
+module SchemaCreateTableTests
+  def test_normal
+    assert_nil(context["Posts"])
+    Groonga::Schema.create_table("Posts", options) do |table|
+    end
+    assert_not_nil(context["Posts"])
+  end
+
+  def test_force
+    Groonga::Schema.create_table("Posts", options) do |table|
+      table.string("name")
+    end
+    assert_not_nil(context["Posts.name"])
+
+    Groonga::Schema.create_table("Posts",
+                                 options(:type => differnt_type,
+                                         :force => true)) do |table|
+    end
+    assert_nil(context["Posts.name"])
+  end
+
+  def test_different_type
+    Groonga::Schema.create_table("Posts", options) do |table|
+    end
+
+    assert_raise(Groonga::Schema::TableCreationWithDifferentOptions) do
+      Groonga::Schema.create_table("Posts",
+                                   options(:type => differnt_type)) do |table|
+      end
+    end
+  end
+
+  def test_same_options
+    Groonga::Schema.create_table("Posts", options) do |table|
+    end
+
+    Groonga::Schema.create_table("Posts", options) do |table|
+    end
+    assert_not_nil(context["Posts"])
+  end
+
+  def test_same_value_type
+    Groonga::Schema.create_table("Posts",
+                                 options(:value_type => "UInt32")) do |table|
+    end
+
+    Groonga::Schema.create_table("Posts",
+                                 options(:value_type => "UInt32")) do |table|
+    end
+    assert_equal(context["UInt32"], context["Posts"].range)
+  end
+
+  def test_differnt_value_type
+    Groonga::Schema.create_table("Posts", options) do |table|
+    end
+
+    assert_raise(Groonga::Schema::TableCreationWithDifferentOptions) do
+      Groonga::Schema.create_table("Posts",
+                                   options(:value_type => "Int32")) do |table|
+      end
+    end
+  end
+
+  def test_same_sub_records
+    Groonga::Schema.create_table("Posts",
+                                 options(:sub_records => true)) do |table|
+    end
+
+    Groonga::Schema.create_table("Posts",
+                                 options(:sub_records => true)) do |table|
+    end
+    assert_true(context["Posts"].support_sub_records?)
+  end
+
+  def test_differnt_sub_records
+    Groonga::Schema.create_table("Posts",
+                                 options(:sub_records => true)) do |table|
+    end
+
+    assert_raise(Groonga::Schema::TableCreationWithDifferentOptions) do
+      Groonga::Schema.create_table("Posts",
+                                   options(:sub_records => false)) do |table|
+      end
+    end
+  end
+
+  private
+  def options(addional_options={})
+    default_options.merge(addional_options)
+  end
+end
+
+module SchemaCreateTableWithKeyTests
+  def test_same_key_type
+    Groonga::Schema.create_table("Posts",
+                                 options(:key_type => "ShortText")) do |table|
+    end
+
+    Groonga::Schema.create_table("Posts",
+                                 options(:key_type => "ShortText")) do |table|
+    end
+    assert_equal(context["ShortText"], context["Posts"].domain)
+  end
+
+  def test_differnt_key_type
+    Groonga::Schema.create_table("Posts", options) do |table|
+    end
+
+    assert_raise(Groonga::Schema::TableCreationWithDifferentOptions) do
+      Groonga::Schema.create_table("Posts",
+                                   options(:key_type => "ShortText")) do |table|
+      end
+    end
+  end
+
+  def test_same_default_tokenizer
+    _options = options(:key_type => "ShortText",
+                       :default_tokenizer => "TokenBigram")
+    Groonga::Schema.create_table("Posts", _options) do |table|
+    end
+
+    Groonga::Schema.create_table("Posts", _options) do |table|
+    end
+    assert_equal(context["TokenBigram"], context["Posts"].default_tokenizer)
+  end
+
+  def test_differnt_default_tokenizer
+    _options = options(:key_type => "ShortText")
+    Groonga::Schema.create_table("Posts", _options) do |table|
+    end
+
+    _options = _options.merge(:default_tokenizer => "TokenBigram")
+    assert_raise(Groonga::Schema::TableCreationWithDifferentOptions) do
+      Groonga::Schema.create_table("Posts", _options) do |table|
+      end
+    end
+  end
+
+  def test_same_key_normalize
+    _options = options(:key_type => "ShortText",
+                       :key_normalize => true)
+    Groonga::Schema.create_table("Posts", _options) do |table|
+    end
+
+    Groonga::Schema.create_table("Posts", _options) do |table|
+    end
+    assert_true(context["Posts"].normalize_key?)
+  end
+
+  def test_differnt_key_normalize
+    _options = options(:key_type => "ShortText",
+                       :key_normalize => true)
+    Groonga::Schema.create_table("Posts", _options) do |table|
+    end
+
+    _options = _options.merge(:key_normalize => false)
+    assert_raise(Groonga::Schema::TableCreationWithDifferentOptions) do
+      Groonga::Schema.create_table("Posts", _options) do |table|
+      end
+    end
+  end
+end
+
+class SchemaCreateTableArrayTest < Test::Unit::TestCase
+  include GroongaTestUtils
+  include SchemaCreateTableTests
+
+  setup :setup_database
+
+  private
+  def default_options
+    {}
+  end
+
+  def differnt_type
+    :hash
+  end
+end
+
+class SchemaCreateTableHashTest < Test::Unit::TestCase
+  include GroongaTestUtils
+  include SchemaCreateTableTests
+  include SchemaCreateTableWithKeyTests
+
+  setup :setup_database
+
+  private
+  def default_options
+    {:type => :hash}
+  end
+
+  def differnt_type
+    :patricia_trie
+  end
+end
+
+class SchemaCreateTablePatriciaTrieTest < Test::Unit::TestCase
+  include GroongaTestUtils
+  include SchemaCreateTableTests
+  include SchemaCreateTableWithKeyTests
+
+  setup :setup_database
+
+  def test_same_key_with_sis
+    _options = options(:key_type => "ShortText",
+                       :key_with_sis => true)
+    Groonga::Schema.create_table("Posts", _options) do |table|
+    end
+
+    Groonga::Schema.create_table("Posts", _options) do |table|
+    end
+    assert_true(context["Posts"].register_key_with_sis?)
+  end
+
+  def test_differnt_key_with_sis
+    _options = options(:key_type => "ShortText",
+                       :key_with_sis => true)
+    Groonga::Schema.create_table("Posts", _options) do |table|
+    end
+
+    _options = _options.merge(:key_with_sis => false)
+    assert_raise(Groonga::Schema::TableCreationWithDifferentOptions) do
+      Groonga::Schema.create_table("Posts", _options) do |table|
+      end
+    end
+  end
+
+  private
+  def default_options
+    {:type => :patricia_trie}
+  end
+
+  def differnt_type
+    :array
+  end
+end

data/test/test-schema.rb

@@ -18,28 +18,6 @@ class SchemaTest < Test::Unit::TestCase
 
   setup :setup_database
 
-  def test_create_table
-    assert_nil(context["Posts"])
-    Groonga::Schema.create_table("Posts") do |table|
-    end
-    assert_not_nil(context["Posts"])
-  end
-
-  def test_create_table_force
-    Groonga::Schema.create_table("Posts") do |table|
-      table.string("name")
-    end
-    assert_not_nil(context["Posts.name"])
-
-    Groonga::Schema.create_table("Posts") do |table|
-    end
-    assert_not_nil(context["Posts.name"])
-
-    Groonga::Schema.create_table("Posts", :force => true) do |table|
-    end
-    assert_nil(context["Posts.name"])
-  end
-
   def test_remove_table
     Groonga::Array.create(:name => "Posts")
     assert_not_nil(context["Posts"])
@@ -266,7 +244,7 @@ class SchemaTest < Test::Unit::TestCase
       table.text :content
     end
 
-    assert_raise(ArgumentError) do
+    assert_raise(Groonga::Schema::ColumnCreationWithDifferentOptions) do
       Groonga::Schema.create_table("Posts") do |table|
         table.integer :content
       end
@@ -341,7 +319,7 @@ class SchemaTest < Test::Unit::TestCase
       table.index "Posts.content"
     end
 
-    assert_raise(ArgumentError) do
+    assert_raise(Groonga::Schema::ColumnCreationWithDifferentOptions) do
       Groonga::Schema.create_table("Terms") do |table|
         table.index "Posts.name", :name => "Posts_content"
       end
@@ -455,5 +433,7 @@ EOS
 
     assert_not_nil(context["Items.text"])
     assert_not_nil(context["TermsText.Items_text"])
+    assert_nil(Groonga::Context.default["Items.text"])
+    assert_nil(Groonga::Context.default["TermsText.Items_text"])
   end
 end

data/test/test-table-offset-and-limit.rb

@@ -18,7 +18,7 @@ module TestOffsetAndLimitSupport
     assert_equal(((100 + 0)...200).to_a, ids(:offset => 0))
     assert_equal(((100 + 32)...200).to_a, ids(:offset => 32))
     assert_equal(((100 + 99)...200).to_a, ids(:offset => 99))
-    assert_raise(Groonga::InvalidArgument) do
+    assert_raise(Groonga::TooLargeOffset) do
       ids(:offset => 100)
     end
   end
@@ -27,7 +27,7 @@ module TestOffsetAndLimitSupport
     assert_equal(((200 - 1)...200).to_a, ids(:offset => -1))
     assert_equal(((200 - 32)...200).to_a, ids(:offset => -32))
     assert_equal(((200 - 100)...200).to_a, ids(:offset => -100))
-    assert_raise(Groonga::InvalidArgument) do
+    assert_raise(Groonga::TooSmallOffset) do
       ids(:offset => -101)
     end
   end
@@ -47,9 +47,7 @@ module TestOffsetAndLimitSupport
     assert_equal(all_ids[0..-1], ids(:limit => -1))
     assert_equal(all_ids[0..-32], ids(:limit => -32))
     assert_equal(all_ids[0..-100], ids(:limit => -100))
-    assert_raise(Groonga::InvalidArgument) do
-      ids(:offset => -101)
-    end
+    assert_equal([], ids(:limit => -101))
   end
 
   private

data/test/test-table-select-mecab.rb

@@ -0,0 +1,80 @@
+# -*- coding: utf-8 -*-
+#
+# 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 TableSelectMecabTest < Test::Unit::TestCase
+  include GroongaTestUtils
+
+  setup :setup_database
+
+  setup
+  def check_mecab_availability
+    omit("MeCab isn't available") if context["TokenMecab"].nil?
+  end
+
+  setup
+  def setup_tables
+    Groonga::Schema.define do |schema|
+      schema.create_table("Users", :key_type => "ShortText") do |table|
+      end
+
+      schema.create_table("Comments", :type => :array) do |table|
+        table.short_text("title")
+        table.text("content")
+        table.time("created_at")
+        table.reference("user", "Users")
+      end
+
+      schema.create_table("Terms",
+                          :type => :patricia_trie,
+                          :default_tokenizer => "TokenMecab") do |table|
+        table.index("Comments.title", :with_section => true)
+        table.index("Comments.content", :with_section => true)
+      end
+    end
+  end
+
+  setup
+  def setup_comments
+    @comments = context["Comments"]
+    @hello = @comments.add(:title => "Hello",
+                           :content => "Hello Good-bye!",
+                           :created_at => Time.parse("2009-08-09"),
+                           :user => "morita")
+    @hello_only_in_content =
+      @comments.add(:title => "(no title)",
+                    :content => "Hello! Hello! Hello!",
+                    :created_at => Time.parse("2009-07-09"))
+    @test = @comments.add(:title => "title",
+                          :content => "test",
+                          :created_at => Time.parse("2009-06-09"),
+                          :user => "gunyara-kun")
+    @japanese =
+      @comments.add(:title => "日本語",
+                    :content => "うちのボロTVはまだ現役です",
+                    :created_at => Time.parse("2009-06-09"),
+                    :user => "darashi")
+  end
+
+  def test_match
+    result = @comments.select do |record|
+      record.content =~ "ボロ"
+    end
+    assert_equal_select_result(["日本語"], result) do |record|
+      record.title
+    end
+  end
+end