@cratis/arc 18.4.3 → 18.6.0

package/validation/rules/for_MaxLengthRule/when_validating/with_string_longer_than_maximum.ts

@@ -0,0 +1,29 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { MaxLengthRule } from '../../LengthRules';
+
+interface TestType {
+    value: string;
+}
+
+describe("when validating with string longer than maximum", () => {
+    let rule: MaxLengthRule<TestType>;
+    let instance: TestType;
+    let results: ReturnType<typeof rule.validate>;
+
+    beforeEach(() => {
+        rule = new MaxLengthRule<TestType>(t => t.value, 5);
+        instance = { value: 'abcdefg' };
+    
+        results = rule.validate(instance, 'value');
+    });
+
+    it("should_return_one_validation_error", () => {
+        results.should.have.lengthOf(1);
+    });
+
+    it("should_include_maximum_length_in_message", () => {
+        results[0].message.should.include('5');
+    });
+});

package/validation/rules/for_MinLengthRule/when_validating/with_string_equal_to_minimum.ts

@@ -0,0 +1,25 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { MinLengthRule } from '../../LengthRules';
+
+interface TestType {
+    value: string;
+}
+
+describe("when validating with string equal to minimum", () => {
+    let rule: MinLengthRule<TestType>;
+    let instance: TestType;
+    let results: ReturnType<typeof rule.validate>;
+
+    beforeEach(() => {
+        rule = new MinLengthRule<TestType>(t => t.value, 5);
+        instance = { value: 'abcde' };
+    
+        results = rule.validate(instance, 'value');
+    });
+
+    it("should_return_no_validation_errors", () => {
+        results.should.be.empty;
+    });
+});

package/validation/rules/for_MinLengthRule/when_validating/with_string_longer_than_minimum.ts

@@ -0,0 +1,25 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { MinLengthRule } from '../../LengthRules';
+
+interface TestType {
+    value: string;
+}
+
+describe("when validating with string longer than minimum", () => {
+    let rule: MinLengthRule<TestType>;
+    let instance: TestType;
+    let results: ReturnType<typeof rule.validate>;
+
+    beforeEach(() => {
+        rule = new MinLengthRule<TestType>(t => t.value, 5);
+        instance = { value: 'abcdefg' };
+    
+        results = rule.validate(instance, 'value');
+    });
+
+    it("should_return_no_validation_errors", () => {
+        results.should.be.empty;
+    });
+});

package/validation/rules/for_MinLengthRule/when_validating/with_string_shorter_than_minimum.ts

@@ -0,0 +1,29 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { MinLengthRule } from '../../LengthRules';
+
+interface TestType {
+    value: string;
+}
+
+describe("when validating with string shorter than minimum", () => {
+    let rule: MinLengthRule<TestType>;
+    let instance: TestType;
+    let results: ReturnType<typeof rule.validate>;
+
+    beforeEach(() => {
+        rule = new MinLengthRule<TestType>(t => t.value, 5);
+        instance = { value: 'abc' };
+    
+        results = rule.validate(instance, 'value');
+    });
+
+    it("should_return_one_validation_error", () => {
+        results.should.have.lengthOf(1);
+    });
+
+    it("should_include_minimum_length_in_message", () => {
+        results[0].message.should.include('5');
+    });
+});

package/validation/rules/for_NotEmptyRule/when_setting_custom_message.ts

@@ -0,0 +1,27 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { NotEmptyRule } from '../NotEmptyRule';
+
+interface TestType {
+    value: string | null;
+}
+
+describe("when setting custom message", () => {
+    let rule: NotEmptyRule<TestType>;
+    let instance: TestType;
+    let customMessage: string;
+    let results: ReturnType<typeof rule.validate>;
+
+    beforeEach(() => {
+        customMessage = 'This field is required';
+        rule = new NotEmptyRule<TestType>(t => t.value).withMessage(customMessage);
+        instance = { value: null };
+    
+        results = rule.validate(instance, 'value');
+    });
+
+    it("should_use_custom_message", () => {
+        results[0].message.should.equal(customMessage);
+    });
+});

package/validation/rules/for_NotEmptyRule/when_validating/with_empty_array.ts

@@ -0,0 +1,25 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { NotEmptyRule } from '../../NotEmptyRule';
+
+interface TestType {
+    value: string[];
+}
+
+describe("when validating with empty array", () => {
+    let rule: NotEmptyRule<TestType>;
+    let instance: TestType;
+    let results: ReturnType<typeof rule.validate>;
+
+    beforeEach(() => {
+        rule = new NotEmptyRule<TestType>(t => t.value);
+        instance = { value: [] };
+    
+        results = rule.validate(instance, 'value');
+    });
+
+    it("should_return_one_validation_error", () => {
+        results.should.have.lengthOf(1);
+    });
+});

package/validation/rules/for_NotEmptyRule/when_validating/with_empty_string.ts

