foobara 0.5.10 → 0.6.2

data/projects/typesystem/spec/state_machine/state_machine_spec.rb

@@ -1,224 +0,0 @@
-RSpec.describe Foobara::StateMachine do
-  describe ".set_transition_map" do
-    subject { state_machine_class }
-
-    let(:state_machine_class) do
-      Class.new(described_class).tap do |klass|
-        klass.set_transition_map(
-          transition_map,
-          states:,
-          initial_state:,
-          terminal_states:,
-          transitions:
-        )
-      end
-    end
-
-    let(:state_machine) {
-      state_machine_class.new
-    }
-
-    let(:states) { nil }
-    let(:initial_state) { nil }
-    let(:terminal_states) { nil }
-    let(:transitions) { nil }
-
-    let(:transition_map) do
-      {
-        unexecuted: {
-          start: :running
-        },
-        running: {
-          fail: :failed,
-          succeed: :succeeded
-        }
-      }
-    end
-
-    context "with only the transition map" do
-      its(:states) { is_expected.to eq([:unexecuted, :running, :failed, :succeeded]) }
-      its(:non_terminal_states) { is_expected.to eq([:unexecuted, :running]) }
-      its(:terminal_states) { is_expected.to eq([:failed, :succeeded]) }
-      its(:initial_state) { is_expected.to eq(:unexecuted) }
-      its(:transitions) { is_expected.to eq([:start, :fail, :succeed]) }
-
-      its(:transition_map) {
-        is_expected.to eq(
-          running: { fail: :failed, succeed: :succeeded },
-          unexecuted: { start: :running }
-        )
-      }
-
-      context "with sugary transition map" do
-        let(:transition_map) do
-          {
-            unexecuted: {
-              start: :running
-            },
-            running: {
-              succeed: :succeeded
-            },
-            [:unexecuted, :running] => {
-              fail: :failed
-            }
-          }
-        end
-
-        its(:states) { is_expected.to eq([:unexecuted, :running, :failed, :succeeded]) }
-        its(:non_terminal_states) { is_expected.to eq([:unexecuted, :running]) }
-        its(:terminal_states) { is_expected.to eq([:failed, :succeeded]) }
-        its(:initial_state) { is_expected.to eq(:unexecuted) }
-        its(:transitions) { is_expected.to eq([:start, :fail, :succeed]) }
-
-        describe "#state" do
-          it "is the expected enum" do
-            expect(state_machine_class.state.all_values).to match_array(state_machine_class.states)
-            expect(state_machine_class.state.FAILED).to eq(:failed)
-          end
-        end
-
-        describe "#transition" do
-          it "is the expected enum" do
-            expect(state_machine_class.transition.all_values).to match_array(state_machine_class.transitions)
-            expect(state_machine_class.transition.FAIL).to eq(:fail)
-          end
-        end
-
-        describe "#perform_transition!" do
-          subject { state_machine.perform_transition!(transition) }
-
-          context "when valid transition" do
-            let(:transition) { :start }
-
-            it { is_expected_to change(state_machine, :current_state).from(:unexecuted).to(:running) }
-          end
-
-          context "when invalid transition" do
-            let(:transition) { :bad_transition }
-
-            # TODO: use two different exceptions to avoid checking the error message
-            it { is_expected_to_raise(Foobara::StateMachine::InvalidTransition, /Expected one of/) }
-          end
-
-          context "when in terminal state" do
-            let(:transition) { :fail }
-
-            before do
-              state_machine.start!
-              state_machine.succeed!
-            end
-
-            it "explodes" do
-              expect(state_machine).to be_in_terminal_state
-              expect(state_machine.allowed_transitions).to be_empty
-
-              expect {
-                state_machine.fail!
-              }.to raise_error(Foobara::StateMachine::InvalidTransition, /is a terminal state/)
-            end
-          end
-        end
-
-        describe "dynamically created can predicates" do
-          it "creates can predicates from the transitions" do
-            expect(state_machine.can_start?).to be(true)
-            expect(state_machine.can_succeed?).to be(false)
-          end
-        end
-
-        describe "#allowed_transitions" do
-          it "is the expected allowed transitions" do
-            expect(state_machine.allowed_transitions).to eq([:start, :fail])
-          end
-        end
-
-        its(:transition_map) {
-          is_expected.to eq(
-            running: { fail: :failed, succeed: :succeeded },
-            unexecuted: { fail: :failed, start: :running }
-          )
-        }
-      end
-    end
-
-    context "with states" do
-      context "with valid states" do
-        let(:states) { [:unexecuted, :running, :failed, :succeeded] }
-
-        its(:states) { is_expected.to eq([:unexecuted, :running, :failed, :succeeded]) }
-      end
-
-      context "with extra states" do
-        let(:states) { [:running, :failed, :succeeded] }
-
-        it { is_expected_to_raise(Foobara::StateMachine::ExtraStates) }
-      end
-
-      context "with missing states" do
-        let(:states) { [:unexecuted, :running, :failed, :succeeded, :extra] }
-
-        it { is_expected_to_raise(Foobara::StateMachine::MissingStates) }
-      end
-    end
-
-    context "with terminal states" do
-      context "with valid states that counts a state with as transition (running)" do
-        let(:terminal_states) { [:running, :failed, :succeeded] }
-
-        its(:terminal_states) { is_expected.to eq([:running, :failed, :succeeded]) }
-      end
-
-      context "with extra terminal_states" do
-        let(:terminal_states) { [:succeeded] }
-
-        it { is_expected_to_raise(Foobara::StateMachine::UnexpectedTerminalStates) }
-      end
-
-      context "with missing terminal_states" do
-        let(:terminal_states) { [:unexecuted, :running, :failed, :succeeded, :extra] }
-
-        it { is_expected_to_raise(Foobara::StateMachine::MissingTerminalStates) }
-      end
-    end
-
-    context "with initial_state" do
-      context "with valid initial state that isn't the default" do
-        let(:initial_state) { :running }
-
-        its(:initial_state) { is_expected.to eq(:running) }
-      end
-
-      context "with invalid initial state" do
-        let(:initial_state) { :invalid }
-
-        it { is_expected_to_raise(Foobara::StateMachine::BadInitialState) }
-      end
-    end
-
-    context "with transitions" do
-      context "with valid transitions" do
-        let(:transitions) { [:start, :fail, :succeed] }
-
-        its(:transitions) { is_expected.to eq([:start, :fail, :succeed]) }
-      end
-
-      context "with extra transitions" do
-        let(:transitions) { [:start, :succeed] }
-
-        it { is_expected_to_raise(Foobara::StateMachine::ExtraTransitions) }
-      end
-
-      context "with missing transitions" do
-        let(:transitions) { [:start, :fail, :succeed, :extra] }
-
-        it { is_expected_to_raise(Foobara::StateMachine::MissingTransitions) }
-      end
-    end
-
-    describe ".states_that_can_perform" do
-      it "returns the expected states allowed to perform the given transition" do
-        expect(state_machine_class.states_that_can_perform(:start)).to eq([:unexecuted])
-      end
-    end
-  end
-end

