standardapi 6.0.0.26 → 6.1.0

data/lib/standard_api/views/application/new.streamer

@@ -1 +1 @@
-json.partial! model_partial(model), model_partial(model).split('/').last.to_sym => instance_variable_get("@#{model.model_name.singular}"), includes: includes
+json.partial! model_partial(model), model_partial(model).split('/').last.to_sym => instance_variable_get("@#{model.model_name.singular}"), includes: includes

data/lib/standard_api/views/application/schema.json.jbuilder

@@ -1,12 +1 @@
-json.set! 'columns' do
-  model.columns.each do |column|
-    json.set! column.name, {
-      type: json_column_type(column.sql_type),
-      primary_key: column.name == model.primary_key,
-      null: column.null,
-      array: column.array
-    }
-  end
-end
-
-json.set! 'limit', resource_limit
+json.partial!('schema', model: model)

data/lib/standard_api/views/application/schema.streamer

@@ -1,16 +1 @@
-json.object! do
-  json.set! 'columns' do
-    json.object! do
-      model.columns.each do |column|
-        json.set! column.name, {
-          type: json_column_type(column.sql_type),
-          primary_key: column.name == model.primary_key,
-          null: column.null,
-          array: column.array
-        }
-      end
-    end
-  end
-
-  json.set! 'limit', resource_limit
-end
+json.partial!('schema', model: model)

data/test/standard_api/caching_test.rb

@@ -0,0 +1,43 @@
+require 'standard_api/test_helper'
+
+class AccountsControllerTest < ActionDispatch::IntegrationTest
+
+  test 'include with cache' do
+    account = create(:account, photos: [])
+    photo = create(:photo, account_id: account.id)
+
+    t1 = 1.day.from_now
+    t2 = 2.days.from_now
+
+    columns = Account.column_names + ['photos_account_cached_at', 'photos_cached_at']
+    Account.stubs(:column_names).returns(columns)
+
+    # Cache Miss
+    Account.any_instance.stubs(:photos_cached_at).returns(t1)
+    get account_path(account, include: :photos, format: :json)
+    assert_equal [photo.id], JSON(response.body)['photos'].map{|x| x['id']}
+
+    # Cache Hit
+    Account.any_instance.stubs(:photos).returns([])
+    Account.any_instance.stubs(:photos_cached_at).returns(t1)
+    get account_path(account, include: :photos, format: :json)
+    assert_equal [photo.id], JSON(response.body)['photos'].map{|x| x['id']}
+
+    # Cache Miss, photos_cached_at updated
+    Account.any_instance.stubs(:photos).returns(Photo.where('false = true'))
+    Account.any_instance.stubs(:photos_cached_at).returns(t2)
+    get account_path(account, include: :photos, format: :json)
+    assert_equal [], JSON(response.body)['photos'].map{|x| x['id']}
+
+    # Two associations that reference the same model
+    property = create(:property)
+    account = create(:account, property: property, subject: property)
+    Account.any_instance.expects(:property_cached_at).returns(t1)
+    Account.any_instance.expects(:subject_cached_at).returns(t1)
+    get account_path(account, include: { property: true, subject: true }, format: 'json')
+    json = JSON(response.body)
+    assert json.has_key?('property')
+    assert json.has_key?('subject')
+  end
+
+end

data/test/standard_api/helpers_test.rb

