Ajustes no gerenciamento de commits e rollbacks em transactions

Testes adicionados para validar a alteração.

Author: Fernando Leal

package-lock.json

@@ -5,14 +5,14 @@
   "main": "./src/index.js",
   "types": "./src/index.d.ts",
   "scripts": {
-    "test": "ts-mocha src/test/**/*.spec.ts",
+    "test": "tsc && ts-mocha src/test/**/*.spec.ts",
     "test-grep": "npm run test -- --grep",
     "test-single": "npm run test-grep -- Mapper --debug-brk",
     "lint": "tslint -p tsconfig.json",
     "build": "tsc",
-    "publish-npm": "tsc & npm publish",
+    "publish-npm": "tsc && npm publish",
     "publish-npm-alpha": "tsc && npm publish --tag alpha",
-    "pack": "cd dist/ & npm pack ../",
+    "pack": "cd dist/ && npm pack ../",
     "ts-mocha": "ts-mocha"
   },
   "dependencies": {
@@ -37,7 +37,7 @@
     "sinon": "^12.0.1",
     "sqlite3": "^5.0.2",
     "ts-mocha": "^9.0.2",
-    "ts-node": "^10.4.0",
+    "ts-node": "^10.7.0",
     "tslint": "^6.1.3",
     "typescript": "^4.6.3"
   },

package.json

@@ -1,5 +1,5 @@
 import { Ddl } from "./../ddl/ddl";
-import { expect } from "chai";
+import { expect } from 'chai';
 import { ObjectToTest } from "./objeto-to-test";
 import { getMapper } from "./mappers-table-new";
 import { Crud } from "../crud";
@@ -8,14 +8,20 @@ import { SQLiteDatabase } from "./database/sqlite-database";
 import { DatabaseObject } from "../definitions";
 import { QueryCompiled } from "../core";
 import { TestClazz } from "./models/test-clazz";
