foobara 0.2.7 → 0.4.1

data/projects/command_connectors/spec/not_found_error_spec.rb

@@ -0,0 +1,17 @@
+RSpec.describe Foobara::CommandConnector::NotFoundError do
+  describe "message" do
+    let(:error) { described_class.for("foo") }
+
+    it "mentions the not-found item" do
+      expect(error.message).to eq("Not found: foo")
+    end
+
+    context "when there's no not-found item provided" do
+      let(:error) { described_class.for(nil) }
+
+      it "has a basic not-found message" do
+        expect(error.message).to eq("Not found")
+      end
+    end
+  end
+end

data/projects/command_connectors/spec/pre_commit_transformers/load_atoms_pre_commit_transformer_spec.rb

@@ -0,0 +1,105 @@
+RSpec.describe Foobara::CommandConnectors::Transformers::LoadAtomsPreCommitTransformer do
+  after { Foobara.reset_alls }
+
+  before do
+    crud_driver = Foobara::Persistence::CrudDrivers::InMemory.new
+    Foobara::Persistence.default_crud_driver = crud_driver
+  end
+
+  let(:some_entity_class) do
+    stub_class "SomeEntity", Foobara::Entity do
+      attributes do
+        id :integer
+        foo :string
+        bar :string
+      end
+
+      primary_key :id
+    end
+  end
+  let(:some_model_class) do
+    some_entity_class
+
+    stub_class "SomeModel", Foobara::Model do
+      attributes do
+        some_entity SomeEntity
+        foo :string
+        bar :string
+      end
+    end
+  end
+
+  let(:type) do
+    some_model_class
+
+    Foobara::TypeDeclarations::Dsl::Attributes.to_declaration do
+      some_tuple [:integer, :string, SomeEntity]
+      some_array [{ type: SomeEntity, description: "some random entity" }]
+      some_model SomeModel
+    end
+  end
+
+  let(:value) do
+    some_record_id = some_record.id
+
+    some_entity_class.transaction do
+      {
+        some_tuple: [1, "foo", some_record_id],
+        some_array: [some_record_id],
+        some_model: { some_entity: some_record_id, foo: "foo", bar: "bar" }
+      }
+    end
+  end
+  let(:some_record) do
+    some_entity_class.transaction do
+      some_entity_class.create(foo: "foo", bar: "bar")
+    end
+  end
+  let(:some_other_record) do
+    some_entity_class.transaction do
+      some_entity_class.create(foo: "baz", bar: "baz")
+    end
+  end
+
+  let(:command_class) do
+    inputs_type = type
+    id = some_other_record.primary_key
+
+    stub_class "SomeCommand", Foobara::Command do
+      inputs inputs_type
+      result inputs_type
+
+      define_method :execute do
+        inputs.merge(some_tuple: [*some_tuple[..-2], id])
+      end
+    end
+  end
+
+  let(:command_connector) do
+    Foobara::CommandConnector.new(default_pre_commit_transformers: described_class)
+  end
+
+  let(:transformer) { described_class.new(to: type) }
+
+  describe "#transform" do
+    it "gives what was passed in because we expect this data to be cast where needed" do
+      command_connector.connect(command_class)
+      response = command_connector.run(
+        full_command_name: command_class.full_command_name,
+        inputs: value,
+        action: "run"
+      )
+
+      expect(response).to be_success
+
+      result = response.outcome.result
+
+      expect(result).to eq(
+        some_tuple: [1, "foo", some_other_record],
+        some_array: [some_record],
+        some_model: SomeModel.new(some_entity: some_record, foo: "foo", bar: "bar")
+      )
+      expect(result[:some_array].first).to be_loaded
+    end
+  end
+end

data/projects/command_connectors/spec/request_spec.rb

