droonga-engine 1.0.1

data/test/unit/plugins/groonga/test_column_rename.rb

@@ -0,0 +1,105 @@
+# Copyright (C) 2014 Droonga Project
+#
+# 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 ColumnRenameTest < GroongaHandlerTest
+  def create_handler
+    Droonga::Plugins::Groonga::ColumnRename::Handler.new("droonga",
+                                                         @handler.context,
+                                                         @messenger,
+                                                         @loop)
+  end
+
+  def test_success
+    Groonga::Schema.define do |schema|
+      schema.create_table("Books", :type => :hash)
+      schema.change_table("Books") do |table|
+        table.column("title", "ShortText", :type => :scalar)
+      end
+    end
+    message = {
+      "table"    => "Books",
+      "name"     => "title",
+      "new_name" => "label",
+    }
+    response = process(:column_rename, message)
+    assert_equal(
+      [NORMALIZED_HEADER_SUCCESS, true],
+      [normalize_header(response.first), response.last]
+    )
+  end
+
+  def test_unknown_table
+    message = {
+      "table"    => "Unknown",
+      "name"     => "title",
+      "new_name" => "label",
+      "type"     => "ShortText",
+    }
+    response = process(:column_rename, message)
+    assert_equal(
+      [NORMALIZED_HEADER_INVALID_ARGUMENT, false],
+      [normalize_header(response.first), response.last]
+    )
+  end
+
+  def test_unknown_column
+    Groonga::Schema.define do |schema|
+      schema.create_table("Books", :type => :hash)
+    end
+    message = {
+      "table"    => "Books",
+      "name"     => "title",
+      "new_name" => "label",
+    }
+    response = process(:column_rename, message)
+    assert_equal(
+      [NORMALIZED_HEADER_INVALID_ARGUMENT, false],
+      [normalize_header(response.first), response.last]
+    )
+  end
+
+  def test_rename
+    Groonga::Schema.define do |schema|
+      schema.create_table("Books", :type => :hash)
+      schema.change_table("Books") do |table|
+        table.column("title", "ShortText", :type => :scalar)
+      end
+    end
+    process(:column_rename,
+            {"table" => "Books", "name" => "title", "new_name" => "label"})
+    assert_equal(<<-SCHEMA, dump)
+table_create Books TABLE_HASH_KEY --key_type ShortText
+column_create Books label COLUMN_SCALAR ShortText
+    SCHEMA
+  end
+
+  def test_rename_with_index
+    Groonga::Schema.define do |schema|
+      schema.create_table("Books", :type => :hash)
+      schema.change_table("Books") do |table|
+        table.column("title", "ShortText", :type => :scalar)
+        table.index("Books", "title", :name => "entry_title")
+      end
+    end
+    process(:column_rename,
+            {"table" => "Books", "name" => "title", "new_name" => "label"})
+    assert_equal(<<-SCHEMA, dump)
+table_create Books TABLE_HASH_KEY --key_type ShortText
+column_create Books label COLUMN_SCALAR ShortText
+
+column_create Books entry_title COLUMN_INDEX Books label
+    SCHEMA
+  end
+end

data/test/unit/plugins/groonga/test_delete.rb

