has_helpers 5.0.2

data/spec/lib/has_helpers/app/command_spec.rb

@@ -0,0 +1,117 @@
+require "rails_helper"
+
+describe ::App::Command do
+  subject do
+    Class.new.tap { |klass| klass.include(described_class) }
+  end
+
+  describe "#run" do
+    it "should have an error when there is no user implementation" do
+      actual = subject.run
+      aggregate_failures do
+        expect(actual.value).to be_nil
+        expect(actual.error).to_not be_nil
+        expect(actual.success?).to be_falsey
+      end
+    end
+
+    it "assigns to the result" do
+      subject.class_eval do
+        def run(...)
+          result.value = 42
+          result.error = "My bad"
+        end
+      end
+
+      aggregate_failures do
+        expect(subject.run.value).to eq(42)
+        expect(subject.run.error).to eq("My bad")
+      end
+    end
+
+    it "an internal exception is captured as an assigned error" do
+      subject.class_eval do
+        def run(...)
+          raise "boom"
+        end
+      end
+      expect(subject.run.error).to eq("boom")
+    end
+
+    it "a failure is captured as an assigned error" do
+      subject.class_eval do
+        def run(...)
+          result.fail "You let the whole team down"
+        end
+      end
+      expect(subject.run.error).to eq("You let the whole team down")
+    end
+
+    it "uses the return value from the user-defined method" do
+      subject.class_eval do
+        def run(...)
+          "OK"
+        end
+      end
+      expect(subject.run.value).to eq("OK")
+    end
+
+    it "uses the explicit value" do
+      subject.class_eval do
+        def run(...)
+          result.value = "Right"
+          "Wrong"
+        end
+      end
+      expect(subject.run.value).to eq("Right")
+    end
+
+    it "uses the explicit value even when falsey" do
+      subject.class_eval do
+        def run(...)
+          result.value = nil
+          "Wrong"
+        end
+      end
+      expect(subject.run.value).to be_nil
+    end
+  end
+end
+
+describe ::App::Command::Result do
+  describe "#fail!" do
+    it "raises an error" do
+      expect { described_class.new.fail! }.to raise_exception(::App::Command::FailureError)
+    end
+
+    it "raises error with the given message" do
+      expect { described_class.new.fail!("message") }.to raise_exception(::App::Command::FailureError).with_message("message")
+    end
+
+    it "raises error with set message" do
+      expect { described_class.new(error: "message").fail! }.to raise_exception(::App::Command::FailureError).with_message("message")
+    end
+  end
+end
+
+
+describe ::App::Command::ResultProxy do
+  describe "#success?" do
+    subject { described_class.new(result) }
+    let(:result) { ::App::Command::Result.new }
+
+    it do
+      expect(subject.success?).to be_truthy
+    end
+
+    it do
+      subject.fail
+      expect(subject.success?).to be_falsey
+    end
+
+    it do
+      subject.error = "Oh, fudge!"
+      expect(subject.success?).to be_falsey
+    end
+  end
+end

