sauce_whisk 0.0.20 → 0.0.21

data/spec/lib/sauce_whisk/account_spec.rb

@@ -1,43 +0,0 @@
-require "spec_helper"
-
-describe SauceWhisk::Account do
-  describe "##new" do
-    it "sets any options passed in as a hash" do
-      options = {
-          :access_key => 12345,
-          :minutes => 23,
-          :mac_minutes => 11,
-          :manual_minutes => 4,
-          :mac_manual_minutes => 87,
-          :id => "someone"
-      }
-
-      test_account = SauceWhisk::Account.new options
-      expect( test_account.access_key ).to eq 12345
-      expect( test_account.minutes ).to eq 23
-      expect( test_account.mac_minutes ).to eq 11
-      expect( test_account.manual_minutes ).to eq 4
-      expect( test_account.mac_manual_minutes ).to eq 87
-      expect( test_account.username ).to eq "someone"
-    end
-
-    it "sets concurrency figures" do
-      concurrencies = {
-          :mac_concurrency => 23,
-          :total_concurrency => 100
-      }
-
-      test_account = SauceWhisk::Account.new concurrencies
-      expect( test_account.mac_concurrency ).to eq 23
-      expect( test_account.total_concurrency ).to eq 100
-    end
-  end
-
-  describe "#add_subaccount", :vcr => {:cassette_name => "accounts"} do
-    let(:parent) {SauceWhisk::Account.new(:access_key => 12345, :minutes => 23, :id => ENV["SAUCE_USERNAME"])}
-
-    it "creates a subaccount" do
-      subaccount = parent.add_subaccount("Manny", "newsub77", "Manny@blackbooks.co.uk", "davesdisease")
-    end
-  end
-end

data/spec/lib/sauce_whisk/accounts_spec.rb

