src/__tests__/app-error.unit.js - Code Metrics - hckrnews/error - Measure and Improve Code Quality continuously with Scrutinizer

src/tests/app-error.unit.js A
last analyzed 2024-04-19 10:26 UTC

↳ Parent: Project

Complexity

Total Complexity	17
Complexity/F	1.21

Size

Lines of Code	187
Function Count	14

Duplication

Duplicated Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
wmc	17
eloc	144
mnd	3
bc	3
fnc	14
dl	0
loc	187
rs	10
bpm	0.2142
cpm	1.2142
noi	0
c	0
b	0
f	0

import { expect, describe, it } from '@jest/globals';
import { AppError } from '../index.js';

describe('App Error test', () => {
    it('It should create a app error with minimum fields', () => {
        const error = new AppError({
            message: 'Example text',
        });

        expect(error instanceof AppError).toEqual(true);
        expect(error instanceof Error).toEqual(true);
        expect(error.name).toEqual('AppError');
        expect(error.message).toEqual('Example text');
        expect(error.value).toEqual(null);
        expect(error.status).toEqual(500);
        expect(error.type).toEqual(null);
        expect(error.date.constructor).toEqual(Date);
        expect(error.stack.includes('AppError: Example text')).toEqual(true);
        expect(error.me).toEqual(null);
    });

    it('It should create a app error with null on optional fields', () => {
        const error = new AppError({
            value: null,
            type: null,
            message: 'Example text',
            me: null,
        });

        expect(error instanceof AppError).toEqual(true);
        expect(error instanceof Error).toEqual(true);
        expect(error.name).toEqual('AppError');
        expect(error.message).toEqual('Example text');
        expect(error.value).toEqual(null);
        expect(error.status).toEqual(500);
        expect(error.type).toEqual(null);
        expect(error.date.constructor).toEqual(Date);
        expect(error.stack.includes('AppError: Example text')).toEqual(true);
        expect(error.me).toEqual(null);
    });

    it('It should create a app error with undefined on optional fields', () => {
        const error = new AppError({
            value: undefined,
            type: undefined,
            message: 'Example text',
            me: undefined,
        });

        expect(error instanceof AppError).toEqual(true);
        expect(error instanceof Error).toEqual(true);
        expect(error.name).toEqual('AppError');
        expect(error.message).toEqual('Example text');
        expect(error.value).toEqual(null);
        expect(error.status).toEqual(500);
        expect(error.type).toEqual(null);
        expect(error.date.constructor).toEqual(Date);
        expect(error.stack.includes('AppError: Example text')).toEqual(true);
        expect(error.me).toEqual(null);
    });

    it('It should create a app error', () => {
        const error = new AppError({
            value: 'test',
            type: String,
            message: 'Example text',
            me: AppError,
        });

        expect(error instanceof AppError).toEqual(true);
        expect(error instanceof Error).toEqual(true);
        expect(error.name).toEqual('AppError');
        expect(error.message).toEqual('Example text');
        expect(error.value).toEqual('test');
        expect(error.status).toEqual(500);
        expect(error.type).toEqual(String);
        expect(error.date.constructor).toEqual(Date);
        expect(error.stack.includes('AppError: Example text')).toEqual(true);
        expect(error.me).toEqual(AppError);
    });

    it('It should handle invalid error values', () => {
        const error = new AppError({
            value: 'test',
            type: 'string',
            message: 'Example text',
            me: AppError,
        });

        expect(error instanceof AppError).toEqual(true);
        expect(error instanceof Error).toEqual(true);
        expect(error.name).toEqual('AppError');
        expect(error.message).toEqual('Invalid error');
        expect(error.value.errors[0][0]).toEqual('type?');
        expect(error.value.values.message).toEqual('Invalid error');
        expect(error.value.values.name).toEqual('AppError');
        expect(error.value.values.status).toEqual(500);
        expect(error.value.values.type).toEqual(Error);
        expect(error.value.values.value).toEqual('test');
        expect(error.status).toEqual(500);
        expect(error.type).toEqual(Error);
        expect(error.date.constructor).toEqual(Date);
        expect(error.stack.includes('AppError: Invalid error')).toEqual(true);
        expect(error.me).toEqual(AppError);
    });

    it('It should catch the error from the stack', () => {
        const DoTwo = () => {
            throw new AppError({
                value: 'test',
                type: String,
                message: 'Example from two',
                me: AppError,
            });
        };

        const DoOne = () => {
            try {
                DoTwo();
            } catch (error) {
                throw new AppError({
                    value: 'test',
                    type: String,
                    message: 'Example from one',
                    me: AppError,
                });
            }
        };

        expect(() => {
            DoOne();
        }).toThrowError('Example from one');

        try {
            DoOne();
        } catch (error) {
            expect(error instanceof AppError).toEqual(true);
            expect(error instanceof Error).toEqual(true);
            expect(error.name).toEqual('AppError');
            expect(error.message).toEqual('Example from one');
            expect(error.value).toEqual('test');
            expect(error.status).toEqual(500);
            expect(error.type).toEqual(String);
            expect(error.date.constructor).toEqual(Date);
            expect(error.stack.includes('AppError: Example from one')).toEqual(
                true
            );
            expect(error.me).toEqual(AppError);
        }
    });

    it('It should catch the error from the sub stack', () => {
        const DoFour = () => {
            throw new AppError({
                value: 'test',
                type: String,
                message: 'Example from four',
                me: AppError,
            });
        };

        const DoThree = () => {
            DoFour();
        };

        expect(() => {
            DoThree();
        }).toThrowError('Example from four');

        try {
            DoThree();
        } catch (error) {
            expect(error instanceof AppError).toEqual(true);
            expect(error instanceof Error).toEqual(true);
            expect(error.name).toEqual('AppError');
            expect(error.message).toEqual('Example from four');
            expect(error.value).toEqual('test');
            expect(error.status).toEqual(500);
            expect(error.type).toEqual(String);
            expect(error.date.constructor).toEqual(Date);
            expect(error.stack.includes('AppError: Example from four')).toEqual(
                true
            );
            expect(error.me).toEqual(AppError);
        }
    });
});


