vsphere-automation-cis 0.4.4 → 0.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a560919df237bef0b0269629ba0aaf799e81622e6c9ba5e2acb2b79b93bd135
-  data.tar.gz: 6afb9f00cbcfa503dbac0eb254e1c666447ae500cc7e76dfb8f241a087c4ed36
+  metadata.gz: 533db8a6fd9eb28f9b59c27da8c5328d8179489957ee2622042d9e844d2781bd
+  data.tar.gz: 5b2598fe24471e61687e88a16a5e8f86fe972911038c4ba8ac2dd14d4e326455
 SHA512:
-  metadata.gz: 9a7fff1bc8c1cc3aa8a062a1358c9c3d67070a63170a1ac0dde791a9e4a015a0c9ae089d3f97c0d261b6632833b988e6ceb70ccc62569c986c92370731615b17
-  data.tar.gz: 72f9a124615192f7c0921c53f8f0cee596690189188fe61feade7558b3f616d957466f44ac49feedf3e71c2c9a090152a8f58cd971fd304604d4c594f81e791a
+  metadata.gz: 7e7c75382d72a550f962aacac76908dcfc0524125b82f1a01b3a5d89e94334ede7137637b261ca12427bd9d2d42141de5035c9a968c3372e6b5898334384b37b
+  data.tar.gz: b0652700c6c38b17987ea0c58154cbf39759966ecd87aa1e1cbde6977fc18d47486b497364a556d6b9b20c1e6116c6396ba6730361862af1d14e15fba490cbfe

data/Gemfile.lock

@@ -1,13 +1,13 @@
 PATH
   remote: ../runtime
   specs:
-    vsphere-automation-runtime (0.4.4)
+    vsphere-automation-runtime (0.4.5)
 
 PATH
   remote: .
   specs:
-    vsphere-automation-cis (0.4.4)
-      vsphere-automation-runtime (~> 0.4.4)
+    vsphere-automation-cis (0.4.5)
+      vsphere-automation-runtime (~> 0.4.5)
 
 GEM
   remote: https://rubygems.org/
@@ -22,7 +22,7 @@ GEM
     hashdiff (1.0.0)
     jaro_winkler (1.5.3)
     method_source (0.9.2)
-    parallel (1.17.0)
+    parallel (1.18.0)
     parser (2.6.5.0)
       ast (~> 2.4.0)
     pry (0.12.2)
@@ -31,19 +31,19 @@ GEM
     public_suffix (4.0.1)
     rainbow (3.0.0)
     rake (12.3.3)
