jsonapi-resources 0.7.1.beta1 → 0.7.1.beta2

data/test/fixtures/posts_tags.yml

@@ -1,59 +0,0 @@
-post_1_short:
-  post_id: 1
-  tag_id: 1
-
-post_1_whiny:
-  post_id: 1
-  tag_id: 2
-
-post_1_grumpy:
-  post_id: 1
-  tag_id: 3
-
-post_2_jr:
-  post_id: 2
-  tag_id: 5
-
-post_11_jr:
-  post_id: 11
-  tag_id: 5
-
-post_12_silly:
-  post_id: 12
-  tag_id: 6
-
-post_12_sleepy:
-  post_id: 12
-  tag_id: 7
-
-post_12_goofy:
-  post_id: 12
-  tag_id: 8
-
-post_12_wacky:
-  post_id: 12
-  tag_id: 9
-
-post_13_silly:
-  post_id: 13
-  tag_id: 6
-
-post_13_sleepy:
-  post_id: 13
-  tag_id: 7
-
-post_13_goofy:
-  post_id: 13
-  tag_id: 8
-
-post_13_wacky:
-  post_id: 13
-  tag_id: 9
-
-post_14_whiny:
-  post_id: 14
-  tag_id: 2
-
-post_14_grumpy:
-  post_id: 14
-  tag_id: 3

data/test/fixtures/preferences.yml

@@ -1,14 +0,0 @@
-a:
-  id: 1
-  advanced_mode: false
-
-b:
-  id: 2
-  advanced_mode: false
-c:
-  id: 3
-  advanced_mode: false
-
-d:
-  id: 4
-  advanced_mode: false

data/test/fixtures/products.yml

@@ -1,3 +0,0 @@
-product_1:
-  id: 1
-  name: Enterprise Gizmo

data/test/fixtures/purchase_orders.yml

@@ -1,23 +0,0 @@
-po_1:
-  id: 1
-  requested_delivery_date:
-  delivery_date: nil
-  customer_id: 1
-
-po_2:
-  id: 2
-  requested_delivery_date:
-  delivery_date: nil
-  customer_id: 1
-
-po_3:
-  id: 3
-  requested_delivery_date:
-  delivery_date: nil
-  customer_id: 1
-
-po_4:
-  id: 4
-  requested_delivery_date:
-  delivery_date: nil
-  customer_id: 3

data/test/fixtures/sections.yml

@@ -1,8 +0,0 @@
-javascript:
-  id: 1
-  name: javascript
-
-ruby:
-  id: 2
-  name: ruby
-

data/test/fixtures/tags.yml

@@ -1,39 +0,0 @@
-short_tag:
-  id: 1
-  name: short
-
-whiny_tag:
-  id: 2
-  name: whiny
-
-grumpy_tag:
-  id: 3
-  name: grumpy
-
-happy_tag:
-  id: 4
-  name: happy
-
-jr_tag:
-  id: 5
-  name: JR
-
-silly_tag:
-  id: 6
-  name: silly
-
-sleepy_tag:
-  id: 7
-  name: sleepy
-
-goofy_tag:
-  id: 8
-  name: goofy
-
-wacky_tag:
-  id: 9
-  name: wacky
-
-bad_tag:
-  id: 10
-  name: bad

data/test/fixtures/vehicles.yml

@@ -1,17 +0,0 @@
-Miata:
-  id: 1
-  type: Car
-  make: Mazda
-  model: Miata MX5
-  drive_layout: Front Engine RWD
-  serial_number: 32432adfsfdysua
-  person_id: 1
-
-Launch20:
-  id: 2
-  type: Boat
-  make: Chris-Craft
-  model: Launch 20
-  length_at_water_line: 15.5ft
-  serial_number: 434253JJJSD
-  person_id: 1

data/test/fixtures/web_pages.yml

@@ -1,3 +0,0 @@
-web_page1:
-  href: http://example.com
-  link: http://link.example.com

data/test/helpers/assertions.rb

@@ -1,13 +0,0 @@
-module Helpers
-  module Assertions
-    def assert_hash_equals(exp, act, msg = nil)
-      msg = message(msg, '') { diff exp, act }
-      assert(matches_hash?(exp, act, {exact: true}), msg)
-    end
-
-    def assert_array_equals(exp, act, msg = nil)
-      msg = message(msg, '') { diff exp, act }
-      assert(matches_array?(exp, act, {exact: true}), msg)
-    end
-  end
-end

data/test/helpers/functional_helpers.rb

@@ -1,59 +0,0 @@
-module Helpers
-  module FunctionalHelpers
-    # from http://jamieonsoftware.com/blog/entry/testing-restful-response-types
-    # def assert_response_is(type, message = '')
-    #   case type
-    #     when :js
-    #       check = [
-    #         'text/javascript'
-    #       ]
-    #     when :json
-    #       check = [
-    #         'application/json',
-    #         'text/json',
-    #         'application/x-javascript',
-    #         'text/x-javascript',
-    #         'text/x-json'
-    #       ]
-    #     when :xml
-    #       check = [ 'application/xml', 'text/xml' ]
-    #     when :yaml
-    #       check = [
-    #         'text/yaml',
-    #         'text/x-yaml',
-    #         'application/yaml',
-    #         'application/x-yaml'
-    #       ]
-    #     else
-    #       if methods.include?('assert_response_types')
-    #         check = assert_response_types
-    #       else
-    #         check = []
-    #       end
-    #   end
-    #
-    #   if @response.content_type
-    #     ct = @response.content_type
-    #   elsif methods.include?('assert_response_response')
-    #     ct = assert_response_response
-    #   else
-    #     ct = ''
-    #   end
-    #
-    #   begin
-    #     assert check.include?(ct)
-    #   rescue Test::Unit::AssertionFailedError
-    #     raise Test::Unit::AssertionFailedError.new(build_message(message, "The response type is not ?", type.to_s))
-    #   end
-    # end
-
-    # def assert_js_redirect_to(path)
-    #   assert_response_is :js
-    #   assert_match /#{"window.location.href = \"" + path + "\""}/, @response.body
-    # end
-    #
-    def json_response
-      JSON.parse(@response.body)
-    end
-  end
-end

