예제 #1
0
        public void FoodItemInvalidFoodGroup()
        {
            FoodItem foodItem = new FoodItem( Guid.NewGuid(), "Apple", "It fell on Newton's head.", 60 );

             Assert.IsNotNull( foodItem.ID );
             Assert.AreEqual( "Apple", foodItem.Name );
             Assert.AreEqual( "It fell on Newton's head.", foodItem.Description );
             Assert.AreEqual( 60, foodItem.CaloriesPerServing );
             Assert.AreEqual( 0, foodItem.FoodGroupsPerServing.Count );
             Assert.IsFalse( foodItem.IsValid );
             Assert.IsNull( foodItem["Name"] );
             Assert.AreEqual( Messages.Error_No_FoodGroups, foodItem["FoodGroupsPerServing"] );
             Assert.IsNull( foodItem["CaloriesPerServing"] );

             // Assign a food group that is valid and one that is not valid
             FoodGroup foodGroup = new FoodGroup( Guid.NewGuid(), "Fruit", "" );
             foodItem.FoodGroupsPerServing.Add( new Serving<FoodGroup>( foodGroup, 1 ) );
             foodItem.FoodGroupsPerServing.Add( new Serving<FoodGroup>( null, 0 ) );
             Assert.IsFalse( foodItem.IsValid );
             Assert.IsNull( foodItem["Name"] );
             // Should contain two messages seperated by double spaces.
             Assert.IsTrue( foodItem["FoodGroupsPerServing"].Contains( Messages.Error_No_Quantity ) );
             Assert.IsTrue( foodItem["FoodGroupsPerServing"].Contains( Messages.Error_No_ServingItem ) );
             Assert.AreEqual( Messages.Error_No_ServingItem.Length + Messages.Error_No_Quantity.Length + 2, foodItem["FoodGroupsPerServing"].Length );
             Assert.IsNull( foodItem["CaloriesPerServing"] );

             foodItem.FoodGroupsPerServing.RemoveAt( 1 );
             Assert.IsTrue( foodItem.IsValid );
             Assert.IsNull( foodItem["Name"] );
             Assert.IsNull( foodItem["FoodGroupsPerServing"] );
             Assert.IsNull( foodItem["CaloriesPerServing"] );
        }
        public void FoodItemAddedToChildrenWhenAddedToRepository()
        {
            var configurationMock = new Mock<IConfiguration>();
             configurationMock.Setup( x => x.DataSource ).Returns( DataSourceType.XMLFile );
             configurationMock.Setup( x => x.FileName ).Returns( FullTestData.DataFileName );

             FullTestData.Reset();
             DataRepository dataRepository = new DataRepository( configurationMock.Object );

             FoodItemNodeViewModel foodItemNodeViewModel = new FoodItemNodeViewModel( dataRepository, null );

             Int32 originalChildCount = foodItemNodeViewModel.Children.Count;

             FoodItem newFoodItem = new FoodItem( Guid.NewGuid(), "New Food Item", "Some Description", 92 );
             newFoodItem.FoodGroupsPerServing.Add( new Serving<FoodGroup>( dataRepository.GetAllFoodGroups()[0], 1 ) );
             dataRepository.SaveItem( newFoodItem );
             Assert.AreEqual( originalChildCount + 1, foodItemNodeViewModel.Children.Count );

             foreach (ClickableTreeNodeViewModel node in foodItemNodeViewModel.Children)
             {
            FoodItem foodItem = dataRepository.GetFoodItem( (Guid)node.Parameter );
            Assert.IsNotNull( foodItem );
            Assert.AreEqual( foodItem.Name, node.Name );
             }
        }
예제 #3
0
        public void DeleteFoodItem()
        {
            var configurationMock = new Mock<IConfiguration>();
             configurationMock.Setup( x => x.DataSource ).Returns( DataSourceType.XMLFile );
             configurationMock.Setup( x => x.FileName ).Returns( FullTestData.DataFileName );

             FullTestData.Reset();
             HealthTracker.DataRepository.Services.DataRepository dataRepository = new HealthTracker.DataRepository.Services.DataRepository( configurationMock.Object );

             // Make a deep copy of a food item.
             FoodItem fruitSalad = new FoodItem();
             fruitSalad.InitializeData( dataRepository.FindFoodItem( f => f.Name == "Fruit Salad" ) );

             // Delete the food item.  Show that the food item has been deleted, but none of the
             // other data repository items have not been effected.
             Int32 origFoodGroupCount = dataRepository.GetAllFoodGroups().Count;
             Int32 origFoodItemCount = dataRepository.GetAllFoodItems().Count;
             Int32 origMealTypeCount = dataRepository.GetAllMealTypes().Count;
             Int32 origMealTemplateCount = dataRepository.GetAllMealTemplates().Count;
             Int32 origMealCount = dataRepository.GetAllMeals().Count;
             dataRepository.Remove( fruitSalad );
             Assert.AreEqual( origFoodGroupCount, dataRepository.GetAllFoodGroups().Count );
             Assert.AreEqual( origFoodItemCount - 1, dataRepository.GetAllFoodItems().Count );
             Assert.AreEqual( origMealTypeCount, dataRepository.GetAllMealTypes().Count );
             Assert.AreEqual( origMealTemplateCount, dataRepository.GetAllMealTemplates().Count );
             Assert.AreEqual( origMealCount, dataRepository.GetAllMeals().Count );
             Assert.IsNotNull( fruitSalad.ID );
             Assert.IsNull( dataRepository.FindFoodItem( f => f.ID == fruitSalad.ID ) );
        }
예제 #4
0
        public void FoodItemDefault()
        {
            FoodItem foodItem = new FoodItem();

             Assert.IsNotNull( foodItem.ID );
             Assert.IsNull( foodItem.Name );
             Assert.IsNull( foodItem.Description );
             Assert.AreEqual( 0, foodItem.CaloriesPerServing );
             Assert.AreEqual( 0, foodItem.FoodGroupsPerServing.Count );
             Assert.IsFalse( foodItem.IsValid );
             Assert.AreEqual( Messages.Error_No_Name, foodItem["Name"] );
             Assert.AreEqual( Messages.Error_No_FoodGroups, foodItem["FoodGroupsPerServing"] );
             Assert.IsNull( foodItem["CaloriesPerServing"] );

             // Assign a name
             foodItem.Name = "Fred";
             Assert.IsFalse( foodItem.IsValid );
             Assert.IsNull( foodItem["Name"] );
             Assert.AreEqual( Messages.Error_No_FoodGroups, foodItem["FoodGroupsPerServing"] );
             Assert.IsNull( foodItem["CaloriesPerServing"] );

             // Assign a food group
             FoodGroup foodGroup = new FoodGroup( Guid.NewGuid(), "Vegetable", "" );
             foodItem.FoodGroupsPerServing.Add( new Serving<FoodGroup>( foodGroup, 1 ) );
             Assert.IsTrue( foodItem.IsValid );
             Assert.IsNull( foodItem["Name"] );
             Assert.IsNull( foodItem["FoodGroupsPerServing"] );
             Assert.IsNull( foodItem["CaloriesPerServing"] );
        }
        public void FoodItemAddedToViewModelWhenAddedToRepository()
        {
            var data = new MockData();
             var dataRespositoryMock = CreateMockDataRepository( data.Foods() );

             var viewModel = new AllFoodItemsViewModel( dataRespositoryMock.Object );
             var food = new FoodItem( Guid.NewGuid(), "New Type", "For a unit test", 42.0M );
             data.Foods().Add( food );
             dataRespositoryMock.Raise( e => e.ItemAdded += null, new RepositoryObjectEventArgs( food ) );

             AssertViewModelContents( viewModel, data.Foods() );
        }
예제 #6
0
        public void InitializeData()
        {
            FoodGroup fruit = new FoodGroup( Guid.NewGuid(), "Fruit", "" );
             FoodGroup meat = new FoodGroup( Guid.NewGuid(), "Meat", "" );
             FoodGroup vegitable = new FoodGroup( Guid.NewGuid(), "Vegetable", "" );
             FoodGroup dairy = new FoodGroup( Guid.NewGuid(), "Dairy", "" );
             FoodGroup grain = new FoodGroup( Guid.NewGuid(), "Grain", "" );
             MealType lunch = new MealType( Guid.NewGuid(), "Lunch", "", DateTime.Now, false );
             MealType snack = new MealType( Guid.NewGuid(), "Snack", "", DateTime.Now, false );
             DateTime currentDateTime = DateTime.Now;

             FoodItem hamburger = new FoodItem( Guid.NewGuid(), "Hamburger", "", 300 );
             hamburger.FoodGroupsPerServing.Add( new Serving<FoodGroup>( grain, 2 ) );
             hamburger.FoodGroupsPerServing.Add( new Serving<FoodGroup>( meat, 1 ) );

             FoodItem glassOfMilk = new FoodItem( Guid.NewGuid(), "Glass of Milk", "", 90 );
             glassOfMilk.FoodGroupsPerServing.Add( new Serving<FoodGroup>( dairy, 1 ) );

             FoodItem babyCarrots = new FoodItem( Guid.NewGuid(), "Baby Carrots", "", 40 );
             babyCarrots.FoodGroupsPerServing.Add( new Serving<FoodGroup>( vegitable, 1 ) );

             MealTemplate sourceMealTemplate = new MealTemplate( Guid.NewGuid(), lunch, currentDateTime, "Test Meal", "This is a test" );
             sourceMealTemplate.FoodItemServings.Add( new Serving<FoodItem>( hamburger, 1 ) );
             sourceMealTemplate.FoodItemServings.Add( new Serving<FoodItem>( glassOfMilk, 2 ) );
             sourceMealTemplate.FoodItemServings.Add( new Serving<FoodItem>( babyCarrots, 1.5M ) );

             MealTemplate mealTemplate = new MealTemplate();
             Assert.AreNotEqual( sourceMealTemplate.ID, mealTemplate.ID );

             mealTemplate.InitializeData( sourceMealTemplate );
             Assert.AreEqual( sourceMealTemplate.ID, mealTemplate.ID );
             Assert.AreEqual( sourceMealTemplate.Name, mealTemplate.Name );
             Assert.AreEqual( sourceMealTemplate.Description, mealTemplate.Description );
             Assert.AreEqual( sourceMealTemplate.Calories, mealTemplate.Calories );
             Assert.AreEqual( sourceMealTemplate.FoodGroupServings.Count, mealTemplate.FoodGroupServings.Count );
             Assert.AreEqual( sourceMealTemplate.FoodItemServings.Count, mealTemplate.FoodItemServings.Count );

             mealTemplate.FoodItemServings[0].Quantity += 1;
             Assert.AreNotEqual( sourceMealTemplate.Calories, mealTemplate.Calories );

             // Create a new mealTemplate template that is just baby carrots (kind of a snack)
             sourceMealTemplate = new MealTemplate( Guid.NewGuid(), snack, DateTime.Now, "Snack", "This is a snack" );
             sourceMealTemplate.FoodItemServings.Add( new Serving<FoodItem>( babyCarrots, 2.5M ) );

             mealTemplate.InitializeData( sourceMealTemplate );
             Assert.AreEqual( sourceMealTemplate.ID, mealTemplate.ID );
             Assert.AreEqual( sourceMealTemplate.Name, mealTemplate.Name );
             Assert.AreEqual( sourceMealTemplate.Description, mealTemplate.Description );
             Assert.AreEqual( sourceMealTemplate.Calories, mealTemplate.Calories );
             Assert.AreEqual( sourceMealTemplate.FoodGroupServings.Count, mealTemplate.FoodGroupServings.Count );
             Assert.AreEqual( sourceMealTemplate.FoodItemServings.Count, mealTemplate.FoodItemServings.Count );
        }