data/projects/typesystem/spec/state_machine/target_attribute_spec.rb

@@ -1,46 +0,0 @@
-RSpec.describe Foobara::StateMachine do
-  let(:state_machine_class) do
-    stub_class "SomeStateMachine", described_class
-    SomeStateMachine.set_transition_map(transition_map)
-    SomeStateMachine
-  end
-
-  let(:transition_map) do
-    {
-      unexecuted: {
-        start: :running
-      },
-      running: {
-        fail: :failed,
-        succeed: :succeeded,
-        reset: :unexecuted
-      }
-    }
-  end
-
-  context "when embedded in another class and utilizing its target_attribute feature" do
-    let(:some_class) do
-      state_machine_class
-
-      stub_class("SomeClass") do
-        attr_accessor :state
-
-        def state_machine
-          @state_machine ||= SomeStateMachine.new(owner: self, target_attribute: :state)
-        end
-      end
-    end
-
-    it "reads/writes to the owner's state attribute" do
-      some_object = some_class.new
-
-      expect(some_object.state).to be_nil
-      expect(some_object.state_machine.owner).to eq(some_object)
-      expect(some_object.state_machine.target_attribute).to eq(:state)
-      expect(some_object.state_machine.current_state).to eq(:unexecuted)
-      some_object.state_machine.start!
-      expect(some_object.state).to eq(:running)
-      expect(some_object.state_machine.current_state).to eq(:running)
-    end
-  end
-end

