has_helpers 5.0.2

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

@@ -0,0 +1,10 @@
+require "rails_helper"
+
+RSpec.describe ::HasHelpers::Dataset do
+  subject { described_class.new }
+
+  describe "#to_renderable" do
+    it { expect(subject.to_renderable).to be_a(::HasHelpers::Container) }
+    it { expect(subject.to_renderable.skin).to include("dataset") }
+  end
+end

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

@@ -0,0 +1,23 @@
+require "rails_helper"
+
+RSpec.describe ::HasHelpers::Icon do
+  describe "#to_s" do
+    it { expect(described_class.new(:phone, orientation: :flip_horizontal, attributes: [:green]).to_s.split(" ")).to contain_exactly(*%w[fa fa-phone fa-flip-horizontal green]) }
+  end
+
+  describe "#to_icon" do
+    it "returns itself" do
+      icon = described_class.new(:jedi)
+      expect(icon.equal?(icon.to_icon)).to be_truthy
+    end
+
+    it "assigns given options" do
+      icon = described_class.new(:user).to_icon(orientation: :rotate_90)
+      expect(icon.orientation).to eq(:rotate_90)
+    end
+  end
+
+  describe "#to_partial_path" do
+    it { expect(::HasHelpers::Icon.new(:yoda).to_partial_path).to eq("has_helpers/icons/icon") }
+  end
+end

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

@@ -0,0 +1,40 @@
+require "rails_helper"
+
+RSpec.describe Input do
+  describe "#label" do
+    it { expect(described_class.new(label: "Look here!").label).to eq("Look here!") }
+    it { expect(described_class.new(name: "Look at me!").label).to eq("Look At Me!") }
+  end
+
+  describe "#value" do
+    it { expect(described_class.new(value: "save").value).to eq("save") }
+    it { expect(described_class.new(name: "save_&_continue").value).to eq("save_&_continue") }
+  end
+
+  describe "#type" do
+    it { expect(described_class.new.type).to eq(described_class::DEFAULT_TYPE) }
+    it { expect(described_class.new(type: :button).type).to eq(:button) }
+  end
+
+  describe "#to_input" do
+    it do
+      input = described_class.new
+      expect(input.equal?(input.to_input)).to be_truthy
+    end
+  end
+
+  describe "#to_action" do
+    it do
+      input = described_class.new
+      action = input.to_action
+      aggregate_failures do
+        expect(action).to be_an(Action)
+        expect(action.input).to eq(input)
+      end
+    end
+  end
+
+  describe "#to_partial_path" do
+    it { expect(described_class.new.to_partial_path).to eq("has_helpers/inputs/input") }
+  end
+end

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

