linode 0.7.10 → 0.8.1

data/spec/linode/nodebalancer/config_spec.rb

@@ -6,42 +6,44 @@ describe Linode::Nodebalancer::Config do
     @api_key = 'foo'
     @linode = Linode::Nodebalancer::Config.new(:api_key => @api_key)
   end
-  
+
   it 'should be a Linode instance' do
     @linode.class.should < Linode
   end
-  
+
   %w(create delete update list).each do |action|
     it "should allow accessing the #{action} API" do
       @linode.should respond_to(action.to_sym)
     end
-  
+
     describe "when accessing the #{action} API" do
       it 'should allow a data hash' do
-        lambda { @linode.send(action.to_sym, {}) }.should_not raise_error(ArgumentError)
+        @linode.stubs(:send_request)
+        lambda { @linode.send(action.to_sym, {}) }.should_not raise_error
       end
-    
+
       it 'should not require arguments' do
-        lambda { @linode.send(action.to_sym) }.should_not raise_error(ArgumentError)      
+        @linode.stubs(:send_request)
+        lambda { @linode.send(action.to_sym) }.should_not raise_error
       end
-    
+
       it "should request the nodebalancer.config.#{action} action" do
         @linode.expects(:send_request).with {|api_action, data| api_action == "nodebalancer.config.#{action}" }
         @linode.send(action.to_sym)
       end
-    
+
       it 'should provide the data hash when making its request' do
         @linode.expects(:send_request).with {|api_action, data| data = { :foo => :bar } }
         @linode.send(action.to_sym, {:foo => :bar})
       end
-    
+
       it 'should return the result of the request' do
-        @linode.expects(:send_request).returns(:bar => :baz)      
-        @linode.send(action.to_sym).should == { :bar => :baz }      
+        @linode.expects(:send_request).returns(:bar => :baz)
+        @linode.send(action.to_sym).should == { :bar => :baz }
       end
-      
-      it "should consider the documentation to live at http://www.linode.com/api/nodebalancer/nodebalancer.config.#{action}" do
-        @linode.documentation_path(Linode.action_path(@linode.class.name, action)).should == "http://www.linode.com/api/nodebalancer/nodebalancer.config.#{action}"
+
+      it "should consider the documentation to live at https://www.linode.com/api/nodebalancer/nodebalancer.config.#{action}" do
+        @linode.documentation_path(Linode.action_path(@linode.class.name, action)).should == "https://www.linode.com/api/nodebalancer/nodebalancer.config.#{action}"
       end
     end
   end

data/spec/linode/nodebalancer/node_spec.rb

@@ -6,42 +6,44 @@ describe Linode::Nodebalancer::Node do
     @api_key = 'foo'
     @linode = Linode::Nodebalancer::Node.new(:api_key => @api_key)
   end
-  
+
   it 'should be a Linode instance' do
     @linode.class.should < Linode
   end
-  
+
   %w(create delete update list).each do |action|
     it "should allow accessing the #{action} API" do
       @linode.should respond_to(action.to_sym)
     end
-  
+
     describe "when accessing the #{action} API" do
       it 'should allow a data hash' do
-        lambda { @linode.send(action.to_sym, {}) }.should_not raise_error(ArgumentError)
+        @linode.stubs(:send_request)
+        lambda { @linode.send(action.to_sym, {}) }.should_not raise_error
       end
-    
+
       it 'should not require arguments' do
-        lambda { @linode.send(action.to_sym) }.should_not raise_error(ArgumentError)      
+        @linode.stubs(:send_request)
+        lambda { @linode.send(action.to_sym) }.should_not raise_error
       end
-    
+
       it "should request the nodebalancer.node.#{action} action" do
         @linode.expects(:send_request).with {|api_action, data| api_action == "nodebalancer.node.#{action}" }
         @linode.send(action.to_sym)
       end
-    
+
       it 'should provide the data hash when making its request' do
         @linode.expects(:send_request).with {|api_action, data| data = { :foo => :bar } }
         @linode.send(action.to_sym, {:foo => :bar})
       end
-    
+
       it 'should return the result of the request' do
