public void GetAllChannelsCallsCorrectMethods()
{
// Arrange
const string CULTURE_CODE = "en-GB";
const long BUSINESSID = 1;
var distributorDaoMock = new Mock<IDistributorDao>();
var channelDaoMock = new Mock<IChannelDao>();
DistributionManager distributionManager = new DistributionManager();
distributionManager.DistributorDao = distributorDaoMock.Object;
distributionManager.ChannelDao = channelDaoMock.Object;
var distributor = DistributionBuilder.BuildDistributor();
var channel1 = DistributionBuilder.BuildChannel();
var channel2 = DistributionBuilder.BuildChannel(channelId: 2, name: "Expedia Silver", shortName: "exp-silver", displaySequence: 2);
List<Channel> channelListMock = new List<Channel>
{
channel1,
channel2
};
var distributors = new List<Distributor> { distributor };
distributorDaoMock.Setup(dao => dao.GetAll(CULTURE_CODE)).Returns(distributors);
channelDaoMock.Setup(dao => dao.GetChannelsWithBusinessOptIns(BUSINESSID, CULTURE_CODE)).Returns(channelListMock);
// Act
List<Distributor> result = distributionManager.GetDistributorsAndChannels(BUSINESSID, CULTURE_CODE);
// Assert
Assert.IsTrue(result[0].Channels.Any(), "No channels returned in distributor");
Assert.AreEqual(channelListMock.Count, result[0].Channels.Count, "Incorrect channels returned");
distributorDaoMock.VerifyAll();
channelDaoMock.Verify(dao => dao.GetChannelsWithBusinessOptIns(BUSINESSID, CULTURE_CODE), Times.AtMostOnce);
}
public void GetAllOptedInBusinessAccountsMethod()
{
// Arrange
const string CULTURE_CODE = "en-GB";
const string CHANNEL_SHORT_NAME = "toprooms";
var distributionManager = new DistributionManager(new EmailManager());
var channelDaoMock = MockRepository.GenerateMock<IChannelDao>();
distributionManager.ChannelDao = channelDaoMock;
var optedInBusinessAccounts = new List<OptedInBusinessAccount>
{
new OptedInBusinessAccount
{
ContentId = "1",
ShortName = "business 1"
}
};
channelDaoMock.Stub(i => i.GetAllOptedInBusinessAccounts(CULTURE_CODE, CHANNEL_SHORT_NAME)).Return(optedInBusinessAccounts);
// Act
var result = distributionManager.GetAllOptedInBusinessAccounts(CULTURE_CODE, CHANNEL_SHORT_NAME);
// Assert
Assert.IsNotNull(result, "No results were returned for opted in business accounts");
// Reset the Daos
distributionManager.ChannelDao = new ChannelDao();
}
public void GetOptedInChannelsCallsCorrectMethods()
{
// Arrange
const long BUSINESS_ID = 1;
const string CULTURE_CODE = "en-GB";
var businessChannelOptInDao = new Mock<IBusinessChannelOptInDao>();
var channelTermsDao = new Mock<IChannelCancellationTermsDao>();
var prePaySettingsDao = new Mock<IPrePayDao>();
var distributionManager = new DistributionManager
{
BusinessChannelOptInDao = businessChannelOptInDao.Object,
ChannelCancellationTermsDao = channelTermsDao.Object,
PrePayDao = prePaySettingsDao.Object
};
var channel1 = DistributionBuilder.BuildChannel();
var channel2 = DistributionBuilder.BuildChannel(channelId: 2, name: "Expedia Silver", shortName: "exp-silver", displaySequence: 2);
var channels = new List<BusinessChannelOptIn>
{
new BusinessChannelOptIn
{
AssociatedChannel = channel1
},
new BusinessChannelOptIn
{
AssociatedChannel = channel2
}
};
businessChannelOptInDao.Setup(dao => dao.GetOptInsByBusiness(BUSINESS_ID, CULTURE_CODE)).Returns(channels);
channelTermsDao.Setup(c => c.GetByBusiness(BUSINESS_ID)).Returns(new List<ChannelCancellationTerms>());
prePaySettingsDao.Setup(x => x.GetPermittedChannelSettings(BUSINESS_ID, 0)).Returns(new List<ChannelPrePayPermittedSetting>());
// Act
List<BusinessChannelOptIn> result = distributionManager.GetOptedInChannels(BUSINESS_ID, CULTURE_CODE);
// Assert
Assert.IsTrue(result.Any(), "No channels returned");
businessChannelOptInDao.VerifyAll();
channelTermsDao.VerifyAll();
prePaySettingsDao.Verify(x => x.GetPermittedChannelSettings(BUSINESS_ID, 0), Times.Once);
}
public void UpdateCancellationForOptedInChannelInvalidTermsUpdateThrowsValidationException(TestData testData)
{
// Arrange
const int CHANNEL_ID = 1;
const long BUSINESS_ID = 1;
const int CHANNEL_TERMS_ID = 1;
var channelDao = new Mock<IChannelDao>();
var channelTermsDao = new Mock<IChannelCancellationTermsDao>();
var distributionManager = new DistributionManager
{
ChannelDao = channelDao.Object,
ChannelCancellationTermsDao = channelTermsDao.Object
};
channelDao.Setup(c => c.GetById(It.Is<int>(i => i == CHANNEL_ID))).Returns(new Channel
{
Id = CHANNEL_ID,
SupportsCustomCancPolicy = true
});
var businessChannelOptIn = new BusinessChannelOptIn
{
ChannelId = CHANNEL_ID,
BusinessId = BUSINESS_ID,
ChannelTermsId = CHANNEL_TERMS_ID,
CancellationValues = new CancellationValues
{
CancellationChargeType = new CancellationChargeType
{
Type = testData.chargeTypeToUse
},
CancellationWindowHours = testData.windowHoursToUse,
CancellationChargeValue = testData.chargeValueToUse
}
};
// set up terms here
var channelTerms = new ChannelCancellationTerms
{
ChannelId = CHANNEL_ID,
AcceptedChargeTypes = new List<CancellationChargeTypeEnum> { testData.acceptableChargeType },
MinChargeValue = testData.minChargeValue,
MaxChargeValue = testData.maxChargeValue,
ChargeValueMultiple = testData.chargeMultiple,
MinChargePercentage = testData.minPercentValue,
MaxChargePercentage = testData.maxPercentValue,
ChargePercentageMultiple = testData.percentMultiple,
WindowMinValue = testData.windowMinValue,
WindowMaxValue = testData.windowMaxValue
};
channelTermsDao.Setup(ct => ct.GetByBusiness(It.IsAny<long>())).Returns(new List<ChannelCancellationTerms> {channelTerms});
// Act
try
{
distributionManager.UpdateCancellationForOptedInChannel(businessChannelOptIn);
Assert.Fail("Validation exception SRVEX30132 was not thrown");
}
catch (ValidationException ex)
{
Assert.AreEqual("SRVEX30132", ex.Code, "SRVEX30132 was not thrown");
channelDao.VerifyAll();
channelTermsDao.VerifyAll();
}
}
public void UpdateCancellationForOptedInChannelDoesntSupportUpdateThrowsValidationException()
{
// Arrange
const int CHANNEL_ID = 1;
const long BUSINESS_ID = 1;
const int CHANNEL_TERMS_ID = 1;
var channelDao = new Mock<IChannelDao>();
var distributionManager = new DistributionManager
{
ChannelDao = channelDao.Object
};
channelDao.Setup(c => c.GetById(It.Is<int>(i => i == CHANNEL_ID))).Returns(new Channel
{
Id = CHANNEL_ID,
SupportsCustomCancPolicy = false
});
var businessChannelOptIn = new BusinessChannelOptIn
{
ChannelId = CHANNEL_ID,
BusinessId = BUSINESS_ID,
ChannelTermsId = CHANNEL_TERMS_ID,
CancellationValues = new CancellationValues()
};
// Act
try
{
distributionManager.UpdateCancellationForOptedInChannel(businessChannelOptIn);
}
catch (ValidationException ex)
{
Assert.AreEqual("SRVEX30131", ex.Code, "SRVEX30131 was not thrown");
channelDao.VerifyAll();
}
}
public void UpdateCancellationForOptedInInvalidChannelThrowsValidationException()
{
// Arrange
const int CHANNEL_ID = 1;
const long BUSINESS_ID = 1;
var distributionManager = new DistributionManager();
var businessChannelOptIn = new BusinessChannelOptIn
{
ChannelId = CHANNEL_ID,
BusinessId = BUSINESS_ID,
CancellationValues = new CancellationValues()
};
// Act
try
{
distributionManager.UpdateCancellationForOptedInChannel(businessChannelOptIn);
}
catch (ValidationException ex)
{
Assert.AreEqual("SRVEX30080", ex.Code, "SRVEX30080 was not thrown");
}
}
public void UpdateCancellationForOptedInGroupChannelCallsCorrectMethods()
{
// Arrange
const int CHANNEL_ID = 1;
const int SUB_CHANNEL_ID = 2;
const long BUSINESS_ID = 1;
const int CHANNEL_TERMS_ID = 1;
var channelDao = new Mock<IChannelDao>();
var businessChannelOptInDao = new Mock<IBusinessChannelOptInDao>();
var eventTrackingManager = new Mock<IEventTrackingManager>();
var channelCancelTermsDao = new Mock<IChannelCancellationTermsDao>();
var distributionManager = new DistributionManager
{
BusinessChannelOptInDao = businessChannelOptInDao.Object,
ChannelDao = channelDao.Object,
EventTrackingManager = eventTrackingManager.Object,
ChannelCancellationTermsDao = channelCancelTermsDao.Object
};
channelDao.Setup(c => c.GetById(It.Is<int>(i => i == CHANNEL_ID))).Returns(new Channel
{
Id = CHANNEL_ID,
SupportsCustomCancPolicy = true,
ChannelType = ChannelTypeEnum.LogicalGroup
});
channelDao.Setup(c => c.GetById(It.Is<int>(i => i == SUB_CHANNEL_ID))).Returns(new Channel
{
Id = SUB_CHANNEL_ID,
SupportsCustomCancPolicy = true,
ChannelType = ChannelTypeEnum.Channel
});
businessChannelOptInDao.Setup(b => b.UpdateCancellation(It.IsAny<BusinessChannelOptIn>())).Returns(true);
channelCancelTermsDao.Setup(cc => cc.GetByBusiness(BUSINESS_ID)).Returns(new List<ChannelCancellationTerms>
{
new ChannelCancellationTerms
{
ChannelId = CHANNEL_ID
},
new ChannelCancellationTerms
{
ChannelId = SUB_CHANNEL_ID
}
});
eventTrackingManager.Setup(
e =>
e.CreateBusinessEventAsync(It.Is<long>(i => i == BUSINESS_ID),
It.Is<BusinessEventTypesEnum>(i => i == BusinessEventTypesEnum.OptinChannelModified),
It.Is<string>(i => i == CHANNEL_ID.ToString(CultureInfo.InvariantCulture)),
It.IsAny<string>()));
eventTrackingManager.Setup(
e =>
e.CreateBusinessEventAsync(It.Is<long>(i => i == BUSINESS_ID),
It.Is<BusinessEventTypesEnum>(i => i == BusinessEventTypesEnum.OptinChannelModified),
It.Is<string>(i => i == SUB_CHANNEL_ID.ToString(CultureInfo.InvariantCulture)),
It.IsAny<string>()));
List<int> sub_channels = new List<int>
{
SUB_CHANNEL_ID
};
businessChannelOptInDao.Setup(b => b.GetOptedInChannelsRelatedToGroup(BUSINESS_ID, CHANNEL_ID))
.Returns(sub_channels);
var businessChannelOptIn = new BusinessChannelOptIn
{
ChannelId = CHANNEL_ID,
BusinessId = BUSINESS_ID,
ChannelTermsId = CHANNEL_TERMS_ID,
CancellationValues = new CancellationValues()
};
// Act
var result = distributionManager.UpdateCancellationForOptedInChannel(businessChannelOptIn);
// Assert
Assert.IsTrue(result, "Update for channel cancellation was not successful");
channelDao.VerifyAll();
businessChannelOptInDao.Verify(bco => bco.UpdateCancellation(It.IsAny<BusinessChannelOptIn>()),
Times.Exactly(2));
eventTrackingManager.Verify(
et =>
et.CreateBusinessEventAsync(It.IsAny<long>(), BusinessEventTypesEnum.OptinChannelModified,
It.IsAny<string>(), It.IsAny<string>()), Times.Exactly(2));
// only need group terms
channelCancelTermsDao.Verify(cc => cc.GetByBusiness(It.IsAny<long>()), Times.Once);
}
public void UpdatePrePayForOptedInChannelInvalidPrePaySettingsThrowsException()
{
// Arrange
const int CHANNEL_ID = 1;
const long BUSINESS_ID = 1;
const int CHANNEL_TERMS_ID = 1;
var channelDao = new Mock<IChannelDao>();
var businessChannelOptInDao = new Mock<IBusinessChannelOptInDao>();
var prePayDao = new Mock<IPrePayDao>();
var distributionManager = new DistributionManager
{
BusinessChannelOptInDao = businessChannelOptInDao.Object,
ChannelDao = channelDao.Object,
PrePayDao = prePayDao.Object
};
channelDao.Setup(c => c.GetById(It.Is<int>(i => i == CHANNEL_ID))).Returns(new Channel
{
Id = CHANNEL_ID
});
businessChannelOptInDao.Setup(b => b.UpdatePrePaySettings(It.IsAny<BusinessChannelOptIn>())).Returns(false);
prePayDao.Setup(cc => cc.GetPermittedChannelSettings(BUSINESS_ID, CHANNEL_ID))
.Returns(new List<ChannelPrePayPermittedSetting>
{
new ChannelPrePayPermittedSetting
{
ChannelId = CHANNEL_ID,
Min = 10,
Max = 100,
Type = PrePayRuleTypeEnum.Amount
}
});
var businessChannelOptIn = new BusinessChannelOptIn
{
ChannelId = CHANNEL_ID,
BusinessId = BUSINESS_ID,
ChannelTermsId = CHANNEL_TERMS_ID,
PrePaySettings = new BusinessChannelPrePaySettings
{
Type = PrePayRuleTypeEnum.Amount,
Value = 150,
IsOverridden = true
}
};
// Act
try
{
distributionManager.UpdatePrePayForOptedInChannel(businessChannelOptIn);
}
catch (ValidationException ex)
{
Assert.AreEqual("SRVEX30135", ex.Code, "SRVEX30135 was not thrown");
}
}
public void UpdatePrePayForOptedInGroupChannelCallsCorrectMethods()
{
// Arrange
const int CHANNEL_ID = 1;
const int SUB_CHANNEL_ID = 2;
const long BUSINESS_ID = 1;
const int CHANNEL_TERMS_ID = 1;
var channelDao = new Mock<IChannelDao>();
var businessChannelOptInDao = new Mock<IBusinessChannelOptInDao>();
var eventTrackingManager = new Mock<IEventTrackingManager>();
var prePayDao = new Mock<IPrePayDao>();
var distributionManager = new DistributionManager
{
BusinessChannelOptInDao = businessChannelOptInDao.Object,
ChannelDao = channelDao.Object,
EventTrackingManager = eventTrackingManager.Object,
PrePayDao = prePayDao.Object
};
channelDao.Setup(c => c.GetById(It.Is<int>(i => i == CHANNEL_ID))).Returns(new Channel
{
Id = CHANNEL_ID,
SupportsCustomCancPolicy = true,
ChannelType = ChannelTypeEnum.LogicalGroup
});
channelDao.Setup(c => c.GetById(It.Is<int>(i => i == SUB_CHANNEL_ID))).Returns(new Channel
{
Id = SUB_CHANNEL_ID,
SupportsCustomCancPolicy = true,
ChannelType = ChannelTypeEnum.Channel
});
businessChannelOptInDao.Setup(b => b.UpdatePrePaySettings(It.IsAny<BusinessChannelOptIn>())).Returns(true);
prePayDao.Setup(cc => cc.GetPermittedChannelSettings(BUSINESS_ID, CHANNEL_ID))
.Returns(new List<ChannelPrePayPermittedSetting>
{
new ChannelPrePayPermittedSetting
{
ChannelId = CHANNEL_ID,
Type = PrePayRuleTypeEnum.Amount,
Min = 1,
Max = 100
}
});
eventTrackingManager.Setup(
e =>
e.CreateBusinessEventAsync(It.Is<long>(i => i == BUSINESS_ID),
It.Is<BusinessEventTypesEnum>(i => i == BusinessEventTypesEnum.OptinChannelModified),
It.Is<string>(i => i == CHANNEL_ID.ToString(CultureInfo.InvariantCulture)),
It.IsAny<string>()));
eventTrackingManager.Setup(
e =>
e.CreateBusinessEventAsync(It.Is<long>(i => i == BUSINESS_ID),
It.Is<BusinessEventTypesEnum>(i => i == BusinessEventTypesEnum.OptinChannelModified),
It.Is<string>(i => i == SUB_CHANNEL_ID.ToString(CultureInfo.InvariantCulture)),
It.IsAny<string>()));
var businessChannelOptIn = new BusinessChannelOptIn
{
ChannelId = CHANNEL_ID,
BusinessId = BUSINESS_ID,
ChannelTermsId = CHANNEL_TERMS_ID,
PrePaySettings = new BusinessChannelPrePaySettings
{
Type = PrePayRuleTypeEnum.Amount,
Value = 10
}
};
var subChannels = new List<int>
{
SUB_CHANNEL_ID
};
businessChannelOptInDao.Setup(b => b.GetOptedInChannelsRelatedToGroup(BUSINESS_ID, CHANNEL_ID))
.Returns(subChannels);
// Act
var result = distributionManager.UpdatePrePayForOptedInChannel(businessChannelOptIn);
// Assert
Assert.IsTrue(result, "Update for channel prepay settings was not successful");
channelDao.VerifyAll();
businessChannelOptInDao.Verify(bco => bco.UpdatePrePaySettings(It.IsAny<BusinessChannelOptIn>()), Times.Exactly(2));
eventTrackingManager.Verify(
et =>
et.CreateBusinessEventAsync(It.IsAny<long>(), BusinessEventTypesEnum.OptinChannelModified,
It.IsAny<string>(), It.IsAny<string>()), Times.Exactly(2));
prePayDao.Verify(cc => cc.GetPermittedChannelSettings(It.IsAny<long>(), It.IsAny<int>()), Times.Once);
}
public void TestSetup()
{
//Arrange
distributionManager = new DistributionManager();
channelCancellationTermsDao = new Mock<IChannelCancellationTermsDao>();
distributionManager.ChannelCancellationTermsDao = channelCancellationTermsDao.Object;
}
