foobara 0.5.10 → 0.6.2

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

@@ -1,240 +0,0 @@
-RSpec.describe Foobara::Entity do
-  after do
-    Foobara.reset_alls
-  end
-
-  let(:entity_class) do
-    stub_class = ->(klass) { stub_const(klass.name, klass) }
-
-    Class.new(described_class) do
-      class << self
-        def name
-          "SomeEntity"
-        end
-      end
-
-      stub_class.call(self)
-
-      attributes pk: :integer,
-                 foo: :integer,
-                 bar: :symbol
-
-      primary_key :pk
-    end
-  end
-
-  let(:attributes) do
-    {
-      foo: 12,
-      bar: :baz
-    }
-  end
-
-  context "with transaction" do
-    around do |example|
-      Foobara::Persistence.default_crud_driver = Foobara::Persistence::CrudDrivers::InMemory.new
-
-      Foobara::Persistence.default_base.transaction do
-        example.run
-      end
-    end
-
-    before do
-      # TODO: move these checks to a persistence_spec
-      expect(Foobara::Persistence.object_to_base(entity_class)).to eq(Foobara::Persistence.default_base)
-      expect(Foobara::Persistence.object_to_base(:default_entity_base)).to eq(Foobara::Persistence.default_base)
-      expect(Foobara::Persistence.object_to_base("default_entity_base")).to eq(Foobara::Persistence.default_base)
-
-      Foobara::Persistence.transaction(entity_class, mode: :open_new) do
-        loaded_and_persisted_record
-      end
-
-      # TODO: implement a no-transaction-required type of mode
-      unloaded_thunk_record
-      not_persisted_record
-    end
-
-    let(:loaded_and_persisted_record) do
-      entity_class.create(attributes)
-    end
-    let(:unloaded_thunk_record) do
-      entity_class.thunk(pk)
-    end
-    let(:not_persisted_record) do
-      # Just testing some un-tested code with this pointless transaction block...
-      transactions = [Foobara::Persistence.default_base.current_transaction]
-      Foobara::Persistence::EntityBase.using_transactions(transactions) do
-        entity_class.create(attributes)
-      end
-    end
-
-    let(:pk) { loaded_and_persisted_record.pk }
-
-    describe "#loaded? and #persisted?" do
-      it "gives the right answer for various contexts" do
-        expect(loaded_and_persisted_record.pk).to be_an(Integer)
-
-        expect(loaded_and_persisted_record).to be_loaded
-        expect(unloaded_thunk_record).to_not be_loaded
-        expect(not_persisted_record).to_not be_loaded
-
-        expect(loaded_and_persisted_record).to be_persisted
-        expect(unloaded_thunk_record).to be_persisted
-        expect(not_persisted_record).to_not be_persisted
-      end
-    end
-
-    describe "setting primary key" do
-      it "is not allowed unless it's the same" do
-        not_persisted_record.pk = 6
-        expect(not_persisted_record.primary_key).to eq(6)
-
-        expect(loaded_and_persisted_record.primary_key).to eq(1)
-        entity_class.transaction(mode: :use_existing) do
-          record = entity_class.thunk(loaded_and_persisted_record.primary_key)
-          expect(record.primary_key).to eq(1)
-          record.pk = "1"
-          expect(record.primary_key).to eq(1)
-          expect {
-            record.pk = 13
-          }.to raise_error(Foobara::Entity::UnexpectedPrimaryKeyChangeError)
-        end
-      end
-    end
-
-    describe "#write_attribute_without_callbacks!" do
-      it "blows up on invalid values" do
-        record = entity_class.create
-
-        record.write_attribute_without_callbacks!(:foo, 5)
-        expect(record.foo).to eq(5)
-
-        expect {
-          record.write_attribute_without_callbacks!(:foo, "asdf")
-        }.to raise_error(Foobara::Value::Processor::Casting::CannotCastError)
-      end
-    end
-  end
-
-  describe ".model_type.process_value!" do
-    before do
-      Foobara::Persistence.default_crud_driver = Foobara::Persistence::CrudDrivers::InMemory.new
-    end
-
-    context "when record comes from a different closed transaction" do
-      let(:record_from_a_different_transaction) do
-        entity_class.transaction do
-          entity_class.create(attributes)
-        end
-      end
-
-      it "casts it to a new thunk from the current transaction using its primary key" do
-        record_from_a_different_transaction
-
-        cast_value = entity_class.transaction do
-          entity_class.model_type.process_value!(record_from_a_different_transaction)
-        end
-
-        expect(cast_value).to be_a(entity_class)
-        expect(cast_value.pk).to eq(record_from_a_different_transaction.pk)
-        expect(cast_value.object_id).to_not eq(record_from_a_different_transaction.object_id)
-      end
-    end
-  end
-
-  describe "equality methods" do
-    let(:loaded_and_persisted_record) do
-      entity_class.build(attributes.merge(pk:)).tap do |record|
-        record.is_persisted = true
-        record.is_loaded = true
-
-        expect(record).to be_persisted
-        expect(record).to be_loaded
-      end
-    end
-    let(:unloaded_thunk_record) do
-      entity_class.build(pk:)
-    end
-    let(:not_persisted_record) do
-      entity_class.build(attributes)
-    end
-    let(:not_persisted_record_with_pk) do
-      entity_class.build(attributes.merge(pk:))
-    end
-
-    let(:pk) { 10 }
-
-    describe "#== #hash and #eql?" do
-      it "gives the expected result for various scenarios" do
-        # rubocop:disable RSpec/IdenticalEqualityAssertion
-        # ==
-        expect(loaded_and_persisted_record).to eq(loaded_and_persisted_record)
-        expect(unloaded_thunk_record).to eq(unloaded_thunk_record)
-        expect(not_persisted_record).to eq(not_persisted_record)
-        expect(not_persisted_record_with_pk).to eq(not_persisted_record_with_pk)
-
-        expect(loaded_and_persisted_record).to eq(unloaded_thunk_record)
-        expect(loaded_and_persisted_record).to_not eq(not_persisted_record)
-        # Tricky to think of what this comparison should be.
-        # One thought would be that they are not equal and persisting the non-persisted one should result
-        # in an error. But will go with considering them equal for now and maybe revisit.
-        expect(loaded_and_persisted_record).to eq(not_persisted_record_with_pk)
-
-        expect(unloaded_thunk_record).to eq(loaded_and_persisted_record)
-        expect(unloaded_thunk_record).to_not eq(not_persisted_record)
-        expect(unloaded_thunk_record).to eq(not_persisted_record_with_pk)
-
-        expect(not_persisted_record).to_not eq(loaded_and_persisted_record)
-        expect(not_persisted_record).to_not eq(unloaded_thunk_record)
-        expect(not_persisted_record).to_not eq(not_persisted_record_with_pk)
-
-        expect(entity_class.build(attributes.dup)).to_not eq(entity_class.build(attributes.dup))
-
-        # hash
-        expect(loaded_and_persisted_record.hash).to eq(loaded_and_persisted_record.hash)
-        expect(unloaded_thunk_record.hash).to eq(unloaded_thunk_record.hash)
-        expect(not_persisted_record.hash).to eq(not_persisted_record.hash)
-        expect(not_persisted_record_with_pk.hash).to eq(not_persisted_record_with_pk.hash)
-
-        expect(loaded_and_persisted_record.hash).to eq(unloaded_thunk_record.hash)
-        expect(loaded_and_persisted_record.hash).to_not eq(not_persisted_record.hash)
-        expect(loaded_and_persisted_record.hash).to eq(not_persisted_record_with_pk.hash)
-
-        expect(unloaded_thunk_record.hash).to eq(loaded_and_persisted_record.hash)
-        expect(unloaded_thunk_record.hash).to_not eq(not_persisted_record.hash)
-        expect(unloaded_thunk_record.hash).to eq(not_persisted_record_with_pk.hash)
-
-        expect(not_persisted_record.hash).to_not eq(loaded_and_persisted_record.hash)
-        expect(not_persisted_record.hash).to_not eq(unloaded_thunk_record.hash)
-        expect(not_persisted_record.hash).to_not eq(not_persisted_record_with_pk.hash)
-
-        # eql?
-        expect(loaded_and_persisted_record).to eql(loaded_and_persisted_record)
-        expect(unloaded_thunk_record).to eql(unloaded_thunk_record)
-        expect(not_persisted_record).to eql(not_persisted_record)
-        expect(not_persisted_record_with_pk).to eql(not_persisted_record_with_pk)
-
-        expect(loaded_and_persisted_record).to eql(unloaded_thunk_record)
-        expect(loaded_and_persisted_record).to_not eql(not_persisted_record)
-        expect(loaded_and_persisted_record).to eql(not_persisted_record_with_pk)
-
-        expect(unloaded_thunk_record).to eql(loaded_and_persisted_record)
-        expect(unloaded_thunk_record).to_not eql(not_persisted_record)
-        expect(unloaded_thunk_record).to eql(not_persisted_record_with_pk)
-
-        expect(not_persisted_record).to_not eql(loaded_and_persisted_record)
-        expect(not_persisted_record).to_not eql(unloaded_thunk_record)
-        expect(not_persisted_record).to_not eql(not_persisted_record_with_pk)
-
-        expect(entity_class.build(attributes.dup)).to_not eql(entity_class.build(attributes.dup))
-        # rubocop:enable RSpec/IdenticalEqualityAssertion
-      end
-    end
-  end
-
-  describe "#inpsect" do
-    subject { entity_class.build(pk: 5).inspect }
-
-    it { is_expected.to eq("<SomeEntity:5>") }
-  end
-end

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

