standardapi 6.0.0.32 → 6.1.0

data/lib/standard_api/test_case/index_tests.rb

@@ -69,9 +69,12 @@ module StandardAPI
       end
 
       test '#index.json params[:include]' do
+        next if includes.empty?
+
         travel_to Time.now do
           create_model
           get resource_path(:index, format: :json), params: { limit: 100, include: includes }
+          assert_response :ok
 
           json = JSON.parse(response.body)[0]
           assert json.is_a?(Hash)
@@ -128,6 +131,13 @@ module StandardAPI
         models = @controller.instance_variable_get("@#{plural_name}")
         assert_equal model.where(id: m.id).sort(required_orders).to_sql, models.to_sql
         @controller.current_mask.delete(plural_name)
+
+        @controller.current_mask[plural_name.to_sym] = { id: m.id }
+        get :index, format: :json
+        models = @controller.instance_variable_get("@#{plural_name}")
+        assert_equal model.where(id: m.id).sort(required_orders).to_sql, models.to_sql
+        @controller.current_mask.delete(plural_name.to_sym)
+
       end
     end
   end

data/lib/standard_api/test_case/schema_tests.rb

@@ -18,7 +18,13 @@ module StandardAPI
           assert_equal_or_nil column.null, actual_column['null']
           assert_equal_or_nil column.array, actual_column['array']
           assert_equal_or_nil column.comment, actual_column['comment']
-          assert_equal_or_nil (column.default || column.default_function), actual_column['default']
+
+          if column.default
+            default = model.connection.lookup_cast_type_from_column(column).deserialize(column.default)
+            assert_equal default, actual_column['default']
+          else
+            assert_nil column.default
+          end
         end
 
         assert json['limit']

data/lib/standard_api/test_case/show_tests.rb

@@ -15,6 +15,7 @@ module StandardAPI
       test '#show.json params[:include]' do
         m = create_model
         get resource_path(:show, id: m.id, include: includes, format: :json)
+        assert_response :ok
 
         json = JSON.parse(response.body)
         includes.each do |included|

data/lib/standard_api/test_case/update_tests.rb

@@ -16,7 +16,7 @@ module StandardAPI
         put resource_path(:update, :id => m.id, format: format), params: { singular_name => attrs }, as: as
         assert_response :ok, "Updating #{m.class.name} with #{attrs.inspect}"
 
-        view_attributes(m.reload).select { |x| attrs.keys.map(&:to_s).include?(x) }.each do |key, value|
+        update_attributes(m.reload).select { |x| attrs.keys.map(&:to_s).include?(x) }.each do |key, value|
           message = "Model / Attribute: #{m.class.name}##{key}"
           if value.is_a?(BigDecimal)
             assert_equal_or_nil normalize_attribute(m, key, attrs[key.to_sym]).to_s.to_f, value.to_s.to_f, message
@@ -34,7 +34,7 @@ module StandardAPI
         get resource_path(:show, id: m.id), as: :json
 
         return if @controller.method(:update).owner != StandardAPI
-        
+
         attrs = attributes_for(singular_name).select{|k,v| !model.readonly_attributes.include?(k.to_s) }
         create_webmocks(attrs)
 
@@ -57,9 +57,9 @@ module StandardAPI
         assert_response :ok, "Updating #{m.class.name} with #{attrs.inspect}"
 
         # (m.attribute_names & attrs.keys.map(&:to_s)).each do |test_key|
-        view_attributes(m.reload).select { |x| attrs.keys.map(&:to_s).include?(x) }.each do |key, value|
+        update_attributes(m.reload).select { |x| attrs.keys.map(&:to_s).include?(x) }.each do |key, value|
           message = "Model / Attribute: #{m.class.name}##{key}"
-          assert_equal_or_nil normalize_attribute(m, key, attrs[key.to_sym]), value, message
+          assert_equal_or_nil normalize_attribute(m, key, attrs[key.to_sym]), normalize_attribute(m, key, value), message
         end
         assert JSON.parse(@response.body).is_a?(Hash)
       end
