Allow the initial value of a sequence to be lazy loaded (#1761)

* Allow the initial value of a sequence to be lazy loaded

Co-authored-by: David Arthur <[email protected]>

* Refactor EnumeratorAdaptor to simplify handling of lazy initial values

This means that any object that responds to `call` can be used to
supply the initial value of a lazy sequence.

@vburzynski suggested this refactoring to simplify the EnumeratorAdapter
class after the introduction of lazily evaluated initial values.

* Add a spec for lazy sequences accepting any inital value that responds to call

---------

Co-authored-by: David Arthur <[email protected]>

Author: ajesler

docs/src/sequences/initial-value.md

@@ -8,3 +8,11 @@ factory :user do
   sequence(:email, 1000) { |n| "person#{n}@example.com" }
 end
 ```
+
+The initial value can also be lazily set by passing a Proc as the value. This Proc will be called the first time the `sequence.next` is called.
+
+```ruby
+factory :user do
+  sequence(:email, proc { Person.count + 1 }) { |n| "person#{n}@example.com" }
+end
+```

lib/factory_bot/sequence.rb

@@ -150,33 +150,47 @@ def fail_value_not_found(value)
     end
 
     class EnumeratorAdapter
-      def initialize(value)
-        @first_value = value
-        @value = value
+      def initialize(initial_value)
+        @initial_value = initial_value
       end
 
       def peek
-        @value
+        value
       end
 
       def next
-        @value = @value.next
+        @value = value.next
       end
 
       def rewind
-        @value = @first_value
+        @value = first_value
       end
 
       def set_value(new_value)
-        if new_value >= @first_value
+        if new_value >= first_value
           @value = new_value
         else
           fail ArgumentError, "Value cannot be less than: #{@first_value}"
         end
       end
 
       def integer_value?
-        @first_value.is_a?(Integer)
+        first_value.is_a?(Integer)
+      end
+
+      private
+
+      def first_value
+        @first_value ||= initial_value
+      end
+
+      def value
+        @value ||= initial_value
+      end
+
+      def initial_value
+        @value = @initial_value.respond_to?(:call) ? @initial_value.call : @initial_value
+        @first_value = @value
       end
     end
   end

spec/acceptance/sequence_setting_spec.rb

@@ -72,6 +72,16 @@
         expect(generate_list(:jet_pilot, :dob, 3).last).to eq Date.parse("2025-05-03")
       end
 
+      it "works with lazy Integer sequences" do
+        FactoryBot.define do
+          sequence(:email, proc { 42 }) { |n| "somebody#{n}@example.com" }
+        end
+
+        expect(generate_list(:email, 3).last).to eq "[email protected]"
+        FactoryBot.set_sequence(:email, 54321)
+        expect(generate_list(:email, 3).last).to eq "[email protected]"
+      end
+
       it "does not collide with other factory or global sequences" do
         define_class("User") { attr_accessor :email }
         define_class("Admin") { attr_accessor :email }

spec/acceptance/sequence_spec.rb

@@ -86,6 +86,60 @@
       expect(generate(:commenter, :length)).to eq "user-called-z"
     end
 
+    it "generates sequences after lazy loading an initial value from a proc" do
+      loaded = false
+
+      FactoryBot.define do
+        sequence :count, proc {
+          loaded = true
+          "d"
+        }
+      end
+
+      expect(loaded).to be false
+
+      first_value = generate(:count)
+      another_value = generate(:count)
+
+      expect(loaded).to be true
+
+      expect(first_value).to eq "d"
+      expect(another_value).to eq "e"
+    end
+
+    it "generates sequences after lazy loading an initial value from an object responding to call" do
+      define_class("HasCallMethod") do
+        def initialise
+          @called = false
+        end
+
+        def called?
+          @called
+        end
+
+        def call
+          @called = true
+          "ABC"
+        end
+      end
+
+      has_call_method_instance = HasCallMethod.new
+
+      FactoryBot.define do
+        sequence :letters, has_call_method_instance
+      end
+
+      expect(has_call_method_instance).not_to be_called
+
+      first_value = generate(:letters)
+      another_value = generate(:letters)
+
+      expect(has_call_method_instance).to be_called
+
+      expect(first_value).to eq "ABC"
+      expect(another_value).to eq "ABD"
+    end
+
     it "generates few values of the sequence" do
       define_class("User") { attr_accessor :email }
 

spec/factory_bot/sequence_spec.rb

@@ -152,6 +152,24 @@
     it_behaves_like "a sequence", first_value: "A", second_value: "B"
   end
 
+  describe "a sequence with lazy initial value and a block" do
+    subject do
+      FactoryBot::Sequence.new(:test, proc { "J" }) do |n|
+        "=#{n}"
+      end
+    end
+
+    it_behaves_like "a sequence", first_value: "=J", second_value: "=K"
+  end
+
+  describe "a sequence with a lazy initial value without a block" do
+    subject do
+      FactoryBot::Sequence.new(:test, proc { 3 })
+    end
+
+    it_behaves_like "a sequence", first_value: 3, second_value: 4
+  end
+
   describe "iterating over items in an enumerator" do
     subject do
       FactoryBot::Sequence.new(:name, %w[foo bar].to_enum) { |n| "=#{n}" }
@@ -175,6 +193,14 @@
     expect(sequence.next(scope)).to eq "=Aattribute"
   end
 
+  it "a custom lazy sequence and scope increments within the correct scope" do
+    sequence = FactoryBot::Sequence.new(:name, proc { "A" }) { |n| "=#{n}#{foo}" }
+    scope = double("scope", foo: "attribute")
+
+    expect(sequence.next(scope)).to eq "=Aattribute"
+    expect(sequence.next(scope)).to eq "=Battribute"
+  end
+
   it "a custom sequence and scope increments within the correct scope when incrementing" do
     sequence = FactoryBot::Sequence.new(:name, "A") { |n| "=#{n}#{foo}" }
     scope = double("scope", foo: "attribute")
@@ -183,6 +209,14 @@
     expect(sequence.next(scope)).to eq "=Battribute"
   end
 
+  it "a custom lazy sequence and scope increments within the correct scope when incrementing" do
+    sequence = FactoryBot::Sequence.new(:name, proc { "A" }) { |n| "=#{n}#{foo}" }
+    scope = double("scope", foo: "attribute")
+    sequence.next(scope)
+
+    expect(sequence.next(scope)).to eq "=Battribute"
+  end
+
   it "a custom scope increments within the correct scope after rewinding" do
     sequence = FactoryBot::Sequence.new(:name, "A") { |n| "=#{n}#{foo}" }
     scope = double("scope", foo: "attribute")
@@ -191,4 +225,13 @@
 
     expect(sequence.next(scope)).to eq "=Aattribute"
   end
+
+  it "a custom scope with a lazy sequence increments within the correct scope after rewinding" do
+    sequence = FactoryBot::Sequence.new(:name, proc { "A" }) { |n| "=#{n}#{foo}" }
+    scope = double("scope", foo: "attribute")
+    sequence.next(scope)
+    sequence.rewind
+
+    expect(sequence.next(scope)).to eq "=Aattribute"
+  end
 end