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

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"
 )
 
-/*
+var (
-Shell command to run this test:
+	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" \
+func init() {
-	CERTIMATE_DEPLOYER_LOCAL_INPUTKEYPATH="/path/to/your-input-key.pem" \
+	argsPrefix := "CERTIMATE_DEPLOYER_LOCAL_"
-	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{
+	flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
-		OutputCertPath: tOutputCertPath,
+	flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
-		OutputKeyPath:  tOutputKeyPath,
+	flag.StringVar(&fOutputCertPath, argsPrefix+"OUTPUTCERTPATH", "", "")
-	})
+	flag.StringVar(&fOutputKeyPath, argsPrefix+"OUTPUTKEYPATH", "", "")
-	if err != nil {
+	flag.StringVar(&fPfxPassword, argsPrefix+"PFXPASSWORD", "", "")
-		t.Errorf("err: %+v", err)
+	flag.StringVar(&fJksAlias, argsPrefix+"JKSALIAS", "", "")
-		panic(err)
+	flag.StringVar(&fJksKeypass, argsPrefix+"JKSKEYPASS", "", "")
-	}
+	flag.StringVar(&fJksStorepass, argsPrefix+"JKSSTOREPASS", "", "")
-
-	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" \
+	go test -v local_test.go -args \
-	CERTIMATE_DEPLOYER_LOCAL_INPUTKEYPATH="/path/to/your-input-key.pem" \
+	--CERTIMATE_DEPLOYER_LOCAL_INPUTCERTPATH="/path/to/your-input-cert.pem" \
-	CERTIMATE_DEPLOYER_LOCAL_OUTPUTCERTPATH="/path/to/your-output-cert.pem" \
+	--CERTIMATE_DEPLOYER_LOCAL_INPUTKEYPATH="/path/to/your-input-key.pem" \
-	CERTIMATE_DEPLOYER_LOCAL_PFXPASSWORD="your-pfx-password" \
+	--CERTIMATE_DEPLOYER_LOCAL_OUTPUTCERTPATH="/path/to/your-output-cert" \
-	go test -v -run TestDeploy_PFX local_test.go
+	--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) {
+func Test(t *testing.T) {
-	envPrefix := "CERTIMATE_DEPLOYER_LOCAL_"
+	flag.Parse()
-	tInputCertData, _ := os.ReadFile(os.Getenv(envPrefix + "INPUTCERTPATH"))
+
-	tInputKeyData, _ := os.ReadFile(os.Getenv(envPrefix + "INPUTKEYPATH"))
+	t.Run("Deploy_PEM", func(t *testing.T) {
-	tOutputCertPath := os.Getenv(envPrefix + "OUTPUTCERTPATH")
+		t.Log(strings.Join([]string{
-	tPfxPassword := os.Getenv(envPrefix + "PFXPASSWORD")
+			"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)
+	})
+
+	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"))
 
 		deployer, err := dLocal.New(&dLocal.LocalDeployerConfig{
 			OutputFormat:   dLocal.OUTPUT_FORMAT_PFX,
-		OutputCertPath: tOutputCertPath,
+			OutputCertPath: fOutputCertPath,
-		PfxPassword:    tPfxPassword,
+			OutputKeyPath:  fOutputKeyPath,
+			PfxPassword:    fPfxPassword,
 		})
 		if err != nil {
 			t.Errorf("err: %+v", err)
-		panic(err)
+			return
 		}
 
-	res, err := deployer.Deploy(context.Background(), string(tInputCertData), string(tInputKeyData))
+		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)
+			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)
-}
+	})
 
-/*
+	t.Run("Deploy_JKS", func(t *testing.T) {
-Shell command to run this test:
+		t.Log(strings.Join([]string{
-
+			"args:",
-		CERTIMATE_DEPLOYER_LOCAL_INPUTCERTPATH="/path/to/your-input-cert.pem" \
+			fmt.Sprintf("INPUTCERTPATH: %v", fInputCertPath),
-		CERTIMATE_DEPLOYER_LOCAL_INPUTKEYPATH="/path/to/your-input-key.pem" \
+			fmt.Sprintf("INPUTKEYPATH: %v", fInputKeyPath),
-		CERTIMATE_DEPLOYER_LOCAL_OUTPUTCERTPATH="/path/to/your-output-cert.pem" \
+			fmt.Sprintf("OUTPUTCERTPATH: %v", fOutputCertPath),
-		CERTIMATE_DEPLOYER_LOCAL_JKSALIAS="your-jks-alias" \
+			fmt.Sprintf("OUTPUTKEYPATH: %v", fOutputKeyPath),
-	  CERTIMATE_DEPLOYER_LOCAL_JKSKEYPASS="your-jks-keypass" \
+			fmt.Sprintf("JKSALIAS: %v", fJksAlias),
-	  CERTIMATE_DEPLOYER_LOCAL_JKSSTOREPASS="your-jks-storepass" \
+			fmt.Sprintf("JKSKEYPASS: %v", fJksKeypass),
-		go test -v -run TestDeploy_JKS local_test.go
+			fmt.Sprintf("JKSSTOREPASS: %v", fJksStorepass),
-*/
+		}, "\n"))
-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,
+			OutputCertPath: fOutputCertPath,
-		JksAlias:       tJksAlias,
+			OutputKeyPath:  fOutputKeyPath,
-		JksKeypass:     tJksKeypass,
+			JksAlias:       fJksAlias,
-		JksStorepass:   tJksStorepass,
+			JksKeypass:     fJksKeypass,
+			JksStorepass:   fJksStorepass,
 		})
 		if err != nil {
 			t.Errorf("err: %+v", err)
-		panic(err)
+			return
 		}
 
