sauce_whisk 0.0.13 → 0.0.14

data/spec/lib/sauce_whisk/assets_spec.rb

@@ -20,9 +20,9 @@ describe SauceWhisk::Assets do
 
     it "initializes the asset properly" do
       asset = SauceWhisk::Assets.fetch job_id, asset_name
-      asset.name.should eq asset_name
-      asset.job.should eq job_id
-      asset.asset_type.should eq :screenshot
+      expect( asset.name ).to eq asset_name
+      expect( asset.job ).to eq job_id
+      expect( asset.asset_type ).to eq :screenshot
     end
 
     context "for an invalid asset" do
@@ -43,4 +43,19 @@ describe SauceWhisk::Assets do
       end
     end
   end
+  
+  describe "#delete", :vcr => {:cassette_name => "assets"} do
+    let(:asset_job_id) {"f7bcec8f706f4910ba128f48e0b8c6c7"}
+    it "can delete a job" do
+      SauceWhisk::Assets.delete(asset_job_id).should be_an_instance_of SauceWhisk::Asset
+    end
+  end
+  
+  describe "#already_deleted_asset", :vcr => {:cassette_name => "assets"} do
+    let(:asset_job_id) {"651c7d737b7547e994678d981dcc433c"}
+    it "returns nil for already deleted assets" do
+      SauceWhisk::Assets.delete(asset_job_id).should be_an_instance_of SauceWhisk::Asset
+    end
+  end
+
 end

data/spec/lib/sauce_whisk/info_spec.rb

@@ -8,12 +8,12 @@ describe "SauceWhisk::Sauce", :vcr => {:cassette_name => "info"}  do
     end
 
     it "returns a hash" do
-      SauceWhisk::Sauce.service_status.should be_a_kind_of Hash
+      expect( SauceWhisk::Sauce.service_status ).to be_a_kind_of Hash
     end
 
     it "symbolizes the keys" do
       SauceWhisk::Sauce.service_status.each do |k,v|
-        k.should be_an_instance_of Symbol
+        expect( k ).to be_an_instance_of Symbol
       end
     end
   end
@@ -25,7 +25,7 @@ describe "SauceWhisk::Sauce", :vcr => {:cassette_name => "info"}  do
     end
 
     it "returns an integer" do
-      SauceWhisk::Sauce.total_job_count.should be_a_kind_of Integer
+      expect( SauceWhisk::Sauce.total_job_count ).to be_a_kind_of Integer
     end
   end
 
@@ -44,7 +44,7 @@ describe "SauceWhisk::Sauce", :vcr => {:cassette_name => "info"}  do
 
     it "returns an array" do
       platforms = SauceWhisk::Sauce.platforms
-      platforms.should be_a_kind_of Array
+      expect( platforms ).to be_a_kind_of Array
     end
 
     context "when called with true" do
@@ -60,7 +60,7 @@ describe "SauceWhisk::Sauce", :vcr => {:cassette_name => "info"}  do
 
   describe "operational?" do
     it "returns true when the service is running" do
-      SauceWhisk::Sauce.operational?.should be_true
+      expect( SauceWhisk::Sauce.operational? ).to be true
     end
   end
 end

data/spec/lib/sauce_whisk/job_spec.rb

@@ -37,19 +37,19 @@ describe SauceWhisk::Job do
 
     it "tracks changes to methods" do
       subject.name = "ANewName"
-      subject.updated_fields.should include :name
+      expect( subject.updated_fields ).to include :name
 
       subject.visibility = true
-      subject.updated_fields.should include :visibility
+      expect( subject.updated_fields ).to include :visibility
     end
 
     it "does not track unchanged methods" do
-      subject.updated_fields.should_not include :build
+      expect( subject.updated_fields ).to_not include :build
     end
 
     it "has empty updated_fields for new instances" do
       new_job = SauceWhisk::Job.new(params)
-      new_job.updated_fields.should eq []
+      expect( new_job.updated_fields ).to eq []
     end
 
     describe "#save" do