@@ -1,137 +0,0 @@
-RSpec.describe Foobara::Model do
-  after do
-    Foobara.reset_alls
-    if Object.const_defined?(:User)
-      Object.send(:remove_const, :User)
-    end
-  end
-
-  describe "extending an entity with mutability" do
-    before do
-      Foobara::Persistence.default_crud_driver = Foobara::Persistence::CrudDrivers::InMemory.new
-    end
-
-    let(:entity_declaration_data) do
-      {
-        type: :entity,
-        name: "User",
-        attributes_declaration: {
-          id: { type: :integer },
-          name: { type: :string },
-          age: { type: :integer }
-        },
-        primary_key: :id
-      }
-    end
-    let(:extended_entity_declaration_data) do
-      { type: :User, mutable: [:age] }
-    end
-    let(:entity_type) do
-      Foobara::Domain.global.foobara_type_from_declaration(entity_declaration_data)
-    end
-    let(:extended_entity_type) do
-      Foobara::Domain.global.foobara_type_from_declaration(extended_entity_declaration_data)
-    end
-
-    it "handles an extension properly" do
-      expect(entity_type).to be_a(Foobara::Types::Type)
-
-      described_class.deanonymize_class(entity_type.target_class)
-
-      User.transaction do
-        user = entity_type.process_value!(name: "Fumiko", age: 100)
-        expect(user).to be_a(User)
-        expect(user.mutable).to be true
-
-        extended_user = extended_entity_type.process_value!(name: "Barbara", age: 200)
-        expect(extended_user).to be_a(User)
-        expect(extended_user.mutable).to eq([:age])
-      end
-    end
-
-    context "when adding attributes to an existing entity" do
-      before do
-        entity_type.target_class.class_eval do
-          attributes do
-            email :string, :required
-          end
-        end
-      end
-
-      it "adds the attributes to the existing type" do
-        type = Foobara.foobara_lookup_type(:User)
-        attributes_type = type.element_types
-        expect(attributes_type.element_types.keys).to contain_exactly(:id, :name, :age, :email)
-      end
-    end
-
-    context "when changing an entity's immutability" do
-      it "updates the type's mutable processor declaration data" do
-        entity_type
-        expect {
-          entity_type.target_class.mutable [:age]
-        }.to change { Foobara.foobara_lookup_type(:User).declaration_data[:mutable] }.from(nil).to([:age])
-      end
-    end
-  end
-
-  describe "extending a model with mutability" do
-    let(:model_declaration_data) do
-      {
-        type: :model,
-        name: "User",
-        attributes_declaration: {
-          name: { type: :string },
-          age: { type: :integer }
-        }
-      }
-    end
-    let(:extended_model_declaration_data) do
-      { type: :User, mutable: [:age] }
-    end
-    let(:model_type) do
-      Foobara::Domain.global.foobara_type_from_declaration(model_declaration_data)
-    end
-    let(:extended_model_type) do
-      Foobara::Domain.global.foobara_type_from_declaration(extended_model_declaration_data)
-    end
-
-    it "handles an extension properly" do
-      expect(model_type).to be_a(Foobara::Types::Type)
-      described_class.deanonymize_class(model_type.target_class)
-
-      user = model_type.process_value!(name: "Fumiko", age: 100)
-      expect(user).to be_a(User)
-      expect(user.mutable).to be true
-
-      extended_user = extended_model_type.process_value!(name: "Barbara", age: 200)
-      expect(extended_user).to be_a(User)
-      expect(extended_user.mutable).to eq([:age])
-    end
-
-    context "when adding attributes to an existing model" do
-      before do
-        model_type.target_class.class_eval do
-          attributes do
-            email :string, :required
-          end
-        end
-      end
-
-      it "adds the attributes to the existing type" do
-        type = Foobara.foobara_lookup_type(:User)
-        attributes_type = type.element_types
-        expect(attributes_type.element_types.keys).to contain_exactly(:name, :age, :email)
-      end
-    end
-
-    context "when changing a model's immutability" do
-      it "updates the type's mutable processor declaration data" do
-        model_type
-        expect {
-          model_type.target_class.mutable [:age]
-        }.to change { Foobara.foobara_lookup_type(:User).declaration_data[:mutable] }.from(nil).to([:age])
-      end
-    end
-  end
-end