@@ -0,0 +1,127 @@
+# Copyright (C) 2014 Droonga Project
+#
+# 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 DeleteTest < GroongaHandlerTest
+  def create_handler
+    Droonga::Plugins::Groonga::Delete::Handler.new("droonga",
+                                                   @handler.context,
+                                                   @messenger,
+                                                   @loop)
+  end
+
+  def test_success
+    Groonga::Schema.define do |schema|
+      schema.create_table("Books", :type => :hash)
+    end
+    Groonga::Context.default["Books"].add("sample")
+    message = {
+      "table" => "Books",
+      "key"   => "sample",
+    }
+    response = process(:delete, message)
+    assert_equal(
+      [NORMALIZED_HEADER_SUCCESS, true],
+      [normalize_header(response.first), response.last]
+    )
+  end
+
+  def test_unknown_table
+    message = {
+      "table" => "Unknown",
+    }
+    response = process(:delete, message)
+    assert_equal(
+      [NORMALIZED_HEADER_INVALID_ARGUMENT, false],
+      [normalize_header(response.first), response.last]
+    )
+  end
+
+  def test_no_identifier
+    Groonga::Schema.define do |schema|
+      schema.create_table("Books", :type => :hash)
+    end
+    message = {
+      "table" => "Books",
+    }
+    response = process(:delete, message)
+    assert_equal(
+      [NORMALIZED_HEADER_INVALID_ARGUMENT, false],
+      [normalize_header(response.first), response.last]
+    )
+  end
+
+  data(:key_and_id => { "key" => "key", "id" => "1" },
+       :id_and_filter => { "id" => "1", "filter" => "filter" },
+       :key_and_filter => { "key" => "key", "filter" => "filter" })
+  def test_duplicated_identifier(data)
+    Groonga::Schema.define do |schema|
+      schema.create_table("Books", :type => :hash)
+    end
+    message = {
+      "table" => "Books",
+    }.merge(data)
+    response = process(:delete, message)
+    assert_equal(
+      [NORMALIZED_HEADER_INVALID_ARGUMENT, false],
+      [normalize_header(response.first), response.last]
+    )
+  end
+
+  class DeleteTest < self
+    def test_key
+      Groonga::Schema.define do |schema|
+        schema.create_table("Books", :type => :hash)
+      end
+      Groonga::Context.default["Books"].add("sample")
+      process(:delete,
+              {"table" => "Books", "key" => "sample"})
+      assert_equal(<<-DUMP, dump)
+table_create Books TABLE_HASH_KEY --key_type ShortText
+      DUMP
+    end
+
+    def test_id
+      Groonga::Schema.define do |schema|
+        schema.create_table("Ages", :type => :array)
+      end
+      Groonga::Context.default["Ages"].add([])
+      process(:delete,
+              {"table" => "Ages", "id" => 1})
+      assert_equal(<<-DUMP, dump)
+table_create Ages TABLE_NO_KEY
+      DUMP
+    end
+
+    def test_filter
+      Groonga::Schema.define do |schema|
+        schema.create_table("Books", :type => :hash)
+      end
+      table = Groonga::Context.default["Books"]
+      table.add("Groonga")
+      table.add("Droonga")
+      process(:delete,
+              {"table" => "Books", "filter" => '_key @^ "D"'})
+      assert_equal(<<-DUMP, dump)
+table_create Books TABLE_HASH_KEY --key_type ShortText
+
+load --table Books
+[
+["_key"],
+["Groonga"]
+]
+      DUMP
+    end
+  end
+end

data/test/unit/plugins/groonga/test_table_create.rb

