Example #1
0
        public async Task CreateLoan(LooseLeafContext context, int _LenderId, int _BorrowerId)
        {
            var loan = new DataAccess.Loan()
            {
                LenderId     = _LenderId,
                BorrowerId   = _BorrowerId,
                Message      = "Test loan message",
                LoanStatusId = 1,
                DropoffDate  = new DateTime(2021, 3, 20),
                ReturnedDate = new DateTime(2021, 3, 23),
                AddressId    = 1
            };
            var loanbooks = new List <LoanedBook> {
                new LoanedBook()
                {
                    Loan = loan, OwnedBookid = 1
                }, new LoanedBook()
                {
                    Loan = loan, OwnedBookid = 2
                }, new LoanedBook()
                {
                    Loan = loan, OwnedBookid = 3
                }
            };
            await context.Loans.AddAsync(loan);

            await context.LoanedBooks.AddRangeAsync(loanbooks);
        }
Example #2
0
        public async Task Loans_GetAllAsync()
        {
            // arrange
            const string LENDER_USERNAME   = "******";
            const string BORROWER_USERNAME = "******";
            const string LOAN_MESSAGE      = "Hello, I would like to borrow your book.";
            const int    LENDER_ID         = 1;
            const int    BORROWER_ID       = 2;

            const int FIRST_OWNED_BOOK_ID  = 1;
            const int SECOND_OWNED_BOOK_ID = 2;

            using var contextFactory = new TestLooseLeafContextFactory();
            using (LooseLeafContext arrangeContext = contextFactory.CreateContext())
            {
                await contextFactory.CreateAddress(arrangeContext);

                await contextFactory.CreateUser(arrangeContext, LENDER_USERNAME);

                await contextFactory.CreateUser(arrangeContext, BORROWER_USERNAME);

                await contextFactory.CreateBook(arrangeContext, "Book 1", "Author 1");

                await contextFactory.CreateOwnedBook(arrangeContext, LENDER_ID, FIRST_OWNED_BOOK_ID);

                await contextFactory.CreateBook(arrangeContext, "Book 2", "Author 2");

                await contextFactory.CreateOwnedBook(arrangeContext, LENDER_ID, SECOND_OWNED_BOOK_ID);

                var loan = new DataAccess.Loan()
                {
                    LenderId     = LENDER_ID,
                    BorrowerId   = BORROWER_ID,
                    Message      = LOAN_MESSAGE,
                    LoanStatusId = (int)Business.Models.LoanStatus.Approved,
                    AddressId    = 1,
                    DropoffDate  = new DateTime(2000, 10, 1),
                    ReturnedDate = new DateTime(2000, 10, 17),
                };

                var loanedBooks = new List <DataAccess.LoanedBook>()
                {
                    new LoanedBook()
                    {
                        Loan = loan, OwnedBookid = FIRST_OWNED_BOOK_ID
                    },
                    new LoanedBook()
                    {
                        Loan = loan, OwnedBookid = SECOND_OWNED_BOOK_ID
                    }
                };

                await arrangeContext.AddAsync(loan);

                await arrangeContext.AddRangeAsync(loanedBooks);

                await arrangeContext.SaveChangesAsync();
            }

            // act
            IEnumerable <ILoanResult> loans;

            using (LooseLeafContext actContext = contextFactory.CreateContext())
            {
                LoanRepository    loanRepository = new LoanRepository(actContext);
                ILoanSearchParams searchParams   = new LoanSearchParams();
                loans = await loanRepository.GetLoansAsync(searchParams);
            }

            // assert
            var firstLoan = loans.First();

            Assert.Single(loans);
            Assert.Equal(LENDER_ID, firstLoan.Lender.Id);
            Assert.Equal(BORROWER_ID, firstLoan.Borrower.Id);
            Assert.Equal(LOAN_MESSAGE, firstLoan.Message);
            Assert.Equal(FIRST_OWNED_BOOK_ID, firstLoan.LoanedBooks.First().Id);
            Assert.Equal(SECOND_OWNED_BOOK_ID, firstLoan.LoanedBooks.Last().Id);
        }