has_helpers 5.0.2

data/spec/lib/has_helpers/concerns/hydrate_concern_spec.rb

@@ -0,0 +1,473 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+describe HasHelpers::Concerns::HydrateConcern do
+  # Create a minimal table for isolated testing. This avoids coupling to any
+  # real model's validations, associations, or other hydrations.
+  before(:all) do
+    ActiveRecord::Schema.define do
+      create_table :hydrate_concern_tests, force: true do |t|
+        t.string :value
+        t.string :status
+      end
+    end
+  end
+
+  after(:all) do
+    ActiveRecord::Schema.define do
+      drop_table :hydrate_concern_tests, if_exists: true
+    end
+  end
+
+  # Fresh anonymous class per example so _hydrate_fields never bleeds between tests.
+  let(:model) do
+    Class.new(ActiveRecord::Base) do
+      self.table_name = "hydrate_concern_tests"
+      include HasHelpers::Concerns::HydrateConcern
+    end
+  end
+
+  after(:each) do
+    ActiveRecord::Base.connection.execute("DELETE FROM hydrate_concern_tests")
+  end
+
+  ###### class methods ######
+
+  describe ".hydrates" do
+    it "stores the field, block, on: and sets: options" do
+      block = -> { }
+      model.hydrates(:value, block, on: :validation)
+
+      expect(model._hydrate_fields[:value]).to eq(block: block, on: :validation, sets: nil)
+    end
+
+    it "defaults on: to nil" do
+      block = -> { }
+      model.hydrates(:value, block)
+
+      expect(model._hydrate_fields[:value][:on]).to be_nil
+    end
+
+    it "defaults sets: to nil" do
+      model.hydrates(:value, -> { })
+
+      expect(model._hydrate_fields[:value][:sets]).to be_nil
+    end
+
+    it "stores sets: when provided" do
+      model.hydrates(:computed, -> { }, sets: [:field_a, :field_b])
+
+      expect(model._hydrate_fields[:computed][:sets]).to eq([:field_a, :field_b])
+    end
+
+    it "accumulates multiple fields" do
+      model.hydrates(:value, -> { })
+      model.hydrates(:status, -> { })
+
+      expect(model._hydrate_fields.keys).to eq([:value, :status])
+    end
+
+    it "does not mutate the parent class _hydrate_fields" do
+      child = Class.new(model) { self._hydrate_fields = {} }
+      model.hydrates(:value, -> { })
+      child.hydrates(:status, -> { })
+
+      expect(model._hydrate_fields.keys).to eq([:value])
+      expect(child._hydrate_fields.keys).to eq([:status])
+    end
+  end
+
+  describe ".hydrated_fields" do
+    it "returns registered field names" do
+      model.hydrates(:value, -> { })
+      model.hydrates(:status, -> { })
+
+      expect(model.hydrated_fields).to eq([:value, :status])
+    end
+
+    it "returns an empty array when nothing is registered" do
+      expect(model.hydrated_fields).to eq([])
+    end
+
+    it "returns sets: values instead of the field name when sets: is provided" do
+      model.hydrates(:computed, -> { }, sets: [:field_a, :field_b])
+
+      expect(model.hydrated_fields).to eq([:field_a, :field_b])
+    end
+
+    it "returns the field name when sets: is nil" do
+      model.hydrates(:value, -> { })
+
+      expect(model.hydrated_fields).to eq([:value])
+    end
+
+    it "flattens sets: values alongside regular field names" do
+      model.hydrates(:value, -> { })
+      model.hydrates(:computed, -> { }, sets: [:field_a, :field_b])
+
+      expect(model.hydrated_fields).to eq([:value, :field_a, :field_b])
+    end
+  end
+
+  ###### timing ######
+
+  describe "on: nil (default)" do
+    before { model.hydrates(:value, -> { self.value ||= "hydrated" }) }
+
+    it "runs at before_validation" do
+      record = model.new
+      record.valid?
+
+      expect(record.value).to eq("hydrated")
+    end
+
+    it "does not run at after_initialize" do
+      record = model.new
+
+      expect(record.value).to be_nil
+    end
+
+    it "does not run at before_save" do
+      record = model.new(value: nil)
+      record.save!(validate: false)
+
+      # before_save only dispatches :save-specific blocks; value stays nil
+      expect(record.value).to be_nil
+    end
+
+    it "does not run at before_update" do
+      record = model.new(value: "initial")
+      record.save!(validate: false)
+      record.status = "trigger_update"
+      record.save!(validate: false)
+
+      expect(record.value).to eq("initial")
+    end
+  end
+
+  describe "on: :validation" do
+    before { model.hydrates(:value, -> { self.value ||= "hydrated" }, on: :validation) }
+
+    it "runs at before_validation" do
+      record = model.new
+      record.valid?
+
+      expect(record.value).to eq("hydrated")
+    end
+
+    it "does not run at after_initialize" do
+      record = model.new
+
+      expect(record.value).to be_nil
+    end
+
+    it "does not run at before_save" do
+      record = model.new(value: nil)
+      record.save!(validate: false)
+
+      expect(record.value).to be_nil
+    end
+
+    it "does not run at before_update" do
+      record = model.new(value: "initial")
+      record.save!(validate: false)
+      record.status = "trigger_update"
+      record.save!(validate: false)
+
+      expect(record.value).to eq("initial")
+    end
+  end
+
+  describe "on: :initialize" do
+    before { model.hydrates(:value, -> { self.value ||= "hydrated" }, on: :initialize) }
+
+    it "runs at after_initialize" do
+      record = model.new
+
+      expect(record.value).to eq("hydrated")
+    end
+
+    it "also runs at before_validation (on: :initialize is not excluded from validation timing)" do
+      record = model.new
+      record.value = nil  # clear what after_initialize set
+      record.valid?
+
+      expect(record.value).to eq("hydrated")
+    end
+
+    it "does not run at before_save" do
+      record = model.new(value: "initial")
+      record.save!(validate: false)
+
+      # before_save only runs on: :save blocks; value stays as-set
+      expect(record.value).to eq("initial")
+    end
+  end
+
+  describe "on: :save" do
+    before { model.hydrates(:value, -> { self.value = "from_save" }, on: :save) }
+
+    it "does not run at after_initialize" do
+      record = model.new
+
+      expect(record.value).to be_nil
+    end
+
+    it "does not run at before_validation" do
+      record = model.new
+      record.valid?
+
+      expect(record.value).to be_nil
+    end
+
+    it "runs at before_save on create" do
+      record = model.new
+      record.save!(validate: false)
+
+      expect(record.value).to eq("from_save")
+    end
+
+    it "runs at before_save on update" do
+      record = model.new(value: "initial")
+      record.save!(validate: false)
+      record.value = "changed"
+      record.save!(validate: false)
+
+      expect(record.value).to eq("from_save")
+    end
+  end
+
+  describe "on: :update" do
+    before { model.hydrates(:value, -> { self.value = "from_update" }, on: :update) }
+
+    it "does not run at after_initialize" do
+      record = model.new
+
+      expect(record.value).to be_nil
+    end
+
+    it "does not run at before_validation" do
+      record = model.new
+      record.valid?
+
+      expect(record.value).to be_nil
+    end
+
+    it "does not run at before_save on create" do
+      record = model.new(value: "initial")
+      record.save!(validate: false)
+
+      expect(record.value).to eq("initial")
+    end
+
+    it "runs at before_update" do
+      record = model.new(value: "initial")
+      record.save!(validate: false)
+      record.status = "trigger_update"
+      record.save!(validate: false)
+
+      expect(record.value).to eq("from_update")
+    end
+  end
+
+  describe "on: :explicit" do
+    before { model.hydrates(:value, -> { self.value ||= "hydrated" }, on: :explicit) }
+
+    it "does not run at after_initialize" do
+      record = model.new
+
+      expect(record.value).to be_nil
+    end
+
+    it "does not run at before_validation" do
+      record = model.new
+      record.valid?
+
+      expect(record.value).to be_nil
+    end
+
+    it "does not run at before_save" do
+      record = model.new(value: nil)
+      record.save!(validate: false)
+
+      expect(record.value).to be_nil
+    end
+
+    it "does not run at before_update" do
+      record = model.new(value: "initial")
+      record.save!(validate: false)
+      record.status = "trigger_update"
+      record.save!(validate: false)
+
+      expect(record.value).to eq("initial")
+    end
+
+    it "runs when #hydrate is called explicitly" do
+      record = model.new
+      record.hydrate
+
+      expect(record.value).to eq("hydrated")
+    end
+  end
+
+  ###### instance methods ######
+
+  describe "#hydrated_fields" do
+    it "returns an empty array before any hydration runs" do
+      record = model.new
+
+      expect(record.hydrated_fields).to eq([])
+    end
+
+    it "includes a field whose value changed during hydration" do
+      model.hydrates(:value, -> { self.value = "set" }, on: :validation)
+      record = model.new
+      record.valid?
+
+      expect(record.hydrated_fields).to include(:value)
+    end
+
+    it "excludes a field whose value did not change during hydration" do
+      model.hydrates(:value, -> { self.value ||= "default" }, on: :validation)
+      record = model.new(value: "already_set")
+      record.valid?
+
+      expect(record.hydrated_fields).not_to include(:value)
+    end
+
+    it "tracks multiple changed fields across different hydrations" do
+      model.hydrates(:value,  -> { self.value  = "v" }, on: :validation)
+      model.hydrates(:status, -> { self.status = "s" }, on: :validation)
+      record = model.new
+      record.valid?
+
+      expect(record.hydrated_fields).to match_array([:value, :status])
+    end
+  end
+
+  describe "#hydrate" do
+    it "returns self" do
+      record = model.new
+
+      expect(record.hydrate).to be(record)
+    end
+
+    it "runs blocks with on: nil" do
+      model.hydrates(:value, -> { self.value ||= "default" })
+      record = model.new
+      record.hydrate
+
+      expect(record.value).to eq("default")
+    end
+
+    it "runs blocks with on: :initialize" do
+      model.hydrates(:value, -> { self.value ||= "init_default" }, on: :initialize)
+      record = model.new  # after_initialize sets value
+      record.value = nil  # clear it
+      record.hydrate
+
+      expect(record.value).to eq("init_default")
+    end
+
+    it "runs blocks with on: :explicit" do
+      model.hydrates(:value, -> { self.value ||= "explicit_default" }, on: :explicit)
+      record = model.new
+      record.hydrate
+
+      expect(record.value).to eq("explicit_default")
+    end
+
+    it "does not run blocks with on: :validation" do
+      model.hydrates(:value, -> { self.value = "validation_only" }, on: :validation)
+      record = model.new
+      record.hydrate
+
+      expect(record.value).to be_nil
+    end
+
+    it "does not run blocks with on: :save" do
+      model.hydrates(:value, -> { self.value = "save_only" }, on: :save)
+      record = model.new
+      record.hydrate
+
+      expect(record.value).to be_nil
+    end
+
+    it "does not run blocks with on: :update" do
+      model.hydrates(:value, -> { self.value = "update_only" }, on: :update)
+      record = model.new
+      record.hydrate
+
+      expect(record.value).to be_nil
+    end
+
+    it "resets hydrated_fields on each call" do
+      model.hydrates(:value, -> { self.value = "first" })
+      record = model.new
+      record.hydrate
+
+      first_fields = record.hydrated_fields.dup
+      expect(first_fields).to include(:value)
+
+      # Second call: block is a no-op now (value already set, no change)
+      model._hydrate_fields = {}
+      model.hydrates(:value, -> { })  # does not change value
+      record.hydrate
+
+      expect(record.hydrated_fields).to eq([])
+    end
+
+    it "passes kwargs to the block" do
+      model.hydrates(:value, ->(**all) { self.value = all[:default_value] })
+      record = model.new
+      record.hydrate(default_value: "from_kwarg")
+
+      expect(record.value).to eq("from_kwarg")
+    end
+  end
+
+  ###### dispatch_block (private, exercised via #hydrate with kwargs) ######
+
+  describe "dispatch_block" do
+    it "calls block without args when no kwargs are passed" do
+      model.hydrates(:value, -> { self.value = "simple" })
+      record = model.new
+      record.hydrate
+
+      expect(record.value).to eq("simple")
+    end
+
+    it "ignores kwargs when block has no params" do
+      model.hydrates(:value, -> { self.value = "no_params" })
+      record = model.new
+      record.hydrate(irrelevant: "data")
+
+      expect(record.value).to eq("no_params")
+    end
+
+    it "passes all kwargs when block has a **rest param" do
+      model.hydrates(:value, ->(**all) { self.value = all[:target] })
+      record = model.new
+      record.hydrate(target: "keyrest_value", extra: "also_passed")
+
+      expect(record.value).to eq("keyrest_value")
+    end
+
+    it "passes only accepted kwargs when block has named keyword params" do
+      model.hydrates(:value, ->(accepted:, ignored: nil) { self.value = accepted })
+      record = model.new
+      record.hydrate(accepted: "yes", other: "no")
+
+      expect(record.value).to eq("yes")
+    end
+
+    it "calls block without args when none of the kwargs match block's keyword params" do
+      model.hydrates(:value, ->(unrelated: nil) { self.value = "fallback" })
+      record = model.new
+      record.hydrate(something_else: "data")
+
+      expect(record.value).to eq("fallback")
+    end
+  end
+end

