@volcanicminds/backend 0.3.6 → 0.5.0

package/lib/api/auth/controller/auth.ts

@@ -5,31 +5,31 @@ export async function register(req: FastifyRequest, reply: FastifyReply) {
   const { password1: password, password2, ...data } = req.data()
 
   if (!req.server['userManager'].isImplemented()) {
-    throw Error('Not implemented')
+    throw new Error('Not implemented')
   }
 
   if (!data.username) {
-    return reply.status(400).send(Error('Username not valid'))
+    return reply.status(400).send(new Error('Username not valid'))
   }
   if (!data.email || !regExp.email.test(data.email)) {
-    return reply.status(400).send(Error('Email not valid'))
+    return reply.status(400).send(new Error('Email not valid'))
   }
   if (!password || !regExp.password.test(password)) {
-    return reply.status(400).send(Error('Password not valid'))
+    return reply.status(400).send(new Error('Password not valid'))
   }
   if (!password2 || password2 !== password) {
-    return reply.status(400).send(Error('Repeated password not match'))
+    return reply.status(400).send(new Error('Repeated password not match'))
   }
 
   let existings = await req.server['userManager'].retrieveUserByEmail(data.email)
   if (existings) {
-    return reply.status(400).send(Error('Email already registered'))
+    return reply.status(400).send(new Error('Email already registered'))
   }
 
   if ((data.requiredRoles || []).includes('admin')) {
     existings = await req.server['userManager'].findQuery({ 'roles:in': 'admin' })
     if (existings?.records?.length) {
-      return reply.status(400).send(Error('User admin already registered'))
+      return reply.status(400).send(new Error('User admin already registered'))
     }
   }
 
@@ -42,7 +42,7 @@ export async function register(req: FastifyRequest, reply: FastifyReply) {
 
   const user = await req.server['userManager'].createUser({ ...data, password: password })
   if (!user) {
-    return reply.status(400).send(Error('User not registered'))
+    return reply.status(400).send(new Error('User not registered'))
   }
 
   return user
@@ -55,18 +55,18 @@ export async function unregister(req: FastifyRequest, reply: FastifyReply) {
   let isValid = await req.server['userManager'].isValidUser(user)
 
   if (!isValid) {
-    return reply.status(403).send(Error('Wrong credentials'))
+    return reply.status(403).send(new Error('Wrong credentials'))
   }
 
   if (user.blocked) {
-    return reply.status(403).send(Error('User blocked'))
+    return reply.status(403).send(new Error('User blocked'))
   }
 
   user = await req.server['userManager'].disableUserById(user.getId())
   isValid = await req.server['userManager'].isValidUser(user)
 
   if (!isValid) {
-    return reply.status(400).send(Error('User not valid'))
+    return reply.status(400).send(new Error('User not valid'))
   }
 
   return { ok: true }
@@ -76,12 +76,12 @@ export async function validatePassword(req: FastifyRequest, reply: FastifyReply)
   const { password } = req.data()
 
   if (!password) {
-    return reply.status(400).send(Error('Password cannot be null'))
+    return reply.status(400).send(new Error('Password cannot be null'))
   }
 
   const match = regExp.password.test(password)
   if (!match) {
-    return reply.status(400).send(Error('Password is not valid'))
+    return reply.status(400).send(new Error('Password is not valid'))
   }
 
   return { ok: match }
@@ -91,26 +91,26 @@ export async function changePassword(req: FastifyRequest, reply: FastifyReply) {
   const { email, oldPassword, newPassword1, newPassword2 } = req.data()
 
   if (!req.server['userManager'].isImplemented()) {
-    throw Error('Not implemented')
+    throw new Error('Not implemented')
   }
 
   if (!newPassword1 || !regExp.password.test(newPassword1)) {
-    return reply.status(400).send(Error('New password is not valid'))
+    return reply.status(400).send(new Error('New password is not valid'))
   }
 
   if (!newPassword2 || newPassword2 !== newPassword1) {
-    return reply.status(400).send(Error('Repeated new password not match'))
+    return reply.status(400).send(new Error('Repeated new password not match'))
   }
 
   let user = await req.server['userManager'].retrieveUserByPassword(email, oldPassword)
   let isValid = await req.server['userManager'].isValidUser(user)
 
   if (!isValid) {
-    return reply.status(403).send(Error('Wrong credentials'))
+    return reply.status(403).send(new Error('Wrong credentials'))
   }
 
   if (user.blocked) {
-    return reply.status(403).send(Error('User blocked'))
+    return reply.status(403).send(new Error('User blocked'))
   }
 
   user = await req.server['userManager'].changePassword(email, newPassword1, oldPassword)
@@ -122,11 +122,11 @@ export async function forgotPassword(req: FastifyRequest, reply: FastifyReply) {
   const { username, email } = req.data()
 
   if (!req.server['userManager'].isImplemented()) {
-    throw Error('Not implemented')
+    throw new Error('Not implemented')
   }
 
   if (!username && (!email || (email && !regExp.email.test(email)))) {
-    return reply.status(400).send(Error('Missing a valid user identifier'))
+    return reply.status(400).send(new Error('Missing a valid user identifier'))
   }
 
   let user = null as any
@@ -139,11 +139,11 @@ export async function forgotPassword(req: FastifyRequest, reply: FastifyReply) {
   let isValid = await req.server['userManager'].isValidUser(user)
 
   if (!isValid) {
-    return reply.status(403).send(Error('Wrong credentials'))
+    return reply.status(403).send(new Error('Wrong credentials'))
   }
 
   if (user?.blocked) {
-    return reply.status(403).send(Error('User blocked'))
+    return reply.status(403).send(new Error('User blocked'))
   }
 
   user = await req.server['userManager'].forgotPassword(user.email)
@@ -156,18 +156,18 @@ export async function confirmEmail(req: FastifyRequest, reply: FastifyReply) {
   const { code } = req.data()
 
   if (!code) {
-    return reply.status(400).send(Error('Missing the confirm email token'))
+    return reply.status(400).send(new Error('Missing the confirm email token'))
   }
 
   let user = await req.server['userManager'].retrieveUserByConfirmationToken(code)
   let isValid = await req.server['userManager'].isValidUser(user)
 
   if (!isValid) {
-    return reply.status(403).send(Error('Wrong credentials'))
+    return reply.status(403).send(new Error('Wrong credentials'))
   }
 
   if (user.blocked) {
-    return reply.status(403).send(Error('User blocked'))
+    return reply.status(403).send(new Error('User blocked'))
   }
 
   user = await req.server['userManager'].userConfirmation(user)
@@ -180,26 +180,26 @@ export async function resetPassword(req: FastifyRequest, reply: FastifyReply) {
   const { code, newPassword1, newPassword2 } = req.data()
 
   if (!req.server['userManager'].isImplemented()) {
-    throw Error('Not implemented')
+    throw new Error('Not implemented')
   }
 
   if (!newPassword1 || !regExp.password.test(newPassword1)) {
-    return reply.status(400).send(Error('New password not valid'))
+    return reply.status(400).send(new Error('New password not valid'))
   }
 
   if (!newPassword2 || newPassword2 !== newPassword1) {
-    return reply.status(400).send(Error('Repeated new password not match'))
+    return reply.status(400).send(new Error('Repeated new password not match'))
   }
 
   let user = await req.server['userManager'].retrieveUserByResetPasswordToken(code)
   let isValid = await req.server['userManager'].isValidUser(user)
 
   if (!isValid) {
-    return reply.status(403).send(Error('Wrong credentials'))
+    return reply.status(403).send(new Error('Wrong credentials'))
   }
 
   if (user.blocked) {
-    return reply.status(403).send(Error('User blocked'))
+    return reply.status(403).send(new Error('User blocked'))
   }
 
   user = await req.server['userManager'].resetPassword(user, newPassword1)
@@ -211,14 +211,14 @@ export async function login(req: FastifyRequest, reply: FastifyReply) {
   const { email, password } = req.data()
 
   if (!req.server['userManager'].isImplemented()) {
-    throw Error('Not implemented')
+    throw new Error('Not implemented')
   }
 
   if (!email || !regExp.email.test(email)) {
-    return reply.status(400).send(Error('Email not valid'))
+    return reply.status(400).send(new Error('Email not valid'))
   }
   if (!password || !regExp.password.test(password)) {
-    return reply.status(400).send(Error('Password not valid'))
+    return reply.status(400).send(new Error('Password not valid'))
   }
 
   const user = await req.server['userManager'].retrieveUserByPassword(email, password)
@@ -227,22 +227,15 @@ export async function login(req: FastifyRequest, reply: FastifyReply) {
   // const isValid = true
 
   if (!isValid) {
-    return reply.status(403).send(Error('Wrong credentials'))
+    return reply.status(403).send(new Error('Wrong credentials'))
   }
 
   if (!(user.confirmed === true)) {
-    return reply.status(403).send(Error('User email unconfirmed'))
-  }
-
-  const isPasswordToBeChanged = req.server['userManager'].isPasswordToBeChanged(user)
-  if (isPasswordToBeChanged) {
-    return reply
-      .status(403)
-      .send({ statusCode: 403, code: 'PASSWORD_TO_BE_CHANGED', message: 'The password is expired' })
+    return reply.status(403).send(new Error('User email unconfirmed'))
   }
 
   if (user.blocked) {
-    return reply.status(403).send(Error('User blocked'))
+    return reply.status(403).send(new Error('User blocked'))
   }
 
   // https://www.iana.org/assignments/jwt/jwt.xhtml
@@ -263,23 +256,28 @@ export async function refreshToken(req: FastifyRequest, reply: FastifyReply) {
   const { token, refreshToken } = req.data()
 
   if (!req.server['userManager'].isImplemented()) {
-    throw Error('Not implemented')
+    throw new Error('Not implemented')
   }
 
-  const tokenData = (await reply.server.jwt.decode(token)) as any
-  const refreshTokenData = await reply.server.jwt['refreshToken'].verify(refreshToken)
+  const tokenData = (await reply.server.jwt.decode(token)) as { sub: number }
+  const minAccettable = Math.floor(Date.now() / 1000) - 2592000 // 30 days
+
+  if (tokenData?.sub > 0 && tokenData?.sub > minAccettable) {
+    return reply.status(403).send(new Error('Token too old'))
+  }
 
+  const refreshTokenData = await reply.server.jwt['refreshToken'].verify(refreshToken)
   if (tokenData?.sub && tokenData?.sub !== refreshTokenData?.sub) {
-    return reply.status(403).send(Error('Mismatched tokens'))
+    return reply.status(403).send(new Error('Mismatched tokens'))
   }
 
-  const user = await req.server['userManager'].retrieveUserByExternalId(tokenData?.sub)
+  const user = await req.server['userManager'].retrieveUserByExternalId(tokenData.sub)
   const isValid = await req.server['userManager'].isValidUser(user)
   // const user = { confirmed: true, blocked: false, externalId: 123456, roles: [{ code: 'admin' }] }
   // const isValid = true
 
   if (!isValid) {
-    return reply.status(403).send(Error('Wrong refresh token'))
+    return reply.status(403).send(new Error('Wrong refresh token'))
   }
 
   const newToken = await reply.jwtSign({ sub: user.externalId })
@@ -291,7 +289,7 @@ export async function refreshToken(req: FastifyRequest, reply: FastifyReply) {
 export async function invalidateTokens(req: FastifyRequest, reply: FastifyReply) {
   let isValid = await req.server['userManager'].isValidUser(req.user)
   if (!req.user || !isValid) {
-    return reply.status(403).send(Error('User not linked'))
+    return reply.status(403).send(new Error('User not linked'))
   }
 
   const user = await req.server['userManager'].resetExternalId(req.user.getId())
@@ -301,7 +299,7 @@ export async function invalidateTokens(req: FastifyRequest, reply: FastifyReply)
 
 export async function block(req: FastifyRequest, reply: FastifyReply) {
   if (!req.server['userManager'].isImplemented()) {
-    throw Error('Not implemented')
+    throw new Error('Not implemented')
   }
 
   if (!req.hasRole(roles.admin) && !req.hasRole(roles.backoffice)) {
@@ -311,13 +309,14 @@ export async function block(req: FastifyRequest, reply: FastifyReply) {
   const { id: userId } = req.parameters()
   const { reason } = req.data()
 
-  const user = await req.server['userManager'].blockUserById(userId, reason)
+  let user = await req.server['userManager'].blockUserById(userId, reason)
+  user = await req.server['userManager'].resetExternalId(user.getId())
   return { ok: !!user.getId() }
 }
 
 export async function unblock(req: FastifyRequest, reply: FastifyReply) {
   if (!req.server['userManager'].isImplemented()) {
-    throw Error('Not implemented')
+    throw new Error('Not implemented')
   }
 
   if (!req.hasRole(roles.admin) && !req.hasRole(roles.backoffice)) {

package/lib/api/token/controller/token.ts

@@ -20,7 +20,7 @@ export async function create(req: FastifyRequest, reply: FastifyReply) {
   const data = req.data()
 
   if (!data.name) {
-    return reply.status(404).send(Error('Token name not valid'))
+    return reply.status(404).send(new Error('Token name not valid'))
   }
 
   // public is the default
@@ -32,7 +32,7 @@ export async function create(req: FastifyRequest, reply: FastifyReply) {
 
   let token = await req.server['tokenManager'].createToken(data)
   if (!token || !token.getId() || !token.externalId) {
-    return reply.status(400).send(Error('Token not registered'))
+    return reply.status(400).send(new Error('Token not registered'))
   }
 
   const bearerToken = await reply.jwtSign(
@@ -42,7 +42,7 @@ export async function create(req: FastifyRequest, reply: FastifyReply) {
     }
   )
   if (!bearerToken) {
-    return reply.status(400).send(Error('Token not signed'))
+    return reply.status(400).send(new Error('Token not signed'))
   }
 
   token = await req.server['tokenManager'].updateTokenById(token.getId(), { token: bearerToken })
@@ -57,7 +57,7 @@ export async function remove(req: FastifyRequest, reply: FastifyReply) {
 
   let token = await req.server['tokenManager'].retrieveTokenById(id)
   if (!token) {
-    return reply.status(403).send(Error('Token not found'))
+    return reply.status(403).send(new Error('Token not found'))
   }
 
   token = await req.server['tokenManager'].removeTokenById(id)

package/lib/api/tool/controller/tool.ts

@@ -0,0 +1,13 @@
+import { FastifyReply, FastifyRequest } from 'fastify'
+
+export async function synchronizeSchemas(req: FastifyRequest, reply: FastifyReply) {
+  if (!req.server['dataBaseManager'].isImplemented()) {
+    throw new Error('Not implemented')
+  }
+
+  reply.send({ ok: true })
+
+  log.warn('Database schema synchronization started')
+  await req.server['dataBaseManager'].synchronizeSchemas()
+  log.warn('Database schema synchronization finished')
+}

package/lib/api/tool/routes.ts

@@ -0,0 +1,24 @@
+module.exports = {
+  config: {
+    title: 'Tool functions',
+    description: 'Tool functions',
+    controller: 'controller',
+    tags: ['tool']
+  },
+  routes: [
+    {
+      method: 'POST',
+      path: '/synchronize-schemas',
+      roles: [roles.admin],
+      handler: 'tool.synchronizeSchemas',
+      middlewares: ['global.isAuthenticated'],
+      config: {
+        title: 'Synchronize database schema',
+        description: 'Synchronize database schema',
+        response: {
+          200: { $ref: 'defaultResponse#' }
+        }
+      }
+    }
+  ]
+}

package/lib/loader/translation.ts

@@ -0,0 +1,67 @@
+const path = require('path')
+const glob = require('glob')
+const { I18n } = require('i18n')
+
+// import { normalizePatterns } from '../util/path'
+
+export function load(): any {
+  const i18n = new I18n({
+    locales: ['en', 'it'],
+    defaultLocale: 'en',
+    // header: 'accept-language',
+    autoReload: false,
+    updateFiles: false,
+    syncFiles: false,
+    extension: '.json',
+    prefix: '',
+    objectNotation: true,
+    // mustacheConfig: { disable: false },
+    // directory: './src/locales',
+
+    logDebugFn: (msg) => log.debug(msg),
+    logWarnFn: (msg) => log.warn(msg),
+    logErrorFn: (msg) => log.error(msg)
+  })
+
+  const basePath = path.join(__dirname, '..', 'locales', '*.json').replaceAll('\\', '/')
+
+  glob.sync(basePath).forEach((f: string) => {
+    log.info('* Loading base dictionary %s', path.parse(f).base)
+    try {
+      const content = require(f)
+      addLocaleFile(i18n, path.parse(f).name, content)
+    } catch (err) {
+      log.error(err)
+    }
+  })
+
+  const addPath = path.join(process.cwd(), 'src', 'locales', '*.json').replaceAll('\\', '/')
+
+  glob.sync(addPath).forEach((f: string) => {
+    log.info('* Loading additional dictionary %s', path.parse(f).base)
+    try {
+      const content = require(f)
+      addLocaleFile(i18n, path.parse(f).name, content)
+    } catch (err) {
+      log.error(err)
+    }
+  })
+
+  i18n.setLocale(i18n.defaultLocale || 'en')
+  //   let test1 = i18n.__('greeting.formal')
+  //   let test2 = i18n.__('hello')
+  //   let test3 = i18n.__('greeting.placeholder.formal', 'UGO')
+  //   let test4 = i18n.__('greeting.placeholder.formalize:Buondì %s', 'UGO')
+  //   let test5 = i18n.__('greeting.formal')
+  //   let test6 = i18n.__({ phrase: 'greeting.formal', locale: 'it' })
+  //   let test7 = i18n.__({ phrase: 'greeting.placeholder.formal', locale: 'it' }, 'UGO')
+  //   i18n.setLocale(i18n.defaultLocale || 'en')
+  return i18n
+}
+
+function addLocaleFile(i18n, locale, content) {
+  let catalog = i18n && i18n.getCatalog()
+  if (catalog && locale && content) {
+    catalog[locale] = catalog[locale] ? { ...catalog[locale], ...content } : content
+  }
+}

package/lib/locales/en.json

@@ -0,0 +1,12 @@
+{
+  "hello": "Hello",
+  "greeting": {
+    "formal": "Hello",
+    "informal": "Hi",
+    "placeholder": {
+      "formal": "Hello %s",
+      "informal": "Hi %s"
+    }
+  },
+  "complex": "Hello {{user.firstname}} {{user.lastname}}"
+}

package/lib/locales/it.json

@@ -0,0 +1,12 @@
+{
+  "hello": "Ciao",
+  "greeting": {
+    "formal": "Ciao",
+    "informal": "Cià",
+    "placeholder": {
+      "formal": "Ciao %s",
+      "informal": "Cià %s"
+    }
+  },
+  "complex": "Ciao {{user.firstname}} {{user.lastname}}"
+}

package/lib/util/errors.ts

@@ -0,0 +1,20 @@
+export class TranslatedError extends Error {
+  locale: string
+  status: number
+  translationCode: string
+  translatedMessage: string
+  data: any
+
+  constructor({ translationCode, data = {}, locale = 'en', defaultMessage = null, status = 400 }) {
+    super()
+    this.name = this.constructor?.name || 'TranslatedError'
+    this.locale = locale
+    this.status = status
+    this.translationCode = translationCode
+    this.translatedMessage = global.t.__({ phrase: translationCode || defaultMessage, locale: locale || 'en' }, data)
+    this.message = this.translatedMessage || defaultMessage || 'generic error'
+    this.data = data
+
+    Error.captureStackTrace(this, this.constructor || TranslatedError)
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volcanicminds/backend",
-  "version": "0.3.6",
+  "version": "0.5.0",
   "codename": "turin",
   "license": "MIT",
   "description": "The volcanic (minds) backend",
@@ -44,12 +44,13 @@
     "server": "cd dist && node server.js",
     "start": "ts-node server.ts",
     "dev": "nodemon --exec \"ts-node\" server.ts",
-    "test": "jest test --config jest.config.js",
+    "test": "yarn test:full",
+    "test:full": "cross-env PORT=2231 NODE_ENV=memory BROWSER=false mocha ./test/index.spec.ts -t 100000",
     "reset": "yarn && yarn upgrade && yarn compile",
     "upgrade-deps": "yarn upgrade-interactive"
   },
   "dependencies": {
-    "@apollo/server": "^4.2.2",
+    "@apollo/server": "^4.3.3",
     "@as-integrations/fastify": "^1.2.0",
     "@fastify/compress": "^6.2.0",
     "@fastify/cors": "^8.2.0",
@@ -58,19 +59,24 @@
     "@fastify/rate-limit": "^7.6.0",
     "@fastify/swagger": "^8.2.0",
     "@fastify/swagger-ui": "^1.3.0",
-    "@types/node": "^18.11.10",
+    "@types/node": "^20.3.1",
     "dotenv": "^16.0.3",
-    "fastify": "^4.10.2",
+    "fastify": "^4.13.0",
     "glob": "^8.0.3",
     "graphql": "^16.6.0",
-    "nanoid": "^4.0.0",
+    "i18n": "^0.15.1",
+    "nanoid": "^4.0.1",
     "object-sizeof": "^1.6.3",
-    "pino": "^8.7.0",
+    "pino": "^8.10.0",
     "pino-pretty": "^9.1.1",
     "root-require": "^0.3.1",
     "semver": "^7.3.8"
   },
   "devDependencies": {
+    "@types/mocha": "^10.0.1",
+    "cross-env": "^7.0.3",
+    "expect": "^29.5.0",
+    "mocha": "^10.2.0",
     "nodemon": "^2.0.20",
     "ts-node": "^10.9.1",
     "typescript": "^4.9.3"

package/test/common/api.ts

@@ -0,0 +1,80 @@
+const axios = require('axios')
+const http = axios.create({ baseURL: `http://0.0.0.0:${process.env.PORT?.replace(/\\n/gm, '\n') || 2231}/` })
+
+import { DEFAULT_ADMIN_EMAIL, DEFAULT_ADMIN_PASSWORD } from '../common/bootstrap'
+
+export async function login(email = DEFAULT_ADMIN_EMAIL, password = DEFAULT_ADMIN_PASSWORD) {
+  try {
+    delete http.defaults.headers.common.Authorization
+    const { data } = await http.post('/auth/login', {
+      email,
+      password
+    })
+    http.defaults.headers.common['Authorization'] = `Bearer ${data.token}`
+    return data
+  } catch (err) {
+    console.log(err)
+    throw err
+  }
+}
+
+export async function logout() {
+  try {
+    delete http.defaults.headers.common.Authorization
+  } catch (err) {
+    throw err
+  }
+}
+
+export async function get(...args) {
+  try {
+    const { data } = await http.get(...args)
+    return data
+  } catch (err) {
+    throw err
+  }
+}
+
+export async function get_with_headers(...args) {
+  try {
+    const { data, headers } = await http.get(...args)
+    return { data, headers }
+  } catch (err) {
+    throw err
+  }
+}
+
+export async function post(...args) {
+  try {
+    const { data } = await http.post(...args)
+    return data
+  } catch (err) {
+    throw err
+  }
+}
+
+export async function put(...args) {
+  try {
+    const { data } = await http.put(...args)
+    return data
+  } catch (err) {
+    throw err
+  }
+}
+
+export async function del(...args) {
+  try {
+    const { data } = await http.delete(...args)
+    return data
+  } catch (err) {
+    throw err
+  }
+}
+
+export function toQueryString(data) {
+  let qs = ''
+  Object.keys(data).map((k) => {
+    qs += `&${k}=${data[k]}`
+  })
+  return qs.slice(1).replace(' ', '%20')
+}

package/test/common/bootstrap.ts

@@ -0,0 +1,33 @@
+const { start: startServer } = require('../../index')
+
+export const DEFAULT_ADMIN_EMAIL = 'admin@user.com'
+export const DEFAULT_ADMIN_PASSWORD = '71iD$k%3X#m4'
+export const COMPANY2_SUPERUSER_EMAIL = 'user@volcanicminds.ai'
+export const COMPANY2_SUPERUSER_PASSWORD = '44O$^yWqn@R4'
+
+let server: any
+
+export async function startUp() {
+  try {
+    global.log.level = 'warn'
+    server = await startServer()
+  } catch (err) {
+    console.log(err)
+    throw err
+  }
+}
+
+export async function tearDown() {
+  await server.close()
+  process.exit(0)
+}
+
+export function buildTasks() {
+  const taskToSkip = (process.env.MOCHA_SKIP_TASK || '').toLowerCase().split(',')
+
+  return {
+    demo: !taskToSkip.includes('demo'),
+    unit: !taskToSkip.includes('unit'),
+    e2e: !taskToSkip.includes('e2e')
+  }
+}

package/test/demo/demo.ts

@@ -0,0 +1,9 @@
+import { expect } from 'expect'
+
+module.exports = () => {
+  describe('A simple test', () => {
+    it('should log useless message', async () => {
+      expect(100).toBeGreaterThan(0)
+    })
+  })
+}