@@ -0,0 +1,95 @@
+RSpec.describe Foobara::CommandConnector::Request do
+  let(:request) do
+    described_class.new
+  end
+
+  describe "#serializer" do
+    before do
+      request.serializers = serializers
+    end
+
+    context "when there's no serializers" do
+      let(:serializers) { nil }
+
+      it "is nil" do
+        expect(request.serializer).to be_nil
+      end
+    end
+
+    context "when there is a serializer" do
+      let(:serializers) { [:yaml] }
+
+      it "returns the serializer" do
+        expect(request.serializer.process_value!(foo: 1)).to eq("---\n:foo: 1\n")
+      end
+
+      context "when serializer is declared as a class" do
+        let(:serializers) { [Foobara::CommandConnectors::Serializers::YamlSerializer] }
+
+        it "returns the serializer" do
+          expect(request.serializer.process_value!(foo: 1)).to eq("---\n:foo: 1\n")
+        end
+      end
+
+      context "when serializer is an instance" do
+        let(:serializers) { [Foobara::CommandConnectors::Serializers::YamlSerializer.new("some request")] }
+
+        it "returns the serializer" do
+          expect(request.serializer.process_value!(foo: 1)).to eq("---\n:foo: 1\n")
+        end
+      end
+
+      context "when serializer is a proc" do
+        let(:serializers) { [proc { "100" }] }
+
+        it "returns the serializer" do
+          expect(request.serializer.process_value!(foo: 1)).to eq("100")
+        end
+      end
+    end
+
+    context "when there are multiple serializers" do
+      let(:serializers) { [:yaml, :json] }
+
+      it "returns the serializer" do
+        expect(request.serializer.processors.size).to eq(2)
+      end
+    end
+  end
+
+  context "with a ran command" do
+    let(:command_class) do
+      stub_class("SomeCommand", Foobara::Command) do
+        inputs a: :integer
+
+        def execute
+          a * a
+        end
+      end
+    end
+
+    let(:command) { command_class.new(inputs).tap(&:run) }
+    let(:inputs) { { a: 4 } }
+    let(:serializers) { [] }
+
+    before do
+      request.command = command
+      request.serializers = serializers
+    end
+
+    describe "#response_body" do
+      it "gives the response body" do
+        expect(request.error_collection).to be_empty
+        expect(request.response_body).to eq(16)
+      end
+
+      context "with a serializer" do
+        let(:serializers) { [:json] }
+
+        it "gives the response body" do
+          expect(request.response_body).to eq("16")
+        end
+      end
+    end
+  end
+end

data/projects/command_connectors/spec/serializer_spec.rb

@@ -0,0 +1,9 @@
+RSpec.describe Foobara::CommandConnectors::Serializer do
+  describe ".serializer_from_symbol" do
+    it "can find the correct serializer" do
+      expect(
+        described_class.serializer_from_symbol(:yaml)
+      ).to eq(Foobara::CommandConnectors::Serializers::YamlSerializer)
+    end
+  end
+end

data/projects/command_connectors/spec/serializers/aggregate_serializer_spec.rb

@@ -0,0 +1,45 @@
+RSpec.describe Foobara::CommandConnectors::Serializers::AggregateSerializer do
+  after do
+    Foobara.reset_alls
+  end
+
+  before do
+    Foobara::Persistence.default_crud_driver = Foobara::Persistence::CrudDrivers::InMemory.new
+  end
+
+  let(:serializer) { described_class.new }
+  let(:entity_class) do
+    stub_class "SomeEntity", Foobara::Entity do
+      attributes do
+        id :integer
+        foo :string, :required
+        bar :string, :required
+      end
+      primary_key :id
+    end
+  end
+
+  describe "#serialize" do
+    context "when serializing an unloaded thunk" do
+      let(:record) do
+        entity_class.transaction do
+          entity_class.create(foo: "foo", bar: "bar")
+        end
+      end
+
+      it "loads the thunk" do
+        record_id = record.id
+
+        entity_class.transaction do
+          thunk = entity_class.thunk(record_id)
+          expect(thunk).to_not be_loaded
+
+          result = serializer.serialize(thunk)
+
+          expect(thunk).to be_loaded
+          expect(result).to eq(foo: "foo", bar: "bar", id: record_id)
+        end
+      end
+    end
+  end
+end

data/projects/command_connectors/spec/serializers/atomic_serializer_spec.rb

@@ -0,0 +1,68 @@
+RSpec.describe Foobara::CommandConnectors::Serializers::AtomicSerializer do
+  after do
+    Foobara.reset_alls
+  end
+
+  before do
+    Foobara::Persistence.default_crud_driver = Foobara::Persistence::CrudDrivers::InMemory.new
+  end
+
+  let(:serializer) { described_class.new }
+  let(:entity_class) do
+    stub_class "SomeEntity", Foobara::Entity do
+      attributes do
+        id :integer
+        foo :string, :required
+        bar :string, :required
+      end
+      primary_key :id
+    end
+  end
+
+  describe "#serialize" do
+    let(:record) do
+      entity_class.transaction do
+        entity_class.create(foo: "foo", bar: "bar")
+      end
+    end
+
+    context "when serializing an unloaded thunk" do
+      it "loads the thunk" do
+        record_id = record.id
+
+        entity_class.transaction do
+          thunk = entity_class.thunk(record_id)
+          expect(thunk).to_not be_loaded
+
+          result = serializer.serialize(thunk)
+
+          expect(thunk).to be_loaded
+          expect(result).to eq(foo: "foo", bar: "bar", id: record_id)
+        end
+      end
+    end
+
+    context "when serializing a model containing an entity" do
+      let(:model_class) do
+        entity_class
+
+        stub_class "SomeModel", Foobara::Model do
+          attributes do
+            some_entity :SomeEntity, :required
+            name :string, :required
+          end
+        end
+      end
+
+      let(:model_instance) do
+        model_class.new(some_entity: record, name: "some name")
+      end
+
+      it "serializes the entity in an atomic fashion" do
+        result = serializer.serialize(model_instance)
+
+        expect(result).to eq(some_entity: { foo: "foo", bar: "bar", id: record.id }, name: "some name")
+      end
+    end
+  end
+end

