GuanM/certimate
1
0
Fork 0
mirror of https://github.com/usual2970/certimate.git synced 2025-10-05 22:14:53 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

test: use flag arguments in test cases for Notifier and Deployer

Browse Source
This commit is contained in:
Fu Diwei
2024-11-19 21:18:36 +08:00
parent 51fb9dca58
commit 414d8d140e
5 changed files with 386 additions and 215 deletions
Download Patch File Download Diff File Expand all files Collapse all files

247
internal/pkg/core/deployer/providers/local/local_test.go
View File

@@ -2,118 +2,185 @@
import (
"context"
"flag"
"fmt"
"os"
"strings"
"testing"
dLocal "github.com/usual2970/certimate/internal/pkg/core/deployer/providers/local"
)
/*
Shell command to run this test:
var (
fInputCertPath string
fInputKeyPath string
fOutputCertPath string
fOutputKeyPath string
fPfxPassword string
fJksAlias string
fJksKeypass string
fJksStorepass string
)
CERTIMATE_DEPLOYER_LOCAL_INPUTCERTPATH="/path/to/your-input-cert.pem" \
CERTIMATE_DEPLOYER_LOCAL_INPUTKEYPATH="/path/to/your-input-key.pem" \
CERTIMATE_DEPLOYER_LOCAL_OUTPUTCERTPATH="/path/to/your-output-cert.pem" \
CERTIMATE_DEPLOYER_LOCAL_OUTPUTKEYPATH="/path/to/your-output-key.pem" \
go test -v -run TestDeploy local_test.go
*/
func TestDeploy(t *testing.T) {
envPrefix := "CERTIMATE_DEPLOYER_LOCAL_"
tInputCertData, _ := os.ReadFile(os.Getenv(envPrefix + "INPUTCERTPATH"))
tInputKeyData, _ := os.ReadFile(os.Getenv(envPrefix + "INPUTKEYPATH"))
tOutputCertPath := os.Getenv(envPrefix + "OUTPUTCERTPATH")
tOutputKeyPath := os.Getenv(envPrefix + "OUTPUTKEYPATH")
func init() {
argsPrefix := "CERTIMATE_DEPLOYER_LOCAL_"
deployer, err := dLocal.New(&dLocal.LocalDeployerConfig{
OutputCertPath: tOutputCertPath,
OutputKeyPath: tOutputKeyPath,
})
if err != nil {
t.Errorf("err: %+v", err)
panic(err)
}
res, err := deployer.Deploy(context.Background(), string(tInputCertData), string(tInputKeyData))
if err != nil {
t.Errorf("err: %+v", err)
panic(err)
}
t.Logf("ok: %v", res)
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
flag.StringVar(&fOutputCertPath, argsPrefix+"OUTPUTCERTPATH", "", "")
flag.StringVar(&fOutputKeyPath, argsPrefix+"OUTPUTKEYPATH", "", "")
flag.StringVar(&fPfxPassword, argsPrefix+"PFXPASSWORD", "", "")
flag.StringVar(&fJksAlias, argsPrefix+"JKSALIAS", "", "")
flag.StringVar(&fJksKeypass, argsPrefix+"JKSKEYPASS", "", "")
flag.StringVar(&fJksStorepass, argsPrefix+"JKSSTOREPASS", "", "")
}
/*
Shell command to run this test:
CERTIMATE_DEPLOYER_LOCAL_INPUTCERTPATH="/path/to/your-input-cert.pem" \
CERTIMATE_DEPLOYER_LOCAL_INPUTKEYPATH="/path/to/your-input-key.pem" \
CERTIMATE_DEPLOYER_LOCAL_OUTPUTCERTPATH="/path/to/your-output-cert.pem" \
CERTIMATE_DEPLOYER_LOCAL_PFXPASSWORD="your-pfx-password" \
go test -v -run TestDeploy_PFX local_test.go
go test -v local_test.go -args \
--CERTIMATE_DEPLOYER_LOCAL_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_DEPLOYER_LOCAL_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_DEPLOYER_LOCAL_OUTPUTCERTPATH="/path/to/your-output-cert" \
--CERTIMATE_DEPLOYER_LOCAL_OUTPUTKEYPATH="/path/to/your-output-key" \
--CERTIMATE_DEPLOYER_LOCAL_PFXPASSWORD="your-pfx-password" \
--CERTIMATE_DEPLOYER_LOCAL_JKSALIAS="your-jks-alias" \
--CERTIMATE_DEPLOYER_LOCAL_JKSKEYPASS="your-jks-keypass" \
--CERTIMATE_DEPLOYER_LOCAL_JKSSTOREPASS="your-jks-storepass"
*/
func TestDeploy_PFX(t *testing.T) {
envPrefix := "CERTIMATE_DEPLOYER_LOCAL_"
tInputCertData, _ := os.ReadFile(os.Getenv(envPrefix + "INPUTCERTPATH"))
tInputKeyData, _ := os.ReadFile(os.Getenv(envPrefix + "INPUTKEYPATH"))
tOutputCertPath := os.Getenv(envPrefix + "OUTPUTCERTPATH")
tPfxPassword := os.Getenv(envPrefix + "PFXPASSWORD")
func Test(t *testing.T) {
flag.Parse()
deployer, err := dLocal.New(&dLocal.LocalDeployerConfig{
OutputFormat: dLocal.OUTPUT_FORMAT_PFX,
OutputCertPath: tOutputCertPath,
PfxPassword: tPfxPassword,
t.Run("Deploy_PEM", func(t *testing.T) {
t.Log(strings.Join([]string{
"args:",
fmt.Sprintf("INPUTCERTPATH: %v", fInputCertPath),
fmt.Sprintf("INPUTKEYPATH: %v", fInputKeyPath),
fmt.Sprintf("OUTPUTCERTPATH: %v", fOutputCertPath),
fmt.Sprintf("OUTPUTKEYPATH: %v", fOutputKeyPath),
}, "\n"))
deployer, err := dLocal.New(&dLocal.LocalDeployerConfig{
OutputCertPath: fOutputCertPath,
OutputKeyPath: fOutputKeyPath,
})
if err != nil {
t.Errorf("err: %+v", err)
return
}
fInputCertData, _ := os.ReadFile(fInputCertPath)
fInputKeyData, _ := os.ReadFile(fInputKeyPath)
res, err := deployer.Deploy(context.Background(), string(fInputCertData), string(fInputKeyData))
if err != nil {
t.Errorf("err: %+v", err)
return
}
fstat1, err := os.Stat(fOutputCertPath)
if err != nil {
t.Errorf("err: %+v", err)
return
} else if fstat1.Size() == 0 {
t.Errorf("err: empty output certificate file")
return
}
fstat2, err := os.Stat(fOutputKeyPath)
if err != nil {
t.Errorf("err: %+v", err)
return
} else if fstat2.Size() == 0 {
t.Errorf("err: empty output private key file")
return
}
t.Logf("ok: %v", res)
})
if err != nil {
t.Errorf("err: %+v", err)
panic(err)
}
res, err := deployer.Deploy(context.Background(), string(tInputCertData), string(tInputKeyData))
if err != nil {
t.Errorf("err: %+v", err)
panic(err)
}
t.Run("Deploy_PFX", func(t *testing.T) {
t.Log(strings.Join([]string{
"args:",
fmt.Sprintf("INPUTCERTPATH: %v", fInputCertPath),
fmt.Sprintf("INPUTKEYPATH: %v", fInputKeyPath),
fmt.Sprintf("OUTPUTCERTPATH: %v", fOutputCertPath),
fmt.Sprintf("OUTPUTKEYPATH: %v", fOutputKeyPath),
fmt.Sprintf("PFXPASSWORD: %v", fPfxPassword),
}, "\n"))
t.Logf("ok: %v", res)
}
deployer, err := dLocal.New(&dLocal.LocalDeployerConfig{
OutputFormat: dLocal.OUTPUT_FORMAT_PFX,
OutputCertPath: fOutputCertPath,
OutputKeyPath: fOutputKeyPath,
PfxPassword: fPfxPassword,
})
if err != nil {
t.Errorf("err: %+v", err)
return
}
/*
Shell command to run this test:
fInputCertData, _ := os.ReadFile(fInputCertPath)
fInputKeyData, _ := os.ReadFile(fInputKeyPath)
res, err := deployer.Deploy(context.Background(), string(fInputCertData), string(fInputKeyData))
if err != nil {
t.Errorf("err: %+v", err)
return
}
CERTIMATE_DEPLOYER_LOCAL_INPUTCERTPATH="/path/to/your-input-cert.pem" \
CERTIMATE_DEPLOYER_LOCAL_INPUTKEYPATH="/path/to/your-input-key.pem" \
CERTIMATE_DEPLOYER_LOCAL_OUTPUTCERTPATH="/path/to/your-output-cert.pem" \
CERTIMATE_DEPLOYER_LOCAL_JKSALIAS="your-jks-alias" \
CERTIMATE_DEPLOYER_LOCAL_JKSKEYPASS="your-jks-keypass" \
CERTIMATE_DEPLOYER_LOCAL_JKSSTOREPASS="your-jks-storepass" \
go test -v -run TestDeploy_JKS local_test.go
*/
func TestDeploy_JKS(t *testing.T) {
envPrefix := "CERTIMATE_DEPLOYER_LOCAL_"
tInputCertData, _ := os.ReadFile(os.Getenv(envPrefix + "INPUTCERTPATH"))
tInputKeyData, _ := os.ReadFile(os.Getenv(envPrefix + "INPUTKEYPATH"))
tOutputCertPath := os.Getenv(envPrefix + "OUTPUTCERTPATH")
tJksAlias := os.Getenv(envPrefix + "JKSALIAS")
tJksKeypass := os.Getenv(envPrefix + "JKSKEYPASS")
tJksStorepass := os.Getenv(envPrefix + "JKSSTOREPASS")
fstat, err := os.Stat(fOutputCertPath)
if err != nil {
t.Errorf("err: %+v", err)
return
} else if fstat.Size() == 0 {
t.Errorf("err: empty output certificate file")
return
}
deployer, err := dLocal.New(&dLocal.LocalDeployerConfig{
OutputFormat: dLocal.OUTPUT_FORMAT_JKS,
OutputCertPath: tOutputCertPath,
JksAlias: tJksAlias,
JksKeypass: tJksKeypass,
JksStorepass: tJksStorepass,
t.Logf("ok: %v", res)
})
if err != nil {
t.Errorf("err: %+v", err)
panic(err)
}
res, err := deployer.Deploy(context.Background(), string(tInputCertData), string(tInputKeyData))
if err != nil {
t.Errorf("err: %+v", err)
panic(err)
}
t.Run("Deploy_JKS", func(t *testing.T) {
t.Log(strings.Join([]string{
"args:",
fmt.Sprintf("INPUTCERTPATH: %v", fInputCertPath),
fmt.Sprintf("INPUTKEYPATH: %v", fInputKeyPath),
fmt.Sprintf("OUTPUTCERTPATH: %v", fOutputCertPath),
fmt.Sprintf("OUTPUTKEYPATH: %v", fOutputKeyPath),
fmt.Sprintf("JKSALIAS: %v", fJksAlias),
fmt.Sprintf("JKSKEYPASS: %v", fJksKeypass),
fmt.Sprintf("JKSSTOREPASS: %v", fJksStorepass),
}, "\n"))
t.Logf("ok: %v", res)
deployer, err := dLocal.New(&dLocal.LocalDeployerConfig{
OutputFormat: dLocal.OUTPUT_FORMAT_JKS,
OutputCertPath: fOutputCertPath,
OutputKeyPath: fOutputKeyPath,
JksAlias: fJksAlias,
JksKeypass: fJksKeypass,
JksStorepass: fJksStorepass,
})
if err != nil {
t.Errorf("err: %+v", err)
return
}
fInputCertData, _ := os.ReadFile(fInputCertPath)
fInputKeyData, _ := os.ReadFile(fInputKeyPath)
res, err := deployer.Deploy(context.Background(), string(fInputCertData), string(fInputKeyData))
if err != nil {
t.Errorf("err: %+v", err)
return
}
fstat, err := os.Stat(fOutputCertPath)
if err != nil {
t.Errorf("err: %+v", err)
return
} else if fstat.Size() == 0 {
t.Errorf("err: empty output certificate file")
return
}
t.Logf("ok: %v", res)
})
}

112
internal/pkg/core/deployer/providers/ssh/ssh_test.go
View File

@@ -2,55 +2,89 @@
import (
"context"
"flag"
"fmt"
"os"
"strconv"
"strings"
"testing"
dSsh "github.com/usual2970/certimate/internal/pkg/core/deployer/providers/ssh"
)
var (
fInputCertPath string
fInputKeyPath string
fSshHost string
fSshPort int
fSshUsername string
fSshPassword string
fOutputCertPath string
fOutputKeyPath string
)
func init() {
argsPrefix := "CERTIMATE_DEPLOYER_SSH_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
flag.StringVar(&fSshHost, argsPrefix+"SSHHOST", "", "")
flag.IntVar(&fSshPort, argsPrefix+"SSHPORT", 0, "")
flag.StringVar(&fSshUsername, argsPrefix+"SSHUSERNAME", "", "")
flag.StringVar(&fSshPassword, argsPrefix+"SSHPASSWORD", "", "")
flag.StringVar(&fOutputCertPath, argsPrefix+"OUTPUTCERTPATH", "", "")
flag.StringVar(&fOutputKeyPath, argsPrefix+"OUTPUTKEYPATH", "", "")
}
/*
Shell command to run this test:
CERTIMATE_DEPLOYER_SSH_INPUTCERTPATH="/path/to/your-input-cert.pem" \
CERTIMATE_DEPLOYER_SSH_INPUTKEYPATH="/path/to/your-input-key.pem" \
CERTIMATE_DEPLOYER_SSH_SSHHOST="localhost" \
CERTIMATE_DEPLOYER_SSH_SSHPORT=22 \
CERTIMATE_DEPLOYER_SSH_SSHUSERNAME="root" \
CERTIMATE_DEPLOYER_SSH_SSHPASSWORD="password" \
CERTIMATE_DEPLOYER_SSH_OUTPUTCERTPATH="/path/to/your-output-cert.pem" \
CERTIMATE_DEPLOYER_SSH_OUTPUTKEYPATH="/path/to/your-output-key.pem" \
go test -v -run TestDeploy ssh_test.go
go test -v ssh_test.go -args \
--CERTIMATE_DEPLOYER_SSH_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_DEPLOYER_SSH_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_DEPLOYER_SSH_SSHHOST="localhost" \
--CERTIMATE_DEPLOYER_SSH_SSHPORT=22 \
--CERTIMATE_DEPLOYER_SSH_SSHUSERNAME="root" \
--CERTIMATE_DEPLOYER_SSH_SSHPASSWORD="password" \
--CERTIMATE_DEPLOYER_SSH_OUTPUTCERTPATH="/path/to/your-output-cert.pem" \
--CERTIMATE_DEPLOYER_SSH_OUTPUTKEYPATH="/path/to/your-output-key.pem"
*/
func TestDeploy(t *testing.T) {
envPrefix := "CERTIMATE_DEPLOYER_LOCAL_"
tInputCertData, _ := os.ReadFile(os.Getenv(envPrefix + "INPUTCERTPATH"))
tInputKeyData, _ := os.ReadFile(os.Getenv(envPrefix + "INPUTKEYPATH"))
tSshHost := os.Getenv(envPrefix + "SSHHOST")
tSshPort, _ := strconv.ParseInt(os.Getenv(envPrefix+"SSHPORT"), 10, 32)
tSshUsername := os.Getenv(envPrefix + "SSHUSERNAME")
tSshPassword := os.Getenv(envPrefix + "SSHPASSWORD")
tOutputCertPath := os.Getenv(envPrefix + "OUTPUTCERTPATH")
tOutputKeyPath := os.Getenv(envPrefix + "OUTPUTKEYPATH")
func Test(t *testing.T) {
flag.Parse()
deployer, err := dSsh.New(&dSsh.SshDeployerConfig{
SshHost: tSshHost,
SshPort: int32(tSshPort),
SshUsername: tSshUsername,
SshPassword: tSshPassword,
OutputCertPath: tOutputCertPath,
OutputKeyPath: tOutputKeyPath,
t.Run("Deploy", func(t *testing.T) {
t.Log(strings.Join([]string{
"args:",
fmt.Sprintf("INPUTCERTPATH: %v", fInputCertPath),
fmt.Sprintf("INPUTKEYPATH: %v", fInputKeyPath),
fmt.Sprintf("SSHHOST: %v", fSshHost),
fmt.Sprintf("SSHPORT: %v", fSshPort),
fmt.Sprintf("SSHUSERNAME: %v", fSshUsername),
fmt.Sprintf("SSHPASSWORD: %v", fSshPassword),
fmt.Sprintf("OUTPUTCERTPATH: %v", fOutputCertPath),
fmt.Sprintf("OUTPUTKEYPATH: %v", fOutputKeyPath),
}, "\n"))
deployer, err := dSsh.New(&dSsh.SshDeployerConfig{
SshHost: fSshHost,
SshPort: int32(fSshPort),
SshUsername: fSshUsername,
SshPassword: fSshPassword,
OutputCertPath: fOutputCertPath,
OutputKeyPath: fOutputKeyPath,
})
if err != nil {
t.Errorf("err: %+v", err)
panic(err)
}
fInputCertData, _ := os.ReadFile(fInputCertPath)
fInputKeyData, _ := os.ReadFile(fInputKeyPath)
res, err := deployer.Deploy(context.Background(), string(fInputCertData), string(fInputKeyData))
if err != nil {
t.Errorf("err: %+v", err)
panic(err)
}
t.Logf("ok: %v", res)
})
if err != nil {
t.Errorf("err: %+v", err)
panic(err)
}
res, err := deployer.Deploy(context.Background(), string(tInputCertData), string(tInputKeyData))
if err != nil {
t.Errorf("err: %+v", err)
panic(err)
}
t.Logf("ok: %v", res)
}

71
internal/pkg/core/deployer/providers/webhook/webhook_test.go
View File

@@ -2,39 +2,64 @@
import (
"context"
"flag"
"fmt"
"os"
"strings"
"testing"
dpWebhook "github.com/usual2970/certimate/internal/pkg/core/deployer/providers/webhook"
)
var (
fInputCertPath string
fInputKeyPath string
fUrl string
)
func init() {
argsPrefix := "CERTIMATE_DEPLOYER_WEBHOOK_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
flag.StringVar(&fUrl, argsPrefix+"URL", "", "")
}
/*
Shell command to run this test:
CERTIMATE_DEPLOYER_WEBHOOK_INPUTCERTPATH="/path/to/your-input-cert.pem" \
CERTIMATE_DEPLOYER_WEBHOOK_INPUTKEYPATH="/path/to/your-input-key.pem" \
CERTIMATE_DEPLOYER_WEBHOOK_URL="https://example.com/your-webhook-url" \
go test -v -run TestDeploy webhook_test.go
go test -v webhook_test.go -args \
--CERTIMATE_DEPLOYER_WEBHOOK_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_DEPLOYER_WEBHOOK_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_DEPLOYER_WEBHOOK_URL="https://example.com/your-webhook-url"
*/
func TestDeploy(t *testing.T) {
envPrefix := "CERTIMATE_DEPLOYER_WEBHOOK_"
tInputCertData, _ := os.ReadFile(os.Getenv(envPrefix + "INPUTCERTPATH"))
tInputKeyData, _ := os.ReadFile(os.Getenv(envPrefix + "INPUTKEYPATH"))
tUrl := os.Getenv(envPrefix + "URL")
func Test(t *testing.T) {
flag.Parse()
deployer, err := dpWebhook.New(&dpWebhook.WebhookDeployerConfig{
Url: tUrl,
t.Run("Notify", func(t *testing.T) {
t.Log(strings.Join([]string{
"args:",
fmt.Sprintf("INPUTCERTPATH: %v", fInputCertPath),
fmt.Sprintf("INPUTKEYPATH: %v", fInputKeyPath),
fmt.Sprintf("URL: %v", fUrl),
}, "\n"))
deployer, err := dpWebhook.New(&dpWebhook.WebhookDeployerConfig{
Url: fUrl,
})
if err != nil {
t.Errorf("err: %+v", err)
return
}
fInputCertData, _ := os.ReadFile(fInputCertPath)
fInputKeyData, _ := os.ReadFile(fInputKeyPath)
res, err := deployer.Deploy(context.Background(), string(fInputCertData), string(fInputKeyData))
if err != nil {
t.Errorf("err: %+v", err)
return
}
t.Logf("ok: %v", res)
})
if err != nil {
t.Errorf("err: %+v", err)
panic(err)
}
res, err := deployer.Deploy(context.Background(), string(tInputCertData), string(tInputKeyData))
if err != nil {
t.Errorf("err: %+v", err)
panic(err)
}
t.Logf("ok: %v", res)
}