Changes to remove a lot of warnings when running the unit tests

Author: Scott Thompson

spec/APIParameterFilter_spec.rb

@@ -20,7 +20,7 @@
     end
 
     it "rejects nil object masks" do
-      expect { filter.object_mask(nil) }.to raise_error
+      expect { filter.object_mask(nil) }.to raise_error(ArgumentError)
     end
 
     it "stores its value in server_object_id when called " do
@@ -38,13 +38,13 @@
 
   describe "#object_mask" do
     it "rejects nil object masks" do
-      expect { filter.object_mask(nil) }.to raise_error
+      expect { filter.object_mask(nil) }.to raise_error(ArgumentError)
     end
 
     it "rejects calls that pass things other than strings" do
-      expect { filter.object_mask(['anArray']) }.to raise_error
-      expect { filter.object_mask({"a" => "hash"}) }.to raise_error
-      expect { filter.object_mask(Object.new) }.to raise_error
+      expect { filter.object_mask(['anArray']) }.to raise_error(ArgumentError)
+      expect { filter.object_mask({"a" => "hash"}) }.to raise_error(ArgumentError)
+      expect { filter.object_mask(Object.new) }.to raise_error(ArgumentError)
     end
 
     it "accepts strings representing a property set" do
@@ -73,7 +73,7 @@
 
   describe "#object_filter" do
     it "rejects nil filters" do
-      expect { filter.object_filter(nil) }.to raise_error
+      expect { filter.object_filter(nil) }.to raise_error(ArgumentError)
     end
 
     it "stores its value in server_object_filter when called" do

spec/Account_spec.rb

@@ -124,7 +124,7 @@
   describe "Account.account_for_client" do
     it "raises an error if there is no client available" do
       SoftLayer::Client.default_client = nil
-      expect {SoftLayer::Account.account_for_client}.to raise_error
+      expect {SoftLayer::Account.account_for_client}.to raise_error(RuntimeError)
     end
 
     it "uses the default client if one is available" do
@@ -141,4 +141,4 @@
       expect(mock_account.id).to be(12345)
     end
   end
-end
+end

spec/BareMetalServerOrder_spec.rb

@@ -30,7 +30,7 @@
 
   it "raises an error if you try to create an order with no client" do
     SoftLayer::Client.default_client = nil
-    expect {SoftLayer::BareMetalServerOrder.new()}.to raise_error
+    expect {SoftLayer::BareMetalServerOrder.new()}.to raise_error(RuntimeError)
   end
 
   it "places its :datacenter attribute into the order template" do
@@ -259,12 +259,12 @@
 
     it "has options routines that raise if not given a client" do
       SoftLayer::Client.default_client = nil
-      expect { SoftLayer::BareMetalServerOrder.create_object_options() }.to raise_error
-      expect { SoftLayer::BareMetalServerOrder.datacenter_options() }.to raise_error
-      expect { SoftLayer::BareMetalServerOrder.core_options() }.to raise_error
-      expect { SoftLayer::BareMetalServerOrder.disk_options() }.to raise_error
-      expect { SoftLayer::BareMetalServerOrder.os_reference_code_options() }.to raise_error
-      expect { SoftLayer::BareMetalServerOrder.max_port_speed_options() }.to raise_error
+      expect { SoftLayer::BareMetalServerOrder.create_object_options() }.to raise_error(RuntimeError)
+      expect { SoftLayer::BareMetalServerOrder.datacenter_options() }.to raise_error(RuntimeError)
+      expect { SoftLayer::BareMetalServerOrder.core_options() }.to raise_error(RuntimeError)
+      expect { SoftLayer::BareMetalServerOrder.disk_options() }.to raise_error(RuntimeError)
+      expect { SoftLayer::BareMetalServerOrder.os_reference_code_options() }.to raise_error(RuntimeError)
+      expect { SoftLayer::BareMetalServerOrder.max_port_speed_options() }.to raise_error(RuntimeError)
     end
   end
 

spec/BareMetalServer_spec.rb

@@ -39,7 +39,7 @@
   it_behaves_like "server with mutable hostname" do
 		let (:server) { sample_server }
   end
-  
+
 	it "can be cancelled" do
 		mock_client = SoftLayer::Client.new(:username => "fakeuser", :api_key => "DEADBEEFBADF00D")
 		allow(mock_client).to receive(:[]) do |service_name|
@@ -54,4 +54,4 @@
 		fake_server = SoftLayer::BareMetalServer.new(mock_client, { "id" => 12345 })
 		fake_server.cancel!(:migrate_larger, 'moving on up!' )
 	end
-end
+end

spec/Client_spec.rb

@@ -135,8 +135,8 @@
     end
 
     it "should reject empty or nil service names" do
