Change toBe to toEqual when ref equals not needed

Author: davidwalschots

angular-reactive-validation/src/get-control-path.spec.ts

@@ -20,7 +20,7 @@ describe('getControlPath', () => {
       })
     });
 
-    expect(getControlPath(firstName)).toBe('name.firstName');
+    expect(getControlPath(firstName)).toEqual('name.firstName');
   }));
 
   it(`emits numeric paths for form arrays`, inject([FormBuilder], (fb: FormBuilder) => {
@@ -38,22 +38,22 @@ describe('getControlPath', () => {
       ])
     });
 
-    expect(getControlPath(firstName)).toBe('persons.0.firstName');
-    expect(getControlPath(firstName2)).toBe('persons.1.firstName');
+    expect(getControlPath(firstName)).toEqual('persons.0.firstName');
+    expect(getControlPath(firstName2)).toEqual('persons.1.firstName');
   }));
 
   it(`emits an empty string for a control without parents`, inject([FormBuilder], (fb: FormBuilder) => {
     const control = fb.control('');
 
-    expect(getControlPath(control)).toBe('');
+    expect(getControlPath(control)).toEqual('');
   }));
 
   it(`emits an index string for a control with only a form array as parent`, inject([FormBuilder], (fb: FormBuilder) => {
     const control = fb.control('');
 
     fb.array([control]);
 
-    expect(getControlPath(control)).toBe('0');
+    expect(getControlPath(control)).toEqual('0');
   }));
 
   it(`emits a single identifier for a control with only a single form group as parent`, inject([FormBuilder], (fb: FormBuilder) => {
@@ -63,6 +63,6 @@ describe('getControlPath', () => {
       control: control
     });
 
-    expect(getControlPath(control)).toBe('control');
+    expect(getControlPath(control)).toEqual('control');
   }));
 });

angular-reactive-validation/src/observable-container.spec.ts

@@ -12,71 +12,71 @@ describe('ObservableContainer', () => {
     const container = new ObservableContainer(() => called = true);
 
     container.subscribe({}, () => subject);
-    expect(called).toBe(false);
+    expect(called).toEqual(false);
     subject.next();
-    expect(called).toBe(true);
+    expect(called).toEqual(true);
   });
 
   it(`calls the function on subscribe`, () => {
     let called = false;
     const container = new ObservableContainer(() => called = true);
 
     container.subscribe({}, () => subject, true);
-    expect(called).toBe(true);
+    expect(called).toEqual(true);
   });
 
   it(`calls the function multiple times when the observable emits multiple times`, () => {
     let calls = 0;
     const container = new ObservableContainer(() => calls++);
 
     container.subscribe({}, () => subject);
-    expect(calls).toBe(0);
+    expect(calls).toEqual(0);
     subject.next();
     subject.next();
-    expect(calls).toBe(2);
+    expect(calls).toEqual(2);
   });
 
   it(`calls the function once per subscribing object`, () => {
     let calls = 0;
-    const objA = {};
-    const objB = {};
+    const objA = { x: 1 };
+    const objB = { x: 2 };
     const container = new ObservableContainer(obj => {
       if (calls === 0) {
-        expect(obj).toEqual(objA);
+        expect(obj).toBe(objA);
       } else {
-        expect(obj).toEqual(objB);
+        expect(obj).toBe(objB);
       }
       calls++;
     });
 
-    container.subscribe([objA, {}], () => subject);
-    expect(calls).toBe(0);
+    container.subscribe([objA, objB], () => subject);
+    expect(calls).toEqual(0);
     subject.next();
-    expect(calls).toBe(2);
+    expect(calls).toEqual(2);
   });
 
   it(`unsubscribes and no longer calls the function when the observable emits`, () => {
     let calls = 0;
     const container = new ObservableContainer(() => calls++);
 
     container.subscribe([{}, {}], () => subject);
-    expect(subject.observers.length).toBe(2);
+    expect(subject.observers.length).toEqual(2);
 
     container.unsubscribeAll();
-    expect(subject.observers.length).toBe(0);
+    expect(subject.observers.length).toEqual(0);
 
     subject.next();
-    expect(calls).toBe(0);
+    expect(calls).toEqual(0);
   });
 
   it(`doesn't subscribe or call the function when no objects are provided`, () => {
     let called = false;
     const container = new ObservableContainer(() => called = true);
 
     container.subscribe([], () => subject);
-    expect(subject.observers.length).toBe(0);
-    expect(called).toBe(false);
+    expect(subject.observers.length).toEqual(0);
+    expect(called).toEqual(false);
     subject.next();
-    expect(called).toBe(false);
+    expect(called).toEqual(false);
   });
 });

