foobara 0.3.0 → 0.4.1

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

@@ -0,0 +1,224 @@
+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

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,6 @@
+# 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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,95 @@
+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

@@ -0,0 +1,107 @@
+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

@@ -0,0 +1,13 @@
+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