jsonapi-resources 0.0.1

data/test/helpers/functional_helpers.rb

@@ -0,0 +1,59 @@
+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/hash_helpers.rb

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

data/test/helpers/value_matchers.rb

@@ -0,0 +1,60 @@
+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

@@ -0,0 +1,40 @@
+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/request_test.rb

@@ -0,0 +1,39 @@
+require File.expand_path('../../../test_helper', __FILE__)
+require File.expand_path('../../../fixtures/active_record', __FILE__)
+
+class RequestTest < ActionDispatch::IntegrationTest
+
+  def test_get
+    get '/posts'
+    assert_equal 200, status
+  end
+
+  def test_put_single
+    put '/posts/3', {"posts" => {"id" => "3", "title" => "A great new Post", "links" => { "tags" => [3,4] }}}
+    assert_equal 200, status
+  end
+
+  # def test_put_links
+  #   put '/posts/3/links/tags', {"tags" => [1,4] }
+  #   assert_equal 200, status
+  # end
+
+  # def test_patch_create
+  #   patch '/posts',
+  #       {"op" => "add",
+  #       "path" => "/-",
+  #       "value" => {"title" => "Another great new Post", "body" => "saasd", "links" => { "author" => 3 }}}
+  #   assert_equal 200, status
+  # end
+
+  def test_destroy_single
+    delete '/posts/7'
+    assert_equal 204, status
+  end
+
+  def test_destroy_multiple
+    delete '/posts/8,9'
+    assert_equal 204, status
+  end
+end
+

data/test/integration/routes/routes_test.rb

@@ -0,0 +1,85 @@
+require File.expand_path('../../../test_helper', __FILE__)
+
+class RoutesTest < ActionDispatch::IntegrationTest
+
+  def test_routing_post
+    assert_routing({ path: 'posts', method: :post }, { controller: 'posts', action: 'create' })
+  end
+
+  def test_routing_put
+    assert_routing({ path: '/posts/1', method: :put }, { controller: 'posts', action: 'update', id: '1' })
+  end
+
+  def test_routing_posts_show
+    assert_routing({ path: '/posts/1', method: :get }, {action: 'show', controller: 'posts', id: '1'})
+  end
+
+  def test_routing_posts_links_author_show
+    assert_routing({ path: '/posts/1/links/author', method: :get }, { controller: 'posts', action: 'show_association', post_id: '1', association: 'author' })
+  end
+
+  def test_routing_posts_links_author_destroy
+    assert_routing({ path: '/posts/1/links/author', method: :delete }, { controller: 'posts', action: 'destroy_association', post_id: '1', association: 'author' })
+  end
+
+  def test_routing_posts_links_author_create
+    assert_routing({ path: '/posts/1/links/author', method: :post }, { controller: 'posts', action: 'create_association', post_id: '1', association: 'author' })
+  end
+
+  def test_routing_posts_links_tags_show
+    assert_routing({ path: '/posts/1/links/tags', method: :get }, { controller: 'posts', action: 'show_association', post_id: '1', association: 'tags' })
+  end
+
+  def test_routing_posts_links_tags_destroy
+    assert_routing({ path: '/posts/1/links/tags/1,2', method: :delete }, { controller: 'posts', action: 'destroy_association', post_id: '1', keys: '1,2', association: 'tags' })
+  end
+
+  def test_routing_posts_links_tags_update
+    assert_routing({ path: '/posts/1/links/tags', method: :post }, { controller: 'posts', action: 'create_association', post_id: '1', association: 'tags' })
+  end
+
+  # V1
+  def test_routing_v1_posts_show
+    assert_routing({ path: '/api/v1/posts/1', method: :get }, {action: 'show', controller: 'api/v1/posts', id: '1'})
+  end
+
+  def test_routing_v1_posts_delete
+    assert_routing({ path: '/api/v1/posts/1', method: :delete }, {action: 'destroy', controller: 'api/v1/posts', id: '1'})
+  end
+
+  def test_routing_v1_posts_links_author_show
+    assert_routing({ path: '/api/v1/posts/1/links/author', method: :get }, { controller: 'api/v1/posts', action: 'show_association', post_id: '1', association: 'author' })
+  end
+
+  # V2
+  def test_routing_v2_posts_show
+    assert_routing({ path: '/api/v2/authors/1', method: :get }, {action: 'show', controller: 'api/v2/authors', id: '1'})
+  end
+
+  def test_routing_v2_posts_links_author_show
+    assert_routing({ path: '/api/v2/posts/1/links/author', method: :get }, { controller: 'api/v2/posts', action: 'show_association', post_id: '1', association: 'author' })
+  end
+
+  def test_routing_v2_preferences_show
+    assert_routing({ path: '/api/v2/preferences', method: :get }, {action: 'show', controller: 'api/v2/preferences'})
+  end
+
+  # V3
+  def test_routing_v3_posts_show
+    assert_routing({ path: '/api/v3/posts/1', method: :get }, {action: 'show', controller: 'api/v3/posts', id: '1'})
+  end
+
+  # ToDo: Refute routing
+  # def test_routing_v3_posts_delete
+  #   assert_routing({ path: '/api/v3/posts/1', method: :delete }, {action: 'destroy', controller: 'api/v3/posts', id: '1'})
+  # end
+
+  # def test_routing_posts_links_author_except_destroy
+  #   assert_routing({ path: '/api/v3/posts/1/links/author', method: :delete }, { controller: 'api/v3/posts', action: 'destroy_association', post_id: '1', association: 'author' })
+  # end
+  #
+  # def test_routing_posts_links_tags_only_create_show
+  #   assert_routing({ path: '/api/v3/posts/1/links/tags/1,2', method: :delete }, { controller: 'api/v3/posts', action: 'destroy_association', post_id: '1', keys: '1,2', association: 'tags' })
+  # end
+end
+

