droonga-engine 1.0.1

data/test/unit/plugins/groonga/select/test_adapter_output.rb

@@ -0,0 +1,201 @@
+# Copyright (C) 2013-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
+
+require "droonga/plugins/groonga/select"
+
+class GroongaSelectAdapterOutputTest < Test::Unit::TestCase
+  private
+  def convert(search_response)
+    converter = Droonga::Plugins::Groonga::Select::ResponseConverter.new
+    converter.convert(search_response)
+  end
+
+  class RecordsTest < self
+    def test_empty
+      start_time = "2001-08-02T10:45:23.5+09:00"
+      elapsed_time = 0
+      count = 0
+
+      search_response = {
+        "EmptyTable" => {
+          "startTime"   => start_time,
+          "elapsedTime" => elapsed_time,
+          "count"       => count,
+          "attributes"  => [
+            {"name" => "_id", "type" => "UInt32", "vector" => false},
+          ],
+          "records"     => [],
+        },
+      }
+
+      status_code = 0
+      start_time_in_unix_time = Time.parse(start_time).to_f
+      headers = [["_id","UInt32"]]
+      expected_select_response = [
+        [status_code, start_time_in_unix_time, elapsed_time],
+        [
+          [[count], headers],
+        ],
+      ]
+
+      assert_equal(expected_select_response, convert(search_response))
+    end
+  end
+
+  class DrilldownTest < self
+    START_TIME   = "2001-08-02T10:45:23.5+09:00"
+    ELAPSED_TIME = 0
+    COUNT        = 0
+
+    def main_search_result
+      {
+        "startTime"   => START_TIME,
+        "elapsedTime" => ELAPSED_TIME,
+        "count"       => COUNT,
+        "attributes"  => [
+          {"name" => "_id", "type" => "UInt32", "vector" => false},
+        ],
+        "records"     => [],
+      }
+    end
+
+    def expected_header
+      status_code = 0
+      start_time_in_unix_time = Time.parse(START_TIME).to_f
+      [status_code, start_time_in_unix_time, ELAPSED_TIME]
+    end
+
+    def expected_main_select_result
+      headers = [["_id","UInt32"]]
+      [[COUNT], headers]
+    end
+
+    def test_no_drilldown
+      search_response = {
+        "EmptyTable" => main_search_result,
+      }
+
+      expected_select_response = [
+        expected_header,
+        [
+          expected_main_select_result,
+        ],
+      ]
+
+      assert_equal(expected_select_response, convert(search_response))
+    end
+
+    def test_have_one_result
+      search_response = {
+        "EmptyTable" => main_search_result,
+        "drilldown_result_a" => {
+          "count" => 3,
+          "attributes" => [
+            {"name" => "_id", "type" => "UInt32", "vector" => false},
+            {"name" => "_key", "type" => "ShortText", "vector" => false},
+            {"name" => "_nsubrecs", "type" => "UInt32", "vector" => false},
+          ],
+          "records" => [
+            [1, "a1", 10],
+            [2, "a2", 20],
+            [3, "a3", 30],
+          ],
+        },
+      }
+
+      headers = [
+        ["_id", "UInt32"],
+        ["_key", "ShortText"],
+        ["_nsubrecs", "UInt32"],
+      ]
+      expected_select_response = [
+        expected_header,
+        [
+          expected_main_select_result,
+          [
+            [3],
+            headers,
+            [
+              [1, "a1", 10],
+              [2, "a2", 20],
+              [3, "a3", 30],
+            ],
+          ],
+        ],
+      ]
+
+      assert_equal(expected_select_response, convert(search_response))
+    end
+
+    def test_have_multiple_results
+      search_response = {
+        "EmptyTable" => main_search_result,
+        "drilldown_result_a" => {
+          "count" => 3,
+          "attributes" => [
+            {"name" => "_key", "type" => "ShortText", "vector" => false},
+            {"name" => "_nsubrecs", "type" => "UInt32", "vector" => false},
+          ],
+          "records" => [
+            ["a1", 10],
+            ["a2", 20],
+            ["a3", 30],
+          ],
+        },
+        "drilldown_result_b" => {
+          "count" => 2,
+          "attributes" => [
+            {"name" => "_key", "type" => "ShortText", "vector" => false},
+            {"name" => "_nsubrecs", "type" => "UInt32", "vector" => false},
+          ],
+          "records" => [
+            ["b1", 10],
+            ["b2", 20],
+          ],
+        },
+      }
+
+      headers = [
+        ["_key", "ShortText"],
+        ["_nsubrecs", "UInt32"],
+      ]
+      expected_select_response = [
+        expected_header,
+        [
+          expected_main_select_result,
+          [
+            [3],
+            headers,
+            [
+              ["a1", 10],
+              ["a2", 20],
+              ["a3", 30],
+            ],
+          ],
+          [
+            [2],
+            headers,
+            [
+              ["b1", 10],
+              ["b2", 20],
+            ],
+          ],
+        ],
+      ]
+
+      assert_equal(expected_select_response, convert(search_response))
+    end
+  end
+end

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

