public async Task UpdateAsync_WithSampleEntity_UpdatesModelInDB()
{
var sample = default(FluentData.SampleEntity);
using (var context = new TestDbContext(options))
{
//Arrange
var repository = new Repository <FluentData.SampleEntity>(context);
var fluentData = new FluentData(context);
sample = fluentData.Generate <FluentData.SampleEntity>();
await fluentData.SaveAsync(sample);
//Act
sample.StringField = "NewString";
await repository.UpdateAsync(sample);
}
//Assert
using (var context = new TestDbContext(options))
{
Assert.That(context.Set <FluentData.SampleEntity>().Count(), Is.EqualTo(1));
FluentData.SampleEntity sampleEntity = context.Set <FluentData.SampleEntity>().Single();
Assert.That(sampleEntity.StringField, Is.EqualTo("NewString"));
AssertTwoSamplesAreEqual(sample, sampleEntity);
}
}
public void GenerateSequence_WithCount_ReturnsListOfSameCount()
{
//Arrange
FluentData fluentData = new FluentData();
//Act
var sequence = fluentData.GenerateSequence <FluentData.SampleEntity>(5);
//Assert
Assert.That(sequence.Count(), Is.EqualTo(5));
}
public async Task PostController_Details_WithId_ReturnsPost()
{
ApplicationUser user = null;
Post post = null;
//Arrange
using (var context = new ApplicationDbContext(inMemoryDatabaseHelper.Options))
{
FluentData fluentData = new FluentData(context);
//create user
user = fluentData.Generate <ApplicationUser>();
await fluentData.SaveAsync(user);
post = fluentData.Generate <Post>();
//create post
post.OriginalPoster = user;
await fluentData.SaveAsync(post);
}
//Act
using (var context = new ApplicationDbContext(inMemoryDatabaseHelper.Options))
{
//Create UserRepo mock
var userRepoMock = new Mock <IUserRepository>();
userRepoMock.Setup(repo => repo.GetUserAsync(ClaimsPrincipal.Current))
.Returns(Task.FromResult(user));
var postsController = new PostsController(context,
userRepoMock.Object,
new Repository <Post>(context));
var result = await postsController.Details(post.Id);
//Assert
Assert.IsInstanceOf <ViewResult>(result);
var viewResult = result as ViewResult;
//IsAssignableFrom
Assert.IsInstanceOf <Post>(viewResult.ViewData.Model);
var model = viewResult.ViewData.Model;
Assert.That(model, Is.InstanceOf <Post>());
var readPost = model as Post;
Assert.AreEqual(readPost.Id, post.Id);
Assert.That(readPost.Title, Is.EqualTo(post.Title));
}
}
public void Generate_WithPost_ReturnsPost()
{
//Arrange
var fluentData = default(FluentData);
using (var context = new ApplicationDbContext(inMemoryDatabaseHelper.Options))
{
fluentData = new FluentData(context);
}
//Act
var post = fluentData.Generate <Post>();
//Assert
Assert.That(post, Is.Not.Null);
Assert.That(post.Title, Is.Not.Null);
Assert.That(post.Content, Is.Not.Null);
}
public void Generate_WithApplicationUser_ReturnsApplicatoinUser()
{
//Arrange
var fluentData = default(FluentData);
using (var context = new ApplicationDbContext(inMemoryDatabaseHelper.Options))
{
fluentData = new FluentData(context);
}
//Act
var user = fluentData.Generate <ApplicationUser>();
//Assert
Assert.That(user, Is.Not.Null);
Assert.That(user.UserName, Is.Not.Null);
Assert.That(user.Email, Is.Not.Null);
Assert.That(user.PasswordHash, Is.Not.Null);
}
public async Task SaveAsync_WithSequence_StoresInDB()
{
using (var context = new ApplicationDbContext(inMemoryDatabaseHelper.Options))
{
//Arrange
FluentData fluentData = new FluentData(context);
var sequence = fluentData.GenerateSequence <ApplicationUser>(5);
//Act
await fluentData.SaveAsync(sequence);
}
//Assert
using (var context = new ApplicationDbContext(inMemoryDatabaseHelper.Options))
{
Assert.That(context.Set <ApplicationUser>().Count(), Is.EqualTo(5));
}
}
public async Task ReadAsync_WithSampleEntity_StoresInDB()
{
var sample = default(FluentData.SampleEntity);
using (var context = new TestDbContext(options))
{
//Arrange
var repository = new Repository <FluentData.SampleEntity>(context);
var fluentData = new FluentData(context);
sample = fluentData.Generate <FluentData.SampleEntity>();
await fluentData.SaveAsync(sample);
//Act
var readSample = await repository.ReadAsync(sample.Id);
//Assert
AssertTwoSamplesAreEqual(sample, readSample);
}
}
public async Task ReadAll_ReturnsSequence()
{
var samples = default(IEnumerable <FluentData.SampleEntity>);
using (var context = new TestDbContext(options))
{
//Arrange
var repository = new Repository <FluentData.SampleEntity>(context);
var fluentData = new FluentData(context);
samples = fluentData.GenerateSequence <FluentData.SampleEntity>(5);
await fluentData.SaveAsync(samples);
}
using (var context = new TestDbContext(options))
{
//Act
var repository = new Repository <FluentData.SampleEntity>(context);
var sequence = repository.ReadAll();
//Assert
Assert.That(sequence.Count(), Is.EqualTo(5));
}
}
public void Create_WithSampleEntity_StoresInDB()
{
var sample = default(FluentData.SampleEntity);
using (var context = new TestDbContext(options))
{
//Arrange
var repository = new Repository <FluentData.SampleEntity>(context);
var fluentData = new FluentData(context);
sample = fluentData.Generate <FluentData.SampleEntity>();
//Act
repository.Create(sample);
}
//Assert
using (var context = new TestDbContext(options))
{
Assert.That(context.Set <FluentData.SampleEntity>().Count(), Is.EqualTo(1));
FluentData.SampleEntity sampleEntity = context.Set <FluentData.SampleEntity>().Single();
Assert.That(sampleEntity.Id, Is.Not.EqualTo(Guid.Empty.ToString()));
AssertTwoSamplesAreEqual(sample, sampleEntity);
}
}
public async Task SaveAsync_WithPost_StoresPostInDB()
{
using (var context = new ApplicationDbContext(inMemoryDatabaseHelper.Options))
{
//Arrange
var fluentData = new FluentData(context);
var user = fluentData.Generate <ApplicationUser>();
await fluentData.SaveAsync(user);
//Act
var post = fluentData.Generate <Post>();
post.OriginalPoster = context.Users.Single();
await fluentData.SaveAsync(post);
}
//Assert
using (var context = new ApplicationDbContext(inMemoryDatabaseHelper.Options))
{
Assert.That(context.Posts.Count(), Is.EqualTo(1));
}
}
public async Task Savesync_WithApplicationUser_StoresApplicationInDB()
{
//Arrange
using (var context = new ApplicationDbContext(inMemoryDatabaseHelper.Options))
{
var fluentData = new FluentData(context);
var user = fluentData.Generate <ApplicationUser>();
//Act
await fluentData.SaveAsync(user);
}
//Assert
using (var context = new ApplicationDbContext(inMemoryDatabaseHelper.Options))
{
Assert.That(context.Users.Count(), Is.EqualTo(1));
var user = context.Users.Single();
Assert.That(user.Id.ToString(), Is.Not.EqualTo(Guid.Empty.ToString()));
Assert.That(user.UserName, Is.Not.Null);
Assert.That(user.Email, Is.Not.Null);
Assert.That(user.PasswordHash, Is.Not.Null);
}
}
