public UserTest()
{
db = new TestDbContext();
int i;
Role coordinatorRole, adminRole;
db.AddRange(new[]
{
userRole = RoleUser(),
coordinatorRole = RoleCoordinator(),
adminRole = RoleAdmin(),
});
UserStatus approved, pending, rejected;
db.AddRange(new[]
{
approved = UserStatusApproved(),
pending = UserStatusPending(),
rejected = UserStatusRejected(),
});
db.AddRange(users = new[]
{
user1 = User(i = 1, userRole, approved),
admin1 = User(++i, adminRole, approved),
coordinator1 = User(++i, coordinatorRole, approved),
userPending = User(++i, userRole, pending),
User(++i, userRole, rejected),
});
db.SaveChanges();
}
public async void GivenWordText_RepositoryChecksWordExists()
{
// Arrange
var sentece = Lorem.Sentence();
var words = Helper.FakeEnumerable(() => new Word().Fake(), 10).ToList();
words.Add(new Word().Fake(Text: sentece));
TestDbContext.Database.EnsureDeleted();
TestDbContext.AddRange(words);
TestDbContext.SaveChanges();
// Act
var result = await new WordRepository(TestDbContext).ExistsAsync(sentece).ConfigureAwait(false);
// Assert
Assert.True(result);
// if not exists
// Act
result = await new WordRepository(TestDbContext).ExistsAsync(string.Empty).ConfigureAwait(false);
// Assert
Assert.False(result);
}
public void TestJsonSerializeFromDatabaseReferenceLoopHandlingIgnore()
{
//SETUP
var options = SqliteInMemory.CreateOptions <TestDbContext>();
using (var context = new TestDbContext(options))
{
context.Database.EnsureCreated();
var seed = GetLinkEntities();
context.AddRange(seed);
context.SaveChanges();
var entities = context.Books
.Include(x => x.Many).ThenInclude(x => x.AuthorLink);
//ATTEMPT
var json = JsonConvert.SerializeObject(entities, new JsonSerializerSettings()
{
PreserveReferencesHandling = PreserveReferencesHandling.Objects,
ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
Formatting = Formatting.Indented
});
//VERIFY
_output.WriteLine(json);
}
}
public async Task <IActionResult> Create(int id, UserRoleViewModel user_roles)
{
UserRoleViewModel UserRoles = new UserRoleViewModel();
UserRoles.Roles = (from r in _context.sys_role
select new RoleSelect
{
role_id = r.id,
//role_no = r.role_no,
role_name = r.rolename,
Selected = false
}).ToList();
if (ModelState.IsValid)
{
var password_hash = PasswordHash(user_roles.User.password);
user_roles.User.password = password_hash;
_context.Add(user_roles.User);
await _context.SaveChangesAsync();
List <sys_user_role> user_role_list = new List <sys_user_role>();
var roles = user_roles.Roles;
if (roles.Count() > 0)
{
foreach (var item in roles)
{
if (item.Selected == true)
{
user_role_list.Add(
new sys_user_role()
{
sys_user_id = user_roles.User.id, sys_role_id = item.role_id
}
);
}
}
}
_context.AddRange(user_role_list);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(UserRoles));
}
public async Task PaginateAsync_Success_Should_ReturnEntityInPaginatedList_Detail_FirstPage()
{
var expCount = 3;
var page = 0;
var take = 3;
_Context.AddRange(new TestAggregateRoot("testing"), new TestAggregateRoot("testing"),
new TestAggregateRoot("testing"), new TestAggregateRoot("testing"), new TestAggregateRoot("testing"));
await _Context.SaveChangesAsync();
_Context.ChangeTracker.Clear();
IRepositoryAsync <TestAggregateRoot, Guid> repository = new TestAggregateRootRepository2(_Context);
var list = await repository.PaginateAsync(page, take);
list.Should().HaveCount(expCount);
}
public void SetUp()
{
var context = new TestDbContext(_options);
context.Database.EnsureDeleted();
context.Database.EnsureCreated();
_cars = Factory.TestCars();
context.AddRange(_cars);
context.SaveChanges();
_context = new TestDbContext(_options);
_testCarRepository = new TestCarRepository(_context);
}
public async void GivenNothing_RepositoryReturnsListOfAllEntities()
{
TestDbContext.Database.EnsureDeleted();
// Arrange
var words = Helper.FakeEnumerable(() => new Word().Fake(), 10);
TestDbContext.AddRange(words);
TestDbContext.SaveChanges();
// Act
var items = await new GenericRepository <Word>(TestDbContext).AllAsync().ConfigureAwait(false);
// Assert
Assert.NotNull(items);
Assert.Equal(10, items.Count);
}
public async Task Seed()
{
if (!_context.Category.Any())
{
_context.AddRange(_Category);
await _context.SaveChangesAsync();
}
if (!_context.Customer.Any())
{
_context.Customer.AddRange(_Customer);
await _context.SaveChangesAsync();
}
if (!_context.Product.Any())
{
_context.Product.AddRange(_Product);
await _context.SaveChangesAsync();
}
}
public PaginatedListTests()
{
//create InMemory DbContext
DbContextOptions <TestDbContext> options;
var builder = new DbContextOptionsBuilder <TestDbContext>();
builder.UseInMemoryDatabase("PaginatedListTests")
.EnableSensitiveDataLogging();
options = builder.Options;
_context = new TestDbContext(options);
_context.Database.EnsureDeleted();
_context.Database.EnsureCreated();
var settings = new PagingSettings
{
PageSize = 20
};
_settings = Microsoft.Extensions.Options.Options.Create(settings);
_items = new List <TestModel>();
for (int i = 0; i < _testItemsCount; i++)
{
_items.Add(new TestModel()
{
Id = Guid.NewGuid(), Name = "test" + i
});
}
for (int i = 0; i < _testItemsCount; i++)
{
_items.Add(new TestModel()
{
Id = Guid.NewGuid(), Name = "name" + i
});
}
_context.AddRange(_items);
_context.SaveChanges();
}
public async Task <IActionResult> Edit(int id, RolePermissionViewModel role_permissions)
{
if (id != role_permissions.Role.id)
{
return(NotFound());
}
if (role_permissions.Permissions == null)
{
return(NotFound());
}
var role = new sys_role()
{
id = role_permissions.Role.id,
//usercode = role_permissions.Role.usercode,
rolename = role_permissions.Role.rolename
};
_context.Attach(role);
_context.Entry(role).CurrentValues.SetValues(role_permissions.Role);
var web_role_permission = _context.sys_role_permission.Where(x => x.sys_role_id == id);
_context.sys_role_permission.RemoveRange(web_role_permission);
List <sys_role_permission> role_permission_list = new List <sys_role_permission>();
var permissions = role_permissions.Permissions;
if (permissions.Count() > 0)
{
foreach (var item in permissions)
{
if (item.Selected == true)
{
role_permission_list.Add(
new sys_role_permission()
{
sys_role_id = id, sys_permission_id = item.permission_id
}
);
}
}
}
_context.AddRange(role_permission_list);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!sys_roleExists(role_permissions.Role.id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
public RequestsTest()
{
db = new TestDbContext();
int i;
Role userRole, coordinatorRole, adminRole;
db.AddRange(new[]
{
userRole = RoleUser(),
coordinatorRole = RoleCoordinator(),
adminRole = RoleAdmin(),
});
UserStatus userStatusApproved;
db.AddRange(new[]
{
userStatusApproved = UserStatusApproved(),
UserStatusPending(),
UserStatusRejected()
});
db.AddRange(new[]
{
user1 = User(i = 1, userRole, userStatusApproved),
user2 = User(++i, userRole, userStatusApproved),
User(++i, adminRole, userStatusApproved),
coordinator1 = User(++i, coordinatorRole, userStatusApproved),
});
db.AddRange(products = new[]
{
Product(i = 1),
Product(++i),
Product(++i),
});
RequestStatus requestStatusPending, requestStatusApproved;
db.AddRange(new[]
{
requestStatusApproved = RequestStatusApproved(),
requestStatusPending = RequestStatusPending(),
RequestStatusRejected()
});
var refNo = Guid.NewGuid();
db.AddRange(requests = new[]
{
Request(user1, Guid.NewGuid(), requestStatusPending, 1),
Request(user2, refNo, requestStatusPending, 0),
Request(user2, refNo, requestStatusApproved, 1),
});
db.AddRange(new[]
{
RequestDetail(i = 1, requests[0], products[0]),
RequestDetail(++i, requests[0], products[1]),
RequestDetail(++i, requests[1], products[2]),
RequestDetail(++i, requests[2], products[0]),
});
db.SaveChanges();
}
