has_helpers 5.0.2

data/spec/lib/hq/structure/inserts_spec.rb

@@ -0,0 +1,152 @@
+require "rails_helper"
+
+describe ::HQ::Structure::Inserts do
+  let(:connection_pool) { ::ActiveRecord::Base.connection_pool }
+
+  describe "#inserts" do
+    let(:table_name_1) { "fizz_#{Random.rand(10)}" }
+
+    let(:mock_klass_1) do
+      table = table_name_1
+      Class.new(ActiveRecord::Base) do
+        self.table_name = table
+      end
+    end
+
+    before(:each) do
+      clean_tables!(table_name_1)
+      table_1 = table_name_1
+      ActiveRecord::Schema.define do
+        create_table table_1, force: true do |t|
+          t.string  :name
+          t.string  :some_type
+          t.integer :organization_id
+        end
+      end
+    end
+
+    after(:each) do
+      clean_tables!(table_name_1)
+    end
+
+    it "does nothing if the table doesn't exist" do
+      structure = described_class.new(connection_pool: connection_pool, tables: ["table_that_doesnt_exist"])
+      expect(structure.build.to_a).to be_empty
+    end
+
+    it "does nothing for a table with no data" do
+      structure = described_class.new(connection_pool: connection_pool, tables: [table_name_1])
+      expect(structure.build.to_a).to be_empty
+    end
+
+    it "creates inserts" do
+      structure = described_class.new(connection_pool: connection_pool, tables: [table_name_1])
+      mock_klass_1.create(name: "Fizz", some_type: "Buzz")
+      inserts = structure.build.to_a
+      aggregate_failures do
+        expect(inserts.size).to eq 1
+        expect(inserts.first).to match(/setval\(.+::regclass, 2, FALSE\)/)
+      end
+    end
+
+    context "with two tables" do
+      let(:table_name_2) { "buzz_#{Random.rand(10)}" }
+
+      let(:mock_klass_2) do
+        table = table_name_2
+        Class.new(ActiveRecord::Base) do
+          self.table_name = table
+        end
+      end
+
+      before(:each) do
+        clean_tables!(table_name_2)
+        table_1 = table_name_1
+        table_2 = table_name_2
+        ActiveRecord::Schema.define do
+          create_table table_2, force: true do |t|
+            t.string  :name
+            t.integer :fk_id
+          end
+
+          add_foreign_key table_2, table_1, column: :fk_id
+        end
+      end
+
+      after(:each) do
+        clean_tables!(table_name_2)
+      end
+
+      it "creates inserts for two tables" do
+        structure = described_class.new(connection_pool: connection_pool, tables: [table_name_2, table_name_1])
+        fizz_buzz = mock_klass_1.create(name: "Fizz", some_type: "Buzz")
+        mock_klass_2.create(name: "Fizz", fk_id: fizz_buzz.id)
+
+        inserts = structure.build.to_a
+        expect(inserts.size).to eq 2
+        first_insert, second_insert = inserts
+
+        aggregate_failures do
+          expect(first_insert).to match table_name_1
+          expect(second_insert).to match table_name_2
+        end
+      end
+
+      it "finds dependencies" do
+        structure = described_class.new(connection_pool: connection_pool, tables: [table_name_2])
+        fizz_buzz = mock_klass_1.create(name: "Fizz", some_type: "Buzz")
+        mock_klass_2.create(name: "Fizz", fk_id: fizz_buzz.id)
+
+        inserts = structure.build.to_a
+        expect(inserts.size).to eq 2
+        first_insert, second_insert = inserts
+
+        aggregate_failures do
+          expect(first_insert).to match table_name_1
+          expect(second_insert).to match table_name_2
+        end
+      end
+    end
+
+    context "with a cyclic dependency" do
+      let(:cyclic_table_name_1) { "cyclic_fizz_#{Random.rand(10)}" }
+      let(:cyclic_table_name_2) { "cyclic_buzz_#{Random.rand(10)}" }
+
+      before(:each) do
+        clean_tables!(cyclic_table_name_1, cyclic_table_name_2)
+        table_1 = cyclic_table_name_1
+        table_2 = cyclic_table_name_2
+        ActiveRecord::Schema.define do
+          create_table table_1, force: true do |t|
+            t.string  :name
+            t.integer :fk_id
+          end
+
+          create_table table_2, force: true do |t|
+            t.string  :name
+            t.integer :fk_id
+          end
+
+          add_foreign_key table_1, table_2, column: :fk_id
+          add_foreign_key table_2, table_1, column: :fk_id
+        end
+      end
+
+      after(:each) do
+        clean_tables!(cyclic_table_name_1, cyclic_table_name_2)
+      end
+
+      it "raises a cyclic error" do
+        structure = described_class.new(connection_pool: connection_pool, tables: [cyclic_table_name_1, cyclic_table_name_2])
+        expect { structure.build }.to raise_error ::TSort::Cyclic
+      end
+    end
+  end
+
+  def clean_tables!(*tables)
+    tables.each do |table_name|
+      ::ActiveRecord::Base.connection.execute("DROP TABLE IF EXISTS #{table_name} CASCADE")
+    end
+  end
+
+end

