standardapi 6.1.0 → 7.1.0

data/test/standard_api/nested_attributes/belongs_to_test.rb

@@ -0,0 +1,71 @@
+require 'standard_api/test_helper'
+
+module NestedAttributes
+  class BelongsToTest < ActionDispatch::IntegrationTest
+    # include StandardAPI::TestCase
+    include StandardAPI::Helpers
+
+
+    # = Create Test
+
+    test 'create record and create nested record' do
+      @controller = PhotosController.new
+      post photos_path, params: { photo: { account: {name: 'Big Ben'}} }, as: :json
+
+      assert_response :created
+      photo = Photo.last
+      assert_equal 'Big Ben', photo.account.name
+    end
+  
+    test 'create record and update nested record' do
+      account = create(:account, name: 'Big Ben')
+    
+      @controller = PhotosController.new
+      post photos_path, params: { photo: { account: {id: account.id, name: 'Little Jimmie'}} }, as: :json
+
+
+      assert_response :created
+      photo = Photo.last
+      assert_equal account.id, photo.account_id
+      assert_equal 'Little Jimmie', photo.account.name
+    end
+
+    # = Update Test
+  
+    test 'update record and create nested record' do
+      photo = create(:photo)
+
+      @controller = PhotosController.new
+      put photo_path(photo), params: { photo: { account: {name: 'Big Ben'}} }, as: :json
+    
+      assert_response :ok
+      photo.reload
+      assert_equal 'Big Ben', photo.account.name
+    end
+
+    test 'update record and update nested record' do
+      account = create(:account, name: 'Big Ben')
+      photo = create(:photo, account: account)
+
+      @controller = PhotosController.new
+      put photo_path(photo), params: { photo: { account: {name: 'Little Jimmie'}} }, as: :json
+    
+      assert_response :ok
+      photo.reload
+      assert_equal 'Little Jimmie', photo.account.name
+    end
+
+    test 'update record and set relation to  nil' do
+      account = create(:account, name: 'Big Ben')
+      photo = create(:photo, account: account)
+
+      @controller = PhotosController.new
+      put photo_path(photo), params: { photo: { account: nil} }, as: :json
+    
+      assert_response :ok
+      photo.reload
+      assert_nil photo.account
+    end
+
+  end
+end

data/test/standard_api/nested_attributes/has_and_belongs_to_many_test.rb

@@ -0,0 +1,70 @@
+require 'standard_api/test_helper'
+
+module NestedAttributes
+  class HasAndBelongsToManyTest < ActionDispatch::IntegrationTest
+    # include StandardAPI::TestCase
+    include StandardAPI::Helpers
+
+
+    # = Create Test
+
+    test 'create record and create nested record' do
+      @controller = PropertiesController.new
+      post properties_path, params: { property: { name: 'Beach House', photos: [{format: 'image/jpeg'}]} }, as: :json
+
+      assert_response :created
+      property = Property.last
+      assert_equal 'Beach House', property.name
+      assert_equal ['image/jpeg'], property.photos.map(&:format)
+    end
+  
+    test 'create record and update nested record' do
+      photo = create(:photo, format: 'image/png')
+
+      @controller = PropertiesController.new
+      post properties_path, params: { property: { name: 'Beach House', photos: [{id: photo.id, format: 'image/jpeg'}] } }, as: :json
+
+      assert_response :created
+      property = Property.last
+      assert_equal 'Beach House', property.name
+      assert_equal [photo.id], property.photos.map(&:id)
+      assert_equal ['image/jpeg'], property.photos.map(&:format)
+      assert_equal 'image/jpeg', photo.reload.format
+    end
+
+    # = Update Test
+
+    test 'update record and create nested record' do
+      property = create(:property)
+
+      @controller = PropertiesController.new
+      put property_path(property), params: { property: { photos: [{format: "image/tiff"}]} }, as: :json
+
+      assert_response :ok
+      assert_equal ["image/tiff"], property.reload.photos.map(&:format)
+    end
+
+    test 'update record and update nested record' do
+      photo = create(:photo, format: 'image/gif')
+      property = create(:property, photos: [photo])
+
+      @controller = PropertiesController.new
+      put property_path(property), params: { property: { photos: [{id: photo.id, format: "image/heic"}]} }, as: :json
+
+      assert_response :ok
+      assert_equal ['image/heic'], property.reload.photos.map(&:format)
+    end
+
+    test 'update record and set relation to an empty array' do
+      photo = create(:photo, format: 'image/gif')
+      property = create(:property, photos: [photo])
+
+      @controller = PropertiesController.new
+      put property_path(property), params: { property: { photos: [] } }, as: :json
+
+      assert_response :ok
+      assert_equal [], property.reload.photos
+    end
+
+  end
+end

data/test/standard_api/nested_attributes/has_many_test.rb

