示例#1
0
        public void UpdateSpecificExpenseShouldModifyGivenExpense()
        {
            var options = new DbContextOptionsBuilder <DataDbContext>()
                          .UseInMemoryDatabase(databaseName: nameof(UpdateSpecificExpenseShouldModifyGivenExpense))
                          .Options;

            using (var context = new DataDbContext(options))
            {
                var expenseService = new ExpensesService(context);

                var toAddExpense = new ExpensesPostModel()
                {
                    Description = "Test description",
                    Sum         = 20,
                    Location    = "Cluj",
                    Date        = DateTime.ParseExact("05/30/2019", "MM/dd/yyyy", CultureInfo.InvariantCulture),
                    Currency    = "RON",
                    Type        = "Utilities",
                    Comments    = new List <Comment>()
                    {
                        new Comment()
                        {
                            Text      = "A test comment",
                            Important = false
                        }
                    }
                };
                var addedExpense = expenseService.AddExpense(toAddExpense);

                // new modified expense
                var toUpdatedExpense = new ExpensesPostModel()
                {
                    Description = "Test description updated",
                    Sum         = 30,
                    Location    = "Brasov",
                    Date        = DateTime.ParseExact("05/31/2019", "MM/dd/yyyy", CultureInfo.InvariantCulture),
                    Currency    = "Euro",
                    Type        = "Food",
                    Comments    = new List <Comment>()
                    {
                        new Comment()
                        {
                            Text      = "An updated test comment",
                            Important = true
                        }
                    }
                };
                var updatedExpense = expenseService.UpsertExpense(addedExpense.Id, toUpdatedExpense);


                Assert.IsNotNull(updatedExpense);
                Assert.AreEqual(toUpdatedExpense.Description, updatedExpense.Description);
                Assert.AreEqual(toUpdatedExpense.Sum, updatedExpense.Sum);
                Assert.AreEqual(toUpdatedExpense.Location, updatedExpense.Location);
                Assert.AreEqual(toUpdatedExpense.Date, updatedExpense.Date);
                Assert.AreEqual(toUpdatedExpense.Currency, updatedExpense.Currency);
                Assert.AreEqual(toUpdatedExpense.Type, updatedExpense.Type.ToString());
                Assert.AreEqual(toUpdatedExpense.Comments, updatedExpense.Comments);
            }
        }
示例#2
0
        public void AddExpenseWithInvalidTypeFieldShouldNotCreateANewExpense()
        {
            var options = new DbContextOptionsBuilder <DataDbContext>()
                          .UseInMemoryDatabase(databaseName: nameof(AddExpenseWithInvalidTypeFieldShouldNotCreateANewExpense))
                          .Options;

            using (var context = new DataDbContext(options))
            {
                var expenseService = new ExpensesService(context);

                var expected = new ExpensesPostModel()
                {
                    Description = "Test description",
                    Sum         = 20,
                    Location    = "Cluj",
                    Date        = DateTime.ParseExact("05/30/2019", "MM/dd/yyyy", CultureInfo.InvariantCulture),
                    Currency    = "RON",
                    Type        = "Invalid Type",
                    Comments    = null
                };

                var actual = expenseService.AddExpense(expected);

                Assert.IsNull(actual);
            }
        }
示例#3
0
        public void DeleteValidExpenseShouldDeleteExpense()
        {
            var options = new DbContextOptionsBuilder <DataDbContext>()
                          .UseInMemoryDatabase(databaseName: nameof(DeleteValidExpenseShouldDeleteExpense))
                          .Options;

            using (var context = new DataDbContext(options))
            {
                var expenseService = new ExpensesService(context);

                var expected = new ExpensesPostModel()
                {
                    Description = "Test description",
                    Sum         = 20,
                    Location    = "Cluj",
                    Date        = DateTime.ParseExact("05/30/2019", "MM/dd/yyyy", CultureInfo.InvariantCulture),
                    Currency    = "RON",
                    Type        = "Food",
                    Comments    = null
                };
                // add the expense to db
                var actual = expenseService.AddExpense(expected);
                // delete expense and put return expense in obj
                var afterDelete = expenseService.DeleteExpense(actual.Id);
                // search for the added expense to see if exists in db
                var result = context.Expensess.Find(actual.Id);

                Assert.IsNotNull(afterDelete);
                Assert.IsNull(result);
            }
        }
