mirror of
https://github.com/directus/directus.git
synced 2026-01-27 07:08:17 -05:00
1514b0c204
* Enable schema caching for blackbox tests * Test if working for all vendors * Undo triggering of all vendors
726 lines
19 KiB
TypeScript
726 lines
19 KiB
TypeScript
import { getUrl } from '@common/config';
|
|
import request from 'supertest';
|
|
import vendors from '@common/get-dbs-to-test';
|
|
import * as common from '@common/index';
|
|
import { collectionName, collectionNameM2O, collectionNameO2M } from './common.seed';
|
|
|
|
describe('Common', () => {
|
|
common.DisableTestCachingSetup();
|
|
|
|
describe('createRole()', () => {
|
|
describe('Creates default admin role', () => {
|
|
it.each(vendors)('%s', async (vendor) => {
|
|
// Setup
|
|
const roleName = common.ROLE.ADMIN.NAME;
|
|
const options: common.OptionsCreateRole = {
|
|
name: roleName,
|
|
appAccessEnabled: true,
|
|
adminAccessEnabled: true,
|
|
};
|
|
|
|
// Action
|
|
await common.CreateRole(vendor, options);
|
|
|
|
// Assert
|
|
const response = await request(getUrl(vendor))
|
|
.get(`/roles`)
|
|
.query({
|
|
filter: { name: { _eq: roleName } },
|
|
fields: ['id', 'name', 'app_access', 'admin_access'],
|
|
limit: 1,
|
|
})
|
|
.set('Authorization', `Bearer ${common.USER.TESTS_FLOW.TOKEN}`)
|
|
.expect('Content-Type', /application\/json/)
|
|
.expect(200);
|
|
|
|
expect(response.body.data).toEqual([
|
|
{
|
|
id: expect.any(String),
|
|
name: roleName,
|
|
app_access: true,
|
|
admin_access: true,
|
|
},
|
|
]);
|
|
});
|
|
});
|
|
|
|
describe('Creates default app access role', () => {
|
|
it.each(vendors)('%s', async (vendor) => {
|
|
// Setup
|
|
const roleName = common.ROLE.APP_ACCESS.NAME;
|
|
const options: common.OptionsCreateRole = {
|
|
name: roleName,
|
|
appAccessEnabled: true,
|
|
adminAccessEnabled: false,
|
|
};
|
|
|
|
// Action
|
|
await common.CreateRole(vendor, options);
|
|
const response = await request(getUrl(vendor))
|
|
.get(`/roles`)
|
|
.query({
|
|
filter: { name: { _eq: roleName } },
|
|
fields: ['id', 'name', 'app_access', 'admin_access'],
|
|
limit: 1,
|
|
})
|
|
.set('Authorization', `Bearer ${common.USER.TESTS_FLOW.TOKEN}`)
|
|
.expect('Content-Type', /application\/json/)
|
|
.expect(200);
|
|
|
|
// Assert
|
|
expect(response.body.data).toEqual([
|
|
{
|
|
id: expect.any(String),
|
|
name: roleName,
|
|
app_access: true,
|
|
admin_access: false,
|
|
},
|
|
]);
|
|
});
|
|
});
|
|
|
|
describe('Creates default API only role', () => {
|
|
it.each(vendors)('%s', async (vendor) => {
|
|
// Setup
|
|
const roleName = common.ROLE.API_ONLY.NAME;
|
|
const options: common.OptionsCreateRole = {
|
|
name: roleName,
|
|
appAccessEnabled: false,
|
|
adminAccessEnabled: false,
|
|
};
|
|
|
|
// Action
|
|
await common.CreateRole(vendor, options);
|
|
const response = await request(getUrl(vendor))
|
|
.get(`/roles`)
|
|
.query({
|
|
filter: { name: { _eq: roleName } },
|
|
fields: ['id', 'name', 'app_access', 'admin_access'],
|
|
limit: 1,
|
|
})
|
|
.set('Authorization', `Bearer ${common.USER.TESTS_FLOW.TOKEN}`)
|
|
.expect('Content-Type', /application\/json/)
|
|
.expect(200);
|
|
|
|
// Assert
|
|
expect(response.body.data).toEqual([
|
|
{
|
|
id: expect.any(String),
|
|
name: roleName,
|
|
app_access: false,
|
|
admin_access: false,
|
|
},
|
|
]);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('createUser()', () => {
|
|
describe('Creates default admin user', () => {
|
|
it.each(vendors)('%s', async (vendor) => {
|
|
// Setup
|
|
const token = common.USER.ADMIN.TOKEN;
|
|
const email = common.USER.ADMIN.EMAIL;
|
|
const password = common.USER.ADMIN.PASSWORD;
|
|
const name = common.USER.ADMIN.NAME;
|
|
const roleName = common.ROLE.ADMIN.NAME;
|
|
const options: common.OptionsCreateUser = {
|
|
token,
|
|
email,
|
|
password,
|
|
name,
|
|
roleName,
|
|
};
|
|
|
|
// Action
|
|
await common.CreateUser(vendor, options);
|
|
const response = await request(getUrl(vendor))
|
|
.get(`/users`)
|
|
.query({
|
|
filter: { email: { _eq: email } },
|
|
fields: ['id', 'email', 'token', 'role'],
|
|
})
|
|
.set('Authorization', `Bearer ${common.USER.TESTS_FLOW.TOKEN}`)
|
|
.expect('Content-Type', /application\/json/)
|
|
.expect(200);
|
|
|
|
// Assert
|
|
expect(response.body.data).toEqual([
|
|
{
|
|
id: expect.any(String),
|
|
email: email,
|
|
token: expect.any(String),
|
|
role: expect.any(String),
|
|
},
|
|
]);
|
|
});
|
|
});
|
|
|
|
describe('Creates default app access user', () => {
|
|
it.each(vendors)('%s', async (vendor) => {
|
|
// Setup
|
|
const token = common.USER.APP_ACCESS.TOKEN;
|
|
const email = common.USER.APP_ACCESS.EMAIL;
|
|
const password = common.USER.APP_ACCESS.PASSWORD;
|
|
const name = common.USER.APP_ACCESS.NAME;
|
|
const roleName = common.ROLE.APP_ACCESS.NAME;
|
|
const options: common.OptionsCreateUser = {
|
|
token,
|
|
email,
|
|
password,
|
|
name,
|
|
roleName,
|
|
};
|
|
|
|
// Action
|
|
await common.CreateUser(vendor, options);
|
|
const response = await request(getUrl(vendor))
|
|
.get(`/users`)
|
|
.query({
|
|
filter: { email: { _eq: email } },
|
|
fields: ['id', 'email', 'token', 'role'],
|
|
})
|
|
.set('Authorization', `Bearer ${common.USER.TESTS_FLOW.TOKEN}`)
|
|
.expect('Content-Type', /application\/json/)
|
|
.expect(200);
|
|
|
|
// Assert
|
|
expect(response.body.data).toEqual([
|
|
{
|
|
id: expect.any(String),
|
|
email: email,
|
|
token: expect.any(String),
|
|
role: expect.any(String),
|
|
},
|
|
]);
|
|
});
|
|
});
|
|
|
|
describe('Creates default API only user', () => {
|
|
it.each(vendors)('%s', async (vendor) => {
|
|
// Setup
|
|
const token = common.USER.API_ONLY.TOKEN;
|
|
const email = common.USER.API_ONLY.EMAIL;
|
|
const password = common.USER.API_ONLY.PASSWORD;
|
|
const name = common.USER.API_ONLY.NAME;
|
|
const roleName = common.ROLE.API_ONLY.NAME;
|
|
const options: common.OptionsCreateUser = {
|
|
token,
|
|
email,
|
|
password,
|
|
name,
|
|
roleName,
|
|
};
|
|
|
|
// Action
|
|
await common.CreateUser(vendor, options);
|
|
const response = await request(getUrl(vendor))
|
|
.get(`/users`)
|
|
.query({
|
|
filter: { email: { _eq: email } },
|
|
fields: ['id', 'email', 'token', 'role'],
|
|
})
|
|
.set('Authorization', `Bearer ${common.USER.TESTS_FLOW.TOKEN}`)
|
|
.expect('Content-Type', /application\/json/)
|
|
.expect(200);
|
|
|
|
// Assert
|
|
expect(response.body.data).toEqual([
|
|
{
|
|
id: expect.any(String),
|
|
email: email,
|
|
token: expect.any(String),
|
|
role: expect.any(String),
|
|
},
|
|
]);
|
|
});
|
|
});
|
|
|
|
describe('Creates default no-role user', () => {
|
|
it.each(vendors)('%s', async (vendor) => {
|
|
// Setup
|
|
const token = common.USER.NO_ROLE.TOKEN;
|
|
const email = common.USER.NO_ROLE.EMAIL;
|
|
const password = common.USER.NO_ROLE.PASSWORD;
|
|
const name = common.USER.NO_ROLE.NAME;
|
|
const options: common.OptionsCreateUser = {
|
|
token,
|
|
email,
|
|
password,
|
|
name,
|
|
};
|
|
|
|
// Action
|
|
await common.CreateUser(vendor, options);
|
|
const response = await request(getUrl(vendor))
|
|
.get(`/users`)
|
|
.query({
|
|
filter: { email: { _eq: email } },
|
|
fields: ['id', 'email', 'token', 'role'],
|
|
})
|
|
.set('Authorization', `Bearer ${common.USER.TESTS_FLOW.TOKEN}`)
|
|
.expect('Content-Type', /application\/json/)
|
|
.expect(200);
|
|
|
|
// Assert
|
|
expect(response.body.data).toEqual([
|
|
{
|
|
id: expect.any(String),
|
|
email: email,
|
|
token: expect.any(String),
|
|
role: null,
|
|
},
|
|
]);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('createCollection()', () => {
|
|
describe('Creates a new collection', () => {
|
|
it.each(vendors)(
|
|
'%s',
|
|
async (vendor) => {
|
|
// Setup
|
|
const options: common.OptionsCreateCollection = {
|
|
collection: collectionName,
|
|
};
|
|
const options2: common.OptionsCreateCollection = {
|
|
collection: collectionNameM2O,
|
|
};
|
|
const options3: common.OptionsCreateCollection = {
|
|
collection: collectionNameO2M,
|
|
};
|
|
|
|
// Action
|
|
await common.CreateCollection(vendor, options);
|
|
const response = await request(getUrl(vendor))
|
|
.get(`/collections/${collectionName}`)
|
|
.set('Authorization', `Bearer ${common.USER.TESTS_FLOW.TOKEN}`)
|
|
.expect('Content-Type', /application\/json/)
|
|
.expect(200);
|
|
|
|
await common.CreateCollection(vendor, options2);
|
|
const response2 = await request(getUrl(vendor))
|
|
.get(`/collections/${collectionNameM2O}`)
|
|
.set('Authorization', `Bearer ${common.USER.TESTS_FLOW.TOKEN}`)
|
|
.expect('Content-Type', /application\/json/)
|
|
.expect(200);
|
|
|
|
await common.CreateCollection(vendor, options3);
|
|
const response3 = await request(getUrl(vendor))
|
|
.get(`/collections/${collectionNameO2M}`)
|
|
.set('Authorization', `Bearer ${common.USER.TESTS_FLOW.TOKEN}`)
|
|
.expect('Content-Type', /application\/json/)
|
|
.expect(200);
|
|
|
|
// Assert
|
|
expect(response.body.data).toEqual({
|
|
collection: collectionName,
|
|
meta: expect.objectContaining({
|
|
collection: collectionName,
|
|
}),
|
|
schema: expect.objectContaining({
|
|
name: collectionName,
|
|
}),
|
|
});
|
|
expect(response2.body.data).toEqual({
|
|
collection: collectionNameM2O,
|
|
meta: expect.objectContaining({
|
|
collection: collectionNameM2O,
|
|
}),
|
|
schema: expect.objectContaining({
|
|
name: collectionNameM2O,
|
|
}),
|
|
});
|
|
expect(response3.body.data).toEqual({
|
|
collection: collectionNameO2M,
|
|
meta: expect.objectContaining({
|
|
collection: collectionNameO2M,
|
|
}),
|
|
schema: expect.objectContaining({
|
|
name: collectionNameO2M,
|
|
}),
|
|
});
|
|
},
|
|
30000
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('createField()', () => {
|
|
describe('Creates a new field', () => {
|
|
it.each(vendors)(
|
|
'%s',
|
|
async (vendor) => {
|
|
// Setup
|
|
const fieldName = 'sample_field';
|
|
const fieldType = 'string';
|
|
const options: common.OptionsCreateField = {
|
|
collection: collectionName,
|
|
field: fieldName,
|
|
type: fieldType,
|
|
};
|
|
|
|
// Action
|
|
await common.CreateField(vendor, options);
|
|
const response = await request(getUrl(vendor))
|
|
.get(`/fields/${collectionName}/${fieldName}`)
|
|
.set('Authorization', `Bearer ${common.USER.TESTS_FLOW.TOKEN}`)
|
|
.expect('Content-Type', /application\/json/)
|
|
.expect(200);
|
|
|
|
// Assert
|
|
expect(response.body.data).toEqual({
|
|
collection: collectionName,
|
|
field: fieldName,
|
|
type: fieldType,
|
|
meta: expect.anything(),
|
|
schema: expect.anything(),
|
|
});
|
|
},
|
|
30000
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('createFieldM2O()', () => {
|
|
describe('Creates a new M2O field', () => {
|
|
it.each(vendors)(
|
|
'%s',
|
|
async (vendor) => {
|
|
// Setup
|
|
const fieldName = 'm2o_field';
|
|
const primaryKeyType = 'integer';
|
|
const collectionOptions: common.OptionsCreateCollection = {
|
|
collection: collectionNameM2O,
|
|
primaryKeyType,
|
|
};
|
|
await common.CreateCollection(vendor, collectionOptions);
|
|
|
|
const options: common.OptionsCreateFieldM2O = {
|
|
collection: collectionName,
|
|
field: fieldName,
|
|
otherCollection: collectionNameM2O,
|
|
primaryKeyType: primaryKeyType,
|
|
};
|
|
|
|
// Action
|
|
await common.CreateFieldM2O(vendor, options);
|
|
const response = await request(getUrl(vendor))
|
|
.get(`/fields/${collectionName}/${fieldName}`)
|
|
.set('Authorization', `Bearer ${common.USER.TESTS_FLOW.TOKEN}`)
|
|
.expect('Content-Type', /application\/json/)
|
|
.expect(200);
|
|
|
|
// Assert
|
|
expect(response.body.data).toEqual({
|
|
collection: collectionName,
|
|
field: fieldName,
|
|
type: primaryKeyType,
|
|
meta: expect.objectContaining({
|
|
special: expect.arrayContaining(['m2o']),
|
|
}),
|
|
schema: expect.anything(),
|
|
});
|
|
},
|
|
30000
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('createFieldO2M()', () => {
|
|
describe('Creates a new O2M field', () => {
|
|
it.each(vendors)(
|
|
'%s',
|
|
async (vendor) => {
|
|
// Setup
|
|
const fieldName = 'o2m_field';
|
|
const otherFieldName = 'm2o_field';
|
|
const primaryKeyType = 'integer';
|
|
const collectionOptions: common.OptionsCreateCollection = {
|
|
collection: collectionNameO2M,
|
|
primaryKeyType,
|
|
};
|
|
await common.CreateCollection(vendor, collectionOptions);
|
|
|
|
const options: common.OptionsCreateFieldO2M = {
|
|
collection: collectionName,
|
|
field: fieldName,
|
|
otherField: otherFieldName,
|
|
otherCollection: collectionNameO2M,
|
|
primaryKeyType: primaryKeyType,
|
|
};
|
|
|
|
// Action
|
|
await common.CreateFieldO2M(vendor, options);
|
|
const response = await request(getUrl(vendor))
|
|
.get(`/fields/${collectionName}/${fieldName}`)
|
|
.set('Authorization', `Bearer ${common.USER.TESTS_FLOW.TOKEN}`)
|
|
.expect('Content-Type', /application\/json/)
|
|
.expect(200);
|
|
|
|
// Assert
|
|
expect(response.body.data).toEqual({
|
|
collection: collectionName,
|
|
field: fieldName,
|
|
type: 'alias',
|
|
meta: expect.anything(),
|
|
schema: null,
|
|
});
|
|
},
|
|
30000
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('createItem()', () => {
|
|
describe('Creates a new item', () => {
|
|
it.each(vendors)(
|
|
'%s',
|
|
async (vendor) => {
|
|
// Setup
|
|
const options: common.OptionsCreateItem = {
|
|
collection: collectionName,
|
|
item: {
|
|
sample_field: 'sample_value',
|
|
},
|
|
};
|
|
|
|
// Action
|
|
const createdItem = await common.CreateItem(vendor, options);
|
|
const response = await request(getUrl(vendor))
|
|
.get(`/items/${collectionName}/${createdItem.id}`)
|
|
.set('Authorization', `Bearer ${common.USER.TESTS_FLOW.TOKEN}`)
|
|
.expect('Content-Type', /application\/json/)
|
|
.expect(200);
|
|
|
|
// Assert
|
|
expect(response.body.data).toEqual(
|
|
expect.objectContaining({
|
|
id: createdItem.id,
|
|
sample_field: 'sample_value',
|
|
})
|
|
);
|
|
},
|
|
30000
|
|
);
|
|
});
|
|
|
|
describe('Creates a new M2O item', () => {
|
|
it.each(vendors)(
|
|
'%s',
|
|
async (vendor) => {
|
|
// Setup
|
|
const options: common.OptionsCreateItem = {
|
|
collection: collectionName,
|
|
item: {
|
|
sample_field: 'sample_value',
|
|
m2o_field: {},
|
|
},
|
|
};
|
|
|
|
// Action
|
|
const createdItem = await common.CreateItem(vendor, options);
|
|
const response = await request(getUrl(vendor))
|
|
.get(`/items/${collectionName}/${createdItem.id}`)
|
|
.set('Authorization', `Bearer ${common.USER.TESTS_FLOW.TOKEN}`)
|
|
.expect('Content-Type', /application\/json/)
|
|
.expect(200);
|
|
|
|
// Assert
|
|
expect(response.body.data).toEqual(
|
|
expect.objectContaining({
|
|
id: createdItem.id,
|
|
sample_field: 'sample_value',
|
|
m2o_field: expect.any(Number),
|
|
})
|
|
);
|
|
},
|
|
30000
|
|
);
|
|
});
|
|
|
|
describe('Creates a new O2M item', () => {
|
|
it.each(vendors)(
|
|
'%s',
|
|
async (vendor) => {
|
|
// Setup
|
|
const options: common.OptionsCreateItem = {
|
|
collection: collectionName,
|
|
item: {
|
|
sample_field: 'sample_value',
|
|
o2m_field: {
|
|
create: [{}],
|
|
update: [],
|
|
delete: [],
|
|
},
|
|
},
|
|
};
|
|
|
|
// Action
|
|
const createdItem = await common.CreateItem(vendor, options);
|
|
const response = await request(getUrl(vendor))
|
|
.get(`/items/${collectionName}/${createdItem.id}`)
|
|
.set('Authorization', `Bearer ${common.USER.TESTS_FLOW.TOKEN}`)
|
|
.expect('Content-Type', /application\/json/)
|
|
.expect(200);
|
|
|
|
// Assert
|
|
expect(response.body.data).toEqual(
|
|
expect.objectContaining({
|
|
id: createdItem.id,
|
|
sample_field: 'sample_value',
|
|
o2m_field: [expect.any(Number)],
|
|
})
|
|
);
|
|
},
|
|
30000
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('deleteField()', () => {
|
|
describe('Deletes an O2M field', () => {
|
|
it.each(vendors)(
|
|
'%s',
|
|
async (vendor) => {
|
|
// Setup
|
|
const fieldName = 'o2m_field';
|
|
const options: common.OptionsDeleteField = {
|
|
collection: collectionName,
|
|
field: fieldName,
|
|
};
|
|
|
|
// Action
|
|
await common.DeleteField(vendor, options);
|
|
const response = await request(getUrl(vendor))
|
|
.get(`/fields/${collectionName}`)
|
|
.set('Authorization', `Bearer ${common.USER.TESTS_FLOW.TOKEN}`)
|
|
.expect('Content-Type', /application\/json/)
|
|
.expect(200);
|
|
|
|
// Assert
|
|
for (const child of response.body.data) {
|
|
expect(child.field).not.toEqual(fieldName);
|
|
}
|
|
},
|
|
30000
|
|
);
|
|
});
|
|
|
|
describe('Deletes other M2O field', () => {
|
|
it.each(vendors)(
|
|
'%s',
|
|
async (vendor) => {
|
|
// Setup
|
|
const fieldName = 'm2o_field';
|
|
const options: common.OptionsDeleteField = {
|
|
collection: collectionNameO2M,
|
|
field: fieldName,
|
|
};
|
|
|
|
// Action
|
|
await common.DeleteField(vendor, options);
|
|
const response = await request(getUrl(vendor))
|
|
.get(`/fields/${collectionNameO2M}`)
|
|
.set('Authorization', `Bearer ${common.USER.TESTS_FLOW.TOKEN}`)
|
|
.expect('Content-Type', /application\/json/)
|
|
.expect(200);
|
|
|
|
// Assert
|
|
for (const child of response.body.data) {
|
|
expect(child.field).not.toEqual(fieldName);
|
|
}
|
|
},
|
|
30000
|
|
);
|
|
});
|
|
|
|
describe('Deletes an M2O field', () => {
|
|
it.each(vendors)(
|
|
'%s',
|
|
async (vendor) => {
|
|
// Setup
|
|
const fieldName = 'm2o_field';
|
|
const options: common.OptionsDeleteField = {
|
|
collection: collectionName,
|
|
field: fieldName,
|
|
};
|
|
|
|
// Action
|
|
await common.DeleteField(vendor, options);
|
|
const response = await request(getUrl(vendor))
|
|
.get(`/fields/${collectionName}`)
|
|
.set('Authorization', `Bearer ${common.USER.TESTS_FLOW.TOKEN}`)
|
|
.expect('Content-Type', /application\/json/)
|
|
.expect(200);
|
|
|
|
// Assert
|
|
for (const child of response.body.data) {
|
|
expect(child.field).not.toEqual(fieldName);
|
|
}
|
|
},
|
|
30000
|
|
);
|
|
});
|
|
|
|
describe('Deletes a field', () => {
|
|
it.each(vendors)(
|
|
'%s',
|
|
async (vendor) => {
|
|
// Setup
|
|
const fieldName = 'sample_field';
|
|
const options: common.OptionsDeleteField = {
|
|
collection: collectionName,
|
|
field: fieldName,
|
|
};
|
|
|
|
// Action
|
|
await common.DeleteField(vendor, options);
|
|
const response = await request(getUrl(vendor))
|
|
.get(`/fields/${collectionName}`)
|
|
.set('Authorization', `Bearer ${common.USER.TESTS_FLOW.TOKEN}`)
|
|
.expect('Content-Type', /application\/json/)
|
|
.expect(200);
|
|
|
|
// Assert
|
|
for (const child of response.body.data) {
|
|
expect(child.field).not.toEqual(fieldName);
|
|
}
|
|
},
|
|
30000
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('deleteCollection()', () => {
|
|
describe('Deletes a collection', () => {
|
|
it.each(vendors)(
|
|
'%s',
|
|
async (vendor) => {
|
|
// Setup
|
|
const options: common.OptionsDeleteCollection = {
|
|
collection: collectionName,
|
|
};
|
|
|
|
// Action
|
|
await common.DeleteCollection(vendor, options);
|
|
const response = await request(getUrl(vendor))
|
|
.get(`/collections`)
|
|
.set('Authorization', `Bearer ${common.USER.TESTS_FLOW.TOKEN}`)
|
|
.expect('Content-Type', /application\/json/)
|
|
.expect(200);
|
|
|
|
// Assert
|
|
for (const child of response.body.data) {
|
|
expect(child.collection).not.toEqual(collectionName);
|
|
}
|
|
},
|
|
30000
|
|
);
|
|
});
|
|
});
|
|
|
|
common.ClearCaches();
|
|
});
|