velocious 1.0.23 → 1.0.25

package/README.md

@@ -32,13 +32,90 @@ npx velocious db:migrate
 # Models
 
 ```bash
-npx velocious g:model Option
+npx velocious g:model Task
+```
+
+# Migrations
+```bash
+npx velocious g:migration create-tasks
+```
+
+```js
+import Migration from "velocious/src/database/migration/index.js"
+
+export default class CreateEvents extends Migration {
+  async up() {
+    await this.createTable("tasks", (t) => {
+      t.timestamps()
+    })
+
+    await this.createTable("task_translations", (t) => {
+      t.references("task", {foreignKey: true, null: false})
+      t.string("locale", {null: false})
+      t.string("name")
+      t.timestamps()
+    })
+
+    await this.addIndex("task_translations", ["task_id", "locale"], {unique: true})
+  }
+
+  async down() {
+    await this.dropTable("task_translations")
+    await this.dropTable("tasks")
+  }
+}
+```
+
+# Querying
+
+```js
+import {Task} from "@/src/models/task"
+
+const tasks = await Task
+  .preload({project: {account: true}})
+  .where({projects: {public: true}})
+  .toArray()
 ```
 
 # Testing
 
+If you are using Velocious for an app, Velocious has a built-in testing framework. You can run your tests like this:
 ```bash
-npm test
+npx velocious test
+```
+
+If you are developing on Velocious, you can run the tests with:
+
+```bash
+npm run test
+```
+
+# Writing a require test
+
+First create a test file under something like the following path 'src/routes/accounts/create-test.js' with something like the following content:
+
+```js
+import {describe, expect, it} from "velocious/src/testing/test.js"
+import Account from "../../models/account.js"
+
+await describe("accounts - create", {type: "request"}, async () => {
+  it("creates an account", async ({client}) => {
+    const response = await client.post("/accounts", {account: {name: "My event company"}})
+
+    expect(response.statusCode()).toEqual(200)
+    expect(response.contentType()).toEqual("application/json")
+
+    const data = JSON.parse(response.body())
+
+    expect(data.status).toEqual("success")
+
+    const createdAccount = await Account.last()
+
+    expect(createdAccount).toHaveAttributes({
+      name: "My event company"
+    })
+  })
+})
 ```
 
 # Running a server

package/bin/velocious.js

@@ -3,7 +3,23 @@
 import Cli from "../src/cli/index.js"
 
 const processArgs = process.argv.slice(2)
-const cli = new Cli({processArgs})
+const parsedProcessArgs = {}
+
+for (let i = 0; i < processArgs.length; i++) {
+  const processArg = processArgs[i]
+  const singleLetterArgMatch = processArg.match(/^-([a-z])$/)
+  const multiLetterArgMatch = processArg.match(/^--([a-z]+)$/)
+
+  if (singleLetterArgMatch) {
+    parsedProcessArgs[singleLetterArgMatch[1]] = processArgs[i + 1]
+    i++
+  } else if (multiLetterArgMatch) {
+    parsedProcessArgs[multiLetterArgMatch[1]] = processArgs[i + 1]
+    i++
+  }
+}
+
+const cli = new Cli({parsedProcessArgs, processArgs})
 
 await cli.execute()
 

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.23",
+  "version": "1.0.25",
   "main": "index.js",
   "scripts": {
     "test": "jasmine",

package/spec/cli/commands/test/test-files-finder-spec.js

@@ -1,4 +1,4 @@
-import TestFilesFinder from "../../../../src/cli/commands/test/test-files-finder.js"
+import TestFilesFinder from "../../../../src/testing/test-files-finder.js"
 
 describe("Cli - Commands - test - TestFilesFinder", () => {
   it("finds the correct test files", async () => {

package/spec/http-server/get-spec.js

@@ -7,7 +7,20 @@ describe("HttpServer", () => {
       const response = await fetch("http://localhost:3006/tasks")
       const text = await response.text()
 
+      expect(response.status).toEqual(200)
+      expect(response.statusText).toEqual("OK")
       expect(text).toEqual("1, 2, 3, 4, 5\n")
     })
   })
+
+  it("returns a 404 error when a collection action isnt found", async () => {
+    await Dummy.run(async () => {
+      const response = await fetch("http://localhost:3006/tasks/doesnt-exist")
+      const text = await response.text()
+
+      expect(response.status).toEqual(404)
+      expect(response.statusText).toEqual("Not Found")
+      expect(text).toEqual("Not found!\n")
+    })
+  })
 })

package/src/application.js

@@ -43,6 +43,7 @@ export default class VelociousApplication {
     logger(this, `Starting server on port ${port}`)
 
     this.httpServer = new HttpServer({configuration, port})
+    this.httpServer.events.on("close", this.onHttpServerClose)
 
     await this.httpServer.start()
   }
@@ -52,4 +53,18 @@ export default class VelociousApplication {
 
     await this.httpServer.stop()
   }
+
+  onHttpServerClose = () => {
+    logger(this, "HTTP server closed")
+
+    if (this.waitResolve) {
+      this.waitResolve()
+    }
+  }
+
+  wait() {
+    return new Promise((resolve) => {
+      this.waitResolve = resolve
+    })
+  }
 }

