rfuzz 0.6

data/test/server.rb

@@ -0,0 +1,101 @@
+require 'rubygems'
+require 'mongrel'
+require 'digest/md5'
+require 'rfuzz/random'
+
+$cookies_count = 0
+
+class CookieHandler < Mongrel::HttpHandler
+  def process(request, response)
+    if request.params["HTTP_COOKIE"]
+      $cookies_count += 1
+    end
+
+    response.start do |head,out|
+      head["Set-Cookie"] = "_session_id=ASDFADSFASDFADSFADSFDSAFADSF"
+      out.write("test")
+    end
+  end
+end
+
+# Returns one of three things to the client as the response body depending
+# on what the client sends:
+# * the body if larger than 0
+# * the HTTP_X_TESTSEND if that's given
+# * the REQUEST_METHOD if nothing else
+class TestHandler < Mongrel::HttpHandler
+  def process(request, response)
+    response.start do |head,out|
+      head["Content-Type"] = "text/html"
+      if request.body.length > 0
+        out.write(request.body.read)
+      elsif request.params["HTTP_X_TESTSEND"]
+        out.write(request.params["HTTP_X_TESTSEND"])
+      else
+        out.write(request.params["REQUEST_METHOD"])
+      end
+    end
+  end
+end
+
+
+# Returns a test chunked encoding with @random size chunks and then
+# sets the X-Real-Length header to what the resulting body should be,
+# and X-MD5-Sum to the hash that should result.
+class ChunkedHandler < Mongrel::HttpHandler
+  def process(request, response)
+    response.start do |head,out|
+      head['Transfer-Encoding'] = "chunked"
+
+      chunks = []
+      @rand = RFuzz::RandomGenerator.new(open("resources/words.txt").read.split("\n"))
+      (@rand.num(20)+10).times { 
+        chunks << @rand.base64(@rand.num(60)+10).join('') 
+      }
+
+      result_body = chunks.join('')
+      head['X-Real-Length'] = result_body.length
+      head['X-MD5-Sum'] = Digest::MD5.new(result_body)
+
+      chunks.each_with_index {|c,i| 
+        # chunk header
+        out.write("#{c.length.to_s(base=16)}#{random_chunk_header}\r\n")
+        out.write(c)
+        out.write("\r\n")
+      }
+
+      case @rand.num(4)
+      when 0
+        out.write("0\r\n")
+      when 1
+        out.write("\r\n")
+      when 2
+        out.write("0\r\n#{@random_chunk_header}")
+      when 3
+        out.write("\r\n#{@random_chunk_header}")
+      end
+    end
+  end
+
+  def random_chunk_header
+    if @rand.num(1) == 0
+      hash = @rand.hash_of(1,5,:words)[0]
+      hash.collect {|k,v| ";#{k}=#{v}"}
+    else
+      ""
+    end
+  end
+end
+
+config = Mongrel::Configurator.new :host => "127.0.0.1", :port => "3001" do
+  listener do
+    uri "/cookies", :handler => CookieHandler.new
+    uri "/test", :handler => TestHandler.new
+    uri "/chunked", :handler => ChunkedHandler.new
+    uri "/error404", :handler => Mongrel::Error404Handler.new("file missing")
+    redirect "/redir", "/test"
+  end
+end
+
+
+$server = Thread.new { config.run; config.join }

data/test/test_client.rb

