[Groonga-commit] droonga/droonga-engine at f161162 [master] Extract tests for reducer from tests for basic plugins

Back to archive index

YUKI Hiroshi null+****@clear*****
Thu Apr 30 16:35:43 JST 2015


YUKI Hiroshi	2015-04-30 16:35:43 +0900 (Thu, 30 Apr 2015)

  New Revision: f1611622c0a2b3570bb5723c0fda519c36d48436
  https://github.com/droonga/droonga-engine/commit/f1611622c0a2b3570bb5723c0fda519c36d48436

  Message:
    Extract tests for reducer from tests for basic plugins

  Copied files:
    test/unit/test_reducer.rb
      (from test/unit/plugins/test_basic.rb)
  Modified files:
    test/unit/plugins/test_basic.rb

  Modified: test/unit/plugins/test_basic.rb (+0 -406)
===================================================================
--- test/unit/plugins/test_basic.rb    2015-04-30 16:23:56 +0900 (57cc1d0)
+++ test/unit/plugins/test_basic.rb    2015-04-30 16:35:43 +0900 (75d75c2)
@@ -24,11 +24,6 @@ class BasicCollectorTest < Test::Unit::TestCase
     teardown_database
   end
 
-  private
-  def create_record(*columns)
-    columns
-  end
-
   def run_collector(collector, message)
     collector_message = Droonga::CollectorMessage.new(message)
     collector.collect(collector_message)
@@ -45,12 +40,6 @@ class BasicCollectorTest < Test::Unit::TestCase
     run_collector(collector, message)
   end
 
