@futdevpro/dynamo-eslint 1.15.25 → 1.20.2

package/src/plugin/rules/explicit-types.spec.ts

@@ -1,190 +1,190 @@
-import explicitTypesRule from './explicit-types';
-
-describe('| explicit-types', () => {
-  it('| should be a valid ESLint rule', () => {
-    expect(explicitTypesRule.meta?.type).toBe('suggestion');
-    expect(explicitTypesRule.meta?.docs?.description).toContain('explicit type annotations');
-  });
-
-  it('| should have create function that returns visitor object', () => {
-    const mockContext = {
-      report: () => {},
-    } as any;
-
-    const result = explicitTypesRule.create(mockContext);
-
-    expect(typeof result).toBe('object');
-    expect(typeof result.FunctionDeclaration).toBe('function');
-    expect(typeof result.ArrowFunctionExpression).toBe('function');
-    expect(typeof result.VariableDeclarator).toBe('function');
-    expect(typeof result.PropertyDefinition).toBe('function');
-  });
-
-  it('| should report missing return types on function declarations', () => {
-    const mockContext = {
-      report: (options: any) => {
-        expect(options.messageId).toBe('missingReturnType');
-        expect(options.data.name).toBe('testFunction');
-      },
-    } as any;
-
-    const mockNode = {
-      type: 'FunctionDeclaration' as const,
-      id: { name: 'testFunction' },
-      returnType: null,
-      params: [],
-    } as any;
-
-    const rule = explicitTypesRule.create(mockContext);
-    rule.FunctionDeclaration(mockNode);
-  });
-
-  it('| should not report when function has return type', () => {
-    const mockContext = {
-      report: (options: any) => {
-        fail('Should not report when function has return type');
-      },
-    } as any;
-
-    const mockNode = {
-      type: 'FunctionDeclaration' as const,
-      id: { name: 'testFunction' },
-      returnType: { type: 'TSTypeAnnotation' },
-      params: [],
-    } as any;
-
-    const rule = explicitTypesRule.create(mockContext);
-    rule.FunctionDeclaration(mockNode);
-  });
-
-  it('| should report missing return types on arrow functions', () => {
-    const mockContext = {
-      report: (options: any) => {
-        expect(options.messageId).toBe('missingArrowReturnType');
-      },
-    } as any;
-
-    const mockNode = {
-      type: 'ArrowFunctionExpression' as const,
-      returnType: null,
-      params: [],
-    } as any;
-
-    const rule = explicitTypesRule.create(mockContext);
-    rule.ArrowFunctionExpression(mockNode);
-  });
-
-  it('| should report missing types on variable declarations', () => {
-    const mockContext = {
-      report: (options: any) => {
-        expect(options.messageId).toBe('missingVariableType');
-        expect(options.data.name).toBe('testVar');
-      },
-    } as any;
-
-    const mockNode = {
-      type: 'VariableDeclarator' as const,
-      id: { name: 'testVar', typeAnnotation: null },
-      init: null,
-    } as any;
-
-    const rule = explicitTypesRule.create(mockContext);
-    rule.VariableDeclarator(mockNode);
-  });
-
-  it('| should not report when variable has type annotation', () => {
-    const mockContext = {
-      report: (options: any) => {
-        fail('Should not report when variable has type annotation');
-      },
-    } as any;
-
-    const mockNode = {
-      type: 'VariableDeclarator' as const,
-      id: { name: 'testVar', typeAnnotation: { type: 'TSTypeAnnotation' } },
-      init: null,
-    } as any;
-
-    const rule = explicitTypesRule.create(mockContext);
-    rule.VariableDeclarator(mockNode);
-  });
-
-  it('| should not report when variable has typed initializer', () => {
-    const mockContext = {
-      report: (options: any) => {
-        fail('Should not report when variable has typed initializer');
-      },
-    } as any;
-
-    const mockNode = {
-      type: 'VariableDeclarator' as const,
-      id: { name: 'testVar', typeAnnotation: null },
-      init: { type: 'CallExpression' },
-    } as any;
-
-    const rule = explicitTypesRule.create(mockContext);
-    rule.VariableDeclarator(mockNode);
-  });
-
-  it('| should report missing parameter types', () => {
-    const mockContext = {
-      report: (options: any) => {
-        expect(options.messageId).toBe('missingParameterType');
-        expect(options.data.name).toBe('param');
-      },
-    } as any;
-
-    const mockNode = {
-      type: 'FunctionDeclaration' as const,
-      id: { name: 'testFunction' },
-      returnType: { type: 'TSTypeAnnotation' },
-      params: [
-        { type: 'Identifier', name: 'param', typeAnnotation: null }
-      ],
-    } as any;
-
-    const rule = explicitTypesRule.create(mockContext);
-    rule.FunctionDeclaration(mockNode);
-  });
-
-  it('| should report missing class property types', () => {
-    const mockContext = {
-      report: (options: any) => {
-        expect(options.messageId).toBe('missingPropertyType');
-        expect(options.data.name).toBe('property');
-      },
-    } as any;
-
-    const mockNode = {
-      type: 'PropertyDefinition' as const,
-      key: { name: 'property' },
-      typeAnnotation: null,
-      value: null,
-    } as any;
-
-    const rule = explicitTypesRule.create(mockContext);
-    rule.PropertyDefinition(mockNode);
-  });
-
-  it('| should report missing destructuring types', () => {
-    const mockContext = {
-      report: (options: any) => {
-        expect(options.messageId).toBe('missingDestructuringType');
-      },
-    } as any;
-
-    const objectPatternNode = {
-      type: 'ObjectPattern' as const,
-      typeAnnotation: null,
-    } as any;
-
-    const arrayPatternNode = {
-      type: 'ArrayPattern' as const,
-      typeAnnotation: null,
-    } as any;
-
-    const rule = explicitTypesRule.create(mockContext);
-    rule.ObjectPattern(objectPatternNode);
-    rule.ArrayPattern(arrayPatternNode);
-  });
-});
+import explicitTypesRule from './explicit-types';
+
+describe('| explicit-types', () => {
+  it('| should be a valid ESLint rule', () => {
+    expect(explicitTypesRule.meta?.type).toBe('suggestion');
+    expect(explicitTypesRule.meta?.docs?.description).toContain('explicit type annotations');
+  });
+
+  it('| should have create function that returns visitor object', () => {
+    const mockContext = {
+      report: () => {},
+    } as any;
+
+    const result = explicitTypesRule.create(mockContext);
+
+    expect(typeof result).toBe('object');
+    expect(typeof result.FunctionDeclaration).toBe('function');
+    expect(typeof result.ArrowFunctionExpression).toBe('function');
+    expect(typeof result.VariableDeclarator).toBe('function');
+    expect(typeof result.PropertyDefinition).toBe('function');
+  });
+
+  it('| should report missing return types on function declarations', () => {
+    const mockContext = {
+      report: (options: any) => {
+        expect(options.messageId).toBe('missingReturnType');
+        expect(options.data.name).toBe('testFunction');
+      },
+    } as any;
+
+    const mockNode = {
+      type: 'FunctionDeclaration' as const,
+      id: { name: 'testFunction' },
+      returnType: null,
+      params: [],
+    } as any;
+
+    const rule = explicitTypesRule.create(mockContext);
+    rule.FunctionDeclaration(mockNode);
+  });
+
+  it('| should not report when function has return type', () => {
+    const mockContext = {
+      report: (options: any) => {
+        fail('Should not report when function has return type');
+      },
+    } as any;
+
+    const mockNode = {
+      type: 'FunctionDeclaration' as const,
+      id: { name: 'testFunction' },
+      returnType: { type: 'TSTypeAnnotation' },
+      params: [],
+    } as any;
+
+    const rule = explicitTypesRule.create(mockContext);
+    rule.FunctionDeclaration(mockNode);
+  });
+
+  it('| should report missing return types on arrow functions', () => {
+    const mockContext = {
+      report: (options: any) => {
+        expect(options.messageId).toBe('missingArrowReturnType');
+      },
+    } as any;
+
+    const mockNode = {
+      type: 'ArrowFunctionExpression' as const,
+      returnType: null,
+      params: [],
+    } as any;
+
+    const rule = explicitTypesRule.create(mockContext);
+    rule.ArrowFunctionExpression(mockNode);
+  });
+
+  it('| should report missing types on variable declarations', () => {
+    const mockContext = {
+      report: (options: any) => {
+        expect(options.messageId).toBe('missingVariableType');
+        expect(options.data.name).toBe('testVar');
+      },
+    } as any;
+
+    const mockNode = {
+      type: 'VariableDeclarator' as const,
+      id: { name: 'testVar', typeAnnotation: null },
+      init: null,
+    } as any;
+
+    const rule = explicitTypesRule.create(mockContext);
+    rule.VariableDeclarator(mockNode);
+  });
+
+  it('| should not report when variable has type annotation', () => {
+    const mockContext = {
+      report: (options: any) => {
+        fail('Should not report when variable has type annotation');
+      },
+    } as any;
+
+    const mockNode = {
+      type: 'VariableDeclarator' as const,
+      id: { name: 'testVar', typeAnnotation: { type: 'TSTypeAnnotation' } },
+      init: null,
+    } as any;
+
+    const rule = explicitTypesRule.create(mockContext);
+    rule.VariableDeclarator(mockNode);
+  });
+
+  it('| should not report when variable has typed initializer', () => {
+    const mockContext = {
+      report: (options: any) => {
+        fail('Should not report when variable has typed initializer');
+      },
+    } as any;
+
+    const mockNode = {
+      type: 'VariableDeclarator' as const,
+      id: { name: 'testVar', typeAnnotation: null },
+      init: { type: 'CallExpression' },
+    } as any;
+
+    const rule = explicitTypesRule.create(mockContext);
+    rule.VariableDeclarator(mockNode);
+  });
+
+  it('| should report missing parameter types', () => {
+    const mockContext = {
+      report: (options: any) => {
+        expect(options.messageId).toBe('missingParameterType');
+        expect(options.data.name).toBe('param');
+      },
+    } as any;
+
+    const mockNode = {
+      type: 'FunctionDeclaration' as const,
+      id: { name: 'testFunction' },
+      returnType: { type: 'TSTypeAnnotation' },
+      params: [
+        { type: 'Identifier', name: 'param', typeAnnotation: null }
+      ],
+    } as any;
+
+    const rule = explicitTypesRule.create(mockContext);
+    rule.FunctionDeclaration(mockNode);
+  });
+
+  it('| should report missing class property types', () => {
+    const mockContext = {
+      report: (options: any) => {
+        expect(options.messageId).toBe('missingPropertyType');
+        expect(options.data.name).toBe('property');
+      },
+    } as any;
+
+    const mockNode = {
+      type: 'PropertyDefinition' as const,
+      key: { name: 'property' },
+      typeAnnotation: null,
+      value: null,
+    } as any;
+
+    const rule = explicitTypesRule.create(mockContext);
+    rule.PropertyDefinition(mockNode);
+  });
+
+  it('| should report missing destructuring types', () => {
+    const mockContext = {
+      report: (options: any) => {
+        expect(options.messageId).toBe('missingDestructuringType');
+      },
+    } as any;
+
+    const objectPatternNode = {
+      type: 'ObjectPattern' as const,
+      typeAnnotation: null,
+    } as any;
+
+    const arrayPatternNode = {
+      type: 'ArrayPattern' as const,
+      typeAnnotation: null,
+    } as any;
+
+    const rule = explicitTypesRule.create(mockContext);
+    rule.ObjectPattern(objectPatternNode);
+    rule.ArrayPattern(arrayPatternNode);
+  });
+});