示例#4
0
        public void GetExpenseByInvalidIdShouldNotFindAnyExpense()
        {
            var options = new DbContextOptionsBuilder <DataDbContext>()
                          .UseInMemoryDatabase(databaseName: nameof(GetExpenseByInvalidIdShouldNotFindAnyExpense))
                          .Options;

            using (var context = new DataDbContext(options))
            {
                var expenseService = new ExpensesService(context);

                var toAddExpense = new ExpensesPostModel()
                {
                    Description = "Test description",
                    Sum         = 20,
                    Location    = "Cluj",
                    Date        = DateTime.ParseExact("05/30/2019", "MM/dd/yyyy", CultureInfo.InvariantCulture),
                    Currency    = "RON",
                    Type        = "Utilities",
                    Comments    = new List <Comment>()
                    {
                        new Comment()
                        {
                            Text      = "A test comment",
                            Important = false
                        }
                    }
                };

                var actual = expenseService.AddExpense(toAddExpense);

                var expected = expenseService.GetExpenseById(55555);

                Assert.IsNull(expected);
            }
        }
 public IActionResult Post([FromBody] ExpensesPostModel expenses)
 {
     if (!ModelState.IsValid)
     {
         return(BadRequest(expenses));
     }
     expensesService.AddExpense(expenses);
     return(Ok());
 }
示例#6
0
        /// <summary>
        /// Create a new Expense, using ExpensesPostModel so we can use string for type
        /// </summary>
        /// <param name="expenses">New Expense object</param>
        /// <returns>Expense added</returns>
        public ExpensesPostModel Create(ExpensesPostModel expenses)
        {
            Expenses toAdd = ExpensesPostModel.ToExpenses(expenses);

            context.Expensess.Add(toAdd);
            context.SaveChanges();

            return(expenses);
        }
        public IActionResult Put(int id, [FromBody] ExpensesPostModel expenses)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(expenses));
            }
            var result = expensesService.UpsertExpense(id, expenses);

            return(Ok());
        }
示例#8
0
        /// <summary>
        /// Create a new Expense, using ExpensesPostModel so we can use string for type
        /// </summary>
        /// <param name="expenses">New Expense object</param>
        /// <returns>Expense added</returns>
        public Expenses AddExpense(ExpensesPostModel expenses)
        {
            Expenses toAdd = ExpensesPostModel.ToExpenses(expenses);

            if (toAdd == null)
            {
                return(null);
            }
            context.Expensess.Add(toAdd);
            context.SaveChanges();

            return(toAdd);
        }
示例#9
0
        /// <summary>
        /// Update/Inseret
        /// </summary>
        /// <param name="id">Id for update, otherwise add</param>
        /// <param name="expenses">New Expense Object that we want to add</param>
        /// <returns>Expense we gave</returns>
        public Expenses UpsertExpense(int id, ExpensesPostModel expenses)
        {
            var existing = context.Expensess.AsNoTracking().Include(c => c.Comments).FirstOrDefault(c => c.Id == id);

            if (existing == null)
            {
                var expense = context.Expensess.Add(ExpensesPostModel.ToExpenses(expenses));
                context.SaveChanges();
                return(expense.Entity);
            }

            var res = ExpensesPostModel.ToUpdateExpenses(expenses, existing);

            context.SaveChanges();
            return(res);
        }
