squall 0.0.3 → 1.0.0

data/lib/squall/client.rb

@@ -1,87 +0,0 @@
-module Squall
-  class Client
-
-    attr_reader :successful, :request, :response, :result, :message, :raw_response
-
-    def initialize
-      @default_options = {:accept => :json, :content_type => 'application/json'}
-      @debug = false
-    end
-
-    def toggle_debug
-      if @debug
-        @debug = false
-        RestClient.log = nil
-      else
-        @debug = true
-        RestClient.log = STDERR
-      end
-    end
-
-    def get(uri)
-      RestClient.get("#{uri_with_auth}/#{uri}.json", @default_options) { |_response, _request, _result|
-        handle_response _response, _request, _result
-      }
-    end
-
-    def post(uri, params = {})
-      RestClient.post("#{uri_with_auth}/#{uri}.json", params.to_json, @default_options) { |_response, _request, _result| 
-        handle_response _response, _request, _result
-      }
-    end
-
-    def put(uri, params = {})
-      RestClient.put("#{uri_with_auth}/#{uri}.json", params.to_json, @default_options) { |_response, _request, _result| 
-        handle_response _response, _request, _result
-      }
-    end
-
-    def delete(uri)
-      RestClient.delete("#{uri_with_auth}/#{uri}.json", @default_options) { |_response, _request, _result|
-        handle_response _response, _request, _result
-      }
-    end
-
-    private
-
-    def required_options!(required, actual)
-      required = required
-      actual = actual.keys
-      missing_keys = required - [actual].flatten 
-      raise(ArgumentError, "Missing key(s): #{missing_keys.join(", ")}") unless missing_keys.empty?
-    end
-
-    def valid_options!(accepted, actual)
-      actual = actual.keys if actual.is_a?(Hash)
-      unknown_keys = actual - accepted
-      raise(ArgumentError, "Unknown key(s): #{unknown_keys.join(", ")}") unless unknown_keys.empty?
-    end
-
-    def uri_with_auth
-      uri = Squall.api_endpoint
-      protocol = uri.port == 443 ? 'https' : 'http'
-      "#{protocol}://#{Squall.api_user}:#{Squall.api_password}@#{uri.host}#{uri.path}"
-    end
-
-    def handle_response(_response, _request, _result)
-      @request      = _request
-      @result       = _result
-      @response     = _response
-      @raw_response = _response
-      @successful = (200..207).include?(_response.code)
-
-      case _response.code
-      when 404
-        @message = "404 Not Found" 
-      when 403
-        @message = "Action is not permitted for that account"
-      when 422
-        @message = "Request Failed: #{@response}"
-      else
-        @message = (_response.strip.empty? ? _response : JSON.parse(_response))
-        _response.return!
-      end
-      @successful
-    end
-  end
-end

data/test/fixtures/virtual_machines.json

@@ -1 +0,0 @@
-[{"virtual_machine":{"label":"label1","cpus":2,"operating_system_distro":"rhel","created_at":"2010-11-16T17:37:23Z","template_id":9,"operating_system":"linux","cpu_shares":16,"updated_at":"2010-11-16T17:37:23Z","memory":512,"local_remote_access_port":null,"allowed_swap":true,"recovery_mode":null,"allow_resize_without_reboot":true,"xen_id":null,"id":39,"hypervisor_id":1,"total_disk_size":6,"ip_addresses":[],"user_id":5,"template_label":null,"hostname":"label1.example.com","booted":false,"monthly_bandwidth_used":0,"remote_access_password":null,"min_disk_size":5,"initial_root_password":"password1","identifier":"blahblah1","locked":false,"built":false}},{"virtual_machine":{"label":"label2","cpus":2,"operating_system_distro":"rhel","created_at":"2010-11-16T17:37:23Z","template_id":9,"operating_system":"linux","cpu_shares":16,"updated_at":"2010-11-16T17:37:23Z","memory":512,"local_remote_access_port":null,"allowed_swap":true,"recovery_mode":null,"allow_resize_without_reboot":true,"xen_id":null,"id":40,"hypervisor_id":1,"total_disk_size":6,"ip_addresses":[],"user_id":5,"template_label":null,"hostname":"label2.example.com","booted":false,"monthly_bandwidth_used":0,"remote_access_password":null,"min_disk_size":5,"initial_root_password":"password2","identifier":"blahblah2","locked":false,"built":false}}]

