public void ItGetsAValue()
{
// Arange
var stringConsumerNeeds = "Hello from provider!";
_mockProviderService
.UponReceiving("A invalid GET request for Date Validation with invalid date parameter")
.With(new ProviderServiceRequest
{
Method = HttpVerb.Get,
Path = "/api/provider",
})
.WillRespondWith(new ProviderServiceResponse {
Status = 200,
Headers = new Dictionary <string, object>
{
{ "Content-Type", "application/json; charset=utf-8" }
},
Body = new
{
message = stringConsumerNeeds
}
});
// Act
var result = ConsumerApiClient.ValidateDateTimeUsingProviderApi(_mockProviderServiceBaseUri).GetAwaiter().GetResult();
var resultBodyText = result.Content.ReadAsStringAsync().GetAwaiter().GetResult();
// Assert
Assert.Contains(stringConsumerNeeds, resultBodyText);
}
public void ItCanHandleInvalidDate()
{
//Arrange
var expectedInvalidMessage = "validDateTime is not a date or time";
_mockProviderService
.Given("There is a date")
.UponReceiving("An Invalid GET Request for Date Validation with invalid date")
.With(new ProviderServiceRequest {
Method = HttpVerb.Get,
Path = "/api/provider",
Query = "validDateTime=TechnicalMeeting"
})
.WillRespondWith(new ProviderServiceResponse {
Status = 400,
Headers = new Dictionary <string, object> {
{ "Content-Type", "application/json; charset=utf-8" }
},
Body = new{
message = expectedInvalidMessage
}
});
//Act
var result = ConsumerApiClient.ValidateDateTimeUsingProviderApi("TechnicalMeeting", _mockProviderServiceBaseUri)
.GetAwaiter()
.GetResult();
var resultBodyText = result.Content.ReadAsStringAsync().GetAwaiter().GetResult();
//Assert
Assert.Contains(expectedInvalidMessage, resultBodyText);
}
public void HeartbeatRespondsAsExpected()
{
// arrange
var expectedSuccessMessage = "API is responding";
_mockProviderService
.UponReceiving("A heartbeat request")
.With(new ProviderServiceRequest
{
Method = HttpVerb.Get,
Path = "/api/heartbeat"
})
.WillRespondWith(new ProviderServiceResponse
{
Status = 200,
Body = Match.Regex("API is responding", "^API is responding$"),
Headers = new Dictionary <string, object>
{
{ "Content-Type", "text/plain; charset=utf-8" }
}
});
// act
var result = ConsumerApiClient.Heartbeat(_mockProviderServiceBaseUri).GetAwaiter().GetResult();
// assert
Assert.Equal(200, (int)result.StatusCode);
}
public void ItHandlesAnEmptyDateParam()
{
// Arange
var invalidRequestMessage = "validDateTime is required";
_mockProviderService.Given("There is data")
.UponReceiving("A valid GET request for Date Validation with empty date parameter")
.With(new ProviderServiceRequest
{
Method = HttpVerb.Get,
Path = "/api/provider",
Query = "validDateTime="
})
.WillRespondWith(new ProviderServiceResponse
{
Status = 400,
Headers = new Dictionary <string, object>
{
{ "Content-Type", "application/json; charset=utf-8" }
},
Body = new
{
message = invalidRequestMessage
}
});
// Act
var result = ConsumerApiClient.ValidateDateTimeUsingProviderApi(string.Empty, _mockProviderServiceBaseUri).GetAwaiter().GetResult();
var resultBodyText = result.Content.ReadAsStringAsync().GetAwaiter().GetResult();
// Assert
Assert.Contains(invalidRequestMessage, resultBodyText);
}
public void ItHandlesHavingNoData()
{
// Arange
var inputString = "07-06-2018";
var invalidRequestMessage = string.Empty;
_mockProviderService.Given("There is no data")
.UponReceiving("A valid GET request for Date Validation with valid date parameter")
.With(new ProviderServiceRequest
{
Method = HttpVerb.Get,
Path = "/api/provider",
Query = $"validDateTime={inputString}"
})
.WillRespondWith(new ProviderServiceResponse
{
Status = 404
});
// Act
var result = ConsumerApiClient.ValidateDateTimeUsingProviderApi(inputString, _mockProviderServiceBaseUri).GetAwaiter().GetResult();
var resultBodyText = result.Content.ReadAsStringAsync().GetAwaiter().GetResult();
// Assert
Assert.Contains(invalidRequestMessage, resultBodyText);
}
public void ItParsesADateCorrectly()
{
var expectedDateString = "04/05/2018";
var expectedDateParsed = DateTime.Parse(expectedDateString).ToString("dd-MM-yyyy HH:mm:ss");
// Arrange
_mockProviderService.Given("There is data")
.UponReceiving("A valid GET request for Date Validation")
.With(new ProviderServiceRequest
{
Method = HttpVerb.Get,
Path = "/api/provider",
Query = $"validDateTime={expectedDateString}"
})
.WillRespondWith(new ProviderServiceResponse {
Status = 200,
Headers = new Dictionary <string, object>
{
{ "Content-Type", "application/json; charset=utf-8" }
},
Body = new
{
test = "NO",
validDateTime = expectedDateParsed
}
});
// Act
var result = ConsumerApiClient.ValidateDateTimeUsingProviderApi(expectedDateString, _mockProviderServiceBaseUri).GetAwaiter().GetResult();
var resultBody = result.Content.ReadAsStringAsync().GetAwaiter().GetResult();
// Assert
Assert.Contains(expectedDateParsed, resultBody);
}
public void ItHandlesValidDateParam()
{
// Arange
var inputString = "07-06-2018";
_mockProviderService.Given("There is data")
.UponReceiving("A valid GET request for Date Validation with valid date parameter")
.With(new ProviderServiceRequest
{
Method = HttpVerb.Get,
Path = "/api/provider",
Query = $"validDateTime={inputString}"
})
.WillRespondWith(new ProviderServiceResponse
{
Status = 200,
Headers = new Dictionary <string, object>
{
{ "Content-Type", "application/json; charset=utf-8" }
},
Body = new
{
test = "NO",
validDateTime = $"{inputString} 00:00:00"
}
});
// Act
var result = ConsumerApiClient.ValidateDateTimeUsingProviderApi(inputString, _mockProviderServiceBaseUri).GetAwaiter().GetResult();
var resultBodyText = result.Content.ReadAsStringAsync().GetAwaiter().GetResult();
// Assert
Assert.Contains($"{inputString} 00:00:00", resultBodyText);
}
public void ValidDateRequired()
{
var invalidRequestMessage = "validDateTime is required";
_mockProviderService
.Given("There is data")
.UponReceiving("An invalid Get Request with no date")
.With(
new ProviderServiceRequest {
Method = HttpVerb.Get,
Path = "/api/provider",
Query = "validDateTime="
}
)
.WillRespondWith(
new ProviderServiceResponse {
Status = 400,
Headers = new Dictionary <string, object>
{
{ "Content-type", "application/json; charset=utf-8" }
},
Body = new
{
message = invalidRequestMessage
}
});
var result = ConsumerApiClient.ValidateDateTimeUsingProviderApi("", _mockProviderServiceBaseUri).GetAwaiter().GetResult();
var resultBodyText = result.Content.ReadAsStringAsync().GetAwaiter().GetResult();
Assert.Contains(invalidRequestMessage, resultBodyText);
}
public void ItChecksDateParsing()
{
var expectedDateString = "10/08/2019";
var expectedDateParsed = DateTime.Parse(expectedDateString).ToString("dd-MM-yyyy HH:mm:ss");
string description = $"A valid date: {expectedDateString} was sent";
_mockProviderService.Given("There is data")
.UponReceiving("A Valid Request is made but not parsed correctly")
.With(new ProviderServiceRequest
{
Method = HttpVerb.Get,
Path = "/api/provider",
Query = $"validDateTime={expectedDateString}"
})
.WillRespondWith(new ProviderServiceResponse {
Status = 200,
Headers = new Dictionary <string, object>
{
{ "Content-Type", "application/json; charset=utf-8" }
},
Body = new
{
test = "YES",
validDateTime = expectedDateParsed
}
});
var result = ConsumerApiClient.ValidateDateTimeUsingProviderApi(expectedDateString, _mockProviderServiceBaseUri).GetAwaiter().GetResult();
var resultBodyText = result.Content.ReadAsStringAsync().GetAwaiter().GetResult();
Assert.Contains(expectedDateParsed, resultBodyText);
}
public void CheckValidDateParam()
{
// Arange
var validDateTimeRequest = "18/08/2019";
var validDateTimeResponse = DateTime.Parse(validDateTimeRequest).ToString("dd-MM-yyyy HH:mm:ss");
_mockProviderService.Given("There is data")
.UponReceiving("A valid GET request for Date Validation")
.With(new ProviderServiceRequest
{
Method = HttpVerb.Get,
Path = "/api/provider",
Query = $"validDateTime={validDateTimeRequest}"
})
.WillRespondWith(new ProviderServiceResponse
{
Status = 200,
Headers = new Dictionary <string, object>
{
{ "Content-Type", "application/json; charset=utf-8" }
},
Body = new
{
test = "NO",
validDateTime = validDateTimeResponse
}
});
// Act
var result = ConsumerApiClient.ValidateDateTimeUsingProviderApi(validDateTimeRequest, _mockProviderServiceBaseUri).GetAwaiter().GetResult();
var resultBodyText = result.Content.ReadAsStringAsync().GetAwaiter().GetResult();
// Assert
Assert.Contains(validDateTimeResponse, resultBodyText);
}
public void ItHandlesInvalidDateParam()
{
/*
* All test cases follow the same 3 steps
* 1) Mock out an interaction withe provider api
* 2) Interaction with the mocked out interaction using the Consumer [HttpDelete]
* 3) Aseert the result is what we expected
*
*
* public IActionResult Delete(inputType id)
* {
* //TODO: Implement Realistic Implementation
* return Ok();
* }
*/
var invalidRequestMessage = "validDateTime is not a date or time";
_mockProviderService.Given("There is data")
.UponReceiving("A invalid Get request for Date Validation with invalid data")
.With(new ProviderServiceRequest
{
Method = HttpVerb.Get,
Path = "/api/provider",
Query = "validDateTime=lolz"
})
.WillRespondWith(new ProviderServiceResponse
{
Status = 400,
Headers = new Dictionary <string, object>
{
{ "Content-type", "application/json; charset=utf-8" }
},
Body = new
{
message = invalidRequestMessage
}
});
var result = ConsumerApiClient.ValidateDateTimeUsingProviderApi("lolz", _mockProviderServiceBaseUri).GetAwaiter().GetResult();
var resultBodyText = result.Content.ReadAsStringAsync().GetAwaiter().GetResult();
Assert.Contains(invalidRequestMessage, resultBodyText);
}
public void ValidLoginRespondsAsExpected()
{
var providerServiceRequest = new ProviderServiceRequest
{
Method = HttpVerb.Post,
Path = "/api/authentication/login",
Headers = new Dictionary <string, object>
{
{ "content-type", "application/json; charset=utf-8" }
},
Body = new
{
username = "******",
password = "******"
}
};
var providerServiceResponse = new ProviderServiceResponse
{
Status = 200,
Headers = new Dictionary <string, object>
{
{ "Content-Type", "application/json; charset=utf-8" }
},
Body = new
{
username = "******"
}
};
_mockProviderService
//.Given("No setup needed")
.UponReceiving("A valid login request")
.With(providerServiceRequest)
.WillRespondWith(providerServiceResponse);
// act
var result = ConsumerApiClient.LogInUser("testuser", "testpassword", _mockProviderServiceBaseUri).GetAwaiter().GetResult();
// assert
Assert.Equal(200, (int)result.StatusCode);
}
public void ItHandlesNoData()
{
// Arrange
_mockProviderService.Given("There is no data")
.UponReceiving("A valid GET request for Date Validation")
.With(new ProviderServiceRequest
{
Method = HttpVerb.Get,
Path = "/api/provider",
Query = "validDateTime=04/04/2018"
})
.WillRespondWith(new ProviderServiceResponse {
Status = 404
});
// Act
var result = ConsumerApiClient.ValidateDateTimeUsingProviderApi("04/04/2018", _mockProviderServiceBaseUri).GetAwaiter().GetResult();
var resultStatus = (int)result.StatusCode;
// Assert
Assert.Equal(404, resultStatus);
}
public void HandlesNoDataCorrectly()
{
var invalidRequestMessage = "There is no datafile";
_mockProviderService
.Given("There is no data")
.UponReceiving("A valid date was sent but there is no datafile")
.With(
new ProviderServiceRequest {
Method = HttpVerb.Get,
Path = "/api/provider",
Query = "validDateTime=04/04/2018"
}
)
.WillRespondWith(
new ProviderServiceResponse {
Status = 404
});
var result = ConsumerApiClient.ValidateDateTimeUsingProviderApi("04/04/2018", _mockProviderServiceBaseUri).GetAwaiter().GetResult();
var resultStatus = (int)result.StatusCode;
Assert.Equal(404, resultStatus);
}
public async Task ItShouldReturnValidDateTime()
{
// Arange
var expectedResult = "{\"test\":\"NO\",\"validDateTime\":\"08-09-2018 00:00:00\"}";
var expectedDateTime = new DateTime(2018, 09, 08);
_mockProviderService.Given("There is data")
.UponReceiving("A valid GET request for Date Validation with valid date parameter")
.With(new ProviderServiceRequest
{
Method = HttpVerb.Get,
Path = "/api/provider",
Query = "validDateTime=2018-09-08"
})
.WillRespondWith(new ProviderServiceResponse
{
Status = 200,
Headers = new Dictionary <string, object>
{
{ "Content-Type", "application/json; charset=utf-8" }
},
Body = new
{
test = "NO",
validDateTime = expectedDateTime.ToString("dd-MM-yyyy HH:mm:ss")
}
});
// Act
var result = await ConsumerApiClient.ValidateDateTimeUsingProviderApi("2018-09-08", _mockProviderServiceBaseUri);
var resultBodyText = await result.Content.ReadAsStringAsync();
// Assert
Assert.Contains(expectedResult, resultBodyText);
}
