public void CanCompleteScans()
{
var loan = Substitute.For<ILoan>();
var ctrl = new BorrowController(_display, _reader, _scanner, _printer, _bookDao, _loanDao, _memberDao);
// Set the UI to the mock so we can test
var borrowctrl = Substitute.For<ABorrowControl>();
ctrl._ui = borrowctrl;
ctrl.initialise();
// Set Pre-conditions
ctrl._state = EBorrowState.SCANNING_BOOKS;
ctrl._loanList.Add(loan);
ctrl._loanList.Add(loan);
Assert.NotNull(ctrl);
Assert.NotEmpty(ctrl._loanList);
Assert.Equal(EBorrowState.SCANNING_BOOKS, ctrl._state);
ctrl.scansCompleted();
borrowctrl.Received(2).DisplayConfirmingLoan(loan.ToString());
Assert.True(!_reader.Enabled);
Assert.True(!_scanner.Enabled);
Assert.Equal(EBorrowState.CONFIRMING_LOANS, ctrl._state);
}
public void CanCompleteScans()
{
var member = _memberDao.AddMember("Jim", "Tulip", "Phone", "Email");
var book = _bookDao.AddBook("Jim Tulip", "Adventures in Programming", "call number");
var loan = _loanDao.CreateLoan(member, book, DateTime.Today, DateTime.Today.AddDays(7));
var ctrl = new BorrowController(_display, _reader, _scanner, _printer, _bookDao, _loanDao, _memberDao);
// Set the UI to the mock so we can test
var borrowctrl = Substitute.For<ABorrowControl>();
ctrl._ui = borrowctrl;
ctrl.initialise();
// Set Pre-conditions
ctrl._state = EBorrowState.SCANNING_BOOKS;
ctrl._loanList.Add(loan);
Assert.NotNull(ctrl);
Assert.NotEmpty(ctrl._loanList);
Assert.Equal(EBorrowState.SCANNING_BOOKS, ctrl._state);
ctrl.scansCompleted();
borrowctrl.Received().DisplayConfirmingLoan(loan.ToString());
Assert.True(!_reader.Enabled);
Assert.True(!_scanner.Enabled);
Assert.Equal(EBorrowState.CONFIRMING_LOANS, ctrl._state);
}
public void RunBookAlreadyScanned()
{
// Some test data initialisation
var borrowDate = DateTime.Today;
var dueDate = DateTime.Today.AddDays(7);
var member = _memberDao.AddMember("Jim", "Tulip", "Phone", "Email");
var existingBook = _bookDao.AddBook("Jim Tulip", "Adventures in Programming", "call number");
var existingLoan = _loanDao.CreateLoan(member, existingBook, borrowDate, dueDate);
_loanDao.CommitLoan(existingLoan);
var book = _bookDao.AddBook("Jim Tulip", "Adventures in Programming 2", "call number");
// Set up
var controller = new BorrowController(_display, _reader, _scanner, _printer,
_bookDao, _loanDao, _memberDao);
controller.initialise();
controller.cardSwiped(member.ID);
controller._bookList.Add(book);
// Test Pre-conditions
Assert.True(_display.Display.IsEnabled);
var borrowCtrl = ((BorrowControl)_display.Display);
var scanBookCtrl = borrowCtrl._controlDict.Single(c => c.Value is ScanBookControl).Value as ScanBookControl;
Assert.NotNull(scanBookCtrl);
Assert.True(scanBookCtrl.IsEnabled);
Assert.True(scanBookCtrl.cancelButton.IsEnabled);
Assert.True(scanBookCtrl.completeButton.IsEnabled);
Assert.True(!_reader.Enabled);
Assert.True(_scanner.Enabled);
Assert.Equal(controller, _scanner.Listener);
Assert.Equal(member.Loans.Count, controller.scanCount);
Assert.Equal(member, controller._borrower);
Assert.Equal(EBorrowState.SCANNING_BOOKS, controller._state);
// Run use case
controller.bookScanned(book.ID);
// Test Post-conditions
Assert.True(scanBookCtrl.IsEnabled);
Assert.True(scanBookCtrl.cancelButton.IsEnabled);
Assert.True(scanBookCtrl.completeButton.IsEnabled);
Assert.True(!_reader.Enabled);
Assert.True(_scanner.Enabled);
Assert.Equal("Book has already been scanned", scanBookCtrl.errorMessage.Content);
Assert.Equal(EBorrowState.SCANNING_BOOKS, controller._state);
}
public void RunMemberExistsAndNotRestricted()
{
// Set up
var controller = new BorrowController(_display, _reader, _scanner, _printer,
_bookDao, _loanDao, _memberDao);
controller.initialise();
// Some test data initialisation
var borrowDate = DateTime.Today;
var dueDate = DateTime.Today.AddDays(7);
var member = _memberDao.AddMember("Jim", "Tulip", "Phone", "Email");
var book = _bookDao.AddBook("Jim Tulip", "Adventures in Programming", "call number");
var loan = _loanDao.CreateLoan(member, book, borrowDate, dueDate);
_loanDao.CommitLoan(loan);
// Test Pre-conditions
Assert.True(_display.Display.IsEnabled);
var borrowCtrl = ((BorrowControl)_display.Display);
var swipeCtrl = borrowCtrl._controlDict.Single(c => c.Value is SwipeCardControl).Value as SwipeCardControl;
var scanBookCtrl = borrowCtrl._controlDict.Single(c => c.Value is ScanBookControl).Value as ScanBookControl;
Assert.NotNull(swipeCtrl);
Assert.True(swipeCtrl.IsEnabled);
Assert.True(swipeCtrl.cancelButton.IsEnabled);
Assert.True(_reader.Enabled);
Assert.Equal(controller, _reader.Listener);
Assert.NotNull(controller._memberDAO);
Assert.Equal(EBorrowState.INITIALIZED, controller._state);
// Run use case
controller.cardSwiped(member.ID);
// Test Post-conditions
Assert.NotNull(scanBookCtrl);
Assert.True(scanBookCtrl.IsEnabled);
Assert.True(scanBookCtrl.cancelButton.IsEnabled);
Assert.True(scanBookCtrl.completeButton.IsEnabled);
Assert.True(!_reader.Enabled);
Assert.True(_scanner.Enabled);
Assert.Equal(member.ID, scanBookCtrl.idLabel.Content);
Assert.Equal($"{member.FirstName} {member.LastName}", scanBookCtrl.nameLabel.Content.ToString());
Assert.Equal(member.Loans[0].ToString(), scanBookCtrl.existingLoanBox.Text); // Test one existing loan is present
Assert.Equal(member.Loans.Count, controller.scanCount);
Assert.Equal(member, controller._borrower);
Assert.Equal(EBorrowState.SCANNING_BOOKS, controller._state);
}
public void RunScenario()
{
var bookDao = new BookDao(new BookHelper());
var loanDao = new LoanDao(new LoanHelper());
var memberDao = new MemberDao(new MemberHelper());
var display = new MainWindow();
var reader = new CardReader();
var scanner = new Scanner();
var printer = new Printer();
var controller = new BorrowController(display, reader, scanner, printer,
bookDao, loanDao, memberDao);
// Test pre-conditions
Assert.NotNull(controller);
Assert.NotNull(bookDao);
Assert.NotNull(loanDao);
Assert.NotNull(memberDao);
Assert.NotNull(display);
Assert.NotNull(reader);
Assert.NotNull(scanner);
Assert.NotNull(printer);
Assert.Equal(controller._bookDAO, bookDao);
Assert.Equal(controller._loanDAO, loanDao);
Assert.Equal(controller._memberDAO, memberDao);
Assert.Equal(controller._display, display);
Assert.Equal(controller._reader, reader);
Assert.Equal(controller._scanner, scanner);
Assert.Equal(controller._printer, printer);
Assert.Equal(controller._reader.Listener, controller);
Assert.Equal(controller._scanner.Listener, controller);
Assert.Equal(EBorrowState.CREATED, controller._state);
// Run use case
controller.initialise();
// Test post-conditions
// Borrow book UI Displayed
Assert.True(display.Display.IsEnabled);
var borrowCtrl = ((BorrowControl) display.Display);
var swipeCtrl = borrowCtrl._controlDict.Single(c => c.Value is SwipeCardControl).Value as SwipeCardControl;
Assert.NotNull(swipeCtrl);
Assert.True(swipeCtrl.IsEnabled);
Assert.True(swipeCtrl.cancelButton.IsEnabled);
Assert.True(reader.Enabled);
Assert.True(!scanner.Enabled);
Assert.Equal(EBorrowState.INITIALIZED, controller._state);
}
public void ScanBooksBookScanCountLessThanLoanLimit()
{
var member = CreateMockIMember();
var book = Substitute.For<IBook>();
book.State.Returns(BookState.AVAILABLE);
var borrowDate = DateTime.Today;
var dueDate = DateTime.Today.AddDays(7);
var loan = Substitute.For<Loan>(book, member, borrowDate, dueDate);
var ctrl = new BorrowController(_display, _reader, _scanner, _printer, _bookDao, _loanDao, _memberDao);
// Set the UI to the mock so we can test
var borrowctrl = Substitute.For<ABorrowControl>();
ctrl._ui = borrowctrl;
InitialiseToScanBookPreConditions(ctrl, member);
_bookDao.GetBookByID(0).Returns(book);
_loanDao.CreateLoan(member, book, borrowDate, dueDate).Returns(loan);
ctrl.bookScanned(0);
_bookDao.Received().GetBookByID(0);
_loanDao.Received().CreateLoan(member, book, borrowDate, dueDate);
borrowctrl.Received().DisplayScannedBookDetails(book.ToString());
borrowctrl.Received().DisplayPendingLoan(loan.ToString());
Assert.Equal(1, ctrl.scanCount);
Assert.NotNull(ctrl._loanList);
Assert.NotEmpty(ctrl._loanList);
Assert.Equal(1, ctrl._loanList.Count);
Assert.Equal(loan, ctrl._loanList[0]);
Assert.NotNull(ctrl._bookList);
Assert.NotEmpty(ctrl._bookList);
Assert.Equal(1, ctrl._bookList.Count);
Assert.Equal(book, ctrl._bookList[0]);
Assert.Equal(EBorrowState.SCANNING_BOOKS, ctrl._state);
}
public void CanCreateControl()
{
var ctrl = new BorrowController(_display, _reader, _scanner, _printer, _bookDao, _loanDao, _memberDao);
Assert.NotNull(ctrl);
}
public void CanRejectLoans()
{
var loan = Substitute.For<ILoan>();
var member = CreateMockIMember();
member.Loans.Returns(new List<ILoan>() { loan });
var ctrl = new BorrowController(_display, _reader, _scanner, _printer, _bookDao, _loanDao, _memberDao);
InitialiseToScanBookPreConditions(ctrl, member);
// Set the UI to the mock so we can test
var borrowctrl = Substitute.For<ABorrowControl>();
ctrl._ui = borrowctrl;
// Set Pre-conditions
ctrl._state = EBorrowState.CONFIRMING_LOANS;
ctrl._loanList.Add(loan);
ctrl._loanList.Add(loan);
Assert.NotNull(ctrl);
Assert.NotEmpty(ctrl._loanList);
Assert.Equal(EBorrowState.CONFIRMING_LOANS, ctrl._state);
ctrl.loansRejected();
borrowctrl.Received().DisplayMemberDetails(member.ID, member.ToString(), member.ContactPhone);
borrowctrl.Received().DisplayExistingLoan(loan.ToString());
borrowctrl.Received().DisplayPendingLoan("");
borrowctrl.Received().DisplayScannedBookDetails("");
Assert.Empty(ctrl._loanList);
Assert.Empty(ctrl._bookList);
Assert.Equal(1, ctrl.scanCount);
Assert.True(!_reader.Enabled);
Assert.True(_scanner.Enabled);
Assert.Equal(EBorrowState.SCANNING_BOOKS, ctrl._state);
}
public void RunMemberExistsAndRestricted()
{
// Set up
var controller = new BorrowController(_display, _reader, _scanner, _printer,
_bookDao, _loanDao, _memberDao);
controller.initialise();
// Some test data initialisation
var borrowDate = DateTime.Today;
var dueDate = DateTime.Today.AddDays(7);
var member = _memberDao.AddMember("Jim", "Tulip", "Phone", "Email");
var book = _bookDao.AddBook("Jim Tulip", "Adventures in Programming", "call number");
var loan = _loanDao.CreateLoan(member, book, borrowDate, dueDate);
_loanDao.CommitLoan(loan);
// Make the loan overdue to put member on restricted status
_loanDao.UpdateOverDueStatus(DateTime.Today.AddMonths(1));
// Test Pre-conditions
Assert.True(_display.Display.IsEnabled);
var borrowCtrl = ((BorrowControl)_display.Display);
var swipeCtrl = borrowCtrl._controlDict.Single(c => c.Value is SwipeCardControl).Value as SwipeCardControl;
var restrictedCtrl = borrowCtrl._controlDict.Single(c => c.Value is RestrictedControl).Value as RestrictedControl;
Assert.NotNull(swipeCtrl);
Assert.True(swipeCtrl.IsEnabled);
Assert.True(swipeCtrl.cancelButton.IsEnabled);
Assert.True(_reader.Enabled);
Assert.Equal(controller, _reader.Listener);
Assert.NotNull(controller._memberDAO);
Assert.Equal(EBorrowState.INITIALIZED, controller._state);
// Run use case
controller.cardSwiped(member.ID);
// Test Post-conditions
Assert.NotNull(restrictedCtrl);
Assert.True(restrictedCtrl.IsEnabled);
Assert.True(restrictedCtrl.cancelButton.IsEnabled);
Assert.True(!_reader.Enabled);
Assert.True(!_scanner.Enabled);
Assert.Equal(member.ID, restrictedCtrl.idLabel.Content);
Assert.Equal($"{member.FirstName} {member.LastName}", restrictedCtrl.nameLabel.Content.ToString());
Assert.Equal(member.Loans[0].ToString(), restrictedCtrl.existingLoanBox.Text); // Test one existing loan is present
Assert.Equal("Borrower has overdue loans", restrictedCtrl.overDueLoanLabel.Content);
Assert.Equal("Member has been restricted from borrowing", restrictedCtrl.errorMessage.Content);
Assert.Equal(member, controller._borrower);
Assert.Equal(EBorrowState.BORROWING_RESTRICTED, controller._state);
}
public void SwipeBorrowerCardShowsCurrentLoans()
{
var loan = Substitute.For<ILoan>();
var member = CreateMockIMember();
member.Loans.Returns(new List<ILoan>() { loan, loan, loan });
var ctrl = new BorrowController(_display, _reader, _scanner, _printer, _bookDao, _loanDao, _memberDao);
// Set the UI to the mock so we can test
var borrowctrl = Substitute.For<ABorrowControl>();
ctrl._ui = borrowctrl;
ctrl.initialise();
//Test pre-conditions
Assert.True(ctrl._reader.Enabled);
Assert.Equal(ctrl, ctrl._reader.Listener);
Assert.NotNull(ctrl._memberDAO);
Assert.Equal(EBorrowState.INITIALIZED, ctrl._state);
_memberDao.GetMemberByID(member.ID).Returns(member);
ctrl.cardSwiped(member.ID);
_memberDao.Received().GetMemberByID(member.ID);
foreach (var l in member.Loans)
{
borrowctrl.Received().DisplayExistingLoan(l.ToString());
}
}
public void SwipeBorrowerCardRestricted()
{
var member = CreateMockIMember();
member.HasOverDueLoans.Returns(true);
var ctrl = new BorrowController(_display, _reader, _scanner, _printer, _bookDao, _loanDao, _memberDao);
// Set the UI to the mock so we can test
var borrowctrl = Substitute.For<ABorrowControl>();
ctrl._ui = borrowctrl;
ctrl.initialise();
//Test pre-conditions
Assert.True(ctrl._reader.Enabled);
Assert.Equal(ctrl, ctrl._reader.Listener);
Assert.NotNull(ctrl._memberDAO);
Assert.Equal(EBorrowState.INITIALIZED, ctrl._state);
_memberDao.GetMemberByID(member.ID).Returns(member);
ctrl.cardSwiped(member.ID);
_memberDao.Received().GetMemberByID(member.ID);
_reader.Received().Enabled = false;
_scanner.Received().Enabled = false;
borrowctrl.Received().DisplayMemberDetails(member.ID, member.ToString(), member.ContactPhone);
borrowctrl.Received().DisplayErrorMessage("Member has been restricted from borrowing");
foreach (var l in member.Loans)
{
borrowctrl.Received().DisplayExistingLoan(l.ToString());
}
Assert.Equal(member, ctrl._borrower);
Assert.True(!ctrl._reader.Enabled);
Assert.True(!ctrl._scanner.Enabled);
Assert.Equal(EBorrowState.BORROWING_RESTRICTED, ctrl._state);
}
public void SwipeBorrowerCardControlNotInitialized()
{
var ctrl = new BorrowController(_display, _reader, _scanner, _printer, _bookDao, _loanDao, _memberDao);
Assert.Equal(EBorrowState.CREATED, ctrl._state);
var ex = Assert.Throws<InvalidOperationException>(() => { ctrl.cardSwiped(1); });
Assert.Equal("Controls must be initialised before member's card is swiped", ex.Message);
}
public void InitialiseControllerEnablesCardReader()
{
var ctrl = new BorrowController(_display, _reader, _scanner, _printer, _bookDao, _loanDao, _memberDao);
ctrl.initialise();
Assert.True(ctrl._reader.Enabled);
}
public void CreateControlThrowsExceptionOnNullArguments()
{
var ex = Assert.Throws<ArgumentException>(
() =>
{
var ctrl = new BorrowController(null, _reader, _scanner, _printer, _bookDao, _loanDao,
_memberDao);
});
Assert.Equal("Display object was not provided to begin the application", ex.Message);
ex = Assert.Throws<ArgumentException>(
() =>
{
var ctrl = new BorrowController(_display, null, _scanner, _printer, _bookDao, _loanDao,
_memberDao);
});
Assert.Equal("Reader object was not provided to begin the application", ex.Message);
ex = Assert.Throws<ArgumentException>(
() =>
{
var ctrl = new BorrowController(_display, _reader, null, _printer, _bookDao, _loanDao,
_memberDao);
});
Assert.Equal("Scanner object was not provided to begin the application", ex.Message);
ex = Assert.Throws<ArgumentException>(
() =>
{
var ctrl = new BorrowController(_display, _reader, _scanner, null, _bookDao, _loanDao,
_memberDao);
});
Assert.Equal("Printer object was not provided to begin the application", ex.Message);
ex = Assert.Throws<ArgumentException>(
() =>
{
var ctrl = new BorrowController(_display, _reader, _scanner, _printer, null, _loanDao,
_memberDao);
});
Assert.Equal("BookDAO object was not provided to begin the application", ex.Message);
ex = Assert.Throws<ArgumentException>(
() =>
{
var ctrl = new BorrowController(_display, _reader, _scanner, _printer, _bookDao, null,
_memberDao);
});
Assert.Equal("LoanDAO object was not provided to begin the application", ex.Message);
ex = Assert.Throws<ArgumentException>(
() =>
{
var ctrl = new BorrowController(_display, _reader, _scanner, _printer, _bookDao, _loanDao,
null);
});
Assert.Equal("MemberDAO object was not provided to begin the application", ex.Message);
}
public void CreateControlSetsStateToCreated()
{
var ctrl = new BorrowController(_display, _reader, _scanner, _printer, _bookDao, _loanDao, _memberDao);
Assert.Equal(EBorrowState.CREATED, ctrl._state);
}
public void CreateControlBookControlAddedAsListenerToCardReaderAndScanner()
{
var ctrl = new BorrowController(_display, _reader, _scanner, _printer, _bookDao, _loanDao, _memberDao);
_reader.Received().Listener = ctrl;
_scanner.Received().Listener = ctrl;
Assert.Equal(ctrl, _reader.Listener);
Assert.Equal(ctrl, _scanner.Listener);
}
public void CreateControlAssignsArgumentsToLocalProperties()
{
var ctrl = new BorrowController(_display, _reader, _scanner, _printer, _bookDao, _loanDao, _memberDao);
Assert.Equal(_display, ctrl._display);
Assert.Equal(_reader, ctrl._reader);
Assert.Equal(_scanner, ctrl._scanner);
Assert.Equal(_printer, ctrl._printer);
Assert.Equal(_bookDao, ctrl._bookDAO);
Assert.Equal(_loanDao, ctrl._loanDAO);
Assert.Equal(_memberDao, ctrl._memberDAO);
}
public void CanSwipeBorrowerCard()
{
var member = CreateMockIMember();
var ctrl = new BorrowController(_display, _reader, _scanner, _printer, _bookDao, _loanDao, _memberDao);
ctrl.initialise();
//Test pre-conditions
Assert.True(ctrl._reader.Enabled);
Assert.Equal(ctrl, ctrl._reader.Listener);
Assert.NotNull(ctrl._memberDAO);
Assert.Equal(EBorrowState.INITIALIZED, ctrl._state);
_memberDao.GetMemberByID(member.ID).Returns(member);
ctrl.cardSwiped(member.ID); // If we get to the end of the method then it hasn't thrown an exception.
}
public void CanScanBook()
{
var member = CreateMockIMember();
var ctrl = new BorrowController(_display, _reader, _scanner, _printer, _bookDao, _loanDao, _memberDao);
InitialiseToScanBookPreConditions(ctrl, member);
// Make the bookDao return a successful read
_bookDao.GetBookByID(0).Returns(Substitute.For<IBook>());
ctrl.bookScanned(0); // if we get this far we've worked.
}
public void ScanBooksBookScanCountLessThanLoanLimitClearsPreviousError()
{
var member = CreateMockIMember();
var book = Substitute.For<IBook>();
book.State.Returns(BookState.AVAILABLE);
var borrowDate = DateTime.Today;
var dueDate = DateTime.Today.AddDays(7);
var loan = Substitute.For<Loan>(book, member, borrowDate, dueDate);
var ctrl = new BorrowController(_display, _reader, _scanner, _printer, _bookDao, _loanDao, _memberDao);
// Set the UI to the mock so we can test
var borrowctrl = Substitute.For<ABorrowControl>();
ctrl._ui = borrowctrl;
InitialiseToScanBookPreConditions(ctrl, member);
_bookDao.GetBookByID(0).Returns(book);
_loanDao.CreateLoan(member, book, borrowDate, dueDate).Returns(loan);
ctrl.bookScanned(0);
// Expect the error message to be cleared
borrowctrl.Received().DisplayErrorMessage("");
}
public void ScanBooksScannerEnabled()
{
var member = CreateMockIMember();
var ctrl = new BorrowController(_display, _reader, _scanner, _printer, _bookDao, _loanDao, _memberDao);
InitialiseToScanBookPreConditions(ctrl, member);
// Make the bookDao return a successful read
_bookDao.GetBookByID(0).Returns(Substitute.For<IBook>());
ctrl.bookScanned(0);
Assert.True(_scanner.Enabled);
}
public void InitialiseControllerSetsStateToInitialized()
{
var ctrl = new BorrowController(_display, _reader, _scanner, _printer, _bookDao, _loanDao, _memberDao);
ctrl.initialise();
Assert.Equal(EBorrowState.INITIALIZED, ctrl._state);
}
public void SwipeBorrowerCardMemberDoesntExist()
{
var memberId = 1;
var ctrl = new BorrowController(_display, _reader, _scanner, _printer, _bookDao, _loanDao, _memberDao);
// Set the UI to the mock so we can test
var borrowctrl = Substitute.For<ABorrowControl>();
ctrl._ui = borrowctrl;
ctrl.initialise();
//Test pre-conditions
Assert.True(ctrl._reader.Enabled);
Assert.Equal(ctrl, ctrl._reader.Listener);
Assert.NotNull(ctrl._memberDAO);
Assert.Equal(EBorrowState.INITIALIZED, ctrl._state);
_memberDao.GetMemberByID(memberId).Returns((Member) null);
ctrl.cardSwiped(memberId);
_memberDao.Received().GetMemberByID(memberId);
// Test using mocks that it received a Borrower not found error.
borrowctrl.Received().DisplayErrorMessage("Borrower was not found in database");
}
public void RejectLoansControlNotConfirmingLoans()
{
var ctrl = new BorrowController(_display, _reader, _scanner, _printer, _bookDao, _loanDao, _memberDao);
var ex = Assert.Throws<InvalidOperationException>(() => { ctrl.loansRejected(); });
Assert.Equal("Control state must be set to 'Confirming Loans'", ex.Message);
}
public void SwipeBorrowerCardShowErrorIfMemberHasReachedLoanLimit()
{
var member = CreateMockIMember();
member.HasReachedLoanLimit.Returns(true);
var ctrl = new BorrowController(_display, _reader, _scanner, _printer, _bookDao, _loanDao, _memberDao);
// Set the UI to the mock so we can test
var borrowctrl = Substitute.For<ABorrowControl>();
ctrl._ui = borrowctrl;
ctrl.initialise();
//Test pre-conditions
Assert.True(ctrl._reader.Enabled);
Assert.Equal(ctrl, ctrl._reader.Listener);
Assert.NotNull(ctrl._memberDAO);
Assert.Equal(EBorrowState.INITIALIZED, ctrl._state);
_memberDao.GetMemberByID(member.ID).Returns(member);
ctrl.cardSwiped(member.ID);
_memberDao.Received().GetMemberByID(member.ID);
borrowctrl.Received().DisplayAtLoanLimitMessage();
}
public void ScanBooksBookAlreadyScanned()
{
var member = CreateMockIMember();
var book = Substitute.For<IBook>();
book.State.Returns(BookState.AVAILABLE);
var ctrl = new BorrowController(_display, _reader, _scanner, _printer, _bookDao, _loanDao, _memberDao);
// Set the UI to the mock so we can test
var borrowctrl = Substitute.For<ABorrowControl>();
ctrl._ui = borrowctrl;
InitialiseToScanBookPreConditions(ctrl, member);
_bookDao.GetBookByID(0).Returns(book);
ctrl._bookList.Add(book); // Add the book to the booklist.
ctrl.bookScanned(0);
_bookDao.Received().GetBookByID(0);
borrowctrl.Received().DisplayErrorMessage("Book has already been scanned");
Assert.Equal(EBorrowState.SCANNING_BOOKS, ctrl._state);
}
private void InitialiseToScanBookPreConditions(BorrowController ctrl, IMember member)
{
ctrl.initialise();
_memberDao.GetMemberByID(member.ID).Returns(member);
ctrl.cardSwiped(member.ID);
// Test Pre-conditions
Assert.NotNull(ctrl);
Assert.NotNull(ctrl._scanner);
Assert.Equal(ctrl._scanner.Listener, ctrl);
Assert.Equal(EBorrowState.SCANNING_BOOKS, ctrl._state);
}
public void ScanBooksBookNotFound()
{
var member = CreateMockIMember();
var ctrl = new BorrowController(_display, _reader, _scanner, _printer, _bookDao, _loanDao, _memberDao);
// Set the UI to the mock so we can test
var borrowctrl = Substitute.For<ABorrowControl>();
ctrl._ui = borrowctrl;
InitialiseToScanBookPreConditions(ctrl, member);
_bookDao.GetBookByID(0).Returns((IBook)null);
ctrl.bookScanned(0);
_bookDao.Received().GetBookByID(0);
borrowctrl.Received().DisplayErrorMessage("Book scanned was not found");
Assert.Equal(EBorrowState.SCANNING_BOOKS, ctrl._state);
}
public void ScanBookControlNotScanningBooks()
{
var ctrl = new BorrowController(_display, _reader, _scanner, _printer, _bookDao, _loanDao, _memberDao);
ctrl.initialise();
var ex = Assert.Throws<InvalidOperationException>(() => { ctrl.bookScanned(0); });
Assert.Equal("Control state must be set to 'Scanning Books'", ex.Message);
}
public void CanInitialiseBorrowerController()
{
var ctrl = new BorrowController(_display, _reader, _scanner, _printer, _bookDao, _loanDao, _memberDao);
ctrl.initialise(); // If test does not fail to this point it hasn't thrown, so Initialise method has worked.
}
