foobara 0.3.0 → 0.4.1

data/projects/entities/spec/spec_helper.rb

@@ -0,0 +1,52 @@
+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 "entities"
+SimpleCov.coverage_dir "coverage/entities"
+
+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/project"
+require "foobara/delegate"
+require "foobara/builtin_types"
+require "foobara/entity"
+require "foobara/in_memory_crud_driver"
+require "foobara/model_attribute_helpers"
+require "foobara/nested_transactionable"
+
+Foobara.install!
+
+RSpec.configure do |config|
+  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/entities/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/entities/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/entities/spec/type_declarations/sensitive_type_removers_spec.rb

@@ -0,0 +1,90 @@
+RSpec.describe Foobara::TypeDeclarations do
+  after { Foobara.reset_alls }
+
+  describe ".remove_sensitive_types" do
+    let(:strict_type_declaration) do
+      type.declaration_data
+    end
+
+    let(:type_declaration_without_sensitive_types) do
+      described_class.remove_sensitive_types(strict_type_declaration)
+    end
+
+    context "when model/entity/detached entity" do
+      let(:type) do
+        stub_class "SomeModel", Foobara::Model do
+          attributes do
+            foo :string
+            foo2 :string, :sensitive
+          end
+        end
+
+        stub_class("InnerEntity", Foobara::Entity) do
+          attributes do
+            id :integer
+            bar :string
+            bar2 :string, :sensitive
+          end
+          primary_key :id
+        end
+
+        stub_class "InnerDetachedEntity", Foobara::DetachedEntity do
+          attributes do
+            id :integer
+            baz :string
+            baz2 :string, :sensitive
+          end
+          primary_key :id
+        end
+
+        stub_class "OuterEntity", Foobara::Entity do
+          attributes do
+            id :integer
+            foo :string
+            foo2 :string, :sensitive
+            some_inner_entity InnerEntity
+            some_detached_entity InnerDetachedEntity
+            some_model SomeModel
+          end
+          primary_key :id
+        end
+
+        OuterEntity.entity_type
+      end
+
+      it "returns a declaration without sensitive attributes all the way down" do
+        expect(
+          type_declaration_without_sensitive_types[:attributes_declaration][:element_type_declarations]
+        ).to eq(
+          id: :integer,
+          foo: :string,
+          some_inner_entity: :InnerEntity,
+          some_detached_entity: :InnerDetachedEntity,
+          some_model: :SomeModel
+        )
+      end
+
+      context "when subclass of an entity" do
+        let(:type) do
+          stub_class "SubEntity", super().target_class
+
+          SubEntity.entity_type
+        end
+
+        it "returns a declaration without sensitive attributes all the way down" do
+          expect(type.target_class).to eq(SubEntity)
+          expect(SubEntity.superclass).to eq(OuterEntity)
+          expect(
+            type_declaration_without_sensitive_types[:attributes_declaration][:element_type_declarations]
+          ).to eq(
+            id: :integer,
+            foo: :string,
+            some_inner_entity: :InnerEntity,
+            some_detached_entity: :InnerDetachedEntity,
+            some_model: :SomeModel
+          )
+        end
+      end
+    end
+  end
+end

data/projects/manifest/lib/foobara/manifest.rb

@@ -2,3 +2,5 @@ module Foobara
   module Manifest
   end
 end
+
+Foobara.project("manifest", project_path: "#{__dir__}/../..")

data/projects/manifest/spec/manifest_spec.rb

