public void Arrange()
{
var expectedPermission = new ProviderPermission
{
AccountId = 1,
AccountLegalEntityId = 2,
ProviderId = 3,
CanCreateCohort = true
};
_dbContextTransaction = new Mock <IDbContextTransaction>();
_dbContext = new Mock <DbContext>();
_dataContext = new Mock <IReservationsDataContext>();
_dataFacade = new Mock <DatabaseFacade>(_dbContext.Object);
_dataFacade.Setup(x => x.BeginTransaction()).Returns(_dbContextTransaction.Object);
_dataContext.Setup(x => x.ProviderPermissions).ReturnsDbSet(new List <ProviderPermission>
{
expectedPermission
});
_dataContext.Setup(x => x.ProviderPermissions.AddAsync(It.IsAny <ProviderPermission>(), It.IsAny <CancellationToken>()))
.ReturnsAsync((EntityEntry <ProviderPermission>)null);
_dataContext.Setup(x => x.ProviderPermissions.FindAsync(expectedPermission.AccountId, expectedPermission.AccountLegalEntityId, expectedPermission.ProviderId))
.ReturnsAsync(expectedPermission);
_dataContext.Setup(x => x.Database)
.Returns(_dataFacade.Object);
_providerPermissionRepository = new Data.Repository.ProviderPermissionRepository(_dataContext.Object);
}
/// <summary>
/// Event Fired When Application Recieves Logon from MarketDataEngine
/// </summary>
/// <param name="obj"></param>
private void MarketDataEngineClientLogonArrived(string obj)
{
try
{
if (Logger.IsDebugEnabled)
{
Logger.Debug(obj, _oType.FullName, "MarketDataEngineClientLogonArrived");
}
ProviderPermission currentPermission;
// Try to get existing Permission settings
if (!_responseHandler.ProviderPermissionDictionary.TryGetValue(obj, out currentPermission))
{
// Create a new Permissions object
currentPermission = new ProviderPermission {
MarketDataProvider = obj, WriteCsv = true
};
}
_responseHandler.OnProviderConnected(currentPermission);
EventSystem.Publish(new LoginArrivedMessage {
Provider = new Provider {
IsConnected = true, ProviderName = obj
}
});
}
catch (Exception exception)
{
Logger.Error(exception, _oType.FullName, "MarketDataEngineClientLogonArrived");
}
}
/// <summary>
/// When User Request To Change Provider Permission
/// </summary>
/// <param name="providerPermission"></param>
private void ChangeInProiderPermission(ProviderPermission providerPermission)
{
try
{
_responseHandler.ChangeProviderPermissions(providerPermission);
}
catch (Exception exception)
{
Logger.Error(exception, _oType.FullName, "ChangeInProiderPermission");
}
}
/// <summary>
/// When Provider Is disconnected
/// Removing its Permission from Dictionary
/// </summary>
/// <param name="permissions">Contains Permission Of Certain Provider</param>
public void OnProviderDisconnect(ProviderPermission permissions)
{
if (Logger.IsDebugEnabled)
{
Logger.Info(permissions.ToString(), _oType.FullName, "OnProviderDisconnect");
}
try
{
ProviderPermissionDictionary.Remove(permissions.MarketDataProvider);
}
catch (Exception exception)
{
Logger.Error(exception, _oType.FullName, "OnProviderDisconnect");
}
}
public async Task Add(ProviderPermission permission)
{
var existingPermission = await _dataContext.ProviderPermissions.FindAsync(permission.AccountId,
permission.AccountLegalEntityId, permission.ProviderId);
if (existingPermission == null)
{
await _dataContext.ProviderPermissions.AddAsync(permission);
}
else
{
existingPermission.CanCreateCohort = permission.CanCreateCohort;
}
_dataContext.SaveChanges();
}
public async Task Then_If_The_Permission_Exists_It_Is_Updated()
{
//Arrange
var expectedPermission = new ProviderPermission
{
AccountId = 1,
AccountLegalEntityId = 2,
ProviderId = 3,
CanCreateCohort = true
};
//Act
await _providerPermissionRepository.Add(expectedPermission);
//Assert
_dataContext.Verify(x => x.ProviderPermissions.AddAsync(It.IsAny <ProviderPermission>(), It.IsAny <CancellationToken>()), Times.Never);
_dataContext.Verify(x => x.SaveChanges(), Times.Once);
}
/// <summary>
/// When New Provider Is Connected
/// Saving its Permissions in a dictionary
/// </summary>
/// <param name="permissions">Contains Permission Of Certain Provider</param>
public void OnProviderConnected(ProviderPermission permissions)
{
if (Logger.IsDebugEnabled)
{
Logger.Info(permissions.ToString(), _oType.FullName, "OnProviderConnected");
}
try
{
// Add permission if they don't exist in the local map
if (!ProviderPermissionDictionary.ContainsKey(permissions.MarketDataProvider))
{
ProviderPermissionDictionary.Add(permissions.MarketDataProvider, permissions);
}
}
catch (Exception exception)
{
Logger.Error(exception, _oType.FullName, "OnProviderConnected");
}
}
public async Task Add(ProviderPermission permission)
{
using (var transaction = _dataContext.Database.BeginTransaction())
{
var existingPermission = await _dataContext.ProviderPermissions.FindAsync(permission.AccountId,
permission.AccountLegalEntityId, permission.ProviderId);
if (existingPermission == null)
{
await _dataContext.ProviderPermissions.AddAsync(permission);
}
else
{
existingPermission.CanCreateCohort = permission.CanCreateCohort;
}
_dataContext.SaveChanges();
transaction.Commit();
}
}
public void Then_The_Entity_Is_Mapped_To_The_Domain_Object(
long accountId,
long accountLegalEntityId,
uint ukPrn,
string accountLegalEntityName,
string accountName,
AgreementType agreementType
)
{
//Arrange
var entity = new ProviderPermission
{
AccountId = accountId,
UkPrn = ukPrn,
AccountLegalEntityId = accountLegalEntityId,
AccountLegalEntity = new AccountLegalEntity
{
AgreementSigned = true,
AccountLegalEntityName = accountLegalEntityName,
AccountId = accountId,
AccountLegalEntityId = accountLegalEntityId
},
Account = new Entities.Account
{
Id = accountId,
Name = accountName
}
};
//Act
var actual = new Domain.ProviderPermissions.ProviderPermission(entity);
//Assert
actual.AccountId.Should().Be(accountId);
actual.UkPrn.Should().Be(ukPrn);
actual.AccountLegalEntityId.Should().Be(accountLegalEntityId);
actual.AgreementSigned.Should().BeTrue();
actual.AccountLegalEntityName.Should().Be(accountLegalEntityName);
actual.AccountName.Should().Be(accountName);
}
/// <summary>
/// Overwrites Previous Writer Permission
/// </summary>
/// <param name="providerPermission"></param>
public void ChangeProviderPermissions(ProviderPermission providerPermission)
{
try
{
ProviderPermission currentPermission;
// Update exsiting permissions if they exist
if (ProviderPermissionDictionary.TryGetValue(providerPermission.MarketDataProvider, out currentPermission))
{
ProviderPermissionDictionary[providerPermission.MarketDataProvider] = providerPermission;
}
else
{
// Add permissions to the local map
ProviderPermissionDictionary.Add(providerPermission.MarketDataProvider, providerPermission);
}
}
catch (Exception exception)
{
Logger.Error(exception, _oType.FullName, "ChangeProviderPermissions");
}
}
public async Task Then_The_Permission_Is_Added_To_The_Repository()
{
//Arrange
var expectedPermission = new ProviderPermission
{
AccountId = 2,
AccountLegalEntityId = 3,
ProviderId = 4,
CanCreateCohort = true
};
//Act
await _providerPermissionRepository.Add(expectedPermission);
//Assert
_dataContext.Verify(x => x.ProviderPermissions.AddAsync(It.Is <ProviderPermission>(
c => c.AccountId.Equals(expectedPermission.AccountId) &&
c.AccountLegalEntityId.Equals(expectedPermission.AccountLegalEntityId) &&
c.ProviderId.Equals(expectedPermission.ProviderId) &&
c.CanCreateCohort.Equals(expectedPermission.CanCreateCohort)
), It.IsAny <CancellationToken>()), Times.Once);
_dataContext.Verify(x => x.SaveChanges(), Times.Once);
}
