fluent-plugin-droonga 0.7.0 → 0.8.0

data/test/command/suite/search/response/records/value/time.expected

@@ -0,0 +1,24 @@
+[
+  "droonga.message",
+  0,
+  {
+    "inReplyTo": null,
+    "statusCode": 200,
+    "type": "search.result",
+    "body": {
+      "result": {
+        "count": 2,
+        "records": [
+          [
+            "Groonga Night 3",
+            "2012-11-29T10:00:00.000000Z"
+          ],
+          [
+            "Groonga Night 4",
+            "2013-11-29T08:00:00.000000Z"
+          ]
+        ]
+      }
+    }
+  }
+]

data/test/command/suite/search/response/records/value/time.test

@@ -0,0 +1,24 @@
+#@include fixture/event.jsons
+{
+  "type": "search",
+  "dataset": "Droonga",
+  "body": {
+    "queries": {
+      "result": {
+        "source": "Event",
+        "sortBy": ["_key"],
+        "output": {
+          "elements": [
+            "startTime",
+            "elapsedTime",
+            "count",
+            "attributes",
+            "records"
+          ],
+          "limit": -1,
+          "attributes": ["_key", "start"]
+        }
+      }
+    }
+  }
+}

data/test/command/suite/search/sort/default-offset-limit.expected

@@ -0,0 +1,43 @@
+[
+  "droonga.message",
+  0,
+  {
+    "inReplyTo": null,
+    "statusCode": 200,
+    "type": "search.result",
+    "body": {
+      "result": {
+        "count": 9,
+        "records": [
+          [
+            "1.9"
+          ],
+          [
+            "1.8"
+          ],
+          [
+            "1.7"
+          ],
+          [
+            "1.6"
+          ],
+          [
+            "1.5"
+          ],
+          [
+            "1.4"
+          ],
+          [
+            "1.3"
+          ],
+          [
+            "1.2"
+          ],
+          [
+            "1.1"
+          ]
+        ]
+      }
+    }
+  }
+]

data/test/command/suite/search/sort/default-offset-limit.test

@@ -0,0 +1,26 @@
+#@include fixture/documents.jsons
+{
+  "type": "search",
+  "dataset": "Droonga",
+  "body": {
+    "queries": {
+      "result": {
+        "source": "Sections",
+        "sortBy": {
+          "keys": ["-_key"]
+        },
+        "output": {
+          "elements": [
+            "startTime",
+            "elapsedTime",
+            "count",
+            "attributes",
+            "records"
+          ],
+          "limit": -1,
+          "attributes": ["_key"]
+        }
+      }
+    }
+  }
+}

data/test/command/suite/watch/subscribe.expected

@@ -0,0 +1,12 @@
+[
+  "droonga.message",
+  0,
+  {
+    "inReplyTo": null,
+    "statusCode": 200,
+    "type": "watch.subscribe.result",
+    "body": [
+      true
+    ]
+  }
+]

data/test/command/suite/watch/subscribe.test

@@ -0,0 +1,9 @@
+{
+  "type": "watch.subscribe",
+  "dataset": "Watch",
+  "body": {
+    "condition": "condition",
+    "subscriber": "subscriber",
+    "route": "localhost:23003/output"
+  }
+}

data/test/command/suite/watch/unsubscribe.expected

@@ -0,0 +1,12 @@
+[
+  "droonga.message",
+  0,
+  {
+    "inReplyTo": null,
+    "statusCode": 200,
+    "type": "watch.unsubscribe.result",
+    "body": [
+      true
+    ]
+  }
+]

data/test/command/suite/watch/unsubscribe.test

@@ -0,0 +1,9 @@
+{
+  "type": "watch.unsubscribe",
+  "dataset": "Watch",
+  "body": {
+    "condition": "condition",
+    "subscriber": "subscriber",
+    "route": "localhost:23003/output"
+  }
+}

data/test/unit/{test_catalog.rb → catalog/test_version1.rb}

@@ -13,11 +13,12 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
-require "droonga/catalog"
+require "droonga/catalog/version1"
 
 class CatalogTest < Test::Unit::TestCase
   def setup
-    @catalog = Droonga::Catalog.new(catalog_path)
+    data = JSON.parse(File.read(catalog_path))
+    @catalog = Droonga::Catalog::Version1.new(data, base_path)
   end
 
   def test_option
@@ -26,7 +27,6 @@ class CatalogTest < Test::Unit::TestCase
 
   def test_get_partitions
     partitions = @catalog.get_partitions("localhost:23003/test")
