public async Task It_Is_Possible_To_Invoke_The_Controller_GetAll()
{
var serviceMock = new Mock <ICityService>();
serviceMock.Setup(s => s.GetAll()).ReturnsAsync(
new List <CityDto>
{
new CityDto
{
Id = Guid.NewGuid(),
Name = Faker.Address.City()
},
new CityDto
{
Id = Guid.NewGuid(),
Name = Faker.Address.City()
}
});
_controller = new CitiesController(serviceMock.Object);
var result = await _controller.GetAll();
Assert.True(result is OkObjectResult);
var resultValue = ((OkObjectResult)result).Value as IEnumerable <CityDto>;
Assert.True(resultValue.Count() == 2);
}
public async Task Create_AddCity_AddedCityReturned()
{
// Arrange
var newCity = new CityDto()
{
Name = Common.CityName
};
var resultCity = new CityDto()
{
Id = 1, Name = Common.CityName
};
var mock = new Mock <IRestaurantManagementService>();
mock.Setup(rmService => rmService.AddCityAsync(It.IsAny <CityDto>()))
.Returns(Task.FromResult(resultCity));
var loggerMock = new Mock <ILogger <CitiesController> >();
var controller = new CitiesController(mock.Object, loggerMock.Object);
// Act
var result = await controller.Create(newCity);
// Assert
var actionResult = Assert.IsType <CreatedAtRouteResult>(result);
Assert.Equal(resultCity, actionResult?.Value);
}
public async Task Given_A_City_Request_Verify_Service_Method_Are_Called_Once()
{
//Arrange
var cityController = new CitiesController(_serviceCore.Object);
_serviceCore.Setup(x => x.GetCityByNameAsync(It.IsAny <string>()));
_serviceCore.Setup(x => x.AddCityAsync(It.IsAny <CityAddTransferModel>()));
_serviceCore.Setup(x => x.UpdateCityAsync(It.IsAny <int>(), It.IsAny <CityUpdateTransferModel>()));
_serviceCore.Setup(x => x.DeleteCityAsync(It.IsAny <int>()));
_serviceCore.Setup(x => x.CityExistsAsync(It.IsAny <int>())).ReturnsAsync(true);
//Act
await cityController.GetCity("test");
await cityController.CreateCity(new CityAddTransferModel());
await cityController.UpdateCity(1, new CityUpdateTransferModel());
await cityController.DeleteCity(1);
//Assert
_serviceCore.Verify(x => x.GetCityByNameAsync(It.IsAny <string>()), Times.Once);
_serviceCore.Verify(x => x.GetCityByNameAsync(It.IsAny <string>()), Times.Once);
_serviceCore.Verify(x => x.AddCityAsync(It.IsAny <CityAddTransferModel>()), Times.Once);
_serviceCore.Verify(x => x.UpdateCityAsync(It.IsAny <int>(), It.IsAny <CityUpdateTransferModel>()), Times.Once);
_serviceCore.Verify(x => x.DeleteCityAsync(It.IsAny <int>()), Times.Once);
}
public void GetAsync_Return_Empty_List()
{
//Arrange
CityDomainModel cityDomainModel = new CityDomainModel
{
Id = 123,
CinemasList = new List <CinemaDomainModel>(),
Name = "Zrenjanin"
};
int expectedStatusCode = 200;
IEnumerable <CityDomainModel> cityDomainModelsIEn = null;
Task <IEnumerable <CityDomainModel> > responseTask = Task.FromResult(cityDomainModelsIEn);
_cityService = new Mock <ICityService>();
_cityService.Setup(x => x.GetAllAsync()).Returns(responseTask);
CitiesController citiesController = new CitiesController(_cityService.Object);
//Act
var result = citiesController.GetAsync().ConfigureAwait(false).GetAwaiter().GetResult().Result;
var objectResult = ((OkObjectResult)result).Value;
List <CityDomainModel> cityDomainModelResultList = (List <CityDomainModel>)objectResult;
//Assert
Assert.IsNotNull(objectResult);
Assert.IsInstanceOfType(result, typeof(OkObjectResult));
Assert.AreEqual(expectedStatusCode, ((OkObjectResult)result).StatusCode);
}
public void GetCity_ById_Async_Return_City_OkObjectResult()
{
//Arrange
CityDomainModel cityDomainModel = new CityDomainModel
{
Id = 123,
CinemasList = new List <CinemaDomainModel>(),
Name = "Zrenjanin"
};
int expectedStatusCode = 200;
Task <CityDomainModel> responseTask = Task.FromResult(cityDomainModel);
_cityService = new Mock <ICityService>();
_cityService.Setup(x => x.GetByIdAsync(It.IsAny <int>())).Returns(responseTask);
CitiesController citiesController = new CitiesController(_cityService.Object);
//Act
var result = citiesController.GetById(cityDomainModel.Id).ConfigureAwait(false).GetAwaiter().GetResult().Result;
var objectResult = ((OkObjectResult)result).Value;
CityDomainModel cityDomainResult = (CityDomainModel)objectResult;
//Assert
Assert.IsNotNull(objectResult);
Assert.IsInstanceOfType(result, typeof(OkObjectResult));
Assert.AreEqual(expectedStatusCode, ((OkObjectResult)result).StatusCode);
Assert.AreEqual(cityDomainModel.Id, cityDomainResult.Id);
}
public async Task It_Is_Possible_To_Invoke_The_Controller_Update()
{
var serviceMock = new Mock <ICityService>();
serviceMock.Setup(s => s.Put(It.IsAny <CityDtoUpdate>())).ReturnsAsync(
new CityDtoUpdateResult
{
Id = Guid.NewGuid(),
Name = "Passo Fundo",
UpdatedAt = DateTime.Now
});
_controller = new CitiesController(serviceMock.Object);
var cityDtoUpdate = new CityDtoUpdate
{
Name = "Passo Fundo"
};
var result = await _controller.Put(cityDtoUpdate);
Assert.True(result is OkObjectResult);
var resultValue = ((OkObjectResult)result).Value as CityDtoUpdateResult;
Assert.NotNull(resultValue);
Assert.Equal(cityDtoUpdate.Name, resultValue.Name);
}
public async Task It_Is_Possible_To_Invoke_The_Controller_Update()
{
var serviceMock = new Mock <ICityService>();
serviceMock.Setup(s => s.Put(It.IsAny <CityDtoUpdate>())).ReturnsAsync(
new CityDtoUpdateResult
{
Id = Guid.NewGuid(),
Name = Faker.Address.City(),
UpdatedAt = DateTime.Now
});
_controller = new CitiesController(serviceMock.Object);
_controller.ModelState.AddModelError("Name", "Nome é obrigatório.");
var cityDtoUpdate = new CityDtoUpdate
{
Name = Faker.Address.City(),
IBGECode = 1
};
var result = await _controller.Put(cityDtoUpdate);
Assert.True(result is BadRequestObjectResult);
}
public void GetGreetings()
{
// Arrange
CitiesController controller = new CitiesController();
// Act
IHttpActionResult result = controller.GetGreetings(_CITY_GUID, _USER_GUID);
var contentResult = result as OkNegotiatedContentResult <getUserGreetingsResponse>;
// Assert
Assert.IsNotNull(result);
Assert.IsNotNull(contentResult.Content);
Assert.IsNotNull(contentResult.Content.greetings);
Assert.IsInstanceOfType(contentResult.Content, typeof(getUserGreetingsResponse));
Assert.AreNotEqual(contentResult.Content.greetings.Count, 0);
//***Test Invalid CityGuid Request***
// Act
IHttpActionResult resultCityInvalidGuid = controller.GetGreetings("invalid", _USER_GUID);
// Assert
Assert.IsNotNull(resultCityInvalidGuid);
Assert.IsInstanceOfType(resultCityInvalidGuid, typeof(BadRequestErrorMessageResult));
//*************************
//***Test Invalid UserGuid Request***
// Act
IHttpActionResult resultInvalidUserGuid = controller.GetGreetings(_CITY_GUID, "invalid");
// Assert
Assert.IsNotNull(resultInvalidUserGuid);
Assert.IsInstanceOfType(resultInvalidUserGuid, typeof(BadRequestErrorMessageResult));
//*************************
}
public CityControllerTest()
{
cityMock = new Mock <IMasterData <City, int> >();
iMappingMock = new Mock <IMapping <Core.Model.Mappings.City> >();
loggerMock = new Mock <ILogger>();
mockCityController = new CitiesController(cityMock.Object, loggerMock.Object, iMappingMock.Object);
}
public void GetCitiesControllerInstallNull()
{
//Arrange
var mockCityService = new Mock <ICityService>();
var cities = new List <City>();
cities.Add(new City()
{
name = "City of Sydney", id = 6619279, country = "AU"
});
mockCityService.Setup(x => x.GetCities("AU")).Returns(cities);
try
{
var controller = new CitiesController(null);
//Act
var result = controller.CityDetails("AU");
}
catch (Exception ex)
{
//Assert
Assert.AreEqual("System.NullReferenceException", ex.GetType().ToString());
}
}
public void SetUp()
{
logger = new Mock <ILogger <CitiesController> >();
citiesServices = new Mock <ICityService>();
subject = new CitiesController(citiesServices.Object, logger.Object);
}
public Context()
{
repository = Substitute.For <ICityInfoRepository>();
mapper = Substitute.For <IMapper>();
controller = new CitiesController(repository, mapper);
}
public async Task GetCities_Should_Return_All_CitiesAsync()
{
var cities = new[]
{
new CityDto()
{
CityId = 1,
Name = "Stockholm",
Sights = new List <SightDto>()
},
new CityDto()
{
CityId = 1,
Name = "Lund",
Sights = new List <SightDto>()
}
};
var mockedService = new Mock <ICitiesService>();
mockedService.Setup(x => x.GetAllCitiesAsync())
.Returns(Task.FromResult((IEnumerable <CityDto>)cities));
var mockedLogger = new Mock <ILogger <CitiesController> >();
var controller = new CitiesController(mockedLogger.Object, mockedService.Object);
var result = await controller.GetCitiesAsync() as OkObjectResult;
var data = result.Value as IEnumerable <CityDto>;
Assert.Collection(data, x => Assert.Contains("Stockholm", x.Name),
x => Assert.Contains("Lund", x.Name));
}
public async Task GetCities_CallsServicesForEachCity()
{
ICollection <City> cityList = new List <City>();
ICollection <Country> countryList = new List <Country>();
cityList.Add(new City {
CountryName = "United Kingdom", Name = "Cardiff"
});
_cityRepository.Setup(cr => cr.GetCitiesAsync(It.IsAny <string>())).ReturnsAsync(cityList);
_mapper.Setup(m => m.Map <CityInformation>(It.IsAny <City>())).Returns(new CityInformation {
CountryName = "United Kingdom", Name = "Cardiff"
});
_countryApiClient.Setup(countries => countries.GetCountriesAsync(It.IsAny <string>())).ReturnsAsync(countryList);
_weatherApiClient.Setup(weather => weather.GetWeatherForCityAsync(It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync(new Envelope {
Weather = new Weather[] { new Weather {
Description = "not too shabby"
} }
});
_appSettings.SetupGet(appSettings => appSettings.CurrentValue)
.Returns(new AppSettingsOptions {
OpenweatherAppId = "12345"
});
var c = new CitiesController(_appSettings.Object, _mapper.Object, _countryApiClient.Object, _weatherApiClient.Object, _cityRepository.Object);
var response = await c.GetCities("mytown");
Assert.IsNotNull(response);
Assert.IsInstanceOfType(response, typeof(OkObjectResult));
Assert.AreEqual("not too shabby", (((OkObjectResult)response).Value as List <CityInformation>).First().WeatherDescription);
_weatherApiClient.Verify();
_countryApiClient.Verify();
}
public void GetCities_NameDoesNotExists_ReturnsEmptyList()
{
var controller = new CitiesController(new FakeCitiesService());
var result = controller.GetCities("non-existing");
Assert.Empty(result.Value);
}
public async Task It_Is_Possible_To_Invoke_The_Controller_Create()
{
var serviceMock = new Mock <ICityService>();
serviceMock.Setup(s => s.Post(It.IsAny <CityDtoCreate>())).ReturnsAsync(
new CityDtoCreateResult
{
Id = Guid.NewGuid(),
Name = "Passo Fundo",
CreatedAt = DateTime.Now
});
_controller = new CitiesController(serviceMock.Object);
_controller.ModelState.AddModelError("Name", "Nome é obrigatório.");
Mock <IUrlHelper> url = new Mock <IUrlHelper>();
url.Setup(s => s.Link(It.IsAny <string>(), It.IsAny <object>())).Returns("http://localhost:5000");
_controller.Url = url.Object;
var cityDtoCreate = new CityDtoCreate
{
Name = "Passo Fundo",
IBGECode = 1
};
var result = await _controller.Post(cityDtoCreate);
Assert.True(result is BadRequestObjectResult);
}
public async Task It_Is_Possible_To_Invoke_The_Controller_Create()
{
var serviceMock = new Mock <ICityService>();
serviceMock.Setup(s => s.Post(It.IsAny <CityDtoCreate>())).ReturnsAsync(
new CityDtoCreateResult
{
Id = Guid.NewGuid(),
Name = "Passo Fundo",
CreatedAt = DateTime.Now
});
_controller = new CitiesController(serviceMock.Object);
Mock <IUrlHelper> url = new Mock <IUrlHelper>();
url.Setup(s => s.Link(It.IsAny <string>(), It.IsAny <object>())).Returns("http://localhost:5000");
_controller.Url = url.Object;
var cityDtoCreate = new CityDtoCreate
{
Name = "Passo Fundo"
};
var result = await _controller.Post(cityDtoCreate);
Assert.True(result is CreatedResult);
var resultValue = ((CreatedResult)result).Value as CityDtoCreateResult;
Assert.NotNull(resultValue);
Assert.Equal(cityDtoCreate.Name, resultValue.Name);
}
public void GetCities_NameExists_ReturnsOneCity()
{
var controller = new CitiesController(new FakeCitiesService());
var result = controller.GetCities("existing");
Assert.Single(result.Value);
}
public async Task GetCity_Should_Return_NotFoundAsync(int id,
string name, int requestId, string expectedMessage)
{
var city = new CityDto()
{
CityId = id,
Name = name,
Sights = new List <SightDto>()
};
var mockedService = new Mock <ICitiesService>();
mockedService.Setup(x => x.GetCityByIdAsync(id))
.Returns(Task.FromResult(city));
var mockedLogger = new Mock <ILogger <CitiesController> >();
var controller = new CitiesController(mockedLogger.Object, mockedService.Object);
var result = await controller.GetCityAsync(requestId);
Assert.IsType <NotFoundObjectResult>(result);
var data = (result as NotFoundObjectResult).Value;
Assert.Equal(expectedMessage, data);
}
public BaseCityController()
{
MockCityRepository = Substitute.For <ICityRepository>(); // Création du mock à partir d'un interafce
CityController = new CitiesController(MockCityRepository); // Injection du mock dans le controleur
CityFaker = new CityGenerator();
ToDTO = new EntitiesToDTO();
}
public async Task GetCities_Valid_Test(int page, int pageSize, string cityName)
{
// Arrange
CitiesController citycon = CreateCityController;
var httpContext = new Mock <HttpContext>();
httpContext
.Setup(m => m.User.IsInRole(Roles.Admin))
.Returns(true);
var context = new ControllerContext(
new ActionContext(
httpContext.Object, new RouteData(),
new ControllerActionDescriptor()));
citycon.ControllerContext = context;
_cityService
.Setup(c => c.GetAllDTOAsync(It.IsAny <string>()))
.ReturnsAsync(GetCitiesBySearch());
// Act
var result = await citycon.GetCities(page, pageSize, cityName);
// Assert
Assert.NotNull(result);
Assert.IsInstanceOf <OkObjectResult>(result);
Assert.IsNotNull(((result as ObjectResult).Value as CitiesViewModel)
.Cities.Where(c => c.Name.Equals("Львів")));
}
public void GetCity_NoEF_ReturnsNotFound()
{
var controller = new CitiesController(_mockCityInfoRepository.Object, _mockMongoRepository.Object, _mockLogger.Object, _mockMailService.Object);
var result = controller.GetCity(1);
Assert.IsInstanceOfType(result, typeof(NotFoundResult));
}
public void GetRating()
{
// Arrange
CitiesController controller = new CitiesController();
// Act
IHttpActionResult result = controller.GetRating(_CITY_GUID, _USER_GUID);
var contentResult = result as OkNegotiatedContentResult <getRatingForCity>;
// Assert
Assert.IsNotNull(result);
Assert.IsNotNull(contentResult.Content);
Assert.IsNotNull(contentResult.Content.rating);
Assert.IsInstanceOfType(contentResult.Content, typeof(getRatingForCity));
//***Test Invalid CityGuid Request***
// Act
IHttpActionResult resultCityInvalidGuid = controller.GetRating("invalid", _USER_GUID);
// Assert
Assert.IsNotNull(resultCityInvalidGuid);
Assert.IsInstanceOfType(resultCityInvalidGuid, typeof(BadRequestErrorMessageResult));
//*************************
//***Test Invalid UserGuid Request***
// Act
IHttpActionResult resultInvalidUserGuid = controller.GetRating(_CITY_GUID, "invalid");
// Assert
Assert.IsNotNull(resultInvalidUserGuid);
Assert.IsInstanceOfType(resultInvalidUserGuid, typeof(BadRequestErrorMessageResult));
//*************************
}
static void Main(string[] args)
{
ValidatorService validatorService = new ValidatorService();
FiltrService filtrService = new FiltrService();
CitiesController citiesController = new CitiesController(validatorService, filtrService);
FiltrData data = new FiltrData
{
Cities = new City[]
{
new City {
Budget = 1000, Name = "Moscow", Point = new Point {
X = 1, Y = 1
}
},
new City {
Budget = 700, Name = "Piter", Point = new Point {
X = 1, Y = 2
}
},
new City {
Budget = 300, Name = "Tver", Point = new Point {
X = 2, Y = 1
}
}
},
Options = new FiltrOptions
{
Iterations = 12,
PercentBet = 0.06
}
};
citiesController.FiltrData(data);
}
public async Task It_Is_Possible_To_Invoke_The_Controller_GetAll()
{
var serviceMock = new Mock <ICityService>();
serviceMock.Setup(s => s.GetAll()).ReturnsAsync(
new List <CityDto>
{
new CityDto
{
Id = Guid.NewGuid(),
Name = Faker.Address.City()
},
new CityDto
{
Id = Guid.NewGuid(),
Name = Faker.Address.City()
}
});
_controller = new CitiesController(serviceMock.Object);
_controller.ModelState.AddModelError("Id", "FormatoInvalido");
var result = await _controller.GetAll();
Assert.True(result is BadRequestObjectResult);
}
public void GetCityReturnNotFound()
{
var sut = new CitiesController();
ActionResult response = sut.GetCity(4);
Assert.IsType <Microsoft.AspNetCore.Mvc.NotFoundResult>(response);
}
public void GetCityReturnOkObjectResult()
{
var sut = new CitiesController();
ActionResult response = sut.GetCity(1);
Assert.IsType <OkObjectResult>(response);
}
public async Task GetCity_ReturnsOk()
{
var controller = new CitiesController();
var result = await controller.GetCity(1);
Assert.IsType <OkObjectResult>(result);
}
public void GetAllCities_RedirectsToGetCitiesWithWildcard()
{
var c = new CitiesController(_appSettings.Object, _mapper.Object, _countryApiClient.Object, _weatherApiClient.Object, _cityRepository.Object);
var result = c.GetAllCities();
Assert.IsInstanceOfType(result, typeof(RedirectToActionResult));
Assert.AreEqual("*", ((RedirectToActionResult)result).RouteValues["cityName"]);
}
public void PutCityTest()
{
var controller = new CitiesController();
var city1 = new City {
ID = 4088, Name = "Kittland", District = "Washington", CountryCode = "USA", Population = 888908
};
Assert.IsType <OkResult>(controller.Put(4088, city1));
}
public void GetAllShouldReturnZeroCitiesWhenEmpty()
{
var data = new FakeTouristSitesData();
var controller = new CitiesController(data);
var result = controller.Get();
var okResult = result as OkNegotiatedContentResult<List<CityResponseModel>>;
Assert.IsNotNull(okResult);
Assert.AreEqual(0, okResult.Content.Count);
}
public void GetShouldReturnOneCityWhenThereIsOne()
{
var data = new FakeTouristSitesData();
data.Cities.Add(new City());
var controller = new CitiesController(data);
var result = controller.Get();
var okResult = result as OkNegotiatedContentResult<List<CityResponseModel>>;
Assert.IsNotNull(okResult);
Assert.AreEqual(1, okResult.Content.Count);
}
