public async Task MonitorEventsAsync_Succeeds()
        {
            var newTag = $"MonitorTests-{Guid.NewGuid().ToString().Substring(1, 10)}";

            var progressJSONMessage = new Progress <JSONMessage>((m) =>
            {
                // Status could be 'Pulling from...'
                Assert.NotNull(m);
                _output.WriteLine($"MonitorEventsAsync_Succeeds: JSONMessage - {m.ID} - {m.Status} {m.From} - {m.Stream}");
            });

            var wasProgressCalled = false;

            var progressMessage = new Progress <Message>((m) =>
            {
                _output.WriteLine($"MonitorEventsAsync_Succeeds: Message - {m.Action} - {m.Status} {m.From} - {m.Type}");
                wasProgressCalled = true;
                Assert.NotNull(m);
            });

            using var cts = CancellationTokenSource.CreateLinkedTokenSource(_cts.Token);

            var task = _client.System.MonitorEventsAsync(
                new ContainerEventsParameters(),
                progressMessage,
                cts.Token);

            await _client.Images.CreateImageAsync(new ImagesCreateParameters { FromImage = $"{_repositoryName}:{_tag}" }, null, progressJSONMessage, _cts.Token);

            await _client.Images.TagImageAsync($"{_repositoryName}:{_tag}", new ImageTagParameters { RepositoryName = _repositoryName, Tag = newTag }, _cts.Token);

            await _client.Images.DeleteImageAsync(
                name : $"{_repositoryName}:{newTag}",
                new ImageDeleteParameters
            {
                Force = true
            },
                _cts.Token);

            // Give it some time for output operation to complete before cancelling task
            await Task.Delay(TimeSpan.FromSeconds(1));

            cts.Cancel();

            await Assert.ThrowsAsync <TaskCanceledException>(() => task).ConfigureAwait(false);

            Assert.True(wasProgressCalled);
        }
Exemple #2
0
        public async Task CreateImageAsync_TaskCancelled_ThowsTaskCanceledException()
        {
            using var cts = CancellationTokenSource.CreateLinkedTokenSource(_cts.Token);

            var newTag            = Guid.NewGuid().ToString();
            var newRepositoryName = Guid.NewGuid().ToString();

            await _dockerClient.Images.TagImageAsync(
                $"{_repositoryName}:{_tag}",
                new ImageTagParameters
            {
                RepositoryName = newRepositoryName,
                Tag            = newTag,
                Force          = true
            },
                cts.Token
                );

            var createImageTask = _dockerClient.Images.CreateImageAsync(
                new ImagesCreateParameters
            {
                FromImage = $"{newRepositoryName}:{newTag}"
            },
                null,
                new Progress <JSONMessage>((message) => _output.WriteLine(JsonConvert.SerializeObject(message))),
                cts.Token);

            TimeSpan delay = TimeSpan.FromMilliseconds(5);

            cts.CancelAfter(delay);

            await Assert.ThrowsAsync <TaskCanceledException>(() => createImageTask);

            Assert.True(createImageTask.IsCanceled);
        }