has_helpers 5.0.2

data/spec/lib/has_helpers/lazy_config_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+require 'rails_helper'
+
+describe ::HasHelpers::LazyConfig do
+  let(:file_path) { File.dirname(__FILE__) + "/../../fixtures/sample_config.yml" }
+  it "reads from an environment-scoped yaml file" do
+    conf = ::HasHelpers::LazyConfig.new(file_path)
+
+    expect(conf.foo).to eq("bar")
+    expect(conf.age).to eq(32)
+    expect(conf.bar).to be_nil
+  end
+
+  it "reads from a block" do
+    local_value = rand(1..100)
+    conf = ::HasHelpers::LazyConfig.new do
+      {
+        value: local_value,
+        double_value: 2 * local_value
+      }
+    end
+
+    expect(conf.value).to eq(local_value)
+    expect(conf.double_value).to eq(2 * local_value)
+    expect(conf.bar).to be_nil
+  end
+
+  it "raises an error if you give it a yaml file AND a block" do
+    expect { ::HasHelpers::LazyConfig.new(file_path) { { foo: "bar" } } }.to raise_error(RuntimeError, ::HasHelpers::LazyConfig::INVALID_INIT_PARAMS_ERR_MSG)
+  end
+end

data/spec/lib/has_helpers/organization_merge_spec.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+describe ::HasHelpers::OrganizationMerge do
+  let(:into_org) { ::FactoryBot.create(:organization) }
+  let(:from_org) { ::FactoryBot.create(:organization) }
+  let(:org_merge_instance) { described_class.new(from: from_org, into: into_org) }
+
+  it "should call the pre-merge function" do
+    expect(org_merge_instance).to receive(:pre_merge_function)
+    org_merge_instance.merge_orgs
+    expect(org_merge_instance.success?).to be true
+  end
+
+  it "should call the start_of_merge_transaction_function" do
+    expect(org_merge_instance).to receive(:start_of_merge_transaction_function)
+    org_merge_instance.merge_orgs
+    expect(org_merge_instance.success?).to be true
+  end
+
+  it "should call the post merge function" do
+    expect(org_merge_instance).to receive(:post_merge_function)
+    org_merge_instance.merge_orgs(into: into_org, from: from_org)
+    expect(org_merge_instance.success?).to be true
+  end
+
+  describe "Importing tables into an organization from another organization" do
+    context "When the included_tables are specified" do
+      let!(:attachment) { ::FactoryBot.create(:attachment, organization: from_org) }
+      let!(:advisor) { ::FactoryBot.create(:advisor, organization: from_org, import_key: "import_key") }
+      let(:included_tables) { ["advisors"] }
+
+      it "should only merge the included_tables" do
+        allow(org_merge_instance).to receive(:included_tables).and_return(included_tables)
+        org_merge_instance.merge_orgs
+        expect(org_merge_instance.success?).to be true
+
+        advisor.reload
+        expect(advisor.organization_id).to eq(into_org.id)
+
+        attachment.reload
+        expect(attachment.organization_id).to eq(from_org.id)
+      end
+    end
+
+    context "When there are tables with read only columns" do
+      let!(:read_only_value) { ::FactoryBot.create(:read_only_value, organization: from_org) }
+
+      it "should disable read-only triggers during the merge" do
+        read_only_value.update!(organization: into_org)
+        read_only_value.reload
+        expect(read_only_value.organization_id).to eq(from_org.id)
+
+        org_merge_instance.merge_orgs
+        expect(org_merge_instance.success?).to be true
+
+        read_only_value.reload
+        expect(read_only_value.organization_id).to eq(into_org.id)
+      end
+    end
+
+    context "When the table has an organization_id" do
+      let!(:attachment) { ::FactoryBot.create(:attachment, :with_advisor, organization: from_org) }
+
+      it "should set the organization_id to the into_organization for records in the from_organization" do
+        org_merge_instance.merge_orgs
+        expect(org_merge_instance.success?).to be true
+
+        attachment.reload
+        expect(attachment.organization).to eq(into_org)
+      end
+    end
+
+    context "When the table has an import key" do
+      let!(:advisor) { ::FactoryBot.create(:advisor, organization: from_org, import_key: "import_key") }
+
+      it "should set the import key to NULL when moving records to the into_organization from the from_organization" do
+        org_merge_instance.merge_orgs
+        expect(org_merge_instance.success?).to be true
+
+        advisor.reload
+        expect(advisor.organization).to eq(into_org)
+        expect(advisor.import_key).to be_nil
+      end
+    end
+  end
+end