data/projects/typesystem/spec/support/rubyprof.rb

@@ -1,32 +0,0 @@
-RSpec.configure do |config|
-  # TODO: move this to foobara-spec-helpers project
-  config.around(:each, :profile) do |example|
-    require "ruby-prof"
-    RubyProf.start
-
-    example.run
-
-    result = RubyProf.stop
-    printer = RubyProf::GraphHtmlPrinter.new(result)
-    File.open("tmp/profile-out.html", "w+") do |file|
-      printer.print(file)
-    end
-  end
-
-  if ENV["RUBY_PROF"] == "true"
-    config.before(:suite) do
-      require "ruby-prof"
-      require "ruby-prof/profile"
-      RubyProf.start
-    end
-
-    config.after(:suite) do
-      result = RubyProf.stop
-
-      printer = RubyProf::GraphHtmlPrinter.new(result)
-      File.open("tmp/profile-out.html", "w+") do |file|
-        printer.print(file)
-      end
-    end
-  end
-end

data/projects/typesystem/spec/support/term_trap.rb

@@ -1,6 +0,0 @@
-# Convenient whenever running into an infinite loop
-Signal.trap("TERM") do
-  puts "SIGTERM received, printing backtrace:"
-  puts caller.join("\n")
-  exit
-end

data/projects/typesystem/spec/type_declarations/attributes_spec.rb

@@ -1,14 +0,0 @@
-RSpec.describe Foobara::TypeDeclarations::Attributes do
-  describe ".reject" do
-    let(:type) do
-      Foobara::GlobalDomain.foobara_type_from_declaration(foo: :integer)
-    end
-    let(:type_declaration) { type.declaration_data }
-
-    context "when nothing changes" do
-      it "gives back the same hash" do
-        expect(described_class.reject(type_declaration, :bar)).to eq(type_declaration)
-      end
-    end
-  end
-end

data/projects/typesystem/spec/type_declarations/attributes_transformer_spec.rb

@@ -1,95 +0,0 @@
-RSpec.describe Foobara::AttributesTransformers do
-  after { Foobara.reset_alls }
-
-  let(:from_type_declaration) do
-    {
-      foo: :string,
-      bar: :string,
-      baz: :string
-    }
-  end
-
-  let(:from_value) do
-    {
-      foo: "foo",
-      bar: "bar",
-      baz: "baz"
-    }
-  end
-
-  let(:direction) { :from }
-
-  describe ".only" do
-    let(:attributes_transformer_class) { described_class.only(*only) }
-    let(:attributes_transformer) { attributes_transformer_class.new(direction => from_type_declaration) }
-    let(:only) { [:foo, :bar] }
-    let(:to_value) { attributes_transformer.process_value!(from_value) }
-
-    it "removes attributes other than what is passed to only" do
-      expect(to_value).to eq(foo: "foo", bar: "bar")
-    end
-
-    context "when direction is to instead of from" do
-      let(:direction) { :to }
-      let(:from_value) do
-        {
-          foo: "foo",
-          bar: "bar"
-        }
-      end
-
-      it "removes attributes other than what is passed to only" do
-        expect(to_value).to eq(foo: "foo", bar: "bar")
-      end
-    end
-
-    context "when only matches all attributes" do
-      let(:only) { [:foo, :bar, :baz] }
-
-      it "is a no-op" do
-        expect(to_value).to eq(from_value)
-      end
-    end
-  end
-
-  describe ".reject" do
-    let(:attributes_transformer_class) { described_class.reject(*reject) }
-    let(:attributes_transformer) { attributes_transformer_class.new(direction => from_type_declaration) }
-    let(:reject) { [:baz] }
-    let(:to_value) { attributes_transformer.process_value!(from_value) }
-
-    it "removes attributes that are specified in reject" do
-      expect(to_value).to eq(foo: "foo", bar: "bar")
-    end
-
-    context "when direction is to instead of from" do
-      let(:direction) { :to }
-      let(:from_value) do
-        {
-          foo: "foo",
-          bar: "bar"
-        }
-      end
-
-      it "removes attributes other than what is passed to only" do
-        expect(to_value).to eq(foo: "foo", bar: "bar")
-      end
-    end
-
-    context "when rejecting multiple attributes" do
-      let(:reject) { [:bar, :baz] }
-
-      it "removes all specified attributes" do
-        expect(to_value).to eq(foo: "foo")
-      end
-    end
-
-    context "when rejecting all attributes" do
-      let(:reject) { [:foo, :bar, :baz] }
-
-      it "returns an empty hash" do
-        expect(to_value).to eq({})
-      end
-    end
-  end
-end

