kubernetes-client/csharp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix warnings for net8 (#1481)

Browse Source 
* fix ca2007

* xUnit1031

* fix ca2007

* fix ca2007

* remove deprecated ctor

* fix xUnit1031

* fix missing doc

* fix missing dispose

* fix ex
This commit is contained in:
Boshi Lian
2024-01-09 09:05:26 -08:00
committed by GitHub
parent f75c4aa484
commit f32cf9eab3
18 changed files with 180 additions and 206 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
tests/KubernetesClient.Tests/AuthTests.cs
View File

@@ -541,7 +541,7 @@ namespace k8s.Tests
var store = new Pkcs12Store();
store.Load(stream, new char[] { });
var keyAlias = store.Aliases.Cast<string>().SingleOrDefault(a => store.IsKeyEntry(a));
var keyAlias = store.Aliases.Cast<string>().SingleOrDefault(store.IsKeyEntry);
var key = (RsaPrivateCrtKeyParameters)store.GetKey(keyAlias).Key;
var bouncyCertificate = store.GetCertificate(keyAlias).Certificate;

8
tests/KubernetesClient.Tests/ByteBufferTests.cs
View File

@@ -255,7 +255,7 @@ namespace k8s.Tests
// Kick off a read operation
var readTask = Task.Run(() => read = buffer.Read(readData, 0, readData.Length));
await Task.Delay(250).ConfigureAwait(false);
await Task.Delay(250).ConfigureAwait(true);
Assert.False(readTask.IsCompleted, "Read task completed before data was available.");
// Write data to the buffer
@@ -264,7 +264,7 @@ namespace k8s.Tests
await TaskAssert.Completed(
readTask,
TimeSpan.FromMilliseconds(1000),
"Timed out waiting for read task to complete.").ConfigureAwait(false);
"Timed out waiting for read task to complete.").ConfigureAwait(true);
Assert.Equal(3, read);
Assert.Equal(0xF0, readData[0]);
@@ -411,10 +411,10 @@ namespace k8s.Tests
var output = new byte[buffer.Size + 1];
var readTask = Task.Run(() => buffer.Read(output, 0, output.Length));
await Task.Delay(TimeSpan.FromSeconds(1)).ConfigureAwait(false);
await Task.Delay(TimeSpan.FromSeconds(1)).ConfigureAwait(true);
buffer.Write(data, 0, data.Length);
await readTask.ConfigureAwait(false);
await readTask.ConfigureAwait(true);
}
#if NETCOREAPP2_0

2
tests/KubernetesClient.Tests/KubernetesClientConfigurationTests.cs
View File

@@ -437,7 +437,7 @@ namespace k8s.Tests
{
var path = Path.GetFullPath("assets/kubeconfig.cluster-extensions.yml");
_ = await KubernetesClientConfiguration.BuildConfigFromConfigFileAsync(new FileInfo(path)).ConfigureAwait(false);
_ = await KubernetesClientConfiguration.BuildConfigFromConfigFileAsync(new FileInfo(path)).ConfigureAwait(true);
}
[Fact]

6
tests/KubernetesClient.Tests/KubernetesExecTests.cs
View File