data/projects/entities/spec/entity/extensions/domain_module_extension_spec.rb

@@ -1,42 +0,0 @@
-RSpec.describe Foobara::Domain::DomainModuleExtension do
-  after do
-    Foobara.reset_alls
-  end
-
-  describe ".foobara_set_entity_base" do
-    context "when using a table prefix" do
-      let(:org) do
-        stub_module("SomeOrg") { foobara_organization! }
-      end
-      let(:domain) do
-        org
-        stub_module("SomeOrg::SomeDomain") { foobara_domain! }
-      end
-      let(:some_entity_class) do
-        domain
-        stub_class("SomeOrg::SomeDomain::SomeEntity", Foobara::Entity) do
-          attributes do
-            id :integer
-            foo :integer
-            bar :symbol
-            created_at :datetime, :allow_nil
-          end
-
-          primary_key :id
-        end
-      end
-      let(:driver_class) { Foobara::Persistence::CrudDrivers::InMemory }
-
-      it "creates a base using the table prefix and uses it for the entities in that domain" do
-        base = domain.foobara_set_entity_base(driver_class, table_prefix: "some_prefix")
-        expect(domain.foobara_default_entity_base).to be(base)
-
-        expect(some_entity_class.entity_base).to be(base)
-
-        expect(
-          base.entity_attributes_crud_driver.table_for(some_entity_class).table_name
-        ).to eq("some_prefix_some_entity")
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-RSpec.describe Foobara::Entity do
-  context "when creating an entity from declaration data" do
-    after do
-      Foobara.reset_alls
-
-      Object.send(:remove_const, :User) if Object.const_defined?(:User)
-    end
-
-    let(:declaration_data) do
-      {
-        type: :entity,
-        name: "User",
-        model_class: "Foo::Bar::Baz::User",
-        model_base_class: "Foobara::Entity",
-        attributes_declaration: {
-          type: :attributes,
-          element_type_declarations: {
-            id: { type: :integer },
-            name: { type: :string }
-          }
-        },
-        primary_key: :id,
-        model_module: "Foo::Bar::Baz",
-        mutable: false
-      }
-    end
-
-    it "creates a model class" do
-      expect(Foobara::GlobalDomain).to_not be_foobara_type_registered("User")
-      Foobara::GlobalDomain.foobara_type_from_strict_stringified_declaration(declaration_data)
-      expect(Foobara::GlobalDomain.foobara_type_registered?("User")).to be true
-    end
-  end
-end

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

