Merge pull request #17 from vojtech-vit-massive/feature/#16-certificates

feat: support for certificate APIs

Octopus-Cmdlets.Tests/AddCertificateTests.cs

@@ -0,0 +1,123 @@
+using System.Collections.Generic;
+using System.Management.Automation;
+using Xunit;
+using Moq;
+using Octopus.Client.Model;
+using Octopus.Client.Repositories;
+using System.Text;
+
+namespace Octopus_Cmdlets.Tests
+{
+    public class AddCertificateTests
+    {
+        private const string CmdletName = "Add-OctoCertificate";
+        private PowerShell _ps;
+        private readonly List<CertificateResource> _certs = new List<CertificateResource>();
+
+        public AddCertificateTests()
+        {
+            _ps = Utilities.CreatePowerShell(CmdletName, typeof (AddCertificate));
+            var octoRepo = Utilities.AddOctopusRepo(_ps.Runspace.SessionStateProxy.PSVariable);
+
+            _certs.Clear();
+
+            var envRepo = new Mock<ICertificateRepository>();
+            envRepo.Setup(c => c.Create(It.IsAny<CertificateResource>(), It.IsAny<object>()))
+                .Returns((CertificateResource c, object o) =>
+                {
+                    _certs.Add(c);
+                    return c;
+                });
+
+            octoRepo.Setup(o => o.Certificates).Returns(envRepo.Object);
+        }
+
+        [Fact]
+        public void With_Name()
+        {
+            // Execute cmdlet
+            _ps.AddCommand(CmdletName)
+                .AddParameter(nameof(AddCertificate.Name), "Octopus_Dev");
+
+            Assert.Throws<ParameterBindingException>(() => _ps.Invoke());
+        }
+
+        [Fact]
+        public void With_CertificateData()
+        {
+            // Execute cmdlet
+            _ps.AddCommand(CmdletName)
+                .AddParameter(nameof(AddCertificate.CertificateData), "CertData");
+
+            Assert.Throws<ParameterBindingException>(() => _ps.Invoke());
+        }
+
+        [Fact]
+        public void With_Name_And_CertificateData()
+        {
+            // Execute cmdlet
+            _ps.AddCommand(CmdletName)
+                .AddParameter(nameof(AddCertificate.Name), "Octopus_Dev")
+                .AddParameter(nameof(AddCertificate.CertificateData), "CertData");
+            _ps.Invoke();
+
+            Assert.Single(_certs);
+            Assert.Equal("Octopus_Dev", _certs[0].Name);
+            Assert.Equal("CertData", _certs[0].CertificateData.NewValue);
+        }
+
+        [Fact]
+        public void With_Name_And_CertificateData_And_Notes()
+        {
+            // Execute cmdlet
+            _ps.AddCommand(CmdletName)
+                .AddParameter(nameof(AddCertificate.Name), "Octopus_Dev")
+                .AddParameter(nameof(AddCertificate.CertificateData), "CertData")
+                .AddParameter(nameof(AddCertificate.Notes), "Octopus Development certificate");
+            _ps.Invoke();
+
+            Assert.Single(_certs);
+            Assert.Equal("Octopus_Dev", _certs[0].Name);
+            Assert.Equal("CertData", _certs[0].CertificateData.NewValue);
+            Assert.Equal("Octopus Development certificate", _certs[0].Notes);
+        }
+
+        [Fact]
+        public void With_Name_And_CertificateData_And_Environments()
+        {
+            // Execute cmdlet
+            _ps.AddCommand(CmdletName)
+                .AddParameter(nameof(AddCertificate.Name), "Octopus_Dev")
+                .AddParameter(nameof(AddCertificate.CertificateData), "CertData")
+                .AddParameter(nameof(AddCertificate.Environments), new[] { "Env1", "Env2" });
+            _ps.Invoke();
+
+            Assert.Single(_certs);
+            Assert.Equal("Octopus_Dev", _certs[0].Name);
+            Assert.Equal("CertData", _certs[0].CertificateData.NewValue);
+            Assert.True(_certs[0].EnvironmentIds.SetEquals(new[] { "Env1", "Env2" }));
+        }
+
+        [Fact]
+        public void With_Arguments()
+        {
+            // Execute cmdlet
+            _ps.AddCommand(CmdletName)
+                .AddArgument("Octopus_Dev")
+                .AddParameter(nameof(AddCertificate.CertificateData), "CertData");
+            _ps.Invoke();
+
+            Assert.Single(_certs);
+            Assert.Equal("Octopus_Dev", _certs[0].Name);
+            Assert.Equal("CertData", _certs[0].CertificateData.NewValue);
+        }
+
+        [Fact]
+        public void No_Arguments()
+        {
+            // Execute cmdlet
+            _ps.AddCommand(CmdletName);
+            Assert.Throws<ParameterBindingException>(() => _ps.Invoke());
+        }
+    }
+}