@@ -61,7 +61,7 @@ describe SauceWhisk::Job do
         end
 
         it "calls the save method of the SauceWhisk::Jobs object" do
-          SauceWhisk::Jobs.should_receive(:save).with(subject)
+          expect( SauceWhisk::Jobs ).to receive(:save).with(subject)
           subject.save
         end
       end
@@ -93,30 +93,44 @@ describe SauceWhisk::Job do
             subject.send("#{param}=", "TOTALLYDIFFERENT")
           }.to raise_exception
 
-          subject.send(param).should_not eq "TOTALLYDIFFERENT"
+          expect( subject.send(param) ).not_to eq "TOTALLYDIFFERENT"
         end
       end
     end
   end
 
-  context "fetched from the API" do
-    subject {SauceWhisk::Jobs.fetch "bd9c43dd6b5549f1b942d1d581d98cac"}
+  context "fetched from the API", :vcr => {:cassette_name => "assets"} do
+    context "with all asset details" do
+      subject {SauceWhisk::Jobs.fetch "bd9c43dd6b5549f1b942d1d581d98cac"}
 
-    describe "#screenshots", :vcr => {:cassette_name => "assets"} do
-      it "contains all the screenshots for that job" do
-        subject.screenshots.length.should be 4
+      it "will set has_all_asset_names true" do
+        expect( subject.has_all_asset_names? ).to be true
       end
 
-      it "contains actual screenshots" do
-        subject.screenshots.first.should be_a_kind_of SauceWhisk::Asset
-        subject.screenshots.first.asset_type.should eq :screenshot
+      describe "#screenshots" do
+        it "contains all the screenshots for that job" do
+          expect( subject.screenshots.length ).to be 4
+        end
+
+        it "contains actual screenshots" do
+          expect( subject.screenshots.first ).to be_a_kind_of SauceWhisk::Asset
+          expect( subject.screenshots.first.asset_type ).to eq :screenshot
+        end
+      end
+
+      describe "#video", :vcr => {:cassette_name => "assets"} do
+        it "should be a video asset" do
+          expect( subject.video ).to be_a_kind_of SauceWhisk::Asset
+          expect( subject.video.asset_type ).to eq :video
+        end
       end
     end
 
-    describe "#video", :vcr => {:cassette_name => "assets"} do
-      it "should be a video asset" do
-        subject.video.should be_a_kind_of SauceWhisk::Asset
-        subject.video.asset_type.should eq :video
+    context "without asset details" do
+      subject {SauceWhisk::Jobs.fetch "1ca64b180cfa40e0a4aee5a4a482f271" }
+
+      it "will set has_all_asset_names false" do
+        expect( subject.has_all_asset_names? ).to be false
       end
     end
   end

data/spec/lib/sauce_whisk/jobs_spec.rb

@@ -6,12 +6,12 @@ describe SauceWhisk::Jobs do
   describe "#all", :vcr => {:cassette_name => 'jobs'} do
 
     it "should return an enumerable" do
-      SauceWhisk::Jobs.all.should be_an Enumerable
+      expect( SauceWhisk::Jobs.all ).to be_an Enumerable
     end
 
     it "should return a set of jobs" do
       jobs_found = SauceWhisk::Jobs.all
-      jobs_found.each {|job| job.should be_a SauceWhisk::Job}
+      jobs_found.each {|job| expect( job ).to be_a SauceWhisk::Job}
     end
   end
 
@@ -31,7 +31,7 @@ describe SauceWhisk::Jobs do
   describe "##pass_job" do
     it "Calls the API and passes the given job" do
       job_id = "rerfreferf"
-      SauceWhisk::Jobs.should_receive(:change_status).with(job_id, true) {}
+      expect( SauceWhisk::Jobs ).to receive(:change_status).with(job_id, true) {}
 
       SauceWhisk::Jobs.pass_job job_id
     end
@@ -40,7 +40,7 @@ describe SauceWhisk::Jobs do
   describe "##fail_job" do
     it "Calls change_status to fail the job" do
       job_id = "rcercer"
