brut 0.16.0 → 0.18.0

data/specs/brut/front_end/forms/radio_button_group_input.spec.rb

@@ -1,54 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Brut::FrontEnd::Forms::RadioButtonGroupInput do
-  describe "#value=" do
-    let(:name) { "test-input" }
-    context "value is present" do
-      it "does not set any violations" do
-        input = described_class.new(
-          input_definition: Brut::FrontEnd::Forms::RadioButtonGroupInputDefinition.new(
-            name:,
-            required: true,
-          ),
-          index: 0,
-          value: "DC"
-        )
-        expect(input.valid?).to eq(true)
-        expect(input.value).to eq("DC")
-        expect(input.typed_value).to eq("DC")
-      end
-    end
-    context "value is not present" do
-      context "required" do
-        it "sets valueMissing violation" do
-          input = described_class.new(
-            input_definition: Brut::FrontEnd::Forms::RadioButtonGroupInputDefinition.new(
-              name:,
-              required: true,
-            ),
-            index: 0,
-            value: ""
-          )
-          expect(input.validity_state).to have_constraint_violation(:valueMissing)
-          expect(input.value).to eq("")
-          expect(input.typed_value).to eq(nil)
-        end
-      end
-      context "not required" do
-        it "does not set any violations" do
-          input = described_class.new(
-            input_definition: Brut::FrontEnd::Forms::RadioButtonGroupInputDefinition.new(
-              name:,
-              required: false,
-            ),
-            index: 0,
-            value: ""
-          )
-          expect(input.valid?).to eq(true)
-          expect(input.value).to eq("")
-          expect(input.typed_value).to eq(nil)
-        end
-      end
-    end
-  end
-end

data/specs/brut/front_end/forms/select_input.spec.rb

@@ -1,54 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Brut::FrontEnd::Forms::SelectInput do
-  describe "#value=" do
-    let(:name) { "test-input" }
-    context "value is present" do
-      it "does not set any violations" do
-        input = described_class.new(
-          input_definition: Brut::FrontEnd::Forms::SelectInputDefinition.new(
-            name:,
-            required: true,
-          ),
-          index: 0,
-          value: "DC"
-        )
-        expect(input.valid?).to eq(true)
-        expect(input.value).to eq("DC")
-        expect(input.typed_value).to eq("DC")
-      end
-    end
-    context "value is not present" do
-      context "required" do
-        it "sets valueMissing violation" do
-          input = described_class.new(
-            input_definition: Brut::FrontEnd::Forms::SelectInputDefinition.new(
-              name:,
-              required: true,
-            ),
-            index: 0,
-            value: ""
-          )
-          expect(input.validity_state).to have_constraint_violation(:valueMissing)
-          expect(input.value).to eq("")
-          expect(input.typed_value).to eq(nil)
-        end
-      end
-      context "not required" do
-        it "does not set any violations" do
-          input = described_class.new(
-            input_definition: Brut::FrontEnd::Forms::SelectInputDefinition.new(
-              name:,
-              required: false,
-            ),
-            index: 0,
-            value: ""
-          )
-          expect(input.valid?).to eq(true)
-          expect(input.value).to eq("")
-          expect(input.typed_value).to eq(nil)
-        end
-      end
-    end
-  end
-end

data/specs/brut/instrumentation/methods.spec.rb