data/spec/lib/hq/structure_spec.rb

@@ -0,0 +1,12 @@
+require "rails_helper"
+
+describe ::HQ::Structure do
+  let(:connection_pool) { ::ActiveRecord::Base.connection_pool }
+
+  describe "#dump" do
+    it "raises an error unless the filename ends with .sql" do
+      structure = described_class.new(connection_pool: connection_pool)
+      expect { structure.dump("structure.rb") }.to raise_error described_class::Error
+    end
+  end
+end

data/spec/models/cards/base_spec.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+describe HasHelpers::Cards::CardBuilder::Base do
+  before do
+    HasHelpers::Cards::Registry.reset!
+    HasHelpers::Cards::Registry.register_card_files([])
+
+    # Dummy class to use as a resource in the DSL
+    stub_const("Advisor", Class.new)
+  end
+
+  it "evaluates the DSL, builds definitions, and registers them in HasHelpers::Cards::Registry" do
+    test_class = Class.new(described_class)
+
+    test_class.define do
+      resources do
+        add Advisor
+      end
+
+      card "Demo",
+           relationship: "demo",
+           relationship_klass: "some_klass",
+           identifier:   HasHelpers::Cards::CardIdentifier::DEMOGRAPHICS,
+           layout:       HasHelpers::Cards::CardLayoutType::SUMMARY do
+        description "Demo card"
+
+        field :age, data_type: HasHelpers::Cards::CardDataType::NUMERIC
+      end
+    end
+
+    definitions = test_class.definitions
+    expect(definitions).not_to be_nil
+    expect(definitions.size).to eq(1)
+
+    definition = definitions.first
+
+    # Card-level metadata
+    expect(definition[:application]).to be_nil
+    expect(definition[:name]).to eq("Demo")
+    expect(definition[:identifier]).to eq(HasHelpers::Cards::CardIdentifier::DEMOGRAPHICS)
+    expect(definition[:relationship]).to eq("demo")
+    expect(definition[:layout_type]).to eq(HasHelpers::Cards::CardLayoutType::SUMMARY.name)
+    expect(definition[:description]).to eq("Demo card")
+
+    expect(definition[:resources]).to eq(
+      [{ class_name: "Advisor", is_mandatory: false }]
+    )
+
+    age_field = definition[:fields].first
+    expect(age_field).to include(
+      kind:               :resource,
+      ref:                :age,
+      data_type:          HasHelpers::Cards::CardDataType::NUMERIC.name.underscore.to_sym,
+      default_visibility: true,
+      default_position:   10,
+      is_required:        false
+    )
+
+    # Base#define also registers all card hashes in HasHelpers::Cards::Registry
+    expect(HasHelpers::Cards::Registry.cards).to eq(definitions)
+  end
+
+  it "captures optional, non-persisted icon_name / icon_color hints at the card level" do
+    test_class = Class.new(described_class)
+
+    test_class.define do
+      resources do
+        add Advisor
+      end
+
+      card "Demo",
+           identifier: HasHelpers::Cards::CardIdentifier::DEMOGRAPHICS,
+           layout:     HasHelpers::Cards::CardLayoutType::SUMMARY,
+           icon_name:  "user-circle",
+           icon_color: "blue" do
+        field :age, data_type: HasHelpers::Cards::CardDataType::NUMERIC
+      end
+    end
+
+    definition = test_class.definitions.first
+    expect(definition[:icon_name]).to eq("user-circle")
+    expect(definition[:icon_color]).to eq("blue")
+  end
+
+  it "defaults icon_name / icon_color to nil when omitted" do
+    test_class = Class.new(described_class)
+
+    test_class.define do
+      resources do
+        add Advisor
+      end
+
+      card "Demo",
+           identifier: HasHelpers::Cards::CardIdentifier::DEMOGRAPHICS,
+           layout:     HasHelpers::Cards::CardLayoutType::SUMMARY do
+        field :age, data_type: HasHelpers::Cards::CardDataType::NUMERIC
+      end
+    end
+
+    definition = test_class.definitions.first
+    expect(definition[:icon_name]).to be_nil
+    expect(definition[:icon_color]).to be_nil
+  end
+
+  it "supports .application and inherits it from superclass" do
+    parent = Class.new(described_class)
+    parent.application "AgenciesHQ"
+
+    child = Class.new(parent)
+    child.define do
+      resources { add Advisor }
+      card "DemoApplication", identifier: HasHelpers::Cards::CardIdentifier::DEMOGRAPHICS, layout: HasHelpers::Cards::CardLayoutType::SUMMARY do
+        field :age, data_type: HasHelpers::Cards::CardDataType::NUMERIC
+      end
+    end
+
+    definition = child.definitions.first
+    expect(definition[:application]).to eq("AgenciesHQ")
+  end
+
+  it "round-trips hover_only from the card DSL" do
+    test_class = Class.new(described_class)
+
+    test_class.define do
+      resources { add Advisor }
+
+      card "Advisor Hover",
+           identifier: "AdvisorHover",
+           layout: HasHelpers::Cards::CardLayoutType::COMPACT,
+           hover_only: true do
+        field :name, data_type: HasHelpers::Cards::CardDataType::STRING
+      end
+    end
+
+    definition = test_class.definitions.first
+
+    expect(definition[:hover_only]).to eq(true)
+  end
+
+  it "raises ArgumentError when .define is called without a block" do
+    test_class = Class.new(described_class)
+
+    expect {
+      test_class.define
+    }.to raise_error(ArgumentError, /Block required/)
+  end
+end

