drnbench 1.0.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bc7f61f1275e4e48a15492d197552728429a7272
-  data.tar.gz: fa6bd343d6a874c165dd95ae77bdc1ca7df730b1
+  metadata.gz: 3b10736f18dbeaf958fe4b9bd29c0a6788b69f3c
+  data.tar.gz: bc4363d42fd30a955a70f4d2241052486e121635
 SHA512:
-  metadata.gz: 226d64e8c67139749313e265c3c6be5ac369b2c03f38dfc269dc2f9a105d682aad9830639e86ebef914306027fbf9ae64001773d4058983a14a307a101b352be
-  data.tar.gz: a97fea6987677e63f4f6511148cec0c30b98646042d5603c9dc61c10cf81325c117cea3ac5f82b794916ef69a6cc7309276fc90657cc7ce60f5b09d71f8b88ae
+  metadata.gz: c7d68baea7789ca3a4a803fa7a4b5d2ff3c24252a7cf49c89d0f33a5eb598f9c0f064dc64c6eb35251abe6a0de4fe910d554e562a5151e18eb00d43973e3ea37
+  data.tar.gz: 4dad01b34e627c89618827e67f2f070c6cdb229f208d65214361b76477b6d91b10f6be69bf62ed2695078356341714f64fd4007277e674a8f8f8f3a0f4d8f527

data/README.md

@@ -7,7 +7,7 @@ Drnbench is a benchmark tool for Droonga.
 It may be used for other HTTP servers.
 
 Drnbench provides features to send multiple random requests with different settings periodically.
-Number of clients (requests) in each period will be automatically increased gradually.
+Number of clients (requests) in each period will be automatically increased progressively.
 So you'll be able to guess the limit performance of the throughput of a server, via the report like following:
 
     n_clients,total_n_requests,queries_per_second,min_elapsed_time,max_elapsed_time,average_elapsed_time,200
@@ -35,39 +35,7 @@ In this scenario, you have to do:
 
 Drnbench will start multiple clients and send many requests based on the patterns file.
 
