feat(repository): repo, connection, tests

Author: michaelyali

dist/package.json

@@ -29,6 +29,8 @@
     "name": "Michael Yali",
     "email": "[email protected]"
   },
-  "dependencies": {},
+  "dependencies": {
+    "@zmotivat0r/o0": "1.0.2"
+  },
   "peerDependencies": {}
 }

e2e/__stubs__/cat.entity.ts

@@ -0,0 +1,7 @@
+import { Entity } from '../../src/couchbase';
+import { config } from './config';
+
+@Entity(config.bucket)
+export class Cat {
+  name: string;
+}

e2e/__stubs__/config.ts

@@ -0,0 +1,10 @@
+import { CouchbaseConnectionConfig } from '../../src/couchbase';
+
+export const config: CouchbaseConnectionConfig = {
+  url: 'couchbase://127.0.0.1',
+  username: 'couchbase',
+  password: 'couchbase',
+  bucket: 'e2e_test',
+};
+
+export const bucketOptions = { bucketType: 'ephemeral', replicaNumber: 0 };

e2e/__stubs__/index.ts

@@ -0,0 +1,2 @@
+export * from './config';
+export * from './cat.entity';

e2e/couchbase/couchbase.connection.factory.spec.ts

@@ -1,59 +1,95 @@
-import { oO } from '@zmotivat0r/o0';
-import { Cluster } from 'couchbase';
-
 import { CouchbaseConnectionFactory } from '../../src/couchbase/couchbase.connection.factory';