@@ -0,0 +1,172 @@
+require 'standard_api/test_helper'
+
+class HelpersTest < ActionView::TestCase
+  include StandardAPI::Helpers
+
+  test "::cached_at_columns_for_includes(includes)" do
+    assert_equal(
+      ['photos_cached_at'],
+      cached_at_columns_for_includes({photos: {}})
+    )
+
+    assert_equal(
+      ['photos_cached_at', 'photos_account_cached_at'],
+      cached_at_columns_for_includes({photos: {account: {}}})
+    )
+
+    assert_equal(
+      ['photos_cached_at', 'photos_account_cached_at', 'photos_properties_cached_at'],
+      cached_at_columns_for_includes({photos: {account: {}, properties: {}}})
+    )
+
+    assert_equal(
+      ['photos_cached_at', 'photos_account_cached_at', 'photos_properties_cached_at', 'photos_properties_landlord_cached_at'],
+      cached_at_columns_for_includes({photos: {account: {}, properties: {landlord: {}}}})
+    )
+  end
+
+  test "::can_cache?" do
+    Account.expects(:column_names).returns(['id'])
+    assert !can_cache?(Account, {})
+
+    Account.expects(:column_names).returns(['id', 'cached_at'])
+    assert can_cache?(Account, {})
+
+    Account.expects(:column_names).returns(['id', 'cached_at'])
+    assert !can_cache?(Account, {photos: {}})
+
+    Account.expects(:column_names).returns(['id', 'cached_at', 'photos_cached_at'])
+    assert can_cache?(Account, {photos: {}})
+
+    Account.expects(:column_names).returns(['id', 'cached_at', 'photos_cached_at'])
+    assert !can_cache?(Account, {photos: {account: {}}})
+
+    Account.expects(:column_names).returns(['id', 'cached_at', 'photos_cached_at', 'photos_account_cached_at'])
+    assert can_cache?(Account, {photos: {account: {}}})
+  end
+
+  test '::can_cache_relation? with non-persisted record' do
+    account = build(:account)
+    assert !can_cache_relation?(account, :photos, {})
+    assert !can_cache_relation?(account, :photos, {})
+    assert !can_cache_relation?(account, :photos, {account: {}})
+    assert !can_cache_relation?(account, :photos, {account: {}})
+  end
+
+  test '::can_cache_relation? with persisted record' do
+    account = create(:account)
+
+    Account.expects(:column_names).returns(['id', 'cached_at'])
+    assert !can_cache_relation?(account, :photos, {})
+
+    Account.expects(:column_names).returns(['id', 'cached_at', 'photos_cached_at'])
+    assert can_cache_relation?(account, :photos, {})
+
+    Account.expects(:column_names).returns(['id', 'cached_at', 'photos_cached_at'])
+    assert !can_cache_relation?(account, :photos, {account: {}})
+
+    Account.expects(:column_names).returns(['id', 'cached_at', 'photos_cached_at', 'photos_account_cached_at'])
+    assert can_cache_relation?(account, :photos, {account: {}})
+  end
+
+  test '::association_cache_key(record, relation, subincludes)' do
+    account = create(:account)
+    photo = create(:photo, account: account)
+    t1 = Time.now
+    t2 = 1.day.from_now
+    t3 = 2.days.from_now
+
+    Account.expects(:column_names).returns(['id', 'cached_at', 'photos_cached_at', 'photos_property_cached_at'])
+    account.expects(:photos_cached_at).returns(t1)
+
+    assert_equal(
+      "accounts/#{account.id}/photos-#{t1.utc.to_s(ActiveRecord::Base.cache_timestamp_format)}",
+      association_cache_key(account, :photos, {})
+    )
+
+    Account.expects(:column_names).returns(['id', 'cached_at', 'photos_cached_at', 'photos_property_cached_at'])
+    account.expects(:photos_cached_at).returns(t1)
+    account.expects(:photos_property_cached_at).returns(t2)
+    assert_equal(
+      "accounts/#{account.id}/photos-2ea683a694a33359514c41435f8f0646-#{t2.utc.to_s(ActiveRecord::Base.cache_timestamp_format)}",
+      association_cache_key(account, :photos, {property: {}})
+    )
+
+    Account.expects(:column_names).returns(['id', 'cached_at', 'photos_cached_at', 'photos_property_cached_at'])
+    account.expects(:photos_cached_at).returns(t1)
+    account.expects(:photos_property_cached_at).returns(t2)
+    assert_equal(
+      "accounts/#{account.id}/photos-779c17ef027655fd8c06c3083d2df64b-#{t2.utc.to_s(ActiveRecord::Base.cache_timestamp_format)}",
+      association_cache_key(account, :photos, { "property" =>  { "order" => { "x" => "desc" }}})
+    )
+
+    Account.expects(:column_names).returns(['id', 'cached_at', 'photos_cached_at', 'photos_property_cached_at', 'photos_agents_cached_at'])
+    account.expects(:photos_cached_at).returns(t1)
+    account.expects(:photos_property_cached_at).returns(t2)
+    account.expects(:photos_agents_cached_at).returns(t3)
+    assert_equal(
+      "accounts/#{account.id}/photos-abbee2d4535400c162c8dbf14bbef6d5-#{t3.utc.to_s(ActiveRecord::Base.cache_timestamp_format)}",
+      association_cache_key(account, :photos, {property: {}, agents: {}})
+    )
+
+    Account.expects(:column_names).returns(['id', 'cached_at', 'photos_cached_at', 'photos_property_cached_at', 'photos_property_agents_cached_at'])
+    account.expects(:photos_cached_at).returns(t1)
+    account.expects(:photos_property_cached_at).returns(t2)
+    account.expects(:photos_property_agents_cached_at).returns(t3)
+    assert_equal(
+      "accounts/#{account.id}/photos-0962ae73347c5c605d329eaa25e2be49-#{t3.utc.to_s(ActiveRecord::Base.cache_timestamp_format)}",
+      association_cache_key(account, :photos, {property: {agents: {}}})
+    )
+
+    Account.expects(:column_names).returns(['id', 'cached_at', 'photos_cached_at', 'photos_property_cached_at', 'photos_agents_cached_at', 'photos_property_addresses_cached_at'])
+    account.expects(:photos_cached_at).returns(t1)
+    account.expects(:photos_property_cached_at).returns(t2)
+    account.expects(:photos_agents_cached_at).returns(t2)
+    account.expects(:photos_property_addresses_cached_at).returns(t3)
+    assert_equal(
+      "accounts/#{account.id}/photos-00ea6afe3ff68037f8b4dcdb275e2a24-#{t3.utc.to_s(ActiveRecord::Base.cache_timestamp_format)}",
+      association_cache_key(account, :photos, {property: {addresses: {}}, agents: {}})
+    )
+
+    # Belongs to
+    Photo.expects(:column_names).returns(['id', 'cached_at', 'account_cached_at'])
+    photo.expects(:account_cached_at).returns(t1)
+    assert_equal(
+      "accounts/#{account.id}-#{t1.utc.to_s(ActiveRecord::Base.cache_timestamp_format)}",
+      association_cache_key(photo, :account, {})
+    )
+
+    Photo.expects(:column_names).returns(['id', 'cached_at', 'account_cached_at', 'account_photos_cached_at'])
+    photo.expects(:account_cached_at).returns(t1)
+    photo.expects(:account_photos_cached_at).returns(t2)
+    assert_equal(
+      "accounts/#{account.id}/07437ce3863467f4cd715ae1ef930f08-#{t2.utc.to_s(ActiveRecord::Base.cache_timestamp_format)}",
+      association_cache_key(photo, :account, {photos: {}})
+    )
+  end
+
+  test '::json_column_type(sql_type)' do
+    assert_equal 'string', json_column_type('character varying')
+    assert_equal 'string', json_column_type('character varying(2)')
+    assert_equal 'string', json_column_type('character varying(255)')
+    assert_equal 'datetime', json_column_type('timestamp without time zone')
+    assert_equal 'datetime', json_column_type('time without time zone')
+    assert_equal 'string', json_column_type('text')
+    assert_equal 'hash', json_column_type('json')
+    assert_equal 'hash', json_column_type('jsonb')
+    assert_equal 'integer', json_column_type('bigint')
+    assert_equal 'integer', json_column_type('integer')
+    assert_equal 'string', json_column_type('inet')
+    assert_equal 'hash', json_column_type('hstore')
+    assert_equal 'datetime', json_column_type('date')
+    assert_equal 'decimal', json_column_type('numeric')
+    assert_equal 'decimal', json_column_type('numeric(12)')
+    assert_equal 'decimal', json_column_type('numeric(12,2)')
+    assert_equal 'decimal', json_column_type('double precision')
+    assert_equal 'string', json_column_type('ltree')
+    assert_equal 'boolean', json_column_type('boolean')
+    assert_equal 'ewkb', json_column_type('geometry')
+    assert_equal 'string', json_column_type('uuid')
+  end
+
+end

