blitz 0.1.12 → 0.1.13

data/lib/blitz/curl/error.rb

@@ -47,21 +47,38 @@ class Error < StandardError # :nodoc:
     class DNS < Region
     end
     
+    # This exception is raised when the arguments to sprint or rush is invalid
+    class Parse < Region
+    end
+    
+    # This exception is raised when a particular step fails in some ways
+    class Step < Region
+        # The step index where the error occurred
+        attr_reader :step
+        
+        # An array of Blitz::Curl::Sprint::Step objects each containing requests
+        # and [potentially] responses. Depending on which step of the transaction
+        # the failure was, this array could potentially be empty
+        attr_reader :steps
+        
+        def initialize json # :nodoc:
+            @step = json['step']
+            @steps = json['steps'].map { |s| Sprint::Step.new s }
+            super
+        end
+    end
+    
     # This exception is raised when the connection to your app fails
-    class Connect < Region
+    class Connect < Step
     end
     
     # This exception is raised when the connection or the response times out
-    class Timeout < Region
+    class Timeout < Step
     end
 
-    # This exception is raised when the arguments to sprint or rush is invalid
-    class Parse < Region
-    end
-    
     # This exception is raised when you have an explicit status code check and
     # the assertion fails
-    class Status < Region
+    class Status < Step
     end
 end
 end # Curl

data/lib/blitz/curl/rush.rb

@@ -4,6 +4,32 @@ module Curl # :nodoc:
 # include the entire timeline containing the average duration, the concurrency,
 # the bytes sent/received, etc.
 class Rush
+    # Per-step (for transactional rushes) metrics of a rush at time[i]
+    class Step
+        # The duration of this step, when successful
+        attr_reader :duration
+        
+        # Average TCP connect times for this step
+        attr_reader :connect
+        
+        # Cummulative errors for this step
+        attr_reader :errors
+        
+        # Cummulative timeouts for this step
+        attr_reader :timeouts
+        
+        # Cummulative assertion failures on status code for this step
+        attr_reader :asserts
+        
+        def initialize json
+            @duration = json['d']
+            @connect = json['c']
+            @errors = json['e']
+            @timeouts = json['t']
+            @asserts = json['a']
+        end
+    end
+    
     # Snapshot of a rush at time[i] containing information about hits, errors
     # timeouts, etc.
     class Point
@@ -34,6 +60,9 @@ class Rush
         # The total number of bytes received
         attr_reader :rxbytes
         
+        # Per-step metric at this point in time
+        attr_reader :steps
+        
         def initialize json # :nodoc:
             @timestamp = json['timestamp']
             @duration = json['duration']
@@ -44,6 +73,7 @@ class Rush
             @volume = json['volume']
             @txbytes = json['txbytes']
             @rxbytes = json['rxbytes']
+            @steps = json['steps'].map { |s| Step.new s }
         end
     end
     
@@ -128,6 +158,8 @@ class Rush
                     raise Error::DNS.new(result)
                 elsif error == 'authorize'
                     raise Error::Authorize.new(result)
+                elsif error == 'parse'
+                    raise Error::Parse.new(result)
                 else
                     raise Error
                 end

data/lib/blitz/curl/sprint.rb

@@ -58,30 +58,46 @@ class Sprint
         end        
     end
     
-    # Contains the result from a successful sprint
-    class Result
-        # The region from which this sprint was executed
-        attr_reader :region
-        
-        # The overall response time for the successful hit
-        attr_reader :duration
-        
+    # Represents a step in the transaction (even if there's only one). Each
+    # step contains the request and response objects as well as the stats
+    # associated with them.
+    class Step
         # The time it took for the TCP connection
         attr_reader :connect
         
+        # The time it took for this step (includes the connect, send and receive)
+        attr_reader :duration
+        
         # The request object containing the URL, headers and content, if any
         attr_reader :request
         
         # The response object containing the status code, headers and content, if any
         attr_reader :response
         
