foobara 0.5.10 → 0.6.2

data/projects/entities/spec/entity/weak_object_set_spec.rb

@@ -1,91 +0,0 @@
-RSpec.describe Foobara::WeakObjectSet do
-  after { set.close }
-
-  let(:set) { described_class.new(key_method) }
-  let(:key_method) { nil }
-
-  describe "auto-removal of garbage collected records" do
-    context "without key_method" do
-      it "automatically removes records that have been garbage collected" do
-        some_object = "asdf"
-        set << some_object
-
-        # Deleting this line breaks the spec for mysterious reasons. Without this line, GC.start doesn't
-        # call the finalizer for "asdf" for some reason until the end of the test suite.
-        # It looks like when these finalizers run is not guaranteed so it might be a bad idea to
-        # test the behavior as if it were. Will leave this test here for now but might need to delete it if
-        # it acts up in other environments.
-        expect(set.size).to eq(1)
-
-        # rubocop:disable Lint/UselessAssignment
-        some_object = nil
-        # rubocop:enable Lint/UselessAssignment
-        GC.start
-
-        expect(set.size).to eq(0)
-        expect(set).to be_empty
-      end
-    end
-
-    context "with key_method passed in" do
-      let(:some_class) do
-        stub_class "Foo" do
-          attr_accessor :bar
-        end
-      end
-      let(:key_method) { :bar }
-
-      it "automatically removes records that have been garbage collected" do
-        some_object = some_class.new.tap { |o| o.bar = "asdf" }
-        some_object_id = some_object.object_id
-        set << some_object
-
-        expect(set).to_not be_empty
-        expect(set.size).to eq(1)
-        expect(set.find_by_key("asdf").object_id).to eq(some_object.object_id)
-        expect(set[some_object_id].object_id).to be(some_object.object_id)
-
-        expect(set.to_a.map(&:object_id)).to eq([some_object_id])
-
-        # rubocop:disable Lint/UselessAssignment
-        some_object = nil
-        # rubocop:enable Lint/UselessAssignment
-        GC.start
-
-        expect(set).to be_empty
-        expect(set.size).to eq(0)
-        expect(set.to_a).to eq([])
-      end
-
-      describe "#<<" do
-        context "when key is unset" do
-          it "can no longer find the object by the old key" do
-            some_object = some_class.new.tap { |o| o.bar = "asdf" }
-            some_object_id = some_object.object_id
-            set << some_object
-
-            expect(set.find_by_key("asdf").object_id).to eq(some_object.object_id)
-
-            some_object.bar = nil
-            set << some_object
-
-            expect(set.find_by_key("asdf")).to be_nil
-            expect(set[some_object]).to eq(some_object)
-            expect(set[some_object_id]).to eq(some_object)
-          end
-        end
-      end
-    end
-  end
-
-  describe "#delete" do
-    it "removes the object being deleted" do
-      some_object = "asdf"
-      set << some_object
-
-      expect {
-        set.delete(some_object)
-      }.to change { set.member?(some_object) }.from(true).to(false)
-    end
-  end
-end

data/projects/entities/spec/model/model_spec.rb