-      expect { test_client.service_named('') }.to raise_error
-      expect { test_client.service_named(nil) }.to raise_error
+      expect { test_client.service_named('') }.to raise_error(ArgumentError)
+      expect { test_client.service_named(nil) }.to raise_error(ArgumentError)
     end
 
     it "should be able to construct a service" do

spec/DynamicAttribute_spec.rb

@@ -131,8 +131,8 @@ class TestClass
     end
 
     it "raises an exception if passed an invalid name" do
-      expect { SoftLayer::DynamicAttribute::DynamicAttributeDefinition.new(nil) }.to raise_error
-      expect { SoftLayer::DynamicAttribute::DynamicAttributeDefinition.new("") }.to raise_error
+      expect { SoftLayer::DynamicAttribute::DynamicAttributeDefinition.new(nil) }.to raise_error(ArgumentError)
+      expect { SoftLayer::DynamicAttribute::DynamicAttributeDefinition.new("") }.to raise_error(ArgumentError)
     end
 
     it "has valid initial values" do

spec/ObjectMaskParser_spec.rb

@@ -34,8 +34,8 @@
   end
 
   it "should reject extraeous text" do
-    expect { result = subject.parse("mask.simple, bob") }.to raise_error
-    expect { result = subject.parse("mask[two,children], bob") }.to raise_error
+    expect { result = subject.parse("mask.simple, bob") }.to raise_error(SoftLayer::ObjectMaskParserError)
+    expect { result = subject.parse("mask[two,children], bob") }.to raise_error(SoftLayer::ObjectMaskParserError)
   end
 
   it "should parse a mask with fiterMask" do
@@ -76,12 +76,12 @@
 
   it "should fail if missing the starting bracket" do
     tokenizer = SoftLayer::ObjectMaskTokenizer.new("propertyName]")
-    expect { sequence = subject.parse_property_set(tokenizer) }.to raise_error
+    expect { sequence = subject.parse_property_set(tokenizer) }.to raise_error(SoftLayer::ObjectMaskParserError)
   end
 
   it "should fail if missing the ending bracket" do
     tokenizer = SoftLayer::ObjectMaskTokenizer.new("[propertyName")
-    expect { sequence = subject.parse_property_set(tokenizer) }.to raise_error
+    expect { sequence = subject.parse_property_set(tokenizer) }.to raise_error(SoftLayer::ObjectMaskParserError)
   end
 end
 
@@ -116,12 +116,12 @@
 
   it "should reject an incomplete sequence" do
     tokenizer = SoftLayer::ObjectMaskTokenizer.new("propertyName,")
-    expect { sequence = subject.parse_property_sequence(tokenizer) }.to raise_error
+    expect { sequence = subject.parse_property_sequence(tokenizer) }.to raise_error(SoftLayer::ObjectMaskParserError)
   end
 
   it "should reject an invalid property" do
     tokenizer = SoftLayer::ObjectMaskTokenizer.new("propertyName,bad_property")
-    expect { sequence = subject.parse_property_sequence(tokenizer) }.to raise_error
+    expect { sequence = subject.parse_property_sequence(tokenizer) }.to raise_error(SoftLayer::ObjectMaskParserError)
   end
 end
 
@@ -222,17 +222,17 @@
 
   it "should fail if you try to provide a type list" do
     tokenizer = SoftLayer::ObjectMaskTokenizer.new("(Valid_Property_Type,Some_Other_Type)")
-    expect { subject.parse_property_type(tokenizer) }.to raise_error
+    expect { subject.parse_property_type(tokenizer) }.to raise_error(SoftLayer::ObjectMaskParserError)
   end
 
   it "should fail if you leave off the first paren" do
     tokenizer = SoftLayer::ObjectMaskTokenizer.new("Valid_Property_Type)")
-    expect { subject.parse_property_type(tokenizer) }.to raise_error
+    expect { subject.parse_property_type(tokenizer) }.to raise_error(SoftLayer::ObjectMaskParserError)
   end
 
   it "should fail if you leave off the last paren" do
     tokenizer = SoftLayer::ObjectMaskTokenizer.new("Valid_Property_Type[foo,bar]")
-    expect { subject.parse_property_type(tokenizer) }.to raise_error
+    expect { subject.parse_property_type(tokenizer) }.to raise_error(SoftLayer::ObjectMaskParserError)
   end
 end
 
@@ -257,4 +257,4 @@
     tokenizer = SoftLayer::ObjectMaskTokenizer.new("*!snork")
     expect { subject.parse_property_type_name(tokenizer) }.to raise_error(SoftLayer::ObjectMaskParserError)
   end
-end
+end

spec/ProductPackage_spec.rb

@@ -71,10 +71,10 @@
 
     it "calling with no client should raise" do
       SoftLayer::Client.default_client = nil
