cloudstack_client 1.5.12 → 2.0.0

data/lib/cloudstack_client/request_handling.rb

@@ -0,0 +1,91 @@
+module CloudstackClient
+  module RequestHandling
+    def send_request(params, opts = {})
+      params['response'] = 'json'
+      params['apiKey'] = @api_key
+      print_debug_output JSON.pretty_generate(params) if @debug
+
+      data = params_to_data(params)
+      uri = URI.parse "#{@api_url}?#{data}&signature=#{create_signature(data)}"
+      http = build_http(uri)
+      response = request_with_retries(http, uri)
+
+      handle_response(response, opts)
+    end
+
+    private
+
+    def build_http(uri)
+      http = Net::HTTP.new(uri.host, uri.port)
+      return configure_https(http) if uri.scheme == 'https'
+
+      http.read_timeout = @read_timeout
+      http
+    end
+
+    def configure_https(http)
+      http.use_ssl = true
+      http.verify_mode = @verify_ssl ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
+      http.ca_file = @ca_file if @ca_file
+      http.read_timeout = @read_timeout
+      http
+    end
+
+    def request_with_retries(http, uri)
+      retries = 0
+      begin
+        request = Net::HTTP::Get.new(uri.request_uri)
+        request['Host'] = host unless host.to_s.strip.empty?
+        http.request(request)
+      rescue Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::EHOSTUNREACH,
+             Errno::ENETUNREACH, Errno::ETIMEDOUT, Net::OpenTimeout,
+             Net::ReadTimeout, SocketError, EOFError => e
+        retries += 1
+        if retries < @request_retries
+          sleep(retries)
+          print "." if @verbose
+          retry
+        end
+        raise ConnectionError,
+              "API URL '#{@api_url}' is not reachable " \
+              "(after #{retries} attempt#{'s' if retries > 1}): #{e.message}"
+      end
+    end
+
+    def handle_response(response, opts)
+      body = parse_response_body(response)
+      return normalize_success(body, opts) if response.is_a?(Net::HTTPOK)
+
+      message = body.is_a?(Hash) ? body[k('errortext')] : body
+      raise ApiError, "Status #{response.code}: #{message}."
+    end
+
+    def parse_response_body(response)
+      JSON.parse(response.body, symbolize_names: @symbolize_keys).values.first
+    rescue JSON::ParserError
+      raise ParseError,
+            "Response from server is not readable. Check if the API endpoint " \
+            "(#{@api_url}) is valid and accessible."
+    end
+
+    def normalize_success(body, opts)
+      return body unless body.respond_to?(:keys)
+      return normalize_counted_response(body, opts) if body.size == 2 && body.key?(k('count'))
+      return normalize_nested_response(body) if body.size == 1 && body.values.first.respond_to?(:keys)
+
+      body.reject! { |key, _| key == k('count') } if body.key?(k('count')) && !opts[:include_count]
+      body.empty? ? [] : body
+    end
+
+    def normalize_counted_response(body, opts)
+      return body if opts[:include_count]
+
+      body.reject { |key, _| key == k('count') }.values.first
+    end
+
+    def normalize_nested_response(body)
+      item = body.values.first
+      item.is_a?(Array) || item.is_a?(Hash) ? item : []
+    end
+  end
+end

data/lib/cloudstack_client/version.rb

@@ -1,3 +1,3 @@
 module CloudstackClient
-  VERSION = "1.5.12"
+  VERSION = "2.0.0"
 end

data/test/api_test.rb

@@ -91,7 +91,7 @@ describe CloudstackClient::Api do
   end
 
   describe "when asked about all required params" do