-  class << self
-    def create_record(*columns)
-      columns
-    end
-  end
-
   class IOTest < self
     data(
       :simple_mapping => {
@@ -112,399 +101,4 @@ class BasicCollectorTest < Test::Unit::TestCase
                    reduce(request))
     end
   end
-
-  # TODO: Split file
-  class ReducerTest < self
-    def reduce_value(deal, left_value, right_value)
-      reducer = Droonga::Reducer.new(deal)
-      reducer.reduce(left_value, right_value)
-    end
-
-    data(
-      :int => {
-        :expected => 1.5,
-        :left => 1,
-        :right => 2,
-      },
-      :float => {
-        :expected => 1.5,
-        :left => 1.0,
-        :right => 2.0,
-      },
-    )
-    def test_average(data)
-      reduced = reduce_value({ "type" => "average" },
-                             data[:left],
-                             data[:right])
-      assert_equal(data[:expected], reduced)
-    end
-
-    data(
-      :true_and_false => {
-        :expected => false,
-        :left => true,
-        :right => false,
-      },
-      :false_and_true => {
-        :expected => false,
-        :left => false,
-        :right => true,
-      },
-      :both_true => {
-        :expected => true,
-        :left => true,
-        :right => true,
-      },
-      :both_false => {
-        :expected => false,
-        :left => false,
-        :right => false,
-      },
-    )
-    def test_and(data)
-      reduced = reduce_value({ "type" => "and" },
-                             data[:left],
-                             data[:right])
-      assert_equal(data[:expected], reduced)
-    end
-
-    data(
-      :true_and_false => {
-        :expected => true,
-        :left => true,
-        :right => false,
-      },
-      :false_and_true => {
-        :expected => true,
-        :left => false,
-        :right => true,
-      },
-      :both_true => {
-        :expected => true,
-        :left => true,
-        :right => true,
-      },
-      :both_false => {
-        :expected => false,
-        :left => false,
-        :right => false,
-      },
-    )
-    def test_or(data)
-      reduced = reduce_value({ "type" => "or" },
-                             data[:left],
-                             data[:right])
-      assert_equal(data[:expected], reduced)
-    end
-
-    data(
-      :numeric_values => {
-        :expected => 3,
-        :left => 1,
-        :right => 2,
-      },
-      :numeric_key_records => {
-        :expected => [
-          create_record(1),
-          create_record(2),
-          create_record(3),
-          create_record(4),
-          create_record(5),
-          create_record(6),
-        ],
-        :left => [
-          create_record(1),
-          create_record(2),
-          create_record(3),
-        ],
-        :right => [
-          create_record(4),
-          create_record(5),
-          create_record(6),
-        ],
-      },
-      :string_key_records => {
-        :expected => [
-          create_record("a"),
-          create_record("b"),
-          create_record("c"),
-          create_record("d"),
-          create_record("e"),
-          create_record("f"),
-        ],
-        :left => [
-          create_record("a"),
-          create_record("b"),
-          create_record("c"),
-        ],
-        :right => [
-          create_record("d"),
-          create_record("e"),
-          create_record("f"),
-        ],
-      },
-      :numeric_values_with_limit => {
-        :expected => 3,
-        :left => 1,
-        :right => 2,
-        :limit => 2,
-      },
-      :numeric_key_records_with_limit => {
-        :expected => [
-          create_record(1),
-          create_record(2),
-        ],
-        :left => [
-          create_record(1),
-          create_record(2),
-          create_record(3),
-        ],
-        :right => [
-          create_record(4),
-          create_record(5),
-          create_record(6),
-        ],
-        :limit => 2,
-      },
-      :string_key_records_with_limit => {
-        :expected => [
-          create_record("a"),
-          create_record("b"),
-        ],
-        :left => [
-          create_record("a"),
-          create_record("b"),
-          create_record("c"),
-        ],
-        :right => [
-          create_record("d"),
-          create_record("e"),
-          create_record("f"),
-        ],
-        :limit => 2,
-      },
-    )
-    def test_sum(data)
-      reduced = reduce_value({ "type" => "sum",
-                               "limit" => data[:limit] || -1 },
-                             data[:left],
-                             data[:right])
-      assert_equal(data[:expected], reduced)
-    end
-
-    data(
-      :numeric_key_records => {
-        :expected => [
-          create_record(1),
-          create_record(2),
-          create_record(3),
-          create_record(4),
-          create_record(5),
-          create_record(6),
-        ],
-        :left => [
-          create_record(1),
-          create_record(3),
-          create_record(5),
-        ],
-        :right => [
-          create_record(2),
-          create_record(4),
-          create_record(6),
-        ],
-      },
-      :string_key_records => {
-        :expected => [
-          create_record("a"),
-          create_record("b"),
-          create_record("c"),
-          create_record("d"),
-          create_record("e"),
-          create_record("f"),
-        ],
-        :left => [
-          create_record("a"),
-          create_record("c"),
-          create_record("e"),
-        ],
-        :right => [
-          create_record("b"),
-          create_record("d"),
-          create_record("f"),
-        ],
-      },
-      :numeric_key_records_with_limit => {
-        :expected => [
-          create_record(1),
-          create_record(2),
-        ],
-        :left => [
-          create_record(1),
-          create_record(3),
-          create_record(5),
-        ],
-        :right => [
-          create_record(2),
-          create_record(4),
-          create_record(6),
-        ],
-        :limit => 2,
-      },
-      :string_key_records_with_limit => {
-        :expected => [
-          create_record("a"),
-          create_record("b"),
-        ],
-        :left => [
-          create_record("a"),
-          create_record("c"),
-          create_record("e"),
-        ],
-        :right => [
-          create_record("b"),
-          create_record("d"),
-          create_record("f"),
-        ],
-        :limit => 2,
-      },
-    )
-    def test_sort(data)
-      reduced = reduce_value({
-                               "type" => "sort",
-                               "operators" => [
-                                 { "column" => 0, "operator" => "<" },
-                               ],
-                               "limit" => data[:limit] || -1,
-                             },
-                             data[:left],
-                             data[:right])
-      assert_equal(data[:expected], reduced)
-    end
-  end
-
-  # TODO: Split file
-  class MergeTest < self
-    def reduce_value(deal, left_value, right_value)
-      reducer = Droonga::Reducer.new(deal)
-      reducer.reduce(left_value, right_value)
-    end
-
-    def test_grouped
-      expected = [
-        [
-          "group3",
-          30,
-          [
-            create_record("A"),
-            create_record("B"),
-            create_record("C"),
-          ],
-        ],
-        [
-          "group1",
-          40,
-          [
-            create_record(2),
-            create_record(4),
-            create_record(6),
-            create_record(1),
-            create_record(3),
-            create_record(5),
-          ],
-        ],
-        [
-          "group4",
-          50,
-          [
-            create_record("D"),
-            create_record("E"),
-            create_record("F"),
-          ],
-        ],
-        [
-          "group2",
-          60,
-          [
-            create_record("b"),
-            create_record("d"),
-            create_record("f"),
-            create_record("a"),
-            create_record("c"),
-            create_record("e"),
-          ],
-        ],
-      ]
-
-      left = [
-        [
-          "group1",
-          10,
-          [
-            create_record(1),
-            create_record(3),
-            create_record(5),
-          ],
-        ],
-        [
-          "group2",
-          20,
-          [
-            create_record("a"),
-            create_record("c"),
-            create_record("e"),
-          ],
-        ],
-        [
-          "group3",
-          30,
-          [
-            create_record("A"),
-            create_record("B"),
-            create_record("C"),
-          ],
-        ],
-      ]
-      right = [
-        [
-          "group1",
-          30,
-          [
-            create_record(2),
-            create_record(4),
-            create_record(6),
-          ],
-        ],
-        [
-          "group2",
-          40,
-          [
-            create_record("b"),
-            create_record("d"),
-            create_record("f"),
-          ],
-        ],
-        [
-          "group4",
-          50,
-          [
-            create_record("D"),
-            create_record("E"),
-            create_record("F"),
-          ],
-        ],
-      ]
-
-      reduced = reduce_value({
-                               "type" => "sort",
-                               "operators" => [
-                                 { "column" => 1, "operator" => "<" },
-                               ],
-                               "key_column" => 0,
-                               "limit" => -1,
-                             },
-                             left,
-                             right)
-      assert_equal(expected, reduced)
-    end
-  end
 end

  Copied: test/unit/test_reducer.rb (+2 -90) 82%
===================================================================
--- test/unit/plugins/test_basic.rb    2015-04-30 16:23:56 +0900 (57cc1d0)
+++ test/unit/test_reducer.rb    2015-04-30 16:35:43 +0900 (8f6f24c)
@@ -13,107 +13,20 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
-require "droonga/plugins/basic"
-
-class BasicCollectorTest < Test::Unit::TestCase
-  def setup
-    setup_database
-  end
-
-  def teardown
-    teardown_database
-  end
+require "droonga/reducer"
 
+class ReducerTest < Test::Unit::TestCase
   private
   def create_record(*columns)
     columns
   end
 
-  def run_collector(collector, message)
-    collector_message = Droonga::CollectorMessage.new(message)
-    collector.collect(collector_message)
-    collector_message.values
-  end
-
-  def gather(message)
-    collector = Droonga::Plugins::Basic::GatherCollector.new
-    run_collector(collector, message)
-  end
-
-  def reduce(message)
-    collector = Droonga::Plugins::Basic::ReduceCollector.new
-    run_collector(collector, message)
-  end
-
   class << self
     def create_record(*columns)
       columns
     end
   end
 
-  class IOTest < self
-    data(
-      :simple_mapping => {
-        :expected => { "output_name" => "result" },
-        :source => "result",
-        :mapping => "output_name",
-      },
-      :complex_mapping => {
-        :expected => { "output_name" => "result" },
-        :source => "result",
-        :mapping => {
-          "output" => "output_name",
-        },
-      },
-    )
-    def test_gather(data)
-      request = {
-        "task" => {
-          "values" => {},
-          "step" => {
-            "body" => nil,
-            "outputs" => nil,
-          },
-        },
-        "id" => nil,
-        "value" => data[:source],
-        "name" => data[:mapping],
-        "descendants" => nil,
-      }
-      assert_equal(data[:expected], gather(request))
-    end
-
-    def test_reduce
-      input_name = "input_#{Time.now.to_i}"
-      output_name = "output_#{Time.now.to_i}"
-      request = {
-        "task" => {
-          "values" => {
-            output_name => [0, 1, 2],
-          },
-          "step" => {
-            "body" => {
-              input_name => {
-                output_name => {
-                  "type" => "sum",
-                  "limit" => -1,
-                },
-              },
-            },
-            "outputs" => nil,
-          },
-        },
-        "id" => nil,
-        "value" => [3, 4, 5],
-        "name" => input_name,
-        "descendants" => nil,
-      }
-      assert_equal({ output_name => [0, 1, 2, 3, 4, 5] },
-                   reduce(request))
-    end
-  end
-
-  # TODO: Split file
   class ReducerTest < self
     def reduce_value(deal, left_value, right_value)
       reducer = Droonga::Reducer.new(deal)
@@ -382,7 +295,6 @@ class BasicCollectorTest < Test::Unit::TestCase
     end
   end
 
-  # TODO: Split file
   class MergeTest < self
     def reduce_value(deal, left_value, right_value)
       reducer = Droonga::Reducer.new(deal)
-------------- next part --------------
HTML����������������������������...
Download 



More information about the Groonga-commit mailing list
Back to archive index