public void CreateUniversityAsync()
{
//Arrange
_mockUnitOfWork.Setup(_mockUnitOfWork => _mockUnitOfWork.Universities.AddAsync(mockUniversity, It.IsAny <CancellationToken>())).Returns(Task.FromResult(mockUniversity));
//Act
var expected = _universityService.CreateUniversityAsync(mockUniversityCreateDto, It.IsAny <CancellationToken>()).Result;
var newId = expected.Id;
var newMockUniversityDto = new UniversityDto()
{
Id = newId,
Name = mockUniversityCreateDto.Name
};
var sameAsExpected = expected;
//Assert
//Assert.AreEqual(expected, newMockUniversityDto);//classic model of assertions(older)
Assert.That(expected, Is.EqualTo(newMockUniversityDto));//constraint model of assertions(newer)
//Assert.That(expected, Is.SameAs(newMockUniversityDto), "fails because it only compares references and not values");//fails because it only compares references and not values
//Assert.That(expected, Is.SameAs(sameAsExpected));//passes
//Assert.That(expected, Has.Exactly(1).Items);//fails because of the type of expected
//Assert.That(expected,Is.Not.Null);
//_mockUnitOfWork.SetupAllProperties();
}
public UniversityDetailsPage(UniversityDto university, string regionName)
{
_httpClient = new SpecialitiesHttpClient();
InitializeComponent();
var specialities =
_httpClient.GetSpecialitiesByUniversityIdAsync(Application.Current.Properties["token"].ToString(),
university.Id).GetAwaiter().GetResult();
BindingContext = _viewModel = new UniversityDetailsViewModel(Navigation, university, specialities, regionName);
}
public static UniversityModel Convert(UniversityDto cityDto)
{
var university = new UniversityModel
{
ShortName = cityDto.ShortName,
Id = cityDto.Id
};
return(university);
}
public ActionResult <UniversityDto> CreateUniversity(UniversityDto dto)
{
var adding = dataContext.Set <University>().Add(new University
{
Name = dto.Name,
});
dataContext.SaveChanges();
dto.Id = adding.Entity.Id;
return(Created($"/api/University/{adding.Entity.Id}", dto));
}
public IActionResult CreateUni([FromBody] UniversityDto universityDto)
{
var university = universityDto.ToDb();
if (university == null)
{
return(BadRequest());
}
_db.Universities.Add(university);
_db.SaveChanges();
return(Ok());
}
public IActionResult Update(int universityId, [FromBody] UniversityDto universityDto)
{
var university = _db.Universities.SingleOrDefault(u => u.UniversityId == universityId);
if (university == null)
{
return(BadRequest("Id not found!"));
}
university.UniName = universityDto.UniName;
_db.Universities.Update(university);
_db.SaveChanges();
return(Ok());
}
public ActionResult <UniversityDto> UpdateUniversity(UniversityDto dto)
{
var target = dataContext.Set <University>().SingleOrDefault(x => x.Id == dto.Id);
if (target == null)
{
return(NotFound());
}
target.Name = dto.Name;
dataContext.SaveChanges();
return(Ok(dto));
}
public ActionResult Add(UniversityDto universityDto)
{
if (!ModelState.IsValid)
{
return(View(universityDto));
}
var university = Mapper.Map <UniversityDto, University>(universityDto);
university.CityId = universityDto.CityId;
university.UniversityTypeId = universityDto.UniversityTypeId;
_universityService.Create(university);
return(RedirectToAction("List"));
}
public async Task <UniversityDto> UpdateUniversityAsync(Guid id, UpdateUniversityDto updateUniversityDto, CancellationToken ct)
{
UniversityDto universityDto = null;
var updatedEntity = _mapper.Map <University>(updateUniversityDto);
updatedEntity.Id = id;
await _uow.Universities.UpdateAsync(updatedEntity, id, ct, updatedEntity.RowVersion);
await _uow.SaveChangesAsync(ct);
var universityEntity = await _uow.Universities.GetAsync(id, ct);
universityDto = _mapper.Map <UniversityDto>(universityEntity);
return(universityDto);
}
public async Task <UniversityDto> GetUniversityByIdAsync(Guid id, CancellationToken ct)
{
UniversityDto universityDto = null;
if (_uow != null)
{
if (_uow.Universities != null)
{
var universityEntity = await _uow.Universities.GetAsync(id, ct);
if (universityEntity != null)
{
universityDto = _mapper.Map <UniversityDto>(universityEntity);
}
}
}
return(universityDto);
}
public async Task <UniversityDto> CreateUniversityAsync(CreateUniversityDto createUniversityDto, CancellationToken ct)
{
UniversityDto universityDto = null;
try
{
var universityEntity = _mapper.Map <University>(createUniversityDto);
await _uow.Universities.AddAsync(universityEntity, ct);
await _uow.SaveChangesAsync(ct);
universityDto = _mapper.Map <UniversityDto>(universityEntity);
}
catch (AutoMapperMappingException ex)
{
_logger.LogError(ex, string.Empty);
}
return(universityDto);
}
public void setUp()
{
obj = new UniversitiesController(_linkGenerator, _logger, _universityService);
id = new Guid("1B7F86DD-FCD0-42A5-5E5F-08D7D5A16E26");
repository = new UniversityRepository(dbContext);
source = new CancellationTokenSource();
token = source.Token;
pagedResourceParameters = new UniversityResourceParameters();
context = new ActionContext();
universityDto = new UniversityDto();
//serviceProvider
var serviceCollection = new ServiceCollection();
//serviceCollection.AddSingleton<IUniversityService, UniversityService>();
//serviceCollection.AddTransient<University>();
serviceCollection.AddTransient <IInstitutionService, InstitutionService>();
_serviceProvider = serviceCollection.BuildServiceProvider();
//--------------------------------------------------------------
uow = new UnitOfWork(dbContext, _serviceProvider);
//logger
var loggerFactory = LoggerFactory.Create(builder =>
{
builder
.AddFilter("Microsoft", LogLevel.Warning)
.AddFilter("System", LogLevel.Warning)
.AddFilter("LoggingConsoleApp.University", LogLevel.Debug)
.AddConsole()
.AddEventLog();
});
logger = loggerFactory.CreateLogger <UniversityService>();
logger.LogInformation("Example log message");
//------------------------------------------------------------------
_mapper = new MapperConfiguration(mc => { mc.AddProfile(new MappingProfile()); }).CreateMapper();
universityService = new UniversityService(uow, _mapper, logger);
}
public AddUniversityResponseDto(UniversityDto university)
{
University = university;
}
public void AddNewUniversity(UniversityDto universityDto)
{
var university = _mapper.Map <University>(universityDto);
_universityRepository.AddNewUniversity(university);
}
public void Update(UniversityDto universityDto)
{
var university = _mapper.Map <University>(universityDto);
_universityRepository.UpdateUniversity(university);
}