@loopback/repository-tests 0.20.2 → 0.21.2

package/src/crud/relations/acceptance/has-one.inclusion-resolver.polymorphic.acceptance.ts

@@ -0,0 +1,208 @@
+// Copyright IBM Corp. and LoopBack contributors 2019,2020. All Rights Reserved.
+// Node module: @loopback/repository-tests
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import {expect, skipIf, toJSON} from '@loopback/testlab';
+import {Suite} from 'mocha';
+import {
+  CrudFeatures,
+  CrudRepositoryCtor,
+  CrudTestContext,
+  DataSourceOptions,
+} from '../../..';
+import {
+  deleteAllModelsInDefaultDataSource,
+  withCrudCtx,
+} from '../../../helpers.repository-tests';
+import {
+  CardInfoRepository,
+  Cash,
+  CashRepository,
+  CreditCard,
+  CreditCardRepository,
+  Customer,
+  CustomerRepository,
+} from '../fixtures/models';
+import {givenBoundCrudRepositories} from '../helpers';
+
+export function hasOneInclusionResolverPolymorphicAcceptance(
+  dataSourceOptions: DataSourceOptions,
+  repositoryClass: CrudRepositoryCtor,
+  features: CrudFeatures,
+) {
+  skipIf<[(this: Suite) => void], void>(
+    !features.supportsInclusionResolvers,
+    describe,
+    'HasOne inclusion resolvers - polymorphic - acceptance',
+    suite,
+  );
+  function suite() {
+    before(deleteAllModelsInDefaultDataSource);
+    let customerRepo: CustomerRepository;
+    let creditCardRepo: CreditCardRepository;
+    let cashRepo: CashRepository;
+    let cardInfoRepo: CardInfoRepository;
+
+    before(
+      withCrudCtx(async function setupRepository(ctx: CrudTestContext) {
+        // this helper should create the inclusion resolvers and also
+        // register inclusion resolvers for us
+        ({customerRepo, creditCardRepo, cashRepo, cardInfoRepo} =
+          givenBoundCrudRepositories(
+            ctx.dataSource,
+            repositoryClass,
+            features,
+          ));
+        expect(customerRepo.paymentMethod.inclusionResolver).to.be.Function();
+
+        await ctx.dataSource.automigrate([
+          Customer.name,
+          CreditCard.name,
+          Cash.name,
+        ]);
+      }),
+    );
+
+    beforeEach(async () => {
+      await customerRepo.deleteAll();
+      await creditCardRepo.deleteAll();
+      await cashRepo.deleteAll();
+      await cardInfoRepo.deleteAll();
+    });
+
+    it('throws an error if it tries to query nonexistent relation names', async () => {
+      const customer = await customerRepo.create({
+        name: 'customer',
+        paymentMethodType: 'CreditCard',
+      });
+      await creditCardRepo.create({
+        customerId: customer.id,
+      });
+      await expect(customerRepo.find({include: ['home']})).to.be.rejectedWith(
+        `Invalid "filter.include" entries: "home"`,
+      );
+    });
+
+    it('returns single model instance including single related instance', async () => {
+      const thor = await customerRepo.create({
+        name: 'Thor',
+        paymentMethodType: 'CreditCard',
+      });
+      const thorCreditCard = await creditCardRepo.create({
+        customerId: thor.id,
+      });
+      const result = await customerRepo.find({
+        include: ['paymentMethod'],
+      });
+
+      const expected = {
+        ...thor,
+        parentId: features.emptyValue,
+        paymentMethod: thorCreditCard,
+      };
+      expect(toJSON(result)).to.deepEqual([toJSON(expected)]);
+    });
+
+    it('returns multiple model instances including related instances', async () => {
+      const thor = await customerRepo.create({
+        name: 'Thor',
+        paymentMethodType: 'Cash',
+      });
+      const odin = await customerRepo.create({
+        name: 'Odin',
+        paymentMethodType: 'CreditCard',
+      });
+      const thorCash = await cashRepo.create({
+        customerId: thor.id,
+      });
+      const odinCreditCard = await creditCardRepo.create({
+        customerId: odin.id,
+      });
+
+      const result = await customerRepo.find({
+        include: ['paymentMethod'],
+      });
+
+      const expected = [
+        {
+          ...thor,
+          parentId: features.emptyValue,
+          paymentMethod: thorCash,
+        },
+        {
+          ...odin,
+          parentId: features.emptyValue,
+          paymentMethod: odinCreditCard,
+        },
+      ];
+      expect(toJSON(result)).to.deepEqual(toJSON(expected));
+    });
+
+    it('returns a specified instance including its related model instance', async () => {
+      const thor = await customerRepo.create({
+        name: 'Thor',
+        paymentMethodType: 'Cash',
+      });
+      const odin = await customerRepo.create({
+        name: 'Odin',
+        paymentMethodType: 'CreditCard',
+      });
+      const bella = await customerRepo.create({
+        name: 'Bella',
+        paymentMethodType: 'CreditCard',
+      });
+      await cashRepo.create({
+        customerId: thor.id,
+      });
+      await creditCardRepo.create({
+        customerId: odin.id,
+      });
+      const bellaPaymentMethod = await creditCardRepo.create({
+        customerId: bella.id,
+      });
+      const bellaCardInfo = await creditCardRepo
+        .cardInfo(bellaPaymentMethod.id)
+        .create({cardHolder: 'bella!'});
+      bellaPaymentMethod.cardInfo = bellaCardInfo;
+      const result = await customerRepo.findById(bella.id, {
+        include: [
+          {
+            relation: 'paymentMethod',
+            scope: {
+              include: [
+                {
+                  relation: 'cardInfo',
+                  targetType: 'CreditCard',
+                },
+              ],
+            },
+          },
+        ],
+      });
+
+      const expected = {
+        ...bella,
+        parentId: features.emptyValue,
+        paymentMethod: bellaPaymentMethod,
+      };
+      expect(toJSON(result)).to.deepEqual(toJSON(expected));
+    });
+
+    it('throws error if the target repository does not have the registered resolver', async () => {
+      const customer = await customerRepo.create({
+        name: 'customer',
+        paymentMethodType: 'CreditCard',
+      });
+      await creditCardRepo.create({
+        customerId: customer.id,
+      });
+      // unregister the resolver
+      customerRepo.inclusionResolvers.delete('paymentMethod');
+
+      await expect(
+        customerRepo.find({include: ['paymentMethod']}),
+      ).to.be.rejectedWith(`Invalid "filter.include" entries: "paymentMethod"`);
+    });
+  }
+}