-import { firstValueFrom } from "rxjs";
+import { firstValueFrom, lastValueFrom } from "rxjs";
+import * as sinon from "sinon";
+import { SinonSandbox } from "sinon";
 
 describe("Managed Transaction", () => {
     let crud: Crud;
     let ddl: Ddl;
     let database: DatabaseObject;
 
+    let sandbox: SinonSandbox;
+
     before(async () => {
+        sandbox = sinon.createSandbox();
+
         const mapper = getMapper();
 
         database = await new SQLiteDatabase().init();
@@ -25,14 +31,14 @@ describe("Managed Transaction", () => {
 
     beforeEach(async () => {
         await ddl.create(GuidClazz).execute().toPromise();
+        sandbox.restore();
     });
 
     afterEach(async () => {
         await ddl.drop(GuidClazz).execute().toPromise();
     });
 
     it("Transaction Simple", async () => {
-
         const transaction = database.managedTransaction();
 
         const obj1 = Object.assign({}, ObjectToTest.guidClazz);
@@ -68,7 +74,6 @@ describe("Managed Transaction", () => {
     });
 
     it("Transaction inactive", async () => {
-
         const transaction = database.managedTransaction();
 
         const obj1 = Object.assign({}, ObjectToTest.guidClazz);
@@ -85,13 +90,91 @@ describe("Managed Transaction", () => {
         expect(queryUpdateResult[0].description).to.equal(obj1.description);
         expect(queryUpdateResult[0].guid).to.equal(obj1.guid);
 
-        expect(() => transaction.add(ddl.drop(GuidClazz))).to.throw(`Transaction (id: ${transaction.id}) is no longer active, and can no longer be used`);
+        expect(() => transaction.add(ddl.drop(GuidClazz))).to.throw(`Transaction (id: ${transaction.id}) is no longer active, and can no longer be used. Current status: COMMITTED`);
 
         const deleteResult = await ddl.drop(GuidClazz).execute().toPromise();
         expect(deleteResult.length).to.equal(1);
         expect(deleteResult[0].rowsAffected).to.equal(1);
     });
 
+    it("Transaction two rollback", async () => {
+        const warn = sandbox.spy(console, "warn");
+
+        const transaction = database.managedTransaction();
+
+        const obj1 = Object.assign({}, ObjectToTest.guidClazz);
+        transaction.add(
+            crud
+                .insert(GuidClazz, { toSave: obj1 })
+        );
+
+        // first rollback
+        await transaction.rollback();
+        expect(warn.notCalled).to.true;
+
+        // second rollback
+        await transaction.rollback();
+
+        const expectedWarnTransaction = `Transaction (id: ${transaction.id}) already rollbacked`;
+        sinon.assert.calledWith(warn, expectedWarnTransaction);
+    });
+
+    it("Transaction two commit", async () => {
+        const warn = sandbox.spy(console, "warn");
+
+        const transaction = database.managedTransaction();
+
+        const obj1 = Object.assign({}, ObjectToTest.guidClazz);
+        transaction.add(
+            crud
+                .insert(GuidClazz, { toSave: obj1 })
+        );
+
+        // first commit
+        await lastValueFrom(transaction.commit());
+        expect(warn.notCalled).to.true;
+
+        // second commit
+        await lastValueFrom(transaction.commit());
+
+        const expectedWarnTransaction = `Transaction (id: ${transaction.id}) already committed`;
+        sinon.assert.calledWith(warn, expectedWarnTransaction);
+    });
+
+    it("Transaction a commit and a rollback", async () => {
+        const transaction = database.managedTransaction();
+
+        const obj1 = Object.assign({}, ObjectToTest.guidClazz);
+        transaction.add(
+            crud
+                .insert(GuidClazz, { toSave: obj1 })
+        );
+
+        // commit
+        await lastValueFrom(transaction.commit());
+
+        // rollback
+        await expect(transaction.rollback())
+            .to.rejectedWith(`Transaction (id: ${transaction.id}) is no longer active, and can no longer be used. Current status: COMMITTED`);
+    });
+
+    it("Transaction a rollback and a commit", async () => {
+        const transaction = database.managedTransaction();
+
+        const obj1 = Object.assign({}, ObjectToTest.guidClazz);
+        transaction.add(
+            crud
+                .insert(GuidClazz, { toSave: obj1 })
+        );
+
+        // rollback
+        await transaction.rollback();
+        
+        // commit
+        await expect(lastValueFrom(transaction.commit()))
+            .to.rejectedWith(`Transaction (id: ${transaction.id}) is no longer active, and can no longer be used. Current status: ROLLBACKED`);
+    });
+
     it("Transaction execute immediate", async () => {
 
         const transaction = database.managedTransaction();

src/test/managed-transaction.spec.ts

@@ -87,6 +87,10 @@ export class ManagedTransaction {
      * Rollback in current transaction
      */
     public async rollback(): Promise<boolean> {
+        if(this._status === TransactionStatus.ROLLBACKED){
+            console.warn(`Transaction (id: ${this._idTransaction}) already rollbacked`)
+            return true;
+        }
         this.checkTransactionActive();
         this.clearStackTransaction();
         if (this._status === TransactionStatus.STARTED
@@ -124,6 +128,10 @@ export class ManagedTransaction {
      * Commit a transaction
      */
     private async commitExecute(): Promise<boolean> {
+        if(this._status === TransactionStatus.COMMITTED){
+            console.warn(`Transaction (id: ${this._idTransaction}) already committed`)
+            return true;
+        }
         this.checkParametersAllowedInTransaction();
         this.checkTransactionActive();
         if (this._status === TransactionStatus.STARTED
@@ -136,7 +144,7 @@ export class ManagedTransaction {
             this.status = TransactionStatus.STARTED;
             await this.sqlBatch(batch);
         }
-        return this.finishTransaction(TransactionStatus.COMMITED);
+        return this.finishTransaction(TransactionStatus.COMMITTED);
     }
 
     /**
@@ -165,7 +173,7 @@ export class ManagedTransaction {
      */
     private checkTransactionActive(): void {
         if (!this.isTransactionActive()) {
-            throw new DatabaseBuilderError(`Transaction (id: ${this._idTransaction}) is no longer active, and can no longer be used`);
+            throw new DatabaseBuilderError(`Transaction (id: ${this._idTransaction}) is no longer active, and can no longer be used. Current status: ${TransactionStatus[this._status]}`);
         }
     }
 
@@ -182,7 +190,7 @@ export class ManagedTransaction {
      * Finish transaction and set status
      * @param status Status for finished transaction
      */
-    private finishTransaction(status: TransactionStatus.ROLLBACKED | TransactionStatus.COMMITED | TransactionStatus.RELEASED): boolean {
+    private finishTransaction(status: TransactionStatus.ROLLBACKED | TransactionStatus.COMMITTED | TransactionStatus.RELEASED): boolean {
         this.status = status;
         this.clearStackTransaction();
         return true;

src/transaction/managed-transaction.ts

@@ -2,6 +2,6 @@ export enum TransactionStatus {
     OPEN,
     STARTED,
     RELEASED,
-    COMMITED,
+    COMMITTED,
     ROLLBACKED
 }