stateful_models 0.0.2 → 0.0.4

data/spec/generators/has_states/install_generator_spec.rb

@@ -4,7 +4,7 @@ require 'rails_helper'
 require 'generators/has_states/install/install_generator'
 
 RSpec.describe HasStates::InstallGenerator do
-  let(:destination) { File.expand_path('../tmp', __dir__) }
+  let(:destination) { File.expand_path('../templates', __dir__) }
 
   before do
     FileUtils.rm_rf(destination)

data/spec/generators/{tmp/db/migrate/20241223213845_create_has_states_states.rb → templates/db/migrate/20250322001530_create_has_states_states.rb}

@@ -1,4 +1,4 @@
- class CreateHasStatesStates < ActiveRecord::Migration[8.0]
+class CreateHasStatesStates < ActiveRecord::Migration[8.0]
   def change
     create_table :has_states_states do |t|
       t.string :type, null: false

data/spec/generators/templates/db/migrate/20250322001530_create_indexes_on_has_states_states.rb

@@ -0,0 +1,11 @@
+class CreateIndexesOnHasStatesStates < ActiveRecord::Migration[8.0]
+  def change
+    change_table :has_states_states do |t|
+      t.index %i[stateable_id state_type]
+      t.index %i[stateable_id state_type status]
+      t.index %i[stateable_id state_type created_at]    
+      t.index %i[stateable_id state_type status created_at] 
+      t.index %i[stateable_type stateable_id]
+    end
+  end
+end

data/spec/has_states/configuration_spec.rb

@@ -74,6 +74,63 @@ RSpec.describe HasStates::Configuration do
         end
       end.to raise_error(ArgumentError, /must be an ActiveRecord model/)
     end
+
+    it 'allows setting a limit on the number of states' do
+      configuration.configure_model User do |model|
+        model.state_type :kyc do |type|
+          type.statuses = %w[pending completed]
+          type.limit = 2
+        end
+      end
+
+      expect(configuration.limit_for(User, 'kyc')).to eq(2)
+    end
+
+    it 'returns nil for limit when no limit is set' do
+      configuration.configure_model User do |model|
+        model.state_type :kyc do |type|
+          type.statuses = %w[pending completed]
+        end
+      end
+
+      expect(configuration.limit_for(User, 'kyc')).to be_nil
+    end
+
+    context 'when a metadata schema is set' do
+      let(:schema) do
+        {
+          type: :object,
+          properties: {
+            name: { type: :string },
+            age: { type: :integer, minimum: 18 }
+          },
+          required: %i[name age]
+        }
+      end
+
+      before do
+        configuration.configure_model User do |model|
+          model.state_type :kyc do |type|
+            type.statuses = %w[pending completed]
+            type.metadata_schema = schema
+          end
+        end
+      end
+
+      it 'allows setting a metadata schema for validation' do
+        expect(configuration.metadata_schema_for(User, 'kyc')).to eq(schema)
+      end
+    end
+
+    it 'returns nil for metadata_schema when no schema is set' do
+      configuration.configure_model User do |model|
+        model.state_type :kyc do |type|
+          type.statuses = %w[pending completed]
+        end
+      end
+
+      expect(configuration.metadata_schema_for(User, 'kyc')).to be_nil
+    end
   end
 
   describe 'callbacks' do

