@appsemble/cli 0.29.11 → 0.30.2

package/lib/resource.test.js

@@ -1,5 +1,6 @@
 import { resolveFixture } from '@appsemble/node-utils';
-import { createServer, createTestUser, models, setArgv, useTestDatabase } from '@appsemble/server';
+import { createServer, createTestUser, models, setArgv } from '@appsemble/server';
+import { PredefinedOrganizationRole } from '@appsemble/types';
 import { setTestApp } from 'axios-test-instance';
 import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
 import { initAxios } from './initAxios.js';
@@ -10,34 +11,102 @@ const argv = { host: 'http://localhost', secret: 'test', aesSecret: 'testSecret'
 let user;
 let organization;
 let testApp;
-useTestDatabase(import.meta);
-beforeAll(() => {
-    vi.useFakeTimers();
-    setArgv(argv);
-});
-beforeEach(async () => {
-    vi.clearAllTimers();
-    vi.setSystemTime(0);
-    const server = await createServer();
-    testApp = await setTestApp(server);
-    initAxios({ remote: testApp.defaults.baseURL });
-    user = await createTestUser();
-    organization = await Organization.create({
-        id: 'testorganization',
-        name: 'Test Organization',
+describe('resource', () => {
+    beforeAll(() => {
+        vi.useFakeTimers();
+        setArgv(argv);
     });
-    await OrganizationMember.create({
-        OrganizationId: organization.id,
-        UserId: user.id,
-        role: 'Owner',
+    beforeEach(async () => {
+        vi.clearAllTimers();
+        vi.setSystemTime(0);
+        const server = await createServer();
+        testApp = await setTestApp(server);
+        initAxios({ remote: testApp.defaults.baseURL });
+        user = await createTestUser();
+        organization = await Organization.create({
+            id: 'testorganization',
+            name: 'Test Organization',
+        });
+        await OrganizationMember.create({
+            OrganizationId: organization.id,
+            UserId: user.id,
+            role: PredefinedOrganizationRole.Owner,
+        });
+        await Organization.create({ id: 'appsemble', name: 'Appsemble' });
     });
-    await Organization.create({ id: 'appsemble', name: 'Appsemble' });
-});
-afterAll(() => {
-    vi.useRealTimers();
-});
-describe('publishResource', () => {
-    it('should publish resources from a file', async () => {
+    afterAll(() => {
+        vi.useRealTimers();
+    });
+    describe('publishResource', () => {
+        it('should publish resources from a file', async () => {
+            const resourceDefinition = {
+                roles: ['$public'],
+                schema: {
+                    type: 'object',
+                    additionalProperties: false,
+                    required: ['name'],
+                    properties: {
+                        name: {
+                            type: 'string',
+                        },
+                        email: {
+                            type: 'string',
+                            format: 'email',
+                        },
+                    },
+                },
+            };
+            const app = await App.create({
+                path: 'test-app',
+                definition: {
+                    resources: { test: resourceDefinition },
+                    name: 'Test App',
+                    defaultPage: 'Test Page',
+                },
+                vapidPublicKey: 'a',
+                vapidPrivateKey: 'b',
+                visibility: 'public',
+                OrganizationId: organization.id,
+            });
+            await authorizeCLI('resources:write', testApp);
+            await publishResource({
+                appId: app.id,
+                definition: resourceDefinition,
+                path: resolveFixture('resources/test.json'),
+                remote: testApp.defaults.baseURL,
+                type: 'test',
+                seed: false,
+            });
+            const resources = await Resource.findAll({
+                where: { AppId: app.id },
+            });
+            expect(resources.map((r) => r.toJSON())).toMatchInlineSnapshot(`
+        [
+          {
+            "$created": "1970-01-01T00:00:00.000Z",
+            "$updated": "1970-01-01T00:00:00.000Z",
+            "email": "test@example.com",
+            "id": 1,
+            "name": "John Doe",
+          },
+          {
+            "$created": "1970-01-01T00:00:00.000Z",
+            "$updated": "1970-01-01T00:00:00.000Z",
+            "email": "test2@example.com",
+            "id": 2,
+            "name": "Jane Doe",
+          },
+          {
+            "$created": "1970-01-01T00:00:00.000Z",
+            "$updated": "1970-01-01T00:00:00.000Z",
+            "id": 3,
+            "name": "test name",
+          },
+        ]
+      `);
+        });
+    });
+    it('should throw  if there is an error', async () => {
         const resourceDefinition = {
             roles: ['$public'],
             schema: {
@@ -68,324 +137,257 @@ describe('publishResource', () => {
             OrganizationId: organization.id,
         });
         await authorizeCLI('resources:write', testApp);
-        await publishResource({
+        await app.destroy();
+        await expect(() => publishResource({
             appId: app.id,
             definition: resourceDefinition,
             path: resolveFixture('resources/test.json'),
             remote: testApp.defaults.baseURL,
             type: 'test',
             seed: false,
-        });
-        const resources = await Resource.findAll({
-            where: { AppId: app.id },
-        });
-        expect(resources.map((r) => r.toJSON())).toMatchInlineSnapshot(`
-      [
-        {
-          "$created": "1970-01-01T00:00:00.000Z",
-          "$updated": "1970-01-01T00:00:00.000Z",
-          "email": "test@example.com",
-          "id": 1,
-          "name": "John Doe",
-        },
-        {
-          "$created": "1970-01-01T00:00:00.000Z",
-          "$updated": "1970-01-01T00:00:00.000Z",
-          "email": "test2@example.com",
-          "id": 2,
-          "name": "Jane Doe",
-        },
-        {
-          "$created": "1970-01-01T00:00:00.000Z",
-          "$updated": "1970-01-01T00:00:00.000Z",
-          "id": 3,
-          "name": "test name",
-        },
-      ]
-    `);
+        })).rejects.toThrow('Request failed with status code 404');
     });
-});
-it('should throw  if there is an error', async () => {
-    const resourceDefinition = {
-        roles: ['$public'],
-        schema: {
-            type: 'object',
-            additionalProperties: false,
-            required: ['name'],
-            properties: {
-                name: {
-                    type: 'string',
+    describe('updateResource', () => {
+        it('should update existing resources', async () => {
+            const resourceDefinition = {
+                roles: ['$public'],
+                schema: {
+                    type: 'object',
+                    additionalProperties: false,
+                    required: ['name'],
+                    properties: {
+                        name: {
+                            type: 'string',
+                        },
+                        email: {
+                            type: 'string',
+                            format: 'email',
+                        },
+                    },
                 },
-                email: {
-                    type: 'string',
-                    format: 'email',
+            };
+            const app = await App.create({
+                path: 'test-app',
+                definition: {
+                    resources: { test: resourceDefinition },
+                    name: 'Test App',
+                    defaultPage: 'Test Page',
                 },
-            },
-        },
-    };
-    const app = await App.create({
-        path: 'test-app',
-        definition: {
-            resources: { test: resourceDefinition },
-            name: 'Test App',
-            defaultPage: 'Test Page',
-        },
-        vapidPublicKey: 'a',
-        vapidPrivateKey: 'b',
-        visibility: 'public',
-        OrganizationId: organization.id,
-    });
-    await authorizeCLI('resources:write', testApp);
-    await app.destroy();
-    await expect(() => publishResource({
-        appId: app.id,
-        definition: resourceDefinition,
-        path: resolveFixture('resources/test.json'),
-        remote: testApp.defaults.baseURL,
-        type: 'test',
-        seed: false,
-    })).rejects.toThrow('Request failed with status code 404');
-});
-describe('updateResource', () => {
-    it('should update existing resources', async () => {
-        const resourceDefinition = {
-            roles: ['$public'],
-            schema: {
-                type: 'object',
-                additionalProperties: false,
-                required: ['name'],
-                properties: {
-                    name: {
-                        type: 'string',
+                vapidPublicKey: 'a',
+                vapidPrivateKey: 'b',
+                visibility: 'public',
+                OrganizationId: organization.id,
+            });
+            await Resource.bulkCreate([
+                {
+                    id: 1,
+                    type: 'test',
+                    AppId: app.id,
+                    data: {
+                        name: 'Hello World',
                     },
-                    email: {
-                        type: 'string',
-                        format: 'email',
+                },
+                {
+                    id: 2,
+                    type: 'test',
+                    AppId: app.id,
+                    data: {
+                        name: 'World Hello',
+                        email: 'hello@example.com',
                     },
                 },
-            },
-        };
-        const app = await App.create({
-            path: 'test-app',
-            definition: {
-                resources: { test: resourceDefinition },
-                name: 'Test App',
-                defaultPage: 'Test Page',
-            },
-            vapidPublicKey: 'a',
-            vapidPrivateKey: 'b',
-            visibility: 'public',
-            OrganizationId: organization.id,
-        });
-        await Resource.bulkCreate([
-            {
-                id: 1,
-                type: 'test',
-                AppId: app.id,
-                data: {
-                    name: 'Hello World',
+                {
+                    id: 3,
+                    type: 'test',
+                    AppId: app.id,
+                    data: {
+                        name: 'Random name',
+                        email: 'removed@example.com',
+                    },
                 },
-            },
-            {
-                id: 2,
-                type: 'test',
-                AppId: app.id,
-                data: {
-                    name: 'World Hello',
-                    email: 'hello@example.com',
+            ]);
+            await authorizeCLI('resources:write', testApp);
+            await updateResource({
+                appId: app.id,
+                resourceName: 'test',
+                remote: testApp.defaults.baseURL,
+                path: resolveFixture('resources/test-update.json'),
+            });
+            const resources = await Resource.findAll();
+            expect(resources.map((r) => r.toJSON())).toMatchInlineSnapshot(`
+        [
+          {
+            "$created": "1970-01-01T00:00:00.000Z",
+            "$updated": "1970-01-01T00:00:00.000Z",
+            "email": "test@example.com",
+            "id": 1,
+            "name": "John Doe",
+          },
+          {
+            "$created": "1970-01-01T00:00:00.000Z",
+            "$updated": "1970-01-01T00:00:00.000Z",
+            "email": "test2@example.com",
+            "id": 2,
+            "name": "Jane Doe",
+          },
+          {
+            "$created": "1970-01-01T00:00:00.000Z",
+            "$updated": "1970-01-01T00:00:00.000Z",
+            "id": 3,
+            "name": "test name",
+          },
+        ]
+      `);
+        });
+        it('should throw if the resource to be updated does not exist', async () => {
+            const resourceDefinition = {
+                roles: ['$public'],
+                schema: {
+                    type: 'object',
+                    additionalProperties: false,
+                    required: ['name'],
+                    properties: {
+                        name: {
+                            type: 'string',
+                        },
+                        email: {
+                            type: 'string',
+                            format: 'email',
+                        },
+                    },
                 },
-            },
-            {
-                id: 3,
-                type: 'test',
-                AppId: app.id,
-                data: {
-                    name: 'Random name',
-                    email: 'removed@example.com',
+            };
+            const app = await App.create({
+                path: 'test-app',
+                definition: {
+                    resources: { test: resourceDefinition },
+                    name: 'Test App',
+                    defaultPage: 'Test Page',
                 },
-            },
-        ]);
-        await authorizeCLI('resources:write', testApp);
-        await updateResource({
-            appId: app.id,
-            resourceName: 'test',
-            remote: testApp.defaults.baseURL,
-            path: resolveFixture('resources/test-update.json'),
-        });
-        const resources = await Resource.findAll();
-        expect(resources.map((r) => r.toJSON())).toMatchInlineSnapshot(`
-      [
-        {
-          "$created": "1970-01-01T00:00:00.000Z",
-          "$updated": "1970-01-01T00:00:00.000Z",
-          "email": "test@example.com",
-          "id": 1,
-          "name": "John Doe",
-        },
-        {
-          "$created": "1970-01-01T00:00:00.000Z",
-          "$updated": "1970-01-01T00:00:00.000Z",
-          "email": "test2@example.com",
-          "id": 2,
-          "name": "Jane Doe",
-        },
-        {
-          "$created": "1970-01-01T00:00:00.000Z",
-          "$updated": "1970-01-01T00:00:00.000Z",
-          "id": 3,
-          "name": "test name",
-        },
-      ]
-    `);
-    });
-    it('should throw if the resource to be updated does not exist', async () => {
-        const resourceDefinition = {
-            roles: ['$public'],
-            schema: {
-                type: 'object',
-                additionalProperties: false,
-                required: ['name'],
-                properties: {
-                    name: {
-                        type: 'string',
+                vapidPublicKey: 'a',
+                vapidPrivateKey: 'b',
+                visibility: 'public',
+                OrganizationId: organization.id,
+            });
+            await Resource.bulkCreate([
+                {
+                    id: 1,
+                    type: 'test',
+                    AppId: app.id,
+                    data: {
+                        name: 'Hello World',
                     },
-                    email: {
-                        type: 'string',
-                        format: 'email',
+                },
+                {
+                    id: 2,
+                    type: 'test',
+                    AppId: app.id,
+                    data: {
+                        name: 'World Hello',
+                        email: 'hello@example.com',
                     },
                 },
-            },
-        };
-        const app = await App.create({
-            path: 'test-app',
-            definition: {
-                resources: { test: resourceDefinition },
-                name: 'Test App',
-                defaultPage: 'Test Page',
-            },
-            vapidPublicKey: 'a',
-            vapidPrivateKey: 'b',
-            visibility: 'public',
-            OrganizationId: organization.id,
+            ]);
+            await authorizeCLI('resources:write', testApp);
+            await expect(() => updateResource({
+                appId: app.id,
+                resourceName: 'test',
+                remote: testApp.defaults.baseURL,
+                path: resolveFixture('resources/test-update.json'),
+            })).rejects.toThrow('Request failed with status code 404');
         });
-        await Resource.bulkCreate([
-            {
-                id: 1,
-                type: 'test',
-                AppId: app.id,
-                data: {
-                    name: 'Hello World',
+        it('should not update if there are no IDs in resource file', async () => {
+            const resourceDefinition = {
+                roles: ['$public'],
+                schema: {
+                    type: 'object',
+                    additionalProperties: false,
+                    required: ['name'],
+                    properties: {
+                        name: {
+                            type: 'string',
+                        },
+                        email: {
+                            type: 'string',
+                            format: 'email',
+                        },
+                    },
                 },
-            },
-            {
-                id: 2,
-                type: 'test',
-                AppId: app.id,
-                data: {
-                    name: 'World Hello',
-                    email: 'hello@example.com',
+            };
+            const app = await App.create({
+                path: 'test-app',
+                definition: {
+                    resources: { test: resourceDefinition },
+                    name: 'Test App',
+                    defaultPage: 'Test Page',
                 },
-            },
-        ]);
-        await authorizeCLI('resources:write', testApp);
-        await expect(() => updateResource({
-            appId: app.id,
-            resourceName: 'test',
-            remote: testApp.defaults.baseURL,
-            path: resolveFixture('resources/test-update.json'),
-        })).rejects.toThrow('Request failed with status code 404');
-    });
-    it('should not update if there are no IDs in resource file', async () => {
-        const resourceDefinition = {
-            roles: ['$public'],
-            schema: {
-                type: 'object',
-                additionalProperties: false,
-                required: ['name'],
-                properties: {
-                    name: {
-                        type: 'string',
-                    },
-                    email: {
-                        type: 'string',
-                        format: 'email',
+                vapidPublicKey: 'a',
+                vapidPrivateKey: 'b',
+                visibility: 'public',
+                OrganizationId: organization.id,
+            });
+            await Resource.bulkCreate([
+                {
+                    id: 1,
+                    type: 'test',
+                    AppId: app.id,
+                    data: {
+                        name: 'Hello World',
                     },
                 },
-            },
-        };
-        const app = await App.create({
-            path: 'test-app',
-            definition: {
-                resources: { test: resourceDefinition },
-                name: 'Test App',
-                defaultPage: 'Test Page',
-            },
-            vapidPublicKey: 'a',
-            vapidPrivateKey: 'b',
-            visibility: 'public',
-            OrganizationId: organization.id,
-        });
-        await Resource.bulkCreate([
-            {
-                id: 1,
-                type: 'test',
-                AppId: app.id,
-                data: {
-                    name: 'Hello World',
-                },
-            },
-            {
-                id: 2,
-                type: 'test',
-                AppId: app.id,
-                data: {
-                    name: 'World Hello',
-                    email: 'hello@example.com',
+                {
+                    id: 2,
+                    type: 'test',
+                    AppId: app.id,
+                    data: {
+                        name: 'World Hello',
+                        email: 'hello@example.com',
+                    },
                 },
-            },
-        ]);
-        await authorizeCLI('resources:write', testApp);
-        const resources = await Resource.findAll();
-        expect(resources.map((r) => r.toJSON())).toMatchInlineSnapshot(`
-      [
-        {
-          "$created": "1970-01-01T00:00:00.000Z",
-          "$updated": "1970-01-01T00:00:00.000Z",
-          "id": 1,
-          "name": "Hello World",
-        },
-        {
-          "$created": "1970-01-01T00:00:00.000Z",
-          "$updated": "1970-01-01T00:00:00.000Z",
-          "email": "hello@example.com",
-          "id": 2,
-          "name": "World Hello",
-        },
-      ]
-    `);
-        await updateResource({
-            appId: app.id,
-            resourceName: 'test',
-            remote: testApp.defaults.baseURL,
-            path: resolveFixture('resources/test.json'),
+            ]);
+            await authorizeCLI('resources:write', testApp);
+            const resources = await Resource.findAll();
+            expect(resources.map((r) => r.toJSON())).toMatchInlineSnapshot(`
+        [
+          {
+            "$created": "1970-01-01T00:00:00.000Z",
+            "$updated": "1970-01-01T00:00:00.000Z",
+            "id": 1,
+            "name": "Hello World",
+          },
+          {
+            "$created": "1970-01-01T00:00:00.000Z",
+            "$updated": "1970-01-01T00:00:00.000Z",
+            "email": "hello@example.com",
+            "id": 2,
+            "name": "World Hello",
+          },
+        ]
+      `);
+            await updateResource({
+                appId: app.id,
+                resourceName: 'test',
+                remote: testApp.defaults.baseURL,
+                path: resolveFixture('resources/test.json'),
+            });
+            expect(resources.map((r) => r.toJSON())).toMatchInlineSnapshot(`
+        [
+          {
+            "$created": "1970-01-01T00:00:00.000Z",
+            "$updated": "1970-01-01T00:00:00.000Z",
+            "id": 1,
+            "name": "Hello World",
+          },
+          {
+            "$created": "1970-01-01T00:00:00.000Z",
+            "$updated": "1970-01-01T00:00:00.000Z",
+            "email": "hello@example.com",
+            "id": 2,
+            "name": "World Hello",
+          },
+        ]
+      `);
         });
-        expect(resources.map((r) => r.toJSON())).toMatchInlineSnapshot(`
-      [
-        {
-          "$created": "1970-01-01T00:00:00.000Z",
-          "$updated": "1970-01-01T00:00:00.000Z",
-          "id": 1,
-          "name": "Hello World",
-        },
-        {
-          "$created": "1970-01-01T00:00:00.000Z",
-          "$updated": "1970-01-01T00:00:00.000Z",
-          "email": "hello@example.com",
-          "id": 2,
-          "name": "World Hello",
-        },
-      ]
-    `);
     });
 });
 //# sourceMappingURL=resource.test.js.map