foobara 0.3.0 → 0.4.1

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

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

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

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