-	res, err := deployer.Deploy(context.Background(), string(tInputCertData), string(tInputKeyData))
+		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)
+			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)
+	})
 }

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" \
+	go test -v ssh_test.go -args \
-	CERTIMATE_DEPLOYER_SSH_INPUTKEYPATH="/path/to/your-input-key.pem" \
+	--CERTIMATE_DEPLOYER_SSH_INPUTCERTPATH="/path/to/your-input-cert.pem" \
-	CERTIMATE_DEPLOYER_SSH_SSHHOST="localhost" \
+	--CERTIMATE_DEPLOYER_SSH_INPUTKEYPATH="/path/to/your-input-key.pem" \
-	CERTIMATE_DEPLOYER_SSH_SSHPORT=22 \
+	--CERTIMATE_DEPLOYER_SSH_SSHHOST="localhost" \
-	CERTIMATE_DEPLOYER_SSH_SSHUSERNAME="root" \
+	--CERTIMATE_DEPLOYER_SSH_SSHPORT=22 \
-	CERTIMATE_DEPLOYER_SSH_SSHPASSWORD="password" \
+	--CERTIMATE_DEPLOYER_SSH_SSHUSERNAME="root" \
-	CERTIMATE_DEPLOYER_SSH_OUTPUTCERTPATH="/path/to/your-output-cert.pem" \
+	--CERTIMATE_DEPLOYER_SSH_SSHPASSWORD="password" \
-	CERTIMATE_DEPLOYER_SSH_OUTPUTKEYPATH="/path/to/your-output-key.pem" \
+	--CERTIMATE_DEPLOYER_SSH_OUTPUTCERTPATH="/path/to/your-output-cert.pem" \
-	go test -v -run TestDeploy ssh_test.go
+	--CERTIMATE_DEPLOYER_SSH_OUTPUTKEYPATH="/path/to/your-output-key.pem"
 */