@@ -1,243 +0,0 @@
-RSpec.describe Foobara::Entity do
-  # Entity types:
-  #
-  # one-to-one (default for foo: Bar attribute)
-  # one-to-many (default for foo: [Bar] attribute)
-  # many-to-one
-  # many-to-many
-  #
-  # .that_own is for many-to-*
-  # .that_owns is for one-to-*
-  #
-  # To specify many-to-* one must add:
-  #
-  # associations: {
-  #   foo: {
-  #     cardinality: "many-to-one"
-  #   }
-  # }
-  #
-  # otherwise an exception will be thrown from .that_own
-  describe ".that_owns" do
-    after { Foobara.reset_alls }
-
-    before do
-      Foobara::Persistence.default_crud_driver = Foobara::Persistence::CrudDrivers::InMemory.new
-
-      stub_class = ->(klass) { stub_const(klass.name, klass) }
-
-      Class.new(Foobara::Entity) do
-        abstract
-
-        class << self
-          def name
-            "Base"
-          end
-        end
-
-        stub_class.call(self)
-
-        attributes id: :integer
-
-        primary_key :id
-      end
-
-      Class.new(Base) do
-        class << self
-          def name
-            "User"
-          end
-        end
-
-        stub_class.call(self)
-
-        attributes name: { type: :string, required: true }
-      end
-
-      Class.new(Base) do
-        class << self
-          def name
-            "Person"
-          end
-        end
-
-        abstract
-
-        stub_class.call(self)
-
-        attributes user: User
-      end
-
-      Class.new(Person) do
-        class << self
-          def name
-            "Applicant"
-          end
-        end
-
-        stub_class.call(self)
-
-        # TODO: make sure this isn't necessary outside of test suite where name is created later...
-        set_model_type
-      end
-
-      Class.new(Base) do
-        class << self
-          def name
-            "Package"
-          end
-        end
-
-        stub_class.call(self)
-
-        attributes applicants: [Applicant],
-                   is_active: :boolean
-      end
-
-      Class.new(Base) do
-        class << self
-          def name
-            "Assignment"
-          end
-        end
-
-        stub_class.call(self)
-
-        attributes package: Package
-      end
-
-      Class.new(Person) do
-        class << self
-          def name
-            "Employee"
-          end
-        end
-
-        stub_class.call(self)
-
-        attributes assignments: { type: :array, element_type_declaration: Assignment, default: [] },
-                   past_assignments: [Assignment],
-                   priority_assignment: Assignment
-
-        association :past_users, "past_assignments.#.package.applicants.#.user"
-        association :priority_package, :"priority_assignment.package"
-      end
-    end
-
-    it "can find the appropriate records through various that_owns/that_own calls" do
-      expect(Employee.filtered_associations(:Assignment)).to eq(
-        ["assignments.#", "past_assignments.#", "priority_assignment"]
-      )
-
-      User.transaction do
-        applicants = []
-        employees = []
-        packages  = []
-        users = []
-
-        10.times do |i|
-          user = User.create(name: "applicant user#{i}")
-          users << user
-          applicants << Applicant.create(user:)
-        end
-
-        10.times do |i|
-          user = User.create(name: "employee user#{i}")
-          employees << Employee.create(user:)
-        end
-
-        20.times do |i|
-          packages << Package.create(is_active: i < 3, applicants: [applicants[i % 3]])
-        end
-
-        15.times do |i|
-          package = packages[i]
-
-          assignment = Assignment.create(package:)
-
-          if i < 10
-            employees[i % 4].assignments += [assignment]
-
-            if i.even?
-              employees[(i % 4) + 1].assignments += [assignment]
-            end
-          else
-            employees[0].past_assignments ||= []
-            employees[0].past_assignments += [assignment]
-          end
-        end
-
-        employee = Employee.all[0]
-        employee.priority_assignment = employee.assignments.first
-
-        expect(Employee.all[1].past_users).to eq([])
-        expect(Employee.all[0].past_users).to contain_exactly(users[0], users[1], users[2])
-
-        applicant = Applicant.all.first
-        user = applicant.user
-
-        expect(Applicant.that_owns(user)).to be(applicant)
-        expect(Employee.that_owns(users[0], "past_")).to eq(Employee.all.first)
-      end
-
-      employee_id = nil
-      assignment_id = nil
-
-      applicant_id, user_id = User.transaction do
-        a = Applicant.all.first
-        [a.id, a.user.id]
-      end
-
-      user = nil
-
-      User.transaction do
-        expect(Employee.all[1].past_users).to eq([])
-        # TODO: create .first query
-        employee = Employee.all.first
-        employee_id = employee.primary_key
-
-        expect(employee.past_users).to contain_exactly(User.thunk(1), User.thunk(2), User.thunk(3))
-        expect(employee.past_users).to eq(employee.values_at("past_assignments.#.package.applicants.#.user"))
-        assignment_id = employee.past_assignments.first
-        expect(
-          Employee.find_by_attribute_containing(:past_assignments, employee.past_assignments.first)
-        ).to be(employee)
-
-        user = User.thunk(user_id)
-        applicant = Applicant.thunk(applicant_id)
-        expect(Applicant.that_owns(user)).to be(applicant)
-        expect(Applicant.find_all_by_attribute_any_of(:user, user).to_a).to eq([applicant])
-        expect(Employee.that_owns(User.thunk(1), "past_")).to eq(Employee.all.first)
-
-        expect(employee.priority_package).to be_a(Package)
-      end
-
-      # test when it's tracked but not loaded...
-      User.transaction do
-        employee = Employee.thunk(employee_id)
-
-        expect(
-          Employee.find_by_attribute_containing(:assignments, 1)
-        ).to be(employee)
-      end
-
-      User.transaction do
-        # This tests the situation where the records have to be fetched from the database to answer the question
-        # which covers a few lines of code that might not be hit by the above transaction
-        expect(Applicant.find_all_by_attribute_any_of(:user, user).first.id).to eq(applicant_id)
-      end
-      User.transaction do
-        expect(Applicant.that_owns(User.thunk(user_id))).to eq(Applicant.thunk(applicant_id))
-      end
-
-      User.transaction do
-        expect(
-          Employee.find_by_attribute_containing(:past_assignments, assignment_id).primary_key
-        ).to be(employee_id)
-        expect(User.find_by_attribute(:name, "applicant user5")).to be(User.thunk(6))
-        expect(User.find_by(name: "applicant user5")).to be(User.thunk(6))
-        expect(User.find_by(name: "does not exist")).to be_nil
-      end
-    end
-  end
-end