package/src/crud/relations/acceptance/has-one.relation.acceptance.ts

@@ -1,4 +1,4 @@
-// Copyright IBM Corp. 2019,2020. All Rights Reserved.
+// Copyright IBM Corp. and LoopBack contributors 2019,2020. All Rights Reserved.
 // Node module: @loopback/repository-tests
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT

package/src/crud/relations/acceptance/has-one.relation.polymorphic.acceptance.ts

@@ -0,0 +1,328 @@
+// Copyright IBM Corp. and LoopBack contributors 2019,2020. All Rights Reserved.
+// Node module: @loopback/repository-tests
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import {DataObject, EntityNotFoundError} from '@loopback/repository';
+import {expect, toJSON} from '@loopback/testlab';
+import {
+  CrudFeatures,
+  CrudRepositoryCtor,
+  CrudTestContext,
+  DataSourceOptions,
+} from '../../..';
+import {
+  deleteAllModelsInDefaultDataSource,
+  MixedIdType,
+  withCrudCtx,
+} from '../../../helpers.repository-tests';
+import {
+  Cash,
+  CashRepository,
+  CreditCard,
+  CreditCardRepository,
+  Customer,
+  CustomerRepository,
+  PaymentMethod,
+} from '../fixtures/models';
+import {givenBoundCrudRepositories} from '../helpers';
+
+export function hasOneRelationPolymorphicAcceptance(
+  dataSourceOptions: DataSourceOptions,
+  repositoryClass: CrudRepositoryCtor,
+  features: CrudFeatures,
+) {
+  describe('hasOne relation polymorphic (acceptance)', () => {
+    let customerRepo: CustomerRepository;
+    let creditCardRepo: CreditCardRepository;
+    let cashRepo: CashRepository;
+    let existingCustomerId: MixedIdType;
+
+    before(deleteAllModelsInDefaultDataSource);
+
+    before(
+      withCrudCtx(async function setupRepository(ctx: CrudTestContext) {
+        ({customerRepo, creditCardRepo, cashRepo} = givenBoundCrudRepositories(
+          ctx.dataSource,
+          repositoryClass,
+          features,
+        ));
+        const models = [Customer, CreditCard, Cash];
+        await ctx.dataSource.automigrate(models.map(m => m.name));
+      }),
+    );
+
+    beforeEach(async () => {
+      await customerRepo.deleteAll();
+      await creditCardRepo.deleteAll();
+      await cashRepo.deleteAll();
+      existingCustomerId = (await givenPersistedCustomerInstance()).id;
+    });
+
+    it('can create an instance of the related model', async () => {
+      const address = await createCustomerPaymentMethod(
+        existingCustomerId,
+        {},
+        'CreditCard',
+      );
+      expect(toJSON(address)).to.containDeep(
+        toJSON({
+          customerId: existingCustomerId,
+        }),
+      );
+
+      const persisted = await creditCardRepo.findById(address.id);
+      expect(toJSON(persisted)).to.deepEqual(
+        toJSON({
+          ...address,
+          zipcode: features.emptyValue,
+          city: features.emptyValue,
+          province: features.emptyValue,
+        }),
+      );
+    });
+
+    // We do not enforce referential integrity at the moment. It is up to
+    // our users to set up unique constraint(s) between related models at the
+    // database level
+    it.skip('refuses to create related model instance twice', async () => {
+      const creditCard = await createCustomerPaymentMethod(
+        existingCustomerId,
+        {},
+        'CreditCard',
+      );
+      await expect(
+        createCustomerPaymentMethod(existingCustomerId, {}, 'Cash'),
+      ).to.be.rejectedWith(/Duplicate entry for PaymentMethod.customerId/);
+      expect(creditCard.toObject()).to.containDeep({
+        customerId: existingCustomerId,
+      });
+
+      const persisted = await creditCardRepo.findById(creditCard.id);
+      expect(persisted.toObject()).to.deepEqual(creditCard.toObject());
+    });
+
+    it('can find instance of the related model', async () => {
+      const creditCard = await createCustomerPaymentMethod(
+        existingCustomerId,
+        {},
+        'CreditCard',
+      );
+      const foundCreditCard = await findCustomerPaymentMethod(
+        existingCustomerId,
+        'CreditCard',
+      );
+      expect(toJSON(foundCreditCard)).to.containEql(toJSON(creditCard));
+      expect(toJSON(foundCreditCard)).to.deepEqual(
+        toJSON({
+          ...creditCard,
+        }),
+      );
+
+      const persisted = await creditCardRepo.find({
+        where: {customerId: existingCustomerId},
+      });
+      expect(persisted[0]).to.deepEqual(foundCreditCard);
+    });
+
+    it('reports EntityNotFound error when related model is deleted', async () => {
+      const paymentMethod = await createCustomerPaymentMethod(
+        existingCustomerId,
+        {},
+        'CreditCard',
+      );
+      await creditCardRepo.deleteById(paymentMethod.id);
+
+      await expect(
+        findCustomerPaymentMethod(existingCustomerId, 'CreditCard'),
+      ).to.be.rejectedWith(EntityNotFoundError);
+    });
+
+    it('can PATCH hasOne instances', async () => {
+      const paymentMethod = await createCustomerPaymentMethod(
+        existingCustomerId,
+        {},
+        'CreditCard',
+      );
+
+      const patchObject = {cardNumber: 46458921} as DataObject<PaymentMethod>;
+      const arePatched = await patchCustomerPaymentMethod(
+        existingCustomerId,
+        {CreditCard: patchObject as DataObject<CreditCard>} as {
+          [polymorphicType: string]: DataObject<CreditCard>;
+        },
+        true,
+      );
+
+      expect(arePatched).to.deepEqual({count: 1});
+      const patchedData = await creditCardRepo.findById(paymentMethod.id);
+
+      expect(toJSON(patchedData)).to.deepEqual(
+        toJSON({
+          id: paymentMethod.id,
+          customerId: existingCustomerId,
+          cardNumber: 46458921,
+        }),
+      );
+    });
+
+    it('patches the related instance only', async () => {
+      const bob = await customerRepo.create({name: 'Bob'});
+      await customerRepo
+        .paymentMethod(bob.id)
+        .create({cardNumber: 12345} as DataObject<PaymentMethod>, {
+          polymorphicType: 'CreditCard',
+        });
+
+      const alice = await customerRepo.create({name: 'Alice'});
+      await customerRepo
+        .paymentMethod(alice.id)
+        .create({cardNumber: 67890} as DataObject<PaymentMethod>, {
+          polymorphicType: 'CreditCard',
+        });
+
+      const result = await patchCustomerPaymentMethod(
+        alice.id,
+        {
+          CreditCard: {
+            cardNumber: 7894512,
+          } as DataObject<CreditCard>,
+        } as {[polymorphicType: string]: DataObject<CreditCard>},
+        true,
+      );
+
+      expect(result).to.deepEqual({count: 1});
+
+      const foundBob = await customerRepo
+        .paymentMethod(bob.id)
+        .get(undefined, {polymorphicType: 'CreditCard'});
+      expect(toJSON(foundBob)).to.containDeep({cardNumber: 12345});
+
+      const foundAlice = await customerRepo
+        .paymentMethod(bob.id)
+        .get(undefined, {polymorphicType: 'CreditCard'});
+      expect(toJSON(foundAlice)).to.containDeep({cardNumber: 12345});
+    });
+
+    it('throws an error when PATCH tries to change the foreignKey', async () => {
+      const anotherId = (await givenPersistedCustomerInstance()).id;
+      await expect(
+        patchCustomerPaymentMethod(
+          existingCustomerId,
+          {
+            CreditCard: {
+              customerId: anotherId,
+            } as DataObject<CreditCard>,
+          } as {[polymorphicType: string]: DataObject<CreditCard>},
+          true,
+        ),
+      ).to.be.rejectedWith(/Property "customerId" cannot be changed!/);
+    });
+
+    it('can DELETE hasOne relation instances', async () => {
+      await createCustomerPaymentMethod(existingCustomerId, {}, 'CreditCard');
+
+      const areDeleted = await deleteCustomerPaymentMethod(
+        existingCustomerId,
+        'CreditCard',
+      );
+      expect(areDeleted).to.deepEqual({count: 1});
+
+      await expect(
+        findCustomerPaymentMethod(existingCustomerId, 'CreditCard'),
+      ).to.be.rejectedWith(EntityNotFoundError);
+    });
+
+    it('deletes the related model instance only', async () => {
+      const bob = await customerRepo.create({name: 'Bob'});
+      await customerRepo
+        .paymentMethod(bob.id)
+        .create({}, {polymorphicType: 'CreditCard'});
+
+      const alice = await customerRepo.create({name: 'Alice'});
+      await customerRepo
+        .paymentMethod(alice.id)
+        .create({}, {polymorphicType: 'Cash'});
+
+      const brown = await customerRepo.create({name: 'Brown'});
+      await customerRepo
+        .paymentMethod(brown.id)
+        .create({}, {polymorphicType: 'Cash'});
+
+      const result = await deleteCustomerPaymentMethod(alice.id, 'Cash');
+
+      expect(result).to.deepEqual({count: 1});
+
+      const found = await cashRepo.find();
+      expect(found).to.have.length(1);
+    });
+
+    it('deletes the related model instance with wrong type', async () => {
+      const bob = await customerRepo.create({name: 'Bob'});
+      await customerRepo
+        .paymentMethod(bob.id)
+        .create({}, {polymorphicType: 'CreditCard'});
+
+      const alice = await customerRepo.create({name: 'Alice'});
+      await customerRepo
+        .paymentMethod(alice.id)
+        .create({}, {polymorphicType: 'Cash'});
+
+      const brown = await customerRepo.create({name: 'Brown'});
+      await customerRepo
+        .paymentMethod(brown.id)
+        .create({}, {polymorphicType: 'Cash'});
+
+      const result = await deleteCustomerPaymentMethod(alice.id, 'CreditCard');
+
+      expect(result).to.deepEqual({count: 0});
+
+      const found = await cashRepo.find();
+      expect(found).to.have.length(2);
+    });
+
+    /*---------------- HELPERS -----------------*/
+
+    async function createCustomerPaymentMethod(
+      customerId: MixedIdType,
+      paymentMethodData: DataObject<PaymentMethod>,
+      polymorphicTypeName: string,
+    ): Promise<PaymentMethod> {
+      return customerRepo
+        .paymentMethod(customerId)
+        .create(paymentMethodData, {polymorphicType: polymorphicTypeName});
+    }
+
+    async function findCustomerPaymentMethod(
+      customerId: MixedIdType,
+      polymorphicType: string,
+    ) {
+      return customerRepo
+        .paymentMethod(customerId)
+        .get(undefined, {polymorphicType: polymorphicType});
+    }
+
+    async function patchCustomerPaymentMethod(
+      customerId: MixedIdType,
+      paymentMethodData: DataObject<PaymentMethod>,
+      isMultipleTypes: boolean,
+    ) {
+      return customerRepo
+        .paymentMethod(customerId)
+        .patch(paymentMethodData, {isPolymorphic: isMultipleTypes});
+    }
+
+    async function deleteCustomerPaymentMethod(
+      customerId: MixedIdType,
+      polymorphicType: string,
+    ) {
+      return customerRepo
+        .paymentMethod(customerId)
+        .delete({polymorphicType: polymorphicType});
+    }
+
+    async function givenPersistedCustomerInstance() {
+      return customerRepo.create({name: 'a customer'});
+    }
+  });
+}