-        @linode.expects(:send_request).returns(:bar => :baz)      
-        @linode.send(action.to_sym).should == { :bar => :baz }      
+        @linode.expects(:send_request).returns(:bar => :baz)
+        @linode.send(action.to_sym).should == { :bar => :baz }
       end
-      
-      it "should consider the documentation to live at http://www.linode.com/api/nodebalancer/nodebalancer.node.#{action}" do
-        @linode.documentation_path(Linode.action_path(@linode.class.name, action)).should == "http://www.linode.com/api/nodebalancer/nodebalancer.node.#{action}"
+
+      it "should consider the documentation to live at https://www.linode.com/api/nodebalancer/nodebalancer.node.#{action}" do
+        @linode.documentation_path(Linode.action_path(@linode.class.name, action)).should == "https://www.linode.com/api/nodebalancer/nodebalancer.node.#{action}"
       end
     end
   end

data/spec/linode/nodebalancer_spec.rb

@@ -6,50 +6,52 @@ describe Linode::Nodebalancer do
     @api_key = 'foo'
     @linode = Linode::Nodebalancer.new(:api_key => @api_key)
   end
-  
+
   it 'should be a Linode instance' do
     @linode.class.should < Linode
   end
-  
+
   %w(update create list delete).each do |action|
     it "should allow accessing the #{action} API" do
       @linode.should respond_to(action.to_sym)
     end
-  
+
     describe "when accessing the #{action} API" do
       it 'should allow a data hash' do
-        lambda { @linode.send(action.to_sym, {}) }.should_not raise_error(ArgumentError)
+        @linode.stubs(:send_request)
+        lambda { @linode.send(action.to_sym, {}) }.should_not raise_error
       end
-    
+
       it 'should not require arguments' do
-        lambda { @linode.send(action.to_sym) }.should_not raise_error(ArgumentError)      
+        @linode.stubs(:send_request)
+        lambda { @linode.send(action.to_sym) }.should_not raise_error
       end
-    
+
       it "should request the nodebalancer.#{action} action" do
         @linode.expects(:send_request).with {|api_action, data| api_action == "nodebalancer.#{action}" }
         @linode.send(action.to_sym)
       end
-    
+
       it 'should provide the data hash when making its request' do
         @linode.expects(:send_request).with {|api_action, data| data = { :foo => :bar } }
         @linode.send(action.to_sym, {:foo => :bar})
       end
-    
+
       it 'should return the result of the request' do
-        @linode.expects(:send_request).returns(:bar => :baz)      
-        @linode.send(action.to_sym).should == { :bar => :baz }      
+        @linode.expects(:send_request).returns(:bar => :baz)
+        @linode.send(action.to_sym).should == { :bar => :baz }
       end
-      
-      it "should consider the documentation to live at http://www.linode.com/api/nodebalancer/nodebalancer.#{action}" do
-        @linode.documentation_path(Linode.action_path(@linode.class.name, action)).should == "http://www.linode.com/api/nodebalancer/nodebalancer.#{action}"
+
+      it "should consider the documentation to live at https://www.linode.com/api/nodebalancer/nodebalancer.#{action}" do
+        @linode.documentation_path(Linode.action_path(@linode.class.name, action)).should == "https://www.linode.com/api/nodebalancer/nodebalancer.#{action}"
       end
     end
   end
-  
+
   it 'should be able to provide access to the Linode Nodebalancer Config API' do
     @linode.should respond_to(:config)
   end
-  
+
   describe 'when providing access to the Linode Nodebalancer Config API' do
     before :each do
       @api_key = 'foo'
@@ -58,36 +60,36 @@ describe Linode::Nodebalancer do
     end
 
     it 'should allow no arguments' do
-      lambda { @linode.config }.should_not raise_error(ArgumentError)
+      lambda { @linode.config }.should_not raise_error
     end
     
     it 'should require no arguments' do
       lambda { @linode.config(:foo) }.should raise_error(ArgumentError)
     end
-    
+
     it 'should return a Linode::Nodebalancer::Config instance' do
       @linode.config.class.should == Linode::Nodebalancer::Config
     end
-    
+
     it 'should set the API key on the Linode::Nodebalancer::Config instance to be our API key' do
       @linode.config.api_key.should == @api_key
     end
