question_page_spec.rb

# frozen_string_literal: true

require 'rails_helper'

RSpec.describe Strata::Flows::QuestionPage do
  before do
    test_model_class = Class.new do
      include ActiveModel::Model
      include ActiveModel::Attributes

      attribute :first_name, :string
      validates :first_name, presence: true, on: :first_name
    end

    stub_const("TestModel", test_model_class)
  end

  let(:record) { TestModel.new }

  describe "with only required attributes" do
    let(:page) { described_class.new("first_name") }

    it "uses the provided name as the set of fields" do
      expect(page.name).to eq("first_name")
      expect(page.fields).to eq([ :first_name ])
    end

    it "is always needed" do
      expect(page).to be_needed(record)
    end

    it "is completed based on the page name" do
      expect(page).not_to be_completed(record)

      record.first_name = "Mary"
      expect(page).to be_completed(record)
    end

    it "is started when the field has a value" do
      expect(page).not_to be_started(record)

      record.first_name = "Mary"
      expect(page).to be_started(record)
    end

    it "returns the correct pathnames" do
      expect(page.edit_pathname).to eq("edit_first_name")
      expect(page.update_pathname).to eq("update_first_name")
    end
  end

  describe "with conditional if" do
    let(:page) { described_class.new("first_name", if: ->(record) { record.first_name.nil? }) }

    it "is needed if conditional is true" do
      expect(page).to be_needed(record)
    end

    it "skips the page if conditional is false" do
      record.first_name = "Minnie"
      expect(page).not_to be_needed(record)
    end
  end

  describe "with explicit fields" do
    let(:page) { described_class.new("name", fields: [ :first_name, :last_name ]) }

    it "uses the passed in fields" do
      expect(page.fields).to eq([ :first_name, :last_name ])
    end
  end

  describe "#started? with a boolean field" do
    before do
      bool_class = Class.new do
        include ActiveModel::Model
        include ActiveModel::Attributes

        attribute :consents, :boolean
      end

      stub_const("BooleanModel", bool_class)
    end

    let(:record) { BooleanModel.new }
    let(:page) { described_class.new("consents") }

    it "is not started when the field is nil" do
      expect(page).not_to be_started(record)
    end

    it "is started when the field is true" do
      record.consents = true
      expect(page).to be_started(record)
    end

    it "is started when the field is explicitly false" do
      record.consents = false
      expect(page).to be_started(record)
    end

    context "when mixed with a string field that is blank" do
      before do
        mixed_class = Class.new do
          include ActiveModel::Model
          include ActiveModel::Attributes

          attribute :consents, :boolean
          attribute :note, :string
        end

        stub_const("MixedBooleanModel", mixed_class)
      end

      let(:record) { MixedBooleanModel.new }
      let(:page) { described_class.new("preferences", fields: [ :note, :consents ]) }

      it "is started when only the boolean field is explicitly false" do
        record.consents = false
        expect(page).to be_started(record)
      end
    end
  end

  describe "#started? when a field is not defined on the record" do
    let(:page) { described_class.new("ghost", fields: [ :nonexistent_field ]) }

    it "does not raise" do
      expect { page.started?(record) }.not_to raise_error
    end

    it "is not started" do
      expect(page).not_to be_started(record)
    end

    context "when mixed with a defined field that has a value" do
      let(:page) { described_class.new("mixed", fields: [ :nonexistent_field, :first_name ]) }

      it "is started" do
        record.first_name = "Mary"
        expect(page).to be_started(record)
      end
    end
  end

  describe "#started? with a multi-parameter field" do
    before do
      test_model_class = Class.new(ActiveRecord::Base) do
        self.table_name = "test_records"
        include Strata::Attributes

        strata_attribute :date_of_birth, :memorable_date
      end

      stub_const("DobModel", test_model_class)
    end

    let(:record) { DobModel.new }
    let(:page) { described_class.new("dob", fields: [ date_of_birth: [ :month, :day, :year ] ]) }

    it "is not started when the field has no value" do
      expect(page).not_to be_started(record)
    end

    it "is started when the field has a value" do
      record.date_of_birth = Date.new(1990, 5, 15)
      expect(page).to be_started(record)
    end
  end

  describe "#started? with a nested-attributes field" do
    before do
      child_class = Class.new(ActiveRecord::Base) do
        self.table_name = "test_application_forms"
      end
      stub_const("NestedAttrsForm", child_class)

      parent_class = Class.new(ActiveRecord::Base) do
        self.table_name = "users"
        has_many :forms, class_name: "NestedAttrsForm", foreign_key: :user_id
        accepts_nested_attributes_for :forms
      end
      stub_const("NestedAttrsUser", parent_class)
    end

    let(:record) { NestedAttrsUser.new(first_name: "Alice", last_name: "Smith") }

    context "with the hash form" do
      let(:page) { described_class.new("forms", fields: [ forms_attributes: [ :test_string ] ]) }

      it "is not started when no nested records have been assigned" do
        expect(page).not_to be_started(record)
      end

      it "is started after nested attributes are assigned" do
        record.forms_attributes = [ { test_string: "hello" } ]
        expect(page).to be_started(record)
      end
    end

    context "with the symbol form" do
      let(:page) { described_class.new("forms", fields: [ :forms_attributes ]) }

      it "is started after nested attributes are assigned" do
        record.forms_attributes = [ { test_string: "hello" } ]
        expect(page).to be_started(record)
      end
    end
  end

  describe "#started? with multiple fields" do
    before do
      multi_field_class = Class.new do
        include ActiveModel::Model
        include ActiveModel::Attributes

        attribute :first_name, :string
        attribute :last_name, :string
      end

      stub_const("MultiFieldModel", multi_field_class)
    end

    let(:record) { MultiFieldModel.new }
    let(:page) { described_class.new("name", fields: [ :first_name, :last_name ]) }

    it "is not started when no fields have values" do
      expect(page).not_to be_started(record)
    end

    it "is started when any field has a value" do
      record.last_name = "Smith"
      expect(page).to be_started(record)
    end
  end

  describe "#attributes" do
    before do
      test_model_class = Class.new(ActiveRecord::Base) do
        self.table_name = "test_records"
        include Strata::Attributes

        strata_attribute :applicant_name, :name
        strata_attribute :home_address, :address
        strata_attribute :date_of_birth, :memorable_date
        strata_attribute :weekly_wage, :money
        strata_attribute :tax_id, :tax_id
        strata_attribute :adopted_on, :us_date
        strata_attribute :period, :us_date, range: true
      end

      stub_const("StrataTestModel", test_model_class)
    end

    let(:record) { StrataTestModel.new }

    it "expands name fields into component columns" do
      page = described_class.new("name", fields: [ :applicant_name ])
      expect(page.attributes(record.class)).to eq([
        :applicant_name_first, :applicant_name_middle, :applicant_name_last, :applicant_name_suffix
      ])
    end

    it "expands address fields into component columns" do
      page = described_class.new("address", fields: [ :home_address ])
      expect(page.attributes(record.class)).to eq([
        :home_address_street_line_1, :home_address_street_line_2,
        :home_address_city, :home_address_state, :home_address_zip_code
      ])
    end

    it "expands memorable_date fields into a multi-parameter hash" do
      page = described_class.new("dob", fields: [ :date_of_birth ])
      expect(page.attributes(record.class)).to eq([
        { date_of_birth: [ :month, :day, :year ] }
      ])
    end

    it "expands range fields into start and end columns" do
      page = described_class.new("period", fields: [ :period ])
      expect(page.attributes(record.class)).to eq([
        :period_start, :period_end
      ])
    end

    it "passes through single-column strata fields unchanged" do
      page = described_class.new("wage", fields: [ :weekly_wage ])
      expect(page.attributes(record.class)).to eq([ :weekly_wage ])
    end

    it "passes through non-strata fields unchanged" do
      page = described_class.new("misc", fields: [ :some_plain_field ])
      expect(page.attributes(record.class)).to eq([ :some_plain_field ])
    end

    it "handles a mix of strata and non-strata fields" do
      page = described_class.new("mixed", fields: [ :applicant_name, :tax_id, :date_of_birth ])
      expect(page.attributes(record.class)).to eq([
        :applicant_name_first, :applicant_name_middle, :applicant_name_last, :applicant_name_suffix,
        :tax_id,
        { date_of_birth: [ :month, :day, :year ] }
      ])
    end
  end
end