squall 1.3.0 → 1.3.1

data/spec/squall/user_spec.rb

@@ -7,53 +7,12 @@ describe Squall::User do
             "used_cpus", "group_id", "id", "used_memory", "payment_amount", "last_name", "remember_token",
             "disk_space_available", "time_zone", "outstanding_amount", "login", "roles", "email", "first_name"]
     @user = Squall::User.new
-    @valid = {:login => 'johndoe', :email => 'johndoe@example.com', :password => 'CD2480A3413F',
-              :password_confirmation => 'CD2480A3413F', :first_name => 'John', :last_name => 'Doe' }
+    @valid = {login: 'johndoe', email: 'johndoe@example.com', password: 'CD2480A3413F',
+              password_confirmation: 'CD2480A3413F', first_name: 'John', last_name: 'Doe' }
   end
 
   describe "#create" do
     use_vcr_cassette "user/create"
-    it "requires login" do
-      invalid = @valid.reject{|k,v| k == :login }
-      requires_attr(:login) { @user.create(invalid) }
-    end
-
-    it "requires email" do
-      invalid = @valid.reject{|k,v| k == :email }
-      requires_attr(:email) { @user.create(invalid) }
-    end
-
-    it "requires password" do
-      invalid = @valid.reject{|k,v| k == :password }
-      requires_attr(:password) { @user.create(invalid) }
-    end
-
-    it "requires password confirmation" do
-      invalid = @valid.reject{|k,v| k == :password_confirmation }
-      requires_attr(:password_confirmation) { @user.create(invalid) }
-    end
-
-    it "requires first name" do
-      invalid = @valid.reject{|k,v| k == :first_name }
-      requires_attr(:first_name) { @user.create(invalid) }
-    end
-
-    it "requires last name" do
-      invalid = @valid.reject{|k,v| k == :last_name }
-      requires_attr(:last_name) { @user.create(invalid) }
-    end
-
-    it "allows all optional params" do
-      optional = [:role, :time_zone, :locale, :status, :billing_plan_id, :role_ids, :suspend_after_hours, :suspend_at]
-      @user.should_receive(:request).exactly(optional.size).times.and_return Hash.new("user" => {})
-      optional.each do |param|
-        @user.create(@valid.merge(param => "test"))
-      end
-    end
-
-    it "raises error on unknown params" do
-      expect { @user.create(@valid.merge(:what => 'what')) }.to raise_error(ArgumentError, 'Unknown params: what')
-    end
 
     it "creates a user" do
       user = @user.create(@valid)
@@ -64,26 +23,15 @@ describe Squall::User do
   describe "#edit" do
     use_vcr_cassette "user/edit"
 
-    it "allows select params" do
-      optional = [:email, :password, :password_confirmation, :first_name, :last_name, :user_group_id, :billing_plan_id, :role_ids, :suspend_at]
-      @user.should_receive(:request).exactly(optional.size).times.and_return Hash.new()
-      optional.each do |param|
-        @user.edit(1, param => "test")
-      end
-    end
-
-    it "raises error on unknown params" do
-      expect { @user.edit(1, :what => 'what') }.to raise_error(ArgumentError, 'Unknown params: what')
-    end
-
     it "edits a user" do
-      user = @user.edit(1, :first_name => "Test")
+      user = @user.edit(1, first_name: "Test")
       @user.success.should be_true
     end
   end
 
   describe "#list" do
     use_vcr_cassette "user/list"
+
     it "returns a user list" do
       users = @user.list
       users.should be_an(Array)
@@ -97,9 +45,6 @@ describe Squall::User do
 
   describe "#show" do
     use_vcr_cassette "user/show"
-    it "requires an id" do
-      expect { @user.show }.to raise_error(ArgumentError)
-    end
 
     it "returns a user" do
       user = @user.show(1)
@@ -109,9 +54,6 @@ describe Squall::User do
 
   describe "#generate_api_key" do
     use_vcr_cassette "user/generate_api_key"