+        def initialize json # :nodoc:
+            @connect = json['connect']
+            @duration = json['duration']
+            @request = Request.new json['request'] if json['request']
+            @response = Response.new json['response'] if json['response']
+        end
+    end
+    
+    # Contains the result from a successful sprint
+    class Result
+        # The region from which this sprint was executed
+        attr_reader :region
+        
+        # The overall response time for the entire transaction
+        attr_reader :duration
+        
+        # Stats about the individual steps
+        attr_reader :steps
+        
         def initialize json # :nodoc:
             result = json['result']
             @region = result['region']
             @duration = result['duration']
-            @connect = result['connect']
-            @request = Request.new result['request']
-            @response = Response.new result['response']
+            @steps = result['steps'].map { |step| Step.new step }
         end        
     end
     
@@ -139,7 +155,7 @@ class Sprint
                     raise Error::Timeout.new(result)
                 elsif error == 'parse'
                     raise Error::Parse.new(result)
-                elsif result['assert'] == 0
+                elsif error == 'assert'
                     raise Error::Status.new(result)
                 else
                     raise Error

data/spec/command/curl_spec.rb

@@ -1,248 +1,244 @@
-describe "arg parsing" do
-
-    TEST_URL = "http://foo.com"
-    VAR = 'foo'
-    TEST_VAR_URL = 'http://foo.com?var=#{foo}'
-    MIN = 10
-    MAX = 30
-    # because of 1.8.7 and 1.9.2 differences, maintain both LIST and LIST_AS_STRING constants
-    LIST = [ 'a', 'b', 'c', '1', '2', '3']
-    LIST_AS_STRING = "[a,b,c,1,2,3]" 
-    COUNT = 60
-    COUNT_DEFAULT = 1000
-    DURATION = 100
-    REGION = 'california'
-
-    curl = ::Blitz::Command::Curl.new
-    describe "basic args" do
-
-        describe "pattern and region" do
-            @args = { 
-                "expanded parameters" => [ '--pattern', '1-250:60', "--region", "#{REGION}", "#{TEST_URL}" ],
-                "short parameters"    => [ '-p', '1-250:60', "--region", "#{REGION}", "#{TEST_URL}" ]
-            }
-
-            @args.each do |name, argv|
-                parsed_args = curl.__send__ :parse_cli, argv
-
-                it "should return a hash from the method when sending #{name}" do
-                    parsed_args.should be_a(Hash)
-                end
-
-                it "should populate the URL into the url key when sending #{name}" do
-                    parsed_args['url'].should be_a(String)
-                    parsed_args['url'].should == TEST_URL
-                end
-
-                it "should put --pattern arguments in the correct structure when sending #{name}" do
-                    parsed_args['pattern'].should be_a(Hash)
-                    parsed_args['pattern']['iterations'].should be_equal 1
-                    parsed_args['pattern']['intervals'].should be_a(Array)
-                    parsed_args['pattern']['intervals'][0].should be_a(Hash)
-                    parsed_args['pattern']['intervals'][0]['start'].should be_equal 1
-                    parsed_args['pattern']['intervals'][0]['end'].should be_equal 250
-                    parsed_args['pattern']['intervals'][0]['duration'].should be_equal 60
-                end
-
-                it "should allow a specific region to be passed when sending #{name}" do
-                    parsed_args['region'].should be_a(String)
-                    parsed_args['region'].should == REGION
-                end
+describe "parse_cli" do
+    attr_reader :curl
+    
+    before :each do
+        @curl = Blitz::Command::Curl.new
+        class << @curl
+            def parse args
+                parse_cli args
             end
         end
