public async Task ShouldAddProduct()
{
Product productMock = new Product()
{
catogeryId = 1,
ProductId = 3,
ProductName = "KotmaleMilkPowder"
};
var services = new ServiceCollection().AddEntityFrameworkInMemoryDatabase();
services.AddSingleton(_mockEnvironment.Object);
services.AddDbContext <ShoppingDBContext>(options =>
{
options.UseInMemoryDatabase("TestDB");
});
var serviceProvider = services.BuildServiceProvider();
using (var scope = serviceProvider.CreateScope())
{
var scopedServices = scope.ServiceProvider;
var shoppingDBContext = scopedServices.GetRequiredService <ShoppingDBContext>();
DbContextSeed.SeedAsync(shoppingDBContext).Wait();
var genericRepository = new GenericRepository <Product>(shoppingDBContext);
var product = await genericRepository.AddAsync(productMock).ConfigureAwait(false);
Assert.Equal(productMock.catogeryId, product.catogeryId);
Assert.Equal(productMock.ProductId, product.ProductId);
Assert.Equal(productMock.ProductName, product.ProductName);
Assert.NotNull(genericRepository.GetAsync(3));
}
}
public async Task AddThemeToArticleAsync(ArticleModel article, string theme)
{
await Initialize();
await ExecuteSafe(async() =>
{
var normalizedTheme = NormalizeThemeName(theme);
var themeModel = ThemeManager.TryGetSimilarTheme(normalizedTheme);
if (themeModel == null)
{
themeModel = new ThemeModel()
{
NormalizedName = normalizedTheme,
Name = theme
};
//concurrency: soem other thread may have added the same theme
var tm = ThemeManager.TryAddTheme(themeModel);
if (tm == themeModel)
{
await _themeGenericRepository.AddAsync(themeModel);
}
}
if (article.Themes.Contains(themeModel))
{
return;
}
article.Themes.Add(themeModel);
await _sqliteService.Add(new ThemeArticleRelations()
{
ArticleId = article.GetId(),
ThemeId = themeModel.GetId()
});
});
}
public virtual async Task <TEntity> Create(TEntity entity)
{
await repo.AddAsync(entity);
await context.SaveChangesAsync();
return(entity);
}
public Task <ActionResult <EpisodeViewModel> > PostAsync([FromBody] EpisodeInputModel inputModel)
=> ExecuteAsync <EpisodeViewModel>(async() =>
{
var userId = User.UserId();
var user = await _usersRepository.GetByIdAsync(userId);
var cause = default(Cause);
var local = default(Local);
var relief = default(Relief);
if (inputModel.CauseId != null)
{
cause = await _causesRepository.GetByIdAsync(inputModel.CauseId.Value);
if (cause == null || cause.UserId != userId)
{
return(BadRequest("Causa inválida"));
}
}
if (inputModel.LocalId != null)
{
local = await _localsRepository.GetByIdAsync(inputModel.LocalId.Value);
if (local == null || local.UserId != userId)
{
return(BadRequest("Local inválido"));
}
}
if (inputModel.ReliefId != null)
{
relief = await _reliefsRepository.GetByIdAsync(inputModel.ReliefId.Value);
if (relief == null || relief.UserId != userId)
{
return(BadRequest("Alívio inválido"));
}
}
var episode = new Episode(
user,
inputModel.Start,
inputModel.End,
inputModel.Intensity,
inputModel.ReleafWorked,
local,
cause,
relief
);
await _episodesRepository.AddAsync(episode);
return(Ok((EpisodeViewModel)episode));
});
public Task <ActionResult <ReliefViewModel> > PostAsync([FromBody] ReliefInputModel inputModel)
=> ExecuteAsync <ReliefViewModel>(async() =>
{
var userId = User.UserId();
var user = await _usersRepository.GetByIdAsync(userId);
var relief = new Relief(user, inputModel.Description, inputModel.Icon);
await _reliefsRepository.AddAsync(relief);
return(Ok((ReliefViewModel)relief));
});
public Task <ActionResult <LocalViewModel> > PostAsync([FromBody] LocalInputModel inputModel)
=> ExecuteAsync <LocalViewModel>(async() =>
{
var userId = User.UserId();
var user = await _usersRepository.GetByIdAsync(userId);
var local = new Local(user, inputModel.Description, inputModel.Icon);
await _localsRepository.AddAsync(local);
return(Ok((LocalViewModel)local));
});
public Task <ActionResult <CauseViewModel> > PostAsync([FromBody] CauseInputModel inputModel)
=> ExecuteAsync <CauseViewModel>(async() =>
{
var userId = User.UserId();
var user = await _usersRepository.GetByIdAsync(userId);
var cause = new Cause(user, inputModel.Description, inputModel.Icon);
await _causesRepository.AddAsync(cause);
return(Ok((CauseViewModel)cause));
});
public Task <ActionResult <MedicationViewModel> > PostAsync([FromBody] MedicationInputModel inputModel)
=> ExecuteAsync <MedicationViewModel>(async() =>
{
var userId = User.UserId();
var user = await _usersRepository.GetByIdAsync(userId);
var medication = new Medication(user, inputModel.Name, inputModel.Description, inputModel.Start, inputModel.Interval, inputModel.TotalDoses);
await _medicationsRepository.AddAsync(medication);
return(Ok((MedicationViewModel)medication));
});
public async Task AddAsync_Should_AddToContext()
{
var testEnity = new TestEntity {
Name = "ABC"
};
mockDbSet.Setup(x => x.AddAsync(testEnity, It.IsAny <CancellationToken>())).Verifiable();
await genericRepository.AddAsync(testEnity);
mockDbSet.Verify();
}
public async Task Account_RegisterNewUser_Test()
{
var user = new ApplicationUser
{
Id = Guid.NewGuid(),
Email = "*****@*****.**",
//Password = PasswordHashHelper.ComputeHash("Demo123!")
};
var isRegistrationSuccessful = await _repo.AddAsync(user);
Assert.IsTrue(isRegistrationSuccessful);
}
public async Task <ActionResult> Create(Car car)
{
if (ModelState.IsValid)
{
await repo.AddAsync(car);
await repo.SaveAsync();
return(RedirectToAction("Index"));
}
return(View(car));
}
public Task <ActionResult> PresentAsync(Guid id, Guid studentId, DateTime date)
=> ExecuteAsync(async() =>
{
var @class = await _classesRepository.GetByIdAsync(
id,
includes: c => c
.Include(r => r.Students)
.ThenInclude(s => s.Attendance));
if (@class == null)
{
return(NotFound());
}
var student = @class.Students.SingleOrDefault(s => s.StudentId == studentId);
if (student == null)
{
return(NotFound());
}
var attendance = student.Attendance.SingleOrDefault(a => a.Date == date.Date);
if (attendance == null)
{
attendance = new Attendance(student, date.Date, false);
await _attendanceRepository.AddAsync(attendance);
}
else
{
attendance.SetAbsent(false);
await _attendanceRepository.UpdateAsync(attendance);
}
return(Ok());
});
public Task <ActionResult <EventViewModel> > PostAsync([FromBody] EventInputModel inputModel)
=> ExecuteAsync <EventViewModel>(async() =>
{
if (inputModel == null)
{
return(BadRequest());
}
var creator = await _usersRepository.GetByIdAsync(inputModel.CreatorId);
var @event = new Event(inputModel.Date, inputModel.Duration, inputModel.Description, creator);
await _eventsRepository.AddAsync(@event);
var jobId = BackgroundJob.Schedule <NotificationService>(s => s.HandleEventNotification(@event.Id), @event.Date - TimeSpan.FromDays(1));
@event.SetNotificationEventId(jobId);
await _eventsRepository.UpdateAsync(@event);
return(Ok((EventViewModel)@event));
});
public async Task Add_success()
{
// Arrange
var expectedListCount = 3;
// Act
var genericRepository = new GenericRepository <Car>(_vehicleDbContext);
await genericRepository.AddAsync(new Car
{
Make = "nissan",
Model = "x-trail st",
Engine = "4-cylinder",
Doors = 4,
Wheels = 4,
VehicleType = VehicleType.Car,
BodyType = BodyType.SUV
});
// Assert
Assert.Equal(expectedListCount, _vehicleDbContext.Cars.Count());
}
public async Task Inventory_AddStockAsync_Test()
{
var stockId = Guid.NewGuid();
var sku = Guid.NewGuid();
var stock = new Stock
{
StockId = stockId,
StockName = "Nike shoes for men",
SKU = sku,
Description = "Nike shoes for men",
Qty = 5,
DateAdded = DateTime.UtcNow,
UnitPrice = 1450,
MarkupPrice = 500,
SellingPrice = 1950,
UserId = Guid.Parse("6BFED575-0954-4421-B911-DA908D8B1553")
};
var isStockAdded = await _repo.AddAsync(stock);
Assert.IsTrue(isStockAdded);
}
public Task <ActionResult <TokenViewModel> > PostAsync([FromServices] TokenProvider provider, [FromBody] UserInputModel inputModel)
=> ExecuteAsync <TokenViewModel>(async() =>
{
var sex = Gender.NotDisclosed;
if (inputModel.Gender.ToUpper() == "Masculino".ToUpper())
{
sex = Gender.Male;
}
if (inputModel.Gender.ToUpper() == "Feminino".ToUpper())
{
sex = Gender.Female;
}
var user = new User(inputModel.Name, inputModel.Email, inputModel.Password, inputModel.BirthDate, sex);
await _usersRepository.AddAsync(user);
await AddDefaultOptionsAsync(user);
var result = await provider.GenerateTokenAsync(inputModel.Email, inputModel.Password);
return(Ok((TokenViewModel)result));
});
public Task <ActionResult <AssignmentViewModel> > PostAsync([FromBody] AssignmentInputModel inputModel)
=> ExecuteAsync <AssignmentViewModel>(async() =>
{
if (inputModel == null)
{
return(BadRequest());
}
var @class = await _classesRepository.GetByIdAsync(inputModel.ClassId);
if (@class == null)
{
return(BadRequest());
}
var assignment = new Assignment(@class, inputModel.DueAt, inputModel.Title, inputModel.Description, inputModel.MaxGrade);
await _assignmentsRepository.AddAsync(assignment);
var jobId = BackgroundJob.Schedule <NotificationService>(s => s.HandleEventNotification(assignment.Id), assignment.DueAt - TimeSpan.FromDays(1));
assignment.SetNotificationEventId(jobId);
await _assignmentsRepository.UpdateAsync(assignment);
return(Ok((AssignmentViewModel)assignment));
});
public async Task CreateAsync(TModelRequest model)
{
var entity = model.Adapt <TEntity>();
await _repository.AddAsync(entity);
}