@@ -1,135 +0,0 @@
-RSpec.describe Foobara::Model do
-  after do
-    Foobara.reset_alls
-    [
-      :SomeModel,
-      :SomeEntity,
-      :Foo
-    ].each do |const|
-      Object.send(:remove_const, const) if Object.const_defined?(const)
-    end
-  end
-
-  let(:model_class) do
-    stub_class("SomeModel", described_class) do
-      attributes do
-        name :string, :required
-        age :integer, :required
-      end
-    end
-  end
-  let(:model_instance) { model_class.new(name:, age:) }
-  let(:name) { "foo" }
-  let(:age) { 100 }
-
-  it "can be mutated" do
-    expect {
-      model_instance.age += 1
-    }.to change(model_instance, :age).by(1)
-  end
-
-  describe "ignore unexpected attributes option" do
-    let(:outer_model_class) do
-      inner = model_class
-
-      stub_class("OuterModel", described_class) do
-        attributes do
-          inner_model inner, :required
-        end
-      end
-    end
-
-    it "ignores unexpected attributes" do
-      attributes = { inner_model: { age: 100, name: "foo", height: 100 } }
-
-      value = outer_model_class.new(attributes)
-      expect(value).to_not be_valid
-
-      value = outer_model_class.new(attributes, ignore_unexpected_attributes: true)
-      expect(value).to be_valid
-
-      expect(value.inner_model.attributes.keys).to contain_exactly(:age, :name)
-    end
-  end
-
-  describe ".deanonymize_class" do
-    let(:type_declaration) do
-      {
-        type: :model,
-        name: model_name,
-        attributes_declaration:,
-        model_module:
-      }
-    end
-    let(:model_name) { "SomeEntity" }
-    let(:model_module) { nil }
-    let(:attributes_declaration) do
-      {
-        foo: { type: :integer, max: 10 },
-        pk: { type: :integer },
-        bar: { type: :string, required: true }
-      }
-    end
-    let(:model_type) do
-      Foobara::Domain.current.foobara_type_from_declaration(type_declaration)
-    end
-    let(:model_class) do
-      model_type.target_class
-    end
-
-    it "deanonymizes the class" do
-      expect(model_class).to be_a(Class)
-      expect(model_class.superclass).to be(described_class)
-      expect(model_class.name).to be_nil
-      expect(model_class.foobara_name).to eq("SomeEntity")
-
-      described_class.deanonymize_class(model_class)
-
-      expect(model_class.name).to eq(model_name)
-
-      # allowed to call it twice...
-      expect(described_class.deanonymize_class(model_class)).to be(model_class)
-    end
-
-    context "with a model module that doesn't exist" do
-      let(:model_module) { "Foo::Bar::Baz" }
-
-      it "deanonymizes the class" do
-        expect(model_class).to be_a(Class)
-        expect(model_class.superclass).to be(described_class)
-        expect(model_class.name).to be_nil
-
-        described_class.deanonymize_class(model_class)
-
-        expect(model_class.name).to eq("Foo::Bar::Baz::SomeEntity")
-      end
-    end
-
-    context "when a module already exists with the desired model name" do
-      let(:model_module) { "Foo::Bar" }
-      let(:model_name) { "SomeModel" }
-
-      before do
-        Foobara::Util.make_module_p("Foo::Bar::SomeModel", tag: true)
-
-        stub_const("Foo::Bar::SomeModel::SOME_CONST", "some_const")
-      end
-
-      after do
-        if Object.const_defined?(:Foo)
-          Object.send(:remove_const, :Foo)
-        end
-      end
-
-      it "upgrades the module to a class and copies over the constants" do
-        expect(Foo::Bar::SomeModel).to be_a(Module)
-        expect(Foo::Bar::SomeModel).to_not be_a(Class)
-
-        described_class.deanonymize_class(model_class)
-
-        expect(Foo::Bar::SomeModel).to be_a(Class)
-        expect(Foo::Bar::SomeModel::SOME_CONST).to eq("some_const")
-      end
-    end
-  end
-end

data/projects/entities/spec/model/types_spec.rb