@@ -0,0 +1,147 @@
+# Copyright (C) 2013 Droonga Project
+#
+# 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 TableCreateTest < GroongaHandlerTest
+  def create_handler
+    Droonga::Plugins::Groonga::TableCreate::Handler.new("droonga",
+                                                        @handler.context,
+                                                        @messenger,
+                                                        @loop)
+  end
+
+  def test_success
+    response = process(:table_create, {"name" => "Books"})
+    assert_equal(
+      [NORMALIZED_HEADER_SUCCESS, true],
+      [normalize_header(response.first), response.last]
+    )
+  end
+
+  def test_failure
+    response = process(:table_create, {})
+    assert_equal(
+      [NORMALIZED_HEADER_INVALID_ARGUMENT, false],
+      [normalize_header(response.first), response.last]
+    )
+  end
+
+  def test_name
+    process(:table_create, {"name" => "Books"})
+    assert_equal(<<-SCHEMA, dump)
+table_create Books TABLE_HASH_KEY --key_type ShortText
+    SCHEMA
+  end
+
+  class FlagsTest < self
+    data({
+           "TABLE_NO_KEY" => {
+             :flags => "TABLE_NO_KEY",
+             :schema => <<-SCHEMA,
+table_create Books TABLE_NO_KEY
+             SCHEMA
+           },
+           "TABLE_HASH_KEY" => {
+             :flags => "TABLE_HASH_KEY",
+             :schema => <<-SCHEMA,
+table_create Books TABLE_HASH_KEY --key_type ShortText
+             SCHEMA
+           },
+           "TABLE_PAT_KEY" => {
+             :flags => "TABLE_PAT_KEY",
+             :schema => <<-SCHEMA,
+table_create Books TABLE_PAT_KEY --key_type ShortText
+             SCHEMA
+           },
+           "TABLE_DAT_KEY" => {
+             :flags => "TABLE_DAT_KEY",
+             :schema => <<-SCHEMA,
+table_create Books TABLE_DAT_KEY --key_type ShortText
+             SCHEMA
+           },
+           "KEY_WITH_SIS with TABLE_PAT_KEY" => {
+             :flags => "KEY_WITH_SIS|TABLE_PAT_KEY",
+             :schema => <<-SCHEMA,
+table_create Books TABLE_PAT_KEY|KEY_WITH_SIS --key_type ShortText
+             SCHEMA
+           },
+           "KEY_WITH_SIS without TABLE_PAT_KEY" => {
+             :flags => "TABLE_NO_KEY|KEY_WITH_SIS",
+             :schema => <<-SCHEMA,
+table_create Books TABLE_NO_KEY
+             SCHEMA
+           },
+         })
+    def test_flags(data)
+      request = {
+        "name" => "Books",
+        "flags" => data[:flags],
+      }
+      process(:table_create, request)
+      assert_equal(data[:schema], dump)
+    end
+  end
+
+  class KeyTypeTest < self
+    def test_key_type
+      request = {
+        "name"  => "Books",
+        "key_type" => "Int32",
+      }
+      process(:table_create, request)
+      assert_equal(<<-SCHEMA, dump)
+table_create Books TABLE_HASH_KEY --key_type Int32
+      SCHEMA
+    end
+  end
+
+  class ValueTypeTest < self
+    def test_value_type
+      request = {
+        "name"  => "Books",
+        "value_type" => "Int32",
+      }
+      process(:table_create, request)
+      assert_equal(<<-SCHEMA, dump)
+table_create Books TABLE_HASH_KEY --key_type ShortText --value_type Int32
+      SCHEMA
+    end
+  end
+
+  class DefaultTokenizerTest < self
+    def test_default_tokenizer
+      request = {
+        "name"  => "Books",
+        "default_tokenizer" => "TokenBigram",
+      }
+      process(:table_create, request)
+      assert_equal(<<-SCHEMA, dump)
+table_create Books TABLE_HASH_KEY --key_type ShortText --default_tokenizer TokenBigram
+      SCHEMA
+    end
+  end
+
+  class NormalizerTest < self
+    def test_normalizer
+      request = {
+        "name"  => "Books",
+        "normalizer" => "NormalizerAuto",
+      }
+      process(:table_create, request)
+      assert_equal(<<-SCHEMA, dump)
+table_create Books TABLE_HASH_KEY --key_type ShortText --normalizer NormalizerAuto
+      SCHEMA
+    end
+  end
+end

data/test/unit/plugins/groonga/test_table_list.rb

