Deleting relationship destroys related resource without checking dependency

[jlugner]

This issue is a (choose one):

• Problem/bug report.
• Feature request.
• Request for support. Note: Please try to avoid submitting issues for support requests. Use Gitter instead.

Checklist before submitting:

• I've searched for an existing issue.
• I've asked my question on Gitter and have not received a satisfactory answer.
• I've included a complete bug report template. This step helps us and allows us to see the bug without trying to reproduce the problem from your description. It helps you because you will frequently detect if it's a problem specific to your project.
• The feature I'm asking for is compliant with the JSON:API spec.

Description

Sending delete requests to some_model/:id/relationships/some_other_model should only remove the related resource if some_model has specified dependent: :destroy on its relation to some_other_model. Right now, the related resource is deleted no matter what the dependency is.

Bug reports:

begin
  require 'bundler/inline'
  require 'bundler'
rescue LoadError => e
  STDERR.puts 'Bundler version 1.10 or later is required. Please update your Bundler'
  raise e
end

gemfile(true, ui: ENV['SILENT'] ? Bundler::UI::Silent.new : Bundler::UI::Shell.new) do
  source 'https://rubygems.org'

  gem 'rails', require: false
  gem 'sqlite3', platform: :mri

  gem 'activerecord-jdbcsqlite3-adapter',
      git: 'https://github.com/jruby/activerecord-jdbc-adapter',
      platform: :jruby

  if ENV['JSONAPI_RESOURCES_PATH']
    gem 'jsonapi-resources', path: ENV['JSONAPI_RESOURCES_PATH'], require: false
  else
    gem 'jsonapi-resources', git: 'https://github.com/cerebris/jsonapi-resources', require: false
  end

end

# prepare active_record database
require 'active_record'

class NullLogger < Logger
  def initialize(*_args)
  end

  def add(*_args, &_block)
  end
end

ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
ActiveRecord::Base.logger = ENV['SILENT'] ? NullLogger.new : Logger.new(STDOUT)
ActiveRecord::Migration.verbose = !ENV['SILENT']

ActiveRecord::Schema.define do
  # Add your schema here
  create_table :base_models, force: true do |t|
  end

  create_table :non_dependent_on_base_models do |t|
    t.references :base_model, foreign_key: false
  end

  create_table :dependent_on_base_models do |t|
    t.references :base_model, foreign_key: true
  end
end

# create models
class BaseModel < ActiveRecord::Base
  has_many :non_dependent_on_base_models, dependent: :nullify
  has_many :dependent_on_base_models, dependent: :destroy
end

class NonDependentOnBaseModel < ActiveRecord::Base
  belongs_to :base_model
end

class DependentOnBaseModel < ActiveRecord::Base
  belongs_to :base_model
end

# prepare rails app
require 'action_controller/railtie'
# require 'action_view/railtie'
require 'jsonapi-resources'

# prepare jsonapi resources and controllers
class BaseModelsController < JSONAPI::ResourceController
end

class NonDependentOnBaseModelsController < JSONAPI::ResourceController
end

class DependentOnBaseModelsController < JSONAPI::ResourceController
end

class BaseModelResource < JSONAPI::Resource
  has_many :non_dependent_on_base_models
  has_many :dependent_on_base_models
end

class NonDependentOnBaseModelResource < JSONAPI::Resource
  has_one :base_model
end

class DependentOnBaseModelResource < JSONAPI::Resource
  has_one :base_model
end

class TestApp < Rails::Application
  config.root = File.dirname(__FILE__)
  config.logger = ENV['SILENT'] ? NullLogger.new : Logger.new(STDOUT)
  Rails.logger = config.logger

  secrets.secret_token = 'secret_token'
  secrets.secret_key_base = 'secret_key_base'

  config.eager_load = false
end

# initialize app
Rails.application.initialize!

JSONAPI.configure do |config|
  config.json_key_format = :underscored_key
  config.route_format = :underscored_key
end

# draw routes
Rails.application.routes.draw do
  jsonapi_resources :base_models
  jsonapi_resources :non_dependent_on_base_models
  jsonapi_resources :dependent_on_base_models
end

# prepare tests
require 'minitest/autorun'
require 'rack/test'

class BugTest < Minitest::Test
  include Rack::Test::Methods

  def json_api_headers
    { 'Accept' => JSONAPI::MEDIA_TYPE, 'CONTENT_TYPE' => JSONAPI::MEDIA_TYPE }
  end

  def delete_request(url, payload)
    delete(url, payload.to_json, json_api_headers)
  end

  def test_delete_dependent_relation_deletes_resource
    base = BaseModel.create
    dependent = DependentOnBaseModel.create(base_model: base)
    delete_request(
      "/base_models/#{base.id}/relationships/dependent_on_base_models",
      data: [{ type: 'dependent_on_base_models', id: dependent.id }]
    )
    assert last_response.no_content?
    assert_equal(0, base.reload.dependent_on_base_models.count)
    assert !DependentOnBaseModel.exists?(id: dependent.id)
  end

  def test_delete_non_dependent_relation_does_not_delete_resource
    base = BaseModel.create
    non_dependent = NonDependentOnBaseModel.create(base_model: base)
    delete_request(
      "/base_models/#{base.id}/relationships/non_dependent_on_base_models",
      data: [{ type: 'non_dependent_on_base_models', id: non_dependent.id }]
    )
    assert last_response.no_content?
    assert_equal(0, base.reload.non_dependent_on_base_models.count)
    assert NonDependentOnBaseModel.exists?(id: non_dependent.id)
  end

  private

  def app
    Rails.application
  end
end

[lgebhardt]

@Pungsnigel Thanks!