- 1. Create a patterns file in the format:
-    
-        {
-          "(pattern type 1 name)": {
-            "frequency": (appearance ratio in all requests),
-            "path":      "(path to the endpoint)",
-            "method":    "(HTTP method)",
-            "patterns":  [
-              { "body": (request body 1 sent by POST method) },
-              { "body": (request body 2 sent by POST method) },
-              ...
-            ]
-          }
-          "(patterns type 2 name)": {
-            "frequency": (appearance ratio in all requests),
-            "patterns":  [
-              {
-                "path":   "(path to the endpoint 1)",
-                "method": "(HTTP method)",
-                "body":   (request body 1 sent by POST method)
-              },
-              {
-                "path":   "(path to the endpoint 2)",
-                "method": "(HTTP method)",
-                "body":   (request body 2 sent by POST method)
-              },
-              ...
-            ]
-          },
-          ...
-        }
-    
-    For example, a file "patterns.json" like:
+ 1. Create a patterns file "patterns.json", like:
     
         {
           "user search": {
@@ -108,6 +76,81 @@ Drnbench will start multiple clients and send many requests based on the pattern
     
  4. You'll get a report.
 
+#### Detailed format of the patterns file
+
+##### Abstract
+
+Abstract type A, grouped patterns with names:
+
+~~~
+{
+  "group name 1": (patterns group),
+  "group name 2": (patterns group),
+  ...
+}
+~~~
+
+Abstract type B, grouped patterns without names:
+
+~~~
+[
+  (patterns group),
+  (patterns group),
+  ...
+]
+~~~
+
+Abstract type C, non-grouped patterns:
+
+~~~
+(patterns group)
+~~~
+
+##### Patterns group
+
+Patterns group type A, without options:
+
+~~~
+[
+  (pattern1),
+  (pattern2),
+  ...
+]
+~~~
+
+Patterns group type B, with options:
+
+~~~
+{
+  "frequency": (appearance ratio in all requests, optional),
+  "path":      "(path to the endpoint, optional)",
+  "method":    "(HTTP method, optional)",
+  "patterns":  [
+    (pattern1),
+    (pattern2),
+    ...
+  ]
+}
+~~~
+
+##### Pattern
+
+Pattern type A, simple path string:
+
+~~~
+"/path/to/the/API/or/page"
+~~~
+
+Pattern B, detailed object:
+
+~~~
+{
+  "path":   "/path/to/the/API/or/page",
+  "method": "(HTTP method)",
+  "body":   (request body sent by POST method)
+}
+~~~
+
 
 ### Benchmarking of request-responsne style commands, with a Droonga-based search system
 

data/Rakefile

@@ -15,6 +15,8 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+task :default => :test
+
 require "bundler/gem_helper"
 require "packnga"
 
@@ -31,3 +33,8 @@ Packnga::DocumentTask.new(spec) do |task|
   task.original_language = "en"
   task.translate_languages = ["ja"]
 end
+
+desc "Run tests"
+task :test do
+  ruby("test/run-test.rb")
+end

data/bin/drnbench-extract-searchterms

@@ -19,38 +19,50 @@ require "drnbench"
 require "ostruct"
 require "optparse"
 require "json"
+require "cgi"
 
 options = OpenStruct.new
 options.column_index = 0
+options.escape = false
 
 option_parser = OptionParser.new do |parser|
   parser.version = Drnbench::VERSION
 
   parser.on("--column-index=INDEX", Integer,
             "Index number of the column to be extracted.",
-            "(#{options.output_column_index})") do |index|
+            "(#{options.column_index})") do |index|
     options.column_index = index
   end
+  parser.on("--escape",
+            "Escape output for URL parameter") do
+    options.escape = true
+  end
 end
 
 groonga_select_result_files = option_parser.parse!(ARGV)
 
-def output_column_value(select_result, column_index)
+def escape_for_param(value)
+  CGI.escape(value.to_s)
+end
+
+def output_column_value(select_result, options)
   select_result = JSON.parse(select_result)
   body = select_result[1]
   search_result = body.first
   records = search_result[2..-1]
   records.each do |record|
-    puts record[column_index]
+    value = record[options.column_index]
+    value = escape_for_param(value) if options.escape
+    puts(value)
   end
 end
 
 if groonga_select_result_files.empty?
-  output_column_value($stdin.read, options.column_index)
+  output_column_value($stdin.read, options)
 else
   groonga_select_result_files.each do |select_result_file|
     File.open(select_result_file) do |input|
-      output_column_value(input.read, options.column_index)
+      output_column_value(input.read, options)
     end
   end
 end

data/bin/drnbench-publish-subscribe

@@ -94,7 +94,7 @@ args = option_parser.parse!(ARGV)
 
 config.validate
 
-runner = Drnbench::PublishSubscribe::GradualRunner.new(config)
+runner = Drnbench::PublishSubscribe::ProgressiveRunner.new(config)
 runner.run
 
 File.open(config.output_path, "w") do |file|

data/bin/drnbench-request-response

@@ -23,70 +23,97 @@ config = Drnbench::RequestResponse::Configuration.new
 option_parser = OptionParser.new do |parser|
   parser.version = Drnbench::VERSION
 
+  parser.separator("")
   parser.on("--duration=SECONDS", Float,
-            "duration of the benmark") do |duration|
+            "Duration of each benchmark.",
+            "(#{config.duration})") do |duration|
     config.duration = duration
   end
   parser.on("--wait=SECONDS", Float,
-            "wait for each request") do |wait|
+            "Interval of each request sent by a client.",
+            "(#{config.wait})") do |wait|
     config.wait = wait
   end
