eipiai 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 34136d9503bd1cfed3341367129e8c7ff9ccfb9d
-  data.tar.gz: 1ec6acd5d189963b9cd0efe1d8649d4c282edca2
+  metadata.gz: 6ea1d2843bc6b4a1b1ed2e268f3a287cdb6c591d
+  data.tar.gz: 72f7c6c496142c5dc5caed1faf5a5c83b1bb810f
 SHA512:
-  metadata.gz: 3adf462831a8f4c9287acbea3bb93d66b31dc8c3e862052d152a7ba091a8611989da4130d35d5f0f2623d115ebefa05d64df378545933e98e552a93b8cb6edfb
-  data.tar.gz: 3a8ab95d17d35671725ea6edbebbd94f599126ce5f073e3350fc2733bbf3fc53935ea9febd22361d5a53b94d1769c250dd643b6c0acaac68a29f88bda379f72e
+  metadata.gz: 88c91bbeb2dc81e6337069fd9053c8c5c262a0a43fd7b70a865c544dedb67061c58648ab2ec14cb93982e6bb1d1fa23df259ce2f5fe97c033fc19fbc04560747
+  data.tar.gz: 5a109aac02025614a11feb80a853f12ad980f6c0537e8fef5b77ea3acae12555b09df0d2fc455ab86d70d49298bd147151f4d3bdda479860ab1aa0b0f00c3c8b

data/.gitignore

@@ -1,9 +1,6 @@
-_builds
-_cache
-_projects
-_steps
 .bundle
 .DS_Store
+.wercker
 .yardoc
 *.gem
 doc/

data/.rubocop.yml

@@ -1,3 +1,6 @@
+AllCops:
+  TargetRubyVersion: 2.3
+
 Metrics/LineLength:
   Max: 100
 

data/.ruby-version

@@ -0,0 +1 @@
+2.3.1

data/.wercker.yml

@@ -1,9 +1,16 @@
-box: ruby
+box: ruby:2.3
 
 build:
   steps:
+  - script:
+    name: fix Bundler issue
+    code: |
+      gem update --system 2.6.1
+      gem install bundler --version $BUNDLER_VERSION
   - bundle-install:
+    path: vendor/bundle
     jobs: "8"
+    clean: true
   - script:
     name: bootstrap
     code: script/bootstrap

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # CHANGELOG
 
