generator-jhipster 7.7.0 → 7.9.0

package/generators/entity-client/templates/angular/src/main/webapp/app/entities/route/entity-management-routing-resolve.service.spec.ts.ejs

@@ -26,7 +26,7 @@ import { ActivatedRouteSnapshot, ActivatedRoute, Router, convertToParamMap } fro
 import { RouterTestingModule } from '@angular/router/testing';
 import { of } from 'rxjs';
 
-import { I<%= entityAngularName %>, <%= entityAngularName %> } from '../<%= entityFileName %>.model';
+import { I<%= entityAngularName %> } from '../<%= entityFileName %>.model';
 import { <%= entityAngularName %>Service } from '../service/<%= entityFileName %>.service';
 
 import { <%= entityAngularName %>RoutingResolveService } from './<%= entityFileName %>-routing-resolve.service';
@@ -36,7 +36,7 @@ describe('<%= entityAngularName %> routing resolve service', () => {
   let mockActivatedRouteSnapshot: ActivatedRouteSnapshot;
   let routingResolveService: <%= entityAngularName %>RoutingResolveService;
   let service: <%= entityAngularName %>Service;
-  let result<%= entityAngularName %>: I<%= entityAngularName %> | undefined;
+  let result<%= entityAngularName %>: I<%= entityAngularName %> | null | undefined;
 
   beforeEach(() => {
     TestBed.configureTestingModule({
@@ -76,7 +76,7 @@ describe('<%= entityAngularName %> routing resolve service', () => {
       expect(result<%= entityAngularName %>).toEqual({ <%= primaryKey.name %>: <%- tsKeyId %> });
     });
 
-    it('should return new I<%= entityAngularName %> if id is not provided', () => {
+    it('should return null if id is not provided', () => {
       // GIVEN
       service.find = jest.fn();
       mockActivatedRouteSnapshot.params = {};
@@ -88,12 +88,12 @@ describe('<%= entityAngularName %> routing resolve service', () => {
 
       // THEN
       expect(service.find).not.toBeCalled();
-      expect(result<%= entityAngularName %>).toEqual(new <%= entityAngularName %>());
+      expect(result<%= entityAngularName %>).toEqual(null);
     });
 
     it('should route to 404 page if data not found in server', () => {
       // GIVEN
-      jest.spyOn(service, 'find').mockReturnValue(of(new HttpResponse({ body: null as unknown as <%= entityAngularName %>})));
+      jest.spyOn(service, 'find').mockReturnValue(of(new HttpResponse<I<%= entityAngularName %>>({ body: null })));
       mockActivatedRouteSnapshot.params = { <%= primaryKey.name %>: <%- tsKeyId %> };
 
       // WHEN

package/generators/entity-client/templates/angular/src/main/webapp/app/entities/route/entity-management-routing-resolve.service.ts.ejs

@@ -22,18 +22,18 @@ import { Resolve, ActivatedRouteSnapshot, Router } from '@angular/router';
 import { Observable, of, EMPTY } from 'rxjs';
 import { mergeMap } from 'rxjs/operators';
 
-import { I<%= entityAngularName %>, <%= entityAngularName %> } from '../<%= entityFileName %>.model';
+import { I<%= entityAngularName %> } from '../<%= entityFileName %>.model';
 import { <%= entityAngularName %>Service } from '../service/<%= entityFileName %>.service';
 
 @Injectable({ providedIn: 'root' })
-export class <%= entityAngularName %>RoutingResolveService implements Resolve<I<%= entityAngularName %>> {
+export class <%= entityAngularName %>RoutingResolveService implements Resolve<I<%= entityAngularName %> | null> {
     constructor(protected service: <%= entityAngularName %>Service, protected router: Router) {}
 
-    resolve(route: ActivatedRouteSnapshot): Observable<I<%= entityAngularName %>> | Observable<never> {
+    resolve(route: ActivatedRouteSnapshot): Observable<I<%= entityAngularName %> | null | never> {
         const id = route.params['<%= primaryKey.name %>'];
         if (id) {
             return this.service.find(id).pipe(
-                mergeMap((<%= entityInstance %>: HttpResponse<<%= entityAngularName %>>) => {
+                mergeMap((<%= entityInstance %>: HttpResponse<I<%= entityAngularName %>>) => {
                     if (<%= entityInstance %>.body) {
                         return of(<%= entityInstance %>.body);
                     } else {
@@ -43,6 +43,6 @@ export class <%= entityAngularName %>RoutingResolveService implements Resolve<I<
                 })
             );
         }
-        return of(new <%= entityAngularName %>());
+        return of(null);
     }
 }

package/generators/entity-client/templates/angular/src/main/webapp/app/entities/route/entity-management-routing.module.ts.ejs

@@ -26,16 +26,15 @@ import { <%= entityAngularName %>DetailComponent } from '../detail/<%= entityFil
 import { <%= entityAngularName %>UpdateComponent } from '../update/<%= entityFileName %>-update.component';
 <%_ } _%>
 import { <%= entityAngularName %>RoutingResolveService } from './<%= entityFileName %>-routing-resolve.service';
+import { ASC } from 'app/config/navigation.constants';
 
 const <%= entityInstance %>Route: Routes = [
     {
         path: '',
         component: <%= entityAngularName %>Component,
-<%_ if (paginationPagination) { _%>
         data: {
-            defaultSort: '<%- primaryKey.name %>,asc',
+            defaultSort: '<%- primaryKey.name %>,' + ASC,
         },
-<%_ } _%>
         canActivate: [UserRouteAccessService]
     },
     {

package/generators/entity-client/templates/angular/src/main/webapp/app/entities/service/entity.service.spec.ts.ejs

@@ -19,33 +19,33 @@
 <%_
 const tsKeyId = generateTestEntityId(primaryKey.type);
 const enumImports = generateEntityClientEnumImports(fields);
-const testEntityPrimaryKey0 = generateTestEntityPrimaryKey(primaryKey, 0);
-const testEntityPrimaryKey1 = generateTestEntityPrimaryKey(primaryKey, 1);
 _%>
 import { TestBed } from '@angular/core/testing';
 import { HttpClientTestingModule, HttpTestingController } from '@angular/common/http/testing';
-<%_ if (fieldsContainDate) { _%>
-import dayjs from 'dayjs/esm';
-<%_ } _%>
 
-<%_ if (fieldsContainDate) { _%>
-import { <% if (fieldsContainLocalDate) { %>DATE_FORMAT,<% } if (fieldsContainInstant || fieldsContainZonedDateTime) { %> DATE_TIME_FORMAT<% } %> } from 'app/config/input.constants';
+<%_ if (fieldsContainLocalDate) { _%>
+import { DATE_FORMAT } from 'app/config/input.constants';
 <%_ } _%>
-<%_ enumImports.forEach( (importedPath, importedType) => { _%>
-import { <%- importedType %> } from '<%- importedPath %>';
-<%_ }); _%>
-import { I<%= entityAngularName %><% if (!readOnly) { %>, <%= entityAngularName %><% } %> } from '../<%= entityFileName %>.model';
+import { I<%= entityAngularName %> } from '../<%= entityFileName %>.model';
+import { sampleWithRequiredData, sampleWithNewData, sampleWithPartialData, sampleWithFullData } from '../<%= entityFileName %>.test-samples';
 
-import { <%= entityAngularName %>Service } from './<%= entityFileName %>.service';
+import { <%= entityAngularName %>Service<% if (fieldsContainDate) { %>, Rest<%= entityAngularName %><% } %> } from './<%= entityFileName %>.service';
+
+const requireRestSample: <% if (fieldsContainDate) { %>Rest<% } else { %>I<% } %><%= entityAngularName %> = {
+  ...sampleWithRequiredData,
+<%_ fields.forEach((field) => { _%>
+<%_  if (field.fieldTypeLocalDate) { _%>
+  <%= field.fieldName %>: sampleWithRequiredData.<%= field.fieldName %>?.format(DATE_FORMAT),
+<%_ } else if (field.fieldTypeTimed) { _%>
+  <%= field.fieldName %>: sampleWithRequiredData.<%= field.fieldName %>?.toJSON(),
+<%_ } _%>
+<%_ }) _%>
+};
 
 describe('<%= entityAngularName %> Service', () => {
     let service: <%= entityAngularName %>Service;
     let httpMock: HttpTestingController;
-    let elemDefault: I<%= entityAngularName %>;
     let expectedResult: I<%= entityAngularName %> | I<%= entityAngularName %>[] | boolean | null;
-<%_ if (fieldsContainDate) { _%>
-    let currentDate: dayjs.Dayjs;
-<%_ } _%>
 
     beforeEach(() => {
         TestBed.configureTestingModule({
@@ -56,83 +56,28 @@ describe('<%= entityAngularName %> Service', () => {
         expectedResult = null;
         service = TestBed.inject(<%= entityAngularName %>Service);
         httpMock = TestBed.inject(HttpTestingController);
-<%_ if (fieldsContainDate) { _%>
-        currentDate = dayjs();
-<%_ } _%>
-
-        elemDefault = {
-<%_ fields.forEach((field) => {
-    const fieldType = field.fieldType;
-_%>
-    <%_ if (field.fieldIsEnum) { _%>
-            <%= field.fieldName %>: <%= fieldType + '.' + field.enumValues[0].name %>,
-    <%_ } else if (field.fieldTypeBoolean) { _%>
-            <%= field.fieldName %>: false,
-    <%_ } else if (field.fieldTypeDuration) { _%>
-            <%= field.fieldName %>: 'PT1S',
-    <%_ } else if (field.fieldTypeNumeric) { _%>
-            <%= field.fieldName %>: 0,
-    <%_ } else if (field.fieldTypeCharSequence) { _%>
-            <%= field.fieldName %>: 'AAAAAAA',
-    <%_ } else if (field.fieldTypeTemporal) { _%>
-            <%= field.fieldName %>: currentDate,
-    <%_ } else if (field.fieldTypeBinary && !field.blobContentTypeText) { _%>
-            <%= field.fieldName %>ContentType: 'image/png',
-            <%= field.fieldName %>: 'AAAAAAA',
-    <%_ } else { /* (fieldType === 'byte[]' || fieldType === 'ByteBuffer') && fieldTypeBlobContent === 'any' || (fieldType === 'byte[]' || fieldType === 'ByteBuffer') && fieldTypeBlobContent === 'image' || fieldType === 'LocalDate' */ _%>
-            <%= field.fieldName %>: 'AAAAAAA',
-    <%_ } _%>
-<%_ }) _%>
-        };
     });
 
     describe('Service methods', () => {
         it('should find an element', () => {
-            const returnedFromService = Object.assign({
-<%_ fields.forEach((field) => { _%>
-    <%_ if (field.fieldTypeLocalDate) { _%>
-                <%= field.fieldName %>: currentDate.format(DATE_FORMAT),
-    <%_ } else if (field.fieldTypeTimed) { _%>
-                <%= field.fieldName %>: currentDate.format(DATE_TIME_FORMAT),
-    <%_ } _%>
-<%_ }) _%>
-            }, elemDefault);
+            const returnedFromService = { ...requireRestSample };
+            const expected = { ...sampleWithRequiredData };
 
             service.find(<%- tsKeyId %>).subscribe(resp => expectedResult = resp.body);
 
             const req = httpMock.expectOne({ method: 'GET' });
             req.flush(returnedFromService);
-            expect(expectedResult).toMatchObject(elemDefault);
+            expect(expectedResult).toMatchObject(expected);
         });
 
 <%_ if (!readOnly) { _%>
         it('should create a <%= entityAngularName %>', () => {
-            const returnedFromService = Object.assign({
-    <%_ if (tsKeyType === 'string') { _%>
-                id: 'ID',
-    <%_ } else { _%>
-                id: 0,
-    <%_ } _%>
-<%_ fields.forEach((field) => { _%>
-    <%_ if (field.fieldTypeLocalDate) { _%>
-                <%= field.fieldName %>: currentDate.format(DATE_FORMAT),
-    <%_ } else if (field.fieldTypeTimed) { _%>
-                <%= field.fieldName %>: currentDate.format(DATE_TIME_FORMAT),
-    <%_ } _%>
-<%_ }) _%>
-            }, elemDefault);
-
-            const expected = Object.assign({
-<%_ fields.forEach((field) => { _%>
-    <%_ if (field.fieldTypeLocalDate) { _%>
-                <%= field.fieldName %>: currentDate,
-    <%_ } else if (field.fieldTypeTimed) { _%>
-                <%= field.fieldName %>: currentDate,
-    <%_ } _%>
-<%_ }) _%>
-            }, returnedFromService);
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const <%= entityInstance %> = { ...sampleWithNewData };
+            const returnedFromService = { ...requireRestSample };
+            const expected = { ...sampleWithRequiredData };
 
-            service.create(new <%= entityAngularName %>()).subscribe(resp => expectedResult = resp.body);
+            service.create(<%= entityInstance %>).subscribe(resp => expectedResult = resp.body);
 
             const req = httpMock.expectOne({ method: 'POST' });
             req.flush(returnedFromService);
@@ -140,72 +85,21 @@ _%>
         });
 
         it('should update a <%= entityAngularName %>', () => {
-            const returnedFromService = Object.assign({
-<%_ fields.forEach((field) => { _%>
-    <%_ if (field.fieldTypeBoolean) { _%>
-                <%= field.fieldName %>: true,
-    <%_ } else if (field.fieldTypeNumeric) { _%>
-                <%= field.fieldName %>: 1,
-    <%_ } else if (field.fieldTypeCharSequence) { _%>
-                <%= field.fieldName %>: 'BBBBBB',
-    <%_ } else if (field.fieldTypeLocalDate) { _%>
-                <%= field.fieldName %>: currentDate.format(DATE_FORMAT),
-    <%_ } else if (field.fieldTypeTimed) { _%>
-                <%= field.fieldName %>: currentDate.format(DATE_TIME_FORMAT),
-    <%_ } else { _%>
-                <%= field.fieldName %>: 'BBBBBB',
-    <%_ } _%>
-<%_ }) _%>
-            }, elemDefault);
-
-            const expected = Object.assign({
-<%_ fields.forEach((field) => { _%>
-    <%_ if (field.fieldTypeLocalDate) { _%>
-                <%= field.fieldName %>: currentDate,
-    <%_ } else if (field.fieldTypeTimed) { _%>
-                <%= field.fieldName %>: currentDate,
-    <%_ } _%>
-<%_ }) _%>
-            }, returnedFromService);
+            const <%= entityInstance %> = { ...sampleWithRequiredData };
+            const returnedFromService = { ...requireRestSample };
+            const expected = { ...sampleWithRequiredData };
 
-            service.update(expected).subscribe(resp => expectedResult = resp.body);
+            service.update(<%= entityInstance %>).subscribe(resp => expectedResult = resp.body);
 
             const req = httpMock.expectOne({ method: 'PUT' });
             req.flush(returnedFromService);
             expect(expectedResult).toMatchObject(expected);
         });
 
-<%_ const fieldsToIncludeInPartialPatchTest = fields.filter(field => !field.id && !field.transient && faker.datatype.boolean()); _%>
         it('should partial update a <%= entityAngularName %>', () => {
-            const patchObject = Object.assign({
-<%_ fieldsToIncludeInPartialPatchTest.forEach((field) => { _%>
-    <%_ if (field.fieldTypeBoolean) { _%>
-                    <%= field.fieldName %>: true,
-    <%_ } else if (field.fieldTypeNumeric) { _%>
-                    <%= field.fieldName %>: 1,
-    <%_ } else if (field.fieldTypeCharSequence) { _%>
-                    <%= field.fieldName %>: 'BBBBBB',
-    <%_ } else if (field.fieldTypeLocalDate) { _%>
-                    <%= field.fieldName %>: currentDate.format(DATE_FORMAT),
-    <%_ } else if (field.fieldTypeTimed) { _%>
-                    <%= field.fieldName %>: currentDate.format(DATE_TIME_FORMAT),
-    <%_ } else { _%>
-                    <%= field.fieldName %>: 'BBBBBB',
-    <%_ } _%>
-<%_ }) _%>
-            }, new <%= entityAngularName %>())
-
-            const returnedFromService = Object.assign(patchObject, elemDefault);
-
-            const expected = Object.assign({
-<%_ fields.forEach((field) => { _%>
-    <%_ if (field.fieldTypeLocalDate) { _%>
-                    <%= field.fieldName %>: currentDate,
-    <%_ } else if (field.fieldTypeTimed) { _%>
-                    <%= field.fieldName %>: currentDate,
-    <%_ } _%>
-<%_ }) _%>
-            }, returnedFromService);
+            const patchObject = { ...sampleWithPartialData };
+            const returnedFromService = { ...requireRestSample };
+            const expected = { ...sampleWithRequiredData }
 
             service.partialUpdate(patchObject).subscribe(resp => expectedResult = resp.body);
 
@@ -216,40 +110,16 @@ _%>
 <%_ } _%>
 
         it('should return a list of <%= entityAngularName %>', () => {
-            const returnedFromService = Object.assign({
-<%_ fields.forEach((field) => { _%>
-    <%_ if (field.fieldTypeBoolean) { _%>
-                <%= field.fieldName %>: true,
-    <%_ } else if (field.fieldTypeNumeric) { _%>
-                <%= field.fieldName %>: 1,
-    <%_ } else if (field.fieldTypeCharSequence) { _%>
-                <%= field.fieldName %>: 'BBBBBB',
-    <%_ } else if (field.fieldTypeLocalDate) { _%>
-                <%= field.fieldName %>: currentDate.format(DATE_FORMAT),
-    <%_ } else if (field.fieldTypeTimed) { _%>
-                <%= field.fieldName %>: currentDate.format(DATE_TIME_FORMAT),
-    <%_ } else { /* (fieldType === 'byte[]' || fieldType === 'ByteBuffer') && fieldTypeBlobContent === 'any' || (fieldType === 'byte[]' || fieldType === 'ByteBuffer') && fieldTypeBlobContent === 'image' || fieldType === 'LocalDate' */ _%>
-                <%= field.fieldName %>: 'BBBBBB',
-    <%_ } _%>
-<%_ }) _%>
-            }, elemDefault);
+            const returnedFromService = { ...requireRestSample };
 
-            const expected = Object.assign({
-<%_ fields.forEach((field) => { _%>
-    <%_ if (field.fieldTypeLocalDate) { _%>
-                <%= field.fieldName %>: currentDate,
-    <%_ } else if (field.fieldTypeTimed) { _%>
-                <%= field.fieldName %>: currentDate,
-    <%_ } _%>
-<%_ }) _%>
-            }, returnedFromService);
+            const expected = { ...sampleWithRequiredData };
 
             service.query().subscribe(resp => expectedResult = resp.body);
 
             const req = httpMock.expectOne({ method: 'GET' });
             req.flush([returnedFromService]);
             httpMock.verify();
-            expect(expectedResult).toContainEqual(expected);
+            expect(expectedResult).toMatchObject([expected]);
         });
 
 <%_ if (!readOnly) { _%>
@@ -264,39 +134,39 @@ _%>
 
         describe('add<%= entityAngularName %>ToCollectionIfMissing', () => {
             it('should add a <%= entityAngularName %> to an empty array', () => {
-                const <%= entityInstance %>: I<%= entityAngularName %> = <%- testEntityPrimaryKey0 %>;
+                const <%= entityInstance %>: I<%= entityAngularName %> = sampleWithRequiredData;
                 expectedResult = service.add<%= entityAngularName %>ToCollectionIfMissing([], <%= entityInstance %>);
                 expect(expectedResult).toHaveLength(1);
                 expect(expectedResult).toContain(<%= entityInstance %>);
             });
 
             it('should not add a <%= entityAngularName %> to an array that contains it', () => {
-                const <%= entityInstance %>: I<%= entityAngularName %> = <%- testEntityPrimaryKey0 %>;
+                const <%= entityInstance %>: I<%= entityAngularName %> = sampleWithRequiredData;
                 const <%= entityInstance %>Collection: I<%= entityAngularName %>[] = [{
                     ...<%= entityInstance %>,
-                }, <%- testEntityPrimaryKey1 %>];
+                }, sampleWithPartialData];
                 expectedResult = service.add<%= entityAngularName %>ToCollectionIfMissing(<%= entityInstance %>Collection, <%= entityInstance %>);
                 expect(expectedResult).toHaveLength(2);
             });
 
             it("should add a <%= entityAngularName %> to an array that doesn't contain it", () => {
-                const <%= entityInstance %>: I<%= entityAngularName %> = <%- testEntityPrimaryKey0 %>;
-                const <%= entityInstance %>Collection: I<%= entityAngularName %>[] = [<%- testEntityPrimaryKey1 %>];
+                const <%= entityInstance %>: I<%= entityAngularName %> = sampleWithRequiredData;
+                const <%= entityInstance %>Collection: I<%= entityAngularName %>[] = [sampleWithPartialData];
                 expectedResult = service.add<%= entityAngularName %>ToCollectionIfMissing(<%= entityInstance %>Collection, <%= entityInstance %>);
                 expect(expectedResult).toHaveLength(2);
                 expect(expectedResult).toContain(<%= entityInstance %>);
             });
 
             it('should add only unique <%= entityAngularName %> to an array', () => {
-                const <%= entityInstance %>Array: I<%= entityAngularName %>[] = [<%- testEntityPrimaryKey0 %>, <%- testEntityPrimaryKey1 %>, <%- generateTestEntityPrimaryKey(primaryKey) %>];
-                const <%= entityInstance %>Collection: I<%= entityAngularName %>[] = [<%- testEntityPrimaryKey0 %>];
+                const <%= entityInstance %>Array: I<%= entityAngularName %>[] = [sampleWithRequiredData, sampleWithPartialData, sampleWithFullData];
+                const <%= entityInstance %>Collection: I<%= entityAngularName %>[] = [sampleWithRequiredData];
                 expectedResult = service.add<%= entityAngularName %>ToCollectionIfMissing(<%= entityInstance %>Collection, ...<%= entityInstance %>Array);
                 expect(expectedResult).toHaveLength(3);
             });
 
             it('should accept varargs', () => {
-                const <%= entityInstance %>: I<%= entityAngularName %> = <%- testEntityPrimaryKey0 %>;
-                const <%= entityInstance %>2: I<%= entityAngularName %> = <%- testEntityPrimaryKey1 %>;
+                const <%= entityInstance %>: I<%= entityAngularName %> = sampleWithRequiredData;
+                const <%= entityInstance %>2: I<%= entityAngularName %> = sampleWithPartialData;
                 expectedResult = service.add<%= entityAngularName %>ToCollectionIfMissing([], <%= entityInstance %>, <%= entityInstance %>2);
                 expect(expectedResult).toHaveLength(2);
                 expect(expectedResult).toContain(<%= entityInstance %>);
@@ -304,18 +174,62 @@ _%>
             });
 
             it('should accept null and undefined values', () => {
-                const <%= entityInstance %>: I<%= entityAngularName %> = <%- testEntityPrimaryKey0 %>;
+                const <%= entityInstance %>: I<%= entityAngularName %> = sampleWithRequiredData;
                 expectedResult = service.add<%= entityAngularName %>ToCollectionIfMissing([], null, <%= entityInstance %>, undefined);
                 expect(expectedResult).toHaveLength(1);
                 expect(expectedResult).toContain(<%= entityInstance %>);
             });
 
             it('should return initial array if no <%= entityAngularName %> is added', () => {
-                const <%= entityInstance %>Collection: I<%= entityAngularName %>[] = [<%- testEntityPrimaryKey0 %>];
+                const <%= entityInstance %>Collection: I<%= entityAngularName %>[] = [sampleWithRequiredData];
                 expectedResult = service.add<%= entityAngularName %>ToCollectionIfMissing(<%= entityInstance %>Collection, undefined, null);
                 expect(expectedResult).toEqual(<%= entityInstance %>Collection);
             });
         });
+
+        describe('compare<%= entityAngularName %>', () => {
+            it('Should return true if both entities are null', () => {
+                const entity1 = null;
+                const entity2 = null;
+
+                const compareResult = service.compare<%= entityAngularName %>(entity1, entity2);
+
+                expect(compareResult).toEqual(true);
+            });
+
+            it('Should return false if one entity is null', () => {
+                const entity1 = <%- generateTestEntityPrimaryKey(primaryKey, 0) %>;
+                const entity2 = null;
+
+                const compareResult1 = service.compare<%= entityAngularName %>(entity1, entity2);
+                const compareResult2 = service.compare<%= entityAngularName %>(entity2, entity1);
+
+                expect(compareResult1).toEqual(false);
+                expect(compareResult2).toEqual(false);
+            });
+
+            it('Should return false if primaryKey differs', () => {
+                const entity1 = <%- generateTestEntityPrimaryKey(primaryKey, 0) %>;
+                const entity2 = <%- generateTestEntityPrimaryKey(primaryKey, 1) %>;
+
+                const compareResult1 = service.compare<%= entityAngularName %>(entity1, entity2);
+                const compareResult2 = service.compare<%= entityAngularName %>(entity2, entity1);
+
+                expect(compareResult1).toEqual(false);
+                expect(compareResult2).toEqual(false);
+            });
+
+            it('Should return false if primaryKey matches', () => {
+                const entity1 = <%- generateTestEntityPrimaryKey(primaryKey, 0) %>;
+                const entity2 = <%- generateTestEntityPrimaryKey(primaryKey, 0) %>;
+
+                const compareResult1 = service.compare<%= entityAngularName %>(entity1, entity2);
+                const compareResult2 = service.compare<%= entityAngularName %>(entity2, entity1);
+
+                expect(compareResult1).toEqual(true);
+                expect(compareResult2).toEqual(true);
+            });
+        });
     });
 
     afterEach(() => {