groonga-command 1.0.4 → 1.0.5

data/test/command/test-select.rb

@@ -17,87 +17,88 @@
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
 class SelectCommandTest < Test::Unit::TestCase
-  include GroongaCommandTestUtils::CommandLineCommandParser
+  private
+  def select_command(pair_arguments={}, ordered_arguments=[])
+    Groonga::Command::Select.new("select", pair_arguments, ordered_arguments)
+  end
 
-  def test_ordered_argument
-    table = "Users"
-    match_columns = "name * 10 || description"
-    query = "groonga"
-    filter = "age >= 18"
-    scorer = "_score = age"
-    sortby = "_score"
-    output_columns = "_key, name"
-    offset = "10"
-    limit = "20"
-    drilldown = "name"
-    drilldown_sortby = "_nsubrecs"
-    drilldown_output_columns = "name, _nsubrecs"
-    drilldown_offset = "5"
-    drilldown_limit = "10"
-    cache = "no"
-    match_escalation_threshold = "-1"
-    query_expansion = "deprecated"
-    query_flags = "ALLOW_LEADING_NOT"
-    query_expander = "Terms.synonym"
-    command = parse("select",
-                    [
-                      table,
-                      match_columns,
-                      query,
-                      filter,
-                      scorer,
-                      sortby,
-                      output_columns,
-                      offset,
-                      limit,
-                      drilldown,
-                      drilldown_sortby,
-                      drilldown_output_columns,
-                      drilldown_offset,
-                      drilldown_limit,
-                      cache,
-                      match_escalation_threshold,
-                      query_expansion,
-                      query_flags,
-                      query_expander,
-                    ],
-                    :output_type => false)
+  class ConstructorTest < self
+    def test_ordered_argument
+      table                      = "Users"
+      match_columns              = "name * 10 || description"
+      query                      = "groonga"
+      filter                     = "age >= 18"
+      scorer                     = "_score = age"
+      sortby                     = "_score"
+      output_columns             = "_key, name"
+      offset                     = "10"
+      limit                      = "20"
+      drilldown                  = "name"
+      drilldown_sortby           = "_nsubrecs"
+      drilldown_output_columns   = "name, _nsubrecs"
+      drilldown_offset           = "5"
+      drilldown_limit            = "10"
+      cache                      = "no"
+      match_escalation_threshold = "-1"
+      query_expansion            = "deprecated"
+      query_flags                = "ALLOW_LEADING_NOT"
+      query_expander             = "Terms.synonym"
 
-    assert_instance_of(Groonga::Command::Select, command)
-    assert_equal({
-                   :table                      => table,
-                   :match_columns              => match_columns,
-                   :query                      => query,
-                   :filter                     => filter,
-                   :scorer                     => scorer,
-                   :sortby                     => sortby,
-                   :output_columns             => output_columns,
-                   :offset                     => offset,
-                   :limit                      => limit,
-                   :drilldown                  => drilldown,
-                   :drilldown_sortby           => drilldown_sortby,
-                   :drilldown_output_columns   => drilldown_output_columns,
-                   :drilldown_offset           => drilldown_offset,
-                   :drilldown_limit            => drilldown_limit,
-                   :cache                      => cache,
-                   :match_escalation_threshold => match_escalation_threshold,
-                   :query_expansion            => query_expansion,
-                   :query_flags                => query_flags,
-                   :query_expander             => query_expander,
-                 },
-                 command.arguments)
-  end
+      ordered_arguments = [
+        table,
+        match_columns,
+        query,
+        filter,
+        scorer,
+        sortby,
+        output_columns,
+        offset,
+        limit,
+        drilldown,
+        drilldown_sortby,
+        drilldown_output_columns,
+        drilldown_offset,
+        drilldown_limit,
+        cache,
+        match_escalation_threshold,
+        query_expansion,
+        query_flags,
+        query_expander,
+      ]
+      command = select_command({}, ordered_arguments)
 