@@ -0,0 +1,164 @@
+
+# Copyright (c) 2006 Zed A. Shaw 
+# You can redistribute it and/or modify it under the same terms as Ruby.
+
+require 'test/unit'
+require 'rfuzz/client'
+load 'test/server.rb'
+require 'digest/md5'
+
+include RFuzz
+
+class TestNotifier < Notifier
+  attr_reader :event_count
+
+  def initialize
+    @event_count = 0
+  end
+
+  def connect(state)
+    @event_count += 1
+  end
+
+  def send_request(state)
+    @event_count += 1
+  end
+
+  def read_header(state)
+    @event_count += 1
+  end
+
+  def read_body(state)
+    @event_count += 1
+  end
+
+  def close(state)
+    @event_count += 1
+  end
+end
+
+class RFuzzClientTest < Test::Unit::TestCase
+
+  def setup
+    @port = 3001
+    @host = "127.0.0.1"
+    @client = HttpClient.new(@host, @port, :redirect => 10)
+  end
+
+  def tearDown
+  end
+
+  def test_cookies
+    cl = HttpClient.new(@host, @port)
+    cl.get("/cookies")
+    assert cl.cookies["_session_id"]
+    assert_equal 0, $cookies_count
+    cl.get("/cookies")
+    assert cl.cookies["_session_id"]
+    assert_equal 1, $cookies_count
+  end
+
+  def test_get
+    resp = @client.get("/test/get")
+    assert_method "GET", resp
+    resp = @client.get("/test/get/query", :query => {"q" => "test"}, :head => { "X-TestSend" => "Status"})
+    assert_header("Status", resp)
+    resp = @client.get("/test/get/query/header", 
+                       :query => {"q" => "test", "a" => [1,2,3]}, 
+                       :head => { "X-TestSend" => "Status"})
+    assert_header("Status", resp)
+  end
+
+  def test_redirect
+    resp = @client.get("/redir")
+    assert_equal "200", resp.http_status, "wrong status"
+  end
+
+  def test_post
+    resp = @client.post("/test/post")
+    assert_method "POST", resp
+    resp = @client.post("/test/post/header", :head => {"X-TestSend" => "Status"}, :body => "TEST BODY")
+    assert_body "TEST BODY", resp
+  end
+
+  def test_put
+    resp = @client.put("/test/put")
+    assert_method("PUT",resp)
+    resp = @client.put("/test/put/header", :head => {"X-TestSend" => "Status"})
+    assert_header("Status", resp)
+    resp = @client.put("/test/put/header/multi", :head => {"X-TestSend" => ["Status", "AGAIN"]})
+  end
+
+  def test_delete
+    resp = @client.delete("/test/delete")
+    assert_method("DELETE", resp)
+  end
+
+  def test_head
+    resp = @client.head("/test/head")
+    assert_method("HEAD", resp)
+  end
+
+  def test_status
+    resp = @client.get("/error404")
+    assert_status "404", resp
+    resp = @client.get("/test/200")
+    assert_status "200", resp
+  end
+
+  def test_overrides
+    cl = HttpClient.new(@host, @port, :head => {"X-Override" => "Test"})
+    assert cl.options[:head], "missing override header"
+  end
+
+  def test_allowed_methods
+    cl = HttpClient.new(@host, @port, :allowed_methods => [:nada])
+    assert_raises RuntimeError do
+      cl.get("/test/wrongmethod")
+    end
+  end
+
+
+  def test_notifier
+    cl = HttpClient.new(@host, @port, :notifier => TestNotifier.new)
+    cl.get("/test/notifier")
+    assert_equal 10, cl.notifier.event_count, "not all events fired"
+   
+    # try to get notified about errors
+    assert_raises Errno::ECONNREFUSED do
+      cl = HttpClient.new(@host, "300", :notifier => TestNotifier.new)
+      cl.get("/test/notifier/fail")
+    end
+
+    assert_equal 2, cl.notifier.event_count, "not all events fired"
+  end
+
+
+  def test_chunked_encoding
+    50.times do
+      resp = @client.get("/chunked")
+      assert_equal resp["X_REAL_LENGTH"].to_i, resp.http_body.length
+      assert_equal resp["X_MD5_SUM"],Digest::MD5.new(resp.http_body).to_s
+    end
+  end
+
+
+  def assert_method(method, resp)
+    assert_equal method, resp.http_body
+  end
+
+  def assert_body(body, resp)
+    assert_equal body, resp.http_body
+  end
+
+  def assert_header(sent, resp)
+    assert_equal sent, resp.http_body
+  end
+
+  def assert_status(status, resp)
+    assert_equal status, resp.http_status
+  end
+
+
+
+end

data/test/test_fuzzrnd.rb

@@ -0,0 +1,31 @@
+# Copyright (c) 2006 Zed A. Shaw 
+# You can redistribute it and/or modify it under the same terms as Ruby.
+
+require 'test/unit'
+require 'fuzzrnd'
+
+include RFuzz
+
+class FuzzRndTest < Test::Unit::TestCase
+  
+  def test_seed_data
+    fr = FuzzRnd.new("TEST SEED")
+    d1 = fr.data(100)
+    assert_equal 100, d1.length, "wrong length"
+
+    d2 = fr.seed("TEST SEED").data(100)
+    assert_equal 100, d2.length, "wrong length"
+
+    assert_equal d1,d2, "same keys should produce same random"
+  end
+
+
+  def test_gen_numbers
+    fr = FuzzRnd.new("TEST SEED")
+    ints = fr.data(100 * 4).unpack("N*")
+    assert_equal 100,ints.length, "didn't get 100 ints"
+
+    floats = fr.data(50 * 8).unpack("G*")
+    assert_equal 50,floats.length, "didn't get 50 floats"
+  end
+end

data/test/test_httpparser.rb