-
-        @command_args = [ 
-            { :short => '-A', :long => '--user-agent', :params => '"TEST STRING"' },
-            { :short => '-b', :long => '--cookie', :params => 'name=somecookie' }, 
-            { :short => '-d', :long => '--data', :params => '"data for post"'}, 
-            { :short => '-D', :long => '--dump-header', :params => '"somefile.out"' },
-            { :short => '-e', :long => '--referer', :params => '"http://google.com"' },
-            { :short => '-H', :long => '--header', :params => 'some_header' }, 
-            { :short => '-s', :long => '--status', :params => '500', :return_type => Integer },
-            { :short => '-T', :long => '--timeout', :params => '750', :return_type => Integer }, 
-            { :short => '-u', :long => '--user', :params => 'foo:bar' }, 
-            { :short => '-X', :long => '--request', :params => 'GET' }, 
-            { :short => '-V', :long => '--verbose' }, 
-            { :short => '-1', :long => '--tlsv1' }, 
-            { :short => '-2', :long => '--sslv2' }, 
-            { :short => '-3', :long => '--sslv3' }, 
-        ]
-        @command_args.each do |test| 
-            test_name = /--(.*)/.match(test[:long])[1]
-            describe "#{test_name}" do
-                [ :short, :long ].each do |flag|
-                    argv = []
-                    argv << test[flag]
-                    argv << test[:params] if test[:params]
-                    argv << "#{TEST_URL}"
-                    it "#{test[flag]} should not raise an error and populate the hash properly" do
-                        lambda { curl.__send__ :parse_cli, argv.dup }.should_not raise_error
-                        parsed_args = curl.__send__ :parse_cli, argv
-                        # special checks for cookies and headers, as their structure in the return data is different
-                        if test_name == 'cookie' || test_name == 'header'
-                            return_key = "#{test_name}s"
-                            parsed_args[return_key].should be_an(Array)
-                            parsed_args[return_key][0].should == test[:params]
-                        # special checks for data, as its structure in the return data is different
-                        elsif test_name == 'data'
-                            parsed_args['content'].should be_a(Hash)
-                            parsed_args['content']['data'].should be_an(Array)
-                            parsed_args['content']['data'][0].should == test[:params]
-                        # special checks for ssl params
-                        elsif test_name.match(/^ssl|tls/)
-                            parsed_args['ssl'].should == test_name
-                        # for integer params, make sure the test returns correct quoting
-                        elsif test[:return_type] == Integer
-                            parsed_args[test_name].should == test[:params].to_i
-                        elsif test[:params].is_a?(String)
-                            parsed_args[test_name].should == test[:params]
-                        end
-                    end
-                end
+    end
+    
+    context "url" do
+        it "should check that the args are not empty" do
+            lambda { curl.parse %w[] }.should raise_error(ArgumentError, /no URL specified!/)
+        end
+        
+        it "should not check for URL when --help is specified" do
+            %w[-h --help].each do |h|
+                hash = curl.parse [h]
+                hash.should include 'help'
             end
         end
+        
+        it "should succeed when a URL is given" do
+            hash = curl.parse %w[blitz.io]
+            hash.should include 'steps'
+            hash['steps'].should be_a(Array)
+            hash['steps'].size.should == 1
+            hash['steps'].first.should include 'url'
+            hash['steps'].first['url'].should == 'blitz.io'
+        end
+        
+        it "should succeed when multiple URLs are given" do
+            hash = curl.parse %w[blitz.io docs.blitz.io]
+            hash.should include 'steps'
+            hash['steps'].should be_a(Array)
+            hash['steps'].size.should == 2
+            hash['steps'][0].should include 'url'
+            hash['steps'][0]['url'].should == 'blitz.io'
+            hash['steps'][1].should include 'url'
+            hash['steps'][1]['url'].should == 'docs.blitz.io'
+        end
     end
-
-    describe "help" do
-        @args = { 
-            "expanded parameters" => [ '--help' ],
-            "short parameters"    => [ '-h' ]
-        }
-        @args.each do |name, argv|
-            it "should return boolean help flag in hash for #{name}" do
-                parsed_args = curl.__send__ :parse_cli, argv
-                parsed_args.should be_a(Hash)
-                parsed_args['help'].should be_true
-            end
+    
+    context "user-agent" do
+        it "should check that a user-agent is given" do
+            lambda { curl.parse %w[--user-agent] }.should raise_error(MiniTest::Assertion, /missing value/)
+        end
+        
+        it "should support one user-agent for each step" do
+            hash = curl.parse %w[-A foo blitz.io -A bar /faq]
+            hash.should include 'steps'
+            hash['steps'].size.should == 2
+            hash['steps'][0]['user-agent'] == 'foo'
+            hash['steps'][1]['user-agent'] == 'bar'
         end
     end
