408 lines
18 KiB
C#
408 lines
18 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Threading.Tasks;
|
|
using LCU.API.Internal.MemberPreferencesApi.Configuration;
|
|
using LCU.Library.Internal.MemberPreferencesApiModels.Entities;
|
|
using LCU.Library.Internal.MemberPreferencesApiModels.Enums;
|
|
using LCU.Library.Internal.LcuMassTransitModels;
|
|
using LCU.API.Internal.MemberPreferencesApiLib.Repositories;
|
|
using LCU.API.Internal.MemberPreferencesApi.Services.XdiServices;
|
|
using LCU.API.Internal.MemberPreferencesApi.MicroApiServices;
|
|
using Moq;
|
|
using Newtonsoft.Json;
|
|
using NUnit.Framework;
|
|
using LCU.API.Internal.MemberPreferencesApi.Models;
|
|
|
|
namespace LCU.API.Internal.MemberPreferencesApi.UnitTests.Services
|
|
{
|
|
public class XdiBatchItemServiceTest
|
|
{
|
|
private IXdiBatchService _xdiBatchItemService;
|
|
private Mock<IXdiBatchItemsRepository> _mockBatchItemsRepository;
|
|
private Mock<IUnitOfWork> _mockUnitOfWork;
|
|
private XdiSftpApiConfiguration _ftpConfiguration;
|
|
private Mock<IUnifiedOptInRepository> _mockUnifiedOptinRepository;
|
|
private Mock<IMemberPreferenceRepository> _mockMemberPreferenceRepository;
|
|
private Mock<IFtpApiService> _mockFtpApiService;
|
|
private ConnectionConfiguration _connectionConfiguration;
|
|
private ReceiveEndpointConfiguration _completionReceiveEndpoint;
|
|
private ReceiveEndpointConfigurations _endpointConfiguration;
|
|
|
|
[SetUp]
|
|
public void Setup()
|
|
{
|
|
_mockBatchItemsRepository = new Mock<IXdiBatchItemsRepository>();
|
|
_mockUnitOfWork = new Mock<IUnitOfWork>();
|
|
_ftpConfiguration = new XdiSftpApiConfiguration();
|
|
_mockUnifiedOptinRepository = new Mock<IUnifiedOptInRepository>();
|
|
_mockMemberPreferenceRepository = new Mock<IMemberPreferenceRepository>();
|
|
_mockFtpApiService = new Mock<IFtpApiService>();
|
|
_endpointConfiguration = new ReceiveEndpointConfigurations();
|
|
_completionReceiveEndpoint = _endpointConfiguration.XdiBatchConfirmEndpoint;
|
|
|
|
_xdiBatchItemService = new XdiBatchService(_mockBatchItemsRepository.Object, _mockUnitOfWork.Object,
|
|
_ftpConfiguration, _mockUnifiedOptinRepository.Object, _mockMemberPreferenceRepository.Object,
|
|
_connectionConfiguration, _endpointConfiguration, _mockFtpApiService.Object);
|
|
}
|
|
|
|
[Test]
|
|
public async Task Test_Item_Exists()
|
|
{
|
|
var existing = new XdiBatchItem()
|
|
{
|
|
Created = DateTime.Now,
|
|
BatchState = BatchState.New,
|
|
LastUpdated = DateTime.Now,
|
|
UserId = "99"
|
|
};
|
|
_mockBatchItemsRepository.Setup(x => x.FindExistingItem(existing.UserId, existing.BatchState))
|
|
.ReturnsAsync(existing);
|
|
_mockBatchItemsRepository.Setup(x => x.Update(existing)).Verifiable();
|
|
_mockBatchItemsRepository.Setup(x => x.SaveAsync(existing)).Verifiable();
|
|
_mockUnitOfWork.Setup(x => x.CompleteAsync()).Verifiable();
|
|
|
|
XdiBatchItem testItem = new XdiBatchItem()
|
|
{
|
|
Created = DateTime.Now,
|
|
BatchState = BatchState.New,
|
|
LastUpdated = DateTime.Now,
|
|
UserId = "99"
|
|
};
|
|
await _xdiBatchItemService.AddXdiBatchItem(testItem);
|
|
|
|
_mockBatchItemsRepository.Verify(x => x.FindExistingItem(existing.UserId, existing.BatchState),
|
|
Times.Once);
|
|
_mockBatchItemsRepository.Verify(x => x.Update(existing), Times.Once);
|
|
_mockBatchItemsRepository.Verify(x => x.SaveAsync(existing), Times.Never);
|
|
_mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public async Task Test_Item_New()
|
|
{
|
|
_mockBatchItemsRepository.Setup(x => x.FindExistingItem(It.IsAny<string>(), It.IsAny<BatchState>()))
|
|
.ReturnsAsync((XdiBatchItem)null);
|
|
_mockBatchItemsRepository.Setup(x => x.Update(It.IsAny<XdiBatchItem>())).Verifiable();
|
|
_mockBatchItemsRepository.Setup(x => x.SaveAsync(It.IsAny<XdiBatchItem>())).Verifiable();
|
|
_mockUnitOfWork.Setup(x => x.CompleteAsync()).Verifiable();
|
|
|
|
XdiBatchItem testItem = new XdiBatchItem()
|
|
{
|
|
Created = DateTime.Now,
|
|
BatchState = BatchState.New,
|
|
LastUpdated = DateTime.Now,
|
|
UserId = "99"
|
|
};
|
|
await _xdiBatchItemService.AddXdiBatchItem(testItem);
|
|
|
|
_mockBatchItemsRepository.Verify(x => x.FindExistingItem(It.IsAny<string>(), It.IsAny<BatchState>()),
|
|
Times.Once);
|
|
_mockBatchItemsRepository.Verify(x => x.Update(It.IsAny<XdiBatchItem>()), Times.Never);
|
|
_mockBatchItemsRepository.Verify(x => x.SaveAsync(It.IsAny<XdiBatchItem>()), Times.Once);
|
|
_mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public async Task Test_Create_Batch_Files()
|
|
{
|
|
IReadOnlyCollection<XdiBatchItem> items = new List<XdiBatchItem>()
|
|
{
|
|
new XdiBatchItem()
|
|
{
|
|
Created = DateTime.Now,
|
|
BatchState = BatchState.New,
|
|
LastUpdated = DateTime.Now,
|
|
UserId = "99"
|
|
},
|
|
new XdiBatchItem()
|
|
{
|
|
Created = DateTime.Now,
|
|
BatchState = BatchState.New,
|
|
LastUpdated = DateTime.Now,
|
|
UserId = "100"
|
|
},
|
|
new XdiBatchItem()
|
|
{
|
|
Created = DateTime.Now,
|
|
BatchState = BatchState.New,
|
|
LastUpdated = DateTime.Now,
|
|
UserId = "101"
|
|
},
|
|
new XdiBatchItem()
|
|
{
|
|
Created = DateTime.Now,
|
|
BatchState = BatchState.New,
|
|
LastUpdated = DateTime.Now,
|
|
UserId = "102"
|
|
},
|
|
//This is pending and we will process it again
|
|
new XdiBatchItem()
|
|
{
|
|
Created = DateTime.Now,
|
|
BatchState = BatchState.TransferPending,
|
|
LastUpdated = DateTime.Now,
|
|
UserId = "103"
|
|
}
|
|
};
|
|
|
|
// Should be one of each type of change, resulting in a single line batch file for all types.
|
|
var settings = new List<MemberOptInSettings>()
|
|
{
|
|
new MemberOptInSettings()
|
|
{
|
|
Id = 1000,
|
|
UniversalOptIn = DeliveryPreference.Paper,
|
|
ENotifications = DeliveryPreference.Electronic,
|
|
EStatements = DeliveryPreference.Electronic,
|
|
UnifiedOptInEmail = "[email protected]",
|
|
ENotificationsEmail = "[email protected]",
|
|
EStatementsEmail = "[email protected]",
|
|
LastUpdated = DateTime.Now,
|
|
LegalDate = DateTime.Now,
|
|
LegalVersion = "1.2.3",
|
|
UserId = "99",
|
|
CreatedByType = UserType.Associate,
|
|
LastUpdatedByType = UserType.System,
|
|
CreatedBy = "test",
|
|
Created = DateTime.Now,
|
|
LastUpdatedBy = "test"
|
|
},
|
|
new MemberOptInSettings()
|
|
{
|
|
Id = 1001,
|
|
UniversalOptIn = DeliveryPreference.Paper,
|
|
ENotifications = null,
|
|
EStatements = DeliveryPreference.Electronic,
|
|
UnifiedOptInEmail = "[email protected]",
|
|
ENotificationsEmail = null,
|
|
EStatementsEmail = "[email protected]",
|
|
UserId = "100"
|
|
},
|
|
new MemberOptInSettings()
|
|
{
|
|
Id = 1002,
|
|
UniversalOptIn = DeliveryPreference.Electronic,
|
|
ENotifications = DeliveryPreference.Paper,
|
|
EStatements = DeliveryPreference.Paper,
|
|
UnifiedOptInEmail = "[email protected]",
|
|
ENotificationsEmail = "[email protected]",
|
|
EStatementsEmail = "[email protected]",
|
|
UserId = "101"
|
|
},
|
|
new MemberOptInSettings()
|
|
{
|
|
Id = 1003,
|
|
UniversalOptIn = DeliveryPreference.Electronic,
|
|
ENotifications = null,
|
|
EStatements = DeliveryPreference.Paper,
|
|
UnifiedOptInEmail = "[email protected]",
|
|
ENotificationsEmail = null,
|
|
EStatementsEmail = null,
|
|
UserId = "102"
|
|
},
|
|
new MemberOptInSettings()
|
|
{
|
|
Id = 1004,
|
|
UniversalOptIn = DeliveryPreference.Electronic,
|
|
ENotifications = DeliveryPreference.Electronic,
|
|
EStatements = DeliveryPreference.Electronic,
|
|
UnifiedOptInEmail = "[email protected]",
|
|
ENotificationsEmail = "[email protected]",
|
|
EStatementsEmail = "[email protected]",
|
|
UserId = "103"
|
|
}
|
|
};
|
|
_mockBatchItemsRepository.Setup(x => x.GetXdiBatchItems()).ReturnsAsync(items);
|
|
foreach (var setting in settings)
|
|
{
|
|
_mockUnifiedOptinRepository.Setup(x => x.GetMemberOptInSettings(setting.UserId))
|
|
.ReturnsAsync(setting);
|
|
}
|
|
|
|
_mockBatchItemsRepository.Setup(x => x.Update(It.IsAny<XdiBatchItem>())).Verifiable();
|
|
_mockBatchItemsRepository.Setup(x => x.Delete(It.IsAny<XdiBatchItem>())).Verifiable();
|
|
_mockUnitOfWork.Setup(x => x.CompleteAsync(It.IsAny<string>(), It.IsAny<DateTime>(), It.IsAny<UserType>()))
|
|
.Verifiable();
|
|
}
|
|
|
|
[Test]
|
|
public async Task CreateFtpQueryPayload_Ok()
|
|
{
|
|
var testFile = new XdiBatchFile
|
|
{
|
|
Data = new List<XdiBatchFileRow>
|
|
{
|
|
new XdiBatchFileRow {UserId = "100", Email = "[email protected]",},
|
|
new XdiBatchFileRow {UserId = "101", Email = "[email protected]",},
|
|
new XdiBatchFileRow {UserId = "102", Email = "[email protected]",},
|
|
new XdiBatchFileRow {UserId = "103", Email = "[email protected]",}
|
|
}
|
|
};
|
|
|
|
IReadOnlyCollection<XdiBatchItem> items = new List<XdiBatchItem>()
|
|
{
|
|
new XdiBatchItem()
|
|
{
|
|
Created = DateTime.Now,
|
|
BatchState = BatchState.New,
|
|
LastUpdated = DateTime.Now,
|
|
UserId = "99"
|
|
},
|
|
new XdiBatchItem()
|
|
{
|
|
Created = DateTime.Now,
|
|
BatchState = BatchState.New,
|
|
LastUpdated = DateTime.Now,
|
|
UserId = "100"
|
|
},
|
|
new XdiBatchItem()
|
|
{
|
|
Created = DateTime.Now,
|
|
BatchState = BatchState.New,
|
|
LastUpdated = DateTime.Now,
|
|
UserId = "101"
|
|
},
|
|
new XdiBatchItem()
|
|
{
|
|
Created = DateTime.Now,
|
|
BatchState = BatchState.New,
|
|
LastUpdated = DateTime.Now,
|
|
UserId = "102"
|
|
},
|
|
//This is pending and we will process it again
|
|
new XdiBatchItem()
|
|
{
|
|
Created = DateTime.Now,
|
|
BatchState = BatchState.TransferPending,
|
|
LastUpdated = DateTime.Now,
|
|
UserId = "103"
|
|
}
|
|
};
|
|
|
|
_mockUnifiedOptinRepository
|
|
.Setup(x => x.GetMemberOptInSettingsNoTracking("100")).ReturnsAsync(new MemberOptInSettings
|
|
{
|
|
UserId = "100",
|
|
UniversalOptIn = DeliveryPreference.Electronic,
|
|
UnifiedOptInEmail = "[email protected]"
|
|
});
|
|
|
|
_mockUnifiedOptinRepository
|
|
.Setup(x => x.GetMemberOptInSettingsNoTracking("101")).ReturnsAsync(new MemberOptInSettings
|
|
{
|
|
UserId = "101",
|
|
UniversalOptIn = DeliveryPreference.Paper
|
|
});
|
|
|
|
_mockUnifiedOptinRepository
|
|
.Setup(x => x.GetMemberOptInSettingsNoTracking("102")).ReturnsAsync(new MemberOptInSettings
|
|
{
|
|
UserId = "102",
|
|
UniversalOptIn = DeliveryPreference.Microfiche
|
|
});
|
|
|
|
_mockUnifiedOptinRepository
|
|
.Setup(x => x.GetMemberOptInSettingsNoTracking("103")).ReturnsAsync(new MemberOptInSettings
|
|
{
|
|
UserId = "103",
|
|
UniversalOptIn = DeliveryPreference.Hold
|
|
});
|
|
|
|
var results = await _xdiBatchItemService.CreateFtpPayload(testFile);
|
|
|
|
Assert.AreEqual(4, results.Count);
|
|
Assert.True(results.Exists(x => x.UserId == "100" && x.Value == "[email protected]"));
|
|
Assert.True(results.Exists(x => x.UserId == "101" && x.Value == DeliveryPreference.Paper));
|
|
Assert.True(results.Exists(x => x.UserId == "102" && x.Value == DeliveryPreference.Paper));
|
|
Assert.True(results.Exists(x => x.UserId == "103" && x.Value == DeliveryPreference.Paper));
|
|
}
|
|
|
|
[Test]
|
|
public async Task CreateFtpQueryPayload_No_Result_Ok()
|
|
{
|
|
var testFile = new XdiBatchFile
|
|
{
|
|
Data = new List<XdiBatchFileRow>
|
|
{
|
|
new XdiBatchFileRow {UserId = "100", Email = "[email protected]",},
|
|
new XdiBatchFileRow {UserId = "101", Email = "[email protected]",},
|
|
new XdiBatchFileRow {UserId = "102", Email = "[email protected]",},
|
|
new XdiBatchFileRow {UserId = "103", Email = "[email protected]",}
|
|
}
|
|
};
|
|
|
|
_mockUnifiedOptinRepository
|
|
.Setup(x => x.GetMemberOptInSettingsNoTracking("100")).ReturnsAsync(new MemberOptInSettings
|
|
{
|
|
UserId = "100",
|
|
UniversalOptIn = DeliveryPreference.Paper
|
|
}).Verifiable();
|
|
|
|
_mockUnifiedOptinRepository
|
|
.Setup(x => x.GetMemberOptInSettingsNoTracking(It.Is<string>(userId => int.Parse(userId) > 100)))
|
|
.Returns(Task.FromResult<MemberOptInSettings>(null));
|
|
|
|
var results = await _xdiBatchItemService.CreateFtpPayload(testFile);
|
|
|
|
Assert.AreEqual(1, results.Count);
|
|
Assert.True(results.Exists(x => x.UserId == "100" && x.Value == DeliveryPreference.Paper));
|
|
}
|
|
|
|
[Test]
|
|
public async Task MarkPendingSuccessful_OK()
|
|
{
|
|
var payload = new List<FtpQueuePayloadItem>()
|
|
{
|
|
new FtpQueuePayloadItem()
|
|
{
|
|
UserId = "100",
|
|
Value = DeliveryPreference.Paper
|
|
},
|
|
new FtpQueuePayloadItem()
|
|
{
|
|
UserId = "101",
|
|
Value = "[email protected]"
|
|
}
|
|
};
|
|
var payloadString = JsonConvert.SerializeObject(payload);
|
|
|
|
var response = new LCU.Library.Internal.ApiResponse.Models.Response()
|
|
{
|
|
ResponsePayload = payloadString,
|
|
Successful = true
|
|
};
|
|
|
|
_mockMemberPreferenceRepository.Setup(x => x.SaveMemberPreferenceAsync(It.IsAny<MemberPreference>()))
|
|
.Verifiable();
|
|
_mockMemberPreferenceRepository
|
|
.Setup(x => x.BulkSaveMemberPreferenceAsync(It.IsAny<List<MemberPreference>>())).Verifiable();
|
|
_mockUnifiedOptinRepository.Setup(x => x.GetOrCreateMemberOptinSettings(It.IsAny<string>()))
|
|
.ReturnsAsync(new MemberOptInSettings());
|
|
_mockBatchItemsRepository.Setup(x => x.MarkPendingSuccessful(It.IsAny<List<string>>())).ReturnsAsync(true)
|
|
.Verifiable();
|
|
|
|
var result = await _xdiBatchItemService.MarkPendingSuccessful(response);
|
|
|
|
Assert.True(result);
|
|
|
|
_mockBatchItemsRepository.Verify(x =>
|
|
x.MarkPendingSuccessful(It.Is<List<string>>(list =>
|
|
list.Contains("100") && list.Contains("101"))));
|
|
|
|
_mockMemberPreferenceRepository.Verify(x => x.SaveMemberPreferenceAsync(It.Is<MemberPreference>(preference =>
|
|
preference.UserId == "100" && preference.Value == DeliveryPreference.Paper)));
|
|
|
|
_mockMemberPreferenceRepository.Verify(x => x.BulkSaveMemberPreferenceAsync(It.Is<List<MemberPreference>>(
|
|
preferenceList =>
|
|
preferenceList.Exists(x => x.UserId == "101" && x.Value == DeliveryPreference.Electronic) &&
|
|
preferenceList.Exists(x => x.UserId == "101" && x.Value == "[email protected]"))));
|
|
|
|
_mockMemberPreferenceRepository.Verify(x =>
|
|
x.SaveMemberPreferenceAsync(It.IsAny<MemberPreference>()), Times.Once());
|
|
|
|
_mockMemberPreferenceRepository.Verify(x =>
|
|
x.BulkSaveMemberPreferenceAsync(It.IsAny<List<MemberPreference>>()), Times.Once());
|
|
}
|
|
}
|
|
}
|