eintopf.info@v0.13.16/test/mailhog.go

// Copyright (C) 2024 The Eintopf authors
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.

package test

import (
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"net/smtp"
	"net/url"
	"testing"
	"time"

	"github.com/ory/dockertest/v3"
)

func RunMailHog(t *testing.T, pool *dockertest.Pool) (string, MailHogClient) {
	// n, err := pool.CreateNetwork("mailhog")
	// if err != nil {
	// 	t.Fatalf("Cloud not create mailhog network: %s", err)
	// }
	mailhog, err := pool.RunWithOptions(&dockertest.RunOptions{
		Repository: "mailhog/mailhog",
		Tag:        "latest",
		// Networks:   []*dockertest.Network{n},
	})
	if err != nil {
		t.Fatalf("Could not start resource: %s", err)
	}
	t.Cleanup(func() {
		if err := pool.Purge(mailhog); err != nil {
			t.Fatalf("Could not purge resource: %s", err)
		}
	})
	client := MailHogClient{URL: fmt.Sprintf("http://localhost:%s", mailhog.GetPort("8025/tcp"))}

	// exponential backoff-retry, because the application in the container might not be ready to accept connections yet
	if err := pool.Retry(func() error {
		_, err := client.V1GetMessages()
		return err
	}); err != nil {
		t.Fatalf("Could not connect to mailhog: %s", err)
	}

	smtpHost := fmt.Sprintf("localhost:%s", mailhog.GetPort("1025/tcp"))
	// stunnel, err := pool.RunWithOptions(&dockertest.RunOptions{
	// 	Repository: "dweomer/stunnel@sha256",
	// 	// Tag:        "sha256:2d883cdcc3c65298a4ec24e07ba6415304d4b579c0826e5d9e0cadad6343ce43",
	// 	Tag: "2d883cdcc3c65298a4ec24e07ba6415304d4b579c0826e5d9e0cadad6343ce43",
	// 	Env: []string{
	// 		"STUNNEL_SERVICE=smtps",
	// 		"STUNNEL_ACCEPT=465",
	// 		fmt.Sprintf("STUNNEL_CONNECT=%s:%s", mailhog.GetIPInNetwork(n), mailhog.GetPort("1025/tcp")),
	// 	},
	// 	ExposedPorts: []string{"465"},
	// 	Networks:     []*dockertest.Network{n},
	// })
	// if err != nil {
	// 	t.Fatalf("Could not start resource: %s", err)
	// }
	// t.Cleanup(func() {
	// 	if err := pool.Purge(stunnel); err != nil {
	// 		t.Fatalf("Could not purge resource: %s", err)
	// 	}
	// })
	// smtpHost := fmt.Sprintf("localhost:%s", stunnel.GetPort("465/tcp"))
	// log.Println("hre", smtpHost)
	// // exponential backoff-retry, because the application in the container might not be ready to accept connections yet
	// if err := pool.Retry(func() error {
	// 	return dialEmail(smtpHost)
	// }); err != nil {
	// 	t.Fatalf("Could not connect to mailhog via stunnel: %s", err)
	// }
	// // time.Sleep(time.Second * 5)
	// log.Println("hrea")
	// t.Fatal("here")

	return smtpHost, client
}

func dialEmail(smtpHost string) error {
	_, err := smtp.Dial(smtpHost)
	if err != nil {
		return err
	}
	// host, _, _ := net.SplitHostPort(smtpHost)
	// tlsconfig := &tls.Config{InsecureSkipVerify: true, ServerName: host}
	// if err := c.StartTLS(tlsconfig); err != nil {
	// 	return err
	// }
	// if err := c.StartTLS(tlsconfig); err != nil {
	// 	return err
	// }
	//
	// w, err := c.Data()
	// if err != nil {
	// 	return err
	// }
	// if _, err := w.Write([]byte{}); err != nil {
	// 	return err
	// }
	// if err := w.Close(); err != nil {
	// 	return err
	// }

	// return c.Quit()
	return nil
}

func (c MailHogClient) WantLastEmailToBe(t *testing.T, from string, to string, subject string, body string) {
	t.Helper()

	messages, err := c.V1GetMessages()
	if err != nil {
		t.Error(err)
	}

	if len(messages) == 0 {
		t.Error("no emails")
		return
	}

	m := messages[len(messages)-1]
	if m.Raw.From != from {
		t.Errorf("want FROM to be %s, got %s", from, messages[0].Raw.From)
	}
	if m.Raw.To[0] != to {
		t.Errorf("want TO to be %s, got %s", to, messages[0].Raw.To[0])
	}
	if m.Content.Headers["Subject"][0] != subject {
		t.Errorf("want SUBJECT to be '%s', got '%s'", subject, messages[0].Content.Headers["Subject"][0])
	}
	if m.Content.Body != body {
		t.Errorf("want BODY to be '%s', got '%s'", body, messages[0].Content.Body)
	}
}

func (c MailHogClient) GetLastEmail() (MailHogMessage, error) {
	messages, err := c.V1GetMessages()
	if err != nil {
		return MailHogMessage{}, err
	}

	if len(messages) == 0 {
		return MailHogMessage{}, fmt.Errorf("no emails received")
	}

	return messages[len(messages)-1], nil
}

type MailHogMessage struct {
	ID   string
	From struct {
		Relays  string
		Mailbox string
		Domain  string
		Params  string
	}
	To []struct {
		Relays  string
		Mailbox string
		Domain  string
		Params  string
	}
	Content struct {
		Headers map[string][]string
		Body    string
		Size    int
		Mime    string
	}
	Created time.Time
	Mime    string
	Raw     struct {
		From string
		To   []string
		Data string
		Helo string
	}
}

type MailHogClient struct {
	URL string
}

func (m MailHogClient) V1GetMessages() ([]MailHogMessage, error) {
	path, err := url.JoinPath(m.URL, "api/v1/messages")
	if err != nil {
		return nil, err
	}
	resp, err := http.Get(path)
	if err != nil {
		return nil, err
	}
	data, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}
	var messages []MailHogMessage
	err = json.Unmarshal(data, &messages)
	if err != nil {
		return nil, err
	}
	return messages, nil
}