data/test/helpers/value_matchers.rb

@@ -1,60 +0,0 @@
-module Helpers
-  module ValueMatchers
-    ### Matchers
-    def matches_value?(v1, v2, options = {})
-      if v1 == :any
-        # any value is acceptable
-      elsif v1 == :not_nil
-        return false if v2 == nil
-      elsif v1.kind_of?(Hash)
-        return false unless matches_hash?(v1, v2, options)
-      elsif v1.kind_of?(Array)
-        return false unless matches_array?(v1, v2, options)
-      else
-        return false unless v2 == v1
-      end
-      true
-    end
-
-    def matches_array?(array1, array2, options = {})
-      return false unless array1.kind_of?(Array) && array2.kind_of?(Array)
-      if options[:exact]
-        return false unless array1.size == array2.size
-      end
-
-      # order of items shouldn't matter:
-      #    ['a', 'b', 'c'], ['b', 'c', 'a'] -> true
-      #
-      # matched items should only be used once:
-      #    ['a', 'b', 'c'], ['a', 'a', 'a'] -> false
-      #    ['a', 'a', 'a'], ['a', 'b', 'c'] -> false
-      matched = {}
-      (0..(array1.size - 1)).each do |i|
-        (0..(array2.size - 1)).each do |j|
-          if !matched.has_value?(j.to_s) && matches_value?(array1[i], array2[j], options)
-            matched[i.to_s] = j.to_s
-            break
-          end
-        end
-        return false unless matched.has_key?(i.to_s)
-      end
-      true
-    end
-
-    # options => {exact: true} # hashes must match exactly (i.e. have same number of key-value pairs that are all equal)
-    def matches_hash?(hash1, hash2, options = {})
-      return false unless hash1.kind_of?(Hash) && hash2.kind_of?(Hash)
-      if options[:exact]
-        return false unless hash1.size == hash2.size
-      end
-
-      hash1 = hash1.deep_symbolize_keys
-      hash2 = hash2.deep_symbolize_keys
-
-      hash1.each do |k1, v1|
-        return false unless hash2.has_key?(k1) && matches_value?(v1, hash2[k1], options)
-      end
-      true
-    end
-  end
-end

data/test/helpers/value_matchers_test.rb

@@ -1,40 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-class ValueMatchersTest < ActionController::TestCase
-
-  def test_matches_value_any
-    assert(matches_value?(:any, 'a'))
-    assert(matches_value?(:any, nil))
-  end
-
-  def test_matches_value_not_nil
-    assert(matches_value?(:not_nil, 'a'))
-    refute(matches_value?(:not_nil, nil))
-  end
-
-  def test_matches_value_array
-    assert(matches_value?(['a', 'b', 'c'], ['b', 'c', 'a']))
-    assert(matches_value?(['a', 'b', 'c'], ['a', 'b', 'c']))
-    refute(matches_value?(['a', 'b', 'c'], ['a', 'a']))
-    refute(matches_value?(['a', 'b', 'c'], ['a', 'b', 'd']))
-
-    assert(matches_value?(['a', 'b', :any], ['a', 'b', 'c']))
-    assert(matches_value?(['a', 'b', :not_nil], ['a', 'b', 'c']))
-    refute(matches_value?(['a', 'b', :not_nil], ['a', 'b', nil]))
-  end
-
-  def test_matches_value_hash
-    assert(matches_value?({a: 'a', b: 'b', c: 'c'}, {a: 'a', b: 'b', c: 'c'}))
-    assert(matches_value?({a: 'a', b: 'b', c: 'c'}, {b: 'b', c: 'c', a: 'a'}))
-    refute(matches_value?({a: 'a', b: 'b', c: 'c'}, {b: 'a', c: 'c', a: 'b'}))
-
-    assert(matches_value?({a: 'a', b: 'b', c: {a: 'a', d: 'e'}}, {b: 'b', c: {a: 'a', d: 'e'}, a: 'a'}))
-    refute(matches_value?({a: 'a', b: 'b', c: {a: 'a', d: 'd'}}, {b: 'b', c: {a: 'a', d: 'e'}, a: 'a'}))
-
-    assert(matches_value?({a: 'a', b: 'b', c: {a: 'a', d: {a: :not_nil}}}, {b: 'b', c: {a: 'a', d: {a: 'b'}}, a: 'a'}))
-    refute(matches_value?({a: 'a', b: 'b', c: {a: 'a', d: {a: :not_nil}}}, {b: 'b', c: {a: 'a', d: {a: nil}}, a: 'a'}))
-
-    assert(matches_value?({a: 'a', b: 'b', c: {a: 'a', d: {a: :any}}}, {b: 'b', c: {a: 'a', d: {a: 'b'}}, a: 'a'}))
-    assert(matches_value?({a: 'a', b: 'b', c: {a: 'a', d: {a: :any}}}, {b: 'b', c: {a: 'a', d: {a: nil}}, a: 'a'}))
-  end
-end

data/test/integration/requests/namespaced_model_test.rb

@@ -1,13 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-
-class NamedspacedModelTest < ActionDispatch::IntegrationTest
-  def setup
-    JSONAPI.configuration.json_key_format = :underscored_key
-  end
-
-  def test_get_flat_posts
-    get '/flat_posts'
-    assert_equal 200, status
-    assert_equal "flat_posts", json_response["data"].first["type"]
-  end
-end