data/projects/command_connectors/spec/serializers/entities_to_primary_keys_serializer_spec.rb

@@ -0,0 +1,36 @@
+RSpec.describe Foobara::CommandConnectors::Serializers::EntitiesToPrimaryKeysSerializer do
+  after do
+    Foobara.reset_alls
+  end
+
+  let(:serializer) { described_class.new(detached_to_primary_key:) }
+  let(:object) { detached_entity_class.new(foo: "foo", bar: "bar", id: 100) }
+  let(:detached_entity_class) do
+    stub_class "SomeDetachedEntity", Foobara::DetachedEntity do
+      attributes do
+        id :integer, :required
+        foo :string, :required
+        bar :string, :required
+      end
+      primary_key :id
+    end
+  end
+
+  describe "#serialize" do
+    context "when detached_to_primary_key is true" do
+      let(:detached_to_primary_key) { true }
+
+      it "converts it to its primary key" do
+        expect(serializer.serialize(object)).to eq(100)
+      end
+    end
+
+    context "when detached_to_primary_key is false" do
+      let(:detached_to_primary_key) { false }
+
+      it "converts it to its attributes" do
+        expect(serializer.serialize(object)).to eq(foo: "foo", bar: "bar", id: 100)
+      end
+    end
+  end
+end

data/projects/command_connectors/spec/serializers/json_serializer_spec.rb

@@ -0,0 +1,22 @@
+RSpec.describe Foobara::CommandConnectors::Serializers::JsonSerializer do
+  let(:serializer) { described_class.new("some request") }
+  let(:object) { { foo: "bar" } }
+
+  describe "#serialize" do
+    it "serializes the object to json" do
+      expect(serializer.serialize(object)).to eq('{"foo":"bar"}')
+    end
+  end
+
+  describe "#deserialize" do
+    it "deserializes the object from json" do
+      expect(serializer.deserialize('{"foo":"bar"}')).to eq("foo" => "bar")
+    end
+  end
+
+  describe "#priority" do
+    subject { serializer.priority }
+
+    it { is_expected.to be_a(Integer) }
+  end
+end

data/projects/command_connectors/spec/serializers/noop_serializer_spec.rb

@@ -0,0 +1,22 @@
+RSpec.describe Foobara::CommandConnectors::Serializers::NoopSerializer do
+  let(:serializer) { described_class.new("some request") }
+  let(:object) { "asdf" }
+
+  describe "#serialize" do
+    it "serializes the object to json" do
+      expect(serializer.serialize(object)).to eq(object)
+    end
+  end
+
+  describe "#deserialize" do
+    it "deserializes the object from json" do
+      expect(serializer.deserialize(object)).to eq(object)
+    end
+  end
+
+  describe "#priority" do
+    subject { serializer.priority }
+
+    it { is_expected.to be_a(Integer) }
+  end
+end

data/projects/command_connectors/spec/serializers/yaml_serializer_spec.rb

@@ -0,0 +1,22 @@
+RSpec.describe Foobara::CommandConnectors::Serializers::YamlSerializer do
+  let(:serializer) { described_class.new("some request") }
+  let(:object) { { foo: "bar" } }
+
+  describe "#serialize" do
+    it "serializes the object to yaml" do
+      expect(serializer.serialize(object)).to eq("---\n:foo: bar\n")
+    end
+  end
+
+  describe "#deserialize" do
+    it "deserializes the object from yaml" do
+      expect(serializer.deserialize("---\n:foo: bar\n")).to eq(foo: "bar")
+    end
+  end
+
+  describe "#priority" do
+    subject { serializer.priority }
+
+    it { is_expected.to be_a(Integer) }
+  end
+end

data/projects/command_connectors/spec/spec_helper.rb