@@ -0,0 +1,85 @@
+require 'standard_api/test_helper'
+
+module NestedAttributes
+  class HasManyTest < ActionDispatch::IntegrationTest
+    # include StandardAPI::TestCase
+    include StandardAPI::Helpers
+
+
+    # = Create Test
+
+    test 'create record and create nested record' do
+      @controller = PropertiesController.new
+      post properties_path, params: { property: { name: 'Beach House', accounts: [{name: 'Billabong'}]} }, as: :json
+
+      assert_response :created
+      property = Property.last
+      assert_equal 'Beach House', property.name
+      assert_equal ['Billabong'], property.accounts.map(&:name)
+    end
+  
+    test 'create record and update nested record' do
+      account = create(:account, name: 'Coco Chanel')
+
+      @controller = PropertiesController.new
+      post properties_path, params: { property: { name: 'Beach House', accounts: [{id: account.id, name: 'Crazy Chanel'}]} }, as: :json
+
+      assert_response :created
+      property = Property.last
+      assert_equal [account.id], property.accounts.map(&:id)
+      assert_equal ['Crazy Chanel'], property.accounts.map(&:name)
+      assert_equal 'Crazy Chanel', account.reload.name
+    end
+
+    # = Update Test
+
+    test 'update record and create nested record' do
+      property = create(:property)
+
+      @controller = PropertiesController.new
+      put property_path(property), params: { property: { accounts: [{name: "Hersey's"}]} }, as: :json
+
+      assert_response :ok
+      assert_equal ["Hersey's"], property.accounts.map(&:name)
+    end
+
+    test 'update record and update nested record' do
+      account = create(:account, name: 'A Co.')
+      property = create(:property, name: 'Empire State Building', accounts: [account])
+
+      @controller = PropertiesController.new
+      put property_path(property), params: { property: { name: 'John Hancock Center', accounts: [{id: account.id, name: "B Co."}]} }, as: :json
+
+      assert_response :ok
+      property.reload
+      assert_equal 'John Hancock Center', property.name
+      assert_equal ['B Co.'], property.accounts.map(&:name)
+    end
+
+    test 'update record and set relation to an empty array' do
+      account = create(:account, name: 'A Co.')
+      property = create(:property, name: 'Empire State Building', accounts: [account])
+
+      @controller = PropertiesController.new
+      put property_path(property), params: { property: { accounts: [] } }, as: :json
+
+      assert_response :ok
+      property.reload
+      assert_equal [], property.accounts
+    end
+    
+    test 'update record and include nested record in response' do
+      account = create(:account, name: 'A Co.')
+      property = create(:property, name: 'Empire State Building', accounts: [account])
+
+      @controller = PropertiesController.new
+      put property_path(property), params: { property: { name: 'John Hancock Center', accounts: [{id: account.id, name: "B Co."}]} }, as: :json
+
+      attributes = JSON.parse(response.body)
+      assert_response :ok
+      assert_equal account.id, attributes["accounts"][0]["id"]
+      assert_equal "B Co.", attributes["accounts"][0]["name"]
+    end
+
+  end
+end

data/test/standard_api/nested_attributes/has_one_test.rb

@@ -0,0 +1,71 @@
+require 'standard_api/test_helper'
+
+module NestedAttributes
+  class HasOneTest < ActionDispatch::IntegrationTest
+    # include StandardAPI::TestCase
+    include StandardAPI::Helpers
+
+
+    # = Create Test
+
+    test 'create record and create nested record' do
+      @controller = PhotosController.new
+
+      post photos_path, params: { photo: { camera: {make: 'Sony'}} }, as: :json
+
+      photo = Photo.last
+      assert_equal photo.id, photo.camera.photo_id
+      assert_equal 'Sony', photo.camera.make
+    end
+  
+    test 'create record and update nested record' do
+      camera = create(:camera, make: 'Sony')
+
+      @controller = PhotosController.new
+      post photos_path, params: { photo: { camera: {id: camera.id, make: 'Nokia'} } }, as: :json
+
+      assert_response :created
+      photo = Photo.last
+      assert_equal photo.id, photo.camera.photo_id
+      assert_equal 'Nokia', photo.camera.make
+    end
+
+    # = Update Test
+  
+    test 'update record and create nested record' do
+      photo = create(:photo)
+
+      @controller = PhotosController.new
+      put photo_path(photo), params: { photo: { camera: {make: 'Canon'}} }, as: :json
+
+      assert_response :ok
+      photo.reload
+      assert_equal 'Canon', photo.camera.make
+    end
+
+    test 'update record and update nested record' do
+      camera = create(:camera, make: 'Leica')
+      photo = create(:photo, camera: camera)
+
+      @controller = PhotosController.new
+      put photo_path(photo), params: { photo: { camera: {make: 'Nokia'}} }, as: :json
+
+      assert_response :ok
+      photo.reload
+      assert_equal 'Nokia', photo.camera.make
+    end
+
+    test 'update record and set relation to  nil' do
+      camera = create(:camera, make: 'Leica')
+      photo = create(:photo, camera: camera)
+
+      @controller = PhotosController.new
+      put photo_path(photo), params: { photo: { camera: nil} }, as: :json
+
+      assert_response :ok
+      photo.reload
+      assert_nil photo.camera
+    end
+
+  end
+end