-    it "requires an id" do
-      expect { @user.generate_api_key }.to raise_error(ArgumentError)
-    end
 
     it "generates a new key" do
       user = @user.generate_api_key(1)
@@ -121,9 +63,6 @@ describe Squall::User do
 
   describe "#suspend" do
     use_vcr_cassette "user/suspend"
-    it "requires an id" do
-      expect { @user.suspend }.to raise_error(ArgumentError)
-    end
 
     it "suspends a user" do
       user = @user.suspend(1)
@@ -133,9 +72,6 @@ describe Squall::User do
 
   describe "#activate" do
     use_vcr_cassette "user/activate"
-    it "requires an id" do
-      expect { @user.activate }.to raise_error(ArgumentError)
-    end
 
     it "activates a user" do
       user = @user.activate(1)
@@ -149,9 +85,6 @@ describe Squall::User do
 
   describe "#delete" do
     use_vcr_cassette "user/delete"
-    it "requires an id" do
-      expect { @user.delete }.to raise_error(ArgumentError)
-    end
 
     it "deletes a user" do
       @user.delete(1)
@@ -161,9 +94,6 @@ describe Squall::User do
 
   describe "#stats" do
     use_vcr_cassette "user/stats"
-    it "requires an id" do
-      expect { @user.stats }.to raise_error(ArgumentError)
-    end
 
     it "returns stats" do
       stats = @user.stats(1)
@@ -173,9 +103,6 @@ describe Squall::User do
 
   describe "#monthly_bills" do
     use_vcr_cassette "user/monthly_bills"
-    it "requires an id" do
-      expect { @user.monthly_bills }.to raise_error(ArgumentError)
-    end
 
     it "returns an array of bills for the user" do
       stats = @user.monthly_bills(1)
@@ -185,9 +112,6 @@ describe Squall::User do
 
   describe "#virtual_machines" do
     use_vcr_cassette "user/virtual_machines"
-    it "requires an id" do
-      expect { @user.virtual_machines }.to raise_error(ArgumentError)
-    end
 
     it "returns the virtual_machines" do
       virtual_machines = @user.virtual_machines(1)
@@ -197,9 +121,6 @@ describe Squall::User do
 
   describe "#hypervisors" do
     use_vcr_cassette "user/hypervisors"
-    it "requires an id" do
-      expect { @user.hypervisors }.to raise_error(ArgumentError)
-    end
 
     it "returns the virtual_machines" do
       hypervisors = @user.hypervisors(1)
@@ -209,9 +130,6 @@ describe Squall::User do
 
   describe "#data_store_zones" do
     use_vcr_cassette "user/data_store_zones"
-    it "requires an id" do
-      expect { @user.data_store_zones }.to raise_error(ArgumentError)
-    end
 
     it "returns the virtual_machines" do
       data_store_zones = @user.data_store_zones(1)
@@ -221,9 +139,6 @@ describe Squall::User do
 
   describe "#network_zones" do
     use_vcr_cassette "user/network_zones"
-    it "requires an id" do
-      expect { @user.network_zones }.to raise_error(ArgumentError)
-    end
 
     it "returns the network_zones" do
       network_zones = @user.network_zones(1)
@@ -233,9 +148,6 @@ describe Squall::User do
 
   describe "#limits" do
     use_vcr_cassette "user/limits"
-    it "requires an id" do
-      expect { @user.limits }.to raise_error(ArgumentError)
-    end
 
     it "returns the limits" do
       limits = @user.limits(1)

data/spec/squall/virtual_machine_spec.rb

@@ -3,8 +3,8 @@ require 'spec_helper'
 describe Squall::VirtualMachine do
   before(:each) do
     @virtual_machine = Squall::VirtualMachine.new