data/test/standard_api/performance.rb

@@ -0,0 +1,39 @@
+require 'standard_api/test_helper'
+require "benchmark/ips"
+
+TIME    = (ENV["BENCHMARK_TIME"] || 20).to_i
+RECORDS = (ENV["BENCHMARK_RECORDS"] || TIME * 1000).to_i
+
+app = ::ActionDispatch::IntegrationTest.new(:app)
+properties = Array.new(1000) do
+  photos = Array.new(10) { FactoryBot.create(:photo) }
+  FactoryBot.create(:property, photos: photos)
+end
+
+Benchmark.ips(TIME) do |x|
+
+  # ActionView::Template.unregister_template_handler :streamer
+  # ActionView::Template.register_template_handler :jbuilder, JbuilderHandler
+
+  x.report("#index.json.jbuilder") do
+    app.get('/properties.json', params: { limit: 100 })
+  end
+
+  x.report("#show.json.jbuilder") do
+    app.get("/properties/#{properties.sample.id}.json")
+  end
+
+  x.report("#show.json.jbuilder w/ include=photos") do
+    app.get("/properties/#{properties.sample.id}.json", params: { include: :photos })
+  end
+
+  # ActionView::Template.unregister_template_handler :jbuilder
+  # ActionView::Template.register_template_handler :streamer, TurboStreamer::Handler
+
+  # x.report("#index.json.streamer") do
+  #   app.get('/properties.json', params: { limit: 100 })
+  # end
+
+  # x.compare!
+
+end

data/test/standard_api/route_helpers_test.rb

@@ -0,0 +1,33 @@
+require 'standard_api/test_helper'
+
+class RouteHelpersTest < ActionDispatch::IntegrationTest
+
+  test 'standard_resources' do
+    assert_routing({ path: '/properties', method: :get }, { controller: 'properties', action: 'index' })
+    assert_routing({ path: '/properties/1', method: :get }, { controller: 'properties', action: 'show', id: '1' })
+    assert_routing({ path: '/properties/new', method: :get }, { controller: 'properties', action: 'new' })
+    assert_routing({ path: '/properties', method: :post }, { controller: 'properties', action: 'create' })
+    assert_routing({ path: '/properties/1', method: :put }, { controller: 'properties', action: 'update', id: '1' })
+    assert_routing({ path: '/properties/1', method: :patch }, { controller: 'properties', action: 'update', id: '1' })
+    assert_routing({ path: '/properties/1', method: :delete }, { controller: 'properties', action: 'destroy', id: '1' })
+    assert_routing({ path: '/properties/schema', method: :get }, { controller: 'properties', action: 'schema' })
+    assert_routing({ path: '/properties/calculate', method: :get }, { controller: 'properties', action: 'calculate' })
+  end
+
+  test 'standard_resource' do
+    assert_routing({ path: '/account', method: :get }, { controller: 'accounts', action: 'show' })
+    assert_routing({ path: '/account/new', method: :get }, { controller: 'accounts', action: 'new' })
+    assert_routing({ path: '/account', method: :post }, { controller: 'accounts', action: 'create' })
+    assert_routing({ path: '/account', method: :put }, { controller: 'accounts', action: 'update' })
+    assert_routing({ path: '/account', method: :patch }, { controller: 'accounts', action: 'update' })
+    assert_routing({ path: '/account', method: :delete }, { controller: 'accounts', action: 'destroy' })
+    assert_routing({ path: '/account/schema', method: :get }, { controller: 'accounts', action: 'schema' })
+    assert_routing({ path: '/account/calculate', method: :get }, { controller: 'accounts', action: 'calculate' })
+  end
+
+  test 'standard_resources subresource routes' do
+    assert_routing({ path: '/photos/1/properties/1', method: :post }, { controller: 'photos', action: 'add_resource', id: '1', relationship: 'properties', resource_id: '1' })
+    assert_routing({ path: '/photos/1/properties/1', method: :delete }, { controller: 'photos', action: 'remove_resource', id: '1', relationship: 'properties', resource_id: '1' })
+  end
+
+end

data/test/standard_api/standard_api_test.rb

