Mastering Jest's toMatch with Regular Expressions

In modern JavaScript development, unit testing is crucial for ensuring code quality and reliability. Jest, a popular testing framework, provides powerful assertion methods. One such method, toMatch, allows you to assert that a string matches a given regular expression. This challenge will test your ability to effectively use toMatch for flexible string validation.

Problem Description

Your task is to write Jest unit tests for a hypothetical validateEmail function. This function (which you do not need to implement) is supposed to return true if a given string is a valid email address, and false otherwise. You will be creating these tests using Jest's expect API and the toMatch matcher. The goal is to design a regular expression that accurately captures the common structure of email addresses, considering various valid formats and rejecting obviously invalid ones.

Key Requirements:

1. Use Jest's expect and toMatch to test the validity of email strings.
2. Construct a robust regular expression that can identify common valid email formats.
3. Ensure your tests cover a range of valid and invalid email addresses.

Expected Behavior:

When the hypothetical validateEmail function is called with a valid email string, your tests should pass using expect(...).toMatch(/your-regex/). When called with an invalid email string, your tests should fail (meaning toMatch should not match).

Edge Cases to Consider:

• Emails with subdomains.
• Emails with special characters in the local part (e.g., +, ., _).
• Emails with longer top-level domains (TLDs).
• Strings that look similar to emails but are invalid (e.g., missing @, missing TLD).

Examples

Example 1: Basic Valid Email

// Hypothetical function (not to be implemented)
// declare function validateEmail(email: string): boolean;

// Test case using toMatch
test('should match a basic valid email', () => {
  const email = 'test@example.com';
  // Your assertion goes here
  // expect(validateEmail(email))...
  // You should use expect(email).toMatch(/your-regex/);
});

Output of the Test (if email is valid according to your regex):

The test passes.

Explanation: This is a straightforward email format that should be easily matched.

Example 2: Invalid Email (Missing @)

// Hypothetical function (not to be implemented)
// declare function validateEmail(email: string): boolean;

// Test case using toMatch
test('should not match an email missing the @ symbol', () => {
  const email = 'testexample.com';
  // Your assertion goes here
  // expect(validateEmail(email))...
  // You should use expect(email).not.toMatch(/your-regex/);
});

Output of the Test (if email is invalid according to your regex):

The test passes.

Explanation: An email address must contain an "@" symbol. Your regex should prevent matching strings without it.

Example 3: Valid Email with Subdomain and Special Character

// Hypothetical function (not to be implemented)
// declare function validateEmail(email: string): boolean;

// Test case using toMatch
test('should match a valid email with subdomain and special character', () => {
  const email = 'user.name+tag@sub.domain.co.uk';
  // Your assertion goes here
  // expect(validateEmail(email))...
  // You should use expect(email).toMatch(/your-regex/);
});

Output of the Test (if email is valid according to your regex):

The test passes.

Explanation: This tests a more complex, but still valid, email structure including a subdomain and a + symbol in the local part.

Constraints

• Your regular expression should be a single, well-formed regular expression literal.
• The solution should focus on a practical, commonly accepted email format, not every RFC-defined edge case.
• Tests should be written in TypeScript using Jest.

Notes

• Remember that toMatch expects a RegExp object or a string that will be converted into a RegExp.
• Consider the structure of an email address: local-part@domain.
• The local-part can contain letters, numbers, and certain special characters.
• The domain consists of one or more labels separated by dots, ending in a TLD.
• For this challenge, you don't need to implement the validateEmail function itself. You are solely responsible for writing the Jest tests that would verify such a function. Your tests will directly use expect(emailString).toMatch(/your-regex/) or expect(emailString).not.toMatch(/your-regex/).