+ * This class wraps {@link IDN#toASCII(String)} with fallback handling for edge cases + * (e.g., bidirectional text in Farsi and Hebrew). The output is guaranteed to be a + * valid RFC 1123 hostname (LDH-compliant per RFC 1035 / RFC 1123). + *
+ * Inline hostname sanitization ensures all output conforms to RFC 1123 LDH rules: + * - Each label 1-63 characters, total ≤253 characters + * - Labels contain only letters, digits, hyphens + * - Labels cannot start/end with hyphens + * - Falls back to "example"/"example.com" (RFC 6761) if unsanitizable + *
+ * See RFC 3490 (IDNA), RFC 3491 (Punycode), RFC 1123, and RFC 6761. + * + * @since 1.0.0 */ public class FakerIDN { + private static final int MAX_LABEL_LENGTH = 63; + private static final int MAX_HOSTNAME_LENGTH = 253; /** - * {@link IDN#toASCII(String)} is too picky for our needs. It was throwing exceptions for fa.yml and - * he.yml as they are Bidi languages and something was causing them to die. This is kind of a brute force - * fix, but it appears to fix the issue. + * Converts a string to an ASCII hostname, applying Punycode (IDN) encoding where needed. + * Never throws; returns valid RFC 1123 hostname or "example" fallback. + * + * @param input the domain name to convert + * @return valid ASCII hostname (LDH-compliant per RFC 1123, never null or empty) */ - public static String toASCII(String in) { + public static String toASCII(@Nullable String input) { + if (input == null || input.isEmpty()) { + return "example"; + } + + @Nullable String asciiResult = tryFullConversion(input); + if (asciiResult == null) { + asciiResult = tryCharacterByCharacter(input); + } + + if (asciiResult == null || asciiResult.isEmpty()) { + asciiResult = "example"; + } + + // Sanitize to RFC 1123: lowercase, [a-z0-9-] only, no leading/trailing hyphens + return sanitizeHostname(asciiResult); + } + + private static String sanitizeHostname(String input) { + String[] labels = input.split("\\.", -1); + StringBuilder result = new StringBuilder(); + + for (int i = 0; i < labels.length; i++) { + if (i > 0) result.append("."); + result.append(sanitizeLabel(labels[i])); + } + + String hostname = result.toString(); + if (hostname.length() > MAX_HOSTNAME_LENGTH) { + hostname = hostname.substring(0, MAX_HOSTNAME_LENGTH).replaceAll("\\.$", ""); + } + return hostname.isEmpty() ? "example.com" : hostname; + } + + private static String sanitizeLabel(String input) { + String result = input.toLowerCase(Locale.ROOT); + StringBuilder sanitized = new StringBuilder(); + for (char c : result.toCharArray()) { + if ((c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || c == '-') { + sanitized.append(c); + } + } + result = sanitized.toString(); + // Preserve xn-- (Punycode prefix) but collapse other consecutive hyphens + if (!result.startsWith("xn--")) { + while (result.contains("--")) result = result.replace("--", "-"); + } + result = result.replaceAll("^-+|-+$", ""); + if (result.length() > MAX_LABEL_LENGTH) { + result = result.substring(0, MAX_LABEL_LENGTH).replaceAll("-+$", ""); + } + return result.isEmpty() ? "example" : result; + } + + @Nullable + private static String tryFullConversion(String input) { try { - return IDN.toASCII(in); + return IDN.toASCII(input); } catch (IllegalArgumentException ignore) { - // let's continue with the character by character encoding hack. + return null; } - final StringBuilder asciiResult = new StringBuilder(); - for (int i = 0; i < in.length(); i++) { + } + + @Nullable + private static String tryCharacterByCharacter(String input) { + final StringBuilder result = new StringBuilder(input.length()); + for (int i = 0; i < input.length(); i++) { try { - asciiResult.append(IDN.toASCII(in.substring(i, i + 1))); + result.append(IDN.toASCII(input.substring(i, i + 1))); } catch (IllegalArgumentException ignored) { + // Skip characters that cannot be converted } } - if (asciiResult.isEmpty()) { - throw new RuntimeException("Unable to convert \"%s\" to ASCII".formatted(in)); - } - return asciiResult.toString(); + return result.length() > 0 ? result.toString() : null; } } diff --git a/src/main/java/net/datafaker/internal/helper/HostnameHelper.java b/src/main/java/net/datafaker/internal/helper/HostnameHelper.java new file mode 100644 index 000000000..3d03d70b2 --- /dev/null +++ b/src/main/java/net/datafaker/internal/helper/HostnameHelper.java @@ -0,0 +1,140 @@ +package net.datafaker.internal.helper; + +import java.net.IDN; +import java.util.Locale; + +/** + * Helper for creating valid hostnames according to RFC 1123 (Letter-Digit-Hyphen rules). + *
+ * This class provides methods to sanitize strings into valid DNS hostnames that conform to: + * - RFC 1035: Original DNS specification + * - RFC 1123: Relaxed hostname rules (allows digits at start of label) + *
+ * Hostname rules per RFC 1123: + * - Each label (segment between dots) is 1-63 characters + * - Total hostname including dots must be ≤253 characters + * - Labels contain only letters, digits, and hyphens (LDH) + * - Labels cannot start or end with hyphens + * - Labels cannot be purely numeric + * + * @since 3.0.0 + */ +public class HostnameHelper { + private static final int MAX_LABEL_LENGTH = 63; + private static final int MAX_HOSTNAME_LENGTH = 253; + + /** + * Converts a string to a valid ASCII hostname label, sanitizing per RFC 1123 LDH rules. + *
+ * Process: + * 1. Apply IDN.toASCII() for non-ASCII input (converts to Punycode if needed) + * 2. Convert to lowercase + * 3. Keep only [a-z0-9-] + * 4. Collapse consecutive hyphens (except preserve "xn--" Punycode prefix) + * 5. Strip leading/trailing hyphens + * 6. Enforce length ≤ 63 characters + * 7. Fall back to "example" if result is empty + *
+ * The fallback value "example" is an IETF-reserved special-use domain name (RFC 6761) + * intended for documentation and examples. + * + * @param input the string to sanitize + * @param locale the locale for lowercase conversion (e.g., Locale.ROOT) + * @return a valid ASCII hostname label (never null or empty) + */ + public static String toAsciiHostnameLabel(String input, Locale locale) { + if (input == null || input.isEmpty()) { + return "example"; + } + + // 1. Try IDN conversion for Unicode input (converts to Punycode if needed) + String result = input; + try { + result = IDN.toASCII(input); + } catch (IllegalArgumentException ignore) { + // Not a valid IDN label; proceed with raw input + } + + // 2. Lowercase the input + result = result.toLowerCase(locale); + + // 3. Keep only [a-z0-9-] + StringBuilder sanitized = new StringBuilder(); + for (char c : result.toCharArray()) { + if ((c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || c == '-') { + sanitized.append(c); + } + } + + result = sanitized.toString(); + + // 4. Collapse consecutive hyphens (preserve "xn--" Punycode prefix) + if (!result.startsWith("xn--")) { + while (result.contains("--")) { + result = result.replace("--", "-"); + } + } + + // 5. Strip leading/trailing hyphens + result = result.replaceAll("^-+|-+$", ""); + + // 6. Enforce max label length + if (result.length() > MAX_LABEL_LENGTH) { + result = result.substring(0, MAX_LABEL_LENGTH); + result = result.replaceAll("-+$", ""); + } + + // 7. Return valid result or fallback + if (result.isEmpty()) { + return "example"; + } + return result; + } + + /** + * Sanitizes each label of a hostname independently and recombines. + *
+ * If input contains dots, each segment is sanitized separately, then recombined. + * This is useful for domain names where each label has independent rules. + *
+ * Fallback behavior: + * - Null or empty input returns "example.com" + * - Result that becomes empty after sanitization returns "example.com" + *
+ * The fallback values are IETF-reserved special-use domain names (RFC 6761) + * intended for documentation and examples. + * + * @param input the hostname/domain to sanitize (may contain dots) + * @param locale the locale for lowercase conversion + * @return a valid ASCII hostname (never null or empty) + */ + public static String toAsciiHostname(String input, Locale locale) { + if (input == null || input.isEmpty()) { + return "example.com"; + } + + String[] labels = input.split("\\.", -1); + StringBuilder result = new StringBuilder(); + + for (int i = 0; i < labels.length; i++) { + if (i > 0) { + result.append("."); + } + result.append(toAsciiHostnameLabel(labels[i], locale)); + } + + String hostname = result.toString(); + + // Enforce total length + if (hostname.length() > MAX_HOSTNAME_LENGTH) { + // Truncate from the end, preserving the TLD + hostname = hostname.substring(0, MAX_HOSTNAME_LENGTH); + hostname = hostname.replaceAll("\\.$", ""); + } + + if (hostname.isEmpty()) { + return "example.com"; + } + return hostname; + } +} diff --git a/src/main/java/net/datafaker/providers/base/Company.java b/src/main/java/net/datafaker/providers/base/Company.java index 1c0c9d02e..a99ee6d85 100644 --- a/src/main/java/net/datafaker/providers/base/Company.java +++ b/src/main/java/net/datafaker/providers/base/Company.java @@ -1,6 +1,7 @@ package net.datafaker.providers.base; import net.datafaker.internal.helper.FakerIDN; +import net.datafaker.internal.helper.HostnameHelper; import net.datafaker.internal.helper.LazyEvaluated; import java.util.Collection; @@ -68,27 +69,46 @@ public String logo() { return "https://pigment.github.io/fake-logos/logos/medium/color/" + number + ".png"; } + /** + * Returns a domain name based on the company name. + *
+ * The domain name is created by sanitizing the company name according to RFC 1123 + * (Letter-Digit-Hyphen rules). The result is always a valid ASCII hostname. + * + * @return a valid ASCII domain name + * @since 0.8.0 + */ + public String domainName() { + String companyName = name(); + return HostnameHelper.toAsciiHostnameLabel(companyName, faker.getContext().getLocale()); + } + + /** + * Returns a web URL for the company. + *
+ * The domain name is created by sanitizing the company name according to RFC 1123 + * (Letter-Digit-Hyphen rules), and the full URL is constructed with a domain suffix. + * + * @return a valid web URL + * @since 0.8.0 + */ public String url() { return "www." + FakerIDN.toASCII(domainName()) + "." + domainSuffix(); } - private String domainName() { - final char[] res = name().toLowerCase(faker.getContext().getLocale()).toCharArray(); - int offset = 0; - for (int i = 0; i < res.length; i++) { - final char c = res[i]; - switch (c) { - case '.', ',', '\'', ' ', ']', '&' -> offset++; - default -> res[i - offset] = res[i]; - } - } - return String.valueOf(res, 0, res.length - offset); - } - + /** + * Returns a domain suffix (TLD). + *
+ * The suffix is sanitized according to RFC 1123 to ensure it is ASCII-compatible.
+ * For non-ASCII locales, the suffix is converted to ASCII via the hostname sanitizer.
+ *
+ * @return a domain suffix (ASCII)
+ */
private String domainSuffix() {
- return resolve("internet.domain_suffix");
+ String suffix = resolve("internet.domain_suffix");
+ return HostnameHelper.toAsciiHostname(suffix, faker.getContext().getLocale());
}
private String joinSampleOfEachList(List
+ * The domain word is created by sanitizing a name according to RFC 1123
+ * (Letter-Digit-Hyphen rules). The result is always a valid ASCII hostname.
+ *
+ * @return a valid ASCII domain name
+ * @since 0.8.0
+ */
public String domainName() {
return domainWord() + "." + domainSuffix();
}
+ /**
+ * Returns a domain word (label without suffix).
+ *
+ * The word is created by sanitizing a last name according to RFC 1123
+ * (Letter-Digit-Hyphen rules). The result is always a valid ASCII hostname label.
+ *
+ * @return a valid ASCII domain label
+ * @since 0.8.0
+ */
public String domainWord() {
- return FakerIDN.toASCII(
- faker.name().lastName().toLowerCase(faker.getContext().getLocale()).replace("'", ""));
+ String lastName = faker.name().lastName().toLowerCase(faker.getContext().getLocale()).replace("'", "");
+ return HostnameHelper.toAsciiHostnameLabel(lastName, faker.getContext().getLocale());
}
+ /**
+ * Returns a domain suffix (TLD).
+ *
+ * The suffix is sanitized according to RFC 1123 to ensure it is ASCII-compatible.
+ * For non-ASCII locales, the suffix is converted to ASCII via the hostname sanitizer.
+ *
+ * @return a domain suffix (ASCII)
+ * @since 0.8.0
+ */
public String domainSuffix() {
- return resolve("internet.domain_suffix");
+ String suffix = resolve("internet.domain_suffix");
+ return HostnameHelper.toAsciiHostname(suffix, faker.getContext().getLocale());
}
/**
@@ -213,18 +242,25 @@ public String url(boolean schemeChoice, boolean portChoice, boolean pathChoice,
/**
* Returns a web domain.
+ *
+ * The domain is created by combining a first name and domain word, both sanitized
+ * according to RFC 1123 (Letter-Digit-Hyphen rules). The result is always a valid
+ * ASCII hostname.
*
* @return a web domain in the form "www.example.com"
* @since 2.0.0
*/
public String webdomain() {
+ String firstName = faker.name().firstName().toLowerCase(
+ faker.getContext().getLocale()).replace("'", "");
+ String firstNameLabel = HostnameHelper.toAsciiHostnameLabel(firstName, faker.getContext().getLocale());
+ String combinedLabel = firstNameLabel + "-" + domainWord();
+ // Sanitize the combined label to handle cases where concatenation might create issues
+ String sanitized = HostnameHelper.toAsciiHostnameLabel(combinedLabel, faker.getContext().getLocale());
+
return String.join("",
"www", ".",
- FakerIDN.toASCII(
- faker.name().firstName().toLowerCase(
- faker.getContext().getLocale()).replace("'", "") + "-" +
- domainWord()
- ),
+ sanitized,
".",
domainSuffix()
);
diff --git a/src/test/java/net/datafaker/internal/helper/FakerIDNTest.java b/src/test/java/net/datafaker/internal/helper/FakerIDNTest.java
index a5495993e..769f16ff0 100644
--- a/src/test/java/net/datafaker/internal/helper/FakerIDNTest.java
+++ b/src/test/java/net/datafaker/internal/helper/FakerIDNTest.java
@@ -3,7 +3,6 @@
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
class FakerIDNTest {
@@ -13,9 +12,11 @@ void toASCIINoError() {
}
@Test
- void toASCIIResultIsEmptyException() { // http://Ⱥbby.com
- assertThatThrownBy(() -> FakerIDN.toASCII("Ⱥ"))
- .isInstanceOf(RuntimeException.class);
+ void toASCIIResultIsEmptyFallback() {
+ // Even with un-convertible characters, should return a valid label, not throw
+ String result = FakerIDN.toASCII("Ⱥ");
+ assertThat(result).isNotEmpty();
+ assertThat(result).matches("^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$");
}
}
diff --git a/src/test/java/net/datafaker/internal/helper/HostnameHelperTest.java b/src/test/java/net/datafaker/internal/helper/HostnameHelperTest.java
new file mode 100644
index 000000000..2cef8b753
--- /dev/null
+++ b/src/test/java/net/datafaker/internal/helper/HostnameHelperTest.java
@@ -0,0 +1,113 @@
+package net.datafaker.internal.helper;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+
+import java.net.URI;
+import java.util.Locale;
+import java.util.regex.Pattern;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+
+/**
+ * Tests for HostnameHelper RFC 1123 LDH compliance.
+ */
+class HostnameHelperTest {
+ private static final Pattern RFC_1123_LABEL_PATTERN = Pattern.compile("^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$");
+ private static final Pattern RFC_1123_HOSTNAME_PATTERN = Pattern.compile("^([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\\.)*[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$");
+
+ @Test
+ void testToAsciiHostnameLabelWithNullInput() {
+ assertThat(HostnameHelper.toAsciiHostnameLabel(null, Locale.ROOT)).isEqualTo("example");
+ }
+
+ @Test
+ void testToAsciiHostnameLabelWithEmptyInput() {
+ assertThat(HostnameHelper.toAsciiHostnameLabel("", Locale.ROOT)).isEqualTo("example");
+ }
+
+ @ParameterizedTest
+ @CsvSource({
+ "simple,simple",
+ "Simple,simple",
+ "SIMPLE,simple",
+ "Simple123,simple123",
+ "example-domain,example-domain",
+ })
+ void testToAsciiHostnameLabelValidInputs(String input, String expected) {
+ String result = HostnameHelper.toAsciiHostnameLabel(input, Locale.ROOT);
+ assertThat(result).isEqualTo(expected);
+ assertThat(result).matches(RFC_1123_LABEL_PATTERN);
+ }
+
+ @ParameterizedTest
+ @CsvSource({
+ "company&name,companyname",
+ "name with spaces,namewithspaces",
+ })
+ void testToAsciiHostnameLabelSpecialCharacters(String input, String expected) {
+ String result = HostnameHelper.toAsciiHostnameLabel(input, Locale.ROOT);
+ assertThat(result).isEqualTo(expected);
+ assertThat(result).matches(RFC_1123_LABEL_PATTERN);
+ }
+
+ @Test
+ void testToAsciiHostnameLabelMaxLength() {
+ String longInput = "a".repeat(100);
+ String result = HostnameHelper.toAsciiHostnameLabel(longInput, Locale.ROOT);
+ assertThat(result).hasSizeLessThanOrEqualTo(63);
+ assertThat(result).matches(RFC_1123_LABEL_PATTERN);
+ }
+
+ @Test
+ void testToAsciiHostnameLabelAmpersand() {
+ String result = HostnameHelper.toAsciiHostnameLabel("Acme & Co", Locale.ROOT);
+ assertThat(result).isNotEmpty();
+ assertThat(result).matches(RFC_1123_LABEL_PATTERN);
+ }
+
+ @Test
+ void testToAsciiHostnameLabelOnlySpecialChars() {
+ String result = HostnameHelper.toAsciiHostnameLabel("!@#$%^&*()", Locale.ROOT);
+ assertThat(result).isEqualTo("example");
+ }
+
+ @Test
+ void testToAsciiHostnameLabelHyphenFallback() {
+ String result = HostnameHelper.toAsciiHostnameLabel("----", Locale.ROOT);
+ assertThat(result).isEqualTo("example");
+ }
+
+ @ParameterizedTest
+ @CsvSource({
+ "example.com,example.com",
+ "EXAMPLE.COM,example.com",
+ "my-domain.co.uk,my-domain.co.uk",
+ "sub.domain.example.com,sub.domain.example.com",
+ })
+ void testToAsciiHostnameValidInputs(String input, String expected) {
+ String result = HostnameHelper.toAsciiHostname(input, Locale.ROOT);
+ assertThat(result).isEqualTo(expected);
+ assertThat(result).matches(RFC_1123_HOSTNAME_PATTERN);
+ }
+
+ @Test
+ void testToAsciiHostnameWithNullInput() {
+ assertThat(HostnameHelper.toAsciiHostname(null, Locale.ROOT)).isEqualTo("example.com");
+ }
+
+ @Test
+ void testToAsciiHostnameWithEmptyInput() {
+ assertThat(HostnameHelper.toAsciiHostname("", Locale.ROOT)).isEqualTo("example.com");
+ }
+
+ @Test
+ void testHostnameCanBeUsedInURI() {
+ String hostname = HostnameHelper.toAsciiHostname("example & co.com", Locale.ROOT);
+ assertDoesNotThrow(() -> {
+ new URI("https://" + hostname + "/");
+ });
+ }
+}
diff --git a/src/test/java/net/datafaker/providers/base/CompanyTest.java b/src/test/java/net/datafaker/providers/base/CompanyTest.java
index 6cf888a5e..6b85098f2 100644
--- a/src/test/java/net/datafaker/providers/base/CompanyTest.java
+++ b/src/test/java/net/datafaker/providers/base/CompanyTest.java
@@ -4,7 +4,12 @@
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.doReturn;
+import java.net.URL;
+import java.net.URI;
import java.util.List;
import java.util.Collection;
import java.util.regex.Pattern;
@@ -51,4 +56,38 @@ void testLogo() {
void testUrl() {
assertThat(company.url()).matches(URL_PATTERN);
}
+
+ @Test
+ void testDomainNameIsValidLabel() {
+ String domainName = company.domainName();
+ // Should be a valid RFC 1123 label: [a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?
+ assertThat(domainName).matches("^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$");
+ }
+
+ @RepeatedTest(10)
+ void testUrlCanBeUsedAsHttpsUrl() {
+ String url = company.url();
+ assertDoesNotThrow(() -> new URL("https://" + url + "/"));
+ }
+
+ @RepeatedTest(10)
+ void testUrlCanBeUsedAsURI() {
+ String url = company.url();
+ assertDoesNotThrow(() -> new URI("https://" + url + "/"));
+ }
+
+ @Test
+ void testDomainNameWithAmpersand() {
+ // Edge case from https://github.com/datafaker-net/datafaker/pull/1757
+ // Company names with & should be sanitized to valid hostnames
+ // Mock the company to ensure the name contains '&'
+ Company mockedCompany = spy(company);
+ doReturn("Acme & Co").when(mockedCompany).name();
+
+ String domainName = mockedCompany.domainName();
+ assertThat(domainName).isNotEmpty();
+ assertThat(domainName).matches("^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$");
+ // Verify that ampersand was stripped (result should be valid)
+ assertThat(domainName).doesNotContain("&");
+ }
}
diff --git a/src/test/java/net/datafaker/providers/base/InternetTest.java b/src/test/java/net/datafaker/providers/base/InternetTest.java
index 13af48326..75282f3ac 100644
--- a/src/test/java/net/datafaker/providers/base/InternetTest.java
+++ b/src/test/java/net/datafaker/providers/base/InternetTest.java
@@ -11,6 +11,7 @@
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
+import java.net.URI;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
@@ -36,6 +37,9 @@
class InternetTest {
public static final Pattern IPV6_HOST_ADDRESS = Pattern.compile("[0-9a-fA-F]{1,4}(:([0-9a-fA-F]{1,4})){1,7}");
+ // RFC 1123 compliant hostname patterns (used in our new/modified domain tests)
+ private static final Pattern RFC_1123_LABEL = Pattern.compile("^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$");
+ private static final Pattern RFC_1123_DOMAIN = Pattern.compile("^([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)(\\.[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)+$");
private final Faker faker = new Faker();
@RepeatedTest(10)
@@ -194,7 +198,12 @@ void testSafeEmailAddressDoesNotIncludeAccentsInTheLocalPart() {
@Test
void testWebdomain() {
- assertThat(faker.internet().webdomain()).matches("www\\.[\\w-]+\\.\\w+");
+ // RFC 1123 compliant: www.