data/spec/lib/has_helpers/resource_importer_spec.rb

@@ -0,0 +1,119 @@
+require "rails_helper"
+
+describe ::HasHelpers::ResourceImporter do
+  before do
+    App.eager_load!
+    HasHelpers::Application.seed!
+    HasHelpers::ResourceType.seed!
+    TimeZone.seed!
+    HasHelpers::Resource.reset_column_information # somehow the column information is not reset after the db migrations
+    HasHelpers::Resource.delete_all
+  end
+  describe ".import_resources" do
+    let(:current_application) { ::HasHelpers::Application::APP_ONE }
+
+    def import_resources!(audit: true)
+      described_class.import_resources(current_application, audit: audit)
+    end
+
+    before(:each) do
+      HasHelpers::Resource.delete_all
+      import_resources!
+    end
+
+    context "raises an audit error" do
+      it "when a class is renamed" do
+        ::HasHelpers::Resource.where(resource_type: ::HasHelpers::ResourceType::BASE).first.update(name: "NewName")
+        expect(import_resources!).to include(::HasHelpers::ResourceImporter::AUDIT_MISSING_RESOURCES % { application_name: current_application.name, resources: ["NewName"] })
+      end
+
+      it "when a nested resource is missing" do
+        current_application.resources.find_by(name: "User").nested_resources.create(::HasHelpers::Resource.find_by(name: "Meetup").attributes.except("id", "created_at"))
+        expect(import_resources!).to include(::HasHelpers::ResourceImporter::AUDIT_MISSING_NESTED_RESOURCES % { application_name: current_application.name, resource_name: "User", nested_resources: ["Meetup"] })
+      end
+    end
+
+    context "does not raise an audit error on audit false" do
+      it "when a class is renamed" do
+        ::HasHelpers::Resource.where(resource_type: ::HasHelpers::ResourceType::BASE).first.update(name: "NewName")
+        expect(import_resources!(audit: false)).not_to include(::HasHelpers::ResourceImporter::AUDIT_MISSING_RESOURCES % { application_name: current_application.name, resources: ["NewName"] })
+      end
+
+      it "when a nested resource is missing" do
+        current_application.resources.find_by(name: "User").nested_resources.create(::HasHelpers::Resource.find_by(name: "Meetup").attributes.except("id", "created_at"))
+        expect(import_resources!(audit: false)).not_to include(::HasHelpers::ResourceImporter::AUDIT_MISSING_NESTED_RESOURCES % { application_name: current_application.name, resource_name: "User", nested_resources: ["Meetup"] })
+      end
+    end
+
+    it "creates BASE resources" do
+      base_resources = current_application.resources.where(resource_type: ::HasHelpers::ResourceType::BASE).pluck(:name)
+      expect(base_resources).to contain_exactly("User", "Organization", "Event")
+    end
+
+    it "aliases the User resource" do
+      advisor_resource = current_application.resources.find_by(name: "User")
+      expect(advisor_resource.alias_name).to eql("UserAlias")
+    end
+
+    it "creates nested resources for User" do
+      user_resource = current_application.resources.find_by(name: "User", parent_id: nil)
+      user_nested_resources = user_resource.nested_resources.not_fields.pluck(:name)
+      expect(user_nested_resources).to contain_exactly("Schedule", "LinkedUser", "Photo")
+    end
+
+    it "creates TYPE resources" do
+      sti_resources = current_application.resources.where(resource_type: ::HasHelpers::ResourceType::TYPE).pluck(:name)
+      expect(sti_resources).to contain_exactly("AnotherEvent")
+    end
+
+    it "creates NESTED resources" do
+      nested_resource = current_application.resources.find_by(name: "Template")
+      expect(nested_resource.resource_type).to eql(::HasHelpers::ResourceType::NESTED)
+    end
+
+    it "creates FIELD resources" do
+      nested_resource = current_application.resources.find_by(name: "appointment_id")
+      expect(nested_resource.resource_type).to eql(::HasHelpers::ResourceType::FIELD)
+    end
+
+    it "creates REQUIRED_FIELD resources" do
+      nested_resource = current_application.resources.find_by(name: "HasHelpers::UserRole").resources.find_by(name: "user_id")
+      expect(nested_resource.resource_type).to eql(::HasHelpers::ResourceType::REQUIRED_FIELD)
+    end
+
+    it "creates SPLIT resources" do
+      split_resources = current_application.resources.where(resource_type: ::HasHelpers::ResourceType::SPLIT).pluck(:name)
+      expect(split_resources).to include("LinkedUser", "Photo")
+    end
+
+    it "creates SUB resources" do
+      base_resources = current_application.resources.where(resource_type: ::HasHelpers::ResourceType::SUB).pluck(:name)
+      expect(base_resources).to contain_exactly("Appointment")
+    end
+
+    it "creates a Client resource for Policy under PolicyHolder and Beneficiary" do
+      policy_resource = current_application.resources.find_by(name: "Policy")
+      policy_nested_resources = policy_resource.nested_resources.not_fields.select { |r| r.name == "Beneficiary" || r.name == "PolicyHolder" }
+      policy_nested_resources.each do |nested_resource|
+        client_resource = current_application.resources.find_by(name: "Client", parent_id: nested_resource.id)
+        expect(client_resource).to be_present
+      end
+    end
+
+
+  end
+
+  describe ".import_resource_nested_resources for single resource" do
+    let(:current_application) { ::HasHelpers::Application::APP_ONE }
+    let!(:resource) { current_application.resources.find_or_create_by(name: "User", resource_type: ::HasHelpers::ResourceType::BASE, application: current_application ) }
+
+
+    it "creates nested resources for User" do
+      importer = described_class.new(current_application)
+      importer.import_resource_nested_resources(resource)
+      user_nested_resources = resource.nested_resources.not_fields.pluck(:name)
+      expect(user_nested_resources).to contain_exactly("Schedule", "LinkedUser", "Photo")
+    end
+
+  end
+end

