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);
}
