droonga-engine 1.1.0 → 1.1.1

data/test/unit/plugins/system/statistics/test_object_count.rb

@@ -0,0 +1,135 @@
+# Copyright (C) 2015 Droonga Project
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License version 2.1 as published by the Free Software Foundation.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+require "droonga/plugins/system"
+
+class SystemStatisticsObjectCountHandlerTest < Test::Unit::TestCase
+  def setup
+    setup_database
+    setup_handler
+
+    Groonga::Schema.define do |schema|
+      schema.create_table("Books", :type => :hash)
+      schema.change_table("Books") do |table|
+        table.column("title", "ShortText", :type => :scalar)
+      end
+    end
+    Groonga::Context.default["Books"].add("sample")
+  end
+
+  def teardown
+    teardown_handler
+    teardown_database
+  end
+
+  private
+  def setup_handler
+    @worker = StubWorker.new
+    @messenger = Droonga::Test::StubHandlerMessenger.new
+    @loop = nil
+    handler_params = {
+      :name      => "name",
+      :label     => "label",
+      :context   => @worker.context,
+      :messenger => @messenger,
+      :loop      => @loop,
+    }
+    @handler = Droonga::Plugins::System::StatisticsObjectCountHandler.new(handler_params)
+  end
+
+  def teardown_handler
+    @handler = nil
+  end
+
+  def process(request)
+    message = Droonga::Test::StubHandlerMessage.new(request)
+    @handler.handle(message)
+  end
+
+  public
+  data(
+    :all => {
+      :request => {
+        "output" => [
+          "tables",
+          "columns",
+          "records",
+          "total",
+        ],
+      },
+      :expected => {
+        "tables"  => 1,
+        "columns" => 1,
+        "records" => 1,
+        "total"   => 3,
+      },
+    },
+    :tables => {
+      :request => {
+        "output" => [
+          "tables",
+        ],
+      },
+      :expected => {
+        "tables"  => 1,
+      },
+    },
+    :columns => {
+      :request => {
+        "output" => [
+          "columns",
+        ],
+      },
+      :expected => {
+        "columns" => 1,
+      },
+    },
+    :records => {
+      :request => {
+        "output" => [
+          "records",
+        ],
+      },
+      :expected => {
+        "records" => 1,
+      },
+    },
+    :total => {
+      :request => {
+        "output" => [
+          "total",
+        ],
+      },
+      :expected => {
+        "total"   => 3,
+      },
+    },
+    :nothing => {
+      :request => {
+        "output" => [],
+      },
+      :expected => {},
+    },
+    :no_parameter => {
+      :request => {},
+      :expected => {},
+    },
+  )
+  def test_output(data)
+    request = data[:request]
+    response = process(request)
+    assert_equal(data[:expected], response)
+  end
+end

data/test/unit/plugins/system/statistics/test_object_count_per_volume.rb

@@ -0,0 +1,149 @@
+# Copyright (C) 2015 Droonga Project
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License version 2.1 as published by the Free Software Foundation.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+require "droonga/plugins/system"
+
+class SystemStatisticsObjectCountPerVolumeHandlerTest < Test::Unit::TestCase
+  def setup
+    setup_database
+    setup_handler
+
+    Groonga::Schema.define do |schema|
+      schema.create_table("Books", :type => :hash)
+      schema.change_table("Books") do |table|
+        table.column("title", "ShortText", :type => :scalar)
+      end
+    end
+    Groonga::Context.default["Books"].add("sample")
+  end
+
+  def teardown
+    teardown_handler
+    teardown_database
+  end
+
+  private
+  def setup_handler
+    @worker = StubWorker.new
+    @messenger = Droonga::Test::StubHandlerMessenger.new
+    @loop = nil
+    handler_params = {
+      :name      => "name",
+      :label     => "label",
+      :context   => @worker.context,
+      :messenger => @messenger,
+      :loop      => @loop,
+    }
+    @handler = Droonga::Plugins::System::StatisticsObjectCountPerVolumeHandler.new(handler_params)
+  end
+
+  def teardown_handler
+    @handler = nil
+  end
+
+  def process(request)
+    message = Droonga::Test::StubHandlerMessage.new(request)
+    @handler.handle(message)
+  end
+
+  public
+  data(
+    :all => {
+      :request => {
+        "output" => [
+          "tables",
+          "columns",
+          "records",
+          "total",
+        ],
+      },
+      :expected => {
+        "label" => {
+          "tables"  => 1,
+          "columns" => 1,
+          "records" => 1,
+          "total"   => 3,
+        },
+      },
+    },
+    :tables => {
+      :request => {
+        "output" => [
+          "tables",
+        ],
+      },
+      :expected => {
+        "label" => {
+          "tables"  => 1,
+        },
+      },
+    },
+    :columns => {
+      :request => {
+        "output" => [
+          "columns",
+        ],
+      },
+      :expected => {
+        "label" => {
+          "columns" => 1,
+        },
+      },
+    },
+    :records => {
+      :request => {
+        "output" => [
+          "records",
+        ],
+      },
+      :expected => {
+        "label" => {
+          "records" => 1,
+        },
+      },
+    },
+    :total => {
+      :request => {
+        "output" => [
+          "total",
+        ],
+      },
+      :expected => {
+        "label" => {
+          "total"   => 3,
+        },
+      },
+    },
+    :nothing => {
+      :request => {
+        "output" => [],
+      },
+      :expected => {
+        "label" => {},
+      },
+    },
+    :no_parameter => {
+      :request => {},
+      :expected => {
+        "label" => {},
+      },
+    },
+  )
+  def test_output(data)
+    request = data[:request]
+    response = process(request)
+    assert_equal(data[:expected], response)
+  end
+end

data/test/unit/plugins/test_basic.rb

@@ -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