codelyzer/test/useLifecycleInterfaceRule.spec.ts at master · xdYoung/codelyzer · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
import { getFailureMessage, Rule } from '../src/useLifecycleInterfaceRule';
import { AngularLifecycleInterfaces, AngularLifecycleMethods } from '../src/util/utils';
import { assertAnnotated, assertFailures, assertSuccess } from './testHelper';

const {
  metadata: { ruleName },
} = Rule;

describe(ruleName, () => {
  describe('failure', () => {
    it('should fail if lifecycle method is declared without implementing its interface', () => {
      const source = `
        class Test {
          ngOnInit() {
          ~~~~~~~~
          }
        }
      `;
      const message = getFailureMessage({
        interfaceName: AngularLifecycleInterfaces.OnInit,
        methodName: AngularLifecycleMethods.ngOnInit,
      });
      assertAnnotated({
        message,
        ruleName,
        source,
      });
    });

    it('should fail if one of the lifecycle methods is declared without implementing its interface', () => {
      const source = `
        class Test extends Component implements OnInit {
          ngOnInit() {}

          ngOnDestroy() {
          ~~~~~~~~~~~
          }
        }
      `;
      const message = getFailureMessage({
        interfaceName: AngularLifecycleInterfaces.OnDestroy,
        methodName: AngularLifecycleMethods.ngOnDestroy,
      });
      assertAnnotated({
        message,
        ruleName,
        source,
      });
    });

    it('should fail if lifecycle methods are declared without implementing their interfaces', () => {
      const source = `
        class Test {
          ngOnInit() {}

          ngOnDestroy() {}
        }
      `;
      assertFailures(ruleName, source, [
        {
          endPosition: {
            character: 18,
            line: 2,
          },
          message: getFailureMessage({
            interfaceName: AngularLifecycleInterfaces.OnInit,
            methodName: AngularLifecycleMethods.ngOnInit,
          }),
          startPosition: {
            character: 10,
            line: 2,
          },
        },
        {
          endPosition: {
            character: 21,
            line: 4,
          },
          message: getFailureMessage({
            interfaceName: AngularLifecycleInterfaces.OnDestroy,
            methodName: AngularLifecycleMethods.ngOnDestroy,
          }),
          startPosition: {
            character: 10,
            line: 4,
          },
        },
      ]);
    });

    it('should fail if lifecycle methods are declared without implementing their interfaces, using namespace', () => {
      const source = `
        class Test extends Component implements ng.OnInit {
          ngOnInit() {}

          ngOnDestroy() {
          ~~~~~~~~~~~
          }
        }
      `;
      const message = getFailureMessage({
        interfaceName: AngularLifecycleInterfaces.OnDestroy,
        methodName: AngularLifecycleMethods.ngOnDestroy,
      });
      assertAnnotated({
        message,
        ruleName,
        source,
      });
    });
  });

  describe('success', () => {
    it('should succeed if lifecycle method is declared implementing its interface', () => {
      const source = `
        class Test implements OnInit {
          ngOnInit() {}
        }
      `;
      assertSuccess(ruleName, source);
    });

    it('should succeed if lifecycle methods are declared implementing their interfaces', () => {
      const source = `
        class Test extends Component implements OnInit, OnDestroy  {
          ngOnInit() {}

          private ngOnChanges = '';

          ngOnDestroy() {}

          ngOnSmth {}
        }
      `;
      assertSuccess(ruleName, source);
    });

    it('should succeed if lifecycle methods are declared implementing their interfaces, using namespaces', () => {
      const source = `
        class Test extends Component implements ng.OnInit, ng.OnDestroy  {
          ngOnInit() {}

          private ngOnChanges = '';

          ngOnDestroy() {}

          ngOnSmth {}
        }
      `;
      assertSuccess(ruleName, source);
    });

    it('should succeed if no lifecycle methods are declared', () => {
      const source = `
        class Test {}
      `;
      assertSuccess(ruleName, source);
    });
  });
});