@@ -0,0 +1,48 @@
+
+# Copyright (c) 2006 Zed A. Shaw 
+# You can redistribute it and/or modify it under the same terms as Ruby.
+
+require 'test/unit'
+require 'http11_client'
+require 'socket'
+
+include RFuzz
+
+class HttpClientParserTest < Test::Unit::TestCase
+    
+  def test_parse_simple
+    parser = HttpClientParser.new
+    req = HttpResponse.new
+    http = "HTTP/1.1 200 OK\r\nContent-Length: 20\r\n\r\n01234567890123456789"
+    nread = parser.execute(req, http, 0)
+    assert_equal 39, nread, "Failed to parse the full HTTP request after #{nread}"
+    assert parser.finished?, "Parser didn't finish"
+    assert !parser.error?, "Parser had error"
+    assert nread == parser.nread, "Number read returned from execute does not match"
+    assert_equal "20", req["CONTENT_LENGTH"], "Wrong content length header"
+    parser.reset
+    assert parser.nread == 0, "Number read after reset should be 0"
+  end
+
+  def parse(body, size, expect_req)
+    parser = HttpClientParser.new
+    req = HttpResponse.new
+    nread = parser.execute(req, body, 0)
+    assert_equal nread, body.length
+    assert !parser.error?
+    assert parser.finished?
+
+    # check data results
+    assert_equal size, req.http_chunk_size.to_i
+    expect_req.each {|k,v|assert_not_nil k; assert_equal req[k.upcase], v}
+  end
+
+  def test_http_parser
+    parse "3;test=stuff;lone\r\n", 3, {"test" => "stuff", "lone" => ""}
+    parse "0\r\n",0,{}
+    parse "\r\n",0,{}
+    parse ";test;test2=test2\r\n",0,{"test" => "", "test2" => "test2"}
+    parse "0;test;test2=test2\r\n",0,{"test" => "", "test2" => "test2"}
+  end
+
+end

data/test/test_random.rb

@@ -0,0 +1,75 @@
+# Copyright (c) 2006 Zed A. Shaw 
+# You can redistribute it and/or modify it under the same terms as Ruby.
+
+require 'test/unit'
+require 'socket'
+require 'rfuzz/random'
+
+include RFuzz
+
+class RandomGeneratorTest < Test::Unit::TestCase
+  def setup
+    @rand = RandomGenerator.new(open("resources/words.txt").read.split("\n"))
+  end
+
+  def test_headers
+    h = @rand.headers(20,10)
+    assert_equal 20,h.length, "wrong number of headers"
+
+    [:words,:base64,:uris,:byte_array,:ints,:floats].each do |t|
+      h = @rand.headers(20,10,type=t)
+      assert_equal 20,h.length
+    end
+
+  end
+
+  def test_queries
+    q = @rand.queries(20,10)
+    assert_equal 20,q.length, "wrong number of queries"
+
+    [:base64,:uris,:byte_array,:ints,:floats].each do |t|
+      q = @rand.queries(20,10,type=t)
+      assert_equal 20,q.length
+    end
+
+  end
+
+  def test_uris
+    u = @rand.uris(20, 10)
+    assert_equal 20,u.length,"wrong number of uris"
+  end
+
+  def test_words
+    w = @rand.words(100)
+    assert_equal 100,w.length,"wrong number of words"
+  end
+
+  def test_bytes
+    b = @rand.bytes(100)
+    assert_not_nil b
+  end
+
+  def test_base64
+    b = @rand.base64(100,20)
+    assert_not_nil b
+    assert_equal 100,b.length
+  end
+
+  def test_num
+    b1 = @rand.num(100)
+    assert_not_nil b1
+    assert b1 < 100, "returned by greater than 10"
+  end
+
+  def test_ints
+    i = @rand.ints(100)
+    assert_equal 100, i.length, "wrong length"
+  end
+
+  def test_floats
+    f = @rand.floats(100)
+    assert_equal 100, f.length, "wrong length"
+  end
+
+end
+

data/test/test_session.rb

@@ -0,0 +1,33 @@
+# Copyright (c) 2006 Zed A. Shaw 
+# You can redistribute it and/or modify it under the same terms as Ruby.
+
+require 'test/unit'
+require 'rfuzz/session'
+include RFuzz
+
+class SessionTest < Test::Unit::TestCase
+
+  def test_simple_session
+    s = Session.new :host => "localhost", :port => 3001
+    s.run 3, :save_as => ["test/runs.csv","test/counts.csv"] do |c,r|
+      len = r.num(10) + 1
+      s.count :len, len
+      uris = r.uris(10,len)
+
+      uris.each do |u| 
+        s.count_errors(:legal) do
+          # first sample for legal uris
+          resp = c.get(u)
+          s.count resp.http_status
+          s.track :status, resp.http_status
+        end
+      end
+    end
+
+    assert_equal 3, s.tracking.length
+    assert File.exist?("test/runs.csv")
+    assert File.exist?("test/counts.csv")
+    File.unlink "test/counts.csv"
+    File.unlink "test/runs.csv"
+  end
+end