+  parser.on("--n-slow-requests=N", Integer,
+            "Number of slow requests to be reported.",
+            "(#{config.n_slow_requests})") do |n_slow_requests|
+    config.n_slow_requests = n_slow_requests
+  end
+
+  parser.separator("")
+  parser.separator("Progressive benchmark:")
   parser.on("--interval=SECONDS", Float,
-            "interval for each gradual case") do |interval|
+            "Interval between each benchmark.",
+            "(#{config.interval})") do |interval|
     config.interval = interval
   end
   parser.on("--start-n-clients=N", Integer,
-            "initial number of clients (optional)") do |n_clients|
+            "Initial number of clients.",
+            "(#{config.start_n_clients})") do |n_clients|
     config.start_n_clients = n_clients
   end
   parser.on("--end-n-clients=N", Integer,
-            "final number of clients (optional)") do |n_clients|
+            "Maximum number of clients.",
+            "(#{config.end_n_clients})") do |n_clients|
     config.end_n_clients = n_clients
   end
   parser.on("--step=COUNT", Integer,
-            "step to increase number of clients (optional)") do |step|
+            "Number of clients increased on each",
+            "progress.",
+            "(#{config.step})") do |step|
     config.step = step
   end
-  parser.on("--n-slow-requests=N", Integer,
-            "number of reporting slow requests (optional)") do |n_slow_requests|
-    config.n_slow_requests = n_slow_requests
-  end
 
+  parser.separator("")
+  parser.separator("Request:")
   parser.on("--mode=MODE", String,
-            "mode of benchmark (optional)",
+            "Request mode.",
             "available modes:",
-            "  http",
+            "  http (default)",
             "  http-droonga-search") do |mode|
     config.mode = mode.gsub(/-/, "_")
   end
   parser.on("--request-patterns-file=PATH",
-            "path to request patterns JSON file") do |path|
+            "Path to request patterns file.") do |path|
     config.request_patterns_file = File.expand_path(path)
   end
 
-  parser.on("--default-host=HOST", String,
-            "default host name (optional)") do |host|
-    config.default_host = host
+  parser.on("--default-hosts=HOST1,HOST2,...", Array,
+            "Default host names for each request.",
+            "(#{config.default_hosts.join(",")})") do |hosts|
+    config.default_hosts = hosts
   end
   parser.on("--default-port=PORT", Integer,
-            "default port number (optional)") do |port|
+            "Default port number for each request.",
+            "(#{config.default_port})") do |port|
     config.default_port = port
   end
   parser.on("--default-path=PATH", String,
-            "default path (optional)") do |path|
+            "Default path for each request",
+            "(#{config.default_path})") do |path|
     config.default_path = path
   end
   parser.on("--default-method=METHOD", String,
-            "default HTTP method (optional)") do |method|
+            "Default HTTP method for each request.",
+            "(#{config.default_method})") do |method|
     config.default_method = method
   end
   parser.on("--default-timeout=SECONDS", Float,
-            "default timeout (optional)") do |timeout|
+            "Default timeout for each request.",
+            "(#{config.default_timeout})") do |timeout|
     config.default_timeout = timeout
   end
+  parser.on("--default-host=HOST1,HOST2,...", Array,
+            "An alias to \"--default-hosts\"",
+            "for backward compatibility.") do |hosts|
+    config.default_hosts = hosts
+  end
 
+  parser.separator("")
+  parser.separator("Output:")
   parser.on("--output-path=PATH",
-            "path to output statistics as a CSV file (optional)") do |path|
+            "Path to output statistics as a CSV file.",
+            "(#{config.output_path})") do |path|
     config.output_path = File.expand_path(path)
   end
 end
@@ -94,7 +121,7 @@ args = option_parser.parse!(ARGV)
 
 config.validate
 
-runner = Drnbench::RequestResponse::GradualRunner.new(config)
+runner = Drnbench::RequestResponse::ProgressiveRunner.new(config)
 runner.run
 
 File.open(config.output_path, "w") do |file|

data/doc/text/news.md

@@ -1,5 +1,14 @@
 # News
 
+## 1.0.3: 2014-10-29 (planned)
+
+ * `drnbench-request-response`
+   * Accept multiple hosts as a comma separated list via the `--default-hosts` option.
+     You can simulate load balancing for multiple endpoints easily.
+   * Accept plain text file of a list of paths as the patterns file.
+ * `drnbench-extract-searchterms`
+   * New `--escape` option is introduced to escape URI-incompatible characters.
+
 ## 1.0.2: 2014-07-30
 
  * 'drnbench-request-response'

