public void SerializeJObject_Should_Use_SerializeJObject_Of_Properties()
{
// Arrange
var builder = new FluentHttpRequestBuilder()
.WithPath("")
.WithMethod(HttpMethod.Post)
.WithContent(body => body.WithoutXmlContent("<xml here>"));
var expectation = FluentExpectationBuilder.Create(
httpRequest: builder.Build(),
httpResponse: HttpResponse.Create(headers: new Dictionary <string, string[]>
{
{ "Content-Type", new[] { "xml" } }
},
body: new JValue("some xml response"),
delay: new Delay(TimeUnit.Milliseconds, 50),
statusCode: 200)
);
// Act
var jo = expectation.AsJObject();
var json = Serializer.Serialize(expectation);
Logger.LogInformation("JSON", json);
// Assert
jo["httpResponse"]["body"].ToObject <string>().Should().Be("some xml response");
}
public EqualityOperatorTestData()
{
var dataType = typeof(T);
if (typeof(Body) == dataType)
{
AddTestData(
CreateBody(b => b.ContainingJson("some json value")),
CreateBody(b => b.MatchingXmlSchema("xml schema")));
}
else if (typeof(VerificationTimes) == dataType)
{
AddTestData(VerificationTimes.Once, VerificationTimes.Twice);
}
else if (typeof(Expectation) == dataType)
{
AddTestData(
FluentExpectationBuilder.Create(times: Times.Once, httpResponse: HttpResponse.Create(statusCode: 200)),
FluentExpectationBuilder.Create(HttpRequest.Create(method: "GET", path: "/test"), httpResponse: HttpResponse.Create(statusCode: 200)));
}
else
{
AddTestData(InstanceFactoryCreator.CreateDefault <T>(), InstanceFactoryCreator.CreateRandom <T>());
}
}
public void Equals_Should_Be_False_When_Instances_Are_Not_Equal()
{
// Arrange
var a = FluentExpectationBuilder.Create(times: Times.Once);
var b = FluentExpectationBuilder.Create();
// Assert
a.Should().NotBe(b);
}
public async Task Should_Setup_Expectation_With_Xml_Body_When_Setup_Using_Predefined_Setup()
{
// Arrange
const string id1 = "IP-100001";
const string id2 = "10001234";
var response = ResponseTemplate
.Replace("{Id1}", id1)
.Replace("{Id2}", id2);
var httpResponse = HttpResponse.Create(
body: new JValue(response),
delay: new Delay(TimeUnit.Milliseconds, 50),
headers: new Dictionary <string, string[]>
{
{ "Content-Type", new[] { $"text/xml; charset=utf-8" } }
});
var expectation = FluentExpectationBuilder.Create(httpResponse: httpResponse);
var responseJson = JsonConvert.SerializeObject(httpResponse);
Output.WriteLine($"responseJson: \n{responseJson}");
var expectationJson = expectation.ToString();
Output.WriteLine($"expectationJson: \n{expectationJson}");
var setup = new MockServerSetup();
setup.Expectations.Add(expectation);
var setupJson = JsonConvert.SerializeObject(setup, Formatting.Indented);
Output.WriteLine($"Setup json: \n{setupJson}");
// Act
await MockedServer.SetupAsync(setup);
await SetupResponseForOrderPlacedRequest(id1, id2);
// Assert
// TODO: verify setup
}
public void Should_Use_ExpectationConverter_When_Using_Standard_Serializer()
{
// Arrange
var expected = JObject.Parse(@"{
""httpRequest"": {
""path"": ""/some/path""
}
}").ToString(Formatting.Indented);
var builder = new FluentHttpRequestBuilder()
.WithPath("/some/path");
var expectation = FluentExpectationBuilder.Create(httpRequest: builder.Build());
// Act
var json = JsonConvert.SerializeObject(expectation);
// Assert
json.Should().Be(expected);
}
public void Should_Convert_To_Expectation_When_Converting_From_String()
{
// Arrange
const string json = @"{
""httpRequest"": {
""path"": ""/some/path""
},
""httpResponse"": {
""statusCode"": 201,
""delay"": {
""timeUnit"": ""MILLISECONDS"",
""value"": 1
}
},
""times"": {
""remainingTimes"": 1,
""unlimited"": false
}
}";
var builder = new FluentHttpRequestBuilder()
.WithPath("/some/path");
var expected = FluentExpectationBuilder.Create(
httpRequest: builder.Build(),
httpResponse: HttpResponse.Create(
statusCode: 201,
delay: new Delay(TimeUnit.Milliseconds, 1)),
times: Times.Once
);
// Act
var jsonReader = new JsonTextReader(new StringReader(json));
var sut = new ExpectationConverter();
var result = sut.ReadJson(jsonReader, typeof(Expectation), null, JsonSerializer.Create(Serializer.SerializerSettings)) as Expectation;
// Assert
result
.Should()
.BeOfType <Expectation>()
.Which
.HttpRequest.Path.Should().Be(expected.HttpRequest.Path);
}
/// <inheritdoc />
public override Expectation ReadJson(JsonReader reader, [NotNull] Type objectType, Expectation existingValue, bool hasExistingValue, JsonSerializer serializer)
{
var token = JToken.ReadFrom(reader);
var expectation = FluentExpectationBuilder.Create();
foreach (var propertyInfo in objectType
.GetProperties(BindingFlags.Public | BindingFlags.Instance)
.Where(p => p.CanWrite && !p.IsSpecialName))
{
var propertyName = propertyInfo.Name;
var firstLetter = propertyName.First().ToString().ToLower();
var camelCasePropertyName = firstLetter + propertyName.Substring(1);
if (!(token.SelectToken(camelCasePropertyName, false) is {} memberJson))
{
continue;
}
try
{
var value = memberJson.ToObject(propertyInfo.PropertyType);
propertyInfo.SetValue(expectation, value, BindingFlags.Instance | BindingFlags.NonPublic, null, null, CultureInfo.DefaultThreadCurrentCulture);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
// if (token.SelectToken("httpRequest", false) is {} httpRequest)
// try
// {
// expectation.HttpRequest = httpRequest.ToObject<HttpRequest>();
// }
// catch (Exception e)
// {
// Console.WriteLine(e);
// }
return(expectation);
}
public void Should_Convert_Expectation_To_Json()
{
// Arrange
var expected = JObject.Parse(@"{
""httpRequest"": {
""path"": ""/some/path""
}
}").ToString(Formatting.Indented);
var builder = new FluentHttpRequestBuilder()
.WithPath("/some/path");
var expectation = FluentExpectationBuilder.Create(httpRequest: builder.Build());
var subject = CreateSubject(out var sb, out var writer);
// Act
subject.WriteJson(writer, expectation, JsonSerializer.CreateDefault());
// Assert
var json = sb.ToString();
json.Should().Be(expected);
}
public void Should_Use_ExpectationConverter_When_Using_Standard_Deserializer()
{
// Arrange
const string json = @"{
""httpRequest"": {
""path"": ""/some/path""
}
}";
var builder = new FluentHttpRequestBuilder().WithPath("/some/path");
// Act
var unused = Verify.Once(builder.Build());
var expected = FluentExpectationBuilder.Create(httpRequest: builder.Build());
// Act
var result = JsonConvert.DeserializeObject <Expectation>(json);
// Assert
result
.Should()
.BeOfType <Expectation>()
.Which
.HttpRequest.Path.Should().Be(expected.HttpRequest.Path);
}
