standardapi 6.0.0.30 → 6.0.0.32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf7ed75a06eda9f024ebd87caccab44573802435d0494944137d92da6403fca2
-  data.tar.gz: f44ad9cdd0d8bb87bc971f0b11b8f50b5f5f1289911d7bf4764f6f867b59b407
+  metadata.gz: 6f8e9f6eee237614e9c303c8fe9e2e624b081272627f9a7aa3f680276872c1a9
+  data.tar.gz: 73ede0c9b6229117b4781071441ac0581a06b16592f95f04959932c010ecb8f0
 SHA512:
-  metadata.gz: 2f0f4ba53a851f87467a584b0a37708a1d2c6a52fc3360c31fbd50462af17918b7c43b435001410984291db24a451940e97487fc549f993d35ecc63d832d3b20
-  data.tar.gz: 26d70be42fd115039c04a4a0ba614225c05a549af0847d3473659c9d593002cd11addcfd330000163eb9d1597843c274593ba99ddd6f9a57ee39b83e8a05fcbb
+  metadata.gz: 904192ff81007b628b672e094dfaad19f4b2c49a0e4119631dd46c320a85d0e2c06200b5570d29d3b70ded73046b843dfd28ce3e40358d3b2294bbf9bb7b50f6
+  data.tar.gz: f9ed735aabd0830d6b2c7a390d4f2bca3bf8bcc1d8b806b615a76462404f58c9b65241c75e7b7e62abe84539705249ed10c82f9f5dcc4cc1ee4911e51513200f

data/lib/standard_api/version.rb

@@ -1,3 +1,3 @@
 module StandardAPI
-  VERSION = '6.0.0.30'
+  VERSION = '6.0.0.32'
 end

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

@@ -6,39 +6,42 @@ end
 
 includes.each do |inc, subinc|
   next if ["limit", "offset", "order", "when", "where", "distinct", "distinct_on"].include?(inc)
-  
+
+
   case association = record.class.reflect_on_association(inc)
-  when ActiveRecord::Reflection::HasManyReflection, ActiveRecord::Reflection::HasAndBelongsToManyReflection, ActiveRecord::Reflection::ThroughReflection
-    can_cache = can_cache_relation?(record.class, inc, subinc)
-    json.cache_if!(can_cache, can_cache ? association_cache_key(record, inc, subinc) : nil) do
-      partial = model_partial(association.klass)
-      json.set! inc do
-        # TODO limit causes preloaded assocations to reload
-        sub_records = record.send(inc)
-        
-        sub_records = sub_records.limit(subinc['limit']) if subinc['limit']
-        sub_records = sub_records.offset(subinc['offset']) if subinc['offset']
-        sub_records = sub_records.order(subinc['order']) if subinc['order']
-        sub_records = sub_records.filter(subinc['where']) if subinc['where']
-        sub_records = sub_records.distinct if subinc['distinct']
-        sub_records = sub_records.distinct_on(subinc['distinct_on']) if subinc['distinct_on']
+  when ActiveRecord::Reflection::AbstractReflection
+    if association.collection?
+      can_cache = can_cache_relation?(record.class, inc, subinc)
+      json.cache_if!(can_cache, can_cache ? association_cache_key(record, inc, subinc) : nil) do
+        partial = model_partial(association.klass)
+        json.set! inc do
+          # TODO limit causes preloaded assocations to reload
+          sub_records = record.send(inc)
+
+          sub_records = sub_records.limit(subinc['limit']) if subinc['limit']
+          sub_records = sub_records.offset(subinc['offset']) if subinc['offset']
+          sub_records = sub_records.order(subinc['order']) if subinc['order']
+          sub_records = sub_records.filter(subinc['where']) if subinc['where']
+          sub_records = sub_records.distinct if subinc['distinct']
+          sub_records = sub_records.distinct_on(subinc['distinct_on']) if subinc['distinct_on']
 
-        json.array! sub_records, partial: partial, as: partial.split('/').last, locals: { includes: subinc }
+          json.array! sub_records, partial: partial, as: partial.split('/').last, locals: { includes: subinc }
+        end
       end
