ovirt-engine-sdk 4.1.5 → 4.1.6

data/ext/ovirtsdk4c/ov_xml_reader.h

@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2015-2016 Red Hat, Inc.
+Copyright (c) 2015-2017 Red Hat, Inc.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -17,10 +17,27 @@ limitations under the License.
 #ifndef __OV_XML_READER_H__
 #define __OV_XML_READER_H__
 
-// Classes:
+#include <ruby.h>
+
+#include <libxml/xmlreader.h>
+#include <stdbool.h>
+
+/* Data type and class: */
+extern rb_data_type_t ov_xml_reader_type;
 extern VALUE ov_xml_reader_class;
 
-// Initialization function:
+/* Content: */
+typedef struct {
+    VALUE io;
+    xmlTextReaderPtr reader;
+    bool closed;
+} ov_xml_reader_object;
+
+/* Macro to get the pointer: */
+#define ov_xml_reader_ptr(object, ptr) \
+    TypedData_Get_Struct((object), ov_xml_reader_object, &ov_xml_reader_type, (ptr))
+
+/* Initialization function: */
 extern void ov_xml_reader_define(void);
 
 #endif

data/ext/ovirtsdk4c/ov_xml_writer.c

@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2015-2016 Red Hat, Inc.
+Copyright (c) 2015-2017 Red Hat, Inc.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -16,7 +16,6 @@ limitations under the License.
 
 #include <ruby.h>
 
-#include <stdbool.h>
 #include <libxml/xmlwriter.h>
 
 #include "ov_module.h"
@@ -31,57 +30,76 @@ static ID STRING_ID;
 static ID STRING_IO_ID;
 static ID WRITE_ID;
 
