linode 0.7.10 → 0.8.1

data/spec/linode/domain_spec.rb

@@ -6,50 +6,52 @@ describe Linode::Domain do
     @api_key = 'foo'
     @linode = Linode::Domain.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 domain.#{action} action" do
         @linode.expects(:send_request).with {|api_action, data| api_action == "domain.#{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/dns/domain.#{action}" do
-        @linode.documentation_path(Linode.action_path(@linode.class.name, action)).should == "http://www.linode.com/api/dns/domain.#{action}"
+
+      it "should consider the documentation to live at https://www.linode.com/api/dns/domain.#{action}" do
+        @linode.documentation_path(Linode.action_path(@linode.class.name, action)).should == "https://www.linode.com/api/dns/domain.#{action}"
       end
     end
   end
-  
+
   it 'should be able to provide access to the Linode Domain Resource API' do
     @linode.should respond_to(:resource)
   end
-  
+
   describe 'when providing access to the Linode Domain Resource API' do
     before :each do
       @api_key = 'foo'
@@ -58,25 +60,25 @@ describe Linode::Domain do
     end
 
     it 'should allow no arguments' do
-      lambda { @linode.resource }.should_not raise_error(ArgumentError)
+      lambda { @linode.resource }.should_not raise_error
     end
-    
+
     it 'should require no arguments' do
       lambda { @linode.resource(:foo) }.should raise_error(ArgumentError)
     end
-    
+
     it 'should return a Linode::Domain::Resource instance' do
       @linode.resource.class.should == Linode::Domain::Resource
     end
-    
+
     it 'should set the API key on the Linode::Domain::Resource instance to be our API key' do
       @linode.resource.api_key.should == @api_key
     end
-    
+
     it 'should set the API url on the Linode::Domain::Resource instance to be our API url' do
       @linode.resource.api_url.should == @api_url
     end
-    
+
     it 'should return the same Linode::Domain::Resource instance when called again' do
       linode = Linode::Domain.new(:api_key => @api_key)
       result = linode.resource

data/spec/linode/image_spec.rb

@@ -0,0 +1,50 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper.rb')
+require 'linode'
+
+describe Linode::Image do
+  before :each do
+    @api_key = 'foo'
+    @linode = Linode::Image.new(:api_key => @api_key)
+  end
+
+  it 'should be a Linode instance' do
+    @linode.class.should < Linode
+  end
+
+  %w(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
+        @linode.stubs(:send_request)
+        lambda { @linode.send(action.to_sym, {}) }.should_not raise_error
+      end
+
+      it 'should not require arguments' do
+        @linode.stubs(:send_request)
+        lambda { @linode.send(action.to_sym) }.should_not raise_error
+      end
+
+      it "should request the image.#{action} action" do
+        @linode.expects(:send_request).with {|api_action, data| api_action == "image.#{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 }
+      end
+
+      it "should consider the documentation to live at https://www.linode.com/api/image/image.#{action}" do
+        @linode.documentation_path(Linode.action_path(@linode.class.name, action)).should == "https://www.linode.com/api/image/image.#{action}"
+      end
+    end
+  end
+end

data/spec/linode/linode/config_spec.rb

@@ -6,42 +6,44 @@ describe Linode::Linode::Config do
     @api_key = 'foo'
     @linode = Linode::Linode::Config.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 avail.#{action} action" do
         @linode.expects(:send_request).with {|api_action, data| api_action == "linode.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/linode/linode.config.#{action}" do
-        @linode.documentation_path(Linode.action_path(@linode.class.name, action)).should == "http://www.linode.com/api/linode/linode.config.#{action}"
+
+      it "should consider the documentation to live at https://www.linode.com/api/linode/linode.config.#{action}" do
+        @linode.documentation_path(Linode.action_path(@linode.class.name, action)).should == "https://www.linode.com/api/linode/linode.config.#{action}"
       end
     end
   end

data/spec/linode/linode/disk_spec.rb

@@ -6,46 +6,48 @@ describe Linode::Linode::Disk do
     @api_key = 'foo'
     @linode = Linode::Linode::Disk.new(:api_key => @api_key)
   end
-  
+
   it 'should be a Linode instance' do
     @linode.class.should < Linode
   end
-  
-  %w(update create list createfromdistribution createfromstackscript duplicate delete resize).each do |action|
+
+  %w(update create list createfromdistribution createfromimage createfromstackscript duplicate delete resize imagize).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 avail.#{action} action" do
         @linode.expects(:send_request).with {|api_action, data| api_action == "linode.disk.#{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.disk.#{action}" do
-        @linode.documentation_path(Linode.action_path(@linode.class.name, action)).should == "http://www.linode.com/api/linode/linode.disk.#{action}"
+
+      it "should consider the documentation to live at https://www.linode.com/api/linode/linode.disk.#{action}" do
+        @linode.documentation_path(Linode.action_path(@linode.class.name, action)).should == "https://www.linode.com/api/linode/linode.disk.#{action}"
       end
     end
   end
-  
+
   it 'should allow retrieving the disk type from disks in the "list" results' do
     @linode.stubs(:post).returns('DATA' => { 'TYPE' => 'foo' })
     @linode.list.type.should == 'foo'

data/spec/linode/linode/ip_spec.rb

@@ -6,42 +6,44 @@ describe Linode::Linode::Ip do
     @api_key = 'foo'
     @linode = Linode::Linode::Ip.new(:api_key => @api_key)
   end
-  
+
   it 'should be a Linode instance' do
     @linode.class.should < Linode
   end
-  
-  %w(list addprivate).each do |action|
+
+  %w(list addprivate addpublic setrdns swap).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 avail.#{action} action" do
         @linode.expects(:send_request).with {|api_action, data| api_action == "linode.ip.#{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.ip.#{action}" do
-        @linode.documentation_path(Linode.action_path(@linode.class.name, action)).should == "http://www.linode.com/api/linode/linode.ip.#{action}"
+
+      it "should consider the documentation to live at https://www.linode.com/api/linode/linode.ip.#{action}" do
+        @linode.documentation_path(Linode.action_path(@linode.class.name, action)).should == "https://www.linode.com/api/linode/linode.ip.#{action}"
       end
     end
   end

data/spec/linode/linode/job_spec.rb

@@ -6,42 +6,44 @@ describe Linode::Linode::Job do
     @api_key = 'foo'
     @linode = Linode::Linode::Job.new(:api_key => @api_key)
   end
-  
+
   it 'should be a Linode instance' do
     @linode.class.should < Linode
   end
-  
+
   %w(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 avail.#{action} action" do
         @linode.expects(:send_request).with {|api_action, data| api_action == "linode.job.#{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.job.#{action}" do
-        @linode.documentation_path(Linode.action_path(@linode.class.name, action)).should == "http://www.linode.com/api/linode/linode.job.#{action}"
+
+      it "should consider the documentation to live at https://www.linode.com/api/linode/linode.job.#{action}" do
+        @linode.documentation_path(Linode.action_path(@linode.class.name, action)).should == "https://www.linode.com/api/linode/linode.job.#{action}"
       end
     end
   end

data/spec/linode/linode_spec.rb

@@ -6,50 +6,52 @@ describe Linode::Linode do
     @api_key = 'foo'
     @linode = Linode::Linode.new(:api_key => @api_key)
   end
-  
+
   it 'should be a Linode instance' do
     @linode.class.should < Linode
   end
-  
-  %w(update create list shutdown boot delete reboot).each do |action|
+
+  %w(update create list shutdown boot delete reboot clone resize).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 linode.#{action} action" do
         @linode.expects(:send_request).with {|api_action, data| api_action == "linode.#{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/linode/linode.#{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/linode/linode.#{action}"
       end
     end
   end
-  
+
   it 'should be able to provide access to the Linode Config API' do
     @linode.should respond_to(:config)
   end
-  
+
   describe 'when providing access to the Linode Config API' do
     before :each do
       @api_key = 'foo'
@@ -58,25 +60,25 @@ describe Linode::Linode 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::Linode::Config instance' do
       @linode.config.class.should == Linode::Linode::Config
     end
-    
+
     it 'should set the API key on the Linode::Linode::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::Linode::Config instance to be our API url' do
       @linode.config.api_url.should == @api_url
     end
-    
+
     it 'should return the same Linode::Linode::Config instance when called again' do
       linode = Linode::Linode.new(:api_key => @api_key)
       result = linode.config
@@ -87,7 +89,7 @@ describe Linode::Linode do
   it 'should be able to provide access to the Linode Disk API' do
     @linode.should respond_to(:disk)
   end
-  
+
   describe 'when providing access to the Linode Disk API' do
     before :each do
       @api_key = 'foo'
@@ -96,36 +98,36 @@ describe Linode::Linode do
     end
 
     it 'should allow no arguments' do
-      lambda { @linode.disk }.should_not raise_error(ArgumentError)
+      lambda { @linode.disk }.should_not raise_error
     end
-    
+
     it 'should require no arguments' do
       lambda { @linode.disk(:foo) }.should raise_error(ArgumentError)
     end
-    
+
     it 'should return a Linode::Linode::Disk instance' do
       @linode.disk.class.should == Linode::Linode::Disk
     end
-    
+
     it 'should set the API key on the Linode::Linode::Disk instance to be our API key' do
       @linode.disk.api_key.should == @api_key
     end
-    
+
     it 'should set the API url on the Linode::Linode::Disk instance to be our API url' do
       @linode.disk.api_url.should == @api_url
     end
-    
+
     it 'should return the same Linode::Linode::Disk instance when called again' do
       linode = Linode::Linode.new(:api_key => @api_key)
       result = linode.disk
       linode.disk.should == result
     end
   end
-  
+
   it 'should be able to provide access to the Linode Job API' do
     @linode.should respond_to(:job)
   end
-  
+
   describe 'when providing access to the Linode Job API' do
     before :each do
       @api_key = 'foo'
@@ -134,36 +136,36 @@ describe Linode::Linode do
     end
 
     it 'should allow no arguments' do
-      lambda { @linode.job }.should_not raise_error(ArgumentError)
+      lambda { @linode.job }.should_not raise_error
     end
-    
+
     it 'should require no arguments' do
       lambda { @linode.job(:foo) }.should raise_error(ArgumentError)
     end
-    
+
     it 'should return a Linode::Linode::Job instance' do
       @linode.job.class.should == Linode::Linode::Job
     end
-    
+
     it 'should set the API key on the Linode::Linode::Job instance to be our API key' do
       @linode.job.api_key.should == @api_key
     end
-    
+
     it 'should set the API url on the Linode::Linode::Job instance to be our API url' do
       @linode.job.api_url.should == @api_url
     end
-    
+
     it 'should return the same Linode::Linode::Job instance when called again' do
       linode = Linode::Linode.new(:api_key => @api_key)
       result = linode.job
       linode.job.should == result
     end
   end
-  
+
   it 'should be able to provide access to the Linode Ip API' do
     @linode.should respond_to(:ip)
   end
-  
+
   describe 'when providing access to the Linode Ip API' do
     before :each do
       @api_key = 'foo'
@@ -172,25 +174,25 @@ describe Linode::Linode do
     end
 
     it 'should allow no arguments' do
-      lambda { @linode.ip }.should_not raise_error(ArgumentError)
+      lambda { @linode.ip }.should_not raise_error
     end
-    
+
     it 'should require no arguments' do
       lambda { @linode.ip(:foo) }.should raise_error(ArgumentError)
     end
-    
+
     it 'should return a Linode::Linode::Ip instance' do
       @linode.ip.class.should == Linode::Linode::Ip
     end
-    
+
     it 'should set the API key on the Linode::Linode::Ip instance to be our API key' do
       @linode.ip.api_key.should == @api_key
     end
-    
+
     it 'should set the API url on the Linode::Linode::Ip instance to be our API url' do
       @linode.ip.api_url.should == @api_url
     end
-    
+
     it 'should return the same Linode::Linode::Linode instance when called again' do
       linode = Linode::Linode.new(:api_key => @api_key)
       result = linode.ip