delphimvcframework/unittests/general/Several/LiveServerTestU.pas

// ***************************************************************************
//
// Delphi MVC Framework
//
// Copyright (c) 2010-2017 Daniele Teti and the DMVCFramework Team
//
// https://github.com/danieleteti/delphimvcframework
//
// ***************************************************************************
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// *************************************************************************** }

unit LiveServerTestU;

interface

uses
  JsonDataObjects,
  DUnitX.TestFramework,
  MVCFramework.RESTClient;

const

  {$IFDEF LINUX_SERVER}

  TEST_SERVER_ADDRESS = '192.168.1.8';

  {$ELSE}

  TEST_SERVER_ADDRESS = '127.0.0.1';

  {$ENDIF}

type

  [TestFixture]
  TBaseServerTest = class(TObject)
  protected
    RESTClient: TRESTClient;
    procedure DoLoginWith(UserName: string);
    procedure DoLogout;

  public
    [SetUp]
    procedure SetUp;
    [TearDown]
    procedure TearDown;

  end;

  TServerTest = class(TBaseServerTest)
  public
    [Test]
    procedure TestReqWithParams;

    // URL_MAPPED_PARAMS_ALLOWED_CHARS = ' <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>@\[\]\{\}\(\)\=;&#\.\_\,%\w\d\x2D\x3A';
    [Test]
    [TestCase('1', ' <20>,<2C>')]
    [TestCase('2', '<27>,<2C>,<2C>')]
    [TestCase('2', '<27>,@,[')]
    [TestCase('2', '],{,}')]
    [TestCase('2', '(,),\')]
    [TestCase('2', '=,;,&')]
    [TestCase('2', '#,.,_')]
    [TestCase('2', '%, , ')]
    procedure TestReqWithURLMappedParams(const par1, par2, par3: string);
    [Test]
    procedure TestPOSTWithParamsAndJSONBody;
    [Test]
    // procedure TestPATCHWithParamsAndJSONBody;
    [Test]
    procedure TestPOSTWithObjectJSONBody;
    [Test]
    procedure TestPUTWithParamsAndJSONBody;
    [Test]
    procedure TestCookies;
    [Test]
    procedure TestSessionWithLogin;
    [Test]
    procedure TestSession;
    [Test]
    procedure TestInvalidateSession;
    [Test]
    procedure TestAsynchRequestPOST;
    [Test]
    procedure TestAsynchRequestPUT;
    [Test]
    procedure TestAsynchRequestGET;
    [Test]
    procedure TestAsynchRequestDELETE;
    [Test]
    procedure TestEncodingRenderJSONValue;
    [Test]
    procedure TestRenderWrappedList;
    [Test]
    procedure TestRenderStreamAndFreeWithOwnerFalse;
    [Test]
    procedure TestRenderStreamAndFreeWithOwnerTrue;
    [Test]
    // procedure TestSerializationType;
    [Test]
    procedure TestProducesConsumes01;
    [Test]
    procedure TestProducesConsumes02;
    [Test]
    procedure TestProducesConsumes03;
    [Test]
    procedure TestProducesConsumesWithWrongAcceptHeader;
    [Test]
    procedure TestExceptionInMVCAfterCreate;
    [Test]
    procedure TestExceptionInMVCBeforeDestroy;
    [Test]
    procedure TestActionFiltersOnBeforeAction;
    [Test]
    procedure TestMiddlewareSpeedMiddleware;
    [Test]
    procedure TestMiddlewareHandler;
    [Test]
    procedure TestPostAListOfObjects;
    // test authentication/authorization with BasicAuth
    procedure TestBasicAuth01;
    [Test]
    procedure TestBasicAuth02;
    [Test]
    procedure TestBasicAuth03;
    [Test]
    procedure TestBasicAuth04;
    [Test]
    procedure TestBasicAuth05;
    // test authentication/authorization with CustomAuth
    [Test]
    procedure TestCustomAuthRequestWithoutLogin;
    [Test]
    procedure TestCustomAuthRequestsWithValidLogin;
    [Test]
    procedure TestCustomAuthRequestsWithValidLogin_HTML;
    [Test]
    procedure TestCustomAuthWrongRequestBodies;
    [Test]
    procedure TestCustomAuthLoginLogout;

    // typed actions
    [Test]
    procedure TestTypedString1;
    [Test]
    procedure TestTypedInteger1;
    [Test]
    procedure TestTypedInt641;
    [Test]
    procedure TestTypedSingle1;
    [Test]
    procedure TestTypedDouble1;
    [Test]
    procedure TestTypedExtended1;
    [Test]
    procedure TestTypedAll;
    [Test]
    procedure TestTypedDateTimeTypes;
    [Test]
    procedure TestTypedBooleans;
  end;

  [TestFixture]
  TJSONRPCServerTest = class(TBaseServerTest)
  public
    [Test]
    procedure TestRequestWithoutParams;
    [Test]
    procedure TestRequestToNotFoundMethod;
    [Test]
    procedure TestRequestWithParams_I_I_ret_I;
    [Test]
    procedure TestRequestWithParams_I_I_I_ret_O;
    [Test]
    procedure TestRequest_S_I_ret_S;
    [Test]
    procedure TestRequestWithParams_I_I_ret_A;
  end;

implementation

uses
  System.Math,
  MVCFramework.Serializer.Defaults,
  MVCFramework.TypesAliases,
  MVCFramework.Commons,
  System.SyncObjs,
  System.Generics.Collections,
  System.SysUtils,
  BusinessObjectsU,
  MVCFramework.Serializer.Commons,
  Soap.EncdDecd,
  System.Classes,
  MVCFramework.SystemJSONUtils, IdCookie, MVCFramework.JSONRPC;

{ TServerTest }

procedure TBaseServerTest.DoLogout;
var
  res: IRESTResponse;
begin
  res := RESTClient.doGET('/logout', []);
  Assert.isTrue(res.ResponseCode = HTTP_STATUS.OK, 'Logout Failed');
end;

procedure TBaseServerTest.SetUp;
begin
  inherited;
  RESTClient := TRESTClient.Create(TEST_SERVER_ADDRESS, 9999);
  RESTClient.ReadTimeout(60 * 1000 * 30);
end;

procedure TBaseServerTest.TearDown;
begin
  inherited;
  RESTClient.Free;
end;

procedure TServerTest.TestActionFiltersOnBeforeAction;
var
  res: IRESTResponse;
begin
  res := RESTClient.doGET('/actionfilters/beforeaction/alwayscalled', []);
  Assert.areEqual<Integer>(HTTP_STATUS.OK, res.ResponseCode);

  res := RESTClient.doGET('/actionfilters/beforeaction/nevercalled', []);
  Assert.areEqual<Integer>(HTTP_STATUS.NotFound, res.ResponseCode);
end;

procedure TServerTest.TestAsynchRequestDELETE;
var
  evt: TEvent;
  r: TWaitResult;
  OK: boolean;
begin
  OK := false;
  evt := TEvent.Create;
  try
    RESTClient.Asynch(
      procedure(Response: IRESTResponse)
      begin
        OK := true;
        evt.SetEvent;
      end,
      procedure(E: Exception)
      begin
        OK := false;
      end).doDELETE('/req/with/params', ['1', '2', '3']);

    // wait for thred finish
    repeat
      r := evt.WaitFor(2000);
    until r = TWaitResult.wrSignaled;

    Assert.AreEqual(true, OK);
  finally
    evt.Free;
  end;
end;

procedure TServerTest.TestAsynchRequestGET;
var
  evt: TEvent;
  r: TWaitResult;
  j: TJSONObject;
begin
  j := nil;
  evt := TEvent.Create;
  try
    RESTClient.Asynch(
      procedure(Response: IRESTResponse)
      begin
        try
          j := TSystemJSON.StringAsJSONObject(Response.BodyAsString);
        except
          // test should not block...never!
        end;
        evt.SetEvent;
      end,
      procedure(E: Exception)
      begin
      end).doGET('/req/with/params', ['1', '2', '3']);

    // wait for thred finish
    repeat
      r := evt.WaitFor(2000);
    until r = TWaitResult.wrSignaled;

    Assert.isTrue(Assigned(j));
    Assert.AreEqual('1', j.Get('par1').JsonValue.Value);
    j.Free;
  finally
    evt.Free;
  end;
end;

procedure TServerTest.TestAsynchRequestPOST;
var
  evt: TEvent;
  r: TWaitResult;
  j: TJSONObject;
begin
  j := nil;
  evt := TEvent.Create;
  try

    RESTClient.Asynch(
      procedure(Response: IRESTResponse)
      begin
        try
          j := TSystemJSON.StringAsJSONObject(Response.BodyAsString);
        except
          // test should not block...never!
        end;
        evt.SetEvent;
      end,
      procedure(E: Exception)
      begin
      end).doPOST('/echo', ['1', '2', '3'],
      TSystemJSON.JSONValueToString(TJSONObject.Create(TJSONPair.Create('from client', 'hello world')))
      );

    // wait for thred finish
    repeat
      r := evt.WaitFor(2000);
    until r = TWaitResult.wrSignaled;

    Assert.isTrue(Assigned(j));
    Assert.AreEqual('from server', j.Get('echo').JsonValue.Value);
    j.Free;
  finally
    evt.Free;
  end;
end;

procedure TServerTest.TestAsynchRequestPUT;
var
  evt: TEvent;
  r: TWaitResult;
  j: TJSONObject;
begin
  j := nil;
  evt := TEvent.Create;
  try
    RESTClient.Asynch(
      procedure(Response: IRESTResponse)
      begin
        try
          j := TSystemJSON.StringAsJSONObject(Response.BodyAsString);
        except
          // test should not block...never!
        end;
        evt.SetEvent;
      end,
      procedure(E: Exception)
      begin
      end).doPUT('/echo', ['1', '2', '3'],
      TSystemJSON.JSONValueToString(TJSONObject.Create(TJSONPair.Create('from client', 'hello world'))));

    // wait for thred finish
    repeat
      r := evt.WaitFor(2000);
    until r = TWaitResult.wrSignaled;

    Assert.isTrue(Assigned(j));
    Assert.AreEqual('from server', j.Get('echo').JsonValue.Value);
    j.Free;
  finally
    evt.Free;
  end;
end;

procedure TServerTest.TestBasicAuth01;
var
  LRes: IRESTResponse;
begin
  RESTClient.Authentication('user1', 'user1');
  Assert.AreEqual('user1', RESTClient.UserName);
  Assert.AreEqual('user1', RESTClient.Password);
  LRes := RESTClient.doGET('/private/role1', []);
  Assert.areEqual<Integer>(HTTP_STATUS.OK, LRes.ResponseCode);
end;

procedure TServerTest.TestBasicAuth02;
var
  LRes: IRESTResponse;
begin
  RESTClient.UserName := '';
  RESTClient.Password := '';
  RESTClient.UseBasicAuthentication := false;
  LRes := RESTClient.doGET('/private/role1', []);
  Assert.areEqual<Integer>(HTTP_STATUS.Unauthorized, LRes.ResponseCode);
end;

procedure TServerTest.TestBasicAuth03;
var
  LRes: IRESTResponse;
begin
  RESTClient.UserName := 'user1';
  RESTClient.Password := 'user1';
  RESTClient.UseBasicAuthentication := true;
  LRes := RESTClient.doGET('/private/role2', []);
  Assert.areEqual<Integer>(HTTP_STATUS.Forbidden, LRes.ResponseCode);
end;

procedure TServerTest.TestBasicAuth04;
var
  LRes: IRESTResponse;
begin
  RESTClient.UserName := 'user1';
  RESTClient.Password := 'user1';
  RESTClient.UseBasicAuthentication := true;
  LRes := RESTClient.doGET('/private/role1', []);
  Assert.areEqual<Integer>(HTTP_STATUS.OK, LRes.ResponseCode);
  LRes := RESTClient.doGET('/people', []);
  Assert.areEqual<Integer>(HTTP_STATUS.OK, LRes.ResponseCode);
end;

procedure TServerTest.TestBasicAuth05;
var
  LRes: IRESTResponse;
begin
  RESTClient.UserName := 'user1';
  RESTClient.Password := 'user1';
  RESTClient.UseBasicAuthentication := true;

  // first
  LRes := RESTClient.doGET('/private/role1session?value=danieleteti', []);
  Assert.areEqual<Integer>(HTTP_STATUS.OK, LRes.ResponseCode);
  LRes := RESTClient.doGET('/private/role1session', []);
  Assert.areEqual<Integer>(HTTP_STATUS.OK, LRes.ResponseCode);
  Assert.AreEqual('danieleteti', LRes.BodyAsString);

  // second
  LRes := RESTClient.doGET('/private/role1session?value=johndoe', []);
  Assert.areEqual<Integer>(HTTP_STATUS.OK, LRes.ResponseCode);
  LRes := RESTClient.doGET('/private/role1session', []);
  Assert.areEqual<Integer>(HTTP_STATUS.OK, LRes.ResponseCode);
  Assert.AreEqual('johndoe', LRes.BodyAsString);
end;

procedure TServerTest.TestCookies;
var
  res: IRESTResponse;
  I: Integer;
begin
  res := RESTClient.doGET('/lotofcookies', []);
  Assert.areEqual<Integer>(HTTP_STATUS.OK, res.ResponseCode);
  Assert.AreEqual(4, res.Cookies.Count, 'Wrong number of cookies');
  for I := 0 to 3 do
  begin
    Assert.AreEqual('usersettings' + IntToStr(I + 1),
      res.Cookies.Cookies[I].CookieName);
    Assert.AreEqual('usersettings' + IntToStr(I + 1) + '-value',
      res.Cookies.Cookies[I].Value);
    Assert.AreEqual('/usersettings' + IntToStr(I + 1), res.Cookies.Cookies[I].Path);
  end;

end;

procedure TServerTest.TestCustomAuthRequestWithoutLogin;
var
  LRes: IRESTResponse;
begin
  LRes := RESTClient.doGET('/privatecustom/role1', []);
  Assert.areEqual<Integer>(HTTP_STATUS.Unauthorized, LRes.ResponseCode);
  Assert.AreEqual('/system/users/logged', LRes.HeaderValue('X-LOGIN-URL'));
  Assert.AreEqual('POST', LRes.HeaderValue('X-LOGIN-METHOD'));

  LRes := RESTClient.doGET('/privatecustom/role2', []);
  Assert.areEqual<Integer>(HTTP_STATUS.Unauthorized, LRes.ResponseCode);
  Assert.AreEqual('/system/users/logged', LRes.HeaderValue('X-LOGIN-URL'));
  Assert.AreEqual('POST', LRes.HeaderValue('X-LOGIN-METHOD'));
end;

procedure TServerTest.TestCustomAuthRequestsWithValidLogin;
var
  LRes: IRESTResponse;
  lJSON: TJSONObject;
  lCookieValue: string;
begin
  lJSON := TJSONObject.Create;
  try
    lJSON.AddPair('username', 'user1');
    lJSON.AddPair('password', 'user1');
    LRes := RESTClient.doPOST('/system/users/logged', [], TSystemJSON.JSONValueToString(lJSON, False));
    Assert.AreEqual('application/json', LRes.ContentType);
    Assert.areEqual<Integer>(HTTP_STATUS.OK, LRes.ResponseCode);
    Assert.AreEqual('/system/users/logged', LRes.HeaderValue('X-LOGOUT-URL'));
    Assert.AreEqual('DELETE', LRes.HeaderValue('X-LOGOUT-METHOD'));
    Assert.AreEqual('{"status":"OK"}', LRes.BodyAsString);
    lCookieValue := LRes.Cookies
      [LRes.Cookies.GetCookieIndex(TMVCConstants.SESSION_TOKEN_NAME)].Value;
    Assert.AreNotEqual('', lCookieValue, 'Session cookie not returned after login');
    Assert.isFalse(lCookieValue.Contains('invalid'),
      'Returned an invalid session token');

    LRes := RESTClient.doGET('/privatecustom/role2', []);
    Assert.areEqual<Integer>(HTTP_STATUS.Forbidden, LRes.ResponseCode,
      'Authorization not respected for not allowed action');

    LRes := RESTClient.doGET('/privatecustom/role1', []);
    Assert.areEqual<Integer>(HTTP_STATUS.OK, LRes.ResponseCode,
      'Authorization not respected for allowed action');
  finally
    lJSON.Free;
  end;
end;

procedure TServerTest.TestCustomAuthRequestsWithValidLogin_HTML;
var
  LRes: IRESTResponse;
  lJSON: TJSONObject;
  lCookieValue: string;
begin
  lJSON := TJSONObject.Create;
  try
    lJSON.AddPair('username', 'user1');
    lJSON.AddPair('password', 'user1');
    LRes := RESTClient.Accept('text/html').doPOST('/system/users/logged', [], TSystemJSON.JSONValueToString(lJSON, False));
    Assert.AreEqual('application/json', LRes.ContentType);
    Assert.areEqual<Integer>(HTTP_STATUS.OK, LRes.ResponseCode);
    Assert.AreEqual('/system/users/logged', LRes.HeaderValue('X-LOGOUT-URL'));
    Assert.AreEqual('DELETE', LRes.HeaderValue('X-LOGOUT-METHOD'));
    Assert.AreEqual('{"status":"OK"}', LRes.BodyAsString);
    lCookieValue := LRes.Cookies
      [LRes.Cookies.GetCookieIndex(TMVCConstants.SESSION_TOKEN_NAME)].Value;
    Assert.AreNotEqual('', lCookieValue, 'Session cookie not returned after login');
    Assert.isFalse(lCookieValue.Contains('invalid'),
      'Returned an invalid session token');

    LRes := RESTClient.doGET('/privatecustom/role2', []);
    Assert.areEqual<Integer>(HTTP_STATUS.Forbidden, LRes.ResponseCode,
      'Authorization not respected for not allowed action');

    LRes := RESTClient.doGET('/privatecustom/role1', []);
    Assert.areEqual<Integer>(HTTP_STATUS.OK, LRes.ResponseCode,
      'Authorization not respected for allowed action');
  finally
    lJSON.Free;
  end;
end;

procedure TServerTest.TestCustomAuthWrongRequestBodies;
var
  LRes: IRESTResponse;
  lJSON: TJSONObject;
begin
  lJSON := TJSONObject.Create;
  try
    // no request body
    LRes := RESTClient.doPOST('/system/users/logged', []);
    Assert.AreEqual<Integer>(HTTP_STATUS.BadRequest, LRes.ResponseCode,
      'Empty request body doesn''t return HTTP 400 Bad Request');

    // wrong request body 1
    LRes := RESTClient.doPOST('/system/users/logged', [], TSystemJSON.JSONValueToString(lJSON, False));
    Assert.AreEqual<Integer>(HTTP_STATUS.Unauthorized, LRes.ResponseCode,
      'Invalid json doesn''t return HTTP 401 Unauthorized');

    // wrong request body 2
    lJSON.AddPair('username', '');
    lJSON.AddPair('password', '');
    LRes := RESTClient.doPOST('/system/users/logged', [], TSystemJSON.JSONValueToString(lJSON, False));
    Assert.AreEqual<Integer>(HTTP_STATUS.Unauthorized, LRes.ResponseCode,
      'Empty username and password doesn''t return HTTP 401 Unauthorized');

    // wrong username and password 3
    lJSON.RemovePair('username').Free;
    lJSON.RemovePair('password').Free;
    lJSON.AddPair('username', 'notvaliduser');
    lJSON.AddPair('password', 'notvalidpassword');
    LRes := RESTClient.doPOST('/system/users/logged', [], TSystemJSON.JSONValueToString(lJSON, False));
    Assert.AreEqual<Integer>(HTTP_STATUS.Unauthorized, LRes.ResponseCode,
      'Wrong username and password doesn''t return HTTP 401 Unauthorized');
  finally
    lJSON.Free;
  end;
end;

procedure TServerTest.TestCustomAuthLoginLogout;
var
  LRes: IRESTResponse;
  lJSON: TJSONObject;
  lLogoutUrl: string;
  lValue: string;
  I: Integer;
  lPieces: TArray<string>;
  lPass: boolean;
begin
  lJSON := TJSONObject.Create;
  try
    lJSON.AddPair('username', 'user1');
    lJSON.AddPair('password', 'user1');
    LRes := RESTClient.doPOST('/system/users/logged', [], TSystemJSON.JSONValueToString(lJSON, False));

    Assert.areEqual<Integer>(HTTP_STATUS.OK, LRes.ResponseCode);
    lLogoutUrl := LRes.HeaderValue('X-LOGOUT-URL');

    LRes := RESTClient.doDELETE(lLogoutUrl, []);
    lPass := false;
    for I := 0 to LRes.Headers.Count do
    begin
      lValue := LRes.Headers[I];
      if lValue.StartsWith('Set-Cookie') then
      begin
        lPieces := lValue.Split([':']);
        lValue := lPieces[1].Trim;
        if lValue.StartsWith(TMVCConstants.SESSION_TOKEN_NAME) and
          lValue.Contains('invalid') then
        begin
          lPass := true;
          Break;
        end;
      end;
    end;
    Assert.isTrue(lPass, 'No session cookie cleanup in the response');
  finally
    lJSON.Free;
  end;

end;

procedure TServerTest.TestEncodingRenderJSONValue;
var
  res: IRESTResponse;
  s: string;
  lJSONObj: TJSONObject;
begin
  res := RESTClient.doGET('/encoding', []);

  lJSONObj := TSystemJSON.StringAsJSONObject(res.BodyAsString);
  s := lJSONObj.Get('name1').JsonValue.Value;
  Assert.AreEqual('j<>rn', s);
  lJSONObj.Free;

  lJSONObj := TSystemJSON.StringAsJSONObject(res.BodyAsString);
  s := lJSONObj.Get('name3').JsonValue.Value;
  Assert.AreEqual('<27><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>', s);
  lJSONObj.Free;

  lJSONObj := TSystemJSON.StringAsJSONObject(res.BodyAsString);
  s := lJSONObj.Get('name2').JsonValue.Value;
  Assert.AreEqual('<27>to je Unicode?', s,
    'If this test fail, check http://qc.embarcadero.com/wc/qcmain.aspx?d=119779');
  lJSONObj.Free;
  { WARNING!!! }
  {
    If this test fail, check
    http://qc.embarcadero.com/wc/qcmain.aspx?d=119779
  }
end;

procedure TServerTest.TestRenderStreamAndFreeWithOwnerFalse;
var
  LRes: IRESTResponse;
begin
  LRes := RESTClient.doGET('/renderstreamandfreewithownerfalse', []);
  Assert.areEqual<Integer>(200, LRes.ResponseCode);
end;

procedure TServerTest.TestRenderStreamAndFreeWithOwnerTrue;
var
  LRes: IRESTResponse;
begin
  LRes := RESTClient.doGET('/renderstreamandfreewithownertrue', []);
  Assert.areEqual<Integer>(200, LRes.ResponseCode);
end;

procedure TServerTest.TestRenderWrappedList;
var
  LRes: IRESTResponse;
  lJSONArr: TJSONArray;
  I: Integer;
  lJSONObj: TJSONObject;
begin
  LRes := RESTClient.doGET('/wrappedpeople', []);

  lJSONArr := TSystemJSON.StringAsJSONArray(LRes.BodyAsString);
  try
    for I := 0 to lJSONArr.Count - 1 do
    begin
      lJSONObj := lJSONArr.Items[I] as TJSONObject;
      Assert.isFalse(lJSONObj.GetValue<string>('firstname').IsEmpty);
    end;
  finally
    lJSONArr.Free;
  end;

end;

procedure TServerTest.TestExceptionInMVCAfterCreate;
var
  res: IRESTResponse;
begin
  res := RESTClient.doGET('/exception/aftercreate/nevercalled', []);
  Assert.areEqual<Integer>(HTTP_STATUS.InternalServerError, res.ResponseCode);
end;

procedure TServerTest.TestExceptionInMVCBeforeDestroy;
var
  res: IRESTResponse;
begin
  res := RESTClient.doGET('/exception/beforedestroy/nevercalled', []);
  Assert.areEqual<Integer>(HTTP_STATUS.InternalServerError, res.ResponseCode);
end;

procedure TServerTest.TestInvalidateSession;
var
  c1: TRESTClient;
  res: IRESTResponse;
begin
  c1 := TRESTClient.Create(TEST_SERVER_ADDRESS, 9999);
  try
    c1.Accept(TMVCMediaType.APPLICATION_JSON);
    c1.doPOST('/session', ['daniele teti']); // imposto un valore in sessione
    res := c1.doGET('/session', []); // rileggo il valore dalla sessione
    Assert.AreEqual('daniele teti', res.BodyAsString);
    c1.SessionID := '';
    res := c1.doGET('/session', []); // rileggo il valore dalla sessione
    Assert.AreEqual('', res.BodyAsString);
  finally
    c1.Free;
  end;
end;

procedure TServerTest.TestMiddlewareHandler;
var
  r: IRESTResponse;
begin
  r := RESTClient.Accept(TMVCMediaType.APPLICATION_JSON)
    .doGET('/handledbymiddleware', []);
  Assert.AreEqual('This is a middleware response', r.BodyAsString);
  Assert.areEqual<Integer>(HTTP_STATUS.OK, r.ResponseCode);
end;

procedure TServerTest.TestMiddlewareSpeedMiddleware;
var
  r: IRESTResponse;
  P: TPerson;
begin
  P := TPerson.Create;
  try
    P.FirstName := StringOfChar('*', 1000);
    P.LastName := StringOfChar('*', 1000);
    P.DOB := EncodeDate(1979, 1, 1);
    P.Married := true;
    r := RESTClient.Accept(TMVCMediaType.APPLICATION_JSON)
      .doPOST('/objects', [], GetDefaultSerializer.SerializeObject(P));
  finally
    P.Free;
  end;

  Assert.AreNotEqual('', r.HeaderValue('request_gen_time'));
end;

// procedure TServerTest.TestPATCHWithParamsAndJSONBody;
// var
// r: IRESTResponse;
// json: TJSONObject;
// begin
// json := TJSONObject.Create;
// json.AddPair('client', 'clientdata');
// r := RESTClient.doPATCH('/echo', ['1', '2', '3'], json);
// Assert.AreEqual('clientdata', r.BodyAsJsonObject.Get('client').JsonValue.Value);
// Assert.AreEqual('from server', r.BodyAsJsonObject.Get('echo').JsonValue.Value);
// end;

procedure TServerTest.TestPostAListOfObjects;
var
  LRes: IRESTResponse;
  LCustomers: TObjectList<TCustomer>;
begin
  LCustomers := TCustomer.GetList;
  try
    LRes := RESTClient.doPOST('/customers/list', [],
      GetDefaultSerializer.SerializeCollection(LCustomers)
    { Mapper.ObjectListToJSONArray<TCustomer>(LCustomers) }
      );
    Assert.areEqual<Integer>(HTTP_STATUS.OK, LRes.ResponseCode);
  finally
    LCustomers.Free;
  end;
end;

procedure TServerTest.TestPOSTWithObjectJSONBody;
var
  r: IRESTResponse;
  P: TPerson;
begin
  P := TPerson.Create;
  try
    P.FirstName := 'Daniele';
    P.LastName := '<27><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>';
    P.DOB := EncodeDate(1979, 1, 1);
    P.Married := true;
    try
      r := RESTClient.Accept(TMVCMediaType.APPLICATION_JSON)
        .doPOST('/objects', [],
        GetDefaultSerializer.SerializeObject(P)
      { Mapper.ObjectToJSONObject(P) }
        );
    except
      Assert.Fail('If this test fail, check http://qc.embarcadero.com/wc/qcmain.aspx?d=119779');
      { WARNING!!! }
      {
        If this test fail, check
        http://qc.embarcadero.com/wc/qcmain.aspx?d=119779
      }
      raise;

    end;
  finally
    P.Free;
  end;

  P := TPerson.Create;
  try
    GetDefaultSerializer.DeserializeObject(r.BodyAsString, P);
    // P := Mapper.JSONObjectToObject<TPerson>(r.BodyAsJsonObject);
    Assert.AreEqual('Daniele', P.FirstName);
    Assert.AreEqual('<27><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>', P.LastName);
    Assert.AreEqual(true, P.Married);
    Assert.AreEqual(EncodeDate(1979, 1, 1), P.DOB);
  finally
    P.Free;
  end;
end;

procedure TServerTest.TestPOSTWithParamsAndJSONBody;
var
  r: IRESTResponse;
  JSON: TJSONObject;
begin
  JSON := TJSONObject.Create;
  JSON.AddPair('client', 'clientdata');
  r := RESTClient.doPOST('/echo', ['1', '2', '3'], TSystemJSON.JSONValueToString(JSON));
  JSON := TSystemJSON.StringAsJSONObject(r.BodyAsString);
  try
    Assert.AreEqual('clientdata', JSON.Get('client').JsonValue.Value);
    Assert.AreEqual('from server', JSON.Get('echo').JsonValue.Value);
  finally
    JSON.Free;
  end;
end;

procedure TServerTest.TestProducesConsumesWithWrongAcceptHeader;
var
  res: IRESTResponse;
begin
  res := RESTClient.Accept('text/plain')
  // action is waiting for a accept: application/json
    .ContentType('application/json').doPOST('/testconsumes', [],
    TSystemJSON.JSONValueToString(TJSONString.Create('Hello World')));
  Assert.areEqual<Integer>(HTTP_STATUS.NotFound, res.ResponseCode);
end;

procedure TServerTest.TestProducesConsumes01;
var
  res: IRESTResponse;
begin
  res := RESTClient.Accept('application/json').ContentType('application/json')
    .ContentCharSet('utf-8').doPOST('/testconsumes', [],
    TSystemJSON.JSONValueToString(TJSONString.Create('Hello World')));
  Assert.areEqual<Integer>(HTTP_STATUS.OK, res.ResponseCode);
  Assert.AreEqual('Hello World', res.BodyAsString);
  Assert.AreEqual('application/json', res.ContentType);
  Assert.AreEqual('utf-8', res.ContentEncoding);
end;

procedure TServerTest.TestProducesConsumes02;
var
  res: IRESTResponse;
begin
  res := RESTClient.Accept('text/plain')
    .ContentType('text/plain')
    .doPOST('/testconsumes', [], 'Hello World');
  Assert.AreEqual('Hello World', res.BodyAsString);
  Assert.AreEqual('text/plain', res.ContentType);
  Assert.AreEqual('UTF-8', res.ContentEncoding);

  res := RESTClient.Accept('text/plain').ContentType('application/json')
    .doPOST('/testconsumes', [], '{"name": "Daniele"}');
  Assert.areEqual<Integer>(HTTP_STATUS.NotFound, res.ResponseCode);
end;

procedure TServerTest.TestProducesConsumes03;
var
  res: IRESTResponse;
begin
  res := RESTClient
    .Accept(TMVCMediaType.TEXT_PLAIN)
    .ContentType(BuildContentType(TMVCMediaType.TEXT_PLAIN, TMVCCharSet.ISO88591))
    .doPOST('/testconsumes/textiso8859_1', [],
    '<27><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>');
  Assert.areEqual<Integer>(HTTP_STATUS.OK, res.ResponseCode);
  Assert.AreNotEqual('<27><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>', res.BodyAsString, 'non iso8859-1 text is rendered ok whan should not');
  Assert.AreEqual(TMVCMediaType.TEXT_PLAIN, res.ContentType);
  Assert.AreEqual(TMVCCharSet.ISO88591, res.ContentEncoding.ToLower);

  res := RESTClient
    .Accept(TMVCMediaType.TEXT_PLAIN)
    .ContentType(BuildContentType(TMVCMediaType.TEXT_PLAIN, TMVCCharSet.ISO88591))
    .doPOST('/testconsumes/textiso8859_1', [],
    'this is an iso8859-1 text');
  Assert.areEqual<Integer>(HTTP_STATUS.OK, res.ResponseCode);
  Assert.AreEqual('this is an iso8859-1 text', res.BodyAsString);
  Assert.AreEqual(TMVCMediaType.TEXT_PLAIN, res.ContentType);
  Assert.AreEqual(TMVCCharSet.ISO88591, res.ContentEncoding.ToLower);

end;

procedure TServerTest.TestPUTWithParamsAndJSONBody;
var
  r: IRESTResponse;
  JSON: TJSONObject;
begin
  JSON := TJSONObject.Create;
  JSON.AddPair('client', 'clientdata');
  r := RESTClient.doPUT('/echo', ['1', '2', '3'], TSystemJSON.JSONValueToString(JSON));

  JSON := TSystemJSON.StringAsJSONObject(r.BodyAsString);
  try
    Assert.AreEqual('clientdata', JSON.Get('client').JsonValue.Value);
    Assert.AreEqual('from server', JSON.Get('echo').JsonValue.Value);
  finally
    JSON.Free;
  end;
end;

procedure TServerTest.TestReqWithParams;
var
  ss: TStringStream;
  lJSON: TJSONObject;
  r: IRESTResponse;
begin
  r := RESTClient.doGET('/unknownurl/bla/bla', []);

  ss := TStringStream.Create;
  try
    ss.CopyFrom(r.Body, 0);
    Assert.AreEqual(ss.DataString, r.BodyAsString,
      'In case of protocol error, the body doesn''t contain the same of BodyAsString');
  finally
    ss.Free;
  end;

  Assert.areEqual<Integer>(HTTP_STATUS.NotFound, r.ResponseCode, '/unknownurl/bla/bla');

  r := RESTClient.doGET('/req/with/params/', []);
  Assert.areEqual<Integer>(HTTP_STATUS.NotFound, r.ResponseCode, '/req/with/params/');

  r := RESTClient.doGET('/req/with/params', []);
  Assert.areEqual<Integer>(HTTP_STATUS.NotFound, r.ResponseCode, '/req/with/params');

  r := RESTClient.doGET('/req/with/params', ['1', '2', '3']);
  Assert.areEqual<Integer>(HTTP_STATUS.OK, r.ResponseCode);

  lJSON := TSystemJSON.StringAsJSONObject(r.BodyAsString);
  try
    Assert.AreEqual('1', lJSON.Get('par1').JsonValue.Value);
    Assert.AreEqual('2', lJSON.Get('par2').JsonValue.Value);
    Assert.AreEqual('3', lJSON.Get('par3').JsonValue.Value);
    Assert.AreEqual('GET', lJSON.Get('method').JsonValue.Value);

    r := RESTClient.doPOST('/req/with/params', ['1', '2', '3']);
    Assert.areEqual<Integer>(HTTP_STATUS.NotFound, r.ResponseCode);

    r := RESTClient.doPUT('/req/with/params', ['1', '2', '3']);
    Assert.areEqual<Integer>(HTTP_STATUS.NotFound, r.ResponseCode);

    r := RESTClient.doDELETE('/req/with/params', ['1', '2', '3']);
    Assert.areEqual<Integer>(HTTP_STATUS.OK, r.ResponseCode);
    Assert.AreEqual('', r.BodyAsString);
  finally
    lJSON.Free;
  end;

end;

procedure TServerTest.TestReqWithURLMappedParams(const par1, par2, par3: string);
var
  r: IRESTResponse;
begin
  r := RESTClient.doGET('/req/with/params', [par1, par2, par3]);
  Assert.areEqual<Integer>(HTTP_STATUS.OK, r.ResponseCode,
    Format('URL mapped fails for these characters: "%s","%s","%s"', [par1, par2, par3]));
end;

// procedure TServerTest.TestSerializationType;
// var
// LResp: IRESTResponse;
// LPersonProps, LPersonFlds: TPerson;
// LObj: TObject;
// begin
// LResp := RESTClient.doGET('/people', ['1']);
// LPersonProps := Mapper.JSONObjectToObject<TPerson>(LResp.BodyAsJsonObject);
// try
// LResp := RESTClient.doGET('/people', ['1', 'asfields']);
// LObj := Mapper.JSONObjectFieldsToObject(LResp.BodyAsJsonObject);
// try
// Assert.AreEqual('BusinessObjectsU.TPerson', LObj.QualifiedClassName);
// LPersonFlds := TPerson(LObj);
// Assert.isTrue(LPersonFlds.Equals(LPersonProps),
// 'Object tranferred using field serialization is different from the object serialized in the default way');
// finally
// LObj.Free;
// end;
// finally
// LPersonProps.Free;
// end;
// end;

procedure TServerTest.TestSession;
var
  c1: TRESTClient;
  res: IRESTResponse;
  s: string;
begin
  c1 := TRESTClient.Create(TEST_SERVER_ADDRESS, 9999);
  try
    c1.Accept(TMVCMediaType.APPLICATION_JSON);
    res := c1.doPOST('/session', ['daniele teti']); // imposto un valore in sessione
    s := res.HeaderValue('Set-Cookie');
    Assert.isFalse(s.Contains('Expires'), 'Session cookie contains "expires" attribute');
    res := c1.doGET('/session', []); // rileggo il valore dalla sessione
    Assert.AreEqual('daniele teti', res.BodyAsString);
    c1.Accept(TMVCMediaType.TEXT_PLAIN);
    res := c1.doGET('/session', []);
    // rileggo il valore dalla sessione
    Assert.AreEqual('daniele teti', res.BodyAsString);

    // aggiungo altri cookies
    res := c1.doGET('/lotofcookies', []); // rileggo il valore dalla sessione
    Assert.areEqual<Integer>(HTTP_STATUS.OK, res.ResponseCode);
    c1.Accept(TMVCMediaType.TEXT_PLAIN);
    res := c1.doGET('/session', []); // rileggo il valore dalla sessione
    Assert.AreEqual('daniele teti', res.BodyAsString);
  finally
    c1.Free;
  end;
end;

procedure TServerTest.TestSessionWithLogin;
begin
  DoLoginWith('daniele');
  DoLogout;
end;

procedure TServerTest.TestTypedAll;
var
  res: IRESTResponse;
  lJObj: TJSONObject;
begin
  // ----------------------'/typed/all/($ParString)/($ParInteger)/($ParInt64)/($ParSingle)/($ParDouble)/($ParExtended)')', []);
  res := RESTClient.doGET
    ('/typed/all/mystring/1234/12345678/12.3/1234.5678/1234.5678', []);
  Assert.isTrue(res.ResponseCode = HTTP_STATUS.OK, 'Cannot route');
  lJObj := TSystemJSON.StringAsJSONObject(res.BodyAsString);
  try
    Assert.AreEqual('mystring', lJObj.GetValue('ParString').Value, 'ParString');
    Assert.AreEqual(1234, TJSONNumber(lJObj.GetValue('ParInteger')).AsInt,
      'ParInteger');
    Assert.AreEqual(int64(12345678), TJSONNumber(lJObj.GetValue('ParInt64')).AsInt64,
      'ParInt64');
    Assert.AreEqual(12.3, RoundTo(TJSONNumber(lJObj.GetValue('ParSingle')).AsDouble,
      -1), 'ParSingle');
    Assert.AreEqual(1234.5678, RoundTo(TJSONNumber(lJObj.GetValue('ParDouble'))
      .AsDouble, -4), 'ParDouble');
    Assert.AreEqual(1234.5678, RoundTo(TJSONNumber(lJObj.GetValue('ParExtended'))
      .AsDouble, -4), 'ParExtended');
  finally
    lJObj.Free;
  end;
end;

procedure TServerTest.TestTypedBooleans;
var
  res: IRESTResponse;
begin
  res := RESTClient.doGET('/typed/booleans/true/false/1/0', []);
  Assert.isTrue(res.ResponseCode = HTTP_STATUS.OK, 'Cannot route');
  Assert.AreEqual('true.false.true.false', res.BodyAsString.ToLower);
end;

procedure TServerTest.TestTypedDouble1;
var
  res: IRESTResponse;
begin
  res := RESTClient.doGET('/typed/double1/1234.5678', []);
  Assert.isTrue(res.ResponseCode = HTTP_STATUS.OK, 'Cannot route');
  Assert.AreEqual('1234.5678 modified from server', res.BodyAsString);

end;

procedure TServerTest.TestTypedExtended1;
var
  res: IRESTResponse;
begin
  res := RESTClient.doGET('/typed/extended1/1234.5678', []);
  Assert.isTrue(res.ResponseCode = HTTP_STATUS.OK, 'Cannot route');
  Assert.AreEqual('1234.5678 modified from server', res.BodyAsString);

end;

procedure TServerTest.TestTypedInt641;
var
  res: IRESTResponse;
begin
  res := RESTClient.doGET('/typed/int641/12345678', []);
  Assert.isTrue(res.ResponseCode = HTTP_STATUS.OK, 'Cannot route');
  Assert.AreEqual('12345678 modified from server', res.BodyAsString);
end;

procedure TServerTest.TestTypedInteger1;
var
  res: IRESTResponse;
begin
  res := RESTClient.doGET('/typed/integer1/1234', []);
  Assert.isTrue(res.ResponseCode = HTTP_STATUS.OK, 'Cannot route');
  Assert.AreEqual('1234 modified from server', res.BodyAsString);
end;

procedure TServerTest.TestTypedSingle1;
var
  res: IRESTResponse;
begin
  res := RESTClient.doGET('/typed/single1/1234.5', []);
  Assert.isTrue(res.ResponseCode = HTTP_STATUS.OK, 'Cannot route');
  Assert.AreEqual('1234.5 modified from server', res.BodyAsString);

end;

procedure TServerTest.TestTypedString1;
var
  res: IRESTResponse;
begin
  res := RESTClient.doGET('/typed/string1/daniele', []);
  Assert.isTrue(res.ResponseCode = HTTP_STATUS.OK, 'Cannot route');
  Assert.AreEqual('daniele modified from server', res.BodyAsString);
end;

procedure TServerTest.TestTypedDateTimeTypes;
var
  res: IRESTResponse;
begin
  // TDate, wrong and correct
  res := RESTClient.doGET('/typed/tdate1/20161012', []);
  Assert.areEqual<Integer>(HTTP_STATUS.InternalServerError, res.ResponseCode, 'wrong TDate');

  res := RESTClient.doGET('/typed/tdate1/2016-10-12', []);
  Assert.areEqual<Integer>(HTTP_STATUS.OK, res.ResponseCode);
  Assert.AreEqual('2016-10-12 modified from server', res.BodyAsString);

  // TDateTime, wrong and correct
  res := RESTClient.doGET('/typed/tdatetime1/20161', []);
  Assert.areEqual<Integer>(HTTP_STATUS.InternalServerError, res.ResponseCode,
    'wrong TDateTime (1)');

  // Wrong
  res := RESTClient.doGET('/typed/tdatetime1/20161012121212', []);
  Assert.areEqual<Integer>(HTTP_STATUS.InternalServerError, res.ResponseCode, 'wrong TDateTime (2)');

  // Correct without 'T'
  res := RESTClient.doGET('/typed/tdatetime1/2016-10-12 12:12:12', []);
  Assert.areEqual<Integer>(HTTP_STATUS.OK, res.ResponseCode, 'wrong TDateTime (3)');
  Assert.AreEqual('2016-10-12T12:12:12.000Z modified from server', res.BodyAsString);

  // Correct in extended form
  res := RESTClient.doGET('/typed/tdatetime1/2016-10-12T12:12:12', []);
  Assert.areEqual<Integer>(HTTP_STATUS.OK, res.ResponseCode);
  Assert.AreEqual('2016-10-12T12:12:12.000Z modified from server', res.BodyAsString);

  // Correct in extended form with timezone
  res := RESTClient.doGET('/typed/tdatetime1/2016-10-12T12:12:12.000Z', []);
  Assert.areEqual<Integer>(HTTP_STATUS.OK, res.ResponseCode);
  Assert.AreEqual('2016-10-12T12:12:12.000Z modified from server', res.BodyAsString);

  // TTime, wrong and correct
  res := RESTClient.doGET('/typed/ttime1/121212', []);
  Assert.areEqual<Integer>(HTTP_STATUS.InternalServerError, res.ResponseCode, 'wrong TTime');

  res := RESTClient.doGET('/typed/ttime1/12:12:12', []);
  Assert.areEqual<Integer>(HTTP_STATUS.OK, res.ResponseCode);
  Assert.AreEqual('12:12:12 modified from server', res.BodyAsString);

end;

procedure TBaseServerTest.DoLoginWith(UserName: string);
var
  res: IRESTResponse;
begin
  res := RESTClient.doGET('/login', [UserName]);
  Assert.isTrue(res.ResponseCode = HTTP_STATUS.OK, 'Login Failed');
end;

{ TJSONRPCServerTest }

procedure TJSONRPCServerTest.TestRequestToNotFoundMethod;
var
  lReq: TJSONRPCRequest;
  lHttpResp: IRESTResponse;
  lResp: TJSONRPCResponse;
begin
  lReq := tjsonrpcrequest.Create;
  try
    lReq.Method := 'nonexist';
    lHttpResp := RESTClient
      .ContentType(TMVCMediaType.APPLICATION_JSON)
      .Accept(TMVCMediaType.APPLICATION_JSON)
      .doPOST('/jsonrpc', [], lReq.AsJSONString);
    Assert.IsNotEmpty(lHttpResp.BodyAsString);
    Assert.AreEqual(http_status.NotFound, Integer(lHttpResp.ResponseCode));

    lResp := TJSONRPCResponse.Create;
    try
      lResp.AsJSONString := lHttpResp.BodyAsString;
      Assert.IsNotNull(lResp.Error);
      Assert.AreEqual(-32601, lResp.Error.Code);
      Assert.IsTrue(lResp.Error.ErrMessage.StartsWith('Method not found'));
    finally
      lResp.Free;
    end;

  finally
    lReq.Free;
  end;
end;

procedure TJSONRPCServerTest.TestRequestWithoutParams;
var
  lReq: TJSONRPCRequest;
  lResp: IRESTResponse;
begin
  lReq := TJSONRPCRequest.Create;
  try
    lReq.Method := 'mynotify';
    lResp := RESTClient
      .ContentType(TMVCMediaType.APPLICATION_JSON)
      .Accept(TMVCMediaType.APPLICATION_JSON)
      .doPOST('/jsonrpc', [], lReq.AsJSONString);
    Assert.IsEmpty(lResp.BodyAsString);
    Assert.AreEqual(http_status.NoContent, Integer(lResp.ResponseCode));
  finally
    lReq.Free;
  end;
end;

procedure TJSONRPCServerTest.TestRequestWithParams_I_I_ret_I;
var
  lReq: TJSONRPCRequest;
  lHttpResp: IRESTResponse;
  lRPCResp: TJSONRPCResponse;
  lResp: TJSONRPCResponse;
begin
  lReq := TJSONRPCRequest.Create;
  try
    lReq.RequestID := 1234;
    lReq.Method := 'subtract';
    lReq.Params.Add(18);
    lReq.Params.Add(8);
    lHttpResp := RESTClient
      .ContentType(TMVCMediaType.APPLICATION_JSON)
      .Accept(TMVCMediaType.APPLICATION_JSON)
      .doPOST('/jsonrpc', [], lReq.AsJSONString);
    Assert.IsNotEmpty(lHttpResp.BodyAsString);
    Assert.AreEqual(http_status.OK, Integer(lHttpResp.ResponseCode));
    lResp := TJSONRPCResponse.Create;
    try
      lResp.AsJSONString := lHttpResp.BodyAsString;
      Assert.AreEqual(10, lResp.Result.AsInteger);
      Assert.AreEqual(1234, lResp.RequestID.AsInteger);
    finally
      lResp.Free;
    end;

  finally
    lReq.Free;
  end;
end;

procedure TJSONRPCServerTest.TestRequestWithParams_I_I_ret_A;
var
  lReq: TJSONRPCRequest;
  lResp: IRESTResponse;
  lRPCResp: TJSONRPCResponse;
  lS: string;
  lArr: TJDOJsonArray;
  I: Integer;
  x: Integer;
begin
  lReq := TJSONRPCRequest.Create;
  try
    lReq.AsJSONString := '{"jsonrpc": "2.0", "method": "GetListFromTo", "params": [1, 5], "id": 1234}';
    lResp := RESTClient
      .ContentType(TMVCMediaType.APPLICATION_JSON)
      .Accept(TMVCMediaType.APPLICATION_JSON)
      .doPOST('/jsonrpc', [], lReq.AsJSONString);
    Assert.IsNotEmpty(lResp.BodyAsString);
    Assert.AreEqual(http_status.OK, Integer(lResp.ResponseCode));
    lRPCResp := TJSONRPCResponse.Create;
    try
      lRPCResp.AsJSONString := lResp.BodyAsString;
      lArr := TJDOJsonArray(lRPCResp.Result.AsObject);
      x := 1;
      for I := 0 to lArr.Count - 1 do
      begin
        Assert.AreEqual(x, lArr[I].IntValue);
        inc(x);
      end;
    finally
      lRPCResp.Free;
    end;
  finally
    lReq.Free;
  end;
end;

procedure TJSONRPCServerTest.TestRequestWithParams_I_I_I_ret_O;
var
  lReq: TJSONRPCRequest;
  lResp: IRESTResponse;
  lRPCResp: TJSONRPCResponse;
  lS: string;
begin
  lReq := TJSONRPCRequest.Create;
  try
    lReq.AsJSONString := '{"jsonrpc": "2.0", "method": "add", "params": [3, 4, 5], "id": 1234}';
    lResp := RESTClient
      .ContentType(TMVCMediaType.APPLICATION_JSON)
      .Accept(TMVCMediaType.APPLICATION_JSON)
      .doPOST('/jsonrpc', [], lReq.AsJSONString);
    Assert.IsNotEmpty(lResp.BodyAsString);
    Assert.AreEqual(http_status.OK, Integer(lResp.ResponseCode));
    lRPCResp := TJSONRPCResponse.Create;
    try
      lRPCResp.AsJSONString := lResp.BodyAsString;
      lS := (lRPCResp.Result.AsObject as TJDOJsonObject).ToJSON();
      Assert.AreEqual(12, TJDOJsonObject(lRPCResp.Result.AsObject).I['res']);
    finally
      lRPCResp.Free;
    end;
  finally
    lReq.Free;
  end;
end;

procedure TJSONRPCServerTest.TestRequest_S_I_ret_S;
var
  lReq: TJSONRPCRequest;
  lResp: IRESTResponse;
  lRPCResp: TJSONRPCResponse;
begin
  lReq := TJSONRPCRequest.Create;
  try
    lReq.AsJSONString := '{"jsonrpc": "2.0", "method": "MultiplyString", "params": ["Daniele", 4], "id": 1234}';
    lResp := RESTClient
      .ContentType(TMVCMediaType.APPLICATION_JSON)
      .Accept(TMVCMediaType.APPLICATION_JSON)
      .doPOST('/jsonrpc', [], lReq.AsJSONString);
    Assert.IsNotEmpty(lResp.BodyAsString);
    Assert.AreEqual(http_status.OK, Integer(lResp.ResponseCode));
    lRPCResp := TJSONRPCResponse.Create;
    try
      lRPCResp.AsJSONString := lResp.BodyAsString;
      Assert.AreEqual('DanieleDanieleDanieleDaniele', lRPCResp.Result.AsString);
    finally
      lRPCResp.Free;
    end;
  finally
    lReq.Free;
  end;
end;

initialization

TDUnitX.RegisterTestFixture(TServerTest);
TDUnitX.RegisterTestFixture(TJSONRPCServerTest);

end.