public void TestInitialize()
{
var fixture = new Fixture();
factories = Substitute.For<Factories>();
navigator = Substitute.For<Navigator>();
stateProvider = Substitute.For<StateProvider>();
facade = Substitute.For<ReplacementBuilderAndSugarEstimatorFacade>();
clipboard = Substitute.For<Clipboard>();
messageDialog = Substitute.For<MessageDialog>();
navigation = new InsulinEditingViewModel.Navigation();
CreateSut();
insulin = fixture.Create<Insulin>();
insulin.InitializeCircumstances(new List<Guid>());
insulin.SetOwner(factories);
sugar = new Sugar();
sugar.SetOwner(factories);
factories.InsulinCircumstances.Returns(fixture.CreateMany<InsulinCircumstance>().ToList());
factories.CreateSugar().Returns(sugar);
settings = new Settings { MaxBolus = 5 };
factories.Settings.Returns(settings);
meal = fixture.Create<Meal>();
factories.Finder.FindMealByInsulin(insulin).Returns(meal);
factories.Finder.FindInsulinById(insulin.Id).Returns(insulin);
var replacementAndEstimatedSugars = new ReplacementAndEstimatedSugars();
replacementAndEstimatedSugars.EstimatedSugars = new List<Sugar>();
replacementAndEstimatedSugars.Replacement
= new Replacement { InsulinTotal = new Insulin(), Items = new List<ReplacementItem>() };
facade.GetReplacementAndEstimatedSugars(Arg.Any<Meal>(), Arg.Any<Insulin>(), Arg.Any<Sugar>())
.Returns(replacementAndEstimatedSugars);
factories.MealNames.Returns(new List<MealName>());
stateProvider.State.Returns(new Dictionary<string, object>());
}
public IList<Pattern> GetPatternsFor(Insulin insulin, Meal meal, Sugar currentBefore = null)
{
var patterns = new List<Pattern>();
finder = factories.Finder;
settings = factories.Settings;
searchedInsulin = insulin;
searchedMeal = meal;
searchedItems = meal.NormalizedItems();
searchedSugarBefore = currentBefore;
foreach (var testMeal in factories.Meals.Where(m => m != searchedMeal))
{
var mealHasMatch = testMeal.Items.Any(item =>
searchedItems.Any(searchedItem =>
item.ProductId == searchedItem.ProductId && item.Unit == searchedItem.Unit));
if (mealHasMatch)
foreach (var item in testMeal.NormalizedItems())
foreach (var searchedItem in searchedItems)
if (item.ProductId == searchedItem.ProductId && item.Unit == searchedItem.Unit)
{
this.searchedItem = searchedItem;
this.item = item;
this.meal = testMeal;
if (ConsiderPattern())
patterns.Add(BuildPattern());
}
}
return patterns;
}
public void ExportsAndImportsMealsAndMealNamesAndProductsAndCategories()
{
var meal = factories.Meals[0];
var mealName = factories.MealNames[0];
var product = factories.Products[0];
var category = factories.Categories[0];
var sut = new ExportAndImportImpl(factories);
var data = sut.Export();
factories.Meals.Clear();
factories.MealNames.Clear();
factories.Products.Clear();
factories.Categories.Clear();
var empty = new Meal();
empty.InitializeItems(new List<MealItem>());
meal.CopyItemsFrom(empty);
Assert.IsEmpty(meal.Items);
sut.Import(data);
Assert.AreEqual(meal.Id, factories.Meals[0].Id);
Assert.AreEqual(meal.Items[0].Value, factories.Meals[0].Items[0].Value);
Assert.AreEqual(mealName.Id, factories.MealNames[0].Id);
Assert.AreEqual(product.Id, factories.Products[0].Id);
Assert.AreEqual(category.Id, factories.Categories[0].Id);
sut.Import(data);
Assert.AreEqual(1, factories.Meals.Count);
Assert.AreEqual(1, factories.MealNames.Count);
Assert.AreEqual(1, factories.Products.Count);
Assert.AreEqual(1, factories.Categories.Count);
}
public void AddMeal()
{
var meal = new Meal { Id = Guid.NewGuid() };
factories.CreateMeal().Returns(meal);
var command = new JournalViewModel.AddMealCommand();
sut.Add(command);
navigator.Received().GoToMealEditing(meal.Id);
}
public Replacement GetReplacementFor(Meal meal, IList<Pattern> usingPatterns)
{
this.meal = meal;
patterns = usingPatterns;
replacement = new Replacement();
CheckPatterns();
BuildItems();
DoActions();
return replacement;
}
public void IsOlder()
{
var factories = Substitute.For<Factories>();
var meal = new Meal();
var sut = new MealViewModel(meal, factories);
Assert.IsFalse(sut.IsOlder);
sut.Date = DateViewModel.CreateNormalDate(DateTime.Now);
Assert.IsFalse(sut.IsOlder);
sut.Date = DateViewModel.CreateGroupOfOlder();
Assert.IsTrue(sut.IsOlder);
}
public ReplacementAndEstimatedSugars GetReplacementAndEstimatedSugars(Meal meal, Insulin insulin,
Sugar currentBefore)
{
var patterns = patternBuilder.GetPatternsFor(insulin, meal,
currentBefore: currentBefore);
var replacement = replacementBuilder.GetReplacementFor(meal, patterns);
var estimatedSugars = sugarEstimator.GetEstimatedSugarsAfter(meal, currentBefore,
usingReplacementItems: replacement.Items);
return new ReplacementAndEstimatedSugars
{
Replacement = replacement,
EstimatedSugars = estimatedSugars
};
}
public Dictionary<TimeSpan, List<CollectedSugar>> CollectByHour(Meal meal,
IList<ReplacementItem> replacementItems)
{
this.meal = meal;
IEnumerable<Tuple<Sugar, ReplacementItem>> sugarTuples = replacementItems
.SelectMany(replacementItem => replacementItem.Pattern.After,
(replacementItem, sugar) => new Tuple<Sugar, ReplacementItem>(sugar, replacementItem));
var collectedSugars = sugarTuples.Select(tuple =>
new CollectedSugar { Collected = GetSugarCopyWithRelativeTime(tuple), Source = tuple.Item2 });
var groupped = collectedSugars
.GroupBy(collectedSugar => new TimeSpan(collectedSugar.Collected.DateTime.Hour, 0, 0));
return groupped.ToDictionary(groupping => groupping.Key + TimeSpan.FromMinutes(Math.Round(
groupping.Average(collectedSugar => collectedSugar.Collected.DateTime.Minute))),
groupping => groupping.ToList());
}
public void TestInitialize()
{
factories = Substitute.For<Factories>();
meal = new Meal();
sut = new MealViewModel(meal, factories);
meal.SetOwner(factories);
meal.InitializeItems(new List<MealItem>());
factories.CreateMealItem().Returns(_ =>
{
var mealItem = new MealItem();
mealItem.SetOwner(factories);
return mealItem;
});
var fixture = new Fixture();
factories.Products.Returns(fixture.CreateMany<Product>(10).ToList());
factories.Finder.Returns(new FinderImpl(factories));
}
public void GetReplacementAndEstimatedSugars()
{
var patternBuilder = Substitute.For<PatternBuilder>();
var replacementBuilder = Substitute.For<ReplacementBuilder>();
var sugarEstimator = Substitute.For<SugarEstimator>();
var sut = new ReplacementBuilderAndSugarEstimatorFacadeImpl(patternBuilder, replacementBuilder,
sugarEstimator);
var meal = new Meal();
var insulin = new Insulin();
var sugar = new Sugar();
var patterns = new List<Pattern>();
var replacement = new Replacement { Items = new List<ReplacementItem>() };
var estimatedSugars = new List<Sugar>();
patternBuilder.GetPatternsFor(insulin, meal, currentBefore: sugar).Returns(patterns);
replacementBuilder.GetReplacementFor(meal, patterns).Returns(replacement);
sugarEstimator.GetEstimatedSugarsAfter(meal, sugar, replacement.Items).Returns(estimatedSugars);
var result = sut.GetReplacementAndEstimatedSugars(meal, insulin, sugar);
Assert.AreSame(replacement, result.Replacement);
Assert.AreSame(estimatedSugars, result.EstimatedSugars);
}
private void SetupMeals()
{
var meal = new Meal();
meal.SetOwner(factories);
meal.Id = Guid.NewGuid();
var mealItem = new MealItem();
mealItem.SetOwner(factories);
mealItem.Value = 100;
meal.InitializeItems(new List<MealItem> { mealItem });
factories.Meals.Returns(new List<Meal> { meal });
factories.CreateMeal().Returns(_ => { factories.Meals.Add(meal); return meal; });
}
protected void InternalCopyItemsFrom(Meal source)
{
var sourceItems = source.items;
items = sourceItems.GetItemsCopy();
}
public void CopyItemsFrom(Meal source)
{
InternalCopyItemsFrom(source);
AssignOwner();
}
public void Weigth(Meal meal, List<CollectedSugar> collectedSugars)
{
foreach (var collected in collectedSugars)
{
var pattern = collected.Source.Pattern;
// TODO: Maybe instead of just always looking at percent of energy in meal I should look at
// percent of CU when sugar is just after meal and also percent of FPU afterwards.
var mealItemsPercentOfEnergyInMeal
= pattern.For.PercentOfEnergyInMeal(meal);
var replacementMealItemsPercentOfEnergyInReplacementMeal
= pattern.Match.PercentOfEnergyInMeal(pattern.From);
collected.Weight
= mealItemsPercentOfEnergyInMeal * replacementMealItemsPercentOfEnergyInReplacementMeal;
}
}
public void FindItem()
{
var sugar = new Sugar { Id = Guid.NewGuid() };
var insulin = new Insulin { Id = Guid.NewGuid() };
var meal = new Meal { Id = Guid.NewGuid() };
factories.Sugars.Add(sugar);
factories.Insulins.Add(insulin);
factories.Meals.Add(meal);
sut.Load();
Assert.IsNull(sut.FindItem(Guid.Empty));
Assert.IsInstanceOf<SugarViewModel>(sut.FindItem(sugar.Id));
Assert.IsInstanceOf<InsulinViewModel>(sut.FindItem(insulin.Id));
Assert.IsInstanceOf<MealViewModel>(sut.FindItem(meal.Id));
}
public void TestInitialize()
{
meal = new Meal { Id = Guid.NewGuid() };
meal.InitializeItems(new List<MealItem>());
factories = Substitute.For<Factories>();
factories.Finder.FindMealById(meal.Id).Returns(meal);
factories.MealNames.Returns(new List<MealName>());
factories.MealNames.Add(new MealName { Id = Guid.NewGuid() });
factories.DefaultEntities.MealName.Returns(new MealName { Id = Guid.NewGuid() });
trial = Substitute.For<TrialViewModel>();
backNavigation = new MealEditingViewModel.BackNavigation();
messageDialog = Substitute.For<MessageDialog>();
sut = new MealEditingViewModel(factories, new BackgroundWorkerSyncFactory(), trial, backNavigation,
new MealItemEditingViewModel(), messageDialog);
sut.Navigator = Substitute.For<Navigator>();
stateProvider = Substitute.For<StateProvider>();
sut.StateProvider = stateProvider;
sut.Init(new MealEditingViewModel.Navigation { MealIdToEdit = meal.Id });
}
public IList<Sugar> GetEstimatedSugarsAfter(Meal meal, Sugar currentBefore,
IList<ReplacementItem> usingReplacementItems)
{
var collectedByHour = sugarCollector.CollectByHour(meal, usingReplacementItems);
var collectedSugars = collectedByHour.Values.SelectMany(values => values).ToList();
sugarRelator.Relate(currentBefore, collectedSugars);
sugarWeighter.Weigth(meal, collectedSugars);
var result = sugarAggregator.Aggregate(collectedByHour);
return result.Keys.ToList();
}
public MealViewModel(Meal meal, Factories factories)
{
Meal = meal;
this.factories = factories;
scores = new MealScoreSelector(this);
}
public void UsesRelatedMealIdWhenProvided()
{
var relatedMeal = new Meal { Id = Guid.NewGuid() };
navigation.RelatedMealId = relatedMeal.Id;
factories.Finder.FindMealById(relatedMeal.Id).Returns(relatedMeal);
InitializeViewModel();
var replacementAndEstimatedSugars = new ReplacementAndEstimatedSugars
{
Replacement = new Replacement
{
InsulinTotal = new Insulin { NormalBolus = 1.5f },
Items = this.replacementAndEstimatedSugars.Replacement.Items
},
EstimatedSugars = this.replacementAndEstimatedSugars.EstimatedSugars
};
facade.GetReplacementAndEstimatedSugars(relatedMeal, Arg.Any<Insulin>(), Arg.Any<Sugar>())
.Returns(replacementAndEstimatedSugars);
sut.CurrentSugar.BloodSugar = "100";
Assert.AreEqual(1.5f, sut.Calculated.Insulin.NormalBolus);
}
public byte PercentOfEnergyInMeal(Meal meal)
{
return (byte)Math.Round((double)Energy / meal.Energy * 100);
}