-
-    describe "Usage errors" do
-        describe "no arguments" do
-            it "should throw an error when no arguments are given" do
-                lambda { curl.__send__ :parse_cli }.should raise_error(ArgumentError, /wrong number of arg/)
-            end
+    
+    context "cookie" do
+        it "should check that a cookie is given" do
+            lambda { curl.parse %w[--cookie] }.should raise_error(MiniTest::Assertion, /missing value/)
         end
-        describe "no URL" do
-            @args = { 
-                "expanded parameters" => [ '--pattern', '1-250:60', "--variable:#{VAR}", "udid", "--region", "#{REGION}" ],
-                "short parameters" => [ '-p', '1-250:60', "-v:#{VAR}", "u", "-r", "#{REGION}" ]
-            }
-            @args.each do |name, argv|
-                it "should throw an error when no URL is given for #{name}" do
-                    lambda { curl.__send__ :parse_cli, argv}.should raise_error(ArgumentError, /URL/)
-                end
-            end
+        
+        it "should be an array of cookies" do
+            hash = curl.parse %w[--cookie foo=bar --cookie hello=world blitz.io]
+            hash['steps'].size.should == 1
+            step = hash['steps'].first
+            step['cookies'].should be_a(Array)
+            step['cookies'].should == [ 'foo=bar', 'hello=world' ]
         end
-        describe "bad arguments" do
-            @args = { 
-                "double dash on short param" => [ '--p', '1-250:60', "--variable:#{VAR}", "udid", "--region", "#{REGION}", "#{TEST_URL}" ],
-                "single dash on long param" => [ '-pattern', '1-250:60', "-v:#{VAR}", "u", "-r", "#{REGION}", "#{TEST_URL}" ],
-                "unsupported option, short format" => [ '-z', "#{TEST_URL}" ],
-                "unsupported option, long format" => [ '--foobar', "#{TEST_URL}" ]
-            }
-            @args.each do |name, argv|
-                it "should throw an error when bad arguments are passed for #{name}" do
-                    lambda { curl.__send__ :parse_cli, argv}.should raise_error(ArgumentError, /Unknown option/)
-                end
-            end
+        
+        it "should support one cookie for each step" do
+            hash = curl.parse %w[-b foo=bar blitz.io -b hello=world /faq]
+            hash.should include 'steps'
+            hash['steps'].size.should == 2
+            hash['steps'][0]['cookies'] == [ 'foo=bar' ]
+            hash['steps'][1]['cookies'] == [ 'hello=world' ]
         end
     end