示例#10
0
        public void GetCommentsFilteredByValueShouldReturnAListOfFilteredComments()
        {
            var options = new DbContextOptionsBuilder <DataDbContext>()
                          .UseInMemoryDatabase(databaseName: nameof(GetCommentsFilteredByValueShouldReturnAListOfFilteredComments))
                          .Options;

            using (var context = new DataDbContext(options))
            {
                var commentsService = new CommentsService(context);
                var expensesService = new ExpensesService(context);

                var expenseWithCommentToAdd = new ExpensesPostModel()
                {
                    Description = "Test description",
                    Sum         = 20,
                    Location    = "Cluj",
                    Date        = DateTime.ParseExact("05/30/2019", "MM/dd/yyyy", CultureInfo.InvariantCulture),
                    Currency    = "RON",
                    Type        = "Utilities",
                    Comments    = new List <Comment>()
                    {
                        new Comment()
                        {
                            Text      = "A test comment 1 filtered",
                            Important = false
                        },
                        new Comment()
                        {
                            Text      = "A test comment 2 filtered",
                            Important = true
                        },
                        new Comment()
                        {
                            Text      = "A test comment 3",
                            Important = false
                        }
                    }
                };
                expensesService.AddExpense(expenseWithCommentToAdd);

                List <CommentGetModel> comments = commentsService.GetAll("filtered");
                int numberOfComments            = comments.Count;

                Assert.IsNotNull(comments);
                Assert.AreEqual(2, numberOfComments);
            }
        }
示例#11
0
        public void DeleteValidExpenseWithCommentsShouldDeleteExpenseAndComments()
        {
            var options = new DbContextOptionsBuilder <DataDbContext>()
                          .UseInMemoryDatabase(databaseName: nameof(DeleteValidExpenseWithCommentsShouldDeleteExpenseAndComments))
                          .Options;

            using (var context = new DataDbContext(options))
            {
                var expenseService = new ExpensesService(context);

                var expected = new ExpensesPostModel()
                {
                    Description = "Test description",
                    Sum         = 20,
                    Location    = "Cluj",
                    Date        = DateTime.ParseExact("05/30/2019", "MM/dd/yyyy", CultureInfo.InvariantCulture),
                    Currency    = "RON",
                    Type        = "Food",
                    Comments    = new List <Comment>()
                    {
                        new Comment()
                        {
                            Text      = "A test comment",
                            Important = false
                        }
                    }
                };
                // add the expense to db
                var actual = expenseService.AddExpense(expected);
                // delete expense and put return expense in obj
                var afterDelete = expenseService.DeleteExpense(actual.Id);
                // find the number of comments that exists in db
                int numberOfCommentsInDb = context.Comments.CountAsync().Result;
                // search for the added expense to see if exists in db
                var resultExpense = context.Expensess.Find(actual.Id);

                Assert.IsNotNull(afterDelete);
                Assert.IsNull(resultExpense);
                Assert.AreEqual(0, numberOfCommentsInDb);
            }
        }
示例#12
0
        public void AddAValidExpenseShouldCreateANewExpense()
        {
            var options = new DbContextOptionsBuilder <DataDbContext>()
                          .UseInMemoryDatabase(databaseName: nameof(AddAValidExpenseShouldCreateANewExpense))
                          .Options;

            using (var context = new DataDbContext(options))
            {
                var expenseService = new ExpensesService(context);

                var expected = new ExpensesPostModel()
                {
                    Description = "Test description",
                    Sum         = 20,
                    Location    = "Cluj",
                    Date        = DateTime.ParseExact("05/30/2019", "MM/dd/yyyy", CultureInfo.InvariantCulture),
                    Currency    = "RON",
                    Type        = "Utilities",
                    Comments    = new List <Comment>()
                    {
                        new Comment()
                        {
                            Text      = "A test comment",
                            Important = false
                        }
                    }
                };

                var actual = expenseService.AddExpense(expected);

                Assert.IsNotNull(actual);
                Assert.AreEqual(expected.Description, actual.Description);
                Assert.AreEqual(expected.Sum, actual.Sum);
                Assert.AreEqual(expected.Location, actual.Location);
                Assert.AreEqual(expected.Date, actual.Date);
                Assert.AreEqual(expected.Currency, actual.Currency);
                Assert.AreEqual(expected.Type, actual.Type.ToString());
                Assert.AreEqual(expected.Comments, actual.Comments);
            }
        }