blitz 0.1.20 → 0.1.21

data/spec/blitz/command/api_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Blitz::Command::API do
+    before :each do
+        @resource = mock RestClient::Resource
+        RestClient::Resource.stub!(:new).and_return @resource
+        @api = Blitz::Command::API.instance
+        @api.credentials= nil
+        File.stub!(:exists?).and_return true
+        File.stub!(:read).and_return "test@example.com\nabc123"
+    end
+    
+    context "#get_credentials" do
+        it "should return given array" do
+            @api.credentials= ['abc@example.com', '123456']
+            result = @api.get_credentials
+            result.should be_nil
+            @api.user.should == 'abc@example.com'
+            @api.password.should == '123456'
+        end
+        
+        it "should return credentials from the file" do
+            result = @api.get_credentials
+            result.should_not be_nil
+            @api.user.should == 'test@example.com'
+            @api.password.should == 'abc123'
+        end
+    end
+    
+    context "#client" do
+        it "should login using credentials from the file" do
+            Blitz::Client.should_receive(:new).
+                with('test@example.com', 'abc123', anything)
+            result = @api.client
+        end
+        
+        it "should reutn a Blitz::Client instance" do
+            result = @api.client
+            result.class.should == Blitz::Client
+        end
+    end
+end

data/spec/blitz/command/curl_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe Blitz::Command::Curl do
+end

data/spec/blitz/curl/rush_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+describe Blitz::Curl::Rush do
+    before :each do
+        @resource = mock RestClient::Resource
+        RestClient::Resource.stub!(:new).and_return @resource
+        File.stub!(:exists?).and_return true
+        File.stub!(:read).and_return "test@example.com\nabc123"
+        args = {
+            :region => 'california',
+            :steps => [ { :url => "http://www.example.com"}],
+            :pattern => {
+               :intervals => [{ :start => 1, :end => 10000, :duration => 60 }]
+           }
+        }
+        @rush = Blitz::Curl::Rush.new args
+    end
+    
+    context "#queue" do
+        before :each do
+            @queue = mock RestClient::Resource
+            json = "{\"ok\":true, \"job_id\":\"j123\", \"status\":\"queued\", \"region\":\"california\"}"
+            @resource.should_receive(:[]).with('/api/1/curl/execute').and_return @queue
+            @queue.should_receive(:post).and_return json
+            @status = mock RestClient::Resource
+        end
+        
+        it "should set the region" do
+            @rush.region.should be_nil
+            @rush.queue
+            @rush.region.should == 'california'
+        end
+
+        it "should set the job_id" do
+            @rush.job_id.should be_nil
+            @rush.queue
+            @rush.job_id.should == 'j123'
+        end
+    end
+    
+    context "#result" do
+        before :each do
+            @queue = mock RestClient::Resource
+            json = "{\"ok\":true, \"job_id\":\"j123\", \"status\":\"queued\", \"region\":\"california\"}"
+            @resource.should_receive(:[]).with('/api/1/curl/execute').and_return @queue
+            @queue.should_receive(:post).and_return json
+            @status = mock RestClient::Resource
+            json2 = "{\"ok\":true, \"status\":\"completed\", \"result\":{\"region\":\"california\", \"timeline\":[]}}"
+            @resource.should_receive(:[]).with("/api/1/jobs/j123/status").and_return @status
+            @status.should_receive(:get).and_return json2
+            @rush.queue
+        end
+        
+        it "should return a new Blitz::Curl::Rush::Result instance" do
+            result = @rush.result
+            result.should_not be_nil
+            result.class.should == Blitz::Curl::Rush::Result
+        end
+        
+        it "should return result with region california" do
+            result = @rush.result
+            result.region.should == 'california'
+        end
+    end
+    
+    context "#execute" do
+        before :each do
+            @queue = mock RestClient::Resource
+            json = "{\"ok\":true, \"job_id\":\"j123\", \"status\":\"queued\", \"region\":\"california\"}"
+            @resource.should_receive(:[]).with('/api/1/curl/execute').and_return @queue
+            @queue.should_receive(:post).and_return json
+            @status = mock RestClient::Resource
+            json2 = "{\"ok\":true, \"status\":\"completed\", \"result\":{\"region\":\"california\", \"timeline\":[]}}"
+            @resource.should_receive(:[]).with("/api/1/jobs/j123/status").and_return @status
+            @status.should_receive(:get).and_return json2
+        end
+        
+        it "should return a new Blitz::Curl::Rush::Result instance" do
+            result = @rush.execute
+            result.should_not be_nil
+            result.class.should == Blitz::Curl::Rush::Result
+        end
+        
+        it "should return result with region california" do
+            result = @rush.execute
+            result.region.should == 'california'
+        end
+    end
+end