@@ -0,0 +1,51 @@
+ENV["FOOBARA_ENV"] = "test"
+
+require "bundler/setup"
+
+unless ENV["SKIP_PRY"] == "true" || ENV["CI"] == "true"
+  require "pry"
+  require "pry-byebug"
+end
+
+require "rspec/its"
+require "simplecov"
+
+SimpleCov.root "#{__dir__}/../../../"
+SimpleCov.command_name "command_connectors"
+SimpleCov.coverage_dir "coverage/command_connectors"
+
+SimpleCov.start do
+  add_filter "spec/support/"
+  # This avoids printing out info about coverage generated by HTTPFormatter
+  formatter Class.new { def format(_result) = nil }
+end
+
+require "foobara/all"
+require "foobara/command_connectors"
+
+RSpec.configure do |config|
+  # Need to do :all instead of :each because for specs that use .around,
+  # .after(:each) do |example| here is called after example.run but before any threads created in
+  # .around might have been cleaned up.
+  config.after(:suite) do
+    expect(Thread.list.size).to eq(1)
+  end
+  config.filter_run_when_matching :focus
+
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.order = :defined
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  # config.raise_errors_for_deprecations!
+end
+
+require "foobara/spec_helpers/all"
+Dir["#{__dir__}/support/**/*.rb"].each { |f| require f }

data/projects/command_connectors/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/command_connectors/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/command_connectors/spec/transformers/entity_to_primary_key_inputs_transformer_spec.rb

@@ -0,0 +1,119 @@
+RSpec.describe Foobara::CommandConnectors::Transformers::EntityToPrimaryKeyInputsTransformer do
+  after { Foobara.reset_alls }
+
+  before do
+    crud_driver = Foobara::Persistence::CrudDrivers::InMemory.new
+    Foobara::Persistence.default_crud_driver = crud_driver
+  end
+
+  let(:some_entity_class) do
+    stub_class "SomeEntity", Foobara::Entity do
+      attributes do
+        id :integer
+        foo :string
+        bar :string
+      end
+
+      primary_key :id
+    end
+  end
+  let(:some_model_class) do
+    some_entity_class
+
+    stub_class "SomeModel", Foobara::Model do
+      attributes do
+        some_entity SomeEntity
+        foo :string
+        bar :string
+      end
+    end
+  end
+
+  let(:type) do
+    some_model_class
+
+    Foobara::TypeDeclarations::Dsl::Attributes.to_declaration do
+      some_tuple [:integer, :string, SomeEntity]
+      some_array [{ type: SomeEntity, description: "some random entity" }]
+      some_model SomeModel
+    end
+  end
+
+  let(:value) do
+    some_record_id = some_record.id
+
+    some_entity_class.transaction do
+      {
+        some_tuple: [1, "foo", some_record_id],
+        some_array: [some_record_id],
+        some_model: { some_entity: some_record_id, foo: "foo", bar: "bar" }
+      }
+    end
+  end
+  let(:some_record) do
+    some_entity_class.transaction do
+      some_entity_class.create(foo: "foo", bar: "bar")
+    end
+  end
+
+  let(:transformer) { described_class.new(to: type) }
+
+  it "gives an expected from_type" do
+    expect(transformer.from_type.declaration_data).to eq(
+      type: :attributes,
+      element_type_declarations: {
+        some_tuple: {
+          type: :tuple,
+          element_type_declarations: [
+            :integer,
+            :string,
+            { type: :integer, description: "SomeEntity id" }
+          ],
+          size: 3
+        },
+        some_array: {
+          type: :array,
+          element_type_declaration: { type: :integer, description: "SomeEntity id : some random entity" }
+        },
+        some_model: {
+          type: :attributes,
+          element_type_declarations: {
+            some_entity: { type: :integer, description: "SomeEntity id" },
+            foo: :string,
+            bar: :string
+          }
+        }
+      }
+    )
+  end
+
+  context "when type has no associations and isn't an entity" do
+    let(:type) { Foobara::BuiltinTypes[:string] }
+
+    it "has a from_type that is the to_type" do
+      expect(transformer.from_type).to eq(transformer.to_type)
+    end
+  end
+
+  describe "#to_type" do
+    context "when it is :allow_nil" do
+      let(:type) do
+        Foobara::GlobalDomain.foobara_type_from_declaration(some_entity_class, :allow_nil)
+      end
+
+      it "carries over the allow_nil processor" do
+        expect(transformer.to_type.declaration_data).to eq(type: :SomeEntity, allow_nil: true)
+      end
+    end
+  end
+
+  describe "#transform" do
+    it "gives what was passed in because we expect this data to be cast where needed" do
+      expect(transformer.transform(value)).to eq(
+        some_tuple: [1, "foo", some_record.id],
+        some_array: [some_record.id],
+        some_model: { some_entity: some_record.id, foo: "foo", bar: "bar" }
+      )
+    end
+  end
+end

data/projects/command_connectors/src/command_connector/commands/describe.rb

@@ -4,8 +4,10 @@ module Foobara
   class CommandConnector
     module Commands
       class Describe < Foobara::Command
-        inputs manifestable: :duck,
-               request: :duck
+        inputs do
+          manifestable :duck, :required
+          request :duck
+        end
         result :associative_array
 
         def execute