foobara 0.5.10 → 0.6.2

data/projects/command_connectors/spec/not_found_error_spec.rb

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

@@ -1,108 +0,0 @@
-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
-    cc = command_class
-    Foobara::CommandConnector.new(default_pre_commit_transformers: described_class) do
-      command cc
-    end
-  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
-      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

@@ -1,118 +0,0 @@
-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
-
-  context "with an auth-mapped method" do
-    let(:command_class) do
-      stub_class("SomeCommand", Foobara::Command) do
-        def self.requires_authentication = true
-      end
-    end
-
-    let(:request) do
-      foo_mapper = Foobara::TypeDeclarations::TypedTransformer.subclass(to: :symbol) { :bar }.instance
-      # TODO: make a block form of this
-      authenticator = Foobara::CommandConnector.to_authenticator(-> { :some_user })
-
-      described_class.new(authenticator:, auth_mappers: { foo: foo_mapper }).tap do |request|
-        request.command_class = command_class
-        request.authenticate
-      end
-    end
-
-    it "can access the auth-mapped method" do
-      expect(request.foo).to eq(:bar)
-    end
-  end
-end

data/projects/command_connectors/spec/serializer_spec.rb

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

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

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

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

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

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

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

@@ -1,56 +0,0 @@
-ENV["FOOBARA_ENV"] = "test"
-
-require "bundler/setup"
-
-if ENV["RUBY_DEBUG"] == "true"
-  require "debug"
-elsif ENV["SKIP_PRY"] != "true" && ENV["CI"] != "true"
-  require "pry"
-  require "pry-byebug" unless ENV["SKIP_BYEBUG"] == "true"
-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"
-# TODO: eliminate this require! We should not depend on entities in this project!
-require "foobara/entities_plumbing"
-
-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
-    threads = Thread.list.reject { |t| t.name == "DEBUGGER__::SESSION@server" }
-    expect(threads.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

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

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