standardapi 6.0.0.32 → 7.1.0

data/test/standard_api/standard_api_test.rb

@@ -6,13 +6,13 @@ class PropertiesControllerTest < ActionDispatch::IntegrationTest
 
   self.includes = [ :photos, :landlord, :english_name ]
 
-  # def normalizers
-  #   {
-  #     Property => {
-  #       "size" => lambda { |value| value.to_i }
-  #     }
-  #   }
-  # end
+  def normalizers
+    {
+      Property => {
+        "size" => lambda { |value| value.round(4).to_s }
+      }
+    }
+  end
 
   # = Routing Tests
   #
@@ -92,17 +92,33 @@ class PropertiesControllerTest < ActionDispatch::IntegrationTest
     assert_equal @controller.send(:model_includes), []
   end
 
-  test 'Controller#model_params defaults to []' do
+  test 'Controller#model_params defaults to ActionController::Parameters' do
+    @controller = DocumentsController.new
+    @controller.params = ActionController::Parameters.new
+    assert_equal @controller.send(:model_params), ActionController::Parameters.new
+  end
+
+  test 'Controller#model_params defaults to ActionController::Parameters when no resource_attributes' do
     @controller = ReferencesController.new
-    assert_equal @controller.send(:model_params), []
+    @controller.params = ActionController::Parameters.new
+    assert_equal @controller.send(:model_params), ActionController::Parameters.new
   end
 
-  test 'Controller#current_mask' do
+  test 'Controller#mask' do
     @controller = ReferencesController.new
-    @controller.instance_variable_set('@current_mask', { 'references' => { 'subject_id' => 1 }})
+    @controller.define_singleton_method(:mask_for) do |table_name|
+      {subject_id: 1}
+    end
     @controller.params = {}
     assert_equal 'SELECT "references".* FROM "references" WHERE "references"."subject_id" = 1', @controller.send(:resources).to_sql
   end
+  
+  test "Auto includes on a controller without a model" do
+    @controller = SessionsController.new
+    assert_nil @controller.send(:model)
+    post sessions_path(format: :json), params: {session: {user: 'user', pass: 'pass'}}
+    assert_response :ok
+  end
 
   test 'ApplicationController#schema.json' do
     get schema_path(format: 'json')
@@ -111,7 +127,7 @@ class PropertiesControllerTest < ActionDispatch::IntegrationTest
     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|
+    @controller.send(:models).reject { |x| %w(Photo Document).include?(x.name)  }.each do |model|
       assert_equal true, schema['models'].has_key?(model.name)
 
       model_comment = model.connection.table_comment(model.table_name)
@@ -123,8 +139,9 @@ class PropertiesControllerTest < ActionDispatch::IntegrationTest
 
       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
+        default = column.default
+        if default
+          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')
@@ -132,11 +149,15 @@ class PropertiesControllerTest < ActionDispatch::IntegrationTest
         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
+        if column.comment
           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
+        
+        if column.respond_to?(:auto_populated?)
+          assert_equal !!column.auto_populated?, schema.dig('models', model.name, 'attributes', column.name, 'auto_populated')
+        end
       end
     end
 
@@ -161,6 +182,26 @@ class PropertiesControllerTest < ActionDispatch::IntegrationTest
     assert_nil schema['limit']
   end
 
+  test 'Controller#schema.json for an enum with default' do
+    get schema_documents_path(format: 'json')
+
+    schema = JSON(response.body)
+
+    assert_equal true, schema.has_key?('attributes')
+    assert_equal 'string', schema['attributes']['level']['type']
+    assert_equal 'public', schema['attributes']['level']['default']
+  end
+
+  test 'Controller#schema.json for an enum without default' do
+    get schema_documents_path(format: 'json')
+
+    schema = JSON(response.body)
+
+    assert_equal true, schema.has_key?('attributes')
+    assert_equal 'string', schema['attributes']['rating']['type']
+    assert_nil schema['attributes']['rating']['default']
+  end
+
   test 'Controller#index w/o limit' do
     account = create(:account)
     get unlimited_index_path(format: 'json')
@@ -186,29 +227,6 @@ class PropertiesControllerTest < ActionDispatch::IntegrationTest
     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
@@ -216,23 +234,55 @@ class PropertiesControllerTest < ActionDispatch::IntegrationTest
     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
+    assert_equal ["properties", "accounts", "documents", "photos", "references", "accounts", 'accounts', 'uuid_models'].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 JSON(response.body).has_key?('landlord')
     assert_nil JSON(response.body)['landlord']
   end
 
+  test 'rendering binary attribute' do
+    reference = create(:reference, sha: "Hello World")
+    get reference_path(reference, format: 'json'), params: { id: reference.id }
+    assert_equal "48656c6c6f20576f726c64", JSON(response.body)['sha']
+  end
+
+  test 'rendering a custom binary attribute' do
+    reference = create(:reference, custom_binary: 2)
+    get reference_path(reference, format: 'json'), params: { id: reference.id }
+    assert_equal 2, JSON(response.body)['custom_binary']
+    assert_equal "\\x00000002".b,reference.custom_binary_before_type_cast
+  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 'rendering serialize_attribute' do
+    property = create(:property, description: 'This text will magically change')
+    get property_path(property, format: 'json'), params: { id: property.id, magic: true }
 
+    body = JSON(response.body)
+    assert_equal body['description'], 'See it changed!'
+  end
+
+  test 'rendering an enum' do
+    public_document = create(:document, level: 'public')
+    
+    get documents_path(format: 'json'), params: { limit: 1 }
+    assert_equal JSON(response.body)[0]['level'], 'public'
+    
+    secret_document = create(:document, level: 'secret')
+    get document_path(secret_document, format: 'json')
+    assert_equal JSON(response.body)['level'], 'secret'
+  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 }}] }
@@ -320,14 +370,22 @@ class PropertiesControllerTest < ActionDispatch::IntegrationTest
   test 'include with where key' do
     photo_a = create(:photo)
     photo_b = create(:photo)