-      SauceWhisk::Jobs.should_receive(:change_status).with(job_id, false) {}
+      expect( SauceWhisk::Jobs ).to receive(:change_status).with(job_id, false) {}
 
       SauceWhisk::Jobs.fail_job job_id
     end
@@ -65,15 +65,51 @@ describe SauceWhisk::Jobs do
   end
 
   describe "##fetch", :vcr => {:cassette_name => "jobs"} do
-    let(:job) {SauceWhisk::Jobs.fetch("bd9c43dd6b5549f1b942d1d581d98cac")}
+    context "for a completed job" do
+      let(:job) {SauceWhisk::Jobs.fetch("bd9c43dd6b5549f1b942d1d581d98cac")}
 
-    it "contains the list of screenshots for the job" do
-      job.screenshot_urls.should be_a_kind_of Enumerable
-      job.screenshot_urls.length.should_not be 0
+      it "contains the list of screenshots for the job" do
+        expect( job.screenshot_urls ).to be_a_kind_of Enumerable
+        expect( job.screenshot_urls.length ).to_not be 0
+      end
+
+      it "returns a job when a valid one is fetched" do
+        expect( job ).to be_an_instance_of SauceWhisk::Job
+      end
+    end
+
+    context "for an incomplete job" do
+      let(:job) {SauceWhisk::Jobs.fetch("1ca64b180cfa40e0a4aee5a4a482f271")}
+
+      it "returns a job even when asset fetching fails" do
+        expect( job ).to be_an_instance_of SauceWhisk::Job
+        expect( job.screenshots ).to be_nil
+      end
+    end
+  end
+
+  describe "##fetch!", :vcr => {:cassette_name => "jobs"} do
+    context "for a completed job" do
+      let(:job) {SauceWhisk::Jobs.fetch! "bd9c43dd6b5549f1b942d1d581d98cac"}
+
+      it "contains the list of screenshots for the job" do
+        expect( job.screenshot_urls ).to be_a_kind_of Enumerable
+        expect( job.screenshot_urls.length ).to_not be 0
+      end
+
+      it "returns a job when a valid one is fetched" do
+        expect( job ).to be_an_instance_of SauceWhisk::Job
+      end
     end
 
-    it "returns a job when a valid one is fetched" do
-      job.should be_an_instance_of SauceWhisk::Job
+    context "for an incomplete job" do
+      let(:job) {SauceWhisk::Jobs.fetch! "1ca64b180cfa40e0a4aee5a4a482f271" }
+
+      it "raises an exception" do
+        expect{
+          job
+        }.to raise_exception SauceWhisk::JobNotComplete
+      end
     end
   end
 

data/spec/lib/sauce_whisk/rest_request_builder_spec.rb

@@ -26,23 +26,46 @@ describe SauceWhisk::RestRequestBuilder do
   describe "#fully_qualified_resource" do
     context "with a resource defined" do
       it "should end with the resource" do
-        dummy_client.fully_qualified_resource.should eq "#{SauceWhisk.base_url}/#{dummy_client.resource}"
+        expect( dummy_client.fully_qualified_resource ).to eq "#{SauceWhisk.base_url}/#{dummy_client.resource}"
       end
     end
 
     context "without a resource defined" do
       it "should return the base url" do
-        dummy_client_without_resource.fully_qualified_resource.should eq SauceWhisk.base_url
+        expect( dummy_client_without_resource.fully_qualified_resource ).to eq SauceWhisk.base_url
       end
     end
   end
 
   describe "#auth_details" do
     it "should return the env vars" do
-      dummy_client.auth_details.should eq mock_auth
+      expect( dummy_client.auth_details ).to eq mock_auth
     end
   end
 