data/spec/lib/has_helpers/rspec_spec.rb

@@ -0,0 +1,16 @@
+require "rails_helper"
+require "has_helpers/rspec"
+
+RSpec.describe "constant matchers" do
+  before :each do
+    ::MyConstant.seed!
+  end
+
+  subject { ::MyConstant }
+
+  it { is_expected.to define_constant("This") }
+  it { is_expected.to define_constant("That") }
+  it { is_expected.to define_constant("Other Thing").with_key(:MISC) }
+  it { is_expected.to_not define_constant("Other Thing") }  # Missing the key
+  it { is_expected.to have_total_constants(3) }
+end

data/spec/lib/has_helpers/search/provider_spec.rb

@@ -0,0 +1,26 @@
+require "rails_helper"
+
+
+describe ::HasHelpers::Search::Provider do
+  describe ".owner_relation_from_scope" do
+    it "returns relation names and scope when a corresponding owner view exists for the specified class" do
+      resource_relation_name,
+      owner_relation_name,
+      resource_relation = described_class.owner_relation_from_scope(::User)
+
+      expect(resource_relation_name).to eq("users")
+      expect(owner_relation_name).to eq("owner_users_view")
+      expect(resource_relation).to_not be_nil
+    end
+
+    it "returns nil for the relation when no corresponding owner view exists" do
+      resource_relation_name,
+      owner_relation_name,
+      resource_relation = described_class.owner_relation_from_scope(::Demographic)
+
+      expect(resource_relation_name).to eq("demographics")
+      expect(owner_relation_name).to eq("owner_demographics_view")
+      expect(resource_relation).to be_nil
+    end
+  end
+end