Octopus-Cmdlets.Tests/GetCertificateTests.cs

@@ -0,0 +1,111 @@
+using System.Collections.Generic;
+using System.Management.Automation;
+using Xunit;
+using Octopus.Client.Model;
+
+namespace Octopus_Cmdlets.Tests
+{
+    public class GetCertificateTests
+    {
+        private const string CmdletName = "Get-OctoCertificate";
+        private PowerShell _ps;
+
+        public GetCertificateTests()
+        {
+            _ps = Utilities.CreatePowerShell(CmdletName, typeof(GetCertificate));
+
+            var octoRepo = Utilities.AddOctopusRepo(_ps.Runspace.SessionStateProxy.PSVariable);
+
+            // Create some certificates
+            var certificates = new List<CertificateResource>
+            {
+                new CertificateResource("Octopus", "OctopusData") { Id = "certificates-1", EnvironmentIds = new ReferenceCollection("env1")},
+                new CertificateResource("Deploy", "DeployData") { Id = "certificates-2", EnvironmentIds = new ReferenceCollection("env2")},
+                new CertificateResource("Automation", "AutomationData") { Id = "certificates-3", EnvironmentIds = new ReferenceCollection("env3")},
+                new CertificateResource("Server", "ServerData") { Id = "certificates-4", EnvironmentIds = new ReferenceCollection("env4")},
+            };
+            octoRepo.Setup(o => o.Certificates.FindAll(null, null)).Returns(certificates);
+        }
+
+        [Fact]
+        public void No_Arguments()
+        {
+            // Execute cmdlet
+            _ps.AddCommand(CmdletName);
+            var certificates = _ps.Invoke<CertificateResource>();
+
+            Assert.Equal(4, certificates.Count);
+        }
+
+        [Fact]
+        public void With_Name()
+        {
+            // Execute cmdlet
+            _ps.AddCommand(CmdletName).AddArgument("Octopus");
+            var certificates = _ps.Invoke<CertificateResource>();
+
+            Assert.Single(certificates);
+            Assert.Equal("Octopus", certificates[0].Name);
+        }
+
+        [Fact]
+        public void With_Invalid_Name()
+        {
+            // Execute cmdlet
+            _ps.AddCommand(CmdletName).AddArgument("Gibberish");
+            var certificates = _ps.Invoke<CertificateResource>();
+
+            Assert.Empty(certificates);
+        }
+
+        [Fact]
+        public void With_Id()
+        {
+            // Execute cmdlet
+            _ps.AddCommand(CmdletName).AddParameter("Id", "certificates-1");
+            var certificates = _ps.Invoke<CertificateResource>();
+
+            Assert.Single(certificates);
+            Assert.Equal("Octopus", certificates[0].Name);
+        }
+
+        [Fact]
+        public void With_Invalid_Id()
+        {
+            // Execute cmdlet
+            _ps.AddCommand(CmdletName).AddParameter("Id", "Gibberish");
+            var certificates = _ps.Invoke<CertificateResource>();
+
+            Assert.Empty(certificates);
+        }
+
+        [Fact]
+        public void With_Environment()
+        {
+            // Execute cmdlet
+            _ps.AddCommand(CmdletName).AddParameter("Environment", "env1");
+            var certificates = _ps.Invoke<CertificateResource>();
+
+            Assert.Single(certificates);
+            Assert.Equal("Octopus", certificates[0].Name);
+        }
+
+        [Fact]
+        public void With_Invalid_EnvironmentValue()
+        {
+            // Execute cmdlet
+            _ps.AddCommand(CmdletName).AddParameter("Environment", "Gibberish");
+            var certificates = _ps.Invoke<CertificateResource>();
+
+            Assert.Empty(certificates);
+        }
+
+        [Fact]
+        public void With_Id_And_Name()
+        {
+            // Execute cmdlet
+            _ps.AddCommand(CmdletName).AddParameter("Name", "Name").AddParameter("Id", "Id");
+            Assert.Throws<ParameterBindingException>(() => _ps.Invoke());
+        }
+    }
+}

Octopus-Cmdlets.Tests/RemoveCertificateTests.cs