data/spec/blitz/curl/sprint_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe Blitz::Curl::Sprint do
+    before :each do
+        @resource = mock RestClient::Resource
+        RestClient::Resource.stub!(:new).and_return @resource
+        File.stub!(:exists?).and_return true
+        File.stub!(:read).and_return "test@example.com\nabc123"
+        args = {
+            :region => 'california',
+            :steps => [ { :url => "http://www.example.com"}]
+        }
+        @sprint = Blitz::Curl::Sprint.new args
+    end
+    
+    context "#queue" do
+        before :each do
+            @queue = mock RestClient::Resource
+            json = "{\"ok\":true, \"job_id\":\"j123\", \"status\":\"queued\", \"region\":\"california\"}"
+            @resource.should_receive(:[]).with('/api/1/curl/execute').and_return @queue
+            @queue.should_receive(:post).and_return json
+            @status = mock RestClient::Resource
+        end
+        
+        it "should set the region" do
+            @sprint.region.should be_nil
+            @sprint.queue
+            @sprint.region.should == 'california'
+        end
+
+        it "should set the job_id" do
+            @sprint.job_id.should be_nil
+            @sprint.queue
+            @sprint.job_id.should == 'j123'
+        end
+    end
+    
+    context "#result" do
+        before :each do
+            @queue = mock RestClient::Resource
+            json = "{\"ok\":true, \"job_id\":\"j123\", \"status\":\"queued\", \"region\":\"california\"}"
+            @resource.should_receive(:[]).with('/api/1/curl/execute').and_return @queue
+            @queue.should_receive(:post).and_return json
+            @status = mock RestClient::Resource
+            json2 = "{\"ok\":true, \"status\":\"completed\", \"result\":{\"region\":\"california\", \"steps\":[]}}"
+            @resource.should_receive(:[]).with("/api/1/jobs/j123/status").and_return @status
+            @status.should_receive(:get).and_return json2
+            @sprint.queue
+        end
+        
+        it "should return a new Blitz::Curl::Sprint::Result instance" do
+            result = @sprint.result
+            result.should_not be_nil
+            result.class.should == Blitz::Curl::Sprint::Result
+        end
+        
+        it "should return result with region california" do
+            result = @sprint.result
+            result.region.should == 'california'
+        end
+    end
+    
+    context "#execute" do
+        before :each do
+            @queue = mock RestClient::Resource
+            json = "{\"ok\":true, \"job_id\":\"j123\", \"status\":\"queued\", \"region\":\"california\"}"
+            @resource.should_receive(:[]).with('/api/1/curl/execute').and_return @queue
+            @queue.should_receive(:post).and_return json
+            @status = mock RestClient::Resource
+            json2 = "{\"ok\":true, \"status\":\"completed\", \"result\":{\"region\":\"california\", \"steps\":[]}}"
+            @resource.should_receive(:[]).with("/api/1/jobs/j123/status").and_return @status
+            @status.should_receive(:get).and_return json2
+        end
+        
+        it "should return a new Blitz::Curl::Sprint::Result instance" do
+            result = @sprint.execute
+            result.should_not be_nil
+            result.class.should == Blitz::Curl::Sprint::Result
+        end
+        
+        it "should return result with region california" do
+            result = @sprint.execute
+            result.region.should == 'california'
+        end
+    end
+end

data/spec/blitz/curl_spec.rb

