foobara 0.2.7 → 0.4.1

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

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

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

@@ -0,0 +1,393 @@
+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"
+          }
+        )
+
+        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
+            }
+          )
+
+          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"
+          }
+        )
+
+        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
+            }
+          )
+
+          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

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

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