data/spec/has_states/state_limit_spec.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe 'State Limit Feature', type: :model do
+  before do
+    HasStates.configuration.clear_callbacks!
+    HasStates.configuration.model_configurations.clear
+
+    HasStates.configure do |config|
+      config.configure_model User do |model|
+        model.state_type :double_limit_state do |type|
+          type.statuses = %w[pending completed]
+          type.limit = 2
+        end
+
+        model.state_type :no_limit_state do |type|
+          type.statuses = %w[pending completed]
+          # No limit set for this type
+        end
+
+        model.state_type :single_limit_state do |type|
+          type.statuses = %w[pending completed]
+          type.limit = 1
+        end
+      end
+    end
+  end
+
+  describe 'state limit validation' do
+    let(:user) { create(:user) }
+
+    context 'with no limit set' do
+      it 'allows creating multiple states of the same type' do
+        # Create multiple onboarding states (no limit)
+        expect do
+          3.times { user.add_state('no_limit_state', status: 'pending') }
+        end.not_to raise_error
+
+        expect(user.states.where(state_type: 'no_limit_state').count).to eq(3)
+      end
+    end
+
+    context 'with a limit set' do
+      it 'allows creating states up to the limit' do
+        # Create double_limit_state states up to the limit (2)
+        expect do
+          2.times { user.add_state('double_limit_state', status: 'pending') }
+        end.not_to raise_error
+
+        expect(user.states.where(state_type: 'double_limit_state').count).to eq(2)
+      end
+
+      it 'prevents creating states beyond the limit' do
+        # Create double_limit_state states up to the limit
+        2.times { user.add_state('double_limit_state', status: 'pending') }
+
+        # Try to create one more (exceeding the limit)
+        expect do
+          user.add_state('double_limit_state', status: 'pending')
+        end.to raise_error(ActiveRecord::RecordInvalid, /maximum number of double_limit_state states/)
+      end
+
+      it 'enforces a limit of 1 correctly' do
+        # Create one state
+        user.add_state('single_limit_state', status: 'pending')
+
+        # Try to create another one (exceeding the limit of 1)
+        expect do
+          user.add_state('single_limit_state', status: 'completed')
+        end.to raise_error(ActiveRecord::RecordInvalid, /maximum number of single_limit_state states/)
+      end
+    end
+
+    context 'with different state types' do
+      it 'applies limits independently to each state type' do
+        # Create states up to the limit for double_limit_state
+        2.times { user.add_state('double_limit_state', status: 'pending') }
+
+        # Create states for no_limit_state (no limit)
+        3.times { user.add_state('no_limit_state', status: 'pending') }
+
+        # Create one state for single_limit_state (limit 1)
+        user.add_state('single_limit_state', status: 'pending')
+
+        # Verify counts
+        expect(user.states.where(state_type: 'double_limit_state').count).to eq(2)
+        expect(user.states.where(state_type: 'no_limit_state').count).to eq(3)
+        expect(user.states.where(state_type: 'single_limit_state').count).to eq(1)
+
+        # Try to exceed limits
+        expect do
+          user.add_state('double_limit_state', status: 'completed')
+        end.to raise_error(ActiveRecord::RecordInvalid, /maximum number of double_limit_state states/)
+
+        expect do
+          user.add_state('single_limit_state', status: 'completed')
+        end.to raise_error(ActiveRecord::RecordInvalid, /maximum number of single_limit_state states/)
+
+        # But can still add more no_limit_state states
+        expect do
+          user.add_state('no_limit_state', status: 'completed')
+        end.not_to raise_error
+      end
+    end
+  end
+end

data/spec/has_states/state_metadata_schema_spec.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe 'Metadata Schema Validation', type: :model do
+  let(:user) { create(:user) }
+  let(:schema) do
+    {
+      type: :object,
+      properties: {
+        name: { type: :string },
+        age: {
+          type: :integer,
+          minimum: 18
+        }
+      },
+      required: %i[name age]
+    }
+  end
+
+  before do
+    HasStates.configuration.clear_callbacks!
+    HasStates.configuration.model_configurations.clear
+
+    HasStates.configure do |config|
+      config.configure_model User do |model|
+        model.state_type :schema_enabled_state do |type|
+          type.statuses = %w[pending completed rejected]
+          type.metadata_schema = schema
+        end
+
+        model.state_type :no_schema_state do |type|
+          type.statuses = %w[active inactive]
+        end
+      end
+    end
+  end
+
+  describe 'validation' do
+    context 'with a valid schema' do
+      it 'validates valid metadata' do
+        # Invalid metadata (too young < 18)
+        expect do
+          user.add_state('schema_enabled_state', status: 'pending', metadata: { name: 'John Doe', age: 17 })
+        end.to raise_error(ActiveRecord::RecordInvalid, /did not have a minimum value of 18/)
+
+        # Invalid metadata (missing required fields)
+        expect do
+          user.add_state('schema_enabled_state', status: 'pending', metadata: { age: 25 })
+        end.to raise_error(ActiveRecord::RecordInvalid, /did not contain a required property of 'name'/)
+
+        # Valid metadata
+        state = user.add_state('schema_enabled_state', status: 'pending', metadata: { name: 'John Doe', age: 25 })
+
+        expect(state).to be_valid
+        expect(state.persisted?).to be true
+      end
+    end
+
+    context 'with no schema defined' do
+      it 'accepts any metadata for state types without a schema' do
+        state = user.add_state('no_schema_state', status: 'active', metadata: {
+                                 anything: 'goes',
+                                 nested: {
+                                   data: 'is fine too'
+                                 },
+                                 numbers: [1, 2, 3]
+                               })
+
+        expect(state).to be_valid
+        expect(state.persisted?).to be true
+      end
+    end
+  end
+end

