test(repository): add repository integration tests

Author: shubhamp-sf

package-lock.json

@@ -44,17 +44,20 @@
     "!*/__tests__"
   ],
   "peerDependencies": {
-    "@loopback/core": "^4.0.3"
+    "@loopback/core": "^4.0.3",
+    "@loopback/repository": "^5.0.4",
+    "@loopback/rest": "^12.0.4"
   },
   "dependencies": {
-    "@loopback/repository": "^5.0.4",
     "sequelize": "^6.25.2",
     "tslib": "^2.0.0"
   },
   "devDependencies": {
+    "@loopback/boot": "^5.0.4",
     "@loopback/build": "^9.0.3",
     "@loopback/core": "^4.0.3",
     "@loopback/eslint-config": "^13.0.3",
+    "@loopback/rest": "^12.0.4",
     "@loopback/testlab": "^5.0.3",
     "@semantic-release/changelog": "^6.0.1",
     "@semantic-release/commit-analyzer": "^9.0.2",
@@ -66,6 +69,7 @@
     "eslint": "^8.22.0",
     "semantic-release": "^19.0.5",
     "source-map-support": "^0.5.21",
+    "sqlite3": "^5.1.2",
     "typescript": "~4.7.4"
   },
   "config": {

package.json

@@ -0,0 +1,13 @@
+import {BootMixin} from '@loopback/boot';
+import {ApplicationConfig} from '@loopback/core';
+import {RepositoryMixin} from '@loopback/repository';
+import {RestApplication} from '@loopback/rest';
+
+export class SequelizeSandboxApplication extends BootMixin(
+  RepositoryMixin(RestApplication),
+) {
+  constructor(options: ApplicationConfig = {}) {
+    super(options);
+    this.projectRoot = __dirname;
+  }
+}

src/__tests__/acceptance/README.md

@@ -0,0 +1,94 @@
+import {
+  Count,
+  CountSchema,
+  FilterExcludingWhere,
+  repository,
+  Where,
+} from '@loopback/repository';
+import {
+  get,
+  getModelSchemaRef,
+  param,
+  post,
+  requestBody,
+  response,
+} from '@loopback/rest';
+import {User} from '../models/user.model';
+import {UserRepository} from '../repositories/user.repository';
+
+export class UserController {
+  constructor(
+    @repository(UserRepository)
+    public userRepository: UserRepository,
+  ) {}
+
+  @post('/users')
+  @response(200, {
+    description: 'User model instance',
+    content: {'application/json': {schema: getModelSchemaRef(User)}},
+  })
+  async create(
+    @requestBody({
+      content: {
+        'application/json': {
+          schema: getModelSchemaRef(User, {
+            title: 'NewUser',
+            exclude: ['id'],
+          }),
+        },
+      },
+    })
+    user: Omit<User, 'id'>,
+  ): Promise<User> {
+    /**
+     * This `syncSequelizeModel` call below is only for testing purposes,
+     * in real project you are supposed to run migrations instead
+     * to sync model definitions to the target database.
+     */
+    await this.userRepository.syncSequelizeModel({
+      force: false,
+    });
+    return this.userRepository.create(user);
+  }
+
+  @get('/users/count')
+  @response(200, {
+    description: 'User model count',
+    content: {'application/json': {schema: CountSchema}},
+  })
+  async count(@param.where(User) where?: Where<User>): Promise<Count> {
+    /**
+     * This `syncSequelizeModel` call below is only for testing purposes,
+     * in real project you are supposed to run migrations instead
+     * to sync model definitions to the target database.
+     */
+    await this.userRepository.syncSequelizeModel({
+      force: false,
+    });
+    return this.userRepository.count(where);
+  }
+
+  @get('/users/{id}')
+  @response(200, {
+    description: 'User model instance',
+    content: {
+      'application/json': {
+        schema: getModelSchemaRef(User, {includeRelations: true}),
+      },
+    },
+  })
+  async findById(
+    @param.path.number('id') id: number,
+    @param.filter(User, {exclude: 'where'}) filter?: FilterExcludingWhere<User>,
+  ): Promise<User> {
+    /**
+     * This `syncSequelizeModel` call below is only for testing purposes,
+     * in real project you are supposed to run migrations instead
+     * to sync model definitions to the target database.
+     */
+    await this.userRepository.syncSequelizeModel({
+      force: false,
+    });
+    return this.userRepository.findById(id, filter);
+  }
+}

src/__tests__/fixtures/application.ts

@@ -0,0 +1,33 @@
+import {inject, lifeCycleObserver, LifeCycleObserver} from '@loopback/core';
+import {
+  SequelizeDataSource,
+  SequelizeDataSourceConfig,
+} from '../../../sequelize';
+
+const config: SequelizeDataSourceConfig = {
+  name: 'db',
+  host: '0.0.0.0',
+  connector: 'sqlite3',
+  database: 'database',
+  file: ':memory:',
+};
+
+// Observe application's life cycle to disconnect the datasource when
+// application is stopped. This allows the application to be shut down
+// gracefully. The `stop()` method is inherited from `juggler.DataSource`.
+// Learn more at https://loopback.io/doc/en/lb4/Life-cycle.html
+@lifeCycleObserver('datasource')
+export class DbDataSource
+  extends SequelizeDataSource
+  implements LifeCycleObserver
+{
+  static dataSourceName = 'db';
+  static readonly defaultConfig = config;
+
+  constructor(
+    @inject('datasources.config.db', {optional: true})
+    dsConfig: SequelizeDataSourceConfig = config,
+  ) {
+    super(dsConfig);
+  }
+}

src/__tests__/fixtures/controllers/user.controller.ts

@@ -0,0 +1,40 @@
+import {Entity, model, property} from '@loopback/repository';
+
+@model()
+export class User extends Entity {
+  @property({
+    type: 'number',
+    id: true,
+    generated: true,
+  })
+  id?: number;
+
+  @property({
+    type: 'string',
+  })
+  name?: string;
+
+  @property({
+    type: 'string',
+    required: true,
+  })
+  email: string;
+
+  @property({
+    type: 'number',
+  })
+  age?: number;
+
+  @property()
+  active?: boolean;
+
+  constructor(data?: Partial<User>) {
+    super(data);
+  }
+}
+
+export interface UserRelations {
+  // describe navigational properties here
+}
+
+export type UserWithRelations = User & UserRelations;

src/__tests__/fixtures/datasources/db.datasource.ts

@@ -0,0 +1,14 @@
+import {inject} from '@loopback/core';
+import {SequelizeRepository} from '../../../sequelize';
+import {DbDataSource} from '../datasources/db.datasource';
+import {User, UserRelations} from '../models/user.model';
+
+export class UserRepository extends SequelizeRepository<
+  User,
+  typeof User.prototype.id,
+  UserRelations
+> {
+  constructor(@inject('datasources.db') dataSource: DbDataSource) {
+    super(User, dataSource);
+  }
+}

src/__tests__/fixtures/models/user.model.ts

@@ -0,0 +1,95 @@
+import {RestApplication} from '@loopback/rest';
+import {
+  Client,
+  createRestAppClient,
+  expect,
+  givenHttpServerConfig,
+  TestSandbox,
+} from '@loopback/testlab';
+import {resolve} from 'path';
+import {SequelizeSandboxApplication} from '../fixtures/application';
+
+describe('Sequelize Repository (integration)', () => {
+  const sandbox = new TestSandbox(resolve(__dirname, '../../.sandbox'));
+
+  let app: SequelizeSandboxApplication;
+  let client: Client;
+
+  beforeEach('reset sandbox', () => sandbox.reset());
+  beforeEach(getAppAndClient);
+  afterEach(async () => {
+    if (app) await app.stop();
+    (app as unknown) = undefined;
+  });
+
+  it('creates an entity', async () => {
+    const user = {
+      name: 'shubham',
+      age: 10,
+      email: 'test@lb4.com',
+    };
+    const res = await client.post('/users').send(user);
+
+    expect(res.body).to.have.property('name', user.name);
+    expect(res.body).to.have.property('age', user.age);
+    expect(res.body).to.have.property('email', user.email);
+  });
+
+  it('counts created entity', async () => {
+    const user = {
+      name: 'shubham',
+      age: 10,
+      email: 'test@lb4.com',
+    };
+    await client.post('/users').send(user);
+
+    const res = await client.get('/users/count').send();
+    expect(res.body).to.have.property('count', 1);
+  });
+
+  it('fetches an entity', async () => {
+    const user = {
+      name: 'shubham',
+      age: 10,
+      email: 'test@lb4.com',
+    };
+    const create = await client.post('/users').send(user);
+    const res = await client.get(`/users/${create.body.id}`);
+    expect(res.body).to.have.property('name', user.name);
+    expect(res.body).to.have.property('age', user.age);
+    expect(res.body).to.have.property('email', user.email);
+  });
+
+  async function getAppAndClient() {
+    await sandbox.copyFile(resolve(__dirname, '../fixtures/application.js'));
+    await sandbox.copyFile(
+      resolve(__dirname, '../fixtures/datasources/db.datasource.js'),
+      'datasources/db.datasource.js',
+    );
+    await sandbox.copyFile(
+      resolve(__dirname, '../fixtures/models/user.model.js'),
+      'models/user.model.js',
+    );
+    await sandbox.copyFile(
+      resolve(__dirname, '../fixtures/controllers/user.controller.js'),
+      'controllers/user.controller.js',
+    );
+    await sandbox.copyFile(
+      resolve(__dirname, '../fixtures/repositories/user.repository.js'),
+      'repositories/user.repository.js',
+    );
+
+    const MyApp = require(resolve(
+      sandbox.path,
+      'application.js',
+    )).SequelizeSandboxApplication;
+    app = new MyApp({
+      rest: givenHttpServerConfig(),
+    });
+
+    await app.boot();
+    await app.start();
+
+    client = createRestAppClient(app as RestApplication);
+  }
+});

src/__tests__/fixtures/repositories/user.repository.ts

@@ -6,6 +6,7 @@ describe('Sequelize DataSource', () => {
   it('throws error when nosql connectors are supplied', () => {
     try {
       new SequelizeDataSource({
+        name: 'db',
         user: 'test',
         password: 'secret',
         connector: 'memory' as SupportedLoopbackConnectors,