has_helpers 5.0.2

data/spec/models/cards/field_builder_spec.rb

@@ -0,0 +1,318 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+describe HasHelpers::Cards::CardBuilder::FieldBuilder do
+  let(:numeric_option) do
+    # Mimics an Option-like enum (e.g. HasHelpers::Cards::CardDataType::Numeric)
+    double("NumericOption", name: "Numeric")
+  end
+
+  describe "#initialize and normalization" do
+    it "normalizes an Option-like data_type to a lowercase symbol" do
+      field = described_class.new(
+        kind:               :resource,
+        ref:                :age,
+        key:                nil,
+        name:               nil,
+        data_type:          numeric_option,
+        mapper:             nil,
+        default_visibility: true,
+        default_position:   10,
+        is_required:        false
+      )
+
+      expect(field.data_type).to eq(:numeric)
+    end
+
+    it "keeps a symbol data_type as-is" do
+      field = described_class.new(
+        kind:               :resource,
+        ref:                :age,
+        key:                nil,
+        name:               nil,
+        data_type:          :string,
+        mapper:             nil,
+        default_visibility: true,
+        default_position:   10,
+        is_required:        false
+      )
+
+      expect(field.data_type).to eq(:string)
+    end
+
+    it "normalizes a string data_type to a lowercase symbol" do
+      field = described_class.new(
+        kind:               :resource,
+        ref:                :age,
+        key:                nil,
+        name:               nil,
+        data_type:          "Boolean",
+        mapper:             nil,
+        default_visibility: true,
+        default_position:   10,
+        is_required:        false
+      )
+
+      expect(field.data_type).to eq(:boolean)
+    end
+
+    it "stringifies mapper and coerces booleans and key" do
+      field = described_class.new(
+        kind:               :custom,
+        ref:                nil,
+        key:                "full_name",
+        name:               "Full Name",
+        data_type:          :string,
+        mapper:             CardsFieldMapper = Class.new, # just something with #to_s
+        default_visibility: "1", # truthy
+        default_position:   20,
+        is_required:        nil  # falsy
+      )
+
+      expect(field.key).to eq(:full_name)
+      expect(field.mapper).to eq(CardsFieldMapper.to_s)
+      expect(field.default_visibility).to eq(true)
+      expect(field.is_required).to eq(false)
+    end
+  end
+
+  describe "#validate!" do
+    it "accepts a valid resource field" do
+      field = described_class.new(
+        kind:               :resource,
+        ref:                :age,
+        key:                nil,
+        name:               nil,
+        data_type:          :integer,
+        mapper:             nil,
+        default_visibility: true,
+        default_position:   10,
+        is_required:        false
+      )
+
+      expect { field.validate! }.not_to raise_error
+    end
+
+    it "accepts a valid custom field" do
+      field = described_class.new(
+        kind:               :custom,
+        ref:                nil,
+        key:                :full_name,
+        name:               "Full Name",
+        data_type:          :string,
+        mapper:             "SomeMapper",
+        default_visibility: true,
+        default_position:   20,
+        is_required:        false
+      )
+
+      expect { field.validate! }.not_to raise_error
+    end
+
+    it "raises when kind is invalid" do
+      field = described_class.new(
+        kind:               :other,
+        ref:                :age,
+        key:                nil,
+        name:               nil,
+        data_type:          :integer,
+        mapper:             nil,
+        default_visibility: true,
+        default_position:   10,
+        is_required:        false
+      )
+
+      expect {
+        field.validate!
+      }.to raise_error(
+        HasHelpers::Cards::CardBuilder::FieldBuilder::ValidationError,
+        /Invalid field kind/
+      )
+    end
+
+    it "raises when data_type is nil" do
+      field = described_class.new(
+        kind:               :resource,
+        ref:                :age,
+        key:                nil,
+        name:               nil,
+        data_type:          nil,
+        mapper:             nil,
+        default_visibility: true,
+        default_position:   10,
+        is_required:        false
+      )
+
+      expect {
+        field.validate!
+      }.to raise_error(
+        HasHelpers::Cards::CardBuilder::FieldBuilder::ValidationError,
+        /data_type is required/
+      )
+    end
+
+    it "raises when a resource field has no ref" do
+      field = described_class.new(
+        kind:               :resource,
+        ref:                nil,
+        key:                nil,
+        name:               nil,
+        data_type:          :integer,
+        mapper:             nil,
+        default_visibility: true,
+        default_position:   10,
+        is_required:        false
+      )
+
+      expect {
+        field.validate!
+      }.to raise_error(
+        HasHelpers::Cards::CardBuilder::FieldBuilder::ValidationError,
+        /resource field must have ref/
+      )
+    end
+
+    it "raises when a custom field has no key" do
+      field = described_class.new(
+        kind:               :custom,
+        ref:                nil,
+        key:                nil,
+        name:               "Full Name",
+        data_type:          :string,
+        mapper:             "SomeMapper",
+        default_visibility: true,
+        default_position:   20,
+        is_required:        false
+      )
+
+      expect {
+        field.validate!
+      }.to raise_error(
+        HasHelpers::Cards::CardBuilder::FieldBuilder::ValidationError,
+        /custom field must have key/
+      )
+    end
+  end
+
+  describe "#to_h / #as_json" do
+    it "returns the normalized hash for a resource field" do
+      field = described_class.new(
+        kind:               :resource,
+        ref:                :age,
+        key:                nil,
+        name:               nil,
+        data_type:          :integer,
+        mapper:             nil,
+        default_visibility: true,
+        default_position:   10,
+        is_required:        false
+      )
+
+      expect(field.to_h).to eq(
+        kind:                  :resource,
+        ref:                   :age,
+        name:                  nil,
+        data_type:             :integer,
+        default_visibility:    true,
+        default_position:      10,
+        is_required:           false,
+        badge_color:           nil,
+        hover_card:            nil,
+        hover_card_source:     nil,
+        hover_record_source:   nil,
+        hover_resource:        nil,
+        hover_resource_source: nil,
+        icon:                  nil,
+        source:                nil,
+        url:                   nil,
+        custom_label:          false,
+        custom_label_key:      nil
+      )
+
+      expect(field.as_json).to eq(field.to_h)
+    end
+
+    it "returns the normalized hash for a custom field" do
+      field = described_class.new(
+        kind:               :custom,
+        ref:                nil,
+        key:                "full_name",
+        name:               "Full Name",
+        data_type:          "String",
+        mapper:             "CardsFieldMapper::Demographics::FullName",
+        default_visibility: false,
+        default_position:   20,
+        is_required:        true
+      )
+
+      expect(field.to_h).to eq(
+        kind:                  :custom,
+        key:                   :full_name,
+        name:                  "Full Name",
+        mapper:                "CardsFieldMapper::Demographics::FullName",
+        data_type:             :string,
+        default_visibility:    false,
+        default_position:      20,
+        is_required:           true,
+        source:                nil,
+        badge_color:           nil,
+        hover_card:            nil,
+        hover_card_source:     nil,
+        hover_record_source:   nil,
+        hover_resource:        nil,
+        hover_resource_source: nil,
+        icon:                  nil,
+        url:                   nil,
+        custom_label:          false,
+        custom_label_key:      nil
+      )
+
+      expect(field.as_json).to eq(field.to_h)
+    end
+
+    it "round-trips hover_card, hover_record_source, and icon" do
+      field = described_class.new(
+        kind:                :virtual,
+        ref:                 :advisor_link,
+        key:                 nil,
+        name:                "Advisor",
+        data_type:           HasHelpers::Cards::CardDataType::HOVER_CARD,
+        mapper:              nil,
+        source:              { from: :advisor, key: :name },
+        hover_card:          :AdvisorHover,
+        hover_record_source: { from: :advisor, key: :id },
+        icon:                :user,
+        default_visibility:  true,
+        default_position:    30,
+        is_required:         false
+      )
+
+      expect(field.data_type).to eq(:hover_card)
+      expect(field.to_h).to include(
+        data_type:           :hover_card,
+        hover_card:          "AdvisorHover",
+        hover_record_source: { from: :advisor, key: :id },
+        icon:                "user"
+      )
+    end
+
+    it "normalizes hover_record_source mapper classes to source shape" do
+      mapper = Class.new
+      field = described_class.new(
+        kind:                :virtual,
+        ref:                 :advisor_link,
+        key:                 nil,
+        name:                "Advisor",
+        data_type:           :hover_card,
+        mapper:              nil,
+        hover_record_source: mapper,
+        default_visibility:  true,
+        default_position:    30,
+        is_required:         false
+      )
+
+      expect(field.hover_record_source).to eq(mapper: mapper.to_s)
+    end
+  end
+end

data/spec/models/cards/registry_spec.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+describe HasHelpers::Cards::Registry do
+  before do
+    described_class.reset!
+    described_class.register_card_files([])
+  end
+
+  describe ".register_card!" do
+    it "stores card hashes and prevents duplicate identifiers" do
+      first_def = {
+        name:               "Demographics",
+        identifier:         HasHelpers::Cards::CardIdentifier::DEMOGRAPHICS,
+        relationship:       "demographics",
+        relationship_klass: "HasContactInfo::Demographic",
+        layout_type:        HasHelpers::Cards::CardLayoutType::SUMMARY.name,
+        variant:            nil,
+        description:        "Basic details",
+        is_customizable:    true,
+        default_visibility: true,
+        default_position:   10,
+        resources:          [],
+        fields:             []
+      }
+
+      described_class.register_card!(first_def)
+
+      expect(described_class.cards.size).to eq(1)
+      expect(described_class.cards.first).to eq(first_def)
+
+      # same identifier, different name → should fail for duplicate
+      duplicate_def = first_def.merge(name: "Other name")
+
+      expect {
+        described_class.register_card!(duplicate_def)
+      }.to raise_error(HasHelpers::Cards::Registry::DuplicateIdentifierError)
+    end
+
+    it "deep-freezes stored structures" do
+      def_hash = {
+        name:               "Emails",
+        identifier:         HasHelpers::Cards::CardIdentifier::ADVISOR_BASIC_INFO,
+        relationship:       "emails",
+        relationship_klass: "HasContactInfo::Email",
+        layout_type:        HasHelpers::Cards::CardLayoutType::LIST.name,
+        variant:            HasHelpers::Cards::CardVariantType::EMAILS.name,
+        description:        "Email addresses card",
+        is_customizable:    true,
+        default_visibility: true,
+        default_position:   10,
+        resources:          [],
+        fields:             []
+      }
+
+      described_class.register_card!(def_hash)
+
+      stored = described_class.cards.first
+      expect(stored).to be_frozen
+      expect(stored[:resources]).to be_frozen
+      expect(stored[:fields]).to be_frozen
+    end
+  end
+
+  describe ".reset!" do
+    it "clears all registered cards" do
+      described_class.register_card!(
+        name:               "Demographics",
+        identifier:         HasHelpers::Cards::CardIdentifier::DEMOGRAPHICS,
+        relationship:       "demographics",
+        relationship_klass: "HasContactInfo::Demographic",
+        layout_type:        HasHelpers::Cards::CardLayoutType::SUMMARY.name,
+        variant:            nil,
+        description:        "Basic details",
+        is_customizable:    true,
+        default_visibility: true,
+        default_position:   10,
+        resources:          [],
+        fields:             []
+      )
+
+      expect(described_class.cards.size).to eq(1)
+
+      described_class.reset!
+
+      expect(described_class.cards).to eq([])
+    end
+  end
+
+  describe ".cards" do
+    it "builds registered definition blocks lazily and only once" do
+      stub_const("Advisor", Class.new)
+      builds = 0
+
+      test_class = Class.new(HasHelpers::Cards::CardBuilder::Base)
+      test_class.define do
+        builds += 1
+
+        resources { add Advisor }
+        card "Lazy",
+             relationship: "lazy",
+             relationship_klass: "some_klass",
+             identifier:   HasHelpers::Cards::CardIdentifier.all[0],
+             layout:       HasHelpers::Cards::CardLayoutType.all.sample
+      end
+
+      expect(builds).to eq(0)
+
+      identifiers = described_class.cards.map { |c| c[:identifier] }
+      expect(builds).to eq(1)
+      expect(identifiers).to include(HasHelpers::Cards::CardIdentifier.all[0])
+
+      described_class.cards
+      expect(builds).to eq(1)
+    end
+
+    it "includes cards defined after the first load" do
+      stub_const("Advisor", Class.new)
+
+      first_class = Class.new(HasHelpers::Cards::CardBuilder::Base)
+      first_class.define do
+        resources { add Advisor }
+        card "First",
+             relationship: "first",
+             relationship_klass: "some_klass",
+             identifier:   HasHelpers::Cards::CardIdentifier.all[0],
+             layout:       HasHelpers::Cards::CardLayoutType.all.sample
+      end
+
+      expect(described_class.cards.map { |c| c[:identifier] }).to include(HasHelpers::Cards::CardIdentifier.all[0])
+
+      second_class = Class.new(HasHelpers::Cards::CardBuilder::Base)
+      second_class.define do
+        resources { add Advisor }
+        card "Second",
+             relationship: "second",
+             relationship_klass: "some_klass",
+             identifier:   HasHelpers::Cards::CardIdentifier.all[1],
+             layout:       HasHelpers::Cards::CardLayoutType.all.sample
+      end
+
+      identifiers = described_class.cards.map { |c| c[:identifier] }
+      expect(identifiers).to include(HasHelpers::Cards::CardIdentifier.all[0], HasHelpers::Cards::CardIdentifier.all[1])
+    end
+  end
+end

data/spec/models/cards/role_card_field_spec.rb

@@ -0,0 +1,111 @@
+require "rails_helper"
+
+describe ::HasHelpers::Cards::RoleCardField, type: :model do
+  let(:organization) { FactoryBot.create(:has_helper_organization) }
+  subject { FactoryBot.build(:cards_role_card_field) }
+
+  before(:each) do
+    HasHelpers::Cards::RoleCardField.delete_all
+    HasHelpers::Cards::RoleResourceCard.delete_all
+    HasHelpers::Cards::CardField.delete_all
+  end
+
+  ###### Associations ######
+  it { is_expected.to belong_to(:role_resource_card).class_name("::HasHelpers::Cards::RoleResourceCard").inverse_of(:role_card_fields) }
+  it { is_expected.to belong_to(:card_field).class_name("::HasHelpers::Cards::CardField").inverse_of(:role_card_fields) }
+  it { is_expected.to belong_to(:organization) }
+  it { is_expected.to belong_to(:created_by).class_name("::HasHelpers::User") }
+  it { is_expected.to belong_to(:updated_by).class_name("::HasHelpers::User") }
+
+  let(:data_type) do
+    ::HasHelpers::Cards::CardDataType.first
+  end
+
+  def create_card_field(card_definition)
+    ::HasHelpers::Cards::CardField.create!(
+      card_definition_id:    card_definition.id,
+      field_resource:     FactoryBot.create(:resource),
+      field_custom_name:  nil,
+      data_type:          data_type,
+      default_position:   1,
+      default_visibility: true
+    )
+  end
+
+  ###### Uniqueness ######
+  it "enforces uniqueness of card_field within a role_resource_card" do
+    role = FactoryBot.create(:role, organization: organization)
+    resource = FactoryBot.create(:resource)
+
+    cd = FactoryBot.create(:cards_card_definition)
+    role_resource_card = FactoryBot.create(:cards_role_resource_card, organization: organization, card_definition_id: cd.id, role_id: role.id, resource_id: resource.id)
+    card_field = create_card_field(cd)
+
+    existing = FactoryBot.create(:cards_role_card_field, role_resource_card_id: role_resource_card.id, card_field_id: card_field.id)
+
+    dup = FactoryBot.build(
+      :cards_role_card_field,
+      role_resource_card: existing.role_resource_card,
+      card_field:         existing.card_field,
+      organization:       existing.organization,
+      created_by:         existing.created_by,
+      updated_by:         existing.updated_by
+    )
+
+    dup.validate
+    expect(dup.errors[:card_field_id] + dup.errors[:card_field]).to be_present
+  end
+
+  ###### Scopes ######
+  describe ".ordered" do
+    it "orders by position asc nulls last then created_at asc" do
+      role = FactoryBot.create(:role, organization: organization)
+      resource = FactoryBot.create(:resource)
+
+      cd = FactoryBot.create(:cards_card_definition)
+      cd_1 = FactoryBot.create(:cards_card_definition)
+      cd_2 = FactoryBot.create(:cards_card_definition)
+
+      role_resource_card = FactoryBot.create(:cards_role_resource_card, organization: organization, card_definition_id: cd.id, role_id: role.id, resource_id: resource.id)
+      role_resource_card_1 = FactoryBot.create(:cards_role_resource_card, organization: organization, card_definition_id: cd_1.id, role_id: role.id, resource_id: resource.id)
+      role_resource_card_2 = FactoryBot.create(:cards_role_resource_card, organization: organization, card_definition_id: cd_2.id, role_id: role.id, resource_id: resource.id)
+
+      card_field = FactoryBot.create(:cards_card_field, :with_field_resource, card_definition_id: role_resource_card.card_definition_id)
+      card_field_1 = FactoryBot.create(:cards_card_field, :with_field_resource, card_definition_id: role_resource_card_1.card_definition_id)
+      card_field_2 = FactoryBot.create(:cards_card_field, :with_field_resource, card_definition_id: role_resource_card_2.card_definition_id)
+   
+      a = FactoryBot.create(:cards_role_card_field, role_resource_card_id: role_resource_card.id, card_field_id: card_field.id, position: 2, created_at: 2.days.ago)
+      b = FactoryBot.create(:cards_role_card_field, role_resource_card_id: role_resource_card_1.id, card_field_id: card_field_1.id, position: 1, created_at: 1.day.ago)
+      c = FactoryBot.create(:cards_role_card_field, role_resource_card_id: role_resource_card_2.id, card_field_id: card_field_2.id, position: nil, created_at: 3.days.ago)
+
+      expect(
+        ::HasHelpers::Cards::RoleCardField.where(id: [a.id, b.id, c.id]).ordered
+      ).to eq([b, a, c])
+    end
+  end
+
+  describe ".visible" do
+    it "returns only visible fields" do
+      role = FactoryBot.create(:role, organization: organization)
+      resource = FactoryBot.create(:resource)
+
+      cd = FactoryBot.create(:cards_card_definition)
+      role_resource_card = FactoryBot.create(:cards_role_resource_card, organization: organization, card_definition_id: cd.id, role_id: role.id, resource_id: resource.id)
+      card_field = FactoryBot.create(:cards_card_field, :with_field_resource, card_definition_id: cd.id)
+
+      role_1 = FactoryBot.create(:role, organization: organization)
+      resource_1 = FactoryBot.create(:resource)
+
+      cd_1 = FactoryBot.create(:cards_card_definition)
+      role_resource_card_1 = FactoryBot.create(:cards_role_resource_card, organization: organization, card_definition_id: cd_1.id, role_id: role_1.id, resource_id: resource_1.id)
+      card_field_1 = FactoryBot.create(:cards_card_field, :with_field_resource, card_definition_id: cd_1.id)
+
+      visible = FactoryBot.create(:cards_role_card_field, organization: organization, role_resource_card_id: role_resource_card.id, card_field_id: card_field.id, is_visible: true)
+      hidden  = FactoryBot.create(:cards_role_card_field, :hidden, organization: organization, role_resource_card_id: role_resource_card_1.id, card_field_id: card_field_1.id)
+
+      expect(
+        ::HasHelpers::Cards::RoleCardField.where(id: [visible.id, hidden.id]).visible
+      ).to match_array([visible])
+    end
+  end
+end

data/spec/models/cards/role_resource_card_spec.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+describe ::HasHelpers::Cards::RoleResourceCard, type: :model do
+  let(:organization) { FactoryBot.create(:has_helper_organization) }
+  let(:role) { FactoryBot.create(:role, organization: organization) }
+  subject { FactoryBot.build(:cards_role_resource_card, organization: organization) }
+
+  before(:each) do
+    HasHelpers::Cards::RoleCardField.delete_all
+    HasHelpers::Cards::RoleResourceCard.delete_all
+    HasHelpers::Cards::CardField.delete_all
+    HasHelpers::Cards.reset!
+  end
+
+  after { HasHelpers::Cards.reset! }
+
+  it { is_expected.to belong_to(:role).class_name("::HasHelpers::Role").inverse_of(:role_resource_cards).optional }
+  it { is_expected.to have_db_column(:role_id) }
+  it { is_expected.to have_db_column(:disabled_at) }
+  it { is_expected.to belong_to(:resource).class_name("::HasHelpers::Resource") }
+  it { is_expected.to belong_to(:card_definition).class_name("::HasHelpers::Cards::CardDefinition").inverse_of(:role_resource_cards) }
+  it { is_expected.to belong_to(:organization).class_name("::HasHelpers::Organization") }
+  it { is_expected.to belong_to(:created_by).class_name("::HasHelpers::User") }
+  it { is_expected.to belong_to(:updated_by).class_name("::HasHelpers::User") }
+  it { is_expected.to have_many(:role_card_fields).class_name("::HasHelpers::Cards::RoleCardField").inverse_of(:role_resource_card).dependent(:destroy) }
+
+  it { is_expected.to validate_presence_of(:organization_id) }
+  it { is_expected.to validate_presence_of(:role_id) }
+  it { is_expected.to validate_presence_of(:resource_id) }
+  it { is_expected.to validate_presence_of(:card_definition_id) }
+
+  ###### Uniqueness ######
+  it "enforces uniqueness of card_definition within org+role+resource scope" do
+    resource = FactoryBot.create(:resource)
+
+    cd = FactoryBot.create(:cards_card_definition)
+    existing = FactoryBot.create(:cards_role_resource_card, organization: organization, card_definition_id: cd.id, role_id: role.id, resource_id: resource.id)
+
+    dup = FactoryBot.build(
+      :cards_role_resource_card,
+      organization:    existing.organization,
+      role_id:            existing.role_id,
+      resource_id:        existing.resource_id,
+      card_definition_id: existing.card_definition_id,
+      created_by:      existing.created_by,
+      updated_by:      existing.updated_by
+    )
+
+    dup.validate
+    expect(dup.errors[:card_definition_id] + dup.errors[:card_definition]).to be_present
+  end
+
+  ###### Scopes ######
+  describe ".active" do
+    it "excludes disabled rows" do
+      res = FactoryBot.create(:resource)
+      cd  = FactoryBot.create(:cards_card_definition)
+      active = FactoryBot.create(:cards_role_resource_card, organization: organization, role_id: role.id, resource_id: res.id, card_definition_id: cd.id)
+      disabled = FactoryBot.create(:cards_role_resource_card, organization: organization, role_id: FactoryBot.create(:role, organization: organization).id, resource_id: res.id, card_definition_id: cd.id, disabled_at: Time.current)
+
+      expect(described_class.active).to include(active)
+      expect(described_class.active).not_to include(disabled)
+    end
+  end
+
+  describe ".ordered" do
+    it "orders by position asc nulls last then created_at asc" do
+      res = FactoryBot.create(:resource)
+      cd  = FactoryBot.create(:cards_card_definition)
+
+      role1 = FactoryBot.create(:role, organization: organization)
+      role2 = FactoryBot.create(:role, organization: organization)
+      role3 = FactoryBot.create(:role, organization: organization)
+
+      rrc1 = FactoryBot.create(:cards_role_resource_card, organization: organization, role_id: role1.id, resource_id: res.id, card_definition_id: cd.id, position: 2, created_at: 2.days.ago)
+      rrc2 = FactoryBot.create(:cards_role_resource_card, organization: organization, role_id: role2.id, resource_id: res.id, card_definition_id: cd.id, position: 1, created_at: 1.day.ago)
+      rrc3 = FactoryBot.create(:cards_role_resource_card, organization: organization, role_id: role3.id, resource_id: res.id, card_definition_id: cd.id, position: nil, created_at: 3.days.ago)
+
+      expect(
+        ::HasHelpers::Cards::RoleResourceCard.where(id: [rrc2.id, rrc1.id, rrc3.id]).ordered
+      ).to eq([rrc2, rrc1, rrc3])
+    end
+  end
+
+  describe "#role" do
+    it "returns the AR role through the facade in server mode" do
+      HasHelpers::Cards.configure do |config|
+        config.mode = :server
+        config.issuer = "admin"
+      end
+      card = FactoryBot.build(:cards_role_resource_card, role_id: role.id)
+
+      expect(card.role).to eq(role)
+    end
+
+    it "returns a remote role through the facade in client mode" do
+      remote_role = HasHelpers::Cards::RemoteRole.new(id: role.id, name: "Remote", organization_id: organization.id)
+      allow(HasHelpers::Cards::Roles).to receive(:find).with(role.id).and_return(remote_role)
+      card = FactoryBot.build(:cards_role_resource_card, role_id: role.id)
+
+      expect(card.role).to eq(remote_role)
+    end
+
+    it "returns nil with nil role_id" do
+      card = FactoryBot.build(:cards_role_resource_card, role_id: nil)
+
+      expect(card.role).to be_nil
+    end
+  end
+end