@rsdk/db.typeorm 2.5.1

package/src/internal/test/strategy.test.e2e.ts

@@ -0,0 +1,1050 @@
+/* eslint-disable unicorn/consistent-function-scoping,unicorn/catch-error-name */
+import {
+  CallOutOfContextWithMandatory,
+  IncompatibleIsolationLevels,
+  NeverRunningInTransaction,
+  Propagation,
+  TransactionRunner,
+} from '@rsdk/db';
+import * as process from 'node:process';
+import { Client } from 'pg';
+import type { QueryRunner } from 'typeorm';
+import { DataSource } from 'typeorm';
+
+import { DEFAULT_ISOLATION_LEVEL, IsolationLevel } from '../../types';
+import { Initializer } from '../initializer';
+import { TypeormTransactionalStrategy } from '../strategy';
+
+import {
+  Account,
+  Cat,
+  cat,
+  contextTransactionMustBeInitialized,
+  contextTransactionMustNotInitialized,
+  secondCat,
+  SyntheticException,
+} from './util';
+
+export const fetchCats = async (): Promise<Cat[]> =>
+  dataSource.manager.find(Cat);
+export const createCat = async (): Promise<Cat> =>
+  dataSource.manager.getRepository(Cat).save(cat);
+export const createSecondCat = async (): Promise<Cat> => {
+  const catRepo = dataSource.manager.getRepository(Cat);
+
+  return await catRepo.save(catRepo.create(secondCat));
+};
+
+const runner = new TransactionRunner(new TypeormTransactionalStrategy());
+let dataSource: DataSource;
+
+export const pingDatabase = async (): Promise<void> =>
+  await dataSource.query('select 1 + 1');
+
+const schemaName = `typeorm`;
+const setupSchema = async (): Promise<void> => {
+  const client = new Client(process.env.DB_URL);
+
+  await client.connect();
+  await client.query(`CREATE SCHEMA IF NOT EXISTS ${schemaName}`);
+  await client.end();
+};
+
+beforeAll(setupSchema);
+
+beforeAll(async () => {
+  Initializer.initialize();
+  dataSource = new DataSource({
+    url: process.env.DB_URL as string,
+    type: process.env.DB_TYPE as 'postgres',
+    entities: [Cat, Account],
+    schema: schemaName,
+    logging: process.env.DB_LOGGING as 'all',
+  });
+  await dataSource.initialize();
+});
+
+beforeEach(async () => {
+  await dataSource.synchronize(true);
+});
+
+afterAll(async () => {
+  await dataSource.destroy();
+});
+
+it('correct run transaction', async () => {
+  const testedFunc = async (): Promise<void> => {
+    contextTransactionMustNotInitialized();
+    await pingDatabase();
+    contextTransactionMustBeInitialized();
+  };
+
+  await runner.transactional(testedFunc);
+});
+
+it('correct release queryRunner', async () => {
+  let qr: QueryRunner | undefined;
+  const testedFunc = async (): Promise<void> => {
+    const context = Initializer.storage.getContext();
+    const queryRunner = context?.queryRunner;
+
+    expect(queryRunner).toBeUndefined();
+    await pingDatabase();
+
+    {
+      const queryRunner = Initializer.storage.getContext()?.queryRunner;
+
+      expect(queryRunner).toBeDefined();
+      qr = queryRunner;
+
+      const transactionActive = queryRunner?.isTransactionActive;
+
+      expect(transactionActive).toBe(true);
+    }
+  };
+
+  await runner.transactional(testedFunc);
+  expect(qr?.isTransactionActive).toBeFalsy();
+  expect(qr?.isReleased).toBeTruthy();
+});
+
+it('example correct release queryRunner', async () => {
+  /**
+   * В случае если queryRunner некорректно релизится по завершению транзакции
+   * Здесь будет ошибка так как queryRunner будет использоваться после своего релиза
+   * Также это проверка на то что queryRunner не прибивается намертво к менеджеру
+   */
+  const testedFunc = async (): Promise<void> => {
+    await dataSource.manager.query('select 1 + 1');
+  };
+
+  await runner.transactional(testedFunc);
+  await testedFunc();
+
+  await runner.transactional(testedFunc);
+  await testedFunc();
+});
+
+it('correct commit transaction', async () => {
+  const testedFunc = async (): Promise<void> => {
+    await createCat();
+  };
+
+  await runner.transactional(testedFunc);
+
+  const cats = await fetchCats();
+
+  expect(cats).toMatchObject([cat]);
+});
+
+it('correct rollback transaction', async () => {
+  const testedFunc = async (): Promise<void> => {
+    await createCat();
+
+    throw new SyntheticException();
+  };
+
+  const err = await runner.transactional(testedFunc).catch((e) => e);
+
+  expect(err).toBeInstanceOf(SyntheticException);
+
+  const cats = await fetchCats();
+
+  expect(cats).toHaveLength(0);
+});
+
+describe('nested', () => {
+  const doSuccessful = async (): Promise<any> => {
+    contextTransactionMustBeInitialized();
+
+    return await createSecondCat();
+  };
+  const doFailed = async (): Promise<void> => {
+    await doSuccessful();
+
+    throw new SyntheticException();
+  };
+
+  it('correct run transaction', async () => {
+    const testedFunc = async (): Promise<void> => {
+      contextTransactionMustNotInitialized();
+      await pingDatabase();
+      await doSuccessful();
+      contextTransactionMustBeInitialized();
+    };
+
+    await runner.transactional(testedFunc);
+  });
+  it('correct release queryRunner', async () => {
+    let qr: QueryRunner | undefined;
+    const testedFunc = async (): Promise<void> => {
+      contextTransactionMustNotInitialized();
+      await pingDatabase();
+      await doSuccessful();
+      {
+        const queryRunner = Initializer.storage.getContext()?.queryRunner;
+
+        expect(queryRunner).toBeDefined();
+        qr = queryRunner;
+
+        const transactionActive = queryRunner?.isTransactionActive;
+
+        expect(transactionActive).toBe(true);
+      }
+    };
+
+    await runner.transactional(testedFunc);
+    expect(qr?.isReleased).toBeTruthy();
+  });
+
+  it('correct commit transaction', async () => {
+    const testedFunc = async (): Promise<void> => {
+      await createCat();
+      await doSuccessful();
+    };
+
+    await runner.transactional(testedFunc);
+
+    const cats = await fetchCats();
+
+    expect(cats).toMatchObject([cat, secondCat]);
+  });
+
+  it('correct rollback transaction', async () => {
+    const testedFunc = async (): Promise<void> => {
+      await createCat();
+      await doFailed();
+    };
+    const err = await runner.transactional(testedFunc).catch((e) => e);
+
+    expect(err).toBeInstanceOf(SyntheticException);
+
+    const cats = await fetchCats();
+
+    expect(cats).toHaveLength(0);
+  });
+  it('correct rollback actions in nested function calls', async () => {
+    const testedFunc = async (): Promise<void> => {
+      await createCat();
+      await doSuccessful();
+
+      throw new SyntheticException();
+    };
+    const err = await runner.transactional(testedFunc).catch((e) => e);
+
+    expect(err).toBeInstanceOf(SyntheticException);
+
+    const cats = await fetchCats();
+
+    expect(cats).toHaveLength(0);
+  });
+});
+
+describe('binded nested', () => {
+  const doSuccessfulCreateSecondCat = async (): Promise<any> => {
+    contextTransactionMustBeInitialized();
+
+    return await createSecondCat();
+  };
+
+  const contextDoSuccessful = (
+    options: IsolationLevel = DEFAULT_ISOLATION_LEVEL,
+  ): Promise<any> => runner.transactional(options, doSuccessfulCreateSecondCat);
+
+  const doFailed = async (): Promise<void> => {
+    await doSuccessfulCreateSecondCat();
+
+    throw new SyntheticException();
+  };
+
+  const contextDoFailed = (
+    options: IsolationLevel = DEFAULT_ISOLATION_LEVEL,
+  ): Promise<any> => runner.transactional(options, doFailed);
+
+  it('correct run transaction', async () => {
+    const testedFunc = async (): Promise<void> => {
+      contextTransactionMustNotInitialized();
+      await pingDatabase();
+      await contextDoSuccessful();
+      contextTransactionMustBeInitialized();
+    };
+
+    await runner.transactional(testedFunc);
+  });
+
+  it('correct run nested transaction (savepoint)', async () => {
+    const testedFunc = async (): Promise<void> => {
+      contextTransactionMustNotInitialized();
+      await runner.transactional(async (): Promise<any> => {
+        contextTransactionMustNotInitialized();
+
+        return await createSecondCat();
+      });
+      contextTransactionMustBeInitialized();
+    };
+
+    await runner.transactional(testedFunc);
+  });
+
+  it('correct release queryRunner', async () => {
+    let qr: QueryRunner | undefined;
+    const testedFunc = async (): Promise<void> => {
+      contextTransactionMustNotInitialized();
+      await pingDatabase();
+      await contextDoSuccessful();
+      {
+        const queryRunner = Initializer.storage.getContext()?.queryRunner;
+
+        qr = queryRunner;
+
+        const transactionActive = queryRunner?.isTransactionActive;
+
+        expect(transactionActive).toBe(true);
+      }
+    };
+
+    await runner.transactional(testedFunc);
+    expect(qr?.isReleased).toBeTruthy();
+  });
+
+  it('correct commit transaction', async () => {
+    const testedFunc = async (): Promise<void> => {
+      await createCat();
+      await contextDoSuccessful();
+    };
+
+    await runner.transactional(testedFunc);
+
+    const cats = await fetchCats();
+
+    expect(cats).toMatchObject([cat, secondCat]);
+  });
+
+  it('correct rollback transaction', async () => {
+    const testedFunc = async (): Promise<void> => {
+      await createCat();
+      await contextDoFailed();
+    };
+    const err = await runner.transactional(testedFunc).catch((e) => e);
+
+    expect(err).toBeInstanceOf(SyntheticException);
+
+    const cats = await fetchCats();
+
+    expect(cats).toHaveLength(0);
+  });
+});
+
+/**
+ * - Поведение при вызове из обернутого в контекст с целевым `propagation` вложенного метода обернутого в контекст с `propagation`
+ *   - NON_SUPPORTED
+ *     - Проверить что внутренние обращения никак не аффектят внешний контекст, то есть в этих обращениях не используется внешнее соединение и как следствие действия внутри вложенного метода не будут откачены вместе с внешними
+ *     - При исключении во вложенном методе сделанные внутри этого метода изменения в бд не будут откачены
+ *   - REQUIRES_NEW
+ *     - Проверить что внутренние обращения никак не аффектят внешний контекст, то есть в этих обращениях не используется внешнее соединение и как следствие действия внутри вложенного метода не будут откачены вместе с внешними
+ *     - Изменения в БД сделанные после успешного завершения вложенного метода не должны быть откачены при завершении с ошибкой внешнего контекста
+ *   - NESTED
+ *     - Проверить что внутренние обращения создают транзакцию если её не было
+ *     - Проверить что внутренние обращения создают savepoint если транзакция проинициализирована во внешнем контексте
+ *     - Изменения в БД сделанные после успешного завершения вложенного метода должны быть откачены в случае неуспешного завершения внешнего контекста
+ *     - Изменения в БД сделанные внутри метода, до выброса исключения должны быть откачены
+ *   - REQUIRED
+ *     - Проверить что внутренние обращения создают транзакцию если её не было
+ *     - Проверить что внутренние обращения не создают savepoint если транзакция проинициализирована во внешнем контексте
+ *     - Изменения в БД сделанные после успешного завершения вложенного метода должны быть откачены в случае неуспешного завершения внешнего контекста
+ *     - Изменения в БД сделанные внутри метода, до выброса исключения не должны быть откачены
+ */
+describe('MANDATORY', () => {
+  const defaultOptions = {
+    isolation: DEFAULT_ISOLATION_LEVEL,
+    propagation: Propagation.MANDATORY,
+  };
+  const contextDoSuccessful = (
+    isolationLevel: IsolationLevel = DEFAULT_ISOLATION_LEVEL,
+  ): Promise<any> =>
+    runner.transactional(
+      {
+        isolation: isolationLevel,
+        propagation: Propagation.MANDATORY,
+      },
+      async (): Promise<any> => {
+        contextTransactionMustBeInitialized();
+
+        return await createSecondCat();
+      },
+    );
+
+  it('throw out of transaction context', async () => {
+    await expect(contextDoSuccessful()).rejects.toBeInstanceOf(
+      CallOutOfContextWithMandatory,
+    );
+  });
+
+  it('correct run transaction', async () => {
+    const testedFunc = async (): Promise<void> => {
+      contextTransactionMustNotInitialized();
+      await pingDatabase();
+      contextTransactionMustBeInitialized();
+    };
+
+    await runner.transactional(testedFunc);
+  });
+
+  it('correct run new transaction', async () => {
+    const testedFunc = async (): Promise<void> => {
+      contextTransactionMustNotInitialized();
+      await runner.transactional(defaultOptions, async (): Promise<any> => {
+        contextTransactionMustNotInitialized();
+
+        return await createSecondCat();
+      });
+      contextTransactionMustBeInitialized();
+    };
+
+    await runner.transactional(testedFunc);
+  });
+
+  it('correct run without nested transaction', async () => {
+    const testedFunc = async (): Promise<void> => {
+      contextTransactionMustNotInitialized();
+      await runner.transactional(
+        {
+          isolation: DEFAULT_ISOLATION_LEVEL,
+          propagation: Propagation.REQUIRES_NEW,
+        },
+        async (): Promise<any> => {
+          contextTransactionMustNotInitialized();
+          await createSecondCat();
+          contextTransactionMustBeInitialized();
+        },
+      );
+      contextTransactionMustNotInitialized();
+    };
+
+    await runner.transactional(testedFunc);
+  });
+
+  it('non rollback actions in nested function calls', async () => {
+    const testedFunc = async (): Promise<void> => {
+      try {
+        await runner.transactional(async () => {
+          await createCat();
+
+          const cats = await fetchCats();
+
+          expect(cats).toEqual([cat]);
+
+          throw new SyntheticException();
+        });
+      } catch (e) {
+        const cats = await fetchCats();
+
+        expect(cats).toHaveLength(1);
+
+        throw e;
+      }
+    };
+
+    await expect(runner.transactional(testedFunc)).rejects.toBeInstanceOf(
+      SyntheticException,
+    );
+
+    const cats = await fetchCats();
+
+    expect(cats).toHaveLength(0);
+  });
+
+  it('correct throw on call incompatible isolation levels', async () => {
+    const testedFunc = async (): Promise<void> => {
+      await createCat();
+      await contextDoSuccessful(IsolationLevel.READ_COMMITTED);
+    };
+
+    await expect(runner.transactional(testedFunc)).rejects.toBeInstanceOf(
+      IncompatibleIsolationLevels,
+    );
+
+    const cats = await fetchCats();
+
+    expect(cats).toHaveLength(0);
+  });
+});
+describe('NESTED', () => {
+  const usedPropagationLevel = Propagation.NESTED;
+  const defaultOptions = {
+    isolation: DEFAULT_ISOLATION_LEVEL,
+    propagation: usedPropagationLevel,
+  };
+  const contextDoSuccessful = (
+    isolationLevel: IsolationLevel = DEFAULT_ISOLATION_LEVEL,
+  ): Promise<any> =>
+    runner.transactional(
+      {
+        isolation: isolationLevel,
+        propagation: usedPropagationLevel,
+      },
+      async (): Promise<any> => {
+        contextTransactionMustBeInitialized();
+
+        return await createSecondCat();
+      },
+    );
+
+  it('correct run transaction', async () => {
+    const testedFunc = async (): Promise<void> => {
+      contextTransactionMustNotInitialized();
+      await pingDatabase();
+      contextTransactionMustBeInitialized();
+    };
+
+    await runner.transactional(testedFunc);
+  });
+
+  it('correct run new transaction', async () => {
+    const testedFunc = async (): Promise<void> => {
+      contextTransactionMustNotInitialized();
+      await runner.transactional(defaultOptions, async (): Promise<any> => {
+        contextTransactionMustNotInitialized();
+        await createSecondCat();
+        contextTransactionMustBeInitialized();
+      });
+      contextTransactionMustBeInitialized();
+    };
+
+    await runner.transactional(defaultOptions, testedFunc);
+  });
+
+  it('throw for incompatible isolation levels', async () => {
+    const testedFunc = async (): Promise<void> => {
+      await createCat();
+      await contextDoSuccessful(IsolationLevel.READ_COMMITTED);
+    };
+
+    await expect(runner.transactional(testedFunc)).rejects.toBeInstanceOf(
+      IncompatibleIsolationLevels,
+    );
+
+    const cats = await fetchCats();
+
+    expect(cats).toHaveLength(0);
+  });
+
+  it('non rollback actions in nested function calls', async () => {
+    const testedFunc = async (): Promise<void> => {
+      try {
+        await runner.transactional(defaultOptions, async () => {
+          await createCat();
+
+          const cats = await fetchCats();
+
+          expect(cats).toEqual([cat]);
+
+          throw new SyntheticException();
+        });
+      } catch (e) {
+        const cats = await fetchCats();
+
+        expect(cats).toHaveLength(0);
+
+        throw e;
+      }
+    };
+
+    await expect(runner.transactional(testedFunc)).rejects.toBeInstanceOf(
+      SyntheticException,
+    );
+
+    const cats = await fetchCats();
+
+    expect(cats).toHaveLength(0);
+  });
+});
+describe('NEVER', () => {
+  const usedPropagationLevel = Propagation.NEVER;
+  const defaultOptions = {
+    isolation: DEFAULT_ISOLATION_LEVEL,
+    propagation: usedPropagationLevel,
+  };
+  const contextDoSuccessful = (
+    isolationLevel: IsolationLevel = DEFAULT_ISOLATION_LEVEL,
+  ): Promise<any> =>
+    runner.transactional(
+      {
+        isolation: isolationLevel,
+        propagation: usedPropagationLevel,
+      },
+      async (): Promise<any> => {
+        contextTransactionMustBeInitialized();
+
+        return await createSecondCat();
+      },
+    );
+
+  it('correct run non transaction', async () => {
+    const testedFunc = async (): Promise<void> => {
+      contextTransactionMustNotInitialized();
+      await pingDatabase();
+      contextTransactionMustNotInitialized();
+    };
+
+    await runner.transactional(defaultOptions, testedFunc);
+  });
+
+  it('correct run nested transaction', async () => {
+    const testedFunc = async (): Promise<void> => {
+      contextTransactionMustNotInitialized();
+      await runner.transactional(async (): Promise<any> => {
+        contextTransactionMustNotInitialized();
+        await createSecondCat();
+        contextTransactionMustBeInitialized();
+      });
+      contextTransactionMustNotInitialized();
+    };
+
+    await runner.transactional(defaultOptions, testedFunc);
+  });
+
+  it('correct throw on call in transaction', async () => {
+    const testedFunc = async (): Promise<void> => {
+      await createCat();
+      await contextDoSuccessful();
+    };
+
+    await expect(runner.transactional(testedFunc)).rejects.toBeInstanceOf(
+      NeverRunningInTransaction,
+    );
+
+    const cats = await fetchCats();
+
+    expect(cats).toHaveLength(0);
+  });
+});
+describe('NOT_SUPPORTED', () => {
+  const usedPropagationLevel = Propagation.NOT_SUPPORTED;
+  const defaultOptions = {
+    isolation: DEFAULT_ISOLATION_LEVEL,
+    propagation: usedPropagationLevel,
+  };
+  const contextDoSuccessful = async (
+    isolationLevel: IsolationLevel = DEFAULT_ISOLATION_LEVEL,
+  ): Promise<any> =>
+    await runner.transactional(
+      {
+        isolation: isolationLevel,
+        propagation: usedPropagationLevel,
+      },
+      async (): Promise<any> => {
+        contextTransactionMustNotInitialized();
+        await createSecondCat();
+        contextTransactionMustNotInitialized();
+      },
+    );
+
+  it('correct run transaction', async () => {
+    const testedFunc = async (): Promise<void> => {
+      contextTransactionMustNotInitialized();
+      await pingDatabase();
+      contextTransactionMustBeInitialized();
+      await contextDoSuccessful();
+
+      contextTransactionMustBeInitialized();
+    };
+
+    await runner.transactional(testedFunc);
+  });
+
+  it('correct run new transaction', async () => {
+    const testedFunc = async (): Promise<void> => {
+      contextTransactionMustNotInitialized();
+      await runner.transactional(defaultOptions, async (): Promise<any> => {
+        contextTransactionMustNotInitialized();
+        await createSecondCat();
+        contextTransactionMustNotInitialized();
+      });
+      contextTransactionMustNotInitialized();
+    };
+
+    await runner.transactional(defaultOptions, testedFunc);
+  });
+
+  it('correct run without nested transaction', async () => {
+    const testedFunc = async (): Promise<void> => {
+      contextTransactionMustNotInitialized();
+      await runner.transactional(defaultOptions, async (): Promise<any> => {
+        contextTransactionMustNotInitialized();
+        await createSecondCat();
+        contextTransactionMustNotInitialized();
+      });
+      contextTransactionMustNotInitialized();
+    };
+
+    await runner.transactional(testedFunc);
+  });
+
+  it('correct run for incompatible isolation levels', async () => {
+    const testedFunc = async (): Promise<void> => {
+      await createCat();
+      await contextDoSuccessful();
+    };
+
+    await runner.transactional(testedFunc);
+
+    const cats = await fetchCats();
+
+    expect(cats).toEqual([cat, secondCat]);
+  });
+
+  it('non rollback actions in nested function calls', async () => {
+    const testedFunc = async (): Promise<void> => {
+      try {
+        await runner.transactional(defaultOptions, async () => {
+          await createCat();
+
+          const cats = await fetchCats();
+
+          expect(cats).toEqual([cat]);
+
+          throw new SyntheticException();
+        });
+      } catch (e) {
+        const cats = await fetchCats();
+
+        expect(cats).toEqual([cat]);
+
+        throw e;
+      }
+    };
+
+    await expect(runner.transactional(testedFunc)).rejects.toBeInstanceOf(
+      SyntheticException,
+    );
+
+    const cats = await fetchCats();
+
+    expect(cats).toEqual([cat]);
+  });
+});
+describe('REQUIRED', () => {
+  const usedPropagationLevel = Propagation.REQUIRED;
+  const defaultOptions = {
+    isolation: DEFAULT_ISOLATION_LEVEL,
+    propagation: usedPropagationLevel,
+  };
+  const contextDoSuccessful = (
+    isolationLevel: IsolationLevel = DEFAULT_ISOLATION_LEVEL,
+  ): Promise<any> =>
+    runner.transactional(
+      {
+        isolation: isolationLevel,
+        propagation: usedPropagationLevel,
+      },
+      async (): Promise<any> => {
+        contextTransactionMustBeInitialized();
+
+        return await createSecondCat();
+      },
+    );
+
+  it('correct run transaction', async () => {
+    const testedFunc = async (): Promise<void> => {
+      contextTransactionMustNotInitialized();
+      await pingDatabase();
+      contextTransactionMustBeInitialized();
+    };
+
+    await runner.transactional(testedFunc);
+  });
+
+  it('correct run new transaction', async () => {
+    const testedFunc = async (): Promise<void> => {
+      contextTransactionMustNotInitialized();
+      await runner.transactional(async (): Promise<any> => {
+        contextTransactionMustNotInitialized();
+        await createSecondCat();
+        contextTransactionMustBeInitialized();
+      });
+      contextTransactionMustBeInitialized();
+    };
+
+    await runner.transactional(testedFunc);
+  });
+
+  it('correct run without nested transaction', async () => {
+    const testedFunc = async (): Promise<void> => {
+      contextTransactionMustNotInitialized();
+      await runner.transactional(defaultOptions, async (): Promise<any> => {
+        contextTransactionMustNotInitialized();
+        await createSecondCat();
+        contextTransactionMustBeInitialized();
+      });
+      contextTransactionMustBeInitialized();
+    };
+
+    await runner.transactional(testedFunc);
+  });
+
+  it('correct run for incompatible isolation levels', async () => {
+    const testedFunc = async (): Promise<void> => {
+      await createCat();
+      await contextDoSuccessful(IsolationLevel.READ_COMMITTED);
+    };
+
+    await expect(runner.transactional(testedFunc)).rejects.toBeInstanceOf(
+      IncompatibleIsolationLevels,
+    );
+
+    const cats = await fetchCats();
+
+    expect(cats).toHaveLength(0);
+  });
+
+  it('non rollback actions in nested function calls', async () => {
+    const testedFunc = async (): Promise<void> => {
+      try {
+        await runner.transactional(defaultOptions, async () => {
+          await createCat();
+
+          const cats = await fetchCats();
+
+          expect(cats).toEqual([cat]);
+
+          throw new SyntheticException();
+        });
+      } catch (e) {
+        const cats = await fetchCats();
+
+        expect(cats).toHaveLength(1);
+
+        throw e;
+      }
+    };
+
+    await expect(runner.transactional(testedFunc)).rejects.toBeInstanceOf(
+      SyntheticException,
+    );
+
+    const cats = await fetchCats();
+
+    expect(cats).toHaveLength(0);
+  });
+
+  it('correct throw on call incompatible isolation levels', async () => {
+    const testedFunc = async (): Promise<void> => {
+      await createCat();
+      await contextDoSuccessful(IsolationLevel.READ_COMMITTED);
+    };
+
+    await expect(runner.transactional(testedFunc)).rejects.toBeInstanceOf(
+      IncompatibleIsolationLevels,
+    );
+
+    const cats = await fetchCats();
+
+    expect(cats).toHaveLength(0);
+  });
+});
+describe('REQUIRES_NEW', () => {
+  const usedPropagationLevel = Propagation.REQUIRES_NEW;
+  const defaultOptions = {
+    isolation: DEFAULT_ISOLATION_LEVEL,
+    propagation: usedPropagationLevel,
+  };
+  const contextDoSuccessful = (
+    isolationLevel: IsolationLevel = DEFAULT_ISOLATION_LEVEL,
+  ): Promise<any> =>
+    runner.transactional(
+      {
+        isolation: isolationLevel,
+        propagation: usedPropagationLevel,
+      },
+      async (): Promise<void> => {
+        contextTransactionMustNotInitialized();
+        await createSecondCat();
+        contextTransactionMustBeInitialized();
+      },
+    );
+
+  it('correct run transaction', async () => {
+    const testedFunc = async (): Promise<void> => {
+      contextTransactionMustNotInitialized();
+      await pingDatabase();
+      contextTransactionMustBeInitialized();
+      await contextDoSuccessful();
+
+      contextTransactionMustBeInitialized();
+    };
+
+    await runner.transactional(testedFunc);
+  });
+
+  it('correct run new transaction', async () => {
+    const testedFunc = async (): Promise<void> => {
+      contextTransactionMustNotInitialized();
+      /**
+       * Не должно задействовать текущее соединение
+       */
+      await contextDoSuccessful();
+      /**
+       * Убеждаемся в том что текущий контекст так и не был проинициализирован
+       */
+      contextTransactionMustNotInitialized();
+    };
+
+    await runner.transactional(defaultOptions, testedFunc);
+  });
+
+  it('correct run for incompatible isolation levels', async () => {
+    const testedFunc = async (): Promise<void> => {
+      await createCat();
+
+      const cats = await fetchCats();
+
+      expect(cats).toEqual([cat]);
+      /**
+       * Исключения не будет так как будет использовано другое соединение
+       */
+      await contextDoSuccessful(IsolationLevel.READ_COMMITTED);
+
+      const cats2 = await fetchCats();
+
+      expect(cats2).toEqual([cat, secondCat]);
+    };
+
+    await runner.transactional(testedFunc);
+
+    const cats = await fetchCats();
+
+    expect(cats).toEqual([cat, secondCat]);
+  });
+
+  it('rollback actions in nested function calls', async () => {
+    const testedFunc = async (): Promise<void> => {
+      try {
+        await runner.transactional(defaultOptions, async () => {
+          await createCat();
+
+          const cats = await fetchCats();
+
+          expect(cats).toEqual([cat]);
+
+          throw new SyntheticException();
+        });
+      } catch (e) {
+        const cats = await fetchCats();
+
+        expect(cats).toHaveLength(0);
+
+        throw e;
+      }
+    };
+
+    await expect(runner.transactional(testedFunc)).rejects.toBeInstanceOf(
+      SyntheticException,
+    );
+
+    const cats = await fetchCats();
+
+    expect(cats).toHaveLength(0);
+  });
+  it('non rollback actions in nested function calls', async () => {
+    const testedFunc = async (): Promise<void> => {
+      await runner.transactional(defaultOptions, async () => {
+        await createCat();
+
+        const cats = await fetchCats();
+
+        expect(cats).toEqual([cat]);
+      });
+
+      /**
+       * Изменения вложенного вызова не должны быть откачены
+       */
+      throw new SyntheticException();
+    };
+
+    await expect(runner.transactional(testedFunc)).rejects.toBeInstanceOf(
+      SyntheticException,
+    );
+
+    const cats = await fetchCats();
+
+    expect(cats).toEqual([cat]);
+  });
+});
+describe('SUPPORTS', () => {
+  const usedPropagationLevel = Propagation.SUPPORTS;
+  const contextDoSuccessful = (
+    isolationLevel: IsolationLevel = DEFAULT_ISOLATION_LEVEL,
+  ): Promise<any> =>
+    runner.transactional(
+      {
+        isolation: isolationLevel,
+        propagation: usedPropagationLevel,
+      },
+      async (): Promise<any> => {
+        return await createSecondCat();
+      },
+    );
+
+  it('correct run transaction', async () => {
+    const testedFunc = async (): Promise<void> => {
+      contextTransactionMustNotInitialized();
+      await pingDatabase();
+      await contextDoSuccessful();
+
+      contextTransactionMustBeInitialized();
+    };
+
+    await runner.transactional(testedFunc);
+  });
+
+  it('correct run new transaction', async () => {
+    const testedFunc = async (): Promise<void> => {
+      contextTransactionMustNotInitialized();
+      await runner.transactional(async (): Promise<any> => {
+        contextTransactionMustNotInitialized();
+
+        return await createSecondCat();
+      });
+      contextTransactionMustBeInitialized();
+    };
+
+    await runner.transactional(testedFunc);
+  });
+
+  it('correct run without nested transaction', async () => {
+    const testedFunc = async (): Promise<void> => {
+      contextTransactionMustNotInitialized();
+      await runner.transactional(
+        {
+          isolation: DEFAULT_ISOLATION_LEVEL,
+          propagation: usedPropagationLevel,
+        },
+        async (): Promise<any> => {
+          contextTransactionMustNotInitialized();
+          await createSecondCat();
+          contextTransactionMustBeInitialized();
+        },
+      );
+      contextTransactionMustBeInitialized();
+    };
+
+    await runner.transactional(testedFunc);
+  });
+
+  it('correct run for incompatible isolation levels', async () => {
+    const testedFunc = async (): Promise<void> => {
+      await createCat();
+      /**
+       * Всё должно сработать так как мы создаём новую транзакцию
+       */
+      await contextDoSuccessful(IsolationLevel.READ_COMMITTED);
+    };
+
+    await runner.transactional(testedFunc);
+
+    const cats = await fetchCats();
+
+    expect(cats).toEqual([cat, secondCat]);
+  });
+});