data/spec/lib/has_helpers/search/search_utils_spec.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe HasHelpers::Search::SearchUtils do
+  let(:user) { double(User, organization_id: 42) } 
+  let(:application) do
+    instance_double("Application", resources: [
+      instance_double("Resource",
+        name: "User",
+        resource_type: HasHelpers::ResourceType::BASE,
+        klass: double(search_index: true)
+      ),
+      instance_double("Resource",
+        name: "Organization",
+        resource_type: HasHelpers::ResourceType::ACTION,
+        klass: double(search_index: true)
+      ),
+      instance_double("Resource",
+        name: "Demographic",
+        resource_type: HasHelpers::ResourceType::BASE,
+        klass: double(search_index: true)
+      )
+    ])
+  end
+
+  describe ".resources" do
+    context "when no resources are given" do
+      it "returns global resource names" do
+        result = described_class.resources(user, application, [])
+        expect(result).to contain_exactly("User", "Demographic")
+      end
+    end
+
+    context "when resources are given" do
+      it "returns the resource list as-is (stripped)" do
+        input = ["User", "Demographic"]
+        result = described_class.resources(user, application, input)
+        expect(result).to eq(["User", "Demographic"])
+      end
+    end
+  end
+
+  describe ".global_resources" do
+    it "returns only base resources with a search_index" do
+      result = described_class.global_resources(user, application)
+      expect(result.map(&:name)).to contain_exactly("User", "Demographic")
+    end
+  end
+
+  describe ".provider" do
+    context "when sql_search feature is active" do
+      it "returns Sql provider" do
+        allow(HasHelpers::Feature).to receive(:active?).with(:sql_search).and_return(true)
+        expect(described_class.provider).to eq(HasHelpers::Query::Sql)
+      end
+    end
+
+    context "when sql_search feature is not active" do
+      it "returns Elasticsearch provider" do
+        allow(HasHelpers::Feature).to receive(:active?).with(:sql_search).and_return(false)
+        expect(described_class.provider).to eq(HasHelpers::Query::Elasticsearch)
+      end
+    end
+  end
+
+  describe ".base_query_options" do
+    let(:options) { { with: { organization_id: 42, some_other_key: "value" } } }
+
+    it "merges default and passed options, preserving organization_id" do
+      result = described_class.base_query_options(options, user)
+      expect(result[:with][:organization_id]).to eq(42)
+      expect(result[:with][:some_other_key]).to eq("value")
+      expect(result[:page]).to eq(1)
+      expect(result[:per_page]).to eq(15)
+    end
+
+    it "removes organization_id if it does not match the user" do
+      options[:with][:organization_id] = 999
+      result = described_class.base_query_options(options, user)
+      expect(result[:with][:organization_id]).to eq(42)
+    end
+
+    it "sets organization_id if not provided" do
+      result = described_class.base_query_options({ with: {} }, user)
+      expect(result[:with][:organization_id]).to eq(42)
+    end
+
+    # The GraphQL `with` argument is a JSON scalar, so its keys arrive as
+    # strings. The organization_id sanitization must see them regardless.
+    context "when `with` has string keys (GraphQL JSON scalar)" do
+      it "preserves organization_id 0 (global / non-org records)" do
+        result = described_class.base_query_options({ with: { "organization_id" => 0 } }, user)
+        expect(result[:with][:organization_id]).to eq(0)
+      end
+
+      it "preserves the user's own organization_id" do
+        result = described_class.base_query_options({ with: { "organization_id" => 42 } }, user)
+        expect(result[:with][:organization_id]).to eq(42)
+      end
+
+      it "replaces a foreign organization_id with the user's" do
+        result = described_class.base_query_options({ with: { "organization_id" => 999 } }, user)
+        expect(result[:with][:organization_id]).to eq(42)
+      end
+
+      it "symbolizes other keys" do
+        result = described_class.base_query_options({ with: { "some_other_key" => "value" } }, user)
+        expect(result[:with][:some_other_key]).to eq("value")
+        expect(result[:with][:organization_id]).to eq(42)
+      end
+    end
+  end
+
+  describe ".valid_resource?" do
+    it "returns true for a valid resource name" do
+      expect(described_class.valid_resource?("User", application)).to be true
+    end
+
+    it "returns false for an invalid resource name" do
+      expect(described_class.valid_resource?("InvalidResource", application)).to be false
+    end
+  end
+
+  describe ".validate_resource!" do
+    it "returns nil for valid resource" do
+      expect(described_class.validate_resource!("User", application)).to be_nil
+    end
+
+    it "returns a 400 status hash for an invalid resource" do
+      expect(described_class.validate_resource!("::InvalidResource", application)).to eq({ status: 400 })
+    end
+  end
+end