data/test/standard_api/route_helpers_test.rb

@@ -30,4 +30,60 @@ class RouteHelpersTest < ActionDispatch::IntegrationTest
     assert_routing({ path: '/photos/1/properties/1', method: :delete }, { controller: 'photos', action: 'remove_resource', id: '1', relationship: 'properties', resource_id: '1' })
   end
 
+  test "standard_resources with only option" do
+    with_routing do |set|
+      set.draw do
+        standard_resources :photos, only: [ :index, :show ]
+      end
+      assert_routing({ path: '/photos', method: :get }, { controller: 'photos', action: 'index' })
+      assert_routing({ path: '/photos/1', method: :get }, { controller: 'photos', action: 'show', id: '1' })
+      assert_equal 2, set.routes.size
+    end
+  end
+
+  test "standard_resources with except option" do
+    with_routing do |set|
+      set.draw do
+        standard_resources :photos, except: [ :destroy ]
+      end
+      assert_routing({ path: '/photos', method: :get }, { controller: 'photos', action: 'index' })
+      assert_routing({ path: '/photos/1', method: :get }, { controller: 'photos', action: 'show', id: '1' })
+      assert_routing({ path: '/photos/new', method: :get }, { controller: 'photos', action: 'new' })
+      assert_routing({ path: '/photos', method: :post }, { controller: 'photos', action: 'create' })
+      assert_routing({ path: '/photos/1', method: :put }, { controller: 'photos', action: 'update', id: '1' })
+      assert_routing({ path: '/photos/1', method: :patch }, { controller: 'photos', action: 'update', id: '1' })
+      assert_routing({ path: '/photos/schema', method: :get }, { controller: 'photos', action: 'schema' })
+      assert_routing({ path: '/photos/calculate', method: :get }, { controller: 'photos', action: 'calculate' })
+      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' })
+      assert_routing({ path: '/photos/1/properties', method: :post }, { controller: 'photos', action: 'create_resource', id: '1', relationship: 'properties' })
+      assert_equal 12, set.routes.size
+    end
+  end
+
+  test "standard_resource with only option" do
+    with_routing do |set|
+      set.draw do
+        standard_resource :accounts, only: :show
+      end
+      assert_routing({ path: '/accounts', method: :get }, { controller: 'accounts', action: 'show' })
+      assert_equal 1, set.routes.size
+    end
+  end
+
+  test "standard_resource with except option" do
+    with_routing do |set|
+      set.draw do
+        standard_resource :accounts, except: [ :destroy ]
+      end
+      assert_routing({ path: '/accounts', method: :get }, { controller: 'accounts', action: 'show' })
+      assert_routing({ path: '/accounts/new', method: :get }, { controller: 'accounts', action: 'new' })
+      assert_routing({ path: '/accounts', method: :post }, { controller: 'accounts', action: 'create' })
+      assert_routing({ path: '/accounts', method: :put }, { controller: 'accounts', action: 'update' })
+      assert_routing({ path: '/accounts', method: :patch }, { controller: 'accounts', action: 'update' })
+      assert_routing({ path: '/accounts/schema', method: :get }, { controller: 'accounts', action: 'schema' })
+      assert_routing({ path: '/accounts/calculate', method: :get }, { controller: 'accounts', action: 'calculate' })
+      assert_equal 10, set.routes.size
+    end
+  end
 end

data/test/standard_api/standard_api_test.rb

@@ -92,18 +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
-    @controller.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')
@@ -112,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)
@@ -125,7 +140,7 @@ 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
-        if default then
+        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
@@ -134,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
 
@@ -163,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')
@@ -188,47 +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}"
-    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
@@ -236,7 +234,7 @@ 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
@@ -246,13 +244,45 @@ class PropertiesControllerTest < ActionDispatch::IntegrationTest
     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 }}] }
@@ -444,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: {

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

@@ -1,5 +1,6 @@
 module PropertyACL
 
+  # Attributes allowed to be updated
   def attributes
     [ :name,
       :aliases,
@@ -12,16 +13,21 @@ module PropertyACL
     ]
   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 ]
+    [ :photos, :accounts ]
   end
 
 end

data/test/standard_api/test_app/controllers.rb

@@ -2,6 +2,18 @@ class ApplicationController < ActionController::Base
   include StandardAPI::Controller
   include StandardAPI::AccessControlList
   prepend_view_path File.join(File.dirname(__FILE__), 'views')
+  
+  helper_method :serialize_attribute
+
+  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
 
@@ -48,6 +60,8 @@ class ReferencesController < ApplicationController
 end
 
 class SessionsController < ApplicationController
+  def create
+  end
 end
 
 class UnlimitedController < ApplicationController
@@ -73,3 +87,6 @@ class DefaultLimitController < ApplicationController
   end
 
 end
+
+class UuidModelController < ApplicationController
+end