-    @valid = {:label => 'testmachine', :hostname => 'testmachine', :memory => 512, :cpus => 1,
-              :cpu_shares => 10, :primary_disk_size => 10, :template_id => 1}
+    @valid = {label: 'testmachine', hostname: 'testmachine', memory: 512, cpus: 1,
+              cpu_shares: 10, primary_disk_size: 10, template_id: 1}
     @keys = ["monthly_bandwidth_used", "cpus", "label", "created_at", "operating_system_distro",
       "cpu_shares", "operating_system", "template_id", "allowed_swap", "local_remote_access_port",
       "memory", "updated_at", "allow_resize_without_reboot", "recovery_mode", "hypervisor_id", "id",
@@ -29,9 +29,6 @@ describe Squall::VirtualMachine do
 
   describe "#show" do
     use_vcr_cassette "virtual_machine/show"
-    it "requires an id" do
-      expect { @virtual_machine.show }.to raise_error(ArgumentError)
-    end
 
     it "returns a virtual_machine" do
       virtual_machine = @virtual_machine.show(1)
@@ -42,71 +39,6 @@ describe Squall::VirtualMachine do
 
   describe "#create" do
     use_vcr_cassette "virtual_machine/create"
-    #  validates :label, :hypervisor_id, :hostname, :memory, :cpus, :presence => true
-    it "requires label" do
-      requires_attr(:label) { @virtual_machine.create }
-    end
-
-    it "requires hostname" do
-      requires_attr(:hostname) {
-        @virtual_machine.create(:label => @valid[:label])
-      }
-    end
-
-    it "requires memory" do
-      requires_attr(:memory) {
-        @virtual_machine.create(:label => @valid[:label], :hostname => @valid[:hostname])
-      }
-    end
-
-    it "requires cpus" do
-      requires_attr(:cpus) {
-        @virtual_machine.create(:label => @valid[:label], :hostname => @valid[:hostname],
-                                :memory => @valid[:memory])
-      }
-    end
-
-    it "requires cpu_shares" do
-      requires_attr(:cpu_shares) {
-        @virtual_machine.create(:label => @valid[:label], :hostname => @valid[:hostname],
-                                :memory => @valid[:memory], :cpus => @valid[:cpu_shares])
-      }
-    end
-
-    it "requires primary_disk_size" do
-      requires_attr(:primary_disk_size) {
-        @virtual_machine.create(:label => @valid[:label], :hostname => @valid[:hostname],
-                                :memory => @valid[:memory], :cpus => @valid[:cpu_shares],
-                                :cpu_shares => @valid[:cpu_shares])
-      }
-    end
-
-    it "raises error on unknown params" do
-      expect {
-        @virtual_machine.create(@valid.merge(:what => 'what'))
-      }.to raise_error(ArgumentError, 'Unknown params: what')
-    end
-
-    it "allows all optional params" do
-      optional = [:swap_disk_size,
-                  :primary_network_id,
-                  :required_automatic_backup,
-                  :rate_limit,
-                  :required_ip_address_assignment,
-                  :required_virtual_machine_build,
-                  :admin_note,
-                  :note,
-                  :allowed_hot_migrate,
-                  :hypervisor_id,
-                  :initial_root_password,
-                  :hypervisor_group_id
-      ]
-
-      @virtual_machine.should_receive(:request).exactly(optional.size).times.and_return Hash.new('virtual_machine' => [])
-      optional.each do |param|
-        @virtual_machine.create(@valid.merge(param => "test"))
-      end
-    end
 
     it "creates a virtual_machine" do
       pending "broken in OnApp (triggering the Network Interfaces error): see README (and update when fixed)" do
@@ -120,24 +52,9 @@ describe Squall::VirtualMachine do
 
   describe "#build" do
     use_vcr_cassette "virtual_machine/build"
-    it "requires an id" do
-      expect { @virtual_machine.build }.to raise_error(ArgumentError)
-      @virtual_machine.success.should be_false
-    end
-
-    it "accepts :template_id and :required_startup" do
-      hash = [:post, "/virtual_machines/1/build.json", {:query=>{:virtual_machine=>{:template_id=>1, :required_startup=>1}}}]
-      @virtual_machine.should_receive(:request).with(*hash).once.and_return({'virtual_machine'=>{}})
-      @virtual_machine.build(1, :template_id => 1, :required_startup => 1)
-    end
-
-    it "raises error on unknown params" do
-      expect { @virtual_machine.build(1, :template_id => 1, :asdf => 1) }.to raise_error(ArgumentError, 'Unknown params: asdf')
-      @virtual_machine.success.should be_false
-    end
 
     it "builds the VM" do
-      build = @virtual_machine.build(72, :template_id => 1)
+      build = @virtual_machine.build(72, template_id: 1)
 
       @virtual_machine.success.should be_true
     end
@@ -146,62 +63,15 @@ describe Squall::VirtualMachine do
   describe "#edit" do
     use_vcr_cassette "virtual_machine/edit"
 
-    it "requires an id" do
-      expect { @virtual_machine.edit }.to raise_error(ArgumentError)
-      @virtual_machine.success.should be_false
-    end
-
-    it "raises error on unknown params" do
-      expect { @virtual_machine.edit(1, :blah => 1) }.to raise_error(ArgumentError, 'Unknown params: blah')
-      @virtual_machine.success.should be_false
-    end
-
-    it "accepts all valid keys" do
-      keys = [:label,
-              :hypervisor_id,
-              :hostname,
-              :memory,
-              :cpus,
-              :cpu_shares,
-              :primary_disk_size,
-              :cpu_shares,
-              :swap_disk_size,
-              :primary_network_id,
-              :required_automatic_backup,
-              :rate_limit,
-              :required_ip_address_assignment,
-              :required_virtual_machine_build,
-              :admin_note,
-              :note,
-              :allowed_hot_migrate,
-              :template_id,
-              :initial_root_password
-      ]
-      keys.each do |k|
-        opts = @virtual_machine.default_params(k.to_sym => 1)
-        args = [:put, '/virtual_machines/1.json', opts]
-        @virtual_machine.should_receive(:request).with(*args).once.and_return([])
-        @virtual_machine.edit(1, k.to_sym => 1 )
-      end
-    end
-
     it "updates the label" do
-      @virtual_machine.edit(1, :label => 'testing')
+      virtual_machine = @virtual_machine.edit(1, label: 'testing')
       @virtual_machine.success.should be_true
+      virtual_machine['label'].should == 'testing'
     end
   end
 
   describe "#change_owner" do
     use_vcr_cassette "virtual_machine/change_owner"
-    it "requires an id" do
-      expect { @virtual_machine.change_owner }.to raise_error(ArgumentError)
-      @virtual_machine.success.should be_false
-    end
-
-    it "requires a user_id" do
-      expect { @virtual_machine.change_owner 1 }.to raise_error(ArgumentError)
-      @virtual_machine.success.should be_false
-    end
 
     pending "this should raise a 422 on OnApp's side, but it's currently raising a 500 which causes HTTParty to explode, see README (and update when fixed)" do
       it "returns error on unknown user" do
@@ -220,15 +90,6 @@ describe Squall::VirtualMachine do
 
   describe "#change_password" do
     use_vcr_cassette "virtual_machine/change_password"
-    it "requires an id" do
-      expect { @virtual_machine.change_password }.to raise_error(ArgumentError)
-      @virtual_machine.success.should be_false
-    end
-
-    it "requires a password" do
-      expect { @virtual_machine.change_password 1 }.to raise_error(ArgumentError)
-      @virtual_machine.success.should be_false
-    end
 
     it "changes the password" do
       result = @virtual_machine.change_password(1, 'passwordsareimportant')
@@ -238,10 +99,6 @@ describe Squall::VirtualMachine do
 
   describe "#set_ssh_keys" do
     use_vcr_cassette "virtual_machine/set_ssh_keys"
-    it "requires an id" do
-      expect { @virtual_machine.set_ssh_keys }.to raise_error(ArgumentError)
-      @virtual_machine.success.should be_false
-    end
 
     it "sets the SSH keys" do
       result = @virtual_machine.set_ssh_keys(1)
@@ -251,25 +108,10 @@ describe Squall::VirtualMachine do
 
   describe "#migrate" do
     use_vcr_cassette "virtual_machine/migrate"
-    it "requires an id" do
-      expect { @virtual_machine.migrate }.to raise_error(ArgumentError)
-      @virtual_machine.success.should be_false
-    end
-
-    it "requires a destination" do
-      requires_attr(:destination) { @virtual_machine.migrate 1 }
-      @virtual_machine.success.should be_false
-    end
-
-    it "accepts cold_migrate_on_rollback" do
-      hash = [:post, "/virtual_machines/1/migrate.json", {:query => {:virtual_machine => {:destination => 1, :cold_migrate_on_rollback => 1}} }]
-      @virtual_machine.should_receive(:request).with(*hash).once.and_return({'virtual_machine'=>{}})
-      @virtual_machine.migrate 1, :destination => 1, :cold_migrate_on_rollback => 1
-    end
 
     it "changes the hypervisor" do
       pending "Broken in OnApp" do
-        result = @virtual_machine.migrate(1, :destination => 2)
+        result = @virtual_machine.migrate(1, destination: 2)
         @virtual_machine.success.should be_true
         result['virtual_machine']['hypervisor_id'].should == 2
       end
@@ -278,9 +120,6 @@ describe Squall::VirtualMachine do
 
   describe "#set_vip" do
     use_vcr_cassette "virtual_machine/set_vip"
-    it "requires an id" do
-      expect { @virtual_machine.set_vip }.to raise_error(ArgumentError)
-    end
 
     it "deletes a virtual_machine" do
       @virtual_machine.set_vip(1)
@@ -298,9 +137,6 @@ describe Squall::VirtualMachine do
 
   describe "#delete" do
     use_vcr_cassette "virtual_machine/delete"
-    it "requires an id" do
-      expect { @virtual_machine.delete }.to raise_error(ArgumentError)
-    end
 
     it "deletes a virtual_machine" do
       virtual_machine = @virtual_machine.delete(1)
@@ -310,51 +146,17 @@ describe Squall::VirtualMachine do
 
   describe "#resize" do
     use_vcr_cassette "virtual_machine/resize"
-    it "requires an id" do
-      expect { @virtual_machine.resize }.to raise_error(ArgumentError)
-    end
-
-    it "accepts memory" do
-      hash = [:post, "/virtual_machines/1/resize.json",  @virtual_machine.default_params(:memory => 1)]
-      @virtual_machine.should_receive(:request).with(*hash).once.and_return({'virtual_machine'=>{}})
-      @virtual_machine.resize 1, :memory => 1
-    end
-
-    it "accepts cpus" do
-      hash = [:post, "/virtual_machines/1/resize.json",  @virtual_machine.default_params(:cpus => 1)]
-      @virtual_machine.should_receive(:request).with(*hash).once.and_return({'virtual_machine'=>{}})
-      @virtual_machine.resize 1, :cpus => 1
-    end
-
-    it "accepts cpu_shares" do
-      hash = [:post, "/virtual_machines/1/resize.json",  @virtual_machine.default_params(:cpu_shares => 1)]
-      @virtual_machine.should_receive(:request).with(*hash).once.and_return({'virtual_machine'=>{}})
-      @virtual_machine.resize 1, :cpu_shares => 1
-    end
-
-    it "accepts allow_cold_resize" do
-      hash = [:post, "/virtual_machines/1/resize.json",  @virtual_machine.default_params(:allow_cold_resize => 1)]
-      @virtual_machine.should_receive(:request).with(*hash).once.and_return({'virtual_machine'=>{}})
-      @virtual_machine.resize 1, :allow_cold_resize => 1
-    end
 
     it "resizes a virtual_machine" do
-      virtual_machine = @virtual_machine.resize(1, :memory => 1000)
+      virtual_machine = @virtual_machine.resize(1, memory: 1000)
       @virtual_machine.success.should be_true
 
       virtual_machine['memory'].should == 1000
     end
-
-    it "requires at least one option" do
-      expect { @virtual_machine.resize(1) }.to raise_error(ArgumentError)
-    end
   end
 
   describe "#suspend" do
     use_vcr_cassette "virtual_machine/suspend"
-    it "requires an id" do
-      expect { @virtual_machine.suspend }.to raise_error(ArgumentError)
-    end
 
     it "suspends a virtual_machine" do
       virtual_machine = @virtual_machine.suspend(1)
@@ -364,9 +166,6 @@ describe Squall::VirtualMachine do
 
   describe "#unlock" do
     use_vcr_cassette "virtual_machine/unlock"
-    it "requires an id" do
-      expect { @virtual_machine.unlock }.to raise_error(ArgumentError)
-    end
 
     it "unlocks a virtual_machine" do
       virtual_machine = @virtual_machine.unlock(1)
@@ -376,10 +175,6 @@ describe Squall::VirtualMachine do
 
   describe "#startup" do
     use_vcr_cassette "virtual_machine/startup"
-    it "requires an id" do
-      expect { @virtual_machine.startup }.to raise_error(ArgumentError)
-      @virtual_machine.success.should be_false
-    end
 
     it "startups a virtual_machine" do
       @virtual_machine.startup(1)
@@ -389,10 +184,6 @@ describe Squall::VirtualMachine do
 
   describe "#shutdown" do
     use_vcr_cassette "virtual_machine/shutdown"
-    it "requires an id" do
-      expect { @virtual_machine.shutdown }.to raise_error(ArgumentError)
-      @virtual_machine.success.should be_false
-    end
 
     it "will shutdown a virtual_machine" do
       virtual_machine = @virtual_machine.shutdown(1)
@@ -402,10 +193,6 @@ describe Squall::VirtualMachine do
 
   describe "#stop" do
     use_vcr_cassette "virtual_machine/stop"
-    it "requires an id" do
-      expect { @virtual_machine.stop }.to raise_error(ArgumentError)
-      @virtual_machine.success.should be_false
-    end
 
     it "will stop a virtual_machine" do
       virtual_machine = @virtual_machine.stop(1)
@@ -415,10 +202,6 @@ describe Squall::VirtualMachine do
 
   describe "#reboot" do
     use_vcr_cassette "virtual_machine/reboot"
-    it "requires an id" do
-      expect { @virtual_machine.reboot }.to raise_error(ArgumentError)
-      @virtual_machine.success.should be_false
-    end
 
     it "will reboot a virtual_machine" do
       virtual_machine = @virtual_machine.reboot(1)
@@ -426,7 +209,7 @@ describe Squall::VirtualMachine do
     end
 
     it "reboots in recovery" do
-      hash = [:post, "/virtual_machines/1/reboot.json", {:query => {:mode => :recovery}}]
+      hash = [:post, "/virtual_machines/1/reboot.json", {query: {mode: :recovery}}]
       @virtual_machine.should_receive(:request).with(*hash).once.and_return({'virtual_machine'=>{}})
       @virtual_machine.reboot 1, true
     end
@@ -434,15 +217,6 @@ describe Squall::VirtualMachine do
 
   describe "#segregate" do
     use_vcr_cassette "virtual_machine/segregate"
-    it "requires an id" do
-      expect { @virtual_machine.segregate }.to raise_error(ArgumentError)
-      @virtual_machine.success.should be_false
-    end
-
-    it "requires a target_vm_id" do
-      expect { @virtual_machine.segregate 1 }.to raise_error(ArgumentError)
-      @virtual_machine.success.should be_false
-    end
 
     it "segregates the VMS with given ids" do
       result = @virtual_machine.segregate(1, 2)
@@ -452,10 +226,6 @@ describe Squall::VirtualMachine do
 
   describe "#console" do
     use_vcr_cassette "virtual_machine/console"
-    it "requires an id" do
-      expect { @virtual_machine.console }.to raise_error(ArgumentError)
-      @virtual_machine.success.should be_false
-    end
 
     it "will reboot a virtual_machine" do
       pending "broken on OnApp (returning 500)" do
@@ -467,10 +237,6 @@ describe Squall::VirtualMachine do
 
   describe "#stats" do
     use_vcr_cassette "virtual_machine/stats"
-    it "requires an id" do
-      expect { @virtual_machine.stats }.to raise_error(ArgumentError)
-      @virtual_machine.success.should be_false
-    end
 
     it "will stop a virtual_machine" do
       pending "broken on OnApp (returning 500)" do

data/spec/squall/whitelist_spec.rb

@@ -3,16 +3,12 @@ require 'spec_helper'
 describe Squall::Whitelist do
   before(:each) do
     @whitelist = Squall::Whitelist.new
-    @valid = {:ip => "192.168.1.1"}
+    @valid = {ip: "192.168.1.1"}
   end
 
   describe "#list" do
     use_vcr_cassette "whitelist/list"
 
-    it "requires user id" do
-      expect { @whitelist.list }.to raise_error(ArgumentError)
-    end
-
     it "returns a user's whitelists" do
       whitelists = @whitelist.list(1)
       whitelists.should be_an(Array)
@@ -26,9 +22,6 @@ describe Squall::Whitelist do
 
   describe "#show" do
     use_vcr_cassette "whitelist/show"
-    it "requires an id" do
-      expect { @whitelist.show(1) }.to raise_error(ArgumentError)
-    end
 
     it "returns a whitelist" do
       whitelist = @whitelist.show(1, 2)
@@ -38,22 +31,6 @@ describe Squall::Whitelist do
 
   describe "#create" do
     use_vcr_cassette "whitelist/create"
-    it "requires amount" do
-      invalid = @valid.reject{|k,v| k == :ip }
-      requires_attr(:ip) { @whitelist.create(1, invalid) }
-    end
-
-    it "allows all optional params" do
-      optional = [:description]
-      @whitelist.should_receive(:request).exactly(optional.size).times.and_return Hash.new("whitelist" => {})
-      optional.each do |param|
-        @whitelist.create(1, @valid.merge(param => "test"))
-      end
-    end
-
-    it "raises error on unknown params" do
-      expect { @whitelist.create(1, @valid.merge(:what => 'what')) }.to raise_error(ArgumentError, 'Unknown params: what')
-    end
 
     it "creates a whitelist for a user" do
       @whitelist.create(1, @valid)
@@ -64,29 +41,14 @@ describe Squall::Whitelist do
   describe "#edit" do
     use_vcr_cassette "whitelist/edit"
 
-    it "allows select params" do
-      optional = [:ip, :description]
-      @whitelist.should_receive(:request).exactly(optional.size).times.and_return Hash.new()
-      optional.each do |param|
-        @whitelist.edit(1, 1, param => "test")
-      end
-    end
-
-    it "raises error on unknown params" do
-      expect { @whitelist.edit(1, 1, :what => 'what') }.to raise_error(ArgumentError, 'Unknown params: what')
-    end
-
     it "edits a whitelist" do
-      @whitelist.edit(1, 1, :description => "This is actually a different computer.")
+      @whitelist.edit(1, 1, description: "This is actually a different computer.")
       @whitelist.success.should be_true
     end
   end
 
   describe "#delete" do
     use_vcr_cassette "whitelist/delete"
-    it "requires an id" do
-      expect { @whitelist.delete }.to raise_error(ArgumentError)
-    end
 
     it "deletes a whitelist" do
       @whitelist.delete(1, 1)