linode 0.5.4

data/spec/linode/domain/resource_spec.rb

@@ -0,0 +1,44 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper.rb')
+require 'linode'
+
+describe Linode::Domain::Resource do
+  before :each do
+    @api_key = 'foo'
+    @linode = Linode::Domain::Resource.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)
+      end
+    
+      it 'should not require arguments' do
+        lambda { @linode.send(action.to_sym) }.should_not raise_error(ArgumentError)      
+      end
+    
+      it "should request the avail.#{action} action" do
+        @linode.expects(:send_request).with {|api_action, data| api_action == "domain.resource.#{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
+    end
+  end
+end

data/spec/linode/domain_spec.rb

@@ -0,0 +1,82 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper.rb')
+require 'linode'
+
+describe Linode::Domain do
+  before :each 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)
+      end
+    
+      it 'should not require arguments' do
+        lambda { @linode.send(action.to_sym) }.should_not raise_error(ArgumentError)      
+      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 }      
+      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'
+      @api_url = 'https://fake.linode.com/'
+      @linode = Linode::Domain.new(:api_key => @api_key, :api_url => @api_url)
+    end
+
+    it 'should allow no arguments' do
+      lambda { @linode.resource }.should_not raise_error(ArgumentError)
+    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
+      linode.resource.should == result
+    end
+  end
+end

data/spec/linode/linode/config_spec.rb

@@ -0,0 +1,44 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper.rb')
+require 'linode'
+
+describe Linode::Linode::Config do
+  before :each 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)
+      end
+    
+      it 'should not require arguments' do
+        lambda { @linode.send(action.to_sym) }.should_not raise_error(ArgumentError)      
+      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 }      
+      end
+    end
+  end
+end

data/spec/linode/linode/disk_spec.rb

@@ -0,0 +1,44 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper.rb')
+require 'linode'
+
+describe Linode::Linode::Disk do
+  before :each 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 duplicate delete 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)
+      end
+    
+      it 'should not require arguments' do
+        lambda { @linode.send(action.to_sym) }.should_not raise_error(ArgumentError)      
+      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 }      
+      end
+    end
+  end
+end

data/spec/linode/linode/ip_spec.rb

@@ -0,0 +1,44 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper.rb')
+require 'linode'
+
+describe Linode::Linode::Ip do
+  before :each 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).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)
+      end
+    
+      it 'should not require arguments' do
+        lambda { @linode.send(action.to_sym) }.should_not raise_error(ArgumentError)      
+      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 }      
+      end
+    end
+  end
+end

data/spec/linode/linode/job_spec.rb

@@ -0,0 +1,44 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper.rb')
+require 'linode'
+
+describe Linode::Linode::Job do
+  before :each 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)
+      end
+    
+      it 'should not require arguments' do
+        lambda { @linode.send(action.to_sym) }.should_not raise_error(ArgumentError)      
+      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 }      
+      end
+    end
+  end
+end

data/spec/linode/linode_spec.rb

@@ -0,0 +1,196 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper.rb')
+require 'linode'
+
+describe Linode::Linode do
+  before :each 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|
+    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)
+      end
+    
+      it 'should not require arguments' do
+        lambda { @linode.send(action.to_sym) }.should_not raise_error(ArgumentError)      
+      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 }      
+      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'
+      @api_url = 'https://fake.linode.com/'
+      @linode = Linode::Linode.new(:api_key => @api_key, :api_url => @api_url)
+    end
+
+    it 'should allow no arguments' do
+      lambda { @linode.config }.should_not raise_error(ArgumentError)
+    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
+      linode.config.should == result
+    end
+  end
+
+  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'
+      @api_url = 'https://fake.linode.com/'
+      @linode = Linode::Linode.new(:api_key => @api_key, :api_url => @api_url)
+    end
+
+    it 'should allow no arguments' do
+      lambda { @linode.disk }.should_not raise_error(ArgumentError)
+    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'
+      @api_url = 'https://fake.linode.com/'
+      @linode = Linode::Linode.new(:api_key => @api_key, :api_url => @api_url)
+    end
+
+    it 'should allow no arguments' do
+      lambda { @linode.job }.should_not raise_error(ArgumentError)
+    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'
+      @api_url = 'https://fake.linode.com/'
+      @linode = Linode::Linode.new(:api_key => @api_key, :api_url => @api_url)
+    end
+
+    it 'should allow no arguments' do
+      lambda { @linode.ip }.should_not raise_error(ArgumentError)
+    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
+      linode.ip.should == result
+    end
+  end
+end