-    end
-  when ActiveRecord::Reflection::BelongsToReflection, ActiveRecord::Reflection::HasOneReflection
-    can_cache = can_cache_relation?(record.class, inc, subinc)
-    if association.is_a?(ActiveRecord::Reflection::BelongsToReflection)
-      can_cache = can_cache && !record.send(association.foreign_key).nil?
-    end
-    json.cache_if!(can_cache, can_cache ? association_cache_key(record, inc, subinc) : nil) do
-      value = record.send(inc)
-      if value.nil?
-        json.set! inc, nil
-      else
-        partial = model_partial(value)
-        json.set! inc do
-          json.partial! partial, partial.split('/').last.to_sym => value, includes: subinc
+    else
+      can_cache = can_cache_relation?(record.class, inc, subinc)
+      if association.is_a?(ActiveRecord::Reflection::BelongsToReflection)
+        can_cache = can_cache && !record.send(association.foreign_key).nil?
+      end
+      json.cache_if!(can_cache, can_cache ? association_cache_key(record, inc, subinc) : nil) do
+        value = record.send(inc)
+        if value.nil?
+          json.set! inc, nil
+        else
+          partial = model_partial(value)
+          json.set! inc do
+            json.partial! partial, partial.split('/').last.to_sym => value, includes: subinc
+          end
         end
       end
     end
@@ -57,7 +60,7 @@ includes.each do |inc, subinc|
       end
     end
   end
-  
+
 end
 
 if !record.errors.blank?

data/test/standard_api/caching_test.rb