data/spec/lib/has_helpers/sentry/graphql_trace_spec.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+require "has_helpers/sentry/graphql_trace"
+
+RSpec.describe HasHelpers::Sentry::GraphqlTrace do
+  subject(:host) { klass.new }
+
+  let(:klass) do
+    Class.new do
+      include HasHelpers::Sentry::GraphqlTrace
+    end
+  end
+
+  let(:controller_name) { "GraphqlController" }
+  let(:operation_name) { "MyOperation" }
+  let(:query) { "query MyOperation { viewer { id } }" }
+  let(:user) { FactoryBot.build(:user) }
+
+  describe "#set_graphql_trace!" do
+    context "when operation_name is blank" do
+      it "does nothing (does not touch Sentry)" do
+        sentry = Module.new
+        sentry.define_singleton_method(:configure_scope) { |&blk| }
+        sentry.define_singleton_method(:set_tags) { |_tags| }
+
+        stub_const("Sentry", sentry)
+
+        expect(Sentry).not_to receive(:configure_scope)
+        expect(Sentry).not_to receive(:set_tags)
+
+        host.set_graphql_trace!(
+          controller_name: controller_name,
+          operation_name: "   ",
+          query: query,
+          user_id: user&.id
+        )
+      end
+    end
+
+    context "when Sentry is not defined" do
+      it "does not raise" do
+        hide_const("Sentry") if defined?(Sentry)
+
+        expect do
+          host.set_graphql_trace!(
+            controller_name: controller_name,
+            operation_name: operation_name,
+            query: query,
+            user_id: user&.id
+          )
+        end.not_to raise_error
+      end
+    end
+
+    context "when Sentry is defined" do
+      let(:fake_scope) { instance_double("SentryScope") }
+
+      before do
+        scope = fake_scope
+
+        sentry = Module.new
+        sentry.define_singleton_method(:configure_scope) do |&blk|
+          blk.call(scope)
+        end
+        sentry.define_singleton_method(:set_tags) { |_tags| }
+
+        stub_const("Sentry", sentry)
+      end
+
+      it "sets the transaction name as <controller>/<operation>" do
+        expect(fake_scope).to receive(:set_transaction_name)
+                                .with("GraphqlController/MyOperation")
+
+        expect(Sentry).to receive(:set_tags).with(
+          graphql_operation_name: "MyOperation",
+          graphql_operation_type: "query"
+        )
+
+        host.set_graphql_trace!(
+          controller_name: controller_name,
+          operation_name: operation_name,
+          query: query,
+          user_id: user&.id
+        )
+      end
+
+      it "detects mutation operation type" do
+        expect(fake_scope).to receive(:set_transaction_name)
+                                .with("GraphqlController/MyOperation")
+
+        expect(Sentry).to receive(:set_tags).with(
+          graphql_operation_name: "MyOperation",
+          graphql_operation_type: "mutation"
+        )
+
+        host.set_graphql_trace!(
+          controller_name: controller_name,
+          operation_name: operation_name,
+          query: "mutation MyOperation { doThing(input: {}) { ok } }",
+          user_id: user&.id
+        )
+      end
+
+      it "detects subscription operation type" do
+        expect(fake_scope).to receive(:set_transaction_name)
+                                .with("GraphqlController/MyOperation")
+
+        expect(Sentry).to receive(:set_tags).with(
+          graphql_operation_name: "MyOperation",
+          graphql_operation_type: "subscription"
+        )
+
+        host.set_graphql_trace!(
+          controller_name: controller_name,
+          operation_name: operation_name,
+          query: "subscription MyOperation { onThing { id } }",
+          user_id: user&.id
+        )
+      end
+
+      it "returns nil operation type when query doesn't include one" do
+        expect(fake_scope).to receive(:set_transaction_name)
+                                .with("GraphqlController/MyOperation")
+
+        expect(Sentry).to receive(:set_tags).with(
+          graphql_operation_name: "MyOperation",
+          graphql_operation_type: nil
+        )
+
+        host.set_graphql_trace!(
+          controller_name: controller_name,
+          operation_name: operation_name,
+          query: "MyOperation { viewer { id } }",
+          user_id: user&.id
+        )
+      end
+    end
+  end
+end

data/spec/lib/has_helpers/ui_attributes_spec.rb