예제 #7
0
        public void FoodItemIDNameDescriptionCalories()
        {
            FoodItem foodItem = new FoodItem( new Guid( "5326e353-fb06-41c6-a30e-e75a9f1efdc6" ), "Orange", "You're round and juicy and sweet!", 40 );

             Assert.AreEqual( new Guid( "5326e353-fb06-41c6-a30e-e75a9f1efdc6" ), foodItem.ID );
             Assert.AreEqual( "Orange", foodItem.Name );
             Assert.AreEqual( "You're round and juicy and sweet!", foodItem.Description );
             Assert.AreEqual( 40, foodItem.CaloriesPerServing );
             Assert.AreEqual( 0, foodItem.FoodGroupsPerServing.Count );
             Assert.IsFalse( foodItem.IsValid );
             Assert.IsNull( foodItem["Name"] );
             Assert.AreEqual( Messages.Error_No_FoodGroups, foodItem["FoodGroupsPerServing"] );
             Assert.IsNull( foodItem["CaloriesPerServing"] );

             // Assign a food group
             FoodGroup foodGroup = new FoodGroup( Guid.NewGuid(), "Fruit", "" );
             foodItem.FoodGroupsPerServing.Add( new Serving<FoodGroup>( foodGroup, 1 ) );
             Assert.IsTrue( foodItem.IsValid );
             Assert.IsNull( foodItem["Name"] );
             Assert.IsNull( foodItem["FoodGroupsPerServing"] );
             Assert.IsNull( foodItem["CaloriesPerServing"] );
        }