angular-reactive-validation/src/validation-error.spec.ts

@@ -12,7 +12,7 @@ describe('ValidationError', () => {
     const error = ValidationError.fromFirstError(control);
 
     expect(error.control).toEqual(control);
-    expect(error.key).toBe('required');
+    expect(error.key).toEqual('required');
     expect(error.errorObject).toEqual(requiredErrorObject);
   });
 
@@ -22,7 +22,7 @@ describe('ValidationError', () => {
     };
     const error = ValidationError.fromFirstError(control);
 
-    expect(error).toBe(undefined);
+    expect(error).toEqual(undefined);
   });
 
   it(`hasMessage returns true when the errorObject contains a message`, () => {
@@ -34,7 +34,7 @@ describe('ValidationError', () => {
       }
     };
     const error = ValidationError.fromFirstError(control);
-    expect(error.hasMessage()).toBe(true);
+    expect(error.hasMessage()).toEqual(true);
   });
 
   it(`hasMessage returns false when the errorObject doesn't contain a message`, () => {
@@ -44,7 +44,7 @@ describe('ValidationError', () => {
       }
     };
     const error = ValidationError.fromFirstError(control);
-    expect(error.hasMessage()).toBe(false);
+    expect(error.hasMessage()).toEqual(false);
   });
 
   it(`getMessage returns the message from the errorObject`, () => {
@@ -57,6 +57,6 @@ describe('ValidationError', () => {
       }
     };
     const error = ValidationError.fromFirstError(control);
-    expect(error.getMessage()).toBe(expected);
+    expect(error.getMessage()).toEqual(expected);
   });
 });

angular-reactive-validation/src/validation-message/validation-message.component.spec.ts

@@ -24,7 +24,7 @@ describe('ValidationMessageComponent', () => {
 
     const result = component.canHandle(error);
 
-    expect(result).toBe(true);
+    expect(result).toEqual(true);
   });
 
   it(`canHandle returns true when the error key and component key are equal (with for)`, () => {
@@ -34,7 +34,7 @@ describe('ValidationMessageComponent', () => {
 
     const result = component.canHandle(error);
 
-    expect(result).toBe(true);
+    expect(result).toEqual(true);
   });
 
   it(`canHandle returns false when the component 'for' doesn't equal the error's control`, () => {
@@ -44,7 +44,7 @@ describe('ValidationMessageComponent', () => {
 
     const result = component.canHandle(error);
 
-    expect(result).toBe(false);
+    expect(result).toEqual(false);
   });
 
   it(`canHandle returns false when the error key doesn't equal the component key`, () => {
@@ -53,7 +53,7 @@ describe('ValidationMessageComponent', () => {
 
     const result = component.canHandle(error);
 
-    expect(result).toBe(false);
+    expect(result).toEqual(false);
   });
 
   function setupErrorMessageTests(): {
@@ -81,7 +81,7 @@ describe('ValidationMessageComponent', () => {
     fixture.detectChanges();
     expect(fixture.nativeElement.querySelector('.message')).not.toBeFalsy();
     expect(fixture.nativeElement.querySelector('.message').textContent)
-      .toBe(`The message is shown. requiredLength: ${error.errorObject.requiredLength}`);
+      .toEqual(`The message is shown. requiredLength: ${error.errorObject.requiredLength}`);
   });
 
   it(`reset hides the error message`, () => {