data/drnbench.gemspec

@@ -56,4 +56,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency("rake")
   spec.add_development_dependency("packnga")
   spec.add_development_dependency("kramdown")
+  spec.add_development_dependency("test-unit")
 end

data/lib/drnbench.rb

@@ -16,7 +16,7 @@
 require "drnbench/version"
 require "drnbench/request-response/configuration"
 require "drnbench/request-response/runner"
-require "drnbench/request-response/gradual-runner"
+require "drnbench/request-response/progressive-runner"
 require "drnbench/publish-subscribe/configuration"
 require "drnbench/publish-subscribe/runner"
-require "drnbench/publish-subscribe/gradual-runner"
+require "drnbench/publish-subscribe/progressive-runner"

data/lib/drnbench/publish-subscribe/{gradual-runner.rb → progressive-runner.rb}

@@ -18,7 +18,7 @@ require "csv"
 
 module Drnbench
   module PublishSubscribe
-    class GradualRunner
+    class ProgressiveRunner
       attr_reader :total_results
 
       def initialize(config)

data/lib/drnbench/request-response/configuration.rb

@@ -21,23 +21,25 @@ module Drnbench
       attr_accessor :duration, :wait, :interval, :request_patterns_file
       attr_accessor :start_n_clients, :end_n_clients, :step, :n_requests, :n_slow_requests
       attr_accessor :mode
-      attr_accessor :default_host, :default_port, :default_path, :default_method, :default_timeout
+      attr_reader   :default_hosts
+      attr_accessor :default_port, :default_path, :default_method, :default_timeout
       attr_accessor :report_progressively, :output_path
 
       MIN_DURATION = 1
       MIN_WAIT     = 0
 
       def initialize
-        @wait                 = 1
-        @interval             = 5
-        @start_n_clients      = 1
+        @duration             = 30
+        @wait                 = 0.01
+        @interval             = 10
+        @start_n_clients      = 0
         @end_n_clients        = 1
         @step                 = 1
         @n_requests           = 1000
         @mode                 = :http
         @n_slow_requests      = 5
 
-        @default_host         = "localhost"
+        @default_hosts        = ["localhost"]
         @default_port         = 80
         @default_path         = "/"
         @default_method       = "GET"
@@ -45,6 +47,8 @@ module Drnbench
 
         @report_progressively = true
         @output_path          = "/tmp/drnbench-result.csv"
+
+        @last_default_host_index = 0
       end
 
       def validate
@@ -72,10 +76,29 @@ module Drnbench
         @request_patterns ||= prepare_request_patterns
       end
 
+      def default_hosts=(hosts)
+        @last_default_host_index = 0
+        @default_hosts = hosts
+      end
+
+      def default_host
+        host = @default_hosts[@last_default_host_index]
+        @last_default_host_index += 1
+        if @last_default_host_index == @default_hosts.size
+          @last_default_host_index = 0
+        end
+        host
+      end
+
       private
       def prepare_request_patterns
         request_patterns = File.read(@request_patterns_file)
-        request_patterns = JSON.parse(request_patterns)
+        begin
+          request_patterns = JSON.parse(request_patterns)
+        rescue JSON::ParserError
+          # it's a simple text file, list of paths
+          request_patterns = request_patterns.strip.split(/\r?\n/)
+        end
       end
     end
   end

data/lib/drnbench/request-response/{gradual-runner.rb → progressive-runner.rb}

@@ -18,7 +18,7 @@ require "csv"
 
 module Drnbench
   module RequestResponse
-    class GradualRunner
+    class ProgressiveRunner
       attr_reader :report_progressively, :result
 
       def initialize(config)

data/lib/drnbench/request-response/request-pattern.rb