@@ -1,136 +0,0 @@
-require "spec_helper"
-
-describe SauceWhisk::Accounts, :vcr => {:cassette_name => "accounts", :match_requests_on => [:uri, :body]} do
-  let(:auth) {"#{ENV["SAUCE_USERNAME"]}:#{ENV["SAUCE_ACCESS_KEY"]}"}
-
-  describe "#fetch" do
-    it "fetches the passed in account" do
-      SauceWhisk::Accounts.fetch ENV["SAUCE_USERNAME"]
-      assert_requested :get, "https://#{auth}@saucelabs.com/rest/v1/users/#{ENV["SAUCE_USERNAME"]}"
-    end
-
-    it "returns an Account object" do
-      username = ENV["SAUCE_USERNAME"]
-      account = SauceWhisk::Accounts.fetch(username)
-      expect( account ).to be_an_instance_of SauceWhisk::Account
-
-      expect( account.username) .to eq username
-      expect( account.access_key ).to_not be_nil
-    end
-
-    it "includes the concurrency by default" do
-      account = SauceWhisk::Accounts.fetch ENV["SAUCE_USERNAME"]
-      assert_requested :get, "https://#{auth}@saucelabs.com/rest/v1/#{ENV["SAUCE_USERNAME"]}/limits"
-      expect( account.total_concurrency ).to eq 20
-      expect( account.mac_concurrency ).to eq 5
-    end
-
-    it "should not include concurrency when conservative is set to false" do
-      account = SauceWhisk::Accounts.fetch(ENV["SAUCE_USERNAME"], false)
-      assert_not_requested :get, "https://#{auth}@saucelabs.com/rest/v1/#{ENV["SAUCE_USERNAME"]}/limits"
-      expect( account.total_concurrency ).to be_nil
-    end
-
-    context "with an invalid account" do
-      it "Raises an InvalidAccountError" do
-        expect{
-          SauceWhisk::Accounts.fetch "IDontExist"
-        }.to raise_error SauceWhisk::InvalidAccountError
-      end
-    end
-  end
-
-  describe "#concurrency_for" do
-    it "fetches the concurrency for the passed in account" do
-      SauceWhisk::Accounts.concurrency_for ENV["SAUCE_USERNAME"]
-      assert_requested :get, "https://#{auth}@saucelabs.com/rest/v1/#{ENV["SAUCE_USERNAME"]}/limits"
-    end
-
-    it "returns concurrencies with altered names" do
-      expected_hash = {:mac_concurrency => 5, :total_concurrency => 20}
-      SauceWhisk::Accounts.concurrency_for(ENV["SAUCE_USERNAME"]).should eq expected_hash
-    end
-
-    it "returns just mac as an integer when requested" do
-      SauceWhisk::Accounts.concurrency_for(ENV["SAUCE_USERNAME"], :mac).should eq 5
-    end
-
-    it "returns just the total as an integer when requested" do
-      SauceWhisk::Accounts.concurrency_for(ENV["SAUCE_USERNAME"], :total).should eq 20
-    end
-  end
-
-  describe "#create_subaccount" do
-    let(:params) {{
-      :username => "newsub77",
-      :password => "davesdisease",
-      :name => "Manny",
-      :email => "Manny@blackbooks.co.uk"
-    }}
-
-    let(:parent) {SauceWhisk::Account.new(:access_key => 12345, :minutes => 23, :id => ENV["SAUCE_USERNAME"])}
-
-    it "calls the correct url" do
-      SauceWhisk::Accounts.create_subaccount(parent,
-          "Manny", "newsub77", "Manny@blackbooks.co.uk", "davesdisease")
-
-      assert_requested(:post,
-        "https://#{auth}@saucelabs.com/rest/v1/users/#{ENV["SAUCE_USERNAME"]}",
-        :body => params.to_json
-      )
-    end
-
-    it "returns a Subaccount object" do
-      sub = SauceWhisk::Accounts.create_subaccount(parent, "Manny", "newsub77",
-          "Manny@blackbooks.co.uk", "davesdisease")
-
-      expect( sub ).to be_a_kind_of SauceWhisk::Account
-    end
-
-    it "returns a Subaccount, parented to the Parent account" do
-      parent = SauceWhisk::Accounts.fetch ENV["SAUCE_USERNAME"]
-
-      sub = SauceWhisk::Accounts.create_subaccount(parent, "Manny", "newsub77",
-                                                   "Manny@blackbooks.co.uk", "davesdisease")
-
-      expect( sub.parent ).to be parent
-    end
-
-    context "trying to create too many subaccounts" do
-      it "should throw SubaccountCreationError" do
-       expect{
-          SauceWhisk::Accounts.create_subaccount(parent, "Manny", "toomany",
-              "Manny@blackbooks.co.uk", "davesdisease")
-        }.to raise_error SauceWhisk::SubAccountCreationError
-      end
-    end
-
-    context "trying to create a subaccount which already exists" do
-      it "should throw SubaccountCreationError" do
-        expect{
-          SauceWhisk::Accounts.create_subaccount(parent, "Manny", "duplicate",
-               "Manny@blackbooks.co.uk", "davesdisease")
-        }.to raise_error SauceWhisk::SubAccountCreationError
-      end
-    end
-
-    context "trying to create a subaccount which causes the tree to be too deep" do
-      it "should throw SubaccountCreationError" do
-        expect{
-          SauceWhisk::Accounts.create_subaccount(parent, "Manny", "deeptree",
-               "Manny@blackbooks.co.uk", "davesdisease")
-        }.to raise_error SauceWhisk::SubAccountCreationError
-      end
-    end
-
-    context "with a non-existant parent" do
-      let(:parent) {SauceWhisk::Account.new(:access_key => 12345, :minutes => 23, :id =>"nopenotaperson")}
-      it "should throw SubaccountCreationError" do
-        expect{
-          SauceWhisk::Accounts.create_subaccount(parent, "Manny", "deeptree",
-                                                 "Manny@blackbooks.co.uk", "davesdisease")
-        }.to raise_error SauceWhisk::InvalidAccountError
-      end
-    end
-  end
-end

data/spec/lib/sauce_whisk/asset_spec.rb