예제 #8
0
        public void CannotSaveAfterFoodItemModificationSaved()
        {
            var dataRepositoryMock = new Mock<IDataRepository>();

             dataRepositoryMock.Setup( x => x.GetAllFoodItems() )
            .Returns( new ReadOnlyCollection<FoodItem>( new List<FoodItem>() ) );
             dataRepositoryMock.Setup( x => x.GetAllMealTypes() )
            .Returns( new ReadOnlyCollection<MealType>( new List<MealType>() ) );

             var foodGroupOne = new FoodGroup( Guid.NewGuid(), "Food Group One", "" );
             var foodGroupTwo = new FoodGroup( Guid.NewGuid(), "Food Group Two", "" );

             var foodItemOne = new FoodItem( Guid.NewGuid(), "Food Item #1", "", 100 );
             foodItemOne.FoodGroupsPerServing.Add( new Serving<FoodGroup>( foodGroupOne, 1.5M ) );

             var foodItemTwo = new FoodItem( Guid.NewGuid(), "Food Item #2", "", 150 );
             foodItemTwo.FoodGroupsPerServing.Add( new Serving<FoodGroup>( foodGroupTwo, 2.25M ) );

             var meal = new Meal( Guid.NewGuid(), new MealType( Guid.NewGuid(), "Test", "", DateTime.Now, false ), DateTime.Now, "Test Meal", "This is a test" );
             meal.FoodItemServings.Add( new Serving<FoodItem>( foodItemOne, 1 ) );
             meal.FoodItemServings.Add( new Serving<FoodItem>( foodItemTwo, 2 ) );

             dataRepositoryMock.Setup( x => x.GetMeal( meal.ID ) ).Returns( meal );
             dataRepositoryMock.Setup( x => x.Contains( meal ) ).Returns( true );

             var viewModel = CreateViewModelForMeal( meal, dataRepositoryMock );

             Assert.IsFalse( viewModel.IsDirty );
             Assert.IsFalse( viewModel.SaveCommand.CanExecute( null ) );

             viewModel.FoodItemServings[0].Quantity += 1.5M;
             Assert.IsTrue( viewModel.IsDirty );
             Assert.IsTrue( viewModel.SaveCommand.CanExecute( null ) );

             viewModel.SaveCommand.Execute( null );
             Assert.IsFalse( viewModel.IsDirty );
             Assert.IsFalse( viewModel.SaveCommand.CanExecute( null ) );
        }
        public void CannotDeleteFoodItemIfUsed()
        {
            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>();

             var foodItem = new FoodItem( Guid.NewGuid(), "Test", "This is a test", 90.5M );
             foodItem.FoodGroupsPerServing.Add( new Serving<FoodGroup>( new FoodGroup( Guid.NewGuid(), "test", "test" ), 1.5M ) );

             dataRepositoryMock.Setup( x => x.Contains( foodItem ) ).Returns( true );
             dataRepositoryMock.Setup( x => x.ItemIsUsed( foodItem ) ).Returns( true );
             dataRepositoryMock.Setup( x => x.GetFoodItem( foodItem.ID ) ).Returns( foodItem );
             dataRepositoryMock
            .Setup( x => x.GetAllFoodGroups() )
            .Returns( new ReadOnlyCollection<FoodGroup>( new List<FoodGroup>() ) );

             var viewModel = new FoodItemViewModel( dataRepositoryMock.Object, regionManagerMock.Object, interactionServiceMock.Object, loggerMock.Object );
             var navigationContext =
            new NavigationContext( regionNavigationServiceMock.Object, new Uri( "FoodItem?ID=" + foodItem.ID.ToString(), UriKind.Relative ) );
             viewModel.OnNavigatedTo( navigationContext );

             // 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.IsFalse( viewModel.DeleteCommand.CanExecute( null ) );
             dataRepositoryMock.VerifyAll();
             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 ExistingFoodItemViewModelIsNotNew()
        {
            var loggerMock = new Mock<ILoggerFacade>();
             var regionNavigationServiceMock = new Mock<IRegionNavigationService>();
             var regionManagerMock = new Mock<IRegionManager>();
             var dataRepositoryMock = new Mock<IDataRepository>();
             var interactionServiceMock = new Mock<IInteractionService>();

             var foodItem = new FoodItem( Guid.NewGuid(), "Test Food Item", "", 420 );

             dataRepositoryMock.Setup( x => x.GetAllFoodGroups() )
               .Returns( new ReadOnlyCollection<FoodGroup>( new List<FoodGroup>() ) );
             dataRepositoryMock.Setup( x => x.Contains( foodItem ) ).Returns( true );
             dataRepositoryMock.Setup( x => x.GetFoodItem( foodItem.ID ) ).Returns( foodItem );

             var testFoodItemViewModel =
            new FoodItemViewModel( dataRepositoryMock.Object, regionManagerMock.Object, interactionServiceMock.Object, loggerMock.Object );

             var navigationContext = new NavigationContext( regionNavigationServiceMock.Object,
            new Uri( "FoodItemView?ID=" + foodItem.ID.ToString(), UriKind.Relative ) );
             testFoodItemViewModel.OnNavigatedTo( navigationContext );
             Assert.IsFalse( testFoodItemViewModel.IsNew );
        }
        /// <summary>
        /// Close test template.  All of the close tests follow this based pattern, so they all call this rather than repeating everything
        /// </summary>
        private void RunCloseTest( Boolean makeDirty, Boolean makeInvalid, MessageBoxResult messageResponse, Boolean expectRemove, Boolean expectSave )
        {
            var loggerMock = new Mock<ILoggerFacade>();
             Mock<IDataRepository> dataRepositoryMock = new Mock<IDataRepository>();
             Mock<IRegionNavigationService> regionNavigationServiceMock = new Mock<IRegionNavigationService>();
             Mock<IRegionManager> regionManagerMock = new Mock<IRegionManager>();
             Mock<IRegion> regionWithoutViewMock = new Mock<IRegion>();
             Mock<IRegion> regionMock = new Mock<IRegion>();
             Mock<IInteractionService> interactionServiceMock = new Mock<IInteractionService>();

             // Set up the food group list in the data repository mock.
             FoodGroup testFoodGroup = new FoodGroup( Guid.NewGuid(), "test", "The only food group in the mock data repository" );
             List<FoodGroup> foodGroups = new List<FoodGroup>();
             foodGroups.Add( testFoodGroup );
             dataRepositoryMock.Setup( x => x.GetAllFoodGroups() ).Returns( new ReadOnlyCollection<FoodGroup>( foodGroups ) );
             FoodItem foodItem = new FoodItem( Guid.NewGuid(), "Test Food Item", "Test Food Item Description", 42.0M );
             foodItem.FoodGroupsPerServing.Add( new Serving<FoodGroup>( testFoodGroup, 5.0M ) );
             Assert.IsTrue( foodItem.IsValid );
             dataRepositoryMock.Setup( x => x.GetFoodItem( foodItem.ID ) ).Returns( foodItem );
             dataRepositoryMock.Setup( x => x.Contains( foodItem ) ).Returns( true );

             // Create the view model under test and associate it with a view
             FoodItemViewModel viewModel =
            new FoodItemViewModel( dataRepositoryMock.Object, regionManagerMock.Object, interactionServiceMock.Object, loggerMock.Object );
             UserControl view = new UserControl();
             view.DataContext = viewModel;

             // Set up two regions each with their own set of views.
             List<UserControl> views = new List<UserControl>();
             views.Add( new UserControl() );
             views.Add( view );
             views.Add( new UserControl() );
             views.Add( new UserControl() );

             List<UserControl> viewsWithoutView = new List<UserControl>();
             viewsWithoutView.Add( new UserControl() );
             viewsWithoutView.Add( new UserControl() );

             List<IRegion> regions = new List<IRegion>();
             regions.Add( regionMock.Object );

             regionManagerMock.Setup( x => x.Regions.GetEnumerator() ).Returns( regions.GetEnumerator() );
             regionWithoutViewMock.Setup( x => x.Views.GetEnumerator() ).Returns( viewsWithoutView.GetEnumerator() );
             regionMock.Setup( x => x.Views.GetEnumerator() ).Returns( views.GetEnumerator() );

             // Navigate to the view that "displays" our food mealType.  This loads the view model
             NavigationContext navigationContext =
            new NavigationContext( regionNavigationServiceMock.Object, new Uri( "FoodItemView?ID=" + foodItem.ID.ToString(), UriKind.Relative ) );
             viewModel.OnNavigatedTo( navigationContext );

             if (makeDirty)
             {
            if (makeInvalid)
            {
               interactionServiceMock
                  .Setup( x => x.ShowMessageBox( Messages.Question_FoodItem_Close, DisplayStrings.CloseCaption, MessageBoxButton.YesNo, MessageBoxImage.Question ) )
                  .Returns( messageResponse );
               viewModel.Name = "";
               Assert.IsTrue( viewModel.IsDirty );
               Assert.IsFalse( viewModel.IsValid );
            }
            else
            {
               interactionServiceMock
                  .Setup( x => x.ShowMessageBox( Messages.Question_FoodItem_Save, DisplayStrings.SaveChangesCaption, MessageBoxButton.YesNoCancel, MessageBoxImage.Question ) )
                  .Returns( messageResponse );
               viewModel.Name = "Something Else";
               Assert.IsTrue( viewModel.IsDirty );
               Assert.IsTrue( viewModel.IsValid );
            }
             }
             else
             {
            // This will fail if we have passed in the non-sensical makeDirty == false, makeInvalid == true
            Assert.AreEqual( makeDirty, viewModel.IsDirty );
             }

             // Attempt a close.
             viewModel.CloseCommand.Execute( null );

             // If we were dirty, then we need to verify that the correct interaction was done, otherwise, that no interaction was done
             if (makeDirty)
             {
            interactionServiceMock.VerifyAll();
             }
             else
             {
            interactionServiceMock.Verify(
               x => x.ShowMessageBox( It.IsAny<String>(), It.IsAny<String>(), It.IsAny<MessageBoxButton>(), It.IsAny<MessageBoxImage>() ), Times.Never() );
             }

             if (expectRemove)
             {
            regionMock.Verify( x => x.Remove( view ), Times.Exactly( 1 ) );
            regionMock.Verify( x => x.Remove( It.IsAny<UserControl>() ), Times.Exactly( 1 ) );
             }
             else
             {
            regionMock.Verify( x => x.Remove( It.IsAny<UserControl>() ), Times.Never() );
             }

             if (expectSave)
             {
            dataRepositoryMock.Verify( x => x.SaveItem( foodItem ), Times.Exactly( 1 ) );
            dataRepositoryMock.Verify( x => x.SaveItem( It.IsAny<FoodItem>() ), Times.Exactly( 1 ) );
             }
             else
             {
            dataRepositoryMock.Verify( x => x.SaveItem( It.IsAny<FoodItem>() ), Times.Never() );
             }
        }
        public void SaveNotCalledForNonChangedFoodItem()
        {
            var loggerMock = new Mock<ILoggerFacade>();
             var regionManagerMock = new Mock<IRegionManager>();
             var regionNavigationServiceMock = new Mock<IRegionNavigationService>();
             var dataRepositoryMock = new Mock<IDataRepository>();
             var interactionServiceMock = new Mock<IInteractionService>();

             var foodItem = new FoodItem( Guid.NewGuid(), "FoodItem", "", 420 );
             foodItem.FoodGroupsPerServing.Add( new Serving<FoodGroup>( new FoodGroup( Guid.NewGuid(), "Test Group", "" ), 1 ) );

             dataRepositoryMock.Setup( x => x.GetAllFoodGroups() )
            .Returns( new ReadOnlyCollection<FoodGroup>( new List<FoodGroup>() ) );
             dataRepositoryMock.Setup( x => x.Contains( foodItem ) ).Returns( true );
             dataRepositoryMock.Setup( x => x.GetFoodItem( foodItem.ID ) ).Returns( foodItem );

             var foodItemViewModel =
            new FoodItemViewModel( dataRepositoryMock.Object, regionManagerMock.Object, interactionServiceMock.Object, loggerMock.Object );
             var navigationContext = new NavigationContext( regionNavigationServiceMock.Object,
            new Uri( "FoodItemView?ID=" + foodItem.ID.ToString(), UriKind.Relative ) );
             foodItemViewModel.OnNavigatedTo( navigationContext );

             Assert.IsTrue( foodItemViewModel.IsValid );
             Assert.IsFalse( foodItemViewModel.IsDirty );
             Assert.IsFalse( foodItemViewModel.IsNew );

             foodItemViewModel.SaveCommand.Execute( null );

             dataRepositoryMock.Verify( x => x.SaveItem( It.IsAny<FoodItem>() ), Times.Never() );
        }
        public void AddingMealForDateToRepositoryUpdatesCaloriesAndFoodGroups()
        {
            PropertyChangedHandler propertyChangedHandler = new PropertyChangedHandler();

             var loggerMock = new Mock<ILoggerFacade>();
             var dataRepositoryMock = new Mock<IDataRepository>();
             var regionManagerMock = new Mock<IRegionManager>();
             var interactionServiceMock = new Mock<IInteractionService>();
             var navigationServiceMock = new Mock<IRegionNavigationService>();

             var data = new MockData();
             var fullMealList = data.Meals();
             var todaysMeals = (from meal in fullMealList
                            where meal.DateAndTimeOfMeal.Date == DateTime.Today
                            select meal).ToList();
             dataRepositoryMock.Setup( x => x.GetAllMealsForDate( DateTime.Today ) ).Returns(
            new ReadOnlyCollection<Meal>( todaysMeals ) );

             var viewModel = new DailyLogViewModel( dataRepositoryMock.Object, regionManagerMock.Object, interactionServiceMock.Object, loggerMock.Object );
             viewModel.CurrentDate = DateTime.Today;
             viewModel.PropertyChanged += propertyChangedHandler.OnPropertyChanged;

             Int32 originalFoodGroupCount = viewModel.FoodGroupServings.Count;
             Decimal originalFoodGroupServings = (from foodGroupServing in viewModel.FoodGroupServings
                                              select foodGroupServing.Quantity).Sum();
             Decimal originalCalories = viewModel.Calories;

             var foodGroupServings = viewModel.FoodGroupServings;
             Assert.AreEqual( 5, foodGroupServings.Count );
             var serving = foodGroupServings.ToList().Find( x => x.Entity.Name == "Fruit" );
             Assert.IsNotNull( serving );
             Assert.AreEqual( 2.5M, serving.Quantity );
             serving = foodGroupServings.ToList().Find( x => x.Entity.Name == "Starch" );
             Assert.IsNotNull( serving );
             Assert.AreEqual( 5.0M, serving.Quantity );
             serving = foodGroupServings.ToList().Find( x => x.Entity.Name == "Dairy" );
             Assert.IsNotNull( serving );
             Assert.AreEqual( 4.75M, serving.Quantity );
             serving = foodGroupServings.ToList().Find( x => x.Entity.Name == "Meat" );
             Assert.IsNotNull( serving );
             Assert.AreEqual( 2.5M, serving.Quantity );
             serving = foodGroupServings.ToList().Find( x => x.Entity.Name == "Vegetable" );
             Assert.IsNotNull( serving );
             Assert.AreEqual( 3.5M, serving.Quantity );

             var foodItem = new FoodItem( Guid.NewGuid(), "test", "", 42 );
             foodItem.FoodGroupsPerServing.Add( new Serving<FoodGroup>( new FoodGroup( Guid.NewGuid(), "Test1", "" ), 2 ) );
             foodItem.FoodGroupsPerServing.Add( new Serving<FoodGroup>( new FoodGroup( Guid.NewGuid(), "Test2", "" ), 1 ) );
             var newMeal = new Meal(
            Guid.NewGuid(), new MealType( Guid.NewGuid(), "Doesn't Matter", "", DateTime.Now, false ), DateTime.Now, "Test Meal", "Just a test" );
             newMeal.FoodItemServings.Add( new Serving<FoodItem>( foodItem, 1 ) );
             todaysMeals.Add( newMeal );
             dataRepositoryMock.Raise( e => e.ItemAdded += null, new RepositoryObjectEventArgs( newMeal ) );
             Assert.AreEqual( originalCalories + 42, viewModel.Calories );
             Assert.AreEqual( originalFoodGroupCount + 2, viewModel.FoodGroupServings.Count );
             Assert.AreEqual( originalFoodGroupServings + 3, (from foodGroupServing in viewModel.FoodGroupServings
                                                          select foodGroupServing.Quantity).Sum() );

             foodGroupServings = viewModel.FoodGroupServings;
             Assert.AreEqual( 7, foodGroupServings.Count );
             serving = foodGroupServings.ToList().Find( x => x.Entity.Name == "Fruit" );
             Assert.IsNotNull( serving );
             Assert.AreEqual( 2.5M, serving.Quantity );
             serving = foodGroupServings.ToList().Find( x => x.Entity.Name == "Starch" );
             Assert.IsNotNull( serving );
             Assert.AreEqual( 5.0M, serving.Quantity );
             serving = foodGroupServings.ToList().Find( x => x.Entity.Name == "Dairy" );
             Assert.IsNotNull( serving );
             Assert.AreEqual( 4.75M, serving.Quantity );
             serving = foodGroupServings.ToList().Find( x => x.Entity.Name == "Meat" );
             Assert.IsNotNull( serving );
             Assert.AreEqual( 2.5M, serving.Quantity );
             serving = foodGroupServings.ToList().Find( x => x.Entity.Name == "Vegetable" );
             Assert.IsNotNull( serving );
             Assert.AreEqual( 3.5M, serving.Quantity );
             serving = foodGroupServings.ToList().Find( x => x.Entity.Name == "Test1" );
             Assert.IsNotNull( serving );
             Assert.AreEqual( 2, serving.Quantity );
             serving = foodGroupServings.ToList().Find( x => x.Entity.Name == "Test2" );
             Assert.IsNotNull( serving );
             Assert.AreEqual( 1, serving.Quantity );

             Assert.AreEqual( 2, propertyChangedHandler.PropertiesChanged.Count );
             Assert.AreEqual( viewModel, propertyChangedHandler.Sender );
             Assert.IsTrue( propertyChangedHandler.PropertiesChanged.Contains( "Calories" ) );
             Assert.IsTrue( propertyChangedHandler.PropertiesChanged.Contains( "FoodGroupServings" ) );
        }
예제 #14
0
 /// <summary>
 /// Determine if a food item is currently referenced by some other entitiy in the repository.
 /// </summary>
 /// <param name="foodItem">The food item</param>
 /// <returns>True if used, false otherwise.</returns>
 public Boolean ItemIsUsed( FoodItem foodItem )
 {
     // I foresee this getting slow once we get a lot of meals in there.
      // May need to implement a usage count on the food item list.
      foreach (MealTemplate mealTemplate in _mealTemplates)
      {
     foreach (Serving<FoodItem> serving in mealTemplate.FoodItemServings)
     {
        if (serving.Entity.ID == foodItem.ID)
        {
           return true;
        }
     }
      }
      return false;
 }
예제 #15
0
        public void FoodItemNameCalories()
        {
            FoodItem foodItem = new FoodItem( Guid.NewGuid(), "Water", "", -1 );

             Assert.IsNotNull( foodItem.ID );
             Assert.AreEqual( "Water", foodItem.Name );
             Assert.IsNull( foodItem.Description );
             Assert.AreEqual( -1, foodItem.CaloriesPerServing );
             Assert.AreEqual( 0, foodItem.FoodGroupsPerServing.Count );
             Assert.IsFalse( foodItem.IsValid );
             Assert.IsNull( foodItem["Name"] );
             Assert.AreEqual( Messages.Error_No_FoodGroups, foodItem["FoodGroupsPerServing"] );
             Assert.AreEqual( Messages.Error_Negative_Calories, foodItem["CaloriesPerServing"] );

             // Assign a food group
             FoodGroup foodGroup = new FoodGroup( Guid.NewGuid(), "Water", "" );
             foodItem.FoodGroupsPerServing.Add( new Serving<FoodGroup>( foodGroup, 1 ) );
             Assert.IsFalse( foodItem.IsValid );
             Assert.IsNull( foodItem["Name"] );
             Assert.IsNull( foodItem["FoodGroupsPerServing"] );
             Assert.AreEqual( Messages.Error_Negative_Calories, foodItem["CaloriesPerServing"] );

             // Provide non-negative Calories
             foodItem.CaloriesPerServing = 0;
             Assert.IsTrue( foodItem.IsValid );
             Assert.IsNull( foodItem["Name"] );
             Assert.IsNull( foodItem["FoodGroupsPerServing"] );
             Assert.IsNull( foodItem["CaloriesPerServing"] );
        }
예제 #16
0
 /// <summary>
 /// Determine if a food item's name is already being used by another food item.
 /// </summary>
 /// <param name="foodItem">The food item</param>
 /// <returns>True if some other food item is using the name, false otherwise.</returns>
 public Boolean NameIsDuplicate( FoodItem foodItem )
 {
     return (_foodItems.Find( food => food.Name == foodItem.Name && food.ID != foodItem.ID ) != null);
 }
예제 #17
0
        public void UndoRedoMealViewModel()
        {
            // Create a meal and then navigate to it to bring it into the view model
             var meal = new Meal( Guid.NewGuid(), new MealType( Guid.NewGuid(), "Test", "", DateTime.Now, false ), DateTime.Now, "Bob", "Battery Operated Buddy" );
             var glassOfWater = new FoodItem( Guid.NewGuid(), "Glass of Water", "", 0 );
             glassOfWater.FoodGroupsPerServing.Add( new Serving<FoodGroup>( new FoodGroup( Guid.NewGuid(), "Water", "" ), 1 ) );
             meal.FoodItemServings.Add( new Serving<FoodItem>( glassOfWater, 1.0M ) );

             var mealViewModel = CreateViewModelForMeal( meal );

             Assert.IsFalse( mealViewModel.IsDirty );
             Assert.IsFalse( mealViewModel.UndoCommand.CanExecute( null ) );
             Assert.IsFalse( mealViewModel.RedoCommand.CanExecute( null ) );

             // Make changes as such:
             //   o name changed from Bob to Pete
             //   o name changed from Pete to Peter
             //   o Description changed from "Battery Operated Buddy" to "The Rock"
             //   o name changed from Peter to Simon
             //   o name changed from Simon to Saul
             //   o description changed from "The Rock" to "The Persecutor"
             //   o description changed from "The Persecutor" to "The Apostle"
             //   o name changed from Saul to Paul
             // Verify can undo, cannot redo at each step
             mealViewModel.Name = "Pete";
             Assert.IsTrue( mealViewModel.UndoCommand.CanExecute( null ) );
             Assert.IsFalse( mealViewModel.RedoCommand.CanExecute( null ) );
             mealViewModel.Name += "r";
             Assert.IsTrue( mealViewModel.UndoCommand.CanExecute( null ) );
             Assert.IsFalse( mealViewModel.RedoCommand.CanExecute( null ) );
             mealViewModel.Description = "The Rock";
             Assert.IsTrue( mealViewModel.UndoCommand.CanExecute( null ) );
             Assert.IsFalse( mealViewModel.RedoCommand.CanExecute( null ) );
             mealViewModel.Name = "Simon";
             Assert.IsTrue( mealViewModel.UndoCommand.CanExecute( null ) );
             Assert.IsFalse( mealViewModel.RedoCommand.CanExecute( null ) );
             mealViewModel.Name = "Saul";
             Assert.IsTrue( mealViewModel.UndoCommand.CanExecute( null ) );
             Assert.IsFalse( mealViewModel.RedoCommand.CanExecute( null ) );
             mealViewModel.Description = "The Persecutor";
             Assert.IsTrue( mealViewModel.UndoCommand.CanExecute( null ) );
             Assert.IsFalse( mealViewModel.RedoCommand.CanExecute( null ) );
             mealViewModel.Description = "The Apostle";
             Assert.IsTrue( mealViewModel.UndoCommand.CanExecute( null ) );
             Assert.IsFalse( mealViewModel.RedoCommand.CanExecute( null ) );
             mealViewModel.Name = "Paul";
             Assert.IsTrue( mealViewModel.UndoCommand.CanExecute( null ) );
             Assert.IsFalse( mealViewModel.RedoCommand.CanExecute( null ) );

             Assert.AreEqual( "Paul", mealViewModel.Name );
             Assert.AreEqual( "The Apostle", mealViewModel.Description );

             // Undo once.  Verify last thing done is undone, and we can redo.
             mealViewModel.UndoCommand.Execute( null );
             Assert.AreEqual( "Saul", mealViewModel.Name );
             Assert.AreEqual( "The Apostle", mealViewModel.Description );
             Assert.IsTrue( mealViewModel.UndoCommand.CanExecute( null ) );
             Assert.IsTrue( mealViewModel.RedoCommand.CanExecute( null ) );

             // Redo.  Verify last thing undone is redone, can no longer redo, can still undo.
             mealViewModel.RedoCommand.Execute( null );
             Assert.AreEqual( "Paul", mealViewModel.Name );
             Assert.AreEqual( "The Apostle", mealViewModel.Description );
             Assert.IsTrue( mealViewModel.UndoCommand.CanExecute( null ) );
             Assert.IsFalse( mealViewModel.RedoCommand.CanExecute( null ) );

             // Undo 4 times, verify undo worked
             mealViewModel.UndoCommand.Execute( null );
             Assert.AreEqual( "Saul", mealViewModel.Name );
             Assert.AreEqual( "The Apostle", mealViewModel.Description );
             Assert.IsTrue( mealViewModel.UndoCommand.CanExecute( null ) );
             Assert.IsTrue( mealViewModel.RedoCommand.CanExecute( null ) );
             mealViewModel.UndoCommand.Execute( null );
             Assert.AreEqual( "Saul", mealViewModel.Name );
             Assert.AreEqual( "The Persecutor", mealViewModel.Description );
             Assert.IsTrue( mealViewModel.UndoCommand.CanExecute( null ) );
             Assert.IsTrue( mealViewModel.RedoCommand.CanExecute( null ) );
             mealViewModel.UndoCommand.Execute( null );
             Assert.AreEqual( "Saul", mealViewModel.Name );
             Assert.AreEqual( "The Rock", mealViewModel.Description );
             Assert.IsTrue( mealViewModel.UndoCommand.CanExecute( null ) );
             Assert.IsTrue( mealViewModel.RedoCommand.CanExecute( null ) );
             mealViewModel.UndoCommand.Execute( null );
             Assert.AreEqual( "Simon", mealViewModel.Name );
             Assert.AreEqual( "The Rock", mealViewModel.Description );
             Assert.IsTrue( mealViewModel.UndoCommand.CanExecute( null ) );
             Assert.IsTrue( mealViewModel.RedoCommand.CanExecute( null ) );

             // Redo 2 times, verify
             mealViewModel.RedoCommand.Execute( null );
             Assert.AreEqual( "Saul", mealViewModel.Name );
             Assert.AreEqual( "The Rock", mealViewModel.Description );
             Assert.IsTrue( mealViewModel.UndoCommand.CanExecute( null ) );
             Assert.IsTrue( mealViewModel.RedoCommand.CanExecute( null ) );
             mealViewModel.RedoCommand.Execute( null );
             Assert.AreEqual( "Saul", mealViewModel.Name );
             Assert.AreEqual( "The Persecutor", mealViewModel.Description );
             Assert.IsTrue( mealViewModel.UndoCommand.CanExecute( null ) );
             Assert.IsTrue( mealViewModel.RedoCommand.CanExecute( null ) );

             // Undo 6 times.  Back to original, cannot undo, can redo
             mealViewModel.UndoCommand.Execute( null );
             Assert.AreEqual( "Saul", mealViewModel.Name );
             Assert.AreEqual( "The Rock", mealViewModel.Description );
             Assert.IsTrue( mealViewModel.UndoCommand.CanExecute( null ) );
             Assert.IsTrue( mealViewModel.RedoCommand.CanExecute( null ) );
             mealViewModel.UndoCommand.Execute( null );
             Assert.AreEqual( "Simon", mealViewModel.Name );
             Assert.AreEqual( "The Rock", mealViewModel.Description );
             Assert.IsTrue( mealViewModel.UndoCommand.CanExecute( null ) );
             Assert.IsTrue( mealViewModel.RedoCommand.CanExecute( null ) );
             mealViewModel.UndoCommand.Execute( null );
             Assert.AreEqual( "Peter", mealViewModel.Name );
             Assert.AreEqual( "The Rock", mealViewModel.Description );
             Assert.IsTrue( mealViewModel.UndoCommand.CanExecute( null ) );
             Assert.IsTrue( mealViewModel.RedoCommand.CanExecute( null ) );
             mealViewModel.UndoCommand.Execute( null );
             Assert.AreEqual( "Peter", mealViewModel.Name );
             Assert.AreEqual( "Battery Operated Buddy", mealViewModel.Description );
             Assert.IsTrue( mealViewModel.UndoCommand.CanExecute( null ) );
             Assert.IsTrue( mealViewModel.RedoCommand.CanExecute( null ) );
             mealViewModel.UndoCommand.Execute( null );
             Assert.AreEqual( "Pete", mealViewModel.Name );
             Assert.AreEqual( "Battery Operated Buddy", mealViewModel.Description );
             Assert.IsTrue( mealViewModel.UndoCommand.CanExecute( null ) );
             Assert.IsTrue( mealViewModel.RedoCommand.CanExecute( null ) );
             mealViewModel.UndoCommand.Execute( null );
             Assert.AreEqual( "Bob", mealViewModel.Name );
             Assert.AreEqual( "Battery Operated Buddy", mealViewModel.Description );
             Assert.IsFalse( mealViewModel.UndoCommand.CanExecute( null ) );
             Assert.IsTrue( mealViewModel.RedoCommand.CanExecute( null ) );

             // Redo 3 times, verify
             mealViewModel.RedoCommand.Execute( null );
             Assert.AreEqual( "Pete", mealViewModel.Name );
             Assert.AreEqual( "Battery Operated Buddy", mealViewModel.Description );
             Assert.IsTrue( mealViewModel.UndoCommand.CanExecute( null ) );
             Assert.IsTrue( mealViewModel.RedoCommand.CanExecute( null ) );
             mealViewModel.RedoCommand.Execute( null );
             Assert.AreEqual( "Peter", mealViewModel.Name );
             Assert.AreEqual( "Battery Operated Buddy", mealViewModel.Description );
             Assert.IsTrue( mealViewModel.UndoCommand.CanExecute( null ) );
             Assert.IsTrue( mealViewModel.RedoCommand.CanExecute( null ) );
             mealViewModel.RedoCommand.Execute( null );
             Assert.AreEqual( "Peter", mealViewModel.Name );
             Assert.AreEqual( "The Rock", mealViewModel.Description );
             Assert.IsTrue( mealViewModel.UndoCommand.CanExecute( null ) );
             Assert.IsTrue( mealViewModel.RedoCommand.CanExecute( null ) );
        }
예제 #18
0
        /// <summary>
        /// Remove a food item from the repository
        /// </summary>
        /// <param name="foodItem">The food item</param>
        public void Remove( FoodItem foodItem )
        {
            Debug.Assert( foodItem != null );

             if (Contains( foodItem ))
             {
            _foodItems.Remove( _foodItems.Find( f => f.ID == foodItem.ID ) );
            if (ItemDeleted != null)
            {
               ItemDeleted( this, new RepositoryObjectEventArgs( foodItem ) );
            }
             }

             SaveRepository();
        }
예제 #19
0
        public void SaveFoodItem()
        {
            var configurationMock = new Mock<IConfiguration>();
             configurationMock.Setup( x => x.DataSource ).Returns( DataSourceType.XMLFile );
             configurationMock.Setup( x => x.FileName ).Returns( FullTestData.DataFileName );

             FullTestData.Reset();
             HealthTracker.DataRepository.Services.DataRepository dataRepository = new HealthTracker.DataRepository.Services.DataRepository( configurationMock.Object );

             // Get some food groups that we can use
             FoodGroup meat = dataRepository.FindFoodGroup( f => f.ID == FullTestData.MeatID );
             FoodGroup vegetables = dataRepository.FindFoodGroup( f => f.ID == FullTestData.VegetableID );

             // Create one new food item, and get a deep copy of one out of the repository.
             // When the new one is saved, a food item should be added to the repository.
             // When the deep copy of the existing one is modified, the modifications should not be applied to the repository
             // until the copy is saved, at which a new food item should not be created, but the food item object with the same
             // ID should have the modifications applied to it.
             FoodItem dublinCoddle = new FoodItem( new Guid( "f6ffa83c-5f7a-4961-8571-801f436c0eb9" ), "Dublin Coddle", "Poormans food", 250 );
             dublinCoddle.FoodGroupsPerServing.Add( new Serving<FoodGroup>( meat, 1 ) );
             dublinCoddle.FoodGroupsPerServing.Add( new Serving<FoodGroup>( vegetables, 2 ) );

             FoodItem repositoryChzBurger = dataRepository.FindFoodItem( f => f.ID == FullTestData.CheeseBurgerID );
             Assert.IsNotNull( repositoryChzBurger );
             FoodItem chzBurger = new FoodItem();
             chzBurger.InitializeData( repositoryChzBurger );
             Int32 origFoodItemCount = dataRepository.GetAllFoodItems().Count;

             // Verify the food groups, etc.
             Assert.AreEqual( repositoryChzBurger.CaloriesPerServing, chzBurger.CaloriesPerServing );
             Assert.AreEqual( repositoryChzBurger.Name, chzBurger.Name );
             Assert.AreEqual( repositoryChzBurger.Description, chzBurger.Description );
             Assert.AreEqual( repositoryChzBurger.FoodGroupsPerServing.Count, chzBurger.FoodGroupsPerServing.Count );

             // Remove the vegetables and bacon, and verify the difference
             chzBurger.Description = "Ground up cow, topped with curdled milk.";
             chzBurger.Name = "Cheese Burger";
             chzBurger.FoodGroupsPerServing.Find( f => f.Entity.ID == FullTestData.MeatID ).Quantity = 1;
             chzBurger.FoodGroupsPerServing.Remove( chzBurger.FoodGroupsPerServing.Find( f => f.Entity.ID == FullTestData.VegetableID ) );
             chzBurger.CaloriesPerServing -= 140;

             repositoryChzBurger = dataRepository.FindFoodItem( f => f.ID == FullTestData.CheeseBurgerID );
             Assert.AreNotEqual( repositoryChzBurger.CaloriesPerServing, chzBurger.CaloriesPerServing );
             Assert.AreNotEqual( repositoryChzBurger.Name, chzBurger.Name );
             Assert.AreNotEqual( repositoryChzBurger.Description, chzBurger.Description );
             Assert.AreNotEqual( repositoryChzBurger.FoodGroupsPerServing.Count, chzBurger.FoodGroupsPerServing.Count );
             Assert.AreNotEqual(
            repositoryChzBurger.FoodGroupsPerServing.Find( f => f.Entity.ID == FullTestData.MeatID ),
            chzBurger.FoodGroupsPerServing.Find( f => f.Entity.ID == FullTestData.MeatID ) );
             Assert.IsNotNull( repositoryChzBurger.FoodGroupsPerServing.Find( f => f.Entity.ID == FullTestData.VegetableID ) );
             Assert.IsNull( chzBurger.FoodGroupsPerServing.Find( f => f.Entity.ID == FullTestData.VegetableID ) );

             // Save the cheese burger, and verify the changes are saved
             dataRepository.SaveItem( chzBurger );
             repositoryChzBurger = dataRepository.FindFoodItem( f => f.ID == FullTestData.CheeseBurgerID );
             Assert.AreEqual( repositoryChzBurger.CaloriesPerServing, chzBurger.CaloriesPerServing );
             Assert.AreEqual( repositoryChzBurger.Name, chzBurger.Name );
             Assert.AreEqual( repositoryChzBurger.Description, chzBurger.Description );
             Assert.AreEqual( repositoryChzBurger.FoodGroupsPerServing.Count, chzBurger.FoodGroupsPerServing.Count );
             Assert.AreEqual(
            repositoryChzBurger.FoodGroupsPerServing.Find( f => f.Entity.ID == FullTestData.MeatID ).Quantity,
            chzBurger.FoodGroupsPerServing.Find( f => f.Entity.ID == FullTestData.MeatID ).Quantity );
             Assert.IsNull( repositoryChzBurger.FoodGroupsPerServing.Find( f => f.Entity.ID == FullTestData.VegetableID ) );
             Assert.IsNull( chzBurger.FoodGroupsPerServing.Find( f => f.Entity.ID == FullTestData.VegetableID ) );

             Assert.AreEqual( origFoodItemCount, dataRepository.GetAllFoodItems().Count );

             // Add some fruit and verify the difference
             chzBurger.Name = "Hawian Cheese Burger";
             chzBurger.Description = "Ground up cow, topped with curdled milk, smoked pig, and pineapple.";
             chzBurger.FoodGroupsPerServing.Add( new Serving<FoodGroup>(
            dataRepository.FindFoodGroup( fg => fg.ID == FullTestData.FruitID ), 0.5M ) );
             chzBurger.FoodGroupsPerServing.Find( f => f.Entity.ID == FullTestData.MeatID ).Quantity += 1;
             chzBurger.CaloriesPerServing += 200;

             repositoryChzBurger = dataRepository.FindFoodItem( f => f.ID == FullTestData.CheeseBurgerID );
             Assert.AreNotEqual( repositoryChzBurger.CaloriesPerServing, chzBurger.CaloriesPerServing );
             Assert.AreNotEqual( repositoryChzBurger.Name, chzBurger.Name );
             Assert.AreNotEqual( repositoryChzBurger.Description, chzBurger.Description );
             Assert.AreNotEqual( repositoryChzBurger.FoodGroupsPerServing.Count, chzBurger.FoodGroupsPerServing.Count );
             Assert.AreNotEqual(
            repositoryChzBurger.FoodGroupsPerServing.Find( f => f.Entity.ID == FullTestData.MeatID ),
            chzBurger.FoodGroupsPerServing.Find( f => f.Entity.ID == FullTestData.MeatID ) );
             Assert.IsNull( repositoryChzBurger.FoodGroupsPerServing.Find( f => f.Entity.ID == FullTestData.FruitID ) );
             Assert.IsNotNull( chzBurger.FoodGroupsPerServing.Find( f => f.Entity.ID == FullTestData.FruitID ) );

             // Save the cheese burger, and verify the changes are saved
             dataRepository.SaveItem( chzBurger );
             repositoryChzBurger = dataRepository.FindFoodItem( f => f.ID == FullTestData.CheeseBurgerID );
             Assert.AreEqual( repositoryChzBurger.CaloriesPerServing, chzBurger.CaloriesPerServing );
             Assert.AreEqual( repositoryChzBurger.Name, chzBurger.Name );
             Assert.AreEqual( repositoryChzBurger.Description, chzBurger.Description );
             Assert.AreEqual( repositoryChzBurger.FoodGroupsPerServing.Count, chzBurger.FoodGroupsPerServing.Count );
             Assert.AreEqual(
            repositoryChzBurger.FoodGroupsPerServing.Find( f => f.Entity.ID == FullTestData.MeatID ).Quantity,
            chzBurger.FoodGroupsPerServing.Find( f => f.Entity.ID == FullTestData.MeatID ).Quantity );
             Assert.IsNotNull( repositoryChzBurger.FoodGroupsPerServing.Find( f => f.Entity.ID == FullTestData.FruitID ) );
             Assert.IsNotNull( chzBurger.FoodGroupsPerServing.Find( f => f.Entity.ID == FullTestData.FruitID ) );

             Assert.AreEqual( origFoodItemCount, dataRepository.GetAllFoodItems().Count );

             // Save the new food item
             dataRepository.SaveItem( dublinCoddle );
             Assert.AreEqual( origFoodItemCount + 1, dataRepository.GetAllFoodItems().Count );
             FoodItem repositoryCoddle = dataRepository.FindFoodItem( f => f.ID == new Guid( "f6ffa83c-5f7a-4961-8571-801f436c0eb9" ) );
             Assert.IsNotNull( repositoryCoddle );
             Assert.AreEqual( "Dublin Coddle", repositoryCoddle.Name );
             Assert.AreEqual( "Poormans food", repositoryCoddle.Description );
             Assert.AreEqual( 250, repositoryCoddle.CaloriesPerServing );
             Assert.AreEqual( 2, repositoryCoddle.FoodGroupsPerServing.Count );
        }
예제 #20
0
        // This is really, really ugly.  It works, but it is not pretty.  Look into changing this.
        private void LoadRepository( String dataFileName )
        {
            XDocument xmlDoc;

             using (FileStream stream = new FileStream( dataFileName, FileMode.Open ))
             {
            using (XmlReader xmlRdr = new XmlTextReader( stream ))
            {
               xmlDoc = XDocument.Load( xmlRdr );

               // If we don't have the root element
               if (xmlDoc.Element( rootNodeTag ) == null)
               {
                  _foodGroups = new List<FoodGroup>();
                  _foodItems = new List<FoodItem>();
                  _mealTypes = new List<MealType>();
                  _mealTemplates = new List<MealTemplate>();
                  _meals = new List<Meal>();
               }
               else
               {
                  if (xmlDoc.Element( rootNodeTag ).Element( foodGroupsNodeTag ) != null)
                  {
                     _foodGroups =
                        (from foodGroupElement in xmlDoc.Element( rootNodeTag ).Element( foodGroupsNodeTag ).Elements( foodGroupNodeTag )
                         select new FoodGroup(
                            (Guid)foodGroupElement.Attribute( idAttribute ),
                            (String)foodGroupElement.Attribute( nameAttribute ),
                            foodGroupElement.Element( descriptionNodeTag ) == null ? null :
                            (String)foodGroupElement.Element( descriptionNodeTag ).Value )).ToList();
                  }
                  else
                  {
                     _foodGroups = new List<FoodGroup>();
                  }

                  // FoodItems
                  _foodItems = new List<FoodItem>();
                  if (xmlDoc.Element( rootNodeTag ).Element( foodItemsNodeTag ) != null)
                  {
                     foreach (XElement foodItemElement in xmlDoc.Element( rootNodeTag ).Element( foodItemsNodeTag ).Elements( foodItemNodeTag ))
                     {
                        // Construct a food item and add it to the collection
                        FoodItem foodItem = new FoodItem( (Guid)foodItemElement.Attribute( idAttribute ),
                           (String)foodItemElement.Attribute( nameAttribute ),
                           foodItemElement.Element( descriptionNodeTag ) == null ? null :
                           (String)foodItemElement.Element( descriptionNodeTag ).Value,
                           (Decimal)foodItemElement.Attribute( caloriesAttribute ) ); // TODO: Should probably do a tryparse on that...
                        _foodItems.Add( foodItem );

                        // Loop through the FoodGroupServings to build that list
                        if (foodItemElement.Element( foodGroupServingsNodeTag ) != null)
                        {
                           foreach (XElement servingElement in foodItemElement.Element( foodGroupServingsNodeTag ).Elements( servingNodeTag ))
                           {
                              Serving<FoodGroup> foodGroupServing = new Serving<FoodGroup>(
                                 _foodGroups.Find( fg => fg.ID == (Guid)servingElement.Attribute( foodGroupIdAttribute ) ),
                                 (Decimal)servingElement.Attribute( quantityAttribute ) );
                              foodItem.FoodGroupsPerServing.Add( foodGroupServing );
                           }
                        }
                     }
                  }

                  if (xmlDoc.Element( rootNodeTag ).Element( mealTypesNodeTag ) != null)
                  {
                     _mealTypes =
                        (from mealTypeElement in xmlDoc.Element( rootNodeTag ).Element( mealTypesNodeTag ).Elements( mealTypeNodeTag )
                         select new MealType(
                            (Guid)mealTypeElement.Attribute( idAttribute ),
                            (String)mealTypeElement.Attribute( nameAttribute ),
                            mealTypeElement.Element( descriptionNodeTag ) == null ? null :
                            (String)mealTypeElement.Element( descriptionNodeTag ).Value,
                            (DateTime)mealTypeElement.Attribute( dateTimeAttribute ),
                            (Boolean)mealTypeElement.Attribute( useDefaultDateTimeAttribute ) )).ToList();
                  }
                  else
                  {
                     _mealTypes = new List<MealType>();
                  }

                  // Meal Templates
                  _mealTemplates = new List<MealTemplate>();
                  if (xmlDoc.Element( rootNodeTag ).Element( mealTemplatesNodeTag ) != null)
                  {
                     foreach (XElement mealTemplateElement in xmlDoc.Element( rootNodeTag ).Element( mealTemplatesNodeTag ).Elements( mealNodeTag ))
                     {
                        // Construct a food item and add it to the collection
                        MealTemplate mealTemplate = new MealTemplate(
                           (Guid)mealTemplateElement.Attribute( idAttribute ),
                           _mealTypes.Find( mt => mt.ID == (Guid)mealTemplateElement.Attribute( mealTypeIdAttribute ) ),
                           (DateTime)mealTemplateElement.Attribute( dateTimeAttribute ),
                           (String)mealTemplateElement.Attribute( nameAttribute ),
                            mealTemplateElement.Element( descriptionNodeTag ) == null ? null :
                            (String)mealTemplateElement.Element( descriptionNodeTag ).Value );
                        _mealTemplates.Add( mealTemplate );

                        // Loop through the FoodItemServings to build that list
                        if (mealTemplateElement.Element( foodItemServingsNodeTag ) != null)
                        {
                           foreach (XElement servingElement in mealTemplateElement.Element( foodItemServingsNodeTag ).Elements( servingNodeTag ))
                           {
                              Serving<FoodItem> foodItem = new Serving<FoodItem>(
                                 _foodItems.Find( fi => fi.ID == (Guid)servingElement.Attribute( foodItemIdAttribute ) ),
                                 (Decimal)servingElement.Attribute( quantityAttribute ) );
                              mealTemplate.FoodItemServings.Add( foodItem );
                           }
                        }
                     }
                  }

                  // Meals
                  _meals = new List<Meal>();
                  if (xmlDoc.Element( rootNodeTag ).Element( mealsNodeTag ) != null)
                  {
                     foreach (XElement mealElement in xmlDoc.Element( rootNodeTag ).Element( mealsNodeTag ).Elements( mealNodeTag ))
                     {
                        // Construct a food item and add it to the collection
                        var meal = new Meal(
                           (Guid)mealElement.Attribute( idAttribute ),
                           _mealTypes.Find( mt => mt.ID == (Guid)mealElement.Attribute( mealTypeIdAttribute ) ),
                           (DateTime)mealElement.Attribute( dateTimeAttribute ),
                           (String)mealElement.Attribute( nameAttribute ),
                            mealElement.Element( descriptionNodeTag ) == null ? null :
                            (String)mealElement.Element( descriptionNodeTag ).Value );
                        _meals.Add( meal );

                        // Loop through the FoodItemServings to build that list
                        if (mealElement.Element( foodItemServingsNodeTag ) != null)
                        {
                           foreach (XElement servingElement in mealElement.Element( foodItemServingsNodeTag ).Elements( servingNodeTag ))
                           {
                              Serving<FoodItem> foodItem = new Serving<FoodItem>(
                                 _foodItems.Find( fi => fi.ID == (Guid)servingElement.Attribute( foodItemIdAttribute ) ),
                                 (Decimal)servingElement.Attribute( quantityAttribute ) );
                              meal.FoodItemServings.Add( foodItem );
                           }
                        }
                     }
                  }
               }
            }
             }
        }
예제 #21
0
        /// <summary>
        /// Add a food item to the repository
        /// </summary>
        /// <param name="foodItem">The food item</param>
        public void SaveItem( FoodItem foodItem )
        {
            Debug.Assert( foodItem != null );

             if (!Contains( foodItem ))
             {
            _foodItems.Add( new FoodItem( foodItem ) );
            if (ItemAdded != null)
            {
               ItemAdded( this, new RepositoryObjectEventArgs( foodItem ) );
            }
             }
             else
             {
            FoodItem repositoryFoodItem = _foodItems.Find( f => f.ID == foodItem.ID );
            Debug.Assert( repositoryFoodItem != null );
            repositoryFoodItem.InitializeData( foodItem );
            if (ItemModified != null)
            {
               ItemModified( this, new RepositoryObjectEventArgs( foodItem ) );
            }
             }

             this.SaveRepository();
        }
예제 #22
0
        public void FoodItemNameDescriptionCalories()
        {
            FoodItem foodItem = new FoodItem( Guid.NewGuid(), "Apple", "It fell on Newton's head.", 60 );

             Assert.IsNotNull( foodItem.ID );
             Assert.AreEqual( "Apple", foodItem.Name );
             Assert.AreEqual( "It fell on Newton's head.", foodItem.Description );
             Assert.AreEqual( 60, foodItem.CaloriesPerServing );
             Assert.AreEqual( 0, foodItem.FoodGroupsPerServing.Count );
             Assert.IsFalse( foodItem.IsValid );
             Assert.IsNull( foodItem["Name"] );
             Assert.AreEqual( Messages.Error_No_FoodGroups, foodItem["FoodGroupsPerServing"] );
             Assert.IsNull( foodItem["CaloriesPerServing"] );

             // Assign a food group
             FoodGroup foodGroup = new FoodGroup( Guid.NewGuid(), "Fruit", "" );
             foodItem.FoodGroupsPerServing.Add( new Serving<FoodGroup>( foodGroup, 1 ) );
             Assert.IsTrue( foodItem.IsValid );
             Assert.IsNull( foodItem["Name"] );
             Assert.IsNull( foodItem["FoodGroupsPerServing"] );
             Assert.IsNull( foodItem["CaloriesPerServing"] );
        }
예제 #23
0
        public void FoodGroupServingsAdjustedAsFoodItemsAdded()
        {
            var data = new MockData();
             var meal = data.Meals().Find( x => x.ID == MockData.DayTwoBreakfastID );

             var viewModel = CreateViewModelForMeal( new Meal( meal ) );

             var foodItem = new FoodItem( Guid.NewGuid(), "Test Food Item", "", 1 );
             foodItem.FoodGroupsPerServing.Add( new Serving<FoodGroup>( new FoodGroup( Guid.NewGuid(), "Test Food Group", "" ), 1 ) );
             viewModel.FoodItemServings.Add( new ServingViewModel<FoodItem>( foodItem, 2 ) );

             Assert.AreEqual( meal.FoodGroupServings.Count + 1, viewModel.FoodGroupServings.Count );
        }
예제 #24
0
        public void InitializeData()
        {
            FoodGroup fruit = new FoodGroup( Guid.NewGuid(), "Fruit", "" );
             FoodGroup meat = new FoodGroup( Guid.NewGuid(), "Meat", "" );
             FoodGroup vegetable = new FoodGroup( Guid.NewGuid(), "Vegetable", "" );

             FoodItem sourceFoodItem = new FoodItem( Guid.NewGuid(), "Banana Burger", "Hamburger meat between banana slices", 235 );
             sourceFoodItem.FoodGroupsPerServing.Add( new Serving<FoodGroup>( fruit, 2 ) );
             sourceFoodItem.FoodGroupsPerServing.Add( new Serving<FoodGroup>( meat, 1 ) );
             Assert.AreEqual( 2, sourceFoodItem.FoodGroupsPerServing.Count );

             FoodItem foodItem = new FoodItem();
             Assert.IsNotNull( foodItem.ID );
             Assert.AreNotEqual( sourceFoodItem.ID, foodItem.ID );
             Assert.IsNull( foodItem.Name );
             Assert.IsNull( foodItem.Description );
             Assert.AreEqual( 0, foodItem.FoodGroupsPerServing.Count );
             Assert.AreEqual( 0, foodItem.CaloriesPerServing );

             foodItem.InitializeData( sourceFoodItem );
             Assert.AreEqual( sourceFoodItem.ID, foodItem.ID );
             Assert.AreEqual( sourceFoodItem.Name, foodItem.Name );
             Assert.AreEqual( sourceFoodItem.Description, foodItem.Description );
             Assert.AreEqual( sourceFoodItem.FoodGroupsPerServing.Count, foodItem.FoodGroupsPerServing.Count );

             Serving<FoodGroup> serving = foodItem.FoodGroupsPerServing.Find( fg => fg.Entity.Name == "Fruit" );
             Assert.IsNotNull( serving );
             Assert.AreEqual( fruit, serving.Entity );
             Assert.AreEqual( 2, serving.Quantity );

             serving = foodItem.FoodGroupsPerServing.Find( fg => fg.Entity.Name == "Meat" );
             Assert.IsNotNull( serving );
             Assert.AreEqual( meat, serving.Entity );
             Assert.AreEqual( 1, serving.Quantity );

             // Create a new source food item, and use it to init the target item
             sourceFoodItem = new FoodItem( Guid.NewGuid(), "Frog Soup", "Frogs, Aritichokes, and stuff", 250 );
             sourceFoodItem.FoodGroupsPerServing.Add( new Serving<FoodGroup>( meat, 1 ) );
             sourceFoodItem.FoodGroupsPerServing.Add( new Serving<FoodGroup>( vegetable, 2 ) );
             sourceFoodItem.FoodGroupsPerServing.Add( new Serving<FoodGroup>( fruit, 0.5M ) );

             foodItem.InitializeData( sourceFoodItem );
             Assert.AreEqual( sourceFoodItem.ID, foodItem.ID );
             Assert.AreEqual( sourceFoodItem.Name, foodItem.Name );
             Assert.AreEqual( sourceFoodItem.Description, foodItem.Description );
             Assert.AreEqual( sourceFoodItem.FoodGroupsPerServing.Count, foodItem.FoodGroupsPerServing.Count );

             serving = foodItem.FoodGroupsPerServing.Find( fg => fg.Entity.Name == "Meat" );
             Assert.IsNotNull( serving );
             Assert.AreEqual( meat, serving.Entity );
             Assert.AreEqual( 1, serving.Quantity );

             serving = foodItem.FoodGroupsPerServing.Find( fg => fg.Entity.Name == "Vegetable" );
             Assert.IsNotNull( serving );
             Assert.AreEqual( vegetable, serving.Entity );
             Assert.AreEqual( 2, serving.Quantity );

             serving = foodItem.FoodGroupsPerServing.Find( fg => fg.Entity.Name == "Fruit" );
             Assert.IsNotNull( serving );
             Assert.AreEqual( fruit, serving.Entity );
             Assert.AreEqual( 0.5M, serving.Quantity );

             // We should also be able to take a Food Item and make something else out of it, such as a category
             FoodGroup category = new FoodGroup();
             category.InitializeData( sourceFoodItem );
             Assert.AreEqual( sourceFoodItem.ID, category.ID );
             Assert.AreEqual( sourceFoodItem.Name, category.Name );
             Assert.AreEqual( sourceFoodItem.Description, category.Description );
        }
예제 #25
0
 public FoodItem( FoodItem foodItem )
     : this()
 {
     this.InitializeData( foodItem );
 }
예제 #26
0
        public override void OnNavigatedTo( NavigationContext navigationContext )
        {
            if (Model == null)
             {
            String idParameter = navigationContext.Parameters["ID"];
            Guid myID;
            FoodItem foodItem = null;

            if (idParameter != null && Guid.TryParse( idParameter, out myID ))
            {
               foodItem = this.DataRepository.GetFoodItem( myID );
            }
            else
            {
               foodItem = new FoodItem();
            }
            Model = foodItem;

            // TODO: Read up and see if there is a better way of diabling the event.
            //       Also, refactor this into a private method.
            FoodGroupsPerServing.CollectionChanged -= OnFoodGroupServingsChanged;
            FoodGroupsPerServing.Clear();
            foreach (Serving<FoodGroup> serving in foodItem.FoodGroupsPerServing)
            {
               ServingViewModel<FoodGroup> servingViewModel = new ServingViewModel<FoodGroup>( serving );
               servingViewModel.PropertyChanged += OnFoodGroupServingPropertyChanged;
               FoodGroupsPerServing.Add( servingViewModel );
            }
            FoodGroupsPerServing.CollectionChanged += OnFoodGroupServingsChanged;

            base.OnNavigatedTo( navigationContext );
             }
        }
예제 #27
0
 /// <summary>
 /// Determine if the repository already contains the food item
 /// </summary>
 /// <param name="foodItem">The food item</param>
 /// <returns>Returns true if the food item is alread in the repository, false oterwise.</returns>
 public Boolean Contains( FoodItem foodItem )
 {
     return (_foodItems.Find( item => item.ID == foodItem.ID ) != null);
 }
        public void AddingMealForOtherDateToRepositoryDoesNotUpdateCaloriesAndFoodGroups()
        {
            PropertyChangedHandler propertyChangedHandler = new PropertyChangedHandler();

             var loggerMock = new Mock<ILoggerFacade>();
             var dataRepositoryMock = new Mock<IDataRepository>();
             var regionManagerMock = new Mock<IRegionManager>();
             var interactionServiceMock = new Mock<IInteractionService>();
             var navigationServiceMock = new Mock<IRegionNavigationService>();

             var data = new MockData();
             var fullMealList = data.Meals();
             var todaysMeals = (from meal in fullMealList
                            where meal.DateAndTimeOfMeal.Date == DateTime.Today
                            select meal).ToList();
             dataRepositoryMock.Setup( x => x.GetAllMealsForDate( DateTime.Today ) ).Returns(
            new ReadOnlyCollection<Meal>( todaysMeals ) );

             var viewModel = new DailyLogViewModel( dataRepositoryMock.Object, regionManagerMock.Object, interactionServiceMock.Object, loggerMock.Object );
             viewModel.CurrentDate = DateTime.Today;
             viewModel.PropertyChanged += propertyChangedHandler.OnPropertyChanged;

             Int32 originalFoodGroupCount = viewModel.FoodGroupServings.Count;
             Decimal originalFoodGroupServings = (from foodGroupServing in viewModel.FoodGroupServings
                                              select foodGroupServing.Quantity).Sum();
             Decimal originalCalories = viewModel.Calories;

             var foodItem = new FoodItem( Guid.NewGuid(), "test", "", 42 );
             foodItem.FoodGroupsPerServing.Add( new Serving<FoodGroup>( new FoodGroup( Guid.NewGuid(), "Test1", "" ), 2 ) );
             foodItem.FoodGroupsPerServing.Add( new Serving<FoodGroup>( new FoodGroup( Guid.NewGuid(), "Test2", "" ), 1 ) );
             var newMeal = new Meal(
            Guid.NewGuid(), new MealType( Guid.NewGuid(), "Doesn't Matter", "", DateTime.Now, false ), DateTime.Now.AddDays( 1 ), "Test Meal", "Just a test" );
             newMeal.FoodItemServings.Add( new Serving<FoodItem>( foodItem, 1 ) );
             dataRepositoryMock.Raise( e => e.ItemAdded += null, new RepositoryObjectEventArgs( newMeal ) );
             Assert.AreEqual( originalCalories, viewModel.Calories );
             Assert.AreEqual( originalFoodGroupCount, viewModel.FoodGroupServings.Count );
             Assert.AreEqual( originalFoodGroupServings, (from foodGroupServing in viewModel.FoodGroupServings
                                                      select foodGroupServing.Quantity).Sum() );

             Assert.AreEqual( 0, propertyChangedHandler.PropertiesChanged.Count );
        }
예제 #29
0
        public List<FoodItem> Foods()
        {
            if (_foods == null)
             {
            _foods = new List<FoodItem>();

            var fruit = FoodGroups().Find( fg => fg.ID == fruitID );
            var dairy = FoodGroups().Find( fg => fg.ID == dairyID );
            var meat = FoodGroups().Find( fg => fg.ID == meatID );
            var vegetable = FoodGroups().Find( fg => fg.ID == vegetableID );
            var starch = FoodGroups().Find( fg => fg.ID == starchID );

            var food = new FoodItem( milkID, "Milk", "Moo Juice", 90.0M );
            food.FoodGroupsPerServing.Add( new Serving<FoodGroup>( dairy, 1.0M ) );
            _foods.Add( food );

            food = new FoodItem( ojID, "Orange Juice", "Fresh Squeazed, lots of pulp", 100.0M );
            food.FoodGroupsPerServing.Add( new Serving<FoodGroup>( fruit, 1.0M ) );
            _foods.Add( food );

            // breakfast Foods
            food = new FoodItem( friedEggID, "Egg", "Chicken abortion, fried", 60.0M );
            food.FoodGroupsPerServing.Add( new Serving<FoodGroup>( meat, 1.0M ) );
            _foods.Add( food );

            food = new FoodItem( hashBrownsID, "Hash Browns", "Shredded tators", 125.5M );
            food.FoodGroupsPerServing.Add( new Serving<FoodGroup>( starch, 1.0M ) );
            _foods.Add( food );

            food = new FoodItem( baconID, "Bacon", "Meat of the gods", 100.0M );
            food.FoodGroupsPerServing.Add( new Serving<FoodGroup>( meat, 1.0M ) );
            _foods.Add( food );

            food = new FoodItem( cerealID, "Cereal", "Shredded Mini-Wheats", 125.0M );
            food.FoodGroupsPerServing.Add( new Serving<FoodGroup>( starch, 2.0M ) );
            _foods.Add( food );

            // lunch foods
            food = new FoodItem( hamSandwichID, "Ham Sandwich", "Dead cured pig between bread", 320.0M );
            food.FoodGroupsPerServing.Add( new Serving<FoodGroup>( meat, 1.0M ) );
            food.FoodGroupsPerServing.Add( new Serving<FoodGroup>( vegetable, 0.5M ) );
            food.FoodGroupsPerServing.Add( new Serving<FoodGroup>( dairy, 0.5M ) );
            food.FoodGroupsPerServing.Add( new Serving<FoodGroup>( starch, 2.0M ) );
            _foods.Add( food );

            food = new FoodItem( baconCheeseBurgerID, "Bacon Cheese Burger", "Burger of the gods", 600.0M );
            food.FoodGroupsPerServing.Add( new Serving<FoodGroup>( meat, 2.0M ) );
            food.FoodGroupsPerServing.Add( new Serving<FoodGroup>( starch, 1.0M ) );
            food.FoodGroupsPerServing.Add( new Serving<FoodGroup>( vegetable, 0.25M ) );
            food.FoodGroupsPerServing.Add( new Serving<FoodGroup>( dairy, 0.5M ) );
            _foods.Add( food );

            food = new FoodItem( frenchFriesID, "French Fries", "Skinny deep fried tators", 200.0M );
            food.FoodGroupsPerServing.Add( new Serving<FoodGroup>( starch, 1.5M ) );
            _foods.Add( food );

            food = new FoodItem( carrotSticksID, "carrotSticks", "Orange skinny poser FFs", 40M );
            food.FoodGroupsPerServing.Add( new Serving<FoodGroup>( vegetable, 1.0M ) );
            _foods.Add( food );

            // Dinner foods - food items dones as full meals.
            food = new FoodItem( chickenDinnerID, "Chicken Dinner", "Chicken, spuds, and veggies", 700 );
            food.FoodGroupsPerServing.Add( new Serving<FoodGroup>( meat, 1.0M ) );
            food.FoodGroupsPerServing.Add( new Serving<FoodGroup>( vegetable, 1.0M ) );
            food.FoodGroupsPerServing.Add( new Serving<FoodGroup>( starch, 1.0M ) );
            _foods.Add( food );

            food = new FoodItem( steakDinnerID, "Steak Dinner", "Cow, spuds, and veggies", 1200 );
            food.FoodGroupsPerServing.Add( new Serving<FoodGroup>( meat, 1.5M ) );
            food.FoodGroupsPerServing.Add( new Serving<FoodGroup>( vegetable, 1.0M ) );
            food.FoodGroupsPerServing.Add( new Serving<FoodGroup>( starch, 1.0M ) );
            _foods.Add( food );
             }

             return _foods;
        }