diff --git a/internal/notify/factory.go b/internal/notify/factory.go index ccdd5389..d4ce1e8f 100644 --- a/internal/notify/factory.go +++ b/internal/notify/factory.go @@ -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(¬ifierEmail.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(¬ifierWebhook.WebhookNotifierConfig{ + return npWebhook.New(&npWebhook.WebhookNotifierConfig{ Url: maps.GetValueAsString(channelConfig, "url"), }) case domain.NotifyChannelDingtalk: - return notifierDingTalk.New(¬ifierDingTalk.DingTalkNotifierConfig{ + return npDingTalk.New(&npDingTalk.DingTalkNotifierConfig{ AccessToken: maps.GetValueAsString(channelConfig, "accessToken"), Secret: maps.GetValueAsString(channelConfig, "secret"), }) case domain.NotifyChannelLark: - return notifierLark.New(¬ifierLark.LarkNotifierConfig{ + return npLark.New(&npLark.LarkNotifierConfig{ WebhookUrl: maps.GetValueAsString(channelConfig, "webhookUrl"), }) case domain.NotifyChannelTelegram: - return notifierTelegram.New(¬ifierTelegram.TelegramNotifierConfig{ + return npTelegram.New(&npTelegram.TelegramNotifierConfig{ ApiToken: maps.GetValueAsString(channelConfig, "apiToken"), ChatId: maps.GetValueAsInt64(channelConfig, "chatId"), }) case domain.NotifyChannelServerChan: - return notifierServerChan.New(¬ifierServerChan.ServerChanNotifierConfig{ + return npServerChan.New(&npServerChan.ServerChanNotifierConfig{ Url: maps.GetValueAsString(channelConfig, "url"), }) case domain.NotifyChannelBark: - return notifierBark.New(¬ifierBark.BarkNotifierConfig{ + return npBark.New(&npBark.BarkNotifierConfig{ DeviceKey: maps.GetValueAsString(channelConfig, "deviceKey"), ServerUrl: maps.GetValueAsString(channelConfig, "serverUrl"), }) diff --git a/internal/pkg/core/deployer/providers/local/local_test.go b/internal/pkg/core/deployer/providers/local/local_test.go new file mode 100644 index 00000000..819c98cf --- /dev/null +++ b/internal/pkg/core/deployer/providers/local/local_test.go @@ -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) +} diff --git a/internal/pkg/core/deployer/providers/ssh/ssh_test.go b/internal/pkg/core/deployer/providers/ssh/ssh_test.go new file mode 100644 index 00000000..3e841f0c --- /dev/null +++ b/internal/pkg/core/deployer/providers/ssh/ssh_test.go @@ -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) +} diff --git a/internal/pkg/core/deployer/providers/webhook/webhook.go b/internal/pkg/core/deployer/providers/webhook/webhook.go index 4de107ff..2e736fa2 100644 --- a/internal/pkg/core/deployer/providers/webhook/webhook.go +++ b/internal/pkg/core/deployer/providers/webhook/webhook.go @@ -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 } diff --git a/internal/pkg/core/deployer/providers/webhook/webhook_test.go b/internal/pkg/core/deployer/providers/webhook/webhook_test.go new file mode 100644 index 00000000..c9ac73aa --- /dev/null +++ b/internal/pkg/core/deployer/providers/webhook/webhook_test.go @@ -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) +} diff --git a/internal/pkg/core/notifier/providers/email/email_test.go b/internal/pkg/core/notifier/providers/email/email_test.go index 1197a1a6..8a9e860f 100644 --- a/internal/pkg/core/notifier/providers/email/email_test.go +++ b/internal/pkg/core/notifier/providers/email/email_test.go @@ -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(¬ifierEmail.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) } diff --git a/internal/pkg/core/notifier/providers/webhook/webhook_test.go b/internal/pkg/core/notifier/providers/webhook/webhook_test.go new file mode 100644 index 00000000..eca46819 --- /dev/null +++ b/internal/pkg/core/notifier/providers/webhook/webhook_test.go @@ -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) +}