Add GPT-slop unit tests :)

Author: hhvrc

src/lib/inputvalidation/emailValidator.test.ts

@@ -1,29 +1,130 @@
-import { describe, expect, it } from 'vitest';
-import { validateEmail } from './emailValidator';
-
-describe('email validator test', () => {
-  it('empty email should return null', () => {
-    const result = validateEmail('');
-    expect(result).toEqual(null);
-  });
-  it('invalid email should return false and error', () => {
-    const result = validateEmail('invalid');
-    expect(result).toEqual({
-      valid: false,
-      message: 'Invalid email',
-    });
-  });
-  it('email with alias should return false and error', () => {
-    const result = validateEmail('john+actual.address@email.com');
-    expect(result).toEqual({
-      valid: false,
-      message: 'Email cannot contain aliases',
-    });
-  });
-  it('valid email should return true and no error', () => {
-    const result = validateEmail('valid.address@email.com');
-    expect(result).toEqual({
-      valid: true,
-    });
-  });
-});
+import { describe, it, expect } from 'vitest'
+import { isEmailAddress, validateEmail } from './emailValidator'
+
+describe('isEmailAddress', () => {
+  it('returns false for empty string', () => {
+    expect(isEmailAddress('')).toBe(false)
+  })
+
+  it('returns false when missing "@" or has multiple "@"', () => {
+    expect(isEmailAddress('plainaddress')).toBe(false)
+    expect(isEmailAddress('a@b@c.com')).toBe(false)
+  })
+
+  it('returns false when total length exceeds 320 characters', () => {
+    const localPart = 'a'.repeat(64)
+    const domainLabel = 'b'.repeat(63)
+    const domain = Array(5).fill(domainLabel).join('.') // 5×63 + 4 dots = 319
+    const validEmail = `${localPart}@${domain}`          // 384 chars total
+    expect(validEmail.length).toBe(64 + 1 + 319)
+    expect(isEmailAddress(validEmail)).toBe(false)
+  })
+
+  it('returns false when local part exceeds 64 characters', () => {
+    const account = 'x'.repeat(65)
+    const address = 'domain.com'
+    expect(isEmailAddress(`${account}@${address}`)).toBe(false)
+  })
+
+  it('returns false when domain part exceeds 255 characters', () => {
+    const account = 'user'
+    const longLabel = 'd'.repeat(63)
+    // 4 labels of 63 chars + 3 dots = 4*63 + 3 = 255
+    const domain = Array(4).fill(longLabel).join('.')
+    expect(domain.length).toBe(255)
+    // Prepend one character to push domain over 255
+    const tooLongDomain = 'e' + domain
+    expect(isEmailAddress(`${account}@${tooLongDomain}`)).toBe(false)
+  })
+
+  it('returns false when any domain label exceeds 63 characters', () => {
+    const account = 'user'
+    const longLabel = 'd'.repeat(64)
+    const address = `${longLabel}.com`
+    expect(isEmailAddress(`${account}@${address}`)).toBe(false)
+  })
+
+  it('returns false for invalid characters or formats not matching regex', () => {
+    // starts with a dot
+    expect(isEmailAddress('.user@domain.com')).toBe(false)
+    // consecutive dots in local part
+    expect(isEmailAddress('user..name@domain.com')).toBe(false)
+    // hyphen at start of domain label
+    expect(isEmailAddress('user@-domain.com')).toBe(false)
+    // no TLD
+    expect(isEmailAddress('user@domain')).toBe(false)
+  })
+
+  it('returns true for valid standard email addresses', () => {
+    expect(isEmailAddress('simple@example.com')).toBe(true)
+    expect(isEmailAddress('very.common@example.co.uk')).toBe(true)
+    expect(isEmailAddress("o'reilly@example.io")).toBe(true)
+    expect(isEmailAddress('user_name-123@sub.domain.com')).toBe(true)
+  })
+})
+
+describe('validateEmail', () => {
+  it('returns null for empty input', () => {
+    const result = validateEmail('')
+    expect(result).toBeNull()
+  })
+
+  it('returns valid: false and message "Invalid email" for syntactically invalid addresses', () => {
+    const invalids = [
+      'noatsign.com',
+      'user@.com',
+      'user@domain..com',
+      'user@domain',
+      'toolong' + 'a'.repeat(320) + '@example.com',
+    ]
+    for (const addr of invalids) {
+      const result = validateEmail(addr)
+      expect(result).not.toBeNull()
+      expect(result?.valid).toBe(false)
+      expect(result?.message).toBe('Invalid email')
+    }
+  })
+
+  it('returns valid: false and message "Email cannot contain aliases" when email contains "+"', () => {
+    const withAlias = 'user+alias@example.com'
+    const result = validateEmail(withAlias)
+    expect(result).not.toBeNull()
+    expect(result?.valid).toBe(false)
+    expect(result?.message).toBe('Email cannot contain aliases')
+  })
+
+  it('returns valid: true for valid email without "+"', () => {
+    const valid = 'firstname.lastname@domain.com'
+    const result = validateEmail(valid)
+    expect(result).not.toBeNull()
+    expect(result?.valid).toBe(true)
+    expect(result).not.toHaveProperty('message')
+  })
+
+  it('treats "+" anywhere in the local part as invalid alias', () => {
+    const examples = [
+      'plus+sign@domain.com',
+      '+start@domain.com',
+      'end+@domain.com',
+      'middle+more@sub.domain.org',
+    ]
+    for (const addr of examples) {
+      const result = validateEmail(addr)
+      expect(result).not.toBeNull()
+      expect(result?.valid).toBe(false)
+      expect(result?.message).toBe('Email cannot contain aliases')
+    }
+  })
+
+  it('does not reject valid emails with hyphens in domain or underscores in local part', () => {
+    const examples = [
+      'user_name@example-domain.com', // underscore in local, hyphen in domain
+      'another.user-name@sub.domain.com', // hyphen in both portions
+    ]
+    for (const addr of examples) {
+      const result = validateEmail(addr)
+      expect(result).not.toBeNull()
+      expect(result?.valid).toBe(true)
+    }
+  })
+})