@@ -0,0 +1,25 @@
+require "rails_helper"
+
+RSpec.describe ::HasHelpers::LogNotifier do
+  describe "when ActiveRecordError" do
+    let!(:message) { "Couldn't find Advisor with id='test'" }
+    let!(:exception) { ActiveRecord::RecordNotFound.new(message) }
+
+    context "when notify console" do
+      it "returns combined exception message and backtrace if Exception" do
+        converted_msg = [exception.to_s, *exception.backtrace].join("\n")
+        expect do
+          ::HasHelpers::LogNotifier.notify(exception)
+        end.to output("#{converted_msg}\n").to_stdout
+      end
+
+      it "returns argument converted to String if not exception" do
+        converted_msg = message.to_s
+        expect do
+          ::HasHelpers::LogNotifier.notify("Couldn't find Advisor with id='test'")
+        end.to output("#{converted_msg}\n").to_stdout
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,17 @@
+require "rails_helper"
+
+RSpec.describe RenderObject do
+  describe "#to_action" do
+    it do
+      render_object = described_class.new
+      aggregate_failures do
+        expect(render_object.to_action).to be_an(Action)
+        expect(render_object.to_action.render_object).to eq(render_object)
+      end
+    end
+  end
+
+  describe "#to_partial_path" do
+    it { expect(described_class.new.to_partial_path).to eq("/has_helpers/render_objects/render_object") }
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+describe HasHelpers::S3Utils do
+  let(:dummy_class) { Class.new { include HasHelpers::S3Utils } }
+  let(:dummy) { dummy_class.new }
+
+  let(:s3_client)   { instance_double(Aws::S3::Client, "s3 client") }
+  let(:s3_resource) { instance_double(Aws::S3::Resource, "s3 resource") }
+  let(:s3_bucket)   { instance_double(Aws::S3::Bucket, "s3 bucket") }
+
+  before do
+    allow(HasHelpers::Aws).to receive(:new_s3_client).and_return(s3_client)
+    allow(HasHelpers::Aws).to receive(:s3_conf).and_return(OpenStruct.new(bucket: "test-bucket", region: "us-east-1"))
+
+    allow(Aws::S3::Resource).to receive(:new).with(client: s3_client).and_return(s3_resource)
+    allow(s3_resource).to receive(:bucket).with("test-bucket").and_return(s3_bucket)
+  end
+
+  describe "#get_s3_bucket" do
+    context "when the bucket exists" do
+      it "returns the bucket" do
+        allow(s3_bucket).to receive(:exists?).and_return(true)
+        expect(dummy.get_s3_bucket("test-bucket")).to eq(s3_bucket)
+      end
+    end
+
+    context "when the bucket does not exist" do
+      it "raises a runtime error" do
+        allow(s3_bucket).to receive(:exists?).and_return(false)
+
+        expect { dummy.get_s3_bucket("test-bucket") }.to raise_error(RuntimeError, /Cannot access S3 bucket/)
+      end
+    end
+  end
+
+  describe "#get_s3_file" do
+    let(:s3_object) { instance_double(Aws::S3::Object, key: "folder/file.txt") }
+    let(:tempfile) do
+      instance_double(
+        Tempfile,
+        write: nil,
+        rewind: nil,
+        read: "mock-content",
+        close: nil,
+        unlink: nil
+      )
+    end
+
+    before do
+      allow(s3_bucket).to receive(:exists?).and_return(true)
+      allow(s3_bucket).to receive(:object).with("folder/file.txt").and_return(s3_object)
+      allow(Tempfile).to receive(:new).with("file.txt").and_return(tempfile)
+    end
+
+    it "downloads and returns a tempfile with the file content" do
+      expect(s3_object).to receive(:get).and_yield("mock-content")
+      expect(tempfile).to receive(:write).with("mock-content")
+      expect(tempfile).to receive(:rewind)
+
+      file = dummy.get_s3_file("test-bucket", "folder/file.txt")
+
+      expect(file).to eq(tempfile)
+      expect(file.read).to eq("mock-content")
+    end
+
+    it "returns nil and logs when an error occurs" do
+      allow(s3_object).to receive(:get).and_raise(StandardError.new("S3 failure"))
+      allow(Rails.logger).to receive(:error)
+
+      result = dummy.get_s3_file("test-bucket", "folder/file.txt")
+
+      expect(result).to be_nil
+      expect(Rails.logger).to have_received(:error).with(/Fetching file.*encountered an issue with message: S3 failure/)
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+require "rails_helper"
+
+describe ::Service do
+  context ".new" do
+    context "given URL" do
+      subject { ::Service.new("http://example.com") }
+
+      it "returns URL as string" do
+        expect(subject.to_s).to eq("http://example.com")
+      end
+
+      it "returns URL as url" do
+        expect(subject.url).to eq("http://example.com")
+      end
+    end
+
+    context "given label and URL" do
+      subject { ::Service.new("Derp", :url => "http://example.com") }
+
+      it "returns label as string" do
+        expect(subject.to_s).to eq("Derp")
+      end
+
+      it "returns URL as url" do
+        expect(subject.url).to eq("http://example.com")
+      end
+    end
+  end
+
+  describe "#icon" do
+    it { expect(described_class.new("http://localhost").icon).to be_nil }
+    it do
+      icon = described_class.new("http://localhost", icon: "phone").icon
+      expect(icon).to be_an(::HasHelpers::Icon)
+      expect(icon.name).to eq("phone")
+    end
+  end
+
+  describe "#to_partial_path" do
+    it { expect(described_class.new("http://localhost").to_partial_path).to eq("has_helpers/services/service") }
+  end
+
+  describe "#to_renderable" do
+    subject { ::Service.new("http://example.com") }
+    it { expect(subject.equal?(subject.to_renderable)).to be(true) }
+  end
+
+  describe "#==" do
+    subject { described_class.new(::Faker::Company.catch_phrase, url: ::Faker::Internet.url) }
+
+    it "should return true when name and url are equal" do
+      other = described_class.new(subject.to_s, url: subject.url)
+      expect(subject).to eq(other)
+    end
+
+    it "should return false when names differ" do
+      other = described_class.new(subject.to_s.succ, url: subject.url)
+      expect(subject).to_not eq(other)
+    end
+
+    it "should return false when urls differ" do
+      other = described_class.new(subject.to_s, url: subject.url.succ)
+      expect(subject).to_not eq(other)
+    end
+
+    context "compared to other types" do
+      it { expect(subject == 1).to be_falsey }
+      it { expect(subject == :symbol).to be_falsey }
+      it { expect(subject == "string").to be_falsey }
+      it { expect(subject == true).to be_falsey }
+    end
+  end
+
+  describe "#html_attrs" do
+    context "when external is true" do
+      it { expect(described_class.new("", external: true).html_attrs.has_key?(:external)).to be_truthy }
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe HasHelpers::SlackNotifier do
+  describe ".default_channel" do
+    it "returns nil in test environment" do
+      expect(HasHelpers::SlackNotifier.default_channel).to be_nil
+    end
+
+    context "with a resolver configured" do
+      around do |example|
+        original = HasHelpers::SlackNotifier.default_channel_resolver
+        example.run
+        HasHelpers::SlackNotifier.default_channel_resolver = original
+      end
+
+      it "still returns nil in test environment even with a resolver" do
+        HasHelpers::SlackNotifier.default_channel_resolver = -> { "#some_channel" }
+        expect(HasHelpers::SlackNotifier.default_channel).to be_nil
+      end
+    end
+  end
+
+  describe ".notify" do
+    context "when channel is nil (test/dev environment)" do
+      it "prints the message to stdout instead of posting to Slack" do
+        expect {
+          HasHelpers::SlackNotifier.notify("something happened")
+        }.to output("something happened\n").to_stdout
+      end
+
+      it "accepts an explicit nil channel" do
+        expect {
+          HasHelpers::SlackNotifier.notify("hello", channel: nil)
+        }.to output("hello\n").to_stdout
+      end
+    end
+
+    context "when channel is set" do
+      let(:slack_client) { double("slack_client") }
+      before do
+        stub_const("SlackConf", double("SlackConf", client: slack_client))
+        # Reset memoized default notifier between tests
+        HasHelpers::SlackNotifier.instance_variable_set(:@default_notifier, nil)
+      end
+
+      it "posts to Slack with the given channel" do
+        expect(slack_client).to receive(:chat_postMessage).with(
+          channel: "#ops",
+          text: "deploy complete",
+          as_user: true,
+          mrkdwn: true,
+          link_names: true
+        )
+
+        HasHelpers::SlackNotifier.notify("deploy complete", channel: "#ops")
+      end
+
+      it "logs a warning and does not raise if Slack post fails" do
+        allow(slack_client).to receive(:chat_postMessage).and_raise(StandardError, "network error")
+        expect(Rails.logger).to receive(:warn).with(/Unable to send slack notification/)
+
+        expect {
+          HasHelpers::SlackNotifier.notify("oops", channel: "#ops")
+        }.not_to raise_error
+      end
+    end
+  end
+end

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

