em-http-test 0.1.0

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+gem "eventmachine"
+gem "em-http-request"

data/README.md

@@ -0,0 +1,52 @@
+em-http-test
+============
+
+Ruby EventMachine-base HTTP load testing library that allows writing simple web application testing scenarios
+that are run using high performance asynchronous IO powered by EventMachine and em-http-request.
+
+Requirements are EventMachine, em-http-request and fiber.
+
+Usage is very simple, for example:
+
+    #!/usr/bin/ruby
+
+    require 'em-http-test'
+
+    concurrency = 10000
+    runtime = 300
+
+    p EM::HttpTest::run(concurrency, runtime) do
+        response = EM::HttpTest::post('http://mytestapp/login') :query => { 'username' => 'oded', 'password' => '123' }
+        sessionid = response['PHPSESSIONID']
+        raise EM::HttpTest::TestFailure, "Error in login" unless response.response_header.status == 200
+        response = EM::HttpTest::get('http://mytestapp/list') :query => { 'filter' => 'all' },
+            :head { 'PHPSESSIONID' => sessionid }
+        raise EM::HttpTest::TestFailure, "Error in list" unless response.response_header.status == 200
+    end
+
+The block passed to `run()` will be executed continously for 300 seconds, with 10,000 sessions running simoultaneously.
+The `EventMachine::HttpTest::post` and `EventMachine::HttpTest::get` are used to dispatch the HTTP requests in an
+apparently synchronous manner allowing test sessions to be written using a simple programming model. 
+
+The named arguments passed to `post()` and `get()` are passed to em-http-request and any arguments supported by 
+em-http-request can be used. To facilitate ease of use, `HttpTest` will convert `:query` data to `:body` content
+when using `post()`. The return value for `post()` and `get()` is the em-http-request client with the response
+data, which can be examined according to the em-http-request API.
+
+To abort a testing session without aborting the entire load test, raise `EventMachine::HttpTest::TestFailure`. All such
+errors will be collected, the aborted session will be counted as a test failure and the exception data will be available
+in the test results summary.
+
+The return value from `run()` is a hash with the following fields:
+
+* `:total`       - total number of sessions that were run
+* `:success`      - total number of sessions that completed without raising a TestFailure
+* `:failure`      - total number of sessions that raised a TestFailure
+* `:failures`     - array containing the exception data element for each failed session
+* `:failure_rate` - the rate of session failures compared to completed sessions (0 to 1)
+* `:min`          - the number of seconds that the fastest session completed in
+* `:max`          - the number of seconds that the slowest session completed in
+* `:average`      - average number of seconds for all test sessions (including failures)
+* `:percentile95` - 95% of the sessions completed in this number of seconds or less
+
+Results in seconds could be fractional seconds.

data/em-http-test.gemspec

@@ -0,0 +1,26 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+require 'em-http-test/version'
+
+Gem::Specification.new do |s|
+	s.name        = "em-http-test"
+	s.version     = EventMachine::HttpTest::VERSION
+	
+	s.platform    = Gem::Platform::RUBY
+	s.authors     = ["Oded Arbel"]
+	s.email       = ["oded@heptagon.co.il"]
+	s.homepage    = "https://github.com/guss77/em-http-test"
+	s.summary     = "EventMachine based, high performance web application load test framework"
+	s.description = s.summary
+	#s.rubyforge_project = "em-http-test"
+	
+	#s.add_dependency "eventmachine", ">= 0.12.0"
+	s.add_dependency "em-http-request", ">= 0.3.0"
+	
+	s.add_development_dependency "rspec"
+	
+	s.files         = `git ls-files`.split("\n")
+	#s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+	s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+	s.require_paths = ["lib"]
+end

data/lib/em-http-test/definitions.rb

@@ -0,0 +1,13 @@
+# EventMachine based HTTP load testing tool
+#
+# Author:: 		Oded Arbel (mailto:oded@heptagon.co.il)
+# Copyright::	Copyright (c) 2013 Heptagon Software
+# License::		GPL v3
+
+# define name space modules
+
+module EventMachine
+end
+
+module EventMachine::HttpTest
+end

data/lib/em-http-test/load-test.rb