@@ -51,7 +51,7 @@ namespace k8s.Tests
{
{ "X-My-Header", new List<string>() { "myHeaderValue", "myHeaderValue2" } },
},
cancellationToken: CancellationToken.None).ConfigureAwait(false);
cancellationToken: CancellationToken.None).ConfigureAwait(true);
var expectedHeaders = new Dictionary<string, string>()
{
@@ -91,7 +91,7 @@ namespace k8s.Tests
{
{ "X-My-Header", new List<string>() { "myHeaderValue", "myHeaderValue2" } },
},
cancellationToken: CancellationToken.None).ConfigureAwait(false);
cancellationToken: CancellationToken.None).ConfigureAwait(true);
var expectedHeaders = new Dictionary<string, string>()
{
@@ -137,7 +137,7 @@ namespace k8s.Tests
{
{ "X-My-Header", new List<string>() { "myHeaderValue", "myHeaderValue2" } },
},
cancellationToken: CancellationToken.None).ConfigureAwait(false);
cancellationToken: CancellationToken.None).ConfigureAwait(true);
var expectedHeaders = new Dictionary<string, string>()
{

14
tests/KubernetesClient.Tests/KubernetesMetricsTests.cs
View File

@@ -35,7 +35,7 @@ namespace k8s.Tests
{
var client = new Kubernetes(new KubernetesClientConfiguration { Host = server.Uri.ToString() });
var nodesMetricsList = await client.GetKubernetesNodesMetricsAsync().ConfigureAwait(false);
var nodesMetricsList = await client.GetKubernetesNodesMetricsAsync().ConfigureAwait(true);
Assert.Single(nodesMetricsList.Items);
@@ -56,7 +56,7 @@ namespace k8s.Tests
var client = new Kubernetes(new KubernetesClientConfiguration { Host = server.Uri.ToString() });
// Should not throw with timespan optional property
var exception = await Record.ExceptionAsync(async () => await client.GetKubernetesNodesMetricsAsync().ConfigureAwait(false)).ConfigureAwait(false);
var exception = await Record.ExceptionAsync(client.GetKubernetesNodesMetricsAsync).ConfigureAwait(true);
Assert.Null(exception);
}
@@ -69,7 +69,7 @@ namespace k8s.Tests
{
var client = new Kubernetes(new KubernetesClientConfiguration { Host = server.Uri.ToString() });
var podsMetricsList = await client.GetKubernetesPodsMetricsAsync().ConfigureAwait(false);
var podsMetricsList = await client.GetKubernetesPodsMetricsAsync().ConfigureAwait(true);
Assert.Single(podsMetricsList.Items);
@@ -94,7 +94,7 @@ namespace k8s.Tests
var client = new Kubernetes(new KubernetesClientConfiguration { Host = server.Uri.ToString() });
// Should not throw with timespan optional property
var exception = await Record.ExceptionAsync(async () => await client.GetKubernetesPodsMetricsAsync().ConfigureAwait(false)).ConfigureAwait(false);
var exception = await Record.ExceptionAsync(client.GetKubernetesPodsMetricsAsync).ConfigureAwait(true);
Assert.Null(exception);
}
@@ -107,7 +107,7 @@ namespace k8s.Tests
{
var client = new Kubernetes(new KubernetesClientConfiguration { Host = server.Uri.ToString() });
var podsMetricsList = await client.GetKubernetesPodsMetricsByNamespaceAsync("empty").ConfigureAwait(false);
var podsMetricsList = await client.GetKubernetesPodsMetricsByNamespaceAsync("empty").ConfigureAwait(true);
Assert.Empty(podsMetricsList.Items);
}
@@ -122,7 +122,7 @@ namespace k8s.Tests
{
var client = new Kubernetes(new KubernetesClientConfiguration { Host = server.Uri.ToString() });
var podsMetricsList = await client.GetKubernetesPodsMetricsByNamespaceAsync(namespaceName).ConfigureAwait(false);
var podsMetricsList = await client.GetKubernetesPodsMetricsByNamespaceAsync(namespaceName).ConfigureAwait(true);
Assert.Single(podsMetricsList.Items);
@@ -147,7 +147,7 @@ namespace k8s.Tests
{
var client = new Kubernetes(new KubernetesClientConfiguration { Host = server.Uri.ToString() });
var podsMetricsList = await client.GetKubernetesPodsMetricsByNamespaceAsync("nonexisting").ConfigureAwait(false);
var podsMetricsList = await client.GetKubernetesPodsMetricsByNamespaceAsync("nonexisting").ConfigureAwait(true);
Assert.Empty(podsMetricsList.Items);
}

16
tests/KubernetesClient.Tests/KubernetesYamlTests.cs
View File

@@ -136,9 +136,9 @@ metadata:
var tempFileName = Path.GetTempFileName();
try
{
await File.WriteAllTextAsync(tempFileName, content).ConfigureAwait(false);
await File.WriteAllTextAsync(tempFileName, content).ConfigureAwait(true);
var objs = await KubernetesYaml.LoadAllFromFileAsync(tempFileName).ConfigureAwait(false);
var objs = await KubernetesYaml.LoadAllFromFileAsync(tempFileName).ConfigureAwait(true);
Assert.Equal(2, objs.Count);
Assert.IsType<V1Pod>(objs[0]);
Assert.IsType<V1Namespace>(objs[1]);
@@ -175,9 +175,9 @@ metadata:
var tempFileName = Path.GetTempFileName();
try
{
await File.WriteAllTextAsync(tempFileName, content).ConfigureAwait(false);
await File.WriteAllTextAsync(tempFileName, content).ConfigureAwait(true);
var objs = await KubernetesYaml.LoadAllFromFileAsync(tempFileName, types).ConfigureAwait(false);
var objs = await KubernetesYaml.LoadAllFromFileAsync(tempFileName, types).ConfigureAwait(true);
Assert.Equal(2, objs.Count);
Assert.IsType<MyPod>(objs[0]);
Assert.IsType<V1Namespace>(objs[1]);
@@ -282,7 +282,7 @@ spec:
}
[Fact]
public void LoadFromStream()
public async Task LoadFromStream()
{
var content = @"apiVersion: v1
kind: Pod
@@ -292,7 +292,7 @@ metadata:
using var stream = new MemoryStream(Encoding.UTF8.GetBytes(content));
var obj = KubernetesYaml.LoadFromStreamAsync<V1Pod>(stream).Result;
var obj = await KubernetesYaml.LoadFromStreamAsync<V1Pod>(stream).ConfigureAwait(true);
Assert.Equal("foo", obj.Metadata.Name);
}
@@ -309,9 +309,9 @@ metadata:
var tempFileName = Path.GetTempFileName();
try
{
await File.WriteAllTextAsync(tempFileName, content).ConfigureAwait(false);
await File.WriteAllTextAsync(tempFileName, content).ConfigureAwait(true);
var obj = await KubernetesYaml.LoadFromFileAsync<V1Pod>(tempFileName).ConfigureAwait(false);
var obj = await KubernetesYaml.LoadFromFileAsync<V1Pod>(tempFileName).ConfigureAwait(true);
Assert.Equal("foo", obj.Metadata.Name);
}
finally

22
tests/KubernetesClient.Tests/LeaderElection/LeaderElectionTests.cs
View File

@@ -55,7 +55,7 @@ namespace k8s.Tests.LeaderElection
};
var countdown = new CountdownEvent(2);
Task.Run(() =>
Task.Run(async () =>
{
var leaderElector = new LeaderElector(leaderElectionConfig);
@@ -71,7 +71,7 @@ namespace k8s.Tests.LeaderElection
countdown.Signal();
};
leaderElector.RunUntilLeadershipLostAsync().Wait();
await leaderElector.RunUntilLeadershipLostAsync().ConfigureAwait(true);
});
countdown.Wait(TimeSpan.FromSeconds(10));
@@ -147,7 +147,7 @@ namespace k8s.Tests.LeaderElection
var lockAStopLeading = new ManualResetEvent(false);
var testLeaderElectionLatch = new CountdownEvent(4);
Task.Run(() =>
Task.Run(async () =>
{
var leaderElector = new LeaderElector(leaderElectionConfigA);
@@ -164,13 +164,13 @@ namespace k8s.Tests.LeaderElection
lockAStopLeading.Set();
};
leaderElector.RunUntilLeadershipLostAsync().Wait();
await leaderElector.RunUntilLeadershipLostAsync().ConfigureAwait(true);
});
lockAStopLeading.WaitOne(TimeSpan.FromSeconds(3));
Task.Run(() =>
Task.Run(async () =>
{
var leaderElector = new LeaderElector(leaderElectionConfigB);
@@ -186,7 +186,7 @@ namespace k8s.Tests.LeaderElection
testLeaderElectionLatch.Signal();
};
leaderElector.RunUntilLeadershipLostAsync().Wait();
await leaderElector.RunUntilLeadershipLostAsync().ConfigureAwait(true);
});
testLeaderElectionLatch.Wait(TimeSpan.FromSeconds(15));
@@ -256,7 +256,7 @@ namespace k8s.Tests.LeaderElection
};
var countdown = new CountdownEvent(2);
Task.Run(() =>
Task.Run(async () =>
{
var leaderElector = new LeaderElector(leaderElectionConfig);
@@ -272,7 +272,7 @@ namespace k8s.Tests.LeaderElection
countdown.Signal();
};
leaderElector.RunUntilLeadershipLostAsync().Wait();
await leaderElector.RunUntilLeadershipLostAsync().ConfigureAwait(true);
});
countdown.Wait(TimeSpan.FromSeconds(15));
@@ -290,7 +290,7 @@ namespace k8s.Tests.LeaderElection
}
[Fact]
public void LeaderElectionThrowException()
public async Task LeaderElectionThrowException()
{
var l = new Mock<ILock>();
l.Setup(obj => obj.GetAsync(CancellationToken.None))
@@ -305,11 +305,11 @@ namespace k8s.Tests.LeaderElection
try
{
leaderElector.RunUntilLeadershipLostAsync().Wait();
await leaderElector.RunUntilLeadershipLostAsync().ConfigureAwait(true);
}
catch (Exception e)
{
Assert.Equal("noxu", e.InnerException?.Message);
Assert.Equal("noxu", e.Message);
return;
}

6
tests/KubernetesClient.Tests/OidcAuthTests.cs
View File

@@ -21,7 +21,7 @@ namespace k8s.Tests
// use unexpired id token as bearer, do not attempt to refresh
var auth = new OidcTokenProvider(clientId, clientSecret, idpIssuerUrl, unexpiredIdToken, refreshToken);
var result = await auth.GetAuthenticationHeaderAsync(CancellationToken.None).ConfigureAwait(false);
var result = await auth.GetAuthenticationHeaderAsync(CancellationToken.None).ConfigureAwait(true);
result.Scheme.Should().Be("Bearer");
result.Parameter.Should().Be(unexpiredIdToken);
@@ -29,7 +29,7 @@ namespace k8s.Tests
{
// attempt to refresh id token when expired
auth = new OidcTokenProvider(clientId, clientSecret, idpIssuerUrl, expiredIdToken, refreshToken);
result = await auth.GetAuthenticationHeaderAsync(CancellationToken.None).ConfigureAwait(false);
result = await auth.GetAuthenticationHeaderAsync(CancellationToken.None).ConfigureAwait(true);
result.Scheme.Should().Be("Bearer");
result.Parameter.Should().Be(expiredIdToken);
Assert.Fail("should not be here");
@@ -43,7 +43,7 @@ namespace k8s.Tests
{
// attempt to refresh id token when null
auth = new OidcTokenProvider(clientId, clientSecret, idpIssuerUrl, null, refreshToken);
result = await auth.GetAuthenticationHeaderAsync(CancellationToken.None).ConfigureAwait(false);
result = await auth.GetAuthenticationHeaderAsync(CancellationToken.None).ConfigureAwait(true);
result.Scheme.Should().Be("Bearer");
result.Parameter.Should().Be(expiredIdToken);
Assert.Fail("should not be here");

26
tests/KubernetesClient.Tests/PodExecTests.cs
View File

@@ -52,7 +52,7 @@ namespace k8s.Tests
TimeSpan.FromSeconds(5));
}
await Host.StartAsync(TestCancellation).ConfigureAwait(false);
await Host.StartAsync(TestCancellation).ConfigureAwait(true);
using (Kubernetes client = CreateTestClient())
{
@@ -67,7 +67,7 @@ namespace k8s.Tests
false,
true,
webSocketSubProtol: WebSocketProtocol.ChannelWebSocketProtocol,
cancellationToken: TestCancellation).ConfigureAwait(false);
cancellationToken: TestCancellation).ConfigureAwait(true);
Assert.Equal(
WebSocketProtocol.ChannelWebSocketProtocol,
clientSocket.SubProtocol); // For WebSockets, the Kubernetes API defaults to the binary channel (v1) protocol.
@@ -82,10 +82,10 @@ namespace k8s.Tests
const int STDOUT = 1;
const string expectedOutput = "This is text send to STDOUT.";
int bytesSent = await SendMultiplexed(serverSocket, STDOUT, expectedOutput).ConfigureAwait(false);
int bytesSent = await SendMultiplexed(serverSocket, STDOUT, expectedOutput).ConfigureAwait(true);
testOutput.WriteLine($"Sent {bytesSent} bytes to server socket; receiving from client socket...");
(string receivedText, byte streamIndex, int bytesReceived) = await ReceiveTextMultiplexed(clientSocket).ConfigureAwait(false);
(string receivedText, byte streamIndex, int bytesReceived) = await ReceiveTextMultiplexed(clientSocket).ConfigureAwait(true);
testOutput.WriteLine(
$"Received {bytesReceived} bytes from client socket ('{receivedText}', stream {streamIndex}).");
@@ -94,7 +94,7 @@ namespace k8s.Tests
await Disconnect(clientSocket, serverSocket,
WebSocketCloseStatus.NormalClosure,
"Normal Closure").ConfigureAwait(false);
"Normal Closure").ConfigureAwait(true);
WebSocketTestAdapter.CompleteTest();
}
@@ -204,8 +204,8 @@ namespace k8s.Tests
{
await Assert.ThrowsAsync<ArgumentNullException>(() => client.NamespacedPodExecAsync(
"pod-name",
"pod-namespace", "my-container", command, false, null, CancellationToken.None))
.ConfigureAwait(false);
"pod-namespace", "my-container", command, false, null, CancellationToken.None)).ConfigureAwait(true)
;
}
}
}
@@ -229,8 +229,8 @@ namespace k8s.Tests
{
var ex = await Assert.ThrowsAsync<KubernetesException>(() => client.NamespacedPodExecAsync(
"pod-name",
"pod-namespace", "my-container", command, false, handler, CancellationToken.None))
.ConfigureAwait(false);
"pod-namespace", "my-container", command, false, handler, CancellationToken.None)).ConfigureAwait(true)
;
Assert.Same(status, ex.Status);
}
}
@@ -254,7 +254,7 @@ namespace k8s.Tests
{
var ex = await Assert.ThrowsAsync<HttpOperationException>(() =>
client.NamespacedPodExecAsync("pod-name", "pod-namespace", "my-container", command, false, handler,
CancellationToken.None)).ConfigureAwait(false);
CancellationToken.None)).ConfigureAwait(true);
Assert.Same(exception, ex);
}
}
@@ -278,8 +278,8 @@ namespace k8s.Tests
{
var ex = await Assert.ThrowsAsync<Exception>(() => client.NamespacedPodExecAsync(
"pod-name",
"pod-namespace", "my-container", command, false, handler, CancellationToken.None))
.ConfigureAwait(false);
"pod-namespace", "my-container", command, false, handler, CancellationToken.None)).ConfigureAwait(true)
;
Assert.Same(exception, ex);
}
}
@@ -330,7 +330,7 @@ namespace k8s.Tests
using (Kubernetes client = kubernetesMock.Object)
{
var exitCode = await client.NamespacedPodExecAsync("pod-name", "pod-namespace", "my-container",
command, false, handler, CancellationToken.None).ConfigureAwait(false);
command, false, handler, CancellationToken.None).ConfigureAwait(true);
Assert.Equal(1, exitCode);
}
}