data/spec/models/cards/card_definition_resource_spec.rb

@@ -0,0 +1,103 @@
+require "rails_helper"
+
+describe ::HasHelpers::Cards::CardDefinitionResource, type: :model do
+  subject { described_class.new }
+
+  before(:each) do
+    HasHelpers::Cards::CardDefinitionResource.delete_all
+    HasHelpers::Cards::CardDefinition.delete_all
+  end
+
+  it { is_expected.to belong_to(:card_definition).class_name("::HasHelpers::Cards::CardDefinition").inverse_of(:card_definition_resources) }
+  it { is_expected.to belong_to(:resource).class_name("::HasHelpers::Resource").inverse_of(:card_definition_resources) }
+  it { is_expected.to validate_presence_of(:card_definition_id) }
+  it { is_expected.to validate_presence_of(:resource_id) }
+
+  # Helpers
+  def ensure_identifier(name)
+    HasHelpers::Cards::CardIdentifier.where(name: name).first ||
+      HasHelpers::Cards::CardIdentifier.create!(
+        id:   "CARD_IDENT_#{name}",
+        name: name
+      )
+  end
+
+  def ensure_layout
+    HasHelpers::Cards::CardLayoutType.first ||
+      HasHelpers::Cards::CardLayoutType.create!(
+        id:   "CARD_LAYOUT_TEST",
+        name: "TestLayout"
+      )
+  end
+
+  ###### Validations ######
+  it "validates uniqueness of card_definition scoped to resource" do
+    resource = FactoryBot.create(:resource)
+
+    identifier = ensure_identifier("AdvisorBasicInfo")
+    layout     = ensure_layout
+
+    card_definition = HasHelpers::Cards::CardDefinition.find_by(identifier: identifier) ||
+                      FactoryBot.create(:cards_card_definition, identifier: identifier, layout_type: layout)
+
+    existing = HasHelpers::Cards::CardDefinitionResource.create!(
+      id:               SecureRandom.uuid,
+      card_definition:  card_definition,
+      resource:         resource,
+      is_mandatory:     nil,
+      default_position: 1
+    )
+
+    dup = HasHelpers::Cards::CardDefinitionResource.new(
+      card_definition:  existing.card_definition,
+      resource:         existing.resource,
+      is_mandatory:     false,
+      default_position: 2
+    )
+
+    dup.validate
+
+    expect(dup.errors[:card_definition_id] + dup.errors[:card_definition]).to be_present
+  end
+
+  ###### Scopes ######
+  describe ".ordered" do
+    it "orders by default_position asc nulls last then created_at asc" do
+      resource = FactoryBot.create(:resource)
+      layout   = ensure_layout
+
+      ident1 = ensure_identifier("AdvisorBasicInfo")
+      ident2 = ensure_identifier("Demographics")
+
+      cd1 = HasHelpers::Cards::CardDefinition.find_by(identifier: ident1) ||
+            FactoryBot.create(:cards_card_definition, identifier: ident1, layout_type: layout)
+
+      cd2 = HasHelpers::Cards::CardDefinition.find_by(identifier: ident2) ||
+            FactoryBot.create(:cards_card_definition, identifier: ident2, layout_type: layout)
+
+      cdr1 = HasHelpers::Cards::CardDefinitionResource.create!(
+        id:               SecureRandom.uuid,
+        card_definition:  cd1,
+        resource:         resource,
+        is_mandatory:     nil,
+        default_position: 2,
+        created_at:       2.days.ago,
+        updated_at:       2.days.ago
+      )
+
+      cdr2 = HasHelpers::Cards::CardDefinitionResource.create!(
+        id:               SecureRandom.uuid,
+        card_definition:  cd2,
+        resource:         resource,
+        is_mandatory:     nil,
+        default_position: 1,
+        created_at:       1.day.ago,
+        updated_at:       1.day.ago
+      )
+
+      scope = HasHelpers::Cards::CardDefinitionResource.where(id: [cdr1.id, cdr2.id]).ordered
+
+      expect(scope).to eq([cdr2, cdr1])
+    end
+  end
+end