data/spec/lib/has_helpers/constant/definition_spec.rb

@@ -0,0 +1,128 @@
+require "rails_helper"
+
+describe ::HasHelpers::Constant::Definition do
+  describe '.attrs' do
+    let(:attrs) { { :name => "Derp", :abbreviation => "drp" } }
+    subject { described_class.new(**attrs) }
+
+    it { expect(subject.attrs).to eq(attrs) }
+    it { expect(subject.name).to eq("Derp") }
+
+    context "lazy" do
+      let(:lazy_attrs) { {:test => proc { :ing }} }
+      subject { described_class.new(:key => "Test", **lazy_attrs) }
+      it { expect(subject.attrs).to eq(lazy_attrs) }
+    end
+  end
+
+  describe "new" do
+    it { expect{ described_class.new(:keys => :other, :than => :name) }.to raise_error(ArgumentError, described_class::ERROR_MSG_MISSING_KEY) }
+    it { expect{ described_class.new(:name => :other) }.to_not raise_error }
+    it { expect{ described_class.new(:key => :other) }.to_not raise_error }
+  end
+
+  describe "#lazy?" do
+    it "returns false when the instance is initialized without a block" do
+      subject = described_class.new(**(FactoryBot.attributes_for(:constant_definition)))
+      expect(subject.lazy?).to be_falsey
+    end
+
+    it "returns false when a block is present" do
+      subject = described_class.new(**(FactoryBot.attributes_for(:constant_definition)), &->{})
+      expect(subject.lazy?).to be_truthy
+    end
+  end
+
+  describe ".evaluate" do
+    it "raises an error when no block is given" do
+      subject = described_class.new(**(FactoryBot.attributes_for(:constant_definition)))
+      expect { subject.evaluate }.to raise_error(NoMethodError)
+    end
+
+    it "executes the given block in the context it was createad and retuns the result" do
+      attrs = { :key => :value }  # This should not affect the return value of the block.
+      subject = described_class.new(**(FactoryBot.attributes_for(:constant_definition)), &generate_block)
+      expect(subject.evaluate).to eq({ :test => :dummy, :herp => :derp })
+    end
+  end
+
+  def generate_block
+    attrs = { :test => :dummy }
+    -> { attrs.merge(:herp => :derp) }
+  end
+
+  describe "#load" do
+    before do
+      ::Color.seed!
+    end
+
+    let!(:red) { ::Color.where(name: 'Red').first_or_create! }
+    let!(:blue) { ::Color.where(name: 'Blue').first_or_create! }
+    let!(:yellow) { ::Color.where(name: 'Yellow').first_or_create! }
+
+    it "finds and returns the constant record" do
+      subject = described_class.new(:name => "Red")
+      expect(subject.load(Color)).to eq(red)
+    end
+
+    context "lazy" do
+      it "evaluates the definition" do
+        subject = Color.send(:__constants__)[:PRIMARY_COLORS]
+        expect(subject.load).to contain_exactly(red, blue, yellow)
+      end
+
+      it "finds and returns the constant record" do
+        name = "Trendy Hipster Clothes"
+        expected = Product.where(:name => name, :code => "THC").first_or_create!
+        subject = described_class.new(:name => name, :code => proc { "THB".next })  # Dynamic :code attribute
+        expect(subject.load(Product)).to eq(expected)
+      end
+    end
+  end
+  
+  before(:each) do
+    Product.all.delete_all
+  end
+
+  describe "#seed!" do
+    subject { described_class.new(:name => "Full on Derp", :code => "FDerp") }
+
+    it "creates a constant record" do
+      expect(Product.find_by(subject.attrs)).to be_nil
+      subject.seed!(Product)
+      expect(Product.find_by(subject.attrs)).to be_a(Product)
+    end
+
+    it "uses an existing record if present" do
+      existing_record = Product.create!(subject.attrs)
+      expect(subject.seed!(Product)).to eq(existing_record)
+    end
+
+    it "sets simple constant ids to type::::name" do
+      attrs = { name: "Test" }
+      simple_option = described_class.new(**attrs)
+      expect(SimpleOption.find_by(**attrs)).to be_nil
+      simple_option.seed!(SimpleOption)
+      expect(SimpleOption.find_by(**attrs)).to be_a(SimpleOption)
+      expect(SimpleOption.find_by(**attrs).id).to eq "SimpleOption::::Test"
+    end
+  end
+
+  describe "#to_s" do
+    it { expect(described_class.new(name: "FooBar").to_s).to eq("FooBar") }
+  end
+
+  describe "#meta" do
+    subject { described_class.new(name: "What's in a name?") }
+
+    it "accepts arbitrary assignments" do
+      expect { subject.meta.data = nil }.to_not raise_error
+    end
+
+    it "makes assignments accessible" do
+      data = { this: "is a test" }
+      subject.meta.data = data
+      expect(subject.meta.data).to eq(data)
+    end
+  end
+end