+## [v0.6.0](https://github.com/blendle/eipiai/tree/v0.6.0) (2015-12-18)
+[Full Changelog](https://github.com/blendle/eipiai/compare/v0.5.1...v0.6.0)
+
+**Merged pull requests:**
+
+- introduce representable and collection models [\#10](https://github.com/blendle/eipiai/pull/10) ([JeanMertz](https://github.com/JeanMertz))
+
 ## [v0.5.1](https://github.com/blendle/eipiai/tree/v0.5.1) (2015-12-14)
 [Full Changelog](https://github.com/blendle/eipiai/compare/v0.5.0...v0.5.1)
 

data/Gemfile

@@ -1,2 +1,3 @@
+# frozen_string_literal: true
 source 'https://rubygems.org'
 gemspec

data/Rakefile

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'bundler/gem_tasks'
 require 'cucumber/rake/task'
 require 'rubocop/rake_task'

data/eipiai.gemspec

@@ -1,4 +1,5 @@
 # coding: utf-8
+# frozen_string_literal: true
 lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'eipiai/version'

data/features/resources/api.feature

@@ -0,0 +1,82 @@
+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: List main API endpoint
+    Given the following resource at "/item/:item_uid":
+      """ruby
+      class ItemResource < Webmachine::Resource
+        include Eipiai::Resource
+
+        def top_level_relation?
+          true
+        end
+
+        def query_keys
+          %w(available)
+        end
+      end
+      """
+    And the following resource at "/items":
+      """ruby
+      class ItemsResource < Webmachine::Resource
+        include Eipiai::Resource
+
+        def top_level_relation?
+          true
+        end
+
+        def query_keys
+          %w(category weight purchased)
+        end
+      end
+      """
+    And the following resource at "/user/:user_uid":
+      """ruby
+      class UserResource < Webmachine::Resource
+        include Eipiai::Resource
+
+        def top_level_relation?
+          true
+        end
+      end
+      """
+    And the following resource at "/user/:user_uid/orders":
+      """ruby
+      class UserOrdersResource < Webmachine::Resource
+        include Eipiai::Resource
+      end
+      """
+
+    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"
+          },
+          "item": {
+            "href": "https://example.org/item/{item_uid}{?available}",
+            "templated": true
+          },
+          "items": {
+            "href": "https://example.org/items{?category,weight,purchased}",
+            "templated": true
+          },
+          "user": {
+            "href": "https://example.org/user/{user_uid}",
+            "templated": true
+          }
+        }
+      }
+      """

data/features/resources/collection.feature

@@ -0,0 +1,60 @@
+Feature: Request a collection of resources
+
+  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
+    Given the following top-level resource at "/items":
+      """ruby
+      class ItemsResource < Webmachine::Resource
+        include Eipiai::Resource
+
+        def object
+          OpenStruct.new(count: 2, items: [{ hello: 'world' }, { hello: 'universe' }])
+        end
+      end
+      """
+    When the client provides the header "Accept: application/json"
+    And the client does a GET request to the "items" resource
+    Then the status code should be "200" (OK)
+    And the response should be JSON:
+      """json
+      {
+        "count": 2,
+        "items": [
+          {
+            "hello": "world"
+          },
+          {
+            "hello": "universe"
+          }
+        ]
+      }
+      """
+
+  Scenario: POST
+    Given the following top-level resource at "/items":
+      """ruby
+      class ItemsResource < Webmachine::Resource
+        include Eipiai::Resource
+
+        def create_path
+          '/item/' + params['uid']
+        end
+
+        def new_object
+          OpenStruct.new(params)
+        end
+      end
+      """
+    When the client provides the header "Content-Type: application/json"
+    And the client does a POST request to the "items" resource with the following content:
+      """json
+      {
+        "uid": "hello",
+        "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"

data/features/resources/collection/get.feature

@@ -0,0 +1,189 @@
+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 "/items":
+      """ruby
+      class ItemsResource < Webmachine::Resource
+        include Eipiai::Resource
+
+        def object
+          OpenStruct.new(count: 2, items: [{ hello: 'world' }, { hello: 'universe' }])
+        end
+      end
+      """
+
+    When the client provides the header "Accept: application/json"
+    And the client does a GET request to the "items" resource
+    Then the status code should be "200" (OK)
+    And the response should be JSON:
+      """json
+      {
+        "count": 2,
+        "items": [
+          {
+            "hello": "world"
+          },
+          {
+            "hello": "universe"
+          }
+        ]
+      }
+      """
+
+  Scenario: Accept header "application/hal+json" returns "200 OK" and a body of type "application/hal+json"
+    Given the following top-level resource at "/items":
+      """ruby
+      class ItemsResource < Webmachine::Resource
+        include Eipiai::Resource
+
+        def to_hal_json
+          to_h.merge(_links: { self: { href: request.uri.path } }).to_json
+        end
+
+        def object
+          OpenStruct.new(count: 2, items: [{ hello: 'world' }, { hello: 'universe' }])
+        end
+      end
+      """
+
+    When the client provides the header "Accept: application/hal+json"
+    And the client does a GET request to the "items" resource
+    Then the status code should be "200" (OK)
+    And the response should be HAL/JSON:
+      """json
+      {
+        "_links": {
+          "self": {
+            "href": "/items"
+          }
+        },
+        "count": 2,
+        "items": [
+          {
+            "hello": "world"
+          },
+          {
+            "hello": "universe"
+          }
+        ]
+      }
+      """
+
+  Scenario: Accept header "text/xml" returns "200 OK" and a body of type "text/html"
+    Given the following top-level resource at "/items":
+      """ruby
+      class ItemsResource < 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: 'items')
+        end
+
+        def object
+          OpenStruct.new(count: 2, items: [{ hello: 'world' }, { hello: 'universe' }])
+        end
+      end
+      """
+
+    When the client provides the header "Accept: text/xml"
+    And the client does a GET request to the "items" resource
+    Then the status code should be "200" (OK)
+    And the response should be XML:
+      """xml
+      <?xml version="1.0" encoding="UTF-8"?>
+      <items>
+        <count type="integer">2</count>
+        <items type="array">
+          <item>
+            <hello>world</hello>
+          </item>
+          <item>
+            <hello>universe</hello>
+          </item>
+        </items>
+      </items>
+      """
+
+  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 "/items":
+      """ruby
+      class ItemsResource < Webmachine::Resource
+        include Eipiai::Resource
+
+        def to_hal_json
+          to_h.merge(_links: { self: { href: request.uri.path } }).to_json
+        end
+
+        def object
+          OpenStruct.new(count: 2, items: [{ hello: 'world' }, { hello: 'universe' }])
+        end
+      end
+      """
+
+    When the client does a GET request to the "items" resource
+    Then the status code should be "200" (OK)
+    And the response should be HAL/JSON:
+      """json
+      {
+        "_links": {
+          "self": {
+            "href": "/items"
+          }
+        },
+        "count": 2,
+        "items": [
+          {
+            "hello": "world"
+          },
+          {
+            "hello": "universe"
+          }
+        ]
+      }
+      """
+
+  Scenario: An unknown Accept header returns "406 Not Acceptable"
+    Given the following top-level resource at "/items":
+      """ruby
+      class ItemsResource < 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 "items" resource
+    Then the status code should be "406" (Not Acceptable)
+
+  Scenario: An empty collection returns "200 OK" with an empty array
+    Given the following top-level resource at "/items":
+      """ruby
+      class ItemsResource < Webmachine::Resource
+        include Eipiai::Resource
+
+        def object
+          OpenStruct.new(count: 0, items: [])
+        end
+      end
+      """
+
+    When the client provides the header "Accept: application/json"
+    And the client does a GET request to the "items" resource
+    Then the status code should be "200" (OK)
+    And the response should be JSON:
+      """json
+      {
+        "count": 0,
+        "items": []
+      }
+      """

data/features/resources/collection/post.feature

@@ -0,0 +1,230 @@
+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 "201 Created" and a body of type "application/json"
+    Given the following top-level resource at "/items":
+      """ruby
+      class ItemsResource < Webmachine::Resource
+        include Eipiai::Resource
+
+        def create_path
+          '/item/' + params['uid']
+        end
+
+        def new_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 POST request to the "items" resource with the following content:
+      """json
+      {
+        "uid": "hello",
+        "hello": "galaxy"
+      }
+      """
+    Then the status code should be "201" (Created)
+    And the response should be JSON:
+      """json
+      {
+        "uid": "hello",
+        "hello": "galaxy"
+      }
+      """
+
+  Scenario: Accept header "application/hal+json" returns "201 Created" and a body of type "application/hal+json"
+    Given the following top-level resource at "/items":
+      """ruby
+      class ItemsResource < Webmachine::Resource
+        include Eipiai::Resource
+
+        def to_hal_json
+          to_h.merge(_links: { self: { href: create_uri } }).to_json
+        end
+
+        def create_path
+          '/item/' + params['uid']
+        end
+
+        def new_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 POST request to the "items" resource with the following content:
+      """json
+      {
+        "uid": "goodbye",
+        "hello": "galaxy"
+      }
+      """
+    Then the status code should be "201" (Created)
+    And the response should be HAL/JSON:
+      """json
+      {
+        "_links": {
+          "self": {
+            "href": "https://example.org/item/goodbye"
+          }
+        },
+        "uid": "goodbye",
+        "hello": "galaxy"
+      }
+      """
+
+  Scenario: Accept header "text/xml" returns "201 Created" and a body of type "text/html"
+    Given the following top-level resource at "/items":
+      """ruby
+      class ItemsResource < 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 create_path
+          '/item/' + params['uid']
+        end
+
+        def new_object
+          OpenStruct.new(params)
+        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 "items" resource with the following content:
+      """json
+      {
+        "uid": "hello",
+        "hello": "galaxy"
+      }
+      """
+    Then the status code should be "201" (Created)
+    And the response should be XML:
+      """xml
+      <?xml version="1.0" encoding="UTF-8"?>
+      <item>
+        <uid>hello</uid>
+        <hello>galaxy</hello>
+      </item>
+      """
+
+  Scenario: Not providing the Accept header returns "201 Created" and a "Location" header
+    Given the following top-level resource at "/items":
+      """ruby
+      class ItemsResource < Webmachine::Resource
+        include Eipiai::Resource
+
+        def create_path
+          '/item/' + params['uid']
+        end
+
+        def new_object
+          OpenStruct.new(params)
+        end
+      end
+      """
+
+    When the client provides the header "Content-Type: application/json"
+    And the client does a POST request to the "items" resource with the following content:
+      """json
+      {
+        "uid": "hi",
+        "hello": "galaxy"
+      }
+      """
+    Then the status code should be "201" (Created)
+    And the response should contain the header "Location" with value "https://example.org/item/hi"
+
+  Scenario: An unknown Accept header returns "406 Not Acceptable"
+    Given the following top-level resource at "/items":
+      """ruby
+      class ItemsResource < 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 "items" resource with 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 "/items":
+      """ruby
+      class ItemsResource < Webmachine::Resource
+        include Eipiai::Resource
+
+        def create_path
+          '/item' + params['uid']
+        end
+
+        def new_object
+          OpenStruct.new(params)
+        end
+      end
+      """
+
+    When the client provides the header "Accept: application/json"
+    And the client does a POST request to the "items" resource with the following content:
+      """json
+      {
+        "uid": "bye",
+        "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 "/items":
+      """ruby
+      class ItemsResource < 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 "items" resource with 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"
+          }
+        ]
+      }
+      """
+
+  @todo
+  Scenario: Providing valid JSON with invalid/unknown attributes returns "422 Unprocessable Entity"