public async Task ReconcileAsync_Exception_LogsError_Async()
{
var kubernetes = new Mock <KubernetesClient>();
var sessions = kubernetes.WithClient <WebDriverSession>();
var pods = kubernetes.WithClient <V1Pod>();
pods.Setup(p => p.CreateAsync(It.IsAny <V1Pod>(), default)).ThrowsAsync(new NotSupportedException());
var loggerFactory = this.services.GetRequiredService <ILoggerFactory>();
var sink = this.services.GetRequiredService <ITestLoggerSink>();
using (var @operator = new ChildOperator <WebDriverSession, V1Pod>(
kubernetes.Object,
this.configuration,
this.filter,
(session, pod) => { },
this.feedbackLoops,
loggerFactory.CreateLogger <ChildOperator <WebDriverSession, V1Pod> >(),
this.services))
{
var parent = new WebDriverSession()
{
Metadata = new V1ObjectMeta(),
};
await @operator.ReconcileAsync(parent, null, default).ConfigureAwait(false);
}
Assert.Collection(
sink.LogEntries,
e => Assert.Equal("Scheduling reconciliation for parent (null) and child (null) for operator ChildOperatorTests", e.Message),
e => Assert.Equal("Caught error Specified method is not supported. while executing reconciliation for operator ChildOperatorTests", e.Message));
}
public async Task ReconcileAsync_FeedbackLoopReturnsNull_DoesNothing_Async()
{
var kubernetes = new Mock <KubernetesClient>();
var sessions = kubernetes.WithClient <WebDriverSession>();
var pods = kubernetes.WithClient <V1Pod>();
Feedback <WebDriverSession, V1Pod> feedback = null;
var parent = new WebDriverSession();
var child = new V1Pod();
var feedbackLoops = new Collection <FeedbackLoop <WebDriverSession, V1Pod> >()
{
new FeedbackLoop <WebDriverSession, V1Pod>((context, cancellationToken) =>
{
return(Task.FromResult(feedback));
}),
};
using (var @operator = new ChildOperator <WebDriverSession, V1Pod>(
kubernetes.Object,
this.configuration,
this.filter,
(session, pod) => { },
feedbackLoops,
this.logger,
this.services))
{
await @operator.ReconcileAsync(parent, child, default).ConfigureAwait(false);
}
sessions.Verify();
}
public async Task CreateSession_HandlesError_Async()
{
var sessionClient = new Mock <NamespacedKubernetesClient <WebDriverSession> >(MockBehavior.Strict);
var kubernetes = new Mock <KubernetesClient>(MockBehavior.Strict);
kubernetes.Setup(c => c.GetClient <WebDriverSession>()).Returns(sessionClient.Object);
var webDriver = new KubernetesWebDriver(kubernetes.Object, NullLogger <KubernetesWebDriver> .Instance);
var request = new NewSessionRequest()
{
Capabilities = new CapabilitiesRequest()
{
AlwaysMatch = new Dictionary <string, object>()
{
{ "platformName", "fake" },
},
},
};
var session = new WebDriverSession()
{
Metadata = new V1ObjectMeta()
{
Name = "fake-abcd",
},
};
sessionClient
.Setup(s => s.CreateAsync(It.IsAny <WebDriverSession>(), default))
.ReturnsAsync(session);
var watchHook = sessionClient.WithWatcher(session);
var task = webDriver.CreateSessionAsync(request, default);
var watchClient = await watchHook.ClientRegistered.Task.ConfigureAwait(false);
// Simulate the session going through the various stages of setup
session.Status = new WebDriverSessionStatus()
{
Error = "error",
Data = "data",
Message = "message",
StackTrace = "stacktrace",
};
Assert.Equal(WatchResult.Stop, await watchClient(k8s.WatchEventType.Modified, session).ConfigureAwait(false));
sessionClient.Setup(s => s.TryReadAsync(session.Metadata.Name, default)).ReturnsAsync(session);
sessionClient.Setup(s => s.DeleteAsync(session, It.IsAny <TimeSpan>(), default)).Returns(Task.CompletedTask);
watchHook.TaskCompletionSource.SetResult(WatchExitReason.ClientDisconnected);
var result = await task.ConfigureAwait(false);
var response = Assert.IsType <WebDriverError>(result.Value);
Assert.Equal(WebDriverErrorCode.SessionNotCreated, response.ErrorCode);
Assert.Equal("data", response.Data);
Assert.Equal("message", response.Message);
Assert.Equal("stacktrace", response.StackTrace);
}
private void CreateSession()
{
var driverFactory = _GetDriverFactory(TestSuiteSettings.WebDriverSettings);
var driverSession = new WebDriverSession(driverFactory, TestSuiteSettings);
// Print Session ID to the console for SauceLabs plugin to work in Jenkins
if (TestSuiteSettings.WebDriverSettings.HubType.EnumValue.Equals(HubType.SauceLabs))
{
Console.WriteLine("SauceOnDemandSessionID={0} job-name={1}",
_GetSessionId(driverSession.Driver),
TestSuiteSettings.WebDriverSettings.AdditionalCapabilities.Find(ac => ac.Id.Equals("name")).Value);
}
//get the launch page to start the session
var launchPage = TestSuiteSettings.GetLaunchPage(SiteLaunchTarget);
//if basic authentication, insert the desired username and password into the url
if (TestSuiteSettings.ApplicationUnderTestSettings.BasicAuthentication)
{
var user =
TestSuiteSettings.ApplicationUnderTestSettings.Users.SingleOrDefault(
u => u.Username.Equals(BasicAuthUsername));
if (user != null)
{
launchPage = string.Format(launchPage, user.Username, user.Password);
}
else
{
throw new InvalidDataException("The supplied username {0} could not be found in suite settings data");
}
}
driverSession.Start(launchPage);
Session = new Session(driverSession);
}
public void BuildServiceOperator_ConfiguresService_Test(int sessionPort)
{
var builder = FakeOperators.BuildServiceOperator(this.host.Services);
var session = new WebDriverSession()
{
Metadata = new V1ObjectMeta()
{
Name = "my-session",
},
Status = new WebDriverSessionStatus()
{
SessionPort = sessionPort,
},
};
var service = new V1Service();
builder.ChildFactory(session, service);
Assert.Collection(
service.Spec.Selector,
l =>
{
Assert.Equal(Annotations.SessionName, l.Key);
Assert.Equal("my-session", l.Value);
});
var port = Assert.Single(service.Spec.Ports);
Assert.Equal(sessionPort, port.TargetPort);
Assert.Equal(sessionPort, port.Port);
}
internal void I_open_Automate_web_url()
{
var session = new WebDriverSession();
driver = session.driver;
this.userLoginLayout = new UserLoginLayout(session.driver);
this.userLoginLayout.SignInPage.GotoAutomationURL();
}
/// <summary>
/// Starts up a new session using the given driver settings
/// </summary>
/// <param name="suiteSettings"></param>
/// <param name="siteUrl"></param>
/// <returns></returns>
protected ISession StartUpSession(ISuiteSettings suiteSettings, string siteUrl)
{
var driverFactory = _GetDriverFactory(suiteSettings.WebDriverSettings);
var driverSession = new WebDriverSession(driverFactory, suiteSettings);
driverSession.Start(siteUrl);
return(new Session(driverSession));
}
public async Task ReconcileAsync_Child_NoOp_Async()
{
var kubernetes = new Mock <KubernetesClient>();
var sessions = kubernetes.WithClient <WebDriverSession>();
var pods = kubernetes.WithClient <V1Pod>();
using (var @operator = new ChildOperator <WebDriverSession, V1Pod>(
kubernetes.Object,
this.configuration,
this.filter,
(session, pod) =>
{
pod.Spec = new V1PodSpec(
new V1Container[]
{
new V1Container()
{
Name = "fake-driver",
Image = "quay.io/kaponata/fake-driver:2.0.1",
},
});
},
this.feedbackLoops,
this.logger,
this.services))
{
var parent = new WebDriverSession()
{
Metadata = new V1ObjectMeta()
{
Name = "my-session",
NamespaceProperty = "default",
Uid = "my-uid",
},
};
var child = new V1Pod()
{
Metadata = new V1ObjectMeta()
{
Name = "my-session",
NamespaceProperty = "default",
},
};
await @operator.ReconcileAsync(
parent, child, default).ConfigureAwait(false);
}
}
public async Task CreateSession_TimesOut_Async()
{
var sessionClient = new Mock <NamespacedKubernetesClient <WebDriverSession> >(MockBehavior.Strict);
var kubernetes = new Mock <KubernetesClient>(MockBehavior.Strict);
kubernetes.Setup(c => c.GetClient <WebDriverSession>()).Returns(sessionClient.Object);
var webDriver = new KubernetesWebDriver(kubernetes.Object, NullLogger <KubernetesWebDriver> .Instance);
webDriver.CreationTimeout = TimeSpan.FromMilliseconds(10);
var request = new NewSessionRequest()
{
Capabilities = new CapabilitiesRequest()
{
AlwaysMatch = new Dictionary <string, object>()
{
{ "platformName", "fake" },
},
},
};
var session = new WebDriverSession()
{
Metadata = new V1ObjectMeta()
{
Name = "fake-abcd",
},
};
sessionClient
.Setup(s => s.CreateAsync(It.IsAny <WebDriverSession>(), default))
.ReturnsAsync(session);
var watchHook = sessionClient.WithWatcher(session);
var task = webDriver.CreateSessionAsync(request, default);
var watchClient = await watchHook.ClientRegistered.Task.ConfigureAwait(false);
var result = await task.ConfigureAwait(false);
var response = Assert.IsType <WebDriverError>(result.Value);
Assert.Equal(WebDriverErrorCode.SessionNotCreated, response.ErrorCode);
Assert.Equal("The session creation timed out.", response.Message);
}
public void BuildIngressOperator_ConfiguresIngress_Test(int sessionPort)
{
var builder = FakeOperators.BuildIngressOperator(this.host.Services);
var session = new WebDriverSession()
{
Metadata = new V1ObjectMeta()
{
Name = "my-session",
},
Status = new WebDriverSessionStatus()
{
SessionId = "1234",
SessionPort = sessionPort,
},
};
var ingress = new V1Ingress();
builder.ChildFactory(session, ingress);
var rule = Assert.Single(ingress.Spec.Rules);
var path = Assert.Single(rule.Http.Paths);
Assert.Equal("/wd/hub/session/my-session/", path.Path);
Assert.Equal("Prefix", path.PathType);
Assert.Equal("my-session", path.Backend.Service.Name);
Assert.Equal(sessionPort, path.Backend.Service.Port.Number);
Assert.NotNull(ingress.Metadata?.Annotations);
Assert.Collection(
ingress.Metadata.Annotations,
a =>
{
Assert.Equal(Annotations.RequestModifier, a.Key);
Assert.Equal("ReplacePathRegex: /wd/hub/session/my-session/(.*) /wd/hub/session/1234/$1", a.Value);
},
a =>
{
Assert.Equal(Annotations.IngressClass, a.Key);
Assert.Equal("traefik", a.Value);
});
}
public async Task DeleteSessionAsync_DeletesSession_Async()
{
var sessionClient = new Mock <NamespacedKubernetesClient <WebDriverSession> >(MockBehavior.Strict);
var kubernetes = new Mock <KubernetesClient>(MockBehavior.Strict);
kubernetes.Setup(c => c.GetClient <WebDriverSession>()).Returns(sessionClient.Object);
var webDriver = new KubernetesWebDriver(kubernetes.Object, NullLogger <KubernetesWebDriver> .Instance);
var session = new WebDriverSession();
sessionClient.Setup(s => s.TryReadAsync("abc", default)).ReturnsAsync(session);
sessionClient.Setup(s => s.DeleteAsync(session, It.IsAny <V1DeleteOptions>(), It.IsAny <TimeSpan>(), default)).Returns(Task.CompletedTask).Verifiable();
var result = await webDriver.DeleteSessionAsync("abc", default).ConfigureAwait(false);
Assert.Null(result.Value);
sessionClient.Verify();
}
public async Task ConnectsDevice_Async()
{
var builder = UIAutomatorOperators.BuildPodOperator(this.host.Services);
var feedbackLoop = Assert.Single(builder.FeedbackLoops);
var session = new WebDriverSession()
{
Spec = new WebDriverSessionSpec()
{
Capabilities = "{}",
DeviceHost = "1.2.3.4",
},
};
var pod = new V1Pod()
{
Status = new V1PodStatus()
{
Phase = "Running",
ContainerStatuses = new V1ContainerStatus[] { },
},
};
var adbStream = new Mock <Stream>();
this.kubernetes
.Setup(c => c.ConnectToPodPortAsync(pod, 5037, It.IsAny <CancellationToken>()))
.ReturnsAsync(adbStream.Object);
var context = new ChildOperatorContext <WebDriverSession, V1Pod>(
parent: session,
child: pod,
this.host.Services);
this.adbClient
.Setup(c => c.ConnectDeviceAsync(new DnsEndPoint("1.2.3.4", 5555), default))
.Returns(Task.CompletedTask)
.Verifiable();
this.adbClient
.Setup(c => c.GetDevicesAsync(default))
public async Task ReconcileAsync_FeedbackLoopHasChildPatch_ExecutesPatch_Async()
{
var kubernetes = new Mock <KubernetesClient>();
var sessions = kubernetes.WithClient <WebDriverSession>();
var pods = kubernetes.WithClient <V1Pod>();
var feedback = new Feedback <WebDriverSession, V1Pod>();
feedback.ChildFeedback = new JsonPatchDocument <V1Pod>();
feedback.ChildFeedback.Add(s => s.Status, new V1PodStatus());
var parent = new WebDriverSession();
var child = new V1Pod();
pods.Setup(p => p.PatchAsync(child, feedback.ChildFeedback, default))
.ReturnsAsync(child)
.Verifiable();
var feedbackLoops = new Collection <FeedbackLoop <WebDriverSession, V1Pod> >()
{
new FeedbackLoop <WebDriverSession, V1Pod>((context, cancellationToken) =>
{
return(Task.FromResult(feedback));
}),
};
using (var @operator = new ChildOperator <WebDriverSession, V1Pod>(
kubernetes.Object,
this.configuration,
this.filter,
(session, pod) => { },
feedbackLoops,
this.logger,
this.services))
{
await @operator.ReconcileAsync(parent, child, default).ConfigureAwait(false);
}
sessions.Verify();
}
public async Task ReconcileAsync_FeedbackLoop_IsPassedScopedServices_Async()
{
var kubernetes = new Mock <KubernetesClient>();
var sessions = kubernetes.WithClient <WebDriverSession>();
var pods = kubernetes.WithClient <V1Pod>();
var feedbackLoops = new Collection <FeedbackLoop <WebDriverSession, V1Pod> >()
{
new FeedbackLoop <WebDriverSession, V1Pod>((context, cancellationToken) =>
{
Assert.NotNull(context.Services);
// Get a scope service, and assert that the scoped service passed to the feedback
// loop is different than the scoped service at the root.
var value = context.Services.GetRequiredService <NamespacedKubernetesClient <V1Job> >();
var rootValue = this.services.GetRequiredService <NamespacedKubernetesClient <V1Job> >();
Assert.NotSame(rootValue, value);
return(Task.FromResult((Feedback <WebDriverSession, V1Pod>)null));
}),
};
var parent = new WebDriverSession();
var child = new V1Pod();
using (var @operator = new ChildOperator <WebDriverSession, V1Pod>(
kubernetes.Object,
this.configuration,
this.filter,
(session, pod) => { },
feedbackLoops,
this.logger,
this.services))
{
await @operator.ReconcileAsync(parent, child, default).ConfigureAwait(false);
}
sessions.Verify();
}
public async Task CreateDeleteWebDriverSession_Async()
{
string name = FormatName(nameof(this.CreateDeleteWebDriverSession_Async));
using (var client = this.CreateKubernetesClient())
{
var webDriverSessionClient = client.GetClient <WebDriverSession>();
WebDriverSession currentDevice = null;
if ((currentDevice = await webDriverSessionClient.TryReadAsync(name, default).ConfigureAwait(false)) != null)
{
await webDriverSessionClient.DeleteAsync(currentDevice, TimeSpan.FromSeconds(100), default).ConfigureAwait(false);
}
var session = new WebDriverSession()
{
Metadata = new V1ObjectMeta()
{
Name = name,
NamespaceProperty = "default",
},
};
var newSession = await webDriverSessionClient.CreateAsync(session, default).ConfigureAwait(false);
Assert.NotNull(newSession);
var readSession = await webDriverSessionClient.TryReadAsync(name, default).ConfigureAwait(false);
Assert.NotNull(readSession);
await webDriverSessionClient.DeleteAsync(newSession, TimeSpan.FromMinutes(1), default).ConfigureAwait(false);
Assert.Null(await webDriverSessionClient.TryReadAsync(name, default).ConfigureAwait(false));
}
}
public async Task InitializeAsync_ParentWithoutChild_SchedulesReconciliation_Async()
{
var kubernetes = new Mock <KubernetesClient>();
var sessionClient = kubernetes.WithClient <WebDriverSession>();
var podClient = kubernetes.WithClient <V1Pod>();
var parent = new WebDriverSession()
{
Metadata = new V1ObjectMeta()
{
Name = "my-session",
NamespaceProperty = "default",
Uid = "my-uid",
},
};
sessionClient.WithList(
null,
"parent-label-selector",
parent);
podClient.WithList(
null,
labelSelector: "app.kubernetes.io/managed-by=ChildOperatorTests");
var createdPods = podClient.TrackCreatedItems();
using (var @operator = new ChildOperator <WebDriverSession, V1Pod>(
kubernetes.Object,
this.configuration,
this.filter,
(session, pod) => { },
this.feedbackLoops,
this.logger,
this.services))
{
await @operator.InitializeAsync(default).ConfigureAwait(false);
public void BuildPodOperator_ConfiguresPod_Test()
{
var builder = FakeOperators.BuildPodOperator(this.host.Services);
var session = new WebDriverSession()
{
Metadata = new V1ObjectMeta()
{
Name = "my-session",
},
};
var pod = new V1Pod();
builder.ChildFactory(session, pod);
Assert.Collection(
pod.Metadata.Labels,
l =>
{
Assert.Equal(Annotations.SessionName, l.Key);
Assert.Equal("my-session", l.Value);
});
var container = Assert.Single(pod.Spec.Containers);
Assert.Equal("quay.io/kaponata/fake-driver:2.0.1", container.Image);
var port = Assert.Single(container.Ports);
Assert.Equal(4774, port.ContainerPort);
var probe = container.ReadinessProbe.HttpGet;
Assert.Equal("/wd/hub/status", probe.Path);
Assert.Equal(4774, probe.Port);
}
public void Operator_ConfiguresPod()
{
var builder = UIAutomatorOperators.BuildPodOperator(this.host.Services);
var session = new WebDriverSession()
{
Metadata = new V1ObjectMeta()
{
Name = "my-session",
},
};
var child = new V1Pod();
builder.ChildFactory(session, child);
Assert.Collection(
child.Metadata.Labels,
a =>
{
Assert.Equal("kaponata.io/session-name", a.Key);
Assert.Equal("my-session", a.Value);
});
Assert.Collection(
child.Spec.Containers,
c =>
{
Assert.Equal("quay.io/kaponata/appium-android:1.20.2", c.Image);
Assert.Equal("appium", c.Name);
Assert.Collection(
c.Args,
a => Assert.Equal("/app/appium/build/lib/main.js", a));
var port = Assert.Single(c.Ports);
Assert.Equal(4723, port.ContainerPort);
Assert.Equal("http", port.Name);
Assert.Equal("/wd/hub/status", c.ReadinessProbe.HttpGet.Path);
Assert.Equal("4723", c.ReadinessProbe.HttpGet.Port);
},
c =>
{
Assert.Equal("quay.io/kaponata/appium-android:1.20.2", c.Image);
Assert.Equal("adb", c.Name);
Assert.Collection(
c.Command,
a => Assert.Equal("/bin/tini", a),
a => Assert.Equal("--", a),
a => Assert.Equal("/android/platform-tools/adb", a));
Assert.Collection(
c.Args,
a => Assert.Equal("-a", a),
a => Assert.Equal("-P", a),
a => Assert.Equal("5037", a),
a => Assert.Equal("server", a),
a => Assert.Equal("nodaemon", a));
var port = Assert.Single(c.Ports);
Assert.Equal(5037, port.ContainerPort);
Assert.Equal("adb", port.Name);
Assert.Equal("5037", c.ReadinessProbe.TcpSocket.Port);
});
}
public async Task ReconcileAsync_NoChild_CreatesChild_Async()
{
var kubernetes = new Mock <KubernetesClient>();
var sessions = kubernetes.WithClient <WebDriverSession>();
var pods = kubernetes.WithClient <V1Pod>();
(var createdPods, var _) = pods.TrackCreatedItems();
using (var @operator = new ChildOperator <WebDriverSession, V1Pod>(
kubernetes.Object,
this.configuration,
this.filter,
(session, pod) =>
{
pod.Spec = new V1PodSpec(
new V1Container[]
{
new V1Container()
{
Name = "fake-driver",
Image = "quay.io/kaponata/fake-driver:2.0.1",
},
});
},
this.feedbackLoops,
this.logger,
this.services))
{
var parent = new WebDriverSession()
{
Metadata = new V1ObjectMeta()
{
Name = "my-session",
NamespaceProperty = "default",
Uid = "my-uid",
},
};
await @operator.ReconcileAsync(parent, null, default).ConfigureAwait(false);
}
Assert.Collection(
createdPods,
p =>
{
// The name, namespace and owner references are initialized correctly
Assert.Equal("my-session", p.Metadata.Name);
Assert.Equal("default", p.Metadata.NamespaceProperty);
Assert.Collection(
p.Metadata.OwnerReferences,
r =>
{
Assert.Equal("my-session", r.Name);
Assert.Equal("WebDriverSession", r.Kind);
Assert.Equal("kaponata.io/v1alpha1", r.ApiVersion);
Assert.Equal("my-uid", r.Uid);
});
// The labels are copied from the configuration
Assert.Collection(
p.Metadata.Labels,
p =>
{
Assert.Equal(Annotations.ManagedBy, p.Key);
Assert.Equal(nameof(ChildOperatorTests), p.Value);
});
});
}
public async Task CreateSession_CreatesSession_Async(string platformName, string automationName, string providerName)
{
var sessionClient = new Mock <NamespacedKubernetesClient <WebDriverSession> >(MockBehavior.Strict);
var kubernetes = new Mock <KubernetesClient>(MockBehavior.Strict);
kubernetes.Setup(c => c.GetClient <WebDriverSession>()).Returns(sessionClient.Object);
var webDriver = new KubernetesWebDriver(kubernetes.Object, NullLogger <KubernetesWebDriver> .Instance);
var request = new NewSessionRequest()
{
Capabilities = new CapabilitiesRequest()
{
AlwaysMatch = new Dictionary <string, object>()
{
{ "platformName", platformName },
{ "appium:automationName", automationName },
},
},
};
var session = new WebDriverSession()
{
Metadata = new V1ObjectMeta()
{
Name = "fake-abcd",
},
};
sessionClient
.Setup(s => s.CreateAsync(It.IsAny <WebDriverSession>(), default))
.Returns <WebDriverSession, CancellationToken>((request, ct) =>
{
Assert.Equal($"{providerName}-", request.Metadata.GenerateName);
Assert.Collection(
request.Metadata.Labels,
l =>
{
Assert.Equal(Annotations.AutomationName, l.Key);
Assert.Equal(providerName, l.Value);
});
if (automationName != null)
{
Assert.Equal($"{{\"alwaysMatch\":{{\"platformName\":\"{platformName}\",\"appium:automationName\":\"{automationName}\"}}}}", request.Spec.Capabilities);
}
else
{
Assert.Equal($"{{\"alwaysMatch\":{{\"platformName\":\"{platformName}\",\"appium:automationName\":null}}}}", request.Spec.Capabilities);
}
return(Task.FromResult(session));
});
var watchHook = sessionClient.WithWatcher(session);
var task = webDriver.CreateSessionAsync(request, default);
var watchClient = await watchHook.ClientRegistered.Task.ConfigureAwait(false);
// Simulate the session going through the various stages of setup
Assert.Equal(WatchResult.Continue, await watchClient(k8s.WatchEventType.Added, session).ConfigureAwait(false));
Assert.Equal(WatchResult.Continue, await watchClient(k8s.WatchEventType.Modified, session).ConfigureAwait(false));
Assert.Equal(WatchResult.Continue, await watchClient(k8s.WatchEventType.Bookmark, session).ConfigureAwait(false));
session.Status = new WebDriverSessionStatus()
{
IngressReady = false,
ServiceReady = false,
SessionReady = false,
};
Assert.Equal(WatchResult.Continue, await watchClient(k8s.WatchEventType.Modified, session).ConfigureAwait(false));
session.Status.IngressReady = true;
Assert.Equal(WatchResult.Continue, await watchClient(k8s.WatchEventType.Modified, session).ConfigureAwait(false));
session.Status.SessionReady = true;
session.Status.Capabilities = "{}";
Assert.Equal(WatchResult.Continue, await watchClient(k8s.WatchEventType.Modified, session).ConfigureAwait(false));
session.Status.ServiceReady = true;
Assert.Equal(WatchResult.Stop, await watchClient(k8s.WatchEventType.Modified, session).ConfigureAwait(false));
sessionClient.Setup(s => s.TryReadAsync(session.Metadata.Name, default)).ReturnsAsync(session);
watchHook.TaskCompletionSource.SetResult(WatchExitReason.ClientDisconnected);
var result = await task.ConfigureAwait(false);
var response = Assert.IsType <NewSessionResponse>(result.Value);
Assert.Equal("fake-abcd", response.SessionId);
Assert.Empty(response.Capabilities);
}
public async Task WatchWebDriverSession_Async()
{
string name = FormatName(nameof(this.WatchWebDriverSession_Async));
using (var client = this.CreateKubernetesClient())
{
var webDriverSessionClient = client.GetClient <WebDriverSession>();
var watchEvents = new Collection <(WatchEventType, WebDriverSession)>();
WebDriverSession currentSession = null;
if ((currentSession = await webDriverSessionClient.TryReadAsync(name, default).ConfigureAwait(false)) != null)
{
await webDriverSessionClient.DeleteAsync(currentSession, TimeSpan.FromSeconds(100), default).ConfigureAwait(false);
}
var watch = webDriverSessionClient.WatchAsync(
new WebDriverSession()
{
Metadata = new V1ObjectMeta()
{
NamespaceProperty = "default", Name = name
}
},
(type, device) =>
{
watchEvents.Add((type, device));
return(Task.FromResult(type == WatchEventType.Deleted ? WatchResult.Stop : WatchResult.Continue));
},
default);
var session = new WebDriverSession()
{
Metadata = new V1ObjectMeta()
{
Name = name,
NamespaceProperty = "default",
},
};
await webDriverSessionClient.CreateAsync(session, default).ConfigureAwait(false);
await webDriverSessionClient.DeleteAsync(session, TimeSpan.FromMinutes(1), default).ConfigureAwait(false);
await watch.ConfigureAwait(false);
Assert.Collection(
watchEvents,
e =>
{
Assert.Equal(WatchEventType.Added, e.Item1);
Assert.NotNull(e.Item2);
},
e =>
{
Assert.Equal(WatchEventType.Deleted, e.Item1);
Assert.NotNull(e.Item2);
});
}
}
public FakeSession()
{
DriverSession = new WebDriverSession(new FakeWebDriverFactory(new FakeWebDriver()), new FakeSuiteSettings());
}
