StraightPreEncryptedForwardTest.cs

using FitConnect;
using FitConnect.Encryption;
using FitConnect.Models;
using FluentAssertions;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;

namespace E2ETest;

[Order(30)]
[TestFixture]
public class StraightPreEncryptedForwardTest : EndToEndTestBase {
    private string _caseId = null!;
    private string _submissionId = null!;

    [Order(10)]
    [Test]
    public void SendingSubmission() {
        // Arrange
        var publicKey = (Sender as Sender)!.GetPublicKeyForDestinationAsync(Settings.DestinationId)
            .Result;

        var joseEncryptor = new JoseEncryptor();
        var encryptedAttachment =
            joseEncryptor.Encrypt(publicKey, File.ReadAllBytes("Test.pdf"));

        var data = JsonConvert.SerializeObject(new {
            Name = "Encrypted Test",
            Content = "A simple test to upload pre-encrypted data"
        });

        var dataHash = FitEncryption.CalculateHash(data);
        var encryptedData = joseEncryptor.Encrypt(publicKey, data);

        var attachment = new Attachment("Test.pdf", "Simple Test");
        var metadata = FitConnect.Sender.CreateMetadata(new Submission {
            Data = encryptedData,
            Attachments = new List<Attachment> { attachment },
            ServiceType = new ServiceType
                { Identifier = Settings.LeikaKey, Name = "Straight forward test" }
        }, dataHash);

        var encryptedMetadata = joseEncryptor.Encrypt(publicKey, metadata);


        // Act
        var submission = EncryptedSubmissionBuilder
            .WithDestination(Settings.DestinationId)
            .WithServiceType("Straight forward test", Settings.LeikaKey)
            .WithEncryptedMetaData(encryptedMetadata)
            .WithEncryptedData(encryptedData)
            .WithEncryptedAttachments(new Dictionary<string, string> {
                {
                    attachment.Id,
                    encryptedAttachment
                }
            })
            .Build();

        var result = Sender.SendAsync(submission).Result;

        if (result.CaseId == null || result.CaseId == null)
            throw new NullReferenceException(
                $"Neither {nameof(result.CaseId)} nor {nameof(result.SubmissionId)} must not be null");

        _caseId = result.CaseId!;
        _submissionId = result.SubmissionId!;
    }

    [Test]
    [Order(20)]
    public void Sender_GetSubmissionState() {
        // Act
        var status = Sender.GetStatusForSubmissionAsync(_caseId, Settings.DestinationId).Result;

        // Assert
        status.Count.Should().BeGreaterThan(0);
        status.Any(s => s.EventType == EventType.Submit).Should().BeTrue();
        status.ForEach(
            s => Logger.LogInformation("Status {When} {Event}", s.EventTime, s.EventType));
    }

    [Test]
    [Order(30)]
    public void Subscriber_GetSubmissionState() {
        // Act
        var status = Subscriber.GetStatusForSubmissionAsync(_caseId, Settings.DestinationId).Result;

        // Assert
        status.Count.Should().BeGreaterThan(0);
        status.ForEach(
            s => Logger.LogInformation("Status {When} {Event}", s.EventTime, s.EventType));
    }

    [Test]
    [Order(40)]
    public void RequestSubmission() {
        var subscriberWithSubmission = Subscriber.RequestSubmissionAsync(_submissionId).Result;

        var data = subscriberWithSubmission.GetDataString();
        Logger.LogInformation("Data {Data}", data);

        data.Should()
            .Contain("A simple test to upload pre-encrypted data");

        var attachments = subscriberWithSubmission.GetAttachmentsAsync().Result;
        attachments.First().Filename.Should().Be("Test.pdf");

        subscriberWithSubmission.AcceptSubmissionAsync().Wait();
    }

    [Test]
    [Order(50)]
    public void Sender_GetSubmissionState_AfterAccepting() {
        // Act
        var status = Sender.GetStatusForSubmissionAsync(_caseId, Settings.DestinationId).Result;

        // Assert
        status.Count.Should().BeGreaterThan(0);
        status.ForEach(
            s => Logger.LogInformation("Status {When} {Event}", s.EventTime, s.EventType));
    }
}