-import { config } from '../../test/__stubs__';
+import { sleep } from '../../src/utils';
+import { config, bucketOptions } from '../__stubs__';
 
 describe('#couchbase', () => {
   describe('#CouchbaseConnectionFactory', () => {
-    describe('#createCluster', () => {
+    it('should be defined', () => {
+      expect(CouchbaseConnectionFactory).toBeDefined();
+    });
+
+    describe('#create', () => {
       it('should be defined', () => {
-        expect(CouchbaseConnectionFactory.createCluster).toBeDefined();
+        expect(CouchbaseConnectionFactory.create).toBeDefined();
       });
-      it('should return cluster object', async () => {
-        const [_, cluster] = await oO(CouchbaseConnectionFactory.createCluster(config));
-        expect(cluster).toBeDefined();
-        expect(cluster).toHaveProperty('auther');
+      it('should create an instance', async () => {
+        const conn = await CouchbaseConnectionFactory.create(config);
+        expect(conn).toBeInstanceOf(CouchbaseConnectionFactory);
       });
-      it('should return mocked cluster object', async () => {
-        const [_, cluster] = await oO(
-          CouchbaseConnectionFactory.createCluster({ ...config, mock: true }),
-        );
-        expect(cluster).toBeDefined();
-        expect(cluster).toHaveProperty('dsnObj');
+      it('should create an instance with mock', async () => {
+        const conn = await CouchbaseConnectionFactory.create({ ...config, mock: true });
+        expect(conn).toBeInstanceOf(CouchbaseConnectionFactory);
       });
     });
 
-    describe('#getBucket', () => {
-      let cluster: Cluster;
+    describe('#methods', () => {
+      let conn: CouchbaseConnectionFactory;
+      let mocked: CouchbaseConnectionFactory;
+
+      async function removeBuckets() {
+        const [_, buckets] = await conn.listBuckets();
+        if (buckets && buckets.length) {
+          for (let i = 0; i < buckets.length; i++) {
+            await conn.removeBucket(buckets[0].name);
+          }
+        }
+      }
 
       beforeAll(async () => {
-        cluster = await CouchbaseConnectionFactory.createCluster(config);
+        conn = await CouchbaseConnectionFactory.create(config);
+        mocked = await CouchbaseConnectionFactory.create({ ...config, mock: true });
+        await removeBuckets();
       });
 
-      it('should be defined', () => {
-        expect(CouchbaseConnectionFactory.getBucket).toBeDefined();
-      });
-      it('should throw an error', async () => {
-        const [err] = await oO(
-          CouchbaseConnectionFactory.getBucket(cluster, { ...config, bucket: 'invalid' }),
-        );
-        expect(err).toBeInstanceOf(Error);
-      });
-      it('should return bucket object', async () => {
-        const [_, bucket] = await oO(
-          CouchbaseConnectionFactory.getBucket(cluster, config),
-        );
-        expect(bucket).toBeDefined();
-        expect((bucket as any)._name).toBe('test');
-        bucket.disconnect();
-      });
-      it('should return mocked bucket object', async () => {
-        const [_, bucket] = await oO(
-          CouchbaseConnectionFactory.getBucket(cluster, { ...config, mock: true }),
-        );
-        expect(bucket).toBeDefined();
-        expect((bucket as any)._name).toBe('default');
+      afterAll(async () => {
+        await removeBuckets();
+      });
+
+      describe('#createBucket', () => {
+        it('should create a bucket', async () => {
+          const [err, ok] = await conn.createBucket(config.bucket, bucketOptions);
+          expect(err).toBeUndefined();
+          expect(ok).toBe(true);
+          await sleep(3500);
+        });
+        it('should return an error', async () => {
+          const [err, _] = await conn.createBucket(config.bucket, bucketOptions);
+          expect(err).toBeInstanceOf(Error);
+        });
+      });
+
+      describe('#listBuckets', () => {
+        it('should return an array of buckets', async () => {
+          const [_, buckets] = await conn.listBuckets();
+          expect(Array.isArray(buckets)).toBe(true);
+        });
+      });
+
+      describe('#getBucket', () => {
+        it('should return an error', async () => {
+          const [err, _] = await conn.getBucket('invalid');
+          expect(err).toBeInstanceOf(Error);
+        });
+        it('should return a bucket', async () => {
+          const [_, bucket] = await conn.getBucket(config.bucket);
+          expect(bucket).toBeDefined();
+          bucket.disconnect();
+        });
+        it('should return a bucket with mock', async () => {
+          const [_, bucket] = await mocked.getBucket(config.bucket);
+          expect(bucket).toBeDefined();
+        });
+      });
+
+      describe('#removeBucket', () => {
+        it('should return an error', async () => {
+          const [err, _] = await conn.removeBucket('invalid');
+          expect(err).toBeInstanceOf(Error);
+        });
+        it('should remove a bucket', async () => {
+          const [_, ok] = await conn.removeBucket(config.bucket);
+          expect(ok).toBe(true);
+        });
       });
     });
   });

e2e/couchbase/couchbase.repository.factory.spec.ts

@@ -0,0 +1,83 @@
+import { CouchbaseConnectionFactory } from '../../src/couchbase/couchbase.connection.factory';
+import { CouchbaseRepositoryFactory } from '../../src/couchbase/couchbase.repository.factory';
+import { CouchbaseException } from '../../src/couchbase/exceptions/couchbase.exception';
+import { Entity } from '../../src/couchbase/decorators/entity.decorator';
+import { sleep, flattenPromise } from '../../src/utils';
+import { config, bucketOptions, Cat } from '../__stubs__';
+
+describe('#couchbase', () => {
+  describe('#CouchbaseRepositoryFactory', () => {
+    it('should be defined', () => {
+      expect(CouchbaseRepositoryFactory).toBeDefined();
+    });
+
+    let conn: CouchbaseConnectionFactory;
+    let mocked: CouchbaseConnectionFactory;
+
+    async function removeBuckets() {
+      const [_, buckets] = await conn.listBuckets();
+      if (buckets && buckets.length) {
+        for (let i = 0; i < buckets.length; i++) {
+          await conn.removeBucket(buckets[0].name);
+        }
+      }
+    }
+
+    beforeAll(async () => {
+      conn = await CouchbaseConnectionFactory.create(config);
+      mocked = await CouchbaseConnectionFactory.create({ ...config, mock: true });
+      await removeBuckets();
+      await conn.createBucket(config.bucket, bucketOptions);
+      await sleep(3500);
+    });
+
+    afterAll(async () => {
+      const [_, bucket] = await conn.getBucket(config.bucket);
+      bucket.disconnect();
+      await removeBuckets();
+    });
+
+    describe('#create', () => {
+      it('should be defined', () => {
+        expect(CouchbaseRepositoryFactory.create).toBeDefined();
+      });
+      it('should throw an error, 1', async () => {
+        const [err] = await flattenPromise(CouchbaseRepositoryFactory.create)();
+        expect(err).toBeInstanceOf(Error);
+      });
+      it('should throw an error, 2', async () => {
+        const [err] = await flattenPromise(CouchbaseRepositoryFactory.create)(conn);
+        expect(err).toBeInstanceOf(Error);
+      });
+      it('should throw an error, 3', async () => {
+        class InvalidTestEntity {}
+        const [err] = await flattenPromise(CouchbaseRepositoryFactory.create)(
+          conn,
+          InvalidTestEntity,
+        );
+        expect(err).toBeInstanceOf(CouchbaseException);
+      });
+      it('should throw an error, 4', async () => {
+        @Entity('invalid')
+        class InvalidTestEntity {}
+        const [err] = await flattenPromise(CouchbaseRepositoryFactory.create)(
+          conn,
+          InvalidTestEntity,
+        );
+        expect(err).toBeInstanceOf(Error);
+      });
+      it('should create new Repository', async () => {
+        const repo = await CouchbaseRepositoryFactory.create(conn, Cat);
+        expect(repo).toBeDefined();
+        expect(typeof repo).toBe('object');
+        expect(repo.entity).toBeDefined();
+      });
+      it('should create new Repository with mock', async () => {
+        const repo = await CouchbaseRepositoryFactory.create(mocked, Cat);
+        expect(repo).toBeDefined();
+        expect(typeof repo).toBe('object');
+        expect(repo.entity).toBeDefined();
+      });
+    });
+  });
+});

e2e/couchbase/couchbase.repository.mixin.spec.ts

@@ -0,0 +1 @@
+import { CouchbaseConnectionFactory } from '../../src/couchbase/couchbase.connection.factory';

integration/app.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+
+import { CouchbaseModule } from '../src/module';
+import { UsersModule } from './users';
+import { config } from './couchbase.config';
+
+@Module({
+  imports: [CouchbaseModule.forRoot(config), UsersModule],
+})
+export class AppModule {}

integration/couchbase.config.ts

@@ -0,0 +1,8 @@
+import { CouchbaseConnectionConfig } from '../src/couchbase';
+
+export const config: CouchbaseConnectionConfig = {
+  url: 'couchbase://127.0.0.1',
+  username: 'couchbase',
+  password: 'couchbase',
+  bucket: 'test',
+};

integration/https-exception.filter.ts

@@ -0,0 +1,28 @@
+import {
+  ExceptionFilter,
+  Catch,
+  ArgumentsHost,
+  HttpException,
+  InternalServerErrorException,
+} from '@nestjs/common';
+
+@Catch()
+export class HttpExceptionFilter implements ExceptionFilter {
+  catch(exception: HttpException, host: ArgumentsHost) {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse();
+    const { status, json } = this.prepareException(exception);
+
+    response.status(status).send(json);
+  }
+
+  prepareException(exc: any): { status: number; json: object } {
+    const error =
+      exc instanceof HttpException ? exc : new InternalServerErrorException(exc.message);
+    const status = error.getStatus();
+    const response = error.getResponse();
+    const json = typeof response === 'string' ? { error: response } : response;
+
+    return { status, json };
+  }
+}