@@ -0,0 +1,194 @@
+# Copyright (C) 2013-2014  Droonga Project
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+module Drnbench
+  module RequestResponse
+    module RequestPattern
+      class Abstract
+        def initialize(source, config)
+          @source = source
+          @config = config
+        end
+
+        def groups
+          @groups ||= prepare_groups
+        end
+
+        def default_group_frequency
+          1.0 / groups.size
+        end
+
+        def requests
+          @requests ||= populate_requests
+        end
+
+        private
+        def prepare_groups
+          if @source.is_a?(Array)
+            if PatternsGroup.valid_source?(@source.first)
+              return @source.collect do |group|
+                PatternsGroup.new(group, self)
+              end
+            end
+            if PatternsGroup.valid_source?(@source)
+              return [
+                PatternsGroup.new(@source, self),
+              ]
+            end
+          elsif @source.is_a?(Hash)
+            if PatternsGroup.valid_source?(@source)
+              return [
+                PatternsGroup.new(@source, self),
+              ]
+            end
+            return @source.values.collect do |group|
+              PatternsGroup.new(group, self)
+            end
+          end
+
+          []
+        end
+
+        def populate_requests
+          requests = []
+          groups.each do |group|
+            n_requests = @config.n_requests * @config.end_n_clients * group.frequency
+            base_patterns = group.patterns.shuffle
+            n_requests.round.times do |count|
+              pattern = base_patterns[count % base_patterns.size]
+              requests << pattern.to_request
+            end
+          end
+          requests
+        end
+      end
+
+      class PatternsGroup
+        class << self
+          def valid_source?(source)
+            if source.is_a?(Array)
+              return Pattern.valid_source?(source.first)
+            end
+            if source.is_a?(Hash)
+              return source.has_key?("patterns")
+            end
+            false
+          end
+        end
+
+        attr_reader :abstract
+
+        def initialize(source, abstract)
+          @source = source
+          @abstract = abstract
+        end
+
+        def frequency
+          if @source.is_a?(Hash) and @source.has_key?("frequency")
+            return @source["frequency"].to_f
+          end
+          @abstract.default_group_frequency
+        end
+
+        def host
+          return nil unless @source.is_a?(Hash)
+          @source["host"]
+        end
+
+        def port
+          return nil unless @source.is_a?(Hash)
+          @source["port"]
+        end
+
+        def method
+          return nil unless @source.is_a?(Hash)
+          @source["method"]
+        end
+
+        def timeout
+          return nil unless @source.is_a?(Hash)
+          @source["timeout"]
+        end
+
+        def patterns
+          @patterns ||= prepare_patterns
+        end
+
+        private
+        def prepare_patterns
+          if @source.is_a?(Hash)
+            if @source.has_key?("pattern")
+              return [
+                Pattern.new(@source["pattern"], self),
+              ]
+            else
+              return @source["patterns"].collect do |pattern|
+                Pattern.new(pattern, self)
+              end
+            end
+          elsif @source.is_a?(Array)
+            return @source.collect do |pattern|
+              Pattern.new(pattern, self)
+            end
+          end
+        end
+      end
+
+      class Pattern
+        class << self
+          def valid_source?(source)
+            return true if source.is_a?(String)
+            return false if source.is_a?(Array)
+            return !source.has_key?("patterns") if source.is_a?(Hash)
+            false
+          end
+        end
+
+        attr_reader :source, :group
+
+        def initialize(source, group)
+          @source = source
+          @group = group
+        end
+
+        def path
+          if @source.is_a?(String)
+            @source
+          else
+            @source["path"]
+          end
+        end
+
+        def to_request
+          @populated ||= populate
+        end
+
+        private
+        def populate
+          if @source.is_a?(String)
+            request = { "path" => @source }
+          else
+            request = @source
+          end
+          request["host"] ||= @group.host
+          request["port"] ||= @group.port
+          request["method"] ||= @group.method
+          request["timeout"] ||= @group.timeout
+          request
+        end
+      end
+    end
+  end
+end

data/lib/drnbench/request-response/runner.rb

@@ -16,6 +16,7 @@
 require "drnbench/client/http"
 require "drnbench/client/http-droonga"
 require "drnbench/request-response/result"