@@ -0,0 +1,171 @@
+# Copyright (C) 2013-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 ColumnCreateTest < GroongaHandlerTest
+  def create_handler
+    Droonga::Plugins::Groonga::ColumnCreate::Handler.new("droonga",
+                                                         @handler.context,
+                                                         @messenger,
+                                                         @loop)
+  end
+
+  def test_success
+    Groonga::Schema.define do |schema|
+      schema.create_table("Books", :type => :hash)
+    end
+    message = {
+      "table" => "Books",
+      "name"  => "title",
+      "type"  => "ShortText",
+    }
+    response = process(:column_create, message)
+    assert_equal(
+      [NORMALIZED_HEADER_SUCCESS, true],
+      [normalize_header(response.first), response.last]
+    )
+  end
+
+  def test_unknown_table
+    message = {
+      "table" => "Unknown",
+      "name"  => "title",
+      "type"  => "ShortText",
+    }
+    response = process(:column_create, message)
+    assert_equal(
+      [NORMALIZED_HEADER_INVALID_ARGUMENT, false],
+      [normalize_header(response.first), response.last]
+    )
+  end
+
+  def test_name
+    Groonga::Schema.define do |schema|
+      schema.create_table("Books", :type => :hash)
+    end
+    process(:column_create,
+            {"table" => "Books", "name" => "title", "type" => "ShortText"})
+    assert_equal(<<-SCHEMA, dump)
+table_create Books TABLE_HASH_KEY --key_type ShortText
+column_create Books title COLUMN_SCALAR ShortText
+    SCHEMA
+  end
+
+  def test_type
+    Groonga::Schema.define do |schema|
+      schema.create_table("Books", :type => :hash)
+    end
+    process(:column_create,
+            {"table" => "Books", "name" => "main_text", "type" => "LongText"})
+    assert_equal(<<-SCHEMA, dump)
+table_create Books TABLE_HASH_KEY --key_type ShortText
+column_create Books main_text COLUMN_SCALAR LongText
+    SCHEMA
+  end
+
+  class FlagsTest < self
+    class DataStoreTest < self
+      data({
+             "COLUMN_SCALAR" => {
+               :flags => "COLUMN_SCALAR",
+             },
+             "COLUMN_VECTOR" => {
+               :flags => "COLUMN_VECTOR",
+             },
+             "COLUMN_VECTOR|WITH_WEIGHT" => {
+               :flags => "COLUMN_VECTOR|WITH_WEIGHT",
+             },
+           })
+      def test_data_store_column_type(data)
+        request = {
+          "table" => "Books",
+          "name"  => "title",
+          "type"  => "ShortText",
+          "flags" => data[:flags],
+        }
+        Groonga::Schema.define do |schema|
+          schema.create_table("Books", :type => :hash)
+        end
+        process(:column_create, request)
+        assert_equal(<<-EXPECTED, dump)
+table_create Books TABLE_HASH_KEY --key_type ShortText
+column_create Books title #{data[:flags]} ShortText
+        EXPECTED
+      end
+    end
+
+    class IndexTest < self
+      def setup
+        super
+        Groonga::Schema.define do |schema|
+          schema.create_table("Books", :type => :hash)
+        end
+        process(:column_create,
+                {"table" => "Books", "name" => "title", "type" => "ShortText"})
+      end
+
+      def test_index_column_type
+        data = {
+          :flags  => "COLUMN_INDEX",
+        }
+        request = {
+          "table"  => "Books",
+          "name"   => "entry_title",
+          "type"   => "Books",
+          "source" => "title",
+          "flags"  => data[:flags],
+        }
+        process(:column_create, request)
+        assert_equal(<<-EXPECTED, dump)
+table_create Books TABLE_HASH_KEY --key_type ShortText
+column_create Books title COLUMN_SCALAR ShortText
+
+column_create Books entry_title #{data[:flags]} Books title
+        EXPECTED
+      end
+
+      data({
+             "WITH_SECTION" => {
+               :flags => "WITH_SECTION",
+             },
+             "WITH_WEIGHT" => {
+               :flags => "WITH_WEIGHT",
+             },
+             "WITH_POSITION" => {
+               :flags => "WITH_POSITION",
+             },
+             "COLUMN_INDEX with all" => {
+               :flags => "WITH_SECTION|WITH_WEIGHT|WITH_POSITION",
+             },
+           })
+      def test_index_flags(data)
+        flags = "COLUMN_INDEX|#{data[:flags]}"
+        request = {
+          "table"  => "Books",
+          "name"   => "entry_title",
+          "type"   => "Books",
+          "source" => "title",
+          "flags"  => flags,
+        }
+        process(:column_create, request)
+        assert_equal(<<-EXPECTED, dump)
+table_create Books TABLE_HASH_KEY --key_type ShortText
+column_create Books title COLUMN_SCALAR ShortText
+
+column_create Books entry_title #{flags} Books title
+        EXPECTED
+      end
+    end
+  end
+end

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

