eipiai 0.6.0 → 0.7.0

data/features/resources/health.feature

@@ -0,0 +1,27 @@
+Feature: Request entrypoint of API
+
+  When a collection of resources exist
+  I want to use Webmachine to provide API access to those resource
+  So that the resources can easily be retrieved in one request
+
+  Scenario: Get service health
+    When the client does a GET request to "/health"
+    Then the status code should be "200" (OK)
+    And the response should be JSON:
+      """json
+      {
+        "healthy": true
+      }
+      """
+
+  Scenario: Get unhealthy service health
+    Given the configuration "healthy" is set to "false"
+    When the client does a GET request to "/health"
+    Then the status code should be "503" (Service Unavailable)
+    And the response contains the "Retry-After" header with value "60"
+    And the response should be JSON:
+      """json
+      {
+        "healthy": false
+      }
+      """

data/features/resources/singular.feature

@@ -0,0 +1,86 @@
+Feature: Working with singular resources (GET, POST, PUT, DELETE)
+
+  When a single resource exists
+  I want to use Webmachine to provide API access to that resource
+  So that the resource can easily be worked with
+
+  Scenario: GET
+    Given the following top-level resource at "/item/:item_uid":
+      """ruby
+      class ItemResource < Webmachine::Resource
+        include Eipiai::Resource
+
+        def object
+          { hello: 'world' }
+        end
+      end
+      """
+
+    When the client provides the header "Accept: application/json"
+    And the client does a GET request to the "item" resource with the template variable "item_uid" set to "hello"
+    Then the status code should be "200" (OK)
+    And the response should be JSON:
+      """json
+      {
+        "hello": "world"
+      }
+      """
+
+  Scenario: POST
+    Given the following top-level resource at "/item/:item_uid":
+      """ruby
+      class ItemResource < Webmachine::Resource
+        include Eipiai::Resource
+
+        def object
+          OpenStruct.new(hello: 'world')
+        end
+      end
+      """
+
+    When the client provides the header "Content-Type: application/json"
+    And the client does a POST request to the "item" resource with the template variable "item_uid" set to "hello" and the following content:
+      """json
+      { "hello": "galaxy" }
+      """
+    Then the status code should be "204" (No Content)
+    And the response should contain the header "Location" with value "https://example.org/item/hello"
+
+  Scenario: PUT
+    Given the following top-level resource at "/item/:item_uid":
+      """ruby
+      class ItemResource < Webmachine::Resource
+        include Eipiai::Resource
+
+        def object
+          OpenStruct.new(hello: 'world')
+        end
+
+        def new_object
+          OpenStruct.new(params)
+        end
+      end
+      """
+
+    When the client provides the header "Content-Type: application/json"
+    And the client does a PUT request to the "item" resource with the template variable "item_uid" set to "hello" and the following content:
+      """json
+      { "hello": "galaxy" }
+      """
+    Then the status code should be "204" (No Content)
+    And the response should contain the header "Location" with value "https://example.org/item/hello"
+
+  Scenario: DELETE
+    Given the following top-level resource at "/item/:item_uid":
+      """ruby
+      class ItemResource < Webmachine::Resource
+        include Eipiai::Resource
+
+        def object
+          OpenStruct.new(hello: 'world')
+        end
+      end
+      """
+
+    When the client does a DELETE request to the "item" resource with the template variable "item_uid" set to "hello"
+    Then the status code should be "204" (No Content)

data/features/resources/singular/delete.feature

