stator 0.8.0 → 0.9.0.beta

data/spec/model_spec.rb

@@ -1,239 +1,201 @@
 # frozen_string_literal: true
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Stator::Model do
 
-  it "should set the default state after initialization" do
-    u = User.new
-    u.state.should eql("pending")
-  end
-
-  it "should see the initial setting of the state as a change with the initial state as the previous value" do
-    u = User.new
-    u.state = "activated"
-    u.state_in_database.should eql("pending")
-  end
-
-  it "should not obstruct normal validations" do
-    u = User.new
-    u.should_not be_valid
-    u.errors[:email].grep(/length/).should_not be_empty
-  end
-
-  it "should ensure a valid state transition when given a bogus state" do
-    u = User.new
-    u.state = "anythingelse"
-
-    u.should_not be_valid
-    u.errors[:state].should eql(["is not a valid state"])
-  end
-
-  it "should allow creation at any state" do
-    u = User.new(email: "doug@example.com")
-    u.state = "hyperactivated"
-
-    u.should be_valid
-  end
+  let(:u) { User.new }
 
-  it "should work normally with active_record dirty methods" do
-    u = User.new(email: "doug@example.com")
+  describe "basic operations" do
 
-    u.will_save_change_to_state?.should_not be true
-    u.state_in_database.should eq("pending")
-    u.state_before_last_save.should be nil
+    it 'should set the default state after initialization' do
+      u.state.to_sym.should eql(:pending)
+    end
 
-    u.state = "hyperactivated"
+    it 'should see the initial setting of the state as a change with the initial state as the previous value' do
+      u.state = :activated
+      u.state_was.to_sym.should eql(:pending)
+    end
 
-    u.will_save_change_to_state?.should be true
-    u.state_in_database.should eq("pending")
-    u.state_before_last_save.should be nil
+    it 'should not obstruct normal validations' do
+      u.should_not be_valid
+      u.errors[:email].grep(/length/).should_not be_empty
+    end
 
-    u.save!
+    it 'should ensure a valid state transition when given a bogus state' do
+      u.state = :anythingelse
 
-    u.will_save_change_to_state?.should_not be true
-    u.state_in_database.should eq("hyperactivated")
-    u.state_before_last_save.should eq("pending")
-  end
+      u.should_not be_valid
+      u.errors[:state].should eql(['is not a valid state'])
+    end
 
-  it "should ensure a valid state transition when given an illegal state based on the current state" do
-    u = User.new
+    it 'should allow creation at any state' do
+      u.email = 'doug@example.com'
+      u.state = :hyperactivated
 
-    allow(u).to receive(:new_record?).and_return(false)
+      u.should be_valid
+    end
 
-    u.state = "hyperactivated"
+    it 'should ensure a valid state transition when given an illegal state based on the current state' do
+      allow(u).to receive(:new_record?).and_return(false)
 
-    u.should_not be_valid
-    u.errors[:state].should_not be_empty
-  end
+      u.state = 'hyperactivated'
 
-  it "should not allow a transition that is currently in a `to` state" do
-    u = User.new(email: "fred@example.com")
-    u.activate!
-    u.hyperactivate!
+      u.should_not be_valid
+      u.errors[:state].should_not be_empty
+    end
 
