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 void Should_Set_Times_Limited(int times)
{
// Arrange
var builder = new FluentExpectationBuilder();
// Act
var result = builder.RespondTimes(times, 200).Setup().Expectations.First().AsJson();
// Assert
_outputHelper.WriteLine(result);
result
.Should()
.MatchRegex($@"(?m)\s*""times"":\s*\{{\s*""remainingTimes"":\s*{times},\s*""unlimited"":\s*false\s*}}");
}
public void Should_Set_BaseUrl()
{
// Arrange
const string baseUrl = "http://example.com";
var builder = new FluentExpectationBuilder();
builder.WithBaseUrl(baseUrl);
// Act
var setup = builder.Setup();
// Assert
_outputHelper.WriteLine(JsonConvert.SerializeObject(setup, Formatting.Indented));
setup.BaseUrl.Should().Be(baseUrl);
}
public void Should_Match_Any_Request_With_Method(string method)
{
// Arrange
var builder = new FluentExpectationBuilder();
// Act
builder.OnHandling(new HttpMethod(method))
.RespondWith(HttpStatusCode.Created);
var expectation = builder.Setup().Expectations.First();
var result = expectation.AsJson();
// Assert
_outputHelper.WriteLine(result);
result.Should().MatchRegex($@"(?smi)""httpRequest"":.*{{.*""method"".*:.*""{method}"".*}}.*,");
}
public void Should_Set_Times_Always()
{
// Arrange
var builder = new FluentExpectationBuilder();
var setup = builder
.RespondTimes(() => Times.Always, 200)
.Setup();
// Act
var result = setup.Expectations.First().AsJson();
// Assert
_outputHelper.WriteLine(result);
result
.Should()
.MatchRegex($@"(?m)\s*""times"":\s*\{{\s*""remainingTimes"":\s*0,\s*""unlimited"":\s*true\s*}}");
}
public void Should_Match_Any_Request()
{
// Arrange
var builder = new FluentExpectationBuilder();
builder
.OnHandlingAny()
.RespondWith(HttpStatusCode.Created);
// Act
var expectation = builder.Setup().Expectations.First();
var result = expectation.AsJson();
// Assert
_outputHelper.WriteLine(result);
result.Should().MatchRegex(@"(?s)^((?!httpRequest).)*$");
}
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_Set_TimeToLive()
{
// Arrange
var builder = new FluentExpectationBuilder();
// Act
var result = builder
.OnHandlingAny()
.RespondWith(HttpStatusCode.OK)
.WhichIsValidFor(10)
.Setup()
.Expectations.First()
.AsJson();
// Assert
_outputHelper.WriteLine(result);
result.Should().MatchRegex(@"(?m)\s*""timeToLive"":\s*\{\s*""timeUnit"":\s*""SECONDS""\s*,\s*""timeToLive"":\s*10\s*,\s*""unlimited""\s*:\s*false\s*}");
}
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);
}
public void Should_Set_Times()
{
// Arrange
Action <IFluentExpectationBuilder> fac = expectationBuilder => expectationBuilder
.OnHandling(HttpMethod.Post, request => request.WithPath("/"))
.RespondOnce(HttpStatusCode.Created, resp => resp.WithDelay(1, TimeUnit.Milliseconds));
var setup = new MockServerSetup();
var builder = new FluentExpectationBuilder(setup);
// Act
fac(builder);
var expectation = builder.Setup().Expectations.First();
var result = expectation.AsJson();
// Assert
_outputHelper.WriteLine(result);
result.Should()
.MatchRegex(@"(?m)\s*""times"":\s*\{\s*""remainingTimes"":\s*1,\s*""unlimited"":\s*false\s*}");
}
/// <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);
}
internal HttpRequest(FluentExpectationBuilder fluentBuilder) : this()
{
Builder = fluentBuilder;
}
public FluentHttpRequestBuilder(FluentExpectationBuilder fluentExpectationBuilder)
{
HttpRequest = new HttpRequest(fluentExpectationBuilder);
}