@@ -1,399 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Brut::Instrumentation::Methods do
-  describe "#instrument" do
-    it "instruments only those methods specified" do
-      mock_container = double("Brut::Framework::Container")
-      instrumentation = instance_double(Brut::Instrumentation::OpenTelemetry)
-      allow(Brut).to receive(:container).and_return(mock_container)
-      allow(mock_container).to receive(:instrumentation).and_return(instrumentation)
-      allow(instrumentation).to receive(:span).and_yield(double("span that should not be used"))
-
-      class_to_instrument = Class.new do
-        include Brut::Instrumentation::Methods
-
-        def save
-          @save_called = true
-        end
-
-        def search
-          @search_called = true
-        end
-
-        def self.name # since this is an anonymous class, need some name to show up
-          "TestClass"
-        end
-
-        private
-
-        def delete
-          @delete_called = true
-        end
-
-        instrument :save, :delete
-      end
-      object = class_to_instrument.new
-
-      object.save
-      object.search
-      object.send(:delete)
-
-      expect(object.instance_variable_get(:@save_called)).to   eq(true)
-      expect(object.instance_variable_get(:@search_called)).to eq(true)
-      expect(object.instance_variable_get(:@delete_called)).to eq(true)
-      expect(instrumentation).to have_received(:span).with(
-        "TestClass#save",
-        attributes: {
-          "brut.class" => "TestClass",
-          "brut.method" => "save",
-        }
-      )
-      expect(instrumentation).to have_received(:span).with(
-        "TestClass#delete",
-        attributes: {
-          "brut.class" => "TestClass",
-          "brut.method" => "delete",
-        }
-      )
-      expect(instrumentation).not_to have_received(:span).with(
-        /\#search/,
-        attributes: kind_of(Hash)
-      )
-    end
-    it "works when called on a method definition" do
-      mock_container = double("Brut::Framework::Container")
-      instrumentation = instance_double(Brut::Instrumentation::OpenTelemetry)
-      allow(Brut).to receive(:container).and_return(mock_container)
-      allow(mock_container).to receive(:instrumentation).and_return(instrumentation)
-      allow(instrumentation).to receive(:span).and_yield(double("span that should not be used"))
-
-      class_to_instrument = Class.new do
-        include Brut::Instrumentation::Methods
-
-        instrument def save
-          @save_called = true
-        end
-
-        def search
-          @search_called = true
-        end
-
-        def self.name # since this is an anonymous class, need some name to show up
-          "TestClass"
-        end
-
-        private
-
-        instrument def delete
-          @delete_called = true
-        end
-      end
-      object = class_to_instrument.new
-
-      object.save
-      object.search
-      object.send(:delete)
-
-      expect(object.instance_variable_get(:@save_called)).to   eq(true)
-      expect(object.instance_variable_get(:@search_called)).to eq(true)
-      expect(object.instance_variable_get(:@delete_called)).to eq(true)
-      expect(instrumentation).to have_received(:span).with(
-        "TestClass#save",
-        attributes: {
-          "brut.class" => "TestClass",
-          "brut.method" => "save",
-        }
-      )
-      expect(instrumentation).to have_received(:span).with(
-        "TestClass#delete",
-        attributes: {
-          "brut.class" => "TestClass",
-          "brut.method" => "delete",
-        }
-      )
-      expect(instrumentation).not_to have_received(:span).with(
-        /\#search/,
-        attributes: kind_of(Hash)
-      )
-    end
-
-    it "calling it twice raises an error" do
-      expect {
-        Class.new do
-          include Brut::Instrumentation::Methods
-
-          def save
-            @save_called = true
-          end
-
-          def self.name # since this is an anonymous class, need some name to show up
-            "TestClass"
-          end
-
-          instrument :save
-          instrument :save
-        end
-      }.to raise_error(ArgumentError, /already instrumented/)
-    end
-
-    it "instrumenting a nonexistent method raises an error" do
-      expect {
-        Class.new do
-          include Brut::Instrumentation::Methods
-
-          def save
-            @save_called = true
-          end
-
-          def self.name # since this is an anonymous class, need some name to show up
-            "TestClass"
-          end
-
-          instrument :foo
-        end
-      }.to raise_error(ArgumentError)
-    end
-  end
-  describe "#instrument_all" do
-    it "instruments all methods" do
-      mock_container = double("Brut::Framework::Container")
-      instrumentation = instance_double(Brut::Instrumentation::OpenTelemetry)
-      allow(Brut).to receive(:container).and_return(mock_container)
-      allow(mock_container).to receive(:instrumentation).and_return(instrumentation)
-      allow(instrumentation).to receive(:span).and_yield(double("span that should not be used"))
-
-      class_to_instrument = Class.new do
-        include Brut::Instrumentation::Methods
-
-        def save
-          @save_called = true
-        end
-
-        def search
-          @search_called = true
-        end
-
-        def self.name # since this is an anonymous class, need some name to show up
-          "TestClass"
-        end
-
-        private
-
-        def delete
-          @delete_called = true
-        end
-
-        instrument_all
-      end
-      object = class_to_instrument.new
-
-      object.save
-      object.search
-      object.send(:delete)
-
-      expect(object.instance_variable_get(:@save_called)).to   eq(true)
-      expect(object.instance_variable_get(:@search_called)).to eq(true)
-      expect(object.instance_variable_get(:@delete_called)).to eq(true)
-      expect(instrumentation).to have_received(:span).with(
-        "TestClass#save",
-        attributes: {
-          "brut.class" => "TestClass",
-          "brut.method" => "save",
-        }
-      )
-      expect(instrumentation).to have_received(:span).with(
-        "TestClass#delete",
-        attributes: {
-          "brut.class" => "TestClass",
-          "brut.method" => "delete",
-        }
-      )
-      expect(instrumentation).to have_received(:span).with(
-        "TestClass#search",
-        attributes: {
-          "brut.class" => "TestClass",
-          "brut.method" => "search",
-        }
-      )
-    end
-    it "instruments all methods defined after it is called" do
-      mock_container = double("Brut::Framework::Container")
-      instrumentation = instance_double(Brut::Instrumentation::OpenTelemetry)
-      allow(Brut).to receive(:container).and_return(mock_container)
-      allow(mock_container).to receive(:instrumentation).and_return(instrumentation)
-      allow(instrumentation).to receive(:span).and_yield(double("span that should not be used"))
-
-      class_to_instrument = Class.new do
-        include Brut::Instrumentation::Methods
-        instrument_all
-
-        def save
-          @save_called = true
-        end
-
-        def search
-          @search_called = true
-        end
-
-        def self.name # since this is an anonymous class, need some name to show up
-          "TestClass"
-        end
-
-        private
-
-        def delete
-          @delete_called = true
-        end
-      end
-      object = class_to_instrument.new
-
-      object.save
-      object.search
-      object.send(:delete)
-
-      expect(object.instance_variable_get(:@save_called)).to   eq(true)
-      expect(object.instance_variable_get(:@search_called)).to eq(true)
-      expect(object.instance_variable_get(:@delete_called)).to eq(true)
-      expect(instrumentation).to have_received(:span).with(
-        "TestClass#save",
-        attributes: {
-          "brut.class" => "TestClass",
-          "brut.method" => "save",
-        }
-      )
-      expect(instrumentation).to have_received(:span).with(
-        "TestClass#delete",
-        attributes: {
-          "brut.class" => "TestClass",
-          "brut.method" => "delete",
-        }
-      )
-      expect(instrumentation).to have_received(:span).with(
-        "TestClass#search",
-        attributes: {
-          "brut.class" => "TestClass",
-          "brut.method" => "search",
-        }
-      )
-    end
-  end
-  describe "#instrument_public" do
-    it "instruments only public methods" do
-      mock_container = double("Brut::Framework::Container")
-      instrumentation = instance_double(Brut::Instrumentation::OpenTelemetry)
-      allow(Brut).to receive(:container).and_return(mock_container)
-      allow(mock_container).to receive(:instrumentation).and_return(instrumentation)
-      allow(instrumentation).to receive(:span).and_yield(double("span that should not be used"))
-
-      class_to_instrument = Class.new do
-        include Brut::Instrumentation::Methods
-
-        def save
-          @save_called = true
-        end
-
-        def search
-          @search_called = true
-        end
-
-        def self.name # since this is an anonymous class, need some name to show up
-          "TestClass"
-        end
-
-        private
-
-        def delete
-          @delete_called = true
-        end
-
-        instrument_public
-
-      end
-      object = class_to_instrument.new
-
-      object.save
-      object.search
-      object.send(:delete)
-
-      expect(object.instance_variable_get(:@save_called)).to   eq(true)
-      expect(object.instance_variable_get(:@search_called)).to eq(true)
-      expect(object.instance_variable_get(:@delete_called)).to eq(true)
-      expect(instrumentation).to have_received(:span).with(
-        "TestClass#save",
-        attributes: {
-          "brut.class" => "TestClass",
-          "brut.method" => "save",
-        }
-      )
-      expect(instrumentation).to have_received(:span).with(
-        "TestClass#search",
-        attributes: {
-          "brut.class" => "TestClass",
-          "brut.method" => "search",
-        }
-      )
-      expect(instrumentation).not_to have_received(:span).with(
-        "TestClass#delete",
-        attributes: kind_of(Hash)
-      )
-    end
-    it "instruments only public methods defined after it is called" do
-      mock_container = double("Brut::Framework::Container")
-      instrumentation = instance_double(Brut::Instrumentation::OpenTelemetry)
-      allow(Brut).to receive(:container).and_return(mock_container)
-      allow(mock_container).to receive(:instrumentation).and_return(instrumentation)
-      allow(instrumentation).to receive(:span).and_yield(double("span that should not be used"))
-
-      class_to_instrument = Class.new do
-        include Brut::Instrumentation::Methods
-        instrument_public
-
-        def save
-          @save_called = true
-        end
-
-        def search
-          @search_called = true
-        end
-
-        def self.name # since this is an anonymous class, need some name to show up
-          "TestClass"
-        end
-
-        private
-
-        def delete
-          @delete_called = true
-        end
-
-      end
-      object = class_to_instrument.new
-
-      object.save
-      object.search
-      object.send(:delete)
-
-      expect(object.instance_variable_get(:@save_called)).to   eq(true)
-      expect(object.instance_variable_get(:@search_called)).to eq(true)
-      expect(object.instance_variable_get(:@delete_called)).to eq(true)
-      expect(instrumentation).to have_received(:span).with(
-        "TestClass#save",
-        attributes: {
-          "brut.class" => "TestClass",
-          "brut.method" => "save",
-        }
-      )
-      expect(instrumentation).to have_received(:span).with(
-        "TestClass#search",
-        attributes: {
-          "brut.class" => "TestClass",
-          "brut.method" => "search",
-        }
-      )
-      expect(instrumentation).not_to have_received(:span).with(
-        "TestClass#delete",
-        attributes: kind_of(Hash)
-      )
-    end
-  end
-end

