wood/certimate
1
0
Fork 0
mirror of https://github.com/woodchen-ink/certimate.git synced 2025-07-18 17:31:55 +08:00
Code Issues Packages Projects Releases Wiki Activity

test: add some unit test cases for new Deployer

Browse Source
This commit is contained in:
Fu Diwei 2024-11-19 20:03:11 +08:00
parent 6367785b1b
commit 51fb9dca58
7 changed files with 307 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
internal/notify/factory.go
View File

@ -5,20 +5,20 @@ import (
"github.com/usual2970/certimate/internal/domain"
"github.com/usual2970/certimate/internal/pkg/core/notifier"
notifierBark "github.com/usual2970/certimate/internal/pkg/core/notifier/providers/bark"
notifierDingTalk "github.com/usual2970/certimate/internal/pkg/core/notifier/providers/dingtalk"
notifierEmail "github.com/usual2970/certimate/internal/pkg/core/notifier/providers/email"
notifierLark "github.com/usual2970/certimate/internal/pkg/core/notifier/providers/lark"
notifierServerChan "github.com/usual2970/certimate/internal/pkg/core/notifier/providers/serverchan"
notifierTelegram "github.com/usual2970/certimate/internal/pkg/core/notifier/providers/telegram"
notifierWebhook "github.com/usual2970/certimate/internal/pkg/core/notifier/providers/webhook"
npBark "github.com/usual2970/certimate/internal/pkg/core/notifier/providers/bark"
npDingTalk "github.com/usual2970/certimate/internal/pkg/core/notifier/providers/dingtalk"
npEmail "github.com/usual2970/certimate/internal/pkg/core/notifier/providers/email"
npLark "github.com/usual2970/certimate/internal/pkg/core/notifier/providers/lark"
npServerChan "github.com/usual2970/certimate/internal/pkg/core/notifier/providers/serverchan"
npTelegram "github.com/usual2970/certimate/internal/pkg/core/notifier/providers/telegram"
npWebhook "github.com/usual2970/certimate/internal/pkg/core/notifier/providers/webhook"
"github.com/usual2970/certimate/internal/pkg/utils/maps"
)
func createNotifier(channel string, channelConfig map[string]any) (notifier.Notifier, error) {
switch channel {
case domain.NotifyChannelEmail:
return notifierEmail.New(&notifierEmail.EmailNotifierConfig{
return npEmail.New(&npEmail.EmailNotifierConfig{
SmtpHost: maps.GetValueAsString(channelConfig, "smtpHost"),
SmtpPort: maps.GetValueAsInt32(channelConfig, "smtpPort"),
SmtpTLS: maps.GetValueOrDefaultAsBool(channelConfig, "smtpTLS", true),
@ -29,34 +29,34 @@ func createNotifier(channel string, channelConfig map[string]any) (notifier.Noti
})
case domain.NotifyChannelWebhook:
return notifierWebhook.New(&notifierWebhook.WebhookNotifierConfig{
return npWebhook.New(&npWebhook.WebhookNotifierConfig{
Url: maps.GetValueAsString(channelConfig, "url"),
})
case domain.NotifyChannelDingtalk:
return notifierDingTalk.New(&notifierDingTalk.DingTalkNotifierConfig{
return npDingTalk.New(&npDingTalk.DingTalkNotifierConfig{
AccessToken: maps.GetValueAsString(channelConfig, "accessToken"),
Secret: maps.GetValueAsString(channelConfig, "secret"),
})
case domain.NotifyChannelLark:
return notifierLark.New(&notifierLark.LarkNotifierConfig{
return npLark.New(&npLark.LarkNotifierConfig{
WebhookUrl: maps.GetValueAsString(channelConfig, "webhookUrl"),
})
case domain.NotifyChannelTelegram:
return notifierTelegram.New(&notifierTelegram.TelegramNotifierConfig{
return npTelegram.New(&npTelegram.TelegramNotifierConfig{
ApiToken: maps.GetValueAsString(channelConfig, "apiToken"),
ChatId: maps.GetValueAsInt64(channelConfig, "chatId"),
})
case domain.NotifyChannelServerChan:
return notifierServerChan.New(&notifierServerChan.ServerChanNotifierConfig{
return npServerChan.New(&npServerChan.ServerChanNotifierConfig{
Url: maps.GetValueAsString(channelConfig, "url"),
})
case domain.NotifyChannelBark:
return notifierBark.New(&notifierBark.BarkNotifierConfig{
return npBark.New(&npBark.BarkNotifierConfig{
DeviceKey: maps.GetValueAsString(channelConfig, "deviceKey"),
ServerUrl: maps.GetValueAsString(channelConfig, "serverUrl"),
})

119
internal/pkg/core/deployer/providers/local/local_test.go Normal file
View File

@ -0,0 +1,119 @@
package local_test
import (
"context"
"os"
"testing"
dLocal "github.com/usual2970/certimate/internal/pkg/core/deployer/providers/local"
)
/*
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_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")
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)
}
/*
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
*/
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")
deployer, err := dLocal.New(&dLocal.LocalDeployerConfig{
OutputFormat: dLocal.OUTPUT_FORMAT_PFX,
OutputCertPath: tOutputCertPath,
PfxPassword: tPfxPassword,
})
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)
}
/*
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_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")
deployer, err := dLocal.New(&dLocal.LocalDeployerConfig{
OutputFormat: dLocal.OUTPUT_FORMAT_JKS,
OutputCertPath: tOutputCertPath,
JksAlias: tJksAlias,
JksKeypass: tJksKeypass,
JksStorepass: tJksStorepass,
})
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)
}

56
internal/pkg/core/deployer/providers/ssh/ssh_test.go Normal file
View File

@ -0,0 +1,56 @@
package ssh_test
import (
"context"
"os"
"strconv"
"testing"
dSsh "github.com/usual2970/certimate/internal/pkg/core/deployer/providers/ssh"
)
/*
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
*/
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")
deployer, err := dSsh.New(&dSsh.SshDeployerConfig{
SshHost: tSshHost,
SshPort: int32(tSshPort),
SshUsername: tSshUsername,
SshPassword: tSshPassword,
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)
}

6
internal/pkg/core/deployer/providers/webhook/webhook.go
View File

@ -77,5 +77,9 @@ func (d *WebhookDeployer) Deploy(ctx context.Context, certPem string, privkeyPem
d.logger.Appendt("Webhook Response", string(resp))
return &deployer.DeployResult{}, nil
return &deployer.DeployResult{
DeploymentData: map[string]any{
"responseText": string(resp),
},
}, nil
}

40
internal/pkg/core/deployer/providers/webhook/webhook_test.go Normal file
View File

@ -0,0 +1,40 @@
package webhook_test
import (
"context"
"os"
"testing"
dpWebhook "github.com/usual2970/certimate/internal/pkg/core/deployer/providers/webhook"
)
/*
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
*/
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")
deployer, err := dpWebhook.New(&dpWebhook.WebhookDeployerConfig{
Url: tUrl,
})
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)
}

55
internal/pkg/core/notifier/providers/email/email_test.go
View File

@ -1,19 +1,25 @@
package email_test
import (
"context"
"os"
"strconv"
"testing"
notifierEmail "github.com/usual2970/certimate/internal/pkg/core/notifier/providers/email"
npEmail "github.com/usual2970/certimate/internal/pkg/core/notifier/providers/email"
)
const (
MockSubject = "test_subject"
MockMessage = "test_message"
)
/*
Shell command to run this test:
CERTIMATE_NOTIFIER_EMAIL_SMTPHOST="smtp.example.com" \
CERTIMATE_NOTIFIER_EMAIL_SMTPPORT=465 \
CERTIMATE_NOTIFIER_EMAIL_SMTPTLS=true \
CERTIMATE_NOTIFIER_EMAIL_SMTPHOST="smtp.example.com" \
CERTIMATE_NOTIFIER_EMAIL_USERNAME="your-username" \
CERTIMATE_NOTIFIER_EMAIL_PASSWORD="your-password" \
CERTIMATE_NOTIFIER_EMAIL_SENDERADDRESS="sender@example.com" \
@ -21,31 +27,34 @@ Shell command to run this test:
go test -v -run TestNotify email_test.go
*/
func TestNotify(t *testing.T) {
smtpPort, err := strconv.ParseInt(os.Getenv("CERTIMATE_NOTIFIER_EMAIL_SMTPPORT"), 10, 32)
if err != nil {
t.Errorf("invalid envvar: %+v", err)
panic(err)
}
envPrefix := "CERTIMATE_NOTIFIER_EMAIL_"
tSmtpHost := os.Getenv(envPrefix + "SMTPHOST")
tSmtpPort, _ := strconv.ParseInt(os.Getenv(envPrefix+"SMTPPORT"), 10, 32)
tSmtpTLS, _ := strconv.ParseBool(os.Getenv(envPrefix + "SMTPTLS"))
tSmtpUsername := os.Getenv(envPrefix + "USERNAME")
tSmtpPassword := os.Getenv(envPrefix + "PASSWORD")
tSenderAddress := os.Getenv(envPrefix + "SENDERADDRESS")
tReceiverAddress := os.Getenv(envPrefix + "RECEIVERADDRESS")
smtpTLS, err := strconv.ParseBool(os.Getenv("CERTIMATE_NOTIFIER_EMAIL_SMTPTLS"))
if err != nil {
t.Errorf("invalid envvar: %+v", err)
panic(err)
}
res, err := notifierEmail.New(&notifierEmail.EmailNotifierConfig{
SmtpHost: os.Getenv("CERTIMATE_NOTIFIER_EMAIL_SMTPHOST"),
SmtpPort: int32(smtpPort),
SmtpTLS: smtpTLS,
Username: os.Getenv("CERTIMATE_NOTIFIER_EMAIL_USERNAME"),
Password: os.Getenv("CERTIMATE_NOTIFIER_EMAIL_PASSWORD"),
SenderAddress: os.Getenv("CERTIMATE_NOTIFIER_EMAIL_SENDERADDRESS"),
ReceiverAddress: os.Getenv("CERTIMATE_NOTIFIER_EMAIL_RECEIVERADDRESS"),
notifier, err := npEmail.New(&npEmail.EmailNotifierConfig{
SmtpHost: tSmtpHost,
SmtpPort: int32(tSmtpPort),
SmtpTLS: tSmtpTLS,
Username: tSmtpUsername,
Password: tSmtpPassword,
SenderAddress: tSenderAddress,
ReceiverAddress: tReceiverAddress,
})
if err != nil {
t.Errorf("invalid envvar: %+v", err)
t.Errorf("err: %+v", err)
panic(err)
}
t.Logf("notify result: %v", res)
res, err := notifier.Notify(context.Background(), MockSubject, MockMessage)
if err != nil {
t.Errorf("err: %+v", err)
panic(err)
}
t.Logf("ok: %v", res)
}

41
internal/pkg/core/notifier/providers/webhook/webhook_test.go Normal file
View File

@ -0,0 +1,41 @@
package webhook_test
import (
"context"
"os"
"testing"
npWebhook "github.com/usual2970/certimate/internal/pkg/core/notifier/providers/webhook"
)
const (
MockSubject = "test_subject"
MockMessage = "test_message"
)
/*
Shell command to run this test:
CERTIMATE_NOTIFIER_WEBHOOK_URL="https://example.com/your-webhook-url" \
go test -v -run TestNotify webhook_test.go
*/
func TestNotify(t *testing.T) {
envPrefix := "CERTIMATE_NOTIFIER_WEBHOOK_"
tUrl := os.Getenv(envPrefix + "URL")
notifier, err := npWebhook.New(&npWebhook.WebhookNotifierConfig{
Url: tUrl,
})
if err != nil {
t.Errorf("err: %+v", err)
panic(err)
}
res, err := notifier.Notify(context.Background(), MockSubject, MockMessage)
if err != nil {
t.Errorf("err: %+v", err)
panic(err)
}
t.Logf("ok: %v", res)
}