foobara 0.2.7 → 0.4.1

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

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

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

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

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

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