public static void Data <TDbContext, TSource>(this MockDbSet <TDbContext, TSource> mockDbSet, IList <TSource> list)
where TDbContext : class
where TSource : class
{
if (list == null)
{
throw new NullReferenceException("list is null at WithData");
}
var data = list.AsQueryable();
mockDbSet.DbSet.As <IQueryable <TSource> >().Setup(m => m.Provider).Returns(data.Provider);
mockDbSet.DbSet.As <IQueryable <TSource> >().Setup(m => m.Expression).Returns(data.Expression);
mockDbSet.DbSet.As <IQueryable <TSource> >().Setup(m => m.ElementType).Returns(data.ElementType);
mockDbSet.DbSet.As <IQueryable <TSource> >().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
Type type = typeof(IDbSet <TSource>);
Type contextType = typeof(TDbContext);
ParameterExpression parameter = Expression.Parameter(contextType);
PropertyInfo info = contextType.GetProperties().First(pi => pi.PropertyType == type);
MemberExpression body = Expression.Property(parameter, info);
dynamic func = Expression.Lambda(body, parameter);
mockDbSet.DbContext.SetupProperty(func, mockDbSet.DbSet.Object);
}
public void ReturnCorrectResult()
{
// Arrange
var mockedCollection = Utils.GetLakesCollection();
var mockedDbSet = MockDbSet.Mock(mockedCollection.AsQueryable());
var mockedDbContext = new Mock <IDatabaseContext>();
mockedDbContext.Setup(c => c.Lakes).Returns(mockedDbSet.Object);
var lakeService = new LakeService(mockedDbContext.Object);
// Act
var result = lakeService.GetAll();
// Assert
Assert.IsTrue(result.Count() == mockedCollection.Count);
var index = 0;
foreach (var lake in result)
{
Assert.AreEqual(mockedCollection[index].Name, lake.Name);
Assert.AreEqual(mockedCollection[index].Id, lake.Id);
index++;
}
}
public void ReturnNull_IfIdNotMatch()
{
// Arrange
var mockedGalleriesCollection = Utils.GetVideoGalleriesCollection();
// Add videos for every gallery, so there won't be empty gallery in the context.
foreach (var gallery in mockedGalleriesCollection)
{
gallery.Videos.Add(new Video()
{
Title = "First video"
});
gallery.Videos.Add(new Video()
{
Title = "Second video"
});
}
var searchedGalleryId = Guid.NewGuid().ToString();
var mockedDbSet = MockDbSet.Mock(mockedGalleriesCollection.AsQueryable());
var mockedDbContext = new Mock <IDatabaseContext>();
mockedDbContext.Setup(c => c.VideoGalleries).Returns(mockedDbSet.Object);
var videoService = new VideoService(mockedDbContext.Object);
// Act
var videos = videoService.GetVideosFromGallery(searchedGalleryId);
// Assert
Assert.IsNull(videos);
}
public async Task Index_returns_two_newest_listings()
{
// Create some test data
var data = new List<Listing>
{
new Listing { ListingId = 1 },
new Listing { ListingId = 4 },
new Listing { ListingId = 2 },
new Listing { ListingId = 3 }
};
// TODO Create a mock set and context
var set = new MockDbSet<Listing>()
.SetupSeedData(data)
.SetupLinq();
var context = new Mock<FakeEstateContext>();
context.Setup(c => c.Listings).Returns(set.Object);
// TODO Create a HomeController and invoke the Index action
var controller = new HomeController(context.Object);
var result = await controller.Index();
// TODO Check the results
var listings = (List<Listing>)result.Model;
Assert.AreEqual(2, listings.Count());
Assert.AreEqual(4, listings[0].ListingId);
Assert.AreEqual(3, listings[1].ListingId);
}
public void CreateNewGallery_IfNotExist_AndAddVideoToGallery()
{
// Arrange
var video = new Video()
{
Title = "Test video"
};
var mockedGallery = Utils.GetEmptyVideoGallery();
var mockedDbSet = MockDbSet.Mock(mockedGallery.AsQueryable());
mockedDbSet.Setup(d => d.Add(It.IsAny <VideoGallery>())).Callback <VideoGallery>((g) => mockedGallery.Add(g));
var mockedDbContext = new Mock <IDatabaseContext>();
mockedDbContext.Setup(c => c.VideoGalleries).Returns(mockedDbSet.Object);
var videoService = new VideoService(mockedDbContext.Object);
var newGalleryName = "Test";
// Act
videoService.AddVideoToGallery(newGalleryName, video);
// Assert
Assert.IsTrue(mockedDbContext.Object.VideoGalleries.Count() == 1);
Assert.IsTrue(mockedDbContext.Object.VideoGalleries.First().Name == newGalleryName);
Assert.IsTrue(mockedDbContext.Object.VideoGalleries.First().Videos.Count == 1);
Assert.AreEqual(mockedDbContext.Object.VideoGalleries.First().Videos.First(), video);
}
public void AddImageToGallery_IfNameMatch()
{
// Arrange
var image = new Image();
var gallery = new ImageGallery()
{
Name = "Test gallery"
};
var mockedCollection = new List <ImageGallery>()
{
gallery
};
var mockedDbSet = MockDbSet.Mock(mockedCollection.AsQueryable());
var mockedDbContext = new Mock <IDatabaseContext>();
mockedDbContext.Setup(c => c.ImageGalleries).Returns(mockedDbSet.Object);
var imageGalleryService = new ImageGalleryService(mockedDbContext.Object);
// Act
imageGalleryService.AddImageToGallery(gallery.Name, image);
// Assert
Assert.IsTrue(gallery.Images.Count == 1);
Assert.IsTrue(gallery.Images.Contains(image));
}
public void AddImageToGallery_IfIdMatch()
{
// Arrange
var image = new Image();
var gallery = new ImageGallery()
{
Name = "Test gallery"
};
var mockedCollection = new List <ImageGallery>()
{
gallery
};
var mockedDbSet = MockDbSet.Mock(mockedCollection.AsQueryable());
mockedDbSet.Setup(d => d.Find(It.IsAny <object[]>())).Returns <object[]>(ids => mockedCollection.FirstOrDefault(d => d.Id == ids[0].ToString()));
var mockedDbContext = new Mock <IDatabaseContext>();
mockedDbContext.Setup(c => c.ImageGalleries).Returns(mockedDbSet.Object);
var imageGalleryService = new ImageGalleryService(mockedDbContext.Object);
// Act
imageGalleryService.AddImageToGallery(image, gallery.Id);
// Assert
Assert.IsTrue(gallery.Images.Count == 1);
Assert.IsTrue(gallery.Images.Contains(image));
}
public void Test_GetQueryableMockDbSet_Empty()
{
var fakeTableDbSet = MockDbSet.GetQueryableMockDbSet <FakeTable>(@"");
_dataContext.Setup(d => d.FakeTables).Returns(fakeTableDbSet.Object);
Assert.IsNotNull(_dataContext.Object.FakeTables);
}
public void AddLakeToDbContext()
{
// Arrange
var lake = new Lake()
{
Name = "Test lake"
};
var mockedCollection = new List <Lake>();
var mockedDbSet = MockDbSet.Mock(mockedCollection.AsQueryable());
mockedDbSet.Setup(d => d.Add(It.IsAny <Lake>())).Callback <Lake>((l) => mockedCollection.Add(l));
var mockedDbContext = new Mock <IDatabaseContext>();
mockedDbContext.Setup(c => c.Lakes).Returns(mockedDbSet.Object);
var lakeService = new LakeService(mockedDbContext.Object);
// Act
lakeService.Add(lake);
// Assert
Assert.IsTrue(mockedCollection.Count == 1);
Assert.AreEqual(lake, mockedCollection[0]);
}
public void GetProductsCountByPhrase_FullCollection_ReturnCountComplexNames()
{
Mock <IStoreContext> mock = new Mock <IStoreContext>();
mock.Setup(m => m.Products).Returns(MockDbSet.GetMockDbSet(new List <Product> {
new Product {
Id = 1, Name = "ProductNameIsEasy", Price = 10, CategoryId = 3
},
new Product {
Id = 2, Name = "ProductName2345", Price = 20, CategoryId = 3
},
new Product {
Id = 3, Name = "ProductName3", Price = 10, CategoryId = 4
},
new Product {
Id = 4, Name = "Product4", Price = 25, CategoryId = 5
},
new Product {
Id = 5, Name = "Product5", Price = 30, CategoryId = 6
}
}).Object);
IProductRepository repo = new ProductRepository(mock.Object);
var result = repo.GetProductsCountByPhrase("Name");
Assert.AreEqual(result, 3);
}
public void SetImageIsConfirmed_ToTrue_IfIdMatch()
{
// Arrange
var mockedCollection = new List <Image>()
{
new Image()
{
IsConfirmed = true
},
new Image()
{
IsConfirmed = false
},
new Image()
{
IsConfirmed = true
},
};
var mockedDbSet = MockDbSet.Mock(mockedCollection.AsQueryable());
mockedDbSet.Setup(d => d.Find(It.IsAny <object[]>())).Returns <object[]>(ids => mockedCollection.FirstOrDefault(d => d.Id == ids[0].ToString()));
var mockedDbContext = new Mock <IDatabaseContext>();
mockedDbContext.Setup(c => c.Images).Returns(mockedDbSet.Object);
var service = new ImageGalleryService(mockedDbContext.Object);
var searchedImageId = mockedCollection[1].Id;
// Act
service.ConfirmImage(searchedImageId);
// Assert
Assert.IsTrue(mockedCollection[1].IsConfirmed);
}
public void ReturnCorectResult_IfIdMatch()
{
// Arrange
var mockedGalleriesCollection = Utils.GetVideoGalleriesCollection();
var searchedGallery = mockedGalleriesCollection[1];
var searchedGalleryId = searchedGallery.Id;
searchedGallery.Videos.Add(new Video()
{
Title = "First video"
});
searchedGallery.Videos.Add(new Video()
{
Title = "Second video"
});
var mockedDbSet = MockDbSet.Mock(mockedGalleriesCollection.AsQueryable());
var mockedDbContext = new Mock <IDatabaseContext>();
mockedDbContext.Setup(c => c.VideoGalleries).Returns(mockedDbSet.Object);
var videoService = new VideoService(mockedDbContext.Object);
// Act
var videos = videoService.GetVideosFromGallery(searchedGalleryId);
// Assert
Assert.IsTrue(videos.Count() == 2);
Assert.IsTrue(videos.First().Title == "First video");
Assert.IsTrue(videos.Last().Title == "Second video");
}
public void AddImageGalleryToDbContext()
{
// Arrange
var gallery = new ImageGallery()
{
Name = "Test gallery"
};
var mockedCollection = new List <ImageGallery>();
var mockedDbSet = MockDbSet.Mock(mockedCollection.AsQueryable());
mockedDbSet.Setup(d => d.Add(It.IsAny <ImageGallery>())).Callback <ImageGallery>((g) => mockedCollection.Add(g));
var mockedDbContext = new Mock <IDatabaseContext>();
mockedDbContext.Setup(c => c.ImageGalleries).Returns(mockedDbSet.Object);
var imageGallertService = new ImageGalleryService(mockedDbContext.Object);
// Act
imageGallertService.Add(gallery);
// Assert
Assert.IsTrue(mockedCollection.Count == 1);
Assert.AreEqual(gallery, mockedCollection[0]);
}
public void ShouldFindUser()
{
var user = new User()
{
Email = "*****@*****.**",
Guid = System.Guid.NewGuid().ToString(),
HashedPassword = "******",
Name = "name",
Role = "admin",
Surname = "dksk"
};
var mockSet = new MockDbSet <User>();
var mockContext = new Mock <WorkSiteDbContext>();
mockContext.Setup(c => c.Set <User>()).Returns(mockSet.Object);
User res;
using (var uow = new WorkSiteUow(mockContext.Object))
{
uow.Users.Create(user);
uow.Save();
res = uow.Users.Read(user.Guid);
}
Assert.Null(res);
}
public void ShouldRemoveUserInMemory()
{
var user = new User()
{
Email = "*****@*****.**",
Guid = System.Guid.NewGuid().ToString(),
HashedPassword = "******",
Name = "name",
Role = "admin",
Surname = "dksk"
};
var mockSet = new MockDbSet <User>();
var mockContext = new Mock <WorkSiteDbContext>();
mockContext.Setup(c => c.Set <User>()).Returns(mockSet.Object);
using (var uow = new WorkSiteUow(mockContext.Object))
{
uow.Users.Create(user);
uow.Save();
uow.Users.Delete(user.Guid);
uow.Save();
}
mockSet.Verify(u => u.Remove(It.IsNotIn(user)), Times.Never);
}
public void DeleteCustomerByIdShouldCauseCustomerToBeNotContainedByDbSet()
{
// Arrange
var mockCustomer = Builder <DeliveryPerson> .CreateNew().Build();
var initialList = new DeliveryPerson[] { mockCustomer };
var mockDbSet = new MockDbSet <DeliveryPerson>(initialList);
var mockContext = new Mock <IContext>();
mockContext.SetupProperty <IDbSet <DeliveryPerson> >(_ => _.DeliveryPersons)
.SetupGet(_ => _.DeliveryPersons)
.Returns(mockDbSet);
mockContext.Setup(_ => _.Save())
.Callback(mockDbSet.Save);
Context = mockContext.Object;
Repository = new DeliveryPersonRepository(Context);
// Act
Repository.DeleteDeliveryPersonById(mockCustomer.Id);
// Assert
var contains = mockDbSet.Contains(mockCustomer);
Assert.IsFalse(contains);
}
public void UpdateCustomerDetailsShouldCauseCustomerInDbSetToBeUpdated()
{
// Arrange
var mockCustomer = Builder <Customer> .CreateNew().Build();
var initialList = new Customer[] { mockCustomer };
var mockDbSet = new MockDbSet <Customer>(initialList);
var mockContext = new Mock <IContext>();
mockContext.SetupProperty <IDbSet <Customer> >(_ => _.Customers)
.SetupGet(_ => _.Customers)
.Returns(mockDbSet);
mockContext.Setup(_ => _.Save())
.Callback(mockDbSet.Save);
Context = mockContext.Object;
Repository = new CustomerRepository(Context);
var updates = Builder <Customer> .CreateNew().And(_ => { _.Id = mockCustomer.Id; }).Build();
// Act
Repository.UpdateCustomerDetails(updates);
var updatedCustomer = mockDbSet.Find(mockCustomer.Id);
// Assert
bool updated = mockCustomer.Address == updatedCustomer.Address &&
mockCustomer.FirstName == updatedCustomer.FirstName &&
mockCustomer.Id == updatedCustomer.Id &&
mockCustomer.LastName == updatedCustomer.LastName &&
mockCustomer.MobileNumber == updatedCustomer.MobileNumber;
Assert.IsTrue(updated);
}
public void ReturnCorrectResult_IfIdMatch()
{
// Arrange
var gallery = new ImageGallery()
{
Name = "Test gallery"
};
var mockedCollection = new List <ImageGallery>()
{
new ImageGallery(),
gallery,
new ImageGallery()
};
var mockedDbSet = MockDbSet.Mock(mockedCollection.AsQueryable());
mockedDbSet.Setup(d => d.Find(It.IsAny <object[]>())).Returns <object[]>(ids => mockedCollection.FirstOrDefault(d => d.Id == ids[0].ToString()));
var mockedDbContext = new Mock <IDatabaseContext>();
mockedDbContext.Setup(c => c.ImageGalleries).Returns(mockedDbSet.Object);
var imageGalleryService = new ImageGalleryService(mockedDbContext.Object);
// Act
var result = imageGalleryService.FindById(gallery.Id);
// Assert
Assert.AreEqual(gallery, result);
}
public void Can_use_linq_opeartors()
{
var data = new List <Blog>
{
new Blog {
BlogId = 1
},
new Blog {
BlogId = 2
},
new Blog {
BlogId = 3
}
};
var set = new MockDbSet <Blog>()
.SetupSeedData(data)
.SetupLinq();
var result = set.Object
.Where(b => b.BlogId > 1)
.OrderByDescending(b => b.BlogId)
.ToList();
Assert.AreEqual(2, result.Count);
Assert.AreEqual(3, result[0].BlogId);
Assert.AreEqual(2, result[1].BlogId);
}
public async Task Index_returns_two_newest_listings()
{
// Create some test data
var data = new List<Product>
{
new Product { ProductID = 1 },
new Product { ProductID = 4 },
new Product { ProductID = 2 },
new Product { ProductID = 3 }
};
//Create a mock set and context
MockDbSet<Product> set = new MockDbSet<Product>().SetupSeedData(data).SetupLinq();
var context = new Mock<AdventureWorksContext>();
context.Setup(c => c.Products).Returns(set.Object);
//Create a Controller and invoke the Index action
List<Product> result = await context.Object.Products.ToListAsync();
//Check the results
List<Product> products = result;
Assert.AreEqual(4, products.Count());
Assert.AreEqual(1, products[0].ProductID);
Assert.AreEqual(4, products[1].ProductID);
}
public void UpdateCustomerDetailsShouldCauseCustomerInDbSetToBeUpdated()
{
// Arrange
var mockDPerson = Builder <DeliveryPerson> .CreateNew().Build();
var initialList = new DeliveryPerson[] { mockDPerson };
var mockDbSet = new MockDbSet <DeliveryPerson>(initialList);
var mockContext = new Mock <IContext>();
mockContext.SetupProperty <IDbSet <DeliveryPerson> >(_ => _.DeliveryPersons)
.SetupGet(_ => _.DeliveryPersons)
.Returns(mockDbSet);
mockContext.Setup(_ => _.Save())
.Callback(mockDbSet.Save);
Context = mockContext.Object;
Repository = new DeliveryPersonRepository(Context);
var updates = Builder <DeliveryPerson> .CreateNew().And(_ => { _.Id = mockDPerson.Id; }).Build();
// Act
Repository.UpdateDeliveryPersonDetails(updates);
var updatedCustomer = mockDbSet.Find(mockDPerson.Id);
// Assert
bool updated = mockDPerson.FirstName == updatedCustomer.FirstName &&
mockDPerson.Id == updatedCustomer.Id &&
mockDPerson.LastName == updatedCustomer.LastName;
Assert.IsTrue(updated);
}
public void ReturnCorrectResult_IfCollectionIsNotEmpty()
{
// Arrange
var fishCollection = Utils.GetFishCollection();
var mockedDbSet = MockDbSet.Mock(fishCollection.AsQueryable());
var mockedDbContext = new Mock <IDatabaseContext>();
mockedDbContext.Setup(c => c.Fish).Returns(mockedDbSet.Object);
var fishService = new FishService(mockedDbContext.Object);
// Act
var allFish = fishService.GetAll();
// Assert
Assert.IsTrue(allFish.Count() == fishCollection.Count);
var index = 0;
foreach (var fish in allFish)
{
Assert.AreEqual(fishCollection[index].Name, fish.Name);
Assert.AreEqual(fishCollection[index].ImageUrl, fish.ImageUrl);
index++;
}
}
public async Task GetItemAsync_Should_ReturnItemWithSortedRelatedComments()
{
// Arrange
var item = new Item {
Id = this._itemId
};
this._items.Setup(r => r.FindAsync(this._itemId)).ReturnsAsync(item);
var comments = Enumerable.Range(0, 100).Select(_ =>
new Comment
{
ItemId = this._random.Next() % 2 == 0 ? this._itemId : this._itemId + 1,
Author = new ApplicationUser {
UserName = "******"
},
CreatedAt = new DateTime(2014, 05, this._random.Next(31) + 1)
}
).ToList();
var dbSet = new MockDbSet <Comment>().SetupSeedData(comments).SetupLinq();
this._comments.SetupGet(r => r.Query).Returns(dbSet.Object);
// Act
Item result = await this._service.GetItemAsync(this._itemId);
// Assert
this._comments.VerifyGet(r => r.Query, Times.Once());
result.Should().NotBeNull();
result.Comments.Should().NotBeNull();
result.Comments.ToList().ForEach(c => c.ItemId.Should().Be(this._itemId));
result.Comments.Should().BeInAscendingOrder(c => c.CreatedAt);
}
public void Index_shows_most_expensive_first()
{
// Arrange
var data = new List<Bike>
{
new Bike { Retail = 100M },
new Bike { Retail = 200M },
new Bike { Retail = 50M }
};
var set = new MockDbSet<Bike>()
.SetupSeedData(data)
.SetupLinq();
var context = new Mock<CycleContext>();
context.Setup(c => c.Bikes).Returns(set.Object);
var controller = new BikesController(context.Object);
// Act
var result = controller.Index() as ViewResult;
// Assert
var bikes = result.Model as IEnumerable<Bike>;
Assert.AreEqual(200M, bikes.First().Retail);
}
public async Task GetItemAsync_Should_SetCommentAuthorNameFromAuthor()
{
// Arrange
var item = new Item {
Id = this._itemId
};
this._items.Setup(r => r.FindAsync(this._itemId)).ReturnsAsync(item);
var authorName = "Homer";
var comment = new Comment
{
ItemId = this._itemId,
Author = new ApplicationUser {
UserName = authorName
}
};
var dbSet = new MockDbSet <Comment>().SetupSeedData(new[] { comment }).SetupLinq();
this._comments.SetupGet(r => r.Query).Returns(dbSet.Object);
// Act
Item result = await this._service.GetItemAsync(this._itemId);
// Assert
result.Comments.Should().HaveCount(1);
result.Comments.Single().AuthorName.Should().Be(authorName);
}
public void Setup()
{
var mockDbSet = new MockDbSet<FakeEntity>(TestData.GetFakeEntities());
_mockDbContext = new Mock<IDbContext>();
_mockDbContext.Setup(m => m.Set<FakeEntity>()).Returns(mockDbSet);
_testRepository = new EFRepository<FakeEntity>(_mockDbContext.Object);
}
public void ReturnTrue_IfGalleryExist_AndVideoIsRemoved()
{
// Arrange
var mockedGalleries = Utils.GetVideoGalleriesCollection();
var video = new Video();
var gallery = mockedGalleries.First();
gallery.Videos.Add(video);
var mockedDbSet = MockDbSet.Mock(mockedGalleries.AsQueryable());
var mockedDbContext = new Mock <IDatabaseContext>();
mockedDbContext.Setup(c => c.VideoGalleries).Returns(mockedDbSet.Object);
var videoService = new VideoService(mockedDbContext.Object);
// Confirm that the gallery contains the video before remove it
Assert.IsTrue(gallery.Videos.Count == 1);
Assert.AreEqual(gallery.Videos.First(), video);
// Act
var isRemoved = videoService.RemoveVideoFromGallery(gallery.Name, video.Id);
Assert.IsTrue(gallery.Videos.Count == 0);
Assert.IsTrue(isRemoved);
}
public void ReturnCorrectResult_IfCollectionIsNotEmpty()
{
// Arrange
var mockedCollection = Utils.GetLocationsCollection();
var mockedDbSet = MockDbSet.Mock(mockedCollection.AsQueryable());
var mockedDbContext = new Mock <IDatabaseContext>();
mockedDbContext.Setup(c => c.Locations).Returns(mockedDbSet.Object);
var locationService = new LocationService(mockedDbContext.Object);
// Act
var result = locationService.GetAll();
// Assert
Assert.IsTrue(result.Count() == 3);
var index = 0;
foreach (var location in result)
{
Assert.AreEqual(mockedCollection[index].Name, location.Name);
index++;
}
}
public void CreateShouldAppendToDatabaseAndSaveChanges()
{
var businessUserDb = new List <BusinessUser>();
var mockSet = new MockDbSet <BusinessUser>(businessUserDb);
var contextMock = new Mock <SomeDataContext>();
contextMock.Setup(c => c.BusinessUsers).Returns(mockSet.Object);
var createBusinessUserCommand = new CreateBusinessUserCommand(Guid.NewGuid(),
new IdentityId("SomeId"),
"SomeLocation",
"SomeLocale",
"SomeGender",
new Email("*****@*****.**"),
"SomeFirstName",
"SomeMiddleName",
"SomeLastName"
);
var businessUserRepository = new BusinessUserRepository(contextMock.Object);
businessUserRepository.Create(createBusinessUserCommand);
contextMock.Verify(x => x.SaveChanges(), Times.Once);
Assert.Single(businessUserDb);
}
public void SaveSomeDataShoulUpdateSomeDataInDatabaseAndSaveChanges()
{
var updateSomeDataCommand = BuildUpdateSomeDataCommand();
var businessUser = new BusinessUser
{
Id = Guid.NewGuid(),
Gender = "SomeGender",
Locale = "SomeLocale",
Location = "SomeLocation",
Identity = new ApplicationUser
{
Email = "*****@*****.**"
}
};
var someDataDb = SomeDataMapper.UpdateSomeDataCommandToPersistanceModel(updateSomeDataCommand);
someDataDb.BusinessUserId = businessUser.Id;
var someDataDbSet = new List <SomeData>
{
someDataDb
};
var businessUserDb = new List <BusinessUser>
{
businessUser
};
var businessUserMockSet = new MockDbSet <BusinessUser>(businessUserDb);
var someDataMockSet = new MockDbSet <SomeData>(someDataDbSet);
var contextMock = new Mock <SomeDataContext>();
contextMock.Setup(c => c.SomeData).Returns(someDataMockSet.Object);
contextMock.Setup(c => c.BusinessUsers).Returns(businessUserMockSet.Object);
var someDataRepository = new SomeDataWriteRepository(contextMock.Object);
var updatedSomeData = SomeAggregate.Create(updateSomeDataCommand.SomeDataId,
"NewFirstName",
"NewMiddleName",
"NewLastName",
"NewTitle",
new Color("#c1d0c3"),
DateTime.Now,
new FacebookUrl(null),
Guid.NewGuid());
someDataRepository.Save(updatedSomeData);
var updatedDb = someDataRepository.Get(updateSomeDataCommand.SomeDataId);
contextMock.Verify(x => x.SaveChanges(), Times.Once);
Assert.Equal(updatedDb.Id, updatedSomeData.Id);
Assert.Equal(updatedDb.Color, updatedSomeData.Color);
Assert.Equal(updatedDb.CreationDate, updatedSomeData.CreationDate);
Assert.Equal(updatedDb.FacebookUrl, updatedSomeData.FacebookUrl);
Assert.Equal(updatedDb.FirstName, updatedSomeData.FirstName);
Assert.Equal(updatedDb.LastName, updatedSomeData.LastName);
Assert.Equal(updatedDb.MiddleName, updatedSomeData.MiddleName);
Assert.Equal(updatedDb.Title, updatedSomeData.Title);
}
public void FindMustReturnNullWhenPredicateReturnsFalseForAllEntities()
{
MockDbSet <Person> persons = new MockDbSet <Person>(new[] { new Person {
FirstName = "Bob", LastName = "Smith"
} });
Assert.Null(persons.Find(Guid.NewGuid()));
}
public void GivenAServiceRequestFulfillment_WhenRemove_ThenContextCallsRemove()
{
var expected = TestData.ServiceRequestFulfillments[0];
Target.Remove(expected);
MockDbSet.AssertWasCalled(m => m.Remove(expected));
}
public void GivenAServiceRequestFulfillment_WhenAdd_ThenAddToContext()
{
var expected = TestData.ServiceRequestFulfillments[0];
Target.Add(expected);
MockDbSet.AssertWasCalled(m => m.Add(expected));
}
public void ReturnsInstance()
{
// Arrange -> Act
var mockObjects = MockDbSet <object> .Of();
// Assert
Assert.IsAssignableFrom <DbSet <object> >(mockObjects);
}
public MockContext()
{
Schedules = new MockDbSet<Schedule>();
Models = new MockDbSet<Model>();
Tasks = new MockDbSet<Task>();
Users = new MockDbSet<User>();
Parts = new MockDbSet<Part>();
Makes = new MockDbSet<Make>();
Vehicles = new MockDbSet<Vehicle>();
}
public async Task Can_use_linq_materializer_directly_on_set_async()
{
var data = new List<Blog> { new Blog(), new Blog() };
var set = new MockDbSet<Blog>()
.SetupSeedData(data)
.SetupLinq();
var result = await set.Object.ToListAsync();
Assert.AreEqual(2, result.Count);
}
public void Data_is_addded_to_set()
{
var data = new List<Blog> { new Blog(), new Blog() };
var set = new MockDbSet<Blog>()
.SetupSeedData(data);
var result = set.Data.ToArray();
Assert.AreEqual(2, result.Length);
Assert.AreSame(data[0], result[0]);
Assert.AreSame(data[1], result[1]);
}
public async Task Can_enumerate_set_async()
{
var data = new List<Blog> { new Blog(), new Blog() };
var set = new MockDbSet<Blog>()
.SetupSeedData(data)
.SetupLinq();
var count = 0;
await set.Object.ForEachAsync(b => count++);
Assert.AreEqual(2, count);
}
public void Can_enumerate_set()
{
var data = new List<Blog> { new Blog {}, new Blog {} };
var set = new MockDbSet<Blog>()
.SetupSeedData(data)
.SetupLinq();
var count = 0;
foreach (var item in set.Object)
{
count++;
}
Assert.AreEqual(2, count);
}
public void ValidateTravel_Invalid()
{
var mockContext = new Mock<ApplicationDbContext>();
var locationMockDbSet = new MockDbSet<Location>();
mockContext.Setup(m => m.Locations).Returns(locationMockDbSet.DbSet.Object);
var entryCharMockDbSet = new MockDbSet<EntryLocationCharacter>();
mockContext.Setup(m => m.EntryLocationCharacters).Returns(entryCharMockDbSet.DbSet.Object);
var service = new TravelService(mockContext.Object);
var result = service.ValidateTravel("tag", 1);
Assert.IsFalse(result.IsValid);
Assert.AreEqual(result.Messages.Count(), 2);
}
public void ValidateTravel_Valid()
{
var mockContext = new Mock<ApplicationDbContext>();
var locationMockDbSet = new MockDbSet<Location>();
locationMockDbSet.Add(new Location { Tag = "tag", Type = ModelEnums.LocationType.City });
mockContext.Setup(m => m.Locations).Returns(locationMockDbSet.DbSet.Object);
var entryCharMockDbSet = new MockDbSet<EntryLocationCharacter>();
entryCharMockDbSet.Add(new EntryLocationCharacter { Arrival = DateTime.Now.AddHours(-1), Character_Id = 1 });
mockContext.Setup(m => m.EntryLocationCharacters).Returns(entryCharMockDbSet.DbSet.Object);
var service = new TravelService(mockContext.Object);
var result = service.ValidateTravel("tag", 1);
Assert.IsTrue(result.IsValid);
}
public void Travel()
{
var mockContext = new Mock<ApplicationDbContext>();
var locationMockDbSet = new MockDbSet<Location>();
locationMockDbSet.Add(new Location { Tag = "tag", Type = ModelEnums.LocationType.City });
mockContext.Setup(m => m.Locations).Returns(locationMockDbSet.DbSet.Object);
var entryCharMockDbSet = new MockDbSet<EntryLocationCharacter>();
entryCharMockDbSet.Add(new EntryLocationCharacter { Arrival = DateTime.Now.AddHours(-1), Character_Id = 1 });
mockContext.Setup(m => m.EntryLocationCharacters).Returns(entryCharMockDbSet.DbSet.Object);
var service = new TravelService(mockContext.Object);
service.Travel("tag", 1);
mockContext.Verify(m => m.SaveChanges(), Times.Once());
Assert.AreEqual(entryCharMockDbSet.Items.Count(), 2);
Assert.IsNotNull(entryCharMockDbSet.Items.First().Leaves);
Assert.IsNull(entryCharMockDbSet.Items.Last().Leaves);
}
public void Can_use_linq_opeartors()
{
var data = new List<Blog>
{
new Blog { BlogId = 1 },
new Blog { BlogId = 2 },
new Blog { BlogId = 3}
};
var set = new MockDbSet<Blog>()
.SetupSeedData(data)
.SetupLinq();
var result = set.Object
.Where(b => b.BlogId > 1)
.OrderByDescending(b => b.BlogId)
.ToList();
Assert.AreEqual(2, result.Count);
Assert.AreEqual(3, result[0].BlogId);
Assert.AreEqual(2, result[1].BlogId);
}
public void Can_use_include_directly_on_set()
{
var data = new List<Blog> { new Blog(), new Blog() };
var set = new MockDbSet<Blog>()
.SetupSeedData(data)
.SetupLinq();
var result = set.Object
.Include(b => b.Posts)
.ToList();
Assert.AreEqual(2, result.Count);
}
public void Can_use_include_after_linq_operator()
{
var data = new List<Blog> { new Blog(), new Blog() };
var set = new MockDbSet<Blog>()
.SetupSeedData(data)
.SetupLinq();
var result = set.Object
.OrderBy(b => b.BlogId)
.Include(b => b.Posts)
.ToList();
Assert.AreEqual(2, result.Count);
}
public void Can_add_data_after_setting_up_linq()
{
var data = new List<Blog> { new Blog(), new Blog() };
var set = new MockDbSet<Blog>()
.SetupLinq()
.SetupSeedData(data);
var result = set.Object.ToList();
Assert.AreEqual(2, result.Count);
}
