public void Can_Get_Summary_With_Grouping()
        {
            using (var mock = AutoMock.GetLoose())
            {
                // Arrange
                var config           = mock.Provide <IAppConfig, TestConfig>();
                var groupedBy        = "Type";
                var testPet          = GetTestPet();
                var expectedMetadata = new Metadata(new[]
                {
                    Link.Self($"{Constants.TOKENIZED_CURRENT_URL}", HttpMethod.Get.Method),
                });
                var expectedCount = new EntityCount(groupedBy, new Dictionary <string, long>
                {
                    { PetType.Cat.ToString(), 1 }
                });
                var expectedFoodSummaryModel = new FoodSummaryModel();
                expectedFoodSummaryModel.FoodCounts.Add(new FoodCount(FoodType.Fish, 1));
                var expected = new SingleResponse(Result.Success, expectedMetadata, expectedFoodSummaryModel);
                mock.Mock <IRepository <PetEntity> >().Setup(x => x.Count <PetType>(groupedBy)).ReturnsAsync(expectedCount);
                var systemUnderTest = mock.Create <FoodService>();

                // Act
                var actual = systemUnderTest.Summary().Result;

                // Assert
                mock.Mock <IRepository <PetEntity> >().VerifyAll();
                Assert.IsNotNull(actual);
                Assert.IsNull(actual.Errors);
                Assert.IsNotNull(actual.Data);
                Assert.IsNotNull(actual.Metadata);
                Assert.IsNotNull(actual.Metadata.Links);
                Assert.AreEqual(actual.Result, Result.Success);
                var actualFoodSummary = actual.Data as FoodSummaryModel;
                Assert.IsNotNull(actualFoodSummary.FoodCounts);
                Assert.AreEqual(expectedFoodSummaryModel.FoodCounts.Count, actualFoodSummary.FoodCounts.Count);
                Assert.IsTrue(FoodCountsAreEqual(expectedFoodSummaryModel.FoodCounts, actualFoodSummary.FoodCounts));
                Assert.AreEqual(expected.Metadata.ServerVersion, actual.Metadata.ServerVersion);
                Assert.IsTrue(MetadataLinksAreEqual(expected.Metadata.Links, actual.Metadata.Links));
            }
        }
Esempio n. 2
0
        public async Task <SingleResponse> Summary()
        {
            var metadata = new Metadata(new[]
            {
                Link.Self($"{Constants.TOKENIZED_CURRENT_URL}", HttpMethod.Get.Method),
            });

            try
            {
                var petEntityCount = await PetRepository.Count <PetType>("Type");

                if (petEntityCount == null)
                {
                    return(new SingleResponse(Result.NotFound, new Metadata(Link.Self($"{Constants.TOKENIZED_CURRENT_URL}", HttpMethod.Get.Method)), $"Could not find any data!"));
                }
                var foodSummaryModel = new FoodSummaryModel();
                foreach (var value in petEntityCount.Values)
                {
                    var foodType = FoodType.Undefined;
                    if (string.IsNullOrEmpty(value.Key))
                    {
                        foodType = FoodType.All;
                    }
                    else
                    {
                        foodType = Mapper.Map <FoodType>(value.Key.ToEnum <PetType>());
                    }
                    foodSummaryModel.FoodCounts.Add(new FoodCount(foodType, value.Value));
                }

                return(new SingleResponse(Result.Success, metadata, foodSummaryModel));
            }
            catch (DataException <PetEntity> ex)
            {
                return(new SingleResponse(ex.Result, metadata, $"{ex.Message}"));
            }
            catch (Exception ex)
            {
                return(new SingleResponse(Result.InternalError, metadata, $"{ex.GetBaseException().Message}"));
            }
        }