-  def test_scorer
-    select = command(:table => "Users",
-                     :filter => "age<=30",
-                     :scorer => "_score = random()")
-    assert_equal("_score = random()", select.scorer)
+      assert_equal({
+                     :table                      => table,
+                     :match_columns              => match_columns,
+                     :query                      => query,
+                     :filter                     => filter,
+                     :scorer                     => scorer,
+                     :sortby                     => sortby,
+                     :output_columns             => output_columns,
+                     :offset                     => offset,
+                     :limit                      => limit,
+                     :drilldown                  => drilldown,
+                     :drilldown_sortby           => drilldown_sortby,
+                     :drilldown_output_columns   => drilldown_output_columns,
+                     :drilldown_offset           => drilldown_offset,
+                     :drilldown_limit            => drilldown_limit,
+                     :cache                      => cache,
+                     :match_escalation_threshold => match_escalation_threshold,
+                     :query_expansion            => query_expansion,
+                     :query_flags                => query_flags,
+                     :query_expander             => query_expander,
+                   },
+                   command.arguments)
+    end
   end
 
-  private
-  def command(arguments)
-    Groonga::Command::Select.new("select", arguments)
+  class ScorerTest < self
+    def test_reader
+      command = select_command(:table  => "Users",
+                               :filter => "age<=30",
+                               :scorer => "_score = random()")
+      assert_equal("_score = random()", command.scorer)
+    end
   end
 
   class FilterTest < self
@@ -106,8 +107,8 @@ class SelectCommandTest < Test::Unit::TestCase
                                 '"35.73360x139.7394","62614x139.7714") && ' +
                 '((type == "たいやき" || type == "和菓子")) && ' +
                  'keyword @ "たいやき" &! keyword @ "白" &! keyword @ "養殖"'
-      select = command(:table => "Users",
-                       :filter => filter)
+      command = select_command(:table => "Users",
+                               :filter => filter)
       assert_equal(['geo_in_rectangle(location,' +
                                      '"35.73360x139.7394","62614x139.7714")',
                      'type == "たいやき"',
@@ -115,14 +116,14 @@ class SelectCommandTest < Test::Unit::TestCase
                      'keyword @ "たいやき"',
                      'keyword @ "白"',
                      'keyword @ "養殖"'],
-                   select.conditions)
+                   command.conditions)
     end
 
     def test_omitted
-      select = command(:table => "Users",
-                       :filter => nil)
+      command = select_command(:table => "Users",
+                               :filter => nil)
       assert_equal([],
-                   select.conditions)
+                   command.conditions)
     end
   end
 end

data/test/command/test-suggest.rb

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 #
+# Copyright (C) 2013  Kouhei Sutou <kou@clear-code.com>
 # Copyright (C) 2012  Haruka Yoshihara <yoshihara@clear-code.com>
 #
 # This library is free software; you can redistribute it and/or
@@ -17,52 +18,59 @@
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
 class SuggestCommandTest < Test::Unit::TestCase
-  class CommandLineTest < self
-    include GroongaCommandTestUtils::CommandLineCommandParser
+  private
+  def suggest_command(pair_arguments={}, ordered_arguments=[])
+    Groonga::Command::Suggest.new("suggest",
+                                  pair_arguments,
+                                  ordered_arguments)
+  end
 
+  class ConstructorTest < self
     def test_ordered_arguments
-      types = "complete"
-      table = "Users"
-      column = "name"
-      query = "name:@ Ali"
-      sortby = "_score"
-      output_columns = "name"
-      offset = "0"
-      limit = "5"
-      frequency_threshold = "120"
+      types                             = "complete"
+      table                             = "Users"
+      column                            = "name"
+      query                             = "name:@ Ali"
+      sortby                            = "_score"
+      output_columns                    = "name"
+      offset                            = "0"
+      limit                             = "5"
+      frequency_threshold               = "120"
       conditional_probability_threshold = "0.3"