@@ -0,0 +1,25 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { NotEmptyRule } from '../../NotEmptyRule';
+
+interface TestType {
+    value: string;
+}
+
+describe("when validating with empty string", () => {
+    let rule: NotEmptyRule<TestType>;
+    let instance: TestType;
+    let results: ReturnType<typeof rule.validate>;
+
+    beforeEach(() => {
+        rule = new NotEmptyRule<TestType>(t => t.value);
+        instance = { value: '' };
+    
+        results = rule.validate(instance, 'value');
+    });
+
+    it("should_return_one_validation_error", () => {
+        results.should.have.lengthOf(1);
+    });
+});

package/validation/rules/for_NotEmptyRule/when_validating/with_non_empty_array.ts

@@ -0,0 +1,25 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { NotEmptyRule } from '../../NotEmptyRule';
+
+interface TestType {
+    value: string[];
+}
+
+describe("when validating with non empty array", () => {
+    let rule: NotEmptyRule<TestType>;
+    let instance: TestType;
+    let results: ReturnType<typeof rule.validate>;
+
+    beforeEach(() => {
+        rule = new NotEmptyRule<TestType>(t => t.value);
+        instance = { value: ['item'] };
+    
+        results = rule.validate(instance, 'value');
+    });
+
+    it("should_return_no_validation_errors", () => {
+        results.should.be.empty;
+    });
+});

package/validation/rules/for_NotEmptyRule/when_validating/with_null_value.ts

@@ -0,0 +1,38 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { NotEmptyRule } from '../../NotEmptyRule';
+import { ValidationResultSeverity } from '../../../ValidationResultSeverity';
+
+interface TestType {
+    value: string | null;
+}
+
+describe("when validating with null value", () => {
+    let rule: NotEmptyRule<TestType>;
+    let instance: TestType;
+    let results: ReturnType<typeof rule.validate>;
+
+    beforeEach(() => {
+        rule = new NotEmptyRule<TestType>(t => t.value);
+        instance = { value: null };
+    
+        results = rule.validate(instance, 'value');
+    });
+
+    it("should_return_one_validation_error", () => {
+        results.should.have.lengthOf(1);
+    });
+
+    it("should_have_error_severity", () => {
+        results[0].severity.should.equal(ValidationResultSeverity.Error);
+    });
+
+    it("should_have_property_name_in_message", () => {
+        results[0].message.should.include('value');
+    });
+
+    it("should_include_property_in_members", () => {
+        results[0].members.should.include('value');
+    });
+});

package/validation/rules/for_NotEmptyRule/when_validating/with_undefined_value.ts

@@ -0,0 +1,30 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { NotEmptyRule } from '../../NotEmptyRule';
+import { ValidationResultSeverity } from '../../../ValidationResultSeverity';
+
+interface TestType {
+    value: string | undefined;
+}
+
+describe("when validating with undefined value", () => {
+    let rule: NotEmptyRule<TestType>;
+    let instance: TestType;
+    let results: ReturnType<typeof rule.validate>;
+
+    beforeEach(() => {
+        rule = new NotEmptyRule<TestType>(t => t.value);
+        instance = { value: undefined };
+    
+        results = rule.validate(instance, 'value');
+    });
+
+    it("should_return_one_validation_error", () => {
+        results.should.have.lengthOf(1);
+    });
+
+    it("should_have_error_severity", () => {
+        results[0].severity.should.equal(ValidationResultSeverity.Error);
+    });
+});

package/validation/rules/for_NotEmptyRule/when_validating/with_valid_string.ts

@@ -0,0 +1,25 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { NotEmptyRule } from '../../NotEmptyRule';
+
+interface TestType {
+    value: string;
+}
+
+describe("when validating with valid string", () => {
+    let rule: NotEmptyRule<TestType>;
+    let instance: TestType;
+    let results: ReturnType<typeof rule.validate>;
+
+    beforeEach(() => {
+        rule = new NotEmptyRule<TestType>(t => t.value);
+        instance = { value: 'test' };
+    
+        results = rule.validate(instance, 'value');
+    });
+
+    it("should_return_no_validation_errors", () => {
+        results.should.be.empty;
+    });
+});

package/validation/rules/for_NotEmptyRule/when_validating/with_whitespace_string.ts

@@ -0,0 +1,25 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { NotEmptyRule } from '../../NotEmptyRule';
+
+interface TestType {
+    value: string;
+}
+
+describe("when validating with whitespace string", () => {
+    let rule: NotEmptyRule<TestType>;
+    let instance: TestType;
+    let results: ReturnType<typeof rule.validate>;
+
+    beforeEach(() => {
+        rule = new NotEmptyRule<TestType>(t => t.value);
+        instance = { value: '   ' };
+    
+        results = rule.validate(instance, 'value');
+    });
+
+    it("should_return_one_validation_error", () => {
+        results.should.have.lengthOf(1);
+    });
+});