1			import { expect, describe, it } from '@jest/globals';
2			import { AppError } from '../index.js';
3
4			describe('App Error test', () => {
5			it('It should create a app error with minimum fields', () => {
6			const error = new AppError({
7			message: 'Example text',
8			});
9
10			expect(error instanceof AppError).toEqual(true);
11			expect(error instanceof Error).toEqual(true);
12			expect(error.name).toEqual('AppError');
13			expect(error.message).toEqual('Example text');
14			expect(error.value).toEqual(null);
15			expect(error.status).toEqual(500);
16			expect(error.type).toEqual(null);
17			expect(error.date.constructor).toEqual(Date);
18			expect(error.stack.includes('AppError: Example text')).toEqual(true);
19			expect(error.me).toEqual(null);
20			});
21
22			it('It should create a app error with null on optional fields', () => {
23			const error = new AppError({
24			value: null,
25			type: null,
26			message: 'Example text',
27			me: null,
28			});
29
30			expect(error instanceof AppError).toEqual(true);
31			expect(error instanceof Error).toEqual(true);
32			expect(error.name).toEqual('AppError');
33			expect(error.message).toEqual('Example text');
34			expect(error.value).toEqual(null);
35			expect(error.status).toEqual(500);
36			expect(error.type).toEqual(null);
37			expect(error.date.constructor).toEqual(Date);
38			expect(error.stack.includes('AppError: Example text')).toEqual(true);
39			expect(error.me).toEqual(null);
40			});
41
42			it('It should create a app error with undefined on optional fields', () => {
43			const error = new AppError({
44			value: undefined,
45			type: undefined,
46			message: 'Example text',
47			me: undefined,
48			});
49
50			expect(error instanceof AppError).toEqual(true);
51			expect(error instanceof Error).toEqual(true);
52			expect(error.name).toEqual('AppError');
53			expect(error.message).toEqual('Example text');
54			expect(error.value).toEqual(null);
55			expect(error.status).toEqual(500);
56			expect(error.type).toEqual(null);
57			expect(error.date.constructor).toEqual(Date);
58			expect(error.stack.includes('AppError: Example text')).toEqual(true);
59			expect(error.me).toEqual(null);
60			});
61
62			it('It should create a app error', () => {
63			const error = new AppError({
64			value: 'test',
65			type: String,
66			message: 'Example text',
67			me: AppError,
68			});
69
70			expect(error instanceof AppError).toEqual(true);
71			expect(error instanceof Error).toEqual(true);
72			expect(error.name).toEqual('AppError');
73			expect(error.message).toEqual('Example text');
74			expect(error.value).toEqual('test');
75			expect(error.status).toEqual(500);
76			expect(error.type).toEqual(String);
77			expect(error.date.constructor).toEqual(Date);
78			expect(error.stack.includes('AppError: Example text')).toEqual(true);
79			expect(error.me).toEqual(AppError);
80			});
81
82			it('It should handle invalid error values', () => {
83			const error = new AppError({
84			value: 'test',
85			type: 'string',
86			message: 'Example text',
87			me: AppError,
88			});
89
90			expect(error instanceof AppError).toEqual(true);
91			expect(error instanceof Error).toEqual(true);
92			expect(error.name).toEqual('AppError');
93			expect(error.message).toEqual('Invalid error');
94			expect(error.value.errors[0][0]).toEqual('type?');
95			expect(error.value.values.message).toEqual('Invalid error');
96			expect(error.value.values.name).toEqual('AppError');
97			expect(error.value.values.status).toEqual(500);
98			expect(error.value.values.type).toEqual(Error);
99			expect(error.value.values.value).toEqual('test');
100			expect(error.status).toEqual(500);
101			expect(error.type).toEqual(Error);
102			expect(error.date.constructor).toEqual(Date);
103			expect(error.stack.includes('AppError: Invalid error')).toEqual(true);
104			expect(error.me).toEqual(AppError);
105			});
106
107			it('It should catch the error from the stack', () => {
108			const DoTwo = () => {
109			throw new AppError({
110			value: 'test',
111			type: String,
112			message: 'Example from two',
113			me: AppError,
114			});
115			};
116
117			const DoOne = () => {
118			try {
119			DoTwo();
120			} catch (error) {
121			throw new AppError({
122			value: 'test',
123			type: String,
124			message: 'Example from one',
125			me: AppError,
126			});
127			}
128			};
129
130			expect(() => {
131			DoOne();
132			}).toThrowError('Example from one');
133
134			try {
135			DoOne();
136			} catch (error) {
137			expect(error instanceof AppError).toEqual(true);
138			expect(error instanceof Error).toEqual(true);
139			expect(error.name).toEqual('AppError');
140			expect(error.message).toEqual('Example from one');
141			expect(error.value).toEqual('test');
142			expect(error.status).toEqual(500);
143			expect(error.type).toEqual(String);
144			expect(error.date.constructor).toEqual(Date);
145			expect(error.stack.includes('AppError: Example from one')).toEqual(
146			true
147			);
148			expect(error.me).toEqual(AppError);
149			}
150			});
151
152			it('It should catch the error from the sub stack', () => {
153			const DoFour = () => {
154			throw new AppError({
155			value: 'test',
156			type: String,
157			message: 'Example from four',
158			me: AppError,
159			});
160			};
161
162			const DoThree = () => {
163			DoFour();
164			};
165
166			expect(() => {
167			DoThree();
168			}).toThrowError('Example from four');
169
170			try {
171			DoThree();
172			} catch (error) {
173			expect(error instanceof AppError).toEqual(true);
174			expect(error instanceof Error).toEqual(true);
175			expect(error.name).toEqual('AppError');
176			expect(error.message).toEqual('Example from four');
177			expect(error.value).toEqual('test');
178			expect(error.status).toEqual(500);
179			expect(error.type).toEqual(String);
180			expect(error.date.constructor).toEqual(Date);
181			expect(error.stack.includes('AppError: Example from four')).toEqual(
182			true
183			);
184			expect(error.me).toEqual(AppError);
185			}
186			});
187			});
188

hckrnews / error

src/__tests__/app-error.unit.js A last analyzed 2024-04-19 10:26 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

src/tests/app-error.unit.js A
last analyzed 2024-04-19 10:26 UTC