Tests !

app/Controllers/events.ts

@@ -11,7 +11,7 @@ export const getAllRoots = async ({ response }: HttpContextContract) => {
 
 /** Return the level 1 children of an event */
 export const getChildren = async ({ params, response }: HttpContextContract) => {
-  const fatherEvent = await Event.findOrFail(params.id)
+  const fatherEvent = await Event.findOrFail(params.eventId)
   const children = await fatherEvent.related('children').query()
 
   return response.ok(children)

app/Controllers/picture.ts

 import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext'
 import Picture from 'App/Models/Picture'
-import { createPictureSchema } from 'App/Schemas/pictures.schema'
+import { createPictureSchema, getPicturesSchema } from 'App/Schemas/pictures.schema'
 
 /** Get all pictures of an event, with param id */
-export const getPictures = async ({ response, params }: HttpContextContract) => {
-  const pictures = await Picture.query().where('eventId', params.id)
+export const getPictures = async ({ request, response }: HttpContextContract) => {
+  const {
+    params: { eventId },
+  } = await request.validate({ schema: getPicturesSchema })
+
+  const pictures = await Picture.query().where('eventId', eventId)
 
   return response.ok(pictures)
 }
@@ -13,8 +17,11 @@ export const getPictures = async ({ response, params }: HttpContextContract) =>
  * Create a picture
  * TODO: Really create a picture, not just metadata
  */
-export const createPicture = async ({ request, response }: HttpContextContract) => {
-  const newPicture = await request.validate({ schema: createPictureSchema })
+export const createPicture = async ({ request, response, params }: HttpContextContract) => {
+  const newPicture = await request.validate({
+    schema: createPictureSchema,
+    data: { ...request.body(), eventId: params.eventId },
+  })
 
   await Picture.create(newPicture)
   return response.created({ message: 'Picture created' })

app/Schemas/pictures.schema.ts

 import { rules, schema } from '@ioc:Adonis/Core/Validator'
 
+export const getPicturesSchema = schema.create({
+  params: schema.object().members({
+    eventId: schema.number([rules.exists({ table: 'events', column: 'id' })]),
+  }),
+})
+
 export const createPictureSchema = schema.create({
   fileName: schema.string([rules.minLength(1), rules.maxLength(255)]),
   author: schema.string([rules.minLength(1), rules.maxLength(255)]),

database/seeders/Event.seeder.ts

@@ -5,7 +5,7 @@ import Event from 'App/Models/Event'
 const EventFactory = Factory.define(Event, async ({ faker }) => {
   return {
     name: `${faker.word.adjective()} ${faker.word.noun()} ${faker.word.adverb()}`,
-    thumbnailId: 0,
+    thumbnailId: faker.number.int({ min: 1, max: 50 }),
     parentId: null,
   }
 }).build()
@@ -13,7 +13,7 @@ const EventFactory = Factory.define(Event, async ({ faker }) => {
 export default class extends BaseSeeder {
   public async run() {
     // Create root events
-    await EventFactory.createMany(30)
+    await EventFactory.createMany(6)
 
     // Create children
     const events = await Event.all()

database/seeders/Picture.seeder.ts

+import Factory from '@ioc:Adonis/Lucid/Factory'
+import BaseSeeder from '@ioc:Adonis/Lucid/Seeder'
+import Picture from 'App/Models/Picture'
+
+const PictureFactory = Factory.define(Picture, async ({ faker }) => {
+  return {
+    fileName: `${faker.music.songName()}.jpg`,
+    author: `${faker.person.firstName()} ${faker.person.lastName()}`,
+    eventId: faker.number.int({ min: 1, max: 50 }),
+  }
+}).build()
+
+export default class extends BaseSeeder {
+  public async run() {
+    // Create root events
+    await PictureFactory.createMany(300)
+  }
+}

start/routes.ts

@@ -21,9 +21,7 @@ import Route from '@ioc:Adonis/Core/Route'
 
 /** ==== Auth ==== */
 Route.group(() => {
-  Route.group(() => {
-    Route.post('/login', 'AuthController.loginNotSigmaUser')
-  }).prefix('/notSigmaUser')
+  Route.post('/notSigmaUser/login', 'AuthController.loginNotSigmaUser')
 
   Route.group(() => {
     Route.get('/login', 'AuthController.loginSigmaUser')
@@ -36,17 +34,18 @@ Route.group(() => {
 /** ==== Events ==== */
 Route.group(() => {
   Route.get('/getAllRoots', 'EventController.getAllRoots')
-  Route.get('/getChildren/:id', 'EventController.getChildren')
   Route.post('/create', 'EventController.createEvent')
-})
-  .prefix('/event')
-  .middleware('auth:api')
 
-/** ==== Pictures ==== */
-Route.group(() => {
-  Route.get('/get/:id', 'PictureController.getPictures').where('id', Route.matchers.number())
+  // A particular event
+  Route.group(() => {
+    Route.get('/children', 'EventController.getChildren')
+    Route.get('/pictures', 'PictureController.getPictures')
+    Route.post('/createPicture', 'PictureController.createPicture')
+  })
+    .prefix('/:eventId')
+    .where('eventId', Route.matchers.number())
 })
-  .prefix('/picture')
+  .prefix('/event')
   .middleware('auth:api')
 
 /** ==== Admin ==== */

tests/functional/auth.spec.ts

+import { test } from '@japa/runner'
+import { getBearerToken } from '../test.utils'
+
+test('Unauthorized', async ({ client }) => {
+  const response = await client.get('/event/getAllRoots')
+  response.assertStatus(401)
+
+  const response2 = await client.post('/admin/notSigmaUser/create').json({
+    username: 'test',
+  })
+  response2.assertStatus(401)
+})
+
+test('Logged in successfuly', async ({ client }) => {
+  const token = await getBearerToken(client, 'thibaut', '0000')
+
+  const response = await client.get('/event/getAllRoots').bearerToken(token)
+  response.assertStatus(200)
+})
+
+test('Invalid credential', async ({ client }) => {
+  const response = await client.post('/auth/notSigmaUser/login').json({
+    username: 'thibaut',
+    password: '1234',
+  })
+  response.assertStatus(401)
+
+  const response2 = await client.post('/auth/notSigmaUser/login').json({
+    username: 'tarwgnwe',
+    password: '0000',
+  })
+  response2.assertStatus(401)
+})
+
+test('Create user', async ({ client }) => {
+  const token = await getBearerToken(client, 'admin', '0000')
+
+  const response = await client
+    .post('/admin/notSigmaUser/create')
+    .bearerToken(token)
+    .json({
+      username: `test${Math.random()}`, // To avoid conflicts
+    })
+  response.assertStatus(201)
+})
+
+test('Create user without being admin', async ({ client }) => {
+  const token = await getBearerToken(client, 'thibaut', '0000')
+
+  const response = await client
+    .post('/admin/notSigmaUser/create')
+    .header('Authorization', `Bearer ${token}`)
+    .json({
+      username: 'test',
+    })
+  response.assertStatus(401)
+})

tests/functional/hello_world.spec.ts

-import { test } from '@japa/runner'
-
-test('display welcome page', async ({ client }) => {
-  const response = await client.get('/')
-
-  response.assertStatus(200)
-  response.assertBodyContains({ hello: 'world' })
-})

tests/test.utils.ts

+import { ApiClient } from '@japa/api-client'
+
+/** Helper to login to the api and obtain an object with the token header */
+export const getBearerToken = async (client: ApiClient, username: string, password: string) => {
+  const response = await client.post('/auth/notSigmaUser/login').json({
+    username,
+    password,
+  })
+
+  response.assertStatus(200)
+  return response.body().token as string
+}