public async Task GetAll_Successful()
{
var cats = await ApiClient.GetAll <Cat>();
cats.Count().Should().Be(TestData.Cats.Count);
RestClientMock.Verify <IEnumerable <Cat> >();
}
public async Task Get_ById_Successful()
{
var existingCat = TestData.Cats.FirstOrDefault();
var cat = await ApiClient.GetById <Cat>(existingCat.Id);
existingCat.Id.Should().Be(cat.Id);
RestClientMock.Verify <Cat>();
}
public async Task Delete_Successful()
{
var cat = TestData.Cats.FirstOrDefault();
await ApiClient.Delete(cat.Id);
TestData.Cats.FirstOrDefault(x => x.Id == cat.Id).Should().BeNull();
RestClientMock.Verify();
}
public async Task Create_Successful()
{
var cat = new Cat {
Id = Guid.NewGuid(), Name = Guid.NewGuid().ToString()
};
await ApiClient.Create(cat);
TestData.Cats.FirstOrDefault(x => x.Id == cat.Id).Should().BeEquivalentTo(cat);
RestClientMock.Verify();
}
public async Task DeleteAsync_Ok()
{
var resultTest = new ResultError();
var restClient = RestClientMock.DeleteRestClient(resultTest);
var testTransferConverter = TestTransferConverter;
var testRestService = new TestRestService(restClient.Object, testTransferConverter);
var result = await testRestService.DeleteAsync();
Assert.True(result.OkStatus);
}
public async Task GetClothesDetail_Error()
{
var error = ErrorTransferData.ErrorBadRequest;
var resultClothes = new ResultCollection <ClothesDetailTransfer>(error);
var restClient = RestClientMock.GetRestClient(resultClothes);
var clothesRestService = GetClothesRestService(restClient.Object);
var result = await clothesRestService.GetClothesDetails(GenderType.Male, String.Empty);
Assert.True(result.HasErrors);
Assert.True(result.Errors.First().ErrorResultType == ErrorResultType.BadRequest);
}
public void ControllerName_Ok()
{
var tests = TestTransferData.TestTransfers;
var resultTests = new ResultCollection <TestTransfer>(tests);
var restClient = RestClientMock.GetRestClient(resultTests);
var testTransferConverter = TestTransferConverter;
var testRestService = new TestRestService(restClient.Object, testTransferConverter);
var controllerName = testRestService.ControllerName;
Assert.Equal("Test", controllerName);
}
public async Task Update_Successful()
{
var cat = TestData.Cats.FirstOrDefault();
var newName = Guid.NewGuid().ToString();
cat.Name = newName;
await ApiClient.Update(cat);
TestData.Cats.FirstOrDefault(x => x.Name == newName).Should().NotBeNull();
RestClientMock.Verify();
}
public async Task GetClothesImages_Error()
{
var clothes = ClothesTransfersData.ClothesMainTransfers.First();
var error = ErrorTransferData.ErrorBadRequest;
var resultClothes = new ResultCollection <byte[]>(error);
var restClient = RestClientMock.GetRestClient(resultClothes);
var clothesRestService = GetClothesRestService(restClient.Object);
var result = await clothesRestService.GetImages(clothes.Id);
Assert.True(result.HasErrors);
Assert.True(result.Errors.First().ErrorResultType == ErrorResultType.BadRequest);
}
public async Task GetClothesImage_Ok()
{
var clothes = ClothesTransfersData.ClothesMainTransfers.First();
var image = clothes.Images.First();
var resultClothes = new ResultValue <byte[]>(image.Image);
var restClient = RestClientMock.GetRestClient(resultClothes);
var clothesRestService = GetClothesRestService(restClient.Object);
var result = await clothesRestService.GetImage(clothes.Id);
Assert.True(result.OkStatus);
Assert.True(result.Value.SequenceEqual(image.Image));
}
public async Task GetByIdAsync_Ok()
{
var test = TestTransferData.TestTransfers.First();
var resultTest = new ResultValue <TestTransfer>(test);
var restClient = RestClientMock.GetRestClient(resultTest);
var testTransferConverter = TestTransferConverter;
var testRestService = new TestRestService(restClient.Object, testTransferConverter);
var result = await testRestService.GetAsync(test.Id);
Assert.True(result.OkStatus);
Assert.True(TestData.TestDomains.First().Equals(result.Value));
}
public async Task GetAsync_Error()
{
var error = ErrorTransferData.ErrorBadRequest;
var resultTests = new ResultCollection <TestTransfer>(error);
var restClient = RestClientMock.GetRestClient(resultTests);
var testTransferConverter = TestTransferConverter;
var testRestService = new TestRestService(restClient.Object, testTransferConverter);
var result = await testRestService.GetAsync();
Assert.True(result.HasErrors);
Assert.True(result.Errors.First().ErrorResultType == ErrorResultType.BadRequest);
}
public async Task PutAsync_Ok()
{
var testDomain = TestData.TestDomains.First();
var test = TestTransferData.TestTransfers.First();
var resultTest = new ResultValue <TestTransfer>(test);
var restClient = RestClientMock.PutRestClient(resultTest);
var testTransferConverter = TestTransferConverter;
var testRestService = new TestRestService(restClient.Object, testTransferConverter);
var result = await testRestService.PutAsync(testDomain);
Assert.True(result.OkStatus);
}
public async Task GetAsync_Ok()
{
var tests = TestTransferData.TestTransfers;
var resultTests = new ResultCollection <TestTransfer>(tests);
var restClient = RestClientMock.GetRestClient(resultTests);
var testTransferConverter = TestTransferConverter;
var testRestService = new TestRestService(restClient.Object, testTransferConverter);
var result = await testRestService.GetAsync();
Assert.True(result.OkStatus);
Assert.True(TestData.TestDomains.SequenceEqual(result.Value));
}
public void OneTimeSetUp()
{
Setup.Bootstrap(SetupType.Test);
SqlDataRecord = new SqlDataRecord(
new SqlMetaData("Id", SqlDbType.UniqueIdentifier),
new SqlMetaData("Name", SqlDbType.NVarChar, 20));
var apiSettings = IocWrapper.Instance.GetService <IApiSettings>();
RestClientMock = new RestClientMock();
ApiClient = new ApiClient(RestClientMock.Instance, apiSettings);
}
public async Task PostCollectionAsync_Ok()
{
var tests = TestData.TestDomains;
var testsIds = tests.Select(test => test.Id).ToList();
var resultIds = new ResultCollection <TestEnum>(testsIds);
var restClient = RestClientMock.PostRestClient(resultIds);
var testTransferConverter = TestTransferConverter;
var testRestService = new TestRestService(restClient.Object, testTransferConverter);
var result = await testRestService.PostCollectionAsync(tests);
Assert.True(result.OkStatus);
Assert.True(result.Value.SequenceEqual(testsIds));
}
public async Task AuthorizeJwt_Error()
{
var error = ErrorTransferData.ErrorBadRequest;
var jwtTokenResult = new ResultValue <string>(error);
var authorize = AuthorizeData.AuthorizeDomains.First();
var restHttpClient = RestClientMock.PostRestClient(jwtTokenResult);
var authorizeTransferConverter = AuthorizeTransferConverter;
var authorizeRestService = new AuthorizeRestService(restHttpClient.Object, authorizeTransferConverter);
var resultToken = await authorizeRestService.AuthorizeJwt(authorize);
Assert.True(resultToken.HasErrors);
Assert.True(error.Equals(resultToken.Errors.First()));
}
public async Task DeleteByIdAsync_Error()
{
var test = TestTransferData.TestTransfers.First();
var error = ErrorTransferData.ErrorBadRequest;
var resultTest = new ResultValue <TestTransfer>(error);
var restClient = RestClientMock.DeleteRestClient(resultTest);
var testTransferConverter = TestTransferConverter;
var testRestService = new TestRestService(restClient.Object, testTransferConverter);
var result = await testRestService.DeleteAsync(test.Id);
Assert.True(result.HasErrors);
Assert.True(result.Errors.First().ErrorResultType == ErrorResultType.BadRequest);
}
public async Task PutAsync_Error()
{
var testDomain = TestData.TestDomains.First();
var error = ErrorTransferData.ErrorBadRequest;
var resultTest = new ResultError(error);
var restClient = RestClientMock.PutRestClient(resultTest);
var testTransferConverter = TestTransferConverter;
var testRestService = new TestRestService(restClient.Object, testTransferConverter);
var result = await testRestService.PutAsync(testDomain);
Assert.True(result.HasErrors);
Assert.True(result.Errors.First().ErrorResultType == ErrorResultType.BadRequest);
}
public async Task PostValueAsync_Ok()
{
var test = TestData.TestDomains.First();
var testId = test.Id;
var resultId = new ResultValue <TestEnum>(testId);
var restClient = RestClientMock.PostRestClient(resultId);
var testTransferConverter = TestTransferConverter;
var testRestService = new TestRestService(restClient.Object, testTransferConverter);
var result = await testRestService.PostValueAsync(test);
Assert.True(result.OkStatus);
Assert.True(result.Value.Equals(testId));
}
public async Task AuthorizeJwt_Ok()
{
const string jwtToken = "jwtToken";
var jwtTokenResult = jwtToken.ToResultValue();
var authorize = AuthorizeData.AuthorizeDomains.First();
var restHttpClient = RestClientMock.PostRestClient(jwtTokenResult);
var authorizeTransferConverter = AuthorizeTransferConverter;
var authorizeRestService = new AuthorizeRestService(restHttpClient.Object, authorizeTransferConverter);
var resultToken = await authorizeRestService.AuthorizeJwt(authorize);
Assert.True(resultToken.OkStatus);
Assert.Equal(jwtToken, resultToken.Value);
}
public async Task GetClothesDetail_Ok()
{
var clothesDetails = ClothesTransfersData.ClothesDetailTransfers;
var resultClothes = new ResultCollection <ClothesDetailTransfer>(clothesDetails);
var restClient = RestClientMock.GetRestClient(resultClothes);
var clothesTransferConverter = ClothesTransferConverterMock.ClothesDetailTransferConverter;
var clothesRestService = GetClothesRestService(restClient.Object);
var result = await clothesRestService.GetClothesDetails(clothesDetails.First().GenderType, clothesDetails.First().ClothesTypeName);
var clothesDomains = clothesTransferConverter.FromTransfers(clothesDetails);
Assert.True(result.OkStatus);
Assert.True(result.Value.SequenceEqual(clothesDomains.Value));
}
public async Task GetGenderCategories_Error()
{
var error = ErrorTransferData.ErrorBadRequest;
var resultGenders = new ResultCollection <GenderCategoryTransfer>(error);
var restClient = RestClientMock.GetRestClient(resultGenders);
var genderTransferConverter = GenderTransferConverterMock.GenderTransferConverter;
var genderCategoryTransferConverter = GenderTransferConverterMock.GenderCategoryTransferConverter;
var genderRestService = new GenderRestService(restClient.Object, genderTransferConverter,
genderCategoryTransferConverter);
var result = await genderRestService.GetGenderCategories();
Assert.True(result.HasErrors);
Assert.True(result.Errors.First().ErrorResultType == ErrorResultType.BadRequest);
}
public async Task GetClothesImages_Ok()
{
var clothes = ClothesTransfersData.ClothesMainTransfers.First();
var images = clothes.Images;
var resultClothes = new ResultCollection <ClothesImageTransfer>(images);
var restClient = RestClientMock.GetRestClient(resultClothes);
var clothesImageTransferConverter = ClothesImageTransferConverterMock.ClothesImageTransferConverter;
var clothesRestService = GetClothesRestService(restClient.Object);
var result = await clothesRestService.GetImages(clothes.Id);
var imageDomains = clothesImageTransferConverter.FromTransfers(images);
Assert.True(result.OkStatus);
Assert.True(result.Value.SequenceEqual(imageDomains.Value));
}
public void CopyTestFile_should_call_expected_web_method(bool expectedResult)
{
// given
const string sourceFileName = "gotta love TDD";
const string targetFileName = "I said what what in the b...";
const string expectedServiceUrl = "I am a base url";
var client = new RestClientMock
{
RestResponse = new RestResponse
{
StatusCode = HttpStatusCode.OK,
Content = expectedResult.ToString().ToLower()
}
};
var clientFactory = new Mock <IRestSharpClientFactory>();
clientFactory
.Setup(x => x.Create(expectedServiceUrl))
.Returns(client);
// when
var testsClient = new TestsClient(expectedServiceUrl, clientFactory.Object);
bool result = testsClient.CopyTestFile(sourceFileName, targetFileName);
// then
Assert.That(result, Is.EqualTo(expectedResult));
IRestRequest request = client.RestRequest;
Assert.That(request.Method, Is.EqualTo(Method.POST));
Assert.That(request.Resource, Is.EqualTo(TestsClient.RESOURCE_PATH + "/testfile/copy"));
Assert.That(request.Parameters.Count, Is.EqualTo(2));
Parameter param1 = request.Parameters[0];
Assert.That(param1.Name, Is.EqualTo("sourceFileName"));
Assert.That(param1.Type, Is.EqualTo(ParameterType.QueryString));
Assert.That(param1.Value, Is.EqualTo(sourceFileName));
Parameter param2 = request.Parameters[1];
Assert.That(param2.Name, Is.EqualTo("targetFileName"));
Assert.That(param2.Type, Is.EqualTo(ParameterType.QueryString));
Assert.That(param2.Value, Is.EqualTo(targetFileName));
}
public void CopyTest_should_call_expected_web_method(bool expectedResult)
{
// given
const string expectedServiceUrl = "some-url-init";
const int expectedPosition = 123;
const string expectedFileName = "lalalala.txt";
var client = new RestClientMock
{
RestResponse = new RestResponse
{
StatusCode = HttpStatusCode.OK,
Content = expectedResult.ToString().ToLower()
}
};
var clientFactory = new Mock <IRestSharpClientFactory>();
clientFactory
.Setup(x => x.Create(expectedServiceUrl))
.Returns(client);
// when
var testsClient = new TestsClient(expectedServiceUrl, clientFactory.Object);
bool result = testsClient.CopyTest(expectedPosition, expectedFileName);
// then
Assert.That(result, Is.EqualTo(expectedResult));
IRestRequest request = client.RestRequest;
Assert.That(request.Method, Is.EqualTo(Method.POST));
Assert.That(request.Resource, Is.EqualTo(TestsClient.RESOURCE_PATH + "/test/copy"));
Assert.That(request.Parameters.Count, Is.EqualTo(2));
Parameter param1 = request.Parameters[0];
Assert.That(param1.Name, Is.EqualTo("position"));
Assert.That(param1.Type, Is.EqualTo(ParameterType.QueryString));
Assert.That(param1.Value, Is.EqualTo(expectedPosition.ToString()));
Parameter param2 = request.Parameters[1];
Assert.That(param2.Name, Is.EqualTo("fileName"));
Assert.That(param2.Type, Is.EqualTo(ParameterType.QueryString));
Assert.That(param2.Value, Is.EqualTo(expectedFileName));
}
public async Task GetGenderCategories_Ok()
{
var genders = GenderTransfersData.GenderCategoryTransfers;
var resultGenders = new ResultCollection <GenderCategoryTransfer>(genders);
var restClient = RestClientMock.GetRestClient(resultGenders);
var genderTransferConverter = GenderTransferConverterMock.GenderTransferConverter;
var genderCategoryTransferConverter = GenderTransferConverterMock.GenderCategoryTransferConverter;
var genderRestService = new GenderRestService(restClient.Object, genderTransferConverter,
genderCategoryTransferConverter);
var result = await genderRestService.GetGenderCategories();
var genderDomains = genderCategoryTransferConverter.FromTransfers(genders);
Assert.True(result.OkStatus);
Assert.True(result.Value.SequenceEqual(genderDomains.Value));
}
public void GetHotelsByLocation_CoordinatesValid_ExpectedResult_WithCallSaveToDb_OneRecord()
{
IRestResponse resp = new RestResponse()
{
Content = JsonConvert.SerializeObject(new Result()
{
Results = new List <HotelResult>()
})
};
RestClientMock.Setup(m => m.ExecuteAsync(It.IsAny <IRestRequest>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(resp))
.Verifiable();
var responce = sut.GetHotelsByLocation("19.22,189.33").GetAwaiter().GetResult();
RestClientMock.Verify(x => x.ExecuteAsync(It.IsAny <IRestRequest>(), It.IsAny <CancellationToken>()), Times.Once);
Assert.IsNotNull(responce);
Assert.IsInstanceOfType(responce, typeof(Result));
Assert.AreEqual(0, responce.Results.Count());
}
private HttpClient CreateClient(IRestResponse restResponse)
{
_restClientMock = new RestClientMock();
_restClientMock.RestResponse = restResponse;
return(new HttpClient(_restClientMock));
}