-func TestDeploy(t *testing.T) {
+func Test(t *testing.T) {
-	envPrefix := "CERTIMATE_DEPLOYER_LOCAL_"
+	flag.Parse()
-	tInputCertData, _ := os.ReadFile(os.Getenv(envPrefix + "INPUTCERTPATH"))
+
-	tInputKeyData, _ := os.ReadFile(os.Getenv(envPrefix + "INPUTKEYPATH"))
+	t.Run("Deploy", func(t *testing.T) {
-	tSshHost := os.Getenv(envPrefix + "SSHHOST")
+		t.Log(strings.Join([]string{
-	tSshPort, _ := strconv.ParseInt(os.Getenv(envPrefix+"SSHPORT"), 10, 32)
+			"args:",
-	tSshUsername := os.Getenv(envPrefix + "SSHUSERNAME")
+			fmt.Sprintf("INPUTCERTPATH: %v", fInputCertPath),
-	tSshPassword := os.Getenv(envPrefix + "SSHPASSWORD")
+			fmt.Sprintf("INPUTKEYPATH: %v", fInputKeyPath),
-	tOutputCertPath := os.Getenv(envPrefix + "OUTPUTCERTPATH")
+			fmt.Sprintf("SSHHOST: %v", fSshHost),
-	tOutputKeyPath := os.Getenv(envPrefix + "OUTPUTKEYPATH")
+			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:        tSshHost,
+			SshHost:        fSshHost,
-		SshPort:        int32(tSshPort),
+			SshPort:        int32(fSshPort),
-		SshUsername:    tSshUsername,
+			SshUsername:    fSshUsername,
-		SshPassword:    tSshPassword,
+			SshPassword:    fSshPassword,
-		OutputCertPath: tOutputCertPath,
+			OutputCertPath: fOutputCertPath,
-		OutputKeyPath:  tOutputKeyPath,
+			OutputKeyPath:  fOutputKeyPath,
 		})
 		if err != nil {
 			t.Errorf("err: %+v", err)
 			panic(err)
 		}
 
-	res, err := deployer.Deploy(context.Background(), string(tInputCertData), string(tInputKeyData))
+		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)
+	})
 }

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" \
+	go test -v webhook_test.go -args \
-	CERTIMATE_DEPLOYER_WEBHOOK_INPUTKEYPATH="/path/to/your-input-key.pem" \
+	--CERTIMATE_DEPLOYER_WEBHOOK_INPUTCERTPATH="/path/to/your-input-cert.pem" \
-	CERTIMATE_DEPLOYER_WEBHOOK_URL="https://example.com/your-webhook-url" \
+	--CERTIMATE_DEPLOYER_WEBHOOK_INPUTKEYPATH="/path/to/your-input-key.pem" \
-	go test -v -run TestDeploy webhook_test.go
+	--CERTIMATE_DEPLOYER_WEBHOOK_URL="https://example.com/your-webhook-url"
 */
-func TestDeploy(t *testing.T) {
+func Test(t *testing.T) {
-	envPrefix := "CERTIMATE_DEPLOYER_WEBHOOK_"
+	flag.Parse()
-	tInputCertData, _ := os.ReadFile(os.Getenv(envPrefix + "INPUTCERTPATH"))
+
-	tInputKeyData, _ := os.ReadFile(os.Getenv(envPrefix + "INPUTKEYPATH"))
+	t.Run("Notify", func(t *testing.T) {
-	tUrl := os.Getenv(envPrefix + "URL")
+		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: tUrl,
+			Url: fUrl,
 		})
 		if err != nil {
 			t.Errorf("err: %+v", err)
-		panic(err)
+			return
 		}
 
-	res, err := deployer.Deploy(context.Background(), string(tInputCertData), string(tInputKeyData))
+		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)
+			return
 		}
 
 		t.Logf("ok: %v", res)
+	})
 }

internal/pkg/core/notifier/providers/email/email_test.go