@@ -0,0 +1,74 @@
+# EventMachine based HTTP load testing tool
+#
+# Author:: 		Oded Arbel (mailto:oded@heptagon.co.il)
+# Copyright::	Copyright (c) 2013 Heptagon Software
+# License::		GPL v3
+
+module EventMachine::HttpTest
+	
+	# Run the specified test in the specified concurrency
+	class LoadTest
+		include EM::Deferrable
+		
+		def initialize(concurrency, &block)
+			@concurrency = concurrency
+			@runners = [] # list of currently running tests
+			@failureCB = [] # list of failure callbacks
+			@successCB = [] # list of success callbacks
+			@test = block
+			@running = true
+			
+			@concurrency.times { self.startTest }
+		end
+
+		# stop the test and don't execute any more test runners
+		def abort
+			@running = false
+		end
+
+		# register a failure handler
+		def onfailure(&block)
+			@failureCB << block
+		end
+
+		# register a success handler
+		def onsuccess(&block)
+			@successCB << block
+		end
+		
+		def count
+			return @runners.size
+		end
+
+		# Add a new test runner
+		def startTest
+			return unless @running # don't start new tests if the EventMachine is stopping
+			startAt = Time.new
+			# create a new runner and add it to the queue
+			runner = TestRunner.new(Fiber.new { @test.call })
+			@runners << runner
+			runner.errback do |e| # if the runner failed
+				@runners.delete(runner) # remove it from the queue
+				@failureCB.each { |b| b.call(Time.new - startAt, e) } # notify the failure handler
+				self.tick # then tick the load test
+			end
+			runner.callback do # if the runnner completed
+				@runners.delete(runner) # remove it from the queue
+				@successCB.each { |b| b.call(Time.new - startAt) } # notify the success handler
+				self.tick # then tick the load test
+			end
+		end
+
+		# Replenish test runners
+		def tick
+			if !@running and @runners.count < 1
+				EM.stop
+				return
+			end
+			missing = @concurrency - @runners.count
+			missing.times { self.startTest }
+		end
+
+	end
+
+end

data/lib/em-http-test/test-failure.rb

@@ -0,0 +1,20 @@
+# EventMachine based HTTP load testing tool
+#
+# Author:: 		Oded Arbel (mailto:oded@heptagon.co.il)
+# Copyright::	Copyright (c) 2013 Heptagon Software
+# License::		GPL v3
+
+module EventMachine::HttpTest
+	
+	# Exception to raise in test code to signify a test failure
+	class TestFailure < Exception
+	
+		attr_accessor :message
+		
+		def initialize(text)
+			self.message = text;
+		end
+		
+	end
+	
+end

data/lib/em-http-test/test-request.rb

@@ -0,0 +1,42 @@
+# EventMachine based HTTP load testing tool
+#
+# Author:: 		Oded Arbel (mailto:oded@heptagon.co.il)
+# Copyright::	Copyright (c) 2013 Heptagon Software
+# License::		GPL v3
+
+module EventMachine::HttpTest
+	
+	# Base test request object that contains the test data
+	class Request
+	
+		def initialize(type, url, options = {})
+			@type = type
+			@url = url
+			@options = options
+			if @type == :POST and !@options[:query].nil?
+				@options[:body] = @options[:query]
+				@options.delete(:query)
+			end
+		end
+		
+		def toRequest
+			case @type
+			when :GET
+				EM::HttpRequest.new(@url).get @options
+			when :POST
+				EM::HttpRequest.new(@url).post @options
+			end
+		end
+	end
+
+	# do a evented HTTP GET
+	def self.get(url, options = {})
+		Fiber.yield Request.new(:GET, url, options)
+	end
+
+	# do a evented HTTP POST
+	def self.post(url, options = {})
+		Fiber.yield Request.new(:POST, url, options)
+	end
+
+end

data/lib/em-http-test/test-runner.rb

