YUKI Hiroshi
null+****@clear*****
Fri Jan 31 19:24:17 JST 2014
YUKI Hiroshi 2014-01-31 19:24:17 +0900 (Fri, 31 Jan 2014) New Revision: 3270b129efc45fca0b755c358e55fd9f15fb9382 https://github.com/droonga/fluent-plugin-droonga/commit/3270b129efc45fca0b755c358e55fd9f15fb9382 Message: Reduce indent level Modified files: test/unit/plugin/distributor/search_planner/test_group_by.rb test/unit/plugin/distributor/search_planner/test_output.rb test/unit/plugin/distributor/search_planner/test_sort_by.rb Modified: test/unit/plugin/distributor/search_planner/test_group_by.rb (+495 -495) =================================================================== --- test/unit/plugin/distributor/search_planner/test_group_by.rb 2014-01-31 19:20:51 +0900 (97d60df) +++ test/unit/plugin/distributor/search_planner/test_group_by.rb 2014-01-31 19:24:17 +0900 (6620fb6) @@ -16,558 +16,558 @@ class DistributedSearchPlannerGroupByTest < Test::Unit::TestCase include DistributedSearchPlannerHelper - class SimpleTest < self - def setup - @output = { - "elements" => ["records"], - "attributes" => ["_nsubrecs", "_key"], - "limit" => 1, - } - @group_by = "family_name" - @request = { - "type" => "search", - "dataset" => "Droonga", - "body" => { - "queries" => { - "families" => { - "source" => "User", - "groupBy" => @group_by, - "output" => @output, - }, + class SimpleTest < self + def setup + @output = { + "elements" => ["records"], + "attributes" => ["_nsubrecs", "_key"], + "limit" => 1, + } + @group_by = "family_name" + @request = { + "type" => "search", + "dataset" => "Droonga", + "body" => { + "queries" => { + "families" => { + "source" => "User", + "groupBy" => @group_by, + "output" => @output, }, }, - } - end - - def test_dependencies - reduce_inputs = ["errors", "families"] - gather_inputs = ["errors_reduced", "families_reduced"] - assert_equal(expected_dependencies(reduce_inputs, gather_inputs), - dependencies) - end - - def test_broadcast_body - changed_output_parameters = { - "unifiable" => true, - } - assert_equal({ - "queries" => { - "families" => { - "source" => "User", - "groupBy" => @group_by, - "output" => @output.merge(changed_output_parameters), - }, + }, + } + end + + def test_dependencies + reduce_inputs = ["errors", "families"] + gather_inputs = ["errors_reduced", "families_reduced"] + assert_equal(expected_dependencies(reduce_inputs, gather_inputs), + dependencies) + end + + def test_broadcast_body + changed_output_parameters = { + "unifiable" => true, + } + assert_equal({ + "queries" => { + "families" => { + "source" => "User", + "groupBy" => @group_by, + "output" => @output.merge(changed_output_parameters), }, }, - broadcast_message["body"]) - end - - def test_reduce_body - assert_equal({ - "families_reduced" => { - "records" => { - "type" => "sort", - "operators" => [], - "key_column" => 1, - "limit" => 1, - }, + }, + broadcast_message["body"]) + end + + def test_reduce_body + assert_equal({ + "families_reduced" => { + "records" => { + "type" => "sort", + "operators" => [], + "key_column" => 1, + "limit" => 1, }, }, - reduce_message["body"]["families"]) - end - - def test_gather_records - assert_equal({ - "elements" => { - "records" => { - "attributes" => ["_nsubrecs", "_key"], - "limit" => 1, - }, + }, + reduce_message["body"]["families"]) + end + + def test_gather_records + assert_equal({ + "elements" => { + "records" => { + "attributes" => ["_nsubrecs", "_key"], + "limit" => 1, }, - "output" => "families", }, - gather_message["body"]["families_reduced"]) - end + "output" => "families", + }, + gather_message["body"]["families_reduced"]) end - - class WithHashAttributesTest < self - def setup - @output = { - "elements" => ["records"], - "attributes" => { - "family_name" => "_key", - "count" => { "source" => "_nsubrecs" }, - }, - "limit" => 1, - } - @group_by = "family_name" - @request = { - "type" => "search", - "dataset" => "Droonga", - "body" => { - "queries" => { - "families" => { - "source" => "User", - "groupBy" => @group_by, - "output" => @output, - }, + end + + class WithHashAttributesTest < self + def setup + @output = { + "elements" => ["records"], + "attributes" => { + "family_name" => "_key", + "count" => { "source" => "_nsubrecs" }, + }, + "limit" => 1, + } + @group_by = "family_name" + @request = { + "type" => "search", + "dataset" => "Droonga", + "body" => { + "queries" => { + "families" => { + "source" => "User", + "groupBy" => @group_by, + "output" => @output, }, }, - } - end - - def test_dependencies - reduce_inputs = ["errors", "families"] - gather_inputs = ["errors_reduced", "families_reduced"] - assert_equal(expected_dependencies(reduce_inputs, gather_inputs), - dependencies) - end - - def test_broadcast_body - changed_output_parameters = { - "attributes" => [ - { "label" => "family_name", "source" => "_key" }, - { "label" => "count", "source" => "_nsubrecs" }, - ], - "unifiable" => true, - } - assert_equal({ - "queries" => { - "families" => { - "source" => "User", - "groupBy" => @group_by, - "output" => @output.merge(changed_output_parameters), - }, + }, + } + end + + def test_dependencies + reduce_inputs = ["errors", "families"] + gather_inputs = ["errors_reduced", "families_reduced"] + assert_equal(expected_dependencies(reduce_inputs, gather_inputs), + dependencies) + end + + def test_broadcast_body + changed_output_parameters = { + "attributes" => [ + { "label" => "family_name", "source" => "_key" }, + { "label" => "count", "source" => "_nsubrecs" }, + ], + "unifiable" => true, + } + assert_equal({ + "queries" => { + "families" => { + "source" => "User", + "groupBy" => @group_by, + "output" => @output.merge(changed_output_parameters), }, }, - broadcast_message["body"]) - end - - def test_reduce_body - assert_equal({ - "families_reduced" => { - "records" => { - "type" => "sort", - "operators" => [], - "key_column" => 0, - "limit" => 1, - }, + }, + broadcast_message["body"]) + end + + def test_reduce_body + assert_equal({ + "families_reduced" => { + "records" => { + "type" => "sort", + "operators" => [], + "key_column" => 0, + "limit" => 1, }, }, - reduce_message["body"]["families"]) - end - - def test_gather_records - assert_equal({ - "elements" => { - "records" => { - "attributes" => ["family_name", "count"], - "limit" => 1, - }, + }, + reduce_message["body"]["families"]) + end + + def test_gather_records + assert_equal({ + "elements" => { + "records" => { + "attributes" => ["family_name", "count"], + "limit" => 1, }, - "output" => "families", }, - gather_message["body"]["families_reduced"]) - end + "output" => "families", + }, + gather_message["body"]["families_reduced"]) end - - class WithHashAttributesMissingKeyTest < self - def setup - @output = { - "elements" => ["records"], - "attributes" => { - "count" => { "source" => "_nsubrecs" }, - }, - "limit" => 1, - } - @group_by = "family_name" - @request = { - "type" => "search", - "dataset" => "Droonga", - "body" => { - "queries" => { - "families" => { - "source" => "User", - "groupBy" => @group_by, - "output" => @output, - }, + end + + class WithHashAttributesMissingKeyTest < self + def setup + @output = { + "elements" => ["records"], + "attributes" => { + "count" => { "source" => "_nsubrecs" }, + }, + "limit" => 1, + } + @group_by = "family_name" + @request = { + "type" => "search", + "dataset" => "Droonga", + "body" => { + "queries" => { + "families" => { + "source" => "User", + "groupBy" => @group_by, + "output" => @output, }, }, - } - end - - def test_dependencies - reduce_inputs = ["errors", "families"] - gather_inputs = ["errors_reduced", "families_reduced"] - assert_equal(expected_dependencies(reduce_inputs, gather_inputs), - dependencies) - end - - def test_broadcast_body - changed_output_parameters = { - "attributes" => [ - { "label" => "count", "source" => "_nsubrecs" }, - "_key", - ], - "unifiable" => true, - } - assert_equal({ - "queries" => { - "families" => { - "source" => "User", - "groupBy" => @group_by, - "output" => @output.merge(changed_output_parameters), - }, + }, + } + end + + def test_dependencies + reduce_inputs = ["errors", "families"] + gather_inputs = ["errors_reduced", "families_reduced"] + assert_equal(expected_dependencies(reduce_inputs, gather_inputs), + dependencies) + end + + def test_broadcast_body + changed_output_parameters = { + "attributes" => [ + { "label" => "count", "source" => "_nsubrecs" }, + "_key", + ], + "unifiable" => true, + } + assert_equal({ + "queries" => { + "families" => { + "source" => "User", + "groupBy" => @group_by, + "output" => @output.merge(changed_output_parameters), }, }, - broadcast_message["body"]) - end - - def test_reduce_body - assert_equal({ - "families_reduced" => { - "records" => { - "type" => "sort", - "operators" => [], - "key_column" => 1, - "limit" => 1, - }, + }, + broadcast_message["body"]) + end + + def test_reduce_body + assert_equal({ + "families_reduced" => { + "records" => { + "type" => "sort", + "operators" => [], + "key_column" => 1, + "limit" => 1, }, }, - reduce_message["body"]["families"]) - end - - def test_gather_records - assert_equal({ - "elements" => { - "records" => { - "attributes" => ["count"], - "limit" => 1, - }, + }, + reduce_message["body"]["families"]) + end + + def test_gather_records + assert_equal({ + "elements" => { + "records" => { + "attributes" => ["count"], + "limit" => 1, }, - "output" => "families", }, - gather_message["body"]["families_reduced"]) - end - end - - class WithComplexAttributesArrayTest < self - def setup - @output = { - "elements" => ["records"], - "attributes" => [ - { "label" => "family_name", "source" => "_key" }, - { "label" => "count", "source" => "_nsubrecs" }, - ], - "limit" => 1, - } - @group_by = "family_name" - @request = { - "type" => "search", - "dataset" => "Droonga", - "body" => { - "queries" => { - "families" => { - "source" => "User", - "groupBy" => @group_by, - "output" => @output, - }, + "output" => "families", + }, + gather_message["body"]["families_reduced"]) + end + end + + class WithComplexAttributesArrayTest < self + def setup + @output = { + "elements" => ["records"], + "attributes" => [ + { "label" => "family_name", "source" => "_key" }, + { "label" => "count", "source" => "_nsubrecs" }, + ], + "limit" => 1, + } + @group_by = "family_name" + @request = { + "type" => "search", + "dataset" => "Droonga", + "body" => { + "queries" => { + "families" => { + "source" => "User", + "groupBy" => @group_by, + "output" => @output, }, }, - } - end - - def test_dependencies - reduce_inputs = ["errors", "families"] - gather_inputs = ["errors_reduced", "families_reduced"] - assert_equal(expected_dependencies(reduce_inputs, gather_inputs), - dependencies) - end - - def test_broadcast_body - changed_output_parameters = { - "unifiable" => true, - } - assert_equal({ - "queries" => { - "families" => { - "source" => "User", - "groupBy" => @group_by, - "output" => @output.merge(changed_output_parameters), - }, + }, + } + end + + def test_dependencies + reduce_inputs = ["errors", "families"] + gather_inputs = ["errors_reduced", "families_reduced"] + assert_equal(expected_dependencies(reduce_inputs, gather_inputs), + dependencies) + end + + def test_broadcast_body + changed_output_parameters = { + "unifiable" => true, + } + assert_equal({ + "queries" => { + "families" => { + "source" => "User", + "groupBy" => @group_by, + "output" => @output.merge(changed_output_parameters), }, }, - broadcast_message["body"]) - end - - def test_reduce_body - assert_equal({ - "families_reduced" => { - "records" => { - "type" => "sort", - "operators" => [], - "key_column" => 0, - "limit" => 1, - }, + }, + broadcast_message["body"]) + end + + def test_reduce_body + assert_equal({ + "families_reduced" => { + "records" => { + "type" => "sort", + "operators" => [], + "key_column" => 0, + "limit" => 1, }, }, - reduce_message["body"]["families"]) - end - - def test_gather_records - assert_equal({ - "elements" => { - "records" => { - "attributes" => ["family_name", "count"], - "limit" => 1, - }, + }, + reduce_message["body"]["families"]) + end + + def test_gather_records + assert_equal({ + "elements" => { + "records" => { + "attributes" => ["family_name", "count"], + "limit" => 1, }, - "output" => "families", }, - gather_message["body"]["families_reduced"]) - end - end - - class WithComplexAttributesArrayMissingKeyTest < self - def setup - @output = { - "elements" => ["records"], - "attributes" => [ - { "label" => "count", "source" => "_nsubrecs" }, - ], - "limit" => 1, - } - @group_by = "family_name" - @request = { - "type" => "search", - "dataset" => "Droonga", - "body" => { - "queries" => { - "families" => { - "source" => "User", - "groupBy" => @group_by, - "output" => @output, - }, + "output" => "families", + }, + gather_message["body"]["families_reduced"]) + end + end + + class WithComplexAttributesArrayMissingKeyTest < self + def setup + @output = { + "elements" => ["records"], + "attributes" => [ + { "label" => "count", "source" => "_nsubrecs" }, + ], + "limit" => 1, + } + @group_by = "family_name" + @request = { + "type" => "search", + "dataset" => "Droonga", + "body" => { + "queries" => { + "families" => { + "source" => "User", + "groupBy" => @group_by, + "output" => @output, }, }, - } - end - - def test_dependencies - reduce_inputs = ["errors", "families"] - gather_inputs = ["errors_reduced", "families_reduced"] - assert_equal(expected_dependencies(reduce_inputs, gather_inputs), - dependencies) - end - - def test_broadcast_body - changed_output_parameters = { - "attributes" => [ - { "label" => "count", "source" => "_nsubrecs" }, - "_key", - ], - "unifiable" => true, - } - assert_equal({ - "queries" => { - "families" => { - "source" => "User", - "groupBy" => @group_by, - "output" => @output.merge(changed_output_parameters), - }, + }, + } + end + + def test_dependencies + reduce_inputs = ["errors", "families"] + gather_inputs = ["errors_reduced", "families_reduced"] + assert_equal(expected_dependencies(reduce_inputs, gather_inputs), + dependencies) + end + + def test_broadcast_body + changed_output_parameters = { + "attributes" => [ + { "label" => "count", "source" => "_nsubrecs" }, + "_key", + ], + "unifiable" => true, + } + assert_equal({ + "queries" => { + "families" => { + "source" => "User", + "groupBy" => @group_by, + "output" => @output.merge(changed_output_parameters), }, }, - broadcast_message["body"]) - end - - def test_reduce_body - assert_equal({ - "families_reduced" => { - "records" => { - "type" => "sort", - "operators" => [], - "key_column" => 1, - "limit" => 1, - }, + }, + broadcast_message["body"]) + end + + def test_reduce_body + assert_equal({ + "families_reduced" => { + "records" => { + "type" => "sort", + "operators" => [], + "key_column" => 1, + "limit" => 1, }, }, - reduce_message["body"]["families"]) - end - - def test_gather_records - assert_equal({ - "elements" => { - "records" => { - "attributes" => ["count"], - "limit" => 1, - }, + }, + reduce_message["body"]["families"]) + end + + def test_gather_records + assert_equal({ + "elements" => { + "records" => { + "attributes" => ["count"], + "limit" => 1, }, - "output" => "families", }, - gather_message["body"]["families_reduced"]) - end - end - - class SubRecodsTest < self - def setup - @output = { - "elements" => ["records"], - "attributes" => [ - "_key", - "_nsubrecs", - { "label" => "users", - "source" => "_subrecs", - "attributes" => ["_key"] }, - ], - "limit" => 1, - } - @group_by = { - "key" => "family_name", - "maxNSubRecords" => 3, - } - @request = { - "type" => "search", - "dataset" => "Droonga", - "body" => { - "queries" => { - "families" => { - "source" => "User", - "groupBy" => @group_by, - "output" => @output, - }, + "output" => "families", + }, + gather_message["body"]["families_reduced"]) + end + end + + class SubRecodsTest < self + def setup + @output = { + "elements" => ["records"], + "attributes" => [ + "_key", + "_nsubrecs", + { "label" => "users", + "source" => "_subrecs", + "attributes" => ["_key"] }, + ], + "limit" => 1, + } + @group_by = { + "key" => "family_name", + "maxNSubRecords" => 3, + } + @request = { + "type" => "search", + "dataset" => "Droonga", + "body" => { + "queries" => { + "families" => { + "source" => "User", + "groupBy" => @group_by, + "output" => @output, }, }, - } - end - - def test_dependencies - reduce_inputs = ["errors", "families"] - gather_inputs = ["errors_reduced", "families_reduced"] - assert_equal(expected_dependencies(reduce_inputs, gather_inputs), - dependencies) - end - - def test_broadcast_body - changed_output_parameters = { - "unifiable" => true, - } - assert_equal({ - "queries" => { - "families" => { - "source" => "User", - "groupBy" => @group_by, - "output" => @output.merge(changed_output_parameters), - }, + }, + } + end + + def test_dependencies + reduce_inputs = ["errors", "families"] + gather_inputs = ["errors_reduced", "families_reduced"] + assert_equal(expected_dependencies(reduce_inputs, gather_inputs), + dependencies) + end + + def test_broadcast_body + changed_output_parameters = { + "unifiable" => true, + } + assert_equal({ + "queries" => { + "families" => { + "source" => "User", + "groupBy" => @group_by, + "output" => @output.merge(changed_output_parameters), }, }, - broadcast_message["body"]) - end - - def test_reduce_body - assert_equal({ - "families_reduced" => { - "records" => { - "type" => "sort", - "operators" => [], - "key_column" => 0, - "limit" => 1, - }, + }, + broadcast_message["body"]) + end + + def test_reduce_body + assert_equal({ + "families_reduced" => { + "records" => { + "type" => "sort", + "operators" => [], + "key_column" => 0, + "limit" => 1, }, }, - reduce_message["body"]["families"]) - end - - def test_gather_records - assert_equal({ - "elements" => { - "records" => { - "attributes" => ["_key", "_nsubrecs", "users"], - "limit" => 1, - }, + }, + reduce_message["body"]["families"]) + end + + def test_gather_records + assert_equal({ + "elements" => { + "records" => { + "attributes" => ["_key", "_nsubrecs", "users"], + "limit" => 1, }, - "output" => "families", }, - gather_message["body"]["families_reduced"]) - end - end - - class CountOnlyTest < self - def setup - @output = { - "elements" => ["count"], - } - @group_by = "family_name" - @request = { - "type" => "search", - "dataset" => "Droonga", - "body" => { - "queries" => { - "families" => { - "source" => "User", - "groupBy" => @group_by, - "output" => @output, - }, + "output" => "families", + }, + gather_message["body"]["families_reduced"]) + end + end + + class CountOnlyTest < self + def setup + @output = { + "elements" => ["count"], + } + @group_by = "family_name" + @request = { + "type" => "search", + "dataset" => "Droonga", + "body" => { + "queries" => { + "families" => { + "source" => "User", + "groupBy" => @group_by, + "output" => @output, }, }, - } - end - - def test_dependencies - reduce_inputs = ["errors", "families"] - gather_inputs = ["errors_reduced", "families_reduced"] - assert_equal(expected_dependencies(reduce_inputs, gather_inputs), - dependencies) - end - - def test_broadcast_body - changed_output_parameters = { - "elements" => ["count", "records"], - "attributes" => ["_key"], - "limit" => -1, - "unifiable" => true, - } - assert_equal({ - "queries" => { - "families" => { - "source" => "User", - "groupBy" => @group_by, - "output" => @output.merge(changed_output_parameters), - }, + }, + } + end + + def test_dependencies + reduce_inputs = ["errors", "families"] + gather_inputs = ["errors_reduced", "families_reduced"] + assert_equal(expected_dependencies(reduce_inputs, gather_inputs), + dependencies) + end + + def test_broadcast_body + changed_output_parameters = { + "elements" => ["count", "records"], + "attributes" => ["_key"], + "limit" => -1, + "unifiable" => true, + } + assert_equal({ + "queries" => { + "families" => { + "source" => "User", + "groupBy" => @group_by, + "output" => @output.merge(changed_output_parameters), }, }, - broadcast_message["body"]) - end - - def test_reduce_body - assert_equal({ - "families_reduced" => { - "count" => { - "type" => "sum", - }, - "records" => { - "type" => "sort", - "operators" => [], - "key_column" => 0, - "limit" => -1, - }, + }, + broadcast_message["body"]) + end + + def test_reduce_body + assert_equal({ + "families_reduced" => { + "count" => { + "type" => "sum", + }, + "records" => { + "type" => "sort", + "operators" => [], + "key_column" => 0, + "limit" => -1, }, }, - reduce_message["body"]["families"]) - end - - def test_gather_records - assert_equal({ - "elements" => { - "count" => { - "target" => "records", - }, - "records" => { - "no_output" => true, - }, + }, + reduce_message["body"]["families"]) + end + + def test_gather_records + assert_equal({ + "elements" => { + "count" => { + "target" => "records", + }, + "records" => { + "no_output" => true, }, - "output" => "families", }, - gather_message["body"]["families_reduced"]) - end + "output" => "families", + }, + gather_message["body"]["families_reduced"]) end + end end Modified: test/unit/plugin/distributor/search_planner/test_output.rb (+240 -240) =================================================================== --- test/unit/plugin/distributor/search_planner/test_output.rb 2014-01-31 19:20:51 +0900 (db1a3d9) +++ test/unit/plugin/distributor/search_planner/test_output.rb 2014-01-31 19:24:17 +0900 (811ed05) @@ -16,41 +16,102 @@ class DistributedSearchPlannerOutputTest < Test::Unit::TestCase include DistributedSearchPlannerHelper - class NoOutputTest < self - def setup - @request = { - "type" => "search", - "dataset" => "Droonga", - "body" => { - "queries" => { - "users" => { - "source" => "User", + class NoOutputTest < self + def setup + @request = { + "type" => "search", + "dataset" => "Droonga", + "body" => { + "queries" => { + "users" => { + "source" => "User", + }, + }, + }, + } + end + + def test_dependencies + reduce_inputs = ["errors"] + gather_inputs = ["errors_reduced"] + assert_equal(expected_dependencies(reduce_inputs, gather_inputs), + dependencies) + end + + def test_broadcast_body + assert_equal({ + "queries" => { + "users" => { + "source" => "User", + }, + }, + }, + broadcast_message["body"]) + end + end + + class NoLimitTest < self + def setup + @request = { + "type" => "search", + "dataset" => "Droonga", + "body" => { + "queries" => { + "users" => { + "source" => "User", + "output" => { + "format" => "complex", + "elements" => ["count", "records"], }, }, }, - } - end + }, + } + end - def test_dependencies - reduce_inputs = ["errors"] - gather_inputs = ["errors_reduced"] - assert_equal(expected_dependencies(reduce_inputs, gather_inputs), - dependencies) - end + def test_dependencies + reduce_inputs = ["errors", "users"] + gather_inputs = ["errors_reduced", "users_reduced"] + assert_equal(expected_dependencies(reduce_inputs, gather_inputs), + dependencies) + end - def test_broadcast_body - assert_equal({ - "queries" => { - "users" => { - "source" => "User", + def test_broadcast_body + assert_equal({ + "queries" => { + "users" => { + "source" => "User", + "output" => { + "format" => "simple", + "elements" => ["count", "records"], }, }, }, - broadcast_message["body"]) - end + }, + broadcast_message["body"]) end - class NoLimitTest < self + def test_reduce_body + assert_equal({ + "users_reduced" => { + "count" => { + "type" => "sum", + }, + }, + }, + reduce_message["body"]["users"]) + end + + def test_gather_body + assert_equal({ + "output" => "users", + }, + gather_message["body"]["users_reduced"]) + end + end + + class ElementsTest < self + class CountTest < self def setup @request = { "type" => "search", @@ -60,8 +121,7 @@ class DistributedSearchPlannerOutputTest < Test::Unit::TestCase "users" => { "source" => "User", "output" => { - "format" => "complex", - "elements" => ["count", "records"], + "elements" => ["count"], }, }, }, @@ -80,11 +140,10 @@ class DistributedSearchPlannerOutputTest < Test::Unit::TestCase assert_equal({ "queries" => { "users" => { - "source" => "User", "output" => { - "format" => "simple", - "elements" => ["count", "records"], + "elements" => ["count"], }, + "source" => "User", }, }, }, @@ -110,145 +169,8 @@ class DistributedSearchPlannerOutputTest < Test::Unit::TestCase end end - class ElementsTest < self - class CountTest < self - def setup - @request = { - "type" => "search", - "dataset" => "Droonga", - "body" => { - "queries" => { - "users" => { - "source" => "User", - "output" => { - "elements" => ["count"], - }, - }, - }, - }, - } - end - - def test_dependencies - reduce_inputs = ["errors", "users"] - gather_inputs = ["errors_reduced", "users_reduced"] - assert_equal(expected_dependencies(reduce_inputs, gather_inputs), - dependencies) - end - - def test_broadcast_body - assert_equal({ - "queries" => { - "users" => { - "output" => { - "elements" => ["count"], - }, - "source" => "User", - }, - }, - }, - broadcast_message["body"]) - end - - def test_reduce_body - assert_equal({ - "users_reduced" => { - "count" => { - "type" => "sum", - }, - }, - }, - reduce_message["body"]["users"]) - end - - def test_gather_body - assert_equal({ - "output" => "users", - }, - gather_message["body"]["users_reduced"]) - end - end - - class RecordsTest < self - def setup - @request = { - "type" => "search", - "dataset" => "Droonga", - "body" => { - "queries" => { - "users" => { - "source" => "User", - "output" => { - "elements" => ["records"], - "attributes" => ["_key"], - "limit" => 1, - }, - }, - }, - }, - } - end - - def test_dependencies - reduce_inputs = ["errors", "users"] - gather_inputs = ["errors_reduced", "users_reduced"] - assert_equal(expected_dependencies(reduce_inputs, gather_inputs), - dependencies) - end - - def test_broadcast_body - assert_equal({ - "queries" => { - "users" => { - "output" => { - "elements" => ["records"], - "attributes" => ["_key"], - "limit" => 1, - }, - "source" => "User", - }, - }, - }, - broadcast_message["body"]) - end - - def test_reduce_body - assert_equal({ - "users_reduced" => { - "records" => { - "type" => "sort", - "operators" => [], - "limit" => 1, - }, - }, - }, - reduce_message["body"]["users"]) - end - - def test_gather_body - assert_equal({ - "elements" => { - "records" => { - "attributes" => ["_key"], - "limit" => 1, - }, - }, - "output" => "users", - }, - gather_message["body"]["users_reduced"]) - end - end - end - - class FormatTest < self + class RecordsTest < self def setup - @output = { - "format" => "complex", - "elements" => ["records"], - "attributes" => ["_id"], - "offset" => 0, - "limit" => 10, - } @request = { "type" => "search", "dataset" => "Droonga", @@ -256,7 +178,11 @@ class DistributedSearchPlannerOutputTest < Test::Unit::TestCase "queries" => { "users" => { "source" => "User", - "output" => @output, + "output" => { + "elements" => ["records"], + "attributes" => ["_key"], + "limit" => 1, + }, }, }, }, @@ -271,14 +197,15 @@ class DistributedSearchPlannerOutputTest < Test::Unit::TestCase end def test_broadcast_body - changed_output_parameters = { - "format" => "simple", - } assert_equal({ "queries" => { "users" => { + "output" => { + "elements" => ["records"], + "attributes" => ["_key"], + "limit" => 1, + }, "source" => "User", - "output" => @output.merge(changed_output_parameters), }, }, }, @@ -291,98 +218,171 @@ class DistributedSearchPlannerOutputTest < Test::Unit::TestCase "records" => { "type" => "sort", "operators" => [], - "limit" => 10, + "limit" => 1, }, }, }, reduce_message["body"]["users"]) end - def test_gather_records + def test_gather_body assert_equal({ - "elements" => { - "records" => { - "format" => "complex", - "attributes" => ["_id"], - "limit" => 10, - }, + "elements" => { + "records" => { + "attributes" => ["_key"], + "limit" => 1, }, + }, "output" => "users", }, gather_message["body"]["users_reduced"]) end end + end - class OffsetTest < self - def setup - @output = { - "elements" => ["records"], - "attributes" => ["_key"], - "offset" => 1, - "limit" => 1, - } - @request = { - "type" => "search", - "dataset" => "Droonga", - "body" => { - "queries" => { - "users" => { - "source" => "User", - "output" => @output, - }, + class FormatTest < self + def setup + @output = { + "format" => "complex", + "elements" => ["records"], + "attributes" => ["_id"], + "offset" => 0, + "limit" => 10, + } + @request = { + "type" => "search", + "dataset" => "Droonga", + "body" => { + "queries" => { + "users" => { + "source" => "User", + "output" => @output, }, }, - } - end + }, + } + end - def test_dependencies - reduce_inputs = ["errors", "users"] - gather_inputs = ["errors_reduced", "users_reduced"] - assert_equal(expected_dependencies(reduce_inputs, gather_inputs), - dependencies) - end + def test_dependencies + reduce_inputs = ["errors", "users"] + gather_inputs = ["errors_reduced", "users_reduced"] + assert_equal(expected_dependencies(reduce_inputs, gather_inputs), + dependencies) + end - def test_broadcast_body - changed_output_parameters = { - "offset" => 0, - "limit" => 2, - } - assert_equal({ - "queries" => { - "users" => { - "source" => "User", - "output" => @output.merge(changed_output_parameters), - }, + def test_broadcast_body + changed_output_parameters = { + "format" => "simple", + } + assert_equal({ + "queries" => { + "users" => { + "source" => "User", + "output" => @output.merge(changed_output_parameters), }, }, - broadcast_message["body"]) - end + }, + broadcast_message["body"]) + end - def test_reduce_body - assert_equal({ - "users_reduced" => { - "records" => { - "type" => "sort", - "operators" => [], - "limit" => 2, - }, + def test_reduce_body + assert_equal({ + "users_reduced" => { + "records" => { + "type" => "sort", + "operators" => [], + "limit" => 10, }, }, - reduce_message["body"]["users"]) - end + }, + reduce_message["body"]["users"]) + end - def test_gather_records - assert_equal({ - "elements" => { - "records" => { - "attributes" => ["_key"], - "offset" => 1, - "limit" => 1, - }, + def test_gather_records + assert_equal({ + "elements" => { + "records" => { + "format" => "complex", + "attributes" => ["_id"], + "limit" => 10, }, - "output" => "users", }, - gather_message["body"]["users_reduced"]) - end + "output" => "users", + }, + gather_message["body"]["users_reduced"]) + end + end + + class OffsetTest < self + def setup + @output = { + "elements" => ["records"], + "attributes" => ["_key"], + "offset" => 1, + "limit" => 1, + } + @request = { + "type" => "search", + "dataset" => "Droonga", + "body" => { + "queries" => { + "users" => { + "source" => "User", + "output" => @output, + }, + }, + }, + } + end + + def test_dependencies + reduce_inputs = ["errors", "users"] + gather_inputs = ["errors_reduced", "users_reduced"] + assert_equal(expected_dependencies(reduce_inputs, gather_inputs), + dependencies) + end + + def test_broadcast_body + changed_output_parameters = { + "offset" => 0, + "limit" => 2, + } + assert_equal({ + "queries" => { + "users" => { + "source" => "User", + "output" => @output.merge(changed_output_parameters), + }, + }, + }, + broadcast_message["body"]) + end + + def test_reduce_body + assert_equal({ + "users_reduced" => { + "records" => { + "type" => "sort", + "operators" => [], + "limit" => 2, + }, + }, + }, + reduce_message["body"]["users"]) + end + + def test_gather_records + assert_equal({ + "elements" => { + "records" => { + "attributes" => ["_key"], + "offset" => 1, + "limit" => 1, + }, + }, + "output" => "users", + }, + gather_message["body"]["users_reduced"]) end + end end Modified: test/unit/plugin/distributor/search_planner/test_sort_by.rb (+589 -589) =================================================================== --- test/unit/plugin/distributor/search_planner/test_sort_by.rb 2014-01-31 19:20:51 +0900 (29a2cce) +++ test/unit/plugin/distributor/search_planner/test_sort_by.rb 2014-01-31 19:24:17 +0900 (b542032) @@ -16,238 +16,593 @@ class DistributedSearchPlannerSortByTest < Test::Unit::TestCase include DistributedSearchPlannerHelper - class SimpleTest < self - def setup - @output = { - "elements" => ["records"], - "attributes" => ["_key"], - "limit" => 1, - } - @request = { - "type" => "search", - "dataset" => "Droonga", - "body" => { - "queries" => { - "users" => { - "source" => "User", - "sortBy" => ["_key"], - "output" => @output, - }, + class SimpleTest < self + def setup + @output = { + "elements" => ["records"], + "attributes" => ["_key"], + "limit" => 1, + } + @request = { + "type" => "search", + "dataset" => "Droonga", + "body" => { + "queries" => { + "users" => { + "source" => "User", + "sortBy" => ["_key"], + "output" => @output, }, }, - } - end + }, + } + end - def test_dependencies - reduce_inputs = ["errors", "users"] - gather_inputs = ["errors_reduced", "users_reduced"] - assert_equal(expected_dependencies(reduce_inputs, gather_inputs), - dependencies) - end + def test_dependencies + reduce_inputs = ["errors", "users"] + gather_inputs = ["errors_reduced", "users_reduced"] + assert_equal(expected_dependencies(reduce_inputs, gather_inputs), + dependencies) + end - def test_broadcast_body - assert_equal({ - "queries" => { - "users" => { - "source" => "User", - "sortBy" => ["_key"], - "output" => @output, - }, + def test_broadcast_body + assert_equal({ + "queries" => { + "users" => { + "source" => "User", + "sortBy" => ["_key"], + "output" => @output, }, }, - broadcast_message["body"]) - end + }, + broadcast_message["body"]) + end - def test_reduce_body - assert_equal({ - "users_reduced" => { - "records" => { - "type" => "sort", - "operators" => [ - { "column" => 0, "operator" => "<" }, - ], - "limit" => 1, - }, + def test_reduce_body + assert_equal({ + "users_reduced" => { + "records" => { + "type" => "sort", + "operators" => [ + { "column" => 0, "operator" => "<" }, + ], + "limit" => 1, }, }, - reduce_message["body"]["users"]) - end + }, + reduce_message["body"]["users"]) + end - def test_gather_records - assert_equal({ - "elements" => { - "records" => { - "attributes" => ["_key"], - "limit" => 1, - }, + def test_gather_records + assert_equal({ + "elements" => { + "records" => { + "attributes" => ["_key"], + "limit" => 1, }, - "output" => "users", }, - gather_message["body"]["users_reduced"]) - end + "output" => "users", + }, + gather_message["body"]["users_reduced"]) + end + end + + class SimpleHiddenColumnTest < self + def setup + @output = { + "elements" => ["records"], + "attributes" => ["_key"], + "limit" => 1, + } + @request = { + "type" => "search", + "dataset" => "Droonga", + "body" => { + "queries" => { + "users" => { + "source" => "User", + "sortBy" => ["name"], + "output" => @output, + }, + }, + }, + } end - class SimpleHiddenColumnTest < self - def setup - @output = { - "elements" => ["records"], - "attributes" => ["_key"], - "limit" => 1, - } - @request = { - "type" => "search", - "dataset" => "Droonga", - "body" => { - "queries" => { - "users" => { - "source" => "User", - "sortBy" => ["name"], - "output" => @output, - }, + def test_dependencies + reduce_inputs = ["errors", "users"] + gather_inputs = ["errors_reduced", "users_reduced"] + assert_equal(expected_dependencies(reduce_inputs, gather_inputs), + dependencies) + end + + def test_broadcast_body + changed_output_parameters = { + "attributes" => ["_key", "name"], + } + assert_equal({ + "queries" => { + "users" => { + "source" => "User", + "sortBy" => ["name"], + "output" => @output.merge(changed_output_parameters), + }, + }, + }, + broadcast_message["body"]) + end + + def test_reduce_body + assert_equal({ + "users_reduced" => { + "records" => { + "type" => "sort", + "operators" => [ + { "column" => 1, "operator" => "<" }, + ], + "limit" => 1, + }, + }, + }, + reduce_message["body"]["users"]) + end + + def test_gather_records + assert_equal({ + "elements" => { + "records" => { + "attributes" => ["_key"], + "limit" => 1, + }, + }, + "output" => "users", + }, + gather_message["body"]["users_reduced"]) + end + end + + class ComplexTest < self + def setup + @output = { + "elements" => ["records"], + "attributes" => ["_key"], + "limit" => 1, + } + @sort_by = { + "keys" => ["_key"], + } + @request = { + "type" => "search", + "dataset" => "Droonga", + "body" => { + "queries" => { + "users" => { + "source" => "User", + "sortBy" => @sort_by, + "output" => @output, }, }, - } - end + }, + } + end - def test_dependencies - reduce_inputs = ["errors", "users"] - gather_inputs = ["errors_reduced", "users_reduced"] - assert_equal(expected_dependencies(reduce_inputs, gather_inputs), - dependencies) - end + def test_dependencies + reduce_inputs = ["errors", "users"] + gather_inputs = ["errors_reduced", "users_reduced"] + assert_equal(expected_dependencies(reduce_inputs, gather_inputs), + dependencies) + end - def test_broadcast_body - changed_output_parameters = { - "attributes" => ["_key", "name"], - } - assert_equal({ - "queries" => { - "users" => { - "source" => "User", - "sortBy" => ["name"], - "output" => @output.merge(changed_output_parameters), - }, + def test_broadcast_body + changed_sort_by_parameters = { + "offset" => 0, + "limit" => 1, + } + assert_equal({ + "queries" => { + "users" => { + "source" => "User", + "sortBy" => @sort_by.merge(changed_sort_by_parameters), + "output" => @output, }, }, - broadcast_message["body"]) - end + }, + broadcast_message["body"]) + end - def test_reduce_body - assert_equal({ - "users_reduced" => { - "records" => { - "type" => "sort", - "operators" => [ - { "column" => 1, "operator" => "<" }, - ], - "limit" => 1, - }, + def test_reduce_body + assert_equal({ + "users_reduced" => { + "records" => { + "type" => "sort", + "operators" => [ + { "column" => 0, "operator" => "<" }, + ], + "limit" => 1, }, }, - reduce_message["body"]["users"]) - end + }, + reduce_message["body"]["users"]) + end - def test_gather_records - assert_equal({ - "elements" => { - "records" => { - "attributes" => ["_key"], - "limit" => 1, - }, + def test_gather_records + assert_equal({ + "elements" => { + "records" => { + "attributes" => ["_key"], + "limit" => 1, }, - "output" => "users", }, - gather_message["body"]["users_reduced"]) - end + "output" => "users", + }, + gather_message["body"]["users_reduced"]) + end + end + + class ComplexHiddenColumnTest < self + def setup + @output = { + "elements" => ["records"], + "attributes" => ["_key"], + "limit" => 1, + } + @sort_by = { + "keys" => ["name"], + } + @request = { + "type" => "search", + "dataset" => "Droonga", + "body" => { + "queries" => { + "users" => { + "source" => "User", + "sortBy" => @sort_by, + "output" => @output, + }, + }, + }, + } end - class ComplexTest < self - def setup - @output = { - "elements" => ["records"], - "attributes" => ["_key"], - "limit" => 1, - } - @sort_by = { - "keys" => ["_key"], - } - @request = { - "type" => "search", - "dataset" => "Droonga", - "body" => { - "queries" => { - "users" => { - "source" => "User", - "sortBy" => @sort_by, - "output" => @output, - }, + def test_dependencies + reduce_inputs = ["errors", "users"] + gather_inputs = ["errors_reduced", "users_reduced"] + assert_equal(expected_dependencies(reduce_inputs, gather_inputs), + dependencies) + end + + def test_broadcast_body + changed_sort_by_parameters = { + "offset" => 0, + "limit" => 1, + } + changed_output_parameters = { + "attributes" => ["_key", "name"], + } + assert_equal({ + "queries" => { + "users" => { + "source" => "User", + "sortBy" => @sort_by.merge(changed_sort_by_parameters), + "output" => @output.merge(changed_output_parameters), + }, + }, + }, + broadcast_message["body"]) + end + + def test_reduce_body + assert_equal({ + "users_reduced" => { + "records" => { + "type" => "sort", + "operators" => [ + { "column" => 1, "operator" => "<" }, + ], + "limit" => 1, + }, + }, + }, + reduce_message["body"]["users"]) + end + + def test_gather_records + assert_equal({ + "elements" => { + "records" => { + "attributes" => ["_key"], + "limit" => 1, + }, + }, + "output" => "users", + }, + gather_message["body"]["users_reduced"]) + end + end + + class WithHashAttributesTest < self + def setup + @output = { + "elements" => ["records"], + "attributes" => { + "id" => "_key", + "name" => { "source" => "name" }, + }, + "limit" => 1, + } + @sort_by = { + "keys" => ["hidden"], + } + @request = { + "type" => "search", + "dataset" => "Droonga", + "body" => { + "queries" => { + "users" => { + "source" => "User", + "sortBy" => @sort_by, + "output" => @output, }, }, - } - end + }, + } + end - def test_dependencies - reduce_inputs = ["errors", "users"] - gather_inputs = ["errors_reduced", "users_reduced"] - assert_equal(expected_dependencies(reduce_inputs, gather_inputs), - dependencies) - end + def test_dependencies + reduce_inputs = ["errors", "users"] + gather_inputs = ["errors_reduced", "users_reduced"] + assert_equal(expected_dependencies(reduce_inputs, gather_inputs), + dependencies) + end - def test_broadcast_body - changed_sort_by_parameters = { - "offset" => 0, - "limit" => 1, - } - assert_equal({ - "queries" => { - "users" => { - "source" => "User", - "sortBy" => @sort_by.merge(changed_sort_by_parameters), - "output" => @output, - }, + def test_broadcast_body + changed_sort_by_parameters = { + "offset" => 0, + "limit" => 1, + } + changed_output_parameters = { + "attributes" => [ + { "label" => "id", "source" => "_key" }, + { "label" => "name", "source" => "name" }, + "hidden", + ], + } + assert_equal({ + "queries" => { + "users" => { + "source" => "User", + "sortBy" => @sort_by.merge(changed_sort_by_parameters), + "output" => @output.merge(changed_output_parameters), }, }, - broadcast_message["body"]) - end + }, + broadcast_message["body"]) + end - def test_reduce_body - assert_equal({ - "users_reduced" => { - "records" => { - "type" => "sort", - "operators" => [ - { "column" => 0, "operator" => "<" }, - ], - "limit" => 1, - }, + def test_reduce_body + assert_equal({ + "users_reduced" => { + "records" => { + "type" => "sort", + "operators" => [ + { "column" => 2, "operator" => "<" }, + ], + "limit" => 1, }, }, - reduce_message["body"]["users"]) - end + }, + reduce_message["body"]["users"]) + end - def test_gather_records - assert_equal({ - "elements" => { - "records" => { - "attributes" => ["_key"], - "limit" => 1, - }, + def test_gather_records + assert_equal({ + "elements" => { + "records" => { + "attributes" => ["id", "name"], + "limit" => 1, }, - "output" => "users", }, - gather_message["body"]["users_reduced"]) - end + "output" => "users", + }, + gather_message["body"]["users_reduced"]) + end + end + + class WithComplexAttributesArrayTest < self + def setup + @output = { + "elements" => ["records"], + "attributes" => [ + { "label" => "id", "source" => "_key" }, + { "label" => "real_name", "source" => "name" }, + ], + "limit" => 1, + } + @sort_by = { + "keys" => ["name"], + } + @request = { + "type" => "search", + "dataset" => "Droonga", + "body" => { + "queries" => { + "users" => { + "source" => "User", + "sortBy" => @sort_by, + "output" => @output, + }, + }, + }, + } + end + + def test_dependencies + reduce_inputs = ["errors", "users"] + gather_inputs = ["errors_reduced", "users_reduced"] + assert_equal(expected_dependencies(reduce_inputs, gather_inputs), + dependencies) end - class ComplexHiddenColumnTest < self + def test_broadcast_body + changed_sort_by_parameters = { + "offset" => 0, + "limit" => 1, + } + changed_output_parameters = { + "attributes" => [ + { "label" => "id", "source" => "_key" }, + { "label" => "real_name", "source" => "name" }, + ], + } + assert_equal({ + "queries" => { + "users" => { + "source" => "User", + "sortBy" => @sort_by.merge(changed_sort_by_parameters), + "output" => @output.merge(changed_output_parameters), + }, + }, + }, + broadcast_message["body"]) + end + + def test_reduce_body + assert_equal({ + "users_reduced" => { + "records" => { + "type" => "sort", + "operators" => [ + { "column" => 1, "operator" => "<" }, + ], + "limit" => 1, + }, + }, + }, + reduce_message["body"]["users"]) + end + + def test_gather_records + assert_equal({ + "elements" => { + "records" => { + "attributes" => ["id", "real_name"], + "limit" => 1, + }, + }, + "output" => "users", + }, + gather_message["body"]["users_reduced"]) + end + end + + class MultipleColumnsTest < self + def setup + @output = { + "elements" => ["records"], + "attributes" => ["_key"], + "limit" => 1, + } + @sort_by = { + "keys" => ["-age", "name", "_key"], + } + @request = { + "type" => "search", + "dataset" => "Droonga", + "body" => { + "queries" => { + "users" => { + "source" => "User", + "sortBy" => @sort_by, + "output" => @output, + }, + }, + }, + } + end + + def test_dependencies + reduce_inputs = ["errors", "users"] + gather_inputs = ["errors_reduced", "users_reduced"] + assert_equal(expected_dependencies(reduce_inputs, gather_inputs), + dependencies) + end + + def test_broadcast_body + changed_sort_by_parameters = { + "offset" => 0, + "limit" => 1, + } + changed_output_parameters = { + "attributes" => ["_key", "age", "name"], + } + assert_equal({ + "queries" => { + "users" => { + "source" => "User", + "sortBy" => @sort_by.merge(changed_sort_by_parameters), + "output" => @output.merge(changed_output_parameters), + }, + }, + }, + broadcast_message["body"]) + end + + def test_reduce_body + assert_equal({ + "users_reduced" => { + "records" => { + "type" => "sort", + "operators" => [ + { "column" => 1, "operator" => ">" }, + { "column" => 2, "operator" => "<" }, + { "column" => 0, "operator" => "<" }, + ], + "limit" => 1, + }, + }, + }, + reduce_message["body"]["users"]) + end + + def test_gather_records + assert_equal({ + "elements" => { + "records" => { + "attributes" => ["_key"], + "limit" => 1, + }, + }, + "output" => "users", + }, + gather_message["body"]["users_reduced"]) + end + end + + class OffsetLimitTest < self + def max_limit + [@sort_by["limit"], @output["limit"]].max + end + + def min_limit + [@sort_by["limit"], @output["limit"]].min + end + + def total_offset + @sort_by["offset"] + @output["offset"] + end + + class RegularRangeTest < self def setup @output = { "elements" => ["records"], "attributes" => ["_key"], - "limit" => 1, + "offset" => 4, + "limit" => 8, } @sort_by = { - "keys" => ["name"], + "keys" => ["_key"], + "offset" => 1, + "limit" => 2, } @request = { "type" => "search", @@ -274,10 +629,11 @@ class DistributedSearchPlannerSortByTest < Test::Unit::TestCase def test_broadcast_body changed_sort_by_parameters = { "offset" => 0, - "limit" => 1, + "limit" => total_offset + max_limit, } changed_output_parameters = { - "attributes" => ["_key", "name"], + "offset" => 0, + "limit" => total_offset + min_limit, } assert_equal({ "queries" => { @@ -297,9 +653,9 @@ class DistributedSearchPlannerSortByTest < Test::Unit::TestCase "records" => { "type" => "sort", "operators" => [ - { "column" => 1, "operator" => "<" }, + { "column" => 0, "operator" => "<" }, ], - "limit" => 1, + "limit" => total_offset + min_limit, }, }, }, @@ -311,7 +667,8 @@ class DistributedSearchPlannerSortByTest < Test::Unit::TestCase "elements" => { "records" => { "attributes" => ["_key"], - "limit" => 1, + "offset" => total_offset, + "limit" => min_limit, }, }, "output" => "users", @@ -320,18 +677,18 @@ class DistributedSearchPlannerSortByTest < Test::Unit::TestCase end end - class WithHashAttributesTest < self + class InfinitOutputLimitTest < self def setup @output = { "elements" => ["records"], - "attributes" => { - "id" => "_key", - "name" => { "source" => "name" }, - }, - "limit" => 1, + "attributes" => ["_key"], + "offset" => 4, + "limit" => -1, } @sort_by = { - "keys" => ["hidden"], + "keys" => ["_key"], + "offset" => 1, + "limit" => 2, } @request = { "type" => "search", @@ -358,14 +715,11 @@ class DistributedSearchPlannerSortByTest < Test::Unit::TestCase def test_broadcast_body changed_sort_by_parameters = { "offset" => 0, - "limit" => 1, + "limit" => total_offset + max_limit, } changed_output_parameters = { - "attributes" => [ - { "label" => "id", "source" => "_key" }, - { "label" => "name", "source" => "name" }, - "hidden", - ], + "offset" => 0, + "limit" => total_offset + max_limit, } assert_equal({ "queries" => { @@ -385,9 +739,9 @@ class DistributedSearchPlannerSortByTest < Test::Unit::TestCase "records" => { "type" => "sort", "operators" => [ - { "column" => 2, "operator" => "<" }, + { "column" => 0, "operator" => "<" }, ], - "limit" => 1, + "limit" => total_offset + max_limit, }, }, }, @@ -398,8 +752,9 @@ class DistributedSearchPlannerSortByTest < Test::Unit::TestCase assert_equal({ "elements" => { "records" => { - "attributes" => ["id", "name"], - "limit" => 1, + "attributes" => ["_key"], + "offset" => total_offset, + "limit" => max_limit, }, }, "output" => "users", @@ -408,18 +763,18 @@ class DistributedSearchPlannerSortByTest < Test::Unit::TestCase end end - class WithComplexAttributesArrayTest < self + class InifinitSortLimitTest < self def setup @output = { "elements" => ["records"], - "attributes" => [ - { "label" => "id", "source" => "_key" }, - { "label" => "real_name", "source" => "name" }, - ], - "limit" => 1, + "attributes" => ["_key"], + "offset" => 4, + "limit" => 8, } @sort_by = { - "keys" => ["name"], + "keys" => ["_key"], + "offset" => 1, + "limit" => -1, } @request = { "type" => "search", @@ -446,13 +801,11 @@ class DistributedSearchPlannerSortByTest < Test::Unit::TestCase def test_broadcast_body changed_sort_by_parameters = { "offset" => 0, - "limit" => 1, + "limit" => total_offset + max_limit, } changed_output_parameters = { - "attributes" => [ - { "label" => "id", "source" => "_key" }, - { "label" => "real_name", "source" => "name" }, - ], + "offset" => 0, + "limit" => total_offset + max_limit, } assert_equal({ "queries" => { @@ -472,9 +825,9 @@ class DistributedSearchPlannerSortByTest < Test::Unit::TestCase "records" => { "type" => "sort", "operators" => [ - { "column" => 1, "operator" => "<" }, + { "column" => 0, "operator" => "<" }, ], - "limit" => 1, + "limit" => total_offset + max_limit, }, }, }, @@ -485,8 +838,9 @@ class DistributedSearchPlannerSortByTest < Test::Unit::TestCase assert_equal({ "elements" => { "records" => { - "attributes" => ["id", "real_name"], - "limit" => 1, + "attributes" => ["_key"], + "offset" => total_offset, + "limit" => max_limit, }, }, "output" => "users", @@ -495,15 +849,18 @@ class DistributedSearchPlannerSortByTest < Test::Unit::TestCase end end - class MultipleColumnsTest < self + class InifinitBothLimitTest < self def setup @output = { "elements" => ["records"], "attributes" => ["_key"], - "limit" => 1, + "offset" => 4, + "limit" => -1, } @sort_by = { - "keys" => ["-age", "name", "_key"], + "keys" => ["_key"], + "offset" => 1, + "limit" => -1, } @request = { "type" => "search", @@ -530,10 +887,11 @@ class DistributedSearchPlannerSortByTest < Test::Unit::TestCase def test_broadcast_body changed_sort_by_parameters = { "offset" => 0, - "limit" => 1, + "limit" => min_limit, } changed_output_parameters = { - "attributes" => ["_key", "age", "name"], + "offset" => 0, + "limit" => min_limit, } assert_equal({ "queries" => { @@ -553,11 +911,9 @@ class DistributedSearchPlannerSortByTest < Test::Unit::TestCase "records" => { "type" => "sort", "operators" => [ - { "column" => 1, "operator" => ">" }, - { "column" => 2, "operator" => "<" }, { "column" => 0, "operator" => "<" }, ], - "limit" => 1, + "limit" => min_limit, }, }, }, @@ -569,7 +925,8 @@ class DistributedSearchPlannerSortByTest < Test::Unit::TestCase "elements" => { "records" => { "attributes" => ["_key"], - "limit" => 1, + "offset" => total_offset, + "limit" => min_limit, }, }, "output" => "users", @@ -577,362 +934,5 @@ class DistributedSearchPlannerSortByTest < Test::Unit::TestCase gather_message["body"]["users_reduced"]) end end - - class OffsetLimitTest < self - def max_limit - [@sort_by["limit"], @output["limit"]].max - end - - def min_limit - [@sort_by["limit"], @output["limit"]].min - end - - def total_offset - @sort_by["offset"] + @output["offset"] - end - - class RegularRangeTest < self - def setup - @output = { - "elements" => ["records"], - "attributes" => ["_key"], - "offset" => 4, - "limit" => 8, - } - @sort_by = { - "keys" => ["_key"], - "offset" => 1, - "limit" => 2, - } - @request = { - "type" => "search", - "dataset" => "Droonga", - "body" => { - "queries" => { - "users" => { - "source" => "User", - "sortBy" => @sort_by, - "output" => @output, - }, - }, - }, - } - end - - def test_dependencies - reduce_inputs = ["errors", "users"] - gather_inputs = ["errors_reduced", "users_reduced"] - assert_equal(expected_dependencies(reduce_inputs, gather_inputs), - dependencies) - end - - def test_broadcast_body - changed_sort_by_parameters = { - "offset" => 0, - "limit" => total_offset + max_limit, - } - changed_output_parameters = { - "offset" => 0, - "limit" => total_offset + min_limit, - } - assert_equal({ - "queries" => { - "users" => { - "source" => "User", - "sortBy" => @sort_by.merge(changed_sort_by_parameters), - "output" => @output.merge(changed_output_parameters), - }, - }, - }, - broadcast_message["body"]) - end - - def test_reduce_body - assert_equal({ - "users_reduced" => { - "records" => { - "type" => "sort", - "operators" => [ - { "column" => 0, "operator" => "<" }, - ], - "limit" => total_offset + min_limit, - }, - }, - }, - reduce_message["body"]["users"]) - end - - def test_gather_records - assert_equal({ - "elements" => { - "records" => { - "attributes" => ["_key"], - "offset" => total_offset, - "limit" => min_limit, - }, - }, - "output" => "users", - }, - gather_message["body"]["users_reduced"]) - end - end - - class InfinitOutputLimitTest < self - def setup - @output = { - "elements" => ["records"], - "attributes" => ["_key"], - "offset" => 4, - "limit" => -1, - } - @sort_by = { - "keys" => ["_key"], - "offset" => 1, - "limit" => 2, - } - @request = { - "type" => "search", - "dataset" => "Droonga", - "body" => { - "queries" => { - "users" => { - "source" => "User", - "sortBy" => @sort_by, - "output" => @output, - }, - }, - }, - } - end - - def test_dependencies - reduce_inputs = ["errors", "users"] - gather_inputs = ["errors_reduced", "users_reduced"] - assert_equal(expected_dependencies(reduce_inputs, gather_inputs), - dependencies) - end - - def test_broadcast_body - changed_sort_by_parameters = { - "offset" => 0, - "limit" => total_offset + max_limit, - } - changed_output_parameters = { - "offset" => 0, - "limit" => total_offset + max_limit, - } - assert_equal({ - "queries" => { - "users" => { - "source" => "User", - "sortBy" => @sort_by.merge(changed_sort_by_parameters), - "output" => @output.merge(changed_output_parameters), - }, - }, - }, - broadcast_message["body"]) - end - - def test_reduce_body - assert_equal({ - "users_reduced" => { - "records" => { - "type" => "sort", - "operators" => [ - { "column" => 0, "operator" => "<" }, - ], - "limit" => total_offset + max_limit, - }, - }, - }, - reduce_message["body"]["users"]) - end - - def test_gather_records - assert_equal({ - "elements" => { - "records" => { - "attributes" => ["_key"], - "offset" => total_offset, - "limit" => max_limit, - }, - }, - "output" => "users", - }, - gather_message["body"]["users_reduced"]) - end - end - - class InifinitSortLimitTest < self - def setup - @output = { - "elements" => ["records"], - "attributes" => ["_key"], - "offset" => 4, - "limit" => 8, - } - @sort_by = { - "keys" => ["_key"], - "offset" => 1, - "limit" => -1, - } - @request = { - "type" => "search", - "dataset" => "Droonga", - "body" => { - "queries" => { - "users" => { - "source" => "User", - "sortBy" => @sort_by, - "output" => @output, - }, - }, - }, - } - end - - def test_dependencies - reduce_inputs = ["errors", "users"] - gather_inputs = ["errors_reduced", "users_reduced"] - assert_equal(expected_dependencies(reduce_inputs, gather_inputs), - dependencies) - end - - def test_broadcast_body - changed_sort_by_parameters = { - "offset" => 0, - "limit" => total_offset + max_limit, - } - changed_output_parameters = { - "offset" => 0, - "limit" => total_offset + max_limit, - } - assert_equal({ - "queries" => { - "users" => { - "source" => "User", - "sortBy" => @sort_by.merge(changed_sort_by_parameters), - "output" => @output.merge(changed_output_parameters), - }, - }, - }, - broadcast_message["body"]) - end - - def test_reduce_body - assert_equal({ - "users_reduced" => { - "records" => { - "type" => "sort", - "operators" => [ - { "column" => 0, "operator" => "<" }, - ], - "limit" => total_offset + max_limit, - }, - }, - }, - reduce_message["body"]["users"]) - end - - def test_gather_records - assert_equal({ - "elements" => { - "records" => { - "attributes" => ["_key"], - "offset" => total_offset, - "limit" => max_limit, - }, - }, - "output" => "users", - }, - gather_message["body"]["users_reduced"]) - end - end - - class InifinitBothLimitTest < self - def setup - @output = { - "elements" => ["records"], - "attributes" => ["_key"], - "offset" => 4, - "limit" => -1, - } - @sort_by = { - "keys" => ["_key"], - "offset" => 1, - "limit" => -1, - } - @request = { - "type" => "search", - "dataset" => "Droonga", - "body" => { - "queries" => { - "users" => { - "source" => "User", - "sortBy" => @sort_by, - "output" => @output, - }, - }, - }, - } - end - - def test_dependencies - reduce_inputs = ["errors", "users"] - gather_inputs = ["errors_reduced", "users_reduced"] - assert_equal(expected_dependencies(reduce_inputs, gather_inputs), - dependencies) - end - - def test_broadcast_body - changed_sort_by_parameters = { - "offset" => 0, - "limit" => min_limit, - } - changed_output_parameters = { - "offset" => 0, - "limit" => min_limit, - } - assert_equal({ - "queries" => { - "users" => { - "source" => "User", - "sortBy" => @sort_by.merge(changed_sort_by_parameters), - "output" => @output.merge(changed_output_parameters), - }, - }, - }, - broadcast_message["body"]) - end - - def test_reduce_body - assert_equal({ - "users_reduced" => { - "records" => { - "type" => "sort", - "operators" => [ - { "column" => 0, "operator" => "<" }, - ], - "limit" => min_limit, - }, - }, - }, - reduce_message["body"]["users"]) - end - - def test_gather_records - assert_equal({ - "elements" => { - "records" => { - "attributes" => ["_key"], - "offset" => total_offset, - "limit" => min_limit, - }, - }, - "output" => "users", - }, - gather_message["body"]["users_reduced"]) - end - end - end + end end
