lumberg 1.0.6 → 1.1.1

data/lib/lumberg/whm/reseller.rb

@@ -5,13 +5,9 @@ module Lumberg
       #
       # *Note:* The user must already exist to be made a reseller. This function will not create an account. If the account does not yet exist, you can use the createacct function to set it up before conferring reseller privileges.
       #
-      # ==== Required 
+      # ==== Required
       #  * <tt>:username</tt> - PENDING
       def create(options = {})
-        Args.new(options) do |c| 
-          c.requires :username 
-          c.booleans :makeowner
-        end
         options[:user] = options.delete(:username)
         server.perform_request('setupreseller', options)
       end
@@ -27,54 +23,35 @@ module Lumberg
 
       # Adds IP addresses to a reseller account
       #
-      # ==== Required 
+      # ==== Required
       #  * <tt>:username</tt> - PENDING
       #
-      # ==== Optional 
+      # ==== Optional
       #  * <tt>:ips</tt> - PENDING
       def add_ips(options = {})
-        Args.new(options) do |c|
-          c.requires :username
-          c.optionals :ips
-          c.booleans :delegate
-        end
-
         options[:user] = options.delete(:username)
         server.perform_request('setresellerips', options)
       end
 
       # Specifies the amount of bandwidth and disk space a reseller is able to use
       #
-      # ==== Required 
+      # ==== Required
       #  * <tt>:username</tt> - PENDING
       #
-      # ==== Optional 
+      # ==== Optional
       #  * <tt>:account_limit</tt> - PENDING
       #  * <tt>:bandwidth_limit</tt> - PENDING
       #  * <tt>:diskspace_limit</tt> - PENDING
       def set_limits(options = {})
-        Args.new(options) do |c|
-          c.requires :username
-          c.optionals :account_limit, :bandwidth_limit, :diskspace_limit
-          c.booleans :enable_account_limit, :enable_resource_limits, :enable_overselling,
-                     :enable_overselling_bandwidth, :enable_overselling_diskspace, :enable_package_limits,
-                     :enable_package_limit_numbers
-        end
-
         options[:user] = options.delete(:username)
         server.perform_request('setresellerlimits', options)
       end
 
       # Terminates a reseller's main account, as well as all accounts owned by the reseller
       #
-      # ==== Required 
+      # ==== Required
       #  * <tt>:reseller</tt> - PENDING
       def terminate(options = {})
-        Args.new(options) do |c|
-          c.requires :reseller
-          c.booleans :terminatereseller
-        end
-      
         # WTF, seriously?
         wtf = "I understand this will irrevocably remove all the "
         wtf << "accounts owned by the reseller #{options[:reseller]}"
@@ -85,111 +62,79 @@ module Lumberg
 
       # Assigns a main, shared IP address to a reseller
       #
-      # ==== Required 
+      # ==== Required
       #  * <tt>:username</tt> - PENDING
       #  * <tt>:ip</tt> - PENDING
       def set_main_ip(options = {})
-        Args.new(options) do |c|
-          c.requires :username, :ip
-        end
-
         options[:user] = options.delete(:username)
         server.perform_request('setresellermainip', options)
       end
 
       # Sets which packages resellers are able to use. It also allows you to define the number of times a package can be used by a reseller
       #
-      # ==== Required 
+      # ==== Required
       #  * <tt>:username</tt> - PENDING
       #  * <tt>:no_limit</tt> - PENDING
       #  * <tt>:package</tt> - PENDING
       #
-      # ==== Optional 
+      # ==== Optional
       #  * <tt>:allowed</tt> - PENDING
       #  * <tt>:number</tt> - PENDING
       def set_package_limit(options = {})
-        Args.new(options) do |c|
-          c.requires :username, :no_limit, :package
-          c.booleans :no_limit, :allowed
-          c.optionals :allowed, :number
-        end
-
         options[:user] = options.delete(:username)
         server.perform_request('setresellerpackagelimit', options)
       end
 
       # Suspends a reseller's account. The suspension will prevent the reseller from accessing his or her account
       #
-      # ==== Required 
+      # ==== Required
       #  * <tt>:username</tt> - PENDING
       #