@@ -0,0 +1,184 @@
+# Copyright (C) 2014 Droonga Project
+#
+# 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 TableListTest < GroongaHandlerTest
+  TABLES_HEADER = [
+    ["id",                "UInt32"],
+    ["name",              "ShortText"],
+    ["path",              "ShortText"],
+    ["flags",             "ShortText"],
+    ["domain",            "ShortText"],
+    ["range",             "ShortText"],
+    ["default_tokenizer", "ShortText"],
+    ["normalizer",        "ShortText"],
+  ]
+
+  def create_handler
+    Droonga::Plugins::Groonga::TableList::Handler.new("droonga",
+                                                      @handler.context,
+                                                      @messenger,
+                                                      @loop)
+  end
+
+  def test_success
+    Groonga::Schema.define do |schema|
+      schema.create_table("Books", :type => :hash)
+    end
+    response = process(:column_list, {})
+    assert_equal(
+      NORMALIZED_HEADER_SUCCESS,
+      normalize_header(response.first)
+    )
+  end
+
+  class ListTest < self
+    def test_hash_table
+      Groonga::Schema.define do |schema|
+        schema.create_table("Books", :type => :hash)
+      end
+      response = process(:table_list, {})
+      expected = [
+        TABLES_HEADER,
+        [256,
+         "Books",
+         @database_path.to_s + ".0000100",
+         "TABLE_HASH_KEY|PERSISTENT",
+         "ShortText",
+         nil,
+         nil,
+         nil],
+      ]
+      assert_equal(expected, response.last)
+    end
+
+    def test_array_table
+      Groonga::Schema.define do |schema|
+        schema.create_table("HistoryEntries", :type => :array)
+      end
+      response = process(:table_list, {})
+      expected = [
+        TABLES_HEADER,
+        [256,
+         "HistoryEntries",
+         @database_path.to_s + ".0000100",
+         "TABLE_NO_KEY|PERSISTENT",
+         nil,
+         nil,
+         nil,
+         nil],
+      ]
+      assert_equal(expected, response.last)
+    end
+
+    def test_patricia_trie_table
+      Groonga::Schema.define do |schema|
+        schema.create_table("Books", :type => :patricia_trie)
+      end
+      response = process(:table_list, {})
+      expected = [
+        TABLES_HEADER,
+        [256,
+         "Books",
+         @database_path.to_s + ".0000100",
+         "TABLE_PAT_KEY|PERSISTENT",
+         "ShortText",
+         nil,
+         nil,
+         nil],
+      ]
+      assert_equal(expected, response.last)
+    end
+
+    def test_double_array_trie_table
+      Groonga::Schema.define do |schema|
+        schema.create_table("Books", :type => :double_array_trie)
+      end
+      response = process(:table_list, {})
+      expected = [
+        TABLES_HEADER,
+        [256,
+         "Books",
+         @database_path.to_s + ".0000100",
+         "TABLE_DAT_KEY|PERSISTENT",
+         "ShortText",
+         nil,
+         nil,
+         nil],
+      ]
+      assert_equal(expected, response.last)
+    end
+
+    def test_with_value_type
+      Groonga::Schema.define do |schema|
+        schema.create_table("BookIds", :type => :hash,
+                                       :key_type => "UInt32",
+                                       :value_type => "UInt32")
+      end
+      response = process(:table_list, {})
+      expected = [
+        TABLES_HEADER,
+        [256,
+         "BookIds",
+         @database_path.to_s + ".0000100",
+         "TABLE_HASH_KEY|PERSISTENT",
+         "UInt32",
+         "UInt32",
+         nil,
+         nil],
+      ]
+      assert_equal(expected, response.last)
+    end
+
+    def test_with_default_tokenizer
+      Groonga::Schema.define do |schema|
+        schema.create_table("Books", :type => :hash,
+                                     :default_tokenizer => "TokenBigram")
+      end
+      response = process(:table_list, {})
+      expected = [
+        TABLES_HEADER,
+        [256,
+         "Books",
+         @database_path.to_s + ".0000100",
+         "TABLE_HASH_KEY|PERSISTENT",
+         "ShortText",
+         nil,
+         "TokenBigram",
+         nil],
+      ]
+      assert_equal(expected, response.last)
+    end
+
+    def test_with_normalizer
+      Groonga::Schema.define do |schema|
+        schema.create_table("Books", :type => :hash,
+                                     :normalizer => "NormalizerAuto")
+      end
+      response = process(:table_list, {})
+      expected = [
+        TABLES_HEADER,
+        [256,
+         "Books",
+         @database_path.to_s + ".0000100",
+         "TABLE_HASH_KEY|PERSISTENT",
+         "ShortText",
+         nil,
+         nil,
+         "NormalizerAuto"],
+      ]
+      assert_equal(expected, response.last)
+    end
+  end
+end

data/test/unit/plugins/groonga/test_table_remove.rb

@@ -0,0 +1,61 @@
+# Copyright (C) 2014 Droonga Project
+#
+# 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 TableRemoveTest < GroongaHandlerTest
+  def create_handler
+    Droonga::Plugins::Groonga::TableRemove::Handler.new("droonga",
+                                                        @handler.context,
+                                                        @messenger,
+                                                        @loop)
+  end
+
+  def setup
+    super
+    Groonga::Schema.define do |schema|
+      schema.create_table("Books", :type => :hash)
+    end
+  end
+
+  def test_success
+    response = process(:table_remove, {"name" => "Books"})
+    assert_equal(
+      [NORMALIZED_HEADER_SUCCESS, true],
+      [normalize_header(response.first), response.last]
+    )
+    assert_equal(<<-SCHEMA, dump)
+    SCHEMA
+  end
+
+  def test_failure
+    response = process(:table_remove, {})
+    assert_equal(
+      [NORMALIZED_HEADER_INVALID_ARGUMENT, false],
+      [normalize_header(response.first), response.last]
+    )
+  end
+
+  def test_remove
+    process(:table_remove, {"name" => "Books"})
+    assert_equal(<<-SCHEMA, dump)
+    SCHEMA
+  end
+
+  def test_unknown_table
+    process(:table_remove, {"name" => "Unknown"})
+    assert_equal(<<-SCHEMA, dump)
+table_create Books TABLE_HASH_KEY --key_type ShortText
+    SCHEMA
+  end
+end