-    rspec (3.8.0)
-      rspec-core (~> 3.8.0)
-      rspec-expectations (~> 3.8.0)
-      rspec-mocks (~> 3.8.0)
-    rspec-core (3.8.2)
-      rspec-support (~> 3.8.0)
-    rspec-expectations (3.8.5)
+    rspec (3.9.0)
+      rspec-core (~> 3.9.0)
+      rspec-expectations (~> 3.9.0)
+      rspec-mocks (~> 3.9.0)
+    rspec-core (3.9.0)
+      rspec-support (~> 3.9.0)
+    rspec-expectations (3.9.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-mocks (3.8.2)
+      rspec-support (~> 3.9.0)
+    rspec-mocks (3.9.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-support (3.8.3)
+      rspec-support (~> 3.9.0)
+    rspec-support (3.9.0)
     rubocop (0.73.0)
       jaro_winkler (~> 1.5.1)
       parallel (~> 1.10)

data/README.md

@@ -3,7 +3,7 @@
 The Ruby gem for the vSphere CIS API
 
 - API version: 2.0.0
-- Package version: 0.4.4
+- Package version: 0.4.5
 
 ## Installation
 

data/lib/vsphere-automation-cis/api_client.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'logger'
+require 'net/http'
+require 'openssl'
+require 'uri'
+require 'vsphere-automation-runtime/configuration'
+require 'vsphere-automation-runtime/version'
+
+module VSphereAutomation
+  # The client responsible for communicating with the API.
+  class ApiClient
+    # The Configuration object holding settings to be used in the API client.
+    attr_accessor :config
+
+    # Defines the headers to be used in HTTP requests of all API calls by
+    # default.
+    #
+    # @return [Hash]
+    attr_reader :default_headers
+
+    # Creates a new instance
+    #
+    # @param config [Configuration] configuration object with values to use
+    def initialize(config = Configuration.default)
+      @config = config
+      @http = create_http
+      @user_agent = default_user_agent
+      @default_headers = { 'Content-Type' => 'application/json',
+                           'User-Agent' => @user_agent }
+    end
+
+    # Retrieves an instance of the object in it's default state
+    #
+    # @return [ApiClient] an instance of the object in it's default state
+    def self.default
+      DEFAULT
+    end
+
+    # Build the collection of parameters
+    def build_collection_param(params, format)
+      params
+    end
+
+    # Make a request to an API endpoint with the given options
+    #
+    # @param http_method [Symbol] the HTTP method to be used
+    # @param path [String] the path request will be made to
+    # @param opts [Hash] any additional options needed
+    # @return [Array<(Object, Fixnum, Hash)>] the deserialized body, status
+    #   code, and headers.
+    def call_api(http_method, path, opts = {})
+      query_params = opts.fetch(:query_params, {})
+      header_params = opts.fetch(:header_params, {})
+      form_params = opts.fetch(:form_params, {})
+      add_auth(query_params, header_params, opts.fetch(:auth_names, []))
+
+      uri = build_request_uri(path, query_params)
+      request = Net::HTTP.const_get(http_method.capitalize).new(uri)
+
+      add_form_params(request, form_params)
+      add_header_params(request, header_params)
+      request.body = opts[:body] if opts[:body]
+      request.content_type = request['Content-Type'] if request['Content-Type']
+
+      if @config.debugging
+        @config.logger.debug("Request Body:\n#{request.body}\n")
+      end
+
+      response = @http.request(request)
+      @cookie = cookie_from_response(response)
+      api_key_from_response(response)
+
+      return_type = opts.fetch(:return_type, {}).fetch(response.code, nil)
+      data = deserialize(response, return_type)
+      [data, Integer(response.code), response.each_header.to_h]
+    end
+
+    # Takes an object and returns the object as an HTTP body
+    #
+    # @param object [Object] object to transform
+    # @return [String] object as JSON string
+    def object_to_http_body(object)
+      return object.map { |o| object_to_http_body(o) } if object.is_a?(Array)
+
+      return object unless object.respond_to?(:to_hash)
+
+      object.to_hash.to_json
+    end
+
+    # Select an Accept header to use
+    #
+    # @param types [Array] a list of suggested types
+    # @return [String] the Accept header value
+    def select_header_accept(types)
+      return DEFAULT_MIME_TYPE unless types.is_a?(Array)
+
+      types.find { |t| t.include?('json') } || types.join(', ')
+    end
+
+    # Select an Content-Type header to use
+    #
+    # @param types [Array] a list of suggested types
+    # @return [String] the Content-Type header value
+    def select_header_content_type(types)
+      return DEFAULT_MIME_TYPE unless types.is_a?(Array)
+
+      types.find { |t| t.include?('json') } || types.first
+    end
+
+    private
+
+    def add_auth(query_params, header_params, auth_names)
+      auth_names.map do |name|
+        settings = @config.auth_settings.fetch(name, {})
+        case settings[:in]
+        when 'header'
+          header_params[settings[:key]] = settings[:value]
+          api_key_from_cookie(settings) unless settings[:value]
+        when 'query'
+          query_params[settings[:key]] = settings[:value]
+        end
+      end
+    end
+
+    def add_form_params(request, form_params)
+      request.set_form_data(form_params) unless form_params.empty?
+    end
+
+    def add_header_params(request, headers)
+      header_params = @default_headers.merge(headers)
+      header_params.merge!(Hash(@cookie))
+      header_params.map { |name, value| request[name] = value }
+    end
+
+    def add_query_params(uri, query_params)
+      uri.query = URI.encode_www_form(query_params)
+    end
+
+    def build_request_uri(path = '', query_params = {})
+      path = "/#{path}".gsub(%r{/+}, '/')
+      uri = URI.parse(@config.base_url + path)
+      add_query_params(uri, query_params)
+      forced_query_params = path.split('?')[1]
+      return URI.join(uri, '?' + forced_query_params) if forced_query_params
+
+      uri
+    end
+
+    def create_http
+      uri = build_request_uri
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = @config.scheme == 'https'
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE unless @config.verify_ssl_host
+      http.read_timeout = @config.timeout
+      http
+    end
+
+    # The default user agent
+    #
+    # @return [String] the default user agent
+    def default_user_agent
+      "SDK/#{VSphereAutomation::Runtime::VERSION} "\
+      "Ruby/#{RUBY_VERSION} "\
+      "(#{Gem::Platform.local.os}; "\
+      "#{Gem::Platform.local.version}; "\
+      "#{Gem::Platform.local.cpu})"
+    end
+
+    # Deserialize the response to the given return type
+    #
+    # @param [Response] response the HTTP response
+    # @param [String] return_type the type to return
+    # @return [Object] the response represented as the return type
+    def deserialize(response, return_type)
+      body = response.body
+
+      return nil if body.nil? || body.empty? || return_type.nil?
+
+      begin
+        data = JSON.parse("[#{body}]", symbolize_names: true).first
+      rescue JSON::ParserError => e
+        raise e unless %w[String Date DateTime].include?(return_type)
+
+        data = body
+      end
+
+      convert_to_type(data, return_type)
+    end
+
+    def convert_to_type(data, return_type)
+      return nil if data.nil?
+      case return_type
+      when 'String'
+        data.to_s
+      when 'Integer'
+        data.to_i
+      when 'Float'
+        data.to_f
+      when 'BOOLEAN'
+        data == true
+      when 'DateTime'
+        # parse date time (expecting ISO 8601 format)
+        DateTime.parse data
+      when 'Date'
+        # parse date time (expecting ISO 8601 format)
+        Date.parse data
+      when 'Object'
+        # generic object (usually a Hash), return directly
+        data
+      when /\AArray<(.+)>\z/
+        # e.g. Array<Pet>
+        sub_type = $1
+        data.map { |item| convert_to_type(item, sub_type) }
+      when /\AHash\<String, (.+)\>\z/
+        # e.g. Hash<String, Integer>
+        sub_type = $1
+        {}.tap do |hash|
+          data.each { |k, v| hash[k] = convert_to_type(v, sub_type) }
+        end
+      else
+        # models, e.g. Pet
+        VSphereAutomation.const_get(return_type).new.tap do |model|
+          model.build_from_hash data
+        end
+      end
+    end
+
+    # Create the Cookie header from a response
+    #
+    # @param response [Net::HTTPResponse] the response
+    # @return [Hash, nil] the Cookie header
+    def cookie_from_response(response)
+      { 'Cookie' => response['set-cookie'] } if response['set-cookie']
+    end
+
+    def api_key_from_response(response)
+      key = @config.auth_settings['api_key'][:key]
+      @config.api_key[key] = response[key] if response[key]
+    end
+
+    def api_key_from_cookie(auth)
+      return if @cookie.nil?
+
+      regex = /(?<key>#{auth[:key]})=(?<value>\w+)/
+      matches = Hash(@cookie)['Cookie'].match(regex)
+      key = @config.auth_settings['api_key'][:key]
+      @config.api_key[key] = matches[:value] if matches
+    end
+
+    # An instance of the object in it's default state
+    DEFAULT = new
+
+    # The default MIME type for Content-Type and Accept headers
+    DEFAULT_MIME_TYPE = 'application/json'
+
+    private_constant :DEFAULT, :DEFAULT_MIME_TYPE
+  end
+end

data/lib/vsphere-automation-cis/api_error.rb

@@ -0,0 +1,34 @@
+# Copyright (c) 2018-2019 VMware, Inc.  All Rights Reserved.
+# SPDX-License-Identifier: MIT
+
+# DO NOT MODIFY. THIS CODE IS GENERATED. CHANGES WILL BE OVERWRITTEN.
+
+# cis - No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+
+module VSphereAutomation
+  class ApiError < StandardError
+    attr_reader :code, :response_headers, :response_body
+
+    # Usage examples:
+    #   ApiError.new
+    #   ApiError.new("message")
+    #   ApiError.new(:code => 500, :response_headers => {}, :response_body => "")
+    #   ApiError.new(:code => 404, :message => "Not Found")
+    def initialize(arg = nil)
+      if arg.is_a? Hash
+        if arg.key?(:message) || arg.key?('message')
+          super(arg[:message] || arg['message'])
+        else
+          super arg
+        end
+
+        arg.each do |k, v|
+          instance_variable_set "@#{k}", v
+        end
+      else
+        super arg
+      end
+    end
+  end
+end

data/lib/vsphere-automation-cis/configuration.rb

@@ -0,0 +1,212 @@
+# Copyright (c) 2018-2019 VMware, Inc.  All Rights Reserved.
+# SPDX-License-Identifier: MIT
+
+# DO NOT MODIFY. THIS CODE IS GENERATED. CHANGES WILL BE OVERWRITTEN.
+
+# cis - No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+
+require 'uri'
+
+module VSphereAutomation
+  class Configuration
+    # Defines url scheme
+    attr_accessor :scheme
+
+    # Defines url host
+    attr_accessor :host
+
+    # Defines url base path
+    attr_accessor :base_path
+
+    # Defines API keys used with API Key authentications.
+    #
+    # @return [Hash] key: parameter name, value: parameter value (API key)
+    #
+    # @example parameter name is "api_key", API key is "xxx" (e.g. "api_key=xxx" in query string)
+    #   config.api_key['api_key'] = 'xxx'
+    attr_accessor :api_key
+
+    # Defines API key prefixes used with API Key authentications.
+    #
+    # @return [Hash] key: parameter name, value: API key prefix
+    #
+    # @example parameter name is "Authorization", API key prefix is "Token" (e.g. "Authorization: Token xxx" in headers)
+    #   config.api_key_prefix['api_key'] = 'Token'
+    attr_accessor :api_key_prefix
+
+    # Defines the username used with HTTP basic authentication.
+    #
+    # @return [String]
+    attr_accessor :username
+
+    # Defines the password used with HTTP basic authentication.
+    #
+    # @return [String]
+    attr_accessor :password
+
+    # Defines the access token (Bearer) used with OAuth2.
+    attr_accessor :access_token
+
+    # Set this to enable/disable debugging. When enabled (set to true), HTTP request/response
+    # details will be logged with `logger.debug` (see the `logger` attribute).
+    # Default to false.
+    #
+    # @return [true, false]
+    attr_accessor :debugging
+
+    # Defines the logger used for debugging.
+    # Default to `Rails.logger` (when in Rails) or logging to STDOUT.
+    #
+    # @return [#debug]
+    attr_accessor :logger
+
+    # Defines the temporary folder to store downloaded files
+    # (for API endpoints that have file response).
+    # Default to use `Tempfile`.
+    #
+    # @return [String]
+    attr_accessor :temp_folder_path
+
+    # The time limit for HTTP request in seconds.
+    # Default to 0 (never times out).
+    attr_accessor :timeout
+
+    # Set this to false to skip client side validation in the operation.
+    # Default to true.
+    # @return [true, false]
+    attr_accessor :client_side_validation
+
+    ### TLS/SSL setting
+    # Set this to false to skip verifying SSL certificate when calling API from https server.
+    # Default to true.
+    #
+    # @note Do NOT set it to false in production code, otherwise you would face multiple types of cryptographic attacks.
+    #
+    # @return [true, false]
+    attr_accessor :verify_ssl
+
+    ### TLS/SSL setting
+    # Set this to false to skip verifying SSL host name
+    # Default to true.
+    #
+    # @note Do NOT set it to false in production code, otherwise you would face multiple types of cryptographic attacks.
+    #
+    # @return [true, false]
+    attr_accessor :verify_ssl_host
+
+    ### TLS/SSL setting
+    # Set this to customize the certificate file to verify the peer.
+    #
+    # @return [String] the path to the certificate file
+    #
+    # @see The `cainfo` option of Typhoeus, `--cert` option of libcurl. Related source code:
+    # https://github.com/typhoeus/typhoeus/blob/master/lib/typhoeus/easy_factory.rb#L145
+    attr_accessor :ssl_ca_cert
+
+    ### TLS/SSL setting
+    # Client certificate file (for client certificate)
+    attr_accessor :cert_file
+
+    ### TLS/SSL setting
+    # Client private key file (for client certificate)
+    attr_accessor :key_file
+
+    # Set this to customize parameters encoding of array parameter with multi collectionFormat.
+    # Default to nil.
+    #
+    # @see The params_encoding option of Ethon. Related source code:
+    # https://github.com/typhoeus/ethon/blob/master/lib/ethon/easy/queryable.rb#L96
+    attr_accessor :params_encoding
+
+    attr_accessor :inject_format
+
+    attr_accessor :force_ending_format
+
+    def initialize
+      @scheme = 'https'
+      @host = '<vcenter>'
+      @base_path = '/rest'
+      @api_key = {}
+      @api_key_prefix = {}
+      @timeout = nil
+      @client_side_validation = true
+      @verify_ssl = true
+      @verify_ssl_host = true
+      @params_encoding = :multi
+      @cert_file = nil
+      @key_file = nil
+      @debugging = false
+      @inject_format = false
+      @force_ending_format = false
+      @logger = defined?(Rails) ? Rails.logger : Logger.new(STDOUT)
+
+      yield(self) if block_given?
+    end
+
+    # The default Configuration object.
+    def self.default
+      @@default ||= Configuration.new
+    end
+
+    def configure
+      yield(self) if block_given?
+    end
+
+    def scheme=(scheme)
+      # remove :// from scheme
+      @scheme = scheme.sub(/:\/\//, '')
+    end
+
+    def host=(host)
+      # remove http(s):// and anything after a slash
+      @host = host.sub(/https?:\/\//, '').split('/').first
+    end
+
+    def base_path=(base_path)
+      # Add leading and trailing slashes to base_path
+      @base_path = "/#{base_path}".gsub(/\/+/, '/')
+      @base_path = '' if @base_path == '/'
+    end
+
+    def base_url
+      url = "#{scheme}://#{[host, base_path].join('/').gsub(/\/+/, '/')}".sub(/\/+\z/, '')
+      URI.encode(url)
+    end
+
+    # Gets API key (with prefix if set).
+    # @param [String] param_name the parameter name of API key auth
+    def api_key_with_prefix(param_name)
+      if @api_key_prefix[param_name]
+        "#{@api_key_prefix[param_name]} #{@api_key[param_name]}"
+      else
+        @api_key[param_name]
+      end
+    end
+
+    # Gets Basic Auth token string
+    def basic_auth_token
+      'Basic ' + ["#{username}:#{password}"].pack('m').delete("\r\n")
+    end
+
+    # Returns Auth Settings hash for api client.
+    def auth_settings
+      {
+        'api_key' =>
+          {
+            type: 'api_key',
+            in: 'header',
+            key: 'vmware-api-session-id',
+            value: api_key_with_prefix('vmware-api-session-id')
+          },
+        'basic_auth' =>
+          {
+            type: 'basic',
+            in: 'header',
+            key: 'Authorization',
+            value: basic_auth_token
+          },
+      }
+    end
+  end
+end

data/lib/vsphere-automation-cis/version.rb

@@ -8,6 +8,6 @@
 
 module VSphereAutomation
   module CIS
-    VERSION = '0.4.4'
+    VERSION = '0.4.5'
   end
 end

data/spec/api_client_spec.rb

@@ -0,0 +1,248 @@
+require 'spec_helper'
+
+describe VSphereAutomation::ApiClient do
+  describe '.default' do
+    it 'returns the same instance every time' do
+      first_instance  = VSphereAutomation::ApiClient.default
+      second_instance = VSphereAutomation::ApiClient.default
+      third_instance  = VSphereAutomation::ApiClient.default
+      expect(first_instance).to be(second_instance)
+      expect(first_instance).to be(third_instance)
+    end
+  end
+
+  describe '#build_collection_param' do
+    context 'when called with format :multi' do
+      it 'returns the collection' do
+        params = { foo: 'bar', baz: 'quux' }
+        expect(subject.build_collection_param(params, :multi)).to eq(params)
+      end
+    end
+  end
+
+  describe '#call_api' do
+    let(:host) { 'example.com' }
+    let(:config) do
+      VSphereAutomation::Configuration.new.tap do |c|
+        c.scheme = 'https'
+        c.host = host
+      end
+    end
+    let(:url) { 'https://example.com/rest/test' }
+    subject { VSphereAutomation::ApiClient.new(config) }
+
+    it 'adds headers to request' do
+      headers = { 'foo' => 'bar' }
+      stub_request(:get, url).with(headers: headers)
+
+      subject.call_api(:GET, '/test', header_params: headers)
+
+      expect(a_request(:get, url).with(headers: headers)).to have_been_made
+    end
+
+    it 'adds query parameters to request' do
+      query_params = { 'foo' => 'bar' }
+      stub_request(:get, url).with(query: query_params)
+
+      subject.call_api(:GET, '/test', query_params: query_params)
+
+      expect(a_request(:get, url).with(query: query_params)).to have_been_made
+    end
+
+    it 'keeps query parameters from the path to request' do
+      # The specs have some paths that contain query parameters already. This
+      # test is to make sure they don't get overwritten.
+      key = '~foo'
+      value = 'bar'
+      query_params = { key => value }
+      stub_request(:post, url).with(query: query_params)
+
+      subject.call_api(:POST, "/test?#{key}=#{value}")
+
+      expect(a_request(:post, url).with(query: query_params)).to have_been_made
+    end
+
+    it 'adds form parameters to the request body' do
+      form_params = { 'foo' => 'bar' }
+      body = form_params.to_a.map { |e| e.join('=') }.join('&')
+      stub_request(:get, url).with(body: body)
+
+      subject.call_api(:GET, '/test', form_params: form_params)
+
+      expect(a_request(:get, url).with(body: body)).to have_been_made
+    end
+
+    it 'uses basic auth information from configuration' do
+      auth_name = 'basic_auth'
+      auth_header = { config.auth_settings[auth_name][:key] =>
+                      config.auth_settings[auth_name][:value] }
+      stub_request(:get, url).with(headers: auth_header)
+
+      subject.call_api(:GET, '/test', auth_names: [auth_name])
+
+      expect(a_request(:get, url)
+               .with(headers: auth_header)).to have_been_made
+    end
+
+    it 'use API key information from configuration' do
+      auth_name = 'api_key'
+      config.api_key[config.auth_settings[auth_name][:key]] = 'foo'
+      auth_header = { config.auth_settings[auth_name][:key] =>
+                      config.auth_settings[auth_name][:value] }
+      stub_request(:get, url).with(headers: auth_header)
+
+      subject.call_api(:GET, '/test', auth_names: [auth_name])
+
+      expect(a_request(:get, url)
+               .with(headers: auth_header)).to have_been_made
+    end
+
+    it 'updates api_key from responses with set-cookie header' do
+      key = config.auth_settings['api_key'][:key]
+      value = 'foo'
+      cookie = "#{key}=#{value};Path=/rest;Secure;HttpOnly"
+      set_cookie_header = { 'set-cookie' => cookie }
+      stub_request(:get, url + '1').to_return(headers: set_cookie_header)
+      stub_request(:get, url + '2')
+
+      subject.call_api(:GET, '/test1')
+      subject.call_api(:GET, '/test2', auth_names: ['api_key'])
+
+      expect(a_request(:get, url + '1')).to have_been_made
+      expect(a_request(:get, url + '2')).to have_been_made
+      expect(subject.config.api_key[key]).to eq(value)
+    end
+
+    it 'updates api_key from responses with api_key header' do
+      key = config.auth_settings['api_key'][:key]
+      value = 'foo'
+      auth_header = { key => value }
+
+      stub_request(:get, url + '1').to_return(headers: auth_header)
+      stub_request(:get, url + '2').with(headers: auth_header)
+
+      subject.call_api(:GET, '/test1')
+      subject.call_api(:GET, '/test2', auth_names: ['api_key'])
+
+      expect(a_request(:get, url + '1')).to have_been_made
+      expect(a_request(:get, url + '2')
+               .with(headers: auth_header)).to have_been_made
+    end
+
+    it 'adds the body to requests when available' do
+      body = { foo: 'bar' }.to_json
+      stub_request(:post, url).with(body: body)
+
+      subject.call_api(:POST, '/test', body: body)
+
+      expect(a_request(:post, url).with(body: body)).to have_been_made
+    end
+
+    it 'sets the Content-Type on requests when available' do
+      content_type = { 'Content-Type' => 'application/json' }
+      body = { foo: 'bar' }.to_json
+
+      stub_request(:post, url).with(body: body, headers: content_type)
+
+      subject.call_api(:POST, '/test', body: body, header_params: content_type)
+
+      expect(a_request(:post, url)
+               .with(body: body, headers: content_type)).to have_been_made
+    end
+  end
+
+  describe '#object_to_http_body' do
+    context 'when given nil' do
+      it 'returns the object as is' do
+        expect(subject.object_to_http_body(nil)).to be_nil
+      end
+    end
+
+    context 'when given a string' do
+      it 'returns the object as is' do
+        expect(subject.object_to_http_body('asdf')).to eq('asdf')
+      end
+    end
+
+    context 'when given an object that responds to `to_hash`' do
+      it 'returns that object as JSON' do
+        obj = OpenStruct.new(foo: 'bar', baz: 'quux')
+        obj.to_hash = obj.to_h
+        json = obj.to_hash.to_json
+
+        expect(subject.object_to_http_body(obj)).to eq(json)
+      end
+    end
+
+    context 'when given an array' do
+      it 'returns a JSON array of objects' do
+        obj = OpenStruct.new(foo: 'bar', baz: 'quux')
+        obj.to_hash = obj.to_h
+        json = obj.to_hash.to_json
+
+        expect(subject.object_to_http_body([obj])).to eq([json])
+      end
+    end
+  end
+
+  describe '#select_header_accept' do
+    context 'when given anything other than an array' do
+      it 'returns application/json as a default' do
+        expect(subject.select_header_accept(nil)).to eq('application/json')
+        expect(subject.select_header_accept('')).to eq('application/json')
+        expect(subject.select_header_accept(1)).to eq('application/json')
+      end
+    end
+
+    context 'when given a list of types' do
+      context 'that includes a JSON type' do
+        it 'returns the first type containing JSON' do
+          xml = 'application/xml'
+          json = 'application/json'
+
+          expect(subject.select_header_accept([xml, json])).to eq(json)
+        end
+      end
+
+      context 'that does not include a JSON type' do
+        it 'returns the all of the types' do
+          xml = 'application/xml'
+          html = 'text/html'
+          result = [xml, html].join(', ')
+
+          expect(subject.select_header_accept([xml, html])).to eq(result)
+        end
+      end
+    end
+  end
+
+  describe '#select_header_content_type' do
+    context 'when given anything other than an array' do
+      it 'returns application/json as a default' do
+        expect(subject.select_header_content_type(nil)).to eq('application/json')
+        expect(subject.select_header_content_type('')).to eq('application/json')
+        expect(subject.select_header_content_type(1)).to eq('application/json')
+      end
+    end
+
+    context 'when given a list of types' do
+      context 'that includes a JSON type' do
+        it 'returns the first type containing JSON' do
+          xml = 'application/xml'
+          json = 'application/json'
+
+          expect(subject.select_header_content_type([xml, json])).to eq(json)
+        end
+      end
+
+      context 'that does not include a JSON type' do
+        it 'returns the first type' do
+          xml = 'application/xml'
+          html = 'text/html'
+
+          expect(subject.select_header_content_type([xml, html])).to eq(xml)
+        end
+      end
+    end
+  end
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,38 @@
+# Copyright (c) 2018-2019 VMware, Inc.  All Rights Reserved.
+# SPDX-License-Identifier: MIT
+
+# DO NOT MODIFY. THIS CODE IS GENERATED. CHANGES WILL BE OVERWRITTEN.
+
+# cis - No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+
+require 'spec_helper'
+
+describe VSphereAutomation::Configuration do
+  let(:config) { VSphereAutomation::Configuration.default }
+
+  before(:each) do
+    # uncomment below to setup host and base_path
+    # require 'URI'
+    # uri = URI.parse("https://<vcenter>/rest")
+    # VSphereAutomation.configure do |c|
+    #   c.host = uri.host
+    #   c.base_path = uri.path
+    # end
+  end
+
+  describe '#base_url' do
+    it 'should have the default value' do
+      # uncomment below to test default value of the base path
+      # expect(config.base_url).to eq("https://<vcenter>/rest")
+    end
+
+    it 'should remove trailing slashes' do
+      [nil, '', '/', '//'].each do |base_path|
+        config.base_path = base_path
+        # uncomment below to test trailing slashes
+        # expect(config.base_url).to eq("https://<vcenter>/rest")
+      end
+    end
+  end
+end

data/vsphere-automation-cis.gemspec

@@ -22,7 +22,7 @@ Gem::Specification.new do |s|
   s.description = "A Ruby SDK for the vSphere REST APIs (CIS)"
   s.license     = 'MIT'
   s.required_ruby_version = ">= 2.3"
-  s.add_runtime_dependency 'vsphere-automation-runtime', '~> 0.4.4'
+  s.add_runtime_dependency 'vsphere-automation-runtime', '~> 0.4.5'
 
   s.add_development_dependency 'bundler', '~> 2.0'
   s.add_development_dependency 'pry', '~> 0.12.2'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vsphere-automation-cis
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.4.5
 platform: ruby
 authors:
 - J.R. Garcia
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-04 00:00:00.000000000 Z
+date: 2019-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: vsphere-automation-runtime
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.4
+        version: 0.4.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.4
+        version: 0.4.5
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -227,6 +227,9 @@ files:
 - lib/vsphere-automation-cis/api/tagging_tag_api.rb
 - lib/vsphere-automation-cis/api/tagging_tag_association_api.rb
 - lib/vsphere-automation-cis/api/tasks_api.rb
+- lib/vsphere-automation-cis/api_client.rb
+- lib/vsphere-automation-cis/api_error.rb
+- lib/vsphere-automation-cis/configuration.rb
 - lib/vsphere-automation-cis/models/cis_session_create_result.rb
 - lib/vsphere-automation-cis/models/cis_session_info.rb
 - lib/vsphere-automation-cis/models/cis_session_result.rb
@@ -313,11 +316,15 @@ files:
 - pkg/vsphere-automation-cis-0.4.1.gem
 - pkg/vsphere-automation-cis-0.4.2.gem
 - pkg/vsphere-automation-cis-0.4.3.gem
+- pkg/vsphere-automation-cis-0.4.4.gem
+- pkg/vsphere-automation-cis-0.4.5.gem
 - spec/api/session_api_spec.rb
 - spec/api/tagging_category_api_spec.rb
 - spec/api/tagging_tag_api_spec.rb
 - spec/api/tagging_tag_association_api_spec.rb
 - spec/api/tasks_api_spec.rb
+- spec/api_client_spec.rb
+- spec/configuration_spec.rb
 - spec/models/cis_session_create_result_spec.rb
 - spec/models/cis_session_info_spec.rb
 - spec/models/cis_session_result_spec.rb
@@ -431,6 +438,8 @@ test_files:
 - spec/api/tagging_tag_association_api_spec.rb
 - spec/api/tagging_category_api_spec.rb
 - spec/api/tagging_tag_api_spec.rb
+- spec/api_client_spec.rb
+- spec/configuration_spec.rb
 - spec/models/cis_tagging_category_update_spec_spec.rb
 - spec/models/vapi_std_errors_invalid_argument_spec.rb
 - spec/models/cis_session_create_result_spec.rb