stateful_models 0.0.1 → 0.0.3

data/spec/{dummy/db/migrate/20241221183116_create_has_states_tables.rb → generators/tmp/db/migrate/20250114180401_create_has_states_states.rb}

@@ -1,8 +1,7 @@
-# frozen_string_literal: true
-
-class CreateHasStatesTables < ActiveRecord::Migration[7.1]
+class CreateHasStatesStates < ActiveRecord::Migration[8.0]
   def change
     create_table :has_states_states do |t|
+      t.string :type, null: false
       t.string :state_type
       t.string :status, null: false
 
@@ -10,10 +9,10 @@ class CreateHasStatesTables < ActiveRecord::Migration[7.1]
 
       t.references :stateable, polymorphic: true, null: false
 
-      t.datetime :completed_at
       t.timestamps
 
+      t.index %i[type stateable_id]
       t.index %i[stateable_type stateable_id]
     end
   end
-end
+end

data/spec/generators/tmp/db/migrate/20250114180401_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/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
 
@@ -261,4 +283,66 @@ RSpec.describe HasStates::State, type: :model do
       end.to change { HasStates.configuration.callbacks.size }.from(1).to(0)
     end
   end
+
+  describe 'custom state types' do
+    # Create a custom state class for testing
+    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
+
+    let(:user) { create(:user) }
+
+    it 'allows creation of custom state types' do
+      state = user.add_state(
+        'kyc',
+        status: 'pending',
+        metadata: { document_type: 'passport' },
+        state_class: KYCState
+      )
+
+      expect(state).to be_valid
+      expect(state).to be_a(KYCState)
+    end
+
+    it 'enforces custom validations' do
+      expect do
+        user.add_state(
+          'kyc',
+          status: 'pending',
+          metadata: { other_field: 'value' },
+          state_class: KYCState
+        )
+      end.to raise_error(
+        ActiveRecord::RecordInvalid,
+        /Metadata must include document_type/
+      )
+    end
+
+    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
+
+    it 'maintains STI type across database reads' do
+      state = user.add_state(
+        'kyc',
+        status: 'pending',
+        metadata: { document_type: 'passport' },
+        state_class: KYCState
+      )
+
+      reloaded_state = HasStates::Base.find(state.id)
+      expect(reloaded_state).to be_a(KYCState)
+    end
+  end
 end

data/spec/has_states/stateable_spec.rb

@@ -0,0 +1,184 @@
+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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stateful_models
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
 - Sebastian Scholl
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-23 00:00:00.000000000 Z
+date: 2025-01-14 00:00:00.000000000 Z
 dependencies: []
 description: "\n    HasStates provides state management and event system capabilities
   for Ruby objects.\n    It allows tracking states, state transitions, and triggering
@@ -24,8 +24,10 @@ 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
 - lib/has_states/callback.rb
 - lib/has_states/configuration.rb
 - lib/has_states/configuration/model_configuration.rb
@@ -62,13 +64,15 @@ files:
 - spec/dummy/config/environments/test.rb
 - spec/dummy/config/initializers/cors.rb
 - spec/dummy/config/initializers/filter_parameter_logging.rb
+- spec/dummy/config/initializers/has_states.rb
 - spec/dummy/config/initializers/inflections.rb
 - spec/dummy/config/locales/en.yml
 - spec/dummy/config/master.key
 - spec/dummy/config/puma.rb
 - spec/dummy/config/routes.rb
 - spec/dummy/db/migrate/20241221171423_create_test_models.rb
-- spec/dummy/db/migrate/20241221183116_create_has_states_tables.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
@@ -80,10 +84,12 @@ files:
 - 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/20241223020432_create_has_states_states.rb
+- spec/generators/tmp/db/migrate/20250114180401_create_has_states_states.rb
+- spec/generators/tmp/db/migrate/20250114180401_create_indexes_on_has_states_states.rb
 - spec/has_states/callback_spec.rb
 - spec/has_states/configuration_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