-
-    describe "variable support" do
-        describe "number and alpha" do
-            @args = { 
-                "number, expanded parameters, no values given" => 
-                    [ '--pattern', '1-250:60', "--variable:#{VAR}", "number", "--region", "#{REGION}", "#{TEST_VAR_URL}" ],
-                "number, short parameters, no values given" => 
-                    [ '-p', '1-250:60', "-v:#{VAR}", "n", "--region", "#{REGION}", "#{TEST_VAR_URL}" ],
-                "number, expanded parameters, no count given" =>
-                    [ '--pattern', '1-250:60', "--variable:#{VAR}", "number[#{MIN},#{MAX}]", "--region", "#{REGION}", "#{TEST_VAR_URL}" ],
-                "number, short parameters, no count given" => 
-                    [ '-p', '1-250:60', "-v:#{VAR}", "n[#{MIN},#{MAX}]", "--region", "#{REGION}", "#{TEST_VAR_URL}" ],
-                "number, expanded parameters, count given" =>
-                    [ '--pattern', '1-250:60', "--variable:#{VAR}", "number[#{MIN},#{MAX},#{COUNT}]", "--region", "#{REGION}", "#{TEST_VAR_URL}" ],
-                "number, short parameters, count given" => 
-                    [ '-p', '1-250:60', "-v:#{VAR}", "n[#{MIN},#{MAX},#{COUNT}]", "--region", "#{REGION}", "#{TEST_VAR_URL}" ],
-                "alpha, expanded parameters, no values given" => 
-                    [ '--pattern', '1-250:60', "--variable:#{VAR}", "alpha", "--region", "#{REGION}", "#{TEST_VAR_URL}" ],
-                "alpha, short parameters, no values given" => 
-                    [ '-p', '1-250:60', "-v:#{VAR}", "a", "--region", "#{REGION}", "#{TEST_VAR_URL}" ],
-                "alpha, expanded parameters, no count given" =>
-                    [ '--pattern', '1-250:60', "--variable:#{VAR}", "alpha[#{MIN},#{MAX}]", "--region", "#{REGION}", "#{TEST_VAR_URL}" ],
-                "alpha, short parameters, no count given" => 
-                    [ '-p', '1-250:60', "-v:#{VAR}", "a[#{MIN},#{MAX}]", "--region", "#{REGION}", "#{TEST_VAR_URL}" ],
-                "alpha, expanded parameters, count given" =>
-                    [ '--pattern', '1-250:60', "--variable:#{VAR}", "alpha[#{MIN},#{MAX},#{COUNT}]", "--region", "#{REGION}", "#{TEST_VAR_URL}" ],
-                "alpha, short parameters, count given" => 
-                    [ '-p', '1-250:60', "-v:#{VAR}", "a[#{MIN},#{MAX},#{COUNT}]", "--region", "#{REGION}", "#{TEST_VAR_URL}" ]
-            }
-
-            @args.each do |name, argv|
-                parsed_args = curl.__send__ :parse_cli, argv
-                it "should work with #{name}" do
-                    parsed_args['variables'].should be_a(Hash)
-                    parsed_args['variables'][VAR].should be_a(Hash)
-
-                    if name.match(/^number/)
-                        parsed_args['variables'][VAR]['type'].should == "number"
-                    elsif name.match(/^alpha/)
-                        parsed_args['variables'][VAR]['type'].should == "alpha"
-                    end
-
-                    if name.match(/no values given/)
-                        parsed_args['variables'][VAR]['min'].should be_nil
-                        parsed_args['variables'][VAR]['max'].should be_nil
-                        parsed_args['variables'][VAR]['count'].should be_nil
-                    elsif name.match(/no count given/)
-                        parsed_args['variables'][VAR]['min'].should be_an(Integer)
-                        parsed_args['variables'][VAR]['min'].should == MIN
-                        parsed_args['variables'][VAR]['max'].should be_an(Integer)
-                        parsed_args['variables'][VAR]['max'].should == MAX
-                        parsed_args['variables'][VAR]['count'].should be_an(Integer)
-                        parsed_args['variables'][VAR]['count'].should == COUNT_DEFAULT
-                    else
-                        parsed_args['variables'][VAR]['min'].should be_an(Integer)
-                        parsed_args['variables'][VAR]['min'].should == MIN
-                        parsed_args['variables'][VAR]['max'].should be_an(Integer)
-                        parsed_args['variables'][VAR]['max'].should == MAX
-                        parsed_args['variables'][VAR]['count'].should be_an(Integer)
-                        parsed_args['variables'][VAR]['count'].should == COUNT
-                    end
-
-                end
-            end
+    
+    context "data" do
+        it "should check that a data is given" do
+            lambda { curl.parse %w[--data] }.should raise_error(MiniTest::Assertion, /missing value/)
         end
