fluent-plugin-droonga 0.9.0 → 0.9.9

data/test/unit/plugin/input_adapter/groonga/test_select.rb

@@ -1,248 +0,0 @@
-
-# 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
-
-require "droonga/plugin/input_adapter/groonga/select"
-
-class InputAdapterGroongaSelectTest < Test::Unit::TestCase
-  def setup
-    @select = Droonga::GroongaInputAdapter::Select.new
-  end
-
-  class RequestTest < self
-    def test_empty
-      select_request = {
-        "table" => "EmptyTable",
-        "output_columns" => "_id",
-      }
-
-      expected_search_request = {
-        "queries" => {
-          "EmptyTable_result" => {
-            "source"   => "EmptyTable",
-            "output"   => {
-              "elements"   => [
-                "startTime",
-                "elapsedTime",
-                "count",
-                "attributes",
-                "records",
-              ],
-              "attributes" => ["_id"],
-              "offset" => 0,
-              "limit" => 10,
-            },
-          },
-        },
-      }
-
-      assert_equal(expected_search_request, convert(select_request))
-    end
-
-    private
-    def convert(select_request)
-      @select.convert(select_request)
-    end
-
-    class OutputColumnsTest < self
-      def assert_attributes(expected_attributes, output_columns)
-        select_request = {
-          "table" => "EmptyTable",
-          "output_columns" => output_columns,
-        }
-
-        expected_search_request = {
-          "queries" => {
-            "EmptyTable_result" => {
-              "source"   => "EmptyTable",
-              "output"   => {
-                "elements"   => [
-                  "startTime",
-                  "elapsedTime",
-                  "count",
-                  "attributes",
-                  "records",
-                ],
-                "attributes" => expected_attributes,
-                "offset" => 0,
-                "limit" => 10,
-              },
-            },
-          },
-        }
-        assert_equal(expected_search_request, convert(select_request))
-      end
-
-      def test_multiple_columns
-        assert_attributes(["_id", "_key"], "_id,_key")
-      end
-
-      class FunctionTest < self
-        def test_single_argument
-          assert_attributes(["snippet_html(content)"], "snippet_html(content)")
-        end
-
-        def test_with_columns
-          assert_attributes(["_id","_key","snippet_html(content)"], "_id,_key,snippet_html(content)")
-        end
-      end
-    end
-
-    class MatchColumnsTest < self
-      def assert_matchTo(expected_matchTo, match_columns)
-        select_request = {
-          "table"          => "EmptyTable",
-          "match_columns"  => match_columns,
-          "query"          => "QueryTest",
-          "output_columns" => "_id",
-        }
-
-        expected_search_request = {
-          "queries" => {
-            "EmptyTable_result" => {
-              "source"   => "EmptyTable",
-              "condition"=> {
-                "query"  => "QueryTest",
-                "matchTo"=> expected_matchTo,
-                "defaultOperator"=> "&&",
-                "allowPragma"=> false,
-                "allowColumn"=> true,
-              },
-              "output"   => {
-                "elements"   => [
-                  "startTime",
-                  "elapsedTime",
-                  "count",
-                  "attributes",
-                  "records",
-                ],
-                "attributes" => ["_id"],
-                "offset" => 0,
-                "limit" => 10,
-              },
-            },
-          },
-        }
-        assert_equal(expected_search_request, convert(select_request))
-      end
-
-      def test_single_column
-        assert_matchTo(["_key"], "_key")
-      end
-
-      def test_multiple_columns
-        assert_matchTo(["_key", "content"], "_key || content")
-      end
-    end
-
-    class OffsetTest < self
-      def assert_offset(expected_offset, offset)
-        select_request = {
-          "table"          => "EmptyTable",
-          "output_columns" => "_id",
-        }
-        select_request["offset"] = offset unless offset.nil?
-
-        expected_search_request = {
-          "queries" => {
-            "EmptyTable_result" => {
-              "source"   => "EmptyTable",
-              "output"   => {
-                "elements"   => [
-                  "startTime",
-                  "elapsedTime",
-                  "count",
-                  "attributes",
-                  "records",
-                ],
-                "attributes" => ["_id"],
-                "offset" => expected_offset,
-                "limit" => 10,
-              },
-            },
-          },
-        }
-        assert_equal(expected_search_request, convert(select_request))
-      end
-
-      def test_zero
-        assert_offset(0, "0")
-      end
-
-      def test_large
-        assert_offset(100, "100")
-      end
-
-      def test_integer
-        assert_offset(100, 100)
-      end
-
-      def test_default
-        assert_offset(0, nil)
-      end
-    end
-
-    class LimitTest < self
-      def assert_limit(expected_limit, limit)
-        select_request = {
-          "table"          => "EmptyTable",
-          "output_columns" => "_id",
-        }
-        select_request["limit"] = limit unless limit.nil?
-
-        expected_search_request = {
-          "queries" => {
-            "EmptyTable_result" => {
-              "source"   => "EmptyTable",
-              "output"   => {
-                "elements"   => [
-                  "startTime",
-                  "elapsedTime",
-                  "count",
-                  "attributes",
-                  "records",
-                ],
-                "attributes" => ["_id"],
-                "offset" => 0,
-                "limit" => expected_limit,
-              },
-            },
-          },
-        }
-        assert_equal(expected_search_request, convert(select_request))
-      end
-
-      def test_zero
-        assert_limit(0, "0")
-      end
-
-      def test_large
-        assert_limit(100, "100")
-      end
-
-      def test_negative
-        assert_limit(-1, "-1")
-      end
-
-      def test_integer
-        assert_limit(100, 100)
-      end
-
-      def test_default
-        assert_limit(10, nil)
-      end
-    end
-  end
-end