data/spec/models/cards/card_definition_spec.rb

@@ -0,0 +1,50 @@
+require "rails_helper"
+
+describe ::HasHelpers::Cards::CardDefinition, type: :model do
+  subject { FactoryBot.build(:cards_card_definition) }
+
+  ##### Associations ######
+  it { is_expected.to have_many(:card_definition_resources).class_name("::HasHelpers::Cards::CardDefinitionResource").inverse_of(:card_definition).dependent(:destroy) }
+  it { is_expected.to have_many(:resources).through(:card_definition_resources) }
+  it { is_expected.to have_many(:card_fields).class_name("::HasHelpers::Cards::CardField").inverse_of(:card_definition).dependent(:destroy) }
+  it { is_expected.to have_many(:role_resource_cards).class_name("::HasHelpers::Cards::RoleResourceCard").inverse_of(:card_definition).dependent(:destroy) }
+
+  ###### Validations ######
+  it { is_expected.to validate_presence_of(:name) }
+  it { is_expected.to validate_presence_of(:identifier_id) }
+  it { is_expected.to validate_inclusion_of(:identifier_id).in_array(::HasHelpers::Cards::CardIdentifier.all.map(&:id)) }
+  it { is_expected.to validate_presence_of(:layout_type_id) }
+  it { is_expected.to validate_inclusion_of(:layout_type_id).in_array(::HasHelpers::Cards::CardLayoutType.all.map(&:id)) }
+
+  before(:each) do
+    ::HasHelpers::Cards::CardDefinition.destroy_all
+    FactoryBot.create(:cards_card_definition, identifier: ::HasHelpers::Cards::CardIdentifier.all[0])
+    FactoryBot.create(:cards_card_definition, identifier: ::HasHelpers::Cards::CardIdentifier.all[1])
+  end
+
+  ###### Scopes ######
+  describe ".ordered" do
+    it "orders by position asc nulls last then created_at asc" do
+      # Use only the available constants
+      idents = ::HasHelpers::Cards::CardIdentifier.all.to_a
+      expect(idents.size).to be >= 2 # only 2 constants defined currently
+
+      layout = ::HasHelpers::Cards::CardLayoutType.first
+
+      # helper for getting a definition for a constant identifier
+      get_or_make_cd = ->(ident) {
+        ::HasHelpers::Cards::CardDefinition.find_by(identifier: ident)
+      }
+
+      cd1 = get_or_make_cd.call(idents[0])
+      cd2 = get_or_make_cd.call(idents[1])
+
+      # Setting positions and dates WITHOUT going through validations/TS
+      cd1.update_columns(position: 1, created_at: 1.day.ago) # with position
+      cd2.update_columns(position: nil, created_at: 2.days.ago) # without position
+
+      result = ::HasHelpers::Cards::CardDefinition.ordered.where(id: [cd1.id, cd2.id]).to_a
+      expect(result).to eq([cd1, cd2])
+    end
+  end
+end

