[AAE-15836] Address review comments

lib/core/src/lib/pipes/full-name.pipe.spec.ts

@@ -17,80 +17,173 @@
 
 import { FullNamePipe } from './full-name.pipe';
 import { UserLike } from './user-like.interface';
-import { cloneDeep } from 'lodash';
-
-interface TestCase {
-    title: string;
-    user: UserLike;
-    result: string;
-};
 
 describe('FullNamePipe', () => {
 
     let pipe: FullNamePipe;
 
-    const emptyUserTestCase: TestCase = {
+    let user: UserLike;
-        title: 'should return empty string when there is no name',
-        user: {},
-        result: ''
-    };
 
-    const onlyUserEmailTestCase: TestCase = {
+    describe('Email address inclusion not requested', () => {
-        title: 'should return user email when firstName, lastName and username are not available',
-        user: { email: 'abcXyz@gmail.com' },
-        result: 'abcXyz@gmail.com'
-    };
 
-    const baseTestCases: TestCase[] = [
+        beforeAll(() => {
-        {
+            pipe = new FullNamePipe();
-            title: 'should return only firstName as fullName when there is no lastName',
+        });
-            user: { firstName: 'Abc', lastName: '', username: '' },
-            result: 'Abc'
-        },
-        {
-            title: 'should return only lastName as fullName when there is no firstName',
-            user: { firstName: '', lastName: 'Xyz', username: '' },
-            result: 'Xyz'
-        },
-        {
-            title: 'should return fullName when firstName and lastName are available',
-            user: { firstName: 'Abc', lastName: 'Xyz', username: '' },
-            result: 'Abc Xyz'
-        },
-        {
-            title: 'should return username when firstName and lastName are not available',
-            user: { firstName: '', lastName: '', username: 'username' },
-            result: 'username'
-        }
-    ];
 
-    [undefined, false, true].forEach(injectionToken => {
+        it('should return empty string when there is no name', () => {
-        [undefined, false, true].forEach(pipeParameter => {
+            user = {};
-            [undefined, '', 'abcXyz@gmail.com'].forEach(emailAddress => {
-                const testCases: TestCase[] = getTestCases(baseTestCases, emailAddress, pipeParameter, injectionToken, emptyUserTestCase, onlyUserEmailTestCase);
 
-                testCases.forEach(testCase => {
+            expect(pipe.transform(user)).toBe('');
-                    it(`${testCase.title} and injection token is ${injectionToken} and pipe parameter is ${pipeParameter} and email address is ${emailAddress}`, () => {
+        });
-                        pipe = new FullNamePipe(injectionToken);
+
-                        expect(pipe.transform(testCase.user, pipeParameter)).toBe(testCase.result);
+        it('should return only firstName as fullName when there is no lastName', () => {
-                    });
+            user = { firstName: 'Abc' };
-                });
+
-            });
+            expect(pipe.transform(user)).toBe('Abc');
+        });
+
+        it('should return only lastName as fullName when there is no firstName', () => {
+            user = { lastName: 'Xyz' };
+
+            expect(pipe.transform(user)).toBe('Xyz');
+        });
+
+        it('should return fullName when firstName and lastName are available', () => {
+            user = { firstName: 'Abc', lastName: 'Xyz' };
+
+            expect(pipe.transform(user)).toBe('Abc Xyz');
+        });
+
+        it('should return username when firstName and lastName are not available', () => {
+            user = { username: 'username' };
+
+            expect(pipe.transform(user)).toBe('username');
+        });
+
+        it('should return user email when firstName, lastName and username are not available', () => {
+            user = { email: 'abcXyz@gmail.com' };
+
+            expect(pipe.transform(user)).toBe('abcXyz@gmail.com');
         });
     });
+
+    describe('Email address inclusion requested via injection token', () => {
+
+        beforeEach(() => {
+            pipe = new FullNamePipe(true);
+            user = { email: 'abcXyz@gmail.com' };
+        });
+
+        it('should return empty string when there is no name', () => {
+            user = {};
+
+            expect(pipe.transform(user)).toBe('');
+        });
+
+        it('should return only firstName and email address as fullName when there is no lastName', () => {
+            user.firstName = 'Abc';
+
+            expect(pipe.transform(user)).toBe('Abc <abcXyz@gmail.com>');
+        });
+
+        it('should return only lastName and email address as fullName when there is no firstName', () => {
+            user.lastName = 'Xyz';
+
+            expect(pipe.transform(user)).toBe('Xyz <abcXyz@gmail.com>');
+        });
+
+        it('should return fullName and email address when firstName and lastName are available', () => {
+            user.firstName = 'Abc';
+            user.lastName = 'Xyz';
+
+            expect(pipe.transform(user)).toBe('Abc Xyz <abcXyz@gmail.com>');
+        });
+
+        it('should return username and email address when firstName and lastName are not available', () => {
+            user.username = 'username';
+
+            expect(pipe.transform(user)).toBe('username <abcXyz@gmail.com>');
+        });
+
+        it('should return user email when firstName, lastName and username are not available', () => {
+            user = { email: 'abcXyz@gmail.com' };
+
+            expect(pipe.transform(user)).toBe('abcXyz@gmail.com');
+        });
+
+        it('should not include email address when email address is not available', () => {
+            user = { firstName: 'Abc', lastName: 'Xyz' };
+
+            expect(pipe.transform(user)).toBe('Abc Xyz');
+        });
+    });
+
+    describe('Email address inclusion requested via pipe parameter', () => {
+
+        beforeEach(() => {
+            pipe = new FullNamePipe();
+            user = { email: 'abcXyz@gmail.com' };
+        });
+
+        it('should return empty string when there is no name', () => {
+            user = {};
+
+            expect(pipe.transform(user, true)).toBe('');
+        });
+
+        it('should return only firstName and email address as fullName when there is no lastName', () => {
+            user.firstName = 'Abc';
+
+            expect(pipe.transform(user, true)).toBe('Abc <abcXyz@gmail.com>');
+        });
+
+        it('should return only lastName and email address as fullName when there is no firstName', () => {
+            user.lastName = 'Xyz';
+
+            expect(pipe.transform(user, true)).toBe('Xyz <abcXyz@gmail.com>');
+        });
+
+        it('should return fullName and email address when firstName and lastName are available', () => {
+            user.firstName = 'Abc';
+            user.lastName = 'Xyz';
+
+            expect(pipe.transform(user, true)).toBe('Abc Xyz <abcXyz@gmail.com>');
+        });
+
+        it('should return username and email address when firstName and lastName are not available', () => {
+            user.username = 'username';
+
+            expect(pipe.transform(user, true)).toBe('username <abcXyz@gmail.com>');
+        });
+
+        it('should return user email when firstName, lastName and username are not available', () => {
+            user = { email: 'abcXyz@gmail.com' };
+
+            expect(pipe.transform(user, true)).toBe('abcXyz@gmail.com');
+        });
+
+        it('should not include email address when email address is not available', () => {
+            user = { firstName: 'Abc', lastName: 'Xyz' };
+
+            expect(pipe.transform(user, true)).toBe('Abc Xyz');
+        });
+    });
+
+    describe('Pipe parameter prevalence over token', () => {
+
+        it('should include email when injection token is false and pipe parameter is true', () => {
+            user = { firstName: 'Abc', lastName: 'Xyz', email: 'abcXyz@gmail.com' };
+            pipe = new FullNamePipe(false);
+
+            expect(pipe.transform(user, true)).toBe('Abc Xyz <abcXyz@gmail.com>');
+        });
+
+        it('should not include email when injection token is true and pipe parameter is false', () => {
+            user = { firstName: 'Abc', lastName: 'Xyz' };
+            pipe = new FullNamePipe(true);
+
+            expect(pipe.transform(user, false)).toBe('Abc Xyz');
+        });
+    });
+
 });
-
-function getTestCases(baseTestCases: TestCase[], emailAddress: string | undefined, pipeParameter: boolean | undefined, injectionToken: boolean | undefined, emptyUserTestCase: TestCase, onlyUserEmailTestCase: TestCase) {
-    let testCases: TestCase[] = cloneDeep(baseTestCases).map(testCase => ({ ...testCase, user: { ...testCase.user, email: emailAddress } }));
-
-    const patchEmailInResult = !!(pipeParameter === undefined ? injectionToken : pipeParameter) && emailAddress?.length;
-    if (patchEmailInResult) {
-        testCases = testCases.map(testCase => ({ ...testCase, result: testCase.result.concat(' <abcXyz@gmail.com>') }));
-    }
-
-    testCases.push(emptyUserTestCase);
-    testCases.push(onlyUserEmailTestCase);
-
-    return testCases;
-}
-

lib/core/src/lib/pipes/full-name.pipe.ts

@@ -25,7 +25,7 @@ export class FullNamePipe implements PipeTransform {
     constructor(@Optional() @Inject(ADF_FULL_NAME_PIPE_INCLUDE_EMAIL) private includeEmail = false) {
     }
 
-    transform(user: UserLike, includeEmail: boolean | undefined): string {
+    transform(user: UserLike, includeEmail?: boolean): string {
         return this.buildFullName(user, includeEmail) ? this.buildFullName(user, includeEmail) : this.buildFromUsernameOrEmail(user, includeEmail);
     }