public void GetProviderWithRoomTypeAndRatePlansCallCorrectMethods()
{
//Arrange
const int ROOMTYPE_ID = 10;
const long BUSINESS_ID = 5002;
var business = new Model.Business.Business {Id = BUSINESS_ID, ShortName = "TestBus2", DefaultCultureCode = "en-GB"};
var roomTypes = new List<RoomType>
{
new RoomType
{
Id = ROOMTYPE_ID,
VariantRatePlans = new List<VariantRatePlan>
{
new VariantRatePlan
{
CancellationClass = new EnumEntity { Code = "FN" },
Id = 1
}
}
}
};
var businessManager = MockRepository.GenerateMock<IBusinessManager>();
var distributorManager = MockRepository.GenerateMock<IDistributionManager>();
var roomTypeManager = MockRepository.GenerateMock<IRoomTypeManager>();
var rateplanManager = MockRepository.GenerateMock<IRatePlanManager>();
contentService.BusinessManager = businessManager;
contentService.DistributionManager = distributorManager;
contentService.RoomTypeManager = roomTypeManager;
contentService.RatePlanManager = rateplanManager;
roomTypeManager.Stub(a => a.GetRoomTypesAndBaseRatePlans(business.Id, business.DefaultCultureCode)).Return(roomTypes);
businessManager.Expect(b => b.GetLimitedBusinessByShortname(business.ShortName)).Return(business);
distributorManager.Expect(d => d.GetDistributorsAndChannels(business.Id, business.DefaultCultureCode));
rateplanManager.Expect(r => r.GetRatePlans(ROOMTYPE_ID, BUSINESS_ID, business.DefaultCultureCode));
//Act
contentService.GetProviderWithRoomTypeAndRatePlans(business.ShortName, string.Empty);
//Assert
businessManager.VerifyAllExpectations();
distributorManager.VerifyAllExpectations();
roomTypeManager.VerifyAllExpectations();
rateplanManager.VerifyAllExpectations();
}
public void SetMerchantInfoOnTransactionModel_PaymentGatewayIsNotOgone_Expect_TransactionModelMerchantId_SetTo_EmptyString()
{
// Arrange
var mockLogger = MockRepository.GenerateMock<ILogger>();
var target = new SettlementHelper(mockLogger, mockServiceClient);
var transactionModel = new Model.Settlement.TransactionModel() { };
var booking = new Model.Booking.Booking() {};
var business = new Model.Business.Business() {MerchantStatusEnum = MerchantStatusEnum.OwnMerchant};
var businessChannel = new Model.Business.Business();
var settlementPayments = new List<SettlementPaymentDto>() { new SettlementPaymentDto() { MerchantPSPID = "1", PaymentGatewayName = PaymentConstants.PAYMENT_GATEWAY_NAME_DATACASH } };
//Act
target.SetMerchantInfoOnTransactionModel(transactionModel, booking, business, businessChannel, settlementPayments);
//Assert
Assert.AreEqual(transactionModel.MerchantId, string.Empty);
}
public void EagleBusinessToEcomBusinessReturnsBusinessAccountWithMappedProperties()
{
// Arrange
var createdByUser = new UserExtension {FirstName = "John", LastName = "Doe"};
var updatedByUser = new UserExtension {FirstName = "Dummy", LastName = "User"};
var eagleBusiness = new Model.Business.Business
{
Id = 12345,
Name = "Business 1",
ShortName = "Bus1",
MerchantDetails = new MerchantDetails(),
CreatedByUser = createdByUser,
UpdatedByUser = updatedByUser,
ReferenceCode = "Bus000001",
Provider = new Provider { ContentId = "1544BCC" },
OnlineBookingScenarios = new Collection<OnlineBookingScenario>()
};
// Act
List<string> missedChannels;
EcomBusinessAccount ecommBusiness = EcomConverter.EagleBusinessToEcom(eagleBusiness, string.Empty, out missedChannels);
// Assert
Assert.AreEqual(string.Empty, ecommBusiness.CreatedByTitle, "CreatedByTitle should be empty");
Assert.AreEqual(createdByUser.FirstName, ecommBusiness.CreatedByFirstname, "CreatedByFirstname doesn't match");
Assert.AreEqual(createdByUser.LastName, ecommBusiness.CreatedByLastname, "CreatedByLastname doesn't match");
Assert.AreEqual(string.Empty, ecommBusiness.ModifiedByTitle, "ModifiedByTitle should be empty");
Assert.AreEqual(updatedByUser.FirstName, ecommBusiness.ModifiedByFirstname, "ModifiedByFirstname doesn't match");
Assert.AreEqual(updatedByUser.LastName, ecommBusiness.ModifiedByLastname, "ModifiedByLastname doesn't match");
Assert.AreEqual(EcomConverter.EXTERNAL_PRODUCT_PROVIDER_CODE, ecommBusiness.BusinessAccountTypeId, "BusinessAccountTypeId doesn't match");
Assert.AreEqual(eagleBusiness.Name, ecommBusiness.FullName, "FullName doesn't match");
Assert.AreEqual(eagleBusiness.ShortName, ecommBusiness.ShortName, "ShortName doesn't match");
Assert.AreEqual(eagleBusiness.ReferenceCode, ecommBusiness.ReferenceCode, "ReferenceCode doesn't match");
Assert.AreEqual(eagleBusiness.Provider.ContentId, ecommBusiness.ContentId, "ContentId doesn't match");
Assert.IsFalse(ecommBusiness.IsMerchant, "IsMerchant should be false");
}
public void GetBusinessInformationWithExpectedResult()
{
// Arrange
const long BUSINESS_TO_GET = 1;
var stubBusinessManager = MockRepository.GenerateStub<IBusinessManager>();
const string SERIALIZED_TIME_ZONE =
"Azores Standard Time;-60;(UTC-01:00) Azores;Azores Standard Time;Azores Daylight Time;[01:01:0001;12:31:9999;60;[0;02:00:00;3;5;0;];[0;03:00:00;10;5;0;];];";
TimeZoneInfo timeZone = TimeZoneInfo.FromSerializedString(SERIALIZED_TIME_ZONE);
Country stubCountry = new Country {Id = 1, Name = "United Kingdom"};
var business = new Model.Business.Business
{
Id = BUSINESS_TO_GET,
BusinessStatus = new EnumEntity {Code = BusinessStatus.ACTIVE, Name = "Active"},
BusinessType = BusinessTypeEnum.Provider,
Name = "FullName",
ShortName = "ShortName",
ReferenceCode = "ABC",
IsTaxRegistered = true,
TaxRegistrationNumber = "1234",
BusinessRegistrationNumber = "4567",
AddressLine1 = "123 Test Street",
AddressLine2 = "45 Test Ave",
AddressLine3 = "82 Test Street",
PostCode = "W6 8JA",
BusinessTelephoneNumber = "123 456 787",
FaxNumber = "123 456 777",
Email = "*****@*****.**",
StateProvinceId = 1,
StateProvince = new StateProvince{ Id = 1, Name = "London", Country = new Country { Id = 1, Name = "United Kingdom" }},
RegionId = 1,
Region = new Region { Id = 1, Name = "UK"},
DefaultCultureCode = "en-GB",
DefaultCulture = new Culture { Code = "en-GB", Name = "English (United Kingdom)", ParentCode = "en" },
TimeZone = timeZone,
WorkingCurrencyCode = "GBP",
ContractCurrencyCode = "GBP",
CountryId = 1,
Country = stubCountry,
Longitude = new decimal(100.5),
Latitude = new decimal(90.6),
IsMerchant = true,
MerchantDetailsId = 1,
IsSMS = true,
IsTermsAndConditions = true,
WorkingCurrency = new Currency("USD", "$", "US Dollars", 2),
Provider = new Provider { RoomCount = 20 }
};
stubBusinessManager.Stub(x => x.GetBusiness(BUSINESS_TO_GET)).Return(business);
stubBusinessManager.Stub(x => x.GetCountryByBusiness(BUSINESS_TO_GET)).Return(stubCountry);
PropertyManagementSystemService.BusinessManager = stubBusinessManager;
// Act
BusinessDto businessDto = PropertyManagementSystemService.GetBusinessInformation(BUSINESS_TO_GET);
// Assert
Assert.IsNotNull(businessDto, "Business information retrieved is null.");
Assert.IsTrue(businessDto.Id != default(long), "Id attribute is not present on Business object.");
Assert.AreEqual(business.BusinessStatus.Code, businessDto.BusinessStatusCode, "BusinessStatusCode attribute doesn't match on Business object.");
Assert.AreEqual(business.BusinessStatus.Name, businessDto.BusinessStatusName, "BusinessStatusName attribute doesn't match on Business object.");
Assert.AreEqual(business.BusinessType.GetCode(), businessDto.BusinessTypeCode, "BusinessTypeCode attribute doesn't match on Business object.");
Assert.AreEqual(business.Name, businessDto.Name, "Name attribute doesn't match on Business object.");
Assert.AreEqual(business.ShortName, businessDto.ShortName, "ShortName attribute doesn't match on Business object.");
Assert.AreEqual(business.ReferenceCode, businessDto.ReferenceCode, "ReferenceCode attribute doesn't match on Business object.");
Assert.AreEqual(business.IsTaxRegistered, businessDto.IsTaxRegistered, "IsTaxRegistered attribute doesn't match on Business object.");
Assert.AreEqual(business.TaxRegistrationNumber, businessDto.TaxRegistrationNumber, "TaxRegistrationNumber attribute doesn't match on Business object.");
Assert.AreEqual(business.BusinessRegistrationNumber, businessDto.BusinessRegistrationNumber, "BusinessRegistrationNumber attribute doesn't match on Business object.");
Assert.AreEqual(business.AddressLine1, businessDto.AddressLine1, "AddressLine1 attribute doesn't match on Business object.");
Assert.AreEqual(business.AddressLine2, businessDto.AddressLine2, "AddressLine2 attribute doesn't match on Business object.");
Assert.AreEqual(business.AddressLine3,businessDto.AddressLine3, "AddressLine3 attribute doesn't match on Business object.");
Assert.AreEqual(business.BusinessTelephoneNumber, businessDto.BusinessTelephoneNumber, "BusinessTelephoneNumber attribute doesn't match on Business object.");
Assert.AreEqual(business.FaxNumber, businessDto.FaxNumber, "FaxNumber attribute doesn't match on Business object.");
Assert.AreEqual(business.Email, businessDto.Email, "Email attribute doesn't match on Business object.");
Assert.AreEqual(business.StateProvinceId, businessDto.StateProvinceId, "StateProvinceId attribute doesn't match on Business object.");
Assert.AreEqual(business.PostCode, businessDto.PostCode, "PostCode attribute doesn't match on Business object.");
Assert.AreEqual(business.RegionId, businessDto.RegionId, "RegionId attribute doesn't match on Business object.");
Assert.AreEqual(business.DefaultCultureCode, businessDto.DefaultCultureCode, "DefaultCultureCode attribute doesn't match on Business object.");
Assert.AreEqual(business.TimeZone.ToSerializedString(), businessDto.TimeZone, "TimeZone attribute doesn't match on Business object.");
Assert.AreEqual(business.WorkingCurrencyCode, businessDto.WorkingCurrencyCode, "Working Currency code doesn't match on Business object.");
Assert.AreEqual(business.ContractCurrencyCode, businessDto.ContractCurrencyCode, "Contract Currency code doesn't match on Business object.");
Assert.AreEqual(business.Longitude, businessDto.Longitude, "Longitude attribute doesn't match on Business object.");
Assert.AreEqual(business.Latitude, businessDto.Latitude, "Latitude attribute doesn't match on Business object.");
Assert.AreEqual(business.IsMerchant, businessDto.IsMerchant, "IsMerchant attribute doesn't match on Business object.");
Assert.AreEqual(business.MerchantDetailsId, businessDto.MerchantDetailsId, "MerchantDetailsId attribute doesn't match on Business object.");
Assert.AreEqual(business.IsSMS, businessDto.IsSMS, "IsSMS attribute doesn't match on Business object.");
Assert.AreEqual(business.IsTermsAndConditions, businessDto.IsTermsAndConditions, "IsTermsAndConditions attribute doesn't match on Business object.");
Assert.AreEqual(business.Provider.RoomCount, businessDto.RoomCount, "RoomCount attribute doesn't match on Business object.");
Assert.AreEqual(business.Provider.ProviderTypeName, businessDto.ProviderType, "ProviderType attribute doesn't match on Business object.");
// Check attributes related to region.
Assert.IsNotNull(businessDto.Region, "Region object is not populated.");
Assert.AreEqual(business.Region.Id, businessDto.Region.Id, "Id attribute doesn't match on Region object.");
Assert.AreEqual(business.Region.Name, businessDto.Region.Name, "Name attribute doesn't match on Region object.");
// Check attributes related to the state province.
Assert.IsNotNull(business.StateProvince, "StateProvince object is not populated.");
Assert.AreEqual(business.StateProvince.Id, businessDto.StateProvince.Id, "Id attribute doesn't match on StateProvince object.");
Assert.AreEqual(business.StateProvince.Name, businessDto.StateProvince.Name, "Name attribute doesn't match on StateProvince object.");
// Check attributes related to country.
Assert.IsNotNull(businessDto.Country, "Country object is not populated.");
Assert.AreEqual(business.Country.Id, businessDto.Country.Id, "Id attribute doesn't match on Country object.");
Assert.AreEqual(business.Country.Name, businessDto.Country.Name, "Name attribute doesn't match on Country object.");
// Check attributes related to the currency.
Assert.IsNotNull(business.WorkingCurrency, "Currency object is not populated.");
Assert.AreEqual(business.WorkingCurrency.ISOCode, businessDto.WorkingCurrency.ISOCode, "Code attribute doesn't match on Currency object.");
Assert.AreEqual(business.WorkingCurrency.Name, businessDto.WorkingCurrency.Name, "Name attribute doesn't match on Currency object.");
// Check attributes related to the default culture.
Assert.IsNotNull(businessDto.DefaultCulture, "DefaultCulture object is not populated.");
Assert.AreEqual(business.DefaultCulture.Code,businessDto.DefaultCulture.Code, "Code attribute doesn't match on the DefaultCulture object.");
Assert.AreEqual(business.DefaultCulture.Name,businessDto.DefaultCulture.Name, "Name attribute doesn't match on the DefaultCulture object.");
Assert.AreEqual(business.DefaultCulture.ParentCode, businessDto.DefaultCulture.ParentCode, "ParentCode attribute doesn't match on the DefaultCulture object.");
}
/// <summary>
/// Map the fields for the Business for Ecomm
/// </summary>
/// <param name="record">record</param>
/// <param name="prefix">prefix</param>
/// <returns></returns>
internal static Model.Business.Business MapReaderForEcomm(IDataReader record, string prefix)
{
// Populate the business fields
var business = new Model.Business.Business
{
Id = DbHelper.ConvertValue<long>(record[prefix + Parameters.Id]),
Name = DbHelper.ConvertValue<string>(record[prefix + Parameters.Name]),
ShortName = DbHelper.ConvertValue<string>(record[prefix + Parameters.ShortName]),
AddressLine1 = DbHelper.ConvertValue<string>(record[prefix + Parameters.AddressLine1]),
City = DbHelper.ConvertValue<string>(record[prefix + Parameters.City]),
PostCode = DbHelper.ConvertValue<string>(record[prefix + Parameters.PostCode]),
DefaultCultureCode = DbHelper.ConvertValue<string>(record[prefix + Parameters.DefaultCultureCode]),
BusinessType = DbHelper.ConvertEnumValue<BusinessTypeEnum>(record[prefix + Parameters.BusinessTypeCode]),
IsMerchant = DbHelper.ConvertValue<bool>(record[prefix + Parameters.IsMerchant]),
TaxRegistrationNumber = DbHelper.ConvertValue<string>(record[prefix + Parameters.TaxRegistrationNumber]),
ReferenceCode = DbHelper.ConvertValue<string>(record[prefix + Parameters.ReferenceCode]),
IsTaxRegistered = DbHelper.ConvertValue<bool>(record[prefix + Parameters.IsTaxRegistered]),
BusinessRegistrationNumber = DbHelper.ConvertValue<string>(record[prefix + Parameters.BusinessRegistrationNumber]),
MerchantStatusEnum = DbHelper.ConvertEnumValue<MerchantStatusEnum>(record[prefix + Parameters.MerchantStatusCode]),
MerchantDetails = MerchantDetailsMapper.MapRecord(record, Parameters.Merchant.ToString()),
BusinessStatusCode = DbHelper.ConvertValue<string>(record[prefix + Parameters.BusinessStatusCode]),
Country = CountryMapper.MapRecordWithCode(record, Parameters.Country.ToString()),
CreatedByUser = MapRecordForSync(record, "UC"),
UpdatedByUser = MapRecordForSync(record, "UU"),
Provider = new Provider
{
ContentId = DbHelper.ConvertValue<string>(record[prefix + Parameters.ContentId])
}
};
return AuditFieldsHelper.MapRecord(business, record, prefix);
}
/// <summary>
/// Map the basic fields for the Business table to the Business model object
/// </summary>
/// <param name="record">The SqlDataReader with the executed query result</param>
/// <param name="prefix">a prefix used to identify fields for the Business model in the resultset if required</param>
/// <returns>An instance of Model.Business.Business</returns>
internal static Model.Business.Business MapRecord(IDataRecord record, string prefix)
{
var business = new Model.Business.Business
{
Id = DbHelper.ConvertValue<long>(record[prefix + Parameters.Id]),
CheckinTime = DbHelper.ConvertValue<string>(record[prefix + Parameters.CheckinTime]),
CheckoutTime = DbHelper.ConvertValue<string>(record[prefix + Parameters.CheckoutTime]),
CheckinTimeLatest = DbHelper.ConvertValue<string>(record[prefix + Parameters.CheckinTimeLatest]),
IsEarlyCheckinAvailable = DbHelper.ConvertValue<bool>(record[prefix + Parameters.IsEarlyCheckinAvailable]),
IsLateCheckoutAvailable = DbHelper.ConvertValue<bool>(record[prefix + Parameters.IsLateCheckoutAvailable]),
CancellationValues = new CancellationValues
{
CancellationType = CancellationTypeMapper.MapRecord(record, Parameters.CancellationType.ToString()),
CancellationChargeType = CancellationChargeTypeMapper.MapRecord(record, Parameters.CancellationChargeType.ToString()),
CancellationChargeValue = DbHelper.ConvertValue<decimal?>(record[prefix + Parameters.CancellationChargeValue]),
CancellationWindowHours = DbHelper.ConvertValue<int?>(record[prefix + Parameters.CancellationWindowHours]),
},
MerchantStatusCode = DbHelper.ConvertValue<string>(record[prefix + Parameters.MerchantStatusCode]),
MerchantStatusEnum = DbHelper.ConvertEnumValue<MerchantStatusEnum>(record[prefix + Parameters.MerchantStatusCode]),
BusinessStatus = EnumEntityMapper.MapRecord(record, Parameters.BusinessStatus.ToString()),
BusinessType = DbHelper.ConvertEnumValue<BusinessTypeEnum>(record[prefix + Parameters.BusinessTypeCode]),
Name = DbHelper.ConvertValue<string>(record[prefix + Parameters.Name]),
ShortName = DbHelper.ConvertValue<string>(record[prefix + Parameters.ShortName]),
ReferenceCode = DbHelper.ConvertValue<string>(record[prefix + Parameters.ReferenceCode]),
IsTaxRegistered = DbHelper.ConvertValue<bool>(record[prefix + Parameters.IsTaxRegistered]),
TaxRegistrationNumber = DbHelper.ConvertValue<string>(record[prefix + Parameters.TaxRegistrationNumber]),
BusinessRegistrationNumber = DbHelper.ConvertValue<string>(record[prefix + Parameters.BusinessRegistrationNumber]),
AddressLine1 = DbHelper.ConvertValue<string>(record[prefix + Parameters.AddressLine1]),
AddressLine2 = DbHelper.ConvertValue<string>(record[prefix + Parameters.AddressLine2]),
AddressLine3 = DbHelper.ConvertValue<string>(record[prefix + Parameters.AddressLine3]),
City = DbHelper.ConvertValue<string>(record[prefix + Parameters.City]),
StateProvinceId = DbHelper.ConvertValue<int?>(record[prefix + Parameters.StateProvinceId]),
PostCode = DbHelper.ConvertValue<string>(record[prefix +Parameters.PostCode]),
CountryId = DbHelper.ConvertValue<int>(record[prefix + Parameters.CountryId]),
BusinessTelephoneNumber = DbHelper.ConvertValue<string>(record[prefix + Parameters.BusinessTelephoneNumber]),
FaxNumber = DbHelper.ConvertValue<string>(record[prefix + Parameters.FaxNumber]),
Email = DbHelper.ConvertValue<string>(record[prefix + Parameters.Email]),
RegionId = DbHelper.ConvertValue<int?>(record[prefix + Parameters.RegionId]),
Longitude = DbHelper.ConvertValue<decimal>(record[prefix + Parameters.Longitude]),
Latitude = DbHelper.ConvertValue<decimal>(record[prefix + Parameters.Latitude]),
TimeZone = TimeZoneInfo.FromSerializedString(DbHelper.ConvertValue<string>(record[prefix + Parameters.DotNetKey])),
TimeZoneId = DbHelper.ConvertValue<int?>(record[prefix + Parameters.TimezoneId]),
DefaultCultureCode = DbHelper.ConvertValue<string>(record[prefix + Parameters.DefaultCultureCode]),
DefaultTaxRate = DbHelper.ConvertValue<decimal>(record[prefix + Parameters.DefaultTaxRate]),
IsMerchant = DbHelper.ConvertValue<bool>(record[prefix + Parameters.IsMerchant]),
MerchantDetailsId = DbHelper.ConvertValue<int?>(record[prefix + Parameters.MerchantDetailsId]),
IsSMS = DbHelper.ConvertValue<bool>(record[prefix + Parameters.IsSMS]),
IsTermsAndConditions = DbHelper.ConvertValue<bool>(record[prefix + Parameters.IsTandC]),
WorkingCurrencyCode = DbHelper.ConvertValue<string>(record[prefix + Parameters.WorkingCurrencyCode]),
ContractCurrencyCode = DbHelper.ConvertValue<string>(record[prefix + Parameters.ContractCurrencyCode]),
Provider = new Provider
{
RoomCount = DbHelper.ConvertValue<int?>(record[prefix + Parameters.RoomCount]),
ProviderTypeName = DbHelper.ConvertValue<string>(record[prefix + Parameters.ProviderType]),
ProviderTypeCode = DbHelper.ConvertValue<string>(record[prefix + Parameters.ProviderTypeCode]),
ContentId = DbHelper.ConvertValue<string>(record[prefix + Parameters.ContentId])
},
ProviderTypeCode = DbHelper.ConvertValue<string>(record[prefix + Parameters.ProviderTypeCode]),
Uri = DbHelper.ConvertValue<string>(record[prefix + Parameters.Uri]),
Region = RegionMapper.MapRecord(record, Parameters.Region.ToString()),
Country = CountryMapper.MapRecordOnlyName(record, Parameters.Country.ToString()),
DefaultCulture = CultureMapper.MapRecord(record, Parameters.DefaultCulture.ToString()),
StateProvince = StateProvinceMapper.MapRecordOnlyName(record, Parameters.StateProvince.ToString()),
BusinessStatusUpdatedByUser = DbHelper.ConvertValue<string>(record[prefix + Parameters.BusinessStatusUpdatedByUser]),
MerchantBankAccountId = DbHelper.ConvertValue<int?>(record[prefix + Parameters.MerchantBankAccountId]),
SettlementBankAccountId = DbHelper.ConvertValue<int?>(record[prefix + Parameters.SettlementBankAccountId]),
BusinessStatusUpdatedDateTime = DbHelper.ConvertValue<DateTime?>(record[prefix + Parameters.BusinessStatusUpdatedDateTime]),
MerchantDetails = MerchantDetailsMapper.MapRecord(record, Parameters.Merchant.ToString()),
GuestMessageCancellationId = DbHelper.ConvertValue<int?>(record[prefix + Parameters.DctGuestMessageCancellation]),
GuestMessageConfirmationId = DbHelper.ConvertValue<int?>(record[prefix + Parameters.DctGuestMessageConfirmation]),
GuestMessageGuestRegistrationId = DbHelper.ConvertValue<int?>(record[prefix + Parameters.DctGuestMessageGuestRegistration]),
GuestMessageInvoiceId = DbHelper.ConvertValue<int?>(record[prefix + Parameters.DctGuestMessageInvoice]),
Logo = new BusinessLogo
{
LogoId = DbHelper.ConvertValue<Guid?>(record[prefix + Parameters.LogoId]),
LogoDigest = DbHelper.ConvertValue<string>(record[prefix + Parameters.LogoDigest]),
LogoExtension = DbHelper.ConvertValue<string>(record[prefix + Parameters.LogoExtension])
},
PrePayRuleValue = DbHelper.ConvertValue<decimal?>(record[prefix + Parameters.PrePayRuleValue]),
PrePayRuleType = DbHelper.ConvertEnumValue<PrePayRuleTypeEnum>(record[prefix + Parameters.PrePayRuleTypeCode]),
CurrentRates = new List<FxRate>()
};
return AuditFieldsHelper.MapRecord(business, record, prefix);
}
public void UpdateBusinessStatusWithAutomaticPrepay()
{
// Arrange
const int businessId = 1;
const string notes = "some notes";
var businessDao = new Mock<IBusinessDao>();
var eventTrackingManager = new Mock<IEventTrackingManager>();
businessManager.BusinessDao = businessDao.Object;
businessManager.EventTrackingManager = eventTrackingManager.Object;
var business = new Model.Business.Business
{
Id = businessId,
BusinessStatus = new EnumEntity { Code = BusinessStatus.PENDING },
PrePayRuleType = PrePayRuleTypeEnum.Unknown
};
businessDao.Setup(x => x.GetByKey(businessId, string.Empty)).Returns(business);
businessDao.Setup(x => x.UpdateStatus(businessId, BusinessStatusType.ACTIVE)).Returns(true);
businessDao.Setup(x => x.ModifyBusinessSettings(It.IsAny<Model.Business.Business>()));
eventTrackingManager.Setup(x => x.CreateBusinessEventAsync(businessId, BusinessEventTypesEnum.Activated, string.Empty, notes));
eventTrackingManager.Setup(x => x.CreateBusinessEventAsync(businessId, BusinessEventTypesEnum.EditBusinessSettings, string.Empty, null));
eventTrackingManager.Setup(x => x.CreateBusinessEventAsync(businessId, BusinessEventTypesEnum.AutomaticPrePayRuleCreated, string.Empty, null));
// Act
businessManager.UpdateStatus(businessId, BusinessStatusType.ACTIVE, notes);
// Assert
businessDao.VerifyAll();
eventTrackingManager.Verify(x => x.CreateBusinessEventAsync(businessId, BusinessEventTypesEnum.Activated, string.Empty, notes), Times.Once());
eventTrackingManager.Verify(x => x.CreateBusinessEventAsync(businessId, BusinessEventTypesEnum.EditBusinessSettings, string.Empty, null), Times.Once());
eventTrackingManager.Verify(x => x.CreateBusinessEventAsync(businessId, BusinessEventTypesEnum.AutomaticPrePayRuleCreated, string.Empty, null), Times.Once());
}
protected override void RunBeforeAllTests()
{
base.RunBeforeAllTests();
var businessManager = new BusinessManager();
var roomTypeManager = new RoomTypeManager();
var roomManager = new RoomManager();
var orderManager = new OrderManager();
//Create a business
var paymentMethod = new BusinessPaymentMethod
{
BusinessId = BUSINESS_ID,
CurrencyCode = CURRENCY,
PaymentMethodCode = PaymentMethodEnum.Cash.GetCode()
};
var provider = new Provider
{
RoomCount = ROOM_COUNT,
ContentId = BUSINESS_ID.ToString(),
ProviderTypeCode = PROVIDER_TYPE,
};
var business = new Model.Business.Business
{
BusinessStatusCode = "A",
BusinessTypeCode = "P",
Name = "Test Business",
ShortName = "Test",
ReferenceCode = "B001",
IsTaxRegistered = true,
TaxRegistrationNumber = "12345",
BusinessRegistrationNumber = "12345",
AddressLine1 = "5 Main Road",
AddressLine2 = "Twickenham",
City = "London",
StateProvinceId = 386,
PostCode = "TW2 5SE",
CountryId = 16,
BusinessTelephoneNumber = "07448752114",
TimeZoneId = 36,
DefaultCultureCode = CULTURE,
WorkingCurrencyCode = CURRENCY,
UpdatedByUserId = new Guid("11111111-1111-1111-1111-111111111111"),
Provider = provider,
BusinessPaymentMethods = new List<BusinessPaymentMethod> {paymentMethod}
};
var businessId = businessManager.CreateBusiness(business);
// Create a room type
var ratePlan = new BaseRatePlan
{
BusinessId = businessId,
CurrencyCode = CURRENCY,
MaxAdults = 2,
MaxChildren = 2,
MaxOccupancy = 3,
BoardBasis = new EnumEntity {Code = "BK"},
CancellationClass = new EnumEntity {Code = "FR"},
RackRate = new decimal(120.0),
SellAtRackRate = true,
RatePlanType = new RatePlanType {Type = RatePlanTypeEnum.Base},
Rates = new RatePlanRate{BusinessId = businessId, MonRate = 120, MonMinStay = 120},
UpdatedByUserId = new Guid("11111111-1111-1111-1111-111111111111"),
};
var roomType = new RoomType
{
BusinessId = businessId,
RoomClass = roomTypeManager.GetRoomClasses(CULTURE).FirstOrDefault(), //new RoomClass { Code = "DBL" },
QualityType = roomTypeManager.GetQualityTypes(CULTURE).FirstOrDefault(), //new QualityType { Code = "APT" },
BathroomType = roomTypeManager.GetBathroomTypes(CULTURE).FirstOrDefault(), //new BathroomType { Code = "SP" },
Code = "DBL99",
ServiceFrequency = new EnumEntity { Code = "B" },
UpdatedByUserId = new Guid("11111111-1111-1111-1111-111111111111"),
BaseRatePlan = ratePlan,
BaseRatePlanId = ratePlan.Id,
Aspect = new Aspect { Code = "BAL"},
};
roomTypeManager.CreateRoomTypeAndBaseRatePlan(roomType);
roomType = roomTypeManager.GetRoomTypesAndBaseRatePlans(businessId, CULTURE).First();
ratePlan = roomType.BaseRatePlan;
//Create a room
var roomId = roomManager.CreateRoom("TestRoom", roomType.Id, businessId);
//Create an order
var booking = new Booking
{
BusinessId = businessId,
Guest = new Guest { DefaultCultureCode = CULTURE, Surname = "TestSurname", BusinessId = businessId },
StartDate = new DateTime(2014, 2, 10, 0, 0, 0, DateTimeKind.Utc),
EndDate = new DateTime(2014, 2, 12, 0, 0, 0, DateTimeKind.Utc),
NumberOfAdults = 2,
NumberOfChildren = 1,
Cost = new decimal(120.5),
BookingStatus = new EnumEntity { Code = BookingStatusType.CONFIRMED },
RoomTypeId = roomType.Id,
RoomId = roomId,
RatePlanId = ratePlan.Id,
Notes = "Testing note",
BookingScenarioType = BookingScenarioTypeEnum.OnAccountBooking,
RateType = new EnumEntity { Code = RateType.BEST_AVAILABLE_RATE },
CheckinStatus = new EnumEntity { Code = CheckinStatusOptions.NOTCHECKEDIN },
IsAvailabilityIgnored = true,
BoardBasis = BoardBasisTypeEnum.BreakfastIncluded,
CancellationDetails = new CancellationDetail()
};
var order = new Order
{
OfflineSourceEnum = OfflineSourceEnum.Web,
OrderSourceCode = SourceType.Pms.GetCode(),
CustomerCurrencyCode = CURRENCY,
Bookings = new List<Booking> { booking },
CustomerCultureCode = "en-GB"
};
// Mock email manager so it doesn't send emails
var emailManager = new Mock<IEmailManager>();
orderManager.EmailManager = emailManager.Object;
emailManager.Setup(x => x.SendConfirmationEmails(order)).Returns(true);
orderManager.CreateOrder(businessId, order);
}
public void ModifyBusinessSettingsCallsCorrectMethod()
{
// Arrange
long businessId = 1;
var businessToModify = new Model.Business.Business
{
Id = businessId,
Provider = new Provider
{
Id = businessId
}
};
var businessDao = new Mock<IBusinessDao>();
var eventTrackingManager = new Mock<IEventTrackingManager>();
businessManager.BusinessDao = businessDao.Object;
businessManager.EventTrackingManager = eventTrackingManager.Object;
businessDao.Setup(b => b.ModifyBusinessSettings(It.IsAny<Model.Business.Business>())).Returns(true);
businessDao.Setup(b => b.DeleteBusinessOfflinePayments(businessId)).Returns(true);
eventTrackingManager.Setup(e => e.CreateBusinessEventAsync(businessId, BusinessEventTypesEnum.EditBusinessSettings, It.IsAny<string>(), null));
// Act
businessManager.ModifyBusinessSettings(businessToModify);
// Assert
businessDao.VerifyAll();
eventTrackingManager.Verify(e => e.CreateBusinessEventAsync(businessId, BusinessEventTypesEnum.EditBusinessSettings, It.IsAny<string>(), null), Times.Once);
}
public void CreateBusinessCallsExpectedMethods()
{
// Arrange
var businessDao = MockRepository.GenerateMock<IBusinessDao>();
var businessEventDao = MockRepository.GenerateMock<IBusinessEventDao>();
var businessChannelOptInDao = MockRepository.GenerateMock<IBusinessChannelOptInDao>();
var distributionManagerMock = MockRepository.GenerateMock<IDistributionManager>();
var businessChannelOverrideDaoMock = MockRepository.GenerateMock<IBusinessChannelOverrideDao>();
var paymentMethod = new BusinessPaymentMethod
{
BusinessId = BUSINESS_ID,
CurrencyCode = CURRENCY,
PaymentMethodCode = PaymentMethodEnum.Cash.GetCode()
};
var newProvider = new Provider
{
RoomCount = ROOM_COUNT,
ContentId = BUSINESS_ID.ToString(),
ProviderTypeCode = PROVIDER_TYPE
};
var channels = new List<BusinessChannelOptIn>
{
new BusinessChannelOptIn
{
Id = CHANNEL_OPT_IN_ID,
ChannelId = CHANNEL_ID,
ChannelTermsId = CHANNEL_TERMS_ID,
BusinessId = BUSINESS_ID
}
};
var newBusiness = new Model.Business.Business
{
Provider = newProvider,
WorkingCurrencyCode = CURRENCY,
BusinessPaymentMethods = new List<BusinessPaymentMethod>
{
paymentMethod
}
};
businessManager.BusinessDao = businessDao;
businessManager.BusinessEventDao = businessEventDao;
businessManager.BusinessChannelOptInDao = businessChannelOptInDao;
businessManager.DistributionManager = distributionManagerMock;
businessManager.BusinessChannelOverrideDao = businessChannelOverrideDaoMock;
businessDao.Expect(x => x.Create(Arg<Model.Business.Business>.Is.Anything))
.Return(BUSINESS_ID)
.Repeat.Once();
businessDao.Expect(x => x.AddBusinessOfflinePaymentMethod(Arg<BusinessPaymentMethod>.Matches(bp => bp.BusinessId == paymentMethod.BusinessId &&
bp.CurrencyCode == paymentMethod.CurrencyCode &&
bp.PaymentMethodCode == paymentMethod.PaymentMethodCode))).Return(true).Repeat.Once();
businessDao.Expect(x => x.CreateProvider(Arg<Provider>.Matches(p => p.Id == newProvider.Id &&
p.RoomCount == newProvider.RoomCount &&
p.ContentId == newProvider.ContentId &&
p.ProviderTypeCode == newProvider.ProviderTypeCode))).Return(true).Repeat.Once();
businessChannelOptInDao.Expect(x => x.GetDefaultChannelsPerBusinessLocation(Arg<long>.Is.Equal(BUSINESS_ID))).Return(channels).Repeat.Once();
distributionManagerMock.Expect(
dmm => dmm.OptInToChannel(Arg<BusinessChannelOptIn>.Matches(bc => bc.Id == CHANNEL_OPT_IN_ID &&
bc.ChannelId == CHANNEL_ID &&
bc.ChannelTermsId ==
CHANNEL_TERMS_ID &&
bc.BusinessId == BUSINESS_ID),
Arg<string>.Is.Anything)).Repeat.Once();
businessEventDao.Expect(
be => be.Create(Arg<BusinessEvent>.Matches(bev => bev.BusinessId == BUSINESS_ID &&
bev.EventType.Code == BusinessEventTypesEnum.Created.GetCode())))
.Repeat.Once();
businessChannelOverrideDaoMock.Expect(
bco => bco.CreateInitialBusinessChannelOverride(Arg<long?>.Is.Anything, Arg<int?>.Is.Anything)).Repeat.Once();
// Act
businessManager.CreateBusiness(newBusiness);
// Assert
businessDao.VerifyAllExpectations();
businessEventDao.VerifyAllExpectations();
distributionManagerMock.VerifyAllExpectations();
businessChannelOptInDao.VerifyAllExpectations();
businessChannelOverrideDaoMock.VerifyAllExpectations();
}
public void ModifyBusinessCallsCorrectMethodsIsSuccessful()
{
// Arrange
Model.Business.Business businessToModify = new Model.Business.Business()
{
Id = BUSINESS_ID,
Provider = new Provider
{
Id = BUSINESS_ID
}
};
IBusinessDao businessDaoMock = MockRepository.GenerateMock<IBusinessDao>();
IBusinessEventDao businessEventDaoMock = MockRepository.GenerateMock<IBusinessEventDao>();
businessDaoMock.Expect(bd => bd.Modify(Arg<Model.Business.Business>.Matches(b => b.Id == businessToModify.Id &&
b.Provider.Id == businessToModify.Provider.Id)))
.Repeat.Once();
businessDaoMock.Expect(
bd => bd.ModifyProvider(Arg<Provider>.Matches(p => p.Id == businessToModify.Provider.Id)))
.Repeat.Once();
businessEventDaoMock.Expect(
be => be.Create(Arg<BusinessEvent>.Matches(bev => bev.BusinessId == businessToModify.Id &&
bev.EventType.Code == BusinessEventTypesEnum.Modified.GetCode() &&
bev.Reference == businessToModify.Id.ToString()))).Repeat.Once();
businessManager.BusinessDao = businessDaoMock;
businessManager.BusinessEventDao = businessEventDaoMock;
// Act
businessManager.ModifyBusiness(businessToModify);
// Assert
businessDaoMock.VerifyAllExpectations();
businessEventDaoMock.VerifyAllExpectations();
}
public void ValidatePrePayCancelSettingsReturnsTrueWhenValid(CancellationValues cancelValues, decimal? prePayValue, PrePayRuleTypeEnum ruleType, bool result)
{
// Arrange
Model.Business.Business business = new Model.Business.Business
{
CancellationValues = cancelValues,
PrePayRuleValue = prePayValue,
PrePayRuleType = ruleType
};
// Act
bool actualResult = businessManager.ValidatePrePayCancelSettingsForBusiness(business);
// Assert
Assert.AreEqual(result, actualResult, "Validation did not match expected");
}
public void GetProviderWithRoomTypeAndRatePlansCallCorrectMethodsAndReturnNull()
{
//Arrange
var business = new Model.Business.Business { Id = 5002, ShortName = "TestBus2", DefaultCultureCode = "en-GB" };
var businessManager = MockRepository.GenerateMock<IBusinessManager>();
var distributorManager = MockRepository.GenerateMock<IDistributionManager>();
var roomTypeManager = MockRepository.GenerateMock<IRoomTypeManager>();
contentService.BusinessManager = businessManager;
contentService.DistributionManager = distributorManager;
contentService.RoomTypeManager = roomTypeManager;
businessManager.Expect(b => b.GetLimitedBusinessByShortname(business.ShortName)).Return(null);
//Act
var result = contentService.GetProviderWithRoomTypeAndRatePlans(business.ShortName, string.Empty);
//Assert
Assert.IsNull(result);
}
public void EagleBusinessToEcomBusinessMapsChannelNames()
{
// Arrange
var channelNames = new List<string> { "Channel1", "Channel3", "Channel3", "Channel4", "Channel5" };
var createdByUser = new UserExtension { FirstName = "John", LastName = "Doe" };
var updatedByUser = new UserExtension { FirstName = "Dummy", LastName = "User" };
const int BUSINESS_ID = 12345;
const string SYNC_CODE_UK = "UK";
const string SYNC_CODE_IN = "IN";
const string CHANNEL_6_NAME = "Channel6";
var businessChannelOptIn = new BusinessChannelOptIn
{
BusinessId = BUSINESS_ID,
PrePaySettings = new BusinessChannelPrePaySettings
{
Type = PrePayRuleTypeEnum.Amount,
Value = 1,
BusinessId = BUSINESS_ID
}
};
var eagleBusiness = new Model.Business.Business
{
Id = BUSINESS_ID,
Name = "Business 1",
ShortName = "Bus1",
CreatedByUser = createdByUser,
UpdatedByUser = updatedByUser,
Distributors = new Collection<Distributor>
{
new Distributor
{
Channels = new List<Channel>
{
new Channel { ShortName = channelNames[0], BusinessChannelOptIn = businessChannelOptIn, ChannelSynchronizationTypeCode = SYNC_CODE_UK},
new Channel { ShortName = channelNames[1], BusinessChannelOptIn = businessChannelOptIn, ChannelSynchronizationTypeCode = SYNC_CODE_UK},
new Channel { ShortName = channelNames[2], BusinessChannelOptIn = businessChannelOptIn, ChannelSynchronizationTypeCode = SYNC_CODE_UK},
}
},
new Distributor
{
Channels = new List<Channel>
{
new Channel { ShortName = channelNames[3], BusinessChannelOptIn = businessChannelOptIn, ChannelSynchronizationTypeCode = SYNC_CODE_UK},
new Channel { ShortName = channelNames[4], BusinessChannelOptIn = businessChannelOptIn, ChannelSynchronizationTypeCode = SYNC_CODE_UK},
new Channel { ShortName = CHANNEL_6_NAME, BusinessChannelOptIn = businessChannelOptIn, ChannelSynchronizationTypeCode = SYNC_CODE_IN}
}
}
},
OnlineBookingScenarios = new Collection<OnlineBookingScenario>(),
MerchantDetails = new MerchantDetails(),
Provider = new Provider { ContentId = BUSINESS_ID.ToString(CultureInfo.InvariantCulture) }
};
// Act
List<string> missedChannels;
var ecommBusiness = EcomConverter.EagleBusinessToEcom(eagleBusiness, SYNC_CODE_UK, out missedChannels);
foreach (var channelName in channelNames)
{
Assert.True(ecommBusiness.Channels.Any(c => c.ChannelName == channelName), string.Format("{0} not found in ecommBusiness.Channels", channelName));
}
Assert.False(ecommBusiness.Channels.Any(c => c.ChannelName == CHANNEL_6_NAME), string.Format("{0} found in ecommBusiness.Channels", CHANNEL_6_NAME));
Assert.IsTrue(missedChannels.Contains(CHANNEL_6_NAME), string.Format("{0} channel name was not missed", CHANNEL_6_NAME));
}
public void SetFinancialInfoOnTransactionModelCallsCorrectMethodsWithExpediaIsSuccessful()
{
// Arrange
const decimal ORDER_AMOUNT_PAID = 25M;
const decimal GROSS_AMOUNT = 50M;
const int ORDER_ID = 5;
const int BOOKING_ID = 3;
const int BOOKING_ITEM_ONE = 1, BOOKING_ITEM_TWO = 2, BOOKING_ITEM_THREE = 3;
const decimal NO_SHOW_ONE = 4, NO_SHOW_TWO = 8;
TransactionModel mockTransModel = new TransactionModel {ScenarioType = ScenarioType.OnAccountPrincipalWholesaleRate};
Booking mockBooking = new Booking()
{
Id = BOOKING_ID,
OrderId = ORDER_ID,
BookingScenarioType = BookingScenarioTypeEnum.OnAccountBooking
};
Model.Business.Business mockBusiness = new Model.Business.Business();
Order mockOrder = new Order()
{
Id = ORDER_ID,
ChannelCommissionType = CommissionTypeEnum.Net,
TotalValue = 4,
TotalNetValue = 3
};
List<BookingItem> mockBookingItems = new List<BookingItem>()
{
new BookingItem
{
Id = BOOKING_ITEM_ONE,
BookingId = BOOKING_ID,
ItemType = ItemTypeEnum.Breakfast,
Charge = new Charge
{
Amount = 5m
}
},
new BookingItem
{
Id = BOOKING_ITEM_THREE,
BookingId = BOOKING_ID,
ItemType = ItemTypeEnum.DistributorCommission
},
new BookingItem
{
Id = BOOKING_ITEM_TWO,
BookingId = BOOKING_ID,
ItemType = ItemTypeEnum.EviivoCommission
}
};
List<BookingConstituent> mockConstituentsOne = new List<BookingConstituent>()
{
new BookingConstituent
{
ItemId = BOOKING_ITEM_ONE,
ConstituentType = BookingConstituentType.ValueAddedTax,
RelevantPercentage = 6
}
};
List<BookingConstituent> mockConstituentsTwo = new List<BookingConstituent>()
{
new BookingConstituent
{
ItemId = BOOKING_ITEM_TWO,
RelevantPercentage = 5
},
new BookingConstituent
{
ItemId = BOOKING_ITEM_TWO,
Amount = NO_SHOW_ONE,
ConstituentType = BookingConstituentType.NoShowFee
}
};
List<BookingConstituent> mockConstituentsThree = new List<BookingConstituent>()
{
new BookingConstituent
{
ItemId = BOOKING_ITEM_THREE,
RelevantPercentage = 10
},
new BookingConstituent
{
ItemId = BOOKING_ITEM_THREE,
Amount = NO_SHOW_TWO,
ConstituentType = BookingConstituentType.NoShowFee
}
};
IBookingItemDao bookingItemDaoMock = MockRepository.GenerateMock<IBookingItemDao>();
bookingItemDaoMock.Expect(bid => bid.GetConstituentsByItemId(Arg<int>.Is.Equal(BOOKING_ITEM_ONE)))
.Return(mockConstituentsOne).Repeat.Once();
bookingItemDaoMock.Expect(bid => bid.GetConstituentsByItemId(Arg<int>.Is.Equal(BOOKING_ITEM_TWO)))
.Return(mockConstituentsTwo).Repeat.Once();
bookingItemDaoMock.Expect(bid => bid.GetConstituentsByItemId(Arg<int>.Is.Equal(BOOKING_ITEM_THREE)))
.Return(mockConstituentsThree).Repeat.Once();
IOrderDao orderDaoMock = MockRepository.GenerateMock<IOrderDao>();
orderDaoMock.Expect(o => o.GetOrderValueByItemTypes(Arg<int>.Is.Anything, Arg<bool>.Is.Anything, Arg<string>.Is.Anything)).Return(GROSS_AMOUNT);
SettlementManager manager = MockRepository.GeneratePartialMock<SettlementManager>();
manager.BookingItemDao = bookingItemDaoMock;
manager.OrderDao = orderDaoMock;
manager.Expect(m => m.GetRelevantPercentageByItemType(Arg<List<BookingItem>>.Is.Equal(mockBookingItems),
Arg<List<BookingConstituent>>.List.ContainsAll(new List<BookingConstituent>
{
mockConstituentsOne.First(), mockConstituentsThree.First(), mockConstituentsTwo.First()
}),
Arg<ItemTypeEnum>.Is.Equal(
ItemTypeEnum.DistributorCommission))).
Return(mockConstituentsThree.First().RelevantPercentage.Value).Repeat.Once();
manager.Expect(m => m.GetRelevantPercentageByItemType(Arg<List<BookingItem>>.Is.Equal(mockBookingItems),
Arg<List<BookingConstituent>>.List.ContainsAll(new List<BookingConstituent>
{
mockConstituentsOne.First(), mockConstituentsThree.First(), mockConstituentsTwo.First()
}),
Arg<ItemTypeEnum>.Is.Equal(
ItemTypeEnum.EviivoCommission))).
Return(mockConstituentsTwo.First().RelevantPercentage.Value).Repeat.Once();
manager.Expect(
m =>
m.GetRelevantPercentageByConstituentType(
Arg<List<BookingConstituent>>.List.ContainsAll(new List<BookingConstituent>
{
mockConstituentsOne.First(),
mockConstituentsThree.First(),
mockConstituentsTwo.First()
}),
Arg<BookingConstituentType>.Is.Equal(BookingConstituentType.ValueAddedTax)))
.Return(mockConstituentsOne.First().RelevantPercentage.Value)
.Repeat.Once();
// Act
manager.SetFinancialInfoOnTransactionModel(mockTransModel, mockBooking, mockBusiness, mockOrder,
mockBookingItems, ORDER_AMOUNT_PAID);
// Assert
Assert.AreEqual(ORDER_AMOUNT_PAID, mockTransModel.AmountPaid, "Amount paid not set");
Assert.AreEqual(GROSS_AMOUNT, mockTransModel.GrossBookingAmount,
"Gross booking amount not set correctly");
Assert.AreEqual(mockOrder.TotalNetValue, mockTransModel.NetBookingAmount,
"Net booking amount not set correctly");
Assert.AreEqual(mockConstituentsTwo.First().RelevantPercentage.Value,
mockTransModel.EviivoCommissionPercentage, "eviivo percentage not set correctly");
Assert.AreEqual(mockConstituentsThree.First().RelevantPercentage.Value,
mockTransModel.DistributorCommissionPercentage,
"distributor Commission not set properly");
Assert.AreEqual(NO_SHOW_ONE + NO_SHOW_TWO, mockTransModel.NoShowFeeAmount, "No show fee not summed");
bookingItemDaoMock.VerifyAllExpectations();
manager.VerifyAllExpectations();
}
public void CreateTransactionModelForInvoiceRequestReturnsTransactionModelCorrectly()
{
#region Arrange
// Arrange
IBookingDao bookingDaoMock = MockRepository.GenerateMock<IBookingDao>();
IBusinessDao businessDaoMock = MockRepository.GenerateMock<IBusinessDao>();
IOrderDao orderDaoMock = MockRepository.GenerateMock<IOrderDao>();
IOrderReferenceDao orderReferenceMock = MockRepository.GenerateMock<IOrderReferenceDao>();
IChannelDao channelDaoMock = MockRepository.GenerateMock<IChannelDao>();
ICountryDao countryDaoMock = MockRepository.GenerateMock<ICountryDao>();
IBookingEventDao bookingEventDaoMock = MockRepository.GenerateMock<IBookingEventDao>();
IBookingEventDataDao bookingEventDataDaoMock = MockRepository.GenerateMock<IBookingEventDataDao>();
IBookingItemDao bookingItemDaoMock = MockRepository.GenerateMock<IBookingItemDao>();
IPaymentEventDao paymentEventDaoMock = MockRepository.GenerateMock<IPaymentEventDao>();
IPaymentDao paymentDaoMock = MockRepository.GenerateMock<IPaymentDao>();
ISettlementHelper settlementHelperMock = MockRepository.GenerateMock<ISettlementHelper>();
bool forceProcess = true;
Booking bookingMock = new Booking
{
Id = GOOD_BOOKING_ID,
OrderId = GOOD_ORDER_ID,
BusinessId = GOOD_BUSINESS_ID,
BookingReferenceNumber = GOOD_BOOKING_REF
};
Model.Business.Business businessMock = new Model.Business.Business
{
Id = GOOD_BUSINESS_ID
};
Order orderMock = new Order
{
Id = GOOD_ORDER_ID,
Bookings = new List<Model.Booking.Booking> {bookingMock},
ChannelId = GOOD_CHANNEL_ID
};
Channel channelMock = new Channel
{
Id = GOOD_CHANNEL_ID,
DistributorId = GOOD_CHANNEL_BUSINESS_ID
};
Model.Business.Business channelBusinessMock = new Model.Business.Business
{
Id = GOOD_CHANNEL_BUSINESS_ID
};
Country countryMock = new Country
{
Id = GOOD_COUNTRY_ID,
IsoChar2Code = UK_COUNTRY_CODE
};
BookingEvent bookingEventMock = new BookingEvent
{
Id = GOOD_EVENT_ID,
BookingId = GOOD_BOOKING_ID
};
List<BookingEventData> bookingEventDataMock = new List<BookingEventData>();
var bookingPaymentMock = new Model.Booking.Payment
{
Id = GOOD_PAYMENT_ID
};
var paymentListMock = new List<Model.Booking.Payment> { bookingPaymentMock };
List<BookingItem> bookingItemMock = new List<BookingItem>();
List<PaymentEvent> paymentEventListMock = new List<PaymentEvent>();
List<SettlementPaymentDto> settlementPaymentDtosMock = new List<SettlementPaymentDto>();
bookingDaoMock.Expect(bd => bd.GetByKey(Arg<int>.Is.Equal(GOOD_BOOKING_ID), Arg<string>.Is.Anything)).Return(bookingMock).Repeat.Never();
businessDaoMock.Expect(bu => bu.GetByKey(Arg<long>.Is.Equal(bookingMock.BusinessId), Arg<string>.Is.Equal(string.Empty))).Return(businessMock).Repeat.Once();
orderDaoMock.Expect(od => od.GetOrderWithBookingsByKey(Arg<int>.Is.Equal(GOOD_ORDER_ID), Arg<string>.Is.Anything, Arg<string>.Is.Anything, Arg<string>.Is.Anything, Arg<GetOrderWithBookingsByEnum>.Is.Equal(GetOrderWithBookingsByEnum.Id))).Return(orderMock).Repeat.Once();
orderReferenceMock.Expect(
or =>
or.GetByOrderIdAndReferenceType(Arg<int>.Is.Equal(GOOD_ORDER_ID),
Arg<ReferenceTypeEnum>.Is.Equal(ReferenceTypeEnum.EcommerceReservation)))
.Return(null)
.Repeat.Once();
channelDaoMock.Expect(cd => cd.GetById(Arg<int>.Is.Equal(orderMock.ChannelId.Value)))
.Return(channelMock)
.Repeat.Once();
businessDaoMock.Expect(bu => bu.GetByKey(Arg<long>.Is.Equal(channelMock.DistributorId.Value), Arg<string>.Is.Equal(string.Empty)))
.Return(channelBusinessMock)
.Repeat.Once();
countryDaoMock.Expect(cod => cod.GetByBusiness(Arg<long>.Is.Equal(bookingMock.BusinessId)))
.Return(countryMock)
.Repeat.Once();
bookingEventDaoMock.Expect(bed => bed.GetByKey(GOOD_EVENT_ID)).Return(bookingEventMock).Repeat.Once();
bookingEventDataDaoMock.Expect(bedd => bedd.GetAllByEventId(Arg<int>.Is.Equal(bookingEventMock.Id)))
.Return(bookingEventDataMock)
.Repeat.Once();
paymentDaoMock.Expect(pd => pd.GetPaymentsByOrder(Arg<int>.Is.Equal(GOOD_ORDER_ID)))
.Return(paymentListMock)
.Repeat.Once();
// settlement manager mocks of inner methods
SettlementManager settlementManagerMock = MockRepository.GeneratePartialMock<SettlementManager>();
settlementManagerMock.Expect(
sm =>
sm.GetPaymentByTypeAndSource(Arg<IEnumerable<Model.Booking.Payment>>.List.ContainsAll(paymentListMock),
Arg<PaymentTypeEnum>.Is.Equal(PaymentTypeEnum.Payment),
Arg<PaymentSourceEnum>.Is.Equal(PaymentSourceEnum.Online)))
.Return(bookingPaymentMock).Repeat.Once();
bookingItemDaoMock.Expect(bid => bid.GetByBooking(Arg<int>.Is.Equal(GOOD_BOOKING_ID)))
.Return(bookingItemMock)
.Repeat.Once();
paymentEventDaoMock.Expect(ped => ped.GetByPaymentId(Arg<int>.Is.Equal(bookingPaymentMock.Id)))
.Return(paymentEventListMock)
.Repeat.Once();
settlementManagerMock.Expect(
smm =>
smm.GetSettlementPayment(
Arg<PaymentRequest>.Matches(
pr => pr.BookingReferenceCode == bookingMock.BookingReferenceNumber &&
pr.IsoCountryCode == countryMock.IsoChar2Code)))
.Return(settlementPaymentDtosMock)
.Repeat.Once();
settlementManagerMock.Expect(
sem =>
sem.SetLineItemsOnTransactionModel(Arg<TransactionModel>.Is.Anything,
Arg<List<SettlementPaymentDto>>.Is.Anything,
Arg<Order>.Matches(
o =>
o.Id == orderMock.Id && o.ChannelId == orderMock.ChannelId &&
o.Bookings != null &&
o.Bookings.Count == orderMock.Bookings.Count),
Arg<List<Model.Booking.Payment>>.List.ContainsAll(paymentListMock),
Arg<List<PaymentEvent>>.Is.Anything)).Repeat.Once();
settlementManagerMock.Expect(
sem =>
sem.SetGuestInfoOnTransactionModel(Arg<TransactionModel>.Is.Anything,
Arg<Order>.Matches(
b =>
b.Id == orderMock.Id &&
b.OrderReference == orderMock.OrderReference))).Repeat.Once();
settlementManagerMock.Expect(
sem => sem.SetBookingInfoOnTransactionModel(Arg<TransactionModel>.Is.Anything,
Arg<Booking>.Matches(b =>
b.Id == bookingMock.Id &&
b.OrderId == bookingMock.OrderId &&
b.BusinessId ==
bookingMock.BusinessId &&
b.BookingReferenceNumber ==
bookingMock.BookingReferenceNumber),
Arg<Order>.Matches(
o =>
o.Id == orderMock.Id &&
o.ChannelId == orderMock.ChannelId &&
o.Bookings != null &&
o.Bookings.Count == orderMock.Bookings.Count),
Arg<BookingEvent>.Matches(
be =>
be.Id == bookingEventMock.Id &&
be.BookingId == bookingEventMock.BookingId),
Arg<List<BookingEventData>>.Is.Anything,
Arg<Model.Business.Business>.Matches(
bu => bu.Id == businessMock.Id),
Arg<List<SettlementPaymentDto>>.Is.Anything,
Arg<string>.Is.Anything)).Repeat.Once();
settlementManagerMock.Expect(
sem => sem.SetFinancialInfoOnTransactionModel(Arg<TransactionModel>.Is.Anything,
Arg<Booking>.Matches(b =>
b.Id == bookingMock.Id &&
b.OrderId == bookingMock.OrderId &&
b.BusinessId ==
bookingMock.BusinessId &&
b.BookingReferenceNumber ==
bookingMock
.BookingReferenceNumber),
Arg<Model.Business.Business>.Matches(
bu => bu.Id == businessMock.Id),
Arg<Order>.Matches(
o =>
o.Id == orderMock.Id &&
o.ChannelId == orderMock.ChannelId &&
o.Bookings != null &&
o.Bookings.Count == orderMock.Bookings.Count),
Arg<List<BookingItem>>.Is.Anything,
Arg<decimal>.Is.Anything)).Repeat.Once();
settlementManagerMock.Expect(
sem =>
sem.SetPaymentInfoOnTransactionModel(Arg<TransactionModel>.Is.Anything,
Arg<Model.Booking.Payment>.Matches(p => p.Id == bookingPaymentMock.Id),
Arg<List<SettlementPaymentDto>>.Is.Anything,
Arg<Order>.Matches(
o =>
o.Id == orderMock.Id &&
o.ChannelId == orderMock.ChannelId &&
o.Bookings != null &&
o.Bookings.Count == orderMock.Bookings.Count),
Arg<bool>.Is.Equal(forceProcess))).Repeat.Once();
settlementManagerMock.Expect(
sem =>
sem.SetProviderDistributorInformationOnTransactionModel(Arg<TransactionModel>.Is.Anything,
Arg<Model.Business.Business>.Matches(
bu => bu.Id == businessMock.Id),
Arg<Model.Business.Business>.Matches(
chbu => chbu.Id == channelBusinessMock.Id),
Arg<Channel>.Is.Anything)).Repeat.Once();
settlementManagerMock.Expect(
sem =>
sem.SetReservedProductOnTransactionModel(Arg<TransactionModel>.Is.Anything,
Arg<Booking>.Matches(b =>
b.Id == bookingMock.Id &&
b.OrderId == bookingMock.OrderId &&
b.BusinessId ==
bookingMock.BusinessId &&
b.BookingReferenceNumber ==
bookingMock
.BookingReferenceNumber),
Arg<Order>.Matches(
o =>
o.Id == orderMock.Id &&
o.ChannelId == orderMock.ChannelId &&
o.Bookings != null &&
o.Bookings.Count == orderMock.Bookings.Count),
Arg<string>.Is.Anything)).Repeat.Once();
settlementHelperMock.Expect(
helper =>
helper.SetMerchantInfoOnTransactionModel(Arg<TransactionModel>.Is.Anything,
Arg<Model.Booking.Booking>.Is.Anything,
Arg<Model.Business.Business>.Is.Anything,
Arg<Model.Business.Business>.Is.Anything,
Arg<List<SettlementPaymentDto>>.Is.Anything));
settlementManagerMock.BookingDao = bookingDaoMock;
settlementManagerMock.BookingEventDao = bookingEventDaoMock;
settlementManagerMock.BookingEventDataDao = bookingEventDataDaoMock;
settlementManagerMock.BookingItemDao = bookingItemDaoMock;
settlementManagerMock.BusinessDao = businessDaoMock;
settlementManagerMock.ChannelDao = channelDaoMock;
settlementManagerMock.CountryDao = countryDaoMock;
settlementManagerMock.OrderDao = orderDaoMock;
settlementManagerMock.OrderReferenceDao = orderReferenceMock;
settlementManagerMock.PaymentEventDao = paymentEventDaoMock;
settlementManagerMock.PaymentDao = paymentDaoMock;
settlementManagerMock.SettlementHelper = settlementHelperMock;
#endregion
// Act
TransactionModel result = settlementManagerMock.CreateTransactionModelForInvoiceRequest(
GOOD_BOOKING_ID, GOOD_ORDER_ID, GOOD_EVENT_ID, forceProcess);
// Assert
settlementManagerMock.VerifyAllExpectations();
bookingDaoMock.VerifyAllExpectations();
bookingEventDaoMock.VerifyAllExpectations();
bookingEventDataDaoMock.VerifyAllExpectations();
bookingItemDaoMock.VerifyAllExpectations();
businessDaoMock.VerifyAllExpectations();
channelDaoMock.VerifyAllExpectations();
countryDaoMock.VerifyAllExpectations();
orderDaoMock.VerifyAllExpectations();
orderReferenceMock.VerifyAllExpectations();
paymentEventDaoMock.VerifyAllExpectations();
paymentDaoMock.VerifyAllExpectations();
settlementHelperMock.VerifyAllExpectations();
}
public void FullModifyBusinessSucceeds()
{
using (new TestDataHelper(GetTestQuery(TestQuery.PopulateBusinessesTestData), GetTestQuery(TestQuery.CleanupUnitTestData)))
{
// Arrange
Model.Business.Business businessToModify = new Model.Business.Business
{
Id = 1,
Name = "_Name_",
AddressLine1 = "_AddressLine1_",
AddressLine2 = "_AddressLine2_",
AddressLine3 = "_AddressLine3_",
City = "_City_",
PostCode = "_PostCode_",
StateProvinceId = selectedStateId,
CountryId = selectedCountryId,
BusinessTelephoneNumber = "0123456789",
FaxNumber = "0987654321",
Email = "_Email_",
Uri = "_Uri_",
TimeZoneId = selectedTimezone,
DefaultCultureCode = selectedCulture,
WorkingCurrencyCode = selectedCurrency,
ContractCurrencyCode = selectedCurrency,
ProviderTypeCode = selectedProviderType,
Provider = new Provider { RoomCount = int.MaxValue },
BusinessStatusCode = "A",
BusinessType = BusinessTypeEnum.Provider,
IsMerchant = true,
Latitude = 0,
Longitude = 0,
ReferenceCode = "_RefCode_",
ShortName = "_ShortName_"
};
// Act
businessDao.Modify(businessToModify);
// Assert
Model.Business.Business businessAfterModify = businessDao.GetByKey(1);
Assert.IsNotNull(businessAfterModify, "Could not retrieve business.");
Assert.AreEqual(businessToModify.Name, businessAfterModify.Name, "Name did not get modified.");
Assert.AreEqual(businessToModify.AddressLine1, businessAfterModify.AddressLine1,
"AddressLine1 did not get modified.");
Assert.AreEqual(businessToModify.AddressLine2, businessAfterModify.AddressLine2,
"AddressLine2 did not get modified.");
Assert.AreEqual(businessToModify.AddressLine3, businessAfterModify.AddressLine3,
"AddressLine3 did not get modified.");
Assert.AreEqual(businessToModify.City, businessAfterModify.City, "City did not get modified.");
Assert.AreEqual(businessToModify.PostCode, businessAfterModify.PostCode,
"PostCode did not get modified.");
Assert.AreEqual(businessToModify.StateProvinceId, businessAfterModify.StateProvinceId,
"StateProvinceId did not get modified.");
Assert.AreEqual(businessToModify.CountryId, businessAfterModify.CountryId,
"CountryId did not get modified.");
Assert.AreEqual(businessAfterModify.BusinessTelephoneNumber,
businessToModify.BusinessTelephoneNumber,
"BusinessTelephoneNumber did not get modified.");
Assert.AreEqual(businessToModify.FaxNumber, businessAfterModify.FaxNumber,
"FaxNumber did not get modified.");
Assert.AreEqual(businessToModify.Email, businessAfterModify.Email, "Email did not get modified.");
Assert.AreEqual(businessToModify.Uri, businessAfterModify.Uri, "Uri did not get modified.");
Assert.AreEqual(businessToModify.TimeZoneId, businessAfterModify.TimeZoneId,
"TimeZoneId did not get modified.");
Assert.AreEqual(businessToModify.DefaultCultureCode, businessAfterModify.DefaultCultureCode,
"DefaultCultureCode did not get modified.");
Assert.AreEqual(businessToModify.WorkingCurrencyCode, businessAfterModify.WorkingCurrencyCode,
"WorkingCurrencyCode did not get modified.");
Assert.AreEqual(businessToModify.ContractCurrencyCode, businessAfterModify.ContractCurrencyCode,
"ContractCurrencyCode did not get modified.");
Assert.AreEqual(businessToModify.ProviderTypeCode, businessAfterModify.ProviderTypeCode,
"ProviderType did not get modified.");
}
}
public void CreateBusinessProviderWithMissingProviderTypeCodeMandatoryFieldExpectException()
{
using (new TestDataHelper(GetTestQuery(TestQuery.PopulateBusinessesTestData), GetTestQuery(TestQuery.CleanupUnitTestData)))
{
var newBusiness = new Model.Business.Business
{
Name = "_Name_",
AddressLine1 = "_AddressLine1_",
AddressLine2 = "_AddressLine2_",
AddressLine3 = "_AddressLine3_",
City = "_City_",
PostCode = "_PostCode_",
StateProvinceId = selectedStateId,
CountryId = selectedCountryId,
BusinessTelephoneNumber = "0123456789",
FaxNumber = "0987654321",
Email = "_Email_",
Uri = "_Uri_",
TimeZoneId = selectedTimezone,
DefaultCultureCode = selectedCulture,
WorkingCurrencyCode = selectedCurrency,
ContractCurrencyCode = selectedCurrency,
ProviderTypeCode = selectedProviderType,
Provider = new Provider { RoomCount = int.MaxValue },
BusinessStatusCode = "A",
BusinessType = BusinessTypeEnum.Provider,
IsMerchant = true,
Latitude = 0,
Longitude = 0,
ReferenceCode = "_RefCode_",
ShortName = "_ShortNamemicky"
};
int newBusinessId = businessDao.Create(newBusiness);
businessDao.CreateProvider(new Provider() {Id = newBusinessId, ProviderTypeCode = "BBR"});
}
}
public void GetMerchantIdForNewProviderModel_WithActiveBusinessAccountInOgone_Expect_MerchantId_SetToActivePaymentMerchantPSPID()
{
const string BUSINESS_SHORT_NAME = "TestBus3";
const string PAYMENT_PSPSID_ONE = "1";
const string PAYMENT_PSPSID_TWO = "2";
var serviceClientMock = MockRepository.GenerateMock<IPaymentServiceServiceClient>();
var target = new SettlementHelper(mockLogger, serviceClientMock);
var business = new Model.Business.Business() { ShortName = BUSINESS_SHORT_NAME, MerchantStatusEnum = MerchantStatusEnum.OwnMerchant };
var merchantAccounts = new List<MerchantAccount>()
{
new MerchantAccount() { ShortName = BUSINESS_SHORT_NAME, MerchantAccountStatusCode = PaymentConstants.PAYMENT_MERCHANT_ACCOUNT_ACTIVE, PSPID = PAYMENT_PSPSID_ONE},
new MerchantAccount() { ShortName = BUSINESS_SHORT_NAME, MerchantAccountStatusCode = PaymentConstants.PAYMENT_MERCHANT_ACCOUNT_INACTIVE, PSPID = PAYMENT_PSPSID_TWO}
};
serviceClientMock.Expect(serviceClient => serviceClient.GetMerchantAccounts("TestBus3")).Return(
Task.FromResult(merchantAccounts));
var merchantId = target.GetMerchantIdForNewProviderModel(business).Result;
Assert.AreEqual(merchantId, PAYMENT_PSPSID_ONE);
}