data/spec/models/cards/card_field_spec.rb

@@ -0,0 +1,46 @@
+require "rails_helper"
+
+describe ::HasHelpers::Cards::CardField, type: :model do
+  subject { FactoryBot.build(:cards_card_field) }
+
+  before(:each) do
+    HasHelpers::Cards::CardField.delete_all
+  end
+
+  it { is_expected.to belong_to(:card_definition).class_name("::HasHelpers::Cards::CardDefinition").inverse_of(:card_fields) }
+
+  it { is_expected.to validate_presence_of(:card_definition_id) }
+  it { is_expected.to validate_presence_of(:data_type_id) }
+  it { is_expected.to validate_inclusion_of(:data_type_id).in_array(::HasHelpers::Cards::CardDataType.all.map(&:id)) }
+
+  ##### Validations ######
+  it "validates presence of data_type (when not passing String)" do
+    cf = FactoryBot.build(:cards_card_field, data_type: nil)
+    expect(cf).not_to be_valid
+    expect(cf.errors[:data_type]).to be_present
+  end
+
+  it "validates uniqueness of field_custom_name scoped to card_definition_id" do
+    cd = ::HasHelpers::Cards::CardDefinition.create(identifier: ::HasHelpers::Cards::CardIdentifier.first, name: Faker::Name.name, layout_type: ::HasHelpers::Cards::CardLayoutType.first )
+    dt = ::HasHelpers::Cards::CardDataType.first
+
+    cf = FactoryBot.create(:cards_card_field, card_definition_id: cd.id, field_custom_name: "UniqueName", data_type: dt)
+    dup = FactoryBot.build(:cards_card_field, card_definition_id: cf.card_definition_id, field_custom_name: cf.field_custom_name, data_type: dt)
+
+    dup.validate
+    expect(dup.errors[:field_custom_name].join(" ")).to match(/already been taken/i)
+  end
+
+  ##### Scopes ######
+  describe ".ordered_default" do
+    it "orders by default_position asc nulls last then created_at asc" do
+      cd = FactoryBot.create(:cards_card_definition)
+      cd_1 = FactoryBot.create(:cards_card_definition)
+      cd_2 = FactoryBot.create(:cards_card_definition)
+      a = FactoryBot.create(:cards_card_field, :with_field_resource, card_definition_id: cd.id, default_position: 2, created_at: 2.days.ago)
+      b = FactoryBot.create(:cards_card_field, :with_field_resource, card_definition_id: cd_1.id, default_position: 1, created_at: 1.day.ago)
+      c = FactoryBot.create(:cards_card_field, :with_field_resource, card_definition_id: cd_2.id, default_position: nil, created_at: 3.days.ago)
+      expect(HasHelpers::Cards::CardField.where(id: [a.id, b.id, c.id]).ordered_default).to eq([b, a, c])
+    end
+  end
+end