@@ -0,0 +1,53 @@
+# EventMachine based HTTP load testing tool
+#
+# Author:: 		Oded Arbel (mailto:oded@heptagon.co.il)
+# Copyright::	Copyright (c) 2013 Heptagon Software
+# License::		GPL v3
+
+# Run a single HTTP test by iterating through the test operatins until the test
+# either raises TestFailure or completes successfully
+module EventMachine::HttpTest
+	
+	class TestRunner
+		include EM::Deferrable
+		
+		def initialize(f)
+			@fiber = f
+			@testreq = @fiber.resume # first call, so no data to test
+			process
+		end
+		
+		# Run a step of the test by calling the test generated URL
+		# and submitting the results to be processed
+		def process
+			unless @fiber.alive?
+				# if the fiber has completed, then we succeeded
+				self.succeed()
+				return
+			end
+			
+			# do another run
+			request = @testreq.toRequest
+			request.errback { |r| self.fail("HTTP error calling #{r.last_effective_url}: #{r.response_header.status}") }
+			request.callback do |r|
+				if r.response_header.status >= 400
+					self.fail("HTTP error #{r.response_header.status}")
+					next
+				end
+				
+				begin
+					@testreq = @fiber.resume r
+					case when @testreq.nil?
+						self.succeed("Test is done")
+					else
+						self.process
+					end
+				rescue TestFailure => e
+					self.fail(e.message)
+				end
+			end
+		end
+		
+	end
+
+end

data/lib/em-http-test/version.rb

@@ -0,0 +1,5 @@
+module EventMachine
+  class HttpTest
+    VERSION = "0.1.0"
+  end
+end

data/lib/em-http-test.rb

@@ -0,0 +1,57 @@
+# EventMachine based HTTP load testing tool
+#
+# Author:: 		Oded Arbel (mailto:oded@heptagon.co.il)
+# Copyright::	Copyright (c) 2013 Heptagon Software
+# License::		GPL v3
+
+require 'rubygems'
+require 'eventmachine'
+require 'em-http'
+require 'fiber'
+
+require 'em-http-test/definitions'
+require 'em-http-test/test-failure'
+require 'em-http-test/test-runner'
+require 'em-http-test/load-test'
+require 'em-http-test/test-request'
+
+module EventMachine::HttpTest
+	
+	# run a load test by executing the test block multiple times in the
+	# specified concurrency. The test will be executed for a total of runtime seconds
+	def self.run(concurrency, runtime, &block)
+		stats = { 
+			:total => 0,
+			:success => 0,
+			:failure => 0,
+			:failures => [],
+		}
+		
+		successTimes = []
+		
+		if block.nil?
+			stats[:error] = 'Invalid test block'
+			return stats
+		end
+		
+		startTime = Time.new
+		
+		EventMachine.run do
+			test = LoadTest.new(concurrency) { block.call }
+			test.onsuccess { |t| stats[:success] += 1; stats[:total] += 1; successTimes << t }
+			test.onfailure { |t,e| stats[:failure] += 1; stats[:total] += 1; successTimes << t; stats[:failures] << e }
+			EventMachine.add_periodic_timer(1) { puts "#{stats[:total]} tests run in #{(Time.new - startTime).to_i} seconds" }
+			EventMachine.add_timer(runtime) { test.abort }
+		end
+		
+		successTimes = successTimes.sort
+		stats[:average] = (successTimes.reduce(:+).to_f / successTimes.size).round(2)
+		stats[:percentile95] = (successTimes[(successTimes.count*0.95).to_i]).round(2)
+		stats[:min] = (successTimes[0]).round(2)
+		stats[:max] = (successTimes[-1]).round(2)
+		stats[:failure_rate] = (stats[:failure].to_f / stats[:total]).round(2)
+		
+		return stats
+	end
+
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: em-http-test
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Oded Arbel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: em-http-request
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: EventMachine based, high performance web application load test framework
+email:
+- oded@heptagon.co.il
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- README.md
+- em-http-test.gemspec
+- lib/em-http-test.rb
+- lib/em-http-test/definitions.rb
+- lib/em-http-test/load-test.rb
+- lib/em-http-test/test-failure.rb
+- lib/em-http-test/test-request.rb
+- lib/em-http-test/test-runner.rb
+- lib/em-http-test/version.rb
+homepage: https://github.com/guss77/em-http-test
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: EventMachine based, high performance web application load test framework
+test_files: []