public void AddQueueItemIsSuccessful()
{
var queueDaoMock = new Mock<IQueueDao>();
var payment = new Model.Booking.Payment
{
OrderId = 5,
CreatedByUserId = new Guid("00000000-0000-0000-0000-000000000000")
};
var invoiceRequest = new SettlementInvoiceRequest
{
BusinessId = 10,
OrderId = payment.OrderId,
BookingId = 2,
OrderSourceCode = SourceType.Online.GetCode()
};
queueDaoMock.Setup(q => q.AddQueueItem(It.Is<QueueItem>(qi =>
qi.PayloadType == PayloadTypeEnum.BookingInv &&
qi.QueueCode == QueueCodeType.SettlementInvoiceRequest &&
qi.UserId == payment.CreatedByUserId &&
qi.Key == payment.OrderId.ToString() &&
qi.Payload.IndexOf("10") > 0))).Returns(new QueueItem());
QueueManager manager = new QueueManager
{
QueueDao = queueDaoMock.Object
};
QueueItem item = new PaymentManager().GetSettlementQueueItemFromPayment(payment, invoiceRequest);
manager.AddQueueItem(item);
queueDaoMock.VerifyAll();
}
public void VerifyIfDeletedPaymentIsSuccessful()
{
// Arrange
var paymentDto = new PaymentDto
{
Id = 1,
Amount = new decimal(10.00),
ReceivedDate = DateTime.Today,
Currency = new CurrencyDto { ISOCode = "GBP" },
PaymentMethod = new PaymentMethodDto { Code = PaymentMethodEnum.CreditCard.GetCode() },
PaymentSource = new PaymentSourceDto { Code = PaymentSourceEnum.Pms.GetCode() },
CardType = new CardTypeDto { Code = CardTypeEnum.Visa.GetCode() },
CardLast4Digits = "1234",
PaymentName = "John",
Notes = "New Payment"
};
var existingPayment = new Model.Booking.Payment
{
Id = 1,
Amount = new decimal(10.00),
ReceivedDate = DateTime.Today,
Currency = new Currency("GBP"),
PaymentMethod = new PaymentMethod(),
PaymentSource = new PaymentSource(),
CardType = new CardType(),
PaymentStatus = new PaymentStatus(),
PaymentType = new PaymentType(),
Notes = "New Payment"
};
var paymentManager = MockRepository.GenerateStub<IPaymentManager>();
paymentManager.Expect(x => x.GetPaymentByKey(paymentDto.Id)).Return(existingPayment);
paymentManager.Expect(x => x.DeletePayment(Arg<Model.Booking.Payment>.Is.Anything)).Return(true);
PropertyManagementSystemService.PaymentManager = paymentManager;
// Act
var result = PropertyManagementSystemService.DeletePaymentForOrder(paymentDto);
// Assert
Assert.IsTrue(result, "The payment wasn't deleted");
}
public void CreateRefundForBookingCreatesRefund()
{
// Arrange
var paymentDto = new PaymentDto
{
Amount = new decimal(10.00),
ReceivedDate = DateTime.Today,
Currency = new CurrencyDto { ISOCode = "GBP" },
PaymentMethod = new PaymentMethodDto { Code = PaymentMethodEnum.CreditCard.GetCode() },
PaymentSource = new PaymentSourceDto { Code = PaymentSourceEnum.Pms.GetCode() },
CardType = new CardTypeDto { Code = CardTypeEnum.Visa.GetCode() },
CardLast4Digits = "1234",
PaymentName = "Johno",
Notes = "New Payment"
};
var newPayment = new Model.Booking.Payment
{
Amount = new decimal(10.00),
ReceivedDate = DateTime.Today,
Currency = new Currency("GBP"),
PaymentMethod = new PaymentMethod(),
PaymentSource = new PaymentSource(),
CardType = new CardType(),
PaymentStatus = new PaymentStatus(),
PaymentType = new PaymentType(),
Notes = "New Payment"
};
var paymentManager = MockRepository.GenerateMock<IPaymentManager>();
paymentManager.Expect(x => x.CreatePaymentForOrder(Arg<Model.Booking.Payment>.Is.Anything, Arg<long>.Is.Anything));
paymentManager.Expect(x => x.GetPaymentByKey(Arg<int>.Is.Anything)).Return(newPayment);
PropertyManagementSystemService.PaymentManager = paymentManager;
// Act
PropertyManagementSystemService.CreateRefundForOrder(paymentDto, 1);
// Assert
paymentManager.VerifyAllExpectations();
}
public void GetPaymentByKeyWithValidPaymentIdReturnsPayment()
{
// Arrange
var paymentManager = new PaymentManager();
const int PAYMENT_ID = 1;
var payment = new Model.Booking.Payment { Id = 1 };
var paymentDao = new Mock<IPaymentDao>();
paymentManager.PaymentDao = paymentDao.Object;
paymentDao.Setup(b => b.GetByKey(PAYMENT_ID)).Returns(payment);
// Act
var paymentReturnedByManager = paymentManager.GetPaymentByKey(PAYMENT_ID);
// Assert
Assert.IsNotNull(paymentReturnedByManager, "Payment is null.");
paymentDao.VerifyAll();
}
public void CreatePaymentInvalidReceivedDateThrowsValidationException()
{
// Arrange
var stubPaymentDao = MockRepository.GenerateStub<IPaymentDao>();
var paymentManager = new PaymentManager
{
PaymentDao = stubPaymentDao
};
var payment = new Model.Booking.Payment
{
Amount = new decimal(10.00),
ReceivedDate = DateTime.Today.AddDays(10),
Currency = new Currency("GBP"),
PaymentMethod = new PaymentMethod { Code = PaymentMethodEnum.Cash.GetCode() },
PaymentSource = new PaymentSource { Code = PaymentSourceEnum.Pms.GetCode() },
PaymentStatus = new PaymentStatus { Code = PaymentStatusEnum.Created.GetCode() },
PaymentType = new PaymentType { Code = PaymentTypeEnum.Payment.GetCode() },
Notes = "New Payment"
};
stubPaymentDao.Stub(b => b.Create(payment)).WhenCalled(delegate { payment.Id = 1; });
try
{
// Act
paymentManager.CreatePaymentForOrder(payment, 1);
// Assert
Assert.Fail("An exception SRVEX30071 of type ValidationException should have been thrown");
}
catch (ValidationException ex)
{
// Assert
Assert.AreEqual("SRVEX30071", ex.Code, "The Validation exception is not returning the right error code");
}
// Make sure this is reset for future tests
paymentManager.PaymentDao = new PaymentDao();
}
public void CreatePaymentCreatesEvents()
{
// Arrange
var mockEventTrackingManager = MockRepository.GenerateMock<IEventTrackingManager>();
CacheHelper.StubBusinessCacheSingleBusiness(1, "TestBus1");
var paymentManager = new PaymentManager
{
PaymentDao = MockRepository.GenerateStub<IPaymentDao>(),
EventTrackingManager = mockEventTrackingManager
};
var payment = new Model.Booking.Payment
{
Id = 1,
OrderId = 1,
Amount = new decimal(10.00),
ReceivedDate = DateTime.Today,
Currency = new Currency("GBP"),
PaymentMethod = new PaymentMethod { Code = PaymentMethodEnum.Cash.GetCode() },
PaymentSource = new PaymentSource { Code = PaymentSourceEnum.Pms.GetCode() },
PaymentStatusEnum = PaymentStatusEnum.Created,
PaymentTypeEnum = PaymentTypeEnum.Payment,
Notes = "New Payment"
};
mockEventTrackingManager.Expect(
u =>
u.CreatePaymentEvent(Arg<int>.Is.Equal(payment.Id),
Arg<PaymentEventTypeEnum>.Is.Equal(PaymentEventTypeEnum.Created), Arg<string>.Is.Equal(payment.Notes)))
.Repeat.Once(); ;
mockEventTrackingManager.Expect(
ev =>
ev.CreateOrderEvent(Arg<int>.Is.Equal(payment.OrderId),
Arg<OrderEventTypeEnum>.Is.Equal(OrderEventTypeEnum.PaymentAdded), Arg<string>.Is.Equal(payment.Id.ToString()), Arg<string>.Is.Equal(payment.Notes)))
.Repeat.Once();
paymentManager.CreatePaymentForOrder(payment, 1);
CacheHelper.ReAssignBusinessDaoToBusinessCache();
// Assert
mockEventTrackingManager.VerifyAllExpectations();
}
public void CreateRefundIsSuccessful()
{
// Arrange
const int PAYMENT_ID = 1;
var stubPaymentDao = MockRepository.GenerateStub<IPaymentDao>();
var paymentManager = new PaymentManager
{
PaymentDao = stubPaymentDao
};
var payment = new Model.Booking.Payment
{
Id = PAYMENT_ID,
Amount = new decimal(10.00),
ReceivedDate = DateTime.Today,
Currency = new Currency("GBP"),
PaymentMethod = new PaymentMethod { Code = PaymentMethodEnum.Cash.GetCode() },
PaymentSource = new PaymentSource { Code = PaymentSourceEnum.Pms.GetCode() },
PaymentStatusEnum = PaymentStatusEnum.Deleted,
PaymentTypeEnum = PaymentTypeEnum.Refund,
Notes = "New Payment"
};
stubPaymentDao.Stub(b => b.Create(payment)).WhenCalled(delegate { payment.Id = 1; });
// Act
paymentManager.CreatePaymentForOrder(payment, 1);
// Assert
Assert.IsNotNull(payment.Id, "The payment reversal id was not attributed.");
// Make sure this is reset for future tests
paymentManager.PaymentDao = new PaymentDao();
}
public void CreatePaymentWithInvalidOrderIdThrowsExpectedResultException()
{
// Arrange
var payment = new Model.Booking.Payment();
try
{
// Act
paymentDao.Create(payment);
// Assert
Assert.Fail("ExpectedResultException with error code SRVEX30073 was not thrown.");
}
catch (ExpectedResultException ex)
{
// Assert
Assert.AreEqual(ex.Code, "SRVEX30073", "The error code returned is not the expected.");
}
}
public void CreateRefundIsSuccessful()
{
using (new TestDataHelper(GetTestQuery(TestQuery.PopulateBookingAndPaymentsTestData), GetTestQuery(TestQuery.CleanupUnitTestData)))
{
// Arrange
const int ORDER_ID = 1;
const int PAYMENT_ID = 1;
var payment = new Model.Booking.Payment
{
Id = PAYMENT_ID,
OrderId = ORDER_ID,
Amount = new decimal(10.00),
ReceivedDate = DateTime.Today,
Currency = new Currency("GBP"),
PaymentMethodEnum = PaymentMethodEnum.Cash,
PaymentSourceEnum = PaymentSourceEnum.Pms,
PaymentStatusEnum = PaymentStatusEnum.Deleted,
PaymentTypeEnum = PaymentTypeEnum.Refund,
CardType = new CardType(),
Notes = "New Payment"
};
//Act
paymentDao.Create(payment);
//Assert
Assert.IsNotNull(payment.Id, "Refund was not created in the database");
}
}
protected override void RunBeforeAllTests()
{
base.RunBeforeAllTests();
GuestManager guestManager = new GuestManager();
PaymentManager paymentManager = new PaymentManager();
Guest guest = new Guest
{
BusinessId = BUSINESS_ID,
DefaultCultureCode = "en-GB",
AddressLine1 = "AL1",
City = "City",
Forename = "Bob",
Surname = "Smith"
};
guestManager.Create(guest);
var mockOrder = new Order
{
IntegrationType = IntegrationTypeEnum.Myweb,
OfflineSourceEnum = OfflineSourceEnum.Web,
CustomerCurrencyCode = "GBP",
OrderSourceCode = SourceType.Online.GetCode(),
LeadGuest = guest,
LeadGuestId = guest.Id.Value
};
orderDao.CreateOrder(BUSINESS_ID, mockOrder);
// set up payment for the order
setupPayment = new Model.Booking.Payment
{
OrderId = mockOrder.Id.Value,
PaymentSourceEnum = PaymentSourceEnum.Online,
PaymentTypeEnum = PaymentTypeEnum.Payment,
PaymentMethodEnum = PaymentMethodEnum.AccountTransfer,
Currency = new Currency(mockOrder.CustomerCurrencyCode),
Amount = 30,
Notes = "Test Notes",
PaymentStatusEnum = PaymentStatusEnum.Created,
ReceivedDate = DateTime.Now.AddDays(-5),
MerchantType = MerchantTypeEnum.EviivoAccount
};
paymentManager.CreatePaymentForOrder(setupPayment, BUSINESS_ID);
}
