Merge pull request #2 from mikro-orm/chore/add-ci-and-tests

chore: add CI workflow and vitest tests

Author: B4nan

.github/workflows/tests.yml

@@ -0,0 +1,34 @@
+name: tests
+
+on:
+  push:
+    branches: [master, main, renovate/**]
+  pull_request:
+    branches: [master, main]
+
+jobs:
+  test:
+    name: Tests
+    if: ${{ !contains(github.event.head_commit.message, '[skip ci]') }}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        node-version: [22, 24]
+    steps:
+      - name: Checkout Source code
+        uses: actions/checkout@v6
+
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v6
+        with:
+          node-version: ${{ matrix.node-version }}
+
+      - name: Install
+        run: npm ci
+
+      - name: Build
+        run: npm run build
+
+      - name: Test
+        run: npm test

.gitignore

@@ -42,3 +42,4 @@ yarn-error.log*
 next-env.d.ts
 
 sqlite.db
+.snapshot-sqlite.db.json

__tests__/actions.spec.ts

@@ -0,0 +1,58 @@
+import { MikroORM, RequestContext } from '@mikro-orm/sqlite';
+import { wrap } from '@mikro-orm/core';
+import { User, UserSchema, Social } from '@/lib/user.entity';
+import { ArticleSchema } from '@/lib/article.entity';
+import { ArticleListingSchema } from '@/lib/article-listing.entity';
+import { TagSchema } from '@/lib/tag.entity';
+import { CommentSchema } from '@/lib/comment.entity';
+
+let orm: MikroORM;
+
+beforeAll(async () => {
+  orm = new MikroORM({
+    dbName: ':memory:',
+    entities: [UserSchema, ArticleSchema, ArticleListingSchema, TagSchema, Social, CommentSchema],
+  });
+
+  await orm.schema.drop();
+  await orm.schema.create();
+});
+
+afterAll(async () => {
+  await orm.close(true);
+});
+
+describe('server action logic', () => {
+  test('create user and serialize', async () => {
+    // replicate what the createUser action does
+    await RequestContext.create(orm.em, async () => {
+      const em = orm.em;
+      const user = em.create(User, {
+        fullName: 'Action User',
+        email: 'action@example.com',
+        password: 'secret',
+      });
+      await em.flush();
+
+      const serialized = wrap(user).toObject();
+      expect(serialized).toHaveProperty('fullName', 'Action User');
+      expect(serialized).toHaveProperty('bio', '');
+      // email and password are hidden, should not appear in toObject
+      expect(serialized).not.toHaveProperty('email');
+      expect(serialized).not.toHaveProperty('password');
+    });
+  });
+
+  test('truncate users', async () => {
+    // first ensure we have a user
+    const em = orm.em.fork();
+    const count = await em.count(User);
+    expect(count).toBeGreaterThan(0);
+
+    // replicate what resetUsers does
+    await em.qb(User).truncate().execute();
+
+    const countAfter = await orm.em.fork().count(User);
+    expect(countAfter).toBe(0);
+  });
+});

__tests__/db.spec.ts

@@ -0,0 +1,205 @@
+import { MikroORM } from '@mikro-orm/sqlite';
+import { User, UserSchema, Social } from '@/lib/user.entity';
+import { Article, ArticleSchema } from '@/lib/article.entity';
+import { ArticleListingSchema } from '@/lib/article-listing.entity';
+import { TagSchema } from '@/lib/tag.entity';
+import { CommentSchema } from '@/lib/comment.entity';
+
+let orm: MikroORM;
+
+beforeAll(async () => {
+  orm = new MikroORM({
+    dbName: ':memory:',
+    entities: [UserSchema, ArticleSchema, ArticleListingSchema, TagSchema, Social, CommentSchema],
+  });
+
+  await orm.schema.drop();
+  await orm.schema.create();
+});
+
+afterAll(async () => {
+  await orm.close(true);
+});
+
+describe('User entity', () => {
+  test('create a user', async () => {
+    const em = orm.em.fork();
+    const user = em.create(User, {
+      fullName: 'John Doe',
+      email: 'john@example.com',
+      password: 'secret123',
+    });
+    await em.flush();
+
+    expect(user.id).toBeDefined();
+    expect(user.fullName).toBe('John Doe');
+    expect(user.bio).toBe('');
+    expect(user.createdAt).toBeInstanceOf(Date);
+    expect(user.updatedAt).toBeInstanceOf(Date);
+  });
+
+  test('password is hashed on create', async () => {
+    const em = orm.em.fork();
+    const user = await em.findOneOrFail(User, { email: 'john@example.com' }, { populate: ['password'] });
+    const password = await user.password.load();
+    // argon2 hashes start with $argon2
+    expect(password).toMatch(/^\$argon2/);
+  });
+
+  test('verify password', async () => {
+    const em = orm.em.fork();
+    const user = await em.findOneOrFail(User, { email: 'john@example.com' }, { populate: ['password'] });
+    expect(await user.verifyPassword('secret123')).toBe(true);
+    expect(await user.verifyPassword('wrongpassword')).toBe(false);
+  });
+
+  test('unique email constraint', async () => {
+    const em = orm.em.fork();
+    em.create(User, {
+      fullName: 'Jane Doe',
+      email: 'john@example.com', // duplicate
+      password: 'password',
+    });
+    await expect(em.flush()).rejects.toThrow();
+  });
+
+  test('user repository exists method', async () => {
+    const em = orm.em.fork();
+    const repo = em.getRepository(User);
+    expect(await repo.exists('john@example.com')).toBe(true);
+    expect(await repo.exists('nonexistent@example.com')).toBe(false);
+  });
+
+  test('user repository login method', async () => {
+    const em = orm.em.fork();
+    const repo = em.getRepository(User);
+    const user = await repo.login('john@example.com', 'secret123');
+    expect(user.fullName).toBe('John Doe');
+  });
+
+  test('user repository login with wrong password', async () => {
+    const em = orm.em.fork();
+    const repo = em.getRepository(User);
+    await expect(repo.login('john@example.com', 'wrong')).rejects.toThrow('Invalid combination of email and password');
+  });
+});
+
+describe('Article entity', () => {
+  test('create an article with author', async () => {
+    const em = orm.em.fork();
+    const author = await em.findOneOrFail(User, { email: 'john@example.com' });
+    const article = em.create(Article, {
+      author,
+      title: 'My First Article',
+      description: 'A test article',
+      text: 'Hello world content',
+    });
+    await em.flush();
+
+    expect(article.id).toBeDefined();
+    expect(article.slug).toBe('my-first-article');
+    expect(article.title).toBe('My First Article');
+    expect(article.description).toBe('A test article');
+    expect(article.author.id).toBe(author.id);
+  });
+
+  test('article slug is generated from title', async () => {
+    const em = orm.em.fork();
+    const author = await em.findOneOrFail(User, { email: 'john@example.com' });
+    const article = em.create(Article, {
+      author,
+      title: 'Hello World!!! Test & Check',
+      description: 'desc',
+      text: 'text',
+    });
+    await em.flush();
+
+    expect(article.slug).toBe('hello-world-test-check');
+  });
+
+  test('article text is lazy loaded', async () => {
+    const em = orm.em.fork();
+    const article = await em.findOneOrFail(Article, { slug: 'my-first-article' });
+    // text is a lazy Ref, not loaded by default
+    expect(article.text.isInitialized()).toBe(false);
+
+    const text = await article.text.load();
+    expect(text).toBe('Hello world content');
+  });
+});
+
+describe('Tag entity', () => {
+  test('create tags and assign to article', async () => {
+    const em = orm.em.fork();
+    const article = await em.findOneOrFail(Article, { slug: 'my-first-article' }, { populate: ['tags'] });
+
+    const tag1 = em.create(TagSchema, { name: 'typescript' });
+    const tag2 = em.create(TagSchema, { name: 'orm' });
+    article.tags.add(tag1, tag2);
+    await em.flush();
+
+    expect(tag1.id).toBeDefined();
+    expect(tag2.id).toBeDefined();
+    expect(article.tags).toHaveLength(2);
+  });
+
+  test('tags are persisted via many-to-many', async () => {
+    const em = orm.em.fork();
+    const article = await em.findOneOrFail(Article, { slug: 'my-first-article' }, { populate: ['tags'] });
+    expect(article.tags).toHaveLength(2);
+    const tagNames = article.tags.getItems().map(t => t.name);
+    expect(tagNames).toContain('typescript');
+    expect(tagNames).toContain('orm');
+  });
+});
+
+describe('Comment entity', () => {
+  test('create a comment on an article', async () => {
+    const em = orm.em.fork();
+    const author = await em.findOneOrFail(User, { email: 'john@example.com' });
+    const article = await em.findOneOrFail(Article, { slug: 'my-first-article' });
+
+    const comment = em.create(CommentSchema, {
+      text: 'Great article!',
+      article,
+      author,
+    });
+    await em.flush();
+
+    expect(comment.id).toBeDefined();
+    expect(comment.text).toBe('Great article!');
+  });
+
+  test('comments are eagerly loaded with article', async () => {
+    const em = orm.em.fork();
+    const article = await em.findOneOrFail(Article, { slug: 'my-first-article' });
+    // comments are defined as eager in ArticleSchema
+    expect(article.comments).toHaveLength(1);
+    expect(article.comments[0].text).toBe('Great article!');
+  });
+
+  test('orphan removal deletes comments when removed from collection', async () => {
+    const em = orm.em.fork();
+    const article = await em.findOneOrFail(Article, { slug: 'my-first-article' });
+    expect(article.comments).toHaveLength(1);
+
+    article.comments.removeAll();
+    await em.flush();
+
+    const comments = await em.fork().find(CommentSchema, { article });
+    expect(comments).toHaveLength(0);
+  });
+});
+
+describe('ArticleListing virtual entity', () => {
+  test('list articles via repository', async () => {
+    const em = orm.em.fork();
+    const repo = em.getRepository(Article);
+    const { items, total } = await repo.listArticles({});
+
+    expect(total).toBeGreaterThanOrEqual(1);
+    expect(items[0]).toHaveProperty('slug');
+    expect(items[0]).toHaveProperty('title');
+    expect(items[0]).toHaveProperty('authorName');
+  });
+});

lib/article.entity.ts

@@ -51,7 +51,7 @@ export const ArticleSchema = defineEntity({
     slug: p.string().unique(),
     title: p.string().index(),
     description: p.string().length(1000),
-    text: p.text().lazy(),
+    text: p.text().lazy().ref(),
     tags: () => p.manyToMany(TagSchema),
     author: () => p.manyToOne(User).ref(),
     comments: () => p.oneToMany(CommentSchema).mappedBy('article').eager().orphanRemoval(),

lib/user.entity.ts

@@ -69,7 +69,7 @@ export const UserSchema = defineEntity({
   properties: {
     fullName: p.string(),
     email: p.string().unique().hidden(),
-    password: p.string().hidden().lazy(),
+    password: p.string().hidden().lazy().ref(),
     bio: p.text().default(''),
     articles: () => p.oneToMany(Article).mappedBy('author').hidden(),
     token: p.string().nullable().persist(false),