foobara 0.5.10 → 0.6.2

data/projects/entities/spec/persistence/entity_base/transaction_spec.rb

@@ -1,509 +0,0 @@
-RSpec.describe Foobara::Persistence::EntityBase::Transaction do
-  before do
-    Foobara::Persistence.default_crud_driver = Foobara::Persistence::CrudDrivers::InMemory.new
-  end
-
-  after do
-    Foobara.reset_alls
-  end
-
-  let(:entity_class) do
-    stub_class("SomeEntity", Foobara::Entity) do
-      attributes pk: :integer,
-                 foo: :integer,
-                 bar: :symbol
-
-      primary_key :pk
-    end
-  end
-
-  describe ".transaction" do
-    it "can create, load, and update records" do
-      expect {
-        entity_class.create(foo: 1, bar: :baz)
-      }.to raise_error(Foobara::Persistence::EntityBase::Transaction::NoCurrentTransactionError)
-
-      transaction = nil
-
-      entity1 = entity_class.transaction do |tx|
-        transaction = tx
-
-        entity = entity_class.create(foo: 1, bar: :baz)
-
-        expect(entity).to be_a(entity_class)
-        expect(entity).to_not be_persisted
-        expect(entity).to_not be_loaded
-
-        expect(tx).to be_open
-        expect(Foobara::Persistence.current_transaction(entity)).to be(tx)
-
-        entity
-      end
-
-      expect(transaction).to be_closed
-      expect(Foobara::Persistence.current_transaction(entity1)).to be_nil
-
-      expect(entity1).to be_a(entity_class)
-      expect(entity1).to be_persisted
-      expect(entity1).to be_loaded
-
-      entity_class.transaction do
-        entity = entity_class.thunk(entity1.primary_key)
-
-        expect(entity).to be_a(entity_class)
-        expect(entity).to be_persisted
-        expect(entity).to_not be_loaded
-
-        expect(entity.bar).to eq(:baz)
-
-        expect(entity).to be_loaded
-
-        singleton = entity_class.thunk(entity.primary_key)
-        expect(singleton).to be(entity)
-
-        entity.bar = "bazbaz"
-      end
-
-      entity_class.transaction do
-        entity = Foobara::Persistence.current_transaction(entity_class).load(entity_class, entity1.primary_key)
-        expect(entity.bar).to eq(:bazbaz)
-
-        expect(entity_class.all.to_a).to eq([entity1])
-      end
-    end
-
-    it "can rollback" do
-      entity1 = entity_class.transaction do
-        entity_class.create(foo: 10, bar: :baz)
-      end
-
-      entity_class.transaction do |tx|
-        entity = entity_class.thunk(entity1.primary_key)
-        expect(entity.foo).to eq(10)
-
-        entity.foo = 20
-
-        expect(entity.foo).to eq(20)
-
-        begin
-          tx.rollback!
-        rescue Foobara::Persistence::EntityBase::Transaction::RolledBack # rubocop:disable Lint/SuppressedException
-        end
-
-        expect(entity.foo).to eq(10)
-
-        entity_class.transaction do
-          expect(entity_class.load(entity.primary_key).foo).to eq(10)
-        end
-
-        expect {
-          entity.foo = 20
-        }.to raise_error(Foobara::Persistence::EntityBase::Transaction::NoCurrentTransactionError)
-      end
-
-      entity_class.transaction do |tx|
-        entity = entity_class.load(entity1.primary_key)
-        entity = entity_class.load(entity.primary_key)
-        expect(entity.foo).to eq(10)
-
-        entity.foo = 20
-
-        expect(entity.foo).to eq(20)
-
-        tx.flush!
-
-        expect(entity.foo).to eq(20)
-
-        entity.foo = 30
-
-        tx.revert!
-
-        expect(entity.foo).to eq(20)
-      end
-
-      entity_class.transaction do
-        entity = entity_class.load(entity1.primary_key)
-        expect(entity.foo).to eq(20)
-      end
-    end
-
-    it "can hard delete" do
-      entity_class.transaction do
-        expect(entity_class.all.to_a).to be_empty
-        entity = entity_class.create(foo: 10, bar: :baz)
-        expect(entity_class.all.to_a).to eq([entity])
-        entity.hard_delete!
-        expect(entity_class.all.to_a).to be_empty
-      end
-
-      entity1 = entity_class.transaction do
-        expect(entity_class.all.to_a).to be_empty
-        entity_class.create(foo: 10, bar: :baz)
-      end
-
-      entity_class.transaction do
-        entity = entity_class.thunk(entity1.primary_key)
-        expect(entity.foo).to eq(10)
-
-        entity.hard_delete!
-
-        expect(entity).to be_hard_deleted
-
-        # TODO: make this work without needing to call #to_a
-        expect(entity_class.all.to_a).to be_empty
-
-        expect {
-          entity.foo = 20
-        }.to raise_error(Foobara::Entity::CannotUpdateHardDeletedRecordError)
-
-        expect(entity.foo).to eq(10)
-
-        entity.restore!
-
-        entity.foo = 20
-      end
-
-      entity_class.transaction do
-        # TODO: make calling #to_a not necessary
-        expect(entity_class.all.to_a).to eq([entity1])
-        entity = entity_class.thunk(entity1.primary_key)
-
-        expect(entity).to be_persisted
-        expect(entity).to_not be_hard_deleted
-        expect(entity.foo).to eq(20)
-
-        entity.hard_delete!
-
-        expect(entity_class.all.to_a).to be_empty
-        expect(entity).to be_hard_deleted
-      end
-
-      entity_class.transaction do
-        expect {
-          entity_class.load(entity1.primary_key)
-          # TODO: come up with a more sensible error
-        }.to raise_error(Foobara::Entity::NotFoundError)
-
-        expect(entity_class.all.to_a).to be_empty
-      end
-    end
-
-    describe "#hard_delete_all" do
-      it "deletes everything" do
-        entities = []
-
-        entity_class.transaction do
-          4.times do
-            entity = entity_class.create(foo: 1, bar: :baz)
-            entities << entity
-          end
-
-          # TODO: make calling #to_a not necessary
-          expect(entity_class.all.to_a).to eq(entities)
-        end
-
-        entity_ids = entities.map(&:primary_key)
-
-        expect(entity_ids).to contain_exactly(1, 2, 3, 4)
-
-        entity_class.transaction do
-          entities = []
-
-          entity_class.all do |record|
-            entities << record
-          end
-
-          entity_ids = entities.map(&:primary_key)
-
-          expect(entity_ids).to contain_exactly(1, 2, 3, 4)
-
-          4.times do
-            entity = entity_class.create(foo: 1, bar: :baz)
-            entities << entity
-          end
-
-          expect(entity_class.all).to match_array(entities)
-
-          Foobara::Persistence.current_transaction(entities.first).hard_delete_all!(entity_class)
-
-          expect(entities).to all be_hard_deleted
-          expect(entity_class.all.to_a).to be_empty
-        end
-
-        entity_class.transaction do
-          expect(entity_class.all.to_a).to be_empty
-        end
-      end
-    end
-
-    describe "#truncate" do
-      it "deletes everything" do
-        entity_class.transaction do
-          4.times do
-            entity_class.create(foo: 1, bar: :baz)
-          end
-
-          # TODO: make calling #to_a not necessary
-          expect(entity_class.count).to eq(4)
-        end
-
-        entity_class.transaction do
-          expect(entity_class.count).to eq(4)
-
-          Foobara::Persistence.current_transaction(entity_class).truncate!
-
-          expect(entity_class.count).to eq(0)
-          expect(entity_class.all.to_a).to be_empty
-        end
-
-        entity_class.transaction do
-          expect(entity_class.count).to eq(0)
-          expect(entity_class.all.to_a).to be_empty
-        end
-      end
-    end
-
-    describe "#load_many" do
-      it "loads many" do
-        entities = nil
-        entity_ids = nil
-
-        entity_class.transaction do |tx|
-          [
-            { foo: 11, bar: :baz },
-            { foo: 22, bar: :baz },
-            { foo: 33, bar: :baz },
-            { foo: 44, bar: :baz }
-          ].map do |attributes|
-            entity_class.create(attributes)
-          end
-
-          expect(entity_class.count).to eq(4)
-
-          entity_class.transaction(mode: :use_existing) do
-            expect(entity_class.count).to eq(4)
-          end
-
-          tx2 = entity_class.transaction(mode: :use_existing)
-
-          tx2.perform do
-            expect(entity_class.count).to eq(4)
-          end
-
-          entity_class.transaction(mode: :open_nested) do
-            expect(entity_class.count).to eq(0)
-          end
-
-          tx.flush!
-
-          entity_class.transaction(mode: :use_existing) do
-            expect(entity_class.count).to eq(4)
-          end
-
-          entity_class.transaction(mode: :open_nested) do
-            expect(entity_class.count).to eq(4)
-          end
-
-          entities = entity_class.all
-
-          expect(entities).to all be_a(Foobara::Entity)
-          expect(entities.size).to eq(4)
-
-          entity_ids = entities.map(&:primary_key)
-          expect(entity_ids).to contain_exactly(1, 2, 3, 4)
-        end
-
-        entity_class.transaction do
-          entity_class.load_many([entity_class.thunk(1)])
-          loaded_entities = entity_class.load_many(entity_ids)
-          expect(loaded_entities).to all be_loaded
-          expect(loaded_entities).to eq(entities)
-        end
-      end
-    end
-
-    describe "#all_exist?" do
-      it "answers whether they all exist or not" do
-        entity_class.transaction do
-          expect(entity_class.all_exist?([101, 102])).to be(false)
-
-          [
-            { foo: 11, bar: :baz, pk: 101 },
-            { foo: 22, bar: :baz, pk: 102 },
-            { foo: 33, bar: :baz },
-            { foo: 44, bar: :baz }
-          ].map do |attributes|
-            entity_class.create(attributes)
-          end
-
-          entity_class.all do |record|
-            expect(record).to_not be_persisted
-          end
-
-          expect(entity_class.all_exist?([101, 102])).to be(true)
-          expect(entity_class.all_exist?([1, 2, 101, 102])).to be(false)
-        end
-
-        entity_class.transaction do
-          expect(entity_class.all_exist?([1, 2, 101, 102])).to be(true)
-          expect(entity_class.all_exist?([3])).to be(false)
-        end
-      end
-    end
-
-    describe "#unhard_delete!" do
-      context "when record was dirty when hard deleted" do
-        it "is still dirty" do
-          entity = entity_class.transaction do
-            entity_class.create(foo: 11, bar: :baz)
-          end
-
-          entity_class.transaction do
-            entity = entity_class.thunk(entity.primary_key)
-
-            expect(entity).to be_persisted
-
-            expect(entity).to_not be_dirty
-
-            entity.foo = 12
-
-            expect(entity).to be_dirty
-            expect(entity).to_not be_hard_deleted
-
-            entity.foo = 11
-
-            expect(entity).to_not be_dirty
-            expect(entity).to_not be_hard_deleted
-
-            entity.foo = 12
-
-            expect(entity).to be_dirty
-            expect(entity).to_not be_hard_deleted
-
-            entity.hard_delete!
-
-            expect(entity).to be_dirty
-            expect(entity).to be_hard_deleted
-
-            entity.unhard_delete!
-
-            expect(entity).to be_dirty
-            expect(entity).to_not be_hard_deleted
-          end
-        end
-      end
-    end
-
-    describe "#exists?" do
-      it "answers it exists or not" do
-        entity_class.transaction do
-          expect(entity_class.all_exist?([101, 102])).to be(false)
-
-          entity_class.create(foo: 11, bar: :baz, pk: 101)
-
-          expect(entity_class.exists?(101)).to be(true)
-
-          entity_class.create(foo: 11, bar: :baz)
-
-          expect(entity_class.exists?(1)).to be(false)
-        end
-
-        entity_class.transaction do
-          expect(entity_class.exists?(101)).to be(true)
-
-          expect(entity_class.exists?(1)).to be(true)
-          expect(entity_class.exists?(2)).to be(false)
-        end
-      end
-    end
-
-    context "when creating a record with an already-in-use key" do
-      it "explodes" do
-        entity_class.transaction do
-          entity_class.create(foo: 11, bar: :baz, pk: 101)
-        end
-
-        expect {
-          entity_class.transaction do
-            entity_class.create(foo: 11, bar: :baz, pk: 101)
-          end
-        }.to raise_error(Foobara::Persistence::EntityAttributesCrudDriver::Table::CannotInsertError)
-      end
-    end
-
-    context "when restoring with a created record" do
-      it "hard deletes it" do
-        entity_class.transaction do |tx|
-          record = entity_class.create(foo: 11, bar: :baz, pk: 101)
-
-          tx.revert!
-
-          expect(record).to be_hard_deleted
-        end
-
-        entity_class.transaction do
-          expect(entity_class.count).to eq(0)
-        end
-      end
-    end
-
-    context "when persisting entity with an association" do
-      let(:aggregate_class) do
-        stub_class "SomeAggregate", Foobara::Entity do
-          attributes pk: :integer,
-                     foo: :integer,
-                     some_entities: [SomeEntity]
-
-          primary_key :pk
-        end
-      end
-
-      it "writes the records to disk using primary keys" do
-        some_entity2 = nil
-
-        some_entity1 = entity_class.transaction do
-          some_entity2 = entity_class.create(foo: 11, bar: :baz)
-          entity_class.create(foo: 11, bar: :baz, pk: 101)
-        end
-
-        entity_class.transaction do
-          some_entity3 = entity_class.create(foo: 11, bar: :baz, pk: 102)
-          some_entity4 = entity_class.create(foo: 11, bar: :baz)
-
-          aggregate_class.create(
-            foo: 30,
-            some_entities: [
-              1,
-              some_entity1,
-              some_entity3,
-              some_entity4
-            ]
-          )
-        end
-
-        entity_class.transaction do |tx|
-          raw_records = aggregate_class.current_transaction_table.entity_attributes_crud_driver_table.records
-          expect(raw_records.size).to eq(1)
-          raw_record = raw_records[1]
-          expect(raw_record[:some_entities]).to contain_exactly(1, 2, 101, 102)
-
-          loaded_aggregate = aggregate_class.load(1)
-          expect(loaded_aggregate.some_entities).to all be_a(SomeEntity)
-          expect(loaded_aggregate.some_entities.map(&:primary_key)).to contain_exactly(1, 2, 101, 102)
-
-          aggregate_class.create(
-            foo: 30,
-            some_entities: [
-              entity_class.create(foo: 11, bar: :baz)
-            ]
-          )
-
-          expect(aggregate_class.contains_associations?).to be(true)
-          expect(entity_class.contains_associations?).to be(false)
-
-          tx.flush!
-        end
-      end
-    end
-  end
-end