data/test/unit/test_command_mapper.rb

@@ -1,44 +0,0 @@
-# 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
-
-require "droonga/command_mapper"
-
-class CommandMapperTest < Test::Unit::TestCase
-  class RegisterTest < self
-    def setup
-      @command_mapper = Droonga::CommandMapper.new
-    end
-
-    def test_name
-      @command_mapper.register(:select)
-      assert_equal(:select, @command_mapper[:select])
-    end
-
-    def test_different_method_name
-      @command_mapper.register(:command_name => :method_name)
-      assert_equal(:method_name, @command_mapper[:command_name])
-    end
-
-    def test_multiple_pairs
-      map = {
-        :command_name_1 => :command_name_1,
-        :command_name_2 => :command_name_2,
-      }
-      @command_mapper.register(map)
-      assert_equal(["command_name_1", "command_name_2"],
-                   @command_mapper.commands)
-    end
-  end
-end

data/test/unit/test_groonga_command_converter.rb

@@ -1,242 +0,0 @@
-# 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
-
-require "groonga_command_converter"
-
-class GroongaCommandConverterTest < Test::Unit::TestCase
-  def setup
-    options = {
-      :id => "test",
-      :date => date,
-      :reply_to => reply_to,
-      :status_code => status_code,
-      :dataset => dataset,
-    }
-    @converter = Droonga::GroongaCommandConverter.new(options)
-  end
-
-  def test_table_create
-    droonga_commands = []
-    command = <<-COMMAND.chomp
-table_create Terms TABLE_PAT_KEY ShortText \
-  --default_tokenizer TokenBigram --normalizer NormalizerAuto
-    COMMAND
-    @converter.convert(command) do |droonga_command|
-      droonga_commands << droonga_command
-    end
-    assert_equal([
-                   {
-                     :id => "test:0",
-                     :date => formatted_date,
-                     :replyTo => reply_to,
-                     :statusCode => status_code,
-                     :dataset => dataset,
-                     :type => "table_create",
-                     :body => {
-                       :name => "Terms",
-                       :flags => "TABLE_PAT_KEY",
-                       :key_type => "ShortText",
-                       :default_tokenizer => "TokenBigram",
-                       :normalizer => "NormalizerAuto",
-                     },
-                   },
-                 ],
-                 droonga_commands)
-  end
-
-  def test_column_create
-    droonga_commands = []
-    command = <<-COMMAND.chomp
-column_create Terms Users_name COLUMN_INDEX|WITH_POSITION Users name
-    COMMAND
-    @converter.convert(command) do |droonga_command|
-      droonga_commands << droonga_command
-    end
-    assert_equal([
-                   {
-                     :id => "test:0",
-                     :date => formatted_date,
-                     :replyTo => reply_to,
-                     :statusCode => status_code,
-                     :dataset => dataset,
-                     :type => "column_create",
-                     :body => {
-                       :table => "Terms",
-                       :name => "Users_name",
-                       :flags => "COLUMN_INDEX|WITH_POSITION",
-                       :type => "Users",
-                       :source => "name",
-                     },
-                   },
-                 ],
-                 droonga_commands)
-  end
-
-  def test_load
-    droonga_commands = []
-    command = <<-COMMAND.chomp
-load --table Users
-[
-["_key","name"],
-["user0","Abe Shinzo"],
-["user1","Noda Yoshihiko"],
-["user2","Kan Naoto"]
-]
-    COMMAND
-    @converter.convert(command) do |droonga_command|
-      droonga_commands << droonga_command
-    end
-    assert_equal([
-                   {
-                     :id => "test:0",
-                     :date => formatted_date,
-                     :replyTo => reply_to,
-                     :statusCode => status_code,
-                     :dataset => dataset,
-                     :type => "add",
-                     :body => {
-                       :table => "Users",
-                       :key => "user0",
-                       :values => {
-                         :name => "Abe Shinzo",
-                       },
-                     },
-                   },
-                   {
-                     :id => "test:1",
-                     :date => formatted_date,
-                     :replyTo => reply_to,
-                     :statusCode => status_code,
-                     :dataset => dataset,
-                     :type => "add",
-                     :body => {
-                       :table => "Users",
-                       :key => "user1",
-                       :values => {
-                         :name => "Noda Yoshihiko",
-                       },
-                     },
-                   },
-                   {
-                     :id => "test:2",
-                     :date => formatted_date,
-                     :replyTo => reply_to,
-                     :statusCode => status_code,
-                     :dataset => dataset,
-                     :type => "add",
-                     :body => {
-                       :table => "Users",
-                       :key => "user2",
-                       :values => {
-                         :name => "Kan Naoto",
-                       },
-                     },
-                   },
-                 ],
-                 droonga_commands)
-  end
-
-  def test_select
-    droonga_commands = []
-    command = <<-COMMAND.chomp
-select --filter "age<=30" --output_type "json" --table "Users"
-    COMMAND
-    @converter.convert(command) do |droonga_command|
-      droonga_commands << droonga_command
-    end
-    assert_equal([
-                   {
-                     :id => "test:0",
-                     :date => formatted_date,
-                     :replyTo => reply_to,
-                     :statusCode => status_code,
-                     :dataset => dataset,
-                     :type => "select",
-                     :body => {
-                       :table => "Users",
-                       :filter => "age<=30",
-                       :output_type => "json",
-                     },
-                   },
-                 ],
-                 droonga_commands)
-  end
-
-  def test_multiple_commands
-    droonga_commands = []
-    commands = <<-COMMANDS.chomp
-table_create Terms TABLE_PAT_KEY ShortText \
-  --default_tokenizer TokenBigram --normalizer NormalizerAuto
-column_create Terms Users_name COLUMN_INDEX|WITH_POSITION Users name
-    COMMANDS
-    @converter.convert(commands) do |droonga_command|
-      droonga_commands << droonga_command
-    end
-    assert_equal([
-                   {
-                     :id => "test:0",
-                     :date => formatted_date,
-                     :replyTo => reply_to,
-                     :statusCode => status_code,
-                     :dataset => dataset,
-                     :type => "table_create",
-                     :body => {
-                       :name => "Terms",
-                       :flags => "TABLE_PAT_KEY",
-                       :key_type => "ShortText",
-                       :default_tokenizer => "TokenBigram",
-                       :normalizer => "NormalizerAuto",
-                     },
-                   },
-                   {
-                     :id => "test:1",
-                     :date => formatted_date,
-                     :replyTo => reply_to,
-                     :statusCode => status_code,
-                     :dataset => dataset,
-                     :type => "column_create",
-                     :body => {
-                       :table => "Terms",
-                       :name => "Users_name",
-                       :flags => "COLUMN_INDEX|WITH_POSITION",
-                       :type => "Users",
-                       :source => "name",
-                     },
-                   },
-                 ],
-                 droonga_commands)
-  end
-
-  private
-  def date
-    Time.utc(2013, 11, 29, 0, 0, 0)
-  end
-
-  def formatted_date
-    "2013-11-29T00:00:00Z"
-  end
-
-  def reply_to
-    "localhost:20033"
-  end
-
-  def status_code
-    200
-  end
-
-  def dataset
-    "test-dataset"
-  end
-end