public void LaunchInChrome(IChromeClientsLauncher chromeClientsLauncher,
string workingDirectory)
{
string launchUrl;
StadiaEndpoint endpoint = chromeClientsLauncher.LaunchParams.Endpoint;
switch (endpoint)
{
case StadiaEndpoint.TestClient:
{
launchUrl = chromeClientsLauncher.MakeTestClientUrl(LaunchName);
break;
}
case StadiaEndpoint.PlayerEndpoint:
{
launchUrl = chromeClientsLauncher.MakePlayerClientUrl(LaunchId);
break;
}
default:
throw new ArgumentOutOfRangeException(
"LaunchInChrome doesn't support this endpoint: " + endpoint);
}
chromeClientsLauncher.LaunchGame(launchUrl, workingDirectory);
}
public void ToLaunchGameRequestNotSupportedTestAccounts(StadiaEndpoint endpoint)
{
LaunchParams parameters = ValidParams;
parameters.Endpoint = endpoint;
parameters.TestAccount = "a/b/c";
parameters.TestAccountGamerName = "gamer#1234";
ConfigStatus status =
_parametersConverter.ToLaunchGameRequest(parameters, out LaunchGameRequest _);
Assert.That(status.IsWarningLevel, Is.EqualTo(true));
Assert.That(status.WarningMessage,
Does.Contain("Test accounts are not supported by any player endpoint"));
Assert.That(status.WarningMessage, Does.Contain("gamer#1234"));
}
public void ToLaunchGameRequestNotSupportedQueryParams(StadiaEndpoint endpoint)
{
LaunchParams parameters = ValidParams;
parameters.Endpoint = endpoint;
parameters.QueryParams = "a=42&vars=valid=1";
ConfigStatus status =
_parametersConverter.ToLaunchGameRequest(parameters, out LaunchGameRequest _);
Assert.That(status.IsWarningLevel, Is.EqualTo(true));
Assert.That(status.WarningMessage,
Does.Contain("are not supported by any player endpoint"));
Assert.That(status.WarningMessage, Does.Contain("a=42"));
Assert.That(status.WarningMessage, Does.Not.Contain("vars=valid=1"));
}
public void LaunchSuspendedWhenEndpointSetSucceeds(
[Values(StadiaEndpoint.AnyEndpoint, StadiaEndpoint.PlayerEndpoint,
StadiaEndpoint.TestClient)]
StadiaEndpoint endpoint)
{
var debugSessionLauncherFactory = Substitute.For <IDebugSessionLauncherFactory>();
IGgpDebugEngine debugEngine = CreateGgpDebugEngine(debugSessionLauncherFactory);
string options = null;
var launchParams = new LaunchParams {
Endpoint = endpoint
};
string args = Convert.ToBase64String(
Encoding.UTF8.GetBytes(new JsonUtil().Serialize(launchParams)));
var debugPort = Substitute.For <IDebugPort2>();
int result = debugEngine.LaunchSuspended("", debugPort, _exePath, args, null, null,
options, enum_LAUNCH_FLAGS.LAUNCH_DEBUG, 0, 0,
0, null, out var _);
Assert.That(result, Is.EqualTo(VSConstants.S_OK));
}
public void ToLaunchGameRequestEnableDeveloperResumeOffer(
StadiaEndpoint endpoint, bool enableOffer)
{
LaunchParams parameters = ValidParams;
parameters.Endpoint = endpoint;
// AnyEndpoint and PlayerEndpoint produce warnings
// when TestAccount or QueryParams are set. We want to receive OK parsing status,
// so we make sure those settings are empty.
parameters.TestAccount = "";
parameters.QueryParams = "";
ConfigStatus status =
_target.ToLaunchGameRequest(parameters, out LaunchGameRequest request);
Assert.That(status.IsOk, Is.EqualTo(true));
Assert.IsNotNull(request);
Assert.That(request.EnableDeveloperResumeOffer, Is.EqualTo(enableOffer));
}
public async Task LaunchNoDebugAsync([Values(false, true)] bool renderdoc,
[Values(false, true)] bool rgp,
[Values(null, "optprintasserts")]
string vulkanDriverVariant,
[Values(StadiaEndpoint.PlayerEndpoint,
StadiaEndpoint.TestClient,
StadiaEndpoint.AnyEndpoint)]
StadiaEndpoint endpoint)
{
_project.GetLaunchRenderDocAsync().Returns(renderdoc);
_project.GetLaunchRgpAsync().Returns(rgp);
_project.GetVulkanDriverVariantAsync().Returns(vulkanDriverVariant);
_project.GetEndpointAsync().Returns(endpoint);
var gamelets = new List <Gamelet>
{
new Gamelet
{
Id = _testGameletId,
Name = _testGameletName,
IpAddr = _testGameletIp,
State = GameletState.Reserved,
}
};
_gameletClient.ListGameletsAsync().Returns(Task.FromResult(gamelets));
_gameletSelector.TrySelectAndPrepareGamelet(Arg.Any <string>(),
Arg.Any <DeployOnLaunchSetting>(), gamelets,
Arg.Any <TestAccount>(), Arg.Any <string>(),
out Gamelet _).Returns(x =>
{
x[_outVariableIndex] = gamelets[0];
return(true);
});
_gameLauncher.LaunchGameApiEnabled.Returns(true);
_gameLauncher.CreateLaunch(Arg.Any <LaunchParams>())
.Returns(_gameLaunch);
var launchSettings = await QueryDebugTargetsAsync(DebugLaunchOptions.NoDebug);
Assert.That(launchSettings.Count, Is.EqualTo(1));
Assert.That(DebugLaunchOptions.NoDebug | DebugLaunchOptions.MergeEnvironment,
Is.EqualTo(launchSettings[0].LaunchOptions));
Assert.That(launchSettings[0].CurrentDirectory, Is.EqualTo(_testProjectDir));
Assert.That(launchSettings[0].Executable,
Is.EqualTo(Environment.SystemDirectory + "\\cmd.exe"));
_launchCommandFormatter.Parse(launchSettings[0].Arguments,
out LaunchParams launchParams,
out string launchName);
Assert.That(launchParams.Account, Is.EqualTo(_testAccount));
Assert.That(launchParams.SdkVersion, Is.EqualTo(_sdkVersionString));
Assert.That(launchParams.Endpoint, Is.EqualTo(endpoint));
Assert.That(launchName, Is.EqualTo(_gameLaunch.LaunchName));
await _remoteDeploy.Received()
.DeployGameExecutableAsync(_project, new SshTarget(gamelets[0]),
Arg.Any <ICancelable>(),
Arg.Any <IAction>());
AssertMetricRecorded(DeveloperEventType.Types.Type.VsiDebugSetupQueries,
DeveloperEventStatus.Types.Code.Success);
AssertMetricRecorded(DeveloperEventType.Types.Type.VsiDeployBinary,
DeveloperEventStatus.Types.Code.Success);
}
