Merge pull request #151 from stas-pavlov/main

Add support for withUrlMatching matching

Author: pimterry

src/rules/base-rule-builder.ts

@@ -30,7 +30,8 @@ import {
     CallbackMatcher,
     HostnameMatcher,
     PortMatcher,
-    ProtocolMatcher
+    ProtocolMatcher,
+    RegexUrlMatcher
 } from "./matchers";
 
 /**
@@ -236,14 +237,23 @@ export abstract class BaseRuleBuilder {
     }
 
     /**
-     * Match only requests that sent with the given protocol.
+     * Match only requests sent with the given protocol.
      * @category Matching
      */
     withProtocol(protocol: "http" | "https" | "ws" | "wss"): this {
         this.matchers.push(new ProtocolMatcher(protocol));
         return this;
     }
 
+    /**
+     * Match only requests whose absolute url matches the given RegExp.
+     * @category Matching
+     */
+    withUrlMatching(pattern: RegExp): this {
+        this.matchers.push(new RegexUrlMatcher(pattern));
+        return this;
+    }
+
     /**
      * Match only requests when the callback returns true
      * @category Matching

src/rules/matchers.ts

@@ -260,6 +260,32 @@ export class RegexPathMatcher extends Serializable implements RequestMatcher {
 
 }
 
+export class RegexUrlMatcher extends Serializable implements RequestMatcher {
+    readonly type = 'regex-url';
+
+    readonly regexSource: string;
+    readonly regexFlags: string;
+
+    constructor(regex: RegExp) {
+        super();
+        this.regexSource = regex.source;
+        this.regexFlags = regex.flags;
+    }
+
+    matches(request: OngoingRequest) {
+        const absoluteUrl = normalizeUrl(request.url);
+
+        // Test the matcher against the full URL
+        const urlMatcher = new RegExp(this.regexSource, this.regexFlags);
+        return urlMatcher.test(absoluteUrl);
+    }
+
+    explain() {
+        return `matching URL /${unescapeRegexp(this.regexSource)}/${this.regexFlags ?? ''}`;
+    }
+
+}
+
 export class HeaderMatcher extends Serializable implements RequestMatcher {
     readonly type = 'header';
 
@@ -590,6 +616,7 @@ export const MatcherLookup = {
     'port': PortMatcher,
     'simple-path': SimplePathMatcher,
     'regex-path': RegexPathMatcher,
+    'regex-url': RegexUrlMatcher,
     'header': HeaderMatcher,
     'query': QueryMatcher,
     'exact-query-string': ExactQueryMatcher,

test/integration/matchers/method-path-matching.spec.ts

@@ -120,6 +120,34 @@ responses by hand.`);
         await expect(result).to.have.responseText('Fake file');
     });
 
+    it("should regex match requests for a matching full URL", async () => {
+        await server.forGet(/localhost:\d+\/[\w\-]+.txt/).thenReply(200, 'Fake file');
+
+        let result = await fetch(server.urlFor('/matching-file.txt'));
+
+        await expect(result).to.have.responseText('Fake file');
+    });
+
+    it("should not negative-regex match requests by full URL with forX matchers", async () => {
+        // It's not so much that this is desired behaviour - more that it follows from the
+        // definition of forGet matching, and we want to preserve it for now, as opposed
+        // to usage of withUrlMatching (below) which does _not_ behave like this.
+
+        await server.forGet(/^(?!.*localhost)/).thenReply(200, 'Fake file');
+
+        let result = await fetch(server.urlFor('/matching-file.txt'));
+
+        await expect(result).to.have.responseText('Fake file');
+    });
+
+    it("should negative-regex match requests by full URL with withUrlMatching", async () => {
+        await server.forGet().withUrlMatching(/^(?!.*localhost)/).thenReply(200, 'Fake file');
+
+        let result2 = await fetch(server.urlFor('/matching-file.txt'));
+
+        await expect(result2).to.have.responseText(/^.*No rules*./);
+    });
+
     it("should reject requests for the wrong path", async () => {
         await server.forGet("/specific-endpoint").thenReply(200, "mocked data");