data/projects/entities/spec/persistence/entity_base/transaction_table_spec.rb

@@ -1,58 +0,0 @@
-RSpec.describe Foobara::Persistence::EntityBase::TransactionTable do
-  after do
-    Foobara.reset_alls
-  end
-
-  before do
-    Foobara::Persistence.default_crud_driver = Foobara::Persistence::CrudDrivers::InMemory.new
-  end
-
-  let(:user_class) do
-    stub_class "User", Foobara::Entity do
-      attributes id: :integer,
-                 first_name: :string
-      primary_key :id
-    end
-  end
-
-  describe "#load_many" do
-    context "when already loaded" do
-      let!(:user) do
-        user_class.transaction do
-          user_class.create(first_name: "f")
-        end
-      end
-
-      it "just returns the already-loaded record" do
-        user_class.transaction do
-          record = user_class.load(user.id)
-          loaded = user_class.load_many(record)
-
-          expect(loaded).to eq([record])
-          expect(loaded.first).to be_loaded
-        end
-      end
-    end
-  end
-
-  describe "#all" do
-    context "when a thunk is unloaded" do
-      it "still yields the loaded record for that thunk" do
-        user = user_class.transaction do
-          user_class.create(first_name: "Basil")
-        end
-
-        user_class.transaction do |tx|
-          user_class.thunk(user.id)
-
-          transaction_table = tx.table_for(user_class)
-
-          transaction_table.all do |record|
-            expect(record).to be_loaded
-            expect(record.first_name).to eq("Basil")
-          end
-        end
-      end
-    end
-  end
-end