data/test/fixtures/virtual_machines_1.json

@@ -1 +0,0 @@
-{"virtual_machine":{"label":"label1","cpus":2,"operating_system_distro":"rhel","created_at":"2010-11-16T17:37:23Z","template_id":9,"operating_system":"linux","cpu_shares":16,"updated_at":"2010-11-16T17:37:23Z","memory":512,"local_remote_access_port":null,"allowed_swap":true,"recovery_mode":null,"allow_resize_without_reboot":true,"xen_id":null,"id":1,"hypervisor_id":1,"total_disk_size":6,"ip_addresses":[],"user_id":5,"template_label":null,"hostname":"label1.example.com","booted":false,"monthly_bandwidth_used":0,"remote_access_password":null,"min_disk_size":5,"initial_root_password":"password1","identifier":"woah","locked":false,"built":false}}

data/test/helper.rb

@@ -1,31 +0,0 @@
-require 'rubygems'
-require 'test/unit'
-require 'redgreen'
-
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-
-require 'squall'
-require 'fakeweb'
-
-class Test::Unit::TestCase
-
-  def setup
-    FakeWeb.allow_net_connect = false
-    FakeWeb.clean_registry
-    Squall.config('user', 'stupidpass', 'http://example.com/onapp')
-  end
-
-  def uri_with_login
-      "http://#{Squall.api_user}:#{Squall.api_password}@#{Squall.api_endpoint.host}#{Squall.api_endpoint.path}"
-  end
-
-  def stub_json_request(meth, uri, content = nil, code = 200)
-    content = File.read(File.join(File.dirname(__FILE__), "fixtures/#{uri.gsub('/', '_')}.json")) if content.nil?
-    fake_response = Net::HTTPOK.new('1.1', code, 'OK') 
-    fake_response['Content-Type'] = 'application/json' 
-    fake_response.instance_variable_set('@body', content)
-    FakeWeb.register_uri(meth, "#{uri_with_login}/#{uri}.json", :content_type => 'application/json', :response => fake_response)
-  end
-
-end

data/test/test_client.rb

