smtp/relay_test.go

   1 // mailpopbox
   2 // Copyright 2020 Blue Static <https://www.bluestatic.org>
   3 // This program is free software licensed under the GNU General Public License,
   4 // version 3.0. The full text of the license can be found in LICENSE.txt.
   5 // SPDX-License-Identifier: GPL-3.0-only
   6
   7 package smtp
   8
   9 import (
  10         "bytes"
  11         "fmt"
  12         "io/ioutil"
  13         "mime"
  14         "mime/multipart"
  15         "net"
  16         "net/mail"
  17         "strings"
  18         "testing"
  19
  20         "go.uber.org/zap"
  21 )
  22
  23 type deliveryServer struct {
  24         testServer
  25         messages []Envelope
  26 }
  27
  28 func (s *deliveryServer) DeliverMessage(env Envelope) *ReplyLine {
  29         s.messages = append(s.messages, env)
  30         return nil
  31 }
  32
  33 func TestRelayRoundTrip(t *testing.T) {
  34         s := &deliveryServer{
  35                 testServer: testServer{domain: "receive.net"},
  36         }
  37         l := runServer(t, s)
  38         defer l.Close()
  39
  40         env := Envelope{
  41                 MailFrom: mail.Address{Address: "from@sender.org"},
  42                 RcptTo:   []mail.Address{{Address: "to@receive.net"}},
  43                 Data:     []byte("~~~Message~~~\n"),
  44                 ID:       "ididid",
  45         }
  46
  47         host, port, _ := net.SplitHostPort(l.Addr().String())
  48         relayMessageToHost(s, env, zap.NewNop(), env.RcptTo[0].Address, host, port)
  49
  50         if want, got := 1, len(s.messages); want != got {
  51                 t.Errorf("Want %d message to be delivered, got %d", want, got)
  52                 return
  53         }
  54
  55         received := s.messages[0]
  56
  57         if want, got := env.MailFrom.Address, received.MailFrom.Address; want != got {
  58                 t.Errorf("Want MailFrom %s, got %s", want, got)
  59         }
  60         if want, got := 1, len(received.RcptTo); want != got {
  61                 t.Errorf("Want %d RcptTo, got %d", want, got)
  62                 return
  63         }
  64         if want, got := env.RcptTo[0].Address, received.RcptTo[0].Address; want != got {
  65                 t.Errorf("Want RcptTo %s, got %s", want, got)
  66         }
  67
  68         if !bytes.HasSuffix(received.Data, env.Data) {
  69                 t.Errorf("Delivered message does not match relayed one. Delivered=%q Relayed=%q", string(env.Data), string(received.Data))
  70         }
  71 }
  72
  73 func TestDeliveryFailureMessage(t *testing.T) {
  74         s := &deliveryServer{}
  75
  76         env := Envelope{
  77                 MailFrom:   mail.Address{Address: "from@sender.org"},
  78                 RcptTo:     []mail.Address{{Address: "to@receive.net"}},
  79                 Data:       []byte("Message\n"),
  80                 ID:         "m.willfail",
  81                 EHLO:       "mx.receive.net",
  82                 RemoteAddr: &net.IPAddr{net.IPv4(127, 0, 0, 1), ""},
  83         }
  84
  85         errorStr1 := "internal message"
  86         errorStr2 := "general error 122"
  87         deliverRelayFailure(s, env, zap.NewNop(), env.RcptTo[0].Address, errorStr1, fmt.Errorf(errorStr2))
  88
  89         if want, got := 1, len(s.messages); want != got {
  90                 t.Errorf("Want %d failure notification, got %d", want, got)
  91                 return
  92         }
  93
  94         failure := s.messages[0]
  95
  96         if want, got := env.MailFrom.Address, failure.RcptTo[0].Address; want != got {
  97                 t.Errorf("Failure message should be delivered to sender %s, actually %s", want, got)
  98         }
  99
 100         // Read the failure message.
 101         buf := bytes.NewBuffer(failure.Data)
 102         msg, err := mail.ReadMessage(buf)
 103         if err != nil {
 104                 t.Errorf("Failed to read message: %v", err)
 105                 return
 106         }
 107
 108         // Parse out the Content-Type to get the multipart boundary string.
 109         mediatype, mtheaders, err := mime.ParseMediaType(msg.Header["Content-Type"][0])
 110         if err != nil {
 111                 t.Errorf("Failed to parse MIME headers: %v", err)
 112                 return
 113         }
 114
 115         if want, got := "multipart/report", mediatype; want != got {
 116                 t.Errorf("Want MIME type of %q, got %q", want, got)
 117         }
 118
 119         if want, got := "delivery-status", mtheaders["report-type"]; want != got {
 120                 t.Errorf("Want report-type of %q, got %q", want, got)
 121         }
 122
 123         boundary := mtheaders["boundary"]
 124
 125         if want, got := "Delivery Status Notification (Failure)", msg.Header["Subject"][0]; want != got {
 126                 t.Errorf("Want Subject field %q, got %q", want, got)
 127         }
 128
 129         if want, got := "<"+env.MailFrom.Address+">", msg.Header["To"][0]; want != got {
 130                 t.Errorf("Want To field %q, got %q", want, got)
 131         }
 132
 133         // Parse the multi-part messsage.
 134         mpr := multipart.NewReader(msg.Body, boundary)
 135         part, err := mpr.NextPart()
 136         if err != nil {
 137                 t.Errorf("Error reading part 0: %v", err)
 138                 return
 139         }
 140
 141         // First part is the human-readable error.
 142         if want, got := "text/plain; charset=UTF-8", part.Header["Content-Type"][0]; want != got {
 143                 t.Errorf("Part 0 type want %q, got %q", want, got)
 144         }
 145
 146         content, err := ioutil.ReadAll(part)
 147         if err != nil {
 148                 t.Errorf("Failed to read part 0 content: %v", err)
 149                 return
 150         }
 151         contentStr := string(content)
 152
 153         if !strings.Contains(contentStr, "Delivery Failure") {
 154                 t.Errorf("Missing Delivery Failure")
 155         }
 156
 157         if want := fmt.Sprintf("%s:\n%s", errorStr1, errorStr2); !strings.Contains(contentStr, want) {
 158                 t.Errorf("Missing error string %q", want)
 159         }
 160
 161         // Second part is the status information.
 162         part, err = mpr.NextPart()
 163         if err != nil {
 164                 t.Errorf("Error reading part 1: %v", err)
 165                 return
 166         }
 167
 168         if want, got := "message/delivery-status", part.Header["Content-Type"][0]; want != got {
 169                 t.Errorf("Part 1 type want %q, got %q", want, got)
 170         }
 171
 172         content, err = ioutil.ReadAll(part)
 173         if err != nil {
 174                 t.Errorf("Failed to read part 1 content: %v", err)
 175                 return
 176         }
 177         contentStr = string(content)
 178
 179         if want := "Original-Envelope-ID: " + env.ID + "\n"; !strings.Contains(contentStr, want) {
 180                 t.Errorf("Missing %q in %q", want, contentStr)
 181         }
 182
 183         if want := "Reporting-UA: " + env.EHLO + "\n"; !strings.Contains(contentStr, want) {
 184                 t.Errorf("Missing %q in %q", want, contentStr)
 185         }
 186
 187         if want := "Reporting-MTA: dns; localhost [127.0.0.1]\n"; !strings.Contains(contentStr, want) {
 188                 t.Errorf("Missing %q in %q", want, contentStr)
 189         }
 190
 191         // Third part is the original message.
 192         part, err = mpr.NextPart()
 193         if err != nil {
 194                 t.Errorf("Error reading part 2: %v", err)
 195                 return
 196         }
 197
 198         if want, got := "message/rfc822", part.Header["Content-Type"][0]; want != got {
 199                 t.Errorf("Part 2 type want %q, got %q", want, got)
 200         }
 201
 202         content, err = ioutil.ReadAll(part)
 203         if err != nil {
 204                 t.Errorf("Failed to read part 2 content: %v", err)
 205                 return
 206         }
 207
 208         if !bytes.Equal(content, env.Data) {
 209                 t.Errorf("Byte content of original message does not match")
 210         }
 211 }