data/projects/entities/spec/persistence/persistence_spec.rb

@@ -1,148 +0,0 @@
-RSpec.describe Foobara::Persistence do
-  after do
-    Foobara.reset_alls
-  end
-
-  describe ".current_transaction_table" do
-    before do
-      described_class.default_crud_driver = Foobara::Persistence::CrudDrivers::InMemory.new
-
-      stub_class :User, Foobara::Entity do
-        attributes id: :integer
-        primary_key :id
-      end
-    end
-
-    it "returns the transaction table" do
-      User.transaction do |tx|
-        table = described_class.current_transaction_table(User)
-        expect(table).to be_a(Foobara::Persistence::EntityBase::TransactionTable)
-        expect(table.transaction).to be(tx)
-      end
-    end
-  end
-
-  describe ".register_base" do
-    context "when using a crud driver that takes args" do
-      let(:crud_driver_class) do
-        stub_class "SomeCrudDriver", Foobara::Persistence::EntityAttributesCrudDriver do
-          attr_accessor :connection_url
-
-          def initialize(connection_url, **)
-            super(**)
-            self.connection_url = connection_url
-          end
-        end
-      end
-
-      it "passes the argument through to the crud driver" do
-        described_class.register_base(
-          crud_driver_class,
-          "some_connection_url",
-          name: "some_base"
-        )
-        base = described_class.bases["some_base"]
-        expect(base.entity_attributes_crud_driver.connection_url).to eq("some_connection_url")
-      end
-    end
-
-    context "when using a table prefix" do
-      let(:user_class) do
-        stub_class :User, Foobara::Entity do
-          attributes id: :integer
-          primary_key :id
-        end
-      end
-
-      let(:driver_class) { Foobara::Persistence::CrudDrivers::InMemory }
-
-      it "registers the base and its crud drivers uses prefixes" do
-        expect {
-          described_class.register_base(driver_class, name: "some_base", table_prefix: "some_prefix")
-        }.to change(described_class.bases, :size).by(1)
-
-        base = described_class.bases["some_base"]
-
-        expect(base).to be_a(Foobara::Persistence::EntityBase)
-
-        table = base.entity_attributes_crud_driver.table_for(user_class)
-
-        expect(table.table_name).to eq("some_prefix_user")
-      end
-    end
-  end
-
-  describe ".sort_bases" do
-    context "with entity classes each with different bases" do
-      let(:entity_class1) do
-        stub_class("Entity1", Foobara::Entity) do
-          attributes do
-            id :integer
-          end
-          primary_key :id
-        end
-      end
-      let(:entity_class2) do
-        stub_class("Entity2", Foobara::Entity) do
-          attributes do
-            id :integer
-            entity1 Entity1
-          end
-          primary_key :id
-        end
-      end
-      let(:entity_class3) do
-        stub_class("Entity3", Foobara::Entity) do
-          attributes do
-            id :integer
-            entity2 Entity2
-          end
-          primary_key :id
-        end
-      end
-      let(:entity_class4) do
-        stub_class("Entity4", Foobara::Entity) do
-          attributes do
-            id :integer
-            entity3 Entity3
-          end
-          primary_key :id
-        end
-      end
-
-      let(:base1) { entity_class1.entity_base }
-      let(:base2) { entity_class2.entity_base }
-      let(:base3) { entity_class3.entity_base }
-      let(:base4) { entity_class4.entity_base }
-      let(:base5) { described_class.register_base(Foobara::Persistence::CrudDrivers::InMemory, name: "Base5") }
-
-      it "can sort the bases as expected" do
-        [
-          entity_class1,
-          entity_class2,
-          entity_class3,
-          entity_class4
-        ].each do |entity_class|
-          base = described_class.register_base(
-            Foobara::Persistence::CrudDrivers::InMemory,
-            name: entity_class.name
-          )
-          described_class.register_entity(base, entity_class)
-        end
-
-        # Without any reason to sort them they will not be sorted so let's create some records
-        described_class.transaction(base1, base2, base3, base4) do
-          entity_class4.create(
-            entity3: entity_class3.create(
-              entity2: entity_class2.create(entity1: entity_class1.create)
-            )
-          )
-        end
-
-        expect(
-          described_class.sort_bases([base3, base4, base5, base1, base2])
-        ).to eq([base4, base3, base2, base1, base5])
-      end
-    end
-  end
-end