Merge pull request #52 from mrjones2014/main

Add ResultRecord#doesNotHaveErrors and ResultRecord#getErrorMessageFor

Author: brandongregoryscott

src/view-models/result-record.test.ts

@@ -2,6 +2,8 @@ import { ResultRecord } from "./result-record";
 import { ErrorType } from "../enumerations/error-type";
 import { ResultErrorRecord } from "./result-error-record";
 import { ResultError } from "../interfaces/result-error";
+import { Factory } from "rosie";
+import { FactoryType } from "../tests/factories/factory-type";
 
 describe("ResultRecord", () => {
     // -----------------------------------------------------------------------------------------
@@ -203,6 +205,97 @@ describe("ResultRecord", () => {
 
     // #endregion errorCount
 
+    // -----------------------------------------------------------------------------------------
+    // #region doesNotHaveErrors
+    // -----------------------------------------------------------------------------------------
+
+    describe("doesNotHaveErrors", () => {
+        test("when errors is null, returns true", () => {
+            expect(
+                Factory.build<ResultRecord<any>>(FactoryType.ResultRecord, {
+                    errors: (null as unknown) as any[],
+                }).doesNotHaveErrors()
+            ).toBeTrue();
+        });
+
+        test("when errors is undefined, returns true", () => {
+            expect(
+                Factory.build<ResultRecord<any>>(FactoryType.ResultRecord, {
+                    errors: undefined,
+                }).doesNotHaveErrors()
+            ).toBeTrue();
+        });
+
+        test("when errors is empty array, returns true", () => {
+            expect(
+                Factory.build<ResultRecord<any>>(FactoryType.ResultRecord, {
+                    errors: [],
+                }).doesNotHaveErrors()
+            ).toBeTrue();
+        });
+
+        test("when errors is not empty, returns false", () => {
+            // Arrange
+            const errors = [
+                Factory.build<ResultErrorRecord>(FactoryType.ResultErrorRecord),
+            ];
+
+            // Act & Assert
+            expect(
+                Factory.build<ResultRecord<any>>(FactoryType.ResultRecord, {
+                    errors: errors,
+                }).doesNotHaveErrors()
+            ).toBeFalse();
+        });
+    }); // end doesNotHaveErrors
+
+    // -----------------------------------------------------------------------------------------
+    // #region getErrorMessageFor
+    // -----------------------------------------------------------------------------------------
+
+    describe("#getErrorMessageFor", () => {
+        it("When no error exists for given key, then returns undefined", () => {
+            // Arrange
+            const errorKey = "TEST_ERROR_KEY";
+            const resultRecord = Factory.build<ResultRecord<any>>(
+                FactoryType.ResultRecord,
+                {
+                    errors: [],
+                }
+            );
+
+            // Act
+            const result = resultRecord.getErrorMessageFor(errorKey);
+
+            // Assert
+            expect(result).toBeNil();
+        });
+
+        it("When an error exists for the given key, then returns the error message", () => {
+            // Arrange
+            const errorKey = "TEST_ERROR_KEY";
+            const resultRecord = Factory.build<ResultRecord<any>>(
+                FactoryType.ResultRecord,
+                {
+                    errors: [
+                        Factory.build<ResultErrorRecord>(
+                            FactoryType.ResultErrorRecord,
+                            {
+                                key: errorKey,
+                            }
+                        ),
+                    ],
+                }
+            );
+
+            // Act
+            const result = resultRecord.getErrorMessageFor(errorKey);
+
+            // Assert
+            expect(result).not.toBeNil();
+        });
+    }); // end getErrorMessageFor
+
     // -----------------------------------------------------------------------------------------
     // #region hasErrorFor
     // -----------------------------------------------------------------------------------------

src/view-models/result-record.ts

@@ -3,6 +3,7 @@ import { Record } from "immutable";
 import { ResultErrorRecord } from "./result-error-record";
 import { Result } from "../interfaces/result";
 import { ErrorType } from "../enumerations/error-type";
+import { RecordUtils } from "../utilities/record-utils";
 
 const defaultValues: Result<any> = {
     errors: undefined,
@@ -19,15 +20,13 @@ class ResultRecord<T> extends Record(defaultValues) implements Result<T> {
 
     constructor(params?: Result<T>) {
         if (params == null) {
-            params = {};
+            params = Object.assign(defaultValues, params);
         }
 
         if (CollectionUtils.hasValues(params.errors)) {
             const errors = params.errors as any[];
             params.errors = errors.map((error) =>
-                error instanceof ResultErrorRecord
-                    ? error
-                    : new ResultErrorRecord(error)
+                RecordUtils.ensureRecord(error, ResultErrorRecord)
             );
         }
 
@@ -60,27 +59,44 @@ class ResultRecord<T> extends Record(defaultValues) implements Result<T> {
         return this._addErrorByType(key, message, ErrorType.ValidationError);
     }
 
+    /**
+     * Evaluates whether there are any errors on the result
+     */
+    public doesNotHaveErrors(): boolean {
+        return !this.hasErrors();
+    }
+
     /**
      * Returns total number of errors
      */
     public errorCount(): number {
-        if (this.errors == null) {
+        if (this.doesNotHaveErrors()) {
             return 0;
         }
 
-        return CollectionUtils.hasValues(this.errors) ? this.errors.length : 0;
+        return this.errors!.length;
     }
 
     /**
-     * Determines if the result contains an error for the supplied key
-     * @param key error key for which to search
+     * Returns an error message for a given key
+     * @param key
      */
-    public hasErrorFor(key: string): boolean {
-        if (this.errors == null || !this.hasErrors()) {
+    public getErrorMessageFor(key: string): string | undefined {
+        return this.errors?.find((e) => e.key === key)?.message;
+    }
+
+    /**
+     * Determines if the result contains an error for the supplied key(s)
+     * @param keys error keys for which to search
+     */
+    public hasErrorFor(...keys: string[]): boolean {
+        if (this.doesNotHaveErrors()) {
             return false;
         }
 
-        return this.errors.some((e) => e.key === key);
+        return this.errors!.some((error: ResultErrorRecord) =>
+            keys.some((key: string) => key === error.key)
+        );
     }
 
     /**
@@ -94,7 +110,7 @@ class ResultRecord<T> extends Record(defaultValues) implements Result<T> {
      * Map all errors into simple string array
      */
     public listErrors(): string[] {
-        if (!this.hasErrors()) {
+        if (this.doesNotHaveErrors()) {
             return [];
         }
         const errors = this.errors as ResultErrorRecord[];
@@ -105,9 +121,10 @@ class ResultRecord<T> extends Record(defaultValues) implements Result<T> {
      * Map all error messages into a simple string array.
      */
     public listErrorMessages(): string[] {
-        if (!this.hasErrors()) {
+        if (this.doesNotHaveErrors()) {
             return [];
         }
+
         const errors = this.errors as ResultErrorRecord[];
         return errors
             .map((e) => String(e.message) || "")
@@ -118,7 +135,7 @@ class ResultRecord<T> extends Record(defaultValues) implements Result<T> {
      * Merges new values into the record and returns a new instance.
      *
      * @param {Partial<Result<T>>} values
-     * @returns {ResultRecord}
+     * @returns {ResultRecord<T>}
      * @memberof ResultRecord
      */
     public with(values: Partial<Result<T>>): ResultRecord<T> {
@@ -153,9 +170,9 @@ class ResultRecord<T> extends Record(defaultValues) implements Result<T> {
 }
 
 // -----------------------------------------------------------------------------------------
-// #region Export
+// #region Exports
 // -----------------------------------------------------------------------------------------
 
 export { ResultRecord };
 
-// #endregion Export
+// #endregion Exports