@@ -68,8 +68,7 @@ module StandardAPI
         trait = FactoryBot.factories[singular_name].definition.defined_traits.any? { |x| x.name.to_s == 'invalid' }
 
         if !trait
-          Rails.logger.try(:warn, "No invalid trait for #{model.name}. Skipping invalid tests")
-          warn("No invalid trait for #{model.name}. Skipping invalid tests")
+          skip("No invalid trait for #{model.name}. Skipping invalid tests")
           return
         end
 
@@ -94,7 +93,7 @@ module StandardAPI
 
           put resource_path(:update, :id => m.id, format: format), params: { include: includes, singular_name => attrs }, as: as
           assert_response :ok, "Updating #{m.class.name} with #{attrs.inspect}"
-        
+
           controller_model = @controller.instance_variable_get("@#{singular_name}")
           json = JSON.parse(response.body)
           includes.each do |included|
@@ -104,7 +103,7 @@ module StandardAPI
             next if !association
 
             if ['belongs_to', 'has_one'].include?(association.macro.to_s)
-              view_attributes(controller_model.send(included)) do |key, value|
+              update_attributes(controller_model.send(included)) do |key, value|
                 message = "Model / Attribute: #{controller_model.send(included).class.name}##{key}"
                 assert_equal json[included.to_s][key.to_s], value, message
               end
@@ -118,7 +117,7 @@ module StandardAPI
                 nil
               end
 
-              view_attributes(m).each do |key, value|
+              update_attributes(m).each do |key, value|
                 message = "Model / Attribute: #{m.class.name}##{key}"
                 if m_json[key.to_s].nil?
                   assert_nil normalize_to_json(m, key, value), message

data/lib/standard_api/version.rb

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

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

@@ -7,20 +7,20 @@ 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::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
+      can_cache = can_cache_relation?(record, inc, subinc)
+      json.set! inc do
+        json.cache_if!(can_cache, can_cache ? association_cache_key(record, inc, subinc) : nil) do
+          partial = model_partial(association.klass)
+
           # 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.reorder(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']
@@ -29,17 +29,17 @@ includes.each do |inc, subinc|
         end
       end
     else
-      can_cache = can_cache_relation?(record.class, inc, subinc)
+      can_cache = can_cache_relation?(record, 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.set! inc do
+        json.cache_if!(can_cache, can_cache ? association_cache_key(record, inc, subinc) : nil) do
+          value = record.send(inc)
+          if value.nil?
+            json.null!
+          else
+            partial = model_partial(value)
             json.partial! partial, partial.split('/').last.to_sym => value, includes: subinc
           end
         end

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

@@ -1,5 +1,5 @@
 json.object! do
-  
+
   record.attributes.each do |name, value|
     # Skip if attribute is included in excludes
     next if defined?(excludes) && excludes[record.model_name.singular.to_sym].try(:find) { |x| x.to_s == name.to_s }
@@ -8,39 +8,41 @@ json.object! do
 
   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)
+    when ActiveRecord::Reflection::AbstractReflection
+      if association.collection?
+        can_cache = can_cache_relation?(record, inc, subinc)
+        json.cache_if!(can_cache, can_cache ? [inc, association_cache_key(record, inc, subinc)] : nil) do
+          json.set! inc do
+            partial = model_partial(association.klass)
+            # 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']
+            sub_records = sub_records.limit(subinc["limit"]) if subinc["limit"]
+            sub_records = sub_records.offset(subinc["offset"]) if subinc["offset"]
+            sub_records = sub_records.reorder(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)
+      else
+        can_cache = can_cache_relation?(record, 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 ? [inc, association_cache_key(record, inc, subinc)] : nil) do
           json.set! inc do
-            json.partial! partial, partial.split('/').last.to_sym => value, includes: subinc
+            value = record.send(inc)
+            if value.nil?
+              json.value! nil
+            else
+              partial = model_partial(value)
+              json.partial! partial, partial.split("/").last.to_sym => value, includes: subinc
+            end
           end
         end
       end