-    it "must respond positively for 'createUser' and params 'account, email, firtsname, lastname, password, username'" do
+    it "must respond positively for 'createUser' with all required params" do
       params = {
         "account"   => "Master",
         "email"     => "me@me.com",
@@ -109,4 +109,26 @@ describe CloudstackClient::Api do
     end
   end
 
+  describe "when asked about commands containing acronyms" do
+    it "must respond positively for the camel case name 'createSSHKeyPair'" do
+      _(@api.command_supported?('createSSHKeyPair')).must_equal true
+    end
+
+    it "must respond positively for the underscored name 'create_ssh_key_pair'" do
+      _(@api.command_supported?('create_ssh_key_pair')).must_equal true
+    end
+
+    it "must respond positively for the underscored name 'list_vpc_offerings'" do
+      _(@api.command_supported?('list_vpc_offerings')).must_equal true
+    end
+
+    it "must resolve params via the underscored name of an acronym command" do
+      _(@api.command_supports_param?('create_ssh_key_pair', 'name')).must_equal true
+    end
+
+    it "must return false rather than raise for an unknown command" do
+      _(@api.command_supports_param?('listClowns', 'name')).must_equal false
+    end
+  end
+
 end

data/test/client_test.rb

@@ -1,29 +1,163 @@
 require "test_helper"
 
 describe CloudstackClient::Client do
-  before do
-    @client = CloudstackClient::Client.new(
-      "https://cloudstack.api/client/api",
-      "test-key",
-      "test-secret"
+  let(:client) do
+    CloudstackClient::Client.new(
+      TestHelpers::TEST_URL, TestHelpers::TEST_KEY, TestHelpers::TEST_SECRET, quiet: true
     )
   end
 
   describe "when the client is instantiated" do
-    it "must respond_to 'list_virtual_machines'" do
-      _(@client.respond_to?(:list_virtual_machines)).must_equal true
+    it "exposes the loaded API definition" do
+      _(client.api).must_be_kind_of CloudstackClient::Api
+      _(client.api.api_version).must_equal CloudstackClient::Api::DEFAULT_API_VERSION
     end
 
-    it "must respond_to 'deploy_virtual_machine'" do
-      _(@client.respond_to?(:deploy_virtual_machine)).must_equal true
+    it "is not in debug mode by default" do
+      _(client.debug).must_equal false
     end
 
-    it "must respond_to 'create_user'" do
-      _(@client.respond_to?(:create_user)).must_equal true
+    it "defines no API methods when no_api_methods is set" do
+      bare = bare_client
+      _(bare.respond_to?(:list_virtual_machines)).must_equal false
+      _(bare.api).must_be_nil
     end
+  end
+
+  describe "generated command methods" do
+    it "sends the CloudStack command name for the underscored method" do
+      stub_list("listVirtualMachines", "virtualmachine", [{ "id" => "vm-1" }])
+
+      client.list_virtual_machines
+
+      _(last_request_params["command"].first).must_equal "listVirtualMachines"
+    end
+
+    it "returns the unwrapped collection" do
+      stub_list("listVirtualMachines", "virtualmachine",
+        [{ "id" => "vm-1" }, { "id" => "vm-2" }])
+
+      _(client.list_virtual_machines).must_equal [{ "id" => "vm-1" }, { "id" => "vm-2" }]
+    end
+
+    it "strips underscores from argument names" do
+      stub_list("listVirtualMachines", "virtualmachine", [])
+
+      client.list_virtual_machines(list_all: true)
+
+      _(last_request_params["listall"].first).must_equal "true"
+    end
+
+    it "passes through arguments that need no translation" do
+      stub_list("listVirtualMachines", "virtualmachine", [])
+
+      client.list_virtual_machines(state: "running")
+
+      _(last_request_params["state"].first).must_equal "running"
+    end
+
+    it "drops arguments the command does not support" do
+      stub_list("listVirtualMachines", "virtualmachine", [])
+
+      client.list_virtual_machines(state: "running", hotdog: "mustard")
+
+      params = last_request_params
+      _(params).must_include "state"
+      _(params).wont_include "hotdog"
+    end
+
+    it "drops arguments with a nil value" do
+      stub_list("listVirtualMachines", "virtualmachine", [])
+
+      client.list_virtual_machines(state: nil, name: "web01")
+
+      params = last_request_params
+      _(params).must_include "name"
+      _(params).wont_include "state"
+    end
+
+    it "accepts String keys as well as Symbol keys" do
+      stub_list("listVirtualMachines", "virtualmachine", [])
+
+      client.list_virtual_machines("state" => "running")
+
+      _(last_request_params["state"].first).must_equal "running"
+    end
+  end
+
+  describe "required parameter validation" do
+    it "raises ParameterError when a required parameter is missing" do
+      error = _(proc { client.deploy_virtual_machine(zoneid: "1") })
+        .must_raise CloudstackClient::ParameterError
+
+      _(error.message).must_match(/deployVirtualMachine requires/)
+      _(error.message).must_match(/serviceofferingid/)
+      _(error.message).must_match(/templateid/)
+    end
+
+    it "raises ParameterError for unsupported parameters in strict mode" do
+      error = _(proc {
+        client.list_virtual_machines({ unsupported: true }, strict_params: true)
+      }).must_raise CloudstackClient::ParameterError
+
+      _(error.message).must_match(/does not support parameter unsupported/)
+    end
+
+    it "does not issue a request when validation fails" do
+      _(proc { client.create_user(username: "meme") })
+        .must_raise CloudstackClient::ParameterError
+
+      assert_not_requested(:get, ApiStubs::ANY_REQUEST)
+    end
+
+    it "proceeds when every required parameter is present" do
+      stub_command("createUser", { "createuserresponse" => { "user" => { "id" => "u-1" } } })
+
+      result = client.create_user(
+        account: "Master", email: "me@me.com", firstname: "Me",
+        lastname: "Me", password: "secret", username: "meme"
+      )
+
+      _(result).must_equal("id" => "u-1")
+    end
+  end
+
+  describe "synchronous and asynchronous dispatch" do
+    it "sends a synchronous command directly" do
+      stub_list("listVirtualMachines", "virtualmachine", [])
+
+      client.list_virtual_machines
+
+      assert_not_requested(:get, ApiStubs::ANY_REQUEST,
+        query: hash_including("command" => "queryAsyncJobResult"))
+    end
+
+    it "polls for an asynchronous command" do
+      stub_async("deployVirtualMachine",
+        polls: [job_success("id" => "vm-1")])
+
+      result = client.stub(:sleep, nil) do
+        client.deploy_virtual_machine(
+          zoneid: "1", serviceofferingid: "2", templateid: "3"
+        )
+      end
+
+      _(result).must_equal("id" => "vm-1")
+      assert_requested(:get, ApiStubs::ANY_REQUEST,
+        query: hash_including("command" => "queryAsyncJobResult"))
+    end
+
+    it "forces a synchronous request when the sync option is given" do
+      stub_command("deployVirtualMachine",
+        { "deployvirtualmachineresponse" => { "jobid" => "job-1" } })
+
+      result = client.deploy_virtual_machine(
+        { zoneid: "1", serviceofferingid: "2", templateid: "3" }, { sync: true }
+      )
 
-    it "must not be in debug mode" do
-      _(@client.debug).must_equal false
+      _(result).must_equal("jobid" => "job-1")
+      assert_not_requested(:get, ApiStubs::ANY_REQUEST,
+        query: hash_including("command" => "queryAsyncJobResult"))
     end
   end
 end

data/test/configuration_test.rb

@@ -31,4 +31,88 @@ describe CloudstackClient::Configuration do
     end
   end
 
+  describe "when the configuration cannot be loaded" do
+    it "must raise when the file does not exist" do
+      error = _(proc {
+        CloudstackClient::Configuration.load(config_file: "/nonexistent/cloudstack.yml")
+      }).must_raise CloudstackClient::ConfigurationError
+
+      _(error.message).must_match(/not found/)
+    end
+
+    it "must raise when the file is not valid YAML" do
+      error = _(proc {
+        CloudstackClient::Configuration.load(
+          config_file: "#{File.expand_path File.dirname(__FILE__)}/data/cloudstack-malformed.yml"
+        )
+      }).must_raise CloudstackClient::ConfigurationError
+
+      _(error.message).must_match(/Can't load configuration/)
+    end
+
+    it "must reject unsafe YAML objects" do
+      error = _(proc {
+        CloudstackClient::Configuration.load(
+          config_file: "#{File.expand_path File.dirname(__FILE__)}/data/cloudstack-unsafe.yml"
+        )
+      }).must_raise CloudstackClient::ConfigurationError
+
+      _(error.message).must_match(/Can't load configuration/)
+    end
+
+    it "must include the backtrace in debug mode" do
+      error = _(proc {
+        CloudstackClient::Configuration.load(
+          config_file: "#{File.expand_path File.dirname(__FILE__)}/data/cloudstack-malformed.yml",
+          debug: true
+        )
+      }).must_raise CloudstackClient::ConfigurationError
+
+      _(error.message).must_match(/Backtrace/)
+    end
+
+    it "must raise when the requested environment is absent" do
+      error = _(proc {
+        CloudstackClient::Configuration.load(
+          config_file: "#{File.expand_path File.dirname(__FILE__)}/data/cloudstack-1.yml",
+          env: "nope"
+        )
+      }).must_raise CloudstackClient::ConfigurationError
+
+      _(error.message).must_match(/Can't find environment nope/)
+    end
+
+    it "must raise when required keys are missing" do
+      error = _(proc {
+        CloudstackClient::Configuration.load(
+          config_file: "#{File.expand_path File.dirname(__FILE__)}/data/cloudstack-incomplete.yml"
+        )
+      }).must_raise CloudstackClient::ConfigurationError
+
+      _(error.message).must_match(/does not contain all required keys/)
+    end
+
+    it "must raise when a required value is empty" do
+      error = _(proc {
+        CloudstackClient::Configuration.load(
+          config_file: "#{File.expand_path File.dirname(__FILE__)}/data/cloudstack-empty.yml"
+        )
+      }).must_raise CloudstackClient::ConfigurationError
+
+      _(error.message).must_match(/does not contain all required keys/)
+    end
+  end
+
+  describe "when the configuration is valid" do
+    it "must return the url and secret key alongside the environment" do
+      config = CloudstackClient::Configuration.load(
+        config_file: "#{File.expand_path File.dirname(__FILE__)}/data/cloudstack-1.yml"
+      )
+
+      _(config[:url]).must_equal "https://cloud.swisstxt.ch/client/api/"
+      _(config[:environment]).must_equal "test1"
+      _(config[:secret_key]).wont_be_nil
+    end
+  end
+
 end