data/spec/has_states/state_spec.rb

@@ -22,6 +22,28 @@ RSpec.describe HasStates::State, type: :model do
     end
   end
 
+  describe 'indexes' do
+    it 'defines an index on stateable_type and stateable_id' do
+      expect(subject).to have_db_index(%i[stateable_type stateable_id])
+    end
+
+    it 'defines an index on stateable_id and state_type' do
+      expect(subject).to have_db_index(%i[stateable_id state_type])
+    end
+
+    it 'defines an index on stateable_id, state_type, and status' do
+      expect(subject).to have_db_index(%i[stateable_id state_type status])
+    end
+
+    it 'defines an index on stateable_id, state_type, and created_at' do
+      expect(subject).to have_db_index(%i[stateable_id state_type created_at])
+    end
+
+    it 'defines an index on stateable_id, state_type, status, and created_at' do
+      expect(subject).to have_db_index(%i[stateable_id state_type status created_at])
+    end
+  end
+
   describe 'validations' do
     context 'status' do
       it 'validates status presence' do
@@ -63,22 +85,22 @@ RSpec.describe HasStates::State, type: :model do
   describe 'instance methods' do
     let(:state) { create(:state, state_type: 'kyc', status: 'pending') }
     let(:model_config) { HasStates.configuration.model_configurations[User] }
-    let(:all_statuses) do
-      model_config.state_types.values.flat_map(&:statuses).uniq
-    end
+    let(:all_statuses) { model_config.state_types.values.flat_map(&:statuses).uniq }
 
-    it 'defines predicate methods for all configured statuses' do
-      all_statuses.each do |status|
-        expect(state).to respond_to("#{status}?")
+    context 'predicate methods' do
+      it 'defines predicate methods for all configured statuses' do
+        all_statuses.each do |status|
+          expect(state).to respond_to("#{status}?")
+        end
       end
-    end
 
-    it 'returns true if the status is pending' do
-      expect(state.pending?).to be(true)
-    end
+      it 'returns true if the status is pending' do
+        expect(state.pending?).to be(true)
+      end
 
-    it 'returns false if the status is not completed' do
-      expect(state.completed?).to be(false)
+      it 'returns false if the status is not completed' do
+        expect(state.completed?).to be(false)
+      end
     end
   end
 
@@ -267,11 +289,12 @@ RSpec.describe HasStates::State, type: :model do
     class KYCState < HasStates::Base
       validates :metadata, presence: true
       validate :required_metadata_fields
-      
+
       private
-      
+
       def required_metadata_fields
         return if metadata&.key?('document_type')
+
         errors.add(:metadata, 'must include document_type')
       end
     end
@@ -306,7 +329,7 @@ RSpec.describe HasStates::State, type: :model do
 
     it 'defaults to HasStates::State when no state_class specified' do
       state = user.add_state('kyc', status: 'pending')
-      
+
       expect(state).to be_a(HasStates::State)
       expect(state).to be_valid
     end

data/spec/has_states/stateable_spec.rb

