/// <inheritdoc cref="ITransformResponseBuilder.WithTransformer(TransformerType, bool)"/> public IResponseBuilder WithTransformer(TransformerType transformerType, bool transformContentFromBodyAsFile = false) { UseTransformer = true; TransformerType = transformerType; UseTransformerForBodyAsFile = transformContentFromBodyAsFile; return(this); }
public void MarkAsWinner(TransformerBattleModel autobotsTransformer, TransformerBattleModel decepticonsTransformer, TransformerType transformerType) { autobotsTransformer.TransformerBattleStatus = transformerType == TransformerType.A ? TransformerBattleStatus.Winned : TransformerBattleStatus.Losed; decepticonsTransformer.TransformerBattleStatus = transformerType == TransformerType.D ? TransformerBattleStatus.Winned : TransformerBattleStatus.Losed; }
public ScribanContextFactory(IFileSystemHandler fileSystemHandler, TransformerType transformerType) { Check.NotNull(fileSystemHandler, nameof(fileSystemHandler)); Check.Condition(transformerType, t => t == TransformerType.Scriban || t == TransformerType.ScribanDotLiquid, nameof(transformerType)); _fileSystemHandler = fileSystemHandler; _transformerType = transformerType; }
public TransformerTypeViewModel(IServiceUnitOfWork serviceUnitOfWork, TransformerType transformerType) { this.serviceUnitOfWork = serviceUnitOfWork; oldTransformerType = transformerType; TransformerType newTransformerType = new TransformerType(); newTransformerType.Name = transformerType.Name; TransformerType = newTransformerType; }
/// <inheritdoc/> public IItemMenu CreateItems(TransformerType transformerType) { return(transformerType switch { TransformerType.Tm => new TmnItemMenu(), TransformerType.Tmn => new TmnItemMenu(), TransformerType.Tmg => new TmgItemMenu(), TransformerType.Tmpng => new TmpngItemMenu(), _ => throw new ArgumentOutOfRangeException(nameof(transformerType), transformerType, null) });
public void Create_With_Scriban_TransformerType_Creates_ITransformerContext(TransformerType transformerType) { // Arrange var sut = new ScribanContextFactory(_fileSystemHandlerMock.Object, transformerType); // Act var result = sut.Create(); // Assert result.Should().NotBeNull(); }
public static Transformer CreateTransformer(TransformerType transformerType, Weapon weapon, Scanner scanner) { Transformer transformer = transformerType switch { TransformerType.OptimusPrime => new OptimusPrime(weapon, scanner), TransformerType.AutoBotX5 => new AutoBotX5(weapon, scanner), _ => throw new ArgumentOutOfRangeException($"No implementation for this type {transformerType}.") }; return(transformer); }
public async Task ImportForeignTransformerTypes(WRLDCWarehouseDbContext _context, ILogger _log, string oracleConnStr, EntityWriteOption opt) { TransformerTypeExtract transTypeExtract = new TransformerTypeExtract(); List <TransformerType> transTypes = transTypeExtract.ExtractTransformerTypes(oracleConnStr); LoadTransformerType loadTrType = new LoadTransformerType(); foreach (TransformerType trType in transTypes) { TransformerType insertedTrType = await loadTrType.LoadSingleAsync(_context, _log, trType, opt); } }
public async Task Response_ProvideResponse_Scriban_WithBodyAsFile(TransformerType transformerType) { // Assign var request = new RequestMessage(new UrlDetails("http://localhost/foo?MyUniqueNumber=1"), "GET", ClientIp); var response = Response.Create() .WithTransformer(transformerType) .WithBodyFromFile(@"c:\\{{request.query.MyUniqueNumber}}\\test.xml"); // Act var responseMessage = await response.ProvideResponseAsync(request, _settings); // Assert Check.That(responseMessage.BodyData.BodyAsFile).Equals(@"c:\1\test.xml"); }
public async Task Response_ProvideResponse_Transformer_UrlPath(TransformerType transformerType, string httpMethod) { // Assign var urlDetails = UrlUtils.Parse(new Uri("http://localhost/wiremock/a/b"), new PathString("/wiremock")); var request = new RequestMessage(urlDetails, httpMethod, ClientIp); var response = Response.Create() .WithBody("url={{request.Url}} absoluteurl={{request.AbsoluteUrl}} path={{request.Path}} absolutepath={{request.AbsolutePath}}") .WithTransformer(transformerType); // Act var responseMessage = await response.ProvideResponseAsync(request, _settings); // Assert Check.That(responseMessage.BodyData.BodyAsString).Equals("url=http://localhost/a/b absoluteurl=http://localhost/wiremock/a/b path=/a/b absolutepath=/wiremock/a/b"); }
public async Task Response_ProvideResponse_Scriban_PathSegments(TransformerType transformerType) { // Assign var urlDetails = UrlUtils.Parse(new Uri("http://localhost/wiremock/a/b"), new PathString("/wiremock")); var request = new RequestMessage(urlDetails, "POST", ClientIp); var response = Response.Create() .WithBody("{{request.PathSegments.[0]}} {{request.AbsolutePathSegments.[0]}}") .WithTransformer(transformerType); // Act var responseMessage = await response.ProvideResponseAsync(request, _settings); // Assert Check.That(responseMessage.BodyData.BodyAsString).Equals("a wiremock"); }
private static IWebhook InitWebhook( string url, string method, IDictionary <string, WireMockList <string> > headers, bool useTransformer, TransformerType transformerType) { return(new Webhook { Request = new WebhookRequest { Url = url, Method = method ?? "post", Headers = headers, UseTransformer = useTransformer, TransformerType = transformerType } }); }
public async Task Response_ProvideResponse_Transformer_UrlPathVerb(TransformerType transformerType) { // Assign var body = new BodyData { BodyAsString = "whatever", DetectedBodyType = BodyType.String }; var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "POSt", ClientIp, body); var response = Response.Create() .WithBody("test {{request.Url}} {{request.Path}} {{request.Method}}") .WithTransformer(transformerType); // Act var responseMessage = await response.ProvideResponseAsync(request, _settings); // Assert Check.That(responseMessage.BodyData.BodyAsString).Equals("test http://localhost/foo /foo POSt"); }
public async Task Response_ProvideResponse_Scriban_Query(TransformerType transformerType) { // Assign var body = new BodyData { BodyAsString = "abc", DetectedBodyType = BodyType.String }; var request = new RequestMessage(new UrlDetails("http://localhost/foo?a=1&a=2&b=5"), "POST", ClientIp, body); var response = Response.Create() .WithBody("test keya={{request.query.a}} idx={{request.query.a.[0]}} idx={{request.query.a.[1]}} keyb={{request.query.b}}") .WithTransformer(transformerType); // Act var responseMessage = await response.ProvideResponseAsync(request, _settings); // Assert Check.That(responseMessage.BodyData.BodyAsString).Equals("test keya=1 idx=1 idx=2 keyb=5"); }
public async Task Response_ProvideResponse_Transformer_StatusCodeIsNull(TransformerType transformerType) { // Assign var body = new BodyData { BodyAsString = "abc", DetectedBodyType = BodyType.String }; var request = new RequestMessage(new UrlDetails("http://localhost/foo?a=400"), "POST", ClientIp, body); var response = Response.Create() .WithBody("test") .WithTransformer(transformerType); // Act var responseMessage = await response.ProvideResponseAsync(request, _settings); // Assert Check.That(responseMessage.BodyData.BodyAsString).Equals("test"); Check.That(responseMessage.StatusCode).Equals(null); }
private static ICryptoTransform GetCryptoTransformer(TransformerType transformerType, byte[] encryptionKey) { using (var aes = Aes.Create()) { aes.BlockSize = 128; aes.KeySize = 256; aes.IV = new byte[16]; aes.Key = encryptionKey.GetHash <SHA256Managed>(); switch (transformerType) { case TransformerType.Encript: return(aes.CreateEncryptor()); case TransformerType.Decript: return(aes.CreateDecryptor()); default: throw new ArgumentOutOfRangeException(nameof(transformerType), transformerType, null); } } }
/// <see cref="IRespondWithAProvider.WithWebhook(string, string, IDictionary{string, WireMockList{string}}, object, bool, TransformerType)"/> public IRespondWithAProvider WithWebhook( [NotNull] string url, [CanBeNull] string method = "post", [CanBeNull] IDictionary <string, WireMockList <string> > headers = null, [CanBeNull] object body = null, bool useTransformer = true, TransformerType transformerType = TransformerType.Handlebars) { Webhooks = new[] { InitWebhook(url, method, headers, useTransformer, transformerType) }; if (body != null) { Webhooks[0].Request.BodyData = new BodyData { BodyAsJson = body, DetectedBodyType = BodyType.Json, DetectedBodyTypeFromContentType = BodyType.Json }; } return(this); }
public async Task Response_ProvideResponse_Scriban_Headers(TransformerType transformerType) { // Assign var body = new BodyData { BodyAsString = "abc", DetectedBodyType = BodyType.String }; var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "POST", ClientIp, body, new Dictionary <string, string[]> { { "Content-Type", new[] { "text/plain" } } }); var response = Response.Create().WithHeader("x", "{{request.Headers[\"Content-Type\"]}}", "{{request.Url}}").WithBody("test").WithTransformer(transformerType); // Act var responseMessage = await response.ProvideResponseAsync(request, _settings); // Assert Check.That(responseMessage.BodyData.BodyAsString).Equals("test"); Check.That(responseMessage.Headers).ContainsKey("x"); Check.That(responseMessage.Headers["x"]).Contains("text/plain"); Check.That(responseMessage.Headers["x"]).Contains("http://localhost/foo"); }
public async Task <TransformerType> LoadSingleAsync(WRLDCWarehouseDbContext _context, ILogger _log, TransformerType transType, EntityWriteOption opt) { // check if entity already exists TransformerType existingTrType = await _context.TransformerTypes.SingleOrDefaultAsync(trT => trT.WebUatId == transType.WebUatId); // check if we have to replace the entity completely if (opt == EntityWriteOption.Replace && existingTrType != null) { _context.TransformerTypes.Remove(existingTrType); } // if entity is not present, then insert or check if we have to replace the entity completely if (existingTrType == null || (opt == EntityWriteOption.Replace && existingTrType != null)) { _context.TransformerTypes.Add(transType); await _context.SaveChangesAsync(); return(transType); } // check if we should not modify existing entities if (opt == EntityWriteOption.DontReplace && existingTrType != null) { return(existingTrType); } // check if we have to modify the entity if (opt == EntityWriteOption.Modify && existingTrType != null) { existingTrType.Name = transType.Name; await _context.SaveChangesAsync(); return(existingTrType); } return(null); }
public void Delete(TransformerType t) { dataBase.TransformerTypes.Delete(t); dataBase.Save(); }
public async Task Response_ProvideResponse_Transformer_Origin_Port_Protocol_Host(TransformerType transformerType) { // Assign var body = new BodyData { BodyAsString = "abc", DetectedBodyType = BodyType.String }; var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body); var response = Response.Create() .WithBody("test {{request.Origin}} {{request.Port}} {{request.Protocol}} {{request.Host}}") .WithTransformer(transformerType); // Act var responseMessage = await response.ProvideResponseAsync(request, _settings); // Assert Check.That(responseMessage.BodyData.BodyAsString).Equals("test http://localhost:1234 1234 http localhost"); }
public async Task Response_ProvideResponse_Transformer_WithBodyAsJson_ResultAsObject(TransformerType transformerType) { // Assign string jsonString = "{ \"things\": [ { \"name\": \"RequiredThing\" }, { \"name\": \"Wiremock\" } ] }"; var bodyData = new BodyData { BodyAsJson = JsonConvert.DeserializeObject(jsonString), DetectedBodyType = BodyType.Json, Encoding = Encoding.UTF8 }; var request = new RequestMessage(new UrlDetails("http://localhost/foo_object"), "POST", ClientIp, bodyData); var responseBuilder = Response.Create() .WithBodyAsJson(new { x = "test {{request.Path}}" }) .WithTransformer(transformerType); // Act var response = await responseBuilder.ProvideResponseAsync(request, _settings); // Assert Check.That(JsonConvert.SerializeObject(response.Message.BodyData.BodyAsJson)).Equals("{\"x\":\"test /foo_object\"}"); }
public void Update(TransformerType t) { dataBase.TransformerTypes.Update(t); dataBase.Save(); }
public async Task <Transformer> LoadSingleAsync(WRLDCWarehouseDbContext _context, ILogger _log, TransformerForeign trForeign, EntityWriteOption opt) { // check if entity already exists Transformer existingTr = await _context.Transformers.SingleOrDefaultAsync(tr => tr.WebUatId == trForeign.WebUatId); // check if we should not modify existing entities if (opt == EntityWriteOption.DontReplace && existingTr != null) { return(existingTr); } // check if substation type is valid string ssTypeSubstation = "SubStation"; string ssTypeGenStation = "Generating Station"; if (!(trForeign.StationType == ssTypeSubstation || trForeign.StationType == ssTypeGenStation)) { _log.LogCritical($"substation type is not {ssTypeSubstation} or {ssTypeGenStation} while inserting Transformer with webUatId {trForeign.WebUatId} and name {trForeign.Name}"); return(null); } MajorSubstation hvSubstation = null; int hvSubstationWebUatId = -1; if (trForeign.StationType == ssTypeSubstation) { // The transformer is in Substation hvSubstationWebUatId = trForeign.HVStationWebUatId; hvSubstation = await _context.MajorSubstations.SingleOrDefaultAsync(hvss => hvss.WebUatId == hvSubstationWebUatId); if (hvSubstation == null) { _log.LogCritical($"Unable to find MajorSubstation with webUatId {hvSubstationWebUatId} while inserting Transformer with webUatId {trForeign.WebUatId} and name {trForeign.Name}"); return(null); } } GeneratingStation hvGenStation = null; int hvGenstationWebUatId = -1; if (trForeign.StationType == ssTypeGenStation) { // The transformer is in GeneratingStation hvGenstationWebUatId = trForeign.HVStationWebUatId; hvGenStation = await _context.GeneratingStations.SingleOrDefaultAsync(hvgt => hvgt.WebUatId == hvGenstationWebUatId); if (hvGenStation == null) { _log.LogCritical($"Unable to find GeneratingStation with webUatId {hvGenstationWebUatId} while inserting Transformer with webUatId {trForeign.WebUatId} and name {trForeign.Name}"); return(null); } } // find the HV Voltage of the Transformer via the Voltage WebUatId int hvVoltWebUatId = trForeign.HighVoltLevelWebUatId; VoltLevel hvVolt = await _context.VoltLevels.SingleOrDefaultAsync(vl => vl.WebUatId == hvVoltWebUatId); // if voltage level doesnot exist, skip the import. Ideally, there should not be such case if (hvVolt == null) { _log.LogCritical($"Unable to find HV VoltLevel with webUatId {hvVoltWebUatId} while inserting Transformer with webUatId {trForeign.WebUatId} and name {trForeign.Name}"); return(null); } // find the LV Voltage of the Transformer via the Voltage WebUatId int lvVoltWebUatId = trForeign.LowVoltLevelWebUatId; VoltLevel lvVolt = await _context.VoltLevels.SingleOrDefaultAsync(vl => vl.WebUatId == lvVoltWebUatId); // if voltage level doesnot exist, skip the import. Ideally, there should not be such case if (lvVolt == null) { _log.LogCritical($"Unable to find LV VoltLevel with webUatId {lvVoltWebUatId} while inserting Transformer with webUatId {trForeign.WebUatId} and name {trForeign.Name}"); // uncomment this after vendor complies for non null LV voltage types // return null; } // find the State of the substation via the State WebUatId int stateWebUatId = trForeign.StateWebUatId; State state = await _context.States.SingleOrDefaultAsync(s => s.WebUatId == stateWebUatId); // if state doesnot exist, skip the import. Ideally, there should not be such case if (state == null) { _log.LogCritical($"Unable to find State with webUatId {stateWebUatId} while inserting Transformer with webUatId {trForeign.WebUatId} and name {trForeign.Name}"); return(null); } // find the TransformerType of the Transformer via the TransformerTypeWebUatId int trTypeWebUatId = trForeign.TransTypeWebUatId; TransformerType trType = await _context.TransformerTypes.SingleOrDefaultAsync(trt => trt.WebUatId == trTypeWebUatId); // if TransformerType doesnot exist, skip the import. Ideally, there should not be such case if (trType == null) { _log.LogCritical($"Unable to find TransformerType with webUatId {trTypeWebUatId} while inserting Transformer with webUatId {trForeign.WebUatId} and name {trForeign.Name}"); return(null); } // check if we have to replace the entity completely if (opt == EntityWriteOption.Replace && existingTr != null) { _context.Transformers.Remove(existingTr); } // if entity is not present, then insert or check if we have to replace the entity completely if (existingTr == null || (opt == EntityWriteOption.Replace && existingTr != null)) { Transformer newTr = new Transformer(); newTr.Name = trForeign.Name; newTr.StationType = trForeign.StationType; newTr.HighVoltLevelId = hvVolt.VoltLevelId; if (lvVolt != null) { newTr.LowVoltLevelId = lvVolt.VoltLevelId; } newTr.TransformerNumber = trForeign.TransformerNumber; newTr.TransformerTypeId = trType.TransformerTypeId; newTr.StateId = state.StateId; newTr.MVACapacity = trForeign.MVACapacity; newTr.CodDate = trForeign.CodDate; newTr.CommDate = trForeign.CommDate; newTr.DecommDate = trForeign.DecommDate; newTr.WebUatId = trForeign.WebUatId; if (trForeign.StationType == ssTypeSubstation) { newTr.HvSubstationId = hvSubstation.MajorSubstationId; } else if (trForeign.StationType == ssTypeGenStation) { newTr.HvGeneratingStationId = hvGenStation.GeneratingStationId; } _context.Transformers.Add(newTr); await _context.SaveChangesAsync(); return(newTr); } // check if we have to modify the entity if (opt == EntityWriteOption.Modify && existingTr != null) { existingTr.Name = trForeign.Name; existingTr.StationType = trForeign.StationType; existingTr.HighVoltLevelId = hvVolt.VoltLevelId; if (lvVolt != null) { existingTr.LowVoltLevelId = lvVolt.VoltLevelId; } existingTr.TransformerNumber = trForeign.TransformerNumber; existingTr.TransformerTypeId = trType.TransformerTypeId; existingTr.StateId = state.StateId; existingTr.MVACapacity = trForeign.MVACapacity; existingTr.CodDate = trForeign.CodDate; existingTr.CommDate = trForeign.CommDate; existingTr.DecommDate = trForeign.DecommDate; if (trForeign.StationType == ssTypeSubstation) { existingTr.HvSubstationId = hvSubstation.MajorSubstationId; } else if (trForeign.StationType == ssTypeGenStation) { existingTr.HvGeneratingStationId = hvGenStation.GeneratingStationId; } await _context.SaveChangesAsync(); return(existingTr); } return(null); }
public void PlayOnce(TransformerType type) { switch (type) { case TransformerType.Position: currentPositioner?.Kill(); transform.localPosition = !positioner.IsReverting ? startPosition : transform.localPosition + positioner.Target; currentPositioner = transform .DOLocalMove(!positioner.IsReverting ? transform.localPosition + positioner.Target : startPosition, positioner.Duration) .SetEase(positioner.Ease) .SetUpdate(UpdateType.Normal, positioner.IsIgnoringTime) .Play(); break; case TransformerType.Rotation: currentRotater?.Kill(); Vector3 target = !rotater.IsReverting ? new Vector3(transform.localRotation.x, transform.localRotation.y, transform.localRotation.z + rotationAmplitudeFactor * rotater.AngleTarget) : startRotation; if (rotater.HasFullAmplitude) { transform.localRotation = !rotater.IsReverting ? Quaternion.Euler(new Vector3(startRotation.x, startRotation.y, startRotation.z - rotater.AngleTarget)) : Quaternion.Euler(target); currentRotater = transform .DORotate(target, rotater.Duration, RotateMode.FastBeyond360) .SetEase(rotater.Ease) .SetRelative() .SetUpdate(UpdateType.Normal, rotater.IsIgnoringTime) .Play(); } else { transform.localRotation = !rotater.IsReverting ? Quaternion.Euler(new Vector3(startRotation.x, startRotation.y, startRotation.z)) : Quaternion.Euler(target); currentRotater = transform .DORotate(target, rotater.Duration, RotateMode.FastBeyond360) .SetEase(rotater.Ease) .SetRelative() .SetUpdate(UpdateType.Normal, rotater.IsIgnoringTime) .Play(); } break; case TransformerType.Scale: currentScaler?.Kill(); float currentFactor = scaler.Factor.RandomValue; transform.localScale = !scaler.IsReverting ? startScale : startScale * currentFactor; currentScaler = transform .DOScale(!scaler.IsReverting ? startScale * currentFactor : startScale, scaler.Duration) .SetEase(scaler.Ease) .SetUpdate(UpdateType.Normal, scaler.IsIgnoringTime) .Play(); break; } }
//[InlineData(TransformerType.Scriban)] Scriban cannot access dynamic Json Objects //[InlineData(TransformerType.ScribanDotLiquid)] public async Task Response_ProvideResponse_Transformer_WithBodyAsJson_ResultAsArray(TransformerType transformerType) { // Assign string jsonString = "{ \"a\": \"test 1\", \"b\": \"test 2\" }"; var bodyData = new BodyData { BodyAsJson = JsonConvert.DeserializeObject(jsonString), DetectedBodyType = BodyType.Json, Encoding = Encoding.UTF8 }; var request = new RequestMessage(new UrlDetails("http://localhost/foo_array"), "POST", ClientIp, bodyData); var response = Response.Create() .WithBodyAsJson(new[] { "first", "{{request.path}}", "{{request.bodyAsJson.a}}", "{{request.bodyAsJson.b}}", "last" }) .WithTransformer(transformerType); // Act var responseMessage = await response.ProvideResponseAsync(request, _settings); // Assert Check.That(JsonConvert.SerializeObject(responseMessage.BodyData.BodyAsJson)).Equals("[\"first\",\"/foo_array\",\"test 1\",\"test 2\",\"last\"]"); }
public async Task Response_ProvideResponse_Transformer_WithNullBody_ShouldNotThrowException(TransformerType transformerType) { // Assign var urlDetails = UrlUtils.Parse(new Uri("http://localhost/wiremock/a/b"), new PathString("/wiremock")); var request = new RequestMessage(urlDetails, "GET", ClientIp); var response = Response.Create().WithTransformer(transformerType); // Act var responseMessage = await response.ProvideResponseAsync(request, _settings); // Assert responseMessage.BodyData.Should().BeNull(); }
public async Task Response_ProvideResponse_Transformer_WithBodyAsString_KeepsEncoding(TransformerType transformerType) { // Assign const string text = "my-text"; Encoding enc = Encoding.Unicode; var bodyData = new BodyData { BodyAsString = text, DetectedBodyType = BodyType.String, Encoding = enc }; var request = new RequestMessage(new UrlDetails("http://localhost/foo_object"), "POST", ClientIp, bodyData); var response = Response.Create() .WithBody("{{request.Body}}", BodyDestinationFormat.SameAsSource, enc) .WithTransformer(transformerType); // Act var responseMessage = await response.ProvideResponseAsync(request, _settings); // Assert responseMessage.BodyData.BodyAsString.Should().Be(text); responseMessage.BodyData.Encoding.Should().Be(enc); }
public async Task Response_ProvideResponse_Scriban_WithBodyAsJson_ResultAsTemplatedString(TransformerType transformerType) { // Assign string jsonString = "{ \"name\": \"WireMock\" }"; var bodyData = new BodyData { BodyAsJson = JsonConvert.DeserializeObject(jsonString), DetectedBodyType = BodyType.Json, Encoding = Encoding.UTF8 }; var request = new RequestMessage(new UrlDetails("http://localhost/foo_object"), "POST", ClientIp, bodyData); var response = Response.Create() .WithBodyAsJson("{{{request.BodyAsJson}}}") .WithTransformer(transformerType); // Act var responseMessage = await response.ProvideResponseAsync(request, _settings); // Assert Check.That(JsonConvert.SerializeObject(responseMessage.BodyData.BodyAsJson)).Equals("{\"name\":\"WireMock\"}"); }
//[InlineData(TransformerType.Scriban)] ["c:\\["1"]\\test.xml"] //[InlineData(TransformerType.ScribanDotLiquid)] public async Task Response_ProvideResponse_Transformer_WithBodyAsFile_And_TransformContentFromBodyAsFile(TransformerType transformerType) { // Assign var filesystemHandlerMock = new Mock <IFileSystemHandler>(MockBehavior.Strict); filesystemHandlerMock.Setup(fs => fs.ReadResponseBodyAsString(It.IsAny <string>())).Returns("<xml MyUniqueNumber=\"{{request.query.MyUniqueNumber}}\"></xml>"); _settings.FileSystemHandler = filesystemHandlerMock.Object; var request = new RequestMessage(new UrlDetails("http://localhost/foo?MyUniqueNumber=1"), "GET", ClientIp); var response = Response.Create() .WithTransformer(transformerType, true) .WithBodyFromFile(@"c:\\{{request.query.MyUniqueNumber}}\\test.xml"); // Act var responseMessage = await response.ProvideResponseAsync(request, _settings); // Assert Check.That(responseMessage.BodyData.BodyAsFile).Equals(@"c:\1\test.xml"); Check.That(responseMessage.BodyData.DetectedBodyType).Equals(BodyType.String); Check.That(responseMessage.BodyData.BodyAsString).Equals("<xml MyUniqueNumber=\"1\"></xml>"); }