package/src/cli/commands/server.js

@@ -5,14 +5,13 @@ export default class VelociousCliCommandsServer extends BaseCommand{
   async execute() {
     this.databasePool = this.configuration.getDatabasePool()
     this.newConfiguration = Object.assign({}, this.databasePool.getConfiguration())
-
-    if (this.args.testing) this.result = []
-
     this.databaseConnection = await this.databasePool.spawnConnectionWithConfiguration(this.newConfiguration)
+
     await this.databaseConnection.connect()
 
-    const host = "0.0.0.0"
-    const port = 3006
+    const {parsedProcessArgs} = this.args
+    const host = parsedProcessArgs.h || parsedProcessArgs.host || "127.0.0.1"
+    const port = parsedProcessArgs.p || parsedProcessArgs.port || 3006
     const application = new Application({
       configuration: this.configuration,
       httpServer: {
@@ -23,7 +22,7 @@ export default class VelociousCliCommandsServer extends BaseCommand{
 
     await application.initialize()
     await application.startHttpServer()
-
     console.log(`Started Velocious HTTP server on ${host}:${port}`)
+    await application.wait()
   }
 }

package/src/cli/commands/{test/index.js → test.js}

@@ -1,13 +1,12 @@
-import BaseCommand from "../../base-command.js"
-import TestFilesFinder from "./test-files-finder.js"
-import TestRunner from "./test-runner.js"
+import BaseCommand from "../base-command.js"
+import TestFilesFinder from "../../testing/test-files-finder.js"
+import TestRunner from "../../testing/test-runner.js"
 
 export default class VelociousCliCommandsInit extends BaseCommand {
   async execute() {
     const testFilesFinder = new TestFilesFinder({directory: this.directory(), processArgs: this.processArgs})
     const testFiles = await testFilesFinder.findTestFiles()
-
-    const testRunner = new TestRunner(testFiles)
+    const testRunner = new TestRunner({configuration: this.configuration, testFiles})
 
     await testRunner.run()
   }

package/src/controller.js

@@ -1,9 +1,16 @@
 import {digs} from "diggerize"
 import ejs from "ejs"
 import * as inflection from "inflection"
+import logger from "./logger.js"
 import restArgsError from "./utils/rest-args-error.js"
 
 export default class VelociousController {
+  static beforeAction(methodName) {
+    if (!this._beforeActions) this._beforeActions = []
+
+    this._beforeActions.push(methodName)
+  }
+
   constructor({action, configuration, controller, params, request, response, viewPath}) {
     if (!action) throw new Error("No action given")
     if (!configuration) throw new Error("No configuration given")
@@ -23,6 +30,36 @@ export default class VelociousController {
     this._viewPath = viewPath
   }
 
+  async _runBeforeCallbacks() {
+    await logger(this, "_runBeforeCallbacks")
+
+    let currentControllerClass = this.constructor
+
+    while (currentControllerClass) {
+      await logger(this, `Running callbacks for ${currentControllerClass.name}`)
+
+      const beforeActions = currentControllerClass._beforeActions
+
+      if (beforeActions) {
+        for (const beforeActionName of beforeActions) {
+          const beforeAction = currentControllerClass.prototype[beforeActionName]
+
+          if (!beforeAction) throw new Error(`No such before action: ${beforeActionName}`)
+
+          const boundBeforeAction = beforeAction.bind(this)
+
+          await boundBeforeAction()
+        }
+      }
+
+      currentControllerClass = Object.getPrototypeOf(currentControllerClass)
+
+      if (!currentControllerClass?.name?.endsWith("Controller")) break
+    }
+
+    await logger(this, "After runBeforeCallbacks")
+  }
+
   params = () => this._params
 
   render({json, status, ...restArgs} = {}) {

package/src/database/migrate-from-require-context.js

@@ -13,16 +13,27 @@ export default class VelociousDatabaseMigrateFromRequireContext {
 
     const files = requireContext.keys()
       .map((file) => {
-        const match = file.match(/(\d{14})-(.+)\.js$/)
+        // "13,14" because somes "require-context"-npm-module deletes first character!?
+        const match = file.match(/(\d{13,14})-(.+)\.js$/)
 
         if (!match) return null
 
-        const date = parseInt(match[1])
+        // Fix require-context-npm-module deletes first character
+        let fileName = file
+        let dateNumber = match[1]
+
+        if (dateNumber.length == 13) {
+          dateNumber = `2${dateNumber}`
+          fileName = `2${fileName}`
+        }
+
+        // Parse regex
+        const date = parseInt(dateNumber)
         const migrationName = match[2]
         const migrationClassName = inflection.camelize(migrationName.replaceAll("-", "_"))
 
         return {
-          file,
+          file: fileName,
           date,
           migrationClassName
         }

package/src/http-server/client/index.js

@@ -40,6 +40,7 @@ export default class VeoliciousHttpServerClient {
       this.currentRequest = new Request({
         configuration: this.configuration
       })
+
       this.currentRequest.requestParser.events.on("done", this.executeCurrentRequest)
       this.currentRequest.feed(data)
       this.state = "requestStarted"

package/src/http-server/client/request-buffer/index.js

@@ -152,12 +152,12 @@ export default class RequestBuffer {
 
       this.events.emit("header", header)
     } else if (line == "\r\n") {
-      if (this.httpMethod.toUpperCase() == "GET") {
+      if (this.httpMethod.toUpperCase() == "GET" || this.httpMethod.toUpperCase() == "OPTIONS") {
         this.completeRequest()
       } else if (this.httpMethod.toUpperCase() == "POST") {
         this.readingBody = true
 
-        const match = this.getHeader("content-type").value.match(/^multipart\/form-data;\s*boundary=(.+)$/i)
+        const match = this.getHeader("content-type")?.value?.match(/^multipart\/form-data;\s*boundary=(.+)$/i)
 
         if (match) {
           this.boundary = match[1]
@@ -176,7 +176,7 @@ export default class RequestBuffer {
   }
 
   parseStatusLine(line) {
-    const match = line.match(/^(GET|POST) (.+?) HTTP\/1\.1\r\n/)
+    const match = line.match(/^(GET|OPTIONS|POST) (.+?) HTTP\/1\.1\r\n/)
 
     if (!match) {
       throw new Error(`Couldn't match status line from: ${line}`)
@@ -185,6 +185,8 @@ export default class RequestBuffer {
     this.httpMethod = match[1]
     this.path = match[2]
     this.setState("headers")
+
+    logger(this, () => ["Parsed status line", {httpMethod: this.httpMethod, path: this.path}])
   }
 
   postRequestDone() {
@@ -194,7 +196,7 @@ export default class RequestBuffer {
   }
 
   setState(newState) {
-    logger(this, `Changing state from ${this.state} to ${newState}`)
+    logger(this, () => [`Changing state from ${this.state} to ${newState}`])
 
     this.state = newState
   }

package/src/http-server/client/request-parser.js

@@ -34,9 +34,46 @@ export default class VelociousHttpServerClientRequestParser {
   feed = (data) => this.requestBuffer.feed(data)
   getHeader = (name) => this.requestBuffer.getHeader(name)?.value
   getHttpMethod = () => digg(this, "requestBuffer", "httpMethod")
-  getHost = () => this.requestBuffer.getHeader("host")?.value
+
+  _getHostMatch = () => {
+    const rawHost = this.requestBuffer.getHeader("origin")?.value
+
+    if (!rawHost) return null
+
+    const match = rawHost.match(/^(.+):\/\/(.+)(|:(\d+))/)
+
+    if (!match) throw new Error(`Couldn't match host: ${rawHost}`)
+
+    return {
+      protocol: match[1],
+      host: match[2],
+      port: match[4]
+    }
+  }
+
+  getHost() {
+    const rawHostSplit = this.requestBuffer.getHeader("host")?.value?.split(":")
+
+    if (rawHostSplit && rawHostSplit[0]) return rawHostSplit[0]
+  }
+
   getPath = () => digg(this, "requestBuffer", "path")
 
+  getPort() {
+    const rawHostSplit = this.requestBuffer.getHeader("host")?.value?.split(":")
+    const httpMethod = this.getHttpMethod()
+
+    if (rawHostSplit && rawHostSplit[1]) {
+      return parseInt(rawHostSplit[1])
+    } else if (httpMethod == "http") {
+      return 80
+    } else if (httpMethod == "https") {
+      return 443
+    }
+  }
+
+  getProtocol = () => this._getHostMatch()?.protocol
+
   requestDone = () => {
     const incorporator = new Incorporator({objects: [this.params, this.requestBuffer.params]})
 

package/src/http-server/client/request-runner.js

@@ -19,17 +19,27 @@ export default class VelociousHttpServerClientRequestRunner {
   getState = () => this.state
 
   async run() {
-    if (!this.request) throw new Error("No request?")
+    const {configuration, request, response} = this
 
-    logger(this, "Run request")
+    if (!request) throw new Error("No request?")
 
-    const routesResolver = new RoutesResolver({
-      configuration: this.configuration,
-      request: this.request,
-      response: this.response
-    })
+    try {
+      if (request.httpMethod() == "OPTIONS" && request.header("sec-fetch-mode") == "cors") {
+        await logger(this, () => ["Run CORS", {httpMethod: request.httpMethod(), secFetchMode: request.header("sec-fetch-mode")}])
+        await configuration.cors({request, response})
+      } else {
+        await logger(this, "Run request")
+        const routesResolver = new RoutesResolver({configuration, request, response})
+
+        await routesResolver.resolve()
+      }
+    } catch (error) {
+      await logger(this, `Error while running request: ${error.message}`)
+
+      response.setStatus(500)
+      response.setErrorBody(error)
+    }
 
-    await routesResolver.resolve()
     this.state = "done"
     this.events.emit("done", this)
   }

package/src/http-server/client/request.js

@@ -7,9 +7,31 @@ export default class VelociousHttpServerClientRequest {
     this.requestParser = new RequestParser({configuration})
   }
 
+  baseURL = () => `${this.protocol()}://${this.hostWithPort()}`
   feed = (data) => this.requestParser.feed(data)
+  header = (headerName) => this.requestParser.requestBuffer.getHeader(headerName)?.value
   httpMethod = () => this.requestParser.getHttpMethod()
   host = () => this.requestParser.getHost()
+
+  hostWithPort = () => {
+    const port = this.port()
+    const protocol = this.protocol()
+    let hostWithPort = `${this.host()}`
+
+    if (port == 80 && protocol == "http") {
+      // Do nothing
+    } else if (port == 443 && protocol == "https") {
+      // Do nothing
+    } else if (port) {
+      hostWithPort += `:${port}`
+    }
+
+    return hostWithPort
+  }
+
+  origin = () => this.header("origin")
   path = () => this.requestParser.getPath()
   params = () => digg(this, "requestParser", "params")
+  port = () => this.requestParser.getPort()
+  protocol = () => this.requestParser.getProtocol()
 }

package/src/http-server/client/response.js

@@ -15,7 +15,7 @@ export default class VelociousHttpServerClientResponse {
   }
 
   getBody() {
-    if (this.body) {
+    if (this.body !== undefined) {
       return this.body
     }
 
@@ -34,10 +34,21 @@ export default class VelociousHttpServerClientResponse {
     this.body = value
   }
 
+  setErrorBody(error) {
+    this.body = `${error.message}\n\n${error.stack}`
+    this.addHeader("Content-Type", "text/plain")
+  }
+
   setStatus(status) {
-    if (status == "not-found" || status == 404) {
+    if (status == "success" || status == 200) {
+      this.statusCode = 200
+      this.statusMessage = "OK"
+    } else if (status == "not-found" || status == 404) {
       this.statusCode = 404
       this.statusMessage = "Not Found"
+    } else if (status == "internal-server-error" || status == 500) {
+      this.statusCode = 500
+      this.statusMessage = "Internal server error"
     } else {
       throw new Error(`Unhandled status: ${status}`)
     }

package/src/http-server/index.js

@@ -1,4 +1,5 @@
 import {digg} from "diggerize"
+import EventEmitter from "events"
 import logger from "../logger.js"
 import Net from "net"
 import ServerClient from "./server-client.js"
@@ -7,6 +8,7 @@ import WorkerHandler from "./worker-handler/index.js"
 export default class VelociousHttpServer {
   clientCount = 0
   clients = {}
+  events = new EventEmitter()
   workerCount = 0
   workerHandlers = []
 
@@ -20,6 +22,7 @@ export default class VelociousHttpServer {
   async start() {
     await this._ensureAtLeastOneWorker()
     this.netServer = new Net.Server()
+    this.netServer.on("close", this.onClose)
     this.netServer.on("connection", this.onConnection)
     await this._netServerListen()
   }
@@ -72,6 +75,10 @@ export default class VelociousHttpServer {
     await this.stopServer()
   }
 
+  onClose = () => {
+    this.events.emit("close")
+  }
+
   onConnection = (socket) => {
     const clientCount = this.clientCount
 

package/src/http-server/server-client.js

@@ -25,7 +25,7 @@ export default class ServerClient {
   }
 
   onSocketData = (chunk) => {
-    logger(this, `Socket ${this.clientCount}: ${chunk}`)
+    logger(this, () => [`Socket ${this.clientCount}: ${chunk}`])
 
     this.worker.postMessage({
       command: "clientWrite",

package/src/http-server/worker-handler/index.js

@@ -54,6 +54,8 @@ export default class VelociousHttpServerWorker {
   onWorkerExit = (code) => {
     if (code !== 0) {
       throw new Error(`Client worker stopped with exit code ${code}`)
+    } else {
+      logger(this, () => [`Client worker stopped with exit code ${code}`])
     }
   }
 
@@ -66,12 +68,10 @@ export default class VelociousHttpServerWorker {
       this.onStartCallback()
       this.onStartCallback = null
     } else if (command == "clientOutput") {
-      logger(this, "CLIENT OUTPUT", data)
+      logger(this, () => ["CLIENT OUTPUT", data])
 
       const {clientCount, output} = digs(data, "clientCount", "output")
 
-      logger(this, "CLIENT OUTPUT", data)
-
       this.clients[clientCount].send(output)
     } else {
       throw new Error(`Unknown command: ${command}`)

package/src/http-server/worker-handler/worker-thread.js

@@ -38,10 +38,10 @@ export default class VelociousHttpServerWorkerHandlerWorkerThread {
     }
   }
 
-  onCommand = (data) => {
-    logger(this, `Worker ${this.workerCount} received command`, data)
+  onCommand = async (data) => {
+    await logger(this, () => [`Worker ${this.workerCount} received command`, data])
 
-    const {command} = data
+    const command = data.command
 
     if (command == "newClient") {
       const {clientCount} = digs(data, "clientCount")
@@ -56,9 +56,13 @@ export default class VelociousHttpServerWorkerHandlerWorkerThread {
 
       this.clients[clientCount] = client
     } else if (command == "clientWrite") {
+      await logger(this, "Looking up client")
+
       const {chunk, clientCount} = digs(data, "chunk", "clientCount")
       const client = digg(this.clients, clientCount)
 
+      await logger(this, `Sending to client ${clientCount}`)
+
       client.onWrite(chunk)
     } else {
       throw new Error(`Unknown command: ${command}`)

package/src/logger.js

@@ -1,15 +1,51 @@
-import {digg} from "diggerize"
+import Configuration from "./configuration.js"
 
-export default function log(object, ...messages) {
-  if (!object.configuration) console.error(`No configuration on ${object.constructor.name}`)
+function consoleLog(message) {
+  return new Promise((resolve) => {
+    process.stdout.write(message, "utf8", resolve)
+  })
+}
 
-  if (object.configuration?.debug) {
-    if (!object.constructor.name) {
-      throw new Error(`No constructor name for object`)
-    }
+export default async function log(object, ...messages) {
+  let configuration
+
+  if (object.configuration) {
+    configuration = object.configuration
+  } else {
+    configuration = Configuration.current()
+  }
+
+  if (configuration?.debug) {
+    try {
+      if (!object.constructor.name) {
+        throw new Error(`No constructor name for object`)
+      }
+
+      const className = object.constructor.name
 
-    const className = object.constructor.name
+      if (messages.length === 1 && typeof messages[0] == "function") {
+        messages = messages[0]()
+      }
 
-    console.log(className, ...messages)
+      let message = ""
+
+      for (const messagePartIndex in messages) {
+        const messagePart = messages[messagePartIndex]
+
+        if (messagePartIndex > 0) {
+          message += " "
+        }
+
+        if (typeof messagePart == "object") {
+          message += JSON.stringify(messagePart)
+        } else {
+          message += messagePart
+        }
+      }
+
+      await consoleLog(`${className} ${message}\n`)
+    } catch (error) {
+      console.error(`ERROR ${error.message}`)
+    }
   }
 }

package/src/routes/get-route.js

@@ -10,7 +10,7 @@ export default class VelociousRouteGetRoute extends BaseRoute {
     this.regExp = new RegExp(`^(${escapeStringRegexp(name)})(.*)$`)
   }
 
-  matchWithPath(path) {
+  matchWithPath({path}) {
     if (path.match(this.regExp)) {
       const [_beginnigSlash, _matchedName, restPath] = match
 

package/src/routes/resolver.js

@@ -57,6 +57,7 @@ export default class VelociousRoutesResolver {
     }
 
     await this.configuration.getDatabasePool().withConnection(async () => {
+      await controllerInstance._runBeforeCallbacks()
       await controllerInstance[action]()
     })
   }

package/src/routes/resource-route.js

@@ -20,7 +20,7 @@ export default class VelociousRouteResourceRoute extends BaseRoute {
       let subRoutesMatchesRestPath = false
 
       for (const route of this.routes) {
-        if (route.matchWithPath(restPath)) {
+        if (route.matchWithPath({path: restPath})) {
           subRoutesMatchesRestPath = true
         }
       }

package/src/testing/request-client.js

@@ -0,0 +1,42 @@
+class Response {
+  constructor(fetchResponse) {
+    this.fetchResponse = fetchResponse
+  }
+
+  async parse() {
+    this._body = await this.fetchResponse.text()
+  }
+
+  body = () => this._body
+  contentType = () => this.fetchResponse.headers.get("content-type")
+  statusCode = () => this.fetchResponse.status
+}
+
+export default class RequestClient {
+  host = "localhost"
+  port = 31006
+
+  get() {
+    throw new Error("get stub")
+  }
+
+  async post(path, data) {
+    const fetchResponse = await fetch(
+      `http://${this.host}:${this.port}${path}`,
+      {
+        body: JSON.stringify(data),
+        headers: {
+          "Content-Type": "application/json"
+        },
+        method: "POST",
+        signal: AbortSignal.timeout(5000)
+      }
+    )
+
+    const response = new Response(fetchResponse)
+
+    await response.parse()
+
+    return response
+  }
+}

package/src/{cli/commands/test → testing}/test-files-finder.js

@@ -90,7 +90,7 @@ export default class TestFilesFinder {
           return true
         }
       }
-    } else if (file.match(/-spec\.js/)) {
+    } else if (file.match(/-(spec|test)\.js/)) {
       return true
     }
 

package/src/testing/test-runner.js

@@ -0,0 +1,85 @@
+import Application from "../../src/application.js"
+import RequestClient from "./request-client.js"
+import {tests} from "./test.js"
+
+export default class TestRunner {
+  constructor({configuration, testFiles}) {
+    this.configuration = configuration
+    this.testFiles = testFiles
+  }
+
+  async application() {
+    if (!this._application) {
+      this._application = new Application({
+        configuration: this.configuration,
+        databases: {
+          default: {
+            host: "mysql",
+            username: "user",
+            password: ""
+          }
+        },
+        httpServer: {port: 31006}
+      })
+
+      await this._application.initialize()
+      await this._application.startHttpServer()
+    }
+
+    return this._application
+  }
+
+  async requestClient() {
+    if (!this._requestClient) {
+      this._requestClient = new RequestClient()
+    }
+
+    return this._requestClient
+  }
+
+  async importTestFiles() {
+    for (const testFile of this.testFiles) {
+      const importTestFile = await import(testFile)
+    }
+  }
+
+  async run() {
+    await this.importTestFiles()
+    await this.runTests(tests, [], 0)
+  }
+
+  async runTests(tests, descriptions, indentLevel) {
+    const leftPadding = " ".repeat(indentLevel * 2)
+
+    for (const testDescription in tests.tests) {
+      const testData = tests.tests[testDescription]
+      const testArgs = Object.assign({}, testData.args)
+      const testName = descriptions.concat([`it ${testDescription}`]).join(" - ")
+
+      if (testArgs.type == "request") {
+        testArgs.application = await this.application()
+        testArgs.client = await this.requestClient()
+      }
+
+      console.log(`${leftPadding}it ${testDescription}`)
+
+      try {
+        await testData.function(testArgs)
+      } catch (error) {
+        // console.error(`${leftPadding}  Test failed: ${error.message}`)
+        console.error(error.stack)
+      }
+    }
+
+    await this.configuration.getDatabasePool().withConnection(async () => {
+      for (const subDescription in tests.subs) {
+        const subTest = tests.subs[subDescription]
+        const newDecriptions = descriptions.concat([subDescription])
+
+        console.log(`${leftPadding}${subDescription}`)
+
+        await this.runTests(subTest, newDecriptions, indentLevel + 1)
+      }
+    })
+  }
+}

package/src/testing/test.js

@@ -0,0 +1,92 @@
+const tests = {
+  args: {},
+  subs: {},
+  tests: {}
+}
+
+let currentPath = [tests]
+
+class Expect {
+  constructor(object) {
+    this._object = object
+  }
+
+  toEqual(result) {
+    if (this._object != result) {
+      throw new Error(`${this._object} wasn't equal to ${result}`)
+    }
+  }
+
+  toHaveAttributes(result) {
+    const differences = {}
+
+    for (const key in result) {
+      const value = result[key]
+      const objectValue = this._object[key]()
+
+      if (value != objectValue) {
+        differences[key] = [value, objectValue]
+      }
+    }
+
+    if (Object.keys(differences).length > 0)
+    throw new Error(`Object had differet values: ${JSON.stringify(differences)}`)
+  }
+}
+
+async function describe(description, arg1, arg2) {
+  let testArgs, testFunction
+
+  if (typeof arg2 == "function") {
+    testFunction = arg2
+    testArgs = arg1
+  } else if (typeof arg1 == "function") {
+    testFunction = arg1
+    testArgs = {}
+  } else {
+    throw new Error(`Invalid arguments for describe: ${arg1}, ${arg2}`)
+  }
+
+  const currentTest = currentPath[currentPath.length - 1]
+  const newTestArgs = Object.assign({}, currentTest.args, testArgs)
+
+  if (description in currentTest.subs) {
+    throw new Error(`Duplicate test description: ${description}`)
+  }
+
+  const newTestData = {args: newTestArgs, subs: {}, tests: {}}
+
+  currentTest.subs[description] = newTestData
+  currentPath.push(newTestData)
+
+  try {
+    await testFunction()
+  } finally {
+    currentPath.pop()
+  }
+}
+
+function expect(arg) {
+  return new Expect(arg)
+}
+
+function it(description, arg1, arg2) {
+  const currentTest = currentPath[currentPath.length - 1]
+  let testArgs, testFunction
+
+  if (typeof arg1 == "function") {
+    testFunction = arg1
+    testArgs = {}
+  } else if (typeof arg2 == "function") {
+    testFunction = arg2
+    testArgs = arg1
+  } else {
+    throw new Error(`Invalid arguments for it: ${description}, ${arg1}`)
+  }
+
+  const newTestArgs = Object.assign({}, currentTest.args, testArgs)
+
+  currentTest.tests[description] = {args: newTestArgs, function: testFunction}
+}
+
+export {describe, expect, it, tests}

package/src/cli/commands/test/test-runner.js

@@ -1,19 +0,0 @@
-export default class TestRunner {
-  constructor(testFiles) {
-    this.testFiles = testFiles
-  }
-
-  async importTestFiles() {
-    for (const testFile of this.testFiles) {
-      const importTestFile = await import(testFile)
-    }
-  }
-
-  async run() {
-    await this.importTestFiles()
-
-    console.log({foundTestFiles: this.testFiles})
-
-    throw new Error("stub")
-  }
-}