@@ -0,0 +1,183 @@
+require 'rails_helper'
+
+RSpec.describe HasStates::Stateable do
+  # Create a test class that includes the concern
+  let(:test_class) do
+    Class.new do
+      include HasStates::Stateable
+      include ActiveRecord::Model
+    end
+  end
+
+  let(:user) { create(:user) } # Assuming you have a User factory
+
+  before do
+    # HasStates.configuration.clear_callbacks!
+    # HasStates.configuration.model_configurations.clear
+
+    HasStates.configure do |config|
+      config.configure_model User do |model|
+        model.state_type :test_type do |type|
+          type.statuses = %w[pending completed]
+        end
+
+        model.state_type :other_test_type do |type|
+          type.statuses = %w[pending completed]
+        end
+      end
+    end
+  end
+
+  describe 'associations' do
+    it 'has many states' do
+      association = User.reflect_on_association(:states)
+
+      expect(association.macro).to eq :has_many
+      expect(association.options[:as]).to eq :stateable
+      expect(association.options[:dependent]).to eq :destroy
+      expect(association.options[:class_name]).to eq 'HasStates::Base'
+    end
+  end
+
+  describe '#add_state' do
+    context 'with default parameters' do
+      it 'creates a new state with default values' do
+        state = user.add_state('test_type')
+
+        expect(state).to be_persisted
+        expect(state.metadata).to eq({})
+        expect(state.status).to eq 'pending'
+        expect(state.state_type).to eq 'test_type'
+        expect(state.type).to eq 'HasStates::State'
+      end
+    end
+
+    context 'with custom parameters' do
+      let(:metadata) { { key: 'value' } }
+
+      it 'creates a new state with provided values' do
+        state = user.add_state('test_type', status: 'completed', metadata: metadata)
+
+        expect(state).to be_persisted
+        expect(state.status).to eq 'completed'
+        expect(state.state_type).to eq 'test_type'
+        expect(state.type).to eq 'HasStates::State'
+        expect(state.metadata).to eq metadata.as_json
+      end
+    end
+
+    context 'with custom state class' do
+      before(:all) do
+        module HasStates
+          class CustomState < State; end
+        end
+      end
+
+      after(:all) do
+        HasStates.send(:remove_const, :CustomState)
+      end
+
+      it 'creates a new state with the specified class' do
+        state = user.add_state('test_type', state_class: HasStates::CustomState)
+
+        expect(state).to be_persisted
+        expect(state.type).to eq 'HasStates::CustomState'
+      end
+    end
+
+    context 'when validation fails' do
+      before do
+        allow_any_instance_of(HasStates::Base).to receive(:save!).and_raise(ActiveRecord::RecordInvalid)
+      end
+
+      it 'raises an ActiveRecord::RecordInvalid error' do
+        expect { user.add_state('test_type') }.to raise_error(ActiveRecord::RecordInvalid)
+      end
+    end
+  end
+
+  describe '#current_state' do
+    let!(:latest_state) { user.add_state('test_type', status: 'completed') }
+
+    before do
+      travel_to 1.day.ago do
+        3.times { user.add_state('test_type', status: 'pending') }
+        2.times { user.add_state('other_test_type', status: 'pending') }
+      end
+    end
+
+    it 'returns the most recent state for the given type' do
+      expect(user.current_state('test_type')).to eq latest_state
+    end
+
+    it 'returns nil when no state exists for the given type' do
+      expect(user.current_state('nonexistent')).to be_nil
+    end
+  end
+
+  describe '#current_states' do
+    before do
+      3.times { user.add_state('test_type', status: 'pending') }
+      3.times { user.add_state('other_test_type', status: 'completed') }
+    end
+
+    it 'returns all states for the given type ordered by creation time' do
+      test_types = user.current_states('test_type')
+
+      expect(test_types.size).to eq 3
+      expect(test_types).to eq test_types.sort_by(&:created_at).reverse
+    end
+
+    it 'returns empty relation when no states exist for the given type' do
+      nonexistent_states = user.current_states('nonexistent')
+      expect(nonexistent_states).to be_empty
+      expect(nonexistent_states).to be_a(ActiveRecord::Relation)
+    end
+  end
+
+  describe 'query methods' do
+    before do
+      2.times { user.add_state('test_type', status: 'pending') }
+      2.times { user.add_state('other_test_type', status: 'pending') }
+    end
+
+    context 'find one methods' do
+      it 'defines query one methods for configured states' do
+        expect(user).to respond_to('test_type')
+        expect(user).to respond_to('other_test_type')
+      end
+
+      it 'returns the most recent state for the given status' do
+        expect(user.test_type).to eq user.current_state('test_type')
+        expect(user.other_test_type).to eq user.current_state('other_test_type')
+      end
+    end
+
+    context 'find many methods' do
+      it 'defines query all methods for configured states' do
+        expect(user).to respond_to('test_types')
+        expect(user).to respond_to('other_test_types')
+      end
+
+      it 'returns all states for the given status ordered by creation time' do
+        test_types = user.test_types
+        other_test_types = user.other_test_types
+
+        expect(test_types.size).to eq 2
+        expect(other_test_types.size).to eq 2
+
+        expect(test_types).to eq test_types.sort_by(&:created_at).reverse
+        expect(other_test_types).to eq other_test_types.sort_by(&:created_at).reverse
+      end
+    end
+  end
+
+  # Optional: Test the destruction of associated states
+  describe 'destroying the stateable object' do
+    let!(:state) { user.add_state('test_type') }
+
+    it 'destroys associated states when the user is destroyed' do
+      expect { user.destroy }.to change { HasStates::Base.count }.by(-1)
+    end
+  end
+end