package/src/crud/relations/acceptance/multi-relations-inclusion-resolver.relation.acceptance.ts

@@ -1,4 +1,4 @@
-// Copyright IBM Corp. 2019,2020. All Rights Reserved.
+// Copyright IBM Corp. and LoopBack contributors 2019,2020. All Rights Reserved.
 // Node module: @loopback/repository-tests
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT

package/src/crud/relations/fixtures/models/address.model.ts

@@ -1,4 +1,4 @@
-// Copyright IBM Corp. 2019. All Rights Reserved.
+// Copyright IBM Corp. and LoopBack contributors 2019. All Rights Reserved.
 // Node module: @loopback/repository-tests
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT

package/src/crud/relations/fixtures/models/cart-item.model.ts

@@ -1,4 +1,4 @@
-// Copyright IBM Corp. 2020. All Rights Reserved.
+// Copyright IBM Corp. and LoopBack contributors 2020. All Rights Reserved.
 // Node module: @loopback/repository-tests
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT

package/src/crud/relations/fixtures/models/contact.model.ts

@@ -0,0 +1,56 @@
+// Copyright IBM Corp. and LoopBack contributors 2019. All Rights Reserved.
+// Node module: @loopback/repository-tests
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import {
+  belongsTo,
+  BelongsToAccessor,
+  Entity,
+  EntityCrudRepository,
+  model,
+  property,
+} from '@loopback/repository';
+import {MixedIdType} from '../../../../helpers.repository-tests';
+import {CustomerWithRelations} from './customer.model';
+import {Stakeholder} from './stakeholder.model';
+
+@model()
+export class Contact extends Entity {
+  @property({
+    id: true,
+    generated: true,
+    useDefaultIdType: true,
+  })
+  id: MixedIdType;
+  @property({
+    type: 'string',
+  })
+  name: string;
+  @property({
+    type: 'string',
+  })
+  email: string;
+
+  @belongsTo(() => Stakeholder, {polymorphic: true})
+  stakeholderId: MixedIdType;
+
+  @property({
+    type: 'string',
+    required: true,
+    default: 'Customer',
+  })
+  stakeholderType: string;
+}
+
+export interface ContactRelations {
+  stakeholder?: CustomerWithRelations;
+}
+
+export type ContactWithRelations = Contact & ContactRelations;
+
+export interface ContactRepository
+  extends EntityCrudRepository<Contact, typeof Contact.prototype.id> {
+  // define additional members like relation methods here
+  stakeholder: BelongsToAccessor<Stakeholder, MixedIdType>;
+}

