import t from "tap";
import { expect } from "chai";
import { z } from "zod";
import {
ALLOWED_INPUT_REGEX,
DOMAIN_FRIENDLY_INPUT_REGEX,
NAME_REGEX,
NICKNAME_REGEX,
GITHUB_USERNAME_REGEX,
DISCORD_TAG_REGEX,
URL_DETECTION_REGEX,
MAX_LENGTH_STANDARD,
MAX_LENGTH_EXTENDED,
} from "../src/lib/validation-helpers";
t.test("Validation Helpers - Regex Tests", async () => {
t.test("ALLOWED_INPUT_REGEX", async (t) => {
t.test("should allow valid inputs", async () => {
const validInputs = [
"Hello World",
"Test 123",
"O'Brien",
"Name-With-Dashes",
"Name_With_Underscores",
"Name (with parentheses)",
"Name+Plus",
"L'Hôpital",
"Café",
"Zürich",
"",
];
for (const input of validInputs) {
expect(ALLOWED_INPUT_REGEX.test(input)).to.be.true;
}
});
t.test("should reject inputs with dots (domain names)", async () => {
const invalidInputs = [
"example.com",
"my.domain",
"user@email.com",
"https://example.com",
"http://test.com",
"/path/to/file",
];
for (const input of invalidInputs) {
expect(ALLOWED_INPUT_REGEX.test(input)).to.be.false;
}
});
});
t.test("DOMAIN_FRIENDLY_INPUT_REGEX", async (t) => {
t.test("should allow valid inputs including domain names", async () => {
const validInputs = [
"Hello World",
"Test 123",
"O'Brien",
"Name-With-Dashes",
"Name_With_Underscores",
"Name (with parentheses)",
"Name+Plus",
"L'Hôpital",
"Café",
"Zürich",
// Domain names (NEW - these should now be allowed)
"example.com",
"my.domain",
"subdomain.example.com",
"test-site.io",
"My Workspace (example.com)",
"Production - api.company.com",
"",
];
for (const input of validInputs) {
expect(DOMAIN_FRIENDLY_INPUT_REGEX.test(input)).to.be.true;
}
});
t.test("should reject inputs with URL schemes and @ symbols", async () => {
const invalidInputs = [
"user@email.com",
"https://example.com",
"http://test.com",
"/path/to/file",
"ftp://server.com",
"mailto:user@example.com",
];
for (const input of invalidInputs) {
expect(DOMAIN_FRIENDLY_INPUT_REGEX.test(input)).to.be.false;
}
});
});
t.test("NAME_REGEX", async (t) => {
t.test("should allow valid names", async () => {
const validNames = [
"John Doe",
"O'Brien",
"Mary-Jane",
"José",
"François",
"Müller",
"",
];
for (const name of validNames) {
expect(NAME_REGEX.test(name)).to.be.true;
}
});
t.test(
"should reject names with special characters or domain-like patterns",
async () => {
const invalidNames = [
"john.doe",
"user@example",
"name_with_underscore",
"name+plus",
"example.com",
"(parentheses)",
];
for (const name of invalidNames) {
expect(NAME_REGEX.test(name)).to.be.false;
}
},
);
});
t.test("NICKNAME_REGEX", async (t) => {
t.test(
"should allow valid nicknames with extended character set",
async () => {
const validNicknames = [
"JohnDoe",
"John Doe",
"O'Brien",
"Mary-Jane",
"user_name", // underscore
"name+tag", // plus
"Smith & Jones", // ampersand
"john.doe", // period
"Player#1234", // hash
"Cool!", // exclamation
"Name (Admin)", // parentheses
"José", // accents
"François",
"Müller",
"user_name+tag", // combination
"Player#1_Pro!", // multiple special chars
"",
];
for (const nickname of validNicknames) {
expect(NICKNAME_REGEX.test(nickname)).to.be.true;
}
},
);
t.test("should reject nicknames with URL-enabling characters", async () => {
const invalidNicknames = [
"user@example.com", // @ symbol (email-like)
"http://example.com", // URL scheme
"https://test.com", // URL scheme
"/path/to/file", // forward slash
"user:password", // colon
"ftp://server.com", // URL scheme
];
for (const nickname of invalidNicknames) {
expect(NICKNAME_REGEX.test(nickname)).to.be.false;
}
});
t.test("should be more permissive than NAME_REGEX", async () => {
// These should pass NICKNAME_REGEX but fail NAME_REGEX
const nicknameOnlyValid = [
"user_name",
"name+tag",
"john.doe",
"Player#1234",
"Cool!",
"Name (Admin)",
"Smith & Jones",
];
for (const input of nicknameOnlyValid) {
expect(NICKNAME_REGEX.test(input)).to.be.true;
expect(NAME_REGEX.test(input)).to.be.false;
}
});
});
t.test("GITHUB_USERNAME_REGEX", async (t) => {
t.test("should allow valid GitHub usernames", async () => {
const validUsernames = [
"", // Empty string (optional field)
"john-doe",
"user123",
"a",
"test-user-123",
"User-Name",
"x".repeat(39), // Max length
];
for (const username of validUsernames) {
expect(GITHUB_USERNAME_REGEX.test(username)).to.be.true;
}
});
t.test("should reject invalid GitHub usernames", async () => {
const invalidUsernames = [
"-john", // Starts with hyphen
"john-", // Ends with hyphen
"john--doe", // Consecutive hyphens
"x".repeat(40), // Too long
"user@name", // Invalid character
];
for (const username of invalidUsernames) {
expect(GITHUB_USERNAME_REGEX.test(username)).to.be.false;
}
});
});
t.test("DISCORD_TAG_REGEX", async (t) => {
t.test("should allow valid Discord usernames", async () => {
const validTags = [
"", // Empty string (optional field)
"username",
"user.name",
"user_name",
"username#1234",
"cool.user",
"ab", // Min length
"a".repeat(32), // Max length
];
for (const tag of validTags) {
expect(DISCORD_TAG_REGEX.test(tag)).to.be.true;
}
});
t.test("should reject invalid Discord usernames", async () => {
const invalidTags = [
"discord", // Reserved word
"here", // Reserved word
"everyone", // Reserved word
"user..name", // Consecutive periods
"a", // Too short
"a".repeat(33), // Too long
"user#123", // Invalid discriminator (not 4 digits)
];
for (const tag of invalidTags) {
expect(DISCORD_TAG_REGEX.test(tag)).to.be.false;
}
});
});
t.test("URL_DETECTION_REGEX", async (t) => {
t.test("should detect URLs", async () => {
const urls = [
"https://example.com",
"http://test.com",
"www.example.com",
"example.com",
"test.io",
"subdomain.example.co.uk",
];
for (const url of urls) {
expect(URL_DETECTION_REGEX.test(url)).to.be.true;
}
});
t.test("should not detect non-URLs", async () => {
const nonUrls = [
"just some text",
"no url here",
"localhost",
"192.168.1.1",
];
for (const text of nonUrls) {
expect(URL_DETECTION_REGEX.test(text)).to.be.false;
}
});
});
t.test("Max Length Validations", async (t) => {
t.test(
"should enforce standard character limit for user profile fields",
async () => {
// User profile fields: firstName, lastName, nickname, githubUsername, discordUsername
const schemaStandard = z.string().max(MAX_LENGTH_STANDARD);
// Should pass with exactly MAX_LENGTH_STANDARD characters
const validStandard = "a".repeat(MAX_LENGTH_STANDARD);
expect(schemaStandard.safeParse(validStandard).success).to.be.true;
// Should fail with MAX_LENGTH_STANDARD + 1 characters
const invalidStandard = "a".repeat(MAX_LENGTH_STANDARD + 1);
expect(schemaStandard.safeParse(invalidStandard).success).to.be.false;
},
);
t.test(
"should enforce standard character limit for workspace display names",
async () => {
const schemaStandard = z.string().max(MAX_LENGTH_STANDARD);
// Should pass with exactly MAX_LENGTH_STANDARD characters
const validStandard = "a".repeat(MAX_LENGTH_STANDARD);
expect(schemaStandard.safeParse(validStandard).success).to.be.true;
// Should fail with MAX_LENGTH_STANDARD + 1 characters
const invalidStandard = "a".repeat(MAX_LENGTH_STANDARD + 1);
expect(schemaStandard.safeParse(invalidStandard).success).to.be.false;
},
);
t.test(
"should enforce extended character limit for workspace descriptions",
async () => {
const schemaExtended = z.string().max(MAX_LENGTH_EXTENDED);
// Should pass with exactly MAX_LENGTH_EXTENDED characters
const validExtended = "a".repeat(MAX_LENGTH_EXTENDED);
expect(schemaExtended.safeParse(validExtended).success).to.be.true;
// Should fail with MAX_LENGTH_EXTENDED + 1 characters
const invalidExtended = "a".repeat(MAX_LENGTH_EXTENDED + 1);
expect(schemaExtended.safeParse(invalidExtended).success).to.be.false;
},
);
t.test("should allow domain names within length limits", async () => {
// Workspace display name: MAX_LENGTH_STANDARD chars with domain
const displayNameSchema = z
.string()
.max(MAX_LENGTH_STANDARD)
.regex(DOMAIN_FRIENDLY_INPUT_REGEX);
const validDisplayName = "My Production Workspace - example.com";
expect(displayNameSchema.safeParse(validDisplayName).success).to.be.true;
// Workspace description: MAX_LENGTH_EXTENDED chars with domain
const descriptionSchema = z
.string()
.max(MAX_LENGTH_EXTENDED)
.regex(DOMAIN_FRIENDLY_INPUT_REGEX);
const validDescription = `This workspace manages api.example.com and handles all production traffic for our services. ${"a".repeat(
400,
)}`;
expect(descriptionSchema.safeParse(validDescription).success).to.be.true;
expect(validDescription.length).to.be.lessThan(MAX_LENGTH_EXTENDED);
});
});
});