data/spec/rails_helper.rb

@@ -14,5 +14,6 @@ require_relative 'support/database_cleaner'
 RSpec.configure do |config|
   config.include(Shoulda::Matchers::ActiveModel, type: :model)
   config.include(Shoulda::Matchers::ActiveRecord, type: :model)
+  config.include(ActiveSupport::Testing::TimeHelpers)
   # ... rest of your RSpec configuration
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: stateful_models
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
 platform: ruby
 authors:
 - Sebastian Scholl
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-23 00:00:00.000000000 Z
-dependencies: []
+date: 2025-03-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json-schema
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: "\n    HasStates provides state management and event system capabilities
   for Ruby objects.\n    It allows tracking states, state transitions, and triggering
   callbacks on state changes.\n  "
@@ -24,6 +38,7 @@ files:
 - README.md
 - lib/generators/has_states/install/install_generator.rb
 - lib/generators/has_states/install/templates/create_has_states_states.rb.erb
+- lib/generators/has_states/install/templates/create_indexes_on_has_states_states.rb.erb
 - lib/generators/has_states/install/templates/initializer.rb.erb
 - lib/has_states.rb
 - lib/has_states/base.rb
@@ -71,6 +86,7 @@ files:
 - spec/dummy/config/routes.rb
 - spec/dummy/db/migrate/20241221171423_create_test_models.rb
 - spec/dummy/db/migrate/20241223212128_create_has_states_states.rb
+- spec/dummy/db/migrate/20250114175939_create_indexes_on_has_states_states.rb
 - spec/dummy/db/schema.rb
 - spec/dummy/db/seeds.rb
 - spec/dummy/log/development.log
@@ -81,11 +97,15 @@ files:
 - spec/dummy/tmp/local_secret.txt
 - spec/factories/has_states.rb
 - spec/generators/has_states/install_generator_spec.rb
-- spec/generators/tmp/config/initializers/has_states.rb
-- spec/generators/tmp/db/migrate/20241223213845_create_has_states_states.rb
+- spec/generators/templates/config/initializers/has_states.rb
+- spec/generators/templates/db/migrate/20250322001530_create_has_states_states.rb
+- spec/generators/templates/db/migrate/20250322001530_create_indexes_on_has_states_states.rb
 - spec/has_states/callback_spec.rb
 - spec/has_states/configuration_spec.rb
+- spec/has_states/state_limit_spec.rb
+- spec/has_states/state_metadata_schema_spec.rb
 - spec/has_states/state_spec.rb
+- spec/has_states/stateable_spec.rb
 - spec/has_states_spec.rb
 - spec/rails_helper.rb
 - spec/spec_helper.rb
@@ -117,7 +137,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
+rubygems_version: 3.5.9
 signing_key:
 specification_version: 4
 summary: Simple and flexible state management for Ruby objects