From 393af2f92cae010bafc3eef92965f8a5ad087610 Mon Sep 17 00:00:00 2001 From: Agnes Lin Date: Fri, 4 Oct 2019 12:50:37 -0400 Subject: [PATCH] refactor(cli): update cli hasmany and belongsto tests with snapshots --- ...lation.belongs-to.integration.snapshots.js | 705 +++++++++++++ ...relation.has-many.integration.snapshots.js | 937 ++++++++++++++++++ .../relation.belongs-to.integration.js | 183 +--- .../relation.has-many.integration.js | 459 +-------- 4 files changed, 1709 insertions(+), 575 deletions(-) create mode 100644 packages/cli/snapshots/integration/generators/relation.belongs-to.integration.snapshots.js create mode 100644 packages/cli/snapshots/integration/generators/relation.has-many.integration.snapshots.js diff --git a/packages/cli/snapshots/integration/generators/relation.belongs-to.integration.snapshots.js b/packages/cli/snapshots/integration/generators/relation.belongs-to.integration.snapshots.js new file mode 100644 index 000000000000..90d399de4abe --- /dev/null +++ b/packages/cli/snapshots/integration/generators/relation.belongs-to.integration.snapshots.js @@ -0,0 +1,705 @@ +// IMPORTANT +// This snapshot file is auto-generated, but designed for humans. +// It should be checked into source control and tracked carefully. +// Re-generate by setting UPDATE_SNAPSHOTS=1 and running tests. +// Make sure to inspect the changes in the snapshots below. +// Do not ignore changes! + +'use strict'; + +exports[`lb4 relation check if the controller file created answers {"relationType":"belongsTo","sourceModel":"Order","destinationModel":"Customer"} controller GET Array of Order's belonging to Customer 1`] = ` +import { + repository, +} from '@loopback/repository'; +import { + param, + get, + getModelSchemaRef, +} from '@loopback/rest'; +import { + Order, + Customer, +} from '../models'; +import {OrderRepository} from '../repositories'; + +export class OrderCustomerController { + constructor( + @repository(OrderRepository) + public orderRepository: OrderRepository, + ) { } + + @get('/orders/{id}/customer', { + responses: { + '200': { + description: 'Customer belonging to Order', + content: { + 'application/json': { + schema: {type: 'array', items: getModelSchemaRef(Customer)}, + }, + }, + }, + }, + }) + async getCustomer( + @param.path.number('id') id: typeof Order.prototype.id, + ): Promise { + return this.orderRepository.customer(id); + } +} + +`; + + +exports[`lb4 relation check if the controller file created answers {"relationType":"belongsTo","sourceModel":"Order","destinationModel":"Customer"} controller with belongsTo class and constructor 1`] = ` +import { + repository, +} from '@loopback/repository'; +import { + param, + get, + getModelSchemaRef, +} from '@loopback/rest'; +import { + Order, + Customer, +} from '../models'; +import {OrderRepository} from '../repositories'; + +export class OrderCustomerController { + constructor( + @repository(OrderRepository) + public orderRepository: OrderRepository, + ) { } + + @get('/orders/{id}/customer', { + responses: { + '200': { + description: 'Customer belonging to Order', + content: { + 'application/json': { + schema: {type: 'array', items: getModelSchemaRef(Customer)}, + }, + }, + }, + }, + }) + async getCustomer( + @param.path.number('id') id: typeof Order.prototype.id, + ): Promise { + return this.orderRepository.customer(id); + } +} + +`; + + +exports[`lb4 relation check if the controller file created answers {"relationType":"belongsTo","sourceModel":"Order","destinationModel":"Customer"} the new controller file added to index.ts file 1`] = ` +export * from './order-customer.controller'; + +`; + + +exports[`lb4 relation check if the controller file created answers {"relationType":"belongsTo","sourceModel":"OrderClass","destinationModel":"CustomerClass"} controller GET Array of OrderClass's belonging to CustomerClass 1`] = ` +import { + repository, +} from '@loopback/repository'; +import { + param, + get, + getModelSchemaRef, +} from '@loopback/rest'; +import { + OrderClass, + CustomerClass, +} from '../models'; +import {OrderClassRepository} from '../repositories'; + +export class OrderClassCustomerClassController { + constructor( + @repository(OrderClassRepository) + public orderClassRepository: OrderClassRepository, + ) { } + + @get('/order-classes/{id}/customer-class', { + responses: { + '200': { + description: 'CustomerClass belonging to OrderClass', + content: { + 'application/json': { + schema: {type: 'array', items: getModelSchemaRef(CustomerClass)}, + }, + }, + }, + }, + }) + async getCustomerClass( + @param.path.number('id') id: typeof OrderClass.prototype.orderNumber, + ): Promise { + return this.orderClassRepository.customerClass(id); + } +} + +`; + + +exports[`lb4 relation check if the controller file created answers {"relationType":"belongsTo","sourceModel":"OrderClass","destinationModel":"CustomerClass"} controller with belongsTo class and constructor 1`] = ` +import { + repository, +} from '@loopback/repository'; +import { + param, + get, + getModelSchemaRef, +} from '@loopback/rest'; +import { + OrderClass, + CustomerClass, +} from '../models'; +import {OrderClassRepository} from '../repositories'; + +export class OrderClassCustomerClassController { + constructor( + @repository(OrderClassRepository) + public orderClassRepository: OrderClassRepository, + ) { } + + @get('/order-classes/{id}/customer-class', { + responses: { + '200': { + description: 'CustomerClass belonging to OrderClass', + content: { + 'application/json': { + schema: {type: 'array', items: getModelSchemaRef(CustomerClass)}, + }, + }, + }, + }, + }) + async getCustomerClass( + @param.path.number('id') id: typeof OrderClass.prototype.orderNumber, + ): Promise { + return this.orderClassRepository.customerClass(id); + } +} + +`; + + +exports[`lb4 relation check if the controller file created answers {"relationType":"belongsTo","sourceModel":"OrderClass","destinationModel":"CustomerClass"} the new controller file added to index.ts file 1`] = ` +export * from './order-class-customer-class.controller'; + +`; + + +exports[`lb4 relation check if the controller file created answers {"relationType":"belongsTo","sourceModel":"OrderClassType","destinationModel":"CustomerClassType"} controller GET Array of OrderClassType's belonging to CustomerClassType 1`] = ` +import { + repository, +} from '@loopback/repository'; +import { + param, + get, + getModelSchemaRef, +} from '@loopback/rest'; +import { + OrderClassType, + CustomerClassType, +} from '../models'; +import {OrderClassTypeRepository} from '../repositories'; + +export class OrderClassTypeCustomerClassTypeController { + constructor( + @repository(OrderClassTypeRepository) + public orderClassTypeRepository: OrderClassTypeRepository, + ) { } + + @get('/order-class-types/{id}/customer-class-type', { + responses: { + '200': { + description: 'CustomerClassType belonging to OrderClassType', + content: { + 'application/json': { + schema: {type: 'array', items: getModelSchemaRef(CustomerClassType)}, + }, + }, + }, + }, + }) + async getCustomerClassType( + @param.path.string('id') id: typeof OrderClassType.prototype.orderString, + ): Promise { + return this.orderClassTypeRepository.customerClassType(id); + } +} + +`; + + +exports[`lb4 relation check if the controller file created answers {"relationType":"belongsTo","sourceModel":"OrderClassType","destinationModel":"CustomerClassType"} controller with belongsTo class and constructor 1`] = ` +import { + repository, +} from '@loopback/repository'; +import { + param, + get, + getModelSchemaRef, +} from '@loopback/rest'; +import { + OrderClassType, + CustomerClassType, +} from '../models'; +import {OrderClassTypeRepository} from '../repositories'; + +export class OrderClassTypeCustomerClassTypeController { + constructor( + @repository(OrderClassTypeRepository) + public orderClassTypeRepository: OrderClassTypeRepository, + ) { } + + @get('/order-class-types/{id}/customer-class-type', { + responses: { + '200': { + description: 'CustomerClassType belonging to OrderClassType', + content: { + 'application/json': { + schema: {type: 'array', items: getModelSchemaRef(CustomerClassType)}, + }, + }, + }, + }, + }) + async getCustomerClassType( + @param.path.string('id') id: typeof OrderClassType.prototype.orderString, + ): Promise { + return this.orderClassTypeRepository.customerClassType(id); + } +} + +`; + + +exports[`lb4 relation check if the controller file created answers {"relationType":"belongsTo","sourceModel":"OrderClassType","destinationModel":"CustomerClassType"} the new controller file added to index.ts file 1`] = ` +export * from './order-class-type-customer-class-type.controller'; + +`; + + +exports[`lb4 relation check source class repository answers {"relationType":"belongsTo","sourceModel":"Order","destinationModel":"Customer"} Order repostitory has all imports 1`] = ` +import {DefaultCrudRepository, repository, BelongsToAccessor} from '@loopback/repository'; +import {Order, Customer} from '../models'; +import {DbDataSource} from '../datasources'; +import {inject, Getter} from '@loopback/core'; +import {CustomerRepository} from './customer.repository'; + +export class OrderRepository extends DefaultCrudRepository< + Order, + typeof Order.prototype.id +> { + + public readonly customer: BelongsToAccessor; + + constructor(@inject('datasources.db') dataSource: DbDataSource, @repository.getter('CustomerRepository') protected customerRepositoryGetter: Getter,) { + super(Order, dataSource); + this.customer = this.createBelongsToAccessorFor('customer', customerRepositoryGetter,); + } +} + +`; + + +exports[`lb4 relation check source class repository answers {"relationType":"belongsTo","sourceModel":"Order","destinationModel":"Customer"} repository has updated constructor 1`] = ` +import {DefaultCrudRepository, repository, BelongsToAccessor} from '@loopback/repository'; +import {Order, Customer} from '../models'; +import {DbDataSource} from '../datasources'; +import {inject, Getter} from '@loopback/core'; +import {CustomerRepository} from './customer.repository'; + +export class OrderRepository extends DefaultCrudRepository< + Order, + typeof Order.prototype.id +> { + + public readonly customer: BelongsToAccessor; + + constructor(@inject('datasources.db') dataSource: DbDataSource, @repository.getter('CustomerRepository') protected customerRepositoryGetter: Getter,) { + super(Order, dataSource); + this.customer = this.createBelongsToAccessorFor('customer', customerRepositoryGetter,); + } +} + +`; + + +exports[`lb4 relation check source class repository answers {"relationType":"belongsTo","sourceModel":"OrderClass","destinationModel":"CustomerClass"} OrderClass repostitory has all imports 1`] = ` +import {DefaultCrudRepository, repository, BelongsToAccessor} from '@loopback/repository'; +import {OrderClass, CustomerClass} from '../models'; +import {MyDBDataSource} from '../datasources'; +import {inject, Getter} from '@loopback/core'; +import {CustomerClassRepository} from './customer-class.repository'; + +export class OrderClassRepository extends DefaultCrudRepository< + OrderClass, + typeof OrderClass.prototype.orderNumber +> { + + public readonly customerClass: BelongsToAccessor; + + constructor(@inject('datasources.myDB') dataSource: MyDBDataSource, @repository.getter('CustomerClassRepository') protected customerClassRepositoryGetter: Getter,) { + super(OrderClass, dataSource); + this.customerClass = this.createBelongsToAccessorFor('customerClassCustNumber', customerClassRepositoryGetter,); + } +} + +`; + + +exports[`lb4 relation check source class repository answers {"relationType":"belongsTo","sourceModel":"OrderClass","destinationModel":"CustomerClass"} repository has updated constructor 1`] = ` +import {DefaultCrudRepository, repository, BelongsToAccessor} from '@loopback/repository'; +import {OrderClass, CustomerClass} from '../models'; +import {MyDBDataSource} from '../datasources'; +import {inject, Getter} from '@loopback/core'; +import {CustomerClassRepository} from './customer-class.repository'; + +export class OrderClassRepository extends DefaultCrudRepository< + OrderClass, + typeof OrderClass.prototype.orderNumber +> { + + public readonly customerClass: BelongsToAccessor; + + constructor(@inject('datasources.myDB') dataSource: MyDBDataSource, @repository.getter('CustomerClassRepository') protected customerClassRepositoryGetter: Getter,) { + super(OrderClass, dataSource); + this.customerClass = this.createBelongsToAccessorFor('customerClassCustNumber', customerClassRepositoryGetter,); + } +} + +`; + + +exports[`lb4 relation check source class repository answers {"relationType":"belongsTo","sourceModel":"OrderClassType","destinationModel":"CustomerClassType"} OrderClassType repostitory has all imports 1`] = ` +import {DefaultCrudRepository, repository, BelongsToAccessor} from '@loopback/repository'; +import {OrderClassType, CustomerClassType} from '../models'; +import {MyDBDataSource} from '../datasources'; +import {inject, Getter} from '@loopback/core'; +import {CustomerClassTypeRepository} from './customer-class-type.repository'; + +export class OrderClassTypeRepository extends DefaultCrudRepository< + OrderClassType, + typeof OrderClassType.prototype.orderString +> { + + public readonly customerClassType: BelongsToAccessor; + + constructor(@inject('datasources.myDB') dataSource: MyDBDataSource, @repository.getter('CustomerClassTypeRepository') protected customerClassTypeRepositoryGetter: Getter,) { + super(OrderClassType, dataSource); + this.customerClassType = this.createBelongsToAccessorFor('customerClassTypeCustNumber', customerClassTypeRepositoryGetter,); + } +} + +`; + + +exports[`lb4 relation check source class repository answers {"relationType":"belongsTo","sourceModel":"OrderClassType","destinationModel":"CustomerClassType"} repository has updated constructor 1`] = ` +import {DefaultCrudRepository, repository, BelongsToAccessor} from '@loopback/repository'; +import {OrderClassType, CustomerClassType} from '../models'; +import {MyDBDataSource} from '../datasources'; +import {inject, Getter} from '@loopback/core'; +import {CustomerClassTypeRepository} from './customer-class-type.repository'; + +export class OrderClassTypeRepository extends DefaultCrudRepository< + OrderClassType, + typeof OrderClassType.prototype.orderString +> { + + public readonly customerClassType: BelongsToAccessor; + + constructor(@inject('datasources.myDB') dataSource: MyDBDataSource, @repository.getter('CustomerClassTypeRepository') protected customerClassTypeRepositoryGetter: Getter,) { + super(OrderClassType, dataSource); + this.customerClassType = this.createBelongsToAccessorFor('customerClassTypeCustNumber', customerClassTypeRepositoryGetter,); + } +} + +`; + + +exports[`lb4 relation check source class repository generate model relation for existing property name Verify is property name that already exist will overwriting 1`] = ` +import {Entity, model, property, belongsTo} from '@loopback/repository'; +import {Customer} from './customer.model'; + +@model() +export class Order extends Entity { + @property({ + type: 'number', + id: true, + default: 0, + }) + id?: number; + + @property({ + type: 'string', + }) + name?: string; + + @belongsTo(() => Customer) + myCustomer: number; + + constructor(data?: Partial) { + super(data); + } +} + +`; + + +exports[`lb4 relation generate model relation answers {"relationType":"belongsTo","sourceModel":"Order","destinationModel":"Customer","relationName":"myCustomer"} add import belongsTo, import for target model and belongsTo decorator 1`] = ` +import {Entity, model, property, belongsTo} from '@loopback/repository'; +import {Customer} from './customer.model'; + +@model() +export class Order extends Entity { + @property({ + type: 'number', + id: true, + default: 0, + }) + id?: number; + + @property({ + type: 'string', + }) + name?: string; + + @belongsTo(() => Customer) + myCustomer: number; + + constructor(data?: Partial) { + super(data); + } +} + +`; + + +exports[`lb4 relation generate model relation answers {"relationType":"belongsTo","sourceModel":"OrderClass","destinationModel":"CustomerClass","relationName":"myCustomer"} add import belongsTo, import for target model and belongsTo decorator 1`] = ` +import {Entity, model, property, belongsTo} from '@loopback/repository'; +import {CustomerClass} from './customer-class.model'; + +@model() +export class OrderClass extends Entity { + @property({ + type: 'number', + id: true, + }) + orderNumber?: number; + + @property({ + type: 'string', + }) + name?: string; + + @belongsTo(() => CustomerClass) + myCustomer: number; + + constructor(data?: Partial) { + super(data); + } +} + +`; + + +exports[`lb4 relation generate model relation answers {"relationType":"belongsTo","sourceModel":"OrderClassType","destinationModel":"CustomerClassType","relationName":"myCustomer"} add import belongsTo, import for target model and belongsTo decorator 1`] = ` +import {Entity, model, property, belongsTo} from '@loopback/repository'; +import {CustomerClassType} from './customer-class-type.model'; + +@model() +export class OrderClassType extends Entity { + @property({ + type: 'string', + id: true, + }) + orderString: string; + + @property({ + type: 'string', + }) + name?: string; + + @belongsTo(() => CustomerClassType) + myCustomer: number; + + constructor(data?: Partial) { + super(data); + } +} + +`; + + +exports[`lb4 relation generate model relation with custom relation name answers {"relationType":"belongsTo","sourceModel":"Order","destinationModel":"Customer","relationName":"customerPK"} relation name should be customerPK 1`] = ` +import {Entity, model, property, belongsTo} from '@loopback/repository'; +import {Customer} from './customer.model'; + +@model() +export class Order extends Entity { + @property({ + type: 'number', + id: true, + default: 0, + }) + id?: number; + + @property({ + type: 'string', + }) + name?: string; + + @belongsTo(() => Customer) + customerPK: number; + + constructor(data?: Partial) { + super(data); + } +} + +`; + + +exports[`lb4 relation generate model relation with custom relation name answers {"relationType":"belongsTo","sourceModel":"OrderClass","destinationModel":"CustomerClass","relationName":"customerPK"} relation name should be customerPK 1`] = ` +import {Entity, model, property, belongsTo} from '@loopback/repository'; +import {CustomerClass} from './customer-class.model'; + +@model() +export class OrderClass extends Entity { + @property({ + type: 'number', + id: true, + }) + orderNumber?: number; + + @property({ + type: 'string', + }) + name?: string; + + @belongsTo(() => CustomerClass) + customerPK: number; + + constructor(data?: Partial) { + super(data); + } +} + +`; + + +exports[`lb4 relation generate model relation with custom relation name answers {"relationType":"belongsTo","sourceModel":"OrderClassType","destinationModel":"CustomerClassType","relationName":"customerPK"} relation name should be customerPK 1`] = ` +import {Entity, model, property, belongsTo} from '@loopback/repository'; +import {CustomerClassType} from './customer-class-type.model'; + +@model() +export class OrderClassType extends Entity { + @property({ + type: 'string', + id: true, + }) + orderString: string; + + @property({ + type: 'string', + }) + name?: string; + + @belongsTo(() => CustomerClassType) + customerPK: number; + + constructor(data?: Partial) { + super(data); + } +} + +`; + + +exports[`lb4 relation generate model relation with default relation name answers {"relationType":"belongsTo","sourceModel":"Order","destinationModel":"Customer"} relation name should be customerId 1`] = ` +import {Entity, model, property, belongsTo} from '@loopback/repository'; +import {Customer} from './customer.model'; + +@model() +export class Order extends Entity { + @property({ + type: 'number', + id: true, + default: 0, + }) + id?: number; + + @property({ + type: 'string', + }) + name?: string; + + @belongsTo(() => Customer) + customerId: number; + + constructor(data?: Partial) { + super(data); + } +} + +`; + + +exports[`lb4 relation generate model relation with default relation name answers {"relationType":"belongsTo","sourceModel":"OrderClass","destinationModel":"CustomerClass"} relation name should be customerClassCustNumber 1`] = ` +import {Entity, model, property, belongsTo} from '@loopback/repository'; +import {CustomerClass} from './customer-class.model'; + +@model() +export class OrderClass extends Entity { + @property({ + type: 'number', + id: true, + }) + orderNumber?: number; + + @property({ + type: 'string', + }) + name?: string; + + @belongsTo(() => CustomerClass) + customerClassCustNumber: number; + + constructor(data?: Partial) { + super(data); + } +} + +`; + + +exports[`lb4 relation generate model relation with default relation name answers {"relationType":"belongsTo","sourceModel":"OrderClassType","destinationModel":"CustomerClassType"} relation name should be customerClassTypeCustNumber 1`] = ` +import {Entity, model, property, belongsTo} from '@loopback/repository'; +import {CustomerClassType} from './customer-class-type.model'; + +@model() +export class OrderClassType extends Entity { + @property({ + type: 'string', + id: true, + }) + orderString: string; + + @property({ + type: 'string', + }) + name?: string; + + @belongsTo(() => CustomerClassType) + customerClassTypeCustNumber: number; + + constructor(data?: Partial) { + super(data); + } +} + +`; diff --git a/packages/cli/snapshots/integration/generators/relation.has-many.integration.snapshots.js b/packages/cli/snapshots/integration/generators/relation.has-many.integration.snapshots.js new file mode 100644 index 000000000000..8602454d504b --- /dev/null +++ b/packages/cli/snapshots/integration/generators/relation.has-many.integration.snapshots.js @@ -0,0 +1,937 @@ +// IMPORTANT +// This snapshot file is auto-generated, but designed for humans. +// It should be checked into source control and tracked carefully. +// Re-generate by setting UPDATE_SNAPSHOTS=1 and running tests. +// Make sure to inspect the changes in the snapshots below. +// Do not ignore changes! + +'use strict'; + +exports[`lb4 relation HasMany check if the controller file created answers {"relationType":"hasMany","sourceModel":"Customer","destinationModel":"Order"} checks controller content with hasMany relation 1`] = ` +import { + Count, + CountSchema, + Filter, + repository, + Where, +} from '@loopback/repository'; +import { + del, + get, + getModelSchemaRef, + getWhereSchemaFor, + param, + patch, + post, + requestBody, +} from '@loopback/rest'; +import { + Customer, + Order, +} from '../models'; +import {CustomerRepository} from '../repositories'; + +export class CustomerOrderController { + constructor( + @repository(CustomerRepository) protected customerRepository: CustomerRepository, + ) { } + + @get('/customers/{id}/orders', { + responses: { + '200': { + description: 'Array of Order\\'s belonging to Customer', + content: { + 'application/json': { + schema: {type: 'array', items: getModelSchemaRef(Order)}, + }, + }, + }, + }, + }) + async find( + @param.path.number('id') id: number, + @param.query.object('filter') filter?: Filter, + ): Promise { + return this.customerRepository.orders(id).find(filter); + } + + @post('/customers/{id}/orders', { + responses: { + '200': { + description: 'Customer model instance', + content: {'application/json': {schema: getModelSchemaRef(Order)}}, + }, + }, + }) + async create( + @param.path.number('id') id: typeof Customer.prototype.id, + @requestBody({ + content: { + 'application/json': { + schema: getModelSchemaRef(Order, { + title: 'NewOrderInCustomer', + exclude: ['id'], + optional: ['customerId'] + }), + }, + }, + }) order: Omit, + ): Promise { + return this.customerRepository.orders(id).create(order); + } + + @patch('/customers/{id}/orders', { + responses: { + '200': { + description: 'Customer.Order PATCH success count', + content: {'application/json': {schema: CountSchema}}, + }, + }, + }) + async patch( + @param.path.number('id') id: number, + @requestBody({ + content: { + 'application/json': { + schema: getModelSchemaRef(Order, {partial: true}), + }, + }, + }) + order: Partial, + @param.query.object('where', getWhereSchemaFor(Order)) where?: Where, + ): Promise { + return this.customerRepository.orders(id).patch(order, where); + } + + @del('/customers/{id}/orders', { + responses: { + '200': { + description: 'Customer.Order DELETE success count', + content: {'application/json': {schema: CountSchema}}, + }, + }, + }) + async delete( + @param.path.number('id') id: number, + @param.query.object('where', getWhereSchemaFor(Order)) where?: Where, + ): Promise { + return this.customerRepository.orders(id).delete(where); + } +} + +`; + + +exports[`lb4 relation HasMany check if the controller file created answers {"relationType":"hasMany","sourceModel":"CustomerClass","destinationModel":"OrderClass"} checks controller content with hasMany relation 1`] = ` +import { + Count, + CountSchema, + Filter, + repository, + Where, +} from '@loopback/repository'; +import { + del, + get, + getModelSchemaRef, + getWhereSchemaFor, + param, + patch, + post, + requestBody, +} from '@loopback/rest'; +import { + CustomerClass, + OrderClass, +} from '../models'; +import {CustomerClassRepository} from '../repositories'; + +export class CustomerClassOrderClassController { + constructor( + @repository(CustomerClassRepository) protected customerClassRepository: CustomerClassRepository, + ) { } + + @get('/customer-classes/{id}/order-classes', { + responses: { + '200': { + description: 'Array of OrderClass\\'s belonging to CustomerClass', + content: { + 'application/json': { + schema: {type: 'array', items: getModelSchemaRef(OrderClass)}, + }, + }, + }, + }, + }) + async find( + @param.path.number('id') id: number, + @param.query.object('filter') filter?: Filter, + ): Promise { + return this.customerClassRepository.orderClasses(id).find(filter); + } + + @post('/customer-classes/{id}/order-classes', { + responses: { + '200': { + description: 'CustomerClass model instance', + content: {'application/json': {schema: getModelSchemaRef(OrderClass)}}, + }, + }, + }) + async create( + @param.path.number('id') id: typeof CustomerClass.prototype.custNumber, + @requestBody({ + content: { + 'application/json': { + schema: getModelSchemaRef(OrderClass, { + title: 'NewOrderClassInCustomerClass', + exclude: ['orderNumber'], + optional: ['customerClassCustNumber'] + }), + }, + }, + }) orderClass: Omit, + ): Promise { + return this.customerClassRepository.orderClasses(id).create(orderClass); + } + + @patch('/customer-classes/{id}/order-classes', { + responses: { + '200': { + description: 'CustomerClass.OrderClass PATCH success count', + content: {'application/json': {schema: CountSchema}}, + }, + }, + }) + async patch( + @param.path.number('id') id: number, + @requestBody({ + content: { + 'application/json': { + schema: getModelSchemaRef(OrderClass, {partial: true}), + }, + }, + }) + orderClass: Partial, + @param.query.object('where', getWhereSchemaFor(OrderClass)) where?: Where, + ): Promise { + return this.customerClassRepository.orderClasses(id).patch(orderClass, where); + } + + @del('/customer-classes/{id}/order-classes', { + responses: { + '200': { + description: 'CustomerClass.OrderClass DELETE success count', + content: {'application/json': {schema: CountSchema}}, + }, + }, + }) + async delete( + @param.path.number('id') id: number, + @param.query.object('where', getWhereSchemaFor(OrderClass)) where?: Where, + ): Promise { + return this.customerClassRepository.orderClasses(id).delete(where); + } +} + +`; + + +exports[`lb4 relation HasMany check if the controller file created answers {"relationType":"hasMany","sourceModel":"CustomerClassType","destinationModel":"OrderClassType"} checks controller content with hasMany relation 1`] = ` +import { + Count, + CountSchema, + Filter, + repository, + Where, +} from '@loopback/repository'; +import { + del, + get, + getModelSchemaRef, + getWhereSchemaFor, + param, + patch, + post, + requestBody, +} from '@loopback/rest'; +import { + CustomerClassType, + OrderClassType, +} from '../models'; +import {CustomerClassTypeRepository} from '../repositories'; + +export class CustomerClassTypeOrderClassTypeController { + constructor( + @repository(CustomerClassTypeRepository) protected customerClassTypeRepository: CustomerClassTypeRepository, + ) { } + + @get('/customer-class-types/{id}/order-class-types', { + responses: { + '200': { + description: 'Array of OrderClassType\\'s belonging to CustomerClassType', + content: { + 'application/json': { + schema: {type: 'array', items: getModelSchemaRef(OrderClassType)}, + }, + }, + }, + }, + }) + async find( + @param.path.number('id') id: number, + @param.query.object('filter') filter?: Filter, + ): Promise { + return this.customerClassTypeRepository.orderClassTypes(id).find(filter); + } + + @post('/customer-class-types/{id}/order-class-types', { + responses: { + '200': { + description: 'CustomerClassType model instance', + content: {'application/json': {schema: getModelSchemaRef(OrderClassType)}}, + }, + }, + }) + async create( + @param.path.number('id') id: typeof CustomerClassType.prototype.custNumber, + @requestBody({ + content: { + 'application/json': { + schema: getModelSchemaRef(OrderClassType, { + title: 'NewOrderClassTypeInCustomerClassType', + exclude: ['orderString'], + optional: ['customerClassTypeCustNumber'] + }), + }, + }, + }) orderClassType: Omit, + ): Promise { + return this.customerClassTypeRepository.orderClassTypes(id).create(orderClassType); + } + + @patch('/customer-class-types/{id}/order-class-types', { + responses: { + '200': { + description: 'CustomerClassType.OrderClassType PATCH success count', + content: {'application/json': {schema: CountSchema}}, + }, + }, + }) + async patch( + @param.path.number('id') id: number, + @requestBody({ + content: { + 'application/json': { + schema: getModelSchemaRef(OrderClassType, {partial: true}), + }, + }, + }) + orderClassType: Partial, + @param.query.object('where', getWhereSchemaFor(OrderClassType)) where?: Where, + ): Promise { + return this.customerClassTypeRepository.orderClassTypes(id).patch(orderClassType, where); + } + + @del('/customer-class-types/{id}/order-class-types', { + responses: { + '200': { + description: 'CustomerClassType.OrderClassType DELETE success count', + content: {'application/json': {schema: CountSchema}}, + }, + }, + }) + async delete( + @param.path.number('id') id: number, + @param.query.object('where', getWhereSchemaFor(OrderClassType)) where?: Where, + ): Promise { + return this.customerClassTypeRepository.orderClassTypes(id).delete(where); + } +} + +`; + + +exports[`lb4 relation HasMany check source class repository answers {"relationType":"hasMany","sourceModel":"Customer","destinationModel":"Order"} checks if Customer repository has generated correctly 1`] = ` +import {DefaultCrudRepository, repository, HasManyRepositoryFactory} from '@loopback/repository'; +import {Customer, Order} from '../models'; +import {DbDataSource} from '../datasources'; +import {inject, Getter} from '@loopback/core'; +import {OrderRepository} from './order.repository'; + +export class CustomerRepository extends DefaultCrudRepository< + Customer, + typeof Customer.prototype.id +> { + + public readonly orders: HasManyRepositoryFactory; + + constructor(@inject('datasources.db') dataSource: DbDataSource, @repository.getter('OrderRepository') protected orderRepositoryGetter: Getter,) { + super(Customer, dataSource); + this.orders = this.createHasManyRepositoryFactoryFor('orders', orderRepositoryGetter,); + } +} + +`; + + +exports[`lb4 relation HasMany check source class repository answers {"relationType":"hasMany","sourceModel":"CustomerClass","destinationModel":"OrderClass"} checks if CustomerClass repository has generated correctly 1`] = ` +import {DefaultCrudRepository, repository, HasManyRepositoryFactory} from '@loopback/repository'; +import {CustomerClass, OrderClass} from '../models'; +import {MyDBDataSource} from '../datasources'; +import {inject, Getter} from '@loopback/core'; +import {OrderClassRepository} from './order-class.repository'; + +export class CustomerClassRepository extends DefaultCrudRepository< + CustomerClass, + typeof CustomerClass.prototype.custNumber +> { + + public readonly orderClasses: HasManyRepositoryFactory; + + constructor(@inject('datasources.myDB') dataSource: MyDBDataSource, @repository.getter('OrderClassRepository') protected orderClassRepositoryGetter: Getter,) { + super(CustomerClass, dataSource); + this.orderClasses = this.createHasManyRepositoryFactoryFor('orderClasses', orderClassRepositoryGetter,); + } +} + +`; + + +exports[`lb4 relation HasMany check source class repository answers {"relationType":"hasMany","sourceModel":"CustomerClassType","destinationModel":"OrderClassType"} checks if CustomerClassType repository has generated correctly 1`] = ` +import {DefaultCrudRepository, repository, HasManyRepositoryFactory} from '@loopback/repository'; +import {CustomerClassType, OrderClassType} from '../models'; +import {MyDBDataSource} from '../datasources'; +import {inject, Getter} from '@loopback/core'; +import {OrderClassTypeRepository} from './order-class-type.repository'; + +export class CustomerClassTypeRepository extends DefaultCrudRepository< + CustomerClassType, + typeof CustomerClassType.prototype.custNumber +> { + + public readonly orderClassTypes: HasManyRepositoryFactory; + + constructor(@inject('datasources.myDB') dataSource: MyDBDataSource, @repository.getter('OrderClassTypeRepository') protected orderClassTypeRepositoryGetter: Getter,) { + super(CustomerClassType, dataSource); + this.orderClassTypes = this.createHasManyRepositoryFactoryFor('orderClassTypes', orderClassTypeRepositoryGetter,); + } +} + +`; + + +exports[`lb4 relation HasMany generate model relation answers {"relationType":"hasMany","sourceModel":"Customer","destinationModel":"Order"} add import hasMany, import for target model and hasMany decorator 1`] = ` +import {Entity, model, property, hasMany} from '@loopback/repository'; +import {Order} from './order.model'; + +@model() +export class Customer extends Entity { + @property({ + type: 'number', + id: true, + default: 0, + }) + id?: number; + + @property({ + type: 'string', + }) + name?: string; + + @hasMany(() => Order) + orders: Order[]; + + constructor(data?: Partial) { + super(data); + } +} + +`; + + +exports[`lb4 relation HasMany generate model relation answers {"relationType":"hasMany","sourceModel":"CustomerClass","destinationModel":"OrderClass"} add import hasMany, import for target model and hasMany decorator 1`] = ` +import {Entity, model, property, hasMany} from '@loopback/repository'; +import {OrderClass} from './order-class.model'; + +@model() +export class CustomerClass extends Entity { + @property({ + type: 'number', + id: true, + }) + custNumber?: number; + + @property({ + type: 'string', + }) + name?: string; + + @hasMany(() => OrderClass ,{keyTo: 'customerClassCustNumber'}) + orderClasses: OrderClass[]; + + constructor(data?: Partial) { + super(data); + } +} + +`; + + +exports[`lb4 relation HasMany generate model relation answers {"relationType":"hasMany","sourceModel":"CustomerClassType","destinationModel":"OrderClassType"} add import hasMany, import for target model and hasMany decorator 1`] = ` +import {Entity, model, property, hasMany} from '@loopback/repository'; +import {OrderClassType} from './order-class-type.model'; + +@model() +export class CustomerClassType extends Entity { + @property({ + type: 'number', + id: true, + }) + custNumber: number; + + @property({ + type: 'string', + }) + name?: string; + + @hasMany(() => OrderClassType ,{keyTo: 'customerClassTypeCustNumber'}) + orderClassTypes: OrderClassType[]; + + constructor(data?: Partial) { + super(data); + } +} + +`; + + +exports[`lb4 relation HasMany generate model relation with custom foreignKey answers {"relationType":"hasMany","sourceModel":"Customer","destinationModel":"Order","foreignKeyName":"mykey"} add the keyTo to the source model 1`] = ` +import {Entity, model, property, hasMany} from '@loopback/repository'; +import {Order} from './order.model'; + +@model() +export class Customer extends Entity { + @property({ + type: 'number', + id: true, + default: 0, + }) + id?: number; + + @property({ + type: 'string', + }) + name?: string; + + @hasMany(() => Order ,{keyTo: 'mykey'}) + orders: Order[]; + + constructor(data?: Partial) { + super(data); + } +} + +`; + + +exports[`lb4 relation HasMany generate model relation with custom foreignKey answers {"relationType":"hasMany","sourceModel":"Customer","destinationModel":"Order","foreignKeyName":"mykey"} add the keyTo to the source model 2`] = ` +import {Entity, model, property} from '@loopback/repository'; + +@model() +export class Order extends Entity { + @property({ + type: 'number', + id: true, + default: 0, + }) + id?: number; + + @property({ + type: 'string', + }) + name?: string; + + @property({ + type: 'number', + }) + mykey?: number; + + constructor(data?: Partial) { + super(data); + } +} + +`; + + +exports[`lb4 relation HasMany generate model relation with custom foreignKey answers {"relationType":"hasMany","sourceModel":"CustomerClass","destinationModel":"OrderClass","foreignKeyName":"mykey"} add the keyTo to the source model 1`] = ` +import {Entity, model, property, hasMany} from '@loopback/repository'; +import {OrderClass} from './order-class.model'; + +@model() +export class CustomerClass extends Entity { + @property({ + type: 'number', + id: true, + }) + custNumber?: number; + + @property({ + type: 'string', + }) + name?: string; + + @hasMany(() => OrderClass ,{keyTo: 'mykey'}) + orderClasses: OrderClass[]; + + constructor(data?: Partial) { + super(data); + } +} + +`; + + +exports[`lb4 relation HasMany generate model relation with custom foreignKey answers {"relationType":"hasMany","sourceModel":"CustomerClass","destinationModel":"OrderClass","foreignKeyName":"mykey"} add the keyTo to the source model 2`] = ` +import {Entity, model, property} from '@loopback/repository'; + +@model() +export class OrderClass extends Entity { + @property({ + type: 'number', + id: true, + }) + orderNumber?: number; + + @property({ + type: 'string', + }) + name?: string; + + @property({ + type: 'number', + }) + mykey?: number; + + constructor(data?: Partial) { + super(data); + } +} + +`; + + +exports[`lb4 relation HasMany generate model relation with custom foreignKey answers {"relationType":"hasMany","sourceModel":"CustomerClassType","destinationModel":"OrderClassType","foreignKeyName":"mykey"} add the keyTo to the source model 1`] = ` +import {Entity, model, property, hasMany} from '@loopback/repository'; +import {OrderClassType} from './order-class-type.model'; + +@model() +export class CustomerClassType extends Entity { + @property({ + type: 'number', + id: true, + }) + custNumber: number; + + @property({ + type: 'string', + }) + name?: string; + + @hasMany(() => OrderClassType ,{keyTo: 'mykey'}) + orderClassTypes: OrderClassType[]; + + constructor(data?: Partial) { + super(data); + } +} + +`; + + +exports[`lb4 relation HasMany generate model relation with custom foreignKey answers {"relationType":"hasMany","sourceModel":"CustomerClassType","destinationModel":"OrderClassType","foreignKeyName":"mykey"} add the keyTo to the source model 2`] = ` +import {Entity, model, property} from '@loopback/repository'; + +@model() +export class OrderClassType extends Entity { + @property({ + type: 'string', + id: true, + }) + orderString: string; + + @property({ + type: 'string', + }) + name?: string; + + @property({ + type: 'number', + }) + mykey?: number; + + constructor(data?: Partial) { + super(data); + } +} + +`; + + +exports[`lb4 relation HasMany generate model relation with custom relation name answers {"relationType":"hasMany","sourceModel":"Customer","destinationModel":"Order","relationName":"myOrders"} relation name should be myOrders 1`] = ` +import {Entity, model, property, hasMany} from '@loopback/repository'; +import {Order} from './order.model'; + +@model() +export class Customer extends Entity { + @property({ + type: 'number', + id: true, + default: 0, + }) + id?: number; + + @property({ + type: 'string', + }) + name?: string; + + @hasMany(() => Order) + myOrders: Order[]; + + constructor(data?: Partial) { + super(data); + } +} + +`; + + +exports[`lb4 relation HasMany generate model relation with custom relation name answers {"relationType":"hasMany","sourceModel":"Customer","destinationModel":"Order","relationName":"myOrders"} relation name should be myOrders 2`] = ` +import {Entity, model, property} from '@loopback/repository'; + +@model() +export class Order extends Entity { + @property({ + type: 'number', + id: true, + default: 0, + }) + id?: number; + + @property({ + type: 'string', + }) + name?: string; + + @property({ + type: 'number', + }) + customerId?: number; + + constructor(data?: Partial) { + super(data); + } +} + +`; + + +exports[`lb4 relation HasMany generate model relation with custom relation name answers {"relationType":"hasMany","sourceModel":"CustomerClass","destinationModel":"OrderClass","relationName":"myOrders"} relation name should be myOrders 1`] = ` +import {Entity, model, property, hasMany} from '@loopback/repository'; +import {OrderClass} from './order-class.model'; + +@model() +export class CustomerClass extends Entity { + @property({ + type: 'number', + id: true, + }) + custNumber?: number; + + @property({ + type: 'string', + }) + name?: string; + + @hasMany(() => OrderClass ,{keyTo: 'customerClassCustNumber'}) + myOrders: OrderClass[]; + + constructor(data?: Partial) { + super(data); + } +} + +`; + + +exports[`lb4 relation HasMany generate model relation with custom relation name answers {"relationType":"hasMany","sourceModel":"CustomerClass","destinationModel":"OrderClass","relationName":"myOrders"} relation name should be myOrders 2`] = ` +import {Entity, model, property} from '@loopback/repository'; + +@model() +export class OrderClass extends Entity { + @property({ + type: 'number', + id: true, + }) + orderNumber?: number; + + @property({ + type: 'string', + }) + name?: string; + + @property({ + type: 'number', + }) + customerClassCustNumber?: number; + + constructor(data?: Partial) { + super(data); + } +} + +`; + + +exports[`lb4 relation HasMany generate model relation with custom relation name answers {"relationType":"hasMany","sourceModel":"CustomerClassType","destinationModel":"OrderClassType","relationName":"myOrders"} relation name should be myOrders 1`] = ` +import {Entity, model, property, hasMany} from '@loopback/repository'; +import {OrderClassType} from './order-class-type.model'; + +@model() +export class CustomerClassType extends Entity { + @property({ + type: 'number', + id: true, + }) + custNumber: number; + + @property({ + type: 'string', + }) + name?: string; + + @hasMany(() => OrderClassType ,{keyTo: 'customerClassTypeCustNumber'}) + myOrders: OrderClassType[]; + + constructor(data?: Partial) { + super(data); + } +} + +`; + + +exports[`lb4 relation HasMany generate model relation with custom relation name answers {"relationType":"hasMany","sourceModel":"CustomerClassType","destinationModel":"OrderClassType","relationName":"myOrders"} relation name should be myOrders 2`] = ` +import {Entity, model, property} from '@loopback/repository'; + +@model() +export class OrderClassType extends Entity { + @property({ + type: 'string', + id: true, + }) + orderString: string; + + @property({ + type: 'string', + }) + name?: string; + + @property({ + type: 'number', + }) + customerClassTypeCustNumber?: number; + + constructor(data?: Partial) { + super(data); + } +} + +`; + + +exports[`lb4 relation HasMany generate model relation with default relation name answers {"relationType":"hasMany","sourceModel":"Customer","destinationModel":"Order"} relation name should be orders 1`] = ` +import {Entity, model, property, hasMany} from '@loopback/repository'; +import {Order} from './order.model'; + +@model() +export class Customer extends Entity { + @property({ + type: 'number', + id: true, + default: 0, + }) + id?: number; + + @property({ + type: 'string', + }) + name?: string; + + @hasMany(() => Order) + orders: Order[]; + + constructor(data?: Partial) { + super(data); + } +} + +`; + + +exports[`lb4 relation HasMany generate model relation with default relation name answers {"relationType":"hasMany","sourceModel":"CustomerClass","destinationModel":"OrderClass"} relation name should be orderClasses 1`] = ` +import {Entity, model, property, hasMany} from '@loopback/repository'; +import {OrderClass} from './order-class.model'; + +@model() +export class CustomerClass extends Entity { + @property({ + type: 'number', + id: true, + }) + custNumber?: number; + + @property({ + type: 'string', + }) + name?: string; + + @hasMany(() => OrderClass ,{keyTo: 'customerClassCustNumber'}) + orderClasses: OrderClass[]; + + constructor(data?: Partial) { + super(data); + } +} + +`; + + +exports[`lb4 relation HasMany generate model relation with default relation name answers {"relationType":"hasMany","sourceModel":"CustomerClassType","destinationModel":"OrderClassType"} relation name should be orderClassTypes 1`] = ` +import {Entity, model, property, hasMany} from '@loopback/repository'; +import {OrderClassType} from './order-class-type.model'; + +@model() +export class CustomerClassType extends Entity { + @property({ + type: 'number', + id: true, + }) + custNumber: number; + + @property({ + type: 'string', + }) + name?: string; + + @hasMany(() => OrderClassType ,{keyTo: 'customerClassTypeCustNumber'}) + orderClassTypes: OrderClassType[]; + + constructor(data?: Partial) { + super(data); + } +} + +`; diff --git a/packages/cli/test/integration/generators/relation.belongs-to.integration.js b/packages/cli/test/integration/generators/relation.belongs-to.integration.js index b161cf4fa3c8..c92b236c826a 100644 --- a/packages/cli/test/integration/generators/relation.belongs-to.integration.js +++ b/packages/cli/test/integration/generators/relation.belongs-to.integration.js @@ -8,7 +8,7 @@ const path = require('path'); const assert = require('yeoman-assert'); const {expect, TestSandbox} = require('@loopback/testlab'); -const fs = require('fs'); +const {expectFileToMatchSnapshot} = require('../../snapshots'); const generator = path.join(__dirname, '../../../generators/relation'); const {SANDBOX_FILES, SourceEntries} = require('../../fixtures/relation'); @@ -116,12 +116,6 @@ describe('lb4 relation', function() { }); context('generate model relation', () => { - const expectedImport = /import {Entity, model, property, belongsTo} from \'\@loopback\/repository\';\n/; - const expectedDecoretor = [ - /@belongsTo\(\(\) => Customer\)\n {2}myCustomer: number;\n/, - /@belongsTo\(\(\) => CustomerClass\)\n {2}myCustomer: number;\n/, - /@belongsTo\(\(\) => CustomerClassType\)\n {2}myCustomer: number;\n/, - ]; const promptArray = [ { relationType: 'belongsTo', @@ -163,26 +157,19 @@ describe('lb4 relation', function() { }); it('add import belongsTo, import for target model and belongsTo decorator ', async () => { - const expectedSourceFile = path.join( + const sourceFilePath = path.join( SANDBOX_PATH, MODEL_APP_PATH, sourceFileName[i], ); - assert.file(expectedSourceFile); - assert.fileContent(expectedSourceFile, expectedImport); - assert.fileContent(expectedSourceFile, expectedDecoretor[i]); + assert.file(sourceFilePath); + expectFileToMatchSnapshot(sourceFilePath); }); } }); context('generate model relation with custom relation name', () => { - const expectedDecoretor = [ - /@belongsTo\(\(\) => Customer\)\n {2}customerPK: number;\n/, - /@belongsTo\(\(\) => CustomerClass\)\n {2}customerPK: number;\n/, - /@belongsTo\(\(\) => CustomerClassType\)\n {2}customerPK: number;\n/, - ]; - const promptArray = [ { relationType: 'belongsTo', @@ -223,23 +210,19 @@ describe('lb4 relation', function() { }); it('relation name should be customerPK', async () => { - const expectedSourceFile = path.join( + const sourceFilePath = path.join( SANDBOX_PATH, MODEL_APP_PATH, sourceFileName[i], ); - assert.fileContent(expectedSourceFile, expectedDecoretor[i]); + assert.file(sourceFilePath); + expectFileToMatchSnapshot(sourceFilePath); }); } }); context('generate model relation with default relation name', () => { - const expectedDecoretor = [ - /@belongsTo\(\(\) => Customer\)\n {2}customerId: number;\n/, - /@belongsTo\(\(\) => CustomerClass\)\n {2}customerClassCustNumber: number;\n/, - /@belongsTo\(\(\) => CustomerClassType\)\n {2}customerClassTypeCustNumber: number;\n/, - ]; const defaultRelationName = [ 'customerId', 'customerClassCustNumber', @@ -283,13 +266,14 @@ describe('lb4 relation', function() { }); it('relation name should be ' + defaultRelationName[i], async () => { - const expectedSourceFile = path.join( + const sourceFilePath = path.join( SANDBOX_PATH, MODEL_APP_PATH, sourceFileName[i], ); - assert.fileContent(expectedSourceFile, expectedDecoretor[i]); + assert.file(sourceFilePath); + expectFileToMatchSnapshot(sourceFilePath); }); } }); @@ -312,21 +296,7 @@ describe('lb4 relation', function() { destinationModel: 'CustomerClassType', }, ]; - const controllerClass = [ - /class OrderCustomerController/, - /class OrderClassCustomerClassController/, - /class OrderClassTypeCustomerClassTypeController/, - ]; - const controllerConstructor = [ - /constructor\(\n {4}\@repository\(OrderRepository\)\n {4}public orderRepository: OrderRepository,\n {2}\) \{ \}\n/, - /constructor\(\n {4}\@repository\(OrderClassRepository\)\n {4}public orderClassRepository: OrderClassRepository,\n {2}\) \{ \}\n/, - /constructor\(\n {4}\@repository\(OrderClassTypeRepository\)\n {4}public orderClassTypeRepository: OrderClassTypeRepository,\n {2}\) \{ \}\n/, - ]; - const indexExport = [ - /export \* from '.\/order-customer.controller';/, - /export \* from '.\/order-class-customer-class.controller';/, - /export \* from '.\/order-class-type-customer-class-type.controller';/, - ]; + const sourceClassnames = ['Customer', 'CustomerClass', 'CustomerClassType']; const targetClassnames = ['Order', 'OrderClass', 'OrderClassType']; promptArray.forEach(function(multiItemPrompt, i) { @@ -349,32 +319,32 @@ describe('lb4 relation', function() { }); it('new controller file created', async () => { - const expectedControllerFile = path.join( + const filePath = path.join( SANDBOX_PATH, CONTROLLER_PATH, controllerFileName[i], ); - assert.file(expectedControllerFile); + assert.file(filePath); }); it('controller with belongsTo class and constructor', async () => { - const expectedControllerFile = path.join( + const filePath = path.join( SANDBOX_PATH, CONTROLLER_PATH, controllerFileName[i], ); - assert.fileContent(expectedControllerFile, controllerClass[i]); - assert.fileContent(expectedControllerFile, controllerConstructor[i]); + assert.file(filePath); + expectFileToMatchSnapshot(filePath); }); it('the new controller file added to index.ts file', async () => { - const expectedControllerIndexFile = path.join( + const indexFilePath = path.join( SANDBOX_PATH, CONTROLLER_PATH, 'index.ts', ); - assert.fileContent(expectedControllerIndexFile, indexExport[i]); + expectFileToMatchSnapshot(indexFilePath); }); it( @@ -383,43 +353,13 @@ describe('lb4 relation', function() { "'s belonging to " + sourceClassnames[i], async () => { - const getOrdersByCustomerIdRegEx = [ - /\@get\('\/orders\/{id}\/customer', \{\n {4}responses: \{\n {6}'200': \{\n/, - /content: \{\n {10}'application\/json': \{\n/, - /async getCustomer\(\n {4}\@param\.path\.number\('id'\) id: typeof Order\.prototype\.id,\n/, - /\)\: Promise \{\n/, - /return this\.orderRepository\.customer\(id\);\n {2}\}\n/, - ]; - const getOrdersClassByCustomerClassIdRegEx = [ - /\@get\('\/order-classes\/{id}\/customer-class', \{\n {4}responses: \{\n {6}'200': \{\n/, - /content: \{\n {10}'application\/json': \{\n/, - /async getCustomerClass\(\n {4}\@param\.path\.number\('id'\) id: typeof OrderClass\.prototype\.orderNumber,\n/, - /\)\: Promise \{\n/, - /return this\.orderClassRepository\.customerClass\(id\);\n {2}\}\n/, - ]; - - const getOrdersClassTypeByCustomerClassTypeIdRegEx = [ - /\@get\('\/order-class-types\/{id}\/customer-class-type', \{\n {4}responses: \{\n {6}'200': \{\n/, - /content: \{\n {10}'application\/json': \{\n/, - /async getCustomerClassType\(\n {4}\@param\.path\.string\('id'\) id: typeof OrderClassType\.prototype\.orderString,\n/, - /\)\: Promise \{\n/, - /return this\.orderClassTypeRepository\.customerClassType\(id\);\n {2}\}\n/, - ]; - - const getRegEx = [ - getOrdersByCustomerIdRegEx, - getOrdersClassByCustomerClassIdRegEx, - getOrdersClassTypeByCustomerClassTypeIdRegEx, - ]; - - const expectedControllerFile = path.join( + const filePath = path.join( SANDBOX_PATH, CONTROLLER_PATH, controllerFileName[i], ); - getRegEx[i].forEach(regex => { - assert.fileContent(expectedControllerFile, regex); - }); + + expectFileToMatchSnapshot(filePath); }, ); } @@ -466,88 +406,28 @@ describe('lb4 relation', function() { }); it(sourceClassnames[i] + ' repostitory has all imports', async () => { - const repositoryBasicImports = [ - /import \{DefaultCrudRepository, repository, BelongsToAccessor\} from \'@loopback\/repository\';\n/, - /import \{inject, Getter\} from '\@loopback\/core';/, - ]; - - const repositoryClassImport = [ - /import \{CustomerRepository\} from '\.\/customer\.repository';/, - /import \{Order, Customer\} from '\.\.\/models';/, - ]; - const repositoryMultiWordClassImport = [ - /import \{CustomerClassRepository\} from '\.\/customer-class\.repository';/, - /import \{OrderClass, CustomerClass\} from '\.\.\/models';/, - ]; - - const repositoryTypeClassImport = [ - /import \{CustomerClassTypeRepository\} from '\.\/customer-class-type\.repository';/, - /import \{OrderClassType, CustomerClassType\} from '\.\.\/models';/, - ]; - - const sourceRepositoryFile = path.join( + const sourceFilePath = path.join( SANDBOX_PATH, REPOSITORY_APP_PATH, repositoryFileName[i], ); - repositoryBasicImports.forEach(regex => { - assert.fileContent(sourceRepositoryFile, regex); - }); - - const importRegEx = [ - repositoryClassImport, - repositoryMultiWordClassImport, - repositoryTypeClassImport, - ]; - - importRegEx[i].forEach(regex => { - assert.fileContent(sourceRepositoryFile, regex); - }); + assert.file(sourceFilePath); + expectFileToMatchSnapshot(sourceFilePath); }); it('repository has updated constructor', async () => { - const singleWordClassConstractor = [ - /public readonly customer: BelongsToAccessor;\n/, - /constructor\(@inject\('datasources\.db'\) dataSource: DbDataSource, @repository\.getter\('CustomerRepository'\) protected customerRepositoryGetter: Getter,\) \{\n/, - /super\(Order, dataSource\);\n {4}this\.customer = this\.createBelongsToAccessorFor\('customer', customerRepositoryGetter,\);\n {2}\}\n/, - ]; - - const multiWordClassConstractor = [ - /public readonly customerClass: BelongsToAccessor;\n/, - /constructor\(@inject\('datasources\.myDB'\) dataSource: MyDBDataSource, @repository\.getter\('CustomerClassRepository'\) protected customerClassRepositoryGetter: Getter,\) \{\n/, - /super\(OrderClass, dataSource\);\n {4}this\.customerClass = this\.createBelongsToAccessorFor\('customerClassCustNumber', customerClassRepositoryGetter,\);\n {2}\}\n/, - ]; - - const typeClassConstractor = [ - /public readonly customerClassType: BelongsToAccessor;\n/, - /constructor\(@inject\('datasources\.myDB'\) dataSource: MyDBDataSource, @repository\.getter\('CustomerClassTypeRepository'\) protected customerClassTypeRepositoryGetter: Getter,\) \{\n/, - /super\(OrderClassType, dataSource\);\n {4}this\.customerClassType = this\.createBelongsToAccessorFor\('customerClassTypeCustNumber', customerClassTypeRepositoryGetter,\);\n {2}\}\n/, - ]; - - const sourceRepositoryFile = path.join( + const sourceFilePath = path.join( SANDBOX_PATH, REPOSITORY_APP_PATH, repositoryFileName[i], ); - const updateConstructorRegEx = [ - singleWordClassConstractor, - multiWordClassConstractor, - typeClassConstractor, - ]; - updateConstructorRegEx[i].forEach(regex => { - assert.fileContent(sourceRepositoryFile, regex); - }); + expectFileToMatchSnapshot(sourceFilePath); }); } context('generate model relation for existing property name', () => { - const expectedDecoretor = [ - /@belongsTo\(\(\) => Customer\)\n {2}myCustomer: number;\n/, - /@belongsTo\(\(\) => CustomerClass\)\n {2}myCustomer: number;\n/, - /@belongsTo\(\(\) => CustomerClassType\)\n {2}myCustomer: number;\n/, - ]; const promptList = [ { relationType: 'belongsTo', @@ -568,19 +448,14 @@ describe('lb4 relation', function() { ) .withPrompts(promptList[0]); - const expectedSourceFile = path.join( + const sourceFilePath = path.join( SANDBOX_PATH, MODEL_APP_PATH, sourceFileName[0], ); - assert.file(expectedSourceFile); - assert.fileContent(expectedSourceFile, expectedDecoretor[0]); - - const data = fs.readFileSync(expectedSourceFile); - const indexOfFirstRelation = data.indexOf('@belongsTo'); - const lastIndexOfRelation = data.lastIndexOf('@belongsTo'); - assert.equal(indexOfFirstRelation, lastIndexOfRelation); + assert.file(sourceFilePath); + expectFileToMatchSnapshot(sourceFilePath); }); }); }); diff --git a/packages/cli/test/integration/generators/relation.has-many.integration.js b/packages/cli/test/integration/generators/relation.has-many.integration.js index 11bf0762f679..ed478574ee36 100644 --- a/packages/cli/test/integration/generators/relation.has-many.integration.js +++ b/packages/cli/test/integration/generators/relation.has-many.integration.js @@ -8,6 +8,7 @@ const path = require('path'); const assert = require('yeoman-assert'); const {expect, TestSandbox} = require('@loopback/testlab'); +const {expectFileToMatchSnapshot} = require('../../snapshots'); const generator = path.join(__dirname, '../../../generators/relation'); const {SANDBOX_FILES, SourceEntries} = require('../../fixtures/relation'); @@ -21,7 +22,6 @@ const REPOSITORY_APP_PATH = 'src/repositories'; const sandbox = new TestSandbox(SANDBOX_PATH); -const hasManyrImportRegEx = /import \{Entity, model, property, hasMany\} from '@loopback\/repository';\n/; const sourceFileName = [ 'customer.model.ts', 'customer-class.model.ts', @@ -116,17 +116,6 @@ describe('lb4 relation HasMany', function() { }, ]; - const expectedImport = [ - /import \{Order\} from '\.\/order\.model';\n/, - /import \{OrderClass\} from '\.\/order-class\.model';\n/, - /import \{OrderClassType\} from '\.\/order-class-type\.model';\n/, - ]; - const expectedDecoretor = [ - /\@hasMany\(\(\) => Order\)\n {2}orders: Order\[\];\n/, - /\@hasMany\(\(\) => OrderClass ,\{keyTo: 'customerClassCustNumber'\}\)/, - /\@hasMany\(\(\) => OrderClassType ,\{keyTo: 'customerClassTypeCustNumber'\}\)/, - ]; - promptArray.forEach(function(multiItemPrompt, i) { describe('answers ' + JSON.stringify(multiItemPrompt), () => { suite(multiItemPrompt, i); @@ -146,18 +135,14 @@ describe('lb4 relation HasMany', function() { .withPrompts(multiItemPrompt); }); - it('add import hasMany, import for target model and hasMany decorator ', async () => { - const expectedSourceFile = path.join( + it('add import hasMany, import for target model and hasMany decorator', async () => { + const sourceFilePath = path.join( SANDBOX_PATH, MODEL_APP_PATH, sourceFileName[i], ); - - assert.file(expectedSourceFile); - assert.fileContent(expectedSourceFile, hasManyrImportRegEx); - assert.fileContent(expectedSourceFile, expectedImport[i]); - - assert.fileContent(expectedSourceFile, expectedDecoretor[i]); + assert.file(sourceFilePath); + expectFileToMatchSnapshot(sourceFilePath); }); } }); @@ -184,22 +169,6 @@ describe('lb4 relation HasMany', function() { }, ]; - const expectedImport = [ - /import \{Order\} from '\.\/order\.model';\n/, - /import \{OrderClass\} from '\.\/order-class\.model';\n/, - /import \{OrderClassType\} from '\.\/order-class-type\.model';\n/, - ]; - const expectedDecoretor = [ - /\@hasMany\(\(\) => Order\)\n {2}myOrders: Order\[\];\n/, - /\@hasMany\(\(\) => OrderClass ,\{keyTo: 'customerClassCustNumber'\}\)/, - /\@hasMany\(\(\) => OrderClassType ,\{keyTo: 'customerClassTypeCustNumber'\}\)/, - ]; - const expectedProperty = [ - /@property\(\{\n {4}type: 'number',\n {2}\}\)\n {2}customerId\?\: number;\n/, - /@property\(\{\n {4}type: 'number',\n {2}\}\)\n {2}customerClassCustNumber\?\: number;\n/, - /@property\(\{\n {4}type: 'number',\n {2}\}\)\n {2}customerClassTypeCustNumber\?\: number;\n/, - ]; - promptArray.forEach(function(multiItemPrompt, i) { describe('answers ' + JSON.stringify(multiItemPrompt), () => { suite(multiItemPrompt, i); @@ -220,25 +189,21 @@ describe('lb4 relation HasMany', function() { }); it('relation name should be myOrders', async () => { - const expectedSourceFile = path.join( + const sourceFilePath = path.join( SANDBOX_PATH, MODEL_APP_PATH, sourceFileName[i], ); - const expectedTargetFile = path.join( + const targetFilePath = path.join( SANDBOX_PATH, MODEL_APP_PATH, targetFileName[i], ); - assert.file(expectedSourceFile); - assert.fileContent(expectedSourceFile, hasManyrImportRegEx); - - assert.fileContent(expectedSourceFile, expectedImport[i]); - - assert.fileContent(expectedSourceFile, expectedDecoretor[i]); - - assert.fileContent(expectedTargetFile, expectedProperty[i]); + assert.file(sourceFilePath); + assert.file(targetFilePath); + expectFileToMatchSnapshot(sourceFilePath); + expectFileToMatchSnapshot(targetFilePath); }); } }); @@ -265,18 +230,6 @@ describe('lb4 relation HasMany', function() { }, ]; - const expectedImport = [ - /import \{Order\} from '\.\/order\.model';\n/, - /import \{OrderClass\} from '\.\/order-class\.model';\n/, - /import \{OrderClassType\} from '\.\/order-class-type\.model';\n/, - ]; - const expectedDecoretor = [ - /\@hasMany\(\(\) => Order ,\{keyTo: 'mykey'\}\)\n {2}orders: Order\[\];\n/, - /\@hasMany\(\(\) => OrderClass ,\{keyTo: 'mykey'\}\)\n {2}orderClasses: OrderClass\[\];\n/, - /\@hasMany\(\(\) => OrderClassType ,\{keyTo: 'mykey'\}\)\n {2}orderClassTypes: OrderClassType\[\];\n/, - ]; - const expectedProperty = /@property\(\{\n {4}type: 'number',\n {2}\}\)\n {2}mykey\?\: number;\n/; - promptArray.forEach(function(multiItemPrompt, i) { describe('answers ' + JSON.stringify(multiItemPrompt), () => { suite(multiItemPrompt, i); @@ -297,25 +250,21 @@ describe('lb4 relation HasMany', function() { }); it('add the keyTo to the source model', async () => { - const expectedSourceFile = path.join( + const sourceFilePath = path.join( SANDBOX_PATH, MODEL_APP_PATH, sourceFileName[i], ); - const expectedTargetFile = path.join( + const targetFilePath = path.join( SANDBOX_PATH, MODEL_APP_PATH, targetFileName[i], ); - assert.file(expectedSourceFile); - assert.fileContent(expectedSourceFile, hasManyrImportRegEx); - - assert.fileContent(expectedSourceFile, expectedImport[i]); - - assert.fileContent(expectedSourceFile, expectedDecoretor[i]); - - assert.fileContent(expectedTargetFile, expectedProperty); + assert.file(sourceFilePath); + assert.file(targetFilePath); + expectFileToMatchSnapshot(sourceFilePath); + expectFileToMatchSnapshot(targetFilePath); }); } }); @@ -339,11 +288,6 @@ describe('lb4 relation HasMany', function() { }, ]; - const expectedDecoretor = [ - /\@hasMany\(\(\) => Order\)\n {2}orders: Order\[\];\n/, - /\@hasMany\(\(\) => OrderClass ,\{keyTo: 'customerClassCustNumber'\}\)\n/, - /\@hasMany\(\(\) => OrderClassType ,\{keyTo: 'customerClassTypeCustNumber'\}\)\n/, - ]; const defaultRelationName = ['orders', 'orderClasses', 'orderClassTypes']; promptArray.forEach(function(multiItemPrompt, i) { describe('answers ' + JSON.stringify(multiItemPrompt), () => { @@ -362,13 +306,14 @@ describe('lb4 relation HasMany', function() { ) .withPrompts(multiItemPrompt); - const expectedSourceFile = path.join( + const sourceFilePath = path.join( SANDBOX_PATH, MODEL_APP_PATH, sourceFileName[i], ); - assert.fileContent(expectedSourceFile, expectedDecoretor[i]); + assert.file(sourceFilePath); + expectFileToMatchSnapshot(sourceFilePath); }); } }); @@ -391,24 +336,6 @@ describe('lb4 relation HasMany', function() { destinationModel: 'OrderClassType', }, ]; - const controllerClass = [ - /class CustomerOrderController/, - /class CustomerClassOrderClassController/, - /class CustomerClassTypeOrderClassTypeController/, - ]; - const controllerConstructor = [ - /constructor\(\n {4}\@repository\(CustomerRepository\) protected customerRepository: CustomerRepository,\n {2}\) \{ \}\n/, - /constructor\(\n {4}\@repository\(CustomerClassRepository\) protected customerClassRepository: CustomerClassRepository,\n {2}\) \{ \}\n/, - /constructor\(\n {4}\@repository\(CustomerClassTypeRepository\) protected customerClassTypeRepository: CustomerClassTypeRepository,\n {2}\) \{ \}\n/, - ]; - - const indexExport = [ - /export \* from '\.\/customer-order\.controller';/, - /export \* from '\.\/customer-class-order-class\.controller';/, - /export \* from '\.\/customer-class-type-order-class-type\.controller';/, - ]; - const sourceClassnames = ['Customer', 'CustomerClass', 'CustomerClassType']; - const targetClassnames = ['Order', 'OrderClass', 'OrderClassType']; promptArray.forEach(function(multiItemPrompt, i) { describe('answers ' + JSON.stringify(multiItemPrompt), () => { @@ -430,273 +357,22 @@ describe('lb4 relation HasMany', function() { }); it('new controller file created', async () => { - const expectedControllerFile = path.join( + const filePath = path.join( SANDBOX_PATH, CONTROLLER_PATH, controllerFileName[i], ); - assert.file(expectedControllerFile); + assert.file(filePath); }); - it('controller with hasMany class and constructor', async () => { - const expectedControllerFile = path.join( + it('checks controller content with hasMany relation', async () => { + const filePath = path.join( SANDBOX_PATH, CONTROLLER_PATH, controllerFileName[i], ); - assert.fileContent(expectedControllerFile, controllerClass[i]); - assert.fileContent(expectedControllerFile, controllerConstructor[i]); + expectFileToMatchSnapshot(filePath); }); - - it('the new controller file added to index.ts file', async () => { - const expectedControllerIndexFile = path.join( - SANDBOX_PATH, - CONTROLLER_PATH, - 'index.ts', - ); - - assert.fileContent(expectedControllerIndexFile, indexExport[i]); - }); - - it( - 'controller GET Array of ' + - targetClassnames[i] + - "'s belonging to " + - sourceClassnames[i], - async () => { - const getOrdersByCustomerIdRegEx = [ - /\@get\('\/customers\/{id}\/orders', {\n {4}responses: {\n {6}'200': {\n/, - /description: 'Array of Order\\'s belonging to Customer',\n/, - /content: {\n {10}'application\/json': {\n/, - /schema: {type: 'array', items: getModelSchemaRef\(Order\)},/, - /},\n . {6}},\n . {4}},\n . {2}},\n {2}}\)\n/, - /async find\(\n . {2}\@param.path.number\('id'\) id: number,\n/, - /\@param.query.object\('filter'\) filter\?: Filter,\n/, - /\)\: Promise {\n/, - /return this\.customerRepository\.orders\(id\)\.find\(filter\);\n {2}}\n/, - ]; - const getOrdersClassByCustomerClassIdRegEx = [ - /\@get\('\/customer-classes\/{id}\/order-classes', {\n {4}responses: {\n {6}'200': {\n/, - /description: 'Array of OrderClass\\'s belonging to CustomerClass',\n/, - /content: {\n {10}'application\/json': {\n/, - /schema: {type: 'array', items: getModelSchemaRef\(OrderClass\)},/, - /},\n . {6}},\n . {4}},\n . {2}},\n {2}}\)\n/, - /async find\(\n . {2}\@param.path.number\('id'\) id: number,\n/, - /\@param.query.object\('filter'\) filter\?: Filter,\n/, - /\)\: Promise {\n/, - /return this\.customerClassRepository\.orderClasses\(id\)\.find\(filter\);\n {2}}\n/, - ]; - const getOrdersClassTypeByCustomerClassTypeIdRegEx = [ - /\@get\('\/customer-class-types\/{id}\/order-class-types', {\n {4}responses: {\n {6}'200': {\n/, - /description: 'Array of OrderClassType\\'s belonging to CustomerClassType',\n/, - /content: {\n {10}'application\/json': {\n/, - /schema: {type: 'array', items: getModelSchemaRef\(OrderClassType\)},/, - /},\n . {6}},\n . {4}},\n . {2}},\n {2}}\)\n/, - /async find\(\n . {2}\@param.path.number\('id'\) id: number,\n/, - /\@param.query.object\('filter'\) filter\?: Filter,\n/, - /\)\: Promise {\n/, - /return this\.customerClassTypeRepository\.orderClassTypes\(id\).find\(filter\);\n {2}}\n/, - ]; - - const getRegEx = [ - getOrdersByCustomerIdRegEx, - getOrdersClassByCustomerClassIdRegEx, - getOrdersClassTypeByCustomerClassTypeIdRegEx, - ]; - - const expectedControllerFile = path.join( - SANDBOX_PATH, - CONTROLLER_PATH, - controllerFileName[i], - ); - getRegEx[i].forEach(regex => { - assert.fileContent(expectedControllerFile, regex); - }); - }, - ); - - it( - 'controller POST ' + targetClassnames[i] + ' to ' + sourceClassnames[i], - async () => { - const postClassCreateRegEx = [ - /\@post\('\/customers\/{id}\/orders', {\n {4}responses: {\n {6}'200': {\n/, - /description: 'Customer model instance',\n/, - /content: {'application\/json': {schema: getModelSchemaRef\(Order\)}},\n/, - /},\n . {2}},\n .}\)\n {2}async create\(\n/, - /\@param\.path\.number\('id'\) id: typeof Customer\.prototype\.id,\n/, - /\@requestBody\(\{\s+content: {\s+'application\/json': {\s+schema: getModelSchemaRef\(Order, {\n/, - /title: 'NewOrderInCustomer',\n/, - /exclude: \['id'\],\n/, - /optional: \['customerId'\]\n/, - /}\),\s+},\s+},\s+}\) order: Omit,\n/, - /\): Promise {\n/, - /return this\.customerRepository\.orders\(id\)\.create\(order\);\n {2}}\n/, - ]; - const postMultiWordClassCreateRegEx = [ - /\@post\('\/customer-classes\/{id}\/order-classes', {\n {4}responses: {\n {6}'200': {\n/, - /description: 'CustomerClass model instance',\n/, - /content: {'application\/json': {schema: getModelSchemaRef\(OrderClass\)}},\n/, - /},\n . {2}},\n .}\)\n {2}async create\(\n/, - /\@param\.path\.number\('id'\) id: typeof CustomerClass\.prototype\.custNumber,\n/, - /\@requestBody\(\{\s+content: {\s+'application\/json': {\s+schema: getModelSchemaRef\(OrderClass, {\n/, - /title: 'NewOrderClassInCustomerClass',\n/, - /exclude: \['orderNumber'\],\n/, - /optional: \['customerClassCustNumber'\]\n/, - /}\),\s+},\s+},\s+}\) orderClass: Omit,\n/, - /\): Promise {\n/, - /return this\.customerClassRepository\.orderClasses\(id\)\.create\(orderClass\);\n {2}}\n/, - ]; - const postTypeClassCreateRegEx = [ - /\@post\('\/customer-class-types\/{id}\/order-class-types', {\n {4}responses: {\n {6}'200': {\n/, - /description: 'CustomerClassType model instance',\n/, - /content: {'application\/json': {schema: getModelSchemaRef\(OrderClassType\)}},\n/, - /},\n . {2}},\n .}\)\n {2}async create\(\n/, - /\@param\.path\.number\('id'\) id: typeof CustomerClassType\.prototype\.custNumber,\n/, - /\@requestBody\(\{\s+content: {\s+'application\/json': {\s+schema: getModelSchemaRef\(OrderClassType, {\n/, - /title: 'NewOrderClassTypeInCustomerClassType',\n/, - /exclude: \['orderString'\],\n/, - /optional: \['customerClassTypeCustNumber'\]\n/, - /}\),\s+},\s+},\s+}\) orderClassType: Omit,\n/, - /\): Promise {\n/, - /return this\.customerClassTypeRepository\.orderClassTypes\(id\)\.create\(orderClassType\);\n {2}}\n/, - ]; - - const expectedControllerFile = path.join( - SANDBOX_PATH, - CONTROLLER_PATH, - controllerFileName[i], - ); - - const postRegEx = [ - postClassCreateRegEx, - postMultiWordClassCreateRegEx, - postTypeClassCreateRegEx, - ]; - - postRegEx[i].forEach(regex => { - assert.fileContent(expectedControllerFile, regex); - }); - }, - ); - - it( - 'controller ' + - targetClassnames[i] + - ' PATCH by ' + - sourceClassnames[i] + - ' id', - async () => { - const updateOrderByCustomerIdRegEx = [ - /\@patch\('\/customers\/{id}\/orders', {\n {4}responses: {\n {6}'200': {\n/, - /description: 'Customer.Order PATCH success count',\n/, - /content: {'application\/json': {schema: CountSchema}},\n/, - /},\n {4}},\n {2}}\)\n {2}async patch\(\n/, - /\@param\.path\.number\('id'\) id: number,\n {4}/, - /\@requestBody\({\s+content: {\s+'application\/json': {\s+schema: getModelSchemaRef\(Order, {partial: true}\),\s+},\s+},\s+}\)\s+order: Partial,\n/, - /\@param\.query\.object\('where', getWhereSchemaFor\(Order\)\) where\?: Where,\n/, - /\): Promise {\n/, - /return this\.customerRepository\.orders\(id\).patch\(order, where\);\n {2}}\n/, - ]; - - const updateOrderClassByCustomerClassIdRegEx = [ - /\@patch\('\/customer-classes\/{id}\/order-classes', {\n {4}responses: {\n {6}'200': {\n/, - /description: 'CustomerClass.OrderClass PATCH success count',\n/, - /content: {'application\/json': {schema: CountSchema}},\n/, - /},\n {4}},\n {2}}\)\n {2}async patch\(\n/, - /\@param\.path\.number\('id'\) id: number,\n {4}/, - /\@requestBody\({\s+content: {\s+'application\/json': {\s+schema: getModelSchemaRef\(OrderClass, {partial: true}\),\s+},\s+},\s+}\)\s+orderClass: Partial,\n/, - /\@param\.query\.object\('where', getWhereSchemaFor\(OrderClass\)\) where\?: Where,\n/, - /\): Promise {\n/, - /return this\.customerClassRepository\.orderClasses\(id\)\.patch\(orderClass, where\);\n {2}}\n/, - ]; - - const updateOrderClassByCustomerClassTypeIdRegEx = [ - /\@patch\('\/customer-class-types\/{id}\/order-class-types', {\n {4}responses: {\n {6}'200': {\n/, - /description: 'CustomerClassType.OrderClassType PATCH success count',\n/, - /content: {'application\/json': {schema: CountSchema}},\n/, - /},\n {4}},\n {2}}\)\n {2}async patch\(\n/, - /\@param\.path\.number\('id'\) id: number,\n {4}/, - /\@requestBody\({\s+content: {\s+'application\/json': {\s+schema: getModelSchemaRef\(OrderClassType, {partial: true}\),\s+},\s+},\s+}\)\s+orderClassType: Partial,\n/, - /\@param\.query\.object\('where', getWhereSchemaFor\(OrderClassType\)\) where\?: Where,\n/, - /\): Promise {\n/, - /return this\.customerClassTypeRepository\.orderClassTypes\(id\).patch\(orderClassType, where\);\n {2}}\n/, - ]; - - const expectedControllerFile = path.join( - SANDBOX_PATH, - CONTROLLER_PATH, - controllerFileName[i], - ); - - const updateRegEx = [ - updateOrderByCustomerIdRegEx, - updateOrderClassByCustomerClassIdRegEx, - updateOrderClassByCustomerClassTypeIdRegEx, - ]; - - updateRegEx[i].forEach(regex => { - assert.fileContent(expectedControllerFile, regex); - }); - }, - ); - - it( - 'controller ' + - targetClassnames[i] + - ' DELETE by ' + - sourceClassnames[i] + - ' id', - async () => { - const deleteOrderByCustomerIdRegEx = [ - /\@del\('\/customers\/{id}\/orders', {\n {4}responses: {\n {6}'200': {\n/, - /description: 'Customer.Order DELETE success count',\n/, - /content: {'application\/json': {schema: CountSchema}},\n/, - /},\n {4}},\n {2}}\)\n {2}async delete\(\n/, - /\@param\.path\.number\('id'\) id: number,\n /, - /\@param\.query\.object\('where', getWhereSchemaFor\(Order\)\) where\?: Where,\n/, - /\): Promise {\n/, - /return this\.customerRepository\.orders\(id\)\.delete\(where\);\n {2}}\n}\n/, - ]; - - const deleteOrderClassByCustomerClassIdRegEx = [ - /\@del\('\/customer-classes\/{id}\/order-classes', {\n {4}responses: {\n {6}'200': {\n/, - /description: 'CustomerClass.OrderClass DELETE success count',\n/, - /content: {'application\/json': {schema: CountSchema}},\n/, - /},\n {4}},\n {2}}\)\n {2}async delete\(\n/, - /\@param\.path\.number\('id'\) id: number,\n /, - /\@param\.query\.object\('where', getWhereSchemaFor\(OrderClass\)\) where\?: Where,\n/, - /\): Promise {\n/, - /return this\.customerClassRepository\.orderClasses\(id\)\.delete\(where\);\n {2}}\n}\n/, - ]; - - const deleteOrderClassTypeByCustomerClassTypeIdRegEx = [ - /\@del\('\/customer-class-types\/{id}\/order-class-types', {\n {4}responses: {\n {6}'200': {\n/, - /description: 'CustomerClassType.OrderClassType DELETE success count',\n/, - /content: {'application\/json': {schema: CountSchema}},\n/, - /},\n {4}},\n {2}}\)\n {2}async delete\(\n/, - /\@param\.path\.number\('id'\) id: number,\n /, - /\@param\.query\.object\('where', getWhereSchemaFor\(OrderClassType\)\) where\?: Where,\n/, - /\): Promise {\n/, - /return this\.customerClassTypeRepository\.orderClassTypes\(id\)\.delete\(where\);\n {2}}\n}\n/, - ]; - - const expectedControllerFile = path.join( - SANDBOX_PATH, - CONTROLLER_PATH, - controllerFileName[i], - ); - - const deleteRegEx = [ - deleteOrderByCustomerIdRegEx, - deleteOrderClassByCustomerClassIdRegEx, - deleteOrderClassTypeByCustomerClassTypeIdRegEx, - ]; - - deleteRegEx[i].forEach(regex => { - assert.fileContent(expectedControllerFile, regex); - }); - }, - ); } }); @@ -739,79 +415,20 @@ describe('lb4 relation HasMany', function() { .withPrompts(multiItemPrompt); }); - it(sourceClassnames[i] + ' repository has all imports', async () => { - const repositoryBasicImports = [ - /repository, HasManyRepositoryFactory} from '\@loopback\/repository';\n/, - /import \{inject, Getter\} from '\@loopback\/core';/, - ]; - - const repositoryClassImport = [ - /import \{OrderRepository\} from '\.\/order\.repository';/, - /import \{Customer, Order\} from '\.\.\/models';/, - ]; - const repositoryMultiWordClassImport = [ - /import \{OrderClassRepository\} from '\.\/order-class\.repository';/, - /import \{CustomerClass, OrderClass\} from '\.\.\/models';/, - ]; - const repositoryTypeClassImport = [ - /import \{OrderClassTypeRepository\} from '\.\/order-class-type\.repository';/, - /import \{CustomerClassType, OrderClassType\} from '\.\.\/models';/, - ]; - - const sourceRepositoryFile = path.join( - SANDBOX_PATH, - REPOSITORY_APP_PATH, - repositoryFileName[i], - ); - - repositoryBasicImports.forEach(regex => { - assert.fileContent(sourceRepositoryFile, regex); - }); - - const importRegEx = [ - repositoryClassImport, - repositoryMultiWordClassImport, - repositoryTypeClassImport, - ]; - - importRegEx[i].forEach(regex => { - assert.fileContent(sourceRepositoryFile, regex); - }); - }); - - it('repository has updated constructor', async () => { - const singleWordClassConstractor = [ - /public readonly orders: HasManyRepositoryFactory;\n/, - /constructor\(\@inject\('datasources\.db'\) dataSource: DbDataSource, \@repository\.getter\('OrderRepository'\) protected orderRepositoryGetter: Getter,\) \{\n/, - /super\(Customer, dataSource\);\n {4}this.orders = this.createHasManyRepositoryFactoryFor\('orders', orderRepositoryGetter,\);\n {2}\}\n/, - ]; - - const multiWordClassConstractor = [ - /public readonly orderClasses: HasManyRepositoryFactory;\n/, - /constructor\(\@inject\('datasources\.myDB'\) dataSource: MyDBDataSource, \@repository\.getter\('OrderClassRepository'\) protected orderClassRepositoryGetter: Getter,\) \{\n/, - /super\(CustomerClass, dataSource\);\n {4}this\.orderClasses = this\.createHasManyRepositoryFactoryFor\('orderClasses', orderClassRepositoryGetter,\);\n {2}\}\n/, - ]; - const typeClassConstractor = [ - /public readonly orderClassTypes: HasManyRepositoryFactory;\n/, - /constructor\(@inject\('datasources\.myDB'\) dataSource: MyDBDataSource, @repository\.getter\('OrderClassTypeRepository'\) protected orderClassTypeRepositoryGetter: Getter,\) \{\n/, - /super\(CustomerClassType, dataSource\);\n {4}this\.orderClassTypes = this\.createHasManyRepositoryFactoryFor\('orderClassTypes', orderClassTypeRepositoryGetter,\);\n {2}\}/, - ]; - - const sourceRepositoryFile = path.join( - SANDBOX_PATH, - REPOSITORY_APP_PATH, - repositoryFileName[i], - ); + it( + 'checks if ' + + sourceClassnames[i] + + ' repository has generated correctly', + async () => { + const sourceFilePath = path.join( + SANDBOX_PATH, + REPOSITORY_APP_PATH, + repositoryFileName[i], + ); - const updateConstructorRegEx = [ - singleWordClassConstractor, - multiWordClassConstractor, - typeClassConstractor, - ]; - updateConstructorRegEx[i].forEach(regex => { - assert.fileContent(sourceRepositoryFile, regex); - }); - }); + expectFileToMatchSnapshot(sourceFilePath); + }, + ); } }); });