@@ -1,39 +0,0 @@
-require "spec_helper"
-
-describe SauceWhisk::Asset do
-
-  describe "#initialize" do
-    let(:data) {"DEDEDEDEDED"}
-    let(:name) {"video01.mpg"}
-    let(:job_id) {"c4revevegegerg"}
-    let(:type) {:video}
-
-    before :each do
-      params = {:data => data, :name => name, :type => type, :job_id => job_id}
-
-      @asset = SauceWhisk::Asset.new params
-    end
-
-    it "should store the name" do
-      expect( @asset.name ).to eq name
-    end
-
-    it "should store the data" do
-      expect( @asset.data ).to eq data
-    end
-
-    it "should store the type" do
-      expect( @asset.asset_type ).to eq type
-    end
-
-    it "should store the job_id" do
-      expect( @asset.job ).to eq job_id
-    end
-  end
-
-  describe "#type" do
-    it "should default to screenshot" do
-      expect( SauceWhisk::Asset.new.asset_type ).to eq :screenshot
-    end
-  end
-end

data/spec/lib/sauce_whisk/assets_spec.rb

@@ -1,61 +0,0 @@
-require "spec_helper"
-
-describe SauceWhisk::Assets do
-  let(:auth) {"#{ENV["SAUCE_USERNAME"]}:#{ENV["SAUCE_ACCESS_KEY"]}"}
-  let(:user) {ENV["SAUCE_USERNAME"]}
-
-  describe "#fetch", :vcr => {:cassette_name => "assets"} do
-    let(:job_id)  {"bd9c43dd6b5549f1b942d1d581d98cac"}
-    let(:asset_name)  {"0000screenshot.png"}
-
-    it "fetches an asset for the requested job" do
-      SauceWhisk::Assets.fetch job_id, asset_name
-
-      assert_requested :get, "https://#{auth}@saucelabs.com/rest/v1/#{user}/jobs/#{job_id}/assets/#{asset_name}"
-    end
-
-    it "returns an asset" do
-      SauceWhisk::Assets.fetch(job_id, asset_name).should be_an_instance_of SauceWhisk::Asset
-    end
-
-    it "initializes the asset properly" do
-      asset = SauceWhisk::Assets.fetch job_id, asset_name
-      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
-      let(:invalid_job_id) {"aaaaaaaaaaaaaaaa"}
-
-      it "returns a RestClient::ResourceNotFound Exception" do
-        expect {
-          SauceWhisk::Assets.fetch invalid_job_id, asset_name
-        }.to raise_error RestClient::ResourceNotFound
-      end
-    end
-
-    context "for an asset that's not available immediately" do
-      let(:slow_job_id) {"n0th3r3y3t"}
-
-      it "returns the asset" do
-        SauceWhisk::Assets.fetch(slow_job_id, asset_name).should be_an_instance_of SauceWhisk::Asset
-      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

@@ -1,66 +0,0 @@
-require "spec_helper"
-
-describe "SauceWhisk::Sauce", :vcr => {:cassette_name => "info"}  do
-  describe "#service_status"do
-    it "calls the correct URI" do
-      SauceWhisk::Sauce.service_status
-      assert_requested :get, "https://saucelabs.com/rest/v1/info/status"
-    end
-
-    it "returns a hash" do
-      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|
-        expect( k ).to be_an_instance_of Symbol
-      end
-    end
-  end
-
-  describe "#test_count" do
-    it "calls the correct URI" do
-      SauceWhisk::Sauce.total_job_count
-      assert_requested :get, "https://saucelabs.com/rest/v1/info/counter"
-    end
-
-    it "returns an integer" do
-      expect( SauceWhisk::Sauce.total_job_count ).to be_a_kind_of Integer
-    end
-  end
-
-  describe "#platforms" do
-    it "calls the correct URI" do
-      SauceWhisk::Sauce.platforms
-      assert_requested :get, "https://saucelabs.com/rest/v1/info/browsers/webdriver"
-    end
-
-    it "only calls the api once" do
-      SauceWhisk::Sauce.instance_variable_set(:@platforms, nil)
-      SauceWhisk::Sauce.platforms
-      SauceWhisk::Sauce.platforms
-      assert_requested :get, "https://saucelabs.com/rest/v1/info/browsers/webdriver"
-    end
-
-    it "returns an array" do
-      platforms = SauceWhisk::Sauce.platforms
-      expect( platforms ).to be_a_kind_of Array
-    end
-
-    context "when called with true" do
-      it "calls the API each time" do
-        SauceWhisk::Sauce.instance_variable_set(:@platforms, nil)
-        SauceWhisk::Sauce.platforms
-        SauceWhisk::Sauce.platforms(true)
-
-        assert_requested :get, "https://saucelabs.com/rest/v1/info/browsers/webdriver", :times => 2
-      end
-    end
-  end
-
-  describe "operational?" do
-    it "returns true when the service is running" do
-      expect( SauceWhisk::Sauce.operational? ).to be true
-    end
-  end
-end