@@ -52,20 +54,20 @@ json.object! do
         elsif value.is_a?(ActiveModel::Model)
           json.set! inc do
             partial = model_partial(value)
-            json.partial! partial, partial.split('/').last.to_sym => value, includes: subinc
+            json.partial! partial, partial.split("/").last.to_sym => value, includes: subinc
           end
         else
           json.set! inc, value.as_json
         end
       end
     end
-    
+
   end
-  
+
   if !record.errors.blank?
     errs = record.errors.to_hash
     errs.default_proc = nil
-    json.set! 'errors', errs
+    json.set! "errors", errs
   end
-  
+
 end

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

@@ -52,7 +52,7 @@ else
     model.columns.each do |column|
       json.set! column.name, {
         type: json_column_type(column.sql_type),
-        default: column.default || column.default_function,
+        default: column.default ? model.connection.lookup_cast_type_from_column(column).deserialize(column.default) : nil,
         primary_key: column.name == model.primary_key,
         null: column.null,
         array: column.array,

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

@@ -61,7 +61,7 @@ else
         model.columns.each do |column|
           json.set! column.name, {
             type: json_column_type(column.sql_type),
-            default: column.default || column.default_function,
+            default: column.default ? model.connection.lookup_cast_type_from_column(column).deserialize(column.default) : nil,
             primary_key: column.name == model.primary_key,
             null: column.null,
             array: column.array,

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/test/standard_api/caching_test.rb

@@ -1,6 +1,6 @@
 require 'standard_api/test_helper'
 
-class AccountsControllerTest < ActionController::TestCase
+class AccountsControllerTest < ActionDispatch::IntegrationTest
 
   test 'include with cache' do
     account = create(:account, photos: [])
@@ -14,20 +14,30 @@ class AccountsControllerTest < ActionController::TestCase
 
     # Cache Miss
     Account.any_instance.stubs(:photos_cached_at).returns(t1)
-    get :show, params: {id: account.id, include: :photos}, format: :json
+    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 :show, params: {id: account.id, include: :photos}, format: :json
+    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 :show, params: {id: account.id, include: :photos}, format: :json
+    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

@@ -45,26 +45,38 @@ class HelpersTest < ActionView::TestCase
     assert can_cache?(Account, {photos: {account: {}}})
   end
 
-  test '::can_cache_relation?' do
+  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, {})
+    assert !can_cache_relation?(account, :photos, {})
 
     Account.expects(:column_names).returns(['id', 'cached_at', 'photos_cached_at'])
-    assert can_cache_relation?(Account, :photos, {})
+    assert can_cache_relation?(account, :photos, {})
 
     Account.expects(:column_names).returns(['id', 'cached_at', 'photos_cached_at'])
-    assert !can_cache_relation?(Account, :photos, {account: {}})
+    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: {}})
+    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(
@@ -72,7 +84,7 @@ class HelpersTest < ActionView::TestCase
       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(
@@ -80,6 +92,7 @@ class HelpersTest < ActionView::TestCase
       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(
@@ -87,6 +100,7 @@ class HelpersTest < ActionView::TestCase
       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)
@@ -95,6 +109,7 @@ class HelpersTest < ActionView::TestCase
       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)
@@ -103,6 +118,7 @@ class HelpersTest < ActionView::TestCase
       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)
@@ -113,14 +129,14 @@ class HelpersTest < ActionView::TestCase
     )
 
     # Belongs to
-    photo = create(:photo, account: account)
+    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 = create(:photo, account: 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(
@@ -151,6 +167,6 @@ class HelpersTest < ActionView::TestCase
     assert_equal 'boolean', json_column_type('boolean')
     assert_equal 'ewkb', json_column_type('geometry')
     assert_equal 'string', json_column_type('uuid')
-    end
+  end
 
 end