package/src/crud/relations/fixtures/models/customer-cart-item-link.model.ts

@@ -1,4 +1,4 @@
-// Copyright IBM Corp. 2020. All Rights Reserved.
+// Copyright IBM Corp. and LoopBack contributors 2020. All Rights Reserved.
 // Node module: @loopback/repository-tests
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT

package/src/crud/relations/fixtures/models/customer-promotion-link.model.ts

@@ -0,0 +1,52 @@
+// Copyright IBM Corp. and LoopBack contributors 2020. All Rights Reserved.
+// Node module: @loopback/repository-tests
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import {
+  Entity,
+  EntityCrudRepository,
+  model,
+  property,
+} from '@loopback/repository';
+import {MixedIdType} from '../../../../helpers.repository-tests';
+
+@model()
+export class CustomerPromotionLink extends Entity {
+  @property({
+    id: true,
+    generated: true,
+    useDefaultIdType: true,
+  })
+  id: MixedIdType;
+
+  @property()
+  customerId: MixedIdType;
+
+  @property()
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  promotion_id: MixedIdType;
+
+  @property({
+    type: 'string',
+    default: 'HalfPrice',
+    required: true,
+  })
+  promotiontype: string;
+
+  @property({
+    type: 'string',
+  })
+  description?: string;
+}
+
+export interface CustomerPromotionLinkRelations {}
+
+export type CustomerPromotionLinkWithRelations = CustomerPromotionLink &
+  CustomerPromotionLinkRelations;
+
+export interface CustomerPromotionLinkRepository
+  extends EntityCrudRepository<
+    CustomerPromotionLink,
+    typeof CustomerPromotionLink.prototype.id
+  > {}