-      # ==== Optional 
+      # ==== Optional
       #  * <tt>:reason</tt> - PENDING
       def suspend(options = {})
-        Args.new(options) do |c|
-          c.requires :username
-          c.optionals :reason
-        end
-
         options[:user] = options.delete(:username)
         server.perform_request('suspendreseller', options)
       end
 
       # Unsuspends a reseller's account
       #
-      # ==== Required 
+      # ==== Required
       #  * <tt>:username</tt> - PENDING
       def unsuspend(options = {})
-        Args.new(options) do |c|
-          c.requires :username
-        end
-
         options[:user] = options.delete(:username)
         server.perform_request('unsuspendreseller', options)
       end
 
       # Lists the total number of accounts owned by a reseller, as well as how many suspended accounts the reseller owns, and what the reseller's account creation limit is, if any.
       # If no reseller is specified, counts will be provided for the reseller who is currently logged in.
-      # 
+      #
       # *Note:* Counts for other users will only be provided if the user issuing the function call has root-level permissions or owns the provided account.
       #
-      # ==== Required 
+      # ==== Required
       #  * <tt>:username</tt> - PENDING
       def account_counts(options = {})
-        Args.new(options) do |c|
-          c.requires :username
-        end
-
         options[:user] = options.delete(:username)
         server.perform_request('acctcounts', options.merge(:key => 'reseller'))
       end
 
       # Defines a reseller's nameservers. Additionally, you may use it to reset a reseller's nameservers to the default settings
       #
-      # ==== Required 
+      # ==== Required
       #  * <tt>:username</tt> - PENDING
       #
-      # ==== Optional 
+      # ==== Optional
       #  * <tt>:nameservers</tt> - PENDING
       def set_nameservers(options = {})
-        Args.new(options) do |c|
-          c.requires :username
-          c.optionals :nameservers
-        end
-
         options[:user] = options.delete(:username)
         server.perform_request('setresellernameservers', options)
       end
 
       # Shows account statistics for a specific reseller's accounts
       #
-      # ==== Required 
+      # ==== Required
       #  * <tt>:reseller</tt> - PENDING
       def stats(options = {})
-        Args.new(options) do |c|
-          c.requires :reseller
-        end
-
         server.perform_request('resellerstats', options)
       end
 
@@ -200,55 +145,21 @@ module Lumberg
 
       # Creates a new reseller ACL list
       #
-      # ==== Required 
+      # ==== Required
       #  * <tt>:acllist</tt> - PENDING
       def save_acl_list(options = {})
-        optional_args = [
-                  "acl-add-pkg", "acl-add-pkg-ip", "acl-add-pkg-shell", "acl-all", "acl-allow-addoncreate", 
-                  "acl-allow-parkedcreate", "acl-allow-unlimited-disk-pkgs", "acl-allow-unlimited-pkgs", 
-                  "acl-clustering", "acl-create-acct", "acl-create-dns", "acl-demo-setup", "acl-disallow-shell", 
-                  "acl-edit-account", "acl-edit-dns", "acl-edit-mx", "acl-edit-pkg", "acl-frontpage", 
-                  "acl-kill-acct", "acl-kill-dns", "acl-limit-bandwidth", "acl-list-accts", "acl-mailcheck",
-                  "acl-mod-subdomains", "acl-news", "acl-onlyselfandglobalpkgs", "acl-park-dns", "acl-passwd", 
-                  "acl-quota", "acl-rearrange-accts", "acl-res-cart", "acl-status", "acl-resftp", "acl-restart", 
-                  "acl-show-bandwidth", "acl-ssl", "acl-ssl-gencrt", "acl-stats", "acl-suspend-acct", "acl-upgrade-account"
-        ].collect { |option| option.to_sym }
-
-        Args.new(options) do |c|
-          c.requires :acllist
-          c.booleans *optional_args 
-          c.optionals *optional_args
-        end
-
         server.perform_request('saveacllist', options.merge(:key => 'results'))
       end
 
       # Sets the ACL for a reseller, or modifies specific ACL items for a reseller
       #
-      # ==== Required 
+      # ==== Required
       #  * <tt>:reseller</tt> - PENDING
       #