@@ -0,0 +1,69 @@
+Feature: Working with singular resources (GET, POST, PUT, DELETE)
+
+  When a single resource exists
+  I want to use Webmachine to provide API access to that resource
+  So that the resource can easily be worked with
+
+  Scenario: Deleting an existing resource returns "204 No Content"
+    Given the following top-level resource at "/item/:item_uid":
+      """ruby
+      class ItemResource < Webmachine::Resource
+        include Eipiai::Resource
+
+        def object
+          OpenStruct.new(hello: 'world')
+        end
+      end
+      """
+
+    When the client does a DELETE request to the "item" resource with the template variable "item_uid" set to "hello"
+    Then the status code should be "204" (No Content)
+
+  Scenario: Failing to delete a resource returns "500 Internal Server Error"
+    Given the following top-level resource at "/item/:item_uid":
+      """ruby
+      class ItemResource < Webmachine::Resource
+        include Eipiai::Resource
+
+        def delete_resource
+          false
+        end
+
+        def object
+          OpenStruct.new(hello: 'world')
+        end
+      end
+      """
+
+    When the client does a DELETE request to the "item" resource with the template variable "item_uid" set to "hello"
+    Then the status code should be "500" (Internal Server Error)
+
+  Scenario: Asynchronously deleting resource returns "202 Accepted"
+    Given the following top-level resource at "/item/:item_uid":
+      """ruby
+      class ItemResource < Webmachine::Resource
+        include Eipiai::Resource
+
+        def delete_completed?
+          false
+        end
+
+        def object
+          OpenStruct.new(hello: 'world')
+        end
+      end
+      """
+
+    When the client does a DELETE request to the "item" resource with the template variable "item_uid" set to "hello"
+    Then the status code should be "202" (Accepted)
+
+  Scenario: Deleting a non-existing resource returns "404 Not Found"
+    Given the following top-level resource at "/item/:item_uid":
+      """ruby
+      class ItemResource < Webmachine::Resource
+        include Eipiai::Resource
+      end
+      """
+
+    When the client does a DELETE request to the "item" resource with the template variable "item_uid" set to "hello"
+    Then the status code should be "404" (Not Found)

data/features/resources/singular/get.feature

@@ -0,0 +1,146 @@
+Feature: Working with singular resources (GET, POST, PUT, DELETE)
+
+  When a single resource exists
+  I want to use Webmachine to provide API access to that resource
+  So that the resource can easily be worked with
+
+  Scenario: Accept header "application/json" returns "200 OK" and a body of type "application/json"
+    Given the following top-level resource at "/item/:item_uid":
+      """ruby
+      class ItemResource < Webmachine::Resource
+        include Eipiai::Resource
+
+        def object
+          OpenStruct.new(hello: 'world')
+        end
+      end
+      """
+
+    When the client provides the header "Accept: application/json"
+    And the client does a GET request to the "item" resource with the template variable "item_uid" set to "hello"
+    Then the status code should be "200" (OK)
+    And the response should be JSON:
+      """json
+      {
+        "hello": "world"
+      }
+      """
+
+  Scenario: Accept header "application/hal+json" returns "200 OK" and a body of type "application/hal+json"
+    Given the following top-level resource at "/item/:item_uid":
+      """ruby
+      class ItemResource < Webmachine::Resource
+        include Eipiai::Resource
+
+        def to_hal_json
+          to_h.merge(_links: { self: { href: create_uri } }).to_json
+        end
+
+        def object
+          OpenStruct.new(hello: 'world')
+        end
+      end
+      """
+
+    When the client provides the header "Accept: application/hal+json"
+    And the client does a GET request to the "item" resource with the template variable "item_uid" set to "hello"
+    Then the status code should be "200" (OK)
+    And the response should be HAL/JSON:
+      """json
+      {
+        "_links": {
+          "self": {
+            "href": "https://example.org/item/hello"
+          }
+        },
+        "hello": "world"
+      }
+      """
+
+  Scenario: Accept header "text/xml" returns "200 OK" and a body of type "text/html"
+    Given the following top-level resource at "/item/:item_uid":
+      """ruby
+      class ItemResource < Webmachine::Resource
+        require 'active_support/core_ext/hash/conversions'
+
+        include Eipiai::Resource
+
+        def content_types_provided
+          [['text/xml', :to_xml]]
+        end
+
+        def to_xml
+          to_h.to_xml(root: 'item')
+        end
+
+        def object
+          OpenStruct.new(hello: 'world')
+        end
+      end
+      """
+
+    When the client provides the header "Accept: text/xml"
+    And the client does a GET request to the "item" resource with the template variable "item_uid" set to "hello"
+    Then the status code should be "200" (OK)
+    And the response should be XML:
+      """xml
+      <?xml version="1.0" encoding="UTF-8"?>
+      <item>
+        <hello>world</hello>
+      </item>
+      """
+
+  Scenario: Not providing the Accept header returns "200 OK" and uses the first in the list of acceptable response content types
+    Given the following top-level resource at "/item/:item_uid":
+      """ruby
+      class ItemResource < Webmachine::Resource
+        include Eipiai::Resource
+
+        def to_hal_json
+          to_h.merge(_links: { self: { href: create_uri } }).to_json
+        end
+
+        def object
+          OpenStruct.new(hello: 'world')
+        end
+      end
+      """
+
+    When the client does a GET request to the "item" resource with the template variable "item_uid" set to "hello"
+    Then the status code should be "200" (OK)
+    And the response should be HAL/JSON:
+      """json
+      {
+        "_links": {
+          "self": {
+            "href": "https://example.org/item/hello"
+          }
+        },
+        "hello": "world"
+      }
+      """
+
+  Scenario: An unknown Accept header returns "406 Not Acceptable"
+    Given the following top-level resource at "/item/:item_uid":
+      """ruby
+      class ItemResource < Webmachine::Resource
+        include Eipiai::Resource
+      end
+      """
+
+    When the client provides the header "Accept: application/unknown"
+    And the client provides the header "Content-Type: application/json"
+    And the client does a GET request to the "item" resource with the template variable "item_uid" set to "hello"
+    Then the status code should be "406" (Not Acceptable)
+
+  Scenario: A resource that can't be found returns "404 Not Found"
+    Given the following top-level resource at "/item/:item_uid":
+      """ruby
+      class ItemResource < Webmachine::Resource
+        include Eipiai::Resource
+      end
+      """
+
+    When the client provides the header "Accept: application/json"
+    And the client does a GET request to the "item" resource with the template variable "item_uid" set to "hello"
+    Then the status code should be "404" (Not Found)

