linode 0.5.4

data/spec/linode/test_spec.rb

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

data/spec/linode/user_spec.rb

@@ -0,0 +1,45 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper.rb')
+require 'linode'
+
+describe Linode::User do
+  before :each do
+    @api_key = 'foo'
+    @linode = Linode::User.new(:api_key => @api_key)
+  end
+  
+  it 'should be a Linode instance' do
+    @linode.class.should < Linode
+  end
+  
+  %w(getapikey).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 user.#{action} action" do
+        @linode.expects(:send_request).with {|api_action, data| api_action == "user.#{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_spec.rb

@@ -0,0 +1,350 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper.rb')
+require 'linode'
+
+describe Linode do
+  describe 'as a class' do
+    it 'should be able to create a new Linode instance' do
+      Linode.should respond_to(:new)
+    end
+  
+    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)
+      end
+      
+      it 'should require an arguments hash' do
+        lambda { Linode.new }.should raise_error(ArgumentError)
+      end
+
+      it 'should fail if no API key is given' do
+        lambda { Linode.new({}) }.should raise_error(ArgumentError)        
+      end
+      
+      it 'should return a Linode instance' do
+        Linode.new(:api_key => 'foo').class.should == Linode
+      end
+    end
+  end
+end
+
+describe 'Linode' do  
+  before :each do
+    @api_key = 'foo'
+    @api_url = 'https://fake.linode.com/'
+    @linode = Linode.new(:api_key => @api_key, :api_url => @api_url)
+  end
+  
+  it 'should be able to return the API key provided at creation time' do
+    @linode.api_key.should == 'foo'
+  end
+  
+  it 'should be able to return the current API URL' do
+    @linode.should respond_to(:api_url)
+  end
+  
+  describe 'when returning the current API URL' do
+    it 'should return the API URL provided at creation time if one was provided' do
+      @linode = Linode.new(:api_key => @api_key, :api_url => 'https://fake.linode.com/')
+      @linode.api_url.should == 'https://fake.linode.com/'
+    end
+    
+    it 'should return the stock linode API URL if none was provided at creation time' do
+      @linode = Linode.new(:api_key => @api_key)
+      @linode.api_url.should == 'https://api.linode.com/'      
+    end
+  end
+  
+  it 'should be able to submit a request via the API' do
+    @linode.should respond_to(:send_request)
+  end
+  
+  describe 'when submitting a request via the API' do
+    before :each do
+      @json = %Q!{
+      		"ERRORARRAY":[],
+      		"ACTION":"test.echo",
+      		"DATA":{"FOO":"bar"}
+      	}!
+      HTTParty.stubs(:get).returns(@json)
+      @linode.stubs(:api_url).returns('https://fake.linode.com/')
+    end
+    
+    it 'should allow a request name and a data hash' do
+      lambda { @linode.send_request('test.echo', {}) }.should_not raise_error(ArgumentError)
+    end
+    
+    it 'should require a request name and a data hash' do
+      lambda { @linode.send_request('test.echo') }.should raise_error(ArgumentError)      
+    end
+    
+    it 'should make a request to the API url' do
+      @linode.stubs(:api_url).returns('https://fake.linode.com/')
+      HTTParty.expects(:get).with { |path, args|
+        path == 'https://fake.linode.com/'
+      }.returns(@json)
+      @linode.send_request('test.echo', { })
+    end
+    
+    it 'should provide the API key when making its request' do
+      HTTParty.expects(:get).with { |path, args|
+        args[:query][:api_key] == @api_key
+      }.returns(@json)
+      @linode.send_request('test.echo', { })      
+    end
+    
+    it 'should set the designated request method as the HTTP API action' do
+      HTTParty.expects(:get).with { |path, args|
+        args[:query][:api_action] == 'test.echo'
+      }.returns(@json)
+      @linode.send_request('test.echo', { })            
+    end
+    
+    it 'should set the response format to JSON' do
+      HTTParty.expects(:get).with { |path, args|
+        args[:query][:api_responseFormat] == 'json'
+      }.returns(@json)
+      @linode.send_request('test.echo', { })      
+    end
+    
+    it 'should provide the data hash to the HTTP API request' do
+      HTTParty.expects(:get).with { |path, args|
+        args[:query]['foo'] == 'bar'
+      }.returns(@json)
+      @linode.send_request('test.echo', { 'foo' => 'bar' })                  
+    end
+    
+    it 'should not allow overriding the API key via the data hash' do
+      HTTParty.expects(:get).with { |path, args|
+        args[:query][:api_key] == @api_key
+      }.returns(@json)
+      @linode.send_request('test.echo', { :api_key => 'h4x0r' })                        
+    end
+    
+    it 'should not allow overriding the API action via the data hash' do
+      HTTParty.expects(:get).with { |path, args|
+        args[:query][:api_action] == 'test.echo'
+      }.returns(@json)
+      @linode.send_request('test.echo', { :api_action => 'h4x0r' })
+    end
+    
+    it 'should not allow overriding the API response format via the data hash' do
+      HTTParty.expects(:get).with { |path, args|
+        args[:query][:api_responseFormat] == 'json'
+      }.returns(@json)
+      @linode.send_request('test.echo', { :api_responseFormat => 'h4x0r' })
+    end
+    
+    it 'should fail when the request submission fails' do
+      HTTParty.stubs(:get).returns(%Q!{
+      		"ERRORARRAY":["failure"],
+      		"ACTION":"test.echo",
+      		"DATA":{"foo":"bar"}
+      }!)
+      lambda { @linode.send_request('test.echo', { :api_action => 'failure' }) }.should raise_error
+    end
+    
+    describe 'when the result is a list of hashes' do
+      it 'should return a list of objects with lower-cased methods for the data fields' do
+        HTTParty.stubs(:get).returns(%Q!{
+        		"ERRORARRAY":[],
+        		"ACTION":"test.echo",
+        		"DATA":[{"FOO":"bar"},{"BAR":"baz"}]
+        }!)
+        @linode.send_request('test.echo', {}).first.foo.should == 'bar'
+        @linode.send_request('test.echo', {}).last.bar.should == 'baz'
+      end
+      
+      it 'should return a list of objects which do not respond to upper-case URLs for the data fields' do
+        HTTParty.stubs(:get).returns(%Q!{
+        		"ERRORARRAY":[],
+        		"ACTION":"test.echo",
+        		"DATA":[{"FOO":"bar"},{"BAR":"baz"}]
+        }!)
+        @linode.send_request('test.echo', {}).first.should_not respond_to(:FOO)
+        @linode.send_request('test.echo', {}).last.should_not respond_to(:BAR)
+      end
+    end
+    
+    describe 'when the result is a hash' do
+      it 'should return an object with lower-cased methods for the data fields' do
+        @linode.send_request('test.echo', {}).foo.should == 'bar'
+      end
+    
+      it 'should return an object which does not respond to upper-case URLs for the data fields' do
+        @linode.send_request('test.echo', {}).should_not respond_to(:FOO)
+      end
+    end
+    
+    describe 'when the result is neither a list nor a hash' do
+      it 'should return the result unchanged' do
+        HTTParty.stubs(:get).returns(%Q!{
+        		"ERRORARRAY":[],
+        		"ACTION":"test.echo",
+        		"DATA":"thingie"
+        }!)
+        @linode.send_request('test.echo', {}).should == "thingie"
+      end
+    end
+  end
+  
+  it 'should be able to provide access to the Linode Test API' do
+    @linode.should respond_to(:test)
+  end
+  
+  describe 'when providing access to the Linode Test API' do
+    it 'should allow no arguments' do
+      lambda { @linode.test }.should_not raise_error(ArgumentError)
+    end
+    
+    it 'should require no arguments' do
+      lambda { @linode.test(:foo) }.should raise_error(ArgumentError)
+    end
+    
+    it 'should return a Linode::Test instance' do
+      @linode.test.class.should == Linode::Test
+    end
+    
+    it 'should set the API key on the Linode::Test instance to be our API key' do
+      @linode.test.api_key.should == @api_key
+    end
+    
+    it 'should set the API URL on the Linode::Test instance to be our API URL' do
+      @linode.test.api_url.should == @api_url
+    end
+    
+    it 'should return the same Linode::Test instance when called again' do
+      linode = Linode.new(:api_key => @api_key)
+      result = linode.test
+      linode.test.should == result
+    end
+  end
+
+  it 'should be able to provide access to the Linode Avail API' do
+    @linode.should respond_to(:avail)
+  end
+  
+  describe 'when providing access to the Linode Avail API' do
+    it 'should allow no arguments' do
+      lambda { @linode.avail }.should_not raise_error(ArgumentError)
+    end
+    
+    it 'should require no arguments' do
+      lambda { @linode.avail(:foo) }.should raise_error(ArgumentError)
+    end
+    
+    it 'should return a Linode::Avail instance' do
+      @linode.avail.class.should == Linode::Avail
+    end
+    
+    it 'should set the API key on the Linode::Avail instance to be our API key' do
+      @linode.avail.api_key.should == @api_key
+    end
+    
+    it 'should set the API url on the Linode::Avail instance to be our API url' do
+      @linode.avail.api_url.should == @api_url
+    end
+    
+    it 'should return the same Linode::Avail instance when called again' do
+      linode = Linode.new(:api_key => @api_key)
+      result = linode.avail
+      linode.avail.should == result
+    end
+  end
+  
+  it 'should be able to provide access to the Linode User API' do
+    @linode.should respond_to(:user)
+  end
+  
+  describe 'when providing access to the Linode User API' do
+    it 'should allow no arguments' do
+      lambda { @linode.user }.should_not raise_error(ArgumentError)
+    end
+    
+    it 'should require no arguments' do
+      lambda { @linode.user(:foo) }.should raise_error(ArgumentError)
+    end
+    
+    it 'should return a Linode::User instance' do
+      @linode.user.class.should == Linode::User
+    end
+    
+    it 'should set the API key on the Linode::User instance to be our API key' do
+      @linode.user.api_key.should == @api_key
+    end
+    
+    it 'should set the API url on the Linode::User instance to be our API url' do
+      @linode.user.api_url.should == @api_url
+    end
+    
+    it 'should return the same Linode::User instance when called again' do
+      linode = Linode.new(:api_key => @api_key)
+      result = linode.user
+      linode.user.should == result
+    end
+  end
+
+  it 'should be able to provide access to the Linode Domain API' do
+    @linode.should respond_to(:domain)
+  end
+  
+  describe 'when providing access to the Linode Domain API' do
+    it 'should allow no arguments' do
+      lambda { @linode.domain }.should_not raise_error(ArgumentError)
+    end
+    
+    it 'should require no arguments' do
+      lambda { @linode.domain(:foo) }.should raise_error(ArgumentError)
+    end
+    
+    it 'should return a Linode::Domain instance' do
+      @linode.domain.class.should == Linode::Domain
+    end
+    
+    it 'should set the API key on the Linode::Domain instance to be our API key' do
+      @linode.domain.api_key.should == @api_key
+    end
+    
+    it 'should set the API url on the Linode::Domain instance to be our API url' do
+      @linode.domain.api_url.should == @api_url
+    end
+    
+    it 'should return the same Linode::Domain instance when called again' do
+      linode = Linode.new(:api_key => @api_key)
+      result = linode.domain
+      linode.domain.should == result
+    end
+  end
+  
+  it 'should be able to provide access to the Linode Linode API' do
+    @linode.should respond_to(:linode)
+  end
+  
+  describe 'when providing access to the Linode Linode API' do
+    it 'should allow no arguments' do
+      lambda { @linode.linode }.should_not raise_error(ArgumentError)
+    end
+    
+    it 'should require no arguments' do
+      lambda { @linode.linode(:foo) }.should raise_error(ArgumentError)
+    end
+    
+    it 'should return a Linode::Linode instance' do
+      @linode.linode.class.should == Linode::Linode
+    end
+    
+    it 'should set the API key on the Linode::Linode instance to be our API key' do
+      @linode.linode.api_key.should == @api_key
+    end
+    
+    it 'should set the API url on the Linode::Linode instance to be our API url' do
+      @linode.linode.api_url.should == @api_url
+    end
+    
+    it 'should return the same Linode::Linode instance when called again' do
+      linode = Linode.new(:api_key => @api_key)
+      result = linode.linode
+      linode.linode.should == result
+    end
+  end
+end
+

data/spec/spec.opts

@@ -0,0 +1,6 @@
+--format
+s
+--colour
+--loadby
+mtime
+--backtrace