-      # ==== Optional 
+      # ==== Optional
       #  * <tt>:acllist</tt> - PENDING
       #  * <tt>:*optional_args</tt> - PENDING
       def set_acls(options = {})
-        optional_args = [
-                  "acl-add-pkg", "acl-add-pkg-ip", "acl-add-pkg-shell", "acl-all", "acl-allow-addoncreate", 
-                  "acl-allow-parkedcreate", "acl-allow-unlimited-disk-pkgs", "acl-allow-unlimited-pkgs", 
-                  "acl-clustering", "acl-create-acct", "acl-create-dns", "acl-demo-setup", "acl-disallow-shell", 
-                  "acl-edit-account", "acl-edit-dns", "acl-edit-mx", "acl-edit-pkg", "acl-frontpage", 
-                  "acl-kill-acct", "acl-kill-dns", "acl-limit-bandwidth", "acl-list-accts", "acl-mailcheck",
-                  "acl-mod-subdomains", "acl-news", "acl-onlyselfandglobalpkgs", "acl-park-dns", "acl-passwd", 
-                  "acl-quota", "acl-rearrange-accts", "acl-res-cart", "acl-status", "acl-resftp", "acl-restart", 
-                  "acl-show-bandwidth", "acl-ssl", "acl-ssl-gencrt", "acl-stats", "acl-suspend-acct", "acl-upgrade-account"
-        ].collect { |option| option.to_sym }
-
-        Args.new(options) do |c|
-          c.requires :reseller
-          c.booleans *optional_args
-          c.optionals :acllist, *optional_args
-        end
-
         server.perform_request('setacls', options)
       end
 
@@ -256,10 +167,6 @@ module Lumberg
       #
       #  *Note:* This function will not delete the account; it will only remove its reseller status
       def unsetup(options = {})
-        Args.new(options) do |c|
-          c.requires :username
-        end
-
         options[:user] = options.delete(:username)
         server.perform_request('unsetupreseller', options)
       end

data/lib/lumberg/whm/server.rb

@@ -49,11 +49,6 @@ module Lumberg
       #  * <tt>:ssl</tt> - PENDING
       #  * <tt>:basic_auth</tt>
       def initialize(options)
-        Args.new(options) do |c|
-          c.requires  :host, :hash
-          c.optionals :user, :ssl, :basic_auth
-        end
-
         @ssl_verify ||= false
         @ssl        = options.delete(:ssl)
         @host       = options.delete(:host)
@@ -90,10 +85,6 @@ module Lumberg
       end
 
       def system_load_average(options = {})
-        Args.new(options) do |c|
-          c.requires "api.version".to_sym
-        end
-
         perform_request('systemloadavg', options.merge(:key => 'data'))
       end
 
@@ -106,63 +97,30 @@ module Lumberg
       end
 
       def add_ip(options = {})
-        Args.new(options) do |c|
-          c.requires :ip, :netmask
-        end
-
         perform_request('addip', options.merge(:key => 'addip'))
       end
 
       def delete_ip(options = {})
-        Args.new(options) do |c|
-          c.requires :ip
-          c.optionals :ethernetdev
-          c.booleans :skipifshutdown
-        end
-
         perform_request('delip', options.merge(:key => 'delip'))
       end
 
       def set_hostname(options = {})
-        Args.new(options) do |c|
-          c.requires :hostname
-        end
-
         perform_request('sethostname', options.merge(:key => 'sethostname'))
       end
 
       def set_resolvers(options = {})
-        Args.new(options) do |c|
-          c.requires :nameserver1
-          c.optionals :nameserver2, :nameserver3
-        end
-
         perform_request('setresolvers', options.merge(:key => 'setresolvers'))
       end
 
       def show_bandwidth(options = {})
-        Args.new(options) do |c|
-          c.optionals :month, :year, :showres, :search, :searchtype
-        end
-
         perform_request('showbw', options.merge(:key => 'bandwidth'))
       end
 
       def set_nv_var(options = {})
-        Args.new(options) do |c|
-          c.requires :key
-          c.optionals :value
-        end
-
         perform_request('nvset', options.merge(:key => 'nvset'))
       end
 
       def get_nv_var(options = {})
