Update assertions

Author: njqdev

test/suite/providers/completionProvider.test.ts

@@ -11,30 +11,30 @@ suite('ParamHintCompletionProvider', () => {
     test("provides items for first param", async () => {
         let param = "param_1:";
         let actual = await providerResult(provider, param);
-        assert.notEqual(actual, null);
+        assert.notStrictEqual(actual, null);
     });
 
     test("provides items for non-first param", async () => {
         let param = "first: str, paramName:";
         let actual = await providerResult(provider, param, "\n\nparamName = 12");
-        assert.notEqual(actual, null);
-        assert.equal(actual?.items[0].label.trim(), PythonType.Int);
+        assert.notStrictEqual(actual, null);
+        assert.strictEqual(actual?.items[0].label.trim(), PythonType.Int);
     });
 
     test("provides items for param on new line", async () => {
         let param = "\n    paramName:";
         let actual = await providerResult(provider, param);
-        assert.notEqual(actual, null);
+        assert.notStrictEqual(actual, null);
 
         param = "\n\tparamName:";
         actual = await providerResult(provider, param);
-        assert.notEqual(actual, null);
+        assert.notStrictEqual(actual, null);
     });
 
     test("provides items for param with legal non-ascii chars", async () => {
         let param = "a変な:";
         let actual = await providerResult(provider, param);
-        assert.notEqual(actual, null);
+        assert.notStrictEqual(actual, null);
     });
 
     test("provides items for nestled function", async () => {
@@ -43,31 +43,31 @@ suite('ParamHintCompletionProvider', () => {
     def nestled(multiple_lines,
                 paramName:`;
         let actual = await providerResult(provider, data);
-        assert.notEqual(actual, null);
+        assert.notStrictEqual(actual, null);
     });
 
     test("provides items for async function", async () => {
         let data = "async def func(test:";
         let pos = new vsc.Position(0, data.length);
         let expected = null;
         let actual = await provideCompletionItems(provider, data, pos);
-        assert.notEqual(actual, null, messageFor(data, expected, actual));
+        assert.notStrictEqual(actual, null, messageFor(data, expected, actual));
 
         let line2 = "        test:";
         data = "async def func(\n" + line2;
         pos = new vsc.Position(1, line2.length);
         actual = await provideCompletionItems(provider, data, pos);
-        assert.notEqual(actual, null, messageFor(data, expected, actual));
+        assert.notStrictEqual(actual, null, messageFor(data, expected, actual));
     });
 
     test("provides default items if nothing is detected", async () => {
         let param = "notFound:";
         let expected = typeHints().concat(typingHints());
         let result = await providerResult(provider, param);
 
-        assert.notEqual(result, null);
+        assert.notStrictEqual(result, null);
         const actual: string[] | undefined = result?.items.map(item => item.label.trim());
-        assert.deepEqual(actual, expected);
+        assert.deepStrictEqual(actual, expected);
     });
 
     test("provides type estimations + default items", async () => {
@@ -76,71 +76,71 @@ suite('ParamHintCompletionProvider', () => {
 
         let result = await providerResult(provider, param, "\n\nparam = Class()");
 
-        assert.notEqual(result, null);
+        assert.notStrictEqual(result, null);
         const actual: string[] | undefined = result?.items.map(item => item.label.trim());
-        assert.deepEqual(actual, expected);
+        assert.deepStrictEqual(actual, expected);
     });
 
     test("does not provide items unless a function def is detected", async () => {
         let text = " :";
         let pos = new vsc.Position(0, text.length);
         let actual = await provideCompletionItems(provider, text, pos);
-        assert.equal(actual, null);
+        assert.strictEqual(actual, null);
     });
 
     test("does not provide items for ':' without a param (within function brackets)", async () => {
         let actual = await providerResult(provider, "param, :");
-        assert.equal(actual, null);
+        assert.strictEqual(actual, null);
     });
 
     test("does not provide items for ':' under a function def", async () => {
         let data = "):\n    d = ', not_a_param:";
         let expected = null;
         let actual = await providerResult(provider, data);
-        assert.equal(actual, expected, messageFor(data, expected, actual));
+        assert.strictEqual(actual, expected, messageFor(data, expected, actual));
 
         data = "):\n    :";
         actual = await providerResult(provider, data);
-        assert.equal(actual, expected, messageFor(data, expected, actual));
+        assert.strictEqual(actual, expected, messageFor(data, expected, actual));
 
         data = "):\n d = { key:";
         actual = await providerResult(provider, data);
-        assert.equal(actual, null, messageFor(data, expected, actual));
+        assert.strictEqual(actual, null, messageFor(data, expected, actual));
 
         data = `self,
         s: str,
         f: float,
         i: int):
     v = ', not_a_param:`;
         actual = await providerResult(provider, data);
-        assert.equal(actual, null, messageFor(data, expected, actual));
+        assert.strictEqual(actual, null, messageFor(data, expected, actual));
 
         data = `self,
         s: str,
         f: float,
         i: int) -> int:
     v = ', not_a_param:`;
         actual = await providerResult(provider, data);
-        assert.equal(actual, null, messageFor(data, expected, actual));
+        assert.strictEqual(actual, null, messageFor(data, expected, actual));
 
         data = `self,
         s: str,
         f: float,
         i: int) -> 変な:
     v = ', not_a_param:`;
         actual = await providerResult(provider, data);
-        assert.equal(actual, null, messageFor(data, expected, actual));
+        assert.strictEqual(actual, null, messageFor(data, expected, actual));
     });
 
     test("does not provide items for end of function definition", async () => {
         let actual = await providerResult(provider, "):");
-        assert.equal(actual, null);
+        assert.strictEqual(actual, null);
     });
 
     test("does not include * in parameter name", async () => {
         let param = "*paramName:";
         let actual = await providerResult(provider, param, "\n\nparamName = 12");
-        assert.equal(actual?.items[0].label.trim(), PythonType.Int);
+        assert.strictEqual(actual?.items[0].label.trim(), PythonType.Int);
     });
 
 });

test/suite/providers/typeHintProvider.test.ts

@@ -18,39 +18,39 @@ suite('TypeHintProvider', () => {
             let documentText = `def test(param:\n\n${param} = 12`;
             let expected = ["int"];
             let actual = await provider.estimateTypeHints(param, documentText);
-            assert.deepEqual(actual, expected);
+            assert.deepStrictEqual(actual, expected);
         });
 
         test("returns [type, typing equivalents] of a collection variable with the same name", async () => {
             let param = "param";
             let documentText = `from typing import List\ndef test(param:\n\n${param} = [12]`;
             let expected = 3;
             let result = await provider.estimateTypeHints(param, documentText);
-            assert.equal(result.length, expected);
+            assert.strictEqual(result.length, expected);
         });
 
         test("does not return duplicates as a result of a type guess", async () => {
             let param = "text";
             let documentText = `def test(param:\n\n${param} = 'this.typeGuessFor() returns str for the param name'`;
             let expected = ["str"];
             let actual = await provider.estimateTypeHints(param, documentText);
-            assert.deepEqual(actual, expected);
+            assert.deepStrictEqual(actual, expected);
         });
 
         test("returns type of a variable and a type guess, if the types differ", async () => {
             let param = "number";
             let documentText = `def test(param:\n\n${param} = 1.23`;
             let expected = 2;
             let result = await provider.estimateTypeHints(param, documentText);
-            assert.equal(result.length, expected);
+            assert.strictEqual(result.length, expected);
         });
 
         test("returns class with same name", async () => {
             let param = "test";
             let documentText = `class Test:`;
             let expected = ["Test"];
             let actual = await provider.estimateTypeHints(param, documentText);
-            assert.deepEqual(actual, expected);
+            assert.deepStrictEqual(actual, expected);
         });
 
         test("returns hint of similar param", async () => {
@@ -59,32 +59,32 @@ suite('TypeHintProvider', () => {
             let documentText = `def func(test: ${hint}):`;
             let expected = [hint];
             let actual = await provider.estimateTypeHints(param, documentText);
-            assert.deepEqual(actual, expected);
+            assert.deepStrictEqual(actual, expected);
         });
 
         test("returns type if param name ends with it", async () => {
             let param = "test_str";
             let expected = ["str"];
             let actual = await provider.estimateTypeHints(param, "");
-            assert.deepEqual(actual, expected, messageFor(param, expected, actual));
+            assert.deepStrictEqual(actual, expected, messageFor(param, expected, actual));
 
             provider = new TypeHintProvider(getDataTypeContainer());
             param = "teststr";
             actual = await provider.estimateTypeHints(param, "");
-            assert.deepEqual(actual, expected, messageFor(param, expected, actual));
+            assert.deepStrictEqual(actual, expected, messageFor(param, expected, actual));
         });
 
         test("returns [type, typing equivalent] if param name ends with collection type", async () => {
             let param = "test_list";
             let documentText = `from typing import List`;
             let expected = ["list", "List["];
             let actual = await provider.estimateTypeHints(param, documentText);
-            assert.deepEqual(actual, expected, messageFor(param, expected, actual));
+            assert.deepStrictEqual(actual, expected, messageFor(param, expected, actual));
 
             provider = new TypeHintProvider(getDataTypeContainer());
             param = "testlist";
             actual = await provider.estimateTypeHints(param, documentText);
-            assert.deepEqual(actual, expected, messageFor(param, expected, actual));
+            assert.deepStrictEqual(actual, expected, messageFor(param, expected, actual));
         });
 
     });

test/suite/providers/typingHintProvider.test.ts

@@ -21,17 +21,17 @@ suite('TypingHintProvider', () => {
 
         test("returns true for 'import typing'", async () => {
             const actual = await provider.detectTypingImport(importTyping);
-            assert.equal(actual, true);
+            assert.strictEqual(actual, true);
         });
 
         test("returns true for 'import typing as x'", async () => {
             const actual = await provider.detectTypingImport(importTypingAsX);
-            assert.equal(actual, true);
+            assert.strictEqual(actual, true);
         });
 
         test("returns true for 'from typing import x'", async () => {
             const actual = await provider.detectTypingImport(fromTypingImport);
-            assert.equal(actual, true);
+            assert.strictEqual(actual, true);
         });
     });
 
@@ -60,7 +60,7 @@ suite('TypingHintProvider', () => {
 
         function getHintTest(provider: TypingHintProvider, expected: string) {
             const actual = provider.getHint(PythonType.List);
-            assert.equal(actual, expected);
+            assert.strictEqual(actual, expected);
         }
     });
 
@@ -120,7 +120,7 @@ suite('TypingHintProvider', () => {
 
         function getHintsTest(provider: TypingHintProvider, testCase: TestCase, type: PythonType) {
             const actual = provider.getHints(varSearchResult(type, testCase.data));
-            assert.deepEqual(actual, testCase.expected, messageFor(testCase.data, testCase.expected, actual));
+            assert.deepStrictEqual(actual, testCase.expected, messageFor(testCase.data, testCase.expected, actual));
         }
     });
 
@@ -136,7 +136,7 @@ suite('TypingHintProvider', () => {
             await provider.detectTypingImport("");
             const expected = typingTypes(false).concat(typingTypes(true));
             const actual = provider.getRemainingHints();
-            assert.deepEqual(actual, expected);
+            assert.deepStrictEqual(actual, expected);
         });
 
         test("returns hints without prefix first, for from typing import", async () => {
@@ -162,7 +162,7 @@ suite('TypingHintProvider', () => {
 
         function getRemainingHintsTest(provider: TypingHintProvider, expected: string) {
             const actual = provider.getRemainingHints();
-            assert.deepEqual(actual, expected);
+            assert.deepStrictEqual(actual, expected);
         }
     });
 

test/suite/typeSearch/classWithSameName.test.ts

@@ -9,26 +9,26 @@ suite('TypeSearch.classWithSameName', () => {
         let expected = "Test";
         let src = `class ${expected}:`;
         let actual = TypeSearch.classWithSameName(value, src);
-        assert.equal(actual, expected);
+        assert.strictEqual(actual, expected);
     });
 
     test("finds subclass", () => {
         let value = "test";
         let expected = "Test";
         let src = `class ${expected}(Super):`;
         let actual = TypeSearch.classWithSameName(value, src);
-        assert.equal(actual, expected);
+        assert.strictEqual(actual, expected);
     });
 
     test("handles tabs and spaces", () => {
         let value = "test";
         let expected = "Test";
         let src = `\tclass  ${expected}:`;
         let actual = TypeSearch.classWithSameName(value, src);
-        assert.equal(actual, expected, messageFor(src, expected, actual));
+        assert.strictEqual(actual, expected, messageFor(src, expected, actual));
 
         src = `    class  ${expected}:`;
         actual = TypeSearch.classWithSameName(value, src);
-        assert.equal(actual, expected, messageFor(src, expected, actual));
+        assert.strictEqual(actual, expected, messageFor(src, expected, actual));
     });
 });