@@ -1,397 +0,0 @@
-RSpec.describe Foobara::Model do
-  after do
-    Foobara.reset_alls
-  end
-
-  describe ".delegate_attribute" do
-    let(:auth_user_class) do
-      stub_class(:AuthUser, described_class) do
-        attributes do
-          username :string, :required
-          email :string
-        end
-      end
-    end
-    let(:user_class) do
-      auth_user
-
-      stub_class(:User, described_class) do
-        attributes do
-          auth_user AuthUser, :required
-          some_attribute :integer
-        end
-      end.tap do |klass|
-        klass.delegate_attribute(:username, [:auth_user, :username], writer:)
-      end
-    end
-
-    let(:writer) { nil }
-    let(:auth_user) { auth_user_class.new(username:, email:) }
-    let(:username) { "Basil" }
-    let(:email) { "basil@foobara.org" }
-
-    let(:user) { user_class.new(auth_user:) }
-
-    let(:manifest) { user_class.model_type.foobara_manifest }
-
-    context "when defining models using classes" do
-      it "creates a reader" do
-        expect(user.username).to eq(username)
-        expect(user).to_not respond_to("username=")
-        expect(user).to_not respond_to(email)
-      end
-
-      it "contains the delegated attribute in the attributes_type" do
-        expect(manifest[:attributes_type][:element_type_declarations][:username]).to eq(:string)
-      end
-
-      it "includes the delegate info in the manifest" do
-        expect(manifest[:delegates]).to eq(
-          username: {
-            data_path: "auth_user.username"
-          },
-          guaranteed_to_exist: [:username]
-        )
-
-        expect(manifest[:declaration_data][:delegates]).to eq(
-          username: {
-            data_path: "auth_user.username"
-          }
-        )
-      end
-
-      context "when creating writer method" do
-        let(:writer) { true }
-
-        it "creates a writer" do
-          expect(user.username).to eq(username)
-          expect(user).to respond_to("username=")
-          expect(user).to_not respond_to(email)
-
-          expect {
-            user.username = "Barbara"
-          }.to change(user, :username).to("Barbara")
-        end
-
-        it "includes the delegate info in the manifest" do
-          expect(manifest[:delegates]).to eq(
-            username: {
-              data_path: "auth_user.username",
-              writer: true
-            },
-            guaranteed_to_exist: [:username]
-          )
-
-          expect(manifest[:declaration_data][:delegates]).to eq(
-            username: {
-              data_path: "auth_user.username",
-              writer: true
-            }
-          )
-        end
-      end
-    end
-
-    context "when defining models using type declarations" do
-      let(:auth_user_declaration) do
-        {
-          type: :model,
-          name: "AuthUser",
-          attributes_declaration: {
-            type: :attributes,
-            element_type_declarations: {
-              username: { type: :string },
-              email: { type: :string }
-            },
-            required: [:username]
-          },
-          delegates: {}
-        }
-      end
-
-      let(:user_declaration) do
-        {
-          type: :model,
-          name: "User",
-          attributes_declaration: {
-            type: :attributes,
-            element_type_declarations: {
-              auth_user: { type: :AuthUser }
-            },
-            required: [:auth_user]
-          },
-          delegates:
-        }
-      end
-
-      let(:delegates) do
-        { username: { data_path: "auth_user.username", writer: } }
-      end
-
-      let(:auth_user_class) do
-        Foobara::Domain.current.foobara_type_from_declaration(auth_user_declaration).target_class
-      end
-
-      let(:user_class) do
-        auth_user_class
-        Foobara::Domain.current.foobara_type_from_declaration(user_declaration).target_class
-      end
-
-      it "creates anonymous classes" do
-        expect(auth_user_class.name).to be_nil
-        expect(user_class.name).to be_nil
-      end
-
-      it "creates a reader" do
-        expect(user.username).to eq(username)
-        expect(user).to_not respond_to("username=")
-        expect(user).to_not respond_to(email)
-      end
-
-      it "includes the delegate info in the manifest" do
-        expect(manifest[:delegates]).to eq(
-          username: {
-            data_path: "auth_user.username"
-          },
-          guaranteed_to_exist: [:username]
-        )
-
-        expect(manifest[:declaration_data][:delegates]).to eq(
-          username: {
-            data_path: "auth_user.username"
-          }
-        )
-      end
-
-      context "when delegates is invalid" do
-        context "when it is not a hash" do
-          let(:delegates) { "not a hash" }
-
-          it "cannot create the type" do
-            expect {
-              user_class
-            }.to raise_error(
-              Foobara::TypeDeclarations::Handlers::ExtendModelTypeDeclaration::DelegatesValidator::InvalidDelegatesError
-            )
-          end
-        end
-
-        context "when it has a bad key" do
-          let(:delegates) do
-            { username: { data_path: "auth_user.username", bad_key: 100 } }
-          end
-
-          it "cannot create the type" do
-            expect {
-              user_class
-            }.to raise_error(
-              Foobara::TypeDeclarations::Handlers::ExtendModelTypeDeclaration::DelegatesValidator::InvalidDelegatesError
-            )
-          end
-        end
-      end
-
-      context "when creating writer method" do
-        let(:writer) { true }
-
-        it "creates a writer" do
-          expect(user.username).to eq(username)
-          expect(user).to respond_to("username=")
-          expect(user).to_not respond_to(email)
-
-          expect {
-            user.username = "Barbara"
-          }.to change(user, :username).to("Barbara")
-        end
-
-        it "includes the delegate info in the manifest" do
-          expect(manifest[:delegates]).to eq(
-            username: {
-              data_path: "auth_user.username",
-              writer: true
-            },
-            guaranteed_to_exist: [:username]
-          )
-
-          expect(manifest[:declaration_data][:delegates]).to eq(
-            username: {
-              data_path: "auth_user.username",
-              writer: true
-            }
-          )
-        end
-      end
-    end
-  end
-
-  describe ".private_attribute" do
-    let(:auth_user_class) do
-      stub_class(:AuthUser, described_class) do
-        attributes do
-          username :string, :required
-          email :string
-          ssn :string
-        end
-
-        private_attribute(:ssn)
-      end
-    end
-    let(:user_class) do
-      auth_user
-
-      stub_class(:User, described_class) do
-        attributes do
-          auth_user AuthUser, :required, :private
-          some_attribute :integer
-        end
-
-        delegate_attribute(:username, :auth_user)
-      end
-    end
-
-    let(:auth_user) { auth_user_class.new(username:, email:) }
-    let(:username) { "Basil" }
-    let(:email) { "basil@foobara.org" }
-    let(:some_attribute) { 100 }
-
-    let(:user) { user_class.new(auth_user:, some_attribute:) }
-
-    let(:manifest) { user_class.model_type.foobara_manifest }
-
-    context "when defining models using classes" do
-      it "hides the private attribute" do
-        expect(user.username).to eq(username)
-        expect(user.some_attribute).to eq(100)
-        expect(user).to_not respond_to("username=")
-        expect(user).to_not respond_to(:auth_user)
-        expect(user_class.private_attribute_names).to eq([:auth_user])
-        expect(auth_user).to_not respond_to(:ssn)
-      end
-
-      it "contains the private attribute in the manifest" do
-        expect(manifest[:private]).to eq([:auth_user])
-      end
-    end
-
-    context "with bad private attribute" do
-      context "with a non-existent attribute name" do
-        let(:user_declaration) do
-          {
-            type: :model,
-            name: "User",
-            attributes_declaration: {
-              type: :attributes,
-              element_type_declarations: {
-                name: :string,
-                password: :string
-              },
-              required: [:name, :password]
-            },
-            private: [:some_invalid_attribute]
-          }
-        end
-
-        it "cannot create the type" do
-          expect {
-            Foobara::Domain.current.foobara_type_from_declaration(user_declaration)
-          }.to raise_error(
-            Foobara::TypeDeclarations::Handlers::ExtendModelTypeDeclaration::
-                ValidAttributeNames::InvalidPrivateValueGivenError
-          )
-        end
-      end
-
-      context "with a non-string/symbol" do
-        let(:user_declaration) do
-          {
-            type: :model,
-            name: "User",
-            attributes_declaration: {
-              type: :attributes,
-              element_type_declarations: {
-                name: :string,
-                password: :string
-              },
-              required: [:name, :password]
-            },
-            private: [Object.new]
-          }
-        end
-
-        it "cannot create the type" do
-          expect {
-            Foobara::Domain.current.foobara_type_from_declaration(user_declaration)
-          }.to raise_error(
-            Foobara::TypeDeclarations::Handlers::ExtendModelTypeDeclaration::
-                ArrayWithSymbolicElements::InvalidPrivateValuesGivenError
-          )
-        end
-      end
-    end
-
-    context "when defining models using type declarations" do
-      let(:auth_user_declaration) do
-        {
-          type: :model,
-          name: "AuthUser",
-          attributes_declaration: {
-            type: :attributes,
-            element_type_declarations: {
-              username: { type: :string },
-              email: { type: :string },
-              ssn: { type: :string, private: true }
-            },
-            required: [:username]
-          },
-          delegates: {}
-        }
-      end
-
-      let(:user_declaration) do
-        {
-          type: :model,
-          name: "User",
-          attributes_declaration: {
-            type: :attributes,
-            element_type_declarations: {
-              auth_user: { type: :AuthUser },
-              some_attribute: { type: :integer }
-            },
-            required: [:auth_user]
-          },
-          delegates:,
-          private: ["auth_user"]
-        }
-      end
-
-      let(:delegates) do
-        { username: { data_path: "auth_user.username" } }
-      end
-
-      let(:auth_user_class) do
-        Foobara::Domain.current.foobara_type_from_declaration(auth_user_declaration).target_class
-      end
-
-      let(:user_class) do
-        auth_user_class
-        Foobara::Domain.current.foobara_type_from_declaration(user_declaration).target_class
-      end
-
-      it "creates anonymous classes" do
-        expect(auth_user_class.name).to be_nil
-        expect(user_class.name).to be_nil
-      end
-
-      it "hides the private attribute" do
-        expect(user.username).to eq(username)
-        expect(user.some_attribute).to eq(100)
-        expect(user).to_not respond_to(:auth_user)
-        expect(user_class.private_attribute_names).to eq([:auth_user])
-      end
-
-      it "includes the private attribute name in the manifest" do
-        expect(manifest[:private]).to eq([:auth_user])
-      end
-    end
-  end
-end

