public void Password() { ExecuteResponse result; using (new KubeTestManager()) { using (var runner = new ProgramRunner()) { // Verify that [neon password] returns help/usage text: result = runner.Execute(Program.Main, "password"); Assert.Equal(0, result.ExitCode); Assert.Contains("Manages neonKUBE passwords.", result.OutputText); result = runner.Execute(Program.Main, "help", "password"); Assert.Equal(0, result.ExitCode); Assert.Contains("Manages neonKUBE passwords.", result.OutputText); // Verify that the "--help" option does the same thing. result = runner.Execute(Program.Main, "password", "--help"); Assert.Equal(0, result.ExitCode); Assert.Contains("Manages neonKUBE passwords.", result.OutputText); // Verify that an invalid command fails. result = runner.Execute(Program.Main, "password", "bad"); Assert.NotEqual(0, result.ExitCode); Assert.Contains("Unexpected [bad] command.", result.ErrorText); } } }
public void VariableInjectEncrypted() { var orgDirectory = Environment.CurrentDirectory; try { using (var manager = new KubeTestManager()) { using (var runner = new ProgramRunner()) { using (var tempFolder = new TempFolder()) { Environment.CurrentDirectory = tempFolder.Path; var vault = new NeonVault(Program.LookupPassword); // Create a test password and a [.password-name] file in the // temp test folder. var result = runner.Execute(Program.Main, $"password", "set", "test"); Assert.Equal(0, result.ExitCode); //------------------------------------------------- // Verify that we can inject variables into an // ENCRYPTED file. File.WriteAllText("test.cmd", "type %1 > output.txt"); File.WriteAllText("file.txt", @" $<<TEST_A>> $<<TEST_B>> $<<TEST_C>> $<<TEST_D>> "); File.WriteAllBytes("file.txt", vault.Encrypt("file.txt", "test")); Assert.True(NeonVault.IsEncrypted("file.txt")); result = runner.Execute(Program.Main, $"run", "--TEST_A=A-VALUE", "--TEST_B=B-VALUE", "--TEST_C=C-VALUE", "--TEST_D=D-VALUE", "--", "test.cmd", "_..file.txt"); Assert.Equal(0, result.ExitCode); var output = File.ReadAllText("output.txt"); Assert.Contains("A-VALUE", output); Assert.Contains("B-VALUE", output); Assert.Contains("C-VALUE", output); Assert.Contains("D-VALUE", output); File.Delete("output.txt"); File.Delete("file.txt"); } } } } finally { Environment.CurrentDirectory = orgDirectory; } }
public void PasswordList() { ExecuteResponse result; using (var manager = new KubeTestManager()) { using (var runner = new ProgramRunner()) { // Verify that [--help] works: result = runner.Execute(Program.Main, "password", "list", "--help"); Assert.Equal(0, result.ExitCode); Assert.Contains("Lists passwords.", result.OutputText); // Add a few passwords: result = runner.Execute(Program.Main, "password", "rm", "--force", "*"); Assert.Equal(0, result.ExitCode); result = runner.ExecuteWithInput(Program.Main, "one", "password", "set", "pwd-1", "-"); Assert.Equal(0, result.ExitCode); result = runner.ExecuteWithInput(Program.Main, "two", "password", "set", "pwd-2", "-"); Assert.Equal(0, result.ExitCode); result = runner.ExecuteWithInput(Program.Main, "three", "password", "set", "pwd-3", "-"); Assert.Equal(0, result.ExitCode); // Verify that we can list via: list result = runner.Execute(Program.Main, "password", "list"); Assert.Equal(0, result.ExitCode); TestHelper.AssertEqualLines( @"pwd-1 pwd-2 pwd-3 ", result.OutputText); // Verify that we can list via: ls result = runner.Execute(Program.Main, "password", "ls"); Assert.Equal(0, result.ExitCode); TestHelper.AssertEqualLines( @"pwd-1 pwd-2 pwd-3 ", result.OutputText); } } }
public void Options() { var orgDirectory = Environment.CurrentDirectory; try { using (var manager = new KubeTestManager()) { using (var runner = new ProgramRunner()) { using (var tempFolder = new TempFolder()) { Environment.CurrentDirectory = tempFolder.Path; //------------------------------------------------- // Verify that the [run] command handles command line options correctly. File.WriteAllText("test.cmd", "echo %* > output.txt"); var result = runner.Execute(Program.Main, $"run", "--", "test.cmd", "-foo", "--bar=foobar", "--hello", "world"); Assert.Equal(0, result.ExitCode); Assert.Contains("-foo --bar=foobar --hello world", File.ReadAllText("output.txt")); } } } } finally { Environment.CurrentDirectory = orgDirectory; } }
public void SourceNamespace() { using (new KubeTestManager()) { using (var runner = new ProgramRunner()) { // Verify that all types are generated when no targets // are specified. var result = runner.Execute(Program.Main, "generate", "models", $"--source-namespace={typeof(FooBar.Class4).Namespace}", thisAssemblyPath); Assert.Equal(0, result.ExitCode); var sourceCode = result.OutputText; ModelGenerator.Compile(sourceCode, "test-assembly", references => ModelGenTestHelper.ReferenceHandler(references)); Assert.DoesNotContain("class Class1", sourceCode); Assert.DoesNotContain("class Class2", sourceCode); Assert.DoesNotContain("class Class3", sourceCode); Assert.Contains("class Class4", sourceCode); Assert.DoesNotContain("class Service1", sourceCode); Assert.DoesNotContain("class Service2", sourceCode); } } }
public void Vault() { using (var runner = new ProgramRunner()) { var result = runner.Execute(Program.Main, "vault"); Assert.Equal(0, result.ExitCode); } }
public void Base() { using (var runner = new ProgramRunner()) { // Verify that base command returns some help. var result = runner.Execute(Program.Main); Assert.Equal(0, result.ExitCode); Assert.Contains("neonKUBE Management Tool: neon", result.OutputText); // Verify that we see an error for an unrecognized command., result = runner.Execute(Program.Main, "invalid-command"); Assert.NotEqual(0, result.ExitCode); } }
public void Run() { using (var runner = new ProgramRunner()) { // Verify that the help command works. var result = runner.Execute(Program.Main, "run", "--help"); Assert.Equal(0, result.ExitCode); Assert.Contains("Runs a sub-command, optionally injecting settings and secrets and/or", result.OutputText); // Verify ther error we get when there's no right command line. result = runner.Execute(Program.Main, "run"); Assert.NotEqual(0, result.ExitCode); Assert.Contains("*** ERROR: Expected a command after a [--] argument.", result.ErrorText); } }
public void Base() { // Verify that base command returns some help. using (var runner = new ProgramRunner()) { var result = runner.Execute(Program.Main, "couchbase"); Assert.Equal(0, result.ExitCode); Assert.Contains("Performs Couchbase related operations.", result.OutputText); } }
public void Execute() { ExecuteResponse result; using (var runner = new ProgramRunner()) { mainExecuted = false; result = runner.Execute(Main, "pass"); Assert.Equal(0, result.ExitCode); Assert.Equal("PASS: STDOUT", result.OutputText); Assert.Equal("PASS: STDERR", result.ErrorText); Assert.True(mainExecuted); mainExecuted = false; result = runner.Execute(Main, "fail"); Assert.Equal(1, result.ExitCode); Assert.Equal("FAIL: STDOUT", result.OutputText); Assert.Equal("FAIL: STDERR", result.ErrorText); Assert.True(mainExecuted); } }
public void VariableOptions() { var orgDirectory = Environment.CurrentDirectory; try { using (var manager = new KubeTestManager()) { using (var runner = new ProgramRunner()) { using (var tempFolder = new TempFolder()) { Environment.CurrentDirectory = tempFolder.Path; var vault = new NeonVault(Program.LookupPassword); //------------------------------------------------- // Verify that we can process [--name=value] run command options. File.WriteAllText("test.cmd", "echo %* > output.txt"); var result = runner.Execute(Program.Main, $"run", "--TEST_A=A-VALUE", "--TEST_B=B-VALUE", "--TEST_C=C-VALUE", "--TEST_D=D-VALUE", "--", "test.cmd", "_.TEST_A", "_.TEST_B", "_.TEST_C", "_.TEST_D"); Assert.Equal(0, result.ExitCode); var output = File.ReadAllText("output.txt"); Assert.Contains("A-VALUE", output); Assert.Contains("B-VALUE", output); Assert.Contains("C-VALUE", output); Assert.Contains("D-VALUE", output); File.Delete("output.txt"); } } } } finally { Environment.CurrentDirectory = orgDirectory; } }
public void StandardFiles() { // We had a problem with [NeonHelper_Execute] where standard output // and standard error streams weren't being relayed back to the // corresponding [neon-cli] streams when the sub-process was an // actual executable rather than a batch script. So the unit tests // above that ran a script passed. // // This test verifies that we get output from an actual executable. var orgDirectory = Environment.CurrentDirectory; try { using (var manager = new KubeTestManager()) { using (var runner = new ProgramRunner()) { using (var tempFolder = new TempFolder()) { Environment.CurrentDirectory = tempFolder.Path; File.WriteAllText("test.txt", "Hello World!"); var result = runner.Execute(Program.Main, $"run", "--", "cat", "test.txt"); Assert.Equal(0, result.ExitCode); Assert.Contains("Hello World!", result.AllText); } } } } finally { Environment.CurrentDirectory = orgDirectory; } }
public void Version() { using (var runner = new ProgramRunner()) { var result = runner.Execute(Program.Main, "version"); Assert.Equal(0, result.ExitCode); Assert.Equal(Build.ProductVersion, result.OutputText.Trim()); result = runner.Execute(Program.Main, "version", "-n"); Assert.Equal(0, result.ExitCode); Assert.Equal(Build.ProductVersion, result.OutputText.Trim()); Assert.DoesNotContain('\n', result.OutputText); result = runner.Execute(Program.Main, "version", "-n", "--git"); Assert.Equal(0, result.ExitCode); Assert.Equal($"{Build.ProductVersion}/{ThisAssembly.Git.Branch}-{ThisAssembly.Git.Commit}", result.OutputText.Trim()); Assert.DoesNotContain('\n', result.OutputText); result = runner.Execute(Program.Main, "version", $"--minimum={Program.Version}"); Assert.Equal(0, result.ExitCode); result = runner.Execute(Program.Main, "version", $"--minimum=0"); Assert.Equal(0, result.ExitCode); result = runner.Execute(Program.Main, "version", $"--minimum=64000.0.0"); Assert.NotEqual(0, result.ExitCode); var curVersion = SemanticVersion.Parse(Program.Version); var newerVersion = SemanticVersion.Create(curVersion.Major, curVersion.Minor, curVersion.Patch + 1, curVersion.Build, curVersion.Prerelease); Assert.True(newerVersion > curVersion); result = runner.Execute(Program.Main, "version", $"--minimum={newerVersion}"); Assert.NotEqual(0, result.ExitCode); } }
public void ReadVariables_Decrypted() { var orgDirectory = Environment.CurrentDirectory; try { using (var manager = new KubeTestManager()) { using (var runner = new ProgramRunner()) { using (var tempFolder = new TempFolder()) { Environment.CurrentDirectory = tempFolder.Path; var vault = new NeonVault(Program.LookupPassword); // Create a test password and a [.password-name] file in the // temp test folder. var result = runner.Execute(Program.Main, $"password", "set", "test"); Assert.Equal(0, result.ExitCode); File.WriteAllText(".password-name", "test"); //------------------------------------------------- // Verify that we can read variables from a couple of // unencrypted variable files. File.WriteAllText("test.cmd", "echo %* > output.txt"); File.WriteAllText("var1.txt", @"# This is a comment. TEST_A=A-VALUE TEST_B=B-VALUE "); File.WriteAllText("var2.txt", @"# This is a comment. TEST_C=C-VALUE TEST_D=D-VALUE "); result = runner.Execute(Program.Main, $"run", "var1.txt", "var2.txt", "--", "test.cmd", "_.TEST_A", "_.TEST_B", "_.TEST_C", "_.TEST_D"); Assert.Equal(0, result.ExitCode); var output = File.ReadAllText("output.txt"); Assert.Contains("A-VALUE", output); Assert.Contains("B-VALUE", output); Assert.Contains("C-VALUE", output); Assert.Contains("D-VALUE", output); File.Delete("output.txt"); File.Delete("var1.txt"); File.Delete("var2.txt"); } } } } finally { Environment.CurrentDirectory = orgDirectory; } }
public void VaultCreate() { using (var manager = new KubeTestManager()) { using (var tempFolder = new TempFolder()) { var orgDir = Environment.CurrentDirectory; Environment.CurrentDirectory = tempFolder.Path; NeonHelper.OpenEditorHandler = path => File.WriteAllText(path, plainText); try { using (var passwordFile = new TempFile(folder: KubeHelper.PasswordsFolder)) { File.WriteAllText(passwordFile.Path, testPassword); var vault = new NeonVault(passwordName => testPassword); using (var runner = new ProgramRunner()) { // Verify that the PATH argument is required. var result = runner.Execute(Program.Main, "vault", "create"); Assert.NotEqual(0, result.ExitCode); Assert.Contains("*** ERROR: The PATH argument is required.", result.ErrorText); // Verify that the PASSWORD-NAME argument is required when there's // no default [.password-name] file. result = runner.Execute(Program.Main, "vault", "create", "test1.txt"); Assert.NotEqual(0, result.ExitCode); Assert.Contains("*** ERROR: A PASSWORD-NAME argument or [.password-name] file is required.", result.ErrorText); // Verify that we can create an encrypted file with an explicitly // named password. result = runner.Execute(Program.Main, "vault", "create", "test2.txt", passwordFile.Name); Assert.Equal(0, result.ExitCode); Assert.True(NeonVault.IsEncrypted("test2.txt", out var passwordName)); Assert.Equal(passwordFile.Name, passwordName); Assert.Equal(plainText, Encoding.UTF8.GetString(vault.Decrypt("test2.txt"))); // Verify that we see an error for a missing password. result = runner.Execute(Program.Main, "vault", "create", "test3.txt", missingPasswordName); Assert.NotEqual(0, result.ExitCode); Assert.Contains($"*** ERROR: [CryptographicException]: Password named [{missingPasswordName}] not found or is blank or whitespace.", result.ErrorText); // Verify that we see an error for an invalid password. result = runner.Execute(Program.Main, "vault", "create", "test4.txt", badPasswordName); Assert.NotEqual(0, result.ExitCode); Assert.Contains($"*** ERROR: [CryptographicException]: Password name [bad/password] contains invalid characters. Only ASCII letters, digits, underscores, dashs and dots are allowed.", result.ErrorText); // Verify that a local [.password-name] file is used successfully when we don't // explicitly pass a password name. File.WriteAllText(".password-name", passwordFile.Name); result = runner.Execute(Program.Main, "vault", "create", "test5.txt"); Assert.Equal(0, result.ExitCode); Assert.True(NeonVault.IsEncrypted("test5.txt", out passwordName)); Assert.Equal(passwordFile.Name, passwordName); Assert.Equal(plainText, Encoding.UTF8.GetString(vault.Decrypt("test5.txt"))); // Verify that a [.password-name] file in the parent directory is used successfully // when we don't explicitly pass a password name. Directory.CreateDirectory("subfolder"); Environment.CurrentDirectory = Path.Combine(Environment.CurrentDirectory, "subfolder"); result = runner.Execute(Program.Main, "vault", "create", "test6.txt"); Assert.Equal(0, result.ExitCode); Assert.True(NeonVault.IsEncrypted("test6.txt", out passwordName)); Assert.Equal(passwordFile.Name, passwordName); Assert.Equal(plainText, Encoding.UTF8.GetString(vault.Decrypt("test6.txt"))); } } } finally { Environment.CurrentDirectory = orgDir; NeonHelper.OpenEditorHandler = null; } } } }
public void PasswordRemove() { ExecuteResponse result; using (var manager = new KubeTestManager()) { using (var runner = new ProgramRunner()) { // Verify that [--help] works: result = runner.Execute(Program.Main, "password", "remove", "--help"); Assert.Equal(0, result.ExitCode); Assert.Contains("Removes a specific named password or all passwords.", result.OutputText); // Add a few passwords: File.WriteAllText(Path.Combine(manager.TestFolder, "pwd-1"), "one"); File.WriteAllText(Path.Combine(manager.TestFolder, "pwd-2"), "two"); File.WriteAllText(Path.Combine(manager.TestFolder, "pwd-3"), "three"); result = runner.Execute(Program.Main, $"password", "set", "pwd-1", Path.Combine(manager.TestFolder, "pwd-1")); Assert.Equal(0, result.ExitCode); result = runner.Execute(Program.Main, $"password", "set", "pwd-2", Path.Combine(manager.TestFolder, "pwd-2")); Assert.Equal(0, result.ExitCode); result = runner.Execute(Program.Main, $"password", "set", "pwd-3", Path.Combine(manager.TestFolder, "pwd-3")); Assert.Equal(0, result.ExitCode); // Verify that we can list the passwords: result = runner.Execute(Program.Main, "password", "ls"); Assert.Equal(0, result.ExitCode); TestHelper.AssertEqualLines( @"pwd-1 pwd-2 pwd-3 ", result.OutputText); // Verify that we can remove a specific password. result = runner.Execute(Program.Main, "password", "rm", "--force", "pwd-2"); Assert.Equal(0, result.ExitCode); result = runner.Execute(Program.Main, "password", "ls"); Assert.Equal(0, result.ExitCode); TestHelper.AssertEqualLines( @"pwd-1 pwd-3 ", result.OutputText); // Verify that we can remove all passwords: result = runner.Execute(Program.Main, "password", "remove", "--force", "*"); Assert.Equal(0, result.ExitCode); result = runner.Execute(Program.Main, "password", "list"); Assert.Equal(0, result.ExitCode); Assert.Empty(result.OutputText); // Verify that we see errors for missing arguments: result = runner.Execute(Program.Main, "password", "rm"); Assert.NotEqual(0, result.ExitCode); Assert.Contains("NAME argument is required.", result.ErrorText); // Verify what we see an error when trying to remove a password // that doesn't exist: result = runner.Execute(Program.Main, "password", "rm", "BAD"); Assert.NotEqual(0, result.ExitCode); Assert.Contains("does not exist", result.ErrorText); } } }
public void PasswordGenerate() { ExecuteResponse result; using (var manager = new KubeTestManager()) { using (var runner = new ProgramRunner()) { //// Verify that [--help] works: result = runner.Execute(Program.Main, "password", "generate", "--help"); Assert.Equal(0, result.ExitCode); Assert.Contains("Generates a cryptographically secure password.", result.OutputText); // Verify that we can generate a password with the default length. result = runner.Execute(Program.Main, "password", "generate"); Assert.Equal(0, result.ExitCode); Assert.Equal(20, result.OutputText.Trim().Length); // Verify that we can generate a password with a specific length. result = runner.Execute(Program.Main, "password", "generate", "30"); Assert.Equal(0, result.ExitCode); Assert.Equal(30, result.OutputText.Trim().Length); result = runner.Execute(Program.Main, "password", "generate", "8"); Assert.Equal(0, result.ExitCode); Assert.Equal(8, result.OutputText.Trim().Length); result = runner.Execute(Program.Main, "password", "generate", "100"); Assert.Equal(0, result.ExitCode); Assert.Equal(100, result.OutputText.Trim().Length); // Verify that invalid password lengths are detected. result = runner.Execute(Program.Main, "password", "generate", "BAD"); Assert.NotEqual(0, result.ExitCode); result = runner.Execute(Program.Main, "password", "generate", "0"); Assert.NotEqual(0, result.ExitCode); result = runner.Execute(Program.Main, "password", "generate", "7"); Assert.NotEqual(0, result.ExitCode); result = runner.Execute(Program.Main, "password", "generate", "101"); Assert.NotEqual(0, result.ExitCode); // Verify that we get different passwords when we run this // multiple times. var previousPasswords = new HashSet <string>(); for (int i = 0; i < 50; i++) { result = runner.Execute(Program.Main, "password", "generate", "100"); Assert.Equal(0, result.ExitCode); var password = result.OutputText.Trim(); Assert.DoesNotContain(previousPasswords, p => p == password); previousPasswords.Add(password); } } } }
public void PasswordSet() { ExecuteResponse result; using (var manager = new KubeTestManager()) { using (var runner = new ProgramRunner()) { // Verify that [--help] works: result = runner.Execute(Program.Main, "password", "set", "--help"); Assert.Equal(0, result.ExitCode); Assert.Contains("Creates or modifies a named password.", result.OutputText); // Add a few passwords via files and verify: File.WriteAllText(Path.Combine(manager.TestFolder, "pwd-1"), "one"); File.WriteAllText(Path.Combine(manager.TestFolder, "pwd-2"), "two"); File.WriteAllText(Path.Combine(manager.TestFolder, "pwd-3"), "three"); result = runner.Execute(Program.Main, $"password", "set", "pwd-1", Path.Combine(manager.TestFolder, "pwd-1")); Assert.Equal(0, result.ExitCode); result = runner.Execute(Program.Main, $"password", "set", "pwd-2", Path.Combine(manager.TestFolder, "pwd-2")); Assert.Equal(0, result.ExitCode); result = runner.Execute(Program.Main, $"password", "set", "pwd-3", Path.Combine(manager.TestFolder, "pwd-3")); Assert.Equal(0, result.ExitCode); result = runner.Execute(Program.Main, "password", "get", "pwd-1"); Assert.Equal(0, result.ExitCode); Assert.Equal("one", result.OutputText.Trim()); result = runner.Execute(Program.Main, "password", "get", "pwd-2"); Assert.Equal(0, result.ExitCode); Assert.Equal("two", result.OutputText.Trim()); result = runner.Execute(Program.Main, "password", "get", "pwd-3"); Assert.Equal(0, result.ExitCode); Assert.Equal("three", result.OutputText.Trim()); // Verify that we can set a password from STDIN: result = runner.Execute(Program.Main, "password", "rm", "--force", "*"); Assert.Equal(0, result.ExitCode); result = runner.ExecuteWithInput(Program.Main, "one", "password", "set", "pwd-1", "-"); Assert.Equal(0, result.ExitCode); result = runner.ExecuteWithInput(Program.Main, "two", "password", "set", "pwd-2", "-"); Assert.Equal(0, result.ExitCode); result = runner.ExecuteWithInput(Program.Main, "three", "password", "set", "pwd-3", "-"); Assert.Equal(0, result.ExitCode); result = runner.Execute(Program.Main, "password", "get", "pwd-1"); Assert.Equal(0, result.ExitCode); Assert.Equal("one", result.OutputText.Trim()); result = runner.Execute(Program.Main, "password", "get", "pwd-2"); Assert.Equal(0, result.ExitCode); Assert.Equal("two", result.OutputText.Trim()); result = runner.Execute(Program.Main, "password", "get", "pwd-3"); Assert.Equal(0, result.ExitCode); Assert.Equal("three", result.OutputText.Trim()); // Verify that we can update a password. result = runner.Execute(Program.Main, "password", "rm", "--force", "*"); Assert.Equal(0, result.ExitCode); result = runner.ExecuteWithInput(Program.Main, "one", "password", "set", "pwd-1", "-"); Assert.Equal(0, result.ExitCode); result = runner.Execute(Program.Main, "password", "get", "pwd-1"); Assert.Equal(0, result.ExitCode); Assert.Equal("one", result.OutputText.Trim()); result = runner.ExecuteWithInput(Program.Main, "1", "password", "set", "pwd-1", "-"); Assert.Equal(0, result.ExitCode); result = runner.Execute(Program.Main, "password", "get", "pwd-1"); Assert.Equal(0, result.ExitCode); Assert.Equal("1", result.OutputText.Trim()); // Verify that password names with all possible character classes works: result = runner.Execute(Program.Main, "password", "rm", "--force", "*"); Assert.Equal(0, result.ExitCode); result = runner.ExecuteWithInput(Program.Main, "password", "password", "set", "a.1_2-3", "-"); Assert.Equal(0, result.ExitCode); result = runner.Execute(Program.Main, "password", "get", "a.1_2-3"); Assert.Equal(0, result.ExitCode); Assert.Equal("password", result.OutputText.Trim()); // Verify that a 20 character password is generated when no PATH argument is passed: result = runner.ExecuteWithInput(Program.Main, "password", "password", "set", "abc"); Assert.Equal(0, result.ExitCode); result = runner.Execute(Program.Main, "password", "get", "abc"); Assert.Equal(0, result.ExitCode); Assert.Equal(20, result.OutputText.Trim().Length); // Verify that we see errors for missing arguments: result = runner.ExecuteWithInput(Program.Main, "password", "password", "set"); Assert.NotEqual(0, result.ExitCode); Assert.Contains("NAME argument is required.", result.ErrorText); // Verify that password name error checking works: result = runner.Execute(Program.Main, "password", "rm", "--force", "*"); Assert.Equal(0, result.ExitCode); result = runner.ExecuteWithInput(Program.Main, "", "password", "set", "pwd@1", "-"); Assert.NotEqual(0, result.ExitCode); result = runner.ExecuteWithInput(Program.Main, "", $"password", "set", $"{new string('a', 101)}", "-"); Assert.NotEqual(0, result.ExitCode); // Verify that password length error checking works: result = runner.Execute(Program.Main, "password", "rm", "--force", "*"); Assert.Equal(0, result.ExitCode); result = runner.ExecuteWithInput(Program.Main, "", "password", "set", "pwd-1", "-"); Assert.NotEqual(0, result.ExitCode); } } }
public async Task Query() { // Verify that the query commands work. var endpoint = bucket.Configuration.GetEndPoint(); var bucketName = bucket.Configuration.BucketName; // Insert a couple documents into the database. var jack = new Person() { Id = 0, Name = "Jack", Age = 10, Data = new byte[] { 0, 1, 2, 3, 4 } }; var jill = new Person() { Id = 1, Name = "Jill", Age = 11, Data = new byte[] { 5, 6, 7, 8, 9 } }; await bucket.InsertSafeAsync(jack, persistTo : PersistTo.One); await bucket.InsertSafeAsync(jill, persistTo : PersistTo.One); await bucket.WaitForIndexerAsync(); bucket.Query <dynamic>($"select count(*) from `{bucket.Name}`;"); using (var runner = new ProgramRunner()) { // Query using the [http://...] target format and passing the query on the command line. var result = runner.Execute(Program.Main, "couchbase", "query", $"http://{endpoint.Address}:{endpoint.Port}@{username}:{password}:{bucketName}", $"select * from `{bucket.Name}`;"); Assert.Equal(0, result.ExitCode); Assert.Contains("Jack", result.OutputText); Assert.Contains("Jill", result.OutputText); // Query again, but using the using the [couchbase://...] target format. result = runner.Execute(Program.Main, "couchbase", "query", $"couchbase://{endpoint.Address}:{endpoint.Port}@{username}:{password}:{bucketName}", $"select * from `{bucket.Name}`;"); Assert.Equal(0, result.ExitCode); Assert.Contains("Jack", result.OutputText); Assert.Contains("Jill", result.OutputText); // Pass the query as a file. using (var tempFile = new TempFile()) { File.WriteAllText(tempFile.Path, $"select * from `{bucket.Name}`;"); result = runner.Execute(Program.Main, "couchbase", "query", $"couchbase://{endpoint.Address}:{endpoint.Port}@{username}:{password}:{bucketName}", $"@{tempFile.Path}"); Assert.Equal(0, result.ExitCode); Assert.Contains("Jack", result.OutputText); Assert.Contains("Jill", result.OutputText); } // Pass the query as STDIN. result = runner.ExecuteWithInput(Program.Main, $"select * from `{bucket.Name}`;", "couchbase", "query", $"couchbase://{endpoint.Address}:{endpoint.Port}@{username}:{password}:{bucketName}", "-"); Assert.Equal(0, result.ExitCode); Assert.Contains("Jack", result.OutputText); Assert.Contains("Jill", result.OutputText); } }
public async Task Upsert() { ExecuteResponse result; // $todo(jeff.lill): // // I'm not testing the document key generation features yet. // Verify that the query commands work. var endpoint = bucket.Configuration.GetEndPoint(); var bucketName = bucket.Configuration.BucketName; // Generate a string with a couple of JSON documents (one per line) // that we'll use for our tests. var jack = new Person() { Id = 0, Name = "Jack", Age = 10, Data = new byte[] { 0, 1, 2, 3, 4 } }; var jill = new Person() { Id = 1, Name = "Jill", Age = 11, Data = new byte[] { 5, 6, 7, 8, 9 } }; var sb = new StringBuilder(); sb.AppendLine(jack.ToString(indented: false)); sb.AppendLine(jill.ToString(indented: false)); using (var runner = new ProgramRunner()) { // Upsert using the [http://...] target format and passing the documents as a file. using (var tempFile = new TempFile()) { File.WriteAllText(tempFile.Path, sb.ToString()); result = runner.Execute(Program.Main, "couchbase", "upsert", $"http://{endpoint.Address}:{endpoint.Port}@{username}:{password}:{bucketName}", tempFile.Path); Assert.Equal(0, result.ExitCode); await bucket.WaitForIndexerAsync(); // Verify that the documents were written. result = runner.ExecuteWithInput(Program.Main, $"select * from `{bucket.Name}`;", "couchbase", "query", $"couchbase://{endpoint.Address}:{endpoint.Port}@{username}:{password}:{bucketName}", "-"); Assert.Equal(0, result.ExitCode); Assert.Contains("Jack", result.OutputText); Assert.Contains("Jill", result.OutputText); } // Generate a couple more documents and test this again but this time passing the // JSON documents as STDIN. var howard = new Person() { Id = 2, Name = "Howard", Age = 10, Data = new byte[] { 0, 1, 2, 3, 4 } }; var john = new Person() { Id = 3, Name = "John", Age = 11, Data = new byte[] { 5, 6, 7, 8, 9 } }; sb.Clear(); sb.AppendLine(howard.ToString(indented: false)); sb.AppendLine(john.ToString(indented: false)); result = runner.ExecuteWithInput(Program.Main, sb.ToString(), "couchbase", "upsert", $"couchbase://{endpoint.Address}:{endpoint.Port}@{username}:{password}:{bucketName}", "-"); await bucket.WaitForIndexerAsync(); Assert.Equal(0, result.ExitCode); // Verify that the documents were written. result = runner.ExecuteWithInput(Program.Main, $"select * from `{bucket.Name}`;", "couchbase", "query", $"couchbase://{endpoint.Address}:{endpoint.Port}@{username}:{password}:{bucketName}", "-"); Assert.Equal(0, result.ExitCode); Assert.Contains("Howard", result.OutputText); Assert.Contains("John", result.OutputText); } }
public void VaultPasswordName() { using (var manager = new KubeTestManager()) { using (var tempFolder = new TempFolder()) { var orgDir = Environment.CurrentDirectory; Environment.CurrentDirectory = tempFolder.Path; NeonHelper.OpenEditorHandler = path => File.WriteAllText(path, plainText); try { using (var passwordFile = new TempFile(folder: KubeHelper.PasswordsFolder)) { File.WriteAllText(passwordFile.Path, testPassword); var vault = new NeonVault(passwordName => testPassword); using (var runner = new ProgramRunner()) { // Verify that the PATH argument is required. var result = runner.Execute(Program.Main, "vault", "password-name"); Assert.NotEqual(0, result.ExitCode); Assert.Contains("*** ERROR: The PATH argument is required.", result.ErrorText); // Verify that we can create an encrypted file with an explicitly // named password. result = runner.Execute(Program.Main, "vault", "create", "test1.txt", passwordFile.Name); Assert.Equal(0, result.ExitCode); Assert.True(NeonVault.IsEncrypted("test1.txt", out var passwordName)); Assert.Equal(passwordFile.Name, passwordName); Assert.Equal(plainText, Encoding.UTF8.GetString(vault.Decrypt("test1.txt"))); // Verify that we can get the password with a line ending. result = runner.Execute(Program.Main, "vault", "password-name", "test1.txt", passwordFile.Name); Assert.Equal(0, result.ExitCode); Assert.Contains(passwordFile.Name, result.OutputText); Assert.Contains("\n", result.OutputText); // Verify that we can get the password without a line ending. result = runner.Execute(Program.Main, "vault", "password-name", "-n", "test1.txt", passwordFile.Name); Assert.Equal(0, result.ExitCode); Assert.Equal(passwordFile.Name, result.OutputText); } } } finally { Environment.CurrentDirectory = orgDir; NeonHelper.OpenEditorHandler = null; } } } }
public void PasswordImportExport() { const string zipPassword = "******"; ExecuteResponse result; using (var manager = new KubeTestManager()) { using (var runner = new ProgramRunner()) { // Verify that [import --help] works: result = runner.Execute(Program.Main, "password", "import", "--help"); Assert.Equal(0, result.ExitCode); Assert.Contains("Imports passwords from an encrypted ZIP file.", result.OutputText); // Verify that [import] checks the PATH argument. result = runner.Execute(Program.Main, "password", "import"); Assert.NotEqual(0, result.ExitCode); Assert.Contains("PATH argument is required.", result.ErrorText); // Verify that [export --help] works: result = runner.Execute(Program.Main, "password", "export", "--help"); Assert.Equal(0, result.ExitCode); Assert.Contains("Exports selected passwords to an encrypted ZIP file.", result.OutputText); // Verify that [export] checks the PATH argument. result = runner.Execute(Program.Main, "password", "export"); Assert.NotEqual(0, result.ExitCode); Assert.Contains("PATH argument is required.", result.ErrorText); // Verify that [export] checks the NAME argument. result = runner.Execute(Program.Main, "password", "export", "test.zip"); Assert.NotEqual(0, result.ExitCode); Assert.Contains("At least one NAME argument is required.", result.ErrorText); // Add a few passwords: result = runner.Execute(Program.Main, "password", "rm", "--force", "*"); Assert.Equal(0, result.ExitCode); result = runner.ExecuteWithInput(Program.Main, "one", "password", "set", "pwd-1", "-"); Assert.Equal(0, result.ExitCode); result = runner.ExecuteWithInput(Program.Main, "two", "password", "set", "pwd-2", "-"); Assert.Equal(0, result.ExitCode); result = runner.ExecuteWithInput(Program.Main, "three", "password", "set", "pwd-3", "-"); Assert.Equal(0, result.ExitCode); // Export all passwords to a ZIP file: var zipPath = Path.Combine(manager.TestFolder, "passwords.zip"); result = runner.ExecuteWithInput(Program.Main, zipPassword, "password", "export", "--stdin", zipPath, "*"); Assert.Equal(0, result.ExitCode); Assert.True(File.Exists(zipPath)); // Remove all passwords, import the passwords using a zip password file, and verify. result = runner.Execute(Program.Main, "password", "rm", "--force", "*"); Assert.Equal(0, result.ExitCode); result = runner.ExecuteWithInput(Program.Main, zipPassword, "password", "import", "--stdin", zipPath); Assert.Equal(0, result.ExitCode); result = runner.Execute(Program.Main, "password", "get", "pwd-1"); Assert.Equal(0, result.ExitCode); Assert.Equal("one", result.OutputText.Trim()); result = runner.Execute(Program.Main, "password", "get", "pwd-2"); Assert.Equal(0, result.ExitCode); Assert.Equal("two", result.OutputText.Trim()); result = runner.Execute(Program.Main, "password", "get", "pwd-3"); Assert.Equal(0, result.ExitCode); Assert.Equal("three", result.OutputText.Trim()); // Export two of the three passwords to a ZIP file: result = runner.ExecuteWithInput(Program.Main, zipPassword, "password", "export", "--stdin", zipPath, "pwd-1", "pwd-2"); Assert.Equal(0, result.ExitCode); Assert.True(File.Exists(zipPath)); // Remove all passwords, import the passwords using a zip password file, and verify. result = runner.Execute(Program.Main, "password", "rm", "--force", "*"); Assert.Equal(0, result.ExitCode); result = runner.ExecuteWithInput(Program.Main, zipPassword, "password", "import", "--stdin", zipPath); Assert.Equal(0, result.ExitCode); result = runner.Execute(Program.Main, "password", "get", "pwd-1"); Assert.Equal(0, result.ExitCode); Assert.Equal("one", result.OutputText.Trim()); result = runner.Execute(Program.Main, "password", "get", "pwd-2"); Assert.Equal(0, result.ExitCode); Assert.Equal("two", result.OutputText.Trim()); result = runner.Execute(Program.Main, "password", "get", "pwd-3"); Assert.NotEqual(0, result.ExitCode); // This one wasn't exported. } } }
public void DecryptFile() { var orgDirectory = Environment.CurrentDirectory; try { using (var manager = new KubeTestManager()) { using (var runner = new ProgramRunner()) { using (var tempFolder = new TempFolder()) { Environment.CurrentDirectory = tempFolder.Path; var vault = new NeonVault(Program.LookupPassword); // Create a test password and a [.password-name] file in the // temp test folder. var result = runner.Execute(Program.Main, $"password", "set", "test"); Assert.Equal(0, result.ExitCode); //------------------------------------------------- // Verify that we can decrypt a file. File.WriteAllText("test.cmd", "type %1 > output.txt"); const string plainText = "The quick brown fox jumped over the lazy dog."; File.WriteAllText("file.txt", plainText); File.WriteAllBytes("file.txt", vault.Encrypt("file.txt", "test")); Assert.True(NeonVault.IsEncrypted("file.txt")); result = runner.Execute(Program.Main, $"run", "--", "test.cmd", "_...file.txt"); Assert.Equal(0, result.ExitCode); var output = File.ReadAllText("output.txt"); Assert.Contains(plainText, output); File.Delete("output.txt"); File.Delete("file.txt"); //------------------------------------------------- // Try this again calling a command directly (batch files seem to have different behavior). File.WriteAllText("type", "%1"); File.WriteAllText("file.txt", plainText); File.WriteAllBytes("file.txt", vault.Encrypt("file.txt", "test")); Assert.True(NeonVault.IsEncrypted("file.txt")); result = runner.Execute(Program.Main, $"run", "--", "cat", "_...file.txt"); Assert.Equal(0, result.ExitCode); Assert.Contains(plainText, result.OutputText); File.Delete("output.txt"); File.Delete("file.txt"); } } } } finally { Environment.CurrentDirectory = orgDirectory; } }
public void PasswordBasics() { ExecuteResponse result; // Verify basic password operations: get, set, list|ls, and remove|rm: using (var manager = new KubeTestManager()) { using (var runner = new ProgramRunner()) { // We should start out with no passwords: result = runner.Execute(Program.Main, "password", "list"); Assert.Equal(0, result.ExitCode); Assert.Empty(result.OutputText.Trim()); result = runner.Execute(Program.Main, "password", "ls"); Assert.Equal(0, result.ExitCode); Assert.Empty(result.OutputText.Trim()); // Add a few passwords via files and verify: File.WriteAllText(Path.Combine(manager.TestFolder, "pwd-1"), "one"); File.WriteAllText(Path.Combine(manager.TestFolder, "pwd-2"), "two"); File.WriteAllText(Path.Combine(manager.TestFolder, "pwd-3"), "three"); result = runner.Execute(Program.Main, $"password", "set", "pwd-1", Path.Combine(manager.TestFolder, "pwd-1")); Assert.Equal(0, result.ExitCode); result = runner.Execute(Program.Main, $"password", "set", "pwd-2", Path.Combine(manager.TestFolder, "pwd-2")); Assert.Equal(0, result.ExitCode); result = runner.Execute(Program.Main, $"password", "set", "pwd-3", Path.Combine(manager.TestFolder, "pwd-3")); Assert.Equal(0, result.ExitCode); result = runner.Execute(Program.Main, "password", "get", "pwd-1"); Assert.Equal(0, result.ExitCode); Assert.Equal("one", result.OutputText.Trim()); result = runner.Execute(Program.Main, "password", "get", "pwd-2"); Assert.Equal(0, result.ExitCode); Assert.Equal("two", result.OutputText.Trim()); result = runner.Execute(Program.Main, "password", "get", "pwd-3"); Assert.Equal(0, result.ExitCode); Assert.Equal("three", result.OutputText.Trim()); // Verify that we can list the passwords: result = runner.Execute(Program.Main, "password", "ls"); Assert.Equal(0, result.ExitCode); TestHelper.AssertEqualLines( @"pwd-1 pwd-2 pwd-3 ", result.OutputText); // Verify that we can remove a specific password. result = runner.Execute(Program.Main, "password", "rm", "--force", "pwd-2"); Assert.Equal(0, result.ExitCode); result = runner.Execute(Program.Main, "password", "ls"); Assert.Equal(0, result.ExitCode); TestHelper.AssertEqualLines( @"pwd-1 pwd-3 ", result.OutputText); // Verify that we can remove all passwords: result = runner.Execute(Program.Main, "password", "rm", "--force", "*"); Assert.Equal(0, result.ExitCode); result = runner.Execute(Program.Main, "password", "ls"); Assert.Equal(0, result.ExitCode); Assert.Empty(result.OutputText); } } }
public void VaultEncrypt() { using (var manager = new KubeTestManager()) { using (var tempFolder = new TempFolder()) { var orgDir = Environment.CurrentDirectory; Environment.CurrentDirectory = tempFolder.Path; NeonHelper.OpenEditorHandler = path => File.WriteAllText(path, plainText); try { using (var passwordFile = new TempFile(folder: KubeHelper.PasswordsFolder)) { File.WriteAllText(passwordFile.Path, testPassword); var vault = new NeonVault(passwordName => testPassword); using (var runner = new ProgramRunner()) { // Verify that the PATH argument is required. var result = runner.Execute(Program.Main, "vault", "encrypt"); Assert.NotEqual(0, result.ExitCode); Assert.Contains("*** ERROR: The PATH argument is required.", result.ErrorText); // Verify that the TARGET argument is required when [--password-name] // or [--p] is not present. result = runner.Execute(Program.Main, "vault", "decrypt", "source.txt"); Assert.NotEqual(0, result.ExitCode); Assert.Contains("*** ERROR: The TARGET argument is required.", result.ErrorText); // Verify that we can encrypt a file in-place, specifying an // explicit password name (using --password-name=NAME). File.WriteAllText("test1.txt", plainText); result = runner.Execute(Program.Main, "vault", "encrypt", "test1.txt", $"--password-name={passwordFile.Name}"); Assert.Equal(0, result.ExitCode); Assert.True(NeonVault.IsEncrypted("test1.txt", out var passwordName)); Assert.Equal(passwordFile.Name, passwordName); Assert.Equal(plainText, Encoding.UTF8.GetString(vault.Decrypt("test1.txt"))); // Verify that we can encrypt a file in-place, specifying an // explicit password name (using --p=NAME). File.WriteAllText("test2.txt", plainText); result = runner.Execute(Program.Main, "vault", "encrypt", "test2.txt", $"-p={passwordFile.Name}"); Assert.Equal(0, result.ExitCode); Assert.True(NeonVault.IsEncrypted("test2.txt", out passwordName)); Assert.Equal(passwordFile.Name, passwordName); Assert.Equal(plainText, Encoding.UTF8.GetString(vault.Decrypt("test2.txt"))); // Verify that we get an error trying to encrypt in-place without a // password name being explicitly specified and also without a // [.password-name] file present. File.WriteAllText("test3.txt", plainText); result = runner.Execute(Program.Main, "vault", "encrypt", "test3.txt"); Assert.NotEqual(0, result.ExitCode); Assert.Contains("*** ERROR: A PASSWORD-NAME argument or [.password-name] file is required.", result.ErrorText); // Verify that we get an error trying to encrypt (not in-place) without a // password name being explicitly specified and also without a // [.password-name] file present. File.WriteAllText("test4.txt", plainText); result = runner.Execute(Program.Main, "vault", "encrypt", "test4.txt", "test4.encypted.txt"); Assert.NotEqual(0, result.ExitCode); Assert.Contains("*** ERROR: A PASSWORD-NAME argument or [.password-name] file is required.", result.ErrorText); // Verify that we can encrypt a file to another with // and explicit password argument. File.WriteAllText("test5.txt", plainText); result = runner.Execute(Program.Main, "vault", "encrypt", "test5.txt", "test5.encypted.txt", passwordName); Assert.Equal(0, result.ExitCode); Assert.True(NeonVault.IsEncrypted("test5.encypted.txt", out passwordName)); Assert.Equal(passwordFile.Name, passwordName); Assert.Equal(plainText, Encoding.UTF8.GetString(vault.Decrypt("test5.encypted.txt"))); // Verify that we can encrypt a file to another with // and explicit [--password-name] option. File.WriteAllText("test6.txt", plainText); result = runner.Execute(Program.Main, "vault", "encrypt", "test6.txt", "test6.encypted.txt", $"--password-name={passwordName}"); Assert.Equal(0, result.ExitCode); Assert.True(NeonVault.IsEncrypted("test6.encypted.txt", out passwordName)); Assert.Equal(passwordFile.Name, passwordName); Assert.Equal(plainText, Encoding.UTF8.GetString(vault.Decrypt("test6.encypted.txt"))); // Verify that we can encrypt a file in-place using a [.password-name] file. File.WriteAllText("test7.txt", plainText); File.WriteAllText(".password-name", passwordName); result = runner.Execute(Program.Main, "vault", "encrypt", "test7.txt"); Assert.Equal(0, result.ExitCode); Assert.True(NeonVault.IsEncrypted("test7.txt", out passwordName)); Assert.Equal(passwordFile.Name, passwordName); Assert.Equal(plainText, Encoding.UTF8.GetString(vault.Decrypt("test7.txt"))); // Verify that we can encrypt a file (not in-place) to another where // the source file is located in a different directory from the target // to ensure that we look for the [.password-name] file starting at // the target directory. using (var tempFile = new TempFile()) { File.WriteAllText(tempFile.Path, plainText); result = runner.Execute(Program.Main, "vault", "encrypt", tempFile.Path, "test8.encrypted.txt"); Assert.Equal(0, result.ExitCode); Assert.True(NeonVault.IsEncrypted("test8.encrypted.txt", out passwordName)); Assert.Equal(passwordFile.Name, passwordName); Assert.Equal(plainText, Encoding.UTF8.GetString(vault.Decrypt("test8.encrypted.txt"))); } } } } finally { Environment.CurrentDirectory = orgDir; NeonHelper.OpenEditorHandler = null; } } } }