8
tests/KubernetesClient.Tests/SerializationTests.cs
View File

@@ -38,8 +38,8 @@ namespace k8s.Tests
var customObject = Animals.Dog;
var result = await client.CustomObjects.CreateNamespacedCustomObjectWithHttpMessagesAsync(customObject, "TestGroup", "TestVersion", "TestNamespace", "TestPlural").ConfigureAwait(false);
var content = await result.Request.Content.ReadAsStringAsync().ConfigureAwait(false);
var result = await client.CustomObjects.CreateNamespacedCustomObjectWithHttpMessagesAsync(customObject, "TestGroup", "TestVersion", "TestNamespace", "TestPlural").ConfigureAwait(true);
var content = await result.Request.Content.ReadAsStringAsync().ConfigureAwait(true);
// Assert that the client serializes using the default options.
Assert.Equal(@"""Dog""", content);
@@ -65,8 +65,8 @@ namespace k8s.Tests
var customObject = Animals.Dog;
var result = await client.CustomObjects.CreateNamespacedCustomObjectWithHttpMessagesAsync(customObject, "TestGroup", "TestVersion", "TestNamespace", "TestPlural").ConfigureAwait(false);
var content = await result.Request.Content.ReadAsStringAsync().ConfigureAwait(false);
var result = await client.CustomObjects.CreateNamespacedCustomObjectWithHttpMessagesAsync(customObject, "TestGroup", "TestVersion", "TestNamespace", "TestPlural").ConfigureAwait(true);
var content = await result.Request.Content.ReadAsStringAsync().ConfigureAwait(true);
// Assert that the client serializes using the specified options.
Assert.Equal(@"""dog""", content);