@@ -1,152 +0,0 @@
-require File.dirname(__FILE__) + '/helper'
-
-class TestClient < Test::Unit::TestCase
-
-  def setup
-    super
-    @client = Squall::Client.new 
-    assert_defaults
-  end
-
-  def test_init
-    default_options = {:accept => :json, :content_type => 'application/json'}
-    assert_equal default_options, @client.instance_variable_get('@default_options')
-    assert_equal false, @client.instance_variable_get('@debug')
-    assert_nil  defined?(Squall::Client::URI_PREFIX)
-  end
-
-  def test_debug
-    assert_nil RestClient.log
-    assert_equal false, @client.instance_variable_get('@debug')
-
-    @client.toggle_debug
-    assert_equal true, @client.instance_variable_get('@debug')
-    assert_equal STDERR, RestClient.log
-
-    @client.toggle_debug
-    assert_nil RestClient.log
-    assert_equal false, @client.instance_variable_get('@debug')
-  end
-
-  def test_get
-    stub_json_request(:get, 'test_get', '["test"]')
-    @client.get('test_get')
-
-    assert_equal :get,  @client.request.method
-  end
-
-  def test_post
-    stub_json_request(:post, 'test_post', '["test"]')
-    @client.post('test_post')
-    assert_equal :post,  @client.request.method
-  end
-
-  def test_put
-    stub_json_request(:put, 'test_put', '["test"]')
-    @client.put('test_put')
-    assert_equal :put,  @client.request.method
-  end
-
-  def test_delete
-    stub_json_request(:delete, 'test_delete', '["test"]')
-    @client.delete('test_delete')
-    assert_equal :delete,  @client.request.method
-  end
-
-  def test_required_options
-    assert_nothing_raised do
-      required_options = [:one, :two, :three]
-      actual_options   = {:one => 1, :two => 2, :three => 3}
-      @client.send(:required_options!, required_options, actual_options)
-    end
-
-    assert_nothing_raised do
-      required_options = [:one, :two, :three]
-      actual_options   = {:one => 1, :two => 2, :three => 3, :four => 4}
-      @client.send(:required_options!, required_options, actual_options)
-    end
-
-    e = assert_raises ArgumentError do
-      required_options = [:one, :two, :three]
-      actual_options   = {:one => 1 }
-      @client.send(:required_options!, required_options, actual_options)
-    end
-    assert_match /Missing key\(s\): two, three/, e.message
-  end
-
-  def test_valid_options
-    assert_nothing_raised do
-      accepted = [:one, :two]
-      actual   = {:one => 1, :two => 2} 
-      @client.send(:valid_options!, accepted, actual)
-    end
-
-    e = assert_raises ArgumentError do
-      accepted = [:one, :two]
-      actual   = {:one => 1, :two => 2, :three => 3} 
-      @client.send(:valid_options!, accepted, actual)
-    end
-    assert_match /Unknown key\(s\): three/, e.message
-  end
-
-  def test_uri_with_auth
-    assert_equal "http://user:stupidpass@example.com/onapp", @client.send(:uri_with_auth)
-
-    Squall.config('user', 'stupidpass', 'example.com/onapp')
-    assert_equal "http://user:stupidpass@example.com/onapp", @client.send(:uri_with_auth)
-
-    Squall.config('user', 'stupidpass', 'https://example.com/onapp')
-    assert_equal "https://user:stupidpass@example.com/onapp", @client.send(:uri_with_auth)
-  end
-
-  def test_handle_response_success
-    stub_json_request(:get, 'handle_response_success', '["response"]')
-    @client.get('handle_response_success')
-
-    assert_instance_of RestClient::Request,  @client.request
-    assert_instance_of Net::HTTPOK,  @client.result
-
-    assert_equal true,  @client.response.respond_to?(:code)
-    assert_equal 200, @client.response.code
-    assert_equal ["response"], @client.message
-    assert_equal true, @client.successful
-    assert_equal '["response"]', @client.response
-  end
-
-  def test_handle_response_error
-    FakeWeb.register_uri(:get, "#{uri_with_login}/handle_response_error_404.json", 
-                         :content_type => 'application/json', :body => '', :status => ["404", "Not Found"])
-    @client.get('handle_response_error_404')
-    assert_equal "404 Not Found", @client.message
-    assert_equal false, @client.successful
-
-    FakeWeb.register_uri(:get, "#{uri_with_login}/handle_response_error_403.json", 
-                         :content_type => 'application/json', :body => '', :status => ["403", "Forbidden"])
-    @client.get('handle_response_error_403')
-    assert_equal "Action is not permitted for that account", @client.message
-    assert_equal false, @client.successful
-
-    FakeWeb.register_uri(:get, "#{uri_with_login}/handle_response_error_422.json", 
-                         :content_type => 'application/json', :body => '422', :status => ["422", "Failed"])
-    @client.get('handle_response_error_422')
-    assert_equal "Request Failed: 422", @client.message
-    assert_equal false, @client.successful
-
-    FakeWeb.register_uri(:get, "#{uri_with_login}/handle_response_error_500.json", 
-                         :content_type => 'application/json', :body => '', :status => ["500", "Failed"])
-    e = assert_raises RestClient::InternalServerError do
-      @client.get('handle_response_error_500')
-    end
-    assert_match /Internal Server Error/i, e.message
-    assert_equal false, @client.successful
-  end
-
-  def assert_defaults
-    assert_nil @client.response
-    assert_nil @client.result
-    assert_nil @client.response
-    assert_nil @client.successful
-    assert_nil @client.message
-  end
-
-end

data/test/test_squall.rb

@@ -1,12 +0,0 @@
-require File.dirname(__FILE__) + '/helper'
-
-class TestSquall < Test::Unit::TestCase
-
-  def test_config
-    url = 'http://example.com/onapp'
-    assert_equal 'user', Squall.api_user
-    assert_equal 'stupidpass', Squall.api_password
-    assert_not_nil Squall.api_endpoint
-    assert_equal URI.parse(url), Squall.api_endpoint
-  end
-end