@@ -0,0 +1,378 @@
+RSpec.describe Foobara::Manifest do
+  after do
+    Foobara.reset_alls
+  end
+
+  before do
+    Foobara::Persistence.default_crud_driver = Foobara::Persistence::CrudDrivers::InMemory.new
+
+    stub_module :SomeOrg do
+      foobara_organization!
+    end
+
+    stub_module :SomeOtherDomain do
+      foobara_domain!
+    end
+
+    stub_class "SomeOtherDomain::SomeDetachedEntity", Foobara::DetachedEntity do
+      attributes do
+        id :integer, :required
+        foo :string, :required
+        bar :string, :required
+      end
+      primary_key :id
+    end
+
+    stub_class "SomeOtherDomain::SomeOtherUser", Foobara::Entity do
+      attributes do
+        id :integer
+        first_name :string, :allow_nil
+        some_detached_entity SomeOtherDomain::SomeDetachedEntity, :required
+      end
+      primary_key :id
+    end
+
+    stub_module("SomeOrg::SomeDomain") do
+      foobara_domain!
+      foobara_depends_on "SomeOtherDomain"
+    end
+
+    stub_module "SomeOrg::SomeDomain::Types"
+
+    stub_class "SomeOrg::SomeDomain::Types::Address", Foobara::Model do
+      attributes do
+        street :string
+        city :string
+        state :string
+        zip :string
+      end
+    end
+
+    stub_class "SomeOrg::SomeDomain::User", Foobara::Entity do
+      attributes do
+        id :integer
+        name :string, :required
+        phone :string, :allow_nil
+        ratings [:integer], default: []
+        junk :associative_array, value_type_declaration: :array
+        address SomeOrg::SomeDomain::Types::Address
+      end
+
+      primary_key :id
+    end
+
+    stub_class "SomeOrg::SomeDomain::Referral", Foobara::Entity do
+      attributes do
+        id :integer
+        user SomeOrg::SomeDomain::User
+        channel :string
+      end
+
+      primary_key :id
+    end
+
+    stub_class "SomeOrg::SomeDomain::QueryUser", Foobara::Command
+    stub_class "SomeOrg::SomeDomain::QueryUser::SomethingWentWrongError", Foobara::RuntimeError do
+      class << self
+        def context_type_declaration
+          {}
+        end
+      end
+    end
+
+    SomeOrg::SomeDomain::QueryUser.class_eval do
+      inputs user: SomeOrg::SomeDomain::User,
+             some_other_user: SomeOtherDomain::SomeOtherUser
+      result :User
+
+      load_all
+
+      possible_error SomeOrg::SomeDomain::QueryUser::SomethingWentWrongError
+    end
+
+    stub_class "SomeOrg::SomeDomain::QueryReferral", Foobara::Command do
+      inputs id: :integer
+      result :Referral
+    end
+
+    stub_class "GlobalError", Foobara::RuntimeError do
+      class << self
+        def context_type_declaration
+          {}
+        end
+      end
+    end
+
+    stub_class "GlobalCommand", Foobara::Command do
+      possible_error GlobalError
+    end
+
+    stub_class "CommandWithNoPossibleErrors", Foobara::Command do
+      def execute
+      end
+    end
+  end
+
+  let(:manifest) { Foobara::Manifest::RootManifest.new(raw_manifest) }
+  let(:raw_manifest) do
+    Foobara::TypeDeclarations.with_manifest_context(include_processors: true) do
+      Foobara.manifest
+    end
+  end
+  let(:raw_stringified_manifest) { Foobara::Util.deep_stringify_keys(raw_manifest) }
+
+  it "is a Manifest" do
+    integer = Foobara::Manifest::Type.new(raw_manifest, [:type, :integer])
+    string = Foobara::Manifest::Type.new(raw_manifest, [:type, :string])
+
+    expect(integer).to be_builtin
+
+    expect(manifest).to be_a(Foobara::Manifest::RootManifest)
+    expect(manifest.detached_entities).to be_an(Array)
+    expect(manifest.lookup_path(:command, :does_not_exist)).to be_nil
+    expect(manifest.lookup(:does_not_exist)).to be_nil
+    expect(manifest.global_domain).to be_global
+    expect(manifest.scoped_category).to be_nil
+    expect(manifest.parent).to be_nil
+
+    domain = manifest.domain_by_name("SomeOrg::SomeDomain")
+    expect(domain.full_domain_name).to eq("SomeOrg::SomeDomain")
+    expect(domain).to be_a(Foobara::Manifest::Domain)
+    expect(domain.scoped_category).to eq(:domain)
+    expect(manifest.domains).to include(domain)
+    expect(domain.domain_name).to eq("SomeDomain")
+
+    expect(domain.organization).to_not be_global
+    expect(domain).to_not be_global
+
+    entity = manifest.entity_by_name("SomeOrg::SomeDomain::User")
+
+    expect(entity).to be_a(Foobara::Manifest::Entity)
+    expect(entity.full_type_name).to eq("SomeOrg::SomeDomain::User")
+    expect(entity.full_entity_name).to eq("SomeOrg::SomeDomain::User")
+    expect(entity.primary_key_name).to eq("id")
+
+    expect(entity.relevant_manifest[:base_type]).to eq(:entity)
+    expect(entity).to_not have_associations
+
+    detached_entity = manifest.detached_entity_by_name("SomeOtherDomain::SomeDetachedEntity")
+    expect(detached_entity).to be_a(Foobara::Manifest::DetachedEntity)
+    expect(detached_entity.full_type_name).to eq("SomeOtherDomain::SomeDetachedEntity")
+    expect(detached_entity.full_detached_entity_name).to eq("SomeOtherDomain::SomeDetachedEntity")
+    expect(detached_entity.primary_key_name).to eq("id")
+    expect(detached_entity).to_not have_associations
+    expect(detached_entity).to be_detached_entity
+    Foobara::Manifest::TypeDeclaration.new(raw_manifest, [*detached_entity.manifest_path, :declaration_data])
+    some_other_domain = manifest.domain_by_name("SomeOtherDomain")
+    #     expect(declaration.to_type).to be_detached_entity
+    expect(some_other_domain.detached_entities).to include(detached_entity)
+    some_other_user = manifest.type_by_name("SomeOtherDomain::SomeOtherUser")
+    detached_entity_declaration = some_other_user.attributes_type.attribute_declarations[:some_detached_entity]
+    expect(detached_entity_declaration).to be_detached_entity
+    expect(detached_entity_declaration.to_detached_entity).to be_detached_entity
+    expect(detached_entity_declaration.to_type).to be_detached_entity
+
+    expect(entity.primary_key_type.to_type).to eq(integer)
+    expect(entity.types_depended_on).to include(integer)
+    expect(entity.scoped_category).to eq(:type)
+    expect(entity.parent).to eq(domain)
+    expect(manifest.entities).to include(entity)
+
+    expect(entity.target_class).to eq("SomeOrg::SomeDomain::User")
+    expect(entity.entity_manifest).to be_a(Hash)
+    expect(entity.type_manifest).to be_a(Hash)
+    expect(entity.attribute_names).to contain_exactly("name", "ratings", "junk", "phone", "address")
+
+    expect(manifest.types).to include(entity)
+    expect(entity.organization.types).to include(entity)
+    expect(entity.to_type_declaration_from_declaration_data.name).to eq("User")
+
+    attributes = entity.attributes_type
+    expect(attributes).to be_a(Foobara::Manifest::TypeDeclaration)
+    expect(attributes).to_not be_reference
+    expect(attributes).to_not be_primitive
+    expect(attributes.attribute_declarations[:id]).to be_reference
+    expect(attributes.attribute_declarations[:id]).to be_primitive
+    expect(attributes.attribute_declarations[:address]).to be_reference
+    expect(attributes.attribute_declarations[:address]).to_not be_primitive
+
+    expect(attributes).to_not be_custom
+    expect(attributes.scoped_category).to be_nil
+    expect(attributes.parent).to be_nil
+    expect(attributes).to be_a(Foobara::Manifest::Attributes)
+    expect(attributes.required?("name")).to be(true)
+    expect(attributes.required?("ratings")).to be(false)
+    expect(attributes.required).to eq([:name])
+    expect(attributes.attribute_declarations[:ratings]).to be_array
+    expect(attributes.attribute_declarations[:ratings].element_type.type).to eq(:integer)
+    expect(attributes.attribute_declarations[:phone].allows_nil?).to be(true)
+    expect(attributes.has_attribute_declarations?).to be(true)
+
+    attribute = attributes.attribute_declarations[:ratings]
+    expect(attribute).to be_attribute
+    expect(attribute.parent_attributes).to eq(attributes)
+    expect(attribute.attribute_name).to eq(:ratings)
+    expect(attribute).to_not be_required
+    expect(attribute.default).to eq([])
+
+    new_attributes = Foobara::Manifest::TypeDeclaration.new(attributes.root_manifest, attributes.manifest_path)
+    expect(new_attributes).to be_a(Foobara::Manifest::Attributes)
+    expect(new_attributes).to be_attributes
+    expect(new_attributes).to eql(attributes)
+    expect(new_attributes.hash).to eql(attributes.hash)
+
+    entity_with_associations = manifest.entity_by_name("SomeOrg::SomeDomain::Referral")
+    expect(entity_with_associations).to have_associations
+
+    expect(entity_with_associations.associations[:user]).to eq(entity)
+
+    expect(
+      entity_with_associations.attributes_type.attribute_declarations[:user].type_symbol
+    ).to eq(:"SomeOrg::SomeDomain::User")
+
+    model = manifest.model_by_name("SomeOrg::SomeDomain::Types::Address")
+
+    expect(model).to be_a(Foobara::Manifest::Model)
+    expect(model.model?).to be(true)
+    expect(entity.attributes_type.attribute_declarations[:address].to_model).to eq(model)
+
+    expect(model.types_depended_on).to include(string)
+    expect(model.scoped_category).to eq(:type)
+    expect(model.parent).to eq(domain)
+    expect(manifest.models).to include(model)
+
+    expect(model.target_class).to eq("SomeOrg::SomeDomain::Types::Address")
+    expect(model.model_manifest).to be_a(Hash)
+    expect(model.type_manifest).to be_a(Hash)
+    expect(model.attribute_names).to contain_exactly("street", "city", "state", "zip")
+
+    expect(manifest.types).to include(model)
+    expect(model.organization.types).to include(model)
+    expect(model.has_associations?).to be(false)
+    expect(model.type_name).to eq("Types::Address")
+
+    attributes = model.attributes_type
+    expect(attributes.scoped_category).to be_nil
+    expect(attributes.parent).to be_nil
+    expect(attributes).to be_a(Foobara::Manifest::Attributes)
+    expect(attributes.attribute_declarations[:street].type).to eq(:string)
+    expect(attributes.sensitive).to be_falsey
+    expect(attributes.sensitive_exposed).to be_falsey
+
+    command = manifest.command_by_name("SomeOrg::SomeDomain::QueryUser")
+
+    expect(command).to be_a(Foobara::Manifest::Command)
+    expect(command.scoped_category).to eq(:command)
+    expect(command.parent_category).to eq(:domain)
+    expect(command.parent_name).to eq("SomeOrg::SomeDomain")
+    expect(command.parent).to eq(domain)
+    expect(command.requires_authentication?).to be false
+    expect(command.command_name).to eq("QueryUser")
+    expect(manifest.commands).to include(command)
+    expect(command.command_manifest).to be_a(Hash)
+    expect(command.inputs_type).to be_a(Foobara::Manifest::Attributes)
+    expect(command.inputs_type.required).to be_nil
+    command = Foobara::Manifest::Command.new(raw_stringified_manifest, command.manifest_path)
+    expect(command.inputs_type.required).to be_nil
+    some_other_user_declaration = command.inputs_type.attribute_declarations[:some_other_user]
+    expect(command.domain.find_type(some_other_user_declaration)).to be_a(Foobara::Manifest::Entity)
+    expect(command.types_depended_on).to include(entity)
+    expect(command.inputs_types_depended_on).to include(entity)
+    expect(command.result_types_depended_on).to include(entity)
+    expect(command.errors_types_depended_on).to include(
+      Foobara::Manifest::Type.new(raw_manifest, [:type, :attributes])
+    )
+
+    type_declaration = command.result_type
+    expect(type_declaration.type).to eq(:"SomeOrg::SomeDomain::User")
+    expect(type_declaration.type_declaration_manifest).to eq(:"SomeOrg::SomeDomain::User")
+    expect(type_declaration.to_entity).to be_a(Foobara::Manifest::Entity)
+    expect(type_declaration.to_entity.scoped_category).to eq(:type)
+    expect(type_declaration).to_not be_sensitive
+
+    global_domain = Foobara::Manifest::Domain.new(raw_manifest, [:domain, "global_organization::global_domain"])
+
+    global_command = manifest.command_by_name("GlobalCommand")
+    expect(global_command).to be_a(Foobara::Manifest::Command)
+    expect(global_command.full_command_name).to eq("GlobalCommand")
+    expect(global_command.result_type).to be_nil
+    expect(global_command.scoped_category).to eq(:command)
+    expect(global_command.parent).to eq(global_domain)
+    expect(global_command.domain).to eq(manifest.global_domain)
+    expect(global_command.scoped_full_name).to eq("GlobalCommand")
+    expect(global_command.domain.reference).to eq("global_organization::global_domain")
+    expect(global_command.organization).to eq(manifest.global_organization)
+    expect(global_command.inputs_type).to be_empty
+
+    foobara_possible_error = command.possible_errors["data.cannot_cast"]
+    expect(foobara_possible_error.scoped_category).to be_nil
+    expect(foobara_possible_error.parent).to be_nil
+    expect(foobara_possible_error._path).to eq([])
+    expect(foobara_possible_error.processor_manifest_data).to be_a(Hash)
+    expect(foobara_possible_error.manually_added).to be_falsey
+
+    foobara_error = foobara_possible_error.error
+    expect(foobara_error).to be_a(Foobara::Manifest::Error)
+    expect(foobara_error.full_error_name).to eq("Foobara::Value::Processor::Casting::CannotCastError")
+    expect(foobara_error.short_error_name).to eq("CannotCastError")
+    expect(foobara_error.scoped_category).to eq(:error)
+    expect(foobara_error.parent).to eq(
+      Foobara::Manifest::ProcessorClass.new(
+        raw_manifest,
+        [:processor_class, "Foobara::Value::Processor::Casting"]
+      )
+    )
+    expect(foobara_error.error_manifest).to be_a(Hash)
+    expect(foobara_error.symbol).to be_a(Symbol)
+    expect(foobara_error.organization.scoped_full_name).to eq("Foobara")
+    expect(foobara_error.domain.scoped_full_name).to eq("Foobara::Value")
+    expect(foobara_error.scoped_full_name).to eq("Foobara::Value::Processor::Casting::CannotCastError")
+    expect(foobara_error.error_name).to eq("CannotCastError")
+    expect(manifest.errors).to include(foobara_error)
+    expect(foobara_error.abstract).to be_falsey
+
+    local_possible_error = command.possible_errors["runtime.something_went_wrong"]
+    expect(local_possible_error.scoped_category).to be_nil
+    expect(local_possible_error.parent).to be_nil
+    local_error = local_possible_error.error
+    expect(local_error).to be_a(Foobara::Manifest::Error)
+    expect(local_error.scoped_category).to eq(:error)
+    expect(local_error.parent).to eq(command)
+    expect(local_error.organization.scoped_full_name).to eq("SomeOrg")
+    expect(local_error.domain.scoped_full_name).to eq("SomeOrg::SomeDomain")
+    expect(local_error.scoped_name).to eq("SomethingWentWrongError")
+    expect(local_error.scoped_full_name).to eq("SomeOrg::SomeDomain::QueryUser::SomethingWentWrongError")
+    expect(local_error.types_depended_on.map(&:name)).to include(:attributes)
+
+    global_error = Foobara::Manifest::Error.new(raw_manifest, [:error, "GlobalError"])
+
+    expect(global_error).to be_a(Foobara::Manifest::Error)
+    expect(global_error.scoped_category).to eq(:error)
+    expect(global_error.parent).to eq(manifest.global_domain)
+    expect(global_error.error_manifest).to be_a(Hash)
+    expect(global_error.symbol).to be_a(Symbol)
+    expect(global_error.organization).to eq(manifest.global_organization)
+    expect(global_error.domain).to eq(manifest.global_domain)
+    expect(global_error.scoped_full_name).to eq("GlobalError")
+    expect(global_error.error_name).to eq("GlobalError")
+
+    # TODO: disable this rubocop rule so we can just check against true
+    expect(manifest).to be_contains("duck::SupportedCasters::AllowNil", :processor_class)
+    processor_class = manifest.lookup_path(:processor_class, :"duck::SupportedCasters::AllowNil")
+    expect(processor_class.full_processor_class_name).to eq("duck::SupportedCasters::AllowNil")
+
+    processor = manifest.lookup("symbol::Casters::string")
+    expect(processor.full_processor_name).to eq("symbol::Casters::string")
+
+    org = manifest.organization_by_name("SomeOrg")
+    expect(org.full_organization_name).to eq("SomeOrg")
+    expect(org).to be_a(Foobara::Manifest::Organization)
+    expect(org.scoped_category).to eq(:organization)
+    expect(org.parent).to be_nil
+    expect(manifest.organizations).to include(org)
+    expect(org.organization_name).to eq("SomeOrg")
+
+    command = manifest.command_by_name("CommandWithNoPossibleErrors")
+    expect(command.possible_errors).to eq({})
+  end
+end