+require "drnbench/request-response/request-pattern"
 
 module Drnbench
   module RequestResponse
@@ -26,7 +27,9 @@ module Drnbench
         n_clients = 1 if n_clients.zero?
         @n_clients = n_clients
         @config = config
-        populate_requests
+
+        abstract = RequestPattern::Abstract.new(@config.request_patterns, @config)
+        @requests = abstract.requests.shuffle
       end
 
       def run
@@ -79,44 +82,6 @@ module Drnbench
 
         @result
       end
-
-      def populate_requests
-        @requests = []
-
-        if @config.request_patterns.is_a?(Array)
-          @config.request_patterns.each do |request_pattern|
-            populate_request_pattern(request_pattern)
-          end
-        else
-          @config.request_patterns.each do |key, request_pattern|
-            populate_request_pattern(request_pattern)
-          end
-        end
-
-        @requests.shuffle!
-      end
-
-      def populate_request_pattern(request_pattern)
-        frequency = request_pattern["frequency"].to_f
-        n_requests = @config.n_requests * @config.end_n_clients * frequency
-
-        base_patterns = nil
-        if request_pattern["pattern"]
-          base_patterns = [request_pattern["pattern"]]
-        else
-          base_patterns = request_pattern["patterns"]
-        end
-        base_patterns = base_patterns.shuffle
-
-        n_requests.round.times do |count|
-          pattern = base_patterns[count % base_patterns.size]
-          pattern["host"] ||= request_pattern["host"]
-          pattern["port"] ||= request_pattern["port"]
-          pattern["method"] ||= request_pattern["method"]
-          pattern["timeout"] ||= request_pattern["timeout"]
-          @requests << pattern
-        end
-      end
     end
   end
 end

data/lib/drnbench/version.rb

@@ -14,5 +14,5 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 module Drnbench
-  VERSION = "1.0.2"
+  VERSION = "1.0.3"
 end

data/test/request-response/test-request-pattern.rb

@@ -0,0 +1,111 @@
+# Copyright (C) 2014 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+require "ostruct"
+require "drnbench/request-response/request-pattern"
+
+module Drnbench::RequestResponse::RequestPattern
+  class RequestResponsePatternsTest < Test::Unit::TestCase
+    CONFIG = OpenStruct.new
+    CONFIG.n_requests = 1
+    CONFIG.end_n_clients = 1
+
+    PATH_STRING = "/path/to/endpoint"
+    PATTERN_HASH = { "path" => PATH_STRING }
+
+    class PatternTest < self
+      data("path string" => PATH_STRING,
+           "hash" => PATTERN_HASH)
+      def test_validation(source)
+        Pattern.valid_source?(source)
+      end
+    end
+
+    class PatternsGroupTest < self
+      data("path string array" => [
+             PATH_STRING,
+           ],
+           "hash array" => [
+             PATTERN_HASH,
+           ],
+           "hash with path string array" => {
+             "patterns" => [
+               PATH_STRING,
+             ],
+           },
+           "hash with hash array" => {
+             "patterns" => [
+               PATTERN_HASH,
+             ],
+           })
+      def test_validation(source)
+        PatternsGroup.valid_source?(source)
+      end
+    end
+
+    class AbstractTest < self
+      data("path string array" => [
+             PATH_STRING,
+           ],
+           "pattern hash array" => [
+             PATTERN_HASH,
+           ],
+
+           "group, hash with path string array" => {
+             "patterns" => [
+               PATH_STRING,
+             ],
+           },
+           "group, hash with hash array" => {
+             "patterns" => [
+               PATTERN_HASH,
+             ],
+           },
+
+           "array of groups, path string array" => [
+             [PATH_STRING],
+           ],
+           "array of groups, hash array" => [
+             [PATTERN_HASH],
+           ],
+           "array of groups, hash with path string array" => [
+             { "patterns" => [PATH_STRING] },
+           ],
+           "array of groups, hash with hash array" => [
+             { "patterns" => [PATTERN_HASH] },
+           ],
+
+           "named groups, path string array" => {
+             "group" => [PATH_STRING],
+           },
+           "named groups, hash array" => {
+             "group" => [PATTERN_HASH],
+           },
+           "named groups, hash with path string array" => {
+             "group" => { "patterns" => [PATH_STRING] },
+           },
+           "named groups, hash with hash array" => {
+             "group" => { "patterns" => [PATTERN_HASH] },
+           })
+      def test_parse(source)
+        abstract = Abstract.new(source, CONFIG)
+        assert_equal(PATH_STRING,
+                     abstract.groups.first.patterns.first.path)
+        assert_equal(1.0,
+                     abstract.groups.first.frequency)
+      end
+    end
+  end
+end

