Files

666 lines
24 KiB
TypeScript
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import env from "../env";
import { isBrowser } from "./browser";
import * as urlsUtils from "./urls";
import { urlRegex } from "./urls";
describe("isUrl", () => {
it("should return false for invalid url", () => {
expect(urlsUtils.isUrl("")).toBe(false);
expect(urlsUtils.isUrl("#invalidurl")).toBe(false);
expect(urlsUtils.isUrl("mailto:")).toBe(false);
expect(urlsUtils.isUrl("sms:")).toBe(false);
expect(urlsUtils.isUrl("://")).toBe(false);
expect(urlsUtils.isUrl("www.example.com")).toBe(false);
});
it("should return true for valid urls", () => {
expect(urlsUtils.isUrl("http://example.com")).toBe(true);
expect(urlsUtils.isUrl("https://www.example.com")).toBe(true);
expect(urlsUtils.isUrl("seafile://openfile")).toBe(true);
expect(urlsUtils.isUrl("figma://launch")).toBe(true);
expect(urlsUtils.isUrl("outline:https://getoutline.com")).toBe(true);
expect(urlsUtils.isUrl("www.example.com", { requireProtocol: false })).toBe(
true
);
});
describe("requireHttps option", () => {
it("should reject HTTP URLs when requireHttps is true", () => {
expect(
urlsUtils.isUrl("http://example.com", { requireHttps: true })
).toBe(false);
expect(
urlsUtils.isUrl("http://example.com/callback", { requireHttps: true })
).toBe(false);
expect(
urlsUtils.isUrl("http://localhost:3000/auth", { requireHttps: true })
).toBe(false);
});
it("should accept HTTPS URLs when requireHttps is true", () => {
expect(
urlsUtils.isUrl("https://example.com", { requireHttps: true })
).toBe(true);
expect(
urlsUtils.isUrl("https://example.com/callback", { requireHttps: true })
).toBe(true);
expect(
urlsUtils.isUrl("https://localhost:3000/auth", { requireHttps: true })
).toBe(true);
});
it("should accept HTTP URLs when requireHttps is false or not specified", () => {
expect(urlsUtils.isUrl("http://example.com")).toBe(true);
expect(
urlsUtils.isUrl("http://example.com", { requireHttps: false })
).toBe(true);
});
it("should allow custom protocols when requireHttps is true", () => {
expect(
urlsUtils.isUrl("seafile://openfile", { requireHttps: true })
).toBe(true);
expect(urlsUtils.isUrl("figma://launch", { requireHttps: true })).toBe(
true
);
expect(urlsUtils.isUrl("myapp://callback", { requireHttps: true })).toBe(
true
);
});
});
});
describe("isPrivateUseSchemeUrl", () => {
it("should return true for private-use schemes", () => {
expect(
urlsUtils.isPrivateUseSchemeUrl("com.example.app:/oauth2redirect")
).toBe(true);
expect(urlsUtils.isPrivateUseSchemeUrl("myapp://callback")).toBe(true);
expect(urlsUtils.isPrivateUseSchemeUrl("myapp://callback?x=1")).toBe(true);
expect(urlsUtils.isPrivateUseSchemeUrl("MyApp://callback")).toBe(true);
expect(urlsUtils.isPrivateUseSchemeUrl("myapp:a")).toBe(true);
expect(urlsUtils.isPrivateUseSchemeUrl("myapp:/a")).toBe(true);
});
it("should return false for web schemes", () => {
expect(urlsUtils.isPrivateUseSchemeUrl("http://example.com")).toBe(false);
expect(urlsUtils.isPrivateUseSchemeUrl("https://example.com")).toBe(false);
expect(urlsUtils.isPrivateUseSchemeUrl("ftp://example.com")).toBe(false);
expect(urlsUtils.isPrivateUseSchemeUrl("wss://example.com")).toBe(false);
});
it("should return false for schemes that can execute or embed content", () => {
expect(urlsUtils.isPrivateUseSchemeUrl("javascript:alert(1)")).toBe(false);
expect(urlsUtils.isPrivateUseSchemeUrl("JavaScript:alert(1)")).toBe(false);
expect(urlsUtils.isPrivateUseSchemeUrl("data:text/html,hi")).toBe(false);
expect(urlsUtils.isPrivateUseSchemeUrl("vbscript:msgbox")).toBe(false);
expect(urlsUtils.isPrivateUseSchemeUrl("file:///etc/passwd")).toBe(false);
expect(urlsUtils.isPrivateUseSchemeUrl("blob:https://example.com/x")).toBe(
false
);
expect(urlsUtils.isPrivateUseSchemeUrl("about:blank")).toBe(false);
});
it("should return false for malformed or empty values", () => {
expect(urlsUtils.isPrivateUseSchemeUrl("")).toBe(false);
expect(urlsUtils.isPrivateUseSchemeUrl("myapp:")).toBe(false);
expect(urlsUtils.isPrivateUseSchemeUrl("myapp:/")).toBe(false);
expect(urlsUtils.isPrivateUseSchemeUrl("myapp://")).toBe(false);
expect(urlsUtils.isPrivateUseSchemeUrl("callback")).toBe(false);
expect(urlsUtils.isPrivateUseSchemeUrl("/relative/path")).toBe(false);
expect(urlsUtils.isPrivateUseSchemeUrl(" myapp://callback")).toBe(false);
expect(urlsUtils.isPrivateUseSchemeUrl("myapp://call back")).toBe(false);
});
});
describe("isBase64Url", () => {
it("should return false for invalid url", () => {
expect(urlsUtils.isBase64Url("")).toBe(false);
expect(urlsUtils.isBase64Url("#invalidurl")).toBe(false);
expect(urlsUtils.isBase64Url("http://example.com")).toBe(false);
expect(urlsUtils.isBase64Url("https://www.example.com")).toBe(false);
expect(urlsUtils.isBase64Url("seafile://openfile")).toBe(false);
expect(urlsUtils.isBase64Url("figma://launch")).toBe(false);
expect(urlsUtils.isBase64Url("outline:https://getoutline.com")).toBe(false);
expect(urlsUtils.isBase64Url("://")).toBe(false);
});
it("should return true for valid urls", () => {
expect(
urlsUtils.isBase64Url(
"data:image/png;base64,R0lGODlhPQBEAPeoAJosM//AwO/AwHVYZ/z595kzAP/s7P+goOXMv8+fhw/v739/f+8PD98fH/8mJl+fn/9ZWb8/PzWlwv///6wWGbImAPgTEMImIN9gUFCEm/gDALULDN8PAD6atYdCTX9gUNKlj8wZAKUsAOzZz+UMAOsJAP/Z2ccMDA8PD/95eX5NWvsJCOVNQPtfX/8zM8+QePLl38MGBr8JCP+zs9myn/8GBqwpAP/GxgwJCPny78lzYLgjAJ8vAP9fX/+MjMUcAN8zM/9wcM8ZGcATEL+QePdZWf/29uc/P9cmJu9MTDImIN+/r7+/vz8/P8VNQGNugV8AAF9fX8swMNgTAFlDOICAgPN"
)
).toBeTruthy();
expect(
urlsUtils.isBase64Url(
"data:image/gif;base64,npkM+fOqD6DDj1aZpITp0dtGCDhr+fVuCu3zlg49ijaokTZTo27uG7Gjn2P+hI8+PDPERoUB318bWbfAJ5sUNFcuGRTYUqV/3ogfXp1rWlMc6awJjiAAd2fm4ogXjz56aypOoIde4OE5u/F9x199dlXnnGiHZWEYbGpsAEA3QXYnHwEFliKAgswgJ8LPeiUXGwedCAKABACCN+EA1pYIIYaFlcDhytd51sGAJbo3onOpajiihlO92KHGaUXGwWjUBChjSPiWJuOO/LYIm4v1tXfE6J4gCSJEZ7YgRYUNrkji9P55sF/ogxw5ZkSqIDaZBV6aSGYq/lGZplndkckZ98xoICbTcIJGQAZc"
)
).toBeTruthy();
});
});
describe("isInternalUrl", () => {
beforeEach(() => {
env.URL = "https://example.com:3000";
});
it("should return false if empty string", () => {
expect(urlsUtils.isInternalUrl("")).toBe(false);
});
it("should return false if port is different", () => {
expect(urlsUtils.isInternalUrl("https://example.com:4000")).toBe(false);
});
it("should return false if port is missing", () => {
expect(urlsUtils.isInternalUrl("https://example.com")).toBe(false);
});
it("should return true if starting with relative path", () => {
expect(urlsUtils.isInternalUrl("/drafts")).toEqual(true);
});
});
describe("signedUrlToAttachmentUrl", () => {
const id = "4d3e6f2a-8b1c-4e5d-9f0a-1b2c3d4e5f60";
const sign = (payload: object) =>
[
btoa(JSON.stringify({ alg: "HS256", typ: "JWT" })),
btoa(JSON.stringify(payload))
.replace(/\+/g, "-")
.replace(/\//g, "_")
.replace(/=+$/, ""),
"signature",
].join(".");
it("should return the redirect url for a signed attachment url", () => {
const origin = isBrowser ? window.location.origin : env.URL;
const sig = sign({
key: `uploads/${id}/${id}/image ünïcode.png`,
type: "attachment",
});
expect(
urlsUtils.signedUrlToAttachmentUrl(`${origin}/api/files.get?sig=${sig}`)
).toEqual(`/api/attachments.redirect?id=${id}`);
expect(
urlsUtils.signedUrlToAttachmentUrl(`/api/files.get?sig=${sig}`)
).toEqual(`/api/attachments.redirect?id=${id}`);
});
it("should return undefined for an external url", () => {
const sig = sign({
key: `uploads/${id}/${id}/image.png`,
type: "attachment",
});
expect(
urlsUtils.signedUrlToAttachmentUrl(
`https://other.example.com/api/files.get?sig=${sig}`
)
).toBeUndefined();
expect(
urlsUtils.signedUrlToAttachmentUrl(
`//other.example.com/api/files.get?sig=${sig}`
)
).toBeUndefined();
});
it("should return undefined for other urls", () => {
expect(
urlsUtils.signedUrlToAttachmentUrl(`/api/attachments.redirect?id=${id}`)
).toBeUndefined();
expect(
urlsUtils.signedUrlToAttachmentUrl("/api/files.get?key=public/a/b/c.png")
).toBeUndefined();
expect(
urlsUtils.signedUrlToAttachmentUrl("/api/files.get?sig=invalid")
).toBeUndefined();
expect(
urlsUtils.signedUrlToAttachmentUrl(
`/api/files.get?sig=${sign({ key: "uploads/a/b/c.png", type: "attachment" })}`
)
).toBeUndefined();
});
});
describe("addMissingUrlPort", () => {
const url = env.URL;
beforeEach(() => {
env.URL = "https://example.com:3000";
});
afterEach(() => {
env.URL = url;
});
it("should add the port to a url without one", () => {
expect(urlsUtils.addMissingUrlPort("https://example.com/drafts")).toBe(
"https://example.com:3000/drafts"
);
});
it("should not change a url that already has a port", () => {
expect(urlsUtils.addMissingUrlPort("https://example.com:4000/drafts")).toBe(
"https://example.com:4000/drafts"
);
});
it("should not change a relative url", () => {
expect(urlsUtils.addMissingUrlPort("/drafts")).toBe("/drafts");
});
it("should not change a url when no port is configured", () => {
env.URL = "https://example.com";
expect(urlsUtils.addMissingUrlPort("https://example.com/drafts")).toBe(
"https://example.com/drafts"
);
});
it("should not add the default https port", () => {
env.URL = "https://example.com:443";
expect(urlsUtils.addMissingUrlPort("https://example.com/drafts")).toBe(
"https://example.com/drafts"
);
});
it("should not add the default http port", () => {
env.URL = "http://example.com:80";
expect(urlsUtils.addMissingUrlPort("http://example.com/drafts")).toBe(
"http://example.com/drafts"
);
});
it("should add a port that is not the default for the protocol", () => {
env.URL = "http://example.com:443";
expect(urlsUtils.addMissingUrlPort("http://example.com/drafts")).toBe(
"http://example.com:443/drafts"
);
});
});
describe("isExternalUrl", () => {
it("should return false if empty url", () => {
expect(urlsUtils.isExternalUrl("")).toBe(false);
});
it("should return false if internal url", () => {
expect(urlsUtils.isExternalUrl("/drafts")).toBe(false);
});
});
describe("sanitizeUrl", () => {
it("should return undefined if not url", () => {
expect(urlsUtils.sanitizeUrl(undefined)).toBeUndefined();
expect(urlsUtils.sanitizeUrl(null)).toBeUndefined();
expect(urlsUtils.sanitizeUrl("")).toBeUndefined();
});
it("should append https:// to non-special urls", () => {
expect(urlsUtils.sanitizeUrl("www.google.com")).toEqual(
"https://www.google.com"
);
});
it("should trim surrounding whitespace rather than append a scheme", () => {
expect(urlsUtils.sanitizeUrl("https://www.google.com\n")).toEqual(
"https://www.google.com"
);
expect(urlsUtils.sanitizeUrl(" https://www.google.com ")).toEqual(
"https://www.google.com"
);
});
describe("special urls", () => {
it("should return the url as it's if starting with /", () => {
expect(urlsUtils.sanitizeUrl("/drafts")).toEqual("/drafts");
});
it("should return the url as it's if starting with #", () => {
expect(urlsUtils.sanitizeUrl("#home")).toEqual("#home");
});
it("should return the url as it's if it's mailto:", () => {
expect(urlsUtils.sanitizeUrl("mailto:outline@getoutline.com")).toEqual(
"mailto:outline@getoutline.com"
);
});
it("should return the url as it's if it's sms:, fax:, tel:", () => {
expect(urlsUtils.sanitizeUrl("mailto:outline@getoutline.com")).toEqual(
"mailto:outline@getoutline.com"
);
expect(urlsUtils.sanitizeUrl("tel:0123456789")).toEqual("tel:0123456789");
expect(urlsUtils.sanitizeUrl("fax:0123456789")).toEqual("fax:0123456789");
expect(urlsUtils.sanitizeUrl("sms:0123456789")).toEqual("sms:0123456789");
});
it("should return the url unchanged if it's geo:", () => {
expect(urlsUtils.sanitizeUrl("geo:37.786971,-122.399677")).toEqual(
"geo:37.786971,-122.399677"
);
});
it("should return the url unchanged if it's maps:", () => {
expect(urlsUtils.sanitizeUrl("maps:?q=Eiffel+Tower")).toEqual(
"maps:?q=Eiffel+Tower"
);
});
it("should return the url unchanged if it's magnet:", () => {
expect(
urlsUtils.sanitizeUrl("magnet:?xt=urn:btih:abc123&dn=file")
).toEqual("magnet:?xt=urn:btih:abc123&dn=file");
});
it("should handle uppercase scheme", () => {
expect(urlsUtils.sanitizeUrl("GEO:37.786971,-122.399677")).toEqual(
"GEO:37.786971,-122.399677"
);
});
it("should return the url as it's if it's a special protocol", () => {
expect(urlsUtils.sanitizeUrl("mqtt://getoutline.com")).toEqual(
"mqtt://getoutline.com"
);
});
});
describe("Blocked protocols", () => {
it("should sanitize base64-encoded image data URIs (links should not embed data)", () => {
expect(
urlsUtils.sanitizeUrl(
"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII="
)
).toEqual(
"https://data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII="
);
});
it("should be sanitized", () => {
expect(urlsUtils.sanitizeUrl("file://localhost.com/outline.txt")).toEqual(
"https://file://localhost.com/outline.txt"
);
expect(urlsUtils.sanitizeUrl("javascript:whatever")).toEqual(
"https://javascript:whatever"
);
expect(
urlsUtils.sanitizeUrl("data:text/html,<script>alert('hi');</script>")
).toEqual("https://data:text/html,<script>alert('hi');</script>");
expect(urlsUtils.sanitizeUrl("vbscript:whatever")).toEqual(
"https://vbscript:whatever"
);
});
});
});
describe("sanitizeImageSrc", () => {
it("should return undefined if not a src", () => {
expect(urlsUtils.sanitizeImageSrc(undefined)).toBeUndefined();
expect(urlsUtils.sanitizeImageSrc(null)).toBeUndefined();
expect(urlsUtils.sanitizeImageSrc("")).toBeUndefined();
});
it("should return base64-encoded image data URIs unchanged", () => {
const png =
"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII=";
expect(urlsUtils.sanitizeImageSrc(png)).toEqual(png);
const gif =
"data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7";
expect(urlsUtils.sanitizeImageSrc(gif)).toEqual(gif);
const jpeg = "data:image/jpeg;base64,/9j/4AAQSkZJRg==";
expect(urlsUtils.sanitizeImageSrc(jpeg)).toEqual(jpeg);
const webp = "data:image/webp;base64,UklGRh4AAABXRUJQVlA4TBEAAAAvAAAAAA";
expect(urlsUtils.sanitizeImageSrc(webp)).toEqual(webp);
const avif = "data:image/avif;base64,AAAAHGZ0eXBhdmlmAAAAAGF2aWY";
expect(urlsUtils.sanitizeImageSrc(avif)).toEqual(avif);
});
it("should sanitize svg data URIs (can contain inline scripts)", () => {
expect(
urlsUtils.sanitizeImageSrc("data:image/svg+xml;base64,PHN2Zy8+")
).toEqual("https://data:image/svg+xml;base64,PHN2Zy8+");
expect(
urlsUtils.sanitizeImageSrc("data:image/svg;base64,PHN2Zy8+")
).toEqual("https://data:image/svg;base64,PHN2Zy8+");
expect(
urlsUtils.sanitizeImageSrc("data:image/SVG+XML;base64,PHN2Zy8+")
).toEqual("https://data:image/SVG+XML;base64,PHN2Zy8+");
expect(
urlsUtils.sanitizeImageSrc("data:image/svg+xml,<svg></svg>")
).toEqual("https://data:image/svg+xml,<svg></svg>");
});
it("should sanitize non-image data URIs", () => {
expect(
urlsUtils.sanitizeImageSrc("data:text/html,<script>alert('hi');</script>")
).toEqual("https://data:text/html,<script>alert('hi');</script>");
});
it("should fall through to sanitizeUrl behavior for non-data-URI input", () => {
expect(urlsUtils.sanitizeImageSrc("https://example.com/a.png")).toEqual(
"https://example.com/a.png"
);
expect(urlsUtils.sanitizeImageSrc("/uploads/a.png")).toEqual(
"/uploads/a.png"
);
expect(urlsUtils.sanitizeImageSrc("javascript:alert(1)")).toEqual(
"https://javascript:alert(1)"
);
});
});
describe("parseShareIdFromUrl", () => {
it("should return share id from url with doc path", () => {
expect(
urlsUtils.parseShareIdFromUrl(
"https://app.example.com/s/my-share/doc/test-abc123"
)
).toBe("my-share");
});
it("should return share uuid from url", () => {
expect(
urlsUtils.parseShareIdFromUrl(
"https://app.example.com/s/2767ba0e-ac5c-4533-b9cf-4f5fc456600e/doc/test-abc123"
)
).toBe("2767ba0e-ac5c-4533-b9cf-4f5fc456600e");
});
it("should return share id when no doc path is present", () => {
expect(
urlsUtils.parseShareIdFromUrl("https://app.example.com/s/my-share")
).toBe("my-share");
});
it("should return undefined for non-share urls", () => {
expect(
urlsUtils.parseShareIdFromUrl("https://app.example.com/doc/test-abc123")
).toBeUndefined();
});
it("should return undefined for invalid urls", () => {
expect(urlsUtils.parseShareIdFromUrl("not a url")).toBeUndefined();
});
});
describe("#urlRegex", () => {
it("should return undefined for invalid urls", () => {
expect(urlRegex(undefined)).toBeUndefined();
expect(urlRegex(null)).toBeUndefined();
expect(urlRegex("invalid url!")).toBeUndefined();
});
it("should return corresponding regex otherwise", () => {
const regex = urlRegex("https://docs.google.com");
expect(regex?.source).toBe(
/^https:\/\/docs\.google\.com(?::443)?(?=[/?#]|$)/.source
);
expect(regex?.test("https://docs.google.com")).toBe(true);
expect(regex?.test("https://docs.google.com/")).toBe(true);
expect(regex?.test("https://docs.google.com/d/123")).toBe(true);
expect(regex?.test("http://google.com")).toBe(false);
expect(regex?.test("http://docs.google.com")).toBe(false);
expect(regex?.test("http://docs.google.com/")).toBe(false);
expect(regex?.test("http://docs.google.com/d/123")).toBe(false);
expect(regex?.test("javascript:alert(1)//https://docs.google.com")).toBe(
false
);
});
it("should only match the exact origin", () => {
const regex = urlRegex("https://docs.google.com");
expect(regex?.test("https://docs.google.com?a=1")).toBe(true);
expect(regex?.test("https://docs.google.com#a")).toBe(true);
expect(regex?.test("https://docs.google.com.evil.net/x")).toBe(false);
expect(regex?.test("https://docs.google.com@evil.net/x")).toBe(false);
expect(regex?.test("https://docs.google.com\\@evil.net/x")).toBe(false);
expect(regex?.test("https://docs.google.com:8080/x")).toBe(false);
});
it("should match a url that states the default port", () => {
for (const base of [
"https://docs.google.com",
"https://docs.google.com:443",
]) {
const regex = urlRegex(base);
expect(regex?.test("https://docs.google.com/x")).toBe(true);
expect(regex?.test("https://docs.google.com:443")).toBe(true);
expect(regex?.test("https://docs.google.com:443/x")).toBe(true);
expect(regex?.test("https://docs.google.com:4430/x")).toBe(false);
expect(regex?.test("https://docs.google.com:80/x")).toBe(false);
}
const http = urlRegex("http://docs.google.com");
expect(http?.test("http://docs.google.com:80/x")).toBe(true);
expect(http?.test("http://docs.google.com:443/x")).toBe(false);
});
it("should only match a non-default port exactly", () => {
const regex = urlRegex("https://docs.google.com:8443");
expect(regex?.test("https://docs.google.com:8443/x")).toBe(true);
expect(regex?.test("https://docs.google.com/x")).toBe(false);
expect(regex?.test("https://docs.google.com:443/x")).toBe(false);
});
});
describe("#getHostname", () => {
it("should return the hostname", () => {
expect(urlsUtils.getHostname("https://Example.com:8080/a?b=c")).toBe(
"example.com"
);
});
it("should return internationalized hostnames as punycode", () => {
expect(urlsUtils.getHostname("https://аpple.com/client.json")).toBe(
"xn--pple-43d.com"
);
});
it("should keep brackets on IPv6 hostnames", () => {
expect(urlsUtils.getHostname("http://[::1]:3000/callback")).toBe("[::1]");
});
it("should return undefined for unparseable input", () => {
expect(urlsUtils.getHostname("not a url")).toBeUndefined();
expect(urlsUtils.getHostname("")).toBeUndefined();
expect(urlsUtils.getHostname(undefined)).toBeUndefined();
});
});
describe("#removeUrlFragment", () => {
it("should remove a hash fragment", () => {
expect(
urlsUtils.removeUrlFragment("https://example.com/doc/abc#h-my-heading")
).toBe("https://example.com/doc/abc");
});
it("should leave urls without a hash untouched", () => {
expect(urlsUtils.removeUrlFragment("https://example.com/doc/abc")).toBe(
"https://example.com/doc/abc"
);
});
it("should preserve query strings", () => {
expect(
urlsUtils.removeUrlFragment("https://example.com/doc/abc?foo=bar#heading")
).toBe("https://example.com/doc/abc?foo=bar");
});
it("should fall back to string stripping for non-parseable input", () => {
expect(urlsUtils.removeUrlFragment("/doc/abc#heading")).toBe("/doc/abc");
});
});
describe("#removeUrlPathSuffix", () => {
it("should remove a trailing path suffix", () => {
expect(
urlsUtils.removeUrlPathSuffix(
"https://example.com/doc/my-doc-abc123/edit",
"/edit"
)
).toBe("https://example.com/doc/my-doc-abc123");
});
it("should not corrupt a hostname containing the suffix", () => {
expect(
urlsUtils.removeUrlPathSuffix(
"https://editing.example.com/doc/my-doc-abc123",
"/edit"
)
).toBe("https://editing.example.com/doc/my-doc-abc123");
});
it("should only strip the trailing suffix, not a match in the hostname", () => {
expect(
urlsUtils.removeUrlPathSuffix(
"https://editing.example.com/doc/my-doc-abc123/edit",
"/edit"
)
).toBe("https://editing.example.com/doc/my-doc-abc123");
});
it("should leave urls without the suffix untouched", () => {
expect(
urlsUtils.removeUrlPathSuffix(
"https://example.com/doc/my-doc-abc123",
"/edit"
)
).toBe("https://example.com/doc/my-doc-abc123");
});
it("should not strip the suffix when it is not the final path segment", () => {
expect(
urlsUtils.removeUrlPathSuffix(
"https://example.com/edit/something",
"/edit"
)
).toBe("https://example.com/edit/something");
});
it("should preserve query strings", () => {
expect(
urlsUtils.removeUrlPathSuffix(
"https://example.com/doc/abc/edit?foo=bar",
"/edit"
)
).toBe("https://example.com/doc/abc?foo=bar");
});
it("should fall back to string stripping for non-parseable input", () => {
expect(
urlsUtils.removeUrlPathSuffix("/doc/my-doc-abc123/edit", "/edit")
).toBe("/doc/my-doc-abc123");
});
});
describe("containsUrl", () => {
it("should return true for text that contains a URL", () => {
expect(urlsUtils.containsUrl("https://example.com")).toBe(true);
expect(urlsUtils.containsUrl("Client (https://example.com/mcp)")).toBe(
true
);
expect(urlsUtils.containsUrl("visit www.example.com now")).toBe(true);
});
it("should return false for text without a URL", () => {
expect(urlsUtils.containsUrl("")).toBe(false);
expect(urlsUtils.containsUrl("Acme Inc")).toBe(false);
expect(urlsUtils.containsUrl("https:")).toBe(false);
});
});