data/spec/lib/has_helpers/app/support/mocks/graphql_reports_helpers.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module GraphqlReportsHelpers
+  class << self
+    # Resets the sequence of IDs used to simulate responses from the GraphQL backend
+    def reset_sequence(to: 0)
+      @last_id = to.to_i
+    end
+
+    # Last generated ID (convenient for assertions)
+    def last_created_id
+      @last_id || 0
+    end
+
+    # Generates the next ID for "create" responses
+    def next_id
+      @last_id = (@last_id || 0) + 1
+    end
+
+    # Minimal structure of a successful response to create_resource
+    def build_create_resource_success(id:)
+      {
+        "data" => {
+          "createResource" => {
+            "resource" => {
+              "id" => id.to_s
+            }
+          }
+        }
+      }
+    end
+
+    # Stub for create_resource that returns an incremental ID starting from start_from
+    def stub_dynamic_create_resource(rspec, start_from: 1)
+      reset_sequence(to: start_from - 1)
+
+      rspec.allow(Reports::ExternalGraphqlClient)
+           .to rspec.receive(:create_resource) do |mutation_name:, input_name:, attributes:|
+        build_create_resource_success(id: next_id)
+      end
+    end
+
+    # Stub that, for a specific name, returns "not found" first and then "found"
+    def stub_query_by_name_first_nil_then_found(rspec, name:)
+      first_call = true
+
+      rspec.allow(Reports::ExternalGraphqlClient)
+           .to rspec.receive(:query_resource_by_name)
+                    .with(name: name) do
+        if first_call
+          first_call = false
+          { "data" => { "resourceName" => nil } }
+        else
+          {
+            "data" => {
+              "resourceName" => {
+                "id" => next_id.to_s,
+                "name" => name
+              }
+            }
+          }
+        end
+      end
+    end
+
+    # Compatibility with specs that call:
+    # GraphqlReportsHelpers.stub_graphql_query_by_name_echo_found(self, start_from: 1)
+    #
+    # This stubs "echoes" the queried name:
+    # - First query for each name -> nil (not found)
+    # - Second and subsequent -> found with incremental ID
+    def stub_graphql_query_by_name_echo_found(rspec, start_from: 1)
+      reset_sequence(to: start_from - 1)
+
+      # State per queried name
+      state_by_name = Hash.new { |h, k| h[k] = :first_nil }
+
+      rspec.allow(Reports::ExternalGraphqlClient)
+           .to rspec.receive(:query_resource_by_name) do |name:|
+        if state_by_name[name] == :first_nil
+          state_by_name[name] = :found
+          { "data" => { "resourceName" => nil } }
+        else
+          {
+            "data" => {
+              "resourceName" => {
+                "id" => next_id.to_s,
+                "name" => name
+              }
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/spec/lib/has_helpers/app/support/mocks/reports_api_mock.rb

@@ -0,0 +1,47 @@
+# Ruby
+module ReportsApiMock
+  class << self
+    def create_resource_success(id:)
+      {
+        "data" => {
+          "createResource" => {
+            "resource" => { "id" => id },
+            "errors" => {}
+          }
+        }
+      }
+    end
+
+    def create_resource_failure(errors:)
+      {
+        "data" => {
+          "createResource" => {
+            "resource" => nil,
+            "errors" => errors || {}
+          }
+        }
+      }
+    end
+
+    def query_resource_by_name_not_found
+      { "data" => { "resourceName" => nil } }
+    end
+
+    def query_resource_by_name_found(id:, name:)
+      { "data" => { "resourceName" => { "id" => id, "name" => name } } }
+    end
+
+    def query_all_resources_response(resources:)
+      edges = resources.map { |r| { "node" => r } }
+      { "data" => { "resources" => { "edges" => edges } } }
+    end
+
+    def created_resource_id(response)
+      response.dig("data", "createResource", "resource", "id")
+    end
+
+    def create_errors(response)
+      response.dig("data", "createResource", "errors") || {}
+    end
+  end
+end

data/spec/lib/has_helpers/attributes_spec.rb

@@ -0,0 +1,220 @@
+require "rails_helper"
+
+describe ::HasHelpers::Attributes do
+  describe '.guarded_attr_accessor' do
+    let(:input) { { :name => "Herp", :value => "Derp" } }
+    let(:icon) { "fa-icon" }
+    let(:klass) do
+      Class.new do
+        include ::HasHelpers::Attributes
+
+        def msg
+          "Hello, spec-world"
+        end
+
+        guarded_attr_accessor :x
+        guarded_attr_accessor :f do
+          :hai_guise
+        end
+        guarded_attr_accessor :unguarded_and_unmemoized, memoize: false do
+          "I come from unguarded_and_unmemoized: #{ msg }"
+        end
+        guarded_attr_accessor :g, guard: -> value { "The value was: #{ value }" } do
+          :hai_guise
+        end
+        guarded_attr_accessor :h do
+          "I come from h: #{ msg }"
+        end
+        guarded_attr_accessor :i, guard: -> value { (value || "Zoink").to_s.upcase }, guard_nil: true
+        guarded_attr_accessor :memoized, guard_nil: true, guard: -> value {
+          raise "This was called more than once!" if @already_called_me_bro
+          @already_called_me_bro = true
+          "M&M"
+        }
+        guarded_attr_accessor :memoized_with_nil, guard_nil: true, guard: -> value {
+          raise "This was called more than once!" if @already_called_me_bro
+          @already_called_me_bro = true
+          nil
+        }
+        guarded_attr_accessor :memoized_with_false, guard_nil: true, guard: -> value {
+          raise "This was called more than once!" if @already_called_me_bro
+          @already_called_me_bro = true
+          false
+        }
+        guarded_attr_accessor :not_memoized, memoize: false, guard_nil: true, guard: -> value {
+          @count ||= 0
+          @count += 1
+        }
+        guarded_attr_accessor :with_args do |x|
+          x * 7
+        end
+        guarded_attr_accessor :implicitly_bypass_nil, guard: :upcase
+        guarded_attr_accessor :guard_nil, guard: :upcase, guard_nil: true
+        guarded_attr_accessor :implicitly_bypass_nil_with_block, guard: :upcase do; end
+        guarded_attr_accessor :guard_nil_with_block, guard: :upcase, guard_nil: true do;
+          @guard_nil_with_block
+        end
+        guarded_attr_accessor :service, :input, auto_guard: true
+        guarded_attr_accessor :unguarded_collection, collection: true
+        guarded_attr_accessor :services, collection: true, guard: -> value { value.to_service }
+        guarded_attr_accessor :inputs, :icons, collection: true, auto_guard: true
+      end
+    end
+    let(:action_klass) do
+      Class.new do
+        def to_service
+          "http://example.com"
+        end
+
+        def to_input
+          { :name => "Herp", :value => "Derp" }
+        end
+
+        def to_icon
+          "fa-icon"
+        end
+      end
+    end
+    subject { klass.new }
+
+    context do
+      it "returns nil for unset attr" do
+        expect(subject.x).to be_nil
+      end
+
+      it "returns set value" do
+        subject.x = :derp
+        expect(subject.x).to eq(:derp)
+      end
+
+      it "returns result of block" do
+        expect(subject.f).to eq(:hai_guise)
+      end
+
+      it "evaluates result of block with guard proc" do
+        expect(subject.g).to eq("The value was: hai_guise")
+      end
+
+      it "evaluates block within context of the current instance" do
+        expect(subject.h).to eq("I come from h: Hello, spec-world")
+      end
+
+      it "returns the evaluated block when unguarded and unmemoized" do
+        expect(subject.unguarded_and_unmemoized).to eq("I come from unguarded_and_unmemoized: Hello, spec-world")
+      end
+
+      it "guards when no block is given" do
+        expect(subject.i).to eq("ZOINK")
+      end
+
+      it "guards implicit value when no block is given" do
+        subject.instance_variable_set(:@i, :derp)
+        expect(subject.i).to eq("DERP")
+      end
+
+      it "passes args to given block" do
+        expect(subject.with_args(3)).to eq(21)
+      end
+    end
+
+    context "memoization" do
+      it "memoizes" do
+        expect{ subject.memoized; subject.memoized }.to_not raise_exception
+      end
+
+      it "memoizes nil" do
+        expect{ subject.memoized_with_nil; subject.memoized_with_nil }.to_not raise_exception
+      end
+
+      it "memoizes false" do
+        expect{ subject.memoized_with_false; subject.memoized_with_false }.to_not raise_exception
+      end
+
+      it "does not memoize when option is set to false" do
+        expect(subject.not_memoized).to eq(1)
+        expect(subject.not_memoized).to eq(2)
+      end
+    end
+
+    context "guard nil" do
+      it "implicitly bypasses nil" do
+        expect(subject.implicitly_bypass_nil).to be_nil
+      end
+
+      it "non-nil value is not implicitly bypassed" do
+        subject.guard_nil = "hey"
+        expect(subject.guard_nil).to eq("HEY")
+      end
+
+      it "executes the guard on nil" do
+        expect { subject.guard_nil }.to raise_error(NoMethodError)
+      end
+
+      it "works normally on non-nil values" do
+        subject.guard_nil = "hey"
+        expect(subject.guard_nil).to eq("HEY")
+      end
+
+      it "implicitly bypasses nil with block" do
+        expect(subject.implicitly_bypass_nil_with_block).to be_nil
+      end
+
+      it "non-nil value is not implicitly bypassed with block" do
+        subject.guard_nil_with_block = "hey"
+        expect(subject.guard_nil_with_block).to eq("HEY")
+      end
+
+      it "executes the guard on nil with block" do
+        expect { subject.guard_nil_with_block }.to raise_error(NoMethodError)
+      end
+
+      it "works normally on non-nil values with block" do
+        subject.guard_nil_with_block = "hey"
+        expect(subject.guard_nil_with_block).to eq("HEY")
+      end
+    end
+
+    context "auto_guard" do
+      it "guards with a symbol matching the attribute name" do
+        subject.service = action_klass.new
+        expect(subject.service).to eq("http://example.com")
+      end
+
+      it "guards for all attribute names given" do
+        subject.input = action_klass.new
+        expect(subject.input).to eq(input)
+      end
+    end
+
+    context "collection" do
+      it "returns an empty collection when the value is nil" do
+        subject.unguarded_collection = nil
+        expect(subject.unguarded_collection).to eq([])
+      end
+
+      it "guards an empty collection" do
+        subject.services = []
+        expect(subject.services).to be_empty
+      end
+
+      it "guards against each element of a collection" do
+        subject.icons = [action_klass.new] * 3
+        expect(subject.icons).to eq([icon] * 3)
+      end
+
+      context "auto_guard" do
+        it "guards with a generated proc" do
+          subject.inputs = [action_klass.new] * 2
+          expect(subject.inputs).to eq([input] * 2)
+        end
+      end
+
+      # context "memoize" do
+      #   it "does _not_ memoize by default" do
+      #     3.times { subject.inputs << action_klass.new }
+      #     expect(subject.inputs).to eq([input] * 3)
+      #   end
+      # end
+    end
+  end
+end

data/spec/lib/has_helpers/aws_spec.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe HasHelpers::Aws do
+  describe "._get_existing_env!" do
+    around do |example|
+      original_env = ENV.to_hash
+      ENV.delete("DUMMY_VAR")
+      example.run
+      ENV.replace(original_env)
+    end
+
+    it "returns the ENV value if present" do
+      ENV["DUMMY_VAR"] = "real_value"
+      expect(described_class._get_existing_env!("DUMMY_VAR", "default")).to eq("real_value")
+    end
+
+    it "returns the fallback value if ENV is missing and in development" do
+      allow(HasUtils::Env).to receive(:development?).and_return(true)
+      allow(HasUtils::Env).to receive(:test?).and_return(false)
+
+      expect(described_class._get_existing_env!("DUMMY_VAR", "fallback")).to eq("fallback")
+    end
+
+    it "returns the fallback value if ENV is missing and in test" do
+      allow(HasUtils::Env).to receive(:development?).and_return(false)
+      allow(HasUtils::Env).to receive(:test?).and_return(true)
+
+      expect(described_class._get_existing_env!("DUMMY_VAR", "fallback")).to eq("fallback")
+    end
+
+    it "aborts if value is missing and not in dev/test" do
+      allow(HasUtils::Env).to receive(:development?).and_return(false)
+      allow(HasUtils::Env).to receive(:test?).and_return(false)
+
+      expect {
+        described_class._get_existing_env!("DUMMY_VAR")
+      }.to raise_error(SystemExit)
+    end
+  end
+
+  describe "conf methods" do
+    before do
+      allow(described_class).to receive(:credentials_conf).and_return(OpenStruct.new(
+        access_key_id: "test-key",
+        secret_access_key: "test-secret"
+      ))
+
+      allow(described_class).to receive(:s3_conf).and_return(OpenStruct.new(
+        bucket: "my-bucket",
+        region: "us-east-2"
+      ))
+
+      allow(described_class).to receive(:sqs_conf).and_return(OpenStruct.new(
+        region: "eu-west-1"
+      ))
+    end
+
+    it "sets credentials_conf with correct values" do
+      expect(described_class.credentials_conf.access_key_id).to eq("test-key")
+      expect(described_class.credentials_conf.secret_access_key).to eq("test-secret")
+    end
+
+    it "sets s3_conf with correct values" do
+      expect(described_class.s3_conf.bucket).to eq("my-bucket")
+      expect(described_class.s3_conf.region).to eq("us-east-2")
+    end
+
+    it "sets sqs_conf with correct values" do
+      expect(described_class.sqs_conf.region).to eq("eu-west-1")
+    end
+  end
+
+  describe "#new_aws_client" do
+    let(:fake_client_class) { class_double("Aws::FakeClient") }
+    let(:credentials) { OpenStruct.new(access_key_id: "abc", secret_access_key: "xyz") }
+
+    it "creates a new client with region and credentials" do
+      expect(fake_client_class).to receive(:new).with(
+        region: "us-west-2",
+        access_key_id: "abc",
+        secret_access_key: "xyz"
+      )
+
+      described_class.new_aws_client(fake_client_class, region: "us-west-2", credentials_conf: credentials)
+    end
+  end
+
+  describe "#new_s3_client" do
+    it "delegates to Aws::S3::Client with config from s3_conf" do
+      client_double = double("Aws::S3::Client")
+      allow(Aws::S3::Client).to receive(:new).and_return(client_double)
+
+      allow(described_class).to receive(:credentials_conf).and_return(OpenStruct.new(
+        access_key_id: "test-key",
+        secret_access_key: "test-secret"
+      ))
+
+      allow(described_class).to receive(:s3_conf).and_return(OpenStruct.new(
+        region: "us-east-1",
+        bucket: "test-bucket"
+      ))
+
+      expect(described_class.new_s3_client).to eq(client_double)
+    end
+  end
+
+  describe "#new_sqs_client" do
+    it "delegates to Aws::SQS::Client with config from sqs_conf" do
+      client_double = double("Aws::SQS::Client")
+      allow(Aws::SQS::Client).to receive(:new).and_return(client_double)
+
+      allow(described_class).to receive(:credentials_conf).and_return(OpenStruct.new(
+        access_key_id: "test-key",
+        secret_access_key: "test-secret"
+      ))
+
+      allow(described_class).to receive(:sqs_conf).and_return(OpenStruct.new(
+        region: "us-west-1"
+      ))
+
+      expect(described_class.new_sqs_client).to eq(client_double)
+    end
+  end
+end