Merge branch 'release/3.0.0'

Author: rhatherall

.gitignore

@@ -67,5 +67,6 @@ __recovery/
 
 # Ignore Build outputs
 Build
+TestInsightSettings.ini
 Tests/Win32
-Tests/Win64
+Tests/Win64

CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [3.0.0](https://github.com/appercept/Delphi-WebMocks/tree/3.0.0) (2021-01-27)
+
+[Full Changelog](https://github.com/appercept/Delphi-WebMocks/compare/2.0.0...3.0.0)
+
+**Implemented enhancements:**
+
+- Assertion matching by URL query parameters [\#41](https://github.com/appercept/Delphi-WebMocks/issues/41)
+- Request content matching by Form-Data [\#20](https://github.com/appercept/Delphi-WebMocks/issues/20)
+- Request matching by JSON values
+
+**Fixed bugs:**
+
+- Test failure due to platform line endings [\#43](https://github.com/appercept/Delphi-WebMocks/issues/43)
+- Request history is not persisting query parameters [\#42](https://github.com/appercept/Delphi-WebMocks/issues/42)
+
 ## [2.0.0](https://github.com/appercept/Delphi-WebMocks/tree/2.0.0) (2020-11-25)
 
 [Full Changelog](https://github.com/appercept/Delphi-WebMocks/compare/1.3.0...2.0.0)

README.md

@@ -1,4 +1,4 @@
-![Delphi compatibility](https://img.shields.io/badge/Delphi-XE8%20or%20newer-brightgreen)
+![Delphi compatibility](https://img.shields.io/badge/Delphi%20compatability-10.3%20or%20newer-brightgreen)
 ![Platform compatibility](https://img.shields.io/badge/platform-Linux64%20%7C%20macOS64%20%7C%20Win32%20%7C%20Win64-lightgrey)
 ![License](https://img.shields.io/github/license/appercept/Delphi-WebMocks)
 ![Lines of Code](https://tokei.rs/b1/github/appercept/Delphi-WebMocks)
@@ -8,14 +8,22 @@ Library for stubbing and setting expectations on HTTP requests in Delphi with
 [DUnitX](https://github.com/VSoftTechnologies/DUnitX).
 
 ## Requirements
-* [Delphi](https://www.embarcadero.com/products/delphi) XE8 or later*
+* [Delphi](https://www.embarcadero.com/products/delphi) 10.3 (Rio) or later*
 * [DUnitX](https://github.com/VSoftTechnologies/DUnitX)
 * [Indy](https://www.indyproject.org)
 
-\* WebMocks was developed in Delphi 10.3 (Rio) and 10.4 (Sydney). WebMocks has
-been reported working on 10.1 (Berlin). I'd be interested to hear from anyone
-working on other versions. As WebMocks makes use of the `System.Net`
-library introduced with XE8 it will not be compatible with earlier versions.
+\* WebMocks was developed in Delphi 10.3 (Rio) and 10.4 (Sydney) and until
+version 3.0 was compatible back to XE8. As WebMocks makes use of the
+`System.Net` library introduced with XE8 it will not be compatible with earlier
+versions. Should you require installing on Delphi versions prior to 10.3 you
+should install version
+[2.0.0](https://github.com/appercept/Delphi-WebMocks/releases/tag/2.0.0).
+
+## Installation: GetIt
+[WebMocks 2.0](https://getitnow.embarcadero.com/WebMocks-2.0/) is available
+through Embarcadero's package manager for Delphi
+[GetIt](https://getitnow.embarcadero.com/). If you have a recent version of
+Delphi including GetIt then this should be the preferred installation method.
 
 ## Installation: Delphinus-Support
 WebMocks should now be listed in
@@ -26,11 +34,11 @@ not be found in your test projects.
 
 ## Installation: Manual
 1. Download and extract the latest version
-   [2.0.0](https://github.com/appercept/Delphi-WebMocks/archive/2.0.0.zip).
+   [3.0.0](https://github.com/appercept/Delphi-WebMocks/archive/3.0.0.zip).
 2. In "Tools > Options" under the "Language / Delphi / Library" add the
    extracted `Source` directory to the "Library path" and "Browsing path".
 
-## Upgrading to versions prior to 2.0.0
+## Upgrading from versions prior to 2.0.0
 Version 2 has dropped the `Delphi.` namespace from all units. Any projects
 upgrade to version 2 or later will need to drop the `Delphi.` prefix from any
 included WebMocks units.
@@ -169,6 +177,23 @@ HTTP request can be matched by content like:
 WebMock.StubRequest('*', '*').WithBody('String content.');
 ```
 
+#### Request matching by form-data
+HTTP requests can be matched by form-data as submitted with `content-type` of
+`application/x-www-form-urlencoded`. Multiple matching field values can be
+combined. For example:
+```Delphi
+WebMock.StubRequest('*', '*')
+  .WithFormData('AField', 'A value.')
+  .WithFormData('AOtherField', 'Another value.');
+```
+
+To simply match the presence of a field, a wildcard `*` can be passed for the
+value.
+
+NOTE: You cannot match form-data (`WithFormData`) and body content (`WithBody`)
+at the same time. Specifying both will result in the latest call overwriting the
+previous matcher.
+
 #### Matching request document path, headers, or content by regular-expression
 Matching a request by regular-expression can be useful for stubbing dynamic
 routes for a ReSTful resource involving a resource name and an unknown resource
@@ -189,8 +214,37 @@ WebMock.StubRequest('*', '*')
   .WithBody(TRegEx.Create('Hello'));
 ```
 
+Matching form-data content can be performed like:
+```Delphi
+WebMock.StubRequest('*', '*')
+  .WithFormData('AField', TRegEx.Create('.*'));
+```
+
 NOTE: Be sure to add `System.RegularExpressions` to your uses clause.
 
+#### Request matching by JSON
+HTTP requests can be matched by JSON data as submitted with `content-type` of
+`application/json` using `WithJSON`. Multiple matching field values can be
+combined. For example:
+```Delphi
+WebMock.StubRequest('*', '*')
+  .WithJSON('ABoolean', True)
+  .WithJSON('AFloat', 0.123)
+  .WithJSON('AInteger', 1)
+  .WithJSON('AString', 'value');
+```
+
+The first argument can be a path. For example, in the following JSON, the path
+`objects[0].key` would match `value 1`.
+```JSON
+{
+  "objects": [
+    { "key": "value 1" },
+    { "key": "value 2" }
+  ]
+}
+```
+
 #### Request matching by predicate function
 If matching logic is required to be more complex than the simple matching, a
 predicate function can be provided in the test to allow custom inspection/logic
@@ -373,11 +427,12 @@ WebClient.Get(WebMock.URLFor('/'));
 WebMock.Assert.Get('/').WasRequested; // Passes
 ```
 
-As with request stubbing you can match requests by HTTP Method, URI, Headers,
-and Body content.
+As with request stubbing you can match requests by HTTP Method, URI, Query
+Parameters, Headers, and Body content (including `WithJSON`).
 ```Delphi
 WebMock.Assert
   .Patch('/resource`)
+  .WithQueryParam('ParamName', 'Value')
   .WithHeader('Content-Type', 'application/json')
   .WithBody('{ "resource": { "propertyA": "Value" } }')
   .WasRequested;
@@ -398,7 +453,7 @@ performing extra unwanted requests.
 This project follows [Semantic Versioning](https://semver.org).
 
 ## License
-Copyright ©2019-2020 Richard Hatherall <[email protected]>
+Copyright ©2019-2021 Richard Hatherall <[email protected]>
 
 WebMocks is distributed under the terms of the Apache License (Version 2.0).
 

Source/WebMock.Assertion.pas

@@ -2,7 +2,7 @@
 {                                                                              }
 {           Delphi-WebMocks                                                    }
 {                                                                              }
-{           Copyright (c) 2019 Richard Hatherall                               }
+{           Copyright (c) 2019-2021 Richard Hatherall                          }
 {                                                                              }
 {           [email protected]                                              }
 {           https://appercept.com                                              }
@@ -29,17 +29,20 @@ interface
 
 uses
   DUnitX.TestFramework,
-  System.Classes, System.Generics.Collections, System.RegularExpressions,
-  WebMock.HTTP.Messages, WebMock.HTTP.RequestMatcher;
+  System.Classes,
+  System.RegularExpressions,
+  System.Rtti,
+  WebMock.HTTP.Messages,
+  WebMock.HTTP.RequestMatcher;
 
 type
   TWebMockAssertion = class(TObject)
   private
-    FMatcher: TWebMockHTTPRequestMatcher;
-    FHistory: TList<IWebMockHTTPRequest>;
+    FMatcher: IWebMockHTTPRequestMatcher;
+    FHistory: IInterfaceList;
     function MatchesHistory: Boolean;
   public
-    constructor Create(AHistory: TList<IWebMockHTTPRequest>);
+    constructor Create(const AHistory: IInterfaceList);
     function Delete(const AURI: string): TWebMockAssertion;
     function Get(const AURI: string): TWebMockAssertion;
     function Patch(const AURI: string): TWebMockAssertion;
@@ -52,10 +55,18 @@   TWebMockAssertion = class(TObject)
     function WithHeader(const AName, AValue: string): TWebMockAssertion; overload;
     function WithHeader(const AName: string; const APattern: TRegEx): TWebMockAssertion; overload;
     function WithHeaders(const AHeaders: TStringList): TWebMockAssertion;
+    function WithQueryParam(const AName, AValue: string): TWebMockAssertion; overload;
+    function WithQueryParam(const AName: string; const APattern: TRegEx): TWebMockAssertion; overload;
+    function WithFormData(const AName, AValue: string): TWebMockAssertion; overload;
+    function WithFormData(const AName: string; const APattern: TRegEx): TWebMockAssertion; overload;
+    function WithJSON(const APath: string; AValue: Boolean): TWebMockAssertion; overload;
+    function WithJSON(const APath: string; AValue: Float64): TWebMockAssertion; overload;
+    function WithJSON(const APath: string; AValue: Integer): TWebMockAssertion; overload;
+    function WithJSON(const APath: string; AValue: string): TWebMockAssertion; overload;
     procedure WasRequested;
     procedure WasNotRequested;
-    property History: TList<IWebMockHTTPRequest> read FHistory;
-    property Matcher: TWebMockHTTPRequestMatcher read FMatcher;
+    property History: IInterfaceList read FHistory;
+    property Matcher: IWebMockHTTPRequestMatcher read FMatcher;
   end;
 
 implementation
@@ -64,9 +75,11 @@ implementation
 
 uses
   System.SysUtils,
-  WebMock.StringRegExMatcher, WebMock.StringWildcardMatcher;
+  WebMock.FormDataMatcher,
+  WebMock.StringRegExMatcher,
+  WebMock.StringWildcardMatcher;
 
-constructor TWebMockAssertion.Create(AHistory: TList<IWebMockHTTPRequest>);
+constructor TWebMockAssertion.Create(const AHistory: IInterfaceList);
 begin
   inherited Create;
   FHistory := AHistory;
@@ -84,12 +97,15 @@ function TWebMockAssertion.Get(const AURI: string): TWebMockAssertion;
 
 function TWebMockAssertion.MatchesHistory: Boolean;
 var
+  I: Integer;
   LRequest: IWebMockHTTPRequest;
 begin
   Result := False;
 
-  for LRequest in History do
+  for I := 0 to History.Count - 1 do
   begin
+    LRequest := History[I] as IWebMockHTTPRequest;
+
     if Matcher.IsMatch(LRequest) then
     begin
       Result := True;
@@ -130,51 +146,69 @@ function TWebMockAssertion.Request(const AMethod, AURI: string): TWebMockAsserti
 
 procedure TWebMockAssertion.WasNotRequested;
 begin
-  if MatchesHistory then
-    Assert.Fail(Format('Found request matching %s', [Matcher.ToString]))
-  else
-    Assert.Pass(Format('Did not find request matching %s', [Matcher.ToString]));
+  try
+    if MatchesHistory then
+      Assert.Fail(Format('Found request matching %s', [Matcher.ToString]))
+    else
+      Assert.Pass(Format('Did not find request matching %s', [Matcher.ToString]));
+  finally
+    Free;
+  end;
 end;
 
 procedure TWebMockAssertion.WasRequested;
 begin
-  if MatchesHistory then
-    Assert.Pass(Format('Found request matching %s', [Matcher.ToString]))
-  else
-    Assert.Fail(Format('Expected to find request matching %s', [Matcher.ToString]));
+  try
+    if MatchesHistory then
+      Assert.Pass(Format('Found request matching %s', [Matcher.ToString]))
+    else
+      Assert.Fail(Format('Expected to find request matching %s', [Matcher.ToString]));
+  finally
+    Free;
+  end;
 end;
 
 function TWebMockAssertion.WithBody(const APattern: TRegEx): TWebMockAssertion;
 begin
-  Matcher.Body := TWebMockStringRegExMatcher.Create(APattern);
+  Matcher.Builder.WithBody(APattern);
+
+  Result := Self;
+end;
+
+function TWebMockAssertion.WithFormData(const AName: string;
+  const APattern: TRegEx): TWebMockAssertion;
+begin
+  Matcher.Builder.WithFormData(AName, APattern);
+
+  Result := Self;
+end;
+
+function TWebMockAssertion.WithFormData(const AName,
+  AValue: string): TWebMockAssertion;
+begin
+  Matcher.Builder.WithFormData(AName, AValue);
 
   Result := Self;
 end;
 
 function TWebMockAssertion.WithHeader(const AName,
   AValue: string): TWebMockAssertion;
 begin
-  Matcher.Headers.AddOrSetValue(
-    AName,
-    TWebMockStringWildcardMatcher.Create(AValue)
-  );
+  Matcher.Builder.WithHeader(AName, AValue);
 
   Result := Self;
 end;
 
 function TWebMockAssertion.WithBody(const AContent: string): TWebMockAssertion;
 begin
-  Matcher.Body := TWebMockStringWildcardMatcher.Create(AContent);
+  Matcher.Builder.WithBody(AContent);
 
   Result := Self;
 end;
 
 function TWebMockAssertion.WithHeader(const AName: string; const APattern: TRegEx): TWebMockAssertion;
 begin
-  Matcher.Headers.AddOrSetValue(
-    AName,
-    TWebMockStringRegExMatcher.Create(APattern)
-  );
+  Matcher.Builder.WithHeader(AName, APattern);
 
   Result := Self;
 end;
@@ -190,4 +224,52 @@ function TWebMockAssertion.WithHeaders(
   Result := Self;
 end;
 
+function TWebMockAssertion.WithJSON(const APath: string;
+  AValue: Boolean): TWebMockAssertion;
+begin
+  Matcher.Builder.WithJSON(APath, AValue);
+
+  Result := Self;
+end;
+
+function TWebMockAssertion.WithJSON(const APath: string;
+  AValue: Float64): TWebMockAssertion;
+begin
+  Matcher.Builder.WithJSON(APath, AValue);
+
+  Result := Self;
+end;
+
+function TWebMockAssertion.WithJSON(const APath: string;
+  AValue: Integer): TWebMockAssertion;
+begin
+  Matcher.Builder.WithJSON(APath, AValue);
+
+  Result := Self;
+end;
+
+function TWebMockAssertion.WithJSON(const APath: string;
+  AValue: string): TWebMockAssertion;
+begin
+  Matcher.Builder.WithJSON(APath, AValue);
+
+  Result := Self;
+end;
+
+function TWebMockAssertion.WithQueryParam(const AName: string;
+  const APattern: TRegEx): TWebMockAssertion;
+begin
+  Matcher.Builder.WithQueryParam(AName, APattern);
+
+  Result := Self;
+end;
+
+function TWebMockAssertion.WithQueryParam(const AName,
+  AValue: string): TWebMockAssertion;
+begin
+  Matcher.Builder.WithQueryParam(AName, AValue);
+
+  Result := Self;
+end;
+
 end.