From 414d8d140e7f5ae775cd328b300ec012957ce8a5 Mon Sep 17 00:00:00 2001 From: Fu Diwei Date: Tue, 19 Nov 2024 21:18:36 +0800 Subject: [PATCH] test: use flag arguments in test cases for `Notifier` and `Deployer` --- .../deployer/providers/local/local_test.go | 247 +++++++++++------- .../core/deployer/providers/ssh/ssh_test.go | 112 +++++--- .../providers/webhook/webhook_test.go | 71 +++-- .../notifier/providers/email/email_test.go | 111 +++++--- .../providers/webhook/webhook_test.go | 60 +++-- 5 files changed, 386 insertions(+), 215 deletions(-) diff --git a/internal/pkg/core/deployer/providers/local/local_test.go b/internal/pkg/core/deployer/providers/local/local_test.go index 819c98cf..74307734 100644 --- a/internal/pkg/core/deployer/providers/local/local_test.go +++ b/internal/pkg/core/deployer/providers/local/local_test.go @@ -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) + }) } diff --git a/internal/pkg/core/deployer/providers/ssh/ssh_test.go b/internal/pkg/core/deployer/providers/ssh/ssh_test.go index 3e841f0c..dbc0109c 100644 --- a/internal/pkg/core/deployer/providers/ssh/ssh_test.go +++ b/internal/pkg/core/deployer/providers/ssh/ssh_test.go @@ -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) } diff --git a/internal/pkg/core/deployer/providers/webhook/webhook_test.go b/internal/pkg/core/deployer/providers/webhook/webhook_test.go index c9ac73aa..8c2cbde8 100644 --- a/internal/pkg/core/deployer/providers/webhook/webhook_test.go +++ b/internal/pkg/core/deployer/providers/webhook/webhook_test.go @@ -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) } diff --git a/internal/pkg/core/notifier/providers/email/email_test.go b/internal/pkg/core/notifier/providers/email/email_test.go index 8a9e860f..a401ac19 100644 --- a/internal/pkg/core/notifier/providers/email/email_test.go +++ b/internal/pkg/core/notifier/providers/email/email_test.go @@ -2,59 +2,88 @@ import ( "context" - "os" - "strconv" + "flag" + "fmt" + "strings" "testing" npEmail "github.com/usual2970/certimate/internal/pkg/core/notifier/providers/email" ) const ( - MockSubject = "test_subject" - MockMessage = "test_message" + mockSubject = "test_subject" + mockMessage = "test_message" ) +var ( + fSmtpHost string + fSmtpPort int + fSmtpTLS bool + fUsername string + fPassword string + fSenderAddress string + fReceiverAddress string +) + +func init() { + argsPrefix := "CERTIMATE_NOTIFIER_EMAIL_" + + flag.StringVar(&fSmtpHost, argsPrefix+"SMTPHOST", "", "") + flag.IntVar(&fSmtpPort, argsPrefix+"SMTPPORT", 0, "") + flag.BoolVar(&fSmtpTLS, argsPrefix+"SMTPTLS", false, "") + flag.StringVar(&fUsername, argsPrefix+"USERNAME", "", "") + flag.StringVar(&fPassword, argsPrefix+"PASSWORD", "", "") + flag.StringVar(&fSenderAddress, argsPrefix+"SENDERADDRESS", "", "") + flag.StringVar(&fReceiverAddress, argsPrefix+"RECEIVERADDRESS", "", "") +} + /* 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_USERNAME="your-username" \ - CERTIMATE_NOTIFIER_EMAIL_PASSWORD="your-password" \ - CERTIMATE_NOTIFIER_EMAIL_SENDERADDRESS="sender@example.com" \ - CERTIMATE_NOTIFIER_EMAIL_RECEIVERADDRESS="receiver@example.com" \ - go test -v -run TestNotify email_test.go + go test -v email_test.go -args \ + --CERTIMATE_NOTIFIER_EMAIL_SMTPHOST="smtp.example.com" \ + --CERTIMATE_NOTIFIER_EMAIL_SMTPPORT=465 \ + --CERTIMATE_NOTIFIER_EMAIL_SMTPTLS=true \ + --CERTIMATE_NOTIFIER_EMAIL_USERNAME="your-username" \ + --CERTIMATE_NOTIFIER_EMAIL_PASSWORD="your-password" \ + --CERTIMATE_NOTIFIER_EMAIL_SENDERADDRESS="sender@example.com" \ + --CERTIMATE_NOTIFIER_EMAIL_RECEIVERADDRESS="receiver@example.com" */ -func TestNotify(t *testing.T) { - 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") +func Test(t *testing.T) { + flag.Parse() - notifier, err := npEmail.New(&npEmail.EmailNotifierConfig{ - SmtpHost: tSmtpHost, - SmtpPort: int32(tSmtpPort), - SmtpTLS: tSmtpTLS, - Username: tSmtpUsername, - Password: tSmtpPassword, - SenderAddress: tSenderAddress, - ReceiverAddress: tReceiverAddress, + t.Run("Notify", func(t *testing.T) { + t.Log(strings.Join([]string{ + "args:", + fmt.Sprintf("SMTPHOST: %v", fSmtpHost), + fmt.Sprintf("SMTPPORT: %v", fSmtpPort), + fmt.Sprintf("SMTPTLS: %v", fSmtpTLS), + fmt.Sprintf("USERNAME: %v", fUsername), + fmt.Sprintf("PASSWORD: %v", fPassword), + fmt.Sprintf("SENDERADDRESS: %v", fSenderAddress), + fmt.Sprintf("RECEIVERADDRESS: %v", fReceiverAddress), + }, "\n")) + + notifier, err := npEmail.New(&npEmail.EmailNotifierConfig{ + SmtpHost: fSmtpHost, + SmtpPort: int32(fSmtpPort), + SmtpTLS: fSmtpTLS, + Username: fUsername, + Password: fPassword, + SenderAddress: fSenderAddress, + ReceiverAddress: fReceiverAddress, + }) + if err != nil { + t.Errorf("err: %+v", err) + return + } + + res, err := notifier.Notify(context.Background(), mockSubject, mockMessage) + 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 := notifier.Notify(context.Background(), MockSubject, MockMessage) - if err != nil { - t.Errorf("err: %+v", err) - panic(err) - } - - t.Logf("ok: %v", res) } diff --git a/internal/pkg/core/notifier/providers/webhook/webhook_test.go b/internal/pkg/core/notifier/providers/webhook/webhook_test.go index eca46819..fc9ded52 100644 --- a/internal/pkg/core/notifier/providers/webhook/webhook_test.go +++ b/internal/pkg/core/notifier/providers/webhook/webhook_test.go @@ -2,40 +2,56 @@ import ( "context" - "os" + "flag" + "fmt" + "strings" "testing" npWebhook "github.com/usual2970/certimate/internal/pkg/core/notifier/providers/webhook" ) const ( - MockSubject = "test_subject" - MockMessage = "test_message" + mockSubject = "test_subject" + mockMessage = "test_message" ) +var fUrl string + +func init() { + argsPrefix := "CERTIMATE_NOTIFIER_WEBHOOK_" + + flag.StringVar(&fUrl, argsPrefix+"URL", "", "") +} + /* Shell command to run this test: - CERTIMATE_NOTIFIER_WEBHOOK_URL="https://example.com/your-webhook-url" \ - go test -v -run TestNotify webhook_test.go + go test -v webhook_test.go -args \ + --CERTIMATE_NOTIFIER_WEBHOOK_URL="https://example.com/your-webhook-url" */ -func TestNotify(t *testing.T) { - envPrefix := "CERTIMATE_NOTIFIER_WEBHOOK_" - tUrl := os.Getenv(envPrefix + "URL") +func Test(t *testing.T) { + flag.Parse() - notifier, err := npWebhook.New(&npWebhook.WebhookNotifierConfig{ - Url: tUrl, + t.Run("Notify", func(t *testing.T) { + t.Log(strings.Join([]string{ + "args:", + fmt.Sprintf("URL: %v", fUrl), + }, "\n")) + + notifier, err := npWebhook.New(&npWebhook.WebhookNotifierConfig{ + Url: fUrl, + }) + if err != nil { + t.Errorf("err: %+v", err) + return + } + + res, err := notifier.Notify(context.Background(), mockSubject, mockMessage) + 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 := notifier.Notify(context.Background(), MockSubject, MockMessage) - if err != nil { - t.Errorf("err: %+v", err) - panic(err) - } - - t.Logf("ok: %v", res) }