@@ -0,0 +1,343 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe HasHelpers::UserRestrictions do
+  # The :has_helper_user factory already builds a primary user_organization.
+  let(:user) { FactoryBot.create(:has_helper_user) }
+  let(:user_organization) { user.user_organizations.first }
+
+  let(:client_view_restrictions) do
+    {
+      "MyApp" => {
+        "Client" => {
+          "restriction_operations" => ["View"],
+          "resource_type" => "Base"
+        }
+      }
+    }
+  end
+
+  def build(application: nil, app_keys: ["MyApp"])
+    described_class.new(user, application: application, app_keys: app_keys)
+  end
+
+  describe "#restrictions" do
+    context "with no restrictions_hash" do
+      it "returns an empty hash" do
+        expect(build.restrictions).to eq({})
+        expect(build.empty?).to be true
+      end
+    end
+
+    context "with a jsonb hash" do
+      before { user_organization.update!(restrictions_hash: client_view_restrictions) }
+
+      it "resolves the app restrictions via app_keys" do
+        expect(build.restrictions).to have_key("Client")
+        expect(build.empty?).to be false
+      end
+    end
+
+    context "with single-encoded JSON text" do
+      before do
+        user_organization.update_column(:restrictions_hash, client_view_restrictions.to_json)
+      end
+
+      it "parses and resolves the app restrictions" do
+        expect(build.restrictions).to have_key("Client")
+      end
+    end
+
+    context "with an Array-formatted app payload" do
+      before do
+        user_organization.update!(
+          restrictions_hash: { "MyApp" => [{ "Client" => { "restriction_operations" => ["View"] } }] }
+        )
+      end
+
+      it "normalizes the array into a flat hash" do
+        expect(build.restrictions).to have_key("Client")
+      end
+    end
+
+    context "app key resolution without app_keys match" do
+      before do
+        user_organization.update!(
+          restrictions_hash: { "MyApp" => { "Client" => { "restriction_operations" => ["View"] } } }
+        )
+      end
+
+      it "matches application case-insensitively" do
+        restrictions = build(application: "MYAPP", app_keys: [])
+        expect(restrictions.restrictions).to have_key("Client")
+      end
+
+      it "matches application via titleize" do
+        user_organization.update!(
+          restrictions_hash: { "My App" => { "Client" => { "restriction_operations" => ["View"] } } }
+        )
+        restrictions = build(application: "my app", app_keys: [])
+        expect(restrictions.restrictions).to have_key("Client")
+      end
+
+      it "returns {} when nothing matches" do
+        restrictions = build(application: "other", app_keys: ["Nope"])
+        expect(restrictions.restrictions).to eq({})
+      end
+    end
+
+    it "memoizes the resolved restrictions" do
+      user_organization.update!(restrictions_hash: client_view_restrictions)
+      # Restrictions are resolved eagerly during initialize (CanCan rules are
+      # defined from `empty?`), so reads afterwards must not re-resolve.
+      restrictions = build
+      expect(restrictions).not_to receive(:restrictions_for_app)
+
+      3.times { restrictions.restrictions }
+    end
+
+    context "when the user has no user_organizations" do
+      let(:lonely_user) { FactoryBot.create(:has_helper_user) }
+
+      it "returns an empty hash" do
+        ::HasHelpers::UserOrganization.where(user_id: lonely_user.id).delete_all
+        restrictions = described_class.new(lonely_user, app_keys: ["MyApp"])
+        expect(restrictions.restrictions).to eq({})
+      end
+    end
+  end
+
+  describe "#restricted?" do
+    before { user_organization.update!(restrictions_hash: client_view_restrictions) }
+
+    it "restricts :read when View is restricted" do
+      expect(build.restricted?(:read, "Client")).to be true
+    end
+
+    it "restricts :read when Read is restricted" do
+      user_organization.update!(
+        restrictions_hash: { "MyApp" => { "Client" => { "restriction_operations" => ["Read"] } } }
+      )
+      expect(build.restricted?(:read, "Client")).to be true
+    end
+
+    it "does not restrict other actions" do
+      expect(build.restricted?(:update, "Client")).to be false
+      expect(build.restricted?(:destroy, "Client")).to be false
+    end
+
+    it "matches namespaced resource names (demodulized)" do
+      expect(build.restricted?(:read, "Crm::Client")).to be true
+    end
+
+    it "matches when the restriction key is namespaced (reverse demodulized)" do
+      user_organization.update!(
+        restrictions_hash: { "MyApp" => { "Crm::Client" => { "restriction_operations" => ["View"] } } }
+      )
+      expect(build.restricted?(:read, "Client")).to be true
+    end
+
+    it "matches via alias_name" do
+      user_organization.update!(
+        restrictions_hash: {
+          "MyApp" => { "Client" => { "restriction_operations" => ["View"], "alias_name" => "Customer" } }
+        }
+      )
+      expect(build.restricted?(:read, "Customer")).to be true
+    end
+
+    it "accepts a Class as resource" do
+      stub_const("Client", Class.new)
+      expect(build.restricted?(:read, Client)).to be true
+    end
+
+    it "accepts objects responding to :klass" do
+      resource = Struct.new(:klass).new("Crm::Client")
+      expect(build.restricted?(:read, resource)).to be true
+    end
+
+    it "returns false for unrestricted resources" do
+      expect(build.restricted?(:read, "Project")).to be false
+    end
+  end
+
+  describe "#restricted_resource_names" do
+    before do
+      user_organization.update!(
+        restrictions_hash: {
+          "MyApp" => {
+            "Client" => { "restriction_operations" => ["View"] },
+            "Invoice" => { "restriction_operations" => ["Read"] },
+            "Project" => { "restriction_operations" => ["Delete"] }
+          }
+        }
+      )
+    end
+
+    it "returns read-restricted resources by default (View + Read)" do
+      expect(build.restricted_resource_names).to contain_exactly("Client", "Invoice")
+    end
+
+    it "filters by custom operations" do
+      expect(build.restricted_resource_names(operations: "Delete")).to contain_exactly("Project")
+    end
+  end
+
+  describe "CanCan::Ability integration" do
+    it "includes CanCan::Ability" do
+      expect(described_class.ancestors).to include(CanCan::Ability)
+    end
+  end
+
+  describe "#can?" do
+    context "with no restrictions" do
+      it "allows everything (can :manage, :all)" do
+        expect(build.can?(:read, "Client")).to be true
+        expect(build.can?(:create, "Anything")).to be true
+        expect(build.can?(:destroy, "Whatever")).to be true
+      end
+    end
+
+    context "with a View restriction on Client" do
+      before { user_organization.update!(restrictions_hash: client_view_restrictions) }
+
+      it "denies :read on the restricted resource" do
+        expect(build.can?(:read, "Client")).to be false
+      end
+
+      it "allows non-restricted actions on the restricted resource" do
+        expect(build.can?(:create, "Client")).to be true
+        expect(build.can?(:update, "Client")).to be true
+      end
+
+      it "allows any action on unrestricted resources" do
+        expect(build.can?(:read, "Project")).to be true
+      end
+
+      it "denies via the :cards UI alias (maps to :read)" do
+        expect(build.can?(:cards, "Client")).to be false
+      end
+
+      it "accepts a Class as subject" do
+        stub_const("Client", Class.new)
+        expect(build.can?(:read, Client)).to be false
+      end
+
+      it "accepts objects responding to :klass" do
+        resource = Struct.new(:klass).new("Crm::Client")
+        expect(build.can?(:read, resource)).to be false
+      end
+    end
+
+    context "with an Update restriction on Client" do
+      before do
+        user_organization.update!(
+          restrictions_hash: { "MyApp" => { "Client" => { "restriction_operations" => ["Update"] } } }
+        )
+      end
+
+      it "denies via the :edit alias (maps to :update)" do
+        expect(build.can?(:edit, "Client")).to be false
+        expect(build.can?(:read, "Client")).to be true
+      end
+    end
+
+    context "with an Export restriction on Client" do
+      before do
+        user_organization.update!(
+          restrictions_hash: { "MyApp" => { "Client" => { "restriction_operations" => ["Export"] } } }
+        )
+      end
+
+      it "denies via the :email alias (maps to :export)" do
+        expect(build.can?(:email, "Client")).to be false
+      end
+    end
+
+    it "memoizes the authorization result per (subject, action)" do
+      user_organization.update!(restrictions_hash: client_view_restrictions)
+      restrictions = build
+      expect(restrictions).to receive(:restricted?).once.and_call_original
+
+      3.times { restrictions.can?(:read, "Client") }
+    end
+  end
+
+  describe "multi-host resolution" do
+    # The same restrictions_hash holds entries for several OneHQ host apps
+    # (AgenciesHQ, ReadyGOP, Reports, HQAdmin); each host resolves only its own
+    # restrictions via its app_keys.
+    before do
+      user_organization.update!(
+        restrictions_hash: {
+          "AgenciesHQ" => { "Donor" => { "restriction_operations" => ["View"] } },
+          "ReadyGOP" => { "Client" => { "restriction_operations" => ["View"] } }
+        }
+      )
+    end
+
+    it "resolves each host's restrictions independently by its own app_keys" do
+      agencies = described_class.new(user, app_keys: ["AgenciesHQ"])
+      readygop = described_class.new(user, app_keys: ["ReadyGOP"])
+
+      expect(agencies.restricted?(:read, "Donor")).to be true
+      expect(agencies.restricted?(:read, "Client")).to be false
+      expect(readygop.restricted?(:read, "Client")).to be true
+      expect(readygop.restricted?(:read, "Donor")).to be false
+    end
+  end
+end
+
+RSpec.describe HasHelpers::Concerns::RestrictionsParseable do
+  let(:dummy) { Class.new { include HasHelpers::Concerns::RestrictionsParseable }.new }
+
+  describe "#parse_raw_restrictions" do
+    let(:hash) { { "MyApp" => { "Client" => { "restriction_operations" => ["View"] } } } }
+
+    it "returns hashes as-is" do
+      expect(dummy.send(:parse_raw_restrictions, hash)).to eq(hash)
+    end
+
+    it "parses a single-encoded JSON string" do
+      expect(dummy.send(:parse_raw_restrictions, hash.to_json)).to eq(hash)
+    end
+
+    it "does not unwrap multi-encoded JSON (single parse only, matching readygop)" do
+      expect(dummy.send(:parse_raw_restrictions, hash.to_json.to_json)).to eq({})
+    end
+
+    it "returns {} and warns on invalid JSON" do
+      expect(Rails.logger).to receive(:warn).with(/Invalid restrictions_hash for user 123/)
+      expect(dummy.send(:parse_raw_restrictions, "invalid json {", user_id: 123)).to eq({})
+    end
+
+    it "returns {} for blank values" do
+      expect(dummy.send(:parse_raw_restrictions, nil)).to eq({})
+      expect(dummy.send(:parse_raw_restrictions, "")).to eq({})
+    end
+
+    it "returns {} for non-hash JSON" do
+      expect(dummy.send(:parse_raw_restrictions, "[1, 2]")).to eq({})
+    end
+  end
+
+  describe "#normalize_restrictions" do
+    it "returns hashes as-is" do
+      input = { "Client" => { "restriction_operations" => ["View"] } }
+      expect(dummy.send(:normalize_restrictions, input)).to eq(input)
+    end
+
+    it "flattens arrays of hashes" do
+      input = [{ "Client" => { "a" => 1 } }, { "Team" => { "b" => 2 } }, "junk"]
+      expect(dummy.send(:normalize_restrictions, input)).to eq(
+        "Client" => { "a" => 1 }, "Team" => { "b" => 2 }
+      )
+    end
+
+    it "returns {} for anything else" do
+      expect(dummy.send(:normalize_restrictions, nil)).to eq({})
+      expect(dummy.send(:normalize_restrictions, "string")).to eq({})
+    end
+  end
+end