Fixes

src/Speckle.Sdk/Api/GraphQL/Client.cs

@@ -35,7 +35,7 @@ public sealed class Client : ISpeckleGraphQLClient, IClient
   public WorkspaceResource Workspace { get; }
   public ServerResource Server { get; }
   public FileImportResource FileImport { get; }
-  public IngestResource Ingest { get; }
+  public ModelIngestionResource Ingestion { get; }
 
   public Uri ServerUrl => new(Account.serverInfo.url);
 
@@ -72,7 +72,7 @@ public sealed class Client : ISpeckleGraphQLClient, IClient
     Workspace = new(this);
     Server = new(this);
     FileImport = new(this, blobApiFactory.Create(account));
-    Ingest = new(this);
+    Ingestion = new(this);
   }
 
   [AutoInterfaceIgnore]

src/Speckle.Sdk/Api/GraphQL/Enums/FileUploadConversionStatus.cs

@@ -1,6 +1,9 @@
-namespace Speckle.Sdk.Api.GraphQL.Enums;
+// ReSharper disable InconsistentNaming
+namespace Speckle.Sdk.Api.GraphQL.Enums;
 
-//This enum isn't explicitly defined in the schema, instead its usages are int typed (But represent an enum)
+/// <remarks>
+/// This enum isn't explicitly defined in the schema, instead its usages are int typed (But represent an enum)
+/// </remarks>
 public enum FileUploadConversionStatus
 {
   Queued = 0,

src/Speckle.Sdk/Api/GraphQL/Enums/ModelIngestionStatus.cs

@@ -0,0 +1,14 @@
+// ReSharper disable InconsistentNaming
+namespace Speckle.Sdk.Api.GraphQL.Enums;
+
+/// <remarks>
+/// string based enum
+/// </remarks>
+public enum ModelIngestionStatus
+{
+  cancelled,
+  failed,
+  processing,
+  queued,
+  success,
+}

src/Speckle.Sdk/Api/GraphQL/Enums/ProjectCommentsUpdatedMessageType.cs

@@ -1,5 +1,8 @@
 namespace Speckle.Sdk.Api.GraphQL.Enums;
 
+/// <remarks>
+/// string based enum
+/// </remarks>
 public enum ProjectCommentsUpdatedMessageType
 {
   ARCHIVED,

src/Speckle.Sdk/Api/GraphQL/Enums/ProjectFileImportUpdatedMessageType.cs

@@ -1,5 +1,8 @@
 namespace Speckle.Sdk.Api.GraphQL.Enums;
 
+/// <remarks>
+/// string based enum
+/// </remarks>
 public enum ProjectFileImportUpdatedMessageType
 {
   CREATED,

src/Speckle.Sdk/Api/GraphQL/Enums/ProjectModelIngestionUpdatedMessageType.cs

@@ -0,0 +1,13 @@
+// ReSharper disable InconsistentNaming
+namespace Speckle.Sdk.Api.GraphQL.Enums;
+
+/// <remarks>
+/// string based enum
+/// </remarks>
+public enum ProjectModelIngestionUpdatedMessageType
+{
+  cancellationRequested,
+  created,
+  deleted,
+  updated,
+}

src/Speckle.Sdk/Api/GraphQL/Enums/ProjectModelsUpdatedMessageType.cs

@@ -1,5 +1,8 @@
 namespace Speckle.Sdk.Api.GraphQL.Enums;
 
+/// <remarks>
+/// string based enum
+/// </remarks>
 public enum ProjectModelsUpdatedMessageType
 {
   CREATED,

src/Speckle.Sdk/Api/GraphQL/Enums/ProjectPendingModelsUpdatedMessageType.cs

@@ -1,5 +1,8 @@
 namespace Speckle.Sdk.Api.GraphQL.Enums;
 
+/// <remarks>
+/// string based enum
+/// </remarks>
 public enum ProjectPendingModelsUpdatedMessageType
 {
   CREATED,

src/Speckle.Sdk/Api/GraphQL/Enums/ProjectUpdatedMessageType.cs

@@ -1,5 +1,8 @@
 namespace Speckle.Sdk.Api.GraphQL.Enums;
 
+/// <remarks>
+/// string based enum
+/// </remarks>
 public enum ProjectUpdatedMessageType
 {
   DELETED,

src/Speckle.Sdk/Api/GraphQL/Enums/ProjectVersionsUpdatedMessageType.cs

@@ -1,5 +1,8 @@
 namespace Speckle.Sdk.Api.GraphQL.Enums;
 
+/// <remarks>
+/// string based enum
+/// </remarks>
 public enum ProjectVersionsUpdatedMessageType
 {
   CREATED,

src/Speckle.Sdk/Api/GraphQL/Enums/ProjectVisibility.cs

@@ -1,5 +1,9 @@
+// ReSharper disable InconsistentNaming
 namespace Speckle.Sdk.Api.GraphQL.Enums;
 
+/// <remarks>
+/// string based enum
+/// </remarks>
 public enum ProjectVisibility
 {
   Private,

src/Speckle.Sdk/Api/GraphQL/Enums/ResourceType.cs

@@ -1,5 +1,9 @@
-namespace Speckle.Sdk.Api.GraphQL.Enums;
+// ReSharper disable InconsistentNaming
+namespace Speckle.Sdk.Api.GraphQL.Enums;
 
+/// <remarks>
+/// string based enum
+/// </remarks>
 public enum ResourceType
 {
   commit,

src/Speckle.Sdk/Api/GraphQL/Enums/UserProjectsUpdatedMessageType.cs

@@ -1,5 +1,8 @@
 namespace Speckle.Sdk.Api.GraphQL.Enums;
 
+/// <remarks>
+/// string based enum
+/// </remarks>
 public enum UserProjectsUpdatedMessageType
 {
   ADDED,

src/Speckle.Sdk/Api/GraphQL/Inputs/IngestInputs.cs

@@ -1,4 +1,6 @@
-namespace Speckle.Sdk.Api.GraphQL.Inputs;
+using Speckle.Sdk.Api.GraphQL.Enums;
+
+namespace Speckle.Sdk.Api.GraphQL.Inputs;
 
 public record SourceDataInput(
   string sourceApplicationSlug,
@@ -32,3 +34,16 @@ public record ModelIngestionFailedInput(
 }
 
 public record ModelIngestionCancelledInput(string ingestionId, string projectId, string cancellationMessage);
+
+public record ProjectModelIngestionSubscriptionInput(
+  string projectId,
+  ModelIngestionReference ingestionReference,
+  ProjectModelIngestionUpdatedMessageType messageType
+);
+
+/// <remarks>
+/// <c>@oneOf</c> i.e. server expects <b>either</b> <paramref name="ingestionId"/> or <paramref name="modelId"/>, but not both.
+/// </remarks>
+/// <param name="ingestionId"></param>
+/// <param name="modelId"></param>
+public record ModelIngestionReference(string? ingestionId, string? modelId);

src/Speckle.Sdk/Api/GraphQL/Models/ModelIngestion.cs

@@ -5,5 +5,8 @@ public sealed class ModelIngestion
   public required string id { get; init; }
   public required DateTime createdAt { get; init; }
   public required DateTime updatedAt { get; init; }
+  public required string modelId { get; init; }
+  public required bool cancellationRequested { get; init; }
+  public required ModelIngestionStatusData statusData { get; init; }
   // public required LimitedUser user { get; init; }
 }

src/Speckle.Sdk/Api/GraphQL/Models/ModelIngestionStatusData.cs

@@ -0,0 +1,9 @@
+using Speckle.Sdk.Api.GraphQL.Enums;
+
+namespace Speckle.Sdk.Api.GraphQL.Models;
+
+public sealed class ModelIngestionStatusData
+{
+  public required ModelIngestionStatus status { get; init; }
+  public required string? progressMessage { get; init; }
+}

src/Speckle.Sdk/Api/GraphQL/Models/SubscriptionMessages.cs

@@ -83,8 +83,11 @@ public sealed class ProjectVersionsUpdatedMessage : EventArgs
   public Version? version { get; init; }
 }
 
-public sealed class ProjectModelIngestionCancellationRequestedMessage : EventArgs
+public sealed class ProjectModelIngestionUpdatedMessage : EventArgs
 {
   [JsonRequired]
-  public required ModelIngestion? modelIngestion { get; init; }
+  public required ModelIngestion modelIngestion { get; init; }
+
+  [JsonRequired]
+  public required ProjectModelIngestionUpdatedMessageType type { get; init; }
 }

src/Speckle.Sdk/Api/GraphQL/Resources/ModelIngestionResource.cs

@@ -5,11 +5,11 @@ using Speckle.Sdk.Api.GraphQL.Models.Responses;
 
 namespace Speckle.Sdk.Api.GraphQL.Resources;
 
-public sealed class Ingestionresource
+public sealed class ModelIngestionResource
 {
   private readonly ISpeckleGraphQLClient _client;
 
-  internal Ingestionresource(ISpeckleGraphQLClient client)
+  internal ModelIngestionResource(ISpeckleGraphQLClient client)
   {
     _client = client;
   }
@@ -32,6 +32,16 @@ public sealed class Ingestionresource
               id
               createdAt
               updatedAt
+              modelId
+              cancellationRequested
+              statusData {
+                ... on HasModelIngestionStatus {
+                  status
+                }
+                ... on HasProgressMessage {
+                  progressMessage
+                }
+              }
             }
           }
         }
@@ -70,39 +80,14 @@ public sealed class Ingestionresource
               id
               createdAt
               updatedAt
-            }
-          }
-        }
-      }
-      """;
-
-    GraphQLRequest request = new() { Query = QUERY, Variables = new { input } };
-
-    var res = await _client
-      .ExecuteGraphQLRequest<RequiredResponse<RequiredResponse<RequiredResponse<ModelIngestion>>>>(
-        request,
-        cancellationToken
-      )
-      .ConfigureAwait(false);
-
-    return res.data.data.data;
-  }
-
-  /// <param name="input"></param>
-  /// <param name="cancellationToken"></param>
-  /// <returns>The version id</returns>
-  /// <inheritdoc cref="ISpeckleGraphQLClient.ExecuteGraphQLRequest{T}"/>
-  public async Task<string> Complete(ModelIngestionSuccessInput input, CancellationToken cancellationToken = default)
-  {
-    //language=graphql
-    const string QUERY = """
-      mutation IngestionComplete($input: ModelIngestionSuccessInput!) {
-        data: projectMutations {
-          data: modelIngestionMutations {
-            data: completeWithVersion(input: $input) {
-              data:statusData {
-                ... on ModelIngestionSuccessStatus {
-                  versionId
+              modelId
+              cancellationRequested
+              statusData {
+                ... on HasModelIngestionStatus {
+                  status
+                }
+                ... on HasProgressMessage {
+                  progressMessage
                 }
               }
             }
@@ -113,42 +98,6 @@ public sealed class Ingestionresource
 
     GraphQLRequest request = new() { Query = QUERY, Variables = new { input } };
 
-    var res = await _client
-      .ExecuteGraphQLRequest<RequiredResponse<RequiredResponse<RequiredResponse<RequiredResponse<string>>>>>(
-        request,
-        cancellationToken
-      )
-      .ConfigureAwait(false);
-
-    return res.data.data.data.data;
-  }
-
-  /// <param name="input"></param>
-  /// <param name="cancellationToken"></param>
-  /// <returns></returns>
-  /// <inheritdoc cref="ISpeckleGraphQLClient.ExecuteGraphQLRequest{T}"/>
-  public async Task<ModelIngestion> FailWithError(
-    ModelIngestionFailedInput input,
-    CancellationToken cancellationToken = default
-  )
-  {
-    //language=graphql
-    const string QUERY = """
-      mutation IngestionFailWithError($input: ModelIngestionFailedInput!) {
-        data: projectMutations {
-          data: modelIngestionMutations {
-            data: failWithError(input: $input) {
-              id
-              createdAt
-              updatedAt
-            }
-          }
-        }
-      }
-      """;
-
-    GraphQLRequest request = new() { Query = QUERY, Variables = new { input } };
-
     var res = await _client
       .ExecuteGraphQLRequest<RequiredResponse<RequiredResponse<RequiredResponse<ModelIngestion>>>>(
         request,
@@ -160,14 +109,107 @@ public sealed class Ingestionresource
   }
 
   /// <summary>
-  /// Request that the ingestion is canceled.
+  /// Request that the server completes the ingestion by creating a version
+  /// If successful, the job will be in a terminal "successful" state.
+  /// </summary>
+  /// <seealso cref="FailWithError"/>
+  /// <seealso cref="FailWithCancel"/>
+  /// <param name="input"></param>
+  /// <param name="cancellationToken"></param>
+  /// <returns>The version id</returns>
+  /// <inheritdoc cref="ISpeckleGraphQLClient.ExecuteGraphQLRequest{T}"/>
+  public async Task<string> Complete(ModelIngestionSuccessInput input, CancellationToken cancellationToken = default)
+  {
+    //language=graphql
+    const string QUERY = """
+      mutation IngestionComplete($input: ModelIngestionSuccessInput!) {
+        data: projectMutations {
+          data: modelIngestionMutations {
+            data: completeWithVersion(input: $input) {
+              data:statusData {
+                ... on ModelIngestionSuccessStatus {
+                  data:versionId
+                }
+              }
+            }
+          }
+        }
+      }
+      """;
+
+    GraphQLRequest request = new() { Query = QUERY, Variables = new { input } };
+
+    var res = await _client
+      .ExecuteGraphQLRequest<
+        RequiredResponse<RequiredResponse<RequiredResponse<RequiredResponse<RequiredResponse<string>>>>>
+      >(request, cancellationToken)
+      .ConfigureAwait(false);
+
+    return res.data.data.data.data.data;
+  }
+
+  /// <summary>
+  /// Fail the job with an error.
   /// </summary>
   /// <remarks>
-  /// Note it's up to the client to observe this cancellation request
-  /// via <see cref="SubscriptionResource.CreateProjectModelIngestionCancellationRequestedSubscription"/>
-  /// and report it as canceled via  <see cref="IngestionResource.CreateProjectModelIngestionCancellationRequestedSubscription"/>`ingestion.fail_with_cancelled`.
-  ///
-  /// See "cooperative cancellation pattern"</remarks>
+  /// For requested user cancellation, use <see cref="FailWithCancel"/> instead
+  /// </remarks>
+  /// <seealso cref="FailWithCancel"/>
+  /// <seealso cref="Complete"/>
+  /// <param name="input"></param>
+  /// <param name="cancellationToken"></param>
+  /// <returns></returns>
+  /// <inheritdoc cref="ISpeckleGraphQLClient.ExecuteGraphQLRequest{T}"/>
+  public async Task<ModelIngestion> FailWithError(
+    ModelIngestionFailedInput input,
+    CancellationToken cancellationToken = default
+  )
+  {
+    //language=graphql
+    const string QUERY = """
+      mutation IngestionFailWithError($input: ModelIngestionFailedInput!) {
+        data: projectMutations {
+          data: modelIngestionMutations {
+            data: failWithError(input: $input) {
+              id
+              createdAt
+              updatedAt
+              modelId
+              cancellationRequested
+              statusData {
+                ... on HasModelIngestionStatus {
+                  status
+                }
+                ... on HasProgressMessage {
+                  progressMessage
+                }
+              }
+            }
+          }
+        }
+      }
+      """;
+
+    GraphQLRequest request = new() { Query = QUERY, Variables = new { input } };
+
+    var res = await _client
+      .ExecuteGraphQLRequest<RequiredResponse<RequiredResponse<RequiredResponse<ModelIngestion>>>>(
+        request,
+        cancellationToken
+      )
+      .ConfigureAwait(false);
+
+    return res.data.data.data;
+  }
+
+  /// <summary>
+  /// Fail the ingestion with a <c>canceled</c> status.
+  /// This should only be done if the user has explicitly requested cancellation
+  /// Other forms of cancellation use <see cref="FailWithError"/>.
+  /// The ingestion should then enter a terminal "canceled" state
+  /// </summary>
+  /// <seealso cref="FailWithError"/>
+  /// <seealso cref="Complete"/>
   /// <param name="input"></param>
   /// <param name="cancellationToken"></param>
   /// <returns></returns>
@@ -186,6 +228,74 @@ public sealed class Ingestionresource
               id
               createdAt
               updatedAt
+              modelId
+              cancellationRequested
+              statusData {
+                ... on HasModelIngestionStatus {
+                  status
+                }
+                ... on HasProgressMessage {
+                  progressMessage
+                }
+              }
+            }
+          }
+        }
+      }
+      """;
+
+    GraphQLRequest request = new() { Query = QUERY, Variables = new { input } };
+
+    var res = await _client
+      .ExecuteGraphQLRequest<RequiredResponse<RequiredResponse<RequiredResponse<ModelIngestion>>>>(
+        request,
+        cancellationToken
+      )
+      .ConfigureAwait(false);
+
+    return res.data.data.data;
+  }
+
+  /// <summary>
+  /// Request that the <see cref="ModelIngestion"/> is canceled.
+  /// </summary>
+  /// <remarks>
+  /// Note simply calling this mutation does not imediatly cancel, it doesn't even guarantee it will be canceled at all.
+  /// It's up to the client to observe this cancellation request
+  /// via <see cref="SubscriptionResource.CreateProjectModelIngestionCancellationRequestedSubscription"/>
+  /// and report it as canceled via  <see cref="ModelIngestionResource.FailWithCancel"/>
+  /// See "cooperative cancellation pattern"
+  /// </remarks>
+  /// <seealso cref="FailWithError"/>
+  /// <seealso cref="Complete"/>
+  /// <param name="input"></param>
+  /// <param name="cancellationToken"></param>
+  /// <returns></returns>
+  /// <inheritdoc cref="ISpeckleGraphQLClient.ExecuteGraphQLRequest{T}"/>
+  public async Task<ModelIngestion> RequestCancellation(
+    ModelIngestionCancelledInput input,
+    CancellationToken cancellationToken = default
+  )
+  {
+    //language=graphql
+    const string QUERY = """
+      mutation IngestionRequestCancellation($input: ModelIngestionRequestCancellationInput!) {
+        data: projectMutations {
+          data: modelIngestionMutations {
+            data: requestCancellation (input: $input) {
+              id
+              createdAt
+              updatedAt
+              modelId
+              cancellationRequested
+              statusData {
+                ... on HasModelIngestionStatus {
+                  status
+                }
+                ... on HasProgressMessage {
+                  progressMessage
+                }
+              }
             }
           }
         }

src/Speckle.Sdk/Api/GraphQL/Resources/SubscriptionResource.cs

@@ -1,4 +1,5 @@
 using GraphQL;
+using Speckle.Sdk.Api.GraphQL.Enums;
 using Speckle.Sdk.Api.GraphQL.Inputs;
 using Speckle.Sdk.Api.GraphQL.Models;
 using Speckle.Sdk.Api.GraphQL.Models.Responses;
@@ -215,31 +216,49 @@ public sealed class SubscriptionResource : IDisposable
   /// <summary>Subscribe to a cancellation request being made for a Model Ingestion</summary>
   /// <remarks><inheritdoc cref="CreateUserProjectsUpdatedSubscription"/></remarks>
   /// <inheritdoc cref="ISpeckleGraphQLClient.SubscribeTo{T}"/>
-  public Subscription<ProjectModelIngestionCancellationRequestedMessage> CreateProjectModelIngestionCancellationRequestedSubscription(
-    string ingestionId,
-    string projectId
+  public Subscription<ProjectModelIngestionUpdatedMessage> CreateProjectModelIngestionUpdatedSubscription(
+    ProjectModelIngestionSubscriptionInput input
   )
   {
     //language=graphql
     const string QUERY = """
-      subscription IngestionCancellationRequested($projectId: ID!, $ingestionId: ID!){
-        data:projectModelIngestionCancellationRequested(projectId: $projectId, ingestionId: $ingestionId) {
-          modelIngestion
-          {
+      subscription IngestionUpdated(
+        $input: ProjectModelIngestionSubscriptionInput!
+      ) {
+        data: projectModelIngestionUpdated(input: $input) {
+          modelIngestion {
             id
             createdAt
             updatedAt
           }
+          type
         }
       }
       """;
-    GraphQLRequest request = new() { Query = QUERY, Variables = new { projectId, ingestionId } };
+    GraphQLRequest request = new() { Query = QUERY, Variables = new { input } };
 
-    Subscription<ProjectModelIngestionCancellationRequestedMessage> subscription = new(_client, request);
+    Subscription<ProjectModelIngestionUpdatedMessage> subscription = new(_client, request);
     _subscriptions.Add(subscription);
     return subscription;
   }
 
+  /// <summary>Subscribe to a cancellation request being made for a Model Ingestion</summary>
+  /// <remarks><inheritdoc cref="CreateUserProjectsUpdatedSubscription"/></remarks>
+  /// <inheritdoc cref="ISpeckleGraphQLClient.SubscribeTo{T}"/>
+  public Subscription<ProjectModelIngestionUpdatedMessage> CreateProjectModelIngestionCancellationRequestedSubscription(
+    string ingestionId,
+    string projectId
+  )
+  {
+    return CreateProjectModelIngestionUpdatedSubscription(
+      new ProjectModelIngestionSubscriptionInput(
+        projectId,
+        new(ingestionId, null),
+        ProjectModelIngestionUpdatedMessageType.cancellationRequested
+      )
+    );
+  }
+
   public void Dispose()
   {
     foreach (var subscription in _subscriptions)

tests/Speckle.Sdk.Tests.Integration/Api/GraphQL/Resources/ModelIngestionResourceExceptionalTests.CancelNonExistentIngestion.verified.json

@@ -0,0 +1,8 @@
+{
+  "Type": "AggregateException",
+  "InnerException": {
+    "Data": {},
+    "Message": "NOT_FOUND_ERROR: Model ingestion was not found",
+    "Type": "SpeckleGraphQLException"
+  }
+}

tests/Speckle.Sdk.Tests.Integration/Api/GraphQL/Resources/ModelIngestionResourceExceptionalTests.CreateIngestionNonExistentProject.verified.json

@@ -0,0 +1,8 @@
+{
+  "Type": "AggregateException",
+  "InnerException": {
+    "Data": {},
+    "Message": "STREAM_NOT_FOUND: Project not found",
+    "Type": "SpeckleGraphQLStreamNotFoundException"
+  }
+}

tests/Speckle.Sdk.Tests.Integration/Api/GraphQL/Resources/ModelIngestionResourceExceptionalTests.UpdateNonExistentNonExistent.verified.json

@@ -0,0 +1,8 @@
+{
+  "Type": "AggregateException",
+  "InnerException": {
+    "Data": {},
+    "Message": "NOT_FOUND_ERROR: Model ingestion was not found",
+    "Type": "SpeckleGraphQLException"
+  }
+}

tests/Speckle.Sdk.Tests.Integration/Api/GraphQL/Resources/ModelIngestionResourceExceptionalTests.cs

@@ -0,0 +1,73 @@
+using System.Reflection;
+using Speckle.Sdk.Api;
+using Speckle.Sdk.Api.GraphQL.Inputs;
+using Speckle.Sdk.Api.GraphQL.Models;
+using Speckle.Sdk.Api.GraphQL.Resources;
+using Speckle.Sdk.Host;
+using Speckle.Sdk.Models;
+
+namespace Speckle.Sdk.Tests.Integration.API.GraphQL.Resources;
+
+public sealed class ModelIngestionResourceExceptionalTests : IAsyncLifetime
+{
+  private IClient _testUser;
+  private ModelIngestionResource Sut => _testUser.Ingestion;
+  private Project _project;
+  private Model _model;
+
+  public Task DisposeAsync() => Task.CompletedTask;
+
+  public async Task InitializeAsync()
+  {
+    TypeLoader.Reset();
+    TypeLoader.Initialize(typeof(Base).Assembly, Assembly.GetExecutingAssembly());
+
+    _testUser = await Fixtures.SeedUserWithClient();
+    _project = await _testUser.Project.Create(new("Test project", "", null));
+    _model = await _testUser.Model.Create(new("Test Model 1", "", _project.id));
+  }
+
+  [Fact]
+  public async Task CreateIngestionNonExistentProject()
+  {
+    var createInput = new ModelIngestionCreateInput(
+      _model.id,
+      "Doesn't exist...",
+      "Starting processing",
+      new(".NET test runner", "0.0.0", null, null)
+    );
+
+    var ex = await Assert.ThrowsAsync<AggregateException>(async () =>
+    {
+      _ = await Sut.Create(createInput);
+    });
+    await Verify(ex);
+  }
+
+  [Fact]
+  public async Task UpdateNonExistentNonExistent()
+  {
+    var updateInput = new ModelIngestionUpdateInput("Doesn't exist", _project.id, "Can't be", 0.5);
+
+    var ex = await Assert.ThrowsAsync<AggregateException>(async () =>
+    {
+      _ = await Sut.UpdateProgress(updateInput);
+    });
+    await Verify(ex);
+  }
+
+  [Fact]
+  public async Task CancelNonExistentIngestion()
+  {
+    var input = new ModelIngestionCancelledInput(
+      "Non-existent-ingestion",
+      _project.id,
+      cancellationMessage: "This was cancelled for testing purposes"
+    );
+    var ex = await Assert.ThrowsAsync<AggregateException>(async () =>
+    {
+      _ = await Sut.FailWithCancel(input);
+    });
+    await Verify(ex);
+  }
+}

tests/Speckle.Sdk.Tests.Integration/Api/GraphQL/Resources/ModelIngestionResourceTests.cs

@@ -1,6 +1,7 @@
 using System.Reflection;
 using Microsoft.Extensions.DependencyInjection;
 using Speckle.Sdk.Api;
+using Speckle.Sdk.Api.GraphQL.Enums;
 using Speckle.Sdk.Api.GraphQL.Inputs;
 using Speckle.Sdk.Api.GraphQL.Models;
 using Speckle.Sdk.Api.GraphQL.Resources;
@@ -49,6 +50,34 @@ public sealed class ModelIngestionResourceTests : IAsyncLifetime
     Assert.Equal(ingest.id, res.id);
   }
 
+  [Fact]
+  public async Task CreateAndUpdate()
+  {
+    var createInput = new ModelIngestionCreateInput(
+      _model.id,
+      _project.id,
+      "Starting processing",
+      new(".NET test runner", "0.0.0", null, null)
+    );
+    ModelIngestion ingest = await Sut.Create(createInput);
+
+    await Update(null, "None");
+    await Update(0.1, "0.1");
+    await Update(0.5, "Whoa-oh! We're half way there!");
+    await Update(1, "Finished");
+    await Update(0.2, "Back to processing again");
+
+    async Task Update(double? progress, string message)
+    {
+      var updateInput = new ModelIngestionUpdateInput(ingest.id, _project.id, message, progress);
+      var res = await Sut.UpdateProgress(updateInput);
+
+      Assert.Equal(message, res.statusData.progressMessage);
+      Assert.False(res.cancellationRequested);
+      Assert.Equal(ModelIngestionStatus.processing, res.statusData.status);
+    }
+  }
+
   [Fact]
   public async Task CreateAndCancel()
   {
@@ -103,7 +132,7 @@ public sealed class ModelIngestionResourceTests : IAsyncLifetime
     ModelIngestionSuccessInput finish = new(ingest.id, _project.id, sendResult.RootId);
     string versionId = await Sut.Complete(finish);
     Version version = await _testUser.Version.Get(versionId, _project.id);
-    Assert.Equal(versionId, version.id);
+    Assert.Equal(version.id, versionId);
     Assert.Equal(sendResult.RootId, version.referencedObject);
   }
 }

tests/Speckle.Sdk.Tests.Integration/Api/GraphQL/Resources/SubscriptionResourceTests.cs

@@ -135,4 +135,24 @@ public class SubscriptionResourceTests : IAsyncLifetime
     subscriptionMessage.type.Should().Be(ProjectCommentsUpdatedMessageType.CREATED);
     subscriptionMessage.comment.Should().NotBeNull();
   }
+
+  [Fact(Timeout = TIMEOUT)]
+  public async Task ProjectModelIngestionCancellationRequested_SubscriptionIsCalled()
+  {
+    ModelIngestion ingestion = await _testUser.Ingestion.Create(
+      new(_testModel.id, _testProject.id, "", new(".NET test", "0.0.0", null, null))
+    );
+    TaskCompletionSource<ProjectModelIngestionUpdatedMessage> tcs = new();
+    using var sub = Sut.CreateProjectModelIngestionCancellationRequestedSubscription(_testProject.id, ingestion.id);
+    sub.Listeners += (_, message) => tcs.SetResult(message);
+
+    await Task.Delay(WAIT_PERIOD); // Give time to subscription to be setup
+
+    await _testUser.Ingestion.RequestCancellation(new(ingestion.id, _testProject.id, "please cancel"));
+
+    var subscriptionMessage = await tcs.Task;
+
+    subscriptionMessage.Should().NotBeNull();
+    subscriptionMessage.modelIngestion.id.Should().Be(ingestion.id);
+  }
 }

tests/Speckle.Sdk.Tests.Integration/Fixtures.cs

@@ -21,7 +21,7 @@ namespace Speckle.Sdk.Tests.Integration;
 
 public static class Fixtures
 {
-  public static readonly ServerInfo Server = new() { url = "http://localhost:3000", name = "Docker Server" };
+  public static readonly ServerInfo Server = new() { url = "http://localhost", name = "Docker Server" };
 
   public static IServiceProvider ServiceProvider { get; set; }