src/lib/inputvalidation/passwordValidator.test.ts

@@ -1,57 +1,135 @@
-import { describe, expect, it } from 'vitest';
-import { validatePassword, validatePasswordMatch } from './passwordValidator';
-
-describe('email validator test', () => {
-  it('empty password should return null', () => {
-    const result = validatePassword('');
-    expect(result).toEqual(null);
-  });
-  it('password with less than 12 characters should return false and error', () => {
-    const result = validatePassword('obfuscation');
-    expect(result).toEqual({
-      valid: false,
-      message: 'Password is too short',
-    });
-  });
-  it('password with length more than 256 characters should return false and error', () => {
-    const result = validatePassword('a'.repeat(257));
-    expect(result).toEqual({
-      valid: false,
-      message: `Seriously? 257 characters? That's too much`,
-    });
-  });
-  it('password with only whitespaces should return false and error', () => {
-    const result = validatePassword(' \r \n  \t  \r \n  ');
-    expect(result).toEqual({
-      valid: false,
-      message: 'Password cannot consist of only whitespaces',
-    });
-  });
-  it('password starting with whitespace should return false and error', () => {
-    const result = validatePassword(' myinsecurepassword123');
-    expect(result).toEqual({
-      valid: false,
-      message: 'Password cannot start or end with whitespace',
-    });
-  });
-  it('password ending with whitespace should return false and error', () => {
-    const result = validatePassword('myinsecurepassword123 ');
-    expect(result).toEqual({
-      valid: false,
-      message: 'Password cannot start or end with whitespace',
-    });
-  });
-  it('password match with different password should return false and error', () => {
-    const result = validatePasswordMatch('password', 'differentpassword');
-    expect(result).toEqual({
-      valid: false,
-      message: 'Passwords do not match',
-    });
-  });
-  it('password match with invalid password should return false and error', () => {
-    const result = validatePasswordMatch('password', 'password');
-    expect(result).toEqual({
-      valid: true,
-    });
-  });
-});
+import { describe, it, expect } from 'vitest'
+import {
+  validatePassword,
+  validatePasswordMatch,
+  getPasswordStrength,
+} from './passwordValidator'
+
+describe('validatePassword', () => {
+  it('returns null for empty password', () => {
+    const result = validatePassword('')
+    expect(result).toBeNull()
+  })
+
+  it('rejects passwords shorter than 12 characters', () => {
+    const result = validatePassword('shortPwd1!')
+    expect(result).not.toBeNull()
+    expect(result?.valid).toBe(false)
+    expect(result?.message).toBe('Password is too short')
+  })
+
+  it('rejects passwords longer than 256 characters', () => {
+    const longPwd = 'a'.repeat(257)
+    const result = validatePassword(longPwd)
+    expect(result).not.toBeNull()
+    expect(result?.valid).toBe(false)
+    expect(result?.message).toBe(`Seriously? ${longPwd.length} characters? That's too much`)
+  })
+
+  it('rejects passwords consisting only of whitespaces', () => {
+    const spaces = ' \r \n  \t  \r \n  '
+    const result = validatePassword(spaces)
+    expect(result).not.toBeNull()
+    expect(result?.valid).toBe(false)
+    expect(result?.message).toBe('Password cannot consist of only whitespaces')
+  })
+
+  it('rejects passwords that start or end with whitespace', () => {
+    const leading = ' validPassword123'
+    const trailing = 'validPassword123 '
+    const both = ' validPassword123 '
+    for (const pwd of [leading, trailing, both]) {
+      const result = validatePassword(pwd)
+      expect(result).not.toBeNull()
+      expect(result?.valid).toBe(false)
+      expect(result?.message).toBe('Password cannot start or end with whitespace')
+    }
+  })
+
+  it('accepts valid passwords of acceptable length and no leading/trailing whitespace', () => {
+    const valid = 'ValidPassword123'
+    const result = validatePassword(valid)
+    expect(result).not.toBeNull()
+    expect(result?.valid).toBe(true)
+    expect(result).not.toHaveProperty('message')
+  })
+})
+
+describe('validatePasswordMatch', () => {
+  it('returns null when original password is empty', () => {
+    const result = validatePasswordMatch('', 'anything')
+    expect(result).toBeNull()
+  })
+
+  it('rejects non-matching passwords', () => {
+    const result = validatePasswordMatch('password123', 'password124')
+    expect(result).not.toBeNull()
+    expect(result?.valid).toBe(false)
+    expect(result?.message).toBe('Passwords do not match')
+  })
+
+  it('accepts matching passwords', () => {
+    const result = validatePasswordMatch('password123', 'password123')
+    expect(result).not.toBeNull()
+    expect(result?.valid).toBe(true)
+    expect(result).not.toHaveProperty('message')
+  })
+})
+
+describe('getPasswordStrength', () => {
+  it('returns None/gray-500/0% for empty string', () => {
+    const { percent, text, color } = getPasswordStrength('')
+    expect(percent).toBe(0)
+    expect(text).toBe('None')
+    expect(color).toBe('gray-500')
+  })
+
+  it('rates a repeated single-character password as Very weak (red-500)', () => {
+    // "aaaaaaaaaaaa" (12×'a'): uniqueLength=1 ⇒ entropy=0 ⇒ percent=0 ⇒ <30
+    const pwd = 'a'.repeat(12)
+    const { percent, text, color } = getPasswordStrength(pwd)
+    expect(percent).toBe(0)
+    expect(text).toBe('Very weak')
+    expect(color).toBe('red-500')
+  })
+
+  it('rates a moderately varied 12-character password as Weak (orange-500)', () => {
+    // "abcABC123!@#": length=12, uniqueLength=12 ⇒ entropy≈43 ⇒ percent≈35.8 ⇒ <50
+    const pwd = 'abcABC123!@#'
+    const { percent, text, color } = getPasswordStrength(pwd)
+    expect(percent).toBeGreaterThanOrEqual(30)
+    expect(percent).toBeLessThan(50)
+    expect(text).toBe('Weak')
+    expect(color).toBe('orange-500')
+  })
+
+  it('rates a 60-character password with two unique chars as Fair (yellow-500)', () => {
+    // 60×(two-character alphabet) ⇒ entropy=60*1=60 ⇒ percent=50 ⇒ <60
+    const pwd = 'ab'.repeat(30)
+    const { percent, text, color } = getPasswordStrength(pwd)
+    expect(percent).toBeCloseTo(50, 1)
+    expect(text).toBe('Fair')
+    expect(color).toBe('yellow-500')
+  })
+
+  it('rates a 72-character password with two unique chars as Strong (green-500)', () => {
+    // 72×(two-character alphabet) ⇒ entropy=72 ⇒ percent=60 ⇒ <99
+    const pwd = 'ab'.repeat(36)
+    const { percent, text, color } = getPasswordStrength(pwd)
+    expect(percent).toBeCloseTo(60, 1)
+    expect(text).toBe('Strong')
+    expect(color).toBe('green-500')
+  })
+
+  it('caps strength at 100% and rates as Very strong (cyan-500) for high entropy', () => {
+    // 100 random characters
+    const randomBytes = new Uint8Array(100)
+    crypto.getRandomValues(randomBytes)
+    const pwd = Array.from(randomBytes, b => String.fromCharCode(b % 94 + 33)).join('')
+
+    const { percent, text, color } = getPasswordStrength(pwd)
+    expect(percent).toBe(100)
+    expect(text).toBe('Very strong')
+    expect(color).toBe('cyan-500')
+  })
+})