nickname.spec.ts raw

   1  import { Nickname, InvalidNicknameError } from './nickname';
   2  
   3  describe('Nickname Value Object', () => {
   4    describe('create', () => {
   5      it('should create a valid nickname', () => {
   6        const nickname = Nickname.create('Alice');
   7  
   8        expect(nickname.toString()).toEqual('Alice');
   9      });
  10  
  11      it('should trim whitespace from nickname', () => {
  12        const nickname = Nickname.create('  Bob  ');
  13  
  14        expect(nickname.toString()).toEqual('Bob');
  15      });
  16  
  17      it('should throw InvalidNicknameError for empty string', () => {
  18        expect(() => Nickname.create('')).toThrowError(InvalidNicknameError);
  19      });
  20  
  21      it('should throw InvalidNicknameError for whitespace-only string', () => {
  22        expect(() => Nickname.create('   ')).toThrowError(InvalidNicknameError);
  23      });
  24  
  25      it('should throw InvalidNicknameError for nickname exceeding 50 characters', () => {
  26        const longNickname = 'a'.repeat(51);
  27  
  28        expect(() => Nickname.create(longNickname)).toThrowError(InvalidNicknameError);
  29      });
  30  
  31      it('should allow nickname with exactly 50 characters', () => {
  32        const maxNickname = 'a'.repeat(50);
  33  
  34        expect(() => Nickname.create(maxNickname)).not.toThrow();
  35        expect(Nickname.create(maxNickname).toString()).toEqual(maxNickname);
  36      });
  37  
  38      it('should allow single character nickname', () => {
  39        const nickname = Nickname.create('X');
  40  
  41        expect(nickname.toString()).toEqual('X');
  42      });
  43    });
  44  
  45    describe('fromStorage', () => {
  46      it('should create nickname from storage without validation', () => {
  47        // This allows loading potentially invalid data from storage
  48        // without throwing during deserialization
  49        const nickname = Nickname.fromStorage('stored-nickname');
  50  
  51        expect(nickname.toString()).toEqual('stored-nickname');
  52      });
  53  
  54      it('should handle long nicknames from legacy storage', () => {
  55        const longLegacyNickname = 'a'.repeat(100);
  56        const nickname = Nickname.fromStorage(longLegacyNickname);
  57  
  58        expect(nickname.toString()).toEqual(longLegacyNickname);
  59      });
  60    });
  61  
  62    describe('equals', () => {
  63      it('should return true for equal nicknames', () => {
  64        const nick1 = Nickname.create('Alice');
  65        const nick2 = Nickname.create('Alice');
  66  
  67        expect(nick1.equals(nick2)).toBe(true);
  68      });
  69  
  70      it('should return false for different nicknames', () => {
  71        const nick1 = Nickname.create('Alice');
  72        const nick2 = Nickname.create('Bob');
  73  
  74        expect(nick1.equals(nick2)).toBe(false);
  75      });
  76  
  77      it('should be case-sensitive', () => {
  78        const nick1 = Nickname.create('alice');
  79        const nick2 = Nickname.create('Alice');
  80  
  81        expect(nick1.equals(nick2)).toBe(false);
  82      });
  83    });
  84  
  85    describe('InvalidNicknameError', () => {
  86      it('should be an instance of InvalidNicknameError', () => {
  87        try {
  88          Nickname.create('');
  89        } catch (e) {
  90          expect(e).toBeInstanceOf(InvalidNicknameError);
  91          expect((e as InvalidNicknameError).message).toContain('cannot be empty');
  92        }
  93      });
  94    });
  95  });
  96