Add tests for Issue JSONAPI-Resources#1467: ActiveModel resources support

Issue JSONAPI-Resources#1467 reported that ActiveModel-based models fail with
'undefined method where' errors in v0.10.7+.

Root cause:
- The default JSONAPI::Resource inherits from ActiveRelationResource
- ActiveRelationResource expects ActiveRecord query methods (where, order, etc.)
- ActiveModel::Model doesn't provide these methods

Solution:
- ActiveModel-based models should use JSONAPI::BasicResource
- BasicResource doesn't assume ActiveRecord and works with any model

Tests added:
1. active_model_resource_test.rb - Shows BasicResource works with ActiveModel
2. active_model_broken_test.rb - Demonstrates the problem with ActiveRelationResource

The tests confirm that using BasicResource is the correct approach for
non-ActiveRecord models.

Related: https://github.com/cerebris/jsonapi-resources/issues/1467

Author: takaokouji

test/fixtures/active_record.rb

@@ -2691,6 +2691,89 @@ class RobotResource < ::JSONAPI::Resource
   end
 end
 
+# Models and Resources for testing Issue #1467: ActiveModel-based resources
+# ActiveModel class without ActiveRecord
+class SimpleModel
+  include ActiveModel::Model
+  include ActiveModel::Attributes
+
+  attribute :id, :integer
+  attribute :name, :string
+  attribute :description, :string
+
+  # Simple in-memory store for testing
+  @@store = {}
+
+  def self.reset_store!
+    @@store = {}
+  end
+
+  def self.create(attributes)
+    model = new(attributes)
+    @@store[model.id] = model
+    model
+  end
+
+  def self.find(id)
+    @@store[id]
+  end
+
+  def self.all
+    @@store.values
+  end
+
+  def self.find_by(attributes)
+    all.find { |model| attributes.all? { |key, value| model.send(key) == value } }
+  end
+end
+
+class SimpleModelResource < JSONAPI::BasicResource
+  model_name 'SimpleModel'
+  model_hint model: SimpleModel, resource: :simple_model
+
+  attribute :name
+  attribute :description
+
+  # Override find_by_key for non-ActiveRecord models
+  def self.find_by_key(key, options = {})
+    model = _model_class.find(key.to_i)
+    return nil unless model
+    new(model, options[:context])
+  end
+
+  # Override find_fragments for non-ActiveRecord models
+  def self.find_fragments(filters, options = {})
+    models = if filters.empty?
+      _model_class.all
+    else
+      # Simple filtering implementation
+      _model_class.all.select do |model|
+        filters.all? { |key, value| model.send(key).to_s == value.to_s }
+      end
+    end
+
+    models.each_with_object({}) do |model, hash|
+      resource = new(model, options[:context])
+      hash[resource.identity] = {
+        identity: resource.identity,
+        cache: nil,
+        attributes: nil,
+        related: nil
+      }
+    end
+  end
+end
+
+# This resource uses the default JSONAPI::Resource (ActiveRelationResource)
+# which will fail with ActiveModel models - reproduces Issue #1467
+class BrokenActiveModelResource < JSONAPI::Resource
+  model_name 'SimpleModel'
+  model_hint model: SimpleModel, resource: :broken_active_model
+
+  attribute :name
+  attribute :description
+end
+
 ### PORO Data - don't do this in a production app
 $breed_data = BreedData.new
 $breed_data.add(Breed.new(0, 'persian'))

test/unit/resource/active_model_broken_test.rb

@@ -0,0 +1,37 @@
+require File.expand_path('../../../test_helper', __FILE__)
+
+# Test for Issue #1467: Demonstrate the problem with ActiveRelationResource and ActiveModel
+# https://github.com/cerebris/jsonapi-resources/issues/1467
+#
+# This test shows that using JSONAPI::Resource (which inherits from ActiveRelationResource)
+# with an ActiveModel-based model will fail because ActiveRelationResource expects
+# ActiveRecord methods like 'where'
+
+class ActiveModelBrokenTest < ActiveSupport::TestCase
+  def setup
+    # Seed some test data in the mock store
+    SimpleModel.reset_store!
+    @model1 = SimpleModel.create(id: 1, name: 'Test 1', description: 'First test')
+    @model2 = SimpleModel.create(id: 2, name: 'Test 2', description: 'Second test')
+  end
+
+  def teardown
+    SimpleModel.reset_store!
+  end
+
+  # This test demonstrates the problem: JSONAPI::Resource (ActiveRelationResource)
+  # attempts to use ActiveRecord methods on ActiveModel models
+  def test_activerelation_resource_fails_with_activemodel
+    resource_klass = BrokenActiveModelResource
+    context = {}
+
+    # This WILL raise NoMethodError because ActiveRelationResource expects ActiveRecord methods
+    # The error could be 'order', 'where', or other ActiveRecord-specific methods
+    error = assert_raises(NoMethodError) do
+      fragments = resource_klass.find_fragments({}, { context: context })
+    end
+
+    # Verify it's trying to use ActiveRecord-like query methods
+    assert_match(/undefined method.*(order|where|limit|offset)/, error.message)
+  end
+end

test/unit/resource/active_model_resource_test.rb

@@ -0,0 +1,63 @@
+require File.expand_path('../../../test_helper', __FILE__)
+
+# Test for Issue #1467: ActiveModel-based resources fail with 'where' method error
+# https://github.com/cerebris/jsonapi-resources/issues/1467
+#
+# This test reproduces the scenario where:
+# - A model uses ActiveModel::Model instead of ActiveRecord::Base
+# - The resource should work with BasicResource or proper configuration
+# - In v0.10.7+, these resources fail with "undefined method 'where'"
+
+class ActiveModelResourceTest < ActiveSupport::TestCase
+  def setup
+    # Seed some test data in the mock store
+    SimpleModel.reset_store!
+    @model1 = SimpleModel.create(id: 1, name: 'Test 1', description: 'First test')
+    @model2 = SimpleModel.create(id: 2, name: 'Test 2', description: 'Second test')
+  end
+
+  def teardown
+    SimpleModel.reset_store!
+  end
+
+  # Test that ActiveModel-based resources can be found without using ActiveRecord methods
+  def test_find_activemodel_resources
+    resource_klass = SimpleModelResource
+    context = {}
+
+    # This should not raise "undefined method 'where'"
+    assert_nothing_raised do
+      fragments = resource_klass.find_fragments({}, { context: context })
+      assert fragments.any?, "Should find SimpleModel fragments"
+      assert_equal 2, fragments.size, "Should find 2 fragments"
+    end
+  end
+
+  # Test that ActiveModel-based resources can be filtered
+  def test_filter_activemodel_resources
+    resource_klass = SimpleModelResource
+    context = {}
+
+    # Test with a filter
+    filters = { name: 'Test 1' }
+
+    # This should not attempt to call _model_class.where(name: 'Test 1')
+    assert_nothing_raised do
+      fragments = resource_klass.find_fragments(filters, { context: context })
+      assert_equal 1, fragments.size, "Should find 1 filtered fragment"
+    end
+  end
+
+  # Test that ActiveModel-based resources work with find_by_key
+  def test_find_by_key_activemodel_resources
+    resource_klass = SimpleModelResource
+    context = {}
+
+    # find_by_key should work for ActiveModel resources
+    assert_nothing_raised do
+      resource = resource_klass.find_by_key(1, context: context)
+      assert resource, "Should find resource by key"
+      assert_equal 'Test 1', resource.name
+    end
+  end
+end