data/features/resources/singular/post.feature

@@ -0,0 +1,235 @@
+Feature: Working with singular resources (GET, POST, PUT, DELETE)
+
+  When a single resource exists
+  I want to use Webmachine to provide API access to that resource
+  So that the resource can easily be worked with
+
+  Scenario: Accept header "application/json" returns "200 OK" and a body of type "application/json"
+    Given the following top-level resource at "/item/:item_uid":
+      """ruby
+      class ItemResource < Webmachine::Resource
+        include Eipiai::Resource
+
+        def from_json
+          object.marshal_load(params.symbolize_keys)
+          super
+        end
+
+        def object
+          @object ||= OpenStruct.new(hello: 'world')
+        end
+      end
+      """
+
+    When the client provides the header "Accept: application/json"
+    And the client provides the header "Content-Type: application/json"
+    And the client does a POST request to the "item" resource with the template variable "item_uid" set to "hello" and the following content:
+      """json
+      {
+        "hello": "galaxy"
+      }
+      """
+    Then the status code should be "200" (OK)
+    And the response should be JSON:
+      """json
+      {
+        "hello": "galaxy"
+      }
+      """
+
+  Scenario: Accept header "application/hal+json" returns "200 OK" and a body of type "application/hal+json"
+    Given the following top-level resource at "/item/:item_uid":
+      """ruby
+      class ItemResource < Webmachine::Resource
+        include Eipiai::Resource
+
+        def to_hal_json
+          to_h.merge(_links: { self: { href: create_uri } }).to_json
+        end
+
+        def from_json
+          object.marshal_load(params.symbolize_keys)
+          super
+        end
+
+        def object
+          @object ||= OpenStruct.new(hello: 'world')
+        end
+      end
+      """
+
+    When the client provides the header "Accept: application/hal+json"
+    And the client provides the header "Content-Type: application/json"
+    And the client does a POST request to the "item" resource with the template variable "item_uid" set to "hello" and the following content:
+      """json
+      {
+        "hello": "galaxy"
+      }
+      """
+    Then the status code should be "200" (OK)
+    And the response should be HAL/JSON:
+      """json
+      {
+        "_links": {
+          "self": {
+            "href": "https://example.org/item/hello"
+          }
+        },
+        "hello": "galaxy"
+      }
+      """
+
+  Scenario: Accept header "text/xml" returns "200 OK" and a body of type "text/html"
+    Given the following top-level resource at "/item/:item_uid":
+      """ruby
+      class ItemResource < Webmachine::Resource
+        require 'active_support/core_ext/hash/conversions'
+
+        include Eipiai::Resource
+
+        def content_types_provided
+          [['text/xml', :to_xml]]
+        end
+
+        def to_xml
+          to_h.to_xml(root: 'item')
+        end
+
+        def from_json
+          object.marshal_load(params.symbolize_keys)
+          super
+        end
+
+        def object
+          @object ||= OpenStruct.new(hello: 'world')
+        end
+      end
+      """
+
+    When the client provides the header "Accept: text/xml"
+    And the client provides the header "Content-Type: application/json"
+    And the client does a POST request to the "item" resource with the template variable "item_uid" set to "hello" and the following content:
+      """json
+      {
+        "hello": "galaxy"
+      }
+      """
+    Then the status code should be "200" (OK)
+    And the response should be XML:
+      """xml
+      <?xml version="1.0" encoding="UTF-8"?>
+      <item>
+        <hello>galaxy</hello>
+      </item>
+      """
+
+  Scenario: Not providing the Accept header returns "204 No Content"
+    Given the following top-level resource at "/item/:item_uid":
+      """ruby
+      class ItemResource < Webmachine::Resource
+        include Eipiai::Resource
+
+        def object
+          OpenStruct.new(hello: 'world')
+        end
+      end
+      """
+
+    When the client provides the header "Content-Type: application/json"
+    And the client does a POST request to the "item" resource with the template variable "item_uid" set to "hello" and the following content:
+      """json
+      {
+        "hello": "galaxy"
+      }
+      """
+    Then the status code should be "204" (No Content)
+    And the response should contain the header "Location" with value "https://example.org/item/hello"
+
+  Scenario: An unknown Accept header returns "406 Not Acceptable"
+    Given the following top-level resource at "/item/:item_uid":
+      """ruby
+      class ItemResource < Webmachine::Resource
+        include Eipiai::Resource
+      end
+      """
+
+    When the client provides the header "Accept: application/unknown"
+    And the client provides the header "Content-Type: application/json"
+    And the client does a POST request to the "item" resource with the template variable "item_uid" set to "hello" and the following content:
+      """json
+      {
+        "hello": "galaxy"
+      }
+      """
+    Then the status code should be "406" (Not Acceptable)
+
+  Scenario: Not providing the Content-Type header returns "415 Unsupported Media Type"
+    Given the following top-level resource at "/item/:item_uid":
+      """ruby
+      class ItemResource < Webmachine::Resource
+        include Eipiai::Resource
+
+        def object
+          OpenStruct.new(hello: 'world')
+        end
+      end
+      """
+
+    When the client provides the header "Accept: application/json"
+    And the client does a POST request to the "item" resource with the template variable "item_uid" set to "hello" and the following content:
+      """json
+      {
+        "hello": "galaxy"
+      }
+      """
+    Then the status code should be "415" (Unsupported Media Type)
+
+  Scenario: Content-Type as JSON but body is not JSON returns "400 Bad Request"
+    Given the following top-level resource at "/item/:item_uid":
+      """ruby
+      class ItemResource < Webmachine::Resource
+        include Eipiai::Resource
+      end
+      """
+
+    When the client provides the header "Accept: application/json"
+    And the client provides the header "Content-Type: application/json"
+    And the client does a POST request to the "item" resource with the template variable "item_uid" set to "hello" and the following content:
+      """json
+      {
+        "hello": INVALID
+      }
+      """
+    Then the status code should be "400" (Bad Request)
+    And the response should be JSON:
+      """json
+      {
+        "_errors": [
+          {
+            "id": "InvalidJson",
+            "message": "invalid json"
+          }
+        ]
+      }
+      """
+
+  Scenario: A resource that can't be found returns "404 Not Found"
+    Given the following top-level resource at "/item/:item_uid":
+      """ruby
+      class ItemResource < Webmachine::Resource
+        include Eipiai::Resource
+      end
+      """
+
+    When the client provides the header "Accept: application/json"
+    And the client provides the header "Content-Type: application/json"
+    And the client does a POST request to the "item" resource with the template variable "item_uid" set to "hello" and the following content:
+      """json
+      {
+        "hello": "universe"
+      }
+      """
+    Then the status code should be "404" (Not Found)
+
+  @todo
+  Scenario: Providing valid JSON with invalid/unknown attributes returns "422 Unprocessable Entity"