-        Args.new(options) do |c|
-          c.requires :key
-          c.optionals :value
-        end
-
         perform_request('nvget', options.merge(:key => 'nvget'))
       end
 
@@ -170,6 +128,18 @@ module Lumberg
         perform_request('reboot', {:key => "reboot"})
       end
 
+      def account
+        @account ||= Account.new(:server => self)
+      end
+
+      def dns
+        @dns ||= Dns.new(:server => self)
+      end
+
+      def reseller
+        @reseller ||= Reseller.new(:server => self)
+      end
+
     private
 
       def do_request(uri, function, params)
@@ -228,27 +198,6 @@ module Lumberg
         raise Lumberg::WhmArgumentError.new("Missing WHM hash") unless hash.is_a?(String)
         hash.gsub(/\n|\s/, '')
       end
-
-      # Creates WHM::Whatever.new(:server => @server)
-      # automagically
-      def auto_accessors
-        [:account, :dns, :reseller]
-      end
-
-      def method_missing(meth, *args, &block)
-        if auto_accessors.include?(meth.to_sym)
-          ivar = instance_variable_get("@#{meth}")
-          if ivar.nil?
-            constant = Whm.const_get(meth.to_s.capitalize)
-            return instance_variable_set("@#{meth}", constant.new(:server => self))
-          else
-            return ivar
-          end
-        else
-          super
-        end
-      end
-
     end
   end
 end

data/spec/whm/account_spec.rb

@@ -12,29 +12,15 @@ module Lumberg
     describe "#create" do
       use_vcr_cassette "whm/account/createacct"
 
-      it "requires a username" do
-        requires_attr('username') { @account.create }
-      end
-
-      it "requires a domain" do
-        requires_attr('domain') { @account.create(:username => 'user') }
-      end
-
-      it "requires a password" do
-        requires_attr('password') { 
-          @account.create(:username => 'user', :domain => 'example.com')
-        }
-      end
-
       it "creates the account with proper params" do
         result = @account.create(:username => 'valid', :password => 'hummingbird123', :domain => 'valid-thing.com')
         result[:success].should be_true
         result[:message].should match(/Account Creation Ok/i)
         result[:params].should_not be_empty
         result[:params].should have_key(:options)
-        result[:params][:options].should include(:nameserver4, :nameserver, :nameserverentry2, :nameserverentry3, 
-                                                  :nameserverentry4, :nameserverentry, :ip, :nameservera2, 
-                                                  :nameservera3, :package, :nameservera4, :nameserver2, 
+        result[:params][:options].should include(:nameserver4, :nameserver, :nameserverentry2, :nameserverentry3,
+                                                  :nameserverentry4, :nameserverentry, :ip, :nameservera2,
+                                                  :nameservera3, :package, :nameservera4, :nameserver2,
                                                   :nameservera, :nameserver3)
       end
 
@@ -48,10 +34,6 @@ module Lumberg
     describe "#remove" do
       use_vcr_cassette "whm/account/removeacct"
 
-      it "requires a username" do
-        requires_attr('username') { @account.remove }
-      end
-
       it "removes a user and keeps DNS by default" do
         result = @account.remove(:username => 'removeme')
         result[:success].should be_true
@@ -80,14 +62,6 @@ module Lumberg
     describe "#change_password" do
       use_vcr_cassette "whm/account/passwd"
 
-      it "requires a username" do
-        requires_attr('username') { @account.change_password }
-      end
-
-      it "requires a password" do
-        requires_attr('password') { @account.change_password(:username => 'changeme') }
-      end
-
       it "changes the password" do
         result = @account.change_password(:username => 'changeme', :password => 'superpass')
         result[:success].should be_true
@@ -104,14 +78,6 @@ module Lumberg
     describe "#limit bandwidth" do
       use_vcr_cassette "whm/account/limitbw"
 
-      it "requires a user" do
-        requires_attr('username') { @account.limit_bandwidth(:bwlimit => 99999) }
-      end
-
-      it "requires a bandwidth" do
-        requires_attr('bwlimit') { @account.limit_bandwidth(:username => 'changeme') }
-      end
-
       it "sets the bandwidth limit" do
         result = @account.limit_bandwidth(:username => 'changeme', :bwlimit => 99999)
         result[:success].should be_true
@@ -121,11 +87,11 @@ module Lumberg
       end
 
       it "isn't successful when the user doesn't exist" do
-        expect { 
-          @account.limit_bandwidth(:username => 'notexists', :bwlimit => 99999) 
+        expect {
+          @account.limit_bandwidth(:username => 'notexists', :bwlimit => 99999)
         }.to raise_error(WhmInvalidUser, /User notexists does not exist/i)
       end
-    end 
+    end
 
     describe "#list" do
       use_vcr_cassette "whm/account/listaccts"
@@ -165,7 +131,7 @@ module Lumberg
         result[:success].should be_true
         result[:params][:acct].should have(1).account
       end
-    end 
+    end
 
     describe "#modify" do
       use_vcr_cassette "whm/account/modifyacct"
@@ -184,7 +150,7 @@ module Lumberg
 
       it "returns the bandwidth limit" do
         result = @account.modify(:username => 'changeme')
-        result[:params][:newcfg][:cpuser][:BWLIMIT].should == "unlimited" 
+        result[:params][:newcfg][:cpuser][:BWLIMIT].should == "unlimited"
       end
 
       it "returns the primary contact email" do
@@ -206,7 +172,7 @@ module Lumberg
         result = @account.modify(:username => 'changeme')
         result[:params][:newcfg][:cpuser][:HASCGI].should be_true
       end
-    end 
+    end
 
     describe "#editquota" do
       use_vcr_cassette "whm/account/editquota"
@@ -232,9 +198,6 @@ module Lumberg
 
     describe "#summary" do
       use_vcr_cassette "whm/account/accountsummary"
-      it "requires a user" do
-        requires_attr('username') { @account.create }
-      end
 
       it "returns an error for invalid users" do
         result = @account.summary(:username => 'notexists')
@@ -247,15 +210,11 @@ module Lumberg
         result[:success].should be_true
         result[:message].should match(/ok/i)
       end
-    end 
+    end
 
     describe "#suspend" do
       use_vcr_cassette "whm/account/suspend"
 
-      it "requires a username" do
-        requires_attr('username') { @account.suspend }
-      end
-
       it "returns an error for invalid users" do
         result = @account.suspend(:username => 'notexists')
         result[:success].should_not be_true
@@ -272,13 +231,10 @@ module Lumberg
         @account.server.should_receive(:perform_request).with('suspendacct', hash_including(:user => 'suspendme', :reason => 'abusive user'))
         @account.suspend(:username => 'suspendme', :reason => 'abusive user')
       end
-    end 
+    end
 
     describe "#unsuspend" do
       use_vcr_cassette "whm/account/unsuspend"
-      it "require a username" do
-        requires_attr('username') { @account.unsuspend }
-      end
 
       it "returns an error for invalid users" do
         result = @account.unsuspend(:username => 'notexists')
@@ -291,10 +247,11 @@ module Lumberg
         result[:success].should be_true
         result[:message].should match(/unsuspending .* account/i)
       end
-    end 
+    end
 
     describe "#list_suspended" do
       use_vcr_cassette 'whm/account/listsuspended'
+
       it "returns non-empty result" do
         # empty isn't a real param. VCR Hacks
         result = @account.list_suspended(:empty => true)
@@ -308,7 +265,7 @@ module Lumberg
         result[:success].should be_true
         result[:params][:accts].should be_empty
       end
-    end 
+    end
 
     describe "#change package" do
       use_vcr_cassette "whm/account/changepackage"
@@ -319,14 +276,6 @@ module Lumberg
         result[:message].should match(/user notexists does not exist/i)
       end
 
-      it "requires a username" do
-        requires_attr('username') { @account.change_package(:pkg => '') }
-      end
-
-      it "requires a pkg" do
-        requires_attr('pkg') { @account.change_package(:username => 'changeme') }
-      end
-
       it "fails if the package was not found" do
         result = @account.change_package(:username => 'changeme', :pkg => 'fakepackage')
         result[:success].should_not be_true
@@ -338,13 +287,10 @@ module Lumberg
         result[:success].should be_true
         result[:message].should match(/Account Upgrade\/Downgrade Complete for changeme/i)
       end
-    end 
+    end
 
     describe "#privs" do
       use_vcr_cassette 'whm/account/myprivs'
-      it "requires a user" do
-        requires_attr('username') { @account.privs }
-      end
 
       it "has a result" do
         result = @account.privs(:username => 'privs')
@@ -352,12 +298,12 @@ module Lumberg
 
         params = result[:params]
         expected = {
-                    :kill_dns => false, :edit_dns => false, :edit_mx => false, :add_pkg => false, 
-                    :suspend_acct => false, :add_pkg_shell => false, :viewglobalpackages => false, 
-                    :resftp => false, :list_accts => false, :all => true, :passwd => false, :quota => false, 
-                    :park_dns => false, :rearrange_accts => false, :allow_addoncreate => false, :demo => false, 
-                    :news => false, :edit_account => false, :allow_unlimited_disk_pkgs => false, :allow_parkedcreate => false, 
-                    :frontpage => false, :restart => false, :ssl_gencrt => false, :allow_unlimited_pkgs => false, 
+                    :kill_dns => false, :edit_dns => false, :edit_mx => false, :add_pkg => false,
+                    :suspend_acct => false, :add_pkg_shell => false, :viewglobalpackages => false,
+                    :resftp => false, :list_accts => false, :all => true, :passwd => false, :quota => false,
+                    :park_dns => false, :rearrange_accts => false, :allow_addoncreate => false, :demo => false,
+                    :news => false, :edit_account => false, :allow_unlimited_disk_pkgs => false, :allow_parkedcreate => false,
+                    :frontpage => false, :restart => false, :ssl_gencrt => false, :allow_unlimited_pkgs => false,
                     :add_pkg_ip => false, :disallow_shell => false, :res_cart => false, :ssl_buy => false, :kill_acct => false,
                     :allow_unlimited_bw_pkgs => false, :create_dns => false, :mailcheck => false, :clustering => false, :ssl => false,
                     :edit_pkg => false, :locale_edit => false, :show_bandwidth => false, :upgrade_account => false, :thirdparty => false,
@@ -365,7 +311,7 @@ module Lumberg
 
         params.should include(expected)
       end
-    end 
+    end
 
     describe "#domainuserdata" do
       use_vcr_cassette "whm/account/domainuserdata"
@@ -376,10 +322,6 @@ module Lumberg
         result[:message].should match(/Unable to determine account owner for domain\./i)
       end
 
-      it "requires a domain" do
-        requires_attr('domain') { @account.domain_user_data }
-      end
-
       it "returns the correct data" do
         result = @account.domain_user_data(:domain => 'example.com')
         result[:success].should be_true
@@ -397,19 +339,11 @@ module Lumberg
         result[:params][:servername].should == "example.com"
         result[:params][:user].should == "changeme"
       end
-    end 
+    end
 
     describe "#setsiteip" do
       use_vcr_cassette "whm/account/setsiteip"
 
-      it "requires an ip" do
-        requires_attr('ip') { @account.set_site_ip }
-      end
-
-      it "requires a username or a domain" do
-        expect { @account.set_site_ip(:ip => '1.1.1.1') }.to raise_error(WhmArgumentError, /may include only one of 'username, domain'/i)
-      end
-
       it "accepts a username for the account to use" do
         result = @account.set_site_ip(:ip => '192.1.2.3', :username => 'changeme')
         result[:success].should be_true
@@ -425,131 +359,39 @@ module Lumberg
         result[:success].should be_true
         result[:message].should match(/OK/i)
       end
-    end 
+    end
 
     describe "#restore" do
       # 11.27/11.28+ only
       use_vcr_cassette "whm/account/restoreaccount"
-      it "requires api.version" do
-        requires_attr('api.version') { 
-          @account.restore_account(:username => 'changeme', 
-                                   :type => 'monthly', 
-                                   :all => false, 
-                                   :ip => false, 
-                                   :mail => false, 
-                                   :mysql => false, 
-                                   :subs => false) 
-        }
-      end
-
-      it "requires a username" do
-        requires_attr('username') { 
-          @account.restore_account("api.version".to_sym => 1, 
-                                   :type => 'monthly', 
-                                   :all => false, 
-                                   :ip => false, 
-                                   :mail => false, 
-                                   :mysql => false, 
-                                   :subs => false) 
-        }
-      end
-
-      it "requires type" do
-        requires_attr('type') { 
-          @account.restore_account("api.version".to_sym => 1, 
-                                   :username => 'changeme', 
-                                   :all => false, 
-                                   :ip => false, 
-                                   :mail => false, 
-                                   :mysql => false, 
-                                   :subs => false) 
-        }
-      end
-
-      it "requires all" do
-        requires_attr('all') { 
-          @account.restore_account("api.version".to_sym => 1, 
-                                   :username => 'changeme', 
-                                   :type => 'monthly', 
-                                   :ip => false, 
-                                   :mail => false, 
-                                   :mysql => false, 
-                                   :subs => false) 
-        }
-      end
-
-      it "requires ip" do
-        requires_attr('ip') { 
-          @account.restore_account("api.version".to_sym => 1, 
-                                   :username => 'changeme', 
-                                   :type => 'monthly', 
-                                   :all => false, 
-                                   :mail => false, 
-                                   :mysql => false, 
-                                   :subs => false) 
-        }
-      end
-
-      it "requires mail" do
-        requires_attr('mail') { @account.restore_account("api.version".to_sym => 1, 
-                                          :username => 'changeme', 
-                                          :type => 'monthly', 
-                                          :all => false, 
-                                          :ip => false, 
-                                          :mysql => false, 
-                                          :subs => false) 
-        }
-      end
-
-      it "requires mysql" do
-        requires_attr('mysql') { @account.restore_account("api.version".to_sym => 1, 
-                                          :username => 'changeme', 
-                                          :type => 'monthly', 
-                                          :all => false, 
-                                          :ip => false, 
-                                          :mail => false, 
-                                          :subs => false) 
-        }
-      end
-
-      it "require subs" do
-       requires_attr('subs') { @account.restore_account("api.version".to_sym => 1, 
-                                          :username => 'changeme', 
-                                          :type => 'monthly', 
-                                          :all => false, 
-                                          :ip => false, 
-                                          :mail => false, 
-                                          :mysql => false) 
-        }
-      end
 
       it "returns an error if it can't find the backup" do
-        result = @account.restore_account("api.version".to_sym => 1, 
-                                          :username => 'notexists', 
-                                          :type => 'daily', 
-                                          :all => false, 
-                                          :ip => false, 
-                                          :mail => false, 
-                                          :mysql => false, 
+        result = @account.restore_account("api.version".to_sym => 1,
+                                          :username => 'notexists',
+                                          :type => 'daily',
+                                          :all => false,
+                                          :ip => false,
+                                          :mail => false,
+                                          :mysql => false,
                                           :subs => false)
         result[:params][:result].to_i.should == 0
         result[:params][:reason].should match(/Unable to find archive/i)
       end
 
       it "restores the account" do
-        result = @account.restore_account("api.version".to_sym => 1, 
-                                          :username => 'changeme', 
-                                          :type => 'daily', 
-                                          :all => false, 
-                                          :ip => false, 
-                                          :mail => false, 
-                                          :mysql => false, 
+        result = @account.restore_account("api.version".to_sym => 1,
+                                          :username => 'changeme',
+                                          :type => 'daily',
+                                          :all => false,
+                                          :ip => false,
+                                          :mail => false,
+                                          :mysql => false,
                                           :subs => false)
         result[:params][:result].to_i.should == 1
         result[:params][:reason].should == "OK"
         result[:params][:output][:raw].should match(/Account Restore Complete/i)
       end
-    end 
+    end
 
     describe "#verify_user" do
       use_vcr_cassette "whm/account/accountsummary"
@@ -558,7 +400,7 @@ module Lumberg
 
       it "does not call the block if the user doesn't exist" do
         @something.should_not_receive(:gold)
-        expect { 
+        expect {
           @account.send(:verify_user, 'notexists') do
             @something.gold
           end