-      expect { SoftLayer::ProductPackage.packages_with_key_name('BARE_METAL_CORE') }.to raise_error
-      expect { SoftLayer::ProductPackage.virtual_server_package() }.to raise_error
-      expect { SoftLayer::ProductPackage.bare_metal_instance_package() }.to raise_error
-      expect { SoftLayer::ProductPackage.bare_metal_server_packages() }.to raise_error
+      expect { SoftLayer::ProductPackage.packages_with_key_name('BARE_METAL_CORE') }.to raise_error(RuntimeError)
+      expect { SoftLayer::ProductPackage.virtual_server_package() }.to raise_error(RuntimeError)
+      expect { SoftLayer::ProductPackage.bare_metal_instance_package() }.to raise_error(RuntimeError)
+      expect { SoftLayer::ProductPackage.bare_metal_server_packages() }.to raise_error(RuntimeError)
     end
   end
-end
+end

spec/ServerFirewall_spec.rb

@@ -24,28 +24,28 @@
     it "accepts :apply_firewall_rules" do
       mock_firewall = SoftLayer::ServerFirewall.new(mock_client, {"id" => 12345})
       allow(mock_firewall).to receive(:rules) { {} }
-    
+
       firewall_update_service = mock_client[:Network_Firewall_Update_Request]
 
       expect(firewall_update_service).to receive(:call_softlayer_api_with_params) do |method, parameters, arguments|
         expect(arguments[0]['bypassFlag']).to be(false)
       end
-    
+
       mock_firewall.change_rules_bypass!(:apply_firewall_rules)
     end
 
     it "accepts :bypass_firewall_rules!" do
       mock_firewall = SoftLayer::ServerFirewall.new(mock_client, {"id" => 12345})
       allow(mock_firewall).to receive(:rules) { {} }
-    
+
       firewall_update_service = mock_client[:Network_Firewall_Update_Request]
       expect(firewall_update_service).to receive(:call_softlayer_api_with_params) do |method, parameters, arguments|
         expect(arguments[0]['bypassFlag']).to be(true)
       end
-    
+
       mock_firewall.change_rules_bypass!(:bypass_firewall_rules)
     end
-  
+
     it "rejects other parameters (particularly true and false)" do
       mock_firewall = SoftLayer::ServerFirewall.new("not really a client", { "id" => 12345 })
       allow(mock_firewall).to receive(:rules) { {} }
@@ -54,15 +54,15 @@
 
       allow(firewall_update_service).to receive(:call_softlayer_api_with_params)
 
-      expect{ mock_firewall.change_rules_bypass!(true) }.to raise_error
-      expect{ mock_firewall.change_rules_bypass!(false) }.to raise_error
-      expect{ mock_firewall.change_rules_bypass!(:route_around_firewall) }.to raise_error
-      expect{ mock_firewall.change_rules_bypass!(:route_through_firewall) }.to raise_error
-      expect{ mock_firewall.change_rules_bypass!("apply_firewall_rules") }.to raise_error
-      expect{ mock_firewall.change_rules_bypass!("bypass_firewall_rules") }.to raise_error
-      expect{ mock_firewall.change_rules_bypass!(nil) }.to raise_error
-      expect{ mock_firewall.change_rules_bypass!(1) }.to raise_error
-      expect{ mock_firewall.change_rules_bypass!(0) }.to raise_error
+      expect{ mock_firewall.change_rules_bypass!(true) }.to raise_error(ArgumentError)
+      expect{ mock_firewall.change_rules_bypass!(false) }.to raise_error(ArgumentError)
+      expect{ mock_firewall.change_rules_bypass!(:route_around_firewall) }.to raise_error(ArgumentError)
+      expect{ mock_firewall.change_rules_bypass!(:route_through_firewall) }.to raise_error(ArgumentError)
+      expect{ mock_firewall.change_rules_bypass!("apply_firewall_rules") }.to raise_error(ArgumentError)
+      expect{ mock_firewall.change_rules_bypass!("bypass_firewall_rules") }.to raise_error(ArgumentError)
+      expect{ mock_firewall.change_rules_bypass!(nil) }.to raise_error(ArgumentError)
+      expect{ mock_firewall.change_rules_bypass!(1) }.to raise_error(ArgumentError)
+      expect{ mock_firewall.change_rules_bypass!(0) }.to raise_error(ArgumentError)
     end
   end
-end
+end

spec/Server_spec.rb

@@ -13,6 +13,6 @@
 describe SoftLayer::Server do
 	it "is an abstract base class" do
 		mock_client = SoftLayer::Client.new(:username => "fakeuser", :api_key => "DEADBEEFBADF00D")
-		expect { SoftLayer::Server.new(mock_client, { "id" => 12345 }) }.to raise_error
+		expect { SoftLayer::Server.new(mock_client, { "id" => 12345 }) }.to raise_error(RuntimeError)
 	end
-end
+end