public void AggregateAmountData_OverallMaximumAmount_Calculates()
        {
            // Arrange
            TransactionGrouper    grouper    = TransactionGrouper.Overall;
            TransactionAggregator aggregator = TransactionAggregator.MaximumAmount;

            TransactionData[] transactions =
            {
                new TransactionData()
                {
                    Amount = 1
                },
                new TransactionData()
                {
                    Amount = 2
                },
                new TransactionData()
                {
                    Amount = 3
                },
                new TransactionData()
                {
                    Amount = 4
                },
                new TransactionData()
                {
                    Amount = 5
                },
                new TransactionData()
                {
                    Amount = 6
                },
                new TransactionData()
                {
                    Amount = 7
                },
                new TransactionData()
                {
                    Amount = 8
                },
                new TransactionData()
                {
                    Amount = 9
                }
            };
            IEnumerable <TransactionData> expectedData = new TransactionData[]
            {
                new TransactionData()
                {
                    Amount = 9
                }
            };

            // Act
            IEnumerable <TransactionData> actualData = Program.AggregateAmountData(transactions, grouper, aggregator);

            // Assert
            Assert.AreEqual(expectedData, actualData);
        }
Beispiel #2
0
        public static void OutputTransactionStats(TransactionGrouper grouper, TransactionAggregator aggregator)
        {
            IEnumerable <TransactionData> amountStats = AggregateAmountData(Transactions, grouper, aggregator);

            foreach (TransactionData stats in amountStats)
            {
                Console.WriteLine($"- {grouper} {aggregator} {stats}");
            }
        }
        public void Run(APIGatewayProxyRequest request, APIGatewayProxyResponse response, FinanceUser user)
        {
            var startDate = request.QueryStringParameters != null &&
                            request.QueryStringParameters.ContainsKey("startDate")
                ? request.QueryStringParameters["startDate"]
                : string.Empty;
            var endDate = request.QueryStringParameters != null &&
                          request.QueryStringParameters.ContainsKey("endDate")
                ? request.QueryStringParameters["endDate"]
                : string.Empty;
            var transactions = new TransactionAggregator()
                               .GetTransactions(
                Configuration.BankClient,
                user,
                startDate,
                endDate);

            response.Body = JsonConvert.SerializeObject(transactions);
        }
Beispiel #4
0
 public static IEnumerable <TransactionData> AggregateAmountData(IEnumerable <TransactionData> transactionData,
                                                                 TransactionGrouper grouper, TransactionAggregator aggregator)
 {
     return(transactionData
            .GroupBy(grouper.KeyFunction, aggregator.AggregateFunction));
 }
        public void AggregateAmountData_YearlyTotalAmount_Calculates()
        {
            // Arrange
            TransactionGrouper    grouper    = TransactionGrouper.Yearly;
            TransactionAggregator aggregator = TransactionAggregator.TotalAmount;

            TransactionData[] transactions =
            {
                new TransactionData()
                {
                    Year = 2000, Amount = 1
                },
                new TransactionData()
                {
                    Year = 2000, Amount = 2
                },
                new TransactionData()
                {
                    Year = 2000, Amount = 3
                },
                new TransactionData()
                {
                    Year = 2001, Amount = 4
                },
                new TransactionData()
                {
                    Year = 2001, Amount = 5
                },
                new TransactionData()
                {
                    Year = 2001, Amount = 6
                },
                new TransactionData()
                {
                    Year = 2002, Amount = 7
                },
                new TransactionData()
                {
                    Year = 2002, Amount = 8
                },
                new TransactionData()
                {
                    Year = 2002, Amount = 9
                }
            };
            IEnumerable <TransactionData> expectedData = new TransactionData[]
            {
                new TransactionData()
                {
                    Year = 2000, Amount = 6
                },
                new TransactionData()
                {
                    Year = 2001, Amount = 15
                },
                new TransactionData()
                {
                    Year = 2002, Amount = 24
                }
            };

            // Act
            IEnumerable <TransactionData> actualData = Program.AggregateAmountData(transactions, grouper, aggregator);

            // Assert
            Assert.AreEqual(expectedData, actualData);
        }