-    lambda {
+    it 'should not allow a transition that is currently in a `to` state' do
+      u.email = 'fred@example.com'
+      u.activate!
       u.hyperactivate!
-    }.should raise_error(/cannot transition to \"hyperactivated\" from \"hyperactivated\"/)
-  end
-
-  it "should run conditional validations" do
-    u = User.new
-    u.state = "semiactivated"
-    u.should_not be_valid
 
-    u.errors[:state].should be_empty
-    u.errors[:email].grep(/format/).should_not be_empty
-  end
-
-  it "should invoke callbacks" do
-    u = User.new(activated: true, email: "doug@example.com", name: "doug")
-    u.activated.should == true
+      lambda {
+        u.hyperactivate!
+      }.should raise_error(/cannot transition to hyperactivated from hyperactivated/)
+    end
 
-    u.deactivate
+    it 'should run conditional validations' do
+      u.state = 'semiactivated'
+      u.should_not be_valid
 
-    u.activated.should == false
-    u.state.should eql("deactivated")
-    u.activated_state_at.should be_nil
-    u.should be_persisted
-  end
-
-  it "should conditionally invoke after_save callbacks when use_previous is true" do
-    u = User.new
-    u.email = "doug@example.com"
+      u.errors[:state].should be_empty
+      u.errors[:email].should_not be_empty
+    end
 
-    u.semiactivate!
+    it 'should invoke callbacks' do
+      u.assign_attributes(activated: true, email: 'doug@example.com', name: 'doug')
+      u.activated.should == true
 
-    u.state.should eql("semiactivated")
-    u.activation_notification_published.should_not be true
+      u.deactivate
 
-    u.activate!
+      u.activated.should == false
+      u.state.should eql :deactivated
+      u.activated_state_at.should be_nil
+      u.should be_persisted
+    end
 
-    u.state.should eql("activated")
-    u.activation_notification_published.should be true
-  end
+    it 'should blow up if the record is invalid and a bang method is used' do
+      u.assign_attributes(email: 'doug@other.com', name: 'doug')
+      -> { u.activate! }.should raise_error(ActiveRecord::RecordInvalid)
+    end
 
-  it "should blow up if the record is invalid and a bang method is used" do
-    u = User.new(email: "doug@other.com", name: "doug")
-    lambda {
-      u.activate!
-    }.should raise_error(ActiveRecord::RecordInvalid)
-  end
+    it 'should allow for other fields to be used other than state' do
+      a = Animal.new
+      a.should be_valid
 
-  it "should allow for other fields to be used other than state" do
-    a = Animal.new
-    a.should be_valid
+      a.birth!
+    end
 
-    a.birth!
-  end
+    it 'should create implicit transitions for state declarations' do
+      a = Animal.new
+      a.should_not be_grown_up
+      a.status = 'grown_up'
+      a.save
+    end
 
-  it "should create implicit transitions for state declarations" do
-    a = Animal.new
-    a.should_not be_grown_up
-    a.status = "grown_up"
-    a.save
-  end
+    it 'should allow multiple machines in the same model' do
+      f = Farm.new
 
-  it "should allow multiple machines in the same model" do
-    f = Farm.new
-    f.should be_dirty
-    f.should be_house_dirty
+      f.should be_dirty
+      f.should be_house_dirty
 
-    f.cleanup
+      f.cleanup
 
-    f.should_not be_dirty
-    f.should be_house_dirty
+      f.should_not be_dirty
+      f.should be_house_dirty
 
-    f.house_cleanup
+      f.house_cleanup # the house namespace
 
-    f.should_not be_house_dirty
-  end
+      f.should_not be_dirty
+      f.should_not be_house_dirty
+    end
 
-  it "should allow saving to be skipped" do
-    f = Farm.new
-    f.cleanup(false)
+    it 'should allow saving to be skipped' do
+      f = Farm.new
+      f.cleanup(false)
 
-    f.should_not be_persisted
-  end
+      f.should_not be_persisted
+    end
 
-  it "should allow no initial state" do
-    f = Factory.new
-    f.state.should be_nil
+    it 'should allow no initial state' do
+      f = Factory.new
+      f.state.should be_nil
 
-    f.construct.should eql(true)
+      f.construct.should eql(true)
 
-    f.state.should eql("constructed")
-  end
+      f.state.should eql(:constructed)
+    end
 
-  it "should allow any transition if validations are opted out of" do
-    u = User.new
-    u.email = "doug@example.com"
+    it 'should allow any transition if validations are opted out of' do
+      u.email = 'doug@example.com'
 
-    u.can_hyperactivate?.should eql(false)
-    u.hyperactivate.should eql(false)
+      u.can_hyperactivate?.should eql(false)
+      u.hyperactivate.should eql(false)
 
-    u.state.should eql("pending")
+      u.current_state.should eql :pending
 
-    u.without_state_transition_validations do
-      u.can_hyperactivate?.should eql(true)
-      u.hyperactivate.should eql(true)
+      u.without_state_transition_validations do
+        u.can_hyperactivate?.should eql(true)
+        u.hyperactivate.should eql(true)
+      end
     end
-  end
 
-  it "should skip tracking timestamps if opted out of" do
-    u = User.new
-    u.email = "doug@example.com"
+    it 'should skip tracking timestamps if opted out of' do
+      u.email = 'doug@example.com'
 
-    u.without_state_transition_tracking do
-      u.semiactivate!
-      u.state.should eql("semiactivated")
-      u.semiactivated_state_at.should be_nil
+      u.without_state_transition_tracking do
+        u.semiactivate!
+        u.state.should eql :semiactivated
+        u.semiactivated_state_at.should be_nil
+      end
+
+      # Make sure that tracking is ensured back to
+      # original value
+      u.activate!
+      u.activated_state_at.should_not be_nil
     end
 
-    # Make sure that tracking is ensured back to
-    # original value
-    u.activate!
-    u.activated_state_at.should_not be_nil
-  end
+    it 'should skip tracking timestamps if opted out of with thread safety' do
+      threads = []
+      skip = User.new(email: 'skip@example.com', state: :pending)
+      nope = User.new(email: 'nope@example.com', state: :pending)
 
-  it "should skip tracking timestamps if opted out of with thread safety" do
-    threads = []
-    skip = User.new(email: "skip@example.com")
-    nope = User.new(email: "nope@example.com")
+      threads << Thread.new do
+        sleep 0.5
+        nope.semiactivate!
+      end
 
-    threads << Thread.new do
-      sleep 0.5
-      nope.semiactivate!
-    end
-    threads << Thread.new do
-      skip.without_state_transition_tracking do
-        sleep 1
-        skip.semiactivate!
+      threads << Thread.new do
+        skip.without_state_transition_tracking do
+          sleep 1
+          skip.semiactivate!
+        end
       end
-    end
 
-    threads.each(&:join)
+      threads.each(&:join)
 
-    nope.semiactivated_state_at.should_not be_nil
-    skip.semiactivated_state_at.should be_nil
-  end
+      nope.semiactivated_state_at.should_not be_nil
+      skip.semiactivated_state_at.should be_nil
+    end
 
-  it "should not inherit _integration cache on dup" do
-    u = User.new(email: "user@example.com")
-    u.save!
+    it 'should not inherit _integration cache on dup' do
+      u.email = 'user@example.com'
+      u.save!
 
-    u_duped = u.dup
+      u_duped = u.dup
 
-    u.semiactivate!
+      u.semiactivate!
 
-    u_duped_integration = u_duped.send(:_integration)
+      u_duped_integration = u_duped.send(:_stator_integration)
 
-    u_duped_integration.state.should_not eql(u.state)
-    u_duped_integration.instance_values["record"].should eq(u_duped)
+      u_duped_integration.state.should_not eql(u.state)
+      u_duped_integration.instance_values['record'].should eq(u_duped)
+    end
   end
 
-  describe "helper methods" do
-    it "should answer the question of whether the state is currently the one invoked" do
+  describe 'helper methods' do
+    it 'should answer the question of whether the state is currently the one invoked' do
       a = Animal.new
       a.should be_unborn
       a.should_not be_born
@@ -244,7 +206,7 @@ describe Stator::Model do
       a.should_not be_unborn
     end
 
-    it "should determine if it can validly execute a transition" do
+    it 'should determine if it can validly execute a transition' do
       a = Animal.new
       a.can_birth?.should eql(true)
 
@@ -254,87 +216,18 @@ describe Stator::Model do
     end
   end
 
-  it "should validate state transitions using the db state after a transaction rollback" do
-    is_active_record_6_or_higher = Gem::Requirement.new(">= 6.0").satisfied_by?(ActiveRecord.version)
-
-    u = User.create!(email: 'doug@example.com')
-    u.state.should eql('pending')
-
-    lambda {
-      ActiveRecord::Base.transaction do
-        # The state change will be applied to the model object in memory.
-        # An UPDATE query will be sent to the db, but it will be rolled back
-        # when the error is raised below.
-        u.activate!
-        raise "Some error"
-      end
-    }.should raise_error("Some error")
-
-    u.state.should eql("activated")
-
-    # Rails 6.0 fixed a bug where a model's dirty state would be incorrect
-    # in a scenario like this one, where a model is updated within a transaction,
-    # and the transaction is then rolled back:
-    #
-    # https://github.com/rails/rails/pull/35987
-    #
-    # We show this dirty behavior change in Rails 6.0 below to clarify why stator itself
-    # behaves differently starting in Rails 6.0.
-    if is_active_record_6_or_higher
-      # On Rails 6.0 or higher, attribute_in_database is "pending" — which is correct,
-      # because the db transaction was rolled back.
-      u.attribute_in_database("state").should eql("pending")
-
-      # Attempting a state change to "hyperactivated" fails, which is correct,
-      # because the previous state change to "activated" did not succeed.
-      lambda {
-        u.hyperactivate!
-      }.should raise_error(ActiveRecord::RecordInvalid, 'Validation failed: State cannot transition to "hyperactivated" from "pending"')
-    else
-      # On Rails < 6.0, attribute_in_database is "activated" — which is incorrect,
-      # because the db transaction was rolled back.
-      u.attribute_in_database("state").should eql("activated")
-
-      # On Rails < 6.0, stator incorrectly allows the state change to "hyperactivated"
-      # because it incorrectly thinks the state has been successfully updated to "activated".
-      lambda {
-        u.hyperactivate!
-      }.should_not raise_error
-    end
-  end
-
-  it "should not support multiple state changes made between saves" do
-    u = User.create!(email: "doug@example.com")
-    u.state.should eql("pending")
-
-    u.activate(false) # change state, but do not save to db
-    u.state.should eql("activated")
-
-    lambda {
-      # Fails because the db state is still "pending", and
-      # the db state is what stator uses for the "previous" state
-      # to check that the state transition is valid.
-      u.hyperactivate!
-    }.should raise_error(ActiveRecord::RecordInvalid, 'Validation failed: State cannot transition to "hyperactivated" from "pending"')
-
-    # The model is updated in-memory with the new state value,
-    # but remains invalid.
-    u.state.should eql("hyperactivated")
-    u.valid?.should be false
-  end
-
-  describe "tracker methods" do
+  describe 'tracker methods' do
     before do
-      Time.zone = "Eastern Time (US & Canada)"
+      Time.zone = 'Eastern Time (US & Canada)'
     end
 
-    it "should store the initial state timestamp when the record is created" do
+    it 'should store the initial state timestamp when the record is created' do
       a = Animal.new
       a.save
       a.unborn_status_at.should be_within(1).of(Time.zone.now)
     end
 
-    it "should store when a record changed state for the first time" do
+    it 'should store when a record changed state for the first time' do
       a = Animal.new
       a.unborn_status_at.should be_nil
       a.born_status_at.should be_nil
@@ -343,7 +236,7 @@ describe Stator::Model do
       a.born_status_at.should be_within(1).of(Time.zone.now)
     end
 
-    it "should store when a record change states" do
+    it 'should store when a record change states' do
       a = Animal.new
       a.status_changed_at.should be_nil
 
@@ -353,15 +246,14 @@ describe Stator::Model do
 
       previous_status_changed_at = a.status_changed_at
 
-      a.name = "new name"
+      a.name = 'new name'
       a.save
 
       a.status_changed_at.should eql(previous_status_changed_at)
     end
 
-    it "should prepend the setting of the timestamp so other callbacks can use it" do
-      u = User.new
-      u.email = "doug@example.com"
+    it 'should prepend the setting of the timestamp so other callbacks can use it' do
+      u.email = 'doug@example.com'
 
       u.tagged_at.should be_nil
       u.semiactivate!
@@ -370,35 +262,34 @@ describe Stator::Model do
       u.tagged_at.should_not be_nil
     end
 
-    it "should respect the timestamp if explicitly provided" do
-      t = Time.at(Time.now.to_i - 3600)
+    it 'should respect the timestamp if explicitly provided' do
+      t = Time.zone.at(Time.now.to_i - 3600)
 
-      u = User.new
-      u.email = "doug@example.com"
-      u.state = "semiactivated"
+      u.email = 'doug@example.com'
+      u.state = 'semiactivated'
       u.semiactivated_state_at = t
       u.save!
 
-      u.state.should eql("semiactivated")
+      u.state.should eql('semiactivated')
       u.semiactivated_state_at.should eql(t)
     end
 
-    it "should respect the timestamp if explicitly provided via create" do
-      t = Time.at(Time.now.to_i - 3600)
+    it 'should respect the timestamp if explicitly provided via create' do
+      t = Time.zone.at(Time.now.to_i - 3600)
 
       u = User.create!(
-        email: "doug@example.com",
-        state: "semiactivated",
+        email: 'doug@example.com',
+        state: 'semiactivated',
         semiactivated_state_at: t
       )
 
-      u.state.should eql("semiactivated")
+      u.state.should eql('semiactivated')
       u.semiactivated_state_at.should eql(t)
     end
 
-    it "should allow opting into track by namespace" do
-      z = ZooKeeper.new(name: "Doug")
-      z.employment_state.should eql("hired")
+    it 'should allow opting into track by namespace' do
+      z = ZooKeeper.new(name: 'Doug')
+      z.employment_state.should eql('hired')
       z.employment_fire!
       z.fired_employment_state_at.should_not be_nil
 
@@ -411,52 +302,53 @@ describe Stator::Model do
       z.ended_working_state_at.should be_nil
     end
 
-    describe "#state_by?" do
-      it "should be true when the transition is earlier" do
-        t = Time.now
-        u = User.create!( email: "doug@example.com", activated_state_at: t)
-        u.state_by?(:activated, Time.at(t.to_i + 1)).should be true
-        u.activated_state_by?(Time.at(t.to_i + 1)).should be true
+    describe '#state_by?' do
+      it 'should be true when the transition is earlier' do
+        t = Time.zone.now
+        u = User.create!(email: 'doug@example.com', activated_state_at: t)
+        u.state_by?(:activated, Time.zone.at(t.to_i + 1)).should be true
+        u.activated_state_by?(Time.zone.at(t.to_i + 1)).should be true
       end
 
-      it "should be true when the transition is at the same time" do
-        t = Time.now
-        u = User.create!( email: "doug@example.com", activated_state_at: t)
+      it 'should be true when the transition is at the same time' do
+        t = Time.zone.now
+        u = User.create!(email: 'doug@example.com', activated_state_at: t)
         u.state_by?(:activated, t).should be true
         u.activated_state_by?(t).should be true
       end
 
-      it "should be false when the transition is later" do
-        t = Time.now
-        u = User.create!( email: "doug@example.com", activated_state_at: t)
-        u.state_by?(:activated, Time.at(t.to_i - 1)).should be false
-        u.activated_state_by?(Time.at(t.to_i - 1)).should be false
+      it 'should be false when the transition is later' do
+        t = Time.zone.now
+        u = User.create!(email: 'doug@example.com', activated_state_at: t)
+        u.state_by?(:activated, Time.zone.at(t.to_i - 1)).should be false
+        u.activated_state_by?(Time.zone.at(t.to_i - 1)).should be false
       end
 
-      it "should be false when the transition is nil" do
-        t = Time.now
-        u = User.create!( email: "doug@example.com", activated_state_at: nil)
+      it 'should be false when the transition is nil' do
+        t = Time.zone.now
+        u = User.create!(email: 'doug@example.com', activated_state_at: nil)
         u.state_by?(:activated, t).should be false
         u.activated_state_by?(t).should be false
       end
 
-      it "should be true when the transition is not nil and the time is nil" do
-        u = User.create!( email: "doug@example.com", activated_state_at: Time.now)
+      it 'should be true when the transition is not nil and the time is nil' do
+        u = User.create!(email: 'doug@example.com', activated_state_at: Time.zone.now)
         u.state_by?(:activated, nil).should be true
         u.activated_state_by?(nil).should be true
       end
 
-      it "should be false when both are nil" do
-        u = User.create!(email: "doug@example.com", activated_state_at: nil)
+      it 'should be false when both are nil' do
+        u = User.create!(email: 'doug@example.com', activated_state_at: nil)
         u.state_by?(:activated, nil).should be false
         u.activated_state_by?(nil).should be false
       end
     end
   end
 
-  describe "aliasing" do
-    it "should allow aliasing within the dsl" do
-      u = User.new(email: "doug@example.com")
+  describe 'aliasing' do
+    it 'should allow aliasing within the dsl' do
+      u = User.new(email: 'doug@example.com')
+
       u.should respond_to(:active?)
       u.should respond_to(:inactive?)
 
@@ -473,34 +365,28 @@ describe Stator::Model do
       u.should be_active
       u.should_not be_inactive
 
-      User::ACTIVE_STATES.should eql(%w[activated hyperactivated])
-      User::INACTIVE_STATES.should eql(%w[pending deactivated semiactivated])
-
-      is_active_record_72_or_higher = Gem::Requirement.new(">= 7.2").satisfied_by?(ActiveRecord.version)
-
-      if (is_active_record_72_or_higher)
-        User.active.to_sql.gsub("  ", " ").should eq("SELECT 'users'.* FROM 'users' WHERE 'users'.'state' IN ('activated', 'hyperactivated')")
-        User.inactive.to_sql.gsub("  ", " ").should eq("SELECT 'users'.* FROM 'users' WHERE 'users'.'state' IN ('pending', 'deactivated', 'semiactivated')")
-      else
-        User.active.to_sql.gsub("  ", " ").should eq("SELECT users.* FROM users WHERE users.state IN ('activated', 'hyperactivated')")
-        User.inactive.to_sql.gsub("  ", " ").should eq("SELECT users.* FROM users WHERE users.state IN ('pending', 'deactivated', 'semiactivated')")
-      end
+      User::ACTIVE_STATES.should eql(%i[activated hyperactivated])
+      User::INACTIVE_STATES.should eql(%i[pending deactivated semiactivated])
 
+      User.active.to_sql.gsub('  ',
+                              ' ').should eq("SELECT users.* FROM users WHERE users.state IN ('activated', 'hyperactivated')")
+      User.inactive.to_sql.gsub('  ',
+                                ' ').should eq("SELECT users.* FROM users WHERE users.state IN ('pending', 'deactivated', 'semiactivated')")
     end
 
-    it "should evaluate inverses correctly" do
+    it 'should evaluate inverses correctly' do
       f = Farm.new
-      f.house_state = "dirty"
+      f.house_state = 'dirty'
       f.should_not be_house_cleaned
 
-      f.house_state = "disgusting"
+      f.house_state = 'disgusting'
       f.should_not be_house_cleaned
 
-      f.house_state = "clean"
+      f.house_state = 'clean'
       f.should be_house_cleaned
     end
 
-    it "should namespace aliases just like everything else" do
+    it 'should namespace aliases just like everything else' do
       f = Farm.new
       f.should respond_to(:house_cleaned?)
 
@@ -510,24 +396,23 @@ describe Stator::Model do
       f.should be_house_cleaned
     end
 
-    it "should allow for explicit constant and scope names to be provided" do
+    it 'should allow for explicit constant and scope names to be provided' do
       User.should respond_to(:luke_warmers)
-      (!!defined?(User::LUKE_WARMERS)).should eql(true)
+      (!defined?(User::LUKE_WARMERS).nil?).should eql(true)
       u = User.new
       u.should respond_to(:luke_warm?)
     end
 
-    it "should not create constants or scopes by default" do
+    it 'should not create constants or scopes by default' do
       u = User.new
       u.should respond_to(:iced_tea?)
-      (!!defined?(User::ICED_TEA_STATES)).should eql(false)
+      (!defined?(User::ICED_TEA_STATES).nil?).should eql(false)
       User.should_not respond_to(:iced_tea)
     end
 
-    it "should determine the full list of states correctly" do
-      states = User._stator("").states
-      states.should eql(%w[pending activated deactivated semiactivated hyperactivated])
+    it 'should determine the full list of states correctly' do
+      states = User._stator('').states
+      states.should eql(%i[pending activated deactivated semiactivated hyperactivated])
     end
   end
-
 end