public void CheckRecurringPayments_None_NewEntryForRecurring() { var repoSetup = new Mock<IPaymentRepository>(); var resultList = new List<Payment>(); var testList = new List<Payment> { new Payment { Id = 1, Amount = 99, ChargedAccountId = 2, ChargedAccount = new Account {Id = 2}, Date = DateTime.Now.AddDays(-3), RecurringPaymentId = 3, RecurringPayment = new RecurringPayment { Id = 3, Recurrence = (int) PaymentRecurrence.Daily, ChargedAccountId = 2, ChargedAccount = new Account {Id = 2}, Amount = 95 }, IsCleared = true, IsRecurring = true }, new Payment { Id = 2, Amount = 105, Date = DateTime.Now.AddDays(-3), ChargedAccountId = 2, ChargedAccount = new Account {Id = 2}, RecurringPaymentId = 4, RecurringPayment = new RecurringPayment { Id = 4, Recurrence = (int) PaymentRecurrence.Weekly, ChargedAccountId = 2, ChargedAccount = new Account {Id = 2}, Amount = 105 }, IsRecurring = true } }; repoSetup.Setup(x => x.Save(It.IsAny<Payment>())) .Callback((Payment payment) => resultList.Add(payment)); repoSetup.SetupGet(x => x.Data).Returns(new ObservableCollection<Payment>(testList)); repoSetup.Setup(x => x.LoadRecurringList(null)).Returns(testList); new RecurringPaymentManager(repoSetup.Object).CheckRecurringPayments(); resultList.Any().ShouldBeTrue(); resultList.First().Amount.ShouldBe(95); resultList.First().ChargedAccountId.ShouldBe(2); resultList.First().RecurringPaymentId.ShouldBe(3); }
public void ShouldFilterByGenre() { using (var session = _documentStore.OpenSession()) { var repository = new Repository(session); Enumerable.Range(1, 8).ToList().ForEach(i => repository.Create(new Book { Title = "Book " + i, Language = "Venda", Genre = "Poetry"})); var book1 = new Book { Title = "Book 9", Language = "Zulu", AgeRange = "0-2", Genre = "Picture Books"}; repository.Create(book1); var book2 = new Book { Title = "Book 10", Language = "Zulu", AgeRange = "3-5", Genre = "Fiction" }; repository.Create(book2); session.SaveChanges(); Assert.AreEqual(10, repository.Count<Book>()); var expectedBooks = new List<Book> { book1 }; var booksController = new BooksController(repository); var view = (ViewResult)booksController.Filter(new List<string>(), new List<string>(), new List<string> {"Picture Books"}); var filterInformation = (FilterInformation)view.Model; var actualBooks = filterInformation.BookInformations.Select(bookInformation => bookInformation.Model).ToList(); Assert.AreEqual(1, actualBooks.Count()); Assert.AreEqual(expectedBooks.First().Language, actualBooks.First().Language); Assert.AreEqual(expectedBooks.First().AgeRange, actualBooks.First().AgeRange); Assert.AreEqual(expectedBooks.First().Genre, actualBooks.First().Genre); Assert.AreEqual("Picture Books", filterInformation.Genres.First()); } }
public void PropertiesTest() { var viewModel = Container.GetExportedValue<EmailListViewModel>(); List<Email> emails = new List<Email>(); emails.Add(new Email()); emails.Add(new Email()); Assert.IsNull(viewModel.Emails); AssertHelper.PropertyChangedEvent(viewModel, x => x.Emails, () => viewModel.Emails = emails); Assert.AreEqual(emails, viewModel.Emails); Assert.IsNull(viewModel.SelectedEmail); AssertHelper.PropertyChangedEvent(viewModel, x => x.SelectedEmail, () => viewModel.SelectedEmail = emails.First()); Assert.AreEqual(emails.First(), viewModel.SelectedEmail); var emptyCommand = new DelegateCommand(() => { }); Assert.IsNull(viewModel.DeleteEmailCommand); AssertHelper.PropertyChangedEvent(viewModel, x => x.DeleteEmailCommand, () => viewModel.DeleteEmailCommand = emptyCommand); Assert.AreEqual(emptyCommand, viewModel.DeleteEmailCommand); Assert.AreEqual("", viewModel.FilterText); AssertHelper.PropertyChangedEvent(viewModel, x => x.FilterText, () => viewModel.FilterText = "abc"); Assert.AreEqual("abc", viewModel.FilterText); }
public void PropertiesTest() { var viewModel = Container.GetExportedValue<ContactListViewModel>(); List<Contact> contacts = new List<Contact>() { new Contact(), new Contact() }; Assert.IsNull(viewModel.Contacts); AssertHelper.PropertyChangedEvent(viewModel, x => x.Contacts, () => viewModel.Contacts = contacts); Assert.AreEqual(contacts, viewModel.Contacts); Assert.IsNull(viewModel.SelectedContact); AssertHelper.PropertyChangedEvent(viewModel, x => x.SelectedContact, () => viewModel.SelectedContact = contacts.First()); Assert.AreEqual(contacts.First(), viewModel.SelectedContact); var emptyCommand = new DelegateCommand(() => { }); Assert.IsNull(viewModel.DeleteContactCommand); AssertHelper.PropertyChangedEvent(viewModel, x => x.DeleteContactCommand, () => viewModel.DeleteContactCommand = emptyCommand); Assert.AreEqual(emptyCommand, viewModel.DeleteContactCommand); Assert.AreEqual("", viewModel.FilterText); AssertHelper.PropertyChangedEvent(viewModel, x => x.FilterText, () => viewModel.FilterText = "abc"); Assert.AreEqual("abc", viewModel.FilterText); }
public void GenericComparerAsIComparer() { List<int> ints = new List<int>(new[] { 10, 5, 2, 23, 7, 5, 3, 45, 23, 64, 25 }); ints.Sort(new GenericComparer<int>()); Assert.AreEqual(ints.Min(), ints.First()); Assert.AreEqual(ints.Max(), ints.Last()); ints.Sort(new GenericComparer<int>((i, i1) => Math.Sin(i) > Math.Sin(i1) ? -1 : Math.Sin(i) < Math.Sin(i1) ? 1 : 0)); Assert.AreEqual(64, ints.First()); Assert.AreEqual(5, ints.Last()); }
public void IndexShouldRenderInCorrectly() { var autoMapperConfig = new AutoMapperConfig(); autoMapperConfig.Execute(typeof(UserController).Assembly); List<Platoon> Platoons = new List<Platoon>() { new Platoon() { Name = "Test", Id = 2, PlatoonCommander = new User() { FirstName = "Asd", LastName = "Asd", Id = "asd" } } }; var usersServiceMock = new Mock<IUsersService>(); usersServiceMock.Setup(x => x.GetById(It.IsAny<string>())) .Returns(new User { FirstName = "Test", SquadId = 1 }); var squadsServiceMock = new Mock<ISquadsService>(); squadsServiceMock.Setup(x => x.GetById(It.IsAny<int>())) .Returns(new Squad { Name = "Test" }); var platoonsServiceMock = new Mock<IPlatoonsService>(); platoonsServiceMock.Setup(x => x.GetAll()) .Returns(new List<Platoon>() { new Platoon() { Name = "Test", Id = 1, PlatoonCommander = new User() { FirstName = "Asd", LastName = "Asd", Id = "asd" } } }.AsQueryable()); var controller = new PlatoonAdministrationController(platoonsServiceMock.Object, squadsServiceMock.Object, usersServiceMock.Object); controller.WithCallTo(x => x.Index()) .ShouldRenderView("Index") .WithModel<PlatoonIndexModel>( viewModel => { Assert.AreNotEqual(Platoons.First().Id, viewModel.Platoons.First().Id); }).AndNoModelErrors(); }
public void AddOrderEntryTest() { List<Order> orders = new List<Order>(); List<BookType> bookTypeList = new List<BookType>(); NMock.Actions.InvokeAction saveOrUpdateAction = new NMock.Actions.InvokeAction(() => orders.Add(order)); orderManagementDaoMock.Expects.Any.MethodWith(x => x.SaveOrUpdate(order)).Will(saveOrUpdateAction); bool isInList = false; order.OrderEntries = new List<OrderEntry>(); oms.CreateNewOrder(order); orderInformationDaoMock.Expects.Any.MethodWith(x => x.GetOrderById(order.Id)).WillReturn(orders.First(x => x.Id == order.Id)); getOrder = ois.GetOrderById(order.Id); NMock.Actions.InvokeAction saveBookType = new NMock.Actions.InvokeAction(new Action(() => bookTypeList.Add(testBook))); storehouseManagementDaoMock.Expects.Any.MethodWith(x => x.SaveBookType(testBook)).Will(saveBookType); sms.SaveBookType(testBook); booksInformationServiceMock.Expects.Any.MethodWith(x => x.GetBookTypeById(testBook.Id)).WillReturn(bookTypeList.FirstOrDefault(x => x.Id == testBook.Id)); oms.AddOrderEntry(order, testBook.Id, TEST_AMOUNT); foreach (var item in order.OrderEntries) { if (item.Amount.Equals(TEST_AMOUNT) && item.BookType.Equals(testBook) && item.Price.Equals(testBook.Price)) isInList = true; }; Assert.IsTrue(isInList); }
public void Behaviour_should_also_work_with_method_calls() { var SUT = new YakShayBus(); SUT.RegisterType<SomeTestClass>(); var resultingMessages = new List<Message>(); var msg = new { SomePartOfTheUID = "A", AnotherPartOfTheUID = "B", SomeFlag = true, SomeString = "ABC" }; SUT.Handle( Message.FromAction(x => x.MethodToInvoke(SomePartOfTheUID: "A", AnotherPartOfTheUID: "B", SomeFlag: true, SomeString: "ABC")) , x => resultingMessages.Add(x)); resultingMessages.Count.ShouldBe(1); resultingMessages.First().ToFriendlyString().ShouldBe(new Message("OnMethodWasInvoked", new { SomePartOfTheUID = "A", AnotherPartOfTheUID = "B", SomeString = "ABC", AnotherInt = 123 }).ToFriendlyString()); }
public void Service_Map_ExpenseReport_ExpenseReportModel_CalculateTotal() { // Arrange int id = 1; IMap<ExpenseReport> map = new Map<ExpenseReport>(); List<ExpenseReport> reports = new List<ExpenseReport>() { new ExpenseReport { Id = 1, Title = "Report One", ExpenseItems = new List<ExpenseItem>() { new ExpenseItem { Id = 1, ExpenseAmount = 12.34m }, new ExpenseItem { Id = 1, ExpenseAmount = 12.34m } } } }; decimal sum = reports.First().ExpenseItems.Sum(x => x.ExpenseAmount); Mock<ExpenseContext> mockContext = new ExpenseContextBuilder() .WithSet<ExpenseReport>(x => x.ExpenseReports, reports.AsQueryable()) .Build(); // Act ExpenseReportQueryService service = new ExpenseReportQueryService(mockContext.Object, map); var result = service.GetExpenseReportById(id); // Assert Assert.AreEqual(sum, result.ExpenseTotal); }
public async Task TestMaxItemCount() { var nextItem = 0; var pool = new PipelinedPool<int>(() => TaskPort.FromResult(++nextItem), null, new PipelinedPoolOptions { MaxRequestsPerItem = 10, TargetItemCount = 2, }); var items = new List<IPooledItem<int>>(); for (int i = 0; i < 20; ++i) { var task = pool.Borrow(); Assert.AreEqual(true, task.IsCompleted); var item = await task; items.Add(item); } Assert.AreEqual(20, items.Count); Assert.AreEqual(10, items.Count(v => v.Item == 1)); Assert.AreEqual(10, items.Count(v => v.Item == 2)); var waiter = pool.Borrow(); Assert.AreEqual(false, waiter.IsCompleted); items.First().Dispose(); Assert.AreEqual(true, waiter.IsCompleted); foreach (var item in items.Skip(1)) { item.Dispose(); } waiter.Result.Dispose(); }
public void Can_Add_Order_Via_Controller() { //ARRANGE List<Order> orders = new List<Order>(); Mock<IOrderRepository> mockOrder = new Mock<IOrderRepository>(); mockOrder.Setup(m => m.AddOrder(It.IsAny<Order>())).Returns((Order order) => { if (orders.LastOrDefault() == null) { order.OrderID = 1; } else { order.OrderID = orders.Last().OrderID + 1; } orders.Add(order); return true; }); mockOrder.Setup(m => m.GetOrder(It.IsAny<int>())).Returns((int id) => { return orders.Where(o => o.OrderID == id).FirstOrDefault(); }); OrderController target = new OrderController(mockOrder.Object); //ACT target.Index(new Order { Address = "lalala st.", Name = "lala", OrderDate = DateTime.Now }); target.Index(new Order { Address = "dadada st.", Name = "dada", OrderDate = DateTime.Now }); //ASSERT Assert.IsNotNull(orders.Last()); Assert.AreEqual(orders.Last().Name, "dada"); Assert.AreEqual(orders.Last().OrderID, orders.First().OrderID + 1); }
public void EtwFileSourceTest() { var observable = EtwObservable.FromFiles(FileName); var source = new TimeSource<EtwNativeEvent>(observable, e => e.TimeStamp); var parsed = from p in source where p.Id == 2 select p.TimeStamp; var buf = parsed.Take(13).Buffer(TimeSpan.FromSeconds(1), source.Scheduler); var list = new List<IList<DateTimeOffset>>(); ManualResetEvent completed = new ManualResetEvent(false); buf.Subscribe( t => list.Add(t), ()=>completed.Set()); source.Connect(); completed.WaitOne(); Assert.AreEqual(2, list.Count()); Assert.AreEqual(7, list.First().Count); Assert.AreEqual(6, list.Skip(1).First().Count); }
public void BookListViewModelBooksTest() { List<Book> books = new List<Book>() { new Book() { Title = "The Fellowship of the Ring" }, new Book() { Title = "The Two Towers" } }; MockBookListView bookListView = new MockBookListView(); IList<BookDataModel> bookDataModels = new SynchronizingCollection<BookDataModel, Book>(books, b => new BookDataModel(b, dummyCommand)); BookListViewModel bookListViewModel = new BookListViewModel(bookListView) { Books = bookDataModels }; Assert.AreEqual(bookDataModels, bookListViewModel.Books); Assert.IsNull(bookListViewModel.SelectedBook); Assert.IsFalse(bookListViewModel.SelectedBooks.Any()); // Select the first book AssertHelper.PropertyChangedEvent(bookListViewModel, x => x.SelectedBook, () => bookListViewModel.SelectedBook = bookDataModels.First()); Assert.AreEqual(books.First(), bookListViewModel.SelectedBook.Book); bookListViewModel.AddSelectedBook(bookDataModels.First()); Assert.IsTrue(bookListViewModel.SelectedBooks.SequenceEqual(new[] { bookDataModels.First() })); // Select both books bookListViewModel.AddSelectedBook(bookDataModels.Last()); Assert.IsTrue(bookListViewModel.SelectedBooks.SequenceEqual(bookDataModels)); }
private void SeedMeals(RestaurantsContext context, List<MealType> mealTypes) { var meals = new List<Meal>() { new Meal() { Name = "French salad", Price = 5.40m, Restaurant = new Restaurant() { Name = "Pri baba", Owner = context.Users.FirstOrDefault(u => u.UserName == TestUserUsername), Town = new Town() {Name = "Bracigovo"} }, Type = mealTypes.First() } }; foreach (var meal in meals) { context.Meals.Add(meal); } context.SaveChanges(); }
public void ReaderWithHeaderTest() { using (var reader = new CsvReader<StockValue>( "csv-samples/IBM.csv", containsHeader: true, separator:',', dateTimeFormat: "yyyyMMdd")) { var stockValues = new List<StockValue>(); StockValue value = null; while ((value = reader.ReadObject()) != null) { if (value == null) throw new NullReferenceException(); stockValues.Add(value); } Assert.AreEqual(473, stockValues.Count); var firstValue = stockValues.First(); var lastValue = stockValues.Last(); Assert.AreEqual(new DateTime(2014, 1, 2), firstValue.DateTime); Assert.AreEqual(185.529999M, firstValue.Close); Assert.AreEqual(new DateTime(2015, 11, 16), lastValue.DateTime); Assert.AreEqual(133.710007M, lastValue.Close); } }
public void FailedCallbackFires() { List<int> order = new List<int> { 1, 2, 3, 4, 5 }; List<int> errors = new List<int>(); ThrottledProcessor<int> queue = new ThrottledProcessor<int>( 100, (int value) => { throw new InvalidOperationException("This is the message"); }, (int value) => Assert.Fail("The success path should never be called"), (int value, Exception ex) => { Assert.AreEqual("This is the message", ex.Message); errors.Add(value); }); foreach (int i in order) { queue.Add(i); } while (queue.Length > 0) { Thread.Sleep(100); } foreach (int expected in order) { int actual = errors.First(); errors.RemoveAt(0); Assert.AreEqual(expected, actual, "The items were failed in the wrong order"); } }
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 Document_Delete_Heirarchy_Permanently() { var docList = new List<Document>(); var total = 20; var dt = new DocumentType(GetExistingDocTypeId()); //allow the doc type to be created underneath itself dt.AllowedChildContentTypeIDs = new int[] { dt.Id }; dt.Save(); //create 20 content nodes underneath each other, this will test deleting with heirarchy as well var lastParentId = -1; for (var i = 0; i < total; i++) { var newDoc = Document.MakeNew(i.ToString() + Guid.NewGuid().ToString("N"), dt, m_User, lastParentId); docList.Add(newDoc); Assert.IsTrue(docList[docList.Count - 1].Id > 0); lastParentId = newDoc.Id; } //now delete all of them permanently, since they are nested, we only need to delete one docList.First().delete(true); //make sure they are all gone foreach (var d in docList) { Assert.IsFalse(Document.IsNode(d.Id)); } }
public void ShortSpam() { InitializeDatastore.Run(); var testList = new List<Tuple<string, bool>> { new Tuple<string, bool> ("a somewhat short message1", false), new Tuple<string, bool> ("Waterboyy I'm not, leblanc is just annoying to play against", false), new Tuple<string, bool> ("i see you're a master theory crafter", false), new Tuple<string, bool> ("a somewhat short message2", false), new Tuple<string, bool> ("a somewhat short message3", true), }; var total = new List<Message>(); foreach (var tuple in testList) { total.Add(new PublicMessage(tuple.Item1)); var op = total.First(); var context = total.Skip(1).ToList(); var testCase = new Banner(op, null, context).SelfSpam(); if (tuple.Item2) { Assert.IsNotNull(testCase); } else { Assert.IsNull(testCase); } } }
public void WithDetails() { var message = new Message("Test"); List<Message> diffs = new List<Message>(); // will be notified on sync only message.Init("Field", 1, 2, 3); // set up anonymous watcher, simply recording all changes message.ChangedWithDetails += (orig, diff) => { diffs.Add(diff); }; Assert.IsTrue(message.IsChanged); Assert.AreEqual(0, diffs.Count); var hasChanged = message.Commit(this); Assert.IsTrue(hasChanged); // notification received Assert.AreEqual(1, diffs.Count); // change corresponds Assert.AreEqual(message.Topic, diffs.First().Topic); Assert.AreEqual((Bin<int>)message["Field"], diffs.First()["Field"]); Assert.IsFalse(message.IsChanged); // sync again, should stay silent this time hasChanged = message.Commit(this); Assert.IsFalse(hasChanged); Assert.AreEqual(1, diffs.Count); message.Topic = "ChangedTopic"; message.Init("Other", 1.68, 3.14); // sync again, check changes hasChanged = message.Commit(this); Assert.IsTrue(hasChanged); Assert.AreEqual(2, diffs.Count); // change corresponds Assert.AreEqual(message.Topic, diffs.Last().Topic); Assert.AreEqual((Bin<double>)message["Other"], diffs.Last()["Other"]); // really only "Other" Assert.AreEqual(1, diffs.Last().Fields.Count()); }
public void TestOfSurroundWithDigits() { string word = "firstWord"; List<string> list = new List<string>(); StringUtilities.SurroundWithDigits(word,list,1); Assert.AreEqual(100,list.Count); Assert.AreEqual("0firstWord0",list.First()); Assert.AreEqual("9firstWord9", list.Last()); }
public void ShouldReturnRoleItems() { var expected = new List<string>() { "ItemOne", "ItemTwo" }; var actual = _dashboardMappingsProvider.GetRoleItems("Admin"); Assert.AreEqual(expected.First(), actual.First()); Assert.AreEqual(expected.Last(), actual.Last()); }
public SkyNet(List<SkyNetCell> nodes, int InitialId) { ResetNodes(nodes); _nodes = nodes; _startNode = _nodes.First(x => x.Id == InitialId); _endNode = null; }
//[TestMethod] //[TestCategory("ProductNoSqlRepository, when List is executed")] public void should_return_a_list_of_products() { // given var expected = new List<IProduct>(); foreach (var product in mockProducts) { expected.Add(productRepo.Set(product)); } // when var actual = productRepo.List(20, 0); // then actual.Count().Should().BeGreaterThan(2); actual.First().Uid.ShouldBeEquivalentTo(expected.First().Uid); actual.First().Title.ShouldBeEquivalentTo(expected.First().Title); actual.First().Description.ShouldBeEquivalentTo(expected.First().Description); }
public void Initialize() { _employees = new List<Employee> { new Employee {FirstName = "Andy", FamilyName = "Dee"}, new Employee {FirstName = "Johnny", FamilyName = "Zor"}, new Employee {FirstName = "Zardoz", FamilyName = "Ohm"} }; SettingsHelper.SaveConnectionString("Data Source=YOGER-SUPERMAN\\SQLEXPRESS;Initial Catalog=HolidayCalendar;Integrated Security=True;Connect Timeout=5"); _holidayCalendar = new HolidayCalendarViewModel(_employees.First(), new EmployeeRepositoryStub(_employees)); }
public void TestClosest() { var list = new List<Vector<string, double>> { new Vector<string, double> {{"x", 1}}, new Vector<string, double> {{"y", 1}} }; var v = new Vector<string, double> {{"x", 2}, {"y", 1}}; var closest = v.Closest(new Set<Vector<string, double>>(list)); closest.Equals(list.First()).ShouldBeTrue(); }
/// <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 async Task GetShows() { var epg = new EpGuidesProvider(); var shows = new List<IShowInfo>(); await epg.GetShowsAsync(shows.Add, CancellationToken.None); var episodes = new List<IEpisodeInfo>(); await epg.GetEpisodesAsync(shows.First(), episodes.Add, CancellationToken.None); }
public void TestCircularRefs() { var list = new List<TestMan> { new TestMan {Name = "Serg", Age = 34}, new TestMan {Name = "Julia", Age = 32} }; list.First().Parent = list.Last(); list.Last().Parent = list.First(); _storage.Put("list", list); var result = _storage.Get<List<TestMan>>("list"); Assert.IsNotNull(result); Assert.AreEqual(2, result.Count); Assert.AreEqual("Serg", result.First().Name); Assert.AreEqual(34, result.First().Age); Assert.AreEqual(result.First(), result.Last().Parent); Assert.AreEqual(result.Last(), result.First().Parent); }
public void TestCompare() { var summary1 = Summary("a"); var summary2 = Summary("b"); var summaries = new List<GroupRootSummary> { summary2, summary1 }; summaries.Sort(); Assert.AreEqual("a", summaries.First().IndicatorName); }