data/projects/typesystem/spec/type_declarations/dsl/attributes_spec.rb

@@ -1,107 +0,0 @@
-RSpec.describe Foobara::TypeDeclarations::Dsl::Attributes do
-  describe ".to_declaration" do
-    it "creates the expected declaration" do
-      declaration = described_class.to_declaration do
-        first_name :string, :required
-        age :integer, "User's age", min: 0
-        nested do
-          foo [:integer]
-          bar :float, default: 1.0
-        end
-        array_of_attributes :array do
-          timestamp :datetime
-        end
-      end
-
-      expect(declaration.declaration_data).to eq(
-        type: :attributes,
-        element_type_declarations: {
-          first_name: :string,
-          age: { type: :integer, min: 0, description: "User's age" },
-          nested: {
-            type: :attributes,
-            element_type_declarations: {
-              foo: [:integer],
-              bar: :float
-            },
-            defaults: {
-              bar: 1.0
-            }
-          },
-          array_of_attributes: {
-            type: :array,
-            element_type_declaration: {
-              type: :attributes,
-              element_type_declarations: {
-                timestamp: :datetime
-              }
-            }
-          }
-        },
-        required: [:first_name]
-      )
-
-      type = Foobara::Domain.current.foobara_type_from_declaration(declaration)
-
-      expect(type).to be_a(Foobara::Types::Type)
-
-      value = type.process_value!(
-        first_name: "John",
-        age: "30",
-        nested: { foo: [1, "2"] },
-        array_of_attributes: [
-          { timestamp: 1_707_520_958 },
-          { timestamp: 1_707_520_959 }
-        ]
-      )
-
-      expect(value).to eq(
-        first_name: "John",
-        age: 30,
-        nested: { foo: [1, 2], bar: 1.0 },
-        array_of_attributes: [
-          { timestamp: Time.parse("2024-02-09 23:22:38 +0000") },
-          { timestamp: Time.parse("2024-02-09 23:22:39 +0000") }
-        ]
-      )
-    end
-
-    context "when accidentally creating an attribute due to calling a method that doesn't exist" do
-      it "raises an informative error" do
-        expect {
-          described_class.to_declaration do
-            attribute not_an_attribute(:asdf).whatever, description: "should fail"
-          end
-        }.to raise_error(Foobara::TypeDeclarations::Dsl::BadAttributeError)
-      end
-
-      context "when attribute doesn't have a type" do
-        it "raises an informative error" do
-          expect {
-            described_class.to_declaration do
-              attribute not_an_attribute, description: "should fail"
-            end
-          }.to raise_error(Foobara::TypeDeclarations::Dsl::NoTypeGivenError)
-        end
-      end
-    end
-
-    context "when declaring sub-attributes via hash" do
-      it "assumes you are trying to create an attribute whose type is attributes" do
-        declaration = described_class.to_declaration do
-          foo bar: :string
-        end
-
-        expect(declaration.declaration_data).to eq(
-          element_type_declarations: {
-            foo: {
-              element_type_declarations: { bar: :string },
-              type: :attributes
-            }
-          },
-          type: :attributes
-        )
-      end
-    end
-  end
-end

data/projects/typesystem/spec/type_declarations/handlers/extend_registered_type_declaration_spec.rb

@@ -1,13 +0,0 @@
-RSpec.describe Foobara::TypeDeclarations::Handlers::ExtendRegisteredTypeDeclaration do
-  let(:handler) { described_class.instance }
-
-  describe "#applicable?" do
-    subject { handler.applicable?(Foobara::TypeDeclaration.new(type_declaration)) }
-
-    context "when passed what looks like a registered type declaration" do
-      let(:type_declaration) { { type: :some_random_type } }
-
-      it { is_expected.to be(false) }
-    end
-  end
-end