+  describe "#make_request" do
+    before :all do
+      VCR.insert_cassette 'rest_request_retry', :record => :new_episodes
+    end
+
+    after :all do
+      VCR.eject_cassette
+    end
+
+    it "should retry 404'd methods n times" do
+      expected_url = "#{SauceWhisk.base_url}/#{dummy_client.resource}"
+      expected_params = {:method => :get, :url => expected_url}.merge mock_auth
+      times = 0
+      expect( RestClient::Request ).to receive(:execute) do |arg|
+        expect(arg).to eq expected_params
+          raise RestClient::ResourceNotFound.new if(times >= SauceWhisk.rest_retries)
+        times += 1
+      end    
+      dummy_client.get
+    end
+
+  end
+
   describe "#get" do
     before :all do
       VCR.insert_cassette 'rest_request', :record => :new_episodes
@@ -54,7 +77,7 @@ describe SauceWhisk::RestRequestBuilder do
     it "should call the base URL with the resource name" do
       expected_url = "#{SauceWhisk.base_url}/#{dummy_client.resource}"
       expected_params = {:method => :get, :url => expected_url}.merge mock_auth
-      RestClient::Request.should_receive(:execute).with(expected_params)
+      expect( RestClient::Request ).to receive(:execute).with(expected_params)
       dummy_client.get
     end
   end
@@ -64,7 +87,7 @@ describe SauceWhisk::RestRequestBuilder do
 
     it "calls the base URL with the delete method" do
       expected_params = {:method => :delete, :url => expected_url}.merge mock_auth
-      RestClient::Request.should_receive(:execute).with(expected_params)
+      expect( RestClient::Request ).to receive(:execute).with(expected_params)
       dummy_client.delete "identifier"
     end
   end
@@ -74,40 +97,40 @@ begin
     let(:expected_payload) {{:tunnel_identifier => "KarlMarx"}}
     it "calls the base URL" do
       expected_url = "#{SauceWhisk.base_url}/#{dummy_client.resource}"
-      RestClient::Request.should_receive(:execute).with(hash_including({:url => expected_url}))
+      expect( RestClient::Request ).to receive(:execute).with(hash_including({:url => expected_url}))
 
       dummy_client.post(:payload => expected_payload)
     end
 
     it "uses the correct method" do
-      RestClient::Request.should_receive(:execute).with(hash_including({:method => :post}))
+      expect( RestClient::Request ).to receive(:execute).with(hash_including({:method => :post}))
       dummy_client.post(:payload => expected_payload)
     end
 
     it "includes the correct payload, in JSON" do
-      RestClient::Request.should_receive(:execute).with(hash_including({:payload => expected_payload.to_json}))
+      expect( RestClient::Request ).to receive(:execute).with(hash_including({:payload => expected_payload.to_json}))
       dummy_client.post(:payload => expected_payload)
     end
 
     it "includes the correct content_type" do
-      RestClient::Request.should_receive(:execute).with(hash_including({:content_type => "application/json"}))
+      expect( RestClient::Request ).to receive(:execute).with(hash_including({:content_type => "application/json"}))
       dummy_client.post(:payload => expected_payload)
     end
 
     it "includes the correct length" do
       expected_length = expected_payload.to_json.length
-      RestClient::Request.should_receive(:execute).with(hash_including({:headers => {"Content-Length" => expected_length}}))
+      expect( RestClient::Request ).to receive(:execute).with(hash_including({:headers => {"Content-Length" => expected_length}}))
       dummy_client.post(:payload => expected_payload)
     end
 
     it "includes the authentication parameters" do
-      RestClient::Request.should_receive(:execute).with(hash_including(mock_auth))
+      expect( RestClient::Request ).to receive(:execute).with(hash_including(mock_auth))
       dummy_client.post(:payload => expected_payload)
     end
 
     it "allows for base resource additions" do
       expected_url = "#{SauceWhisk.base_url}/#{dummy_client.resource}/dummy_res"
-      RestClient::Request.should_receive(:execute).with(hash_including({:payload => expected_payload.to_json, :url => expected_url}))
+      expect( RestClient::Request ).to receive(:execute).with(hash_including({:payload => expected_payload.to_json, :url => expected_url}))
 
       dummy_client.post(:payload => expected_payload, :resource =>"dummy_res")
     end