-    
+
     it 'should set the API url on the Linode::Nodebalancer::Config instance to be our API url' do
       @linode.config.api_url.should == @api_url
     end
-    
+
     it 'should return the same Linode::Nodebalancer::Config instance when called again' do
       linode = Linode::Nodebalancer.new(:api_key => @api_key)
       result = linode.config
       linode.config.should == result
     end
   end
-  
+
   it 'should be able to provide access to the Linode Nodebalancer Node API' do
     @linode.should respond_to(:node)
   end
-  
+
   describe 'when providing access to the Linode Nodebalancer Node API' do
     before :each do
       @api_key = 'foo'
@@ -96,25 +98,25 @@ describe Linode::Nodebalancer do
     end
 
     it 'should allow no arguments' do
-      lambda { @linode.node }.should_not raise_error(ArgumentError)
+      lambda { @linode.node }.should_not raise_error
     end
-    
+
     it 'should require no arguments' do
       lambda { @linode.node(:foo) }.should raise_error(ArgumentError)
     end
-    
+
     it 'should return a Linode::Nodebalancer::Node instance' do
       @linode.node.class.should == Linode::Nodebalancer::Node
     end
-    
+
     it 'should set the API key on the Linode::Nodebalancer::Node instance to be our API key' do
       @linode.node.api_key.should == @api_key
     end
-    
+
     it 'should set the API url on the Linode::Nodebalancer::Node instance to be our API url' do
       @linode.node.api_url.should == @api_url
     end
-    
+
     it 'should return the same Linode::Nodebalancer::Node instance when called again' do
       linode = Linode::Nodebalancer.new(:api_key => @api_key)
       result = linode.node

data/spec/linode/stackscript_spec.rb

@@ -6,42 +6,44 @@ describe Linode::Stackscript do
     @api_key = 'foo'
     @linode = Linode::Stackscript.new(:api_key => @api_key)
   end
-  
+
   it 'should be a Linode instance' do
     @linode.class.should < Linode
   end
-  
+
   %w(update create list delete).each do |action|
     it "should allow accessing the #{action} API" do
       @linode.should respond_to(action.to_sym)
     end
-  
+
     describe "when accessing the #{action} API" do
       it 'should allow a data hash' do
-        lambda { @linode.send(action.to_sym, {}) }.should_not raise_error(ArgumentError)
+        @linode.stubs(:send_request)
+        lambda { @linode.send(action.to_sym, {}) }.should_not raise_error
       end
-    
+
       it 'should not require arguments' do
-        lambda { @linode.send(action.to_sym) }.should_not raise_error(ArgumentError)      
+        @linode.stubs(:send_request)
+        lambda { @linode.send(action.to_sym) }.should_not raise_error
       end
-    
+
       it "should request the stackscript.#{action} action" do
         @linode.expects(:send_request).with {|api_action, data| api_action == "stackscript.#{action}" }
         @linode.send(action.to_sym)
       end
-    
+
       it 'should provide the data hash when making its request' do
         @linode.expects(:send_request).with {|api_action, data| data = { :foo => :bar } }
         @linode.send(action.to_sym, {:foo => :bar})
       end
-    
+
       it 'should return the result of the request' do
-        @linode.expects(:send_request).returns(:bar => :baz)      
-        @linode.send(action.to_sym).should == { :bar => :baz }      
+        @linode.expects(:send_request).returns(:bar => :baz)
+        @linode.send(action.to_sym).should == { :bar => :baz }
       end
-      
-      it "should consider the documentation to live at http://www.linode.com/api/stackscript/stackscript.#{action}" do
-        @linode.documentation_path(Linode.action_path(@linode.class.name, action)).should == "http://www.linode.com/api/stackscript/stackscript.#{action}"
+
+      it "should consider the documentation to live at https://www.linode.com/api/stackscript/stackscript.#{action}" do
+        @linode.documentation_path(Linode.action_path(@linode.class.name, action)).should == "https://www.linode.com/api/stackscript/stackscript.#{action}"
       end
     end
   end

data/spec/linode/test_spec.rb

@@ -6,43 +6,45 @@ describe Linode::Test do
     @api_key = 'foo'
     @linode = Linode::Test.new(:api_key => @api_key)
   end
-  
+
   it 'should be a Linode instance' do
     @linode.class.should < Linode
   end
