eipiai 0.6.0 → 0.7.0

data/features/resources/singular/put.feature

@@ -0,0 +1,164 @@
+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: Replace an existing record 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
+
+        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: Creating a new record returns "201 Created"
+    Given the following top-level resource at "/item/:item_uid":
+      """ruby
+      class ItemResource < Webmachine::Resource
+        include Eipiai::Resource
+
+        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 "201" (Created)
+    And the response should contain the header "Location" with value "https://example.org/item/hello"
+
+  Scenario: Replace an existing record while providing Accept header "application/json" returns "200 OK"
+    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
+          @object ||= OpenStruct.new(hello: 'world', foo: 'bar')
+        end
+
+        def new_object
+          @object = OpenStruct.new(params)
+        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 PUT request to the "item" resource with the template variable "item_uid" set to "hello" and the following content:
+      """json
+      {
+        "hello": "galaxy",
+        "foo": "bar"
+      }
+      """
+    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",
+        "foo": "bar"
+      }
+      """
+
+  Scenario: Create new object while providing Accept "application/json" returns "200 OK"
+    Given the following top-level resource at "/item/:item_uid":
+      """ruby
+      class ItemResource < Webmachine::Resource
+        include Eipiai::Resource
+
+        def object
+          @object
+        end
+
+        def new_object
+          @object = OpenStruct.new(params)
+        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 PUT request to the "item" resource with the template variable "item_uid" set to "hello" and the following content:
+      """json
+      {
+        "hello": "universe",
+        "foo": "bar"
+      }
+      """
+    Then the status code should be "200" (OK)
+    And the response should be JSON:
+      """json
+      {
+        "hello": "universe",
+        "foo": "bar"
+      }
+      """
+
+  Scenario: Replacing existing object while providing Accept "application/json" returns "200 OK"
+    Given the following top-level resource at "/item/:item_uid":
+      """ruby
+      class ItemResource < Webmachine::Resource
+        include Eipiai::Resource
+
+        def object
+          @object ||= OpenStruct.new(hello: 'world')
+        end
+
+        def new_object
+          @object = OpenStruct.new(params)
+        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 PUT request to the "item" resource with the template variable "item_uid" set to "hello" and the following content:
+      """json
+      {
+        "hello": "universe",
+        "foo": "bar"
+      }
+      """
+    Then the status code should be "200" (OK)
+    And the response should be JSON:
+      """json
+      {
+        "hello": "universe",
+        "foo": "bar"
+      }
+      """

data/features/step_definitions/steps.rb

@@ -1,3 +1,13 @@
+# frozen_string_literal: true
 Given(/^the configuration "([^"]*)" is set to "([^"]*)"$/) do |config, value|
   Eipiai.configuration.send("#{config}=", value)
 end
+
+Then(/^the response should be XML:$/) do |xml|
+  dump last_response.body
+
+  xml = Liquid::Template.parse(xml).render
+
+  assert_equal last_response.headers['Content-Type'], 'text/xml'
+  expect(last_response.body.strip).to eq(xml)
+end

data/features/step_definitions/webmachine_steps.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+Given(/^the following( top-level)? resource at "([^"]*)":$/) do |top, path, code|
+  if top
+    code = code.lines.map do |line|
+      next line unless line.include?('Webmachine::Resource')
+
+      line + "  def top_level_relation?\n    true\n  end\n\n"
+    end.join
+  end
+
+  add_resource(path, code)
+end
+
+def add_resource(path, code)
+  resource = code[/class (\S+Resource)/, 1]
+
+  if Eipiai::Test.const_defined?(resource)
+    Eipiai::Test.class_exec { remove_const(resource) }
+  end
+
+  Eipiai::Test.class_eval(code)
+  add_route(path, resource)
+end
+
+def add_route(path, resource)
+  path = path.split('/').drop(1).map! { |r| r[0] == ':' ? r[1..-1].to_sym : r }
+
+  Eipiai::Test::App.tap do |app|
+    app.add_route path, Eipiai::Test.const_get(resource)
+    Eipiai::ApiRepresenter.populate_from_app(app)
+  end
+end
+
+Before do
+  # Add the `/api` and `/health` routes
+  #
+  Eipiai::Test::App.add_route ['api'], Eipiai::ApiResource
+  Eipiai::Test::App.add_route ['health'], Eipiai::HealthResource
+end
+
+After do
+  # Remove any existing resource objects
+  #
+  Eipiai::Test.class_exec do
+    constants.each do |constant|
+      remove_const(constant) if constant.to_s.end_with?('Resource')
+    end
+  end
+
+  # Remove any existing routes
+  #
+  Eipiai::Test::App.dispatcher.instance_variable_set(:@routes, [])
+
+  # Remove links from ApiRepresenter
+  #
+  Eipiai.class_exec { remove_const(:ApiRepresenter) }
+  load 'eipiai/roar/representers/api.rb'
+end