data/test/test_helper.rb

@@ -0,0 +1,98 @@
+require 'simplecov'
+
+# To run tests with coverage
+# COVERAGE=true rake test
+if ENV['COVERAGE']
+  SimpleCov.start do
+  end
+end
+
+require 'minitest/autorun'
+require 'minitest/spec'
+require 'rails/all'
+
+require 'jsonapi/routing_ext'
+
+require File.expand_path('../helpers/value_matchers', __FILE__)
+require File.expand_path('../helpers/hash_helpers', __FILE__)
+require File.expand_path('../helpers/functional_helpers', __FILE__)
+
+Rails.env = 'test'
+
+class TestApp < Rails::Application
+  config.eager_load = false
+  config.root = File.dirname(__FILE__)
+  config.session_store :cookie_store, key: 'session'
+  config.secret_key_base = 'secret'
+
+  #Raise errors on unsupported parameters
+  config.action_controller.action_on_unpermitted_parameters = :raise
+end
+
+TestApp.initialize!
+
+require File.expand_path('../fixtures/active_record', __FILE__)
+
+TestApp.routes.draw do
+  jsonapi_resources :authors
+  jsonapi_resources :people
+  jsonapi_resources :comments
+  jsonapi_resources :tags
+  jsonapi_resources :posts
+  jsonapi_resources :sections
+  jsonapi_resources :currencies
+  jsonapi_resources :expense_entries
+  jsonapi_resources :breeds
+  jsonapi_resources :planets
+  jsonapi_resources :planet_types
+  jsonapi_resources :moons
+  jsonapi_resources :preferences
+
+
+  namespace :api do
+    namespace :v1 do
+      jsonapi_resources :authors
+      jsonapi_resources :people
+      jsonapi_resources :comments
+      jsonapi_resources :tags
+      jsonapi_resources :posts
+      jsonapi_resources :sections
+      jsonapi_resources :currencies
+      jsonapi_resources :expense_entries
+      jsonapi_resources :breeds
+      jsonapi_resources :planets
+      jsonapi_resources :planet_types
+      jsonapi_resources :moons
+      jsonapi_resources :preferences
+    end
+
+    namespace :v2 do
+      jsonapi_resources :authors
+      jsonapi_resources :posts
+      jsonapi_resource :preferences
+    end
+
+    namespace :v3 do
+      jsonapi_resource :preferences do
+      #   Intentionally empty block to skip association urls
+      end
+
+      jsonapi_resources :posts, except: [:destroy] do
+        jsonapi_link :author, except: [:destroy]
+        jsonapi_links :tags, only: [:show, :create]
+      end
+    end
+  end
+end
+
+class MiniTest::Unit::TestCase
+  include Helpers::HashHelpers
+  include Helpers::ValueMatchers
+  include Helpers::FunctionalHelpers
+end
+
+class ActiveSupport::TestCase
+  setup do
+    @routes = TestApp.routes
+  end
+end

data/test/unit/operation/operations_processor_test.rb