-  
+
   ["echo"].each do |action|
-  
+
     it "should allow accessing the #{action} API" do
       @linode.should respond_to(action.to_sym)
     end
-  
+
     describe "when accessing the #{action} API" do
       it 'should allow a data hash' do
-        lambda { @linode.send(action.to_sym, {}) }.should_not raise_error(ArgumentError)
+        @linode.stubs(:send_request)
+        lambda { @linode.send(action.to_sym, {}) }.should_not raise_error
       end
-    
+
       it 'should not require arguments' do
-        lambda { @linode.send(action.to_sym) }.should_not raise_error(ArgumentError)      
+        @linode.stubs(:send_request)
+        lambda { @linode.send(action.to_sym) }.should_not raise_error
       end
-    
+
       it "should request the test.#{action} action" do
         @linode.expects(:send_request).with {|api_action, data| api_action == "test.#{action}" }
         @linode.send(action.to_sym)
       end
-    
+
       it 'should provide the data hash when making its request' do
         @linode.expects(:send_request).with {|api_action, data| data = { :foo => :bar } }
         @linode.send(action.to_sym, {:foo => :bar})
       end
-    
+
       it 'should return the result of the request' do
-        @linode.expects(:send_request).returns(:bar => :baz)      
-        @linode.send(action.to_sym).should == { :bar => :baz }      
+        @linode.expects(:send_request).returns(:bar => :baz)
+        @linode.send(action.to_sym).should == { :bar => :baz }
       end
-      
-      it "should consider the documentation to live at http://www.linode.com/api/linode/linode.#{action}" do
-        @linode.documentation_path(Linode.action_path(@linode.class.name, action)).should == "http://www.linode.com/api/utility/test.#{action}"
+
+      it "should consider the documentation to live at https://www.linode.com/api/linode/linode.#{action}" do
+        @linode.documentation_path(Linode.action_path(@linode.class.name, action)).should == "https://www.linode.com/api/utility/test.#{action}"
       end
     end
   end

data/spec/linode/user_spec.rb

@@ -17,7 +17,7 @@ describe Linode::User do
   
   describe 'when returning the API key for the connection' do
     it 'should work without arguments' do
-      lambda { @linode.getapikey }.should_not raise_error(ArgumentError)
+      lambda { @linode.getapikey }.should_not raise_error
     end
     
     it 'should not allow arguments' do
@@ -29,8 +29,8 @@ describe Linode::User do
       @linode.getapikey.should == 'foo'
     end
       
-    it "should consider the documentation to live at http://www.linode.com/api/utility/user.getapikey" do
-      @linode.documentation_path(Linode.action_path(@linode.class.name, 'getapikey')).should == "http://www.linode.com/api/utility/user.getapikey"
+    it "should consider the documentation to live at https://www.linode.com/api/utility/user.getapikey" do
+      @linode.documentation_path(Linode.action_path(@linode.class.name, 'getapikey')).should == "https://www.linode.com/api/utility/user.getapikey"
     end
   end
 end

data/spec/linode_spec.rb

@@ -9,7 +9,7 @@ describe Linode do
 
     describe 'when creating a new Linode instance' do
       it 'should accept an arguments hash' do
-        lambda { Linode.new(:api_key => 'foo') }.should_not raise_error(ArgumentError)
+        lambda { Linode.new(:api_key => 'foo') }.should_not raise_error
       end
 
       it 'should require an arguments hash' do
@@ -17,17 +17,22 @@ describe Linode do
       end
 
       it 'should not fail if an API key is given' do
-        lambda { Linode.new({ :api_key => 'foo' }) }.should_not raise_error(ArgumentError)
+        lambda { Linode.new({ :api_key => 'foo' }) }.should_not raise_error
       end
 
       it 'should not fail if a username/password combo is given' do
-        lambda { Linode.new({ :username => 'bar', :password => 'baz' }) }.should_not raise_error(ArgumentError)
+        lambda { Linode.new({ :username => 'bar', :password => 'baz' }) }.should_not raise_error
       end
 
       it 'should fail if no API key nor username/password combo is given' do
         lambda { Linode.new({}) }.should raise_error(ArgumentError)
       end
 