-
-        describe "list parameter" do
-            @args = { 
-                "expanded parameters" => [ '--pattern', '1-250:60', "--variable:#{VAR}", "list#{LIST_AS_STRING}", "--region", "#{REGION}", "#{TEST_URL}" ],
-                "short parameters" => [ '-p', '1-250:60', "-v:#{VAR}", "#{LIST_AS_STRING}", "-r", "#{REGION}", "#{TEST_URL}" ]
-            }
-            @args.each do |name, argv|
-                it "should allow lists to be sent as a variable type for #{name}" do
-                    parsed_args = curl.__send__ :parse_cli, argv
-                    parsed_args['variables'][VAR].should be_a(Hash)
-                    parsed_args['variables'][VAR]['type'].should == 'list'
-                    parsed_args['variables'][VAR]['entries'].should be_an(Array)
-                    parsed_args['variables'][VAR]['entries'].should == LIST
-                end
-            end
+        
+        it "should be an array of data" do
+            hash = curl.parse %w[--data foo=bar --data hello=world blitz.io]
+            hash['steps'].size.should == 1
+            step = hash['steps'].first
+            step['content'].should be_a(Hash)
+            step['content']['data'].should be_a(Array)
+            step['content']['data'].should == [ 'foo=bar', 'hello=world' ]
+        end
+        
+        it "should support one data for each step" do
+            hash = curl.parse %w[-d foo=bar blitz.io -d hello=world /faq]
+            hash.should include 'steps'
+            hash['steps'].size.should == 2
+            hash['steps'][0]['content']['data'] == [ 'foo=bar' ]
+            hash['steps'][1]['content']['data'] == [ 'hello=world' ]
+        end
+    end
+    
+    context "referer" do
+        it "should check that a referer is given" do
+            lambda { curl.parse %w[--referer] }.should raise_error(MiniTest::Assertion, /missing value/)
+        end
+        
+        it "should support one referer for each step" do
+            hash = curl.parse %w[-e foo blitz.io -e bar /faq]
+            hash.should include 'steps'
+            hash['steps'].size.should == 2
+            hash['steps'][0]['referer'] == 'foo'
+            hash['steps'][1]['referer'] == 'bar'
+        end
+    end
+    
+    context "headers" do
+        it "should check that a header is given" do
+            lambda { curl.parse %w[--header] }.should raise_error(MiniTest::Assertion, /missing value/)
+        end
+        
+        it "should be an array of headers" do
+            hash = curl.parse %w[-H foo=bar -H hello=world blitz.io]
+            hash['steps'].size.should == 1
+            step = hash['steps'].first
+            step['headers'].should be_a(Array)
+            step['headers'].should == [ 'foo=bar', 'hello=world' ]
+        end
+        
+        it "should support one header for each step" do
+            hash = curl.parse %w[-H foo=bar blitz.io -H hello=world /faq]
+            hash.should include 'steps'
+            hash['steps'].size.should == 2
+            hash['steps'][0]['headers'] == [ 'foo=bar' ]
+            hash['steps'][1]['headers'] == [ 'hello=world' ]
         end