data/test/test_virtual_machine.rb

@@ -1,98 +0,0 @@
-require File.dirname(__FILE__) + '/helper'
-
-class TestVirtualMachine < Test::Unit::TestCase
-  def setup
-    super
-    @virtual = Squall::VirtualMachine.new  
-  end
-
-  def test_uri_prefix
-    assert_equal 'virtual_machines' , Squall::VirtualMachine::URI_PREFIX
-  end
-  
-  def test_list
-    stub_json_request(:get, 'virtual_machines')
-    vms = @virtual.list
-    assert_equal 2, vms.size
-    assert_equal 'label1', vms[0]['label']
-    assert_equal 'label2', vms[1]['label']
-    assert_equal true, @virtual.successful
-    assert_instance_of Array, vms
-  end
-
-  def test_show
-    stub_json_request(:get, 'virtual_machines/1')
-    show = @virtual.show(1)
-    assert_instance_of Hash, show
-    expected = {"monthly_bandwidth_used"=>0, "cpus"=>2, "label"=>"label1", 
-                "created_at"=>"2010-11-16T17:37:23Z", "operating_system_distro"=>"rhel", 
-                "cpu_shares"=>16, "operating_system"=>"linux", "template_id"=>9, 
-                "allowed_swap"=>true, "local_remote_access_port"=>nil, "memory"=>512,
-                "updated_at"=>"2010-11-16T17:37:23Z", "allow_resize_without_reboot"=>true,
-                "recovery_mode"=>nil, "hypervisor_id"=>1, "id"=>1, "xen_id"=>nil, 
-                "user_id"=>5, "booted"=>false, "hostname"=>"label1.example.com", 
-                "template_label"=>nil, "total_disk_size"=>6, "identifier"=>"woah", 
-                "initial_root_password"=>"password1", "min_disk_size"=>5, "remote_access_password"=>nil,
-                "built"=>false, "locked"=>false, "ip_addresses"=>[]}
-    assert_equal expected, show
-    assert_equal true, @virtual.successful
-  end
-
-  def test_edit
-    stub_json_request(:put, 'virtual_machines/1', '')
-    edit = @virtual.edit(1, :cpus => 1)
-    assert_equal true, edit
-    assert_equal true, @virtual.successful
-    
-    e = assert_raises ArgumentError do
-      @virtual.edit(1, :what => 1)
-    end
-    assert_match /Unknown key\(s\): what/, e.message
-  end
-
-  def test_create
-    params = {:memory => 128, :cpus => 1, :label => 'test_create', :template_id => 1, 
-              :hypervisor_id => 1, :initial_root_password => 'hi', :hostname => 'test_create'}
-
-    response = '{"virtual_machine":{"primary_network_id":"1", "cpus":"1", "label":"test_create",
-    "cpu_shares":"10", "template_id":"1", "swap_disk_size":"1", "memory":"128",
-    "required_virtual_machine_build":"1", "hypervisor_id":"1",
-    "required_ip_address_assignment":"1", "rate_limit":"10",
-    "primary_disk_size":"5", "hostname":"s",
-    "initial_root_password":"hi"} }'
-
-    stub_json_request(:post, 'virtual_machines', response)
-
-    create = @virtual.create(params)
-    assert_equal true, create
-    assert_equal JSON.parse(response), @virtual.message
-  end
-
-  def test_destroy
-    stub_json_request(:delete, 'virtual_machines/1', '')
-    destroy = @virtual.destroy(1)
-    assert_equal true, destroy
-  end
-
-  def test_reboot
-    stub_json_request(:post, 'virtual_machines/1/reboot', '')
-    reboot = @virtual.reboot(1)
-    assert_equal true, reboot
-  end
-
-  def test_search
-    stub_json_request(:get, 'virtual_machines')
-    search = @virtual.search('label2')
-    assert_equal 1, search.size
-
-    search = @virtual.search('label2', :label)
-    assert_equal 1, search.size
-
-    search = @virtual.search('label', :label)
-    assert_equal 2, search.size
-
-    search = @virtual.search(1, :hypervisor_id)
-    assert_equal 2, search.size
-  end
-
-end