(project init)

Author: sean-hale-dev

README.md

@@ -1,34 +1,13 @@
-This is a [Next.js](https://nextjs.org/) project bootstrapped with [`create-next-app`](https://github.com/vercel/next.js/tree/canary/packages/create-next-app).
-
-## Getting Started
-
-First, run the development server:
-
-```bash
-npm run dev
-# or
-yarn dev
-```
-
-Open [http://localhost:3000](http://localhost:3000) with your browser to see the result.
-
-You can start editing the page by modifying `pages/index.tsx`. The page auto-updates as you edit the file.
-
-[API routes](https://nextjs.org/docs/api-routes/introduction) can be accessed on [http://localhost:3000/api/hello](http://localhost:3000/api/hello). This endpoint can be edited in `pages/api/hello.ts`.
-
-The `pages/api` directory is mapped to `/api/*`. Files in this directory are treated as [API routes](https://nextjs.org/docs/api-routes/introduction) instead of React pages.
-
-## Learn More
-
-To learn more about Next.js, take a look at the following resources:
-
-- [Next.js Documentation](https://nextjs.org/docs) - learn about Next.js features and API.
-- [Learn Next.js](https://nextjs.org/learn) - an interactive Next.js tutorial.
-
-You can check out [the Next.js GitHub repository](https://github.com/vercel/next.js/) - your feedback and contributions are welcome!
-
-## Deploy on Vercel
-
-The easiest way to deploy your Next.js app is to use the [Vercel Platform](https://vercel.com/new?utm_medium=default-template&filter=next.js&utm_source=create-next-app&utm_campaign=create-next-app-readme) from the creators of Next.js.
-
-Check out our [Next.js deployment documentation](https://nextjs.org/docs/deployment) for more details.
+# Deers.IO
+
+## Dependencies
+- Postgres
+- Redis
+
+## Env Vars
+- `DATABASE_URL`
+- `MINIO_ACCESS_KEY`
+- `MINIO_SECRET_KEY`
+- `MINIO_HOST`
+- `MINIO_PORT`
+- `REDIS_HOST`

__test__/assets/white.png

@@ -0,0 +1,238 @@
+import prisma from '../../util/prisma';
+import { makeError } from '../../util/error';
+import { createEntity, deleteEntity, getEntities, getEntity, updateEntity } from '../entity';
+import { PrismaClientKnownRequestError } from '@prisma/client/runtime';
+
+
+describe('entity controller', () => {
+  beforeEach(() => {
+    jest.mock('../../util/prisma');
+  })
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe('create entity', () => {
+    test('valid create - no socials', () => {
+      const spy = jest.spyOn(prisma.entity, 'create');
+      spy.mockResolvedValueOnce({ id: 1, type: 'ARTIST', name: 'testArtist' });
+
+      expect.assertions(1)
+      return expect(createEntity({ name: 'testArtist', type: 'ARTIST' })).resolves.toEqual({id: 1, type: 'ARTIST', name: 'testArtist'});
+    })
+
+    test('valid create - with socials', () => {
+      const spy = jest.spyOn(prisma.entity, 'create');
+      spy.mockResolvedValueOnce({ id: 1, type: 'ARTIST', name: 'testArtist', });
+
+      expect.assertions(1)
+      return expect(
+        createEntity({
+          name: 'testArtist',
+          type: 'ARTIST',
+          socials: [
+            { type: 'TELEGRAM',    value: 'telegramArtist' },
+            { type: 'TWITTER',     value: 'twitterArtist' },
+            { type: 'WEBSITE',     value: 'https://websiteArtist.com' },
+            { type: 'FURAFFINITY', value: 'furaffinityArtist' },
+            { type: 'CUSTOM',      value: 'customArtistValue', name: 'customField' },
+          ]
+        })
+      ).resolves.toEqual({id: 1, type: 'ARTIST', name: 'testArtist'});
+    })
+
+    test('invalid entity type', () => {
+      expect.assertions(1)
+      return expect(createEntity({ name: 'testArtist', type: 'wrong type' })).rejects.toEqual(makeError('user', 'Invalid entity type'));
+    })
+
+    test('invalid social type', () => {
+      expect.assertions(1)
+      return expect(createEntity({ name: 'testCharacter', type: 'CHARACTER', socials: [{type: "wrong type", value: "something"}] }))
+        .rejects.toEqual(makeError('user', 'Invalid social. Non-valid type provided'));
+    })
+
+    test('invalid social form', () => {
+      expect.assertions(1)
+      return expect(createEntity({ name: 'testCharacter', type: 'CHARACTER', socials: [{type: "wrong type"}] }))
+        .rejects.toEqual(makeError('user', 'Invalid social. Must provide type, value'));
+    })
+
+    test('non-custom social provided name', () => {
+      expect.assertions(1)
+      return expect(createEntity({ name: 'testCharacter', type: 'CHARACTER', socials: [{type: 'TELEGRAM', name: "bad", value: "something"}] }))
+        .rejects.toEqual(makeError('user', 'Invalid social. Non-custom social fields should not specify name'));
+    })
+
+    test('custom social missing name', () => {
+      expect.assertions(1)
+      return expect(createEntity({ name: 'testCharacter', type: 'CHARACTER', socials: [{type: "CUSTOM", value: "something"}] }))
+        .rejects.toEqual(makeError('user', 'Invalid social. Custom socials must specify name'));
+    })
+
+    test('prisma error', () => {
+      const spy = jest.spyOn(prisma.entity, 'create');
+      spy.mockRejectedValueOnce(new Error());
+      expect.assertions(1)
+      return expect(createEntity({ name: 'testCharacter', type: 'CHARACTER', socials: [{type: "CUSTOM", name: 'test', value: "something"}] }))
+        .rejects.toEqual(makeError('server'));
+    })
+  })
+
+  describe('get entity', () => {
+    test('valid fetch', () => {
+      const spy = jest.spyOn(prisma.entity, 'findUnique');
+
+      const mock_entity = {
+        id: 1,
+        name: "testArtist",
+        type: 'ARTIST',
+        socials: [ { id: 1, type: "TELEGRAM", value: 'telegramArtist', name: null, entityId: 1 } ]
+      }
+      // @ts-ignore
+      spy.mockResolvedValueOnce(mock_entity);
+
+      expect.assertions(1)
+      return expect(getEntity(1)).resolves.toEqual(mock_entity);
+    })
+
+    test('non-existant entity', () => {
+      const spy = jest.spyOn(prisma.entity, 'findUnique');
+      spy.mockRejectedValueOnce(new PrismaClientKnownRequestError('', 'P2001', ''));
+
+      expect.assertions(1);
+      return expect(getEntity(1)).rejects.toEqual(makeError('user', 'Could not find entity'));
+    })
+
+    test('prisma error', () => {
+      const spy = jest.spyOn(prisma.entity, 'findUnique');
+      spy.mockRejectedValueOnce(new Error());
+
+      expect.assertions(1);
+      return expect(getEntity(1)).rejects.toEqual(makeError('server'));
+    })
+
+    test('invalid ID', () => {
+      expect.assertions(1);
+      return expect(getEntity(NaN)).rejects.toEqual(makeError('user', 'Invalid ID provided'))
+    })
+  })
+
+  describe('get entities', () => {
+    test('valid fetch', () => {
+      const spy = jest.spyOn(prisma.entity, 'findMany');
+      spy.mockResolvedValueOnce([1,2].map(i => ({id: i, name: 'testEnt', type: 'ARTIST'})));
+
+      expect.assertions(1);
+      return expect(getEntities()).resolves.toEqual([1,2].map(i => ({id: i, name: 'testEnt', type: 'ARTIST'})));
+    })
+
+    test('prisma error', () => {
+      const spy = jest.spyOn(prisma.entity, 'findMany');
+      spy.mockRejectedValueOnce(new Error());
+
+      expect.assertions(1)
+      return expect(getEntities()).rejects.toEqual(makeError('server'));
+    })
+  })
+
+  describe('delete entity', () => {
+    test('valid deletion', () => {
+      const spy = jest.spyOn(prisma.entity, 'delete');
+      spy.mockResolvedValueOnce({id: 1, name: 'testEnt', type: 'ARTIST'});
+      expect.assertions(1)
+      return expect(deleteEntity(1)).resolves.toEqual({id: 1, name: 'testEnt', type: 'ARTIST'});
+    })
+
+    test('invalid ID', () => {
+      expect.assertions(1)
+      return expect(deleteEntity(NaN)).rejects.toEqual(makeError('user', 'Invalid ID provided'));
+    })
+
+    test('non-existant entity', () => {
+      const spy = jest.spyOn(prisma.entity, 'delete');
+      spy.mockRejectedValueOnce(new PrismaClientKnownRequestError('', 'P2001', ''));
+      expect.assertions(1);
+      return expect(deleteEntity(1)).rejects.toEqual(makeError('user', 'Could not find entity'));
+    })
+
+    test('entity has associated commissions', () => {
+      const spy = jest.spyOn(prisma.entity, 'delete');
+      spy.mockRejectedValueOnce(new PrismaClientKnownRequestError('', 'P2003', ''));
+      expect.assertions(1);
+      return expect(deleteEntity(1)).rejects.toEqual(makeError('user', 'Entity has commissions associated with it'));
+    })
+
+    test('prisma error', () => {
+      const spy = jest.spyOn(prisma.entity, 'delete');
+      spy.mockRejectedValueOnce(new Error());
+      expect.assertions(1);
+      return expect(deleteEntity(1)).rejects.toEqual(makeError('server'));
+    })
+  })
+
+  describe('update entity', () => {
+    test('valid update', () => {
+      const spy = jest.spyOn(prisma.entity, 'update');
+      spy.mockResolvedValueOnce({id: 1, name: 'newName', type: 'CHARACTER'});
+      expect.assertions(1);
+      const updateArgs = {
+        name: 'newName',
+        type: 'CHARACTER',
+        socials: {
+          add: [{type: 'TELEGRAM', value: 'entTelegram'}],
+          remove: [1,2,3]
+        }
+      }
+      return expect(updateEntity(1, updateArgs)).resolves.toEqual({id: 1, name: 'newName', type: 'CHARACTER'});
+    })
+
+    test('invalid name', () => {
+      expect.assertions(1)
+      return expect(updateEntity(1, {name: ''})).rejects.toEqual(makeError('user', 'Entity name cannot be empty'));
+    })
+
+    test('invalid type', () => {
+      expect.assertions(1)
+      return expect(updateEntity(1, {type: ''})).rejects.toEqual(makeError('user', 'Invalid entity type'));
+    })
+
+    test('invalid social type', () => {
+      expect.assertions(1)
+      return expect(updateEntity(1, {socials: { add: [{type: "wrong type", value: "wrong"}] }})).rejects.toEqual(makeError('user', 'Invalid social. Non-valid type provided'));
+    })
+
+    test('invalid social form', () => {
+      expect.assertions(1)
+      return expect(updateEntity(1, {socials: { add: [{type: "wrong type"}] }})).rejects.toEqual(makeError('user', 'Invalid social. Must provide type, value'));
+    })
+
+    test('non-custom social with name', () => {
+      expect.assertions(1)
+      return expect(updateEntity(1, {socials: { add: [{type: "TELEGRAM", value: 'entTelegram', name: 'bad'}] }})).rejects.toEqual(makeError('user', 'Invalid social. Non-custom social fields should not specify name'));
+    })
+
+    test('custom social without name', () => {
+      expect.assertions(1)
+      return expect(updateEntity(1, {socials: { add: [{type: "CUSTOM", value: 'entVal'}] }})).rejects.toEqual(makeError('user', 'Invalid social. Custom socials must specify name'));
+    })
+
+    test('invalid social ID', () => {
+      expect.assertions(1)
+      return expect(updateEntity(1, {socials: { remove: [NaN] }})).rejects.toEqual(makeError('user', 'Invalid ID provided'));
+    })
+
+    test('invalid entity ID', () => {
+      expect.assertions(1)
+      return expect(updateEntity(NaN, {socials: { remove: [NaN] }})).rejects.toEqual(makeError('user', 'Invalid ID provided'));
+    })
+
+    test('prisma error', () => {
+      const spy = jest.spyOn(prisma.entity, 'update');
+      spy.mockRejectedValueOnce(new Error());
+      expect.assertions(1);
+      return expect(updateEntity(1, {name: "something"})).rejects.toEqual(makeError('server'));
+    })
+  })
+})

__test__/assets/white_1024.png

@@ -0,0 +1,59 @@
+import { createUser, validateCredentials } from '../user';
+import prisma from '../../util/prisma';
+import { makeError } from '../../util/error';
+
+
+describe('user controller', () => {
+  beforeEach(() => {
+    jest.mock('../../util/prisma');
+  })
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  const mock_user = {
+    username: 'testuser',
+    password: 'testpass',
+  };
+
+  const mock_user_hashed = {
+    username: 'testuser',
+    password: '$2b$08$S5YDuYLmC3uuM5zpkpxtsuklUm9X9EynvEoR7osWcXppZ0Hjclfrm',
+  }
+
+  test('successfully creates user', async () => {
+    const prismaSpy = jest.spyOn(prisma.user, 'create');
+    prismaSpy.mockResolvedValueOnce({...mock_user, id: 1});
+    await createUser(mock_user.username, mock_user.password);
+
+    expect(prismaSpy).toHaveBeenCalledTimes(1);
+    const args = prismaSpy.mock.lastCall![0].data;
+    expect(args.username).toBe(mock_user.username);
+    expect(args.password).not.toBe(mock_user.password);
+  });
+
+  test('prisma fails on create user', () => {
+    const prismaSpy = jest.spyOn(prisma.user, 'create');
+    prismaSpy.mockRejectedValueOnce(new Error());
+    expect.assertions(1);
+
+    return expect(createUser(mock_user.username, mock_user.password)).rejects.toEqual(makeError('server'))
+  });
+
+  test('successfully validates password', async () => {
+    const prismaSpy = jest.spyOn(prisma.user, 'findUnique');
+    prismaSpy.mockResolvedValueOnce({ id: 1, username: mock_user.username, password: mock_user_hashed.password})
+
+    const result = await validateCredentials(mock_user.username, mock_user.password);
+    expect(result).toBeTruthy();
+  })
+
+  test('validation could not find user', () => {
+    const prismaSpy = jest.spyOn(prisma.user, 'findUnique');
+    prismaSpy.mockRejectedValueOnce(new Error());
+    expect.assertions(1);
+
+    return expect(validateCredentials(mock_user.username, mock_user.password)).rejects.toEqual(makeError('server'))
+  })
+})