data/features/support/app.rb

@@ -1,38 +1,26 @@
-lib = File.expand_path('../lib', __dir__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-
+# frozen_string_literal: true
 require 'eipiai'
+require 'webmachine'
 require 'webmachine/adapters/rack'
-require_relative '../../support/fixtures/app'
-
-include Eipiai::TestApp
-
-WebmachineApp = Webmachine::Application.new do |app|
-  app.routes do
-    add ['api'], Eipiai::ApiResource
-    add ['health'], Eipiai::HealthResource
 
-    add ['items'], ItemsResource
-    add ['item', :item_uid], ItemResource
-    add ['users'], UsersResource
-    add ['user', :user_uid], UserResource
+module Eipiai
+  module Test
+    App = Webmachine::Application.new do |app|
+      app.configure do |config|
+        config.adapter = :Rack
+      end
+    end
   end
-
-  app.configure do |config|
-    config.adapter = :Rack
-  end
-
-  Eipiai::ApiRepresenter.populate_from_app(app)
 end
 
 def app
-  WebmachineApp.adapter
+  Eipiai::Test::App.adapter
 end
 
 Before do
-  Eipiai.configuration = Eipiai::Configuration.new
-  Eipiai.configure do |config|
-    config.base_uri   = 'https://example.org'
-    config.curie_uris = { b: 'https://api.example.org/rel/{rel}' }
+  Eipiai.configuration.tap do |c|
+    c.healthy    = true
+    c.base_uri   = 'https://example.org'
+    c.curie_uris = { b: 'https://api.example.org/rel/{rel}' }
   end
 end

data/features/support/env.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'cucumber/blendle_steps'
 
 Before do

data/features/validation.feature

@@ -1,3 +1,4 @@
+@wip
 Feature: Object validation
 
   When accepting external requests to create objects

data/features/webmachine.feature

@@ -1,65 +1,10 @@
+@wip
 Feature: Webmachine CRUD operations
 
   When a new JSON API service needs to be developed
   I want to use Eipiai's default CRUD setup
   So that the basic API operations are quick and easy to implement
 
-  Scenario: List main API endpoint
-    When the client does a GET request to "/api"
-    Then the status code should be "200" (OK)
-    And the response should be HAL/JSON:
-      """json
-      {
-        "_links": {
-          "self": {
-            "href": "https://example.org/api"
-          },
-          "api": {
-            "href": "https://example.org/api"
-          },
-          "health": {
-            "href": "https://example.org/health"
-          },
-          "items": {
-            "href": "https://example.org/items"
-          },
-          "item": {
-            "templated": true,
-            "href": "https://example.org/item/{item_uid}"
-          },
-          "users": {
-            "href": "https://example.org/users"
-          },
-          "user": {
-            "templated": true,
-            "href": "https://example.org/user/{user_uid}"
-          }
-        }
-      }
-      """
-
-  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
-      }
-      """
-
   Scenario: Create resource
     Given the client provides the header "Content-Type: application/json"
     When the client does a POST request to the "items" resource with the following content:

data/lib/eipiai.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'eipiai/configuration'
 
 require 'eipiai/models'

data/lib/eipiai/configuration.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # Eipiai
 #
 # The main module for the library.

data/lib/eipiai/models.rb

@@ -1,2 +1,3 @@
+# frozen_string_literal: true
 require 'eipiai/models/collection'
 require 'eipiai/models/representable'

data/lib/eipiai/models/collection.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Eipiai
   # Collection
   #

data/lib/eipiai/models/representable.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Eipiai
   # Representable
   #
@@ -21,19 +22,19 @@ module Eipiai
       "#{self.class.name}Representer".constantize.new(self)
     end
 
-    # to_hash
+    # to_h
     #
-    # call `#to_hash` on the representer belonging to the object.
+    # call `#to_h` on the representer belonging to the object.
     #
     # @example
     #   item = Item.new.extend(Eipiai::Representable)
-    #   item.to_hash # => { '_links' => { 'self' => { 'href' => '/item' } } }
+    #   item.to_h # => { '_links' => { 'self' => { 'href' => '/item' } } }
     #
     # @param [Hash] options to be used inside the representer
     # @return [Hash] hash representation of the object
     #
-    def to_hash(options = {})
-      represented.to_hash(options)
+    def to_h(options = {})
+      represented.to_h(options)
     end
 
     # from_hash

data/lib/eipiai/roar.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'roar'
 
 require 'eipiai/roar/ext/hal'

data/lib/eipiai/roar/ext/hal.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'roar/json'
 require 'set'
 
@@ -50,6 +51,8 @@ module Roar
               hash['_links']['curies'] = curies.to_a if curies.any?
             end
           end
+
+          alias to_h to_hash
         end
 
         prepend ToHashExt