@@ -0,0 +1,42 @@
+require "rails_helper"
+
+describe ::HasHelpers::UIAttributes do
+  let(:klass) do
+    Class.new do
+      include ::HasHelpers::UIAttributes
+    end
+  end
+  subject { klass.new }
+
+  context "#html_attrs" do
+    it "returns an empty HTMLAttributes::HTMLAttrs subject by default" do
+      expect(subject.html_attrs).to eq({})
+    end
+
+    it "includes skin as the 'class' HTML attribute" do
+      subject.skin = "derp"
+      expect(subject.html_attrs).to eq({ class: "derp" })
+    end
+
+    it "merges skin and 'class' HTML attribute" do
+      subject.skin = "derp"
+      subject.html_attrs = { class: "herp" }
+      expect(subject.html_attrs).to eq({ class: "herp derp" })
+    end
+
+    it "allows injection of attributes" do
+      subject.html_attrs.merge!(disabled: true)
+      aggregate_failures do
+        expect(subject.html_attrs[:disabled]).to eq(true)
+        expect(subject.html_attrs).to be_an_instance_of(::HasHelpers::UIAttributes::HTMLAttributes::HTMLAttrs)
+      end
+    end
+
+    it "injects data attrs" do
+      subject.data = { toggle: "dropdown", trigger: "click" }
+      expect(subject.html_attrs).to eq({ "data_toggle" => "dropdown", "data_trigger" => "click" })
+    end
+
+    it { expect(subject.html_attrs.to_partial_path).to eq("has_helpers/ui_attributes/html_attrs") }
+  end
+end

data/spec/lib/has_helpers/utils/action_spec.rb

@@ -0,0 +1,49 @@
+require "rails_helper"
+
+RSpec.describe Action do
+  describe "#icon" do
+    it "returns nil when neither icon nor actions are set" do
+      action = described_class.new
+      expect(action.icon).to be_nil
+    end
+
+    it "returns icon" do
+      action = described_class.new(icon: :fork)
+      aggregate_failures do
+        expect(action.icon).to be_an(::HasHelpers::Icon)
+        expect(action.icon.name).to eq("fork")
+      end
+    end
+
+    it "returns default icon when actions are set" do
+      action = described_class.new(actions: [Action.new])
+      aggregate_failures do
+        expect(action.icon).to be_an(::HasHelpers::Icon)
+        expect(action.icon.name).to eq(Action::DEFAULT_ICON.to_s)
+      end
+    end
+  end
+
+  describe "#to_action" do
+    it "returns itself" do
+      action = described_class.new
+      expect(action.equal?(action.to_action)).to be_truthy
+    end
+  end
+
+  describe "#cast_actions" do
+    it do
+      actions = ["http://example.com".to_service, "http://localhost".to_service]
+      action = described_class.new(actions: actions)
+      aggregate_failures do
+        expect(action.cast_actions.all? { |act| act.is_a?(described_class) }).to be_truthy
+        expect(action.cast_actions.all?(&:nested)).to be_truthy
+        expect(action.cast_actions.map(&:service).all?(&:nested)).to be_truthy
+      end
+    end
+  end
+
+  describe "#to_partial_path" do
+    it { expect(described_class.new.to_partial_path).to eq("has_helpers/actions/action") }
+  end
+end

data/spec/lib/has_helpers/utils/alert_spec.rb

@@ -0,0 +1,33 @@
+require "rails_helper"
+
+describe ::HasHelpers::Alert do
+  describe "details" do
+    let(:detail) { "Hello" }
+    let(:detail2) { "Goodbye" }
+    it { expect(described_class.new.details).to eq([]) }
+    it { expect(described_class.new(:details => detail).details).to eq([detail]) }
+    it { expect(described_class.new(:details => [detail]).details).to eq([detail]) }
+    it { expect(described_class.new(:details => [detail, detail2]).details).to eq([detail, detail2]) }
+  end
+
+  describe ".new" do
+    it "assigns single detail" do
+      detail = "Hey"
+      expect(described_class.new(detail).details).to contain_exactly(detail)
+    end
+  end
+
+  describe "#type" do
+    it "is info by default" do
+      expect(described_class.new.type).to eq(described_class::INFO)
+    end
+
+    it "can be a non-default type" do
+      expect(described_class.new(:type => described_class::DANGER).type).to eq(described_class::DANGER)
+    end
+  end
+
+  describe "#to_partial_path" do
+    it { expect(described_class.new.to_partial_path).to eq("has_helpers/alerts/alert") }
+  end
+end