@@ -117,32 +140,32 @@ end
   describe "#put", :vcr => {:cassette_name => 'jobs'} do
     let(:expected_url) {"#{SauceWhisk.base_url}/#{dummy_client.resource}/something"}
     it "calls the base URL with the put method" do
-      RestClient::Request.should_receive(:execute).with(hash_including({:url => expected_url}))
+      expect( RestClient::Request ).to receive(:execute).with(hash_including({:url => expected_url}))
       dummy_client.put "something", "another_thing"
     end
 
     it "includes the right content_type" do
-      RestClient::Request.should_receive(:execute).with(hash_including({:content_type => "application/json"}))
+      expect( RestClient::Request ).to receive(:execute).with(hash_including({:content_type => "application/json"}))
       dummy_client.put "something", "another_thing"
     end
 
     it "includes the right method" do
-      RestClient::Request.should_receive(:execute).with(hash_including({:method => :put}))
+      expect( RestClient::Request ).to receive(:execute).with(hash_including({:method => :put}))
       dummy_client.put "something", "another_thing"
     end
 
     it "includes the content length" do
-      RestClient::Request.should_receive(:execute).with(hash_including(:headers => {"Content-Length" => 13}))
+      expect( RestClient::Request ).to receive(:execute).with(hash_including(:headers => {"Content-Length" => 13}))
       dummy_client.put "something", "another_thing"
     end
 
     it "includes authentication details" do
-      RestClient::Request.should_receive(:execute).with(hash_including(mock_auth))
+      expect( RestClient::Request ).to receive(:execute).with(hash_including(mock_auth))
       dummy_client.put "something", "another_thing"
     end
 
     it "sends the payload" do
-      RestClient::Request.should_receive(:execute).with(hash_including({:payload => "another_thing"}))
+      expect( RestClient::Request ).to receive(:execute).with(hash_including({:payload => "another_thing"}))
       dummy_client.put "something", "another_thing"
     end
   end

data/spec/lib/sauce_whisk/sauce_whisk_spec.rb

@@ -20,7 +20,7 @@ describe SauceWhisk do
   describe "##pass_job" do
     it "should call #pass on the jobs object" do
       job_id = "0418999"
-      SauceWhisk::Jobs.should_receive(:pass_job).with(job_id) {true}
+      expect( SauceWhisk::Jobs ).to receive(:pass_job).with(job_id) {true}
       SauceWhisk.pass_job job_id
     end
   end
@@ -32,16 +32,16 @@ describe SauceWhisk do
         end
       end
       SauceWhisk.logger = dummy_logger
-      SauceWhisk.logger.should be dummy_logger
+      expect( SauceWhisk.logger ).to be dummy_logger
     end
 
-    it "defaults to STDIN" do
+    it "defaults to STDOUT" do
       SauceWhisk.logger = nil
-      SauceWhisk.logger.should be STDOUT
+      expect( SauceWhisk.logger ).to be_a_kind_of Logger
     end
   end
 
-  describe "##retries" do
+  describe "##asset_fetch_retries" do
     it "tries to read from Sauce.config" do
       SauceWhisk.instance_variable_set(:@asset_fetch_retries, nil)
       mock_config = Class.new(Hash) do
@@ -51,7 +51,26 @@ describe SauceWhisk do
       end
 
       stub_const "::Sauce::Config", mock_config
-      SauceWhisk.asset_fetch_retries.should equal 3
+      expect( SauceWhisk.asset_fetch_retries ).to equal 3
+    end
+  end
+
+  describe "##rest_retries" do
+    it "defaults to 1" do
+      SauceWhisk.instance_variable_set(:@rest_retries, nil)
+      expect( SauceWhisk.rest_retries ).to equal 1
+    end
+
+    it "tries to read from Sauce.config" do
+      SauceWhisk.instance_variable_set(:@rest_retries, nil)
+      mock_config = Class.new(Hash) do
+        def initialize
+          self.store(:rest_retries, 3)
+        end
+      end
+
+      stub_const "::Sauce::Config", mock_config
+      expect( SauceWhisk.rest_retries ).to equal 3
     end
   end
 end