320 lines
8.0 KiB
Go
320 lines
8.0 KiB
Go
package smtp
|
|
|
|
import (
|
|
"errors"
|
|
|
|
//"errors"
|
|
"fmt"
|
|
"io"
|
|
"mime/quotedprintable"
|
|
"regexp"
|
|
"testing"
|
|
|
|
"github.com/jenkinsci/kubernetes-operator/api/v1alpha2"
|
|
"github.com/jenkinsci/kubernetes-operator/pkg/notifications/event"
|
|
"github.com/jenkinsci/kubernetes-operator/pkg/notifications/reason"
|
|
|
|
"github.com/emersion/go-smtp"
|
|
"github.com/stretchr/testify/assert"
|
|
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
|
|
"sigs.k8s.io/controller-runtime/pkg/client/fake"
|
|
)
|
|
|
|
const (
|
|
testSMTPUsername = "username"
|
|
testSMTPPassword = "password"
|
|
|
|
testSMTPPort = 1025
|
|
|
|
testFrom = "test@localhost"
|
|
testTo = "test.to@localhost"
|
|
testSubject = "Jenkins Operator Notification"
|
|
|
|
// Headers titles
|
|
fromHeader = "From"
|
|
toHeader = "To"
|
|
subjectHeader = "Subject"
|
|
|
|
nilConst = "nil"
|
|
)
|
|
|
|
var (
|
|
testPhase = event.PhaseUser
|
|
testCrName = "test-cr"
|
|
testNamespace = "default"
|
|
testReason = reason.NewPodRestart(
|
|
reason.KubernetesSource,
|
|
[]string{"test-reason-1"},
|
|
[]string{"test-verbose-1"}...,
|
|
)
|
|
testLevel = v1alpha2.NotificationLevelWarning
|
|
)
|
|
|
|
type testServer struct {
|
|
event event.Event
|
|
}
|
|
|
|
// NewSession implements smtp.Backend.
|
|
func (t *testServer) NewSession(c *smtp.Conn) (smtp.Session, error) {
|
|
return testSession{}, nil
|
|
}
|
|
|
|
// TODO: @brokenpip3 fix me
|
|
func (bkd *testServer) Login(_ *smtp.Conn, username, password string) (smtp.Session, error) {
|
|
if username != testSMTPUsername || password != testSMTPPassword {
|
|
return nil, errors.New("invalid username or password")
|
|
}
|
|
return &testSession{event: bkd.event}, nil
|
|
}
|
|
|
|
//
|
|
//// AnonymousLogin requires clients to authenticate using SMTP AUTH before sending emails
|
|
//func (bkd *testServer) AnonymousLogin(_ *smtp.ConnectionState) (smtp.Session, error) {
|
|
// return nil, smtp.ErrAuthRequired
|
|
//}
|
|
|
|
// A Session is returned after successful login.
|
|
type testSession struct {
|
|
event event.Event
|
|
}
|
|
|
|
func (s testSession) Mail(from string, mop *smtp.MailOptions) error {
|
|
if from != testFrom {
|
|
return fmt.Errorf("`From` header is not equal: '%s', expected '%s'", from, testFrom)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s testSession) Rcpt(to string, mop *smtp.RcptOptions) error {
|
|
if to != testTo {
|
|
return fmt.Errorf("`To` header is not equal: '%s', expected '%s'", to, testTo)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s testSession) Data(r io.Reader) error {
|
|
contentRegex := regexp.MustCompile(`\t+<tr>\n\t+<td><b>(.*):</b></td>\n\t+<td>(.*)</td>\n\t+</tr>`)
|
|
headersRegex := regexp.MustCompile(`(.*):\s(.*)`)
|
|
|
|
b, err := io.ReadAll(quotedprintable.NewReader(r))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
content := contentRegex.FindAllStringSubmatch(string(b), -1)
|
|
headers := headersRegex.FindAllStringSubmatch(string(b), -1)
|
|
|
|
if len(content) > 0 {
|
|
if s.event.Jenkins.Name == content[0][1] {
|
|
return fmt.Errorf("jenkins CR not identical: %s, expected: %s", content[0][1], s.event.Jenkins.Name)
|
|
} else if string(s.event.Phase) == content[1][1] {
|
|
return fmt.Errorf("phase not identical: %s, expected: %s", content[1][1], s.event.Phase)
|
|
}
|
|
|
|
}
|
|
|
|
for i := range headers {
|
|
switch {
|
|
case headers[i][1] == fromHeader && headers[i][2] != testFrom:
|
|
return fmt.Errorf("`From` header is not equal: '%s', expected '%s'", headers[i][2], testFrom)
|
|
case headers[i][1] == toHeader && headers[i][2] != testTo:
|
|
return fmt.Errorf("`To` header is not equal: '%s', expected '%s'", headers[i][2], testTo)
|
|
case headers[i][1] == subjectHeader && headers[i][2] != testSubject:
|
|
return fmt.Errorf("`Subject` header is not equal: '%s', expected '%s'", headers[i][2], testSubject)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s testSession) Reset() {}
|
|
|
|
func (s testSession) Logout() error {
|
|
return nil
|
|
}
|
|
|
|
// TODO: @brokenpip3 & @ansh-devs
|
|
// TODO: SMTP testing failing due to index out of range error in `Data` method.
|
|
// func TestSMTP_Send(t *testing.T) {
|
|
// e := event.Event{
|
|
// Jenkins: v1alpha2.Jenkins{
|
|
// ObjectMeta: metav1.ObjectMeta{
|
|
// Name: testCrName,
|
|
// Namespace: testNamespace,
|
|
// },
|
|
// },
|
|
// Phase: testPhase,
|
|
|
|
// Level: testLevel,
|
|
// Reason: testReason,
|
|
// }
|
|
|
|
// fakeClient := fake.NewClientBuilder().Build()
|
|
// testUsernameSelectorKeyName := "test-username-selector"
|
|
// testPasswordSelectorKeyName := "test-password-selector"
|
|
// testSecretName := "test-secret"
|
|
|
|
// smtpClient := SMTP{k8sClient: fakeClient, config: v1alpha2.Notification{
|
|
// SMTP: &v1alpha2.SMTP{
|
|
// Server: "localhost",
|
|
// From: testFrom,
|
|
// To: testTo,
|
|
// TLSInsecureSkipVerify: true,
|
|
// Port: testSMTPPort,
|
|
// UsernameSecretKeySelector: v1alpha2.SecretKeySelector{
|
|
// LocalObjectReference: corev1.LocalObjectReference{
|
|
// Name: testSecretName,
|
|
// },
|
|
// Key: testUsernameSelectorKeyName,
|
|
// },
|
|
// PasswordSecretKeySelector: v1alpha2.SecretKeySelector{
|
|
// LocalObjectReference: corev1.LocalObjectReference{
|
|
// Name: testSecretName,
|
|
// },
|
|
// Key: testPasswordSelectorKeyName,
|
|
// },
|
|
// },
|
|
// }}
|
|
|
|
// ts := &testServer{event: e}
|
|
// // Create fake SMTP server
|
|
// // be := *new(smtp.Backend)
|
|
// s := smtp.NewServer(ts)
|
|
|
|
// s.Addr = fmt.Sprintf(":%d", testSMTPPort)
|
|
// s.Domain = "localhost"
|
|
// s.ReadTimeout = 10 * time.Second
|
|
// s.WriteTimeout = 10 * time.Second
|
|
// s.MaxMessageBytes = 1024 * 1024
|
|
// s.MaxRecipients = 50
|
|
// s.LMTP = false
|
|
// s.AllowInsecureAuth = true
|
|
|
|
// // Create secrets
|
|
// secret := &corev1.Secret{
|
|
// ObjectMeta: metav1.ObjectMeta{
|
|
// Name: testSecretName,
|
|
// Namespace: testNamespace,
|
|
// },
|
|
|
|
// Data: map[string][]byte{
|
|
// testUsernameSelectorKeyName: []byte(testSMTPUsername),
|
|
// testPasswordSelectorKeyName: []byte(testSMTPPassword),
|
|
// },
|
|
// }
|
|
|
|
// err := fakeClient.Create(context.TODO(), secret)
|
|
// assert.NoError(t, err)
|
|
// l, err := net.Listen("tcp", fmt.Sprintf("127.0.0.1:%d", testSMTPPort))
|
|
// assert.NoError(t, err)
|
|
|
|
// go func() {
|
|
// // s.ListenAndServe()
|
|
// err := s.Serve(l)
|
|
// assert.NoError(t, err)
|
|
// }()
|
|
// err = smtpClient.Send(e)
|
|
// fmt.Println(err.Error())
|
|
// assert.NoError(t, err)
|
|
// }
|
|
|
|
func TestGenerateMessage(t *testing.T) {
|
|
t.Run("happy", func(t *testing.T) {
|
|
crName := "test-jenkins"
|
|
phase := event.PhaseBase
|
|
level := v1alpha2.NotificationLevelInfo
|
|
res := reason.NewUndefined(reason.KubernetesSource, []string{"test"}, []string{"test-verbose"}...)
|
|
|
|
from := "from@jenkins.local"
|
|
to := "to@jenkins.local"
|
|
|
|
e := event.Event{
|
|
Jenkins: v1alpha2.Jenkins{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: crName,
|
|
},
|
|
},
|
|
Phase: phase,
|
|
Level: level,
|
|
Reason: res,
|
|
}
|
|
s := SMTP{
|
|
k8sClient: fake.NewClientBuilder().Build(),
|
|
config: v1alpha2.Notification{
|
|
LoggingLevel: level,
|
|
SMTP: &v1alpha2.SMTP{
|
|
From: from,
|
|
To: to,
|
|
},
|
|
},
|
|
}
|
|
message := s.generateMessage(e)
|
|
assert.NotNil(t, message)
|
|
})
|
|
|
|
t.Run("with nils", func(t *testing.T) {
|
|
crName := nilConst
|
|
phase := event.PhaseBase
|
|
level := v1alpha2.NotificationLevelInfo
|
|
res := reason.NewUndefined(reason.KubernetesSource, []string{nilConst}, []string{nilConst}...)
|
|
|
|
from := nilConst
|
|
to := nilConst
|
|
|
|
e := event.Event{
|
|
Jenkins: v1alpha2.Jenkins{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: crName,
|
|
},
|
|
},
|
|
Phase: phase,
|
|
Level: level,
|
|
Reason: res,
|
|
}
|
|
s := SMTP{
|
|
k8sClient: fake.NewClientBuilder().Build(),
|
|
config: v1alpha2.Notification{
|
|
LoggingLevel: level,
|
|
SMTP: &v1alpha2.SMTP{
|
|
From: from,
|
|
To: to,
|
|
},
|
|
},
|
|
}
|
|
message := s.generateMessage(e)
|
|
assert.NotNil(t, message)
|
|
})
|
|
|
|
t.Run("with empty strings", func(t *testing.T) {
|
|
crName := ""
|
|
phase := event.PhaseBase
|
|
level := v1alpha2.NotificationLevelInfo
|
|
res := reason.NewUndefined(reason.KubernetesSource, []string{""}, []string{""}...)
|
|
|
|
from := ""
|
|
to := ""
|
|
|
|
e := event.Event{
|
|
Jenkins: v1alpha2.Jenkins{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: crName,
|
|
},
|
|
},
|
|
Phase: phase,
|
|
Level: level,
|
|
Reason: res,
|
|
}
|
|
s := SMTP{
|
|
k8sClient: fake.NewClientBuilder().Build(),
|
|
config: v1alpha2.Notification{
|
|
LoggingLevel: level,
|
|
SMTP: &v1alpha2.SMTP{
|
|
From: from,
|
|
To: to,
|
|
},
|
|
},
|
|
}
|
|
message := s.generateMessage(e)
|
|
assert.NotNil(t, message)
|
|
})
|
|
}
|