data/test/run-test.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2013 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+require "pathname"
+
+require "rubygems"
+require "bundler"
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require "test-unit"
+
+base_dir = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+lib_dir = File.join(base_dir, "lib")
+test_dir = File.join(base_dir, "test")
+
+$LOAD_PATH.unshift(lib_dir)
+$LOAD_PATH.unshift(test_dir)
+
+ARGV.unshift("--max-diff-target-string-size=10000")
+
+exit Test::Unit::AutoRunner.run(true, test_dir)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: drnbench
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.3
 platform: ruby
 authors:
 - YUKI Hiroshi
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-31 00:00:00.000000000 Z
+date: 2014-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -109,6 +109,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: It may be used for other HTTP servers.
 email:
 - yuki@clear-code.com
@@ -121,33 +135,36 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- README.md
-- Rakefile
 - Gemfile
-- drnbench.gemspec
 - LICENSE.txt
+- README.md
+- Rakefile
+- bin/drnbench-extract-searchterms
+- bin/drnbench-generate-select-patterns
+- bin/drnbench-publish-subscribe
+- bin/drnbench-request-response
 - doc/text/news.md
-- lib/drnbench/client/http.rb
+- drnbench.gemspec
+- lib/drnbench.rb
+- lib/drnbench/chart/gnuplot.rb
 - lib/drnbench/client/http-droonga.rb
-- lib/drnbench/request-response/gradual-runner.rb
+- lib/drnbench/client/http.rb
+- lib/drnbench/publish-subscribe/configuration.rb
+- lib/drnbench/publish-subscribe/progressive-runner.rb
+- lib/drnbench/publish-subscribe/runner.rb
+- lib/drnbench/publish-subscribe/watch.rb
+- lib/drnbench/reporters/throughput-reporter.rb
 - lib/drnbench/request-response/configuration.rb
+- lib/drnbench/request-response/progressive-runner.rb
+- lib/drnbench/request-response/request-pattern.rb
 - lib/drnbench/request-response/result.rb
 - lib/drnbench/request-response/runner.rb
-- lib/drnbench/reporters/throughput-reporter.rb
-- lib/drnbench/version.rb
-- lib/drnbench/chart/gnuplot.rb
-- lib/drnbench/publish-subscribe/watch.rb
-- lib/drnbench/publish-subscribe/gradual-runner.rb
-- lib/drnbench/publish-subscribe/configuration.rb
-- lib/drnbench/publish-subscribe/runner.rb
-- lib/drnbench/server/protocol-adapter.rb
-- lib/drnbench/server/engine.rb
 - lib/drnbench/server/configuration.rb
-- lib/drnbench.rb
-- bin/drnbench-extract-searchterms
-- bin/drnbench-generate-select-patterns
-- bin/drnbench-request-response
-- bin/drnbench-publish-subscribe
+- lib/drnbench/server/engine.rb
+- lib/drnbench/server/protocol-adapter.rb
+- lib/drnbench/version.rb
+- test/request-response/test-request-pattern.rb
+- test/run-test.rb
 homepage: https://github.com/groonga/grntest
 licenses:
 - GPLv3 or later
@@ -168,9 +185,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.4.1
 signing_key: 
 specification_version: 4
 summary: Drnbench is a benchmark tool for Droonga.
-test_files: []
+test_files:
+- test/run-test.rb
+- test/request-response/test-request-pattern.rb
 has_rdoc: