has_helpers 5.0.2

data/spec/lib/has_helpers/active_record/lookup_model_spec.rb

@@ -0,0 +1,408 @@
+require "rails_helper"
+
+describe "has helper lookup models" do
+  describe "organization lookup" do
+    let(:organization) { FactoryBot.create(:organization) }
+
+    let(:organization_id) { { "id" => organization.id } }
+    let(:organization_name) { { "name" => organization.name } }
+    let(:organization_params) { { "id" => organization.id, "name" => organization.name } }
+
+    it "search by id" do
+      result = ::Organization.lookup(organization_id, nil)
+      expect(result).not_to be_nil
+      expect(result.id).to eq(organization.id)
+      expect(result.name).to eq(organization.name)
+    end
+
+    it "search by name" do
+      result = ::Organization.lookup(organization_name, nil)
+      expect(result).not_to be_nil
+      expect(result.id).to eq(organization.id)
+      expect(result.name).to eq(organization.name)
+    end
+
+    it "search by params with AND condition" do
+      result = ::Organization.lookup(organization_params, nil)
+      expect(result).not_to be_nil
+      expect(result.id).to eq(organization.id)
+      expect(result.name).to eq(organization.name)
+    end
+  end
+
+  describe "user lookup" do
+    let(:user) { FactoryBot.create(:user) }
+
+    let(:user_id) { { "id" => user.id } }
+    let(:user_name) { { "name" => user.name } }
+    let(:user_id_incorrect) { { "id" => "f24e0a10-3616-48af-9f0f-3afa1916f539", "name" => user.name } }
+    let(:scope_active) { [{where: {user_status_id: Status::ACTIVE}}] }
+    let(:scope_by_organization) { [{joins: :user_organizations, where: {"user_organizations.organization_id" => user.organizations.first.id}}] }
+    let(:scopes) { [{joins: :user_organizations, where: {user_status_id: Status::ACTIVE, "user_organizations.organization_id" => user.organizations.first.id }}] }
+    let!(:user1) { FactoryBot.create(:user) }
+    let!(:user2) { FactoryBot.create(:user, username: user1.username) }
+
+    it "multiple users found and show error false" do
+      result = ::User.lookup({username: user1.username}, nil)
+      expect(result).to be_nil
+    end
+
+    it "multiple users found and show error true" do
+      result = ::User.lookup({username: user1.username}, nil, show_error: true)
+      expect(result).to eq "Multiple found."
+    end
+
+    it "not found user and show error true" do
+      result = ::User.lookup({username: user1.username+"@@@!!"}, nil, show_error: true)
+      expect(result).to eq "Not found."
+    end
+
+    it "search by id" do
+      result = ::User.lookup(user_id, nil)
+      expect(result).not_to be_nil
+      expect(result.id).to eq(user.id)
+      expect(result.name).to eq(user.name)
+    end
+    it "search by id without specifying the id in a hash" do
+      result = ::User.lookup(user.id, nil)
+      expect(result).not_to be_nil
+      expect(result.id).to eq(user.id)
+      expect(result.name).to eq(user.name)
+    end
+
+    it "search by name with case sensitive false" do
+      result = ::User.lookup(user.name, nil, case_sensitive: false)
+      expect(result).not_to be_nil
+      expect(result.id).to eq(user.id)
+      expect(result.name).to eq(user.name)
+    end
+
+    it "search by id with case sensitive false" do
+      result = ::User.lookup(user.id, nil, case_sensitive: false)
+      expect(result).not_to be_nil
+      expect(result.id).to eq(user.id)
+      expect(result.name).to eq(user.name)
+    end
+
+    it "search by name" do
+      result = ::User.lookup(user_name, nil)
+      expect(result).not_to be_nil
+      expect(result.id).to eq(user.id)
+      expect(result.name).to eq(user.name)
+    end
+
+    it "search by params with OR condition" do
+      result = ::User.lookup(user_id_incorrect, nil, condition: LogicalOperator::OR)
+      expect(result).not_to be_nil
+      expect(result.id).to eq(user.id)
+      expect(result.name).to eq(user.name)
+    end
+
+    it "search by params with OR condition and case sensitive false" do
+      result = ::User.lookup(user.name, nil, condition: LogicalOperator::OR, case_sensitive: false)
+      expect(result).not_to be_nil
+      expect(result.id).to eq(user.id)
+      expect(result.name).to eq(user.name)
+    end
+
+    it "search by params with OR condition and id nil" do
+      result = ::User.lookup({id: nil, name: user.name }, nil,condition: LogicalOperator::OR)
+      expect(result).not_to be_nil
+      expect(result.id).to eq(user.id)
+      expect(result.name).to eq(user.name)
+    end
+
+    it "search by params with case sensitive" do
+      result = ::User.lookup({name: user.name }, nil, case_sensitive: false)
+      expect(result).not_to be_nil
+      expect(result.id).to eq(user.id)
+      expect(result.name).to eq(user.name)
+    end
+
+    it "search by id in scope active" do
+      user.update(user_status_id: Status::ACTIVE)
+      result = ::User.lookup(user_id, nil, scope: scope_active)
+      expect(result).not_to be_nil
+      expect(result.id).to eq(user.id)
+      expect(result.name).to eq(user.name)
+    end
+
+    it "search by id in scope by_organization" do
+      result = ::User.lookup(user_id, nil, scope: scope_by_organization)
+      expect(result).not_to be_nil
+      expect(result.id).to eq(user.id)
+      expect(result.name).to eq(user.name)
+    end
+
+    it "search by id with two scopes" do
+      user.update(user_status_id: Status::ACTIVE)
+      result = ::User.lookup(user_id, nil, scope: scopes)
+      expect(result).not_to be_nil
+      expect(result.id).to eq(user.id)
+      expect(result.name).to eq(user.name)
+    end
+
+    it "search by organization id/name with OR condition" do
+      result = ::User.lookup(user_id, nil, scope: scope_by_organization)
+      expect(result).not_to be_nil
+      expect(result.id).to eq(user.id)
+      expect(result.name).to eq(user.name)
+    end
+  end
+
+  describe "lookup supported columns" do
+    it "when a prefix is set and multi nil" do
+      result = User.supported_columns_lookup("user_one")
+      expect(result).to include(
+        "user_one_id",
+        "user_one_name"
+        )
+    end
+
+    it "when prefix and multi are nil" do
+      result = User.supported_columns_lookup()
+      expect(result).to include(
+        "id",
+        "name"
+        )
+    end
+
+    it "when prefix and multi are set" do
+      result = User.supported_columns_lookup("user", 3)
+      expect(result).to include(
+        "user_one_id",
+        "user_two_id",
+        "user_three_id",
+        "user_one_name",
+        "user_two_name",
+        "user_three_name"
+        )
+        expect(result).not_to include(
+        "user_four_id",
+        "user_four_name"
+        )
+    end
+  end
+
+  describe "name with apostrophe" do
+    let(:user) { FactoryBot.create(:user, :name_with_apostrophe ) }
+    it "search by name with OR condition" do
+      result = ::User.lookup({name: user.name}, nil, condition: LogicalOperator::OR)
+      expect(result).not_to be_nil
+      expect(result.id).to eq(user.id)
+      expect(result.name).to eq(user.name)
+    end
+    it "search by name with OR condition and case sensitive false" do
+      result = ::User.lookup({"organizations.id": user.organizations.first.id, name: user.name}, nil, condition: LogicalOperator::OR, case_sensitive: false)
+      expect(result).not_to be_nil
+      expect(result.id).to eq(user.id)
+      expect(result.name).to eq(user.name)
+    end
+  end
+
+  describe "when name nil and id is set" do
+    let(:user) { FactoryBot.create(:user, :name_with_apostrophe ) }
+    it "search by name with OR condition" do
+      result = ::User.lookup({ id: user.id, name:nil }, nil, condition: LogicalOperator::OR)
+      expect(result).not_to be_nil
+      expect(result.id).to eq(user.id)
+      expect(result.name).to eq(user.name)
+    end
+  end
+
+  describe "hydrate model" do
+    describe "create a valid advisor" do
+      let(:current_user) { FactoryBot.create(:user) }
+      let(:user_one) { FactoryBot.create(:user, :with_org, organization: current_user.organizations.first) }
+      let(:user_two) { FactoryBot.create(:user, :with_org, organization: current_user.organizations.first) }
+      let(:data) {
+        {
+          "advisor_user_one_id" => user_one.id,
+          "advisor_user_two_id" => user_two.id,
+          "advisor_name" => ::Faker::Name.name,
+          "advisor_import_key" => ::Faker::Alphanumeric.alphanumeric(number: 20),
+          "advisor_npn" => ::Faker::Number.number(digits: 9)
+        }
+      }
+      let(:result) { ::Advisor.assign_data(data, prefix: "advisor", current_user: current_user, multi: 2) }
+      it "create the advisor" do
+        expect(result[:associations_with_errors]).to be_empty
+        expect(result[:model]).not_to be_nil
+        expect(result[:model].users).not_to be_empty
+        expect(result[:model].users.first.id).to eq user_one.id
+        expect(result[:model].name).to eq data["advisor_name"]
+        expect(result[:model].import_key).to eq data["advisor_import_key"]
+        expect(result[:model].npn).to eq data["advisor_npn"]
+      end
+    end
+
+    describe "create a valid firm" do
+      let(:current_user) { FactoryBot.create(:user) }
+      let(:data) {
+        {
+          "firm_import_key" => ::Faker::Alphanumeric.alphanumeric(number: 20),
+          "firm_start_date" => Date.today - 7,
+          "firm_end_date" => Date.today + 7
+        }
+      }
+      let(:result) { ::Firm.assign_data(data, prefix: "firm", current_user: current_user) }
+      it "create the advisor" do
+        expect(result[:associations_with_errors]).to be_empty
+        expect(result[:model]).not_to be_nil
+        expect(result[:model].import_key).to eq data["firm_import_key"]
+        expect(result[:model].start_date).to eq data["firm_start_date"]
+      end
+    end
+
+    describe "try to create an advisor with an invalid user" do
+      let(:current_user) { FactoryBot.create(:user) }
+      let(:data) {
+        {
+          "advisor_user_one_id" => "@@!!###",
+          "advisor_user_two_id" => "##$$",
+          "advisor_name" => ::Faker::Name.name,
+          "advisor_import_key" => ::Faker::Alphanumeric.alphanumeric(number: 20),
+          "advisor_npn" => ::Faker::Number.number(digits: 9)
+        }
+      }
+      let(:result) { ::Advisor.assign_data(data, prefix: "advisor", current_user: current_user, multi: 2) }
+      it "return an error" do
+        expect(result[:associations_with_errors]).not_to be_empty
+        expect(result[:associations_with_errors][::User]).to eq "user"
+      end
+    end
+  end
+
+  describe "available columns" do
+    it "columns for Firm" do
+      result = Firm.klass_available_columns
+      expect(result).to include("type")
+      expect(result).not_to include("organization")
+      expect(result).not_to include("created_at")
+    end
+
+    it "columns for Advisor" do
+      result = Advisor.klass_available_columns
+      expect(result).not_to include("import_key")
+      expect(result).to include("npn")
+      expect(result).to include("demographic")
+      expect(result).to include("name")
+      expect(result).not_to include("organization")
+      expect(result).not_to include("created_at")
+    end
+
+    it "columns for Policy" do
+      result = Policy.klass_available_columns
+      expect(result).to include("policy_type")
+      expect(result).to include("name")
+      expect(result).not_to include("organization")
+      expect(result).not_to include("import_key")
+      expect(result).not_to include("created_at")
+    end
+  end
+
+  describe "multiple found" do
+    context "return_multiple is true" do
+      let!(:user1) { FactoryBot.create(:user) }
+      let!(:user2) { FactoryBot.create(:user, username: user1.username) }
+      let!(:user3) { FactoryBot.create(:user, username: user1.username) }
+      let!(:user4) { FactoryBot.create(:user, username: user1.username) }
+      it "return multiple" do
+        result = ::User.lookup({ username: user1.username }, nil, return_multiple: true)
+        expect(result).not_to be nil
+        expect(result.size).to be > 1
+      end
+
+      it "return nil" do
+        result = ::User.lookup({ id: user1.username }, nil, return_multiple: true)
+        expect(result).to be_empty
+      end
+    end
+
+    context "return_multiple is true and search by lookup_attributes_precedence" do
+      let!(:user1) { FactoryBot.create(:user) }
+      let!(:user2) { FactoryBot.create(:user, username: user1.username) }
+      let!(:user3) { FactoryBot.create(:user, username: user1.username) }
+      let!(:user4) { FactoryBot.create(:user, username: user1.username) }
+      it "return multiple" do
+        result = ::User.lookup(user1.username, nil, return_multiple: true)
+        expect(result).not_to be nil
+        expect(result.size).to be > 1
+      end
+    end
+
+    context "return_multiple is false" do
+      let!(:user1) { FactoryBot.create(:user) }
+      let!(:user2) { FactoryBot.create(:user, username: user1.username) }
+      let!(:user3) { FactoryBot.create(:user, username: user1.username) }
+      it "return nil" do
+        result = ::User.lookup({username: user1.username}, nil, return_multiple: false)
+        expect(result).to be nil
+      end
+    end
+  end
+
+  describe "advisor lookup" do
+    let(:advisor) { FactoryBot.create(:advisor, :with_demographic_ssn) }
+    let(:contract) { FactoryBot.create(:contract, advisor: advisor, organization_id: advisor.organization_id) }
+
+    it "search by id and return nil" do
+      result = ::Advisor.lookup({ "id": advisor.import_key }, advisor.organization_id)
+      expect(result).to be_nil
+    end
+
+    it "search by id, with return multiple true return nil" do
+      result = ::Advisor.lookup({ "id": advisor.import_key }, advisor.organization_id, return_multiple: true)
+      expect(result).to be_empty
+    end
+
+    it "search by ssn" do
+      result = ::Advisor.lookup({ "demographics.ssn": advisor.demographic.ssn }, advisor.organization_id)
+      expect(result).not_to be_nil
+      expect(result.id).to eq(advisor.id)
+      expect(result.demographic.ssn).to eq(advisor.demographic.ssn)
+    end
+
+    it "search by import key" do
+      result = ::Advisor.lookup({ import_key: advisor.import_key }, advisor.organization_id)
+      expect(result).not_to be_nil
+      expect(result.id).to eq(advisor.id)
+      expect(result.import_key).to eq(advisor.import_key)
+    end
+
+    it "find the advisor by demographic name case insensitive" do
+      result = ::Advisor.lookup({ "demographics.name": advisor.demographic.name.downcase }, advisor.organization_id, case_sensitive: false)
+      expect(result).not_to be_nil
+      expect(result.id).to eq(advisor.id)
+      expect(result.import_key).to eq(advisor.import_key)
+    end
+
+    it "find the advisor trought the contract_id" do
+      result = ::Advisor.lookup(contract.id, advisor.organization_id)
+      expect(result).not_to be_nil
+      expect(result.id).to eq(advisor.id)
+      expect(result.import_key).to eq(advisor.import_key)
+    end
+
+    it "find the advisor trought the contract_id in hash" do
+      result = ::Advisor.lookup({"contracts.id": contract.id}, advisor.organization_id)
+      expect(result).not_to be_nil
+      expect(result.id).to eq(advisor.id)
+      expect(result.import_key).to eq(advisor.import_key)
+    end
+  end
+
+  describe "lookup case_sensitive: false" do
+    let(:firm) { FactoryBot.create(:firm, :with_valid_dates, name: "I Sat By The Ocean") }
+    
+    it "find the record also when a no text/string is inside search params" do
+      result = ::Firm.lookup({ "name": firm.name.upcase, "start_date": firm.start_date.to_s }, firm.organization_id, case_sensitive: false)
+      expect(result).not_to be_nil
+      expect(result.id).to eq(firm.id)
+
+      result = ::Firm.lookup({ "name": firm.name.downcase, "start_date": firm.start_date.to_s }, firm.organization_id, case_sensitive: false)
+      expect(result).not_to be_nil
+      expect(result.id).to eq(firm.id)
+    end
+  end
+end

data/spec/lib/has_helpers/active_record/nested_resource_spec.rb

@@ -0,0 +1,43 @@
+require "rails_helper"
+
+describe ::HasHelpers::ActiveRecord::NestedResource do
+  let(:user) { FactoryBot.create(:user) }
+  subject { FactoryBot.create(:schedule, user: user) }
+
+  describe "#to_service" do
+    it "returns an edit service with a nested URL" do
+      service = subject.to_service
+
+      aggregate_failures do
+        expect(service).to be_a(::Service)
+        expect(service.url).to eq("/users/#{ user.id }/schedules/#{ subject.id }/edit")
+      end
+    end
+
+    context "with namespaced nested resource" do
+      let(:audit) { FactoryBot.create(:audit) }
+      it { expect(audit.to_service.url).to eq("/organizations/#{ audit.organization_id }/audits/#{ audit.id }/edit") }
+    end
+
+    context "options" do
+      describe ":use_base_class" do
+        subject { FactoryBot.create(:event_template) }
+        it { expect(subject.to_service.url).to eq("/organizations/#{ subject.organization_id }/event_templates/#{ subject.id }/edit") }  # use_base_class defaulted to false
+        it { expect(subject.to_service(use_base_class: true).url).to eq("/organizations/#{ subject.organization_id }/templates/#{ subject.id }/edit") }
+      end
+    end
+  end
+
+  describe "#name" do
+    it "returns the titleized class name if name is not otherwise defined" do
+      anonymous_coward = FactoryBot.create(:anonymous_coward)
+      expect(anonymous_coward.name).to eq("Anonymous Coward")
+    end
+
+    it "returns the result of the name method when present" do
+      name = "My Template"
+      template = FactoryBot.create(:event_template, name: name)
+      expect(template.name).to eq(name)
+    end
+  end
+end