agerix/iconify
2
0
Fork 0
mirror of https://github.com/iconify/iconify.git synced 2025-01-06 07:20:40 +00:00
Code Issues Releases Activity

Replace jest done function with promises in utils tests

Browse Source
This commit is contained in:
Vjacheslav Trushkin 2022-09-07 20:00:33 +03:00
parent 33b3e42834
commit 2dc12bd462
3 changed files with 679 additions and 608 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

377
packages/utils/tests/validate-alias-test.ts
View File

@ -46,26 +46,10 @@ describe('Testing validating alias', () => {
});
});
test('Null', (done) => {
try {
validateIconSet({
prefix: 'foo',
icons: {
bar: {
body: '<g />',
},
},
aliases: null,
});
done('Expected to throw error when aliases is null');
} catch (err) {
//
}
// Fix it
expect(
validateIconSet(
{
test('Null', () => {
return new Promise((fulfill, reject) => {
try {
validateIconSet({
prefix: 'foo',
icons: {
bar: {
@ -73,48 +57,44 @@ describe('Testing validating alias', () => {
},
},
aliases: null,
},
{ fix: true }
)
).toEqual({
prefix: 'foo',
icons: {
bar: {
body: '<g />',
},
},
});
});
reject('Expected to throw error when aliases is null');
return;
} catch {
//
}
done();
});
test('Invalid parent', (done) => {
try {
const result = validateIconSet({
// Fix it
expect(
validateIconSet(
{
prefix: 'foo',
icons: {
bar: {
body: '<g />',
},
},
aliases: null,
},
{ fix: true }
)
).toEqual({
prefix: 'foo',
icons: {
bar: {
body: '<g />',
},
},
aliases: {
baz: {
parent: 'missing',
},
},
});
done(
'Expected to throw error when alias has missing parent, got ' +
JSON.stringify(result)
);
} catch (err) {
//
}
// Fix it
expect(
validateIconSet(
{
fulfill(true);
});
});
test('Invalid parent', () => {
return new Promise((fulfill, reject) => {
try {
const result = validateIconSet({
prefix: 'foo',
icons: {
bar: {
@ -126,51 +106,51 @@ describe('Testing validating alias', () => {
parent: 'missing',
},
},
},
{ fix: true }
)
).toEqual({
prefix: 'foo',
icons: {
bar: {
body: '<g />',
},
},
});
});
reject(
'Expected to throw error when alias has missing parent, got ' +
JSON.stringify(result)
);
return;
} catch {
//
}
done();
});
test('Invalid parent, 2 levels', (done) => {
try {
const result = validateIconSet({
// Fix it
expect(
validateIconSet(
{
prefix: 'foo',
icons: {
bar: {
body: '<g />',
},
},
aliases: {
baz: {
parent: 'missing',
},
},
},
{ fix: true }
)
).toEqual({
prefix: 'foo',
icons: {
bar: {
body: '<g />',
},
},
aliases: {
baz: {
parent: 'missing',
},
baz2: {
parent: 'baz',
},
},
});
done(
'Expected to throw error when alias has missing parent, got ' +
JSON.stringify(result)
);
} catch (err) {
//
}
// Fix it
expect(
validateIconSet(
{
fulfill(true);
});
});
test('Invalid parent, 2 levels', () => {
return new Promise((fulfill, reject) => {
try {
const result = validateIconSet({
prefix: 'foo',
icons: {
bar: {
@ -185,51 +165,54 @@ describe('Testing validating alias', () => {
parent: 'baz',
},
},
},
{ fix: true }
)
).toEqual({
prefix: 'foo',
icons: {
bar: {
body: '<g />',
},
},
});
});
reject(
'Expected to throw error when alias has missing parent, got ' +
JSON.stringify(result)
);
return;
} catch {
//
}
done();
});
test('Invalid parent, 2 levels, reverse order', (done) => {
try {
const result = validateIconSet({
// Fix it
expect(
validateIconSet(
{
prefix: 'foo',
icons: {
bar: {
body: '<g />',
},
},
aliases: {
baz: {
parent: 'missing',
},
baz2: {
parent: 'baz',
},
},
},
{ fix: true }
)
).toEqual({
prefix: 'foo',
icons: {
bar: {
body: '<g />',
},
},
aliases: {
baz: {
parent: 'baz2',
},
baz2: {
parent: 'missing',
},
},
});
done(
'Expected to throw error when alias has missing parent, got ' +
JSON.stringify(result)
);
} catch (err) {
//
}
// Fix it
expect(
validateIconSet(
{
fulfill(true);
});
});
test('Invalid parent, 2 levels, reverse order', () => {
return new Promise((fulfill, reject) => {
try {
const result = validateIconSet({
prefix: 'foo',
icons: {
bar: {
@ -244,54 +227,54 @@ describe('Testing validating alias', () => {
parent: 'missing',
},
},
},
{ fix: true }
)
).toEqual({
prefix: 'foo',
icons: {
bar: {
body: '<g />',
},
},
});
});
reject(
'Expected to throw error when alias has missing parent, got ' +
JSON.stringify(result)
);
return;
} catch {
//
}
done();
});
test('Parent loop', (done) => {
try {
const result = validateIconSet({
// Fix it
expect(
validateIconSet(
{
prefix: 'foo',
icons: {
bar: {
body: '<g />',
},
},
aliases: {
baz: {
parent: 'baz2',
},
baz2: {
parent: 'missing',
},
},
},
{ fix: true }
)
).toEqual({
prefix: 'foo',
icons: {
bar: {
body: '<g />',
},
},
aliases: {
baz: {
parent: 'baz2',
},
baz2: {
parent: 'baz',
},
baz3: {
parent: 'bar',
},
},
});
done(
'Expected to throw error when alias has missing parent, got ' +
JSON.stringify(result)
);
} catch (err) {
//
}
// Fix it
expect(
validateIconSet(
{
fulfill(true);
});
});
test('Parent loop', () => {
return new Promise((fulfill, reject) => {
try {
const result = validateIconSet({
prefix: 'foo',
icons: {
bar: {
@ -309,23 +292,55 @@ describe('Testing validating alias', () => {
parent: 'bar',
},
},
},
{ fix: true }
)
).toEqual({
prefix: 'foo',
icons: {
bar: {
body: '<g />',
},
},
aliases: {
baz3: {
parent: 'bar',
},
},
});
});
reject(
'Expected to throw error when alias has missing parent, got ' +
JSON.stringify(result)
);
return;
} catch {
//
}
done();
// Fix it
expect(
validateIconSet(
{
prefix: 'foo',
icons: {
bar: {
body: '<g />',
},
},
aliases: {
baz: {
parent: 'baz2',
},
baz2: {
parent: 'baz',
},
baz3: {
parent: 'bar',
},
},
},
{ fix: true }
)
).toEqual({
prefix: 'foo',
icons: {
bar: {
body: '<g />',
},
},
aliases: {
baz3: {
parent: 'bar',
},
},
});
fulfill(true);
});
});
});

504
packages/utils/tests/validate-icon-test.ts
View File

@ -54,45 +54,25 @@ describe('Testing validating icon', () => {
});
// Required string
test('body', (done) => {
// Missing body
try {
validateIconSet({
prefix: 'foo',
icons: {
bar: {
width: 16,
},
},
});
done('Expected to throw error when body is missing');
} catch (err) {
//
}
try {
validateIconSet(
{
test('body', () => {
return new Promise((fulfill, reject) => {
// Missing body
try {
validateIconSet({
prefix: 'foo',
icons: {
bar: {
width: 16,
},
},
},
{
fix: true,
}
);
done(
'Expected to throw error when body is missing and cannot be fixed'
);
} catch (err) {
//
}
});
reject('Expected to throw error when body is missing');
return;
} catch {
//
}
try {
expect(
try {
validateIconSet(
{
prefix: 'foo',
@ -100,140 +80,86 @@ describe('Testing validating icon', () => {
bar: {
width: 16,
},
baz: {
body: '<g />',
},
},
},
{
fix: true,
}
)
).toEqual({
prefix: 'foo',
icons: {
baz: {
body: '<g />',
},
},
});
} catch (err) {
done(
'Expected to not throw error when body is missing, but icon set can be fixed'
);
//
}
);
reject(
'Expected to throw error when body is missing and cannot be fixed'
);
return;
} catch {
//
}
validationValues.forEach((item, value) => {
// Validate without fixing
try {
validateIconSet({
expect(
validateIconSet(
{
prefix: 'foo',
icons: {
bar: {
width: 16,
},
baz: {
body: '<g />',
},
},
},
{
fix: true,
}
)
).toEqual({
prefix: 'foo',
icons: {
bar: {
body: value,
baz: {
body: '<g />',
},
},
});
if (item.type !== 'string') {
done(`Expected to throw error when body is ${item.text}`);
}
} catch (err) {
if (item.type === 'string') {
done(`Expected to pass when body is ${item.text}`);
}
}
// Attempt to fix (will fail because icon set is empty after failing icon is removed)
try {
validateIconSet(
{
prefix: 'foo',
icons: {
bar: {
body: value,
},
},
},
{
fix: true,
}
} catch {
reject(
'Expected to not throw error when body is missing, but icon set can be fixed'
);
if (item.type !== 'string') {
done(`Expected to throw error when body is ${item.text}`);
}
} catch (err) {
if (item.type === 'string') {
done(`Expected to pass when body is ${item.text}`);
}
return;
}
// Attempt to fix (will not fail because another icon is valid)
try {
validateIconSet(
{
prefix: 'foo',
icons: {
bar: {
body: value,
},
baz: {
body: '<g />',
},
},
},
{
fix: true,
}
);
} catch (err) {
done('Expected to pass when another icon is valid');
}
});
done();
});
// Numbers
['width', 'height', 'left', 'top', 'rotate'].forEach((prop) => {
test(prop, (done) => {
// Validate without fixing
validationValues.forEach((item, value) => {
// Validate without fixing
try {
validateIconSet({
prefix: 'foo',
icons: {
bar: {
body: '<g />',
[prop]: value,
body: value,
},
},
});
if (item.type !== 'number') {
done(
`Expected to throw error when ${prop} is ${item.text}`
if (item.type !== 'string') {
reject(
`Expected to throw error when body is ${item.text}`
);
return;
}
} catch (err) {
if (item.type === 'number') {
done(`Expected to pass when ${prop} is ${item.text}`);
} catch {
if (item.type === 'string') {
reject(`Expected to pass when body is ${item.text}`);
return;
}
}
});
// Fix
validationValues.forEach((item, value) => {
// Attempt to fix (will fail because icon set is empty after failing icon is removed)
try {
const result = validateIconSet(
validateIconSet(
{
prefix: 'foo',
icons: {
bar: {
body: '<g />',
[prop]: value,
body: value,
},
},
},
@ -242,37 +168,212 @@ describe('Testing validating icon', () => {
}
);
const icon =
item.type === 'number'
? {
body: '<g />',
[prop]: value,
}
: {
// [prop] should be deleted
body: '<g />',
};
if (item.type !== 'string') {
reject(
`Expected to throw error when body is ${item.text}`
);
return;
}
} catch {
if (item.type === 'string') {
reject(`Expected to pass when body is ${item.text}`);
return;
}
}
expect(result).toEqual({
prefix: 'foo',
icons: {
bar: icon,
// Attempt to fix (will not fail because another icon is valid)
try {
validateIconSet(
{
prefix: 'foo',
icons: {
bar: {
body: value,
},
baz: {
body: '<g />',
},
},
},
});
} catch (err) {
done(
`Expected to not throw error when ${prop} is being fixed`
{
fix: true,
}
);
} catch {
reject('Expected to pass when another icon is valid');
return;
}
});
done();
fulfill(true);
});
});
// Numbers
['width', 'height', 'left', 'top', 'rotate'].forEach((prop) => {
test(prop, () => {
return new Promise((fulfill, reject) => {
// Validate without fixing
validationValues.forEach((item, value) => {
try {
validateIconSet({
prefix: 'foo',
icons: {
bar: {
body: '<g />',
[prop]: value,
},
},
});
if (item.type !== 'number') {
reject(
`Expected to throw error when ${prop} is ${item.text}`
);
return;
}
} catch {
if (item.type === 'number') {
reject(
`Expected to pass when ${prop} is ${item.text}`
);
return;
}
}
});
// Fix
validationValues.forEach((item, value) => {
try {
const result = validateIconSet(
{
prefix: 'foo',
icons: {
bar: {
body: '<g />',
[prop]: value,
},
},
},
{
fix: true,
}
);
const icon =
item.type === 'number'
? {
body: '<g />',
[prop]: value,
}
: {
// [prop] should be deleted
body: '<g />',
};
expect(result).toEqual({
prefix: 'foo',
icons: {
bar: icon,
},
});
} catch {
reject(
`Expected to not throw error when ${prop} is being fixed`
);
return;
}
});
fulfill(true);
});
});
});
// Boolean
['hFlip', 'vFlip', 'hidden'].forEach((prop) => {
test(prop, (done) => {
test(prop, () => {
return new Promise((fulfill, reject) => {
validationValues.forEach((item, value) => {
// Validate
try {
validateIconSet({
prefix: 'foo',
icons: {
bar: {
body: '<g />',
[prop]: value,
},
},
});
if (item.type !== 'boolean') {
reject(
`Expected to throw error when ${prop} is ${item.text}`
);
return;
}
} catch {
if (item.type === 'boolean') {
reject(
`Expected to pass when ${prop} is ${item.text}`
);
return;
}
}
});
// Fix
validationValues.forEach((item, value) => {
try {
const result = validateIconSet(
{
prefix: 'foo',
icons: {
bar: {
body: '<g />',
[prop]: value,
},
},
},
{
fix: true,
}
);
const icon =
item.type === 'boolean'
? {
body: '<g />',
[prop]: value,
}
: {
// [prop] should be deleted
body: '<g />',
};
expect(result).toEqual({
prefix: 'foo',
icons: {
bar: icon,
},
});
} catch {
reject(
`Expected to not throw error when ${prop} is being fixed`
);
return;
}
});
fulfill(true);
});
});
});
// Unexpected field
test('foo', () => {
return new Promise((fulfill, reject) => {
validationValues.forEach((item, value) => {
// Validate
try {
@ -281,19 +382,21 @@ describe('Testing validating icon', () => {
icons: {
bar: {
body: '<g />',
[prop]: value,
foo: value,
},
},
});
if (item.type !== 'boolean') {
done(
`Expected to throw error when ${prop} is ${item.text}`
if (item.type === 'object') {
reject(
`Expected to throw error when value is ${item.text}`
);
return;
}
} catch (err) {
if (item.type === 'boolean') {
done(`Expected to pass when ${prop} is ${item.text}`);
} catch {
if (item.type !== 'object') {
reject(`Expected to pass when value is ${item.text}`);
return;
}
}
});
@ -307,7 +410,7 @@ describe('Testing validating icon', () => {
icons: {
bar: {
body: '<g />',
[prop]: value,
foo: value,
},
},
},
@ -317,13 +420,13 @@ describe('Testing validating icon', () => {
);
const icon =
item.type === 'boolean'
item.type !== 'object'
? {
body: '<g />',
[prop]: value,
foo: value,
}
: {
// [prop] should be deleted
// should be deleted
body: '<g />',
};
@ -333,82 +436,15 @@ describe('Testing validating icon', () => {
bar: icon,
},
});
} catch (err) {
done(
`Expected to not throw error when ${prop} is being fixed`
} catch {
reject(
`Expected to not throw error when value is being fixed`
);
return;
}
});
done();
fulfill(true);
});
});
// Unexpected field
test('foo', (done) => {
validationValues.forEach((item, value) => {
// Validate
try {
validateIconSet({
prefix: 'foo',
icons: {
bar: {
body: '<g />',
foo: value,
},
},
});
if (item.type === 'object') {
done(`Expected to throw error when value is ${item.text}`);
}
} catch (err) {
if (item.type !== 'object') {
done(`Expected to pass when value is ${item.text}`);
}
}
});
// Fix
validationValues.forEach((item, value) => {
try {
const result = validateIconSet(
{
prefix: 'foo',
icons: {
bar: {
body: '<g />',
foo: value,
},
},
},
{
fix: true,
}
);
const icon =
item.type !== 'object'
? {
body: '<g />',
foo: value,
}
: {
// should be deleted
body: '<g />',
};
expect(result).toEqual({
prefix: 'foo',
icons: {
bar: icon,
},
});
} catch (err) {
done(`Expected to not throw error when value is being fixed`);
}
});
done();
});
});

406
packages/utils/tests/validate-test.ts
View File

@ -1,36 +1,42 @@
import { validateIconSet } from '../lib/icon-set/validate';
describe('Testing validation', () => {
test('Not object', (done) => {
try {
validateIconSet(void 0);
done('Expected to throw error on undefined');
} catch (err) {
//
}
test('Not object', () => {
return new Promise((fulfill, reject) => {
try {
validateIconSet(void 0);
reject('Expected to throw error on undefined');
return;
} catch {
//
}
try {
validateIconSet({});
done('Expected to throw error on empty object');
} catch (err) {
//
}
try {
validateIconSet({});
reject('Expected to throw error on empty object');
return;
} catch {
//
}
try {
validateIconSet(null);
done('Expected to throw error on null');
} catch (err) {
//
}
try {
validateIconSet(null);
reject('Expected to throw error on null');
return;
} catch {
//
}
try {
validateIconSet([]);
done('Expected to throw error on array');
} catch (err) {
//
}
try {
validateIconSet([]);
reject('Expected to throw error on array');
return;
} catch {
//
}
done();
fulfill(true);
});
});
test('Valid set', () => {
@ -53,40 +59,64 @@ describe('Testing validation', () => {
});
});
test('Missing stuff', (done) => {
try {
validateIconSet({
prefix: 'foo',
});
done('Expected to throw error when icons are missing');
} catch (err) {
//
}
test('Missing stuff', () => {
return new Promise((fulfill, reject) => {
try {
validateIconSet({
prefix: 'foo',
});
reject('Expected to throw error when icons are missing');
return;
} catch {
//
}
try {
validateIconSet({
prefix: 'foo',
icons: {},
});
done('Expected to throw error when icons are empty');
} catch (err) {
//
}
try {
validateIconSet({
prefix: 'foo',
icons: {},
});
reject('Expected to throw error when icons are empty');
return;
} catch {
//
}
try {
validateIconSet([]);
done('Expected to throw error on array');
} catch (err) {
//
}
try {
validateIconSet([]);
reject('Expected to throw error on array');
return;
} catch {
//
}
done();
fulfill(true);
});
});
test('Characters', (done) => {
// Correct icon set
expect(
validateIconSet({
test('Characters', () => {
return new Promise((fulfill, reject) => {
// Correct icon set
expect(
validateIconSet({
prefix: 'foo',
icons: {
bar: {
body: '<g />',
},
},
aliases: {
baz: {
parent: 'bar',
hFlip: true,
},
},
chars: {
e00: 'bar',
e01: 'baz',
},
})
).toEqual({
prefix: 'foo',
icons: {
bar: {
@ -103,49 +133,11 @@ describe('Testing validation', () => {
e00: 'bar',
e01: 'baz',
},
})
).toEqual({
prefix: 'foo',
icons: {
bar: {
body: '<g />',
},
},
aliases: {
baz: {
parent: 'bar',
hFlip: true,
},
},
chars: {
e00: 'bar',
e01: 'baz',
},
});
// Missing icon
try {
validateIconSet({
prefix: 'foo',
icons: {
bar: {
body: '<g />',
},
},
chars: {
e01: 'baz',
},
});
done(
'Expected to throw error when character points to missing icon'
);
} catch (err) {
//
}
expect(
validateIconSet(
{
// Missing icon
try {
validateIconSet({
prefix: 'foo',
icons: {
bar: {
@ -155,39 +147,42 @@ describe('Testing validation', () => {
chars: {
e01: 'baz',
},
},
{ fix: true }
)
).toEqual({
prefix: 'foo',
icons: {
bar: {
body: '<g />',
},
},
});
});
reject(
'Expected to throw error when character points to missing icon'
);
return;
} catch {
//
}
// Bad character
try {
validateIconSet({
expect(
validateIconSet(
{
prefix: 'foo',
icons: {
bar: {
body: '<g />',
},
},
chars: {
e01: 'baz',
},
},
{ fix: true }
)
).toEqual({
prefix: 'foo',
icons: {
bar: {
body: '<g />',
},
},
chars: {
test: 'bar',
},
});
done('Expected to throw error when character is invalid');
} catch (err) {
//
}
expect(
validateIconSet(
{
// Bad character
try {
validateIconSet({
prefix: 'foo',
icons: {
bar: {
@ -195,93 +190,118 @@ describe('Testing validation', () => {
},
},
chars: {
// Valid character
'e000-f123': 'bar',
// Multiple invalid characters
'test': 'bar',
'E0': 'bar',
test: 'bar',
},
});
reject('Expected to throw error when character is invalid');
return;
} catch {
//
}
expect(
validateIconSet(
{
prefix: 'foo',
icons: {
bar: {
body: '<g />',
},
},
chars: {
// Valid character
'e000-f123': 'bar',
// Multiple invalid characters
'test': 'bar',
'E0': 'bar',
},
},
{ fix: true }
)
).toEqual({
prefix: 'foo',
icons: {
bar: {
body: '<g />',
},
},
{ fix: true }
)
).toEqual({
prefix: 'foo',
icons: {
bar: {
body: '<g />',
chars: {
'e000-f123': 'bar',
},
},
chars: {
'e000-f123': 'bar',
},
});
});
done();
fulfill(true);
});
});
test('Invalid default values', (done) => {
try {
validateIconSet(
{
prefix: 'foo',
icons: {
icon1: {
body: '<path d="icon1" />',
test('Invalid default values', () => {
return new Promise((fulfill, reject) => {
try {
validateIconSet(
{
prefix: 'foo',
icons: {
icon1: {
body: '<path d="icon1" />',
},
},
height: 24,
// Object
width: {
foo: 1,
},
},
height: 24,
// Object
width: {
foo: 1,
},
},
{ fix: true }
);
done('Expected to throw error for bad default properties');
} catch (err) {
//
}
{ fix: true }
);
reject('Expected to throw error for bad default properties');
return;
} catch {
//
}
try {
validateIconSet(
{
prefix: 'foo',
icons: {
icon1: {
body: '<path d="icon1" />',
try {
validateIconSet(
{
prefix: 'foo',
icons: {
icon1: {
body: '<path d="icon1" />',
},
},
height: 24,
// Object
left: null,
},
height: 24,
// Object
left: null,
},
{ fix: true }
);
done('Expected to throw error for bad default properties');
} catch (err) {
//
}
{ fix: true }
);
reject('Expected to throw error for bad default properties');
return;
} catch {
//
}
try {
validateIconSet(
{
prefix: 'foo',
icons: {
icon1: {
body: '<path d="icon1" />',
try {
validateIconSet(
{
prefix: 'foo',
icons: {
icon1: {
body: '<path d="icon1" />',
},
},
height: 24,
// String
width: '32',
},
height: 24,
// String
width: '32',
},
{ fix: true }
);
done('Expected to throw error for bad default properties');
} catch (err) {
//
}
{ fix: true }
);
reject('Expected to throw error for bad default properties');
return;
} catch {
//
}
done();
fulfill(true);
});
});
});