public async Task ShouldStartApiWithoutBlocking()
            {
                var fixture = new Fixture()
                              .WithValidCurrentSession()
                              .WithSuccessfulSignInResult();

                var expected = new OnePasswordApiSettings
                {
                    StartWithoutBlocking = true,
                    Port = 5500
                };

                var sut  = fixture.CreateSubject();
                var args = new[] { "-s", "-a", "-api" };

                _ = await sut.ExecuteAsync(args);

                fixture.ApiRunner.VerifyCalledWith(expected);
            }
            public async Task ShouldStartApiWithBlockingInGivenPort()
            {
                var fixture = new Fixture()
                              .WithValidCurrentSession()
                              .WithSuccessfulSignInResult();

                var expected = new OnePasswordApiSettings
                {
                    StartWithoutBlocking = false,
                    Port = 6000
                };

                var sut  = fixture.CreateSubject();
                var args = new[] { "-s", "-api", "6000" };

                _ = await sut.ExecuteAsync(args);

                fixture.Logger.VerifyLogInformation($"Appy 1Password session API listening on port: {expected.Port}");
                fixture.ApiRunner.VerifyCalledWith(expected);
            }
        public async Task <int> ExecuteAsync(params string[] args)
        {
            var adaptedArgs = args.EscapeArgs();

            var app = _commandLineAppFactory.Create(
                name: "appy-op",
                fullName: "Appy 1Password Session Tool"
                );

            app.HelpOption("-h|--help");
            app.VersionOption("-v|--version", GetVersion());

            var signInOption = app.Option("-s|--signin", "Signin to 1Password account (eg: --signin <organization> <email_address> <secret_key>).", CommandOptionType.SingleOrNoValue);
            var vaultOption  = app.Option("-vt|--vault", "1Password vault to use. If not specified, it will use the last known.", CommandOptionType.SingleValue);
            var envOption    = app.Option("-env|--environment", "1Password note section environment. If not specified, it will use the last known.", CommandOptionType.SingleValue);
            var autoRenew    = app.Option("-a|--auto-renew", "Automatically renew 1Password session activity before the 30 min expire.", CommandOptionType.NoValue);
            var apiOption    = app.Option <int?>("-api|--local-api", "Launch a local Http API (default port 5500) to get configurations for session (eg: -api 6000).", CommandOptionType.SingleOrNoValue);

            app.OnExecuteAsync(async cancellationToken =>
            {
                var currentSession = await _sessionStorage.GetCurrent();

                var signInCommand = BuildSignInCommand(app, signInOption, currentSession);
                var signInResult  = await _onePasswordTool.Execute(signInCommand, cancellationToken);

                var environment = envOption.HasValue() ? envOption.Value() : currentSession.Environment;
                var vault       = vaultOption.HasValue() ? vaultOption.Value() : currentSession.Vault;

                var session = AppyOnePasswordSession.New(
                    organization: signInCommand.Organization,
                    vault: vault,
                    environment: environment,
                    sessionToken: signInResult.SessionToken);

                _logger.LogInformation("Updating 1Password session information.");

                await _sessionStorage.Update(session);

                _consoleVisualizer.Render(session);

                _logger.LogInformation(string.Empty);
                _logger.LogInformation("You can now go to your project and start your debug session.");

                if (!autoRenew.HasValue())
                {
                    _logger.LogInformation("Session tokens expire after 30 minutes of inactivity, after which you’ll need to sign in again.");
                }

                if (apiOption.HasValue())
                {
                    var apiSettings = new OnePasswordApiSettings
                    {
                        StartWithoutBlocking = autoRenew.HasValue(),
                        Port = apiOption.ParsedValue ?? 5500
                    };

                    _logger.LogInformation($"Appy 1Password session API listening on port: {apiSettings.Port}");

                    _apiRunner.Start(apiSettings);
                }

                if (!autoRenew.HasValue())
                {
                    return(0);
                }

                var foreverCancellationTokenSource = new CancellationTokenSource();

                await AutoRenewSessionActivity(session, foreverCancellationTokenSource.Token);

                return(0);
            });

            try
            {
                return(await app.ExecuteAsync(adaptedArgs.ToArray()));
            }
            catch (CommandParsingException ex)
            {
                _logger.LogError(ex.Message);

                app.ShowHelp();

                return(1);
            }
            catch (ValidationException ex)
            {
                var result = ex.Result?.Errors?.FirstOrDefault()?.Message;

                _logger.LogError(result);

                return(1);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex.Message);

                return(1);
            }
        }
Beispiel #4
0
 public void VerifyCalledWith(OnePasswordApiSettings expected)
 {
     Verify(x => x.Start(
                It.Is <OnePasswordApiSettings>(settings =>
                                               settings.IsEquivalentTo(expected))));
 }