Testing within routes

[joshmeads]

@arthurfiorette thanks for Kita! I want to give it a serious try in a production system as I'm looking at alternatives for NestJS. Given the team sized involved I want to maintain high code to test locality. I see in your create app you have a src and a test folder - is there any way we can have within routes a structure like this?

> routes/
  index.ts
  index.test.ts
  about.ts
  about.test.ts
  > posts/
    index.ts
    index.test.ts

Trying that out the box results in an error (hence this discussion). I was wondering if there is a built in way to ignore certain globs (test.ts, spec.ts, etc) or is that something you'd be open to adding? I'm happy to assist with a PR if you can give me a rough direction on what's needed as I haven't yet spent the time to go through the codebase.

Thanks!

[arthurfiorette]

hey @joshmeads. I did not create any spec for testing routes (yet). So there's no builtin support for testing it.

Would you like to help me design a new one? I could implement or fix any problems that might happen.

[joshmeads]

I'll take a closer look at the codebase and let you know! Cheers

[joshmeads]

At a high level how about something like this? Trying to keep it as little magic as possible and allowing it all to work with node:test, tap, jest, etc.

Only real work I believe would be:

1. Ignore all *.{spec,test}.ts routes in the main cli/runtime libs.
2. Create a load function which would essentially do what your existing testing setup suggested (load fastify, load the plugin, run fastify.inject as it knows the route + method, etc). We could then simply import { get } from "file" and pass that to it.

I'm making assumptions currently but I assume we could easily detect the method based on the export name. Followed by using its types like Query from the runtime to figure out type safety during the test.

In order to know the path though I'm assuming its going to need to be compiled first? Thoughts?

import assert from 'node:assert';
import test, { describe, beforeEach, afterEach } from 'node:test';
import { get, post } from './index';
import { load } from '@kitajs/test';
import fastify from 'fastify';
import { someOtherPlugin } from 'someOtherPluginPlace'; 

describe('Index Route', async () => {
  // Optionally pass in our own fastify instance for extra customization
  await using server = fastify();
  server.register(someOtherPlguin);

  beforeEach(async () => {
    // Do something here if needed.
  });

  test('POST /user', async () => {
    // This would do all of the injection work for you (fastify and plugin) - this time with a custom fastify instance
    await using route = load(post, fastify);

    const response = await route.exec({
      body: {
        name: 'Bob',
        favoriteShow: 'For All Mankind'
      }
    });

    const json = response.json();

    assert.strictEqual(response.statusCode, 201);
    assert.match(json.id, /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/);
    assert.equal(json.name, 'Bob');
    assert.equal(json.favoriteShow, 'For All Mankind');
  });

  test('GET /user', async () => {
    // This would do all of the injection work for you (fastify and plugin);
    await using route = load(get);

    const response = await route.exec({
      params: {
        // Infer the params this route could take from load(route)
        name: 'Bob'
      },
      // Shows a type error as it can infer this is a GET request
      body: {}
    });

    assert.strictEqual(response.statusCode, 200);
    assert.deepStrictEqual(response.json(), {
      name: 'Bob',
      greeting: 'Hi Bob!',
      favoriteShow: 'For All Mankind'
    });
  });

  afterEach(async () => {
    // Do something here if needed.
  });
});

Main benefits would be:

• No magic
• Type completion
• Knowing what you're testing exactly via import rather than some path

[joshmeads]

@arthurfiorette any thoughts?