public void GetCountries_Should_Get_Expected_Result() {
// Arrange
var countries = new List<Country>() {
new Country { Id = 1, Name = "Turkey", ISOCode = "TR", CreatedOn = DateTimeOffset.Now },
new Country { Id = 2, Name = "United Kingdom", ISOCode = "EN", CreatedOn = DateTimeOffset.Now },
new Country { Id = 3, Name = "United States", ISOCode = "US", CreatedOn = DateTimeOffset.Now },
new Country { Id = 4, Name = "Argentina", ISOCode = "AR", CreatedOn = DateTimeOffset.Now },
new Country { Id = 4, Name = "Bahamas", ISOCode = "BS", CreatedOn = DateTimeOffset.Now },
new Country { Id = 4, Name = "Uruguay", ISOCode = "UY", CreatedOn = DateTimeOffset.Now }
};
var dbSet = new FakeDbSet<Country>();
foreach (var country in countries) {
dbSet.Add(country);
}
var entitiesContext = new Mock<IEntitiesContext>();
entitiesContext.Setup(ec => ec.Set<Country>()).Returns(dbSet);
var countriesRepo = new EntityRepository<Country>(entitiesContext.Object);
var countriesController = new CountriesController(countriesRepo, Mapper.Engine);
var pageIndex = 1;
var pageSize = 3;
// Act
var paginatedDto = countriesController.GetCountries(pageIndex, pageSize);
// Assert
Assert.NotNull(paginatedDto);
Assert.Equal(countries.Count, paginatedDto.TotalCount);
Assert.Equal(pageSize, paginatedDto.PageSize);
Assert.Equal(pageIndex, paginatedDto.PageIndex);
}
public FakeExempleDbContext()
{
AlphabeticalListOfProducts = new FakeDbSet<AlphabeticalListOfProduct>();
Categories = new FakeDbSet<Category>();
CategorySalesFor1997 = new FakeDbSet<CategorySalesFor1997>();
CurrentProductLists = new FakeDbSet<CurrentProductList>();
Customers = new FakeDbSet<Customer>();
CustomerAndSuppliersByCities = new FakeDbSet<CustomerAndSuppliersByCity>();
CustomerDemographics = new FakeDbSet<CustomerDemographic>();
Employees = new FakeDbSet<Employee>();
Invoices = new FakeDbSet<Invoice>();
Orders = new FakeDbSet<Order>();
OrderDetails = new FakeDbSet<OrderDetail>();
OrderDetailsExtendeds = new FakeDbSet<OrderDetailsExtended>();
OrdersQries = new FakeDbSet<OrdersQry>();
OrderSubtotals = new FakeDbSet<OrderSubtotal>();
Products = new FakeDbSet<Product>();
ProductsAboveAveragePrices = new FakeDbSet<ProductsAboveAveragePrice>();
ProductSalesFor1997 = new FakeDbSet<ProductSalesFor1997>();
ProductsByCategories = new FakeDbSet<ProductsByCategory>();
Regions = new FakeDbSet<Region>();
SalesByCategories = new FakeDbSet<SalesByCategory>();
SalesTotalsByAmounts = new FakeDbSet<SalesTotalsByAmount>();
Shippers = new FakeDbSet<Shipper>();
SummaryOfSalesByQuarters = new FakeDbSet<SummaryOfSalesByQuarter>();
SummaryOfSalesByYears = new FakeDbSet<SummaryOfSalesByYear>();
Suppliers = new FakeDbSet<Supplier>();
Sysdiagrams = new FakeDbSet<Sysdiagram>();
Territories = new FakeDbSet<Territory>();
}
public FakeLagaModelDbContext()
{
LoggerEntries = new FakeDbSet<LoggerEntry>();
LoggerOperations = new FakeDbSet<LoggerOperation>();
LoggerThreads = new FakeDbSet<LoggerThread>();
LoggerThreadStatus = new FakeDbSet<LoggerThreadStatus>();
}
public void GivenAValidId_ReturnsGenre()
{
const int aValidId = 1;
var genres = new List<Genre>
{
new Genre
{
Id = aValidId
}
};
var dbSet = new FakeDbSet<Genre>();
genres.ForEach(genre => dbSet.Add(genre));
var entitiesContext = A.Fake<IEntitiesContext>();
A.CallTo(() => entitiesContext.Set<Genre>()).Returns(dbSet);
var fakeValidator = A.Fake<IValidator>();
var failure = new ValidationFailure("Id", "error");
var failures = new List<ValidationFailure> { failure };
A.CallTo(() => fakeValidator.Validate(A<Genre>.Ignored)).Returns(new ValidationResult(failures));
IValidatorFactory factory = A.Fake<IValidatorFactory>();
//var hasPermissionToGet = new HasPermissionToGet(fakeRepo);
//A.CallTo(() => factory.GetValidator<HasPermissionToGet>()).Returns<HasPermissionToGet>(hasPermissionToGet as IValidator<HasPermissionToGet>);
var fakeMapping = A.Fake<IMappingEngine>();
var repo = new EntityRepository<Genre>(entitiesContext);
var genreService = new GenreService(repo, factory, fakeMapping);
Genre result = genreService.GetGenre(aValidId);
result.Should().NotBeNull();
}
public void Scenario2_existing_product_type()
{
var gameSimContext = new Mock<IGameSimContext>();
var domainProductType = new ProductType
{
Id = 1
};
var pDs = new List<ProductType>()
{
domainProductType
};
var productTypes = new FakeDbSet<ProductType>(pDs);
gameSimContext.Setup(x => x.ProductTypes).Returns(productTypes);
var controller = new ProductTypeController(gameSimContext.Object);
var productTypeToSave = new WebApi.Models.ProductType
{
Id = 1,
Name = "test",
ManufacturerTypeId = 1,
Products = new List<Product>(),
RequiredProducts = new List<Product>(),
TimeToManufacture = 10,
SalePriceInDollars = 10
};
var ret = controller.Post(productTypeToSave);
productTypes.Count().ShouldEqual(1);
ret.Id.ShouldEqual(1);
gameSimContext.Verify(x=>x.SetValues(It.IsAny<ProductType>(), It.IsAny<ProductType>()));
}
public void Run()
{
var db = MockRepository.GenerateMock<IMusicContext>();
var library = MockRepository.GenerateMock<IITunesLibrary>();
var translator = MockRepository.GenerateMock<IAlbumTranslator>();
var config = MockRepository.GenerateMock<IConfig>();
var albumInfo = MockRepository.GenerateMock<ILastFmAlbumInfo>();
var album = new Album { Artist = "Chroma Key", Genre = "Rock", Name = "You Go Now", Year = 1999 };
var tracks = new List<Track>();
var dbSetAlbums = new FakeDbSet<Album>();
var fileLocation = "loc";
var albums = new List<Album> { album };
db.Expect(d => d.UpdateExisting(albums)).Return(0);
db.Stub(d => d.Albums).Return(dbSetAlbums);
config.Stub(c => c.ITunesFileLocation).Return(fileLocation);
library.Stub(l => l.Parse(fileLocation)).Return(tracks);
translator.Stub(t => t.Convert(tracks)).Return(albums);
db.Expect(d => d.SaveChanges()).Return(1);
using (new ConfigScope(config)) {
new AlbumExport(db, library, translator, albumInfo).Run();
}
Assert.AreEqual(1, dbSetAlbums.Count());
Assert.AreEqual(album, dbSetAlbums.First());
albumInfo.AssertWasCalled(t => t.UpdateAlbums(albums));
db.VerifyAllExpectations();
}
public void UserProfileEmailMustBeSet()
{
//Arrange
var mockContext = new Mock<DataContext>();
var actualProfile = new UserProfile {UserName = "******"};
var userProfileDbSet = new FakeDbSet<UserProfile>(new[]
{
actualProfile
});
mockContext
.Setup(context => context.UserProfiles)
.Returns(userProfileDbSet);
var sut = new AccountService(() => mockContext.Object);
var upsertUserProfile = new UserProfile
{
UserName = "******",
Email = "testemail"
};
//Act
sut.UpsertUserProfile(upsertUserProfile);
//Assert
Assert.AreEqual("testemail", actualProfile.Email);
}
public void UpdateLesson_ExistingLesson_LessonUpdate()
{
IDbSet<LessonDto> lessons = new FakeDbSet<LessonDto>(new[]
{
new LessonDto
{
LessonId = 42,
Date = new DateTime(2010, 1, 1),
GroupId = 1
}
});
A.CallTo(() => _context.Lessons).Returns(lessons);
_repository.UpdateLesson(new LessonDto
{
LessonId = 42,
Date = new DateTime(2013, 10, 10),
GroupId = 3
});
Assert.Equal(new DateTime(2013, 10, 10), lessons.First().Date);
Assert.Equal(3, lessons.First().GroupId);
A.CallTo(() => _context.SaveChanges()).MustHaveHappened();
}
public static void PopulateData()
{
Students = new FakeStudentSet();
Students.Add(new Student() { FirstName = "Jamal", LastName = "Ali", Address = "Dhaka" });
Students.Add(new Student() { FirstName = "Jamal1", LastName = "Ali1", Address = "Dhaka1" });
Students.Add(new Student() { FirstName = "Jamal2", LastName = "Ali2", Address = "Dhaka2" });
}
public void MustFindMatchingUserViaUserName()
{
//Arrange
var mockContext = new Mock<DataContext>();
var userId = 3;
var userProfileDbSet = new FakeDbSet<UserProfile>(new[]
{
new UserProfile {UserId = 4, UserName = "******"},
new UserProfile {UserId = userId, UserName = "******"}
});
mockContext
.Setup(context => context.UserProfiles)
.Returns(userProfileDbSet);
var sut = new AccountService(() => mockContext.Object);
var upsertUserProfile = new UserProfile {UserName = "******"};
//Act
sut.UpsertUserProfile(upsertUserProfile);
//Assert
mockContext
.Verify(context => context.SetState(
It.Is<UserProfile>(profile => profile.UserId == userId),
It.IsAny<EntityState>()));
}
public FakeDbContext()
{
Users = new FakeDbSet<ApplicationUser>();
IotHubs = new FakeDbSet<IotHub>();
IotHubSensors = new FakeDbSet<IotHubSensor>();
Ticks = new FakeDbSet<SensorTick>();
}
public FakeCMSDbContext()
{
AuthTokens = new FakeDbSet<AuthToken>();
Barcodes = new FakeDbSet<Barcode>();
Catalogues = new FakeDbSet<Catalogue>();
Clients = new FakeDbSet<Client>();
ClientAllowScopes = new FakeDbSet<ClientAllowScope>();
ItemAttributes = new FakeDbSet<ItemAttribute>();
ItemMasters = new FakeDbSet<ItemMaster>();
Members = new FakeDbSet<Member>();
MemberInRoles = new FakeDbSet<MemberInRole>();
MemberSpecificScopes = new FakeDbSet<MemberSpecificScope>();
Merchandises = new FakeDbSet<Merchandise>();
Products = new FakeDbSet<Product>();
ProductPictures = new FakeDbSet<ProductPicture>();
Promotions = new FakeDbSet<Promotion>();
PurchasePrices = new FakeDbSet<PurchasePrice>();
Restructures = new FakeDbSet<Restructure>();
Roles = new FakeDbSet<Role>();
RoleInScopes = new FakeDbSet<RoleInScope>();
Scopes = new FakeDbSet<Scope>();
SubCodes = new FakeDbSet<SubCode>();
Suppliers = new FakeDbSet<Supplier>();
SupplierAttributes = new FakeDbSet<SupplierAttribute>();
Sysdiagrams = new FakeDbSet<Sysdiagram>();
}
public void GetByProgramId_Returns_Object_If_Found()
{
//arrange
var programId = 10;
var mockRepo = new Mock<IRemoteEntities>();
var program = new Program() { Id = programId };
var remote = new DTO.Remote()
{
Id = 7,
Programs = new List<Program>()
{
program
}
};
var dbSet = new FakeDbSet<DTO.Remote>(remote);
mockRepo.SetupGet(m => m.Remotes)
.Returns(dbSet);
DataFactory.Set(mockRepo.Object);
//act
var logic = new RemoteLogic();
var actual = logic.GetByProgramId(programId);
//assert
Assert.AreEqual(remote, actual);
}
public void Scenario2_new_product_type()
{
var gameSimContext = new Mock<IGameSimContext>();
var pDs = GetExistingDomainProductTypes();
var productTypes = new FakeDbSet<ProductType>(pDs);
var products = new FakeDbSet<Domain.Product>();
gameSimContext.Setup(x => x.ProductTypes).Returns(productTypes);
gameSimContext.Setup(x => x.Products).Returns(products);
var controller = new ProductTypeController(gameSimContext.Object);
var productTypeToSave = new WebApi.Models.ProductType
{
Name = "test",
RequiredProducts = new List<Product>
{
new Product
{
ProductTypeId = 1
}
}
};
var ret = controller.Post(productTypeToSave);
productTypes.Count().ShouldEqual(3);
products.Count().ShouldEqual(1);
var productType = productTypes.ToArray()[1];
productType.Id.ShouldEqual(3);
productType.RequiredProducts.First().RequiredByTypeId.ShouldEqual(1);
productType.RequiredProducts.First().ProductTypeId.ShouldEqual(2);
productType.RequiredProducts.First().Quantity.ShouldEqual(1);
ret.Id.ShouldEqual(2);
}
public void GetUserTokenAsync_InvalidArguments_Null()
{
IDbSet<UserTokenDto> tokens = new FakeDbSet<UserTokenDto>();
A.CallTo(() => _context.UserTokens).Returns(tokens);
IUserTokenDto token = _repository.GetUserTokenAsync("purpose", "token", 42).Result;
Assert.Null(token);
}
public FakeResourcePlanningDbContext()
{
Activities = new FakeDbSet<Activity>();
BudgetHoursOnActivities = new FakeDbSet<BudgetHoursOnActivity>();
BudgetPeriodes = new FakeDbSet<BudgetPeriode>();
Employees = new FakeDbSet<Employee>();
SchemaVersions = new FakeDbSet<SchemaVersion>();
}
public void SetUp()
{
var fakeDbSet = new FakeDbSet<Student>();
fakeBackingCollection = fakeDbSet.BackingCollection;
contextWithFake = new Mock<StudentContext>();
contextWithFake.SetupGet(c => c.Students).Returns(fakeDbSet);
serviceWithFake = new StudentService(contextWithFake.Object);
}
public void SetUp()
{
var fakeDbSet = new FakeDbSet <Student>();
fakeBackingCollection = fakeDbSet.BackingCollection;
contextWithFake = new Mock <StudentContext>();
contextWithFake.SetupGet(c => c.Students).Returns(fakeDbSet);
serviceWithFake = new StudentService(contextWithFake.Object);
}
public void GetUserByEmail_NonExistingEmail_Null()
{
IDbSet<UserDto> users = new FakeDbSet<UserDto>(new[] { new UserDto { Email = "test" } });
A.CallTo(() => _context.Users).Returns(users);
IUserDto user = _userRepository.GetUserByEmail("*****@*****.**").Result;
Assert.Null(user);
}
public BaseTest()
{
AutoMapperConfiguration.Config();
_mockUnitOfWork = new Mock <IUnitOfWork>();
_mockRepository = new Mock <IRepository <TEntity> >();
_dbSet = new FakeDbSet <IEntity>();
//_mockUnitOfWork.Setup(x => x.Countries).Returns(_mockRepository.Object);
//mockService.Setup(x => x.Countries.FindAll(null)).Returns(dbSet);
}
public void AddQuestionToQuiz_NotNullQuestionQuizDoesntExist_QuestionNotAdded()
{
IDbSet<QuizDto> quizes = new FakeDbSet<QuizDto>();
A.CallTo(() => _context.Quizes).Returns(quizes);
_quizRepository.AddQuestionToQuiz(QuizId, A.Fake<QuestionDto>()).Wait();
A.CallTo(() => _context.SaveChangesAsync()).MustNotHaveHappened();
}
public void IndexTest()
{
var mockData = new FakeDbSet<ValuesTable>();
var mock = new Mock<Entities>();
mock.Setup(m => m.ValuesTable).Returns(mockData);
HomeController controller = new HomeController(mock.Object);
ActionResult result = controller.Index();
Assert.IsNotNull(result);
}
// Privates
private FakeDbSet<Person> GetPersonDbSet(IEnumerable<Person> people) {
var personDbSet = new FakeDbSet<Person>();
foreach (var person in people) {
personDbSet.Add(person);
}
return personDbSet;
}
public void GetUserClaims_ExistingUserId_NotEmpty()
{
var userClaims = new FakeDbSet<UserClaimDto>(new[]
{
new UserClaimDto { User = new UserDto {UserId = 42}}
});
A.CallTo(() => _context.UserClaims).Returns(userClaims);
Assert.NotEmpty(_userClaimRepository.GetUserClaims(42));
}
public void Remove_WithItemThatIsNotInSet_ShouldSucceed()
{
var objToRemove = new Person();
var data = new List <Person>();
var sut = new FakeDbSet <Person>(data);
var result = sut.Remove(objToRemove);
Assert.That(result, Is.SameAs(objToRemove));
}
public FakePlannerDbContext()
{
Connections = new FakeDbSet<Connection>();
Files = new FakeDbSet<File>();
Handshakes = new FakeDbSet<Handshake>();
Logs = new FakeDbSet<Log>();
Shakes = new FakeDbSet<Shake>();
sys_DatabaseFirewallRule = new FakeDbSet<sys_DatabaseFirewallRule>();
Users = new FakeDbSet<User>();
}
internal override Mock <IDbContext> GetDbContextMock()
{
var stores = new FakeDbSet <Core.StoreModule.Store> {
new Core.StoreModule.Store {
Id = 1
}
};
var categories = new FakeDbSet <ProductCategory> {
new ProductCategory {
Id = 1
}
};
_products.Clear();
_products.Add(
new Product
{
Id = 1,
CategoryId = 1,
Name = "A",
Variants = new List <ProductVariant>
{
new ProductVariant {
Id = 1, Sku = "AAA"
},
new ProductVariant {
Id = 2, Sku = "ZZZ"
}
}
});
_products.Add(
new Product
{
Id = 2,
CategoryId = 1,
Name = "A",
Variants = new List <ProductVariant>
{
new ProductVariant {
Id = 3, Sku = "ABA"
},
new ProductVariant {
Id = 4, Sku = "AZZ"
}
}
});
var dbContextMock = new Mock <IDbContext>();
dbContextMock.Setup(c => c.Products).Returns(_products);
dbContextMock.Setup(c => c.Stores).Returns(stores);
dbContextMock.Setup(c => c.ProductCategories).Returns(categories);
return(dbContextMock);
}
private FakeDbSet <Thread> GetThreadsDbSet(IEnumerable <Thread> threads)
{
var threadsDbSet = new FakeDbSet <Thread>();
foreach (var thread in threads)
{
threadsDbSet.Add(thread);
}
return(threadsDbSet);
}
private void SetupQueryHandler(IList<BoardEntity> data)
{
var fakeDbSet = new FakeDbSet<BoardEntity>();
data.ToList().ForEach(x => fakeDbSet.Add(x));
mockDataContext = new Mock<IDataContext>();
mockDataContext.Setup(x => x.Set<BoardEntity>()).Returns(fakeDbSet);
mockMappingService = new Mock<IMappingService>();
handler = new GetBoardColumnBySlugQueryHandler(mockDataContext.Object, mockMappingService.Object);
}
private void SetupQueryHandler(IList<BoardTaskEntity> data)
{
var fakeDbSet = new FakeDbSet<BoardTaskEntity>();
data.ToList().ForEach(x => fakeDbSet.Add(x));
mockDataContext = new Mock<IDataContext>();
mockDataContext.Setup(x => x.Set<BoardTaskEntity>()).Returns(fakeDbSet);
mockMappingService = new Mock<IMappingService>();
handler = new GetBoardTaskByIdQueryHandler(mockDataContext.Object, mockMappingService.Object);
}
public void Arrange()
{
_db = new Mock <EmployerAccountsDbContext>();
_account = new Account
{
Id = 333333,
HashedId = "ABC123",
Name = "Account"
};
_sentTransferConnectionInvitation = new TransferConnectionInvitationBuilder()
.WithId(222222)
.WithSenderAccount(_account)
.WithReceiverAccount(new Account())
.WithCreatedDate(DateTime.UtcNow)
.Build();
_receivedTransferConnectionInvitation = new TransferConnectionInvitationBuilder()
.WithId(111111)
.WithSenderAccount(new Account())
.WithReceiverAccount(_account)
.WithCreatedDate(DateTime.UtcNow.AddDays(-1))
.Build();
_transferConnectionInvitations = new List <TransferConnectionInvitation>
{
_sentTransferConnectionInvitation,
_receivedTransferConnectionInvitation,
new TransferConnectionInvitationBuilder()
.WithSenderAccount(new Account())
.WithReceiverAccount(new Account())
.WithCreatedDate(DateTime.UtcNow.AddDays(-2))
.Build()
};
_transferConnectionInvitationsDbSet = new FakeDbSet <TransferConnectionInvitation>(_transferConnectionInvitations);
_configurationProvider = new MapperConfiguration(c =>
{
c.AddProfile <AccountMappings>();
c.AddProfile <TransferConnectionInvitationMappings>();
c.AddProfile <UserMappings>();
});
_db.Setup(d => d.TransferConnectionInvitations).Returns(_transferConnectionInvitationsDbSet);
_handler = new GetTransferConnectionInvitationsQueryHandler(new Lazy <EmployerAccountsDbContext>(() => _db.Object), _configurationProvider);
_query = new GetTransferConnectionInvitationsQuery
{
AccountId = _account.Id
};
}
public FakeMyDbContext()
{
_changeTracker = null;
_configuration = null;
_database = null;
AttendanceStatus = new FakeDbSet <AttendanceStatu>("AttendanceStatusId");
Employees = new FakeDbSet <Employee>("EmployeeId");
EmployeeAnnualLeaves = new FakeDbSet <EmployeeAnnualLeave>("EmployeeAnnualLeaveId");
EmployeeAttendances = new FakeDbSet <EmployeeAttendance>("EmployeeAttendanceId");
}
public void Arrange()
{
_db = new Mock <EmployerAccountsDbContext>();
_senderAccount = new Account
{
Id = 333333,
HashedId = "ABC123",
Name = "Sender"
};
_receiverAccount = new Account
{
Id = 222222,
HashedId = "XYZ987",
Name = "Receiver"
};
_receivedTransferConnectionInvitation = new TransferConnectionInvitationBuilder()
.WithId(111111)
.WithSenderAccount(_senderAccount)
.WithReceiverAccount(_receiverAccount)
.WithStatus(TransferConnectionInvitationStatus.Pending)
.Build();
_rejectedTransferConnectionInvitation = new TransferConnectionInvitationBuilder()
.WithId(111111)
.WithSenderAccount(_senderAccount)
.WithReceiverAccount(_receiverAccount)
.WithStatus(TransferConnectionInvitationStatus.Rejected)
.Build();
_transferConnectionInvitations = new List <TransferConnectionInvitation> {
_receivedTransferConnectionInvitation, _rejectedTransferConnectionInvitation
};
_transferConnectionInvitationsDbSet = new FakeDbSet <TransferConnectionInvitation>(_transferConnectionInvitations);
_configurationProvider = new MapperConfiguration(c =>
{
c.AddProfile <AccountMappings>();
c.AddProfile <TransferConnectionInvitationMappings>();
c.AddProfile <UserMappings>();
});
_db.Setup(d => d.TransferConnectionInvitations).Returns(_transferConnectionInvitationsDbSet);
_handler = new GetReceivedTransferConnectionInvitationQueryHandler(new Lazy <EmployerAccountsDbContext>(() => _db.Object), _configurationProvider);
_query = new GetReceivedTransferConnectionInvitationQuery
{
AccountId = _receiverAccount.Id,
TransferConnectionInvitationId = _receivedTransferConnectionInvitation.Id
};
}
// Privates
private FakeDbSet <Person> GetPersonDbSet(IEnumerable <Person> people)
{
var personDbSet = new FakeDbSet <Person>();
foreach (var person in people)
{
personDbSet.Add(person);
}
return(personDbSet);
}
public void ReturnsInstance()
{
// Arrange
var item = new object();
// Act
var dbSet = new FakeDbSet <object>(item);
// Assert
Assert.IsAssignableFrom <FakeDbSet <object> >(dbSet);
}
public void AddRange_WithItems_ShouldAddItemsToSourceList()
{
var data = new List <Person>();
var sut = new FakeDbSet <Person>(data);
var itemsToAdd = new[] { new Person(), new Person() };
var result = sut.AddRange(itemsToAdd);
Assert.That(itemsToAdd, Is.SubsetOf(data));
Assert.That(result, Is.EquivalentTo(itemsToAdd));
}
public void Add_WithItem_ShouldAddItemToSourceList()
{
var data = new List <Person>();
var sut = new FakeDbSet <Person>(data);
var objToAdd = new Person();
var result = sut.Add(objToAdd);
Assert.That(data, Contains.Item(objToAdd));
Assert.That(result, Is.SameAs(objToAdd));
}
public void ReturnsInstance()
{
// Arrange
var data = new List <object>();
// Act
var dbSet = new FakeDbSet <object>(data);
// Assert
Assert.IsAssignableFrom <FakeDbSet <object> >(dbSet);
}
public void GetCountries_Should_Get_Expected_Result()
{
// Arrange
var countries = new List <Country>()
{
new Country {
Id = 1, Name = "Turkey", ISOCode = "TR", CreatedOn = DateTimeOffset.Now
},
new Country {
Id = 2, Name = "United Kingdom", ISOCode = "EN", CreatedOn = DateTimeOffset.Now
},
new Country {
Id = 3, Name = "United States", ISOCode = "US", CreatedOn = DateTimeOffset.Now
},
new Country {
Id = 4, Name = "Argentina", ISOCode = "AR", CreatedOn = DateTimeOffset.Now
},
new Country {
Id = 4, Name = "Bahamas", ISOCode = "BS", CreatedOn = DateTimeOffset.Now
},
new Country {
Id = 4, Name = "Uruguay", ISOCode = "UY", CreatedOn = DateTimeOffset.Now
}
};
var dbSet = new FakeDbSet <Country>();
foreach (var country in countries)
{
dbSet.Add(country);
}
var entitiesContext = new Mock <IEntitiesContext>();
entitiesContext.Setup(ec => ec.Set <Country>()).Returns(dbSet);
var userContext = getMockedUserContext();
var countriesRepo = new MultiTenantRepository <Country>(entitiesContext.Object);
MultiTenantServices <Country, int> countryService = new CountryService(countriesRepo);
var countriesController = new CountriesController(countryService, Global._mapper, userContext);
var pageIndex = 1;
var pageSize = 3;
// Act
var paginatedDto = countriesController.GetCountries(pageIndex, pageSize).Result;
// Assert
Assert.NotNull(paginatedDto);
Assert.Equal(countries.Count, paginatedDto.TotalCount);
Assert.Equal(pageSize, paginatedDto.PageSize);
Assert.Equal(pageIndex, paginatedDto.PageIndex);
}
public void ReturnsPaginatedList()
{
Pagination firstPageThreeResults = new Pagination(1, 3);
IEnumerable <FooEntity> tenFooEntities = this.GivenAFooEntities(10);
FakeDbSet <FooEntity> fooDbSet = new FakeDbSet <FooEntity>(tenFooEntities);
Mock <FakeDatabase> database = FakeDatabase.CreateMockOfFakeDatabase(fooDbSet);
BaseRepository <FooEntity> baseRepository = this.GivenABaseRepositoryWithDatabase(database.Object);
IPagedList <FooEntity> pageResults = baseRepository.GetPage(new Query <FooEntity>(null, firstPageThreeResults, null));
CollectionAssert.AreEqual(tenFooEntities.Take(3).ToList(), pageResults.ToList());
}
public void ReturnsResultsOrderDescendingByIndex()
{
IOrdering <FooEntity> orderingById = new FooOrderByDescendingId();
IEnumerable <FooEntity> tenFooEntities = this.GivenAFooEntitiesWithRandomId(10);
FakeDbSet <FooEntity> fooDbSet = new FakeDbSet <FooEntity>(tenFooEntities);
Mock <FakeDatabase> database = FakeDatabase.CreateMockOfFakeDatabase(fooDbSet);
BaseRepository <FooEntity> baseRepository = this.GivenABaseRepositoryWithDatabase(database.Object);
IEnumerable <FooEntity> results = baseRepository.GetAll(new Query <FooEntity>(null, null, orderingById));
CollectionAssert.AreEqual(tenFooEntities.OrderByDescending(i => i.Id).ToList(), results.ToList());
}
public void ReturnsAllResultsOfLastPage()
{
Pagination lastPageThreeResults = new Pagination(4, 3);
IEnumerable <FooEntity> tenFooEntities = this.GivenAFooEntities(10);
FakeDbSet <FooEntity> fooDbSet = new FakeDbSet <FooEntity>(tenFooEntities);
Mock <FakeDatabase> database = FakeDatabase.CreateMockOfFakeDatabase(fooDbSet);
BaseRepository <FooEntity> baseRepository = this.GivenABaseRepositoryWithDatabase(database.Object);
IEnumerable <FooEntity> results = baseRepository.GetAll(new Query <FooEntity>(null, lastPageThreeResults, null));
CollectionAssert.AreEqual(tenFooEntities.Skip(9).Take(1).ToList(), results.ToList());
}
public async Task ToListAsync_Default_AsyncReturnsCorrectItem() {
// Arrange
var repository = new FakeDbSet<DummyModel>();
repository.Add(new DummyModel { Id = 1, Value = "Dummy" });
// Act
var type = await repository.ToListAsync();
// Assert
Assert.AreEqual(1, type.Count);
Assert.AreEqual(1, type[0].Id);
}
public void given_mapping_fetails_and_status_when_updated_verify_status(int input1, int input2, bool status)
{
var landingToCoreTempDetails = new FakeDbSet <LandingToCoreTempDetails>()
{
Parameters <LandingToCoreTempDetails> .GetSingle(input1), Parameters <LandingToCoreTempDetails> .GetSingle(input2)
};
_dbContext.Setup(d => d.LandingToCoreTempDetails).Returns(landingToCoreTempDetails);
_dataAccess.TempMappingStatusUpdateForDatasetId(_dbContext.Object, input2, status);
Assert.False(_dbContext.Object.LandingToCoreTempDetails.FirstOrDefault(l => l.DatasetId == input2).Status);
}
public void given_dataset_id_when_mapping_is_cancelled_verify_changes_are_removed(int input1, int input2)
{
var landingToCoreTempDetails = new FakeDbSet <LandingToCoreTempDetails>()
{
Parameters <LandingToCoreTempDetails> .GetSingle(input1), Parameters <LandingToCoreTempDetails> .GetSingle(input2)
};
_dbContext.Setup(d => d.LandingToCoreTempDetails).Returns(landingToCoreTempDetails).Callback(() => _dbContext.Setup(db => db.LandingToCoreTempDetails.RemoveRange(landingToCoreTempDetails.ToList())));
_dataAccess.CancelMapping(input2);
_dbContext.Verify(x => x.SaveChanges(), Times.Once());
}
public void AssignQuizAsync_NotNullAssignment_Saved()
{
var assignments = A.Fake<IDbSet<AssignedQuizDto>>();
var groups = new FakeDbSet<GroupDto> {new GroupDto {GroupId = 1, GroupNumber = 1, Year = 2009}};
A.CallTo(() => _context.AssignedQuizes).Returns(assignments);
A.CallTo(() => _context.Groups).Returns(groups);
var assignment = new AssignedQuizDto {Group = new GroupDto {Year = 2014, GroupNumber = 1}};
_quizRepository.AssignQuizAsync(assignment).Wait();
A.CallTo(() => assignments.Add(assignment)).MustHaveHappened();
A.CallTo(() => _context.SaveChangesAsync()).MustHaveHappened();
}
public void AddQuestionToQuiz_NotNullQuestionQuizExists_QuestionAdded()
{
IDbSet<QuizDto> quizes = new FakeDbSet<QuizDto>(new[] { _quizDto });
QuestionDto question = new QuestionDto { QuestionId = 1, QuestionItems = new List<QuestionItemDto>()};
List<QuestionDto> questions = new List<QuestionDto>();
_quizDto.Questions = questions;
A.CallTo(() => _context.Quizes).Returns(quizes);
_quizRepository.AddQuestionToQuiz(QuizId, question).Wait();
Assert.Equal(question.QuestionId, _quizDto.Questions.FirstOrDefault().QuestionId);
A.CallTo(() => _context.SaveChangesAsync()).MustHaveHappened();
}
public void Remove_WithItemThatIsInSet_ShouldRemoveItem()
{
var objToRemove = new Person();
var data = new List <Person> {
objToRemove
};
var sut = new FakeDbSet <Person>(data);
var result = sut.Remove(objToRemove);
Assert.That(result, Is.SameAs(objToRemove));
Assert.That(data, !Contains.Item(objToRemove));
}
public void DetailsTest()
{
var mockData = new FakeDbSet<ValuesTable>() { new ValuesTable() { Computer = "aaa", Counter = "CPU", CounterValue = 10.23, Id = 0, Time = DateTime.Now } };
var mock = new Mock<Entities>();
mock.Setup(m => m.ValuesTable).Returns(mockData);
HomeController controller = new HomeController(mock.Object);
ViewResult result = controller.Details(0) as ViewResult;
Assert.IsNotNull(result);
var reading = (ValuesTable)result.ViewData.Model;
Assert.AreEqual("aaa", reading.Computer);
Assert.AreEqual("CPU", reading.Counter);
}
/// <summary>
/// Create a new Dataset and add a list records
/// </summary>
/// <param name="people">List containing all the records to add to the fake dataset</param>
/// <returns>FakeDbSet<Person></returns>
private FakeDbSet <Person> GetFakePeopleDbSet(IEnumerable <Person> people)
{
// Create empty test dBSet
var FakePeopleDbSet = new FakeDbSet <Person>();
// Add list of test records
foreach (var person in people)
{
FakePeopleDbSet.Add(person);
}
return(FakePeopleDbSet);
}
public void given_file_resend_audit_details_when_created_then_audit_details_created(int input1, int input2)
{
var data = new FakeDbSet <OutboundFileResendAudit>()
{
Parameters <OutboundFileResendAudit> .GetSingle(input1), Parameters <OutboundFileResendAudit> .GetSingle(input2)
};
_dbContext.Setup(s => s.OutboundFileResendAudit.Add(data.FirstOrDefault()));
_dataAccess.CreateOutboundResendAudit(data.ToList());
_dbContext.Verify(x => x.SaveChanges(), Times.Once());
}
public void GetType_Default_ImplementsIDbSet() {
// Arrange
var repository = new FakeDbSet<DummyModel>();
// Act
var type = repository.GetType();
// Assert
Assert.IsTrue(type.GetInterfaces().Any(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(IDbSet<>)));
//repository.Add(new DummyModel { Id = 1, Value = "dummy item #1" });
}
public FakeContosoUniversityEntities()
{
Courses = new FakeDbSet <Course>("CourseId");
Departments = new FakeDbSet <Department>("DepartmentId");
Enrollments = new FakeDbSet <Enrollment>("EnrollmentId");
OfficeAssignments = new FakeDbSet <OfficeAssignment>("InstructorId");
People = new FakeDbSet <Person>("Id");
Sysdiagrams = new FakeDbSet <Sysdiagram>("DiagramId");
VwDepts = new FakeDbSet <VwDept>("DeptName");
VwDeptCourseCounts = new FakeDbSet <VwDeptCourseCount>("DepartmentId");
InitializePartial();
}
public void GetType_Default_ImplementsIDbSet()
{
// Arrange
var repository = new FakeDbSet <DummyModel>();
// Act
var type = repository.GetType();
// Assert
Assert.IsTrue(type.GetInterfaces().Any(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(IDbSet <>)));
//repository.Add(new DummyModel { Id = 1, Value = "dummy item #1" });
}
public void given_dataset_id_when_edited_then_updates_dataset_file_details(int input1)
{
var data = new FakeDbSet <DatasetFileDetails>()
{
Parameters <DatasetFileDetails> .GetSingle(input1)
};
var input = Parameters <DatasetFileDetails> .GetSingle(input1);
_dbContext.Setup(db => db.DatasetFileDetails).Returns(data);
var result = _dataAccess.UpdateDataSetSftpDetailsByDataSetID(input);
}
public void GetCountries_Should_Get_Expected_Result()
{
// Arrange
List <Country> countries = new List <Country>()
{
new Country {
Id = 1, Name = "Turkey", ISOCode = "TR", CreatedOn = DateTimeOffset.Now
},
new Country {
Id = 2, Name = "United Kingdom", ISOCode = "EN", CreatedOn = DateTimeOffset.Now
},
new Country {
Id = 3, Name = "United States", ISOCode = "US", CreatedOn = DateTimeOffset.Now
},
new Country {
Id = 4, Name = "Argentina", ISOCode = "AR", CreatedOn = DateTimeOffset.Now
},
new Country {
Id = 4, Name = "Bahamas", ISOCode = "BS", CreatedOn = DateTimeOffset.Now
},
new Country {
Id = 4, Name = "Uruguay", ISOCode = "UY", CreatedOn = DateTimeOffset.Now
}
};
FakeDbSet <Country> dbSet = new FakeDbSet <Country>();
foreach (var country in countries)
{
dbSet.Add(country);
}
Mock <IEntitiesContext> entitiesContext = new Mock <IEntitiesContext>();
entitiesContext.Setup(ec => ec.Set <Country>()).Returns(dbSet);
EntityRepository <Country> countriesRepo = new EntityRepository <Country>(entitiesContext.Object);
CountriesController countriesController = new CountriesController(countriesRepo, Mapper.Engine);
const int pageIndex = 1;
const int pageSize = 3;
// Act
var paginatedDto = countriesController.GetCountries(pageIndex, pageSize);
// Assert
Assert.NotNull(paginatedDto);
Assert.Equal(countries.Count, paginatedDto.TotalCount);
Assert.Equal(pageSize, paginatedDto.PageSize);
Assert.Equal(pageIndex, paginatedDto.PageIndex);
}
public void RemoveRange()
{
var data = new List <Person> {
new Person(), new Person(), new Person()
};
var itemsToRemove = data.Take(2).ToList();
var sut = new FakeDbSet <Person>(data);
var result = sut.RemoveRange(itemsToRemove);
Assert.That(data, !Intersects.With(itemsToRemove));
Assert.That(result, Is.EquivalentTo(itemsToRemove));
}
private void SetupCommandHandler(IList<BoardEntity> boards, IList<BoardTaskEntity> boardTasks)
{
mockDataContext = new Mock<IDataContext>();
var fakeBoardDbSet = new FakeDbSet<BoardEntity>();
boards.ToList().ForEach(x => fakeBoardDbSet.Add(x));
mockDataContext.Setup(x => x.Set<BoardEntity>()).Returns(fakeBoardDbSet);
var fakeBoardTaskDbSet = new FakeDbSet<BoardTaskEntity>();
boardTasks.ToList().ForEach(x => fakeBoardTaskDbSet.Add(x));
mockDataContext.Setup(x => x.Set<BoardTaskEntity>()).Returns(fakeBoardTaskDbSet);
handler = new DeleteBoardTaskCommandHandler(mockDataContext.Object);
}
public void given_a_party_when_edited_then_updates_party(int input1)
{
var input = Parameters <PartyAcctDetails> .GetSingle(input1);
var expected = new FakeDbSet <PartyAcctDetails>()
{
Parameters <PartyAcctDetails> .GetSingle(input1)
};
//_dbContext.Setup(db => db.CustomerAcctDetails).Returns(expected);
_dbContext.Setup(x => x.Entry(input)).Returns(() => _dbContext.Object.Entry(input)).Callback(() => _dbContext.Setup(db => db.PartyAcctDetails).Returns(expected));
var result = _dataAccess.UpdateParty(input);
}
public void given_dataset_table_details_when_edited_then_updates_dataset_table_details(int input1)
{
var input = Parameters <DatasetTableDetails> .GetSingle(input1);
var expected = new FakeDbSet <DatasetTableDetails>()
{
Parameters <DatasetTableDetails> .GetSingle(input1)
};
_dbContext.Setup(db => db.DatasetTableDetails).Returns(expected);
//_dbContext.Setup(x => x.Entry(input)).Returns(() => _dbContext.Object.Entry(input)).Callback(() => _dbContext.Setup(db => db.DatasetFileDetails).Returns(expected));
_dataAccess.UpdateDatasetTableDetails(input);
}