@@ -0,0 +1,132 @@
+using System.Collections.Generic;
+using System.Management.Automation;
+using Xunit;
+using Moq;
+using Octopus.Client.Exceptions;
+using Octopus.Client.Model;
+
+namespace Octopus_Cmdlets.Tests
+{
+    public class RemoveCertificateTests
+    {
+        private const string CmdletName = "Remove-OctoCertificate";
+        private PowerShell _ps;
+        private readonly List<CertificateResource> _certs = new List<CertificateResource>();
+
+        private readonly CertificateResource _cert = new CertificateResource("CERT2", "CertData2");
+
+        public RemoveCertificateTests()
+        {
+            _ps = Utilities.CreatePowerShell(CmdletName, typeof(RemoveCertificate));
+
+            var octoRepo = Utilities.AddOctopusRepo(_ps.Runspace.SessionStateProxy.PSVariable);
+
+            // Create some library variable sets
+            _certs.Clear();
+            _certs.Add(new CertificateResource("CERT 1", "CertData1") { Id = "CERT1" });
+            _certs.Add(_cert);
+            _certs.Add(new CertificateResource("CERT 3", "CertData3") { Id = "CERT3" });
+
+            octoRepo.Setup(o => o.Certificates.Delete(It.IsAny<CertificateResource>())).Callback(
+                (CertificateResource set) =>
+                {
+                    if (_certs.Contains(set))
+                        _certs.Remove(set);
+                    else
+                        throw new KeyNotFoundException("The given key was not present in the dictionary.");
+                }
+                );
+
+            octoRepo.Setup(o => o.Certificates.Get("CERT1")).Returns(_cert);
+            octoRepo.Setup(o => o.Certificates.Get(It.IsNotIn(new[] { "CERT1" })))
+                .Throws(new OctopusResourceNotFoundException("Not Found"));
+
+            octoRepo.Setup(o => o.Certificates.FindByName("CERT 2", It.IsAny<string>(), It.IsAny<object>())).Returns(_cert);
+            octoRepo.Setup(o => o.Certificates.FindByName("Gibberish", It.IsAny<string>(), It.IsAny<object>())).Returns((CertificateResource) null);
+        }
+
+        [Fact]
+        public void No_Arguments()
+        {
+            // Execute cmdlet
+            _ps.AddCommand(CmdletName);
+            Assert.Throws<ParameterBindingException>(() => _ps.Invoke());
+        }
+
+        [Fact]
+        public void With_Id()
+        {
+            // Execute cmdlet
+            _ps.AddCommand(CmdletName).AddParameter("Id", new [] {"CERT1"});
+            _ps.Invoke();
+
+            Assert.Equal(2, _certs.Count);
+            Assert.DoesNotContain(_cert, _certs);
+        }
+
+        [Fact]
+        public void With_Invalid_Id()
+        {
+            // Execute cmdlet
+            _ps.AddCommand(CmdletName).AddParameter("Id", new[] {"Gibberish"});
+            _ps.Invoke();
+
+            Assert.Equal(3, _certs.Count);
+            Assert.Single(_ps.Streams.Warning);
+            Assert.Equal("A certificate with the id 'Gibberish' does not exist.", _ps.Streams.Warning[0].ToString());
+        }
+
+        [Fact]
+        public void With_Name()
+        {
+            // Execute cmdlet
+            _ps.AddCommand(CmdletName).AddParameter("Name", new[] {"CERT 2"});
+            _ps.Invoke();
+
+            Assert.Equal(2, _certs.Count);
+            Assert.DoesNotContain(_cert, _certs);
+        }
+
+        [Fact]
+        public void With_Invalid_Name()
+        {
+            // Execute cmdlet
+            _ps.AddCommand(CmdletName).AddParameter("Name", new[] { "Gibberish" });
+            _ps.Invoke();
+
+            Assert.Equal(3, _certs.Count);
+            Assert.Single(_ps.Streams.Warning);
+            Assert.Equal("The certificate 'Gibberish' does not exist.", _ps.Streams.Warning[0].ToString());
+        }
+
+        [Fact]
+        public void With_Valid_And_Invalid_Names()
+        {
+            // Execute cmdlet
+            _ps.AddCommand(CmdletName).AddParameter("Name", new[] { "CERT 2", "Gibberish" });
+            _ps.Invoke();
+
+            Assert.Equal(2, _certs.Count);
+            Assert.DoesNotContain(_cert, _certs);
+        }
+
+        [Fact]
+        public void With_Arguments()
+        {
+            // Execute cmdlet
+            _ps.AddCommand(CmdletName).AddArgument(new[] { "CERT 2" });
+            _ps.Invoke();
+
+            Assert.Equal(2, _certs.Count);
+            Assert.DoesNotContain(_cert, _certs);
+        }
+
+        [Fact]
+        public void With_Name_And_Id()
+        {
+            // Execute cmdlet
+            _ps.AddCommand(CmdletName).AddParameter("Name", "Gibberish").AddParameter("Id", "Gibberish");
+            Assert.Throws<ParameterBindingException>(() => _ps.Invoke());
+        }
+    }
+}