data/projects/manifest/spec/model_spec.rb

@@ -0,0 +1,74 @@
+RSpec.describe Foobara::Manifest do
+  after do
+    Foobara.reset_alls
+  end
+
+  before do
+    Foobara::Persistence.default_crud_driver = Foobara::Persistence::CrudDrivers::InMemory.new
+
+    user_entity
+    some_model
+  end
+
+  let(:manifest) { Foobara::Manifest::RootManifest.new(raw_manifest) }
+  let(:raw_manifest) { Foobara.manifest }
+  let(:user_entity) do
+    stub_class "User", Foobara::Entity do
+      attributes do
+        id :integer
+        first_name :string, :allow_nil
+      end
+      primary_key :id
+    end
+  end
+  let(:model) { manifest.model_by_name("SomeModel") }
+
+  describe "#has_associations?" do
+    subject { model.has_associations? }
+
+    context "when one of its attributes is an entity" do
+      let(:some_model) do
+        stub_class "SomeModel", Foobara::Model do
+          attributes do
+            user User
+          end
+        end
+      end
+
+      it { is_expected.to be(true) }
+    end
+
+    context "when one of its attributes is an array of entities" do
+      let(:some_model) do
+        stub_class "SomeModel", Foobara::Model do
+          attributes do
+            users [User]
+          end
+        end
+      end
+
+      it { is_expected.to be(true) }
+    end
+
+    context "when one of its attributes is a model that has entities in it" do
+      let(:some_other_model) do
+        stub_class "SomeOtherModel", Foobara::Model do
+          attributes do
+            users [User]
+          end
+        end
+      end
+      let(:some_model) do
+        other_model_class = some_other_model
+
+        stub_class "SomeModel", Foobara::Model do
+          attributes do
+            other other_model_class
+          end
+        end
+      end
+
+      it { is_expected.to be(true) }
+    end
+  end
+end

data/projects/manifest/spec/spec_helper.rb

@@ -0,0 +1,50 @@
+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 "manifest"
+SimpleCov.coverage_dir "coverage/manifest"
+
+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"
+
+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 }