public void Find_RecordNotExists_ReturnsNull()
{
var cassette = new Cassette(Context.Cassette1);
var record = cassette.Find("wrong");
Assert.IsNull(record);
}
public async Task <HttpResponseMessage> SendExplorerApiRequest(
HttpMethod method,
string endpoint,
object?data,
string testClassName,
string vcrSessionName,
VCRMode vcrMode = VCRMode.Record)
{
// For the explorer interactions, most of the times, we don't want to use the cache
// So we set the default vcr mode to always record.
var testConfig = GetTestConfig(testClassName, vcrSessionName, vcrMode);
using var request = new HttpRequestMessage(method, endpoint);
if (data != null)
{
request.Content = new StringContent(JsonSerializer.Serialize(data));
request.Content.Headers.ContentType = new MediaTypeHeaderValue(System.Net.Mime.MediaTypeNames.Application.Json);
}
using var clientHandler = new HttpClientHandler();
using var cassette = new Cassette(testConfig.VcrCassettePath);
using var handler = new ReplayingHandler(
clientHandler,
testConfig.VcrMode,
cassette,
RecordingOptions.RecordAll);
using var client = CreateDefaultClient(handler);
return(await client.SendAsync(request));
}
public async Task GetUsersApi_InvokedOnFirstCallFromCassetteOnSecondCall_Success()
{
using var _ = TestServerHelper.BuildAndStartHost();
var httpClientHandler = new SocketsHttpHandler();
var innerHandler = new StubHttpRequestHandler(httpClientHandler);
var cassette = new Cassette();
var tryReplayHandler = new TryReplayHttpMessageHandler(cassette, innerHandler);
using var httpClient = new HttpClient(tryReplayHandler)
{
BaseAddress = _baseAddress
};
await httpClient.GetStringAsync("/api/users/1");
Assert.That(innerHandler.Invoked, Is.True);
Assert.That(cassette.Records, Has.Count.EqualTo(1));
innerHandler.Invoked = false;
var result = await httpClient.GetStringAsync("/api/users/1");
Assert.That(innerHandler.Invoked, Is.False);
var actual = JObject.Parse(result);
var expected = JObject.Parse("{\"id\": 1, \"name\": \"User 1\"}");
Assert.That(actual, Is.EqualTo(expected));
}
public async Task GetRedirectUsersApi_InvokedOnFirstCallFromCassetteOnSecondCall_Success()
{
using var _ = TestServerHelper.BuildAndStartHost();
var httpClientHandler = new SocketsHttpHandler();
var innerHandler = new StubHttpRequestHandler(httpClientHandler);
var cassette = new Cassette();
var tryReplayHandler = new TryReplayHttpMessageHandler(cassette, innerHandler);
using var httpClient = new HttpClient(tryReplayHandler)
{
BaseAddress = _baseAddress
};
var response = await httpClient.GetAsync("/api/get_users/2");
Assert.That(innerHandler.Invoked, Is.True);
Assert.That(cassette.Records, Has.Count.EqualTo(1));
Assert.That(response.RequestMessage.RequestUri, Is.EqualTo(new Uri(_baseAddress, "/api/users/2")));
innerHandler.Invoked = false;
response = await httpClient.GetAsync("/api/get_users/2");
Assert.That(innerHandler.Invoked, Is.False);
Assert.That(response.RequestMessage?.RequestUri, Is.EqualTo(new Uri(_baseAddress, "/api/users/2")));
var actual = JObject.Parse(await response.Content.ReadAsStringAsync());
var expected = JObject.Parse("{\"id\": 2, \"name\": \"User 2\"}");
Assert.That(actual, Is.EqualTo(expected));
}
void Trigger(Cassette controller)
{
if (controller)
{
controller.Trigger();
}
}
public void Recording_PostEmptyContent_ContentLengthHeaderSaved()
{
var cassette = new Cassette(Context.CreateCassette("new"));
player.Start();
player.Load(cassette);
player.Record("record1");
using (var server = new Server(remoteAddress1))
{
Task.Run(() => server.Accept());
var client = new Client(baseAddress);
client.Send("/", "POST", headers: new NameValueCollection {
{ "Content-Length", "0" }
});
}
player.Stop();
var record = cassette.Find("record1");
var mock = (JObject)record.Read();
var jrequest = (JObject)mock["request"];
Assert.IsNull(jrequest["content"]);
Assert.AreEqual("0", jrequest["headers"]["Content-Length"].ToString());
}
public async Task SendAsync_WithCookieContainerWithCookieInResponse_CookiesAddedToContainer()
{
var cassette = new Cassette();
var record = new CassetteRecord(
new CassetteRecordRequest(
HttpMethod.Get.Method,
new Uri("http://*****:*****@"{""a"": 1, ""b"": 2}"));
cassette.Add(record);
var cookieContainer = new CookieContainer();
var replayingHttpMessageHandler = new PublicReplayingHttpMessageHandler(cassette, cookieContainer);
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
Version = new Version(1, 1),
RequestUri = new Uri("http://localhost:8080/test"),
Content = null,
};
await replayingHttpMessageHandler.SendAsync(request, CancellationToken.None);
Assert.That(cookieContainer.GetCookies(request.RequestUri)["value"]?.Value, Is.EqualTo("123"));
}
public void Save_FileExists_UpdatesToValidFile()
{
var cassette = new Cassette(Context.Cassette1);
var record = new Record("record");
var request = JObject.Parse("{\"request\":{},\"response\":{}}");
record.Write(request);
cassette.Save(record);
var anotherCassette = new Cassette(cassette.Path);
Assert.AreEqual(3, anotherCassette.Records.Count);
var record1 = anotherCassette.Records[0];
Assert.AreEqual("record1", record1.Name);
Assert.AreEqual(3, record1.List.Count);
var record2 = anotherCassette.Records[1];
Assert.AreEqual("record2", record2.Name);
Assert.AreEqual(1, record2.List.Count);
var record3 = anotherCassette.Records[2];
Assert.AreEqual("record", record3.Name);
Assert.AreEqual(1, record.List.Count);
}
public void Initialize_FileNotExists_CreatesEmptyRecords()
{
var cassette = new Cassette(Context.CassetteNew);
Assert.IsNotNull(cassette.Records);
Assert.IsEmpty(cassette.Records);
}
public void OnCassetteInserted(Cassette c)
{
base.baseEntity.ClientRPC(null, "Client_OnCassetteInserted", c.net.ID);
ServerTogglePlay(false);
base.baseEntity.SendNetworkUpdate();
SetFlag(BaseEntity.Flags.Reserved1, true);
}
public async Task ReplaceMatchingInteractionInCassetteFile()
{
var originalInteractionsInCassette = Cassette.ReadCassette(_testCassettePath).ToList();
originalInteractionsInCassette.Count.ShouldBe(3);
var originalRecordedTime1 = originalInteractionsInCassette.ElementAt(0).RecordedAt;
var originalRecordedTime2 = originalInteractionsInCassette.ElementAt(1).RecordedAt;
var originalRecordedTime3 = originalInteractionsInCassette.ElementAt(2).RecordedAt;
var httpClient = HttpClients.NewHttpClient(_testCassettePath, ScotchMode.Recording);
var albumService = new AlbumService(httpClient);
var album = await albumService.GetAsync(2);
album.Id.ShouldBe(2);
var newInteractionsInCassette = Cassette.ReadCassette(_testCassettePath).ToList();
newInteractionsInCassette.Count.ShouldBe(3);
var newRecordedTime1 = newInteractionsInCassette.ElementAt(0).RecordedAt;
var newRecordedTime2 = newInteractionsInCassette.ElementAt(1).RecordedAt;
var newRecordedTime3 = newInteractionsInCassette.ElementAt(2).RecordedAt;
originalRecordedTime1.ShouldBe(newRecordedTime1);
originalRecordedTime2.ShouldNotBe(newRecordedTime2);
originalRecordedTime3.ShouldBe(newRecordedTime3);
}
public void Close_AfterRecorded_RewindsRecord()
{
var cassette = new Cassette(Context.CassetteNew);
player.Start();
player.Load(cassette);
player.Record("record1");
using (var server = new Server(remoteAddress1))
{
Task.Run(() => server.Accept());
var client = new Client(baseAddress);
client.Send("/path", "GET");
player.Close();
player = new Player(baseAddress, remoteAddress1);
player.Start();
player.Load(cassette);
player.Play("record1");
Assert.DoesNotThrow(() => client.Send("/path", "GET"));
}
}
public async Task SendAsync_PostJsonContentRequest_Success()
{
var cassette = new Cassette();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("http://*****:*****@"{""a"":1, ""b"": 2}";
var handler = new PublicRecordingHttpMessageHandler(new MockHttpRequestHandler(new StringContent(body, Encoding.UTF8, "application/json")), cassette);
await handler.SendAsync(request, CancellationToken.None);
Assert.That(cassette.Records, Has.Count.EqualTo(1));
Assert.That(cassette.Records[0].Request.Method, Is.EqualTo(request.Method.Method));
Assert.That(cassette.Records[0].Request.Uri, Is.EqualTo(request.RequestUri));
Assert.That(cassette.Records[0].Request.Headers, Has.Count.GreaterThanOrEqualTo(1));
Assert.That(cassette.Records[0].Request.Headers["Content-Type"], Contains.Substring("application/json").And.Contains("charset=utf-8"));
Assert.That(cassette.Records[0].Request.Headers["Host"], Is.EqualTo("localhost"));
Assert.That(cassette.Records[0].Request.Body, Is.EqualTo(new StringCassetteBody("{}")));
Assert.That(cassette.Records[0].Response.Version, Is.EqualTo(new Version(1, 1)));
Assert.That(cassette.Records[0].Response.StatusCode, Is.EqualTo(200));
Assert.That(cassette.Records[0].Response.Headers, Has.Count.EqualTo(2));
Assert.That(cassette.Records[0].Response.Headers["Server"], Is.EqualTo("Test-Server"));
Assert.That(cassette.Records[0].Response.Headers["Content-Type"], Contains.Substring("application/json").And.Contains("charset=utf-8"));
Assert.That(cassette.Records[0].Response.Body, Is.EqualTo(new StringCassetteBody(body)));
}
public async Task SendAsync_WithCookieContainer_ShouldBeRecorderInRequest()
{
var baseUri = new Uri("http://localhost:8080");
var cookieContainer = new CookieContainer();
cookieContainer.Add(baseUri, new Cookie("value", "123"));
var cassette = new Cassette();
var handler = new PublicRecordingHttpMessageHandler(
new MockHttpRequestHandler(new StringContent("{}", Encoding.UTF8, "application/json"))
{
CookieContainer = cookieContainer
},
cassette);
HttpRequestMessage request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri(baseUri, "/api/data"),
};
await handler.SendAsync(request, CancellationToken.None);
Assert.That(cassette.Records, Has.Count.EqualTo(1));
Assert.That(cassette.Records[0].Request.Headers["Cookie"], Is.EqualTo(cookieContainer.GetCookieHeader(baseUri)));
}
public void OneTimeSetUp()
{
cassette = new Cassette($"{Context.AssemblyDirectoryName}/../../GithubClient/Tests/Mock/Http/Activity.json");
Context.Player.Load(cassette);
client = new Client(Context.Player.BaseAddress);
}
public void Find_RecordExists_ReturnsRecord()
{
var cassette = new Cassette(Context.Cassette1);
var record = cassette.Find("record1");
Assert.IsNotNull(record);
Assert.AreEqual("record1", record.Name);
Assert.AreEqual(3, record.List.Count);
}
private int Cpu_ReadPort()
{
var data = 0x1F;
if (!Cassette.ReadSenseBuffer())
{
data &= 0xEF;
}
return(data);
}
public async Task TestBooleanColumn()
{
using var testScope = fixture.PrepareExplorationTestScope(Cassette.GenerateVcrFilename(this));
await testScope.RunAndCheckMetrics(
"GiveMeSomeCredit",
"loans",
"SeriousDlqin2yrs",
metrics => Assert.True(metrics.Any()));
}
public async Task TestDateColumn()
{
using var testScope = fixture.PrepareExplorationTestScope(Cassette.GenerateVcrFilename(this));
await testScope.RunAndCheckMetrics(
"gda_banking",
"loans",
"birthdate",
metrics => Assert.True(metrics.Any()));
}
public async Task TestDatetimeColumn()
{
using var testScope = fixture.PrepareExplorationTestScope(Cassette.GenerateVcrFilename(this));
await testScope.RunAndCheckMetrics(
"gda_taxi",
"rides",
"pickup_datetime",
metrics => Assert.True(metrics.Any()));
}
public CoProcessor(SDCart in_parent)
{
Cart = in_parent;
m_function_groups = new IFunctionGroup[CoProcessorConstants.FunctionGroupCount];
m_function_groups[0] = new Cassette(this);
CoProcessorRead = null;
CoProcessorWrite = null;
Status = CoProcessorConstants.ERR_OK;
}
public void Ctor_Records_NoRecords([Values(1, 5)] int count)
{
var records = Enumerable
.Range(0, count)
.Select(i => new CassetteRecord(
new CassetteRecordRequest("GET", new Uri("http://localhost:8080/test"), new NameValueCollection()),
new CassetteRecordResponse(new Version(1, 1), 204, "No Content", new NameValueCollection())));
var cassette = new Cassette(records);
Assert.That(cassette.Records, Has.Count.EqualTo(count));
}
private Cassette[] ExtractCassetteStatus(byte[] Data)
{
Cassette[] cassettes = new Cassette[3];
try
{
if (Data != null && Data.Length > 0)
{
for (int i = 0; i < 3; i++)
{
cassettes[i].cassetteId = i + 1;
cassettes[i].billType = (int)(Data[2 * i] & 0x1F);
cassettes[i].billNumber = (int)Data[(2 * i) + 1];
cassettes[i].presence = ((Data[2 * i] & 0x80) == 0x80) ? true : false;
cassettes[i].cassetteFull = ((Data[2 * i] & 0x40) == 0x40) ? true : false;
if ((Data[2 * i] & 0x1F) == 0x1F)
{
cassettes[i].cassetteStatus = CassetteStatus.NOT_ASSIGNED;
}
else if ((Data[2 * i] & 0x1F) == 0x18)
{
cassettes[i].cassetteStatus = CassetteStatus.ESCROW;
Constants.EscrowCassetteNo = i + 1;
}
else
{
cassettes[i].cassetteStatus = CassetteStatus.NORMAL;
if (i == 0)
{
Constants.Cassette1Note = cassettes[0].billType;
Constants.Cassette1NoteCont = cassettes[0].billNumber;
}
if (i == 1)
{
Constants.Cassette1Note = cassettes[1].billType;
Constants.Cassette2NoteCont = cassettes[1].billNumber;
}
if (i == 2)
{
Constants.Cassette1Note = cassettes[2].billType;
Constants.Cassette3NoteCont = cassettes[2].billNumber;
}
}
}
}
}
catch (Exception ex)
{
log.Error("Error BNRManager -> ExtractCassetteStatus() - " + ex.ToString());
}
Constants.CassettesInfo = cassettes;
return(cassettes);
}
public async Task SendAsync_PostRequest_Success(Type cassetteBodyType)
{
var cassette = new Cassette();
var record = new CassetteRecord(
new CassetteRecordRequest(
HttpMethod.Post.Method,
new Uri("http://*****:*****@"{""a"": 1, ""b"": 2}"));
cassette.Add(record);
var replayingHttpMessageHandler = new PublicReplayingHttpMessageHandler(cassette);
var contentFactory = new Dictionary <Type, Func <HttpContent> >
{
{ typeof(StringCassetteBody), () => new StringContent("{}") },
{ typeof(BytesCassetteBody), () => new StreamContent(new MemoryStream(Encoding.UTF8.GetBytes("{}"))) },
};
var content = contentFactory[cassetteBodyType]();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
Headers =
{
{ "Cookie", "value=1" },
},
Version = new Version(1, 1),
RequestUri = new Uri("http://localhost:8080/test"),
Content = content,
};
var response = await replayingHttpMessageHandler.SendAsync(request, CancellationToken.None);
Assert.That(response, Is.Not.Null);
Assert.That(response.Version, Is.EqualTo(record.Response.Version));
Assert.That(response.StatusCode, Is.EqualTo((HttpStatusCode)record.Response.StatusCode));
Assert.That(response.ReasonPhrase, Is.EqualTo(record.Response.StatusMessage));
Assert.That(response.RequestMessage, Is.Not.Null);
Assert.That(response.Headers.GetValues("Server"), Is.EqualTo(new[] { record.Response.Headers["Server"] }));
}
public RecordingHttpMessageHandler(HttpMessageHandler innerHandler, Cassette cassette) : base(innerHandler)
{
var cookieContainerProperty = innerHandler.GetType().GetRuntimeProperty(nameof(HttpClientHandler.CookieContainer));
if (cookieContainerProperty?.PropertyType == typeof(CookieContainer) && cookieContainerProperty.CanRead)
{
// Create Open Delegate from property getter method
var cookieContainerGetter = cookieContainerProperty.GetMethod.CreateDelegate(typeof(Func <,>).MakeGenericType(innerHandler.GetType(), typeof(CookieContainer)));
_innerHandlerCookieContainerGetter = () => (CookieContainer)cookieContainerGetter.DynamicInvoke(innerHandler);
}
_cassette = cassette;
}
public async void TestLastName()
{
using var scope = testFixture.SimpleComponentTestScope(
"gda_banking",
"cards",
"lastname",
Cassette.GenerateVcrFilename(this));
await scope.ResultTest <EmailCheckComponent, bool>(Assert.False);
await scope.ResultTest <TextGeneratorComponent, IEnumerable <string> >(result =>
Assert.True(result.All(v => v.Length >= 3)));
}
public async Task <TestScope> CreateTestScope(
string dataSource,
string table,
IEnumerable <string> columns,
object caller,
[CallerMemberName] string callerMemberName = "")
{
var vcrFileName = Cassette.GenerateVcrFilename(caller, callerMemberName);
var columnInfo = await GetColumnInfo(dataSource, table, columns).Collect();
var samplesToPublish = Config.Get <ExplorerOptions>().DefaultSamplesToPublish;
return(new TestScope(Container, ApiUri, dataSource, table, columns, columnInfo, vcrFileName, samplesToPublish));
}
public void Save_RewindsRecord()
{
var cassette = new Cassette(Context.Cassette1);
var record = new Record("record");
cassette.Save(record);
var record1 = cassette.Records[0];
var req1 = record1.Read();
var req2 = record1.Read();
Assert.IsNotNull(req1);
Assert.IsNotNull(req2);
}
public async Task TestMultiColumn()
{
using var testScope = fixture.PrepareExplorationTestScope(Cassette.GenerateVcrFilename(this));
await testScope.RunAndCheckMetrics(
"gda_banking",
"loans",
new[] { "firstname", "duration" },
metrics =>
{
Assert.True(metrics["firstname"].Any());
Assert.True(metrics["duration"].Any());
Assert.True(metrics.Count == 2);
});
}
public void Initialize_ValidFile_LoadsRecords()
{
var cassette = new Cassette(Context.Cassette1);
Assert.AreEqual(2, cassette.Records.Count);
var record1 = cassette.Records[0];
Assert.AreEqual("record1", record1.Name);
Assert.AreEqual(3, record1.List.Count);
var record2 = cassette.Records[1];
Assert.AreEqual("record2", record2.Name);
Assert.AreEqual(1, record2.List.Count);
}