data/test/integration/requests/request_test.rb

@@ -1,932 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-
-class RequestTest < ActionDispatch::IntegrationTest
-  def setup
-    JSONAPI.configuration.json_key_format = :underscored_key
-    JSONAPI.configuration.route_format = :underscored_route
-    $test_user = Person.find(1)
-  end
-
-  def after_teardown
-    Api::V2::BookResource.paginator :offset
-    JSONAPI.configuration.route_format = :underscored_route
-  end
-
-  def assert_jsonapi_response(expected_status)
-    assert_equal JSONAPI::MEDIA_TYPE, response.content_type
-    assert_equal expected_status, status
-  end
-
-  def test_get
-    get '/posts'
-    assert_jsonapi_response 200
-  end
-
-  def test_get_inflected_resource
-    get '/api/v8/numeros_telefone'
-    assert_jsonapi_response 200
-  end
-
-  def test_get_nested_to_one
-    get '/posts/1/author'
-    assert_jsonapi_response 200
-  end
-
-  def test_get_nested_to_many
-    get '/posts/1/comments'
-    assert_jsonapi_response 200
-  end
-
-  def test_get_nested_to_many_bad_param
-    get '/posts/1/comments?relationship=books'
-    assert_jsonapi_response 200
-  end
-
-  def test_get_underscored_key
-    original_config = JSONAPI.configuration.dup
-    JSONAPI.configuration.json_key_format = :underscored_key
-    get '/iso_currencies'
-    assert_jsonapi_response 200
-    assert_equal 3, json_response['data'].size
-  ensure
-    JSONAPI.configuration = original_config
-  end
-
-  def test_get_underscored_key_filtered
-    original_config = JSONAPI.configuration.dup
-    JSONAPI.configuration.json_key_format = :underscored_key
-    get '/iso_currencies?filter[country_name]=Canada'
-    assert_jsonapi_response 200
-    assert_equal 1, json_response['data'].size
-    assert_equal 'Canada', json_response['data'][0]['attributes']['country_name']
-  ensure
-    JSONAPI.configuration = original_config
-  end
-
-  def test_get_camelized_key_filtered
-    original_config = JSONAPI.configuration.dup
-    JSONAPI.configuration.json_key_format = :camelized_key
-    get '/iso_currencies?filter[countryName]=Canada'
-    assert_jsonapi_response 200
-    assert_equal 1, json_response['data'].size
-    assert_equal 'Canada', json_response['data'][0]['attributes']['countryName']
-  ensure
-    JSONAPI.configuration = original_config
-  end
-
-  def test_get_camelized_route_and_key_filtered
-    original_config = JSONAPI.configuration.dup
-    JSONAPI.configuration.json_key_format = :camelized_key
-    get '/api/v4/isoCurrencies?filter[countryName]=Canada'
-    assert_jsonapi_response 200
-    assert_equal 1, json_response['data'].size
-    assert_equal 'Canada', json_response['data'][0]['attributes']['countryName']
-  ensure
-    JSONAPI.configuration = original_config
-  end
-
-  def test_get_camelized_route_and_links
-    original_config = JSONAPI.configuration.dup
-    JSONAPI.configuration.json_key_format = :camelized_key
-    JSONAPI.configuration.route_format = :camelized_route
-    get '/api/v4/expenseEntries/1/relationships/isoCurrency'
-    assert_jsonapi_response 200
-    assert_hash_equals({'links' => {
-                         'self' => 'http://www.example.com/api/v4/expenseEntries/1/relationships/isoCurrency',
-                         'related' => 'http://www.example.com/api/v4/expenseEntries/1/isoCurrency'
-                       },
-                       'data' => {
-                          'type' => 'isoCurrencies',
-                          'id' => 'USD'
-                         }
-                       }, json_response)
-  ensure
-    JSONAPI.configuration = original_config
-  end
-
-  def test_put_single_without_content_type
-    put '/posts/3',
-        {
-          'data' => {
-            'linkage' => {
-              'type' => 'posts',
-              'id' => '3',
-            },
-            'attributes' => {
-              'title' => 'A great new Post'
-            },
-            'links' => {
-              'tags' => [
-                {type: 'tags', id: 3},
-                {type: 'tags', id: 4}
-              ]
-            }
-          }
-        }.to_json, "CONTENT_TYPE" => "application/json"
-
-    assert_equal 415, status
-  end
-
-  def test_put_single
-    put '/posts/3',
-        {
-          'data' => {
-            'type' => 'posts',
-            'id' => '3',
-            'attributes' => {
-              'title' => 'A great new Post'
-            },
-            'relationships' => {
-              'tags' => {
-                'data' => [
-                  {type: 'tags', id: 3},
-                  {type: 'tags', id: 4}
-                ]
-              }
-            }
-          }
-        }.to_json, "CONTENT_TYPE" => JSONAPI::MEDIA_TYPE
-
-    assert_jsonapi_response 200
-  end
-
-  def test_post_single_without_content_type
-    post '/posts',
-      {
-        'posts' => {
-          'attributes' => {
-            'title' => 'A great new Post'
-          },
-          'relationships' => {
-            'tags' => {
-              'data' => [
-                  {type: 'tags', id: 3},
-                  {type: 'tags', id: 4}
-                ]
-            }
-          }
-        }
-      }.to_json, "CONTENT_TYPE" => "application/json"
-
-    assert_equal 415, status
-  end
-
-  def test_post_single
-    post '/posts',
-      {
-        'data' => {
-          'type' => 'posts',
-          'attributes' => {
-            'title' => 'A great new Post',
-            'body' => 'JSONAPIResources is the greatest thing since unsliced bread.'
-          },
-          'relationships' => {
-            'author' => {'data' => {type: 'people', id: '3'}}
-          }
-        }
-      }.to_json, "CONTENT_TYPE" => JSONAPI::MEDIA_TYPE
-
-    assert_jsonapi_response 201
-  end
-
-  def test_post_single_missing_data_contents
-    post '/posts',
-         {
-           'data' => {
-           }
-         }.to_json, "CONTENT_TYPE" => JSONAPI::MEDIA_TYPE
-
-    assert_jsonapi_response 400
-  end
-
-  def test_post_single_minimal_valid
-    post '/comments',
-         {
-           'data' => {
-             'type' => 'comments'
-           }
-         }.to_json, "CONTENT_TYPE" => JSONAPI::MEDIA_TYPE
-
-    assert_jsonapi_response 201
-    assert_nil json_response['data']['attributes']['body']
-    assert_nil json_response['data']['relationships']['post']['data']
-    assert_nil json_response['data']['relationships']['author']['data']
-  end
-
-  def test_post_single_minimal_invalid
-    post '/posts',
-      {
-        'data' => {
-          'type' => 'posts'
-        }
-      }.to_json, "CONTENT_TYPE" => JSONAPI::MEDIA_TYPE
-
-    assert_jsonapi_response 422
-  end
-
-  def test_update_relationship_without_content_type
-    ruby = Section.find_by(name: 'ruby')
-    patch '/posts/3/relationships/section', { 'data' => {type: 'sections', id: ruby.id.to_s }}.to_json
-
-    assert_equal 415, status
-  end
-
-  def test_patch_update_relationship_to_one
-    ruby = Section.find_by(name: 'ruby')
-    patch '/posts/3/relationships/section', { 'data' => {type: 'sections', id: ruby.id.to_s }}.to_json, "CONTENT_TYPE" => JSONAPI::MEDIA_TYPE
-
-    assert_equal 204, status
-  end
-
-  def test_put_update_relationship_to_one
-    ruby = Section.find_by(name: 'ruby')
-    put '/posts/3/relationships/section', { 'data' => {type: 'sections', id: ruby.id.to_s }}.to_json, "CONTENT_TYPE" => JSONAPI::MEDIA_TYPE
-
-    assert_equal 204, status
-  end
-
-  def test_patch_update_relationship_to_many_acts_as_set
-    # Comments are acts_as_set=false so PUT/PATCH should respond with 403
-
-    rogue = Comment.find_by(body: 'Rogue Comment Here')
-    patch '/posts/5/relationships/comments', { 'data' => [{type: 'comments', id: rogue.id.to_s }]}.to_json, "CONTENT_TYPE" => JSONAPI::MEDIA_TYPE
-
-    assert_jsonapi_response 403
-  end
-
-  def test_post_update_relationship_to_many
-    rogue = Comment.find_by(body: 'Rogue Comment Here')
-    post '/posts/5/relationships/comments', { 'data' => [{type: 'comments', id: rogue.id.to_s }]}.to_json, "CONTENT_TYPE" => JSONAPI::MEDIA_TYPE
-
-    assert_equal 204, status
-  end
-
-  def test_put_update_relationship_to_many_acts_as_set
-    # Comments are acts_as_set=false so PUT/PATCH should respond with 403. Note: JR currently treats PUT and PATCH as equivalent
-
-    rogue = Comment.find_by(body: 'Rogue Comment Here')
-    put '/posts/5/relationships/comments', { 'data' => [{type: 'comments', id: rogue.id.to_s }]}.to_json, "CONTENT_TYPE" => JSONAPI::MEDIA_TYPE
-
-    assert_jsonapi_response 403
-  end
-
-  def test_index_content_type
-    get '/posts'
-    assert_match JSONAPI::MEDIA_TYPE, headers['Content-Type']
-  end
-
-  def test_get_content_type
-    get '/posts/3'
-    assert_match JSONAPI::MEDIA_TYPE, headers['Content-Type']
-  end
-
-  def test_put_content_type
-    put '/posts/3',
-        {
-          'data' => {
-            'type' => 'posts',
-            'id' => '3',
-            'attributes' => {
-              'title' => 'A great new Post'
-            },
-            'relationships' => {
-              'tags' => {
-                'data' => [
-                  {type: 'tags', id: 3},
-                  {type: 'tags', id: 4}
-                ]
-              }
-            }
-          }
-        }.to_json, "CONTENT_TYPE" => JSONAPI::MEDIA_TYPE
-
-    assert_match JSONAPI::MEDIA_TYPE, headers['Content-Type']
-  end
-
-  def test_patch_content_type
-    patch '/posts/3',
-        {
-          'data' => {
-            'type' => 'posts',
-            'id' => '3',
-            'attributes' => {
-              'title' => 'A great new Post'
-            },
-            'relationships' => {
-              'tags' => {
-                'data' => [
-                  {type: 'tags', id: 3},
-                  {type: 'tags', id: 4}
-                ]
-              }
-            }
-          }
-        }.to_json, "CONTENT_TYPE" => JSONAPI::MEDIA_TYPE
-
-    assert_match JSONAPI::MEDIA_TYPE, headers['Content-Type']
-  end
-
-  def test_post_correct_content_type
-    post '/posts',
-      {
-       'data' => {
-         'type' => 'posts',
-         'attributes' => {
-           'title' => 'A great new Post'
-         },
-         'relationships' => {
-           'author' => {'data' => {type: 'people', id: '3'}}
-         }
-       }
-     }.to_json, "CONTENT_TYPE" => JSONAPI::MEDIA_TYPE
-
-    assert_match JSONAPI::MEDIA_TYPE, headers['Content-Type']
-  end
-
-  def test_destroy_single
-    delete '/posts/7'
-    assert_equal 204, status
-    assert_nil headers['Content-Type']
-  end
-
-  def test_destroy_multiple
-    delete '/posts/8,9'
-    assert_equal 204, status
-  end
-
-  def test_pagination_none
-    Api::V2::BookResource.paginator :none
-    get '/api/v2/books'
-    assert_jsonapi_response 200
-    assert_equal 901, json_response['data'].size
-  end
-
-  def test_pagination_offset_style
-    Api::V2::BookResource.paginator :offset
-    get '/api/v2/books'
-    assert_jsonapi_response 200
-    assert_equal JSONAPI.configuration.default_page_size, json_response['data'].size
-    assert_equal 'Book 0', json_response['data'][0]['attributes']['title']
-  end
-
-  def test_pagination_offset_style_offset
-    Api::V2::BookResource.paginator :offset
-    get '/api/v2/books?page[offset]=50'
-    assert_jsonapi_response 200
-    assert_equal JSONAPI.configuration.default_page_size, json_response['data'].size
-    assert_equal 'Book 50', json_response['data'][0]['attributes']['title']
-  end
-
-  def test_pagination_offset_style_offset_limit
-    Api::V2::BookResource.paginator :offset
-    get '/api/v2/books?page[offset]=50&page[limit]=20'
-    assert_jsonapi_response 200
-    assert_equal 20, json_response['data'].size
-    assert_equal 'Book 50', json_response['data'][0]['attributes']['title']
-  end
-
-  def test_pagination_offset_bad_param
-    Api::V2::BookResource.paginator :offset
-    get '/api/v2/books?page[irishsetter]=50&page[limit]=20'
-    assert_jsonapi_response 400
-  end
-
-  def test_pagination_related_resources_link
-    Api::V2::BookResource.paginator :offset
-    get '/api/v2/books?page[limit]=2'
-    assert_jsonapi_response 200
-    assert_equal 2, json_response['data'].size
-    assert_equal 'http://www.example.com/api/v2/books/1/book_comments',
-                 json_response['data'][1]['relationships']['book_comments']['links']['related']
-  end
-
-  def test_pagination_related_resources_data
-    Api::V2::BookResource.paginator :offset
-    Api::V2::BookCommentResource.paginator :offset
-    get '/api/v2/books/1/book_comments?page[limit]=10'
-    assert_jsonapi_response 200
-    assert_equal 10, json_response['data'].size
-    assert_equal 'This is comment 18 on book 1.', json_response['data'][9]['attributes']['body']
-  end
-
-  def test_pagination_related_resources_links
-    Api::V2::BookResource.paginator :offset
-    Api::V2::BookCommentResource.paginator :offset
-    get '/api/v2/books/1/book_comments?page[limit]=10'
-    assert_equal 'http://www.example.com/api/v2/books/1/book_comments?page%5Blimit%5D=10&page%5Boffset%5D=0', json_response['links']['first']
-    assert_equal 'http://www.example.com/api/v2/books/1/book_comments?page%5Blimit%5D=10&page%5Boffset%5D=10', json_response['links']['next']
-    assert_equal 'http://www.example.com/api/v2/books/1/book_comments?page%5Blimit%5D=10&page%5Boffset%5D=16', json_response['links']['last']
-  end
-
-  def test_pagination_related_resources_links_meta
-    Api::V2::BookResource.paginator :offset
-    Api::V2::BookCommentResource.paginator :offset
-    JSONAPI.configuration.top_level_meta_include_record_count = true
-    get '/api/v2/books/1/book_comments?page[limit]=10'
-    assert_equal 26, json_response['meta']['record_count']
-    assert_equal 'http://www.example.com/api/v2/books/1/book_comments?page%5Blimit%5D=10&page%5Boffset%5D=0', json_response['links']['first']
-    assert_equal 'http://www.example.com/api/v2/books/1/book_comments?page%5Blimit%5D=10&page%5Boffset%5D=10', json_response['links']['next']
-    assert_equal 'http://www.example.com/api/v2/books/1/book_comments?page%5Blimit%5D=10&page%5Boffset%5D=16', json_response['links']['last']
-  ensure
-    JSONAPI.configuration.top_level_meta_include_record_count = false
-  end
-
-  def test_filter_related_resources
-    Api::V2::BookCommentResource.paginator :offset
-    JSONAPI.configuration.top_level_meta_include_record_count = true
-    get '/api/v2/books/1/book_comments?filter[book]=2'
-    assert_equal 0, json_response['meta']['record_count']
-    get '/api/v2/books/1/book_comments?filter[book]=1&page[limit]=20'
-    assert_equal 26, json_response['meta']['record_count']
-  ensure
-    JSONAPI.configuration.top_level_meta_include_record_count = false
-  end
-
-  def test_pagination_related_resources_without_related
-    Api::V2::BookResource.paginator :offset
-    Api::V2::BookCommentResource.paginator :offset
-    get '/api/v2/books/10/book_comments'
-    assert_jsonapi_response 200
-    assert_nil json_response['links']['next']
-    assert_equal 'http://www.example.com/api/v2/books/10/book_comments?page%5Blimit%5D=10&page%5Boffset%5D=0', json_response['links']['first']
-    assert_equal 'http://www.example.com/api/v2/books/10/book_comments?page%5Blimit%5D=10&page%5Boffset%5D=0', json_response['links']['last']
-  end
-
-  def test_related_resource_alternate_relation_name_record_count
-    original_config = JSONAPI.configuration.dup
-    JSONAPI.configuration.default_paginator = :paged
-    JSONAPI.configuration.top_level_meta_include_record_count = true
-
-    get '/api/v2/books/1/aliased_comments'
-    assert_jsonapi_response 200
-    assert_equal 26, json_response['meta']['record_count']
-  ensure
-    JSONAPI.configuration = original_config
-  end
-
-  def test_pagination_related_resources_data_includes
-    Api::V2::BookResource.paginator :offset
-    Api::V2::BookCommentResource.paginator :offset
-    get '/api/v2/books/1/book_comments?page[limit]=10&include=author,book'
-    assert_jsonapi_response 200
-    assert_equal 10, json_response['data'].size
-    assert_equal 'This is comment 18 on book 1.', json_response['data'][9]['attributes']['body']
-  end
-
-  def test_pagination_empty_results
-    Api::V2::BookResource.paginator :offset
-    Api::V2::BookCommentResource.paginator :offset
-    get '/api/v2/books?filter[id]=2000&page[limit]=10'
-    assert_jsonapi_response 200
-    assert_equal 0, json_response['data'].size
-    assert_nil json_response['links']['next']
-    assert_equal 'http://www.example.com/api/v2/books?filter%5Bid%5D=2000&page%5Blimit%5D=10&page%5Boffset%5D=0', json_response['links']['first']
-    assert_equal 'http://www.example.com/api/v2/books?filter%5Bid%5D=2000&page%5Blimit%5D=10&page%5Boffset%5D=0', json_response['links']['last']
-  end
-
-  # def test_pagination_related_resources_data_includes
-  #   Api::V2::BookResource.paginator :none
-  #   Api::V2::BookCommentResource.paginator :none
-  #   get '/api/v2/books?filter[]'
-  #   assert_jsonapi_response 200
-  #   assert_equal 10, json_response['data'].size
-  #   assert_equal 'This is comment 18 on book 1.', json_response['data'][9]['attributes']['body']
-  # end
-
-
-  def test_flow_self
-    get '/posts'
-    assert_jsonapi_response 200
-    post_1 = json_response['data'][0]
-
-    get post_1['links']['self']
-    assert_jsonapi_response 200
-    assert_hash_equals post_1, json_response['data']
-  end
-
-  def test_flow_link_to_one_self_link
-    get '/posts'
-    assert_jsonapi_response 200
-    post_1 = json_response['data'][0]
-
-    get post_1['relationships']['author']['links']['self']
-    assert_jsonapi_response 200
-    assert_hash_equals(json_response, {
-                                      'links' => {
-                                        'self' => 'http://www.example.com/posts/1/relationships/author',
-                                        'related' => 'http://www.example.com/posts/1/author'
-                                      },
-                                      'data' => {type: 'people', id: '1'}
-                                    })
-  end
-
-  def test_flow_link_to_many_self_link
-    get '/posts'
-    assert_jsonapi_response 200
-    post_1 = json_response['data'][0]
-
-    get post_1['relationships']['tags']['links']['self']
-    assert_jsonapi_response 200
-    assert_hash_equals(json_response,
-                       {
-                         'links' => {
-                           'self' => 'http://www.example.com/posts/1/relationships/tags',
-                           'related' => 'http://www.example.com/posts/1/tags'
-                          },
-                          'data' => [
-                            {type: 'tags', id: '1'},
-                            {type: 'tags', id: '2'},
-                            {type: 'tags', id: '3'}
-                          ]
-                       })
-  end
-
-  def test_flow_link_to_many_self_link_put
-    get '/posts'
-    assert_jsonapi_response 200
-    post_1 = json_response['data'][4]
-
-    post post_1['relationships']['tags']['links']['self'],
-         {'data' => [{'type' => 'tags', 'id' => '10'}]}.to_json,
-         "CONTENT_TYPE" => JSONAPI::MEDIA_TYPE
-
-    assert_equal 204, status
-
-    get post_1['relationships']['tags']['links']['self']
-    assert_jsonapi_response 200
-    assert_hash_equals(json_response,
-                       {
-                         'links' => {
-                           'self' => 'http://www.example.com/posts/5/relationships/tags',
-                           'related' => 'http://www.example.com/posts/5/tags'
-                         },
-                         'data' => [
-                           {type: 'tags', id: '10'}
-                         ]
-                       })
-  end
-
-  def test_flow_self_formatted_route_1
-    original_config = JSONAPI.configuration.dup
-    JSONAPI.configuration.route_format = :dasherized_route
-    JSONAPI.configuration.json_key_format = :dasherized_key
-    get '/api/v6/purchase-orders'
-    assert_jsonapi_response 200
-    po_1 = json_response['data'][0]
-    assert_equal 'purchase-orders', json_response['data'][0]['type']
-
-    get po_1['links']['self']
-    assert_jsonapi_response 200
-    assert_hash_equals po_1, json_response['data']
-  ensure
-    JSONAPI.configuration = original_config
-  end
-
-  def test_flow_self_formatted_route_2
-    original_config = JSONAPI.configuration.dup
-    JSONAPI.configuration.route_format = :underscored_route
-    JSONAPI.configuration.json_key_format = :dasherized_key
-    get '/api/v7/purchase_orders'
-    assert_jsonapi_response 200
-    assert_equal 'purchase-orders', json_response['data'][0]['type']
-
-    po_1 = json_response['data'][0]
-
-    get po_1['links']['self']
-    assert_jsonapi_response 200
-    assert_hash_equals po_1, json_response['data']
-  ensure
-    JSONAPI.configuration = original_config
-  end
-
-  def test_flow_self_formatted_route_3
-    original_config = JSONAPI.configuration.dup
-    JSONAPI.configuration.route_format = :underscored_route
-    JSONAPI.configuration.json_key_format = :underscored_key
-    get '/api/v7/purchase_orders'
-    assert_jsonapi_response 200
-    assert_equal 'purchase_orders', json_response['data'][0]['type']
-
-    po_1 = json_response['data'][0]
-
-    get po_1['links']['self']
-    assert_jsonapi_response 200
-    assert_hash_equals po_1, json_response['data']
-  ensure
-    JSONAPI.configuration = original_config
-  end
-
-  def test_post_formatted_keys
-    original_config = JSONAPI.configuration.dup
-    JSONAPI.configuration.route_format = :dasherized_route
-    JSONAPI.configuration.json_key_format = :dasherized_key
-    post '/api/v6/purchase-orders',
-         {
-           'data' => {
-             'attributes' => {
-               'delivery-name' => 'ASDFG Corp'
-             },
-             'type' => 'purchase-orders'
-           }
-         }.to_json, "CONTENT_TYPE" => JSONAPI::MEDIA_TYPE
-
-    assert_jsonapi_response 201
-  ensure
-    JSONAPI.configuration = original_config
-  end
-
-  def test_post_formatted_keys_different_route_key_1
-    original_config = JSONAPI.configuration.dup
-    JSONAPI.configuration.route_format = :dasherized_route
-    JSONAPI.configuration.json_key_format = :underscored_key
-    post '/api/v6/purchase-orders',
-         {
-           'data' => {
-             'attributes' => {
-               'delivery_name' => 'ASDFG Corp'
-             },
-             'type' => 'purchase_orders'
-           }
-         }.to_json, "CONTENT_TYPE" => JSONAPI::MEDIA_TYPE
-
-    assert_jsonapi_response 201
-  ensure
-    JSONAPI.configuration = original_config
-  end
-
-  def test_post_formatted_keys_different_route_key_2
-    original_config = JSONAPI.configuration.dup
-    JSONAPI.configuration.route_format = :underscored_route
-    JSONAPI.configuration.json_key_format = :dasherized_key
-    post '/api/v7/purchase_orders',
-         {
-           'data' => {
-             'attributes' => {
-               'delivery-name' => 'ASDFG Corp'
-             },
-             'type' => 'purchase-orders'
-           }
-         }.to_json, "CONTENT_TYPE" => JSONAPI::MEDIA_TYPE
-
-    assert_jsonapi_response 201
-  ensure
-    JSONAPI.configuration = original_config
-  end
-
-  def test_post_formatted_keys_wrong_format
-    original_config = JSONAPI.configuration.dup
-    JSONAPI.configuration.route_format = :dasherized_route
-    JSONAPI.configuration.json_key_format = :dasherized_key
-    post '/api/v6/purchase-orders',
-         {
-           'data' => {
-             'attributes' => {
-               'delivery_name' => 'ASDFG Corp'
-             },
-             'type' => 'purchase-orders'
-           }
-         }.to_json, "CONTENT_TYPE" => JSONAPI::MEDIA_TYPE
-
-    assert_jsonapi_response 400
-  ensure
-    JSONAPI.configuration = original_config
-  end
-
-  def test_patch_formatted_dasherized
-    original_config = JSONAPI.configuration.dup
-    JSONAPI.configuration.route_format = :dasherized_route
-    JSONAPI.configuration.json_key_format = :dasherized_key
-    patch '/api/v6/purchase-orders/1',
-         {
-           'data' => {
-             'id' => '1',
-             'attributes' => {
-               'delivery-name' => 'ASDFG Corp'
-             },
-             'type' => 'purchase-orders'
-           }
-         }.to_json, "CONTENT_TYPE" => JSONAPI::MEDIA_TYPE
-
-    assert_jsonapi_response 200
-  end
-
-  def test_patch_formatted_dasherized_links
-    original_config = JSONAPI.configuration.dup
-    JSONAPI.configuration.route_format = :dasherized_route
-    JSONAPI.configuration.json_key_format = :dasherized_key
-    patch '/api/v6/line-items/1',
-          {
-            'data' => {
-              'id' => '1',
-              'type' => 'line-items',
-              'attributes' => {
-                'item-cost' => '23.57'
-              },
-              'relationships' => {
-                'purchase-order' => {
-                  'data' => {'type' => 'purchase-orders', 'id' => '2'}
-                }
-              }
-            }
-          }.to_json, "CONTENT_TYPE" => JSONAPI::MEDIA_TYPE
-
-    assert_jsonapi_response 200
-  ensure
-    JSONAPI.configuration = original_config
-  end
-
-  def test_patch_formatted_dasherized_replace_to_many
-    original_config = JSONAPI.configuration.dup
-    JSONAPI.configuration.route_format = :dasherized_route
-    JSONAPI.configuration.json_key_format = :dasherized_key
-    patch '/api/v6/purchase-orders/2?include=line-items,order-flags',
-          {
-            'data' => {
-              'id' => '2',
-              'type' => 'purchase-orders',
-              'relationships' => {
-                'line-items' => {
-                  'data' => [
-                    {'type' => 'line-items', 'id' => '3'},
-                    {'type' => 'line-items', 'id' => '4'}
-                  ]
-                },
-                'order-flags' => {
-                  'data' => [
-                    {'type' => 'order-flags', 'id' => '1'},
-                    {'type' => 'order-flags', 'id' => '2'}
-                  ]
-                }
-              }
-            }
-          }.to_json, "CONTENT_TYPE" => JSONAPI::MEDIA_TYPE
-
-    assert_jsonapi_response 200
-  ensure
-    JSONAPI.configuration = original_config
-  end
-
-  def test_patch_formatted_dasherized_replace_to_many_computed_relation
-    $original_test_user = $test_user
-    $test_user = Person.find(5)
-    original_config = JSONAPI.configuration.dup
-    JSONAPI.configuration.route_format = :dasherized_route
-    JSONAPI.configuration.json_key_format = :dasherized_key
-    patch '/api/v6/purchase-orders/2?include=line-items,order-flags',
-          {
-            'data' => {
-              'id' => '2',
-              'type' => 'purchase-orders',
-              'relationships' => {
-                'line-items' => {
-                  'data' => [
-                    {'type' => 'line-items', 'id' => '3'},
-                    {'type' => 'line-items', 'id' => '4'}
-                  ]
-                },
-                'order-flags' => {
-                  'data' => [
-                    {'type' => 'order-flags', 'id' => '1'},
-                    {'type' => 'order-flags', 'id' => '2'}
-                  ]
-                }
-              }
-            }
-          }.to_json, "CONTENT_TYPE" => JSONAPI::MEDIA_TYPE
-
-    assert_jsonapi_response 200
-  ensure
-    JSONAPI.configuration = original_config
-    $test_user = $original_test_user
-  end
-
-  def test_post_to_many_link
-    original_config = JSONAPI.configuration.dup
-    JSONAPI.configuration.route_format = :dasherized_route
-    JSONAPI.configuration.json_key_format = :dasherized_key
-    post '/api/v6/purchase-orders/3/relationships/line-items',
-          {
-            'data' => [
-              {'type' => 'line-items', 'id' => '3'},
-              {'type' => 'line-items', 'id' => '4'}
-            ]
-          }.to_json, "CONTENT_TYPE" => JSONAPI::MEDIA_TYPE
-
-    assert_equal 204, status
-  ensure
-    JSONAPI.configuration = original_config
-  end
-
-  def test_post_computed_relation_to_many
-    $original_test_user = $test_user
-    $test_user = Person.find(5)
-    original_config = JSONAPI.configuration.dup
-    JSONAPI.configuration.route_format = :dasherized_route
-    JSONAPI.configuration.json_key_format = :dasherized_key
-    post '/api/v6/purchase-orders/4/relationships/line-items',
-         {
-           'data' => [
-             {'type' => 'line-items', 'id' => '5'},
-             {'type' => 'line-items', 'id' => '6'}
-           ]
-         }.to_json, "CONTENT_TYPE" => JSONAPI::MEDIA_TYPE
-
-    assert_equal 204, status
-  ensure
-    JSONAPI.configuration = original_config
-    $test_user = $original_test_user
-  end
-
-  def test_patch_to_many_link
-    original_config = JSONAPI.configuration.dup
-    JSONAPI.configuration.route_format = :dasherized_route
-    JSONAPI.configuration.json_key_format = :dasherized_key
-    patch '/api/v6/purchase-orders/3/relationships/order-flags',
-         {
-           'data' => [
-             {'type' => 'order-flags', 'id' => '1'},
-             {'type' => 'order-flags', 'id' => '2'}
-           ]
-         }.to_json, "CONTENT_TYPE" => JSONAPI::MEDIA_TYPE
-
-    assert_equal 204, status
-  ensure
-    JSONAPI.configuration = original_config
-  end
-
-  def test_patch_to_many_link_computed_relation
-    $original_test_user = $test_user
-    $test_user = Person.find(5)
-    original_config = JSONAPI.configuration.dup
-    JSONAPI.configuration.route_format = :dasherized_route
-    JSONAPI.configuration.json_key_format = :dasherized_key
-    patch '/api/v6/purchase-orders/4/relationships/order-flags',
-          {
-            'data' => [
-              {'type' => 'order-flags', 'id' => '1'},
-              {'type' => 'order-flags', 'id' => '2'}
-            ]
-          }.to_json, "CONTENT_TYPE" => JSONAPI::MEDIA_TYPE
-
-    assert_equal 204, status
-  ensure
-    JSONAPI.configuration = original_config
-    $test_user = $original_test_user
-  end
-
-  def test_patch_to_one
-    original_config = JSONAPI.configuration.dup
-    JSONAPI.configuration.route_format = :dasherized_route
-    JSONAPI.configuration.json_key_format = :dasherized_key
-    patch '/api/v6/line-items/5/relationships/purchase-order',
-         {
-           'data' => {'type' => 'purchase-orders', 'id' => '3'}
-         }.to_json, "CONTENT_TYPE" => JSONAPI::MEDIA_TYPE
-
-    assert_equal 204, status
-  ensure
-    JSONAPI.configuration = original_config
-  end
-
-  def test_include_parameter_allowed
-    get '/api/v2/books/1/book_comments?include=author'
-    assert_jsonapi_response 200
-  end
-
-  def test_include_parameter_not_allowed
-    JSONAPI.configuration.allow_include = false
-    get '/api/v2/books/1/book_comments?include=author'
-    assert_jsonapi_response 400
-  ensure
-    JSONAPI.configuration.allow_include = true
-  end
-
-  def test_filter_parameter_not_allowed
-    JSONAPI.configuration.allow_filter = false
-    get '/api/v2/books?filter[author]=1'
-    assert_jsonapi_response 400
-  ensure
-    JSONAPI.configuration.allow_filter = true
-  end
-
-  def test_sort_parameter_not_allowed
-    JSONAPI.configuration.allow_sort = false
-    get '/api/v2/books?sort=title'
-    assert_jsonapi_response 400
-  ensure
-    JSONAPI.configuration.allow_sort = true
-  end
-
-  def test_getting_different_resources_when_sti
-    get '/vehicles'
-    assert_jsonapi_response 200
-    types = json_response['data'].map{|r| r['type']}.sort
-    assert_array_equals ['boats', 'cars'], types
-  end
-
-  def test_getting_resource_with_correct_type_when_sti
-    get '/vehicles/1'
-    assert_jsonapi_response 200
-    assert_equal 'cars', json_response['data']['type']
-  end
-end