data/specs/brut/junk_drawer.spec.rb

@@ -1,79 +0,0 @@
-require "spec_helper"
-
-RSpec.describe "RichString" do
-  describe ".from_string" do
-    context "nil" do
-      it "returns nil when blank_is_nil is true" do
-        expect(RichString.from_string(nil)).to eq(nil)
-      end
-      it "returns nil when blank_is_nil is false" do
-        expect(RichString.from_string(nil, blank_is_nil: false)).to eq(nil)
-      end
-    end
-    context "empty string" do
-      it "returns nil when blank_is_nil is true" do
-        expect(RichString.from_string("     ")).to eq(nil)
-      end
-      it "returns the string when blank_is_nil is false" do
-        expect(RichString.from_string("     ", blank_is_nil: false)).to eq("     ")
-      end
-    end
-    context "non-empty string" do
-      it "returns a RichString containing the string" do
-        rich_string = RichString.from_string(" foo    ")
-        expect(rich_string.to_str).to eq(" foo    ")
-      end
-    end
-  end
-  describe "#underscorized" do
-    it "returns self if there's nothing to convert" do
-      rich_string = RichString.new("alreadydone")
-      expect(rich_string.underscorized).to eq(rich_string)
-    end
-    it "splits up CamelCase, turns - into _ and downcases everything" do
-      rich_string = RichString.new("DashBoardPage")
-      expect(rich_string.underscorized.to_s).to eq("dash_board_page")
-    end
-    it "handles weird situations" do
-      rich_string = RichString.new("Dash--BoardHTMLPage---")
-      expect(rich_string.underscorized.to_s).to eq("dash_board_h_t_m_l_page")
-    end
-    it "handles namespaces" do
-      rich_string = RichString.new("WebHooks::Stripe")
-      expect(rich_string.underscorized.to_s).to eq("web_hooks/stripe")
-    end
-  end
-  describe "#camelize" do
-    it "splits on _ and -, captializes each part and joins them" do
-      expect(RichString.new("a-normal-base-case").camelize).to eq("ANormalBaseCase")
-      expect(RichString.new("an__odd-_-----_one").camelize).to eq("AnOddOne")
-      expect(RichString.new("Somewhat-Close").camelize).to eq("SomewhatClose")
-      expect(RichString.new("AlreadyDone").camelize).to eq("AlreadyDone")
-    end
-  end
-  describe "#capitalize" do
-    context "first_only" do
-      it "capitalizes the first letter, but does not affect the case of remaining letters" do
-        expect(RichString.new("this is a String").capitalize(:first_only).to_s).to eq("This is a String")
-      end
-    end
-    context "no first_only" do
-      it "behaves as Ruby's stdlib does, which is to capitalize the first letter and downcase the rest" do
-        expect(RichString.new("this is a String").capitalize.to_s).to eq("This is a string")
-      end
-    end
-  end
-  describe "#humanized" do
-    it "replaces - and _ with spaces" do
-      expect(RichString.new("this-is-a-string").humanized).to eq("this is a string")
-    end
-  end
-  describe "#to_s_or_nil" do
-    it "returns nil if the string is empty" do
-      expect(RichString.new("   ").to_s_or_nil).to eq(nil)
-    end
-    it "returns the string if the string is not empty" do
-      expect(RichString.new(" foo ").to_s_or_nil).to eq(" foo ")
-    end
-  end
-end

