rroonga 2.0.4 → 2.0.5

data/test/test-remote.rb

@@ -0,0 +1,63 @@
+# 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
+
+class RemoteTest < Test::Unit::TestCase
+  include GroongaTestUtils
+
+  setup :before => :append
+  def setup_remote_connection
+    @process_id = nil
+
+    package_config = PKGConfig.package_config("groonga")
+    groonga = package_config.variable("groonga")
+
+    @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)
+    end
+    sleep(1)
+  end
+
+  teardown
+  def teardown_remote_connection
+    Process.kill(:TERM, @process_id) if @process_id
+  end
+
+  def test_send
+    _context = Groonga::Context.new
+    _context.connect(:host => @host, :port => @port)
+    assert_equal(0, _context.send("status"))
+    id, result = _context.receive
+    assert_equal(0, id)
+    values = JSON.load(result)
+    assert_equal(["alloc_count", "cache_hit_rate", "command_version",
+                  "default_command_version", "max_command_version",
+                  "n_queries", "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,267 @@
+# 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
+
+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_different_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
+
+  def test_default_path
+    Groonga::Schema.create_table("Posts", options) do |table|
+    end
+    assert_equal("#{@database_path}.0000100",
+                 context["Posts"].path)
+  end
+
+  def test_default_named_path
+    options_with_named_path = options.merge(:named_path => true)
+    Groonga::Schema.create_table("Posts", options_with_named_path) do |table|
+    end
+    assert_equal("#{@database_path}.tables/Posts",
+                 context["Posts"].path)
+  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(:key_type => "Int32")) 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-dumper.rb

@@ -0,0 +1,235 @@
+# 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 SchemaDumperTest < Test::Unit::TestCase
+  include GroongaTestUtils
+
+  setup :setup_database
+
+  private
+  def define_simple_schema
+    Groonga::Schema.define do |schema|
+      schema.create_table("Posts") do |table|
+        table.short_text :title
+        table.short_text :comments, :type => :vector
+      end
+    end
+  end
+
+  def define_built_in_types_schema
+    Groonga::Schema.define do |schema|
+      schema.create_table("Posts") do |table|
+        table.boolean :public
+        table.int8 :int8
+        table.uint8 :uint8
+        table.int16 :int16
+        table.uint16 :uint16
+        table.int32 :int32
+        table.uint32 :uint32
+        table.int64 :int64
+        table.uint64 :uint64
+        table.float :vote_average
+        table.time :published_at
+        table.short_text :title
+        table.text :content
+        table.long_text :attachment
+        table.tokyo_geo_point :location_tokyo
+        table.wgs84_geo_point :location_wgs84
+      end
+    end
+  end
+
+  def define_reference_schema
+    Groonga::Schema.define do |schema|
+      schema.create_table("Items") do |table|
+        table.short_text("title")
+      end
+
+      schema.create_table("Users") do |table|
+        table.short_text("name")
+      end
+
+      schema.create_table("Comments") do |table|
+        table.reference("item", "Items")
+        table.reference("author", "Users")
+        table.reference("children", "Items", :type => :vector)
+        table.text("content")
+        table.time("issued")
+      end
+    end
+  end
+
+  def define_index_schema
+    Groonga::Schema.define do |schema|
+      schema.create_table("Items",
+                          :type => :hash,
+                          :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
+  end
+
+  class RubySyntaxSchemaDumperTest < SchemaDumperTest
+    def test_simple
+      define_simple_schema
+      assert_equal(<<-EOS, dump)
+create_table("Posts",
+             :force => true) do |table|
+  table.short_text("comments", :type => :vector)
+  table.short_text("title")
+end
+EOS
+    end
+
+    def test_built_in_types
+      define_built_in_types_schema
+      assert_equal(<<-EOS, dump)
+create_table("Posts",
+             :force => true) do |table|
+  table.long_text("attachment")
+  table.text("content")
+  table.integer16("int16")
+  table.integer32("int32")
+  table.integer64("int64")
+  table.integer8("int8")
+  table.tokyo_geo_point("location_tokyo")
+  table.wgs84_geo_point("location_wgs84")
+  table.boolean("public")
+  table.time("published_at")
+  table.short_text("title")
+  table.unsigned_integer16("uint16")
+  table.unsigned_integer32("uint32")
+  table.unsigned_integer64("uint64")
+  table.unsigned_integer8("uint8")
+  table.float("vote_average")
+end
+EOS
+    end
+
+    def test_reference
+      define_reference_schema
+      assert_equal(<<-EOS, dump)
+create_table("Comments",
+             :force => true) do |table|
+  table.text("content")
+  table.time("issued")
+end
+
+create_table("Items",
+             :force => true) do |table|
+  table.short_text("title")
+end
+
+create_table("Users",
+             :force => true) do |table|
+  table.short_text("name")
+end
+
+change_table("Comments") do |table|
+  table.reference("author", "Users")
+  table.reference("children", "Items", :type => :vector)
+  table.reference("item", "Items")
+end
+EOS
+    end
+
+    def test_index
+      define_index_schema
+      assert_equal(<<-EOS, dump)
+create_table("Items",
+             :type => :hash,
+             :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
+
+    private
+    def dump
+      Groonga::Schema.dump
+    end
+  end
+
+  class CommandSyntaxSchemaDumperTest < SchemaDumperTest
+    def test_simple
+      define_simple_schema
+      assert_equal(<<-EOS, dump)
+table_create Posts TABLE_NO_KEY
+column_create Posts comments COLUMN_VECTOR ShortText
+column_create Posts title COLUMN_SCALAR ShortText
+EOS
+    end
+
+    def test_reference
+      define_reference_schema
+      assert_equal(<<-EOS, dump)
+table_create Comments TABLE_NO_KEY
+column_create Comments content COLUMN_SCALAR Text
+column_create Comments issued COLUMN_SCALAR Time
+
+table_create Items TABLE_NO_KEY
+column_create Items title COLUMN_SCALAR ShortText
+
+table_create Users TABLE_NO_KEY
+column_create Users name COLUMN_SCALAR ShortText
+
+column_create Comments author COLUMN_SCALAR Users
+column_create Comments children COLUMN_VECTOR Items
+column_create Comments item COLUMN_SCALAR Items
+EOS
+    end
+
+    def test_index
+      define_index_schema
+      assert_equal(<<-EOS, dump)
+table_create Items TABLE_HASH_KEY --key_type ShortText
+column_create Items title COLUMN_SCALAR ShortText
+
+table_create Terms TABLE_PAT_KEY|KEY_NORMALIZE --key_type ShortText --default_tokenizer TokenBigram
+
+column_create Terms Items__key COLUMN_INDEX|WITH_POSITION Items _key
+column_create Terms Items_title COLUMN_INDEX|WITH_POSITION Items title
+EOS
+    end
+
+    private
+    def dump
+      Groonga::Schema.dump(:syntax => :command)
+    end
+  end
+end