@@ -0,0 +1,170 @@
+# 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 ColumnListTest < GroongaHandlerTest
+  COLUMNS_HEADER = [
+    ["id",     "UInt32"],
+    ["name",   "ShortText"],
+    ["path",   "ShortText"],
+    ["type",   "ShortText"],
+    ["flags",  "ShortText"],
+    ["domain", "ShortText"],
+    ["range",  "ShortText"],
+    ["source", "ShortText"],
+  ]
+
+  def create_handler
+    Droonga::Plugins::Groonga::ColumnList::Handler.new("droonga",
+                                                       @handler.context,
+                                                       @messenger,
+                                                       @loop)
+  end
+
+  class HeaderTest < self
+    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",
+      }
+      response = process(:column_list, message)
+      assert_equal(
+        NORMALIZED_HEADER_SUCCESS,
+        normalize_header(response.first)
+      )
+    end
+
+    def test_unknown_table
+      message = {
+        "table" => "Unknown",
+        "name"  => "title",
+        "type"  => "ShortText",
+      }
+      response = process(:column_list, message)
+      assert_equal(
+        NORMALIZED_HEADER_INVALID_ARGUMENT,
+        normalize_header(response.first)
+      )
+    end
+  end
+
+  class BodyTest < self
+    def test_fix
+      Groonga::Schema.define do |schema|
+        schema.create_table("Books", :type => :hash)
+        schema.change_table("Books") do |table|
+          table.column("age", "UInt32", :type => :scalar)
+        end
+      end
+      response = process(:column_list,
+                         {"table" => "Books"})
+      expected = [
+        COLUMNS_HEADER,
+        [257,
+         "age",
+         @database_path.to_s + ".0000101",
+         "fix",
+         "COLUMN_SCALAR",
+         "Books",
+         "UInt32",
+         []],
+      ]
+      assert_equal(expected, response.last)
+    end
+
+    def test_var
+      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
+      response = process(:column_list,
+                         {"table" => "Books"})
+      expected = [
+        COLUMNS_HEADER,
+        [257,
+         "title",
+         @database_path.to_s + ".0000101",
+         "var",
+         "COLUMN_SCALAR",
+         "Books",
+         "ShortText",
+         []],
+      ]
+      assert_equal(expected, response.last)
+    end
+
+    def test_vector
+      Groonga::Schema.define do |schema|
+        schema.create_table("Books", :type => :hash)
+        schema.change_table("Books") do |table|
+          table.column("authors", "ShortText", :type => :vector)
+        end
+      end
+      response = process(:column_list,
+                         {"table" => "Books"})
+      expected = [
+        COLUMNS_HEADER,
+        [257,
+         "authors",
+         @database_path.to_s + ".0000101",
+         "var",
+         "COLUMN_VECTOR",
+         "Books",
+         "ShortText",
+        []],
+      ]
+      assert_equal(expected, response.last)
+    end
+
+    def test_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
+      response = process(:column_list,
+                         {"table" => "Books"})
+      expected = [
+        COLUMNS_HEADER,
+        [258,
+         "entry_title",
+         @database_path.to_s + ".0000102",
+         "index",
+         "COLUMN_INDEX",
+         "Books",
+         "Books",
+         ["title"]],
+        [257,
+         "title",
+         @database_path.to_s + ".0000101",
+         "var",
+         "COLUMN_SCALAR",
+         "Books",
+         "ShortText",
+         []],
+      ]
+      assert_equal(expected, response.last)
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# 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 ColumnRemoveTest < GroongaHandlerTest
+  def create_handler
+    Droonga::Plugins::Groonga::ColumnRemove::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",
+    }
+    response = process(:column_remove, message)
+    assert_equal(
+      [NORMALIZED_HEADER_SUCCESS, true],
+      [normalize_header(response.first), response.last]
+    )
+  end
+
+  def test_unknown_table
+    message = {
+      "table" => "Unknown",
+      "name"  => "title",
+      "type"  => "ShortText",
+    }
+    response = process(:column_remove, 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",
+    }
+    response = process(:column_remove, message)
+    assert_equal(
+      [NORMALIZED_HEADER_INVALID_ARGUMENT, false],
+      [normalize_header(response.first), response.last]
+    )
+  end
+
+  def test_remove
+    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_remove,
+            {"table" => "Books", "name" => "title"})
+    assert_equal(<<-SCHEMA, dump)
+table_create Books TABLE_HASH_KEY --key_type ShortText
+    SCHEMA
+  end
+
+  def test_remove_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_remove,
+            {"table" => "Books", "name" => "title"})
+    assert_equal(<<-SCHEMA, dump)
+table_create Books TABLE_HASH_KEY --key_type ShortText
+    SCHEMA
+  end
+end