data/spec/lib/sauce_whisk/job_spec.rb

@@ -1,137 +0,0 @@
-require "spec_helper"
-
-describe SauceWhisk::Job do
-  let(:job) {SauceWhisk::Job.new}
-  let(:user) {ENV["SAUCE_USERNAME"]}
-  subject {SauceWhisk::Job.new}
-
-  it {should respond_to :id}
-
-  context "Initialized" do
-    let(:params) {{
-      "id" => "dsfargeg",
-      "owner" => "Dave",
-      "status" => "Things",
-      "error" => nil,
-      "name" => "Test All The RESTS",
-      "browser" => "firefox",
-      "browser_version" => "18",
-      "os" => "Windows 2008",
-      "creation_time" => Time.now.to_i,
-      "start_time" => Time.now + 4,
-      "end_time" => Time.now + 118,
-      "video_url" => "http://www.notarealplace.com/somewhere/resource",
-      "log_url" => "http://www.underthesea.com/notreally/404",
-      "public" => false,
-      "tags" => ["ruby", "awesome", "restful"],
-      "custom_data" => ""
-    }}
-
-    subject {SauceWhisk::Job.new(params)}
-
-    it "sets parameters at init" do
-      params.each do |k,v|
-        subject.send(k).should eq v
-      end
-    end
-
-    it "tracks changes to methods" do
-      subject.name = "ANewName"
-      expect( subject.updated_fields ).to include :name
-
-      subject.visibility = true
-      expect( subject.updated_fields ).to include :visibility
-    end
-
-    it "does not track unchanged methods" do
-      expect( subject.updated_fields ).to_not include :build
-    end
-
-    it "has empty updated_fields for new instances" do
-      new_job = SauceWhisk::Job.new(params)
-      expect( new_job.updated_fields ).to eq []
-    end
-
-    describe "#save" do
-      subject {SauceWhisk::Job.new(params)}
-
-      context "with changed values" do
-        before(:each) do
-          subject.name = "New_Name"
-        end
-
-        it "calls the save method of the SauceWhisk::Jobs object" do
-          expect( SauceWhisk::Jobs ).to receive(:save).with(subject)
-          subject.save
-        end
-      end
-    end
-
-    describe "#stop" do
-      subject {SauceWhisk::Job.new(params.merge({"id" => "3edc8fe6d52645bf931b1003da65af1f"}))}
-
-      it "Calls the correct REST API method", :vcr => {:cassette_name => "jobs"} do
-        subject.stop
-        assert_requested :put, "https://#{user}:#{ENV["SAUCE_ACCESS_KEY"]}@saucelabs.com/rest/v1/#{user}/jobs/#{subject.id}/stop"
-      end
-    end
-
-    describe "parameters" do
-      it "lets you set only the parameters which are mutable" do
-        [:name, :build, :passed, :tags, :custom_data, :visibility].each do |param|
-          changed_value = "Changed#{param}"
-          subject.send("#{param}=", changed_value)
-          subject.send(param).should eq changed_value
-        end
-      end
-
-      it "throws an exception if you try to set one of the fixed attributes" do
-        [:id, :owner, :browser, :browser_version, :os, :error, :creation_time,
-         :start_time, :end_time, :video_url, :log_url
-        ].each do |param|
-          expect {
-            subject.send("#{param}=", "TOTALLYDIFFERENT")
-          }.to raise_exception
-
-          expect( subject.send(param) ).not_to eq "TOTALLYDIFFERENT"
-        end
-      end
-    end
-  end
-
-  context "fetched from the API", :vcr => {:cassette_name => "assets"} do
-    context "with all asset details" do
-      subject {SauceWhisk::Jobs.fetch "bd9c43dd6b5549f1b942d1d581d98cac"}
-
-      it "will set has_all_asset_names true" do
-        expect( subject.has_all_asset_names? ).to be true
-      end
-
-      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
-
-    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
-end