data/projects/entities/spec/nested_transactionable/nested_transactionable_spec.rb

@@ -1,67 +0,0 @@
-RSpec.describe Foobara::NestedTransactionable do
-  before do
-    Foobara::Persistence.default_crud_driver = Foobara::Persistence::CrudDrivers::InMemory.new
-  end
-
-  after { Foobara.reset_alls }
-
-  let(:entity_class) do
-    stub_class("SomeEntity", Foobara::Entity) do
-      attributes do
-        id :integer
-        foo :string, :required
-      end
-      primary_key :id
-    end
-  end
-
-  let(:type) do
-    Foobara::Domain.current.foobara_type_from_declaration(SomeEntity)
-  end
-
-  describe ".with_needed_transactions_for_type" do
-    it "opens needed transactions for the given type" do
-      entity_class
-
-      expect {
-        described_class.with_needed_transactions_for_type(type) do
-          SomeEntity.create(foo: "foo")
-        end
-      }.to change {
-        SomeEntity.transaction { SomeEntity.count }
-      }
-    end
-
-    context "when type doesn't depend on any entity classes" do
-      let(:type) { Foobara::BuiltinTypes[:integer] }
-
-      it "returns the result of the block without opening transactions" do
-        expect(described_class.with_needed_transactions_for_type(type) { 100 }).to eq(100)
-      end
-    end
-
-    context "when there's an error" do
-      let(:some_error_class) do
-        stub_class("SomeError", StandardError)
-      end
-
-      it "rolls back the transaction" do
-        entity_class
-
-        expect {
-          begin
-            described_class.with_needed_transactions_for_type(type) do
-              SomeEntity.create(foo: "foo")
-              expect(SomeEntity.count).to eq(1)
-              raise some_error_class
-            end
-          rescue SomeError
-            nil
-          end
-        }.to_not change {
-          SomeEntity.transaction { SomeEntity.count }
-        }
-      end
-    end
-  end
-end

data/projects/entities/spec/persistence/entity_attributes_crud_drivers/in_memory_minimal_spec.rb

@@ -1,13 +0,0 @@
-require "foobara/spec_helpers/it_behaves_like_a_crud_driver"
-
-# rubocop:disable RSpec/EmptyExampleGroup
-RSpec.describe Foobara::Persistence::CrudDrivers::InMemoryMinimal do
-  after { Foobara.reset_alls }
-
-  before do
-    Foobara::Persistence.default_crud_driver = described_class.new
-  end
-
-  it_behaves_like_a_crud_driver
-end
-# rubocop:enable RSpec/EmptyExampleGroup