mirror of
https://github.com/directus/directus.git
synced 2026-01-28 02:28:03 -05:00
83b6027cc3
* Run blackbox tests in parallel * Add slight delay for updates in timezone tests * Revert trigger on PR
307 lines
9.0 KiB
TypeScript
307 lines
9.0 KiB
TypeScript
import { getUrl } from '@common/config';
|
|
import vendors from '@common/get-dbs-to-test';
|
|
import request from 'supertest';
|
|
import { cloneDeep } from 'lodash';
|
|
import { validateDateDifference } from '@utils/validate-date-difference';
|
|
import { CreateCollection, CreateField, DeleteCollection } from '@common/functions';
|
|
import * as common from '@common/index';
|
|
import { sleep } from '@utils/sleep';
|
|
|
|
const collectionName = 'schema_timezone_tests';
|
|
|
|
type SchemaTimezoneTypesObject = {
|
|
date: string;
|
|
time?: string;
|
|
datetime: string;
|
|
timestamp: string;
|
|
};
|
|
|
|
type SchemaTimezoneTypesResponse = SchemaTimezoneTypesObject & {
|
|
date_created: string;
|
|
date_updated: string;
|
|
};
|
|
|
|
describe('schema', () => {
|
|
const sampleDates: SchemaTimezoneTypesObject[] = [];
|
|
|
|
for (let i = 0; i < 24; i++) {
|
|
const hour = i < 10 ? '0' + i : String(i);
|
|
sampleDates.push(
|
|
{
|
|
date: `2022-01-05`,
|
|
time: `${hour}:11:11`,
|
|
datetime: `2022-01-05T${hour}:11:11`,
|
|
timestamp: `2022-01-05T${hour}:11:11-01:00`,
|
|
},
|
|
{
|
|
date: `2022-01-10`,
|
|
time: `${hour}:22:22`,
|
|
datetime: `2022-01-10T${hour}:22:22`,
|
|
timestamp: `2022-01-10T${hour}:22:22Z`,
|
|
},
|
|
{
|
|
date: `2022-01-15`,
|
|
time: `${hour}:33:33`,
|
|
datetime: `2022-01-15T${hour}:33:33`,
|
|
timestamp: `2022-01-15T${hour}:33:33+02:00`,
|
|
}
|
|
);
|
|
}
|
|
|
|
describe('timezone', () => {
|
|
describe('update timezone field schema', () => {
|
|
common.DisableTestCachingSetup();
|
|
|
|
it.each(vendors)(
|
|
'%s',
|
|
async (vendor) => {
|
|
// Delete the table in case it already exists
|
|
await DeleteCollection(vendor, { collection: collectionName });
|
|
|
|
const tableOptions = {
|
|
collection: collectionName,
|
|
schema: {},
|
|
meta: {},
|
|
};
|
|
await CreateCollection(vendor, tableOptions);
|
|
|
|
const fieldOptions = {
|
|
collection: collectionName,
|
|
field: 'date',
|
|
meta: {},
|
|
schema: {},
|
|
type: 'date',
|
|
};
|
|
await CreateField(vendor, fieldOptions);
|
|
|
|
fieldOptions.field = 'time';
|
|
fieldOptions.type = 'time';
|
|
await CreateField(vendor, fieldOptions);
|
|
|
|
fieldOptions.field = 'datetime';
|
|
fieldOptions.type = 'dateTime';
|
|
await CreateField(vendor, fieldOptions);
|
|
|
|
fieldOptions.field = 'timestamp';
|
|
fieldOptions.type = 'timestamp';
|
|
await CreateField(vendor, fieldOptions);
|
|
|
|
fieldOptions.field = 'date_created';
|
|
fieldOptions.type = 'timestamp';
|
|
await CreateField(vendor, fieldOptions);
|
|
|
|
fieldOptions.field = 'date_updated';
|
|
fieldOptions.type = 'timestamp';
|
|
await CreateField(vendor, fieldOptions);
|
|
|
|
await request(getUrl(vendor))
|
|
.patch(`/collections/${collectionName}`)
|
|
.send({
|
|
meta: {},
|
|
})
|
|
.set('Authorization', `Bearer ${common.USER.ADMIN.TOKEN}`)
|
|
.expect('Content-Type', /application\/json/)
|
|
.expect(200);
|
|
|
|
await request(getUrl(vendor))
|
|
.patch(`/fields/${collectionName}/date_created`)
|
|
.send({
|
|
meta: {
|
|
special: ['date-created'],
|
|
},
|
|
})
|
|
.set('Authorization', `Bearer ${common.USER.ADMIN.TOKEN}`)
|
|
.expect('Content-Type', /application\/json/)
|
|
.expect(200);
|
|
|
|
await request(getUrl(vendor))
|
|
.patch(`/fields/${collectionName}/date_updated`)
|
|
.send({
|
|
meta: {
|
|
special: ['date-updated'],
|
|
},
|
|
})
|
|
.set('Authorization', `Bearer ${common.USER.ADMIN.TOKEN}`)
|
|
.expect('Content-Type', /application\/json/)
|
|
.expect(200);
|
|
|
|
switch (vendor) {
|
|
case 'sqlite3':
|
|
await request(getUrl(vendor))
|
|
.patch(`/fields/${collectionName}/timestamp`)
|
|
.send({
|
|
meta: {
|
|
special: ['cast-timestamp'],
|
|
},
|
|
})
|
|
.set('Authorization', `Bearer ${common.USER.ADMIN.TOKEN}`)
|
|
.expect('Content-Type', /application\/json/)
|
|
.expect(200);
|
|
await request(getUrl(vendor))
|
|
.patch(`/fields/${collectionName}/date_created`)
|
|
.send({
|
|
meta: {
|
|
special: ['date-created', 'cast-timestamp'],
|
|
},
|
|
})
|
|
.set('Authorization', `Bearer ${common.USER.ADMIN.TOKEN}`)
|
|
.expect('Content-Type', /application\/json/)
|
|
.expect(200);
|
|
|
|
await request(getUrl(vendor))
|
|
.patch(`/fields/${collectionName}/date_updated`)
|
|
.send({
|
|
meta: {
|
|
special: ['date-updated', 'cast-timestamp'],
|
|
},
|
|
})
|
|
.set('Authorization', `Bearer ${common.USER.ADMIN.TOKEN}`)
|
|
.expect('Content-Type', /application\/json/)
|
|
.expect(200);
|
|
break;
|
|
case 'oracle':
|
|
await request(getUrl(vendor))
|
|
.patch(`/fields/${collectionName}/datetime`)
|
|
.send({
|
|
meta: {
|
|
special: ['cast-datetime'],
|
|
},
|
|
})
|
|
.set('Authorization', `Bearer ${common.USER.ADMIN.TOKEN}`)
|
|
.expect('Content-Type', /application\/json/)
|
|
.expect(200);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
},
|
|
300000
|
|
);
|
|
});
|
|
|
|
common.ClearCaches();
|
|
|
|
describe('stores the correct timezone data', () => {
|
|
it.each(vendors)(
|
|
'%s',
|
|
async (vendor) => {
|
|
const dates = cloneDeep(sampleDates);
|
|
|
|
if (vendor === 'oracle') {
|
|
for (const date of dates) {
|
|
delete date.time;
|
|
}
|
|
}
|
|
|
|
const insertionStartTimestamp = new Date();
|
|
|
|
await request(getUrl(vendor))
|
|
.post(`/items/${collectionName}`)
|
|
.send(dates)
|
|
.set('Authorization', `Bearer ${common.USER.ADMIN.TOKEN}`)
|
|
.expect('Content-Type', /application\/json/)
|
|
.expect(200);
|
|
|
|
const insertionEndTimestamp = new Date();
|
|
|
|
const response = await request(getUrl(vendor))
|
|
.get(`/items/${collectionName}?fields=*`)
|
|
.set('Authorization', `Bearer ${common.USER.ADMIN.TOKEN}`)
|
|
.expect('Content-Type', /application\/json/)
|
|
.expect(200);
|
|
|
|
expect(response.body.data.length).toBe(sampleDates.length);
|
|
|
|
for (let index = 0; index < sampleDates.length; index++) {
|
|
const responseObj = response.body.data[index] as SchemaTimezoneTypesResponse;
|
|
|
|
if (vendor === 'oracle') {
|
|
expect(responseObj.date).toBe(sampleDates[index]!.date);
|
|
expect(responseObj.datetime).toBe(sampleDates[index]!.datetime);
|
|
expect(responseObj.timestamp.substring(0, 19)).toBe(
|
|
new Date(sampleDates[index]!.timestamp).toISOString().substring(0, 19)
|
|
);
|
|
const dateCreated = new Date(responseObj.date_created);
|
|
expect(dateCreated.toISOString()).toBe(
|
|
validateDateDifference(
|
|
insertionStartTimestamp,
|
|
dateCreated,
|
|
insertionEndTimestamp.getTime() - insertionStartTimestamp.getTime()
|
|
).toISOString()
|
|
);
|
|
expect(responseObj.date_updated).toBeNull();
|
|
continue;
|
|
}
|
|
|
|
expect(responseObj.date).toBe(sampleDates[index]!.date);
|
|
expect(responseObj.time).toBe(sampleDates[index]!.time);
|
|
expect(responseObj.datetime).toBe(sampleDates[index]!.datetime);
|
|
expect(responseObj.timestamp.substring(0, 19)).toBe(
|
|
new Date(sampleDates[index]!.timestamp).toISOString().substring(0, 19)
|
|
);
|
|
const dateCreated = new Date(responseObj.date_created);
|
|
expect(dateCreated.toISOString()).toBe(
|
|
validateDateDifference(
|
|
insertionStartTimestamp,
|
|
dateCreated,
|
|
insertionEndTimestamp.getTime() - insertionStartTimestamp.getTime() + 1000
|
|
).toISOString()
|
|
);
|
|
expect(responseObj.date_updated).toBeNull();
|
|
}
|
|
},
|
|
10000
|
|
);
|
|
});
|
|
|
|
describe('stores the correct timezone data when updated', () => {
|
|
it.each(vendors)('%s', async (vendor) => {
|
|
await sleep(1000);
|
|
|
|
const payload = {
|
|
date: sampleDates[0]!.date,
|
|
};
|
|
|
|
const existingDataResponse = await request(getUrl(vendor))
|
|
.get(`/items/${collectionName}?fields=*&limit=1`)
|
|
.set('Authorization', `Bearer ${common.USER.ADMIN.TOKEN}`)
|
|
.expect('Content-Type', /application\/json/)
|
|
.expect(200);
|
|
|
|
const updateStartTimestamp = new Date();
|
|
|
|
await request(getUrl(vendor))
|
|
.patch(`/items/${collectionName}/${existingDataResponse.body.data[0].id}`)
|
|
.send(payload)
|
|
.set('Authorization', `Bearer ${common.USER.ADMIN.TOKEN}`)
|
|
.expect('Content-Type', /application\/json/)
|
|
.expect(200);
|
|
|
|
const updateEndTimestamp = new Date();
|
|
|
|
const response = await request(getUrl(vendor))
|
|
.get(`/items/${collectionName}/${existingDataResponse.body.data[0].id}?fields=*`)
|
|
.set('Authorization', `Bearer ${common.USER.ADMIN.TOKEN}`)
|
|
.expect('Content-Type', /application\/json/)
|
|
.expect(200);
|
|
|
|
const responseObj = response.body.data as SchemaTimezoneTypesResponse;
|
|
|
|
expect(responseObj.date).toBe(sampleDates[0]!.date);
|
|
expect(responseObj.date_created).not.toBeNull();
|
|
expect(responseObj.date_updated).not.toBeNull();
|
|
const dateCreated = new Date(responseObj.date_created);
|
|
const dateUpdated = new Date(responseObj.date_updated);
|
|
expect(dateUpdated.toISOString()).not.toBe(dateCreated.toISOString());
|
|
expect(dateUpdated.toISOString()).toBe(
|
|
validateDateDifference(
|
|
updateStartTimestamp,
|
|
dateUpdated,
|
|
updateEndTimestamp.getTime() - updateStartTimestamp.getTime() + 1000
|
|
).toISOString()
|
|
);
|
|
});
|
|
});
|
|
});
|
|
});
|