82
tests/KubernetesClient.Tests/StreamDemuxerTests.cs
View File

@@ -29,7 +29,7 @@ namespace k8s.Tests
// Send 100 bytes, expect 1 (channel index) + 100 (payload) = 101 bytes
Assert.True(
await WaitForAsync(() => sentBuffer.Count == 101).ConfigureAwait(false),
await WaitForAsync(() => sentBuffer.Count == 101).ConfigureAwait(true),
$"Demuxer error: expect to send 101 bytes, but actually send {sentBuffer.Count} bytes.");
Assert.True(sentBuffer[0] == channelIndex, "The first sent byte is not channel index!");
Assert.True(sentBuffer[1] == 0xEF, "Incorrect payload!");
@@ -56,7 +56,7 @@ namespace k8s.Tests
// Send 300 bytes in 2 messages, expect 1 (channel index) * 2 + 300 (payload) = 302 bytes
Assert.True(
await WaitForAsync(() => sentBuffer.Count == 302).ConfigureAwait(false),
await WaitForAsync(() => sentBuffer.Count == 302).ConfigureAwait(true),
$"Demuxer error: expect to send 302 bytes, but actually send {sentBuffer.Count} bytes.");
Assert.True(sentBuffer[0] == channelIndex, "The first sent byte is not channel index!");
Assert.True(sentBuffer[1] == 0xEF, "The first part of payload incorrect!");
@@ -84,21 +84,21 @@ namespace k8s.Tests
{
await ws.InvokeReceiveAsync(
new ArraySegment<byte>(GenerateRandomBuffer(100, channelIndex, 0xAA, false)),
WebSocketMessageType.Binary, true).ConfigureAwait(false);
WebSocketMessageType.Binary, true).ConfigureAwait(true);
await ws.InvokeReceiveAsync(
new ArraySegment<byte>(GenerateRandomBuffer(200, channelIndex, 0xAB, false)),
WebSocketMessageType.Binary, true).ConfigureAwait(false);
WebSocketMessageType.Binary, true).ConfigureAwait(true);
await ws.InvokeReceiveAsync(
new ArraySegment<byte>(GenerateRandomBuffer(300, channelIndex, 0xAC, false)),
WebSocketMessageType.Binary, true).ConfigureAwait(false);
WebSocketMessageType.Binary, true).ConfigureAwait(true);
await WaitForAsync(() => receivedBuffer.Count == expectedCount).ConfigureAwait(false);
await ws.CloseAsync(WebSocketCloseStatus.NormalClosure, "normal", CancellationToken.None).ConfigureAwait(false);
await WaitForAsync(() => receivedBuffer.Count == expectedCount).ConfigureAwait(true);
await ws.CloseAsync(WebSocketCloseStatus.NormalClosure, "normal", CancellationToken.None).ConfigureAwait(true);
});
var buffer = new byte[50];
while (true)
{
var cRead = await stream.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false);
var cRead = await stream.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(true);
if (cRead == 0)
{
break;
@@ -110,7 +110,7 @@ namespace k8s.Tests
}
}
await t.ConfigureAwait(false);
await t.ConfigureAwait(true);
Assert.True(
receivedBuffer.Count == expectedCount,
@@ -144,21 +144,21 @@ namespace k8s.Tests
{
await ws.InvokeReceiveAsync(
new ArraySegment<byte>(GenerateRandomBuffer(100, channelIndex, 0xB1, true)),
WebSocketMessageType.Binary, true).ConfigureAwait(false);
WebSocketMessageType.Binary, true).ConfigureAwait(true);
await ws.InvokeReceiveAsync(
new ArraySegment<byte>(GenerateRandomBuffer(200, channelIndex, 0xB2, false)),
WebSocketMessageType.Binary, true).ConfigureAwait(false);
WebSocketMessageType.Binary, true).ConfigureAwait(true);
await ws.InvokeReceiveAsync(
new ArraySegment<byte>(GenerateRandomBuffer(300, channelIndex, 0xB3, false)),
WebSocketMessageType.Binary, true).ConfigureAwait(false);
WebSocketMessageType.Binary, true).ConfigureAwait(true);
await WaitForAsync(() => receivedBuffer.Count == expectedCount).ConfigureAwait(false);
await ws.CloseAsync(WebSocketCloseStatus.NormalClosure, "normal", CancellationToken.None).ConfigureAwait(false);
await WaitForAsync(() => receivedBuffer.Count == expectedCount).ConfigureAwait(true);
await ws.CloseAsync(WebSocketCloseStatus.NormalClosure, "normal", CancellationToken.None).ConfigureAwait(true);
});
var buffer = new byte[50];
while (true)
{
var cRead = await stream.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false);
var cRead = await stream.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(true);
if (cRead == 0)
{
break;
@@ -170,7 +170,7 @@ namespace k8s.Tests
}
}
await t.ConfigureAwait(false);
await t.ConfigureAwait(true);
Assert.True(
receivedBuffer.Count == expectedCount,
@@ -204,21 +204,21 @@ namespace k8s.Tests
{
await ws.InvokeReceiveAsync(
new ArraySegment<byte>(GenerateRandomBuffer(2, channelIndex, 0xC1, true)),
WebSocketMessageType.Binary, false).ConfigureAwait(false);
WebSocketMessageType.Binary, false).ConfigureAwait(true);
await ws.InvokeReceiveAsync(
new ArraySegment<byte>(GenerateRandomBuffer(100, channelIndex, 0xC2, false)),
WebSocketMessageType.Binary, true).ConfigureAwait(false);
WebSocketMessageType.Binary, true).ConfigureAwait(true);
await ws.InvokeReceiveAsync(
new ArraySegment<byte>(GenerateRandomBuffer(300, channelIndex, 0xC3, false)),
WebSocketMessageType.Binary, true).ConfigureAwait(false);
WebSocketMessageType.Binary, true).ConfigureAwait(true);
await WaitForAsync(() => receivedBuffer.Count == expectedCount).ConfigureAwait(false);
await ws.CloseAsync(WebSocketCloseStatus.NormalClosure, "normal", CancellationToken.None).ConfigureAwait(false);
await WaitForAsync(() => receivedBuffer.Count == expectedCount).ConfigureAwait(true);
await ws.CloseAsync(WebSocketCloseStatus.NormalClosure, "normal", CancellationToken.None).ConfigureAwait(true);
});
var buffer = new byte[50];
while (true)
{
var cRead = await stream.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false);
var cRead = await stream.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(true);
if (cRead == 0)
{
break;
@@ -230,7 +230,7 @@ namespace k8s.Tests
}
}
await t.ConfigureAwait(false);
await t.ConfigureAwait(true);
Assert.True(
receivedBuffer.Count == expectedCount,
@@ -268,24 +268,24 @@ namespace k8s.Tests
// Simulate WebSocket received remote data to multiple streams
await ws.InvokeReceiveAsync(
new ArraySegment<byte>(GenerateRandomBuffer(100, channelIndex1, 0xD1, false)),
WebSocketMessageType.Binary, true).ConfigureAwait(false);
WebSocketMessageType.Binary, true).ConfigureAwait(true);
await ws.InvokeReceiveAsync(
new ArraySegment<byte>(GenerateRandomBuffer(200, channelIndex2, 0xD2, false)),
WebSocketMessageType.Binary, true).ConfigureAwait(false);
WebSocketMessageType.Binary, true).ConfigureAwait(true);
await ws.InvokeReceiveAsync(
new ArraySegment<byte>(GenerateRandomBuffer(300, channelIndex1, 0xD3, false)),
WebSocketMessageType.Binary, true).ConfigureAwait(false);
WebSocketMessageType.Binary, true).ConfigureAwait(true);
await WaitForAsync(() => receivedBuffer1.Count == expectedCount1).ConfigureAwait(false);
await WaitForAsync(() => receivedBuffer2.Count == expectedCount2).ConfigureAwait(false);
await ws.CloseAsync(WebSocketCloseStatus.NormalClosure, "normal", CancellationToken.None).ConfigureAwait(false);
await WaitForAsync(() => receivedBuffer1.Count == expectedCount1).ConfigureAwait(true);
await WaitForAsync(() => receivedBuffer2.Count == expectedCount2).ConfigureAwait(true);
await ws.CloseAsync(WebSocketCloseStatus.NormalClosure, "normal", CancellationToken.None).ConfigureAwait(true);
});
var t2 = Task.Run(async () =>
{
var buffer = new byte[50];
while (true)
{
var cRead = await stream1.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false);
var cRead = await stream1.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(true);
if (cRead == 0)
{
break;
@@ -302,7 +302,7 @@ namespace k8s.Tests
var buffer = new byte[50];
while (true)
{
var cRead = await stream2.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false);
var cRead = await stream2.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(true);
if (cRead == 0)
{
break;
@@ -314,7 +314,7 @@ namespace k8s.Tests
}
}
});
await Task.WhenAll(t1, t2, t3).ConfigureAwait(false);
await Task.WhenAll(t1, t2, t3).ConfigureAwait(true);
Assert.True(
receivedBuffer1.Count == expectedCount1,
@@ -359,24 +359,24 @@ namespace k8s.Tests
// Simulate WebSocket received remote data to multiple streams
await ws.InvokeReceiveAsync(
new ArraySegment<byte>(GenerateRandomBuffer(100, channelIndex1, 0xE1, true)),
WebSocketMessageType.Binary, true).ConfigureAwait(false);
WebSocketMessageType.Binary, true).ConfigureAwait(true);
await ws.InvokeReceiveAsync(
new ArraySegment<byte>(GenerateRandomBuffer(200, channelIndex2, 0xE2, true)),
WebSocketMessageType.Binary, true).ConfigureAwait(false);
WebSocketMessageType.Binary, true).ConfigureAwait(true);
await ws.InvokeReceiveAsync(
new ArraySegment<byte>(GenerateRandomBuffer(300, channelIndex1, 0xE3, false)),
WebSocketMessageType.Binary, true).ConfigureAwait(false);
WebSocketMessageType.Binary, true).ConfigureAwait(true);
await WaitForAsync(() => receivedBuffer1.Count == expectedCount1).ConfigureAwait(false);
await WaitForAsync(() => receivedBuffer2.Count == expectedCount2).ConfigureAwait(false);
await ws.CloseAsync(WebSocketCloseStatus.NormalClosure, "normal", CancellationToken.None).ConfigureAwait(false);
await WaitForAsync(() => receivedBuffer1.Count == expectedCount1).ConfigureAwait(true);
await WaitForAsync(() => receivedBuffer2.Count == expectedCount2).ConfigureAwait(true);
await ws.CloseAsync(WebSocketCloseStatus.NormalClosure, "normal", CancellationToken.None).ConfigureAwait(true);
});
var t2 = Task.Run(async () =>
{
var buffer = new byte[50];
while (true)
{
var cRead = await stream1.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false);
var cRead = await stream1.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(true);
if (cRead == 0)
{
break;
@@ -393,7 +393,7 @@ namespace k8s.Tests
var buffer = new byte[50];
while (true)
{
var cRead = await stream2.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false);
var cRead = await stream2.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(true);
if (cRead == 0)
{
break;
@@ -405,7 +405,7 @@ namespace k8s.Tests
}
}
});
await Task.WhenAll(t1, t2, t3).ConfigureAwait(false);
await Task.WhenAll(t1, t2, t3).ConfigureAwait(true);
Assert.True(
receivedBuffer1.Count == expectedCount1,

6
tests/KubernetesClient.Tests/TokenFileAuthTests.cs
View File

@@ -13,17 +13,17 @@ namespace k8s.Tests
public async Task TestToken()
{
var auth = new TokenFileAuth("assets/token1");
var result = await auth.GetAuthenticationHeaderAsync(CancellationToken.None).ConfigureAwait(false);
var result = await auth.GetAuthenticationHeaderAsync(CancellationToken.None).ConfigureAwait(true);
result.Scheme.Should().Be("Bearer");
result.Parameter.Should().Be("token1");
auth.TokenFile = "assets/token2";
result = await auth.GetAuthenticationHeaderAsync(CancellationToken.None).ConfigureAwait(false);
result = await auth.GetAuthenticationHeaderAsync(CancellationToken.None).ConfigureAwait(true);
result.Scheme.Should().Be("Bearer");
result.Parameter.Should().Be("token1");
auth.TokenExpiresAt = DateTime.UtcNow.AddSeconds(-1);
result = await auth.GetAuthenticationHeaderAsync(CancellationToken.None).ConfigureAwait(false);
result = await auth.GetAuthenticationHeaderAsync(CancellationToken.None).ConfigureAwait(true);
result.Scheme.Should().Be("Bearer");
result.Parameter.Should().Be("token2");
}

146
tests/KubernetesClient.Tests/WatchTests.cs
View File

@@ -59,7 +59,7 @@ namespace k8s.Tests
using (listTask.Watch<V1Pod, V1PodList>((type, item) => { }, e => { onErrorCalled = true; }))
{
await Task.Delay(TimeSpan.FromSeconds(1)).ConfigureAwait(false); // delay for onerror to be called
await Task.Delay(TimeSpan.FromSeconds(1)).ConfigureAwait(true); // delay for onerror to be called
}
Assert.True(onErrorCalled);
@@ -72,7 +72,7 @@ namespace k8s.Tests
// this line did not throw
// listTask.Watch<Corev1Pod>((type, item) => { });
}).ConfigureAwait(false);
}).ConfigureAwait(true);
}
}
@@ -85,8 +85,8 @@ namespace k8s.Tests
using (var server = new MockKubeApiServer(testOutput, async httpContext =>
{
// block until reponse watcher obj created
await created.WaitAsync().ConfigureAwait(false);
await WriteStreamLine(httpContext, MockAddedEventStreamLine).ConfigureAwait(false);
await created.WaitAsync().ConfigureAwait(true);
await WriteStreamLine(httpContext, MockAddedEventStreamLine).ConfigureAwait(true);
return false;
}))
{
@@ -98,7 +98,7 @@ namespace k8s.Tests
{
// here watcher is ready to use, but http server has not responsed yet.
created.Set();
await Task.WhenAny(eventsReceived.WaitAsync(), Task.Delay(TestTimeout)).ConfigureAwait(false);
await Task.WhenAny(eventsReceived.WaitAsync(), Task.Delay(TestTimeout)).ConfigureAwait(true);
}
Assert.True(eventsReceived.IsSet);
@@ -121,20 +121,20 @@ namespace k8s.Tests
httpContext.Response.StatusCode = (int)HttpStatusCode.OK;
httpContext.Response.ContentLength = null;
await WriteStreamLine(httpContext, MockKubeApiServer.MockPodResponse).ConfigureAwait(false);
await WriteStreamLine(httpContext, MockBadStreamLine).ConfigureAwait(false);
await WriteStreamLine(httpContext, MockAddedEventStreamLine).ConfigureAwait(false);
await WriteStreamLine(httpContext, MockBadStreamLine).ConfigureAwait(false);
await WriteStreamLine(httpContext, MockModifiedStreamLine).ConfigureAwait(false);
await WriteStreamLine(httpContext, MockKubeApiServer.MockPodResponse).ConfigureAwait(true);
await WriteStreamLine(httpContext, MockBadStreamLine).ConfigureAwait(true);
await WriteStreamLine(httpContext, MockAddedEventStreamLine).ConfigureAwait(true);
await WriteStreamLine(httpContext, MockBadStreamLine).ConfigureAwait(true);
await WriteStreamLine(httpContext, MockModifiedStreamLine).ConfigureAwait(true);
// make server alive, cannot set to int.max as of it would block response
await serverShutdown.WaitAsync().ConfigureAwait(false);
await serverShutdown.WaitAsync().ConfigureAwait(true);
return false;
}))
{
var client = new Kubernetes(new KubernetesClientConfiguration { Host = server.Uri.ToString() });
var listTask = await client.CoreV1.ListNamespacedPodWithHttpMessagesAsync("default", watch: true).ConfigureAwait(false);
var listTask = await client.CoreV1.ListNamespacedPodWithHttpMessagesAsync("default", watch: true).ConfigureAwait(true);
var events = new HashSet<WatchEventType>();
var errors = 0;
@@ -157,7 +157,7 @@ namespace k8s.Tests
connectionClosed.Set);
// wait server yields all events
await Task.WhenAny(eventsReceived.WaitAsync(), Task.Delay(TestTimeout)).ConfigureAwait(false);
await Task.WhenAny(eventsReceived.WaitAsync(), Task.Delay(TestTimeout)).ConfigureAwait(true);
Assert.True(
eventsReceived.CurrentCount == 0,
@@ -173,7 +173,7 @@ namespace k8s.Tests
// Let the server know it can initiate a shut down.
serverShutdown.Set();
await Task.WhenAny(connectionClosed.WaitAsync(), Task.Delay(TestTimeout)).ConfigureAwait(false);
await Task.WhenAny(connectionClosed.WaitAsync(), Task.Delay(TestTimeout)).ConfigureAwait(true);
Assert.True(connectionClosed.IsSet);
}
}
@@ -187,15 +187,15 @@ namespace k8s.Tests
using (var server = new MockKubeApiServer(testOutput, async httpContext =>
{
await WriteStreamLine(httpContext, MockAddedEventStreamLine).ConfigureAwait(false);
await serverShutdown.WaitAsync().ConfigureAwait(false);
await WriteStreamLine(httpContext, MockAddedEventStreamLine).ConfigureAwait(true);
await serverShutdown.WaitAsync().ConfigureAwait(true);
return false;
}))
{
var client = new Kubernetes(new KubernetesClientConfiguration { Host = server.Uri.ToString() });
var listTask = await client.CoreV1.ListNamespacedPodWithHttpMessagesAsync("default", watch: true).ConfigureAwait(false);
var listTask = await client.CoreV1.ListNamespacedPodWithHttpMessagesAsync("default", watch: true).ConfigureAwait(true);
var events = new HashSet<WatchEventType>();
@@ -212,7 +212,7 @@ namespace k8s.Tests
onClosed: connectionClosed.Set);
// wait at least an event
await Task.WhenAny(eventsReceived.WaitAsync(), Task.Delay(TestTimeout)).ConfigureAwait(false);
await Task.WhenAny(eventsReceived.WaitAsync(), Task.Delay(TestTimeout)).ConfigureAwait(true);
Assert.True(
eventsReceived.CurrentCount == 0,
"Timed out waiting for events.");
@@ -224,7 +224,7 @@ namespace k8s.Tests
events.Clear();
await Task.WhenAny(connectionClosed.WaitAsync(), Task.Delay(TestTimeout)).ConfigureAwait(false);
await Task.WhenAny(connectionClosed.WaitAsync(), Task.Delay(TestTimeout)).ConfigureAwait(true);
Assert.False(watcher.Watching);
Assert.True(connectionClosed.IsSet);
@@ -243,19 +243,19 @@ namespace k8s.Tests
using (var server = new MockKubeApiServer(testOutput, async httpContext =>
{
await WriteStreamLine(httpContext, MockAddedEventStreamLine).ConfigureAwait(false);
await WriteStreamLine(httpContext, MockDeletedStreamLine).ConfigureAwait(false);
await WriteStreamLine(httpContext, MockModifiedStreamLine).ConfigureAwait(false);
await WriteStreamLine(httpContext, MockErrorStreamLine).ConfigureAwait(false);
await WriteStreamLine(httpContext, MockAddedEventStreamLine).ConfigureAwait(true);
await WriteStreamLine(httpContext, MockDeletedStreamLine).ConfigureAwait(true);
await WriteStreamLine(httpContext, MockModifiedStreamLine).ConfigureAwait(true);
await WriteStreamLine(httpContext, MockErrorStreamLine).ConfigureAwait(true);
// make server alive, cannot set to int.max as of it would block response
await serverShutdown.WaitAsync().ConfigureAwait(false);
await serverShutdown.WaitAsync().ConfigureAwait(true);
return false;
}))
{
var client = new Kubernetes(new KubernetesClientConfiguration { Host = server.Uri.ToString() });
var listTask = await client.CoreV1.ListNamespacedPodWithHttpMessagesAsync("default", watch: true).ConfigureAwait(false);
var listTask = await client.CoreV1.ListNamespacedPodWithHttpMessagesAsync("default", watch: true).ConfigureAwait(true);
var events = new HashSet<WatchEventType>();
var errors = 0;
@@ -278,7 +278,7 @@ namespace k8s.Tests
waitForClosed.Set);
// wait server yields all events
await Task.WhenAny(eventsReceived.WaitAsync(), Task.Delay(TestTimeout)).ConfigureAwait(false);
await Task.WhenAny(eventsReceived.WaitAsync(), Task.Delay(TestTimeout)).ConfigureAwait(true);
Assert.True(
eventsReceived.CurrentCount == 0,
@@ -295,7 +295,7 @@ namespace k8s.Tests
serverShutdown.Set();
await Task.WhenAny(waitForClosed.WaitAsync(), Task.Delay(TestTimeout)).ConfigureAwait(false);
await Task.WhenAny(waitForClosed.WaitAsync(), Task.Delay(TestTimeout)).ConfigureAwait(true);
Assert.True(waitForClosed.IsSet);
Assert.False(watcher.Watching);
}
@@ -310,21 +310,21 @@ namespace k8s.Tests
using (var server = new MockKubeApiServer(testOutput, async httpContext =>
{
await WriteStreamLine(httpContext, MockKubeApiServer.MockPodResponse).ConfigureAwait(false);
await Task.Delay(TimeSpan.FromSeconds(120)).ConfigureAwait(false); // The default timeout is 100 seconds
await WriteStreamLine(httpContext, MockAddedEventStreamLine).ConfigureAwait(false);
await WriteStreamLine(httpContext, MockDeletedStreamLine).ConfigureAwait(false);
await WriteStreamLine(httpContext, MockModifiedStreamLine).ConfigureAwait(false);
await WriteStreamLine(httpContext, MockErrorStreamLine).ConfigureAwait(false);
await WriteStreamLine(httpContext, MockKubeApiServer.MockPodResponse).ConfigureAwait(true);
await Task.Delay(TimeSpan.FromSeconds(120)).ConfigureAwait(true); // The default timeout is 100 seconds
await WriteStreamLine(httpContext, MockAddedEventStreamLine).ConfigureAwait(true);
await WriteStreamLine(httpContext, MockDeletedStreamLine).ConfigureAwait(true);
await WriteStreamLine(httpContext, MockModifiedStreamLine).ConfigureAwait(true);
await WriteStreamLine(httpContext, MockErrorStreamLine).ConfigureAwait(true);
// make server alive, cannot set to int.max as of it would block response
await serverShutdown.WaitAsync().ConfigureAwait(false);
await serverShutdown.WaitAsync().ConfigureAwait(true);
return false;
}))
{
var client = new Kubernetes(new KubernetesClientConfiguration { Host = server.Uri.ToString() });
var listTask = await client.CoreV1.ListNamespacedPodWithHttpMessagesAsync("default", watch: true).ConfigureAwait(false);
var listTask = await client.CoreV1.ListNamespacedPodWithHttpMessagesAsync("default", watch: true).ConfigureAwait(true);
var events = new HashSet<WatchEventType>();
var errors = 0;
@@ -347,7 +347,7 @@ namespace k8s.Tests
connectionClosed.Set);
// wait server yields all events
await Task.WhenAny(eventsReceived.WaitAsync(), Task.Delay(TestTimeout)).ConfigureAwait(false);
await Task.WhenAny(eventsReceived.WaitAsync(), Task.Delay(TestTimeout)).ConfigureAwait(true);
Assert.True(
eventsReceived.CurrentCount == 0,
@@ -364,7 +364,7 @@ namespace k8s.Tests
serverShutdown.Set();
await Task.WhenAny(connectionClosed.WaitAsync(), Task.Delay(TestTimeout)).ConfigureAwait(false);
await Task.WhenAny(connectionClosed.WaitAsync(), Task.Delay(TestTimeout)).ConfigureAwait(true);
Assert.True(connectionClosed.IsSet);
}
}
@@ -379,14 +379,14 @@ namespace k8s.Tests
using (var server = new MockKubeApiServer(testOutput, async httpContext =>
{
await WriteStreamLine(httpContext, MockKubeApiServer.MockPodResponse).ConfigureAwait(false);
await waitForException.WaitAsync().ConfigureAwait(false);
await WriteStreamLine(httpContext, MockKubeApiServer.MockPodResponse).ConfigureAwait(true);
await waitForException.WaitAsync().ConfigureAwait(true);
throw new IOException("server down");
}))
{
var client = new Kubernetes(new KubernetesClientConfiguration { Host = server.Uri.ToString() });
var listTask = await client.CoreV1.ListNamespacedPodWithHttpMessagesAsync("default", watch: true).ConfigureAwait(false);
var listTask = await client.CoreV1.ListNamespacedPodWithHttpMessagesAsync("default", watch: true).ConfigureAwait(true);
waitForException.Set();
Watcher<V1Pod> watcher;
@@ -400,13 +400,13 @@ namespace k8s.Tests
waitForClosed.Set);
// wait server down
await Task.WhenAny(exceptionReceived.WaitAsync(), Task.Delay(TestTimeout)).ConfigureAwait(false);
await Task.WhenAny(exceptionReceived.WaitAsync(), Task.Delay(TestTimeout)).ConfigureAwait(true);
Assert.True(
exceptionReceived.IsSet,
"Timed out waiting for exception");
await Task.WhenAny(waitForClosed.WaitAsync(), Task.Delay(TestTimeout)).ConfigureAwait(false);
await Task.WhenAny(waitForClosed.WaitAsync(), Task.Delay(TestTimeout)).ConfigureAwait(true);
Assert.True(waitForClosed.IsSet);
Assert.False(watcher.Watching);
@@ -439,11 +439,11 @@ namespace k8s.Tests
using (var server = new MockKubeApiServer(testOutput, async httpContext =>
{
await WriteStreamLine(httpContext, MockKubeApiServer.MockPodResponse).ConfigureAwait(false);
await WriteStreamLine(httpContext, MockAddedEventStreamLine).ConfigureAwait(false);
await WriteStreamLine(httpContext, MockKubeApiServer.MockPodResponse).ConfigureAwait(true);
await WriteStreamLine(httpContext, MockAddedEventStreamLine).ConfigureAwait(true);
// make server alive, cannot set to int.max as of it would block response
await serverShutdown.WaitAsync().ConfigureAwait(false);
await serverShutdown.WaitAsync().ConfigureAwait(true);
return false;
}))
{
@@ -456,7 +456,7 @@ namespace k8s.Tests
Assert.False(handler1.Called);
Assert.False(handler2.Called);
var listTask = await client.CoreV1.ListNamespacedPodWithHttpMessagesAsync("default", watch: true).ConfigureAwait(false);
var listTask = await client.CoreV1.ListNamespacedPodWithHttpMessagesAsync("default", watch: true).ConfigureAwait(true);
var events = new HashSet<WatchEventType>();
@@ -468,7 +468,7 @@ namespace k8s.Tests
});
// wait server yields all events
await Task.WhenAny(eventsReceived.WaitAsync(), Task.Delay(TestTimeout)).ConfigureAwait(false);
await Task.WhenAny(eventsReceived.WaitAsync(), Task.Delay(TestTimeout)).ConfigureAwait(true);
Assert.True(
eventsReceived.CurrentCount == 0,
@@ -492,13 +492,13 @@ namespace k8s.Tests
using (var server = new MockKubeApiServer(testOutput, async httpContext =>
{
await WriteStreamLine(httpContext, MockAddedEventStreamLine).ConfigureAwait(false);
await WriteStreamLine(httpContext, MockDeletedStreamLine).ConfigureAwait(false);
await WriteStreamLine(httpContext, MockModifiedStreamLine).ConfigureAwait(false);
await WriteStreamLine(httpContext, MockErrorStreamLine).ConfigureAwait(false);
await WriteStreamLine(httpContext, MockAddedEventStreamLine).ConfigureAwait(true);
await WriteStreamLine(httpContext, MockDeletedStreamLine).ConfigureAwait(true);
await WriteStreamLine(httpContext, MockModifiedStreamLine).ConfigureAwait(true);
await WriteStreamLine(httpContext, MockErrorStreamLine).ConfigureAwait(true);
// make server alive, cannot set to int.max as of it would block response
await serverShutdown.WaitAsync().ConfigureAwait(false);
await serverShutdown.WaitAsync().ConfigureAwait(true);
return false;
}))
{
@@ -527,7 +527,7 @@ namespace k8s.Tests
onClosed: connectionClosed.Set);
// wait server yields all events
await Task.WhenAny(eventsReceived.WaitAsync(), Task.Delay(TestTimeout)).ConfigureAwait(false);
await Task.WhenAny(eventsReceived.WaitAsync(), Task.Delay(TestTimeout)).ConfigureAwait(true);
Assert.True(
eventsReceived.CurrentCount == 0,
@@ -544,7 +544,7 @@ namespace k8s.Tests
serverShutdown.Set();
await Task.WhenAny(connectionClosed.WaitAsync(), Task.Delay(TestTimeout)).ConfigureAwait(false);
await Task.WhenAny(connectionClosed.WaitAsync(), Task.Delay(TestTimeout)).ConfigureAwait(true);
Assert.True(connectionClosed.IsSet);
}
}
@@ -554,8 +554,8 @@ namespace k8s.Tests
{
using var server = new MockKubeApiServer(testOutput, async httpContext =>
{
await Task.Delay(TimeSpan.FromSeconds(120)).ConfigureAwait(false); // The default timeout is 100 seconds
await WriteStreamLine(httpContext, MockKubeApiServer.MockPodResponse).ConfigureAwait(false);
await Task.Delay(TimeSpan.FromSeconds(120)).ConfigureAwait(true); // The default timeout is 100 seconds
await WriteStreamLine(httpContext, MockKubeApiServer.MockPodResponse).ConfigureAwait(true);
return false;
});
@@ -568,8 +568,8 @@ namespace k8s.Tests
Host = server.Uri.ToString(),
HttpClientTimeout = TimeSpan.FromSeconds(5),
});
await client.CoreV1.ListNamespacedPodWithHttpMessagesAsync("default").ConfigureAwait(false);
}).ConfigureAwait(false);
await client.CoreV1.ListNamespacedPodWithHttpMessagesAsync("default").ConfigureAwait(true);
}).ConfigureAwait(true);
// cts
await Assert.ThrowsAsync<TaskCanceledException>(async () =>
@@ -580,8 +580,8 @@ namespace k8s.Tests
{
Host = server.Uri.ToString(),
});
await client.CoreV1.ListNamespacedPodWithHttpMessagesAsync("default", cancellationToken: cts.Token).ConfigureAwait(false);
}).ConfigureAwait(false);
await client.CoreV1.ListNamespacedPodWithHttpMessagesAsync("default", cancellationToken: cts.Token).ConfigureAwait(true);
}).ConfigureAwait(true);
}
[Fact]
@@ -592,14 +592,14 @@ namespace k8s.Tests
using (var server = new MockKubeApiServer(testOutput, async httpContext =>
{
await Task.Delay(TimeSpan.FromSeconds(120)).ConfigureAwait(false); // The default timeout is 100 seconds
await WriteStreamLine(httpContext, MockAddedEventStreamLine).ConfigureAwait(false);
await WriteStreamLine(httpContext, MockDeletedStreamLine).ConfigureAwait(false);
await WriteStreamLine(httpContext, MockModifiedStreamLine).ConfigureAwait(false);
await WriteStreamLine(httpContext, MockErrorStreamLine).ConfigureAwait(false);
await Task.Delay(TimeSpan.FromSeconds(120)).ConfigureAwait(true); // The default timeout is 100 seconds
await WriteStreamLine(httpContext, MockAddedEventStreamLine).ConfigureAwait(true);
await WriteStreamLine(httpContext, MockDeletedStreamLine).ConfigureAwait(true);
await WriteStreamLine(httpContext, MockModifiedStreamLine).ConfigureAwait(true);
await WriteStreamLine(httpContext, MockErrorStreamLine).ConfigureAwait(true);
// make server alive, cannot set to int.max as of it would block response
await serverShutdown.WaitAsync().ConfigureAwait(false);
await serverShutdown.WaitAsync().ConfigureAwait(true);
return false;
}))
{
@@ -627,7 +627,7 @@ namespace k8s.Tests
});
// wait server yields all events
await Task.WhenAny(eventsReceived.WaitAsync(), Task.Delay(TestTimeout)).ConfigureAwait(false);
await Task.WhenAny(eventsReceived.WaitAsync(), Task.Delay(TestTimeout)).ConfigureAwait(true);
Assert.True(
eventsReceived.CurrentCount == 0,
@@ -654,8 +654,8 @@ namespace k8s.Tests
using (var server = new MockKubeApiServer(testOutput, async httpContext =>
{
httpContext.Response.StatusCode = 200;
await httpContext.Response.Body.FlushAsync().ConfigureAwait(false);
await Task.Delay(TimeSpan.FromSeconds(5)).ConfigureAwait(false); // The default timeout is 100 seconds
await httpContext.Response.Body.FlushAsync().ConfigureAwait(true);
await Task.Delay(TimeSpan.FromSeconds(5)).ConfigureAwait(true); // The default timeout is 100 seconds
return true;
}, resp: ""))
@@ -668,8 +668,8 @@ namespace k8s.Tests
await Assert.ThrowsAnyAsync<OperationCanceledException>(async () =>
{
await client.CoreV1.ListNamespacedPodWithHttpMessagesAsync("default", watch: true,
cancellationToken: cts.Token).ConfigureAwait(false);
}).ConfigureAwait(false);
cancellationToken: cts.Token).ConfigureAwait(true);
}).ConfigureAwait(true);
}
}
@@ -733,7 +733,7 @@ namespace k8s.Tests
{
var server = new MockKubeApiServer(testOutput, async httpContext =>
{
await WriteStreamLine(httpContext, MockAddedEventStreamLine).ConfigureAwait(false);
await WriteStreamLine(httpContext, MockAddedEventStreamLine).ConfigureAwait(true);
return false;
});
@@ -742,7 +742,7 @@ namespace k8s.Tests
new KubernetesClientConfiguration { Host = server.Uri.ToString() }, handler);
Assert.Null(handler.Version);
await client.CoreV1.ListNamespacedPodWithHttpMessagesAsync("default", watch: true).ConfigureAwait(false);
await client.CoreV1.ListNamespacedPodWithHttpMessagesAsync("default", watch: true).ConfigureAwait(true);
Assert.Equal(HttpVersion.Version20, handler.Version);
}
}