+    photo_c = create(:photo)
 
-    property = create(:property, photos: [photo_b])
+    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
@@ -338,6 +396,14 @@ class PropertiesControllerTest < ActionDispatch::IntegrationTest
     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')
@@ -380,8 +446,8 @@ class PropertiesControllerTest < ActionDispatch::IntegrationTest
 
     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
+    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
@@ -408,7 +474,7 @@ class PropertiesControllerTest < ActionDispatch::IntegrationTest
       },
       format: 'json')
 
-    assert_equal [photos.first.id], JSON(response.body)['photos'].map { |x| x['id'] }
+    assert_equal [photos.map(&:id).sort.first], JSON(response.body)['photos'].map { |x| x['id'] }
 
     get property_path(property,
       include: {
@@ -549,6 +615,19 @@ class PropertiesControllerTest < ActionDispatch::IntegrationTest
     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)
@@ -556,6 +635,65 @@ class PropertiesControllerTest < ActionDispatch::IntegrationTest
     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')

data/test/standard_api/test_app/app/controllers/acl/account_acl.rb

@@ -0,0 +1,15 @@
+module AccountACL
+
+  def attributes
+    [ "property_id", "name" ]
+  end
+
+  def orders
+    [ "id" ]
+  end
+
+  def includes
+    [ "photos", "subject", "property" ]
+  end
+
+end

data/test/standard_api/test_app/app/controllers/acl/camera_acl.rb

@@ -0,0 +1,7 @@
+module CameraACL
+
+  def attributes
+    [ :make ]
+  end
+
+end

data/test/standard_api/test_app/app/controllers/acl/photo_acl.rb

@@ -0,0 +1,13 @@
+module PhotoACL
+
+  def attributes
+    [
+      :format
+    ]
+  end
+  
+  def nested
+    [ :account, :camera ]
+  end
+
+end

data/test/standard_api/test_app/app/controllers/acl/property_acl.rb

@@ -0,0 +1,33 @@
+module PropertyACL
+
+  # Attributes allowed to be updated
+  def attributes
+    [ :name,
+      :aliases,
+      :description,
+      :constructed,
+      :size,
+      :active
+      # :photos_attributes,
+      # { photos_attributes: [ :id, :account_id, :property_id, :format] }
+    ]
+  end
+
+  # Orderings allowed
+  def orders
+    ["id", "name", "aliases", "description", "constructed", "size", "created_at", "active"]
+  end
+
+  # Sub resources allowed to be included in the response
+  def includes
+    [ :photos, :landlord, :english_name, :document ]
+  end
+
+  # Sub resourced allowed to be set during create / update / delete if a user is
+  # allowed to ....
+  # only add to and from the relation, can also create or update the subresource
+  def nested
+    [ :photos, :accounts ]
+  end
+
+end

data/test/standard_api/test_app/app/controllers/acl/reference_acl.rb

@@ -0,0 +1,7 @@
+module ReferenceACL
+
+  def includes
+    { subject: [ :landlord, :photos ] }
+  end
+
+end

data/test/standard_api/test_app/controllers.rb

@@ -1,43 +1,18 @@
 class ApplicationController < ActionController::Base
   include StandardAPI::Controller
+  include StandardAPI::AccessControlList
   prepend_view_path File.join(File.dirname(__FILE__), 'views')
+  
+  helper_method :serialize_attribute
 
-  private
-
-  def account_params
-    [ "property_id", "name" ]
-  end
-
-  def account_orders
-    [ "id" ]
-  end
-
-  def account_includes
-    [ "photos" ]
-  end
-
-  def property_params
-    [ :name,
-      :aliases,
-      :description,
-      :constructed,
-      :size,
-      :active,
-      :photos_attributes,
-      { photos_attributes: [ :id, :account_id, :property_id, :format] }
-    ]
-  end
-
-  def property_orders
-    ["id", "name", "aliases", "description", "constructed", "size", "created_at", "active"]
-  end
-
-  def property_includes
-    [:photos, :landlord, :english_name, :document]
-  end
-
-  def reference_includes
-    { subject: [ :landlord, :photos ] }
+  def serialize_attribute(json, record, attribute, type)
+    value = if attribute == 'description' && params["magic"] === "true"
+      'See it changed!'
+    else
+      record.send(attribute)
+    end
+    
+    json.set! attribute, type == :binary ? value&.unpack1('H*') : value
   end
 
 end
@@ -46,32 +21,37 @@ class PropertiesController < ApplicationController
 end
 
 class AccountsController < ApplicationController
+
+  def show
+    @account = Account.last
+  end
+
 end
 
 class DocumentsController < ApplicationController
 
-  def document_params
+  def document_attributes
     [ :file, :type ]
   end
-  
+
   def document_orders
-    [:id]
+    [ :id ]
   end
 
 end
 
 class PhotosController < ApplicationController
 
-  def photo_params
+  def photo_attributes
     [ :id, :account_id, :property_id, :format ]
   end
 
   def photo_orders
-    [:id]
+    [ :id ]
   end
 
   def photo_includes
-    [:account]
+    [ :account ]
   end
 
 end
@@ -80,6 +60,8 @@ class ReferencesController < ApplicationController
 end
 
 class SessionsController < ApplicationController
+  def create
+  end
 end
 
 class UnlimitedController < ApplicationController
@@ -104,4 +86,7 @@ class DefaultLimitController < ApplicationController
     100
   end
 
-end
+end
+
+class UuidModelController < ApplicationController
+end