public async Task SendFile_Exception_ShouldAddToFailedTransmission()
{
var transmissionLinkMock = new Mock <ITransmissionLink>();
transmissionLinkMock.Setup(x => x.SendFile(It.IsAny <Recipient>(), It.IsAny <Folder>(), It.IsAny <File>()))
.Callback <Recipient, Folder, File>((x, y, z) =>
{
throw new InvalidOperationException();
});
Guid transmittedFileId = Guid.Empty;
Guid transmittedRecipientId = Guid.Empty;
var transmissionRepositoryMock = new Mock <ITransmissionRepository>();
transmissionRepositoryMock.Setup(x => x.AddFailedFileTransmission(It.IsAny <Guid>(), It.IsAny <Guid>()))
.Callback <Guid, Guid>((x, y) => {
transmittedFileId = x;
transmittedRecipientId = y;
})
.ReturnsAsync(() => Result.Success());
var recipient = Helper.GetRecipientModel("testRecipient");
var folder = Helper.GetFolderModel("testFolder");
var file = Helper.GetFileModel();
var transmissionService = new TransmissionService(transmissionLinkMock.Object, transmissionRepositoryMock.Object);
var canContinue = await transmissionService.SendFile(recipient, folder, file);
Assert.AreEqual(recipient.Id, transmittedRecipientId);
Assert.AreEqual(file.Id, transmittedFileId);
Assert.IsTrue(canContinue);
}
private void ProcessIndividualMassCommEntity(MassCommunication massComm)
{
try
{
if (massComm.Recipients == null ||
massComm.Recipients.Count == 0)
{
throw new NoRecipientsFoundException(massComm);
}
var svc = new TransmissionService(massComm);
svc.PrepareForSend();
var lstResults = svc.Send();
var lstUpdatedRecipients = UpdateTransmissionStatus(lstResults);
_repository.RecipientRepository.UpdateStatuses(lstUpdatedRecipients);
UpdateStatus(massComm, lstResults);
_repository.MassCommunicationRepository.UpdateStatuses(massComm);
}
catch (Exception ex)
{
Logging.LogError(ex);
Fail(massComm, ex);
}
}
public async Task SendFile_ShouldCallTransmissionLinkSendFile()
{
Recipient transmittedRecipient = null;
Folder transmittedFolder = null;
File transmittedFile = null;
var transmissionLinkMock = new Mock <ITransmissionLink>();
transmissionLinkMock.Setup(x => x.SendFile(It.IsAny <Recipient>(), It.IsAny <Folder>(), It.IsAny <File>()))
.Callback <Recipient, Folder, File>((x, y, z) =>
{
transmittedRecipient = x;
transmittedFolder = y;
transmittedFile = z;
});
var transmissionRepositoryMock = new Mock <ITransmissionRepository>();
transmissionRepositoryMock.Setup(x => x.AddFailedFileTransmission(It.IsAny <Guid>(), It.IsAny <Guid>()));
var recipient = Helper.GetRecipientModel("testRecipient");
var folder = Helper.GetFolderModel("testFolder");
var file = Helper.GetFileModel();
var transmissionService = new TransmissionService(transmissionLinkMock.Object, transmissionRepositoryMock.Object);
await transmissionService.SendFile(recipient, folder, file);
Assert.AreSame(recipient, transmittedRecipient);
Assert.AreSame(folder, transmittedFolder);
Assert.AreSame(file, transmittedFile);
}
public async Task SendEofMessage_ShouldCallTransmissionLinkSendEofMessage()
{
Recipient transmittedRecipient = null;
EofMessage transmittedEofMessage = null;
var transmissionLinkMock = new Mock <ITransmissionLink>();
transmissionLinkMock.Setup(x => x.SendEofMessage(It.IsAny <Recipient>(), It.IsAny <EofMessage>()))
.Callback <Recipient, EofMessage>((x, y) =>
{
transmittedRecipient = x;
transmittedEofMessage = y;
});
var transmissionRepositoryMock = new Mock <ITransmissionRepository>();
transmissionRepositoryMock.Setup(x => x.AddFailedFileTransmission(It.IsAny <Guid>(), It.IsAny <Guid>()));
var recipient = Helper.GetRecipientModel("testRecipient");
var eofMesage = Helper.GetEofMessageModel();
var transmissionService = new TransmissionService(transmissionLinkMock.Object, transmissionRepositoryMock.Object);
await transmissionService.SendEofMessage(recipient, eofMesage);
Assert.AreSame(recipient, transmittedRecipient);
Assert.AreSame(eofMesage, transmittedEofMessage);
}
public TorrentStopCommandHandler(
IBotTelegramClient botTelegramClient,
TransmissionService transmissionService,
ILogger <TorrentListCommandHandler> logger)
: base(botTelegramClient, _supportedCommands)
{
_transmissionService = transmissionService;
_logger = logger;
}
public FileExportWorker(IFolderRepository folderRepository
, IFileRepository fileRepository
, TransmissionService communicationService
, WorkerQueueContainer workerQueueContainer
, IBroker broker)
{
_folderRepository = folderRepository;
_fileRepository = fileRepository;
_communicationService = communicationService;
_workerQueueContainer = workerQueueContainer;
_recipientsAddedNotificationSubscription = broker.Subscribe(this);
}
public RetryWorker(IConfiguration configuration
, TransmissionService transmissionService
, WorkerQueueContainer workerQueueContainer
, IFileRepository fileRepository
, ITransmissionRepository transmissionRepository
)
{
_triggerInterval = int.TryParse(configuration[Constants.RetryTriggerInterval], out var interval) ? interval : 10;
_transmissionService = transmissionService;
_workerQueueContainer = workerQueueContainer;
_fileRepository = fileRepository;
_transmissionRepository = transmissionRepository;
}
public FileDisassemblerWorker(IConfiguration configuration, WorkerQueueContainer workerQueueContainer
, FileDisassemblerServiceFactory fileProcessServiceFactory
, TransmissionService transmissionService
, IRecipientRepository recipientRepository
, IWebhookService webhookService
, IFileRepository fileRepository)
{
_amountOfConcurrentJobs = int.Parse(configuration[Constants.ConcurrentFileDisassemblyJobs]);
_workerQueueContainer = workerQueueContainer;
_fileProcessServiceFactory = fileProcessServiceFactory;
_transmissionService = transmissionService;
_recipientRepository = recipientRepository;
_webhookService = webhookService;
_fileRepository = fileRepository;
}
public TransmissionController(
ILogger <SystemInformationController> logger,
IConfiguration config,
IOptions <ConfigEnvironment> envOpt
)
{
if (envOpt.Value.UseSsh)
{
var credentials = new OSCommander.Dtos.SshCredentials(
config["Ssh:Host"],
config["Ssh:Username"],
config["Ssh:Password"]);
_serviceService = new Service(logger, credentials);
_transmissionService = new TransmissionService(logger, credentials);
}
else
{
_serviceService = new Service(logger);
_transmissionService = new TransmissionService(logger);
}
}
public async Task SendEofMessage_ExceptionDuringAddFailedTransmission_ShouldNotContinue()
{
var transmissionLinkMock = new Mock <ITransmissionLink>();
transmissionLinkMock.Setup(x => x.SendEofMessage(It.IsAny <Recipient>(), It.IsAny <EofMessage>()))
.Callback <Recipient, EofMessage>((x, y) =>
{
throw new InvalidOperationException();
});
var transmissionRepositoryMock = new Mock <ITransmissionRepository>();
transmissionRepositoryMock.Setup(x => x.AddFailedEofMessageTransmission(It.IsAny <Guid>(), It.IsAny <Guid>()))
.ReturnsAsync(() => Result.Failure());
var recipient = Helper.GetRecipientModel("testRecipient");
var eofMesage = Helper.GetEofMessageModel();
var transmissionService = new TransmissionService(transmissionLinkMock.Object, transmissionRepositoryMock.Object);
var canContinue = await transmissionService.SendEofMessage(recipient, eofMesage);
Assert.IsFalse(canContinue);
}
public FileChunkExportWorker(WorkerQueueContainer workerQueueContainer, TransmissionService transmissionService)
{
_workerQueueContainer = workerQueueContainer;
_transmissionService = transmissionService;
}