@@ -2,59 +2,88 @@
 
 import (
 	"context"
-	"os"
+	"flag"
-	"strconv"
+	"fmt"
+	"strings"
 	"testing"
 
 	npEmail "github.com/usual2970/certimate/internal/pkg/core/notifier/providers/email"
 )
 
 const (
-	MockSubject = "test_subject"
+	mockSubject = "test_subject"
-	MockMessage = "test_message"
+	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" \
+	go test -v email_test.go -args \
-	CERTIMATE_NOTIFIER_EMAIL_SMTPPORT=465 \
+	--CERTIMATE_NOTIFIER_EMAIL_SMTPHOST="smtp.example.com" \
-	CERTIMATE_NOTIFIER_EMAIL_SMTPTLS=true \
+	--CERTIMATE_NOTIFIER_EMAIL_SMTPPORT=465 \
-	CERTIMATE_NOTIFIER_EMAIL_USERNAME="your-username" \
+	--CERTIMATE_NOTIFIER_EMAIL_SMTPTLS=true \
-	CERTIMATE_NOTIFIER_EMAIL_PASSWORD="your-password" \
+	--CERTIMATE_NOTIFIER_EMAIL_USERNAME="your-username" \
-	CERTIMATE_NOTIFIER_EMAIL_SENDERADDRESS="sender@example.com" \
+	--CERTIMATE_NOTIFIER_EMAIL_PASSWORD="your-password" \
-	CERTIMATE_NOTIFIER_EMAIL_RECEIVERADDRESS="receiver@example.com" \
+	--CERTIMATE_NOTIFIER_EMAIL_SENDERADDRESS="sender@example.com" \
-	go test -v -run TestNotify email_test.go
+	--CERTIMATE_NOTIFIER_EMAIL_RECEIVERADDRESS="receiver@example.com"
 */
-func TestNotify(t *testing.T) {
+func Test(t *testing.T) {
-	envPrefix := "CERTIMATE_NOTIFIER_EMAIL_"
+	flag.Parse()
-	tSmtpHost := os.Getenv(envPrefix + "SMTPHOST")
+
-	tSmtpPort, _ := strconv.ParseInt(os.Getenv(envPrefix+"SMTPPORT"), 10, 32)
+	t.Run("Notify", func(t *testing.T) {
-	tSmtpTLS, _ := strconv.ParseBool(os.Getenv(envPrefix + "SMTPTLS"))
+		t.Log(strings.Join([]string{
-	tSmtpUsername := os.Getenv(envPrefix + "USERNAME")
+			"args:",
-	tSmtpPassword := os.Getenv(envPrefix + "PASSWORD")
+			fmt.Sprintf("SMTPHOST: %v", fSmtpHost),
-	tSenderAddress := os.Getenv(envPrefix + "SENDERADDRESS")
+			fmt.Sprintf("SMTPPORT: %v", fSmtpPort),
-	tReceiverAddress := os.Getenv(envPrefix + "RECEIVERADDRESS")
+			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:        tSmtpHost,
+			SmtpHost:        fSmtpHost,
-		SmtpPort:        int32(tSmtpPort),
+			SmtpPort:        int32(fSmtpPort),
-		SmtpTLS:         tSmtpTLS,
+			SmtpTLS:         fSmtpTLS,
-		Username:        tSmtpUsername,
+			Username:        fUsername,
-		Password:        tSmtpPassword,
+			Password:        fPassword,
-		SenderAddress:   tSenderAddress,
+			SenderAddress:   fSenderAddress,
-		ReceiverAddress: tReceiverAddress,
+			ReceiverAddress: fReceiverAddress,
 		})
 		if err != nil {
 			t.Errorf("err: %+v", err)
-		panic(err)
+			return
 		}
 
-	res, err := notifier.Notify(context.Background(), MockSubject, MockMessage)
+		res, err := notifier.Notify(context.Background(), mockSubject, mockMessage)
 		if err != nil {
 			t.Errorf("err: %+v", err)
-		panic(err)
+			return
 		}
 
 		t.Logf("ok: %v", res)
+	})
 }

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"
+	mockSubject = "test_subject"
-	MockMessage = "test_message"
+	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 webhook_test.go -args \
-	go test -v -run TestNotify webhook_test.go
+	--CERTIMATE_NOTIFIER_WEBHOOK_URL="https://example.com/your-webhook-url"
 */
-func TestNotify(t *testing.T) {
+func Test(t *testing.T) {
-	envPrefix := "CERTIMATE_NOTIFIER_WEBHOOK_"
+	flag.Parse()
-	tUrl := os.Getenv(envPrefix + "URL")
+
+	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: tUrl,
+			Url: fUrl,
 		})
 		if err != nil {
 			t.Errorf("err: %+v", err)
-		panic(err)
+			return
 		}
 
-	res, err := notifier.Notify(context.Background(), MockSubject, MockMessage)
+		res, err := notifier.Notify(context.Background(), mockSubject, mockMessage)
 		if err != nil {
 			t.Errorf("err: %+v", err)
-		panic(err)
+			return
 		}
 
 		t.Logf("ok: %v", res)
+	})
 }