@@ -0,0 +1,699 @@
+require 'standard_api/test_helper'
+
+class PropertiesControllerTest < ActionDispatch::IntegrationTest
+  include StandardAPI::TestCase
+  include StandardAPI::Helpers
+
+  self.includes = [ :photos, :landlord, :english_name ]
+
+  def normalizers
+    {
+      Property => {
+        "size" => lambda { |value| value.round(4).to_s }
+      }
+    }
+  end
+
+  # = Routing Tests
+  #
+  # These also can't be included in StandardAPI::TestCase because we don't know
+  # how the other's routes are setup
+
+  # test 'route to #metadata' do
+  #   assert_routing '/metadata', path_with_action('metadata')
+  #   assert_recognizes path_with_action('metadata'), "/metadata"
+  # end
+
+  test 'route to #tables.json' do
+    assert_recognizes({"controller"=>"application", "action"=>"tables"}, { method: :get, path: "/tables" })
+  end
+
+  test 'route to #create.json' do
+    assert_routing({ method: :post, path: "/#{plural_name}" }, path_with_action('create'))
+    assert_recognizes(path_with_action('create'), { method: :post, path: "/#{plural_name}" })
+  end
+
+  test 'route to #calculate.json' do
+    assert_routing "/#{plural_name}/calculate", path_with_action('calculate')
+    assert_recognizes(path_with_action('calculate'), "/#{plural_name}/calculate")
+  end
+
+  test 'route to #destroy.json' do
+    assert_routing({ method: :delete, path: "/#{plural_name}/1" }, path_with_action('destroy', id: '1'))
+    assert_recognizes(path_with_action('destroy', id: '1'), { method: :delete, path: "/#{plural_name}/1" })
+  end
+
+  test 'route to #index.json' do
+    assert_routing "/#{plural_name}", path_with_action('index')
+    assert_recognizes path_with_action('index'), "/#{plural_name}"
+  end
+
+  test 'route to #show.json' do
+    assert_routing "/#{plural_name}/1", path_with_action('show', id: '1')
+    assert_recognizes(path_with_action('show', id: '1'), "/#{plural_name}/1")
+  end
+
+  test 'route to #update.json' do
+    assert_routing({ method: :put, path: "#{plural_name}/1" }, path_with_action('update', id: '1'))
+    assert_recognizes(path_with_action('update', id: '1'), { method: :put, path: "/#{plural_name}/1" })
+    assert_routing({ method: :patch, path: "/#{plural_name}/1" }, path_with_action('update', id: '1'))
+    assert_recognizes(path_with_action('update', id: '1'), { method: :patch, path: "/#{plural_name}/1" })
+  end
+
+  test 'route to #schema.json' do
+    assert_routing({ method: :get, path: "/#{plural_name}/schema" }, path_with_action('schema'))
+    assert_recognizes(path_with_action('schema'), { method: :get, path: "/#{plural_name}/schema" })
+  end
+
+  # = Controller Tests
+
+  test 'StandardAPI-Version' do
+    get schema_references_path(format: 'json')
+    assert_equal StandardAPI::VERSION, response.headers['StandardAPI-Version']
+  end
+
+  test 'Controller#new' do
+    @controller = ReferencesController.new
+    assert_equal @controller.send(:model), Reference
+
+    @controller = SessionsController.new
+    assert_nil @controller.send(:model)
+    get new_session_path
+    assert_response :ok
+  end
+
+  test 'Controller#model_orders defaults to []' do
+    @controller = ReferencesController.new
+    assert_equal @controller.send(:model_orders), []
+  end
+
+  test 'Controller#model_includes defaults to []' do
+    @controller = DocumentsController.new
+    assert_equal @controller.send(:model_includes), []
+  end
+
+  test 'Controller#model_params defaults to []' do
+    @controller = ReferencesController.new
+    @controller.params = {}
+    assert_equal @controller.send(:model_params), ActionController::Parameters.new
+  end
+
+  test 'Controller#current_mask' do
+    @controller = ReferencesController.new
+    @controller.instance_variable_set('@current_mask', { 'references' => { 'subject_id' => 1 }})
+    @controller.params = {}
+    assert_equal 'SELECT "references".* FROM "references" WHERE "references"."subject_id" = 1', @controller.send(:resources).to_sql
+  end
+
+  test 'ApplicationController#schema.json' do
+    get schema_path(format: 'json')
+
+    schema = JSON(response.body)
+    controllers = ApplicationController.descendants
+    controllers.select! { |c| c.ancestors.include?(StandardAPI::Controller) && c != StandardAPI::Controller }
+
+    @controller.send(:models).reject { |x| x.name == 'Photo' }.each do |model|
+      assert_equal true, schema['models'].has_key?(model.name)
+
+      model_comment = model.connection.table_comment(model.table_name)
+      if model_comment.nil? then
+        assert_nil schema.dig('models', model.name, 'comment')
+      else
+        assert_equal model_comment, schema.dig('models', model.name, 'comment')
+      end
+
+      model.columns.each do |column|
+        assert_equal json_column_type(column.sql_type), schema.dig('models', model.name, 'attributes', column.name, 'type')
+        default = column.default
+        if default then
+          default = model.connection.lookup_cast_type_from_column(column).deserialize(default)
+          assert_equal default, schema.dig('models', model.name, 'attributes', column.name, 'default')
+        else
+          assert_nil schema.dig('models', model.name, 'attributes', column.name, 'default')
+        end
+        assert_equal column.name == model.primary_key, schema.dig('models', model.name, 'attributes', column.name, 'primary_key')
+        assert_equal column.null, schema.dig('models', model.name, 'attributes', column.name, 'null')
+        assert_equal column.array, schema.dig('models', model.name, 'attributes', column.name, 'array')
+        if column.comment then
+          assert_equal column.comment, schema.dig('models', model.name, 'attributes', column.name, 'comment')
+        else
+          assert_nil schema.dig('models', model.name, 'attributes', column.name, 'comment')
+        end
+      end
+    end
+
+    assert_equal 'test comment', schema['comment']
+  end
+
+  test 'Controller#schema.json' do
+    get schema_references_path(format: 'json')
+
+    schema = JSON(response.body)
+    assert_equal true, schema.has_key?('attributes')
+    assert_equal true, schema['attributes']['id']['primary_key']
+    assert_equal 1000, schema['limit']
+  end
+
+  test 'Controller#schema.json w/o limit' do
+    get schema_unlimited_index_path(format: 'json')
+
+    schema = JSON(response.body)
+    assert_equal true, schema.has_key?('attributes')
+    assert_equal true, schema['attributes']['id']['primary_key']
+    assert_nil schema['limit']
+  end
+
+  test 'Controller#index w/o limit' do
+    account = create(:account)
+    get unlimited_index_path(format: 'json')
+
+    assert_equal [account.id], JSON(response.body).map { |x| x['id'] }
+  end
+
+  test 'Controller#index with default limit' do
+    create(:account)
+    get default_limit_index_path(format: 'json')
+    assert_response :ok
+  end
+
+  test 'Controller#create redirects to correct route with STI models' do
+    attrs = attributes_for(:pdf)
+    post documents_path, params: { document: attrs }
+    assert_response :redirect
+  end
+
+  test 'Controller#update redirects to correct route with STI models' do
+    pdf = create(:pdf)
+    patch document_path(pdf), params: { document: pdf.attributes }
+    assert_redirected_to document_path(pdf)
+  end
+
+  test 'Controller#add_resource' do
+    property = create(:property, photos: [])
+    photo = create(:photo)
+
+    post "/properties/#{property.id}/photos/#{photo.id}"
+    assert_equal property.photos.reload.map(&:id), [photo.id]
+    assert_response :created
+
+    post "/properties/#{property.id}/photos/9999999"
+    assert_response :not_found
+  end
+
+  test 'Controller#add_resource with has_one' do
+    photo = create(:document)
+    property = create(:property)
+    post "/properties/#{property.id}/document/#{photo.id}"
+    assert_equal property.reload.document, photo
+    assert_response :created
+  end
+
+  test 'Controller#remove_resource' do
+    photo = create(:photo)
+    property = create(:property, photos: [photo])
+    assert_equal property.photos.reload, [photo]
+    delete "/properties/#{property.id}/photos/#{photo.id}"
+    assert_equal property.photos.reload, []
+    assert_response :no_content
+
+    delete "/properties/#{property.id}/photos/9999999"
+    assert_response :not_found
+  end
+
+  test 'Controller#remove_resource with has_one' do
+    photo = create(:document)
+    property = create(:property, document: photo)
+    assert_equal property.document, photo
+    delete "/properties/#{property.id}/document/#{photo.id}"
+    assert_nil property.reload.document
+    assert_response :no_content
+  end
+
+  # = View Tests
+
+  test 'rendering tables' do
+    get tables_path(format: 'json')
+    assert_response :ok
+    # assert_equal ['properties', 'accounts', 'photos', 'references', 'sessions', 'unlimited'], response.parsed_body
+    # Multiple 'accounts' because multiple controllers with that model for testing.
+    assert_equal ["properties", "accounts", "documents", "photos", "references", "accounts", 'accounts'].sort, response.parsed_body.sort
+  end
+
+  test 'rendering null attribute' do
+    property = create(:property)
+    get property_path(property, format: 'json'), params: { id: property.id, include: [:landlord] }
+    assert JSON(response.body).has_key?('landlord')
+    assert_nil JSON(response.body)['landlord']
+  end
+
+  test 'rendering null attribute for has_one through' do
+    property = create(:property)
+    get property_path(property, format: 'json'), params: { id: property.id, include: [:document] }
+    assert JSON(response.body).has_key?('document')
+    assert_nil JSON(response.body)['document']
+  end
+
+  test '#index.json uses overridden partial' do
+    create(:property, photos: [create(:photo)])
+    get properties_path(format: 'json'), params: { limit: 100, include: [{:photos => { order: :id }}] }
+
+    photo = JSON(response.body)[0]['photos'][0]
+    assert_equal true, photo.has_key?('template')
+    assert_equal 'photos/_photo', photo['template']
+  end
+
+  test '#show.json uses overridden partial' do
+    property = create(:property, photos: [create(:photo)])
+    get property_path(property, format: 'json'), params: { id: property.id, include: [:photos] }
+
+    photo = JSON(response.body)['photos'][0]
+    assert_equal true, photo.has_key?('template')
+    assert_equal 'photos/_photo', photo['template']
+  end
+
+  test '#schema.json uses overridden partial' do
+    get schema_photos_path(format: 'json')
+
+    schema = JSON(response.body)
+    assert_rendered 'photos/schema', format: 'json', handler: 'jbuilder'
+    assert_equal true, schema.has_key?('template')
+    assert_equal 'photos/schema', schema['template']
+  end
+
+  test 'application#schema.json renders overridden #schema.json partials' do
+    get schema_path(format: 'json')
+
+    schema = JSON(response.body)
+    assert_rendered 'application/schema', format: 'json', handler: 'jbuilder'
+    assert_equal 'photos/schema', schema.dig('models', 'Photo', 'template')
+  end
+
+  test 'belongs_to polymorphic association' do
+    photo = create(:photo)
+    reference = create(:reference, subject: photo)
+    get reference_path(reference, include: :subject, format: 'json')
+
+    json = JSON(response.body)
+    assert_equal 'photos/_photo', json['subject']['template']
+  end
+
+  test '#index.json includes polymorphic association' do
+    property1 = create(:property)
+    property2 = create(:property)
+    photo = create(:photo)
+    create(:reference, subject: property1)
+    create(:reference, subject: property2)
+    create(:reference, subject: photo)
+
+    get references_path(format: 'json'), params: { include: [:subject], limit: 10 }
+
+    json = JSON(response.body)
+    assert_equal 'photos/_photo', json.find { |x| x['subject_type'] == "Photo"}['subject']['template']
+  end
+
+  test 'has_many association' do
+    p = create(:property, photos: [create(:photo)])
+    get properties_path(format: 'json'), params: { limit: 100, include: [:photos] }
+    assert_equal p.photos.first.id, JSON(response.body)[0]['photos'][0]['id']
+  end
+
+  test 'belongs_to association' do
+    account = create(:account)
+    photo = create(:photo, account: account)
+    get photo_path(photo, include: 'account', format: 'json')
+    assert_equal account.id, JSON(response.body)['account']['id']
+  end
+
+  test 'has_one association' do
+    account = create(:account)
+    property = create(:property, landlord: account)
+    get property_path(property, include: 'landlord', format: 'json')
+    assert_equal account.id, JSON(response.body)['landlord']['id']
+  end
+
+  test 'include method' do
+    property = create(:property)
+    get property_path(property, include: 'english_name', format: 'json')
+    assert_equal 'A Name', JSON(response.body)['english_name']
+  end
+
+  test 'include with where key' do
+    photo_a = create(:photo)
+    photo_b = create(:photo)
+    photo_c = create(:photo)
+
+    property = create(:property, photos: [photo_b, photo_c])
+    get property_path(property, include: { photos: { where: { id: photo_a.id } } }, format: :json)
+    assert_equal [], JSON(response.body)['photos']
+
+    property.photos << photo_a
+    get property_path(property, include: { photos: { where: { id: photo_a.id } } }, format: :json)
+    assert_equal [photo_a.id], JSON(response.body)['photos'].map { |x| x['id'] }
+    get property_path(property, include: { photos: { where: [
+      { id: photo_a.id },
+      'OR',
+      { id: photo_c.id}
+    ] } }, format: :json)
+    assert_equal [photo_a.id, photo_c.id].sort,
+      JSON(response.body)['photos'].map { |x| x['id'] }.sort
+  end
+
+  test 'include with order key' do
+    photos = Array.new(5) { create(:photo) }
+    property = create(:property, photos: photos)
+
+    get property_path(property, include: { photos: { order: { id: :asc } } }, format: 'json')
+    assert_equal photos.map(&:id).sort, JSON(response.body)['photos'].map { |x| x['id'] }
+  end
+
+  test 'include relation with default order using an order key' do
+    p1 = create(:photo)
+    p2 = create(:photo)
+    account = create(:account, photos: [ p1, p2 ])
+    get account_path(account, include: { photos: { order: { created_at: :desc } } }, format: 'json')
+    assert_equal [ p2.id, p1.id ], JSON(response.body)['photos'].map { |x| x["id"] }
+  end
+
+  test 'include with limit key' do
+    5.times { create(:property, photos: Array.new(5) { create(:photo) }) }
+    get properties_path(include: { photos: { limit: 1 } }, limit: 5, format: 'json')
+
+    properties = JSON(response.body)
+    assert_equal 5, properties.length
+
+    properties.each do |property|
+      assert_equal 1, property['photos'].length
+    end
+  end
+
+  test 'include with when key' do
+    photo = create(:photo)
+    account = create(:account, photos: [ photo ])
+    account_reference = create(:reference, subject: account)
+
+    property = create(:property, landlord: account)
+    property_reference = create(:reference, subject: property)
+
+
+    get references_path(
+      include: {
+        "subject" => {
+          "landlord" => {
+            "when" => {
+              "subject_type" => 'Property'
+            }
+          },
+          "photos" => {
+            "when" => {
+              "subject_type" => 'Account'
+            }
+          }
+        }
+      },
+      limit: 20,
+      format: 'json'
+    )
+
+    json = JSON(response.body)
+
+    assert_equal photo.id, json.find { |x| x['id'] == account_reference.id }.dig('subject', 'photos', 0, 'id')
+    assert_equal account.id, json.find { |x| x['id'] == property_reference.id }.dig('subject', 'landlord', 'id')
+  end
+
+  test 'include with distinct key' do
+    account = create(:account)
+    photos = Array.new(5) { create(:photo, account: account) }
+    property = create(:property, photos: photos)
+
+    get property_path(property, include: { photos: { distinct: true } }, format: 'json')
+    assert_equal 5, JSON(response.body)['photos'].size
+  end
+
+  test 'include with distinct_on key' do
+    account = create(:account)
+    photos = Array.new(5) { create(:photo, account: account) }
+    property = create(:property, photos: photos)
+
+    get property_path(property,
+      include: {
+        photos: {
+          distinct_on: :account_id,
+          # order: [:account_id, { id: :asc }]
+          order: { account_id: :asc, id: :asc }
+        }
+      },
+      format: 'json')
+
+    assert_equal [photos.first.id], JSON(response.body)['photos'].map { |x| x['id'] }
+
+    get property_path(property,
+      include: {
+        photos: {
+          distinct_on: :account_id,
+          order: { account_id: :asc, id: :desc }
+        }
+      }, format: 'json')
+
+    assert_equal [photos.last.id], JSON(response.body)['photos'].map { |x| x['id'] }
+  end
+
+  test 'unknown inlcude' do
+    property = create(:property, accounts: [ create(:account) ])
+    get property_path(property, include: [:accounts], format: 'json')
+    assert_response :bad_request
+    assert_equal 'found unpermitted parameter: "accounts"', response.body
+  end
+
+  test 'unknown order' do
+    create(:property)
+    get properties_path(order: 'updated_at', limit: 1, format: 'json')
+    assert_response :bad_request
+    assert_equal 'found unpermitted parameter: "updated_at"', response.body
+  end
+
+  # Includes Test
+
+  test 'Includes::normailze' do
+    method = StandardAPI::Includes.method(:normalize)
+    assert_equal method.call(:x), { 'x' => {} }
+    assert_equal method.call([:x, :y]), { 'x' => {}, 'y' => {} }
+    assert_equal method.call([ { x: true }, { y: true } ]), { 'x' => {}, 'y' => {} }
+    assert_equal method.call({ x: true, y: true }), { 'x' => {}, 'y' => {} }
+    assert_equal method.call({ x: { y: true } }), { 'x' => { 'y' => {} } }
+    assert_equal method.call({ x: { y: {} } }), { 'x' => { 'y' => {} } }
+    assert_equal method.call({ x: [:y] }), { 'x' => { 'y' => {} } }
+
+
+    assert_equal method.call({ x: { where: { y: false } } }), { 'x' => { 'where' => { 'y' => false } } }
+    assert_equal method.call({ x: { order: { y: :asc } } }), { 'x' => { 'order' => { 'y' => :asc } } }
+  end
+
+  # sanitize({:key => {}}, [:key]) # => {:key => {}}
+  # sanitize({:key => {}}, {:key => true}) # => {:key => {}}
+  # sanitize({:key => {}}, :value => {}}, [:key]) => # Raises ParseError
+  # sanitize({:key => {}}, :value => {}}, {:key => true}) => # Raises ParseError
+  # sanitize({:key => {:value => {}}}, {:key => [:value]}) # => {:key => {:value => {}}}
+  # sanitize({:key => {:value => {}}}, {:key => {:value => true}}) # => {:key => {:value => {}}}
+  # sanitize({:key => {:value => {}}}, [:key]) => # Raises ParseError
+  test 'Includes::sanitize' do
+    method = StandardAPI::Includes.method(:sanitize)
+    assert_equal method.call(:x, [:x]), { 'x' => {} }
+    assert_equal method.call(:x, {:x => true}), { 'x' => {} }
+
+    assert_raises(StandardAPI::UnpermittedParameters) do
+      method.call([:x, :y], [:x])
+    end
+
+    assert_raises(StandardAPI::UnpermittedParameters) do
+      method.call([:x, :y], {:x => true})
+    end
+
+    assert_raises(StandardAPI::UnpermittedParameters) do
+      method.call({:x => true, :y => true}, [:x])
+    end
+    assert_raises(StandardAPI::UnpermittedParameters) do
+      method.call({:x => true, :y => true}, {:x => true})
+    end
+    assert_raises(StandardAPI::UnpermittedParameters) do
+      method.call({ x: { y: true }}, { x: true })
+    end
+
+    assert_equal method.call({ x: { y: true }}, { x: { y: true } }), { 'x' => { 'y' => {} } }
+  end
+
+  # Order Test
+
+  test 'Orders::sanitize(:column, [:column])' do
+    method = StandardAPI::Orders.method(:sanitize)
+
+    assert_equal :x, method.call(:x, :x)
+    assert_equal :x, method.call(:x, [:x])
+    assert_equal :x, method.call([:x], [:x])
+    assert_raises(StandardAPI::UnpermittedParameters) do
+      method.call(:x, :y)
+    end
+
+    assert_equal({ x: :asc }, method.call({ x: :asc }, :x))
+    assert_equal({ x: :desc }, method.call({ x: :desc }, :x))
+    assert_equal([{ x: :desc}, {y: :desc }], method.call({ x: :desc, y: :desc }, [:x, :y]))
+    assert_equal({ x: :asc }, method.call([{ x: :asc }], :x))
+    assert_equal({ x: :desc }, method.call([{ x: :desc }], :x))
+    assert_equal({ x: { asc: :nulls_last } }, method.call([{ x: { asc: :nulls_last } }], :x))
+    assert_equal({ x: { asc: :nulls_first } }, method.call([{ x: { asc: :nulls_first } }], :x))
+    assert_equal({ x: { desc: :nulls_last } }, method.call([{ x: { desc: :nulls_last } }], :x))
+    assert_equal({ x: { desc: :nulls_first }}, method.call([{ x: { desc: :nulls_first } }], :x))
+    assert_equal({ relation: :id }, method.call(['relation.id'], { relation: :id }))
+    assert_equal({ relation: :id }, method.call([{ relation: :id }], { relation: :id }))
+    assert_equal({ relation: :id }, method.call([{ relation: :id }], [{ relation: :id }]))
+    assert_equal({ relation: :id }, method.call([{ relation: [:id] }], { relation: [:id] }))
+    assert_equal({ relation: :id }, method.call([{ relation: [:id] }], [{ relation: [:id] }]))
+    assert_equal({ relation: { id: :desc } }, method.call([{'relation.id' => :desc}], { relation: :id }))
+    assert_equal({ relation: { id: :desc } }, method.call([{ relation: { id: :desc } }], { relation: [:id] }))
+    assert_equal({ relation: { id: :desc } }, method.call([{ relation: { id: :desc } }], [{ relation: [:id] }]))
+    assert_equal({ relation: { id: :desc } }, method.call([{ relation: [{ id: :desc }] }], [{ relation: [:id] }]))
+    assert_equal({ relation: { id: :desc } }, method.call([{ relation: [{ id: :desc }] }], [{ relation: [:id] }]))
+    assert_equal({ relation: {:id => {:asc => :nulls_last}} }, method.call([{ relation: {:id => {:asc => :nulls_last}} }], [{ relation: [:id] }]))
+    assert_equal({ relation: {:id => {:asc => :nulls_last}} }, method.call([{ relation: {:id => {:asc => :nulls_last}} }], [{ relation: [:id] }]))
+    assert_equal({ relation: {:id => [{:asc => :nulls_last}]} }, method.call([{ relation: {:id => [{:asc => :nulls_last}]} }], [{ relation: [:id] }]))
+    assert_equal({ relation: {:id => [{:asc => :nulls_last}]} }, method.call([{ relation: {:id => [{:asc => :nulls_last}]} }], [{ relation: [:id] }]))
+  end
+
+  test 'order: :attribute' do
+    properties = Array.new(2) { create(:property) }
+
+    get properties_path(order: :id, limit: 100, format: 'json')
+    assert_equal properties.map(&:id).sort, JSON(response.body).map { |x| x['id'] }
+  end
+
+  test 'order: { attribute: :direction }' do
+    properties = Array.new(2) { create(:property) }
+
+    get properties_path(order: { id: :asc }, limit: 100, format: 'json')
+    assert_equal properties.map(&:id).sort, JSON(response.body).map { |x| x['id'] }
+
+    get properties_path(order: { id: :desc }, limit: 100, format: 'json')
+    assert_equal properties.map(&:id).sort.reverse, JSON(response.body).map { |x| x['id'] }
+  end
+
+  test 'order: { attribute: { direction: :nulls } }' do
+    properties = [ create(:property), create(:property, description: nil) ]
+
+    get properties_path(order: { description: { asc: :nulls_last } }, limit: 100, format: 'json')
+    assert_equal properties.map(&:id).sort, JSON(response.body).map { |x| x['id'] }
+
+    get properties_path(order: { description: { asc: :nulls_first } }, limit: 100, format: 'json')
+    assert_equal properties.map(&:id).sort.reverse, JSON(response.body).map { |x| x['id'] }
+  end
+
+  test 'ordering via nulls_first/last' do
+    p1 = create(:property, description: 'test')
+    p2 = create(:property, description: nil)
+
+    get properties_path(format: 'json'), params: { limit: 100, order: { description: { desc: 'nulls_last' } } }
+    properties = JSON(response.body)
+    assert_equal p1.id, properties.first['id']
+
+    get properties_path(format: 'json'), params: { limit: 100, order: { description: { asc: 'nulls_last' } } }
+    properties = JSON(response.body)
+    assert_equal p1.id, properties.first['id']
+  end
+
+  # Calculate Test
+  test 'calculate' do
+    create(:photo)
+    get '/photos/calculate', params: {select: {count: "*"}}
+    assert_equal [1], JSON(response.body)
+  end
+
+  test 'calculate distinct aggregation' do
+    assert_sql(<<-SQL) do
+      SELECT DISTINCT COUNT("properties"."id") FROM "properties"
+    SQL
+      create(:property)
+      create(:property)
+      get '/properties/calculate', params: {
+        select: { count: "id" },
+        distinct: true
+      }
+      assert_equal [2], JSON(response.body)
+    end
+  end
+
+  test 'calculate aggregation distinctly' do
+    assert_sql(<<-SQL) do
+      SELECT COUNT(DISTINCT "properties"."id") FROM "properties"
+    SQL
+      create(:property)
+      create(:property)
+      get '/properties/calculate', params: {
+        select: { count: { distinct: "id" } }
+      }
+      assert_equal [2], JSON(response.body)
+    end
+  end
+
+  test 'calculate distinct aggregation distinctly' do
+    assert_sql(<<-SQL) do
+      SELECT DISTINCT COUNT(DISTINCT "properties"."id") FROM "properties"
+    SQL
+      create(:property)
+      create(:property)
+      get '/properties/calculate', params: {
+        select: { count: { distinct: "id" } },
+        distinct: true
+      }
+      assert_equal [2], JSON(response.body)
+    end
+  end
+
+  test 'calculate distinct count' do
+    p1 = create(:property)
+    p2 = create(:property)
+    a1 = create(:account, property: p1)
+    a2 = create(:account, property: p2)
+    get '/properties/calculate', params: {
+      select: { count: 'id' },
+      where: {
+        accounts: {
+          id: [a1.id, a2.id]
+        }
+      },
+      group_by: 'id',
+      distinct: true
+    }
+    assert_equal Hash[p1.id.to_s, 1, p2.id.to_s, 1], JSON(response.body)
+  end
+
+  test 'calculate group_by' do
+    create(:photo, format: 'jpg')
+    create(:photo, format: 'jpg')
+    create(:photo, format: 'png')
+    get '/photos/calculate', params: {select: {count: "*"}, group_by: 'format'}
+    assert_equal ({'png' => 1, 'jpg' => 2}), JSON(response.body)
+  end
+
+  test 'calculate join' do
+    p1 = create(:property)
+    p2 = create(:property)
+    create(:account, photos_count: 1, property: p1)
+    create(:account, photos_count: 2, property: p2)
+
+    get '/properties/calculate', params: {select: {sum: "accounts.photos_count"}, join: 'accounts'}
+    assert_equal [3], JSON(response.body)
+  end
+
+  test 'calculate count distinct' do
+    photo = create(:photo)
+    landlord = create(:account)
+    create(:property, landlord: landlord, photos: [photo])
+    create(:property, landlord: landlord, photos: [photo])
+
+    get '/photos/calculate', params: {select: {count: "*"},
+      where: {properties: {landlord: {id: landlord.id}}},
+      distinct: true
+    }
+
+    assert_equal [1], JSON(response.body)
+  end
+
+end