-typedef struct {
-    VALUE io;
-    xmlTextWriterPtr writer;
-} ov_xml_writer_object;
-
-static void ov_xml_writer_check_closed(ov_xml_writer_object* object) {
-    if (object->writer == NULL) {
+static void ov_xml_writer_check_closed(ov_xml_writer_object* ptr) {
+    if (ptr->writer == NULL) {
         rb_raise(ov_error_class, "The writer is already closed");
     }
 }
 
-static void ov_xml_writer_mark(ov_xml_writer_object *object) {
-    /* Mark the IO object as reachable: */
-    if (!NIL_P(object->io)) {
-        rb_gc_mark(object->io);
-    }
+static void ov_xml_writer_mark(void* vptr) {
+    ov_xml_writer_object* ptr;
+
+    ptr = vptr;
+    rb_gc_mark(ptr->io);
 }
 
-static void ov_xml_writer_free(ov_xml_writer_object *object) {
+static void ov_xml_writer_free(void* vptr) {
+    ov_xml_writer_object* ptr;
+
+    /* Get the pointer: */
+    ptr = vptr;
+
     /* Free the libxml writer, the buffer is automatically closed: */
-    if (object->writer != NULL) {
-        xmlTextWriterPtr tmp = object->writer;
-        object->writer = NULL;
+    if (ptr->writer != NULL) {
+        xmlTextWriterPtr tmp = ptr->writer;
+        ptr->writer = NULL;
         xmlFreeTextWriter(tmp);
     }
 
     /* Free this object: */
-    xfree(object);
+    xfree(ptr);
 }
 
+rb_data_type_t ov_xml_writer_type = {
+    .wrap_struct_name = "OVXMLWRITER",
+    .function = {
+        .dmark = ov_xml_writer_mark,
+        .dfree = ov_xml_writer_free,
+        .dsize = NULL,
+        .reserved = { NULL, NULL }
+    },
+#ifdef RUBY_TYPED_FREE_IMMEDIATELY
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+#endif
+};
+
 static VALUE ov_xml_writer_alloc(VALUE klass) {
-    ov_xml_writer_object* object = NULL;
+    ov_xml_writer_object* ptr;
 
-    object = ALLOC(ov_xml_writer_object);
-    memset(object, 0, sizeof(ov_xml_writer_object));
-    return Data_Wrap_Struct(klass, ov_xml_writer_mark, ov_xml_writer_free, object);
+    ptr = ALLOC(ov_xml_writer_object);
+    ptr->io = Qnil;
+    ptr->writer = NULL;
+    return TypedData_Wrap_Struct(klass, &ov_xml_writer_type, ptr);
 }
 
 static int ov_xml_writer_callback(void *context, const char *buffer, int length) {
     VALUE count;
     VALUE data;
-    ov_xml_writer_object *object = (ov_xml_writer_object*) context;
+    ov_xml_writer_object* ptr;
+
+    /* Get the pointer: */
+    ptr = context;
 
     /* Do nothing if the writer is already closed: */
-    if (object->writer == NULL) {
+    if (ptr->writer == NULL) {
         return 0;
     }
 
     /* Convert the buffer to a Ruby string and write it to the IO object, using the "write" method: */
     data = rb_str_new(buffer, length);
-    count = rb_funcall(object->io, WRITE_ID, 1, data);
+    count = rb_funcall(ptr->io, WRITE_ID, 1, data);
 
     return NUM2INT(count);
 }
@@ -99,11 +117,11 @@ static VALUE ov_xml_writer_initialize(int argc, VALUE* argv, VALUE self) {
     VALUE indent;
     VALUE io;
     VALUE io_class;
-    ov_xml_writer_object* object = NULL;
-    xmlOutputBufferPtr buffer = NULL;
+    ov_xml_writer_object* ptr;
+    xmlOutputBufferPtr buffer;
 
     /* Get the pointer to the object: */
-    Data_Get_Struct(self, ov_xml_writer_object, object);
+    ov_xml_writer_ptr(self, ptr);
 
     /* Get the values of the parameters: */
     if (argc > 2) {
@@ -115,12 +133,12 @@ static VALUE ov_xml_writer_initialize(int argc, VALUE* argv, VALUE self) {
     /* The first parameter can be an IO object or nil. If it is nil then we need to create a IO object where we can
        write the generated XML. */
     if (NIL_P(io)) {
-        object->io = ov_xml_writer_create_string_io();
+        ptr->io = ov_xml_writer_create_string_io();
     }
     else {
         io_class = rb_class_of(io);
         if (io_class == rb_cIO) {
-            object->io = io;
+            ptr->io = io;
         }
         else {
             rb_raise(
@@ -132,50 +150,50 @@ static VALUE ov_xml_writer_initialize(int argc, VALUE* argv, VALUE self) {
     }
 
     /* Create the libxml buffer that writes to the IO object: */
-    buffer = xmlOutputBufferCreateIO(ov_xml_writer_callback, NULL, object, NULL);
+    buffer = xmlOutputBufferCreateIO(ov_xml_writer_callback, NULL, ptr, NULL);
     if (buffer == NULL) {
         rb_raise(ov_error_class, "Can't create XML buffer");
     }
 
     /* Create the libxml writer: */
-    object->writer = xmlNewTextWriter(buffer);
-    if (object->writer == NULL) {
+    ptr->writer = xmlNewTextWriter(buffer);
+    if (ptr->writer == NULL) {
         xmlOutputBufferClose(buffer);
         rb_raise(ov_error_class, "Can't create XML writer");
     }
 
     /* Enable indentation: */
     if (RTEST(indent)) {
-        xmlTextWriterSetIndent(object->writer, 1);
-        xmlTextWriterSetIndentString(object->writer, BAD_CAST "  ");
+        xmlTextWriterSetIndent(ptr->writer, 1);
+        xmlTextWriterSetIndentString(ptr->writer, BAD_CAST "  ");
     }
 
     return self;
 }
 
 static VALUE ov_xml_writer_string(VALUE self) {
-    int rc = 0;
-    ov_xml_writer_object* object = NULL;
+    int rc;
+    ov_xml_writer_object* ptr;
 
-    Data_Get_Struct(self, ov_xml_writer_object, object);
-    ov_xml_writer_check_closed(object);
-    rc = xmlTextWriterFlush(object->writer);
+    ov_xml_writer_ptr(self, ptr);
+    ov_xml_writer_check_closed(ptr);
+    rc = xmlTextWriterFlush(ptr->writer);
     if (rc < 0) {
         rb_raise(ov_error_class, "Can't flush XML writer");
     }
-    return rb_funcall(object->io, STRING_ID, 0, NULL);
+    return rb_funcall(ptr->io, STRING_ID, 0, NULL);
 }
 
 static VALUE ov_xml_writer_write_start(VALUE self, VALUE name) {
-    char* c_name = NULL;
-    int rc = 0;
-    ov_xml_writer_object* object = NULL;
+    char* c_name;
+    int rc;
+    ov_xml_writer_object* ptr;
 
-    Data_Get_Struct(self, ov_xml_writer_object, object);
-    ov_xml_writer_check_closed(object);
+    ov_xml_writer_ptr(self, ptr);
+    ov_xml_writer_check_closed(ptr);
     Check_Type(name, T_STRING);
     c_name = StringValueCStr(name);
-    rc = xmlTextWriterStartElement(object->writer, BAD_CAST c_name);
+    rc = xmlTextWriterStartElement(ptr->writer, BAD_CAST c_name);
     if (rc < 0) {
         rb_raise(ov_error_class, "Can't start XML element");
     }
@@ -183,12 +201,12 @@ static VALUE ov_xml_writer_write_start(VALUE self, VALUE name) {
 }
 
 static VALUE ov_xml_writer_write_end(VALUE self) {
-    int rc = 0;
-    ov_xml_writer_object* object = NULL;
+    int rc;
+    ov_xml_writer_object* ptr;
 
-    Data_Get_Struct(self, ov_xml_writer_object, object);
-    ov_xml_writer_check_closed(object);
-    rc = xmlTextWriterEndElement(object->writer);
+    ov_xml_writer_ptr(self, ptr);
+    ov_xml_writer_check_closed(ptr);
+    rc = xmlTextWriterEndElement(ptr->writer);
     if (rc < 0) {
         rb_raise(ov_error_class, "Can't end XML element");
     }
@@ -196,18 +214,18 @@ static VALUE ov_xml_writer_write_end(VALUE self) {
 }
 
 static VALUE ov_xml_writer_write_attribute(VALUE self, VALUE name, VALUE value) {
-    char* c_name = NULL;
-    char* c_value = NULL;
-    int rc = 0;
-    ov_xml_writer_object* object = NULL;
+    char* c_name;
+    char* c_value;
+    int rc;
+    ov_xml_writer_object* ptr;
 
-    Data_Get_Struct(self, ov_xml_writer_object, object);
-    ov_xml_writer_check_closed(object);
+    ov_xml_writer_ptr(self, ptr);
+    ov_xml_writer_check_closed(ptr);
     Check_Type(name, T_STRING);
     Check_Type(value, T_STRING);
     c_name = StringValueCStr(name);
     c_value = StringValueCStr(value);
-    rc = xmlTextWriterWriteAttribute(object->writer, BAD_CAST c_name, BAD_CAST c_value);
+    rc = xmlTextWriterWriteAttribute(ptr->writer, BAD_CAST c_name, BAD_CAST c_value);
     if (rc < 0) {
         rb_raise(ov_error_class, "Can't write attribute with name \"%s\" and value \"%s\"", c_name, c_value);
     }
@@ -215,18 +233,18 @@ static VALUE ov_xml_writer_write_attribute(VALUE self, VALUE name, VALUE value)
 }
 
 static VALUE ov_xml_writer_write_element(VALUE self, VALUE name, VALUE value) {
-    char* c_name = NULL;
-    char* c_value = NULL;
-    int rc = 0;
-    ov_xml_writer_object* object = NULL;
+    char* c_name;
+    char* c_value;
+    int rc;
+    ov_xml_writer_object* ptr;
 
-    Data_Get_Struct(self, ov_xml_writer_object, object);
-    ov_xml_writer_check_closed(object);
+    ov_xml_writer_ptr(self, ptr);
+    ov_xml_writer_check_closed(ptr);
     Check_Type(name, T_STRING);
     Check_Type(value, T_STRING);
     c_name = StringValueCStr(name);
     c_value = StringValueCStr(value);
-    rc = xmlTextWriterWriteElement(object->writer, BAD_CAST c_name, BAD_CAST c_value);
+    rc = xmlTextWriterWriteElement(ptr->writer, BAD_CAST c_name, BAD_CAST c_value);
     if (rc < 0) {
         rb_raise(ov_error_class, "Can't write element with name \"%s\" and value \"%s\"", c_name, c_value);
     }
@@ -234,12 +252,12 @@ static VALUE ov_xml_writer_write_element(VALUE self, VALUE name, VALUE value) {
 }
 
 static VALUE ov_xml_writer_flush(VALUE self) {
-    ov_xml_writer_object* object = NULL;
-    int rc = 0;
+    int rc;
+    ov_xml_writer_object* ptr;
 
-    Data_Get_Struct(self, ov_xml_writer_object, object);
-    ov_xml_writer_check_closed(object);
-    rc = xmlTextWriterFlush(object->writer);
+    ov_xml_writer_ptr(self, ptr);
+    ov_xml_writer_check_closed(ptr);
+    rc = xmlTextWriterFlush(ptr->writer);
     if (rc < 0) {
         rb_raise(ov_error_class, "Can't flush XML writer");
     }
@@ -247,12 +265,12 @@ static VALUE ov_xml_writer_flush(VALUE self) {
 }
 
 static VALUE ov_xml_writer_close(VALUE self) {
-    ov_xml_writer_object* object = NULL;
+    ov_xml_writer_object* ptr;
 
-    Data_Get_Struct(self, ov_xml_writer_object, object);
-    ov_xml_writer_check_closed(object);
-    xmlFreeTextWriter(object->writer);
-    object->writer = NULL;
+    ov_xml_writer_ptr(self, ptr);
+    ov_xml_writer_check_closed(ptr);
+    xmlFreeTextWriter(ptr->writer);
+    ptr->writer = NULL;
     return Qnil;
 }
 

data/ext/ovirtsdk4c/ov_xml_writer.h

@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2015-2016 Red Hat, Inc.
+Copyright (c) 2015-2017 Red Hat, Inc.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -17,10 +17,25 @@ limitations under the License.
 #ifndef __OV_XML_WRITER_H__
 #define __OV_XML_WRITER_H__
 
-// Classes:
+#include <ruby.h>
+
+#include <libxml/xmlwriter.h>
+
+/* Data type and class: */
+extern rb_data_type_t ov_xml_writer_type;
 extern VALUE ov_xml_writer_class;
 
-// Initialization function:
+/* Content: */
+typedef struct {
+    VALUE io;
+    xmlTextWriterPtr writer;
+} ov_xml_writer_object;
+
+/* Macro to get the pointer: */
+#define ov_xml_writer_ptr(object, ptr) \
+    TypedData_Get_Struct((object), ov_xml_writer_object, &ov_xml_writer_type, (ptr))
+
+/* Initialization function: */
 extern void ov_xml_writer_define(void);
 
 #endif

data/ext/ovirtsdk4c/ovirtsdk4c.c

@@ -21,6 +21,7 @@ limitations under the License.
 #include "ov_http_client.h"
 #include "ov_http_request.h"
 #include "ov_http_response.h"
+#include "ov_http_transfer.h"
 #include "ov_xml_reader.h"
 #include "ov_xml_writer.h"
 
@@ -33,6 +34,7 @@ void Init_ovirtsdk4c(void) {
     ov_http_client_define();
     ov_http_request_define();
     ov_http_response_define();
+    ov_http_transfer_define();
     ov_xml_reader_define();
     ov_xml_writer_define();
 }

data/lib/ovirtsdk4.rb

@@ -28,6 +28,7 @@ require 'ovirtsdk4c'
 # Own requirements.
 #
 require 'ovirtsdk4/version.rb'
+require 'ovirtsdk4/error.rb'
 require 'ovirtsdk4/connection.rb'
 require 'ovirtsdk4/type.rb'
 require 'ovirtsdk4/types.rb'

data/lib/ovirtsdk4/connection.rb

@@ -95,7 +95,13 @@ module OvirtSDK4
     # @option opts [Hash] :headers Custom HTTP headers to send with all requests. The keys of the hash can be
     #   strings of symbols, and they will be used as the names of the headers. The values of the hash will be used
     #   as the names of the headers. If the same header is provided here and in the `headers` parameter of a specific
-    #   method call, then the `headers` parameter of the specific method call will have precendence.
+    #   method call, then the `headers` parameter of the specific method call will have precedence.
+    #
+    # @option opts [Integer] :connections (0) The maximum number of connections to open to the host. If the value is
+    #   `0` (the default) then the number of connections will be unlimited.
+    #
+    # @option opts [Integer] :pipeline (0) The maximum number of request to put in an HTTP pipeline without waiting for
+    #   the response. If the value is `0` (the default) then pipelining is disabled.
     #
     def initialize(opts = {})
       # Get the values of the parameters and assign default values:
@@ -115,6 +121,8 @@ module OvirtSDK4
       @proxy_username = opts[:proxy_username]
       @proxy_password = opts[:proxy_password]
       @headers = opts[:headers]
+      @connections = opts[:connections] || 0
+      @pipeline = opts[:pipeline] || 0
 
       # Check that the URL has been provided:
       raise ArgumentError, "The 'url' option is mandatory" unless @url
@@ -147,7 +155,9 @@ module OvirtSDK4
         compress: @compress,
         proxy_url: @proxy_url,
         proxy_username: @proxy_username,
-        proxy_password: @proxy_password
+        proxy_password: @proxy_password,
+        connections: @connections,
+        pipeline: @pipeline
       )
     end
 
@@ -174,10 +184,9 @@ module OvirtSDK4
     end
 
     #
-    # Sends an HTTP request and waits for the response.
+    # Sends an HTTP request.
     #
     # @param request [HttpRequest] The request object containing the details of the HTTP request to send.
-    # @return [Response] A request object containing the details of the HTTP response received.
     #
     # @api private
     #
@@ -208,13 +217,31 @@ module OvirtSDK4
       @token ||= create_access_token
       request.token = @token
 
-      # Create an empty response:
-      response = HttpResponse.new
+      # Send the request:
+      @client.send(request)
+    end
 
-      # Send the request and wait for the response:
-      @client.send(request, response)
+    #
+    # Waits for the response to the given request.
+    #
+    # @param request [HttpRequest] The request object whose corresponding response you want to wait for.
+    # @return [Response] A request object containing the details of the HTTP response received.
+    #
+    def wait(request)
+      # Wait for the response:
+      response = @client.wait(request)
+      raise response if response.is_a?(Exception)
+
+      # If the request failed because of authentication, and it wasn't a request to the SSO service, then the
+      # most likely cause is an expired SSO token. In this case we need to request a new token, and try the original
+      # request again, but only once. It if fails again, we just return the failed response.
+      if response.code == 401 && request.token
+        @token = create_access_token
+        request.token = @token
+        @client.send(request)
+        response = @client.wait(request)
+      end
 
-      # Return the response:
       response
     end
 
@@ -273,25 +300,26 @@ module OvirtSDK4
     #
     def get_sso_response(url, parameters)
       # Create the request:
-      request = HttpRequest.new(
-        method: :POST,
-        url: url,
-        headers: {
-          'User-Agent' => "RubySDK/#{VERSION}",
-          'Content-Type' => 'application/x-www-form-urlencoded',
-          'Accept' => 'application/json'
-        },
-        body: URI.encode_www_form(parameters)
-      )
+      request = HttpRequest.new
+      request.method = :POST
+      request.url = url
+      request.headers = {
+        'User-Agent' => "RubySDK/#{VERSION}",
+        'Content-Type' => 'application/x-www-form-urlencoded',
+        'Accept' => 'application/json'
+      }
+      request.body = URI.encode_www_form(parameters)
 
       # Add the global headers:
       request.headers.merge!(@headers) if @headers
 
-      # Create an empty response:
-      response = HttpResponse.new
-
       # Send the request and wait for the response:
-      @client.send(request, response)
+      @client.send(request)
+      response = @client.wait(request)
+      raise response if response.is_a?(Exception)
+
+      # Check the returned content type:
+      check_json_content_type(response)
 
       # Parse and return the JSON response:
       JSON.parse(response.body)
@@ -361,10 +389,14 @@ module OvirtSDK4
     # `true`.
     #
     # @param raise_exception [Boolean]
+    #
+    # @param timeout [Integer] (nil) The maximun total time to wait for the test to complete, in seconds. If the value
+    #   is `nil` (the default) then the timeout set globally for the connection will be used.
+    #
     # @return [Boolean]
     #
-    def test(raise_exception = false)
-      system_service.get
+    def test(raise_exception = false, timeout = nil)
+      system_service.get(timeout: timeout)
       true
     rescue StandardError
       raise if raise_exception
@@ -412,7 +444,7 @@ module OvirtSDK4
       # Check that the "href" has a value, as it is needed in order to retrieve the representation of the object:
       href = object.href
       if href.nil?
-        raise Error, "Can't follow link because the 'href' attribute does't have a value"
+        raise Error, "Can't follow link because the 'href' attribute doesn't have a value"
       end
 
       # Check that the value of the "href" attribute is compatible with the base URL of the connection:
@@ -446,5 +478,123 @@ module OvirtSDK4
       # Remove the temporary file that contains the trusted CA certificates:
       @ca_store.unlink if @ca_store
     end
+
+    #
+    # Checks that the content type of the given response is JSON. If it is JSON then it does nothing. If it isn't
+    # JSON then it raises an exception.
+    #
+    # @param response [HttpResponse] The HTTP response to check.
+    #
+    # @api private
+    #
+    def check_json_content_type(response)
+      check_content_type(JSON_CONTENT_TYPE_RE, 'JSON', response)
+    end
+
+    #
+    # Checks that the content type of the given response is XML. If it is XML then it does nothing. If it isn't
+    # XML then it raises an exception.
+    #
+    # @param response [HttpResponse] The HTTP response to check.
+    #
+    # @api private
+    #
+    def check_xml_content_type(response)
+      check_content_type(XML_CONTENT_TYPE_RE, 'XML', response)
+    end
+
+    #
+    # Creates and raises an error containing the details of the given HTTP response.
+    #
+    # @param response [HttpResponse] The HTTP response where the details of the raised error will be taken from.
+    # @param detail [String, Fault] (nil) The detail of the error. It can be a string or a `Fault` object.
+    #
+    # @api private
+    #
+    def raise_error(response, detail = nil)
+      # Check if the detail is a fault:
+      fault = detail.is_a?(Fault) ? detail : nil
+
+      # Build the error message from the response and the fault:
+      message = ''
+      unless fault.nil?
+        unless fault.reason.nil?
+          message << ' ' unless message.empty?
+          message << "Fault reason is \"#{fault.reason}\"."
+        end
+        unless fault.detail.nil?
+          message << ' ' unless message.empty?
+          message << "Fault detail is \"#{fault.detail}\"."
+        end
+      end
+      unless response.nil?
+        unless response.code.nil?
+          message << ' ' unless message.empty?
+          message << "HTTP response code is #{response.code}."
+        end
+        unless response.message.nil?
+          message << ' ' unless message.empty?
+          message << "HTTP response message is \"#{response.message}\"."
+        end
+      end
+
+      # If the detail is a string, append it to the message:
+      if detail.is_a?(String)
+        message << ' ' unless message.empty?
+        message << detail
+        message << '.'
+      end
+
+      # Create and populate the error:
+      error = Error.new(message)
+      error.code = response.code if response
+      error.fault = fault
+
+      raise error
+    end
+
+    private
+
+    #
+    # Regular expression used to check JSON content type.
+    #
+    # @api private
+    #
+    JSON_CONTENT_TYPE_RE = %r{^\s*(application|text)/json\s*(;.*)?$}i
+
+    #
+    # Regular expression used to check XML content type.
+    #
+    # @api private
+    #
+    XML_CONTENT_TYPE_RE = %r{^\s*(application|text)/xml\s*(;.*)?$}i
+
+    #
+    # The typical URL path, used just to generate informative error messages.
+    #
+    # @api private
+    #
+    TYPICAL_PATH = '/ovirt-engine/api'.freeze
+
+    #
+    # Checks the content type of the given HTTP response and raises an exception if it isn't the expected one.
+    #
+    # @param expected_re [Regex] The regular expression used to check the expected content type.
+    # @param expected_name [String] The name of the expected content type.
+    # @param response [HttpResponse] The HTTP response to check.
+    #
+    # @api private
+    #
+    def check_content_type(expected_re, expected_name, response)
+      content_type = response.headers['content-type']
+      return if expected_re =~ content_type
+      detail = "The response content type '#{content_type}' isn't #{expected_name}"
+      url = URI(@url)
+      if url.path != TYPICAL_PATH
+        detail << ". Is the path '#{url.path}' included in the 'url' parameter correct?"
+        detail << " The typical one is '#{TYPICAL_PATH}'"
+      end
+      raise_error(response, detail)
+    end
   end
 end