Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
package generate_test
import (
"crypto/ecdsa"
"crypto/elliptic"
"crypto/mldsa"
"crypto/x509"
"encoding/pem"
"net"
"os"
"path/filepath"
"testing"
"github.com/stretchr/testify/require"
"github.com/getarcaneapp/arcane/cli/v2/pkg/generate"
)
func TestGenerateMTLSCommandWritesMLDSA87Assets(t *testing.T) {
outDir := t.TempDir()
cmd := generate.Command()
cmd.SetArgs([]string{"mtls", "--out-dir", outDir, "--env-id", "env-123", "--app-url", "https://manager.example.com"})
_, err := captureOutput(func() error {
_, err := cmd.ExecuteC()
return err
})
require.NoError(t, err,
"command failed: %v", err)
assertMLDSA87PrivateKey(t, filepath.Join(outDir, "ca.key"))
assertMLDSA87PrivateKey(t, filepath.Join(outDir, "agent.key"))
assertMLDSA87Certificate(t, filepath.Join(outDir, "ca.crt"))
cert := assertMLDSA87Certificate(t, filepath.Join(outDir, "agent.crt"))
require.False(t, len(cert.URIs) == 0 || cert.URIs[0].String() != "spiffe://manager.example.com/edge/env-123",
"expected edge SPIFFE URI SAN, got %v", cert.URIs)
}
func TestGenerateTLSCommandWritesECDSAP384ServerCert(t *testing.T) {
outDir := t.TempDir()
cmd := generate.Command()
cmd.SetArgs([]string{"tls", "--out-dir", outDir, "--common-name", "localhost", "--host", "localhost", "--host", "127.0.0.1", "--cert-name", "local-manager.crt", "--key-name", "local-manager.key"})
_, err := captureOutput(func() error {
_, err := cmd.ExecuteC()
return err
})
require.NoError(t, err,
"command failed: %v", err)
assertECDSAP384PrivateKey(t, filepath.Join(outDir, "local-manager.key"))
cert := assertECDSAP384Certificate(t, filepath.Join(outDir, "local-manager.crt"))
require.Equal(t, []string{"localhost"}, cert.DNSNames,
"expected only localhost DNS SAN, got %v", cert.DNSNames)
require.False(t, len(cert.IPAddresses) == 0 || !cert.IPAddresses[0].Equal(net.ParseIP("127.0.0.1")),
"expected 127.0.0.1 IP SAN, got %v", cert.IPAddresses)
}
func TestGenerateTLSCommandOverwritesCertificateAtomically(t *testing.T) {
outDir := t.TempDir()
cmd := generate.Command()
cmd.SetArgs([]string{"tls", "--out-dir", outDir, "--common-name", "localhost", "--host", "localhost", "--cert-name", "server.crt", "--key-name", "server.key"})
_, err := captureOutput(func() error {
_, err := cmd.ExecuteC()
return err
})
require.NoError(t, err,
"command failed: %v", err)
certPath := filepath.Join(outDir, "server.crt")
keyPath := filepath.Join(outDir, "server.key")
require.Equal(t, []string{"localhost"}, assertECDSAP384Certificate(t, certPath).DNSNames)
firstCert, err := os.ReadFile(certPath)
require.NoError(t, err,
"failed to read first cert: %v", err)
cmd = generate.Command()
cmd.SetArgs([]string{"tls", "--out-dir", outDir, "--common-name", "localhost", "--host", "localhost", "--cert-name", "server.crt", "--key-name", "server.key"})
_, err = captureOutput(func() error {
_, executeCErr := cmd.ExecuteC()
return executeCErr
})
require.NoError(t, err,
"command failed: %v", err)
secondCert, err := os.ReadFile(certPath)
require.NoError(t, err,
"failed to read second cert: %v", err)
require.NotEqual(t, string(secondCert), string(firstCert),
"expected certificate to be replaced on second generation")
require.Equal(t, []string{"localhost"}, assertECDSAP384Certificate(t, certPath).DNSNames)
assertECDSAP384PrivateKey(t, keyPath)
tmpFiles, err := filepath.Glob(filepath.Join(outDir, "*.tmp-*"))
require.NoError(t, err,
"failed to glob temp files: %v", err)
require.Empty(t, tmpFiles,
"expected atomic write temp files to be cleaned up, got %v", tmpFiles)
}
func assertECDSAP384PrivateKey(t *testing.T, path string) {
t.Helper()
pemBytes, err := os.ReadFile(path)
require.NoError(t, err,
"failed to read key %s: %v", path, err)
block, _ := pem.Decode(pemBytes)
require.NotNil(t, block,
"failed to decode key PEM %s", path)
require.Equal(t, "PRIVATE KEY", block.Type,
"expected PRIVATE KEY for %s, got %s", path, block.Type)
parsed, err := x509.ParsePKCS8PrivateKey(block.Bytes)
require.NoError(t, err,
"failed to parse private key %s: %v", path, err)
key, ok := parsed.(*ecdsa.PrivateKey)
require.True(t, ok,
"expected ECDSA private key for %s", path)
require.Equal(t, elliptic.P384(), key.Curve,
"expected P-384 private key for %s", path)
}
func assertMLDSA87PrivateKey(t *testing.T, path string) {
t.Helper()
pemBytes, err := os.ReadFile(path)
require.NoError(t, err,
"failed to read key %s: %v", path, err)
block, _ := pem.Decode(pemBytes)
require.NotNil(t, block,
"failed to decode key PEM %s", path)
require.Equal(t, "PRIVATE KEY", block.Type,
"expected PRIVATE KEY for %s, got %s", path, block.Type)
parsed, err := x509.ParsePKCS8PrivateKey(block.Bytes)
require.NoError(t, err,
"failed to parse private key %s: %v", path, err)
key, ok := parsed.(*mldsa.PrivateKey)
require.True(t, ok,
"expected ML-DSA private key for %s", path)
require.Equal(t, mldsa.MLDSA87(), key.PublicKey().Parameters(),
"expected ML-DSA-87 private key for %s", path)
}
func assertMLDSA87Certificate(t *testing.T, path string) *x509.Certificate {
t.Helper()
pemBytes, err := os.ReadFile(path)
require.NoError(t, err,
"failed to read certificate %s: %v", path, err)
block, _ := pem.Decode(pemBytes)
require.NotNil(t, block,
"failed to decode certificate PEM %s", path)
cert, err := x509.ParseCertificate(block.Bytes)
require.NoError(t, err,
"failed to parse certificate %s: %v", path, err)
publicKey, ok := cert.PublicKey.(*mldsa.PublicKey)
require.True(t, ok,
"expected ML-DSA public key for %s", path)
require.Equal(t, mldsa.MLDSA87(), publicKey.Parameters(),
"expected ML-DSA-87 certificate for %s", path)
return cert
}
func assertECDSAP384Certificate(t *testing.T, path string) *x509.Certificate {
t.Helper()
pemBytes, err := os.ReadFile(path)
require.NoError(t, err,
"failed to read certificate %s: %v", path, err)
block, _ := pem.Decode(pemBytes)
require.NotNil(t, block,
"failed to decode certificate PEM %s", path)
cert, err := x509.ParseCertificate(block.Bytes)
require.NoError(t, err,
"failed to parse certificate %s: %v", path, err)
publicKey, ok := cert.PublicKey.(*ecdsa.PublicKey)
require.True(t, ok,
"expected ECDSA public key for %s", path)
require.Equal(t, elliptic.P384(), publicKey.Curve,
"expected P-384 certificate for %s", path)
return cert
}