public void GetAllShouldReturnTodos()
{
var data = new List<Todo>
{
new Todo {Id = 1},
new Todo {Id = 2},
new Todo {Id = 3},
}.AsQueryable();
var mockSet = new Mock<DbSet<Todo>>();
mockSet.As<IQueryable<Todo>>().Setup(m => m.Provider).Returns(data.Provider);
mockSet.As<IQueryable<Todo>>().Setup(m => m.Expression).Returns(data.Expression);
mockSet.As<IQueryable<Todo>>().Setup(m => m.ElementType).Returns(data.ElementType);
mockSet.As<IQueryable<Todo>>().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
var mockContext = new Mock<ApplicationDbContext>();
mockContext.Setup(c => c.Todos).Returns(mockSet.Object);
var service = new TodoRepository(mockContext.Object);
var todos = service.GetAll().ToList();
Assert.AreEqual(3, todos.Count);
Assert.AreEqual(1, todos[0].Id);
Assert.AreEqual(2, todos[1].Id);
Assert.AreEqual(3, todos[2].Id);
}
private Mock<ApplicationDbContext> GetApplicationDbContextMock()
{
// single user
var appUser = new ApplicationUser();
appUser.Id = "1";
var data = new List<ToDo> {
new ToDo { Id = 0, Title = "Todo 1", Completed = false, User = appUser },
new ToDo { Id = 1, Title = "Todo 2", Completed = true, User = appUser },
}.AsQueryable();
var mockSet = new Mock<DbSet<ToDo>>();
mockSet.As<IDbAsyncEnumerable<ToDo>>()
.Setup(m => m.GetAsyncEnumerator())
.Returns(new TestDbAsyncEnumerator<ToDo>(data.GetEnumerator()));
mockSet.As<IQueryable<ToDo>>()
.Setup(m => m.Provider)
.Returns(new TestDbAsyncQueryProvider<ToDo>(data.Provider));
mockSet.As<IQueryable<ToDo>>().Setup(m => m.Expression).Returns(data.Expression);
mockSet.As<IQueryable<ToDo>>().Setup(m => m.ElementType).Returns(data.ElementType);
mockSet.As<IQueryable<ToDo>>().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
var applicationDbContext = new Mock<ApplicationDbContext>();
applicationDbContext.Setup(c => c.ToDos).Returns(mockSet.Object);
return applicationDbContext;
}
public void GetAllTasks_Order_By_Username()
{
var taskData = new List<TaskModel>
{
Build_Task_For_Testing("B's Task", new DateTime(2015, 7, 3, 5, 5, 5), "B's Test Task", "B"),
Build_Task_For_Testing("C's Task", new DateTime(2015, 7, 5, 5, 5, 5), "C's Test Task", "C"),
Build_Task_For_Testing("D's Task", new DateTime(2015, 7, 6, 5, 5, 5), "D's Test Task", "D")
}.AsQueryable();
var taskData2 = new List<TaskModel> { }.AsQueryable();
var mockSet = new Mock<DbSet<TaskModel>>();
mockSet.As<IQueryable<TaskModel>>().Setup(m => m.Provider).Returns(taskData.Provider);
mockSet.As<IQueryable<TaskModel>>().Setup(m => m.Expression).Returns(taskData.Expression);
mockSet.As<IQueryable<TaskModel>>().Setup(m => m.ElementType).Returns(taskData.ElementType);
mockSet.As<IQueryable<TaskModel>>().Setup(m => m.GetEnumerator()).Returns(taskData.GetEnumerator());
var mockDbContext = new Mock<TaskDBContext>();
mockDbContext.Setup(t => t.Tasks).Returns(mockSet.Object);
var testClass = new TestClass(mockDbContext.Object);
var allTasks = testClass.GetAllTasks();
Assert.AreEqual(3, allTasks.Count);
Assert.AreEqual("B", allTasks[0].Username);
Assert.AreEqual("C", allTasks[1].Username);
Assert.AreEqual("D", allTasks[2].Username);
}
public void Get_Object_fromPager_User_Match_To_DB()
{
var users = new List<staff>{new staff{
Email = "*****@*****.**",
FirstName = "andrew",
LastName = "nick",
ID = 3
},
new staff{
Email = "*****@*****.**",
FirstName = "aasdndrew",
LastName = "nicasdk",
ID = 30}
};
Mock<IStaffDAO> mockStaffDAO = new Mock<IStaffDAO>();
mockStaffDAO.Setup(m => m.Get()).Returns(users);
StaffBL staffBL = new StaffBL(mockStaffDAO.Object);
var result = staffBL.Get(5, 0, "");
Assert.AreEqual(users.Count(), result.staffMembers.Count());
IEnumerator<staff> e1 = users.GetEnumerator();
IEnumerator<staff> e2 = result.staffMembers.GetEnumerator();
while (e1.MoveNext() && e2.MoveNext())
{
Assert.AreEqual(e1.Current, e2.Current);
}
}
private legion_service_api generateSensorDataSet()
{
Random rnd = new Random();
IQueryable<sensor_data> data = new List<sensor_data>
{
new sensor_data { Id = 1, userGuid = "teste.teste.teste", sensor_name = "sensor1", timestamp = DateTime.Now.AddMilliseconds(rnd.Next(1000, 10000))},
new sensor_data { Id = 3, userGuid = "teste.teste.teste", sensor_name = "sensor2", timestamp = DateTime.Now.AddMilliseconds(rnd.Next(1000, 10000))},
new sensor_data { Id = 4, userGuid = "teste.teste.teste", sensor_name = "sensor2", timestamp = DateTime.Now.AddMilliseconds(rnd.Next(1000, 10000))},
new sensor_data { Id = 5, userGuid = "teste.teste.teste", sensor_name = "sensor3", timestamp = DateTime.Now.AddMilliseconds(rnd.Next(1000, 10000))},
new sensor_data { Id = 6, userGuid = "teste.teste.teste2", sensor_name = "sensor2", timestamp = DateTime.Now.AddMilliseconds(rnd.Next(1000, 10000))},
new sensor_data { Id = 7, userGuid = "teste.teste.teste2", sensor_name = "sensor2", timestamp = DateTime.Now.AddMilliseconds(rnd.Next(1000, 10000))},
new sensor_data { Id = 2, userGuid = "teste.teste.teste2", sensor_name = "sensor1", timestamp = DateTime.Now.AddMilliseconds(rnd.Next(1000, 10000))}
}.AsQueryable();
var mockset = new Mock<DbSet<sensor_data>>();
mockset.As<IQueryable<sensor_data>>().Setup(m => m.Provider).Returns(data.Provider);
mockset.As<IQueryable<sensor_data>>().Setup(m => m.Expression).Returns(data.Expression);
mockset.As<IQueryable<sensor_data>>().Setup(m => m.ElementType).Returns(data.ElementType);
mockset.As<IQueryable<sensor_data>>().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
var mockContext = new Mock<legion_serviceContext>();
mockContext.Setup(s => s.sensor_data).Returns(mockset.Object);
return new legion_service_api(mockContext.Object);
}
public void GetUserStocks_must_return_all_stocks_of_user_from_context()
{
var data = new List<UserStock>
{
new UserStock {ID = 0, Name = "DAX", User = Thread.CurrentPrincipal.Identity.GetUserName()},
new UserStock {ID = 1, Name = "NYSE", User = "******"},
new UserStock {ID = 1, Name = "NASDAQ", User = Thread.CurrentPrincipal.Identity.GetUserName()},
}.AsQueryable();
var mockSet = new Mock<DbSet<UserStock>>();
mockSet.As<IQueryable<UserStock>>().Setup(m => m.Provider).Returns(data.Provider);
mockSet.As<IQueryable<UserStock>>().Setup(m => m.Expression).Returns(data.Expression);
mockSet.As<IQueryable<UserStock>>().Setup(m => m.ElementType).Returns(data.ElementType);
mockSet.As<IQueryable<UserStock>>().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
var mockContext = new Mock<IStockExchangeDbContext>();
mockContext.Setup(c => c.UserStocks).Returns(mockSet.Object);
var service = new UserStocksController(mockContext.Object);
var result = service.GetUserStocks();
Assert.AreEqual(2, result.Count());
Assert.AreEqual("DAX", result.Single(us => us.ID == 0).Name);
Assert.AreEqual("NASDAQ", result.Single(us => us.ID == 1).Name);
}
public void TestInitalise()
{
var Urls = new List<ShortUrlEntity>();
Urls.Add(new ShortUrlEntity
{
Id = 0,
Nsfw = false,
RedirectionUrl = "http://www.google.com/",
ShortCode = "google",
Views = 0
});
Urls.Add(new ShortUrlEntity
{
Id = 1,
Nsfw = true,
RedirectionUrl = "http://www.google2.com/",
ShortCode = "google2",
Views = 20
});
var dbSet = new Mock<IEntitySet<ShortUrlEntity>>();
dbSet.Setup(s => s.GetEnumerator()).Returns(Urls.GetEnumerator());
var context = new Mock<IShortUrlContext>();
context.Setup(r => r.EntitySet<ShortUrlEntity>()).Returns(dbSet.Object);
repo = new ShortUrlRepository(context.Object);
}
public void GetFirstUnsentAddress_ShouldReturnNull_IfNoUserWithNotSentStatusExistsInDatabase()
{
// Arrange
var stubContext = new Mock<Context>();
var stubRecipients = new List<Recipient>
{
new Recipient("*****@*****.**"),
new Recipient("*****@*****.**"),
new Recipient("*****@*****.**"),
}.AsQueryable();
stubRecipients.ElementAt(0).MarkAsSent(DateTime.Now);
stubRecipients.ElementAt(1).MarkAsSent(DateTime.Now);
stubRecipients.ElementAt(2).MarkAsFailed("sending failed", DateTime.Now);
var stubDbSet = new Mock<DbSet<Recipient>>();
stubDbSet.As<IQueryable<Recipient>>().Setup(m => m.Provider).Returns(stubRecipients.Provider);
stubDbSet.As<IQueryable<Recipient>>().Setup(m => m.Expression).Returns(stubRecipients.Expression);
stubDbSet.As<IQueryable<Recipient>>().Setup(m => m.ElementType).Returns(stubRecipients.ElementType);
stubDbSet.As<IQueryable<Recipient>>().Setup(m => m.GetEnumerator()).Returns(stubRecipients.GetEnumerator());
stubContext.Setup(c => c.Recipients).Returns(stubDbSet.Object);
// Act
var repository = new Repository(stubContext.Object);
var recipient = repository.GetFirstUnsentAddress();
// Assert
Assert.IsNull(recipient);
}
public async Task GetAllBlogsAsync_orders_by_name()
{
var data = new List<Blog>
{
new Blog { Name = "BBB" },
new Blog { Name = "ZZZ" },
new Blog { Name = "AAA" },
}.AsQueryable();
var mockSet = new Mock<DbSet<Blog>>();
mockSet.As<IDbAsyncEnumerable<Blog>>()
.Setup(m => m.GetAsyncEnumerator())
.Returns(new TestDbAsyncEnumerator<Blog>(data.GetEnumerator()));
mockSet.As<IQueryable<Blog>>()
.Setup(m => m.Provider)
.Returns(new TestDbAsyncQueryProvider<Blog>(data.Provider));
mockSet.As<IQueryable<Blog>>().Setup(m => m.Expression).Returns(data.Expression);
mockSet.As<IQueryable<Blog>>().Setup(m => m.ElementType).Returns(data.ElementType);
mockSet.As<IQueryable<Blog>>().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
var mockContext = new Mock<BloggingContext>();
mockContext.Setup(c => c.Blogs).Returns(mockSet.Object);
var service = new BlogService(mockContext.Object);
var blogs = await service.GetAllBlogsAsync();
Assert.AreEqual(3, blogs.Count);
Assert.AreEqual("AAA", blogs[0].Name);
Assert.AreEqual("BBB", blogs[1].Name);
Assert.AreEqual("ZZZ", blogs[2].Name);
}
public async Task Delete()
{
var data = new List<Department>
{
new Department {DepartmentID = 1, Name = "Test1", Budget = 1001, StartDate = DateTime.Today.AddDays(1)},
new Department {DepartmentID = 2, Name = "Test2", Budget = 1002, StartDate = DateTime.Today.AddDays(2)},
new Department {DepartmentID = 3, Name = "Test3", Budget = 1003, StartDate = DateTime.Today.AddDays(3)},
new Department {DepartmentID = 4, Name = "Test4", Budget = 1004, StartDate = DateTime.Today.AddDays(4)}
}.AsQueryable();
var mockSet = new Mock<DbSet<Department>>();
mockSet.As<IQueryable<Department>>().Setup(m => m.Provider).Returns(data.Provider);
mockSet.As<IQueryable<Department>>().Setup(m => m.Expression).Returns(data.Expression);
mockSet.As<IQueryable<Department>>().Setup(m => m.ElementType).Returns(data.ElementType);
mockSet.As<IQueryable<Department>>().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
var mockContext = new Mock<SchoolContext>();
mockContext.Setup(m => m.Departments).Returns(mockSet.Object);
var controller = new DepartmentController(mockContext.Object);
Department departmentToDelete = controller.GetAllDepartments().First();
await controller.Delete(departmentToDelete);
mockContext.Verify(m => m.SaveChangesAsync(), Times.Once());
//Assert.AreEqual(3, controller.GetAllDepartments().Count);
}
public void RepositoryGetArtistById()
{
const int expectedId = 3;
var expected = new Artist { Id = expectedId, Name = "WWWW", Country = "WEE", Identifier = "dfr" };
var data = new List<Artist>{
expected,
new Artist{Id = 1, Name = "Ronald", Country = "ZW", Identifier = "abc", Eliases = new List<Elias>{new Elias {Id = 1, EliasName = "Ron", ArtistId = 1}}},
new Artist{Id = 2, Name = "Zebra", Country = "SA", Identifier = "bvf", Eliases = new List<Elias>{new Elias {Id = 2, EliasName = "Zeb", ArtistId = 2}}}
}.AsQueryable();
var mockSet = new Mock<DbSet<Artist>>();
mockSet.As<IQueryable<Artist>>().Setup(m => m.Provider).Returns(data.Provider);
mockSet.As<IQueryable<Artist>>().Setup(m => m.Expression).Returns(data.Expression);
mockSet.As<IQueryable<Artist>>().Setup(m => m.ElementType).Returns(data.ElementType);
mockSet.As<IQueryable<Artist>>().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
var mockContext = new Mock<BEContext>();
mockContext.Setup(m => m.Artists).Returns(mockSet.Object);
mockContext.Setup(m => m.Set<Artist>()).Returns(mockSet.Object);
var repo = new Repository<Artist>(mockContext.Object);
var list = repo.GetArtistById(expectedId);
Assert.AreEqual(1, list.Id);
}
public void GetAll_retrieveallitems_allitemsretrieved()
{
// Arrange
var data = new List<Warehouse>
{
new Warehouse(1, 10, 10),
new Warehouse(2, 15, 20),
new Warehouse(3, 25, 30),
}.AsQueryable();
var mockContext = new Mock<PDSDatabase>();
var mockSet = new Mock<MockableDbSetWithIQueryable<Warehouse>>();
mockContext.Setup(c => c.Warehouses).Returns(mockSet.Object);
mockSet.Setup(m => m.Provider).Returns(data.Provider);
mockSet.Setup(m => m.Expression).Returns(data.Expression);
mockSet.Setup(m => m.ElementType).Returns(data.ElementType);
mockSet.Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
var repostitory = new InDatabaseWarehouseRepository(mockContext.Object);
// Act
var warehouses = (List<Warehouse>)repostitory.GetAll();
// Assert
Assert.AreEqual(3, warehouses.Count);
}
public void ClassInit()
{
// Installing mock DbSet.
var data = new List<MockCatalog>
{
new MockCatalog(false) { Name = "BBB" },
new MockCatalog(false) { Name = "ZZZ" },
new MockCatalog(false) { Name = "AAA" },
}.AsQueryable();
var mockDbSet = new Mock<DbSet<MockCatalog>>();
mockDbSet.As<IQueryable<MockCatalog>>().Setup(m => m.Provider).Returns(data.Provider);
mockDbSet.As<IQueryable<MockCatalog>>().Setup(m => m.Expression).Returns(data.Expression);
mockDbSet.As<IQueryable<MockCatalog>>().Setup(m => m.ElementType).Returns(data.ElementType);
mockDbSet.As<IQueryable<MockCatalog>>().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
// Installing mock Context.
var mockContext = new Mock<MetadataEFContext>();
mockContext.Setup(m => m.Set<MockCatalog>()).Returns(mockDbSet.Object);
// Installing repository.
var catalogRepository = new EFCatalogRepository<MockCatalog>(mockContext.Object);
// Installing shared tests.
SharedTests = new SharedTests<MockCatalog>(mockDbSet, mockContext, catalogRepository, CreateCatalogItem);
}
public void can_mock_convict_context_SpeedTest()
{
/// Arrange Objects:
var convicts = new List<Convict> {
new Convict { ConvictCode = "1234",
Email = "*****@*****.**"
},
new Convict { ConvictCode = "1233",
Email = "*****@*****.**"
},
new Convict { ConvictCode = "1232",
Email = "*****@*****.**"
}
}.AsQueryable();
var mockSet = Substitute.For<IDbSet<Convict>>();
mockSet.Provider.Returns(convicts.Provider);
mockSet.Expression.Returns(convicts.Expression);
mockSet.ElementType.Returns(convicts.ElementType);
mockSet.GetEnumerator().Returns(convicts.GetEnumerator());
var context = Substitute.For<IConvictsContext>();
context.Convicts.Returns(mockSet);
Assert.AreEqual(3, context.Convicts.Count());
Assert.AreEqual("1234", context.Convicts.First().ConvictCode);
}
public void TestCacheableGetAllProductsSync()
{
var data = new List<Product>
            {
                new Product { ProductName = "BBB"},
                new Product { ProductName = "ZZZ" },
                new Product { ProductName = "AAA" }
            }.AsQueryable();
var mockSet = new Mock<DbSet<Product>>();
mockSet.As<IQueryable<Product>>().Setup(m => m.Provider).Returns(data.Provider);
mockSet.As<IQueryable<Product>>().Setup(m => m.Expression).Returns(data.Expression);
mockSet.As<IQueryable<Product>>().Setup(m => m.ElementType).Returns(data.ElementType);
mockSet.As<IQueryable<Product>>().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
var mockContext = new Mock<SampleContext>();
mockContext.Setup(c => c.Products).Returns(mockSet.Object);
// public List<Product> GetAllProductsOrderedByName()
var products = mockContext.Object.Products
.OrderBy(product => product.ProductName)
.Cacheable()
.ToList();
Assert.AreEqual(3, products.Count);
Assert.AreEqual("AAA", products[0].ProductName);
Assert.AreEqual("BBB", products[1].ProductName);
Assert.AreEqual("ZZZ", products[2].ProductName);
}
public void Flatten_ExceptionThrownSynchronously_ExceptionThrownIsPropagatedToCaller()
{
var list1 = new List<int> { 1 };
var list2 = new List<int> { 2 };
var partialResult1 = new Mock<IPartialResult<int>>();
var partialResult2 = new Mock<IPartialResult<int>>();
partialResult2.Setup( res => res.GetEnumerator() ).Returns( () => list2.GetEnumerator() );
partialResult2.Setup( res => res.HasMoreResults ).Returns( true );
partialResult2.Setup( res => res.GetNextAsync() ).Throws( new InvalidOperationException( "test" ) );
partialResult1.Setup( res => res.GetEnumerator() ).Returns( () => list1.GetEnumerator() );
partialResult1.Setup( res => res.HasMoreResults ).Returns( true );
partialResult1.Setup( res => res.GetNextAsync() ).Returns( () => Task.Factory.StartNew( () => partialResult2.Object ) );
try
{
Task.Factory.StartNew( () => partialResult1.Object ).FlattenAsync().Wait();
}
catch ( AggregateException exception )
{
var inner = exception.InnerExceptions.Single() as InvalidOperationException;
Assert.IsNotNull( inner, "Inner exception was not an InvalidOperationException." );
Assert.IsTrue( inner.Message == "test", "Inner exception did not contain our message." );
}
}
public void ReturnCacheTest()
{
VMWallet vwWallet = new VMWallet(new Dictionary<FaceValueTypes, int>{
{FaceValueTypes.One,100},
{FaceValueTypes.Two,100},
{FaceValueTypes.Five,100},
{FaceValueTypes.Ten,100}
});
List<Coin> AddingCoins = new List<Coin>{
new Coin(FaceValueTypes.Ten),
new Coin(FaceValueTypes.Ten),
new Coin(FaceValueTypes.Two),
new Coin(FaceValueTypes.One)
};
foreach(var coin in AddingCoins)
{
vwWallet.Add(coin);
}
Assert.AreEqual(23, vwWallet.MoneyCache);
List<Coin> returned_coins = vwWallet.ReturnCache();
Assert.AreEqual(AddingCoins.Count, returned_coins.Count);
var e1 = AddingCoins.GetEnumerator();
var e2 = returned_coins.GetEnumerator();
while (e1.MoveNext() && e2.MoveNext())
{
Assert.AreEqual(e1.Current, e2.Current);
}
}
private void SetupForGetMessages()
{
var list1 = new List<Message>()
{
new Message()
{
Body = "B1"
},
new Message()
{
Body = "B2"
}
}.AsQueryable();
var mockMessages = new Mock<DbSet<Message>>();
mockMessages.As<IQueryable<Message>>().Setup(m => m.Provider).Returns(list1.Provider);
mockMessages.As<IQueryable<Message>>().Setup(m => m.Expression).Returns(list1.Expression);
mockMessages.As<IQueryable<Message>>().Setup(m => m.ElementType).Returns(list1.ElementType);
mockMessages.As<IQueryable<Message>>().Setup(m => m.GetEnumerator()).Returns(list1.GetEnumerator());
var mockContext = new Mock<AppDbContext>();
mockContext.Setup(c => c.Messages).Returns(mockMessages.Object);
_dbContext = mockContext.Object;
}
public void InitVBAProjectIntitializesRepo()
{
//Assert.Inconclusive("This test accesses file system.");
//arrange
var component = new Mock<VBComponent>();
component.Setup(c => c.Name).Returns("Module1");
component.Setup(c => c.Type).Returns(vbext_ComponentType.vbext_ct_StdModule);
component.Setup(c => c.Export("foo")).Verifiable();
var componentList = new List<VBComponent> { component.Object };
var components = new Mock<VBComponents>();
components.Setup(c => c.GetEnumerator()).Returns(componentList.GetEnumerator());
var project = new Mock<VBProject>();
project.Setup(p => p.VBComponents).Returns(components.Object);
project.Setup(p => p.Name).Returns("SourceControlTest");
//act
var git = new GitProvider(project.Object);
git.InitVBAProject(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments));
//assert
Assert.AreEqual(project.Object.Name, git.CurrentRepository.Name);
var repoDir = Path.Combine(git.CurrentRepository.LocalLocation, ".git");
Assert.IsTrue(Directory.Exists(repoDir), "Repo directory does not exist.");
}
public void GetAll_retrieveallitems_allitemsretrieved()
{
// Arrange
var data = new List<Package>
{
new Package(1, "S", "SA", "R", "RA", 1, "City", "Country", "1010", "Street"),
new Package(2, "S", "SA", "R", "RA", 1, "City", "Country", "1010", "Street"),
new Package(3, "S", "SA", "R", "RA", 2, "City", "Country", "1010", "Street"),
}.AsQueryable();
var mockContext = new Mock<PDSDatabase>();
var mockSet = new Mock<MockableDbSetWithIQueryable<Package>>();
mockContext.Setup(c => c.Packages).Returns(mockSet.Object);
mockSet.Setup(m => m.Provider).Returns(data.Provider);
mockSet.Setup(m => m.Expression).Returns(data.Expression);
mockSet.Setup(m => m.ElementType).Returns(data.ElementType);
mockSet.Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
var repostitory = new InDatabasePackageRepository(mockContext.Object);
// Act
var packages = (List<Package>)repostitory.GetAll();
// Assert
Assert.AreEqual(3, packages.Count);
}
public void GetFirstUnsentAddress_ShouldReturnFirstRecipientWithNotSentStatus_IfItExistsInDatabase()
{
// Arrange
var stubContext = new Mock<Context>();
var stubRecipients = new List<Recipient>
{
new Recipient("*****@*****.**"),
new Recipient("*****@*****.**"),
new Recipient("*****@*****.**"),
}.AsQueryable();
stubRecipients.First().MarkAsSent(DateTime.Now);
var stubDbSet = new Mock<DbSet<Recipient>>();
stubDbSet.As<IQueryable<Recipient>>().Setup(m => m.Provider).Returns(stubRecipients.Provider);
stubDbSet.As<IQueryable<Recipient>>().Setup(m => m.Expression).Returns(stubRecipients.Expression);
stubDbSet.As<IQueryable<Recipient>>().Setup(m => m.ElementType).Returns(stubRecipients.ElementType);
stubDbSet.As<IQueryable<Recipient>>().Setup(m => m.GetEnumerator()).Returns(stubRecipients.GetEnumerator());
stubContext.Setup(c => c.Recipients).Returns(stubDbSet.Object);
// Act
var repository = new Repository(stubContext.Object);
var recipient = repository.GetFirstUnsentAddress();
// Assert
Assert.AreEqual("*****@*****.**", recipient.Email);
}
public void LookAheadTestStartZero()
{
var instructions = new List<XamlInstruction>();
var enumerator = instructions.GetEnumerator();
enumerator.MoveNext();
var count = LookaheadBuffer.GetUntilEndOfRoot(enumerator).Count();
Assert.AreEqual(0, count);
}
public void IndexSortedByName()
{
// Create some test data that is not ordered alphabetically
var data = new List<Department>
{
new Department { Name = "CCC" },
new Department { Name = "AAA" },
new Department { Name = "BBB" }
}.AsQueryable();
var set = new Mock<DbSet<Department>>();
// Wire up LINQ on mock set to use LINQ to Objects against test data
// Includes wire up to make async work (see http://msdn.com/data/dn314429#async for details)
set.As<IDbAsyncEnumerable<Department>>()
.Setup(m => m.GetAsyncEnumerator())
.Returns(new TestDbAsyncEnumerator<Department>(data.GetEnumerator()));
set.As<IQueryable<Department>>()
.Setup(m => m.Provider)
.Returns(new TestDbAsyncQueryProvider<Department>(data.Provider));
set.As<IQueryable<Department>>().Setup(m => m.Expression).Returns(data.Expression);
set.As<IQueryable<Department>>().Setup(m => m.ElementType).Returns(data.ElementType);
set.As<IQueryable<Department>>().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
// Create a mock context that returns mock set with test data
var context = new Mock<AdventureWorksContext>();
context.Setup(c => c.Departments).Returns(set.Object);
// Create a controller based on mock context and invoke Index action
var controller = new DepartmentsController(context.Object);
var result = controller.Index().Result;
// Ensure we get a ViewResult back
Assert.IsInstanceOfType(result, typeof(ViewResult));
var viewResult = (ViewResult)result;
// Ensure model is a collection of all Departments ordered by name
Assert.IsInstanceOfType(viewResult.Model, typeof(IEnumerable<Department>));
var departments = (IEnumerable<Department>)viewResult.Model;
Assert.AreEqual(3, departments.Count());
Assert.AreEqual("AAA", departments.First().Name, "Results not sorted alphabetically");
Assert.AreEqual("BBB", departments.Skip(1).First().Name, "Results not sorted alphabetically");
Assert.AreEqual("CCC", departments.Skip(2).First().Name, "Results not sorted alphabetically");
}
public void EnumeratorEnumerable_Test()
{
List<Int32> collection = new List<Int32>(TestUtilities.GenerateRandomArray(100));
EnumeratorEnumerable<Int32> enu = new EnumeratorEnumerable<int>(collection.GetEnumerator());
IEnumerator<Int32> cEnu = collection.GetEnumerator();
IEnumerator<Int32> eEnu = enu.GetEnumerator();
while (true)
{
Boolean cNxt = cEnu.MoveNext();
Boolean eNxt = eEnu.MoveNext();
Assert.AreEqual(cNxt, eNxt);
if (!cNxt) break;
Assert.AreEqual(cEnu.Current, eEnu.Current);
}
}
/// <summary>The create mock context.</summary>
/// <returns>The <see cref="Mock" />.</returns>
public static Mock<IDatabaseContext> CreateMockContext()
{
Mock<IDatabaseContext> contextMock = new Mock<IDatabaseContext>();
IQueryable<Region> regions = new List<Region>
{
new Region { Id = 1, CountryId = 1, Name = "England" },
new Region { Id = 2, CountryId = 1, Name = "Scotland" },
new Region { Id = 3, CountryId = 1, Name = "Wales" },
new Region { Id = 4, CountryId = 1, Name = "Northen Ireland" },
new Region { Id = 5, CountryId = 2, Name = "Queensland" },
new Region { Id = 6, CountryId = 2, Name = "Victoria" },
new Region { Id = 7, CountryId = 2, Name = "Tasmania" },
new Region { Id = 8, CountryId = 2, Name = "New South Wales" }
}.AsQueryable();
IQueryable<Country> coutries = new List<Country>
{
new Country
{
Id = 1, Name = "United Kingdom", Regions = regions.Where(a => a.CountryId == 1).ToList()
},
new Country
{
Id = 2, Name = "Australia", Regions = regions.Where(a => a.CountryId == 2).ToList()
}
}.AsQueryable();
foreach (Region region in regions)
{
region.Country = coutries.First(a => a.Id == region.CountryId);
}
Mock<IDbSet<Country>> countryMock = new Mock<IDbSet<Country>>();
countryMock.As<IQueryable<Country>>().Setup(m => m.Provider).Returns(coutries.Provider);
countryMock.As<IQueryable<Country>>().Setup(m => m.Expression).Returns(coutries.Expression);
countryMock.As<IQueryable<Country>>().Setup(m => m.ElementType).Returns(coutries.ElementType);
countryMock.As<IQueryable<Country>>().Setup(m => m.GetEnumerator()).Returns(coutries.GetEnumerator());
Mock<IDbSet<Region>> regionMock = new Mock<IDbSet<Region>>();
regionMock.As<IQueryable<Region>>().Setup(m => m.Provider).Returns(regions.Provider);
regionMock.As<IQueryable<Region>>().Setup(m => m.Expression).Returns(regions.Expression);
regionMock.As<IQueryable<Region>>().Setup(m => m.ElementType).Returns(regions.ElementType);
regionMock.As<IQueryable<Region>>().Setup(m => m.GetEnumerator()).Returns(regions.GetEnumerator());
contextMock.Setup(a => a.Countries).Returns(countryMock.Object);
contextMock.Setup(a => a.Regions).Returns(regionMock.Object);
// verify that the mocking is setup correctly
List<Region> result = contextMock.Object.Countries.Include(a => a.Regions).SelectMany(a => a.Regions).ToList();
Assert.AreEqual(regions.Count(), result.Count);
return contextMock;
}
public void CheckMultiVersionCsdlsRoundtrip()
{
const string inputText =
@"<?xml version=""1.0"" encoding=""utf-16""?>
<Schema Namespace=""Real4"" xmlns=""http://docs.oasis-open.org/odata/ns/edm"">
<ComplexType Name=""Complex4"" BaseType=""Real4.Complex1"">
<Property Name=""Prop4"" Type=""Edm.Int32"" Nullable=""false"" />
</ComplexType>
</Schema>";
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
settings.Encoding = System.Text.Encoding.UTF8;
List<StringWriter> outStrings = new List<StringWriter>();
List<XmlReader> readers = new List<XmlReader>();
List<XmlWriter> writers = new List<XmlWriter>();
foreach (string s in new string[] { inputText })
{
readers.Add(XmlReader.Create(new StringReader(s)));
}
for (int i = 0; i < readers.Count; i++)
{
StringWriter sw = new StringWriter();
outStrings.Add(sw);
writers.Add(XmlWriter.Create(sw, settings));
}
IEdmModel model;
IEnumerable<EdmError> errors;
bool parsed = CsdlReader.TryParse(readers, out model, out errors);
Assert.IsTrue(parsed, "Model Parsed");
Assert.IsTrue(errors.Count() == 0, "No errors");
Assert.AreEqual(EdmConstants.EdmVersion4, model.GetEdmVersion(), "Version check");
IEnumerator<XmlWriter> writerEnumerator = writers.GetEnumerator();
model.TryWriteCsdl(s => { writerEnumerator.MoveNext(); return writerEnumerator.Current; }, out errors);
foreach (XmlWriter xw in writers)
{
xw.Flush();
xw.Close();
}
IEnumerator<StringWriter> swEnumerator = outStrings.GetEnumerator();
foreach (string input in new string[] { inputText })
{
swEnumerator.MoveNext();
Assert.IsTrue(swEnumerator.Current.ToString() == input, "Input = Output");
}
}
public void CannotDeleteMealTemplateIfNew()
{
var loggerMock = new Mock<ILoggerFacade>();
var dataRepositoryMock = new Mock<IDataRepository>();
var interactionServiceMock = new Mock<IInteractionService>();
var regionNavigationServiceMock = new Mock<IRegionNavigationService>();
var regionManagerMock = new Mock<IRegionManager>();
dataRepositoryMock.Setup( x => x.Contains( It.IsAny<MealTemplate>() ) ).Returns( false );
dataRepositoryMock.Setup( x => x.ItemIsUsed( It.IsAny<MealTemplate>() ) ).Returns( false );
dataRepositoryMock
.Setup( x => x.GetAllMealTypes() )
.Returns( new ReadOnlyCollection<MealType>( new List<MealType>() ) );
dataRepositoryMock
.Setup( x => x.GetAllFoodItems() )
.Returns( new ReadOnlyCollection<FoodItem>( new List<FoodItem>() ) );
var viewModel = new MealTemplateViewModel( dataRepositoryMock.Object, regionManagerMock.Object, interactionServiceMock.Object, loggerMock.Object );
var navigationContext = new NavigationContext( regionNavigationServiceMock.Object, new Uri( "MealTemplate", UriKind.Relative ) );
viewModel.OnNavigatedTo( navigationContext );
viewModel.Name = "test";
viewModel.Description = "This is a test";
viewModel.TimeOfMeal = DateTime.Now;
viewModel.TypeOfMeal = new MealType( Guid.NewGuid(), "test", "test", DateTime.Now, false );
viewModel.FoodItemServings.Add( new ServingViewModel<FoodItem>( new FoodItem( Guid.NewGuid(), "test", "test", 90.0M ), 1.25M ) );
// Setup the regions so we can determine if the view has been removed or not
var view = new UserControl();
view.DataContext = viewModel;
var views = new List<UserControl>();
views.Add( new UserControl() );
views.Add( view );
views.Add( new UserControl() );
views.Add( new UserControl() );
var regionMock = new Mock<IRegion>();
var regions = new List<IRegion>();
regions.Add( regionMock.Object );
regionManagerMock.Setup( x => x.Regions.GetEnumerator() ).Returns( regions.GetEnumerator() );
regionMock.Setup( x => x.Views.GetEnumerator() ).Returns( views.GetEnumerator() );
Assert.IsTrue( viewModel.IsNew );
Assert.IsFalse( viewModel.IsUsed );
Assert.IsTrue( viewModel.IsValid );
Assert.IsFalse( viewModel.DeleteCommand.CanExecute( null ) );
interactionServiceMock.Verify(
x => x.ShowMessageBox( It.IsAny<String>(), It.IsAny<String>(), It.IsAny<MessageBoxButton>(), It.IsAny<MessageBoxImage>() ), Times.Never() );
regionMock.Verify( x => x.Remove( It.IsAny<Object>() ), Times.Never() );
}
public void LookAheadTestStartMiniumLength()
{
var look = new List<XamlInstruction>
{
X.StartObject<Style>(),
X.EndObject()
};
var enumerator = look.GetEnumerator();
enumerator.MoveNext();
var count = LookaheadBuffer.GetUntilEndOfRoot(enumerator).Count();
Assert.AreEqual(2, count);
}
public async Task UnitOfWork_GetAllAsync_ReturnProducts()
{
var data = new List<Product>
{
new Product { Name = "BBB" },
new Product { Name = "ZZZ" },
new Product { Name = "AAA" },
}.AsQueryable();
var mockSet = new Mock<DbSet<Product>>();
mockSet.As<IDbAsyncEnumerable<Product>>()
.Setup(m => m.GetAsyncEnumerator())
.Returns(new TestDbAsyncEnumerator<Product>(data.GetEnumerator()));
mockSet.As<IQueryable<Product>>()
.Setup(m => m.Provider)
.Returns(new TestDbAsyncQueryProvider<Product>(data.Provider));
mockSet.As<IQueryable<Product>>().Setup(m => m.Expression).Returns(data.Expression);
mockSet.As<IQueryable<Product>>().Setup(m => m.ElementType).Returns(data.ElementType);
mockSet.As<IQueryable<Product>>().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
var mockContext = new Mock<ProjectContext>();
mockContext.Setup(c => c.Products).Returns(mockSet.Object);
mockContext.Setup(e => e.Set<Product>()).Returns(mockSet.Object);
var unitOfWork = new UnitOfWork(mockContext.Object);
var products = await unitOfWork.Products.GetAllAsync();
var listProducts = products.ToList();
Assert.AreEqual(3, listProducts.Count);
Assert.AreEqual(1, listProducts.Count(p=>p.Name=="BBB"));
Assert.AreEqual(1, listProducts.Count(p => p.Name == "ZZZ"));
Assert.AreEqual(1, listProducts.Count(p => p.Name == "AAA"));
}
public void GetArticles_WhenRepositoryIsEmpty_ShouldReturnEmptyList()
{
var data = new List<Article>
{}.AsQueryable();
setMock.As<IQueryable<Article>>().Setup(m => m.Provider).Returns(data.Provider);
setMock.As<IQueryable<Article>>().Setup(m => m.Expression).Returns(data.Expression);
setMock.As<IQueryable<Article>>().Setup(m => m.ElementType).Returns(data.ElementType);
setMock.As<IQueryable<Article>>().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
var articles = sut.GetArticles();
Assert.AreEqual(0, articles.Count());
}