@@ -0,0 +1,33 @@
+require 'standard_api/test_helper'
+
+class AccountsControllerTest < ActionController::TestCase
+
+  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 :show, params: {id: account.id, 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 :show, params: {id: account.id, 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 :show, params: {id: account.id, include: :photos}, format: :json
+    assert_equal [], JSON(response.body)['photos'].map{|x| x['id']}
+  end
+
+end

data/test/standard_api/helpers_test.rb

@@ -0,0 +1,156 @@
+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?' do
+    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)
+    t1 = Time.now
+    t2 = 1.day.from_now
+    t3 = 2.days.from_now
+
+    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(: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(: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(: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(: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(: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 = create(:photo, account: account)
+    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 = create(:photo, account: account)
+    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,591 @@
+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.to_i }
+  #     }
+  #   }
+  # 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
+    assert_equal @controller.send(:model_params), []
+  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 || column.default_function
+        if default then
+          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}.json"
+    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#remove_resource' do
+    photo = create(:photo)
+    property = create(:property, photos: [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
+
+  # = 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_equal true, 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)
+
+    property = create(:property, photos: [photo_b])
+    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'] }
+  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 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 json.find { |x| x['id'] == account_reference.id }.dig('subject', 'photos', 0, 'id'), photo.id
+    assert_equal json.find { |x| x['id'] == property_reference.id }.dig('subject', 'landlord', 'id'), account.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
+
+  # Calculate Test
+  test 'calculate' do
+    create(:photo)
+    get '/photos/calculate', params: {select: {count: "*"}}
+    assert_equal [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

data/test/standard_api/test_app/controllers.rb

@@ -33,7 +33,7 @@ class ApplicationController < ActionController::Base
   end
 
   def property_includes
-    [:photos, :landlord, :english_name]
+    [:photos, :landlord, :english_name, :document]
   end
 
   def reference_includes

data/test/standard_api/test_app/models.rb

@@ -21,6 +21,8 @@ class Property < ActiveRecord::Base
   has_and_belongs_to_many :photos
   has_many :accounts
   has_one :landlord, class_name: 'Account'
+  has_one :document_attachments, class_name: "Attachment", as: :record, inverse_of: :record
+  has_one :document, through: "document_attachments"
 
   validates :name, presence: true
   accepts_nested_attributes_for :photos
@@ -34,6 +36,15 @@ class Reference < ActiveRecord::Base
   belongs_to :subject, polymorphic: true
 end
 
+class Document < ActiveRecord::Base
+  attr_accessor :file
+end
+
+class Attachment < ActiveRecord::Base
+  belongs_to :record, polymorphic: true
+  belongs_to :document
+end
+
 # = Migration
 
 class CreateModelTables < ActiveRecord::Migration[6.0]
@@ -87,6 +98,12 @@ class CreateModelTables < ActiveRecord::Migration[6.0]
     create_table "documents", force: :cascade do |t|
       t.string   'type'
     end
+    
+    create_table "attachments", force: :cascade do |t| 
+      t.string  'record_type'
+      t.integer  'record_id'
+      t.integer  'document_id'
+    end
   end
 
 end

data/test/standard_api/test_helper.rb

@@ -0,0 +1,226 @@
+require File.expand_path('../test_app', __FILE__)
+
+require "minitest/autorun"
+require 'minitest/unit'
+require 'factory_bot'
+require 'faker'
+require 'standard_api/test_case'
+require 'byebug'
+require 'mocha/minitest'
+
+# Setup the test db
+ActiveSupport.test_order = :random
+
+include ActionDispatch::TestProcess
+
+class ActiveSupport::TestCase
+  include ActiveRecord::TestFixtures
+  include FactoryBot::Syntax::Methods
+
+  def setup
+    @routes ||= TestApplication.routes
+    @subscribers, @layouts, @partials = [], {}, {}
+
+    Rails.cache.clear
+
+    @subscribers << ActiveSupport::Notifications.subscribe("!render_template.action_view") do |_name, _start, _finish, _id, payload|
+      path = payload[:identifier]
+      virtual_path = payload[:virtual_path]
+      format, handler = *path.split("/").last.split('.').last(2)
+
+      partial = virtual_path =~ /^.*\/_[^\/]*$/
+
+      if partial
+        if @partials[virtual_path]
+          @partials[virtual_path][:count] += 1
+        else
+          @partials[virtual_path] = {
+            count: 1,
+            path: virtual_path,
+            format: format,
+            handler: handler
+          }
+        end
+      else
+        if @layouts[virtual_path]
+          @layouts[virtual_path][:count] += 1
+        else
+          @layouts[virtual_path] = {
+            count: 1,
+            path: virtual_path,
+            format: format,
+            handler: handler
+          }
+        end
+      end
+    end
+  end
+
+  def teardown
+    @subscribers.each do |subscriber|
+      ActiveSupport::Notifications.unsubscribe(subscriber)
+    end
+  end
+
+  # = Helper Methods
+
+  def controller_path
+    if defined?(@controller)
+      @controller.controller_path
+    else
+      controller_class.new.controller_path
+    end
+  end
+
+  def path_with_action(action, options={})
+    { :controller => controller_path, :action => action }.merge(options)
+  end
+
+  def assert_rendered(options = {}, message = nil)
+    options = case options
+    when NilClass, Regexp, String, Symbol
+      { layout: options }
+    when Hash
+      options
+    else
+      raise ArgumentError, "assert_template only accepts a String, Symbol, Hash, Regexp, or nil"
+    end
+
+    options.assert_valid_keys(:layout, :partial, :count, :format, :handler)
+
+    if expected_layout = options[:layout]
+      case expected_layout
+      when String, Symbol
+        msg = message || sprintf("expecting layout <%s> but action rendered <%s>",
+          expected_layout, @layouts.keys)
+        assert_includes @layouts.keys, expected_layout.to_s, msg
+
+        key = expected_layout.to_s
+        value = @layouts[key]
+
+        if expected_count = options[:count]
+          actual_count = value[:count]
+          msg = message || sprintf("expecting %s to be rendered %s time(s) but rendered %s time(s)",
+                 expected_partial, expected_count, actual_count)
+          assert_equal expected_count, actual_count, msg
+        end
+
+        if expected_format = options[:format]
+          actual_format = value[:format]
+          msg = message || sprintf("expecting %s to be rendered as %s but rendered as %s",
+                 expected_partial, expected_format, actual_format)
+          assert_equal expected_format, actual_format, msg
+        end
+
+        if expected_handler = options[:handler]
+          actual_handler = value[:handler]
+          msg = message || sprintf("expecting %s to be rendered as %s but rendered as %s",
+                 expected_partial, expected_handler, actual_handler)
+          assert_equal expected_handler, actual_handler, msg
+        end
+      when Regexp
+        msg = message || sprintf("expecting layout <%s> but action rendered <%s>",
+          expected_layout, @layouts.keys)
+        assert(@layouts.keys.any? {|l| l =~ expected_layout }, msg)
+
+        key = @layouts.keys.find {|l| l =~ expected_layout }
+        value = @layouts[key]
+
+        if expected_count = options[:count]
+          actual_count = value[:count]
+          msg = message || sprintf("expecting %s to be rendered %s time(s) but rendered %s time(s)",
+                 expected_partial, expected_count, actual_count)
+          assert_equal expected_count, actual_count, msg
+        end
+
+        if expected_format = options[:format]
+          actual_format = value[:format]
+          msg = message || sprintf("expecting %s to be rendered as %s but rendered as %s",
+                 expected_partial, expected_format, actual_format)
+          assert_equal expected_format, actual_format, msg
+        end
+
+        if expected_handler = options[:handler]
+          actual_handler = value[:handler]
+          msg = message || sprintf("expecting %s to be rendered as %s but rendered as %s",
+                 expected_partial, expected_handler, actual_handler)
+          assert_equal expected_handler, actual_handler, msg
+        end
+      when nil, false
+        assert(@layouts.empty?, msg)
+      end
+    elsif expected_partial = options[:partial]
+      case expected_partial
+      when String, Symbol
+        msg = message || sprintf("expecting partial <%s> but action rendered <%s>",
+          expected_partial, @partials.keys)
+        assert_includes @partials.keys, expected_partial.to_s, msg
+
+        key = expected_partial.to_s
+        value = @partials[key]
+
+        if expected_count = options[:count]
+          actual_count = value[:count]
+          msg = message || sprintf("expecting %s to be rendered %s time(s) but rendered %s time(s)",
+                 expected_partial, expected_count, actual_count)
+          assert_equal expected_count, actual_count, msg
+        end
+
+        if expected_format = options[:format]
+          actual_format = value[:format]
+          msg = message || sprintf("expecting %s to be rendered as %s but rendered as %s",
+                 expected_partial, expected_format, actual_format)
+          assert_equal expected_format, actual_format, msg
+        end
+
+        if expected_handler = options[:handler]
+          actual_handler = value[:handler]
+          msg = message || sprintf("expecting %s to be rendered as %s but rendered as %s",
+                 expected_partial, expected_handler, actual_handler)
+          assert_equal expected_handler, actual_handler, msg
+        end
+      when Regexp
+        msg = message || sprintf("expecting partial <%s> but action rendered <%s>",
+          expected_partial, @partials.keys)
+        assert(@partials.keys.any? {|l| l =~ expected_partial }, msg)
+
+        key = @partials.keys.find {|l| l =~ expected_partial }
+        value = @partials[key]
+
+        if expected_count = options[:count]
+          actual_count = value[:count]
+          msg = message || sprintf("expecting %s to be rendered %s time(s) but rendered %s time(s)",
+                 expected_partial, expected_count, actual_count)
+          assert_equal expected_count, actual_count, msg
+        end
+
+        if expected_format = options[:format]
+          actual_format = value[:format]
+          msg = message || sprintf("expecting %s to be rendered as %s but rendered as %s",
+                 expected_partial, expected_format, actual_format)
+          assert_equal expected_format, actual_format, msg
+        end
+
+        if expected_handler = options[:handler]
+          actual_handler = value[:handler]
+          msg = message || sprintf("expecting %s to be rendered as %s but rendered as %s",
+                 expected_partial, expected_handler, actual_handler)
+          assert_equal expected_handler, actual_handler, msg
+        end
+      when nil, false
+        assert(@partials.empty?, msg)
+      end
+    end
+  end
+
+end
+
+class ActionController::TestCase
+
+  def assigns(key = nil)
+    assigns = {}.with_indifferent_access
+    @controller.view_assigns.each { |k, v| assigns.regular_writer(k, v) }
+    key.nil? ? assigns : assigns[key]
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: standardapi
 version: !ruby/object:Gem::Version
-  version: 6.0.0.30
+  version: 6.0.0.32
 platform: ruby
 authors:
 - James Bracy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-10 00:00:00.000000000 Z
+date: 2020-02-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -276,6 +276,11 @@ files:
 - lib/standard_api/views/application/schema.streamer
 - lib/standard_api/views/application/show.json.jbuilder
 - lib/standard_api/views/application/show.streamer
+- test/standard_api/caching_test.rb
+- test/standard_api/helpers_test.rb
+- test/standard_api/performance.rb
+- test/standard_api/route_helpers_test.rb
+- test/standard_api/standard_api_test.rb
 - test/standard_api/test_app.rb
 - test/standard_api/test_app/config/database.yml
 - test/standard_api/test_app/controllers.rb
@@ -290,6 +295,7 @@ files:
 - test/standard_api/test_app/views/photos/schema.streamer
 - test/standard_api/test_app/views/properties/edit.html.erb
 - test/standard_api/test_app/views/sessions/new.html.erb
+- test/standard_api/test_helper.rb
 homepage: https://github.com/waratuman/standardapi
 licenses:
 - MIT
@@ -312,7 +318,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: StandardAPI makes it easy to expose a query interface for your Rails models