public static ModifiableRecordSession LoadRecordSession(string path)
{
using var stream = System.IO.File.OpenRead(path);
using var doc = JsonDocument.Parse(stream);
return(new ModifiableRecordSession(RecordSession.Deserialize(doc.RootElement)));
}
public void CanRoundtripSessionRecord(string body, string contentType)
{
byte[] bodyBytes = Encoding.UTF8.GetBytes(body);
var session = new RecordSession();
session.Variables["a"] = "value a";
session.Variables["b"] = "value b";
RecordEntry recordEntry = new RecordEntry();
recordEntry.Request.Headers.Add("Content-Type", new[] { contentType });
recordEntry.Request.Headers.Add("Other-Header", new[] { "multi", "value" });
recordEntry.Request.Body = bodyBytes;
recordEntry.RequestUri = "url";
recordEntry.RequestMethod = RequestMethod.Delete;
recordEntry.Response.Headers.Add("Content-Type", new[] { contentType });
recordEntry.Response.Headers.Add("Other-Response-Header", new[] { "multi", "value" });
recordEntry.Response.Body = bodyBytes;
recordEntry.StatusCode = 202;
session.Entries.Add(recordEntry);
var arrayBufferWriter = new ArrayBufferWriter <byte>();
using var jsonWriter = new Utf8JsonWriter(arrayBufferWriter, new JsonWriterOptions()
{
Indented = true
});
session.Serialize(jsonWriter);
jsonWriter.Flush();
TestContext.Out.WriteLine(Encoding.UTF8.GetString(arrayBufferWriter.WrittenMemory.ToArray()));
var document = JsonDocument.Parse(arrayBufferWriter.WrittenMemory);
var deserializedSession = RecordSession.Deserialize(document.RootElement);
Assert.AreEqual("value a", deserializedSession.Variables["a"]);
Assert.AreEqual("value b", deserializedSession.Variables["b"]);
RecordEntry deserializedRecord = deserializedSession.Entries.Single();
Assert.AreEqual(RequestMethod.Delete, recordEntry.RequestMethod);
Assert.AreEqual("url", recordEntry.RequestUri);
Assert.AreEqual(202, recordEntry.StatusCode);
CollectionAssert.AreEqual(new[] { contentType }, deserializedRecord.Request.Headers["content-type"]);
CollectionAssert.AreEqual(new[] { "multi", "value" }, deserializedRecord.Request.Headers["other-header"]);
CollectionAssert.AreEqual(new[] { contentType }, deserializedRecord.Response.Headers["content-type"]);
CollectionAssert.AreEqual(new[] { "multi", "value" }, deserializedRecord.Response.Headers["other-response-header"]);
CollectionAssert.AreEqual(bodyBytes, deserializedRecord.Request.Body);
CollectionAssert.AreEqual(bodyBytes, deserializedRecord.Response.Body);
}
public static RecordingHandler LoadRecordSessionIntoInMemoryStore(string path)
{
using var stream = System.IO.File.OpenRead(path);
using var doc = JsonDocument.Parse(stream);
var guid = Guid.NewGuid().ToString();
var session = new ModifiableRecordSession(RecordSession.Deserialize(doc.RootElement));
RecordingHandler handler = new RecordingHandler(Directory.GetCurrentDirectory());
handler.InMemorySessions.TryAdd(guid, session);
return(handler);
}
public async Task TestCanSkipRecordingEntireRequestResponse()
{
var currentPath = Directory.GetCurrentDirectory();
var httpContext = new DefaultHttpContext();
var pathToRecording = "recordings/skip_entry";
var mockClient = new HttpClient(new MockHttpHandler());
var recordingHandler = new RecordingHandler(currentPath)
{
RedirectableClient = mockClient,
RedirectlessClient = mockClient
};
var fullPathToRecording = Path.Combine(currentPath, pathToRecording) + ".json";
recordingHandler.StartRecording(pathToRecording, httpContext.Response);
var sessionId = httpContext.Response.Headers["x-recording-id"].ToString();
CreateRecordModeRequest(httpContext, "request-response");
await recordingHandler.HandleRecordRequestAsync(sessionId, httpContext.Request, httpContext.Response);
httpContext = new DefaultHttpContext();
// send a second request that SHOULD be recorded
CreateRecordModeRequest(httpContext);
httpContext.Request.Headers.Remove("x-recording-skip");
httpContext.Request.Body = TestHelpers.GenerateStreamRequestBody("{ \"key\": \"value\" }");
await recordingHandler.HandleRecordRequestAsync(sessionId, httpContext.Request, httpContext.Response);
recordingHandler.StopRecording(sessionId);
try
{
using var fileStream = File.Open(fullPathToRecording, FileMode.Open);
using var doc = JsonDocument.Parse(fileStream);
var record = RecordSession.Deserialize(doc.RootElement);
Assert.Single(record.Entries);
var entry = record.Entries.First();
Assert.Equal("value", JsonDocument.Parse(entry.Request.Body).RootElement.GetProperty("key").GetString());
Assert.Equal(MockHttpHandler.DefaultResponse, Encoding.UTF8.GetString(entry.Response.Body));
}
finally
{
File.Delete(fullPathToRecording);
}
}
public async Task StartPlaybackAsync(string sessionId, HttpResponse outgoingResponse, RecordingType mode = RecordingType.FilePersisted)
{
var id = Guid.NewGuid().ToString();
ModifiableRecordSession session;
if (mode == RecordingType.InMemory)
{
if (!InMemorySessions.TryGetValue(sessionId, out session))
{
throw new HttpException(HttpStatusCode.BadRequest, $"There is no in-memory session with id {sessionId} available for playback retrieval.");
}
session.SourceRecordingId = sessionId;
}
else
{
var path = GetRecordingPath(sessionId);
if (!File.Exists(path))
{
throw new TestRecordingMismatchException($"Recording file path {path} does not exist.");
}
using var stream = System.IO.File.OpenRead(path);
using var doc = await JsonDocument.ParseAsync(stream).ConfigureAwait(false);
session = new ModifiableRecordSession(RecordSession.Deserialize(doc.RootElement))
{
Path = path
};
}
if (!PlaybackSessions.TryAdd(id, session))
{
throw new HttpException(HttpStatusCode.InternalServerError, $"Unexpectedly failed to add new playback session under id {id}.");
}
outgoingResponse.Headers.Add("x-recording-id", id);
var json = JsonSerializer.Serialize(session.Session.Variables);
outgoingResponse.Headers.Add("Content-Type", "application/json");
// Write to the response
await outgoingResponse.WriteAsync(json);
}
public void BodyNormalizationWorksWhenMatching(string body, string contentType)
{
byte[] bodyBytes = Encoding.UTF8.GetBytes(body);
var session = new RecordSession();
session.Variables["a"] = "value a";
session.Variables["b"] = "value b";
RecordEntry recordEntry = new RecordEntry();
recordEntry.Request.Headers.Add("Content-Type", new[] { contentType });
recordEntry.Request.Headers.Add("Other-Header", new[] { "multi", "value" });
recordEntry.Request.Body = bodyBytes;
recordEntry.RequestUri = "http://localhost/";
recordEntry.RequestMethod = RequestMethod.Delete;
recordEntry.Response.Headers.Add("Content-Type", new[] { contentType });
recordEntry.Response.Headers.Add("Other-Response-Header", new[] { "multi", "value" });
recordEntry.Response.Body = bodyBytes;
recordEntry.StatusCode = 202;
session.Entries.Add(recordEntry);
var arrayBufferWriter = new ArrayBufferWriter <byte>();
using var jsonWriter = new Utf8JsonWriter(arrayBufferWriter, new JsonWriterOptions()
{
Indented = true
});
session.Serialize(jsonWriter);
jsonWriter.Flush();
var document = JsonDocument.Parse(arrayBufferWriter.WrittenMemory);
var deserializedSession = RecordSession.Deserialize(document.RootElement);
var matcher = new RecordMatcher();
Assert.NotNull(deserializedSession.Lookup(recordEntry, matcher, new[] { new RecordedTestSanitizer() }));
}
public async Task TestCanSkipRecordingRequestBody()
{
var currentPath = Directory.GetCurrentDirectory();
var httpContext = new DefaultHttpContext();
var pathToRecording = "recordings/skip_body";
var mockClient = new HttpClient(new MockHttpHandler());
var recordingHandler = new RecordingHandler(currentPath)
{
RedirectableClient = mockClient,
RedirectlessClient = mockClient
};
var fullPathToRecording = Path.Combine(currentPath, pathToRecording) + ".json";
recordingHandler.StartRecording(pathToRecording, httpContext.Response);
var sessionId = httpContext.Response.Headers["x-recording-id"].ToString();
CreateRecordModeRequest(httpContext, "request-body");
await recordingHandler.HandleRecordRequestAsync(sessionId, httpContext.Request, httpContext.Response);
recordingHandler.StopRecording(sessionId);
try
{
using var fileStream = File.Open(fullPathToRecording, FileMode.Open);
using var doc = JsonDocument.Parse(fileStream);
var record = RecordSession.Deserialize(doc.RootElement);
var entry = record.Entries.First();
Assert.Null(entry.Request.Body);
Assert.Equal(MockHttpHandler.DefaultResponse, Encoding.UTF8.GetString(entry.Response.Body));
}
finally
{
File.Delete(fullPathToRecording);
}
}