-      prefix_search = "yes"
-      similar_search = "yes"
+      prefix_search                     = "yes"
+      similar_search                    = "yes"
 
-      arguments = [
-        types, table, column, query, sortby, output_columns,
-        offset, limit, frequency_threshold,
+      ordered_arguments = [
+        types,
+        table,
+        column,
+        query,
+        sortby,
+        output_columns,
+        offset,
+        limit,
+        frequency_threshold,
         conditional_probability_threshold,
-        prefix_search, similar_search
+        prefix_search,
+        similar_search
       ]
-      command = parse(*arguments)
-      assert_instance_of(Groonga::Command::Suggest, command)
+      command = suggest_command({}, ordered_arguments)
 
       expected_arguments = {
-        :types => types,
-        :table => table,
-        :column => column,
-        :query => query,
-        :sortby => sortby,
-        :output_columns => output_columns,
-        :offset => offset,
-        :limit => limit,
-        :frequency_threshold => frequency_threshold,
+        :types                             => types,
+        :table                             => table,
+        :column                            => column,
+        :query                             => query,
+        :sortby                            => sortby,
+        :output_columns                    => output_columns,
+        :offset                            => offset,
+        :limit                             => limit,
+        :frequency_threshold               => frequency_threshold,
         :conditional_probability_threshold => conditional_probability_threshold,
-        :prefix_search => prefix_search,
-        :similar_search => similar_search
+        :prefix_search                     => prefix_search,
+        :similar_search                    => similar_search
       }
       assert_equal(expected_arguments, command.arguments)
     end
-
-    private
-    def parse(*arguments)
-      super("suggest", arguments, :output_type => false)
-    end
   end
 end

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

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2012  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2012-2013  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
@@ -17,9 +17,14 @@
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
 class TableCreateCommandTest < Test::Unit::TestCase
-  class CommandLineTest < self
-    include GroongaCommandTestUtils::CommandLineCommandParser
+  private
+  def table_create_command(pair_arguments={}, ordered_arguments=[])
+    Groonga::Command::TableCreate.new("table_create",
+                                      pair_arguments,
+                                      ordered_arguments)
+  end
 
+  class ConstructorTest < self
     def test_ordered_arguments
       name              = "Users"
       flags             = "TABLE_PAT_KEY"
@@ -28,8 +33,15 @@ class TableCreateCommandTest < Test::Unit::TestCase
       default_tokenizer = "TokenBigram"
       normalizer        = "NormalizerAuto"
 
-      command = parse([name, flags, key_type, value_type, default_tokenizer, normalizer])
-      assert_instance_of(Groonga::Command::TableCreate, command)
+      ordered_arguments = [
+        name,
+        flags,
+        key_type,
+        value_type,
+        default_tokenizer,
+        normalizer,
+      ]
+      command = table_create_command({}, ordered_arguments)
       assert_equal({
                      :name              => name,
                      :flags             => flags,
@@ -40,105 +52,100 @@ class TableCreateCommandTest < Test::Unit::TestCase
                    },
                    command.arguments)
     end
+  end
 
-    private
-    def parse(arguments)
-      super("table_create", arguments, :output_type => false)
+  class FlagsTest < self
+    def test_multiple
+      command = table_create_command({"flags" => "TABLE_PAT_KEY|KEY_WITH_SIS"})
+      assert_equal(["TABLE_PAT_KEY", "KEY_WITH_SIS"],
+                   command.flags)
     end
 
-    class FlagsTest < self
-      def test_multiple
-        command = parse({"flags" => "TABLE_PAT_KEY|KEY_WITH_SIS"})
-        assert_equal(["TABLE_PAT_KEY", "KEY_WITH_SIS"],
-                     command.flags)
-      end
+    def test_one
+      command = table_create_command({"flags" => "TABLE_NO_KEY"})
+      assert_equal(["TABLE_NO_KEY"],
+                   command.flags)
+    end
 
-      def test_one
-        command = parse({"flags" => "TABLE_NO_KEY"})
-        assert_equal(["TABLE_NO_KEY"],
-                     command.flags)
-      end
+    def test_no_flags
+      command = table_create_command
+      assert_equal([], command.flags)
+    end
 
-      def test_no_flags
-        command = parse({})
-        assert_equal([], command.flags)
+    class PredicateTest < self
+      data({
+             "TABLE_NO_KEY" => {
+               :expected => true,
+               :flags    => "TABLE_NO_KEY",
+             },
+             "other flag"   => {
+               :expected => false,
+               :flags    => "TABLE_HASH_KEY",
+             }
+           })
+      def test_table_no_key?(data)
+        command = table_create_command({"flags" => data[:flags]})
+        assert_equal(data[:expected], command.table_no_key?)
       end
 
-      class PredicateTest < self
-        data({
-               "TABLE_NO_KEY" => {
-                 :expected => true,
-                 :flags    => "TABLE_NO_KEY",
-               },
-               "other flag"   => {
-                 :expected => false,
-                 :flags    => "TABLE_HASH_KEY",
-               }
-             })
-        def test_table_no_key?(data)
-          command = parse({"flags" => data[:flags]})
-          assert_equal(data[:expected], command.table_no_key?)
-        end
-
-        data({
-               "TABLE_HASH_KEY" => {
-                 :expected => true,
-                 :flags    => "TABLE_HASH_KEY",
-               },
-               "other flag"   => {
-                 :expected => false,
-                 :flags    => "TABLE_PAT_KEY",
-               }
-             })
-        def test_table_hash_key?(data)
-          command = parse({"flags" => data[:flags]})
-          assert_equal(data[:expected], command.table_hash_key?)
-        end
+      data({
+             "TABLE_HASH_KEY" => {
+               :expected => true,
+               :flags    => "TABLE_HASH_KEY",
+             },
+             "other flag"   => {
+               :expected => false,
+               :flags    => "TABLE_PAT_KEY",
+             }
+           })
+      def test_table_hash_key?(data)
+        command = table_create_command({"flags" => data[:flags]})
+        assert_equal(data[:expected], command.table_hash_key?)
+      end
 
-        data({
-               "TABLE_PAT_KEY" => {
-                 :expected => true,
-                 :flags    => "TABLE_PAT_KEY",
-               },
-               "other flag"   => {
-                 :expected => false,
-                 :flags    => "TABLE_DAT_KEY",
-               }
-             })
-        def test_table_pat_key?(data)
-          command = parse({"flags" => data[:flags]})
-          assert_equal(data[:expected], command.table_pat_key?)
-        end
+      data({
+             "TABLE_PAT_KEY" => {
+               :expected => true,
+               :flags    => "TABLE_PAT_KEY",
+             },
+             "other flag"   => {
+               :expected => false,
+               :flags    => "TABLE_DAT_KEY",
+             }
+           })
+      def test_table_pat_key?(data)
+        command = table_create_command({"flags" => data[:flags]})
+        assert_equal(data[:expected], command.table_pat_key?)
+      end
 
-        data({
-               "TABLE_DAT_KEY" => {
-                 :expected => true,
-                 :flags    => "TABLE_DAT_KEY",
-               },
-               "other flag"   => {
-                 :expected => false,
-                 :flags    => "TABLE_NO_KEY",
-               }
-             })
-        def test_table_dat_key?(data)
-          command = parse({"flags" => data[:flags]})
-          assert_equal(data[:expected], command.table_dat_key?)
-        end
+      data({
+             "TABLE_DAT_KEY" => {
+               :expected => true,
+               :flags    => "TABLE_DAT_KEY",
+             },
+             "other flag"   => {
+               :expected => false,
+               :flags    => "TABLE_NO_KEY",
+             }
+           })
+      def test_table_dat_key?(data)
+        command = table_create_command({"flags" => data[:flags]})
+        assert_equal(data[:expected], command.table_dat_key?)
+      end
 
-        data({
-               "KEY_WITH_SIS" => {
-                 :expected => true,
-                 :flags    => "KEY_WITH_SIS|TABLE_PAT_KEY",
-               },
-               "other flag"   => {
-                 :expected => false,
-                 :flags    => "TABLE_NO_KEY",
-               }
-             })
-        def test_key_with_sis?(data)
-          command = parse({"flags" => data[:flags]})
-          assert_equal(data[:expected], command.key_with_sis?)
-        end
+      data({
+             "KEY_WITH_SIS" => {
+               :expected => true,
+               :flags    => "KEY_WITH_SIS|TABLE_PAT_KEY",
+             },
+             "other flag"   => {
+               :expected => false,
+               :flags    => "TABLE_NO_KEY",
+             }
+           })
+      def test_key_with_sis?(data)
+        command = table_create_command({"flags" => data[:flags]})
+        assert_equal(data[:expected], command.key_with_sis?)
       end
     end
   end

data/test/command/test-table-remove.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2012  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2012-2013  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
@@ -17,23 +17,22 @@
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
 class TableRemoveCommandTest < Test::Unit::TestCase
-  class CommandLineTest < self
-    include GroongaCommandTestUtils::CommandLineCommandParser
+  private
+  def table_remove_command(pair_arguments={}, ordered_arguments=[])
+    Groonga::Command::TableRemove.new("table_remove",
+                                      pair_arguments,
+                                      ordered_arguments)
+  end
 
+  class ConstructorTest < self
     def test_ordered_arguments
       name = "Users"
 
-      command = parse(name)
-      assert_instance_of(Groonga::Command::TableRemove, command)
+      command = table_remove_command({}, [name])
       assert_equal({
                      :name => name,
                    },
                    command.arguments)
     end
-
-    private
-    def parse(*arguments)
-      super("table_remove", arguments, :output_type => false)
-    end
   end
 end

data/test/command/test-table-rename.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2012  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2012-2013  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
@@ -17,25 +17,24 @@
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
 class TableRenameCommandTest < Test::Unit::TestCase
-  class CommandLineTest < self
-    include GroongaCommandTestUtils::CommandLineCommandParser
+  private
+  def table_rename_command(pair_arguments={}, ordered_arguments=[])
+    Groonga::Command::TableRename.new("table_rename",
+                                      pair_arguments,
+                                      ordered_arguments)
+  end
 
+  class ConstructorTest < self
     def test_ordered_arguments
       name     = "Users"
       new_name = "People"
 
-      command = parse(name, new_name)
-      assert_instance_of(Groonga::Command::TableRename, command)
+      command = table_rename_command({}, [name, new_name])
       assert_equal({
                      :name     => name,
                      :new_name => new_name,
                    },
                    command.arguments)
     end
-
-    private
-    def parse(*arguments)
-      super("table_rename", arguments, :output_type => false)
-    end
   end
 end

data/test/command/test-truncate.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2012  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2012-2013  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
@@ -17,23 +17,22 @@
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
 class TruncateCommandTest < Test::Unit::TestCase
-  class CommandLineTest < self
-    include GroongaCommandTestUtils::CommandLineCommandParser
+  private
+  def truncate_command(pair_arguments={}, ordered_arguments=[])
+    Groonga::Command::Truncate.new("truncate",
+                                   pair_arguments,
+                                   ordered_arguments)
+  end
 
+  class ConstructorTest < self
     def test_ordered_arguments
       table = "Users"
 
-      command = parse(table)
-      assert_instance_of(Groonga::Command::Truncate, command)
+      command = truncate_command([], [table])
       assert_equal({
                      :table => table,
                    },
                    command.arguments)
     end
-
-    private
-    def parse(*arguments)
-      super("truncate", arguments, :output_type => false)
-    end
   end
 end