-    base_path = File.expand_path("../fixtures", __FILE__)
     assert_equal({
                    "localhost:23003/test.000" => {
                      :database  => "#{base_path}/000/db",
@@ -53,7 +53,15 @@ class CatalogTest < Test::Unit::TestCase
   end
 
   private
+  def fixture_path(base_path)
+    File.expand_path("../../fixtures/#{base_path}", __FILE__)
+  end
+
   def catalog_path
-    @catalog_path ||= File.expand_path("../fixtures/catalog.json", __FILE__)
+    @catalog_path ||= fixture_path("catalog/version1.json")
+  end
+
+  def base_path
+    File.dirname(catalog_path)
   end
 end

data/test/unit/helper.rb

@@ -13,6 +13,8 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
+require "droonga/test"
+
 require_relative "helper/sandbox"
 require_relative "helper/fixture"
 require_relative "helper/stub_worker"

data/test/unit/plugin/collector/test_basic.rb

@@ -16,15 +16,16 @@
 require "droonga/plugin/collector/basic"
 
 class BasicCollectorTest < Test::Unit::TestCase
-  include PluginHelper
-
   def setup
     setup_database
-    setup_plugin(Droonga::BasicCollector)
+    @plugin = Droonga::BasicCollector.new
+    @outputs = []
+    stub(@plugin).emit do |name, value|
+      @outputs << [name, value]
+    end
   end
 
   def teardown
-    teardown_plugin
     teardown_database
   end
 
@@ -84,9 +85,13 @@ class BasicCollectorTest < Test::Unit::TestCase
         },
         :mapping => {
           "output" => "search_result",
-          "element" => "records",
-          "offset" => 1,
-          "limit" => 1,
+          "elements" => {
+            "records" => {
+              "type" => "sort",
+              "offset" => 1,
+              "limit" => 1,
+            },
+          },
         },
       },
       :offset_and_unlimited_limit => {
@@ -107,9 +112,39 @@ class BasicCollectorTest < Test::Unit::TestCase
         },
         :mapping => {
           "output" => "search_result",
-          "element" => "records",
-          "offset" => 1,
-          "limit" => -1,
+          "elements" => {
+            "records" => {
+              "type" => "sort",
+              "offset" => 1,
+              "limit" => -1,
+            },
+          },
+        },
+      },
+      :too_large_offset => {
+        :expected => {
+          "count" => 2,
+          "records" => [
+          ],
+        },
+        :source => {
+          "count" => 2,
+          "records" => [
+            create_record(1, 1.1, 1.2),
+            create_record(2, 2.1, 2.2),
+          ],
+        },
+        :mapping => {
+          "output" => "search_result",
+          "elements" => {
+            "records" => {
+              "type" => "sort",
+              "format" => "simple",
+              "attributes" => [],
+              "offset" => 10000,
+              "limit" => -1,
+            },
+          },
         },
       },
       :attributes => {
@@ -129,9 +164,13 @@ class BasicCollectorTest < Test::Unit::TestCase
         },
         :mapping => {
           "output" => "search_result",
-          "element" => "records",
-          "attributes" => ["_key", "chapter", "section", "subsection", "paragraph"],
-          "limit" => -1,
+          "elements" => {
+            "records" => {
+              "type" => "sort",
+              "attributes" => ["_key", "chapter", "section", "subsection", "paragraph"],
+              "limit" => -1,
+            },
+          },
         },
       },
       :attributes_with_sort_attributes => {
@@ -151,9 +190,13 @@ class BasicCollectorTest < Test::Unit::TestCase
         },
         :mapping => {
           "output" => "search_result",
-          "element" => "records",
-          "attributes" => ["_key", "chapter", "section"],
-          "limit" => -1,
+          "elements" => {
+            "records" => {
+              "type" => "sort",
+              "attributes" => ["_key", "chapter", "section"],
+              "limit" => -1,
+            },
+          },
         },
       },
       :format_simple => {
@@ -173,10 +216,14 @@ class BasicCollectorTest < Test::Unit::TestCase
         },
         :mapping => {
           "output" => "search_result",
-          "element" => "records",
-          "format" => "simple",
-          "attributes" => ["_key", "chapter", "section"],
-          "limit" => -1,
+          "elements" => {
+            "records" => {
+              "type" => "sort",
+              "format" => "simple",
+              "attributes" => ["_key", "chapter", "section"],
+              "limit" => -1,
+            },
+          },
         },
       },
       :format_complex => {
@@ -196,10 +243,73 @@ class BasicCollectorTest < Test::Unit::TestCase
         },
         :mapping => {
           "output" => "search_result",
-          "element" => "records",
-          "format" => "complex",
-          "attributes" => ["_key", "chapter", "section"],
-          "limit" => -1,
+          "elements" => {
+            "records" => {
+              "type" => "sort",
+              "format" => "complex",
+              "attributes" => ["_key", "chapter", "section"],
+              "limit" => -1,
+            },
+          },
+        },
+      },
+      :count_with_records => {
+        :expected => {
+          "count" => 2,
+          "records" => [
+            [],
+            [],
+          ],
+        },
+        :source => {
+          "count" => 5,
+          "records" => [
+            [],
+            [],
+          ],
+        },
+        :mapping => {
+          "output" => "search_result",
+          "elements" => {
+            "count" => {
+              "type" => "count",
+              "target" => "records",
+            },
+            "records" => {
+              "type" => "sort",
+              "format" => "simple",
+              "attributes" => [],
+              "limit" => -1,
+            },
+          },
+        },
+      },
+      :count_only => {
+        :expected => {
+          "count" => 2,
+        },
+        :source => {
+          "count" => 5,
+          "records" => [
+            [],
+            [],
+          ],
+        },
+        :mapping => {
+          "output" => "search_result",
+          "elements" => {
+            "count" => {
+              "type" => "count",
+              "target" => "records",
+            },
+            "records" => {
+              "type" => "sort",
+              "format" => "simple",
+              "attributes" => [],
+              "limit" => -1,
+              "no_output" => true,
+            },
+          },
         },
       },
     )