data/specs/spec_helper.rb

@@ -1,27 +0,0 @@
-require "brut"
-require_relative "support"
-
-RSpec.configure do |config|
-  config.expect_with :rspec do |expectations|
-    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
-  end
-
-  config.mock_with :rspec do |mocks|
-    mocks.verify_partial_doubles = true
-  end
-
-  config.shared_context_metadata_behavior = :apply_to_host_groups
-
-  config.filter_run_when_matching :focus
-  config.disable_monkey_patching!
-  config.warnings = ENV["RSPEC_WARNINGS"] == "true"
-
-  if config.files_to_run.one?
-    config.default_formatter = "doc"
-  end
-
-  config.profile_examples = (ENV["RSPEC_PROFILE_EXAMPLES"] || "0").to_i
-
-  config.order = :random
-  Kernel.srand config.seed
-end

data/specs/support/matchers/have_constraint_violation.rb

@@ -1,23 +0,0 @@
-RSpec::Matchers.define :have_constraint_violation do |key|
-  match do |validity_state|
-    key = key.to_s
-    validity_state.any? do |constraint_violation|
-      constraint_violation.key == key
-    end
-  end
-
-  failure_message do |validity_state|
-    keys_with_violations = validity_state.map { it.key }
-
-    if keys_with_violations.any?
-      "Did not find a violation for '#{key}', but found these keys with violations: #{keys_with_violations.join(", ")}"
-    else
-      "Did not find any constraint violations"
-    end
-  end
-
-  failure_message_when_negated do |validity_state|
-    "Found #{key} as a violation when not expecting it"
-  end
-end
-

data/specs/support/matchers.rb

@@ -1,5 +0,0 @@
-module Support
-  module Matchers
-  end
-end
-require_relative "matchers/have_constraint_violation"

data/specs/support.rb

@@ -1,3 +0,0 @@
-module Support
-end
-require_relative "support/matchers"