-
-        describe "udid parameter" do
-            @args = { 
-                "expanded parameters" => [ '--pattern', '1-250:60', "--variable:#{VAR}", "udid", "--region", "#{REGION}", "#{TEST_URL}" ],
-                "short parameters" => [ '-p', '1-250:60', "-v:#{VAR}", "u", "-r", "#{REGION}", "#{TEST_URL}" ]
-            }
-            @args.each do |name, argv|
-                parsed_args = curl.__send__ :parse_cli, argv
-                it "should allow udid to be sent as a variable type" do
-                    parsed_args['variables'][VAR].should be_a(Hash)
-                    parsed_args['variables'][VAR]['type'].should == 'udid'
-                end
+    end
+    
+    context "pattern" do
+        it "should check that a pattern is given" do
+            lambda { curl.parse %w[--pattern] }.should raise_error(MiniTest::Assertion, /missing value/)
+        end
+        
+        it "should add the pattern to the hash" do
+            hash = curl.parse %w[-p 1-250:60 blitz.io]
+            hash['pattern'].should be_a(Hash)
+            hash['pattern']['iterations'].should == 1
+            hash['pattern']['intervals'].should be_an(Array)
+            hash['pattern']['intervals'].size.should == 1
+            hash['pattern']['intervals'].first['iterations'].should == 1
+            hash['pattern']['intervals'].first['start'].should == 1
+            hash['pattern']['intervals'].first['end'].should == 250
+            hash['pattern']['intervals'].first['duration'].should == 60
+        end
+        
+        it "should parse multiple intervals in the pattern" do
+            hash = curl.parse %w[-p 1-250:60,500-500:10 blitz.io]
+            hash['pattern'].should be_a(Hash)
+            hash['pattern']['iterations'].should == 1
+            hash['pattern']['intervals'].should be_an(Array)
+            hash['pattern']['intervals'].size.should == 2
+            hash['pattern']['intervals'].first['iterations'].should == 1
+            hash['pattern']['intervals'].first['start'].should == 1
+            hash['pattern']['intervals'].first['end'].should == 250
+            hash['pattern']['intervals'].first['duration'].should == 60
+            hash['pattern']['intervals'].last['iterations'].should == 1
+            hash['pattern']['intervals'].last['start'].should == 500
+            hash['pattern']['intervals'].last['end'].should == 500
+            hash['pattern']['intervals'].last['duration'].should == 10
+        end
+    end
+    
+    context "region" do
+        it "should check that a region is given" do
+            lambda { curl.parse %w[--region] }.should raise_error(MiniTest::Assertion, /missing value/)
+        end
+        
+        it "should verify that it's a valid region" do
+            [ 'california', 'virginia', 'ireland', 'singapore', 'japan' ].each do |r|
+                lambda { curl.parse ['-r', r, 'blitz.io' ] }.should_not raise_error
             end
+                
+            lambda { curl.parse %w[-r a ] }.should raise_error(MiniTest::Assertion, /must be one of/)
+        end
+    end
+    
+    context "status" do
+        it "should check that a status is given" do
+            lambda { curl.parse %w[--status] }.should raise_error(MiniTest::Assertion, /missing value/)
+        end
+        
+        it "should support one status for each step" do
+            hash = curl.parse %w[-s 302 blitz.io -s 200 /faq]
+            hash.should include 'steps'
+            hash['steps'].size.should == 2
+            hash['steps'][0]['status'] == 302
+            hash['steps'][1]['status'] == 200
+        end
+    end
+    
+    context "timeout" do
+        it "should check that a timeout is given" do
+            lambda { curl.parse %w[--timeout] }.should raise_error(MiniTest::Assertion, /missing value/)
+        end
+        
+        it "should support one timeout for each step" do
+            hash = curl.parse %w[-T 100 blitz.io -T 200 /faq]
+            hash.should include 'steps'
+            hash['steps'].size.should == 2
+            hash['steps'][0]['timeout'] == 100
+            hash['steps'][1]['timeout'] == 200
+        end
+    end
+    
+    context "user" do
+        it "should check that a user is given" do
+            lambda { curl.parse %w[--user] }.should raise_error(MiniTest::Assertion, /missing value/)
+        end
+        
+        it "should support one user for each step" do
+            hash = curl.parse %w[-u foo:bar blitz.io -u hello:world /faq]
+            hash.should include 'steps'
+            hash['steps'].size.should == 2
+            hash['steps'][0]['user'] == 'foo:bar'
+            hash['steps'][1]['user'] == 'hello:world'
+        end
+    end
+    
+    context "request" do
+        it "should check that a request is given" do
+            lambda { curl.parse %w[--request] }.should raise_error(MiniTest::Assertion, /missing value/)
+        end
+        
+        it "should support one request for each step" do
+            hash = curl.parse %w[-X GET blitz.io -X POST /faq]
+            hash.should include 'steps'
+            hash['steps'].size.should == 2
+            hash['steps'][0]['request'] == 'GET'
+            hash['steps'][1]['request'] == 'POST'
         end
     end
-end 
-
+end