@@ -220,7 +330,7 @@ class BasicCollectorTest < Test::Unit::TestCase
       @plugin.process("collector_gather", request)
       output_name = data[:mapping]
       output_name = output_name["output"] if output_name.is_a?(Hash)
-      assert_equal([data[:expected], output_name], @messages.last)
+      assert_equal([output_name, data[:expected]], @outputs.last)
     end
   end
 
@@ -286,6 +396,7 @@ class BasicCollectorTest < Test::Unit::TestCase
       }
       @plugin.process("collector_reduce", request)
       assert_equal([
+                     output_name,
                      {
                        "numeric_value" => 3,
                        "numeric_key_records" => [
@@ -305,9 +416,8 @@ class BasicCollectorTest < Test::Unit::TestCase
                          create_record("f"),
                        ],
                      },
-                     output_name
                    ],
-                   @messages.last)
+                   @outputs.last)
     end
 
     def test_sum_with_limit
@@ -371,6 +481,7 @@ class BasicCollectorTest < Test::Unit::TestCase
       }
       @plugin.process("collector_reduce", request)
       assert_equal([
+                     output_name,
                      {
                        "numeric_value" => 3,
                        "numeric_key_records" => [
@@ -386,9 +497,8 @@ class BasicCollectorTest < Test::Unit::TestCase
                          create_record("f"),
                        ],
                      },
-                     output_name
                    ],
-                   @messages.last)
+                   @outputs.last)
     end
 
     def test_sort
@@ -452,6 +562,7 @@ class BasicCollectorTest < Test::Unit::TestCase
       }
       @plugin.process("collector_reduce", request)
       assert_equal([
+                     output_name,
                      {
                        "numeric_key_records" => [
                          create_record(1),
@@ -470,9 +581,8 @@ class BasicCollectorTest < Test::Unit::TestCase
                          create_record("f"),
                        ],
                      },
-                     output_name
                    ],
-                   @messages.last)
+                   @outputs.last)
     end
 
     def test_sort_with_limit
@@ -536,6 +646,7 @@ class BasicCollectorTest < Test::Unit::TestCase
       }
       @plugin.process("collector_reduce", request)
       assert_equal([
+                     output_name,
                      {
                        "numeric_key_records" => [
                          create_record(1),
@@ -550,9 +661,154 @@ class BasicCollectorTest < Test::Unit::TestCase
                          create_record("f"),
                        ],
                      },
-                     output_name
                    ],
-                   @messages.last)
+                   @outputs.last)
+    end
+  end
+
+  class MergeTest < self
+    def test_grouped
+      input_name = "input_#{Time.now.to_i}"
+      output_name = "output_#{Time.now.to_i}"
+      request = {
+        "task" => {
+          "values" => {
+            output_name => {
+              "records" => [
+                [
+                  "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"),
+                  ],
+                ],
+              ],
+            },
+          },
+          "component" => {
+            "body" => {
+              input_name => {
+                output_name => {
+                  "records" => {
+                    "type" => "sort",
+                    "operators" => [
+                      { "column" => 1, "operator" => "<" },
+                    ],
+                    "key_column" => 0,
+                    "limit" => -1,
+                  },
+                },
+              },
+            },
+            "outputs" => nil,
+          },
+        },
+        "id" => nil,
+        "value" => {
+          "records" => [
+            [
+              "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"),
+              ],
+            ],
+          ],
+        },
+        "name" => input_name,
+        "descendants" => nil,
+      }
+      @plugin.process("collector_reduce", request)
+      assert_equal([
+                     output_name,
+                     {
+                       "records" => [
+                         [
+                           "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"),
+                           ],
+                         ],
+                       ],
+                     },
+                   ],
+                   @outputs.last)
     end
   end
 end