@@ -0,0 +1,242 @@
+require 'spec_helper'
+
+describe Blitz::Curl do
+    describe "parse_cli" do
+        context "url" do
+            it "should check that the args are not empty" do
+                lambda { 
+                    Blitz::Curl.parse_cli %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 = Blitz::Curl.parse_cli [h]
+                    hash.should include 'help'
+                end
+            end
+
+            it "should succeed when a URL is given" do
+                hash = Blitz::Curl.parse_cli %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 = Blitz::Curl.parse_cli %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
+
+        context "user-agent" do
+            it "should check that a user-agent is given" do
+                lambda { 
+                    Blitz::Curl.parse_cli %w[--user-agent] 
+                }.should raise_error(MiniTest::Assertion, /missing value/)
+            end
+
+            it "should support one user-agent for each step" do
+                hash = Blitz::Curl.parse_cli %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
+
+        context "cookie" do
+            it "should check that a cookie is given" do
+                lambda { Blitz::Curl.parse_cli %w[--cookie] }.should raise_error(MiniTest::Assertion, /missing value/)
+            end
+
+            it "should be an array of cookies" do
+                hash = Blitz::Curl.parse_cli %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
+
+            it "should support one cookie for each step" do
+                hash = Blitz::Curl.parse_cli %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
+
+        context "data" do
+            it "should check that a data is given" do
+                lambda { Blitz::Curl.parse_cli %w[--data] }.should raise_error(MiniTest::Assertion, /missing value/)
+            end
+
+            it "should be an array of data" do
+                hash = Blitz::Curl.parse_cli %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 = Blitz::Curl.parse_cli %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 { Blitz::Curl.parse_cli %w[--referer] }.should raise_error(MiniTest::Assertion, /missing value/)
+            end
+
+            it "should support one referer for each step" do
+                hash = Blitz::Curl.parse_cli %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 { Blitz::Curl.parse_cli %w[--header] }.should raise_error(MiniTest::Assertion, /missing value/)
+            end
+
+            it "should be an array of headers" do
+                hash = Blitz::Curl.parse_cli %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 = Blitz::Curl.parse_cli %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
+        end
+
+        context "pattern" do
+            it "should check that a pattern is given" do
+                lambda { Blitz::Curl.parse_cli %w[--pattern] }.should raise_error(MiniTest::Assertion, /missing value/)
+            end
+
+            it "should add the pattern to the hash" do
+                hash = Blitz::Curl.parse_cli %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 = Blitz::Curl.parse_cli %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 { Blitz::Curl.parse_cli %w[--region] }.should raise_error(MiniTest::Assertion, /missing value/)
+            end
+
+            it "should verify that it's a valid region" do
+                [ 'california', 'oregon', 'virginia', 'ireland', 'singapore', 'japan', 'saopaulo' ].each do |r|
+                    lambda { Blitz::Curl.parse_cli ['-r', r, 'blitz.io' ] }.should_not raise_error
+                end
+
+                lambda { Blitz::Curl.parse_cli %w[-r -a ] }.should raise_error(MiniTest::Assertion, /missing value/)
+                lambda { Blitz::Curl.parse_cli %w[-r --data ] }.should raise_error(MiniTest::Assertion, /missing value/)
+            end
+        end
+
+        context "status" do
+            it "should check that a status is given" do
+                lambda { Blitz::Curl.parse_cli %w[--status] }.should raise_error(MiniTest::Assertion, /missing value/)
+            end
+
+            it "should support one status for each step" do
+                hash = Blitz::Curl.parse_cli %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 { Blitz::Curl.parse_cli %w[--timeout] }.should raise_error(MiniTest::Assertion, /missing value/)
+            end
+
+            it "should support one timeout for each step" do
+                hash = Blitz::Curl.parse_cli %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 { Blitz::Curl.parse_cli %w[--user] }.should raise_error(MiniTest::Assertion, /missing value/)
+            end
+
+            it "should support one user for each step" do
+                hash = Blitz::Curl.parse_cli %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 { Blitz::Curl.parse_cli %w[--request] }.should raise_error(MiniTest::Assertion, /missing value/)
+            end
+
+            it "should support one request for each step" do
+                hash = Blitz::Curl.parse_cli %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