@@ -0,0 +1,188 @@
+require File.expand_path('../../../test_helper', __FILE__)
+require File.expand_path('../../../fixtures/active_record', __FILE__)
+
+require 'jsonapi/operation'
+require 'jsonapi/operation_result'
+require 'jsonapi/operations_processor'
+
+class OperationsProcessorTest < MiniTest::Unit::TestCase
+  def setup
+  end
+
+  def test_create_single_resource
+    op = JSONAPI::OperationsProcessor.new()
+
+    count = Planet.count
+
+    operations = [
+      JSONAPI::CreateResourceOperation.new(PlanetResource, {attributes: {'name' => 'earth', 'description' => 'The best planet ever.'}})
+    ]
+
+    request = JSONAPI::Request.new
+    request.operations = operations
+
+    results = op.process(request)
+
+    assert_kind_of(Array, results)
+    assert_kind_of(JSONAPI::OperationResult, results[0])
+    assert_equal(:created, results[0].code)
+    assert_equal(results.size, 1)
+    assert_equal(Planet.count, count + 1)
+  end
+
+  def test_create_multiple_resources
+    op = JSONAPI::OperationsProcessor.new()
+
+    count = Planet.count
+
+    operations = [
+      JSONAPI::CreateResourceOperation.new(PlanetResource, {attributes: {'name' => 'earth', 'description' => 'The best planet for life.'}}),
+      JSONAPI::CreateResourceOperation.new(PlanetResource, {attributes: {'name' => 'mars', 'description' => 'The red planet.'}}),
+      JSONAPI::CreateResourceOperation.new(PlanetResource, {attributes: {'name' => 'venus', 'description' => 'A very hot planet.'}})
+    ]
+
+    request = JSONAPI::Request.new
+    request.operations = operations
+
+    results = op.process(request)
+
+    assert_kind_of(Array, results)
+    assert_equal(results.size, 3)
+    assert_equal(Planet.count, count + 3)
+  end
+
+  def test_add_has_one_association
+    op = JSONAPI::OperationsProcessor.new()
+
+    saturn = Planet.find(1)
+    gas_giant = PlanetType.find(1)
+    planetoid = PlanetType.find(2)
+    assert_equal(saturn.planet_type_id, planetoid.id)
+
+
+    operations = [
+      JSONAPI::ReplaceHasOneAssociationOperation.new(PlanetResource, saturn.id, :planet_type, gas_giant.id)
+    ]
+
+    request = JSONAPI::Request.new
+    request.operations = operations
+
+    results = op.process(request)
+
+    assert_kind_of(Array, results)
+    assert_kind_of(JSONAPI::OperationResult, results[0])
+    assert_equal(:created, results[0].code)
+    assert_equal(results[0].resource.object.attributes['planet_type_id'], gas_giant.id)
+  end
+
+  def test_add_has_many_association
+    op = JSONAPI::OperationsProcessor.new()
+
+    betax = Planet.find(5)
+    betay = Planet.find(6)
+    betaz = Planet.find(7)
+    gas_giant = PlanetType.find(1)
+    unknown = PlanetType.find(5)
+    assert_equal(betax.planet_type_id, unknown.id)
+    assert_equal(betay.planet_type_id, unknown.id)
+    assert_equal(betaz.planet_type_id, unknown.id)
+
+    operations = [
+      JSONAPI::CreateHasManyAssociationOperation.new(PlanetTypeResource, gas_giant.id, :planets, [betax.id, betay.id, betaz.id])
+    ]
+
+    request = JSONAPI::Request.new
+    request.operations = operations
+
+    results = op.process(request)
+
+    betax.reload
+    betay.reload
+    betaz.reload
+
+    assert_equal(betax.planet_type_id, gas_giant.id)
+    assert_equal(betay.planet_type_id, gas_giant.id)
+    assert_equal(betaz.planet_type_id, gas_giant.id)
+  end
+
+  def test_replace_attributes
+    op = JSONAPI::OperationsProcessor.new()
+
+    count = Planet.count
+    saturn = Planet.find(1)
+    assert_equal(saturn.name, 'Satern')
+
+    operations = [
+      JSONAPI::ReplaceFieldsOperation.new(PlanetResource, 1, {attributes: {'name' => 'saturn'}}),
+    ]
+
+    request = JSONAPI::Request.new
+    request.operations = operations
+
+    results = op.process(request)
+
+    assert_kind_of(Array, results)
+    assert_equal(results.size, 1)
+
+    assert_kind_of(JSONAPI::OperationResult, results[0])
+    assert_equal(:ok, results[0].code)
+
+    saturn = Planet.find(1)
+
+    assert_equal(saturn.name, 'saturn')
+
+    assert_equal(Planet.count, count)
+  end
+
+  def test_remove_resource
+    op = JSONAPI::OperationsProcessor.new
+
+    count = Planet.count
+    pluto = Planet.find(2)
+    assert_equal(pluto.name, 'Pluto')
+
+    operations = [
+      JSONAPI::RemoveResourceOperation.new(PlanetResource, 2),
+    ]
+
+    request = JSONAPI::Request.new
+    request.operations = operations
+
+    results = op.process(request)
+
+    assert_kind_of(Array, results)
+    assert_equal(results.size, 1)
+
+    assert_kind_of(JSONAPI::OperationResult, results[0])
+    assert_equal(:no_content, results[0].code)
+    assert_equal(Planet.count, count - 1)
+  end
+
+  def test_rollback_from_error
+    op = JSONAPI::ActiveRecordOperationsProcessor.new
+
+    count = Planet.count
+
+    operations = [
+      JSONAPI::RemoveResourceOperation.new(PlanetResource, 3),
+      JSONAPI::RemoveResourceOperation.new(PlanetResource, 4),
+      JSONAPI::RemoveResourceOperation.new(PlanetResource, 4)
+    ]
+
+    request = JSONAPI::Request.new
+    request.operations = operations
+
+    results = op.process(request)
+
+    assert_equal(Planet.count, count)
+
+    assert_kind_of(Array, results)
+    assert_equal(results.size, 3)
+
+    assert_kind_of(JSONAPI::OperationResult, results[0])
+    assert_equal(:no_content, results[0].code)
+    assert_equal(:no_content, results[1].code)
+    assert_equal(404, results[2].code)
+  end
+
+end