cloudstack_client 1.6.0 → 2.0.0

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

data/test/connection_test.rb

@@ -0,0 +1,364 @@
+require "test_helper"
+
+describe CloudstackClient::Connection do
+  let(:connection) do
+    CloudstackClient::Connection.new(
+      TestHelpers::TEST_URL,
+      TestHelpers::TEST_KEY,
+      TestHelpers::TEST_SECRET,
+      quiet: true
+    )
+  end
+
+  describe "input validation" do
+    it "raises when the API URL is missing" do
+      _(proc { CloudstackClient::Connection.new(nil, "k", "s") })
+        .must_raise CloudstackClient::InputError
+    end
+
+    it "raises when the API key is missing" do
+      _(proc { CloudstackClient::Connection.new("http://url", nil, "s") })
+        .must_raise CloudstackClient::InputError
+    end
+
+    it "raises when the secret key is missing" do
+      _(proc { CloudstackClient::Connection.new("http://url", "k", nil) })
+        .must_raise CloudstackClient::InputError
+    end
+
+    it "raises when the async poll interval is below 1 second" do
+      error = _(proc {
+        CloudstackClient::Connection.new("http://url", "k", "s", async_poll_interval: 0.5)
+      }).must_raise CloudstackClient::InputError
+      _(error.message).must_match(/POLL INTERVAL/)
+    end
+
+    it "raises when the async timeout is below 60 seconds" do
+      error = _(proc {
+        CloudstackClient::Connection.new("http://url", "k", "s", async_timeout: 30)
+      }).must_raise CloudstackClient::InputError
+      _(error.message).must_match(/ASYNC TIMEOUT/)
+    end
+
+    it "raises when request retries is below 1" do
+      error = _(proc {
+        CloudstackClient::Connection.new("http://url", "k", "s", request_retries: 0)
+      }).must_raise CloudstackClient::InputError
+      _(error.message).must_match(/REQUEST RETRIES/)
+    end
+
+    it "applies the documented defaults" do
+      _(connection.read_timeout).must_equal CloudstackClient::Connection::DEF_REQ_TIMEOUT
+      _(connection.async_timeout).must_equal CloudstackClient::Connection::DEF_ASYNC_TIMEOUT
+      _(connection.async_poll_interval).must_equal CloudstackClient::Connection::DEF_POLL_INTERVAL
+      _(connection.request_retries).must_equal CloudstackClient::Connection::DEF_REQUEST_RETRIES
+      _(connection.verify_ssl).must_equal true
+      _(connection).wont_respond_to :secret_key=
+    end
+
+    it "allows SSL verification to be disabled explicitly" do
+      configured = CloudstackClient::Connection.new(
+        TestHelpers::TEST_URL,
+        TestHelpers::TEST_KEY,
+        TestHelpers::TEST_SECRET,
+        verify_ssl: false,
+        ca_file: "/tmp/cloudstack-ca.pem"
+      )
+
+      _(configured.verify_ssl).must_equal false
+      _(configured.ca_file).must_equal "/tmp/cloudstack-ca.pem"
+    end
+  end
+
+  describe "request signing" do
+    # Golden value: HMAC-SHA1 of the downcased payload, Base64 encoded and then
+    # URL escaped. Pinned so a change to the signing algorithm fails loudly.
+    it "signs the downcased payload with HMAC-SHA1" do
+      expected = CGI.escape(
+        Base64.encode64(
+          OpenSSL::HMAC.digest("sha1", TestHelpers::TEST_SECRET, "apikey=test-key&command=listzones")
+        ).chomp
+      )
+
+      _(connection.send(:create_signature, "apiKey=test-key&command=listZones"))
+        .must_equal expected
+    end
+
+    it "is case insensitive, because the payload is downcased before signing" do
+      _(connection.send(:create_signature, "command=listZones"))
+        .must_equal connection.send(:create_signature, "COMMAND=LISTZONES")
+    end
+
+    it "sends the signature and apiKey with the request" do
+      stub_list("listZones", "zone", [{ "id" => "1" }])
+      connection.send_request("command" => "listZones")
+
+      params = last_request_params
+      _(params["apiKey"].first).must_equal TestHelpers::TEST_KEY
+      _(params["response"].first).must_equal "json"
+      _(params["signature"].first).wont_be_nil
+    end
+  end
+
+  describe "parameter serialization" do
+    it "sorts parameters, since the signature depends on their order" do
+      _(connection.send(:params_to_data, "z" => "1", "a" => "2", "m" => "3"))
+        .must_equal "a=2&m=3&z=1"
+    end
+
+    it "serializes an Array of Hashes as an indexed map" do
+      data = connection.send(:params_to_data,
+        "tags" => [{ "key" => "role", "value" => "web" }])
+
+      _(data).must_equal "tags[0].key=role&tags[0].value=web"
+    end
+
+    it "serializes a Hash as an indexed key/value map" do
+      data = connection.send(:params_to_data, "details" => { "cpu" => "2" })
+
+      _(data).must_equal "details[0].key=cpu&details[0].value=2"
+    end
+
+    it "escapes spaces as %20 rather than +" do
+      _(connection.send(:escape, "my machine")).must_equal "my%20machine"
+    end
+
+    it "leaves asterisks unescaped" do
+      _(connection.send(:escape, "*")).must_equal "*"
+    end
+
+    it "escapes reserved characters" do
+      _(connection.send(:escape, "a&b=c")).must_equal "a%26b%3Dc"
+    end
+  end
+
+  describe "response unwrapping" do
+    it "returns the collection from a count plus collection response" do
+      stub_list("listZones", "zone", [{ "id" => "1" }, { "id" => "2" }])
+
+      _(connection.send_request("command" => "listZones"))
+        .must_equal [{ "id" => "1" }, { "id" => "2" }]
+    end
+
+    it "keeps the count when include_count is requested" do
+      stub_list("listZones", "zone", [{ "id" => "1" }])
+
+      result = connection.send_request({ "command" => "listZones" }, include_count: true)
+      _(result["count"]).must_equal 1
+      _(result["zone"]).must_equal [{ "id" => "1" }]
+    end
+
+    it "returns an empty Array for a zero count response" do
+      stub_command("listZones", { "listzonesresponse" => { "count" => 0 } })
+
+      _(connection.send_request("command" => "listZones")).must_equal []
+    end
+
+    it "unwraps a single nested Hash" do
+      stub_command("createUser", { "createuserresponse" => { "user" => { "id" => "42" } } })
+
+      _(connection.send_request("command" => "createUser")).must_equal("id" => "42")
+    end
+
+    it "returns a scalar-valued body unchanged" do
+      stub_command("someCommand", { "somecommandresponse" => { "jobid" => "job-9" } })
+
+      _(connection.send_request("command" => "someCommand")).must_equal("jobid" => "job-9")
+    end
+
+    it "returns an empty body as an empty Array" do
+      stub_command("listZones", { "listzonesresponse" => {} })
+
+      _(connection.send_request("command" => "listZones")).must_equal []
+    end
+  end
+
+  describe "symbolized keys" do
+    let(:connection) do
+      CloudstackClient::Connection.new(
+        TestHelpers::TEST_URL, TestHelpers::TEST_KEY, TestHelpers::TEST_SECRET,
+        quiet: true, symbolize_keys: true
+      )
+    end
+
+    it "returns Symbol keys throughout the response" do
+      stub_list("listZones", "zone", [{ "id" => "1", "name" => "zone1" }])
+
+      _(connection.send_request("command" => "listZones"))
+        .must_equal [{ id: "1", name: "zone1" }]
+    end
+
+    it "still strips the count key when it is symbolized" do
+      stub_list("listZones", "zone", [{ "id" => "1" }])
+      result = connection.send_request("command" => "listZones")
+
+      _(result).must_equal [{ id: "1" }]
+    end
+  end
+
+  describe "error handling" do
+    it "raises ApiError with the errortext for a non-200 response" do
+      stub_command("listZones",
+        { "listzonesresponse" => { "errortext" => "Unable to execute" } },
+        status: 431)
+
+      error = _(proc { connection.send_request("command" => "listZones") })
+        .must_raise CloudstackClient::ApiError
+      _(error.message).must_match(/431/)
+      _(error.message).must_match(/Unable to execute/)
+    end
+
+    it "raises ParseError when the body is not JSON" do
+      stub_request(:get, ApiStubs::ANY_REQUEST).to_return(status: 200, body: "<html>oops</html>")
+
+      error = _(proc { connection.send_request("command" => "listZones") })
+        .must_raise CloudstackClient::ParseError
+      _(error.message).must_match(/not readable/)
+    end
+
+    it "raises ConnectionError when the endpoint is unreachable" do
+      stub_request(:get, ApiStubs::ANY_REQUEST).to_raise(Errno::ECONNREFUSED)
+
+      error = _(proc { connection.send_request("command" => "listZones") })
+        .must_raise CloudstackClient::ConnectionError
+      _(error.message).must_match(/is not reachable/)
+    end
+  end
+
+  describe "retries" do
+    it "makes exactly one attempt with the default retry setting" do
+      stub_request(:get, ApiStubs::ANY_REQUEST).to_raise(Errno::ECONNREFUSED)
+
+      error = _(proc { connection.send_request("command" => "listZones") })
+        .must_raise CloudstackClient::ConnectionError
+      _(error.message).must_match(/after 1 attempt/)
+      assert_requested(:get, ApiStubs::ANY_REQUEST, times: 1)
+    end
+
+    it "retries up to request_retries attempts before giving up" do
+      connection = CloudstackClient::Connection.new(
+        TestHelpers::TEST_URL, TestHelpers::TEST_KEY, TestHelpers::TEST_SECRET,
+        quiet: true, request_retries: 3
+      )
+      stub_request(:get, ApiStubs::ANY_REQUEST).to_raise(Errno::ECONNREFUSED)
+
+      error = connection.stub(:sleep, nil) do
+        _(proc { connection.send_request("command" => "listZones") })
+          .must_raise CloudstackClient::ConnectionError
+      end
+
+      _(error.message).must_match(/after 3 attempts/)
+      assert_requested(:get, ApiStubs::ANY_REQUEST, times: 3)
+    end
+
+    it "returns the result when a retry succeeds" do
+      connection = CloudstackClient::Connection.new(
+        TestHelpers::TEST_URL, TestHelpers::TEST_KEY, TestHelpers::TEST_SECRET,
+        quiet: true, request_retries: 3
+      )
+      stub_request(:get, ApiStubs::ANY_REQUEST)
+        .to_raise(Errno::ECONNREFUSED)
+        .then.to_return(
+          status: 200,
+          body: JSON.generate("listzonesresponse" => { "count" => 1, "zone" => [{ "id" => "1" }] })
+        )
+
+      result = connection.stub(:sleep, nil) do
+        connection.send_request("command" => "listZones")
+      end
+
+      _(result).must_equal [{ "id" => "1" }]
+    end
+  end
+
+  describe "asynchronous requests" do
+    it "returns the jobresult once the job succeeds" do
+      stub_async("deployVirtualMachine",
+        polls: [job_success("virtualmachine" => { "id" => "vm-1" })])
+
+      result = connection.stub(:sleep, nil) do
+        connection.send_async_request("command" => "deployVirtualMachine")
+      end
+
+      _(result).must_equal("virtualmachine" => { "id" => "vm-1" })
+    end
+
+    it "polls until the job leaves the pending state" do
+      stub_async("deployVirtualMachine",
+        polls: [job_pending, job_pending, job_success("id" => "vm-1")])
+
+      result = connection.stub(:sleep, nil) do
+        connection.send_async_request("command" => "deployVirtualMachine")
+      end
+
+      _(result).must_equal("id" => "vm-1")
+    end
+
+    it "raises JobError when the job fails" do
+      stub_async("deployVirtualMachine",
+        polls: [job_failure("Insufficient capacity")])
+
+      error = connection.stub(:sleep, nil) do
+        _(proc { connection.send_async_request("command" => "deployVirtualMachine") })
+          .must_raise CloudstackClient::JobError
+      end
+
+      _(error.message).must_match(/Insufficient capacity/)
+      _(error.message).must_match(/530/)
+    end
+
+    it "raises JobError when a failed job has no error text" do
+      stub_async(
+        "deployVirtualMachine",
+        polls: [{ "jobstatus" => 2, "jobresultcode" => 530 }]
+      )
+
+      error = connection.stub(:sleep, nil) do
+        _(proc { connection.send_async_request("command" => "deployVirtualMachine") })
+          .must_raise CloudstackClient::JobError
+      end
+
+      _(error.message).must_match(/Unknown error/)
+    end
+
+    it "raises TimeoutError when the job never completes" do
+      stub_async("deployVirtualMachine", polls: [job_pending])
+
+      error = connection.stub(:sleep, nil) do
+        _(proc { connection.send_async_request("command" => "deployVirtualMachine") })
+          .must_raise CloudstackClient::TimeoutError
+      end
+
+      _(error.message).must_match(/timed out/)
+    end
+
+    it "rejects per-request async options that are out of range" do
+      _(proc {
+        connection.send_async_request({ "command" => "x" }, async_timeout: 5)
+      }).must_raise CloudstackClient::InputError
+    end
+  end
+
+  describe "the host option" do
+    it "sets the Host header when a host is given" do
+      connection = CloudstackClient::Connection.new(
+        TestHelpers::TEST_URL, TestHelpers::TEST_KEY, TestHelpers::TEST_SECRET,
+        quiet: true, host: "cloudstack.internal"
+      )
+      stub_list("listZones", "zone", [{ "id" => "1" }])
+
+      connection.send_request("command" => "listZones")
+
+      assert_requested(:get, ApiStubs::ANY_REQUEST,
+        headers: { "Host" => "cloudstack.internal" }, times: 1)
+    end
+
+    it "omits the Host header when no host is given" do
+      stub_list("listZones", "zone", [{ "id" => "1" }])
+      connection.send_request("command" => "listZones")
+
+      signature = WebMock::RequestRegistry.instance.requested_signatures.hash.keys.last
+      _(signature.headers.to_h.keys.map(&:downcase)).wont_include "host"
+    end
+  end
+end

data/test/data/cloudstack-empty.yml

@@ -0,0 +1,3 @@
+:url: ""
+:api_key: test-key
+:secret_key: test-secret

data/test/data/cloudstack-incomplete.yml

@@ -0,0 +1,5 @@
+---
+:default: test1
+test1:
+  :url: https://cloud.test/client/api
+  :api_key: only-an-api-key-no-secret

data/test/data/cloudstack-malformed.yml

@@ -0,0 +1,5 @@
+---
+:default: test1
+test1:
+  :url: "unterminated
+   :api_key: [1, 2

data/test/data/cloudstack-unsafe.yml

@@ -0,0 +1 @@
+--- !ruby/object:Object {}