+      it 'should allow providing a logger' do
+        linode = Linode.new(:api_key => 'foo', :logger => 'bar')
+        linode.logger.should == 'bar'
+      end
+
       it 'should return a Linode instance' do
         Linode.new(:api_key => 'foo').class.should == Linode
       end
@@ -144,7 +149,7 @@ describe 'Linode' do
     end
 
     it 'should allow a request name and a data hash' do
-      lambda { @linode.send_request('test.echo', {}) }.should_not raise_error(ArgumentError)
+      lambda { @linode.send_request('test.echo', {}) }.should_not raise_error
     end
 
     it 'should require a request name and a data hash' do
@@ -285,7 +290,7 @@ describe 'Linode' do
 
   describe 'when providing access to the Linode Test API' do
     it 'should allow no arguments' do
-      lambda { @linode.test }.should_not raise_error(ArgumentError)
+      lambda { @linode.test }.should_not raise_error
     end
 
     it 'should require no arguments' do
@@ -317,7 +322,7 @@ describe 'Linode' do
 
   describe 'when providing access to the Linode Avail API' do
     it 'should allow no arguments' do
-      lambda { @linode.avail }.should_not raise_error(ArgumentError)
+      lambda { @linode.avail }.should_not raise_error
     end
 
     it 'should require no arguments' do
@@ -349,7 +354,7 @@ describe 'Linode' do
 
   describe 'when providing access to the Linode User API' do
     it 'should allow no arguments' do
-      lambda { @linode.user }.should_not raise_error(ArgumentError)
+      lambda { @linode.user }.should_not raise_error
     end
 
     it 'should require no arguments' do
@@ -381,7 +386,7 @@ describe 'Linode' do
 
   describe 'when providing access to the Linode Domain API' do
     it 'should allow no arguments' do
-      lambda { @linode.domain }.should_not raise_error(ArgumentError)
+      lambda { @linode.domain }.should_not raise_error
     end
 
     it 'should require no arguments' do
@@ -413,7 +418,7 @@ describe 'Linode' do
 
   describe 'when providing access to the Linode Linode API' do
     it 'should allow no arguments' do
-      lambda { @linode.linode }.should_not raise_error(ArgumentError)
+      lambda { @linode.linode }.should_not raise_error
     end
 
     it 'should require no arguments' do
@@ -439,13 +444,45 @@ describe 'Linode' do
     end
   end
 
+  it 'should be able to provide access to the Linode Account API' do
+    @linode.should respond_to(:account)
+  end
+
+  describe 'when providing access to the Linode Account API' do
+    it 'should allow no arguments' do
+      lambda { @linode.account }.should_not raise_error
+    end
+
+    it 'should require no arguments' do
+      lambda { @linode.account(:foo) }.should raise_error(ArgumentError)
+    end
+
+    it 'should return a Linode::Account instance' do
+      @linode.account.class.should == Linode::Account
+    end
+
+    it 'should set the API key on the Linode::Account instance to be our API key' do
+      @linode.account.api_key.should == @api_key
+    end
+
+    it 'should set the API url on the Linode::Account instance to be our API url' do
+      @linode.account.api_url.should == @api_url
+    end
+
+    it 'should return the same Linode::Account instance when called again' do
+      linode = Linode.new(:api_key => @api_key)
+      result = linode.account
+      linode.account.should == result
+    end
+  end
+
   it 'should be able to provide access to the Linode Nodebalancer API' do
     @linode.should respond_to(:nodebalancer)
   end
 
   describe 'when providing access to the Linode Nodebalancer API' do
     it 'should allow no arguments' do
-      lambda { @linode.nodebalancer }.should_not raise_error(ArgumentError)
+      lambda { @linode.nodebalancer }.should_not raise_error
     end
 
     it 'should require no arguments' do
@@ -477,7 +514,7 @@ describe 'Linode' do
 
   describe 'when providing access to the Linode Stackscript API' do
     it 'should allow no arguments' do
-      lambda { @linode.stackscript }.should_not raise_error(ArgumentError)
+      lambda { @linode.stackscript }.should_not raise_error
     end
 
     it 'should require no arguments' do
@@ -503,4 +540,3 @@ describe 'Linode' do
     end
   end
 end
-