Refactor web package into two packages: httpd and webui

webui/mailbox_controller.go

@@ -0,0 +1,431 @@
+package webui
+
+import (
+	"fmt"
+	"html/template"
+	"io"
+	"net/http"
+	"net/mail"
+	"strconv"
+	"time"
+
+	"github.com/jhillyerd/inbucket/httpd"
+	"github.com/jhillyerd/inbucket/log"
+	"github.com/jhillyerd/inbucket/smtpd"
+)
+
+// JSONMessageHeader contains the basic header data for a message
+type JSONMessageHeader struct {
+	Mailbox string
+	ID      string `json:"Id"`
+	From    string
+	Subject string
+	Date    time.Time
+	Size    int64
+}
+
+// JSONMessage contains the same data as the header plus a JSONMessageBody
+type JSONMessage struct {
+	Mailbox string
+	ID      string `json:"Id"`
+	From    string
+	Subject string
+	Date    time.Time
+	Size    int64
+	Body    *JSONMessageBody
+	Header  mail.Header
+}
+
+// JSONMessageBody contains the Text and HTML versions of the message body
+type JSONMessageBody struct {
+	Text string
+	HTML string `json:"Html"`
+}
+
+// MailboxIndex renders the index page for a particular mailbox
+func MailboxIndex(w http.ResponseWriter, req *http.Request, ctx *httpd.Context) (err error) {
+	// Form values must be validated manually
+	name := req.FormValue("name")
+	selected := req.FormValue("id")
+
+	if len(name) == 0 {
+		ctx.Session.AddFlash("Account name is required", "errors")
+		http.Redirect(w, req, httpd.Reverse("RootIndex"), http.StatusSeeOther)
+		return nil
+	}
+
+	name, err = smtpd.ParseMailboxName(name)
+	if err != nil {
+		ctx.Session.AddFlash(err.Error(), "errors")
+		http.Redirect(w, req, httpd.Reverse("RootIndex"), http.StatusSeeOther)
+		return nil
+	}
+
+	// Remember this mailbox was visited
+	RememberMailbox(ctx, name)
+
+	return httpd.RenderTemplate("mailbox/index.html", w, map[string]interface{}{
+		"ctx":      ctx,
+		"name":     name,
+		"selected": selected,
+	})
+}
+
+// MailboxLink handles pretty links to a particular message. Renders a redirect
+func MailboxLink(w http.ResponseWriter, req *http.Request, ctx *httpd.Context) (err error) {
+	// Don't have to validate these aren't empty, Gorilla returns 404
+	id := ctx.Vars["id"]
+	name, err := smtpd.ParseMailboxName(ctx.Vars["name"])
+	if err != nil {
+		ctx.Session.AddFlash(err.Error(), "errors")
+		http.Redirect(w, req, httpd.Reverse("RootIndex"), http.StatusSeeOther)
+		return nil
+	}
+
+	uri := fmt.Sprintf("%s?name=%s&id=%s", httpd.Reverse("MailboxIndex"), name, id)
+	http.Redirect(w, req, uri, http.StatusSeeOther)
+	return nil
+}
+
+// MailboxList renders a list of messages in a mailbox. Renders JSON or a partial
+func MailboxList(w http.ResponseWriter, req *http.Request, ctx *httpd.Context) (err error) {
+	// Don't have to validate these aren't empty, Gorilla returns 404
+	name, err := smtpd.ParseMailboxName(ctx.Vars["name"])
+	if err != nil {
+		return err
+	}
+	mb, err := ctx.DataStore.MailboxFor(name)
+	if err != nil {
+		// This doesn't indicate not found, likely an IO error
+		return fmt.Errorf("Failed to get mailbox for %q: %v", name, err)
+	}
+	messages, err := mb.GetMessages()
+	if err != nil {
+		// This doesn't indicate empty, likely an IO error
+		return fmt.Errorf("Failed to get messages for %v: %v", name, err)
+	}
+	log.Tracef("Got %v messsages", len(messages))
+
+	if ctx.IsJSON {
+		jmessages := make([]*JSONMessageHeader, len(messages))
+		for i, msg := range messages {
+			jmessages[i] = &JSONMessageHeader{
+				Mailbox: name,
+				ID:      msg.ID(),
+				From:    msg.From(),
+				Subject: msg.Subject(),
+				Date:    msg.Date(),
+				Size:    msg.Size(),
+			}
+		}
+		return httpd.RenderJSON(w, jmessages)
+	}
+
+	return httpd.RenderPartial("mailbox/_list.html", w, map[string]interface{}{
+		"ctx":      ctx,
+		"name":     name,
+		"messages": messages,
+	})
+}
+
+// MailboxShow renders a particular message from a mailbox. Renders JSON or a partial
+func MailboxShow(w http.ResponseWriter, req *http.Request, ctx *httpd.Context) (err error) {
+	// Don't have to validate these aren't empty, Gorilla returns 404
+	id := ctx.Vars["id"]
+	name, err := smtpd.ParseMailboxName(ctx.Vars["name"])
+	if err != nil {
+		return err
+	}
+	mb, err := ctx.DataStore.MailboxFor(name)
+	if err != nil {
+		// This doesn't indicate not found, likely an IO error
+		return fmt.Errorf("Failed to get mailbox for %q: %v", name, err)
+	}
+	msg, err := mb.GetMessage(id)
+	if err == smtpd.ErrNotExist {
+		http.NotFound(w, req)
+		return nil
+	}
+	if err != nil {
+		// This doesn't indicate empty, likely an IO error
+		return fmt.Errorf("GetMessage(%q) failed: %v", id, err)
+	}
+	header, err := msg.ReadHeader()
+	if err != nil {
+		return fmt.Errorf("ReadHeader(%q) failed: %v", id, err)
+	}
+	mime, err := msg.ReadBody()
+	if err != nil {
+		return fmt.Errorf("ReadBody(%q) failed: %v", id, err)
+	}
+
+	if ctx.IsJSON {
+		return httpd.RenderJSON(w,
+			&JSONMessage{
+				Mailbox: name,
+				ID:      msg.ID(),
+				From:    msg.From(),
+				Subject: msg.Subject(),
+				Date:    msg.Date(),
+				Size:    msg.Size(),
+				Header:  header.Header,
+				Body: &JSONMessageBody{
+					Text: mime.Text,
+					HTML: mime.Html,
+				},
+			})
+	}
+
+	body := template.HTML(httpd.TextToHTML(mime.Text))
+	htmlAvailable := mime.Html != ""
+
+	return httpd.RenderPartial("mailbox/_show.html", w, map[string]interface{}{
+		"ctx":           ctx,
+		"name":          name,
+		"message":       msg,
+		"body":          body,
+		"htmlAvailable": htmlAvailable,
+		"attachments":   mime.Attachments,
+	})
+}
+
+// MailboxPurge deletes all messages from a mailbox.  Renders JSON or text/plain OK
+func MailboxPurge(w http.ResponseWriter, req *http.Request, ctx *httpd.Context) (err error) {
+	// Don't have to validate these aren't empty, Gorilla returns 404
+	name, err := smtpd.ParseMailboxName(ctx.Vars["name"])
+	if err != nil {
+		return err
+	}
+	mb, err := ctx.DataStore.MailboxFor(name)
+	if err != nil {
+		// This doesn't indicate not found, likely an IO error
+		return fmt.Errorf("Failed to get mailbox for %q: %v", name, err)
+	}
+	// Delete all messages
+	err = mb.Purge()
+	if err != nil {
+		return fmt.Errorf("Mailbox(%q) purge failed: %v", name, err)
+	}
+	log.Tracef("HTTP purged mailbox for %q", name)
+
+	if ctx.IsJSON {
+		return httpd.RenderJSON(w, "OK")
+	}
+
+	w.Header().Set("Content-Type", "text/plain")
+	if _, err := io.WriteString(w, "OK"); err != nil {
+		return err
+	}
+	return nil
+}
+
+// MailboxHTML displays the HTML content of a message. Renders a partial
+func MailboxHTML(w http.ResponseWriter, req *http.Request, ctx *httpd.Context) (err error) {
+	// Don't have to validate these aren't empty, Gorilla returns 404
+	id := ctx.Vars["id"]
+	name, err := smtpd.ParseMailboxName(ctx.Vars["name"])
+	if err != nil {
+		return err
+	}
+	mb, err := ctx.DataStore.MailboxFor(name)
+	if err != nil {
+		// This doesn't indicate not found, likely an IO error
+		return fmt.Errorf("Failed to get mailbox for %q: %v", name, err)
+	}
+	message, err := mb.GetMessage(id)
+	if err == smtpd.ErrNotExist {
+		http.NotFound(w, req)
+		return nil
+	}
+	if err != nil {
+		// This doesn't indicate missing, likely an IO error
+		return fmt.Errorf("GetMessage(%q) failed: %v", id, err)
+	}
+	mime, err := message.ReadBody()
+	if err != nil {
+		return fmt.Errorf("ReadBody(%q) failed: %v", id, err)
+	}
+
+	w.Header().Set("Content-Type", "text/html; charset=UTF-8")
+	return httpd.RenderPartial("mailbox/_html.html", w, map[string]interface{}{
+		"ctx":     ctx,
+		"name":    name,
+		"message": message,
+		// TODO: It is not really safe to render, need to sanitize.
+		"body": template.HTML(mime.Html),
+	})
+}
+
+// MailboxSource displays the raw source of a message, including headers. Renders text/plain
+func MailboxSource(w http.ResponseWriter, req *http.Request, ctx *httpd.Context) (err error) {
+	// Don't have to validate these aren't empty, Gorilla returns 404
+	id := ctx.Vars["id"]
+	name, err := smtpd.ParseMailboxName(ctx.Vars["name"])
+	if err != nil {
+		return err
+	}
+	mb, err := ctx.DataStore.MailboxFor(name)
+	if err != nil {
+		// This doesn't indicate not found, likely an IO error
+		return fmt.Errorf("Failed to get mailbox for %q: %v", name, err)
+	}
+	message, err := mb.GetMessage(id)
+	if err == smtpd.ErrNotExist {
+		http.NotFound(w, req)
+		return nil
+	}
+	if err != nil {
+		// This doesn't indicate missing, likely an IO error
+		return fmt.Errorf("GetMessage(%q) failed: %v", id, err)
+	}
+	raw, err := message.ReadRaw()
+	if err != nil {
+		return fmt.Errorf("ReadRaw(%q) failed: %v", id, err)
+	}
+
+	w.Header().Set("Content-Type", "text/plain")
+	if _, err := io.WriteString(w, *raw); err != nil {
+		return err
+	}
+	return nil
+}
+
+// MailboxDownloadAttach sends the attachment to the client; disposition:
+// attachment, type: application/octet-stream
+func MailboxDownloadAttach(w http.ResponseWriter, req *http.Request, ctx *httpd.Context) (err error) {
+	// Don't have to validate these aren't empty, Gorilla returns 404
+	id := ctx.Vars["id"]
+	name, err := smtpd.ParseMailboxName(ctx.Vars["name"])
+	if err != nil {
+		ctx.Session.AddFlash(err.Error(), "errors")
+		http.Redirect(w, req, httpd.Reverse("RootIndex"), http.StatusSeeOther)
+		return nil
+	}
+	numStr := ctx.Vars["num"]
+	num, err := strconv.ParseUint(numStr, 10, 32)
+	if err != nil {
+		ctx.Session.AddFlash("Attachment number must be unsigned numeric", "errors")
+		http.Redirect(w, req, httpd.Reverse("RootIndex"), http.StatusSeeOther)
+		return nil
+	}
+
+	mb, err := ctx.DataStore.MailboxFor(name)
+	if err != nil {
+		// This doesn't indicate not found, likely an IO error
+		return fmt.Errorf("Failed to get mailbox for %q: %v", name, err)
+	}
+	message, err := mb.GetMessage(id)
+	if err == smtpd.ErrNotExist {
+		http.NotFound(w, req)
+		return nil
+	}
+	if err != nil {
+		// This doesn't indicate missing, likely an IO error
+		return fmt.Errorf("GetMessage(%q) failed: %v", id, err)
+	}
+	body, err := message.ReadBody()
+	if err != nil {
+		return err
+	}
+	if int(num) >= len(body.Attachments) {
+		ctx.Session.AddFlash("Attachment number too high", "errors")
+		http.Redirect(w, req, httpd.Reverse("RootIndex"), http.StatusSeeOther)
+		return nil
+	}
+	part := body.Attachments[num]
+
+	w.Header().Set("Content-Type", "application/octet-stream")
+	w.Header().Set("Content-Disposition", "attachment")
+	if _, err := w.Write(part.Content()); err != nil {
+		return err
+	}
+	return nil
+}
+
+// MailboxViewAttach sends the attachment to the client for online viewing
+func MailboxViewAttach(w http.ResponseWriter, req *http.Request, ctx *httpd.Context) (err error) {
+	// Don't have to validate these aren't empty, Gorilla returns 404
+	name, err := smtpd.ParseMailboxName(ctx.Vars["name"])
+	if err != nil {
+		ctx.Session.AddFlash(err.Error(), "errors")
+		http.Redirect(w, req, httpd.Reverse("RootIndex"), http.StatusSeeOther)
+		return nil
+	}
+	id := ctx.Vars["id"]
+	numStr := ctx.Vars["num"]
+	num, err := strconv.ParseUint(numStr, 10, 32)
+	if err != nil {
+		ctx.Session.AddFlash("Attachment number must be unsigned numeric", "errors")
+		http.Redirect(w, req, httpd.Reverse("RootIndex"), http.StatusSeeOther)
+		return nil
+	}
+
+	mb, err := ctx.DataStore.MailboxFor(name)
+	if err != nil {
+		// This doesn't indicate not found, likely an IO error
+		return fmt.Errorf("Failed to get mailbox for %q: %v", name, err)
+	}
+	message, err := mb.GetMessage(id)
+	if err == smtpd.ErrNotExist {
+		http.NotFound(w, req)
+		return nil
+	}
+	if err != nil {
+		// This doesn't indicate missing, likely an IO error
+		return fmt.Errorf("GetMessage(%q) failed: %v", id, err)
+	}
+	body, err := message.ReadBody()
+	if err != nil {
+		return err
+	}
+	if int(num) >= len(body.Attachments) {
+		ctx.Session.AddFlash("Attachment number too high", "errors")
+		http.Redirect(w, req, httpd.Reverse("RootIndex"), http.StatusSeeOther)
+		return nil
+	}
+	part := body.Attachments[num]
+
+	w.Header().Set("Content-Type", part.ContentType())
+	if _, err := w.Write(part.Content()); err != nil {
+		return err
+	}
+	return nil
+}
+
+// MailboxDelete removes a particular message from a mailbox.  Renders JSON or plain/text OK
+func MailboxDelete(w http.ResponseWriter, req *http.Request, ctx *httpd.Context) (err error) {
+	// Don't have to validate these aren't empty, Gorilla returns 404
+	id := ctx.Vars["id"]
+	name, err := smtpd.ParseMailboxName(ctx.Vars["name"])
+	if err != nil {
+		return err
+	}
+	mb, err := ctx.DataStore.MailboxFor(name)
+	if err != nil {
+		// This doesn't indicate not found, likely an IO error
+		return fmt.Errorf("Failed to get mailbox for %q: %v", name, err)
+	}
+	message, err := mb.GetMessage(id)
+	if err == smtpd.ErrNotExist {
+		http.NotFound(w, req)
+		return nil
+	}
+	if err != nil {
+		// This doesn't indicate missing, likely an IO error
+		return fmt.Errorf("GetMessage(%q) failed: %v", id, err)
+	}
+	err = message.Delete()
+	if err != nil {
+		return fmt.Errorf("Delete(%q) failed: %v", id, err)
+	}
+
+	if ctx.IsJSON {
+		return httpd.RenderJSON(w, "OK")
+	}
+
+	w.Header().Set("Content-Type", "text/plain")
+	if _, err := io.WriteString(w, "OK"); err != nil {
+		return err
+	}
+	return nil
+}

webui/recent.go

@@ -0,0 +1,35 @@
+package webui
+
+import (
+	"github.com/jhillyerd/inbucket/httpd"
+)
+
+const (
+	// maximum mailboxes to remember
+	maxRemembered = 8
+	// session value key; referenced in templates, do not change
+	mailboxKey = "recentMailboxes"
+)
+
+// RememberMailbox manages the list of recently accessed mailboxes stored in the session
+func RememberMailbox(ctx *httpd.Context, mailbox string) {
+	recent := RecentMailboxes(ctx)
+	newRecent := make([]string, 1, maxRemembered)
+	newRecent[0] = mailbox
+
+	for _, recBox := range recent {
+		// Insert until newRecent is full, but don't repeat the new mailbox
+		if len(newRecent) < maxRemembered && mailbox != recBox {
+			newRecent = append(newRecent, recBox)
+		}
+	}
+
+	ctx.Session.Values[mailboxKey] = newRecent
+}
+
+// RecentMailboxes returns a slice of the most recently accessed mailboxes
+func RecentMailboxes(ctx *httpd.Context) []string {
+	val := ctx.Session.Values[mailboxKey]
+	recent, _ := val.([]string)
+	return recent
+}

webui/rest_test.go

@@ -0,0 +1,533 @@
+package webui
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"net/http/httptest"
+	"net/mail"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/jhillyerd/go.enmime"
+	"github.com/jhillyerd/inbucket/config"
+	"github.com/jhillyerd/inbucket/httpd"
+	"github.com/jhillyerd/inbucket/smtpd"
+	"github.com/stretchr/testify/mock"
+)
+
+// OutputJSONHeader holds the received Header
+type OutputJSONHeader struct {
+	Mailbox             string
+	ID                  string `json:"Id"`
+	From, Subject, Date string
+	Size                int
+}
+
+// OutputJSONMessage holds the received Message
+type OutputJSONMessage struct {
+	Mailbox             string
+	ID                  string `json:"Id"`
+	From, Subject, Date string
+	Size                int
+	Header              map[string][]string
+	Body                struct {
+		Text string
+		HTML string `json:"Html"`
+	}
+}
+
+// InputMessageData holds the message we want to test
+type InputMessageData struct {
+	Mailbox       string
+	ID            string `json:"Id"`
+	From, Subject string
+	Date          time.Time
+	Size          int
+	Header        mail.Header
+	HTML          string `json:"Html"`
+	Text          string
+}
+
+func (d *InputMessageData) MockMessage() *MockMessage {
+	msg := &MockMessage{}
+	msg.On("ID").Return(d.ID)
+	msg.On("From").Return(d.From)
+	msg.On("Subject").Return(d.Subject)
+	msg.On("Date").Return(d.Date)
+	msg.On("Size").Return(d.Size)
+	gomsg := &mail.Message{
+		Header: d.Header,
+	}
+	msg.On("ReadHeader").Return(gomsg, nil)
+	body := &enmime.MIMEBody{
+		Text: d.Text,
+		Html: d.HTML,
+	}
+	msg.On("ReadBody").Return(body, nil)
+	return msg
+}
+
+func (d *InputMessageData) CompareToJSONHeader(j *OutputJSONHeader) (errors []string) {
+	if d.Mailbox != j.Mailbox {
+		errors = append(errors, fmt.Sprintf("Expected JSON.Mailbox=%q, got %q", d.Mailbox,
+			j.Mailbox))
+	}
+	if d.ID != j.ID {
+		errors = append(errors, fmt.Sprintf("Expected JSON.Id=%q, got %q", d.ID,
+			j.ID))
+	}
+	if d.From != j.From {
+		errors = append(errors, fmt.Sprintf("Expected JSON.From=%q, got %q", d.From,
+			j.From))
+	}
+	if d.Subject != j.Subject {
+		errors = append(errors, fmt.Sprintf("Expected JSON.Subject=%q, got %q", d.Subject,
+			j.Subject))
+	}
+	exDate := d.Date.Format("2006-01-02T15:04:05.999999999-07:00")
+	if exDate != j.Date {
+		errors = append(errors, fmt.Sprintf("Expected JSON.Date=%q, got %q", exDate,
+			j.Date))
+	}
+	if d.Size != j.Size {
+		errors = append(errors, fmt.Sprintf("Expected JSON.Size=%v, got %v", d.Size,
+			j.Size))
+	}
+
+	return errors
+}
+
+func (d *InputMessageData) CompareToJSONMessage(j *OutputJSONMessage) (errors []string) {
+	if d.Mailbox != j.Mailbox {
+		errors = append(errors, fmt.Sprintf("Expected JSON.Mailbox=%q, got %q", d.Mailbox,
+			j.Mailbox))
+	}
+	if d.ID != j.ID {
+		errors = append(errors, fmt.Sprintf("Expected JSON.Id=%q, got %q", d.ID,
+			j.ID))
+	}
+	if d.From != j.From {
+		errors = append(errors, fmt.Sprintf("Expected JSON.From=%q, got %q", d.From,
+			j.From))
+	}
+	if d.Subject != j.Subject {
+		errors = append(errors, fmt.Sprintf("Expected JSON.Subject=%q, got %q", d.Subject,
+			j.Subject))
+	}
+	exDate := d.Date.Format("2006-01-02T15:04:05.999999999-07:00")
+	if exDate != j.Date {
+		errors = append(errors, fmt.Sprintf("Expected JSON.Date=%q, got %q", exDate,
+			j.Date))
+	}
+	if d.Size != j.Size {
+		errors = append(errors, fmt.Sprintf("Expected JSON.Size=%v, got %v", d.Size,
+			j.Size))
+	}
+	if d.Text != j.Body.Text {
+		errors = append(errors, fmt.Sprintf("Expected JSON.Text=%q, got %q", d.Text,
+			j.Body.Text))
+	}
+	if d.HTML != j.Body.HTML {
+		errors = append(errors, fmt.Sprintf("Expected JSON.Html=%q, got %q", d.HTML,
+			j.Body.HTML))
+	}
+	for k, vals := range d.Header {
+		jvals, ok := j.Header[k]
+		if ok {
+			for _, v := range vals {
+				hasValue := false
+				for _, jv := range jvals {
+					if v == jv {
+						hasValue = true
+						break
+					}
+				}
+				if !hasValue {
+					errors = append(errors, fmt.Sprintf("JSON.Header[%q] missing value %q", k, v))
+				}
+			}
+		} else {
+			errors = append(errors, fmt.Sprintf("JSON.Header missing key %q", k))
+		}
+	}
+
+	return errors
+}
+
+func TestRestMailboxList(t *testing.T) {
+	// Setup
+	ds := &MockDataStore{}
+	logbuf := setupWebServer(ds)
+
+	// Test invalid mailbox name
+	w, err := testRestGet("http://localhost/mailbox/foo@bar")
+	expectCode := 500
+	if err != nil {
+		t.Fatal(err)
+	}
+	if w.Code != expectCode {
+		t.Errorf("Expected code %v, got %v", expectCode, w.Code)
+	}
+
+	// Test empty mailbox
+	emptybox := &MockMailbox{}
+	ds.On("MailboxFor", "empty").Return(emptybox, nil)
+	emptybox.On("GetMessages").Return([]smtpd.Message{}, nil)
+
+	w, err = testRestGet("http://localhost/mailbox/empty")
+	expectCode = 200
+	if err != nil {
+		t.Fatal(err)
+	}
+	if w.Code != expectCode {
+		t.Errorf("Expected code %v, got %v", expectCode, w.Code)
+	}
+
+	// Test MailboxFor error
+	ds.On("MailboxFor", "error").Return(&MockMailbox{}, fmt.Errorf("Internal error"))
+	w, err = testRestGet("http://localhost/mailbox/error")
+	expectCode = 500
+	if err != nil {
+		t.Fatal(err)
+	}
+	if w.Code != expectCode {
+		t.Errorf("Expected code %v, got %v", expectCode, w.Code)
+	}
+
+	if t.Failed() {
+		// Wait for handler to finish logging
+		time.Sleep(2 * time.Second)
+		// Dump buffered log data if there was a failure
+		_, _ = io.Copy(os.Stderr, logbuf)
+	}
+
+	// Test MailboxFor error
+	error2box := &MockMailbox{}
+	ds.On("MailboxFor", "error2").Return(error2box, nil)
+	error2box.On("GetMessages").Return([]smtpd.Message{}, fmt.Errorf("Internal error 2"))
+
+	w, err = testRestGet("http://localhost/mailbox/error2")
+	expectCode = 500
+	if err != nil {
+		t.Fatal(err)
+	}
+	if w.Code != expectCode {
+		t.Errorf("Expected code %v, got %v", expectCode, w.Code)
+	}
+
+	// Test JSON message headers
+	data1 := &InputMessageData{
+		Mailbox: "good",
+		ID:      "0001",
+		From:    "from1",
+		Subject: "subject 1",
+		Date:    time.Date(2012, 2, 1, 10, 11, 12, 253, time.FixedZone("PST", -800)),
+	}
+	data2 := &InputMessageData{
+		Mailbox: "good",
+		ID:      "0002",
+		From:    "from2",
+		Subject: "subject 2",
+		Date:    time.Date(2012, 7, 1, 10, 11, 12, 253, time.FixedZone("PDT", -700)),
+	}
+	goodbox := &MockMailbox{}
+	ds.On("MailboxFor", "good").Return(goodbox, nil)
+	msg1 := data1.MockMessage()
+	msg2 := data2.MockMessage()
+	goodbox.On("GetMessages").Return([]smtpd.Message{msg1, msg2}, nil)
+
+	// Check return code
+	w, err = testRestGet("http://localhost/mailbox/good")
+	expectCode = 200
+	if err != nil {
+		t.Fatal(err)
+	}
+	if w.Code != expectCode {
+		t.Fatalf("Expected code %v, got %v", expectCode, w.Code)
+	}
+
+	// Check JSON
+	dec := json.NewDecoder(w.Body)
+	var result []OutputJSONHeader
+	if err := dec.Decode(&result); err != nil {
+		t.Errorf("Failed to decode JSON: %v", err)
+	}
+	if len(result) != 2 {
+		t.Errorf("Expected 2 results, got %v", len(result))
+	}
+	if errors := data1.CompareToJSONHeader(&result[0]); len(errors) > 0 {
+		for _, e := range errors {
+			t.Error(e)
+		}
+	}
+	if errors := data2.CompareToJSONHeader(&result[1]); len(errors) > 0 {
+		for _, e := range errors {
+			t.Error(e)
+		}
+	}
+
+	if t.Failed() {
+		// Wait for handler to finish logging
+		time.Sleep(2 * time.Second)
+		// Dump buffered log data if there was a failure
+		_, _ = io.Copy(os.Stderr, logbuf)
+	}
+}
+
+func TestRestMessage(t *testing.T) {
+	// Setup
+	ds := &MockDataStore{}
+	logbuf := setupWebServer(ds)
+
+	// Test invalid mailbox name
+	w, err := testRestGet("http://localhost/mailbox/foo@bar/0001")
+	expectCode := 500
+	if err != nil {
+		t.Fatal(err)
+	}
+	if w.Code != expectCode {
+		t.Errorf("Expected code %v, got %v", expectCode, w.Code)
+	}
+
+	// Test requesting a message that does not exist
+	emptybox := &MockMailbox{}
+	ds.On("MailboxFor", "empty").Return(emptybox, nil)
+	emptybox.On("GetMessage", "0001").Return(&MockMessage{}, smtpd.ErrNotExist)
+
+	w, err = testRestGet("http://localhost/mailbox/empty/0001")
+	expectCode = 404
+	if err != nil {
+		t.Fatal(err)
+	}
+	if w.Code != expectCode {
+		t.Errorf("Expected code %v, got %v", expectCode, w.Code)
+	}
+
+	// Test MailboxFor error
+	ds.On("MailboxFor", "error").Return(&MockMailbox{}, fmt.Errorf("Internal error"))
+	w, err = testRestGet("http://localhost/mailbox/error/0001")
+	expectCode = 500
+	if err != nil {
+		t.Fatal(err)
+	}
+	if w.Code != expectCode {
+		t.Errorf("Expected code %v, got %v", expectCode, w.Code)
+	}
+
+	if t.Failed() {
+		// Wait for handler to finish logging
+		time.Sleep(2 * time.Second)
+		// Dump buffered log data if there was a failure
+		_, _ = io.Copy(os.Stderr, logbuf)
+	}
+
+	// Test GetMessage error
+	error2box := &MockMailbox{}
+	ds.On("MailboxFor", "error2").Return(error2box, nil)
+	error2box.On("GetMessage", "0001").Return(&MockMessage{}, fmt.Errorf("Internal error 2"))
+
+	w, err = testRestGet("http://localhost/mailbox/error2/0001")
+	expectCode = 500
+	if err != nil {
+		t.Fatal(err)
+	}
+	if w.Code != expectCode {
+		t.Errorf("Expected code %v, got %v", expectCode, w.Code)
+	}
+
+	// Test JSON message headers
+	data1 := &InputMessageData{
+		Mailbox: "good",
+		ID:      "0001",
+		From:    "from1",
+		Subject: "subject 1",
+		Date:    time.Date(2012, 2, 1, 10, 11, 12, 253, time.FixedZone("PST", -800)),
+		Header: mail.Header{
+			"To": []string{"fred@fish.com", "keyword@nsa.gov"},
+		},
+		Text: "This is some text",
+		HTML: "This is some HTML",
+	}
+	goodbox := &MockMailbox{}
+	ds.On("MailboxFor", "good").Return(goodbox, nil)
+	msg1 := data1.MockMessage()
+	goodbox.On("GetMessage", "0001").Return(msg1, nil)
+
+	// Check return code
+	w, err = testRestGet("http://localhost/mailbox/good/0001")
+	expectCode = 200
+	if err != nil {
+		t.Fatal(err)
+	}
+	if w.Code != expectCode {
+		t.Fatalf("Expected code %v, got %v", expectCode, w.Code)
+	}
+
+	// Check JSON
+	dec := json.NewDecoder(w.Body)
+	var result OutputJSONMessage
+	if err := dec.Decode(&result); err != nil {
+		t.Errorf("Failed to decode JSON: %v", err)
+	}
+	if errors := data1.CompareToJSONMessage(&result); len(errors) > 0 {
+		for _, e := range errors {
+			t.Error(e)
+		}
+	}
+
+	if t.Failed() {
+		// Wait for handler to finish logging
+		time.Sleep(2 * time.Second)
+		// Dump buffered log data if there was a failure
+		_, _ = io.Copy(os.Stderr, logbuf)
+	}
+}
+
+func testRestGet(url string) (*httptest.ResponseRecorder, error) {
+	req, err := http.NewRequest("GET", url, nil)
+	req.Header.Add("Accept", "application/json")
+	if err != nil {
+		return nil, err
+	}
+
+	w := httptest.NewRecorder()
+	httpd.Router.ServeHTTP(w, req)
+	return w, nil
+}
+
+func setupWebServer(ds smtpd.DataStore) *bytes.Buffer {
+	// Capture log output
+	buf := new(bytes.Buffer)
+	log.SetOutput(buf)
+
+	// Have to reset default mux to prevent duplicate routes
+	http.DefaultServeMux = http.NewServeMux()
+	cfg := config.WebConfig{
+		TemplateDir: "../themes/integral/templates",
+		PublicDir:   "../themes/integral/public",
+	}
+	httpd.Initialize(cfg, ds)
+	SetupRoutes(httpd.Router)
+
+	return buf
+}
+
+// MockDataStore used to mock DataStore interface
+type MockDataStore struct {
+	mock.Mock
+}
+
+func (m *MockDataStore) MailboxFor(name string) (smtpd.Mailbox, error) {
+	args := m.Called(name)
+	return args.Get(0).(smtpd.Mailbox), args.Error(1)
+}
+
+func (m *MockDataStore) AllMailboxes() ([]smtpd.Mailbox, error) {
+	args := m.Called()
+	return args.Get(0).([]smtpd.Mailbox), args.Error(1)
+}
+
+// MockMailbox used to mock Mailbox interface
+type MockMailbox struct {
+	mock.Mock
+}
+
+func (m *MockMailbox) GetMessages() ([]smtpd.Message, error) {
+	args := m.Called()
+	return args.Get(0).([]smtpd.Message), args.Error(1)
+}
+
+func (m *MockMailbox) GetMessage(id string) (smtpd.Message, error) {
+	args := m.Called(id)
+	return args.Get(0).(smtpd.Message), args.Error(1)
+}
+
+func (m *MockMailbox) Purge() error {
+	args := m.Called()
+	return args.Error(0)
+}
+
+func (m *MockMailbox) NewMessage() (smtpd.Message, error) {
+	args := m.Called()
+	return args.Get(0).(smtpd.Message), args.Error(1)
+}
+
+func (m *MockMailbox) String() string {
+	args := m.Called()
+	return args.String(0)
+}
+
+// Mock Message object
+type MockMessage struct {
+	mock.Mock
+}
+
+func (m *MockMessage) ID() string {
+	args := m.Called()
+	return args.String(0)
+}
+
+func (m *MockMessage) From() string {
+	args := m.Called()
+	return args.String(0)
+}
+
+func (m *MockMessage) Date() time.Time {
+	args := m.Called()
+	return args.Get(0).(time.Time)
+}
+
+func (m *MockMessage) Subject() string {
+	args := m.Called()
+	return args.String(0)
+}
+
+func (m *MockMessage) ReadHeader() (msg *mail.Message, err error) {
+	args := m.Called()
+	return args.Get(0).(*mail.Message), args.Error(1)
+}
+
+func (m *MockMessage) ReadBody() (body *enmime.MIMEBody, err error) {
+	args := m.Called()
+	return args.Get(0).(*enmime.MIMEBody), args.Error(1)
+}
+
+func (m *MockMessage) ReadRaw() (raw *string, err error) {
+	args := m.Called()
+	return args.Get(0).(*string), args.Error(1)
+}
+
+func (m *MockMessage) RawReader() (reader io.ReadCloser, err error) {
+	args := m.Called()
+	return args.Get(0).(io.ReadCloser), args.Error(1)
+}
+
+func (m *MockMessage) Size() int64 {
+	args := m.Called()
+	return int64(args.Int(0))
+}
+
+func (m *MockMessage) Append(data []byte) error {
+	// []byte arg seems to mess up testify/mock
+	return nil
+}
+
+func (m *MockMessage) Close() error {
+	args := m.Called()
+	return args.Error(0)
+}
+
+func (m *MockMessage) Delete() error {
+	args := m.Called()
+	return args.Error(0)
+}
+
+func (m *MockMessage) String() string {
+	args := m.Called()
+	return args.String(0)
+}

webui/root_controller.go

@@ -0,0 +1,44 @@
+package webui
+
+import (
+	"fmt"
+	"html/template"
+	"io/ioutil"
+	"net/http"
+
+	"github.com/jhillyerd/inbucket/config"
+	"github.com/jhillyerd/inbucket/httpd"
+)
+
+// RootIndex serves the Inbucket landing page
+func RootIndex(w http.ResponseWriter, req *http.Request, ctx *httpd.Context) (err error) {
+	greeting, err := ioutil.ReadFile(config.GetWebConfig().GreetingFile)
+	if err != nil {
+		return fmt.Errorf("Failed to load greeting: %v", err)
+	}
+
+	return httpd.RenderTemplate("root/index.html", w, map[string]interface{}{
+		"ctx":      ctx,
+		"greeting": template.HTML(string(greeting)),
+	})
+}
+
+// RootStatus serves the Inbucket status page
+func RootStatus(w http.ResponseWriter, req *http.Request, ctx *httpd.Context) (err error) {
+	retentionMinutes := config.GetDataStoreConfig().RetentionMinutes
+	smtpListener := fmt.Sprintf("%s:%d", config.GetSMTPConfig().IP4address.String(),
+		config.GetSMTPConfig().IP4port)
+	pop3Listener := fmt.Sprintf("%s:%d", config.GetPOP3Config().IP4address.String(),
+		config.GetPOP3Config().IP4port)
+	webListener := fmt.Sprintf("%s:%d", config.GetWebConfig().IP4address.String(),
+		config.GetWebConfig().IP4port)
+	return httpd.RenderTemplate("root/status.html", w, map[string]interface{}{
+		"ctx":              ctx,
+		"version":          config.Version,
+		"buildDate":        config.BuildDate,
+		"retentionMinutes": retentionMinutes,
+		"smtpListener":     smtpListener,
+		"pop3Listener":     pop3Listener,
+		"webListener":      webListener,
+	})
+}

webui/routes.go

@@ -0,0 +1,23 @@
+// Package webui powers Inbucket's web GUI
+package webui
+
+import (
+	"github.com/gorilla/mux"
+	"github.com/jhillyerd/inbucket/httpd"
+)
+
+// SetupRoutes populates routes for the webui into the provided Router
+func SetupRoutes(r *mux.Router) {
+	r.Path("/").Handler(httpd.Handler(RootIndex)).Name("RootIndex").Methods("GET")
+	r.Path("/status").Handler(httpd.Handler(RootStatus)).Name("RootStatus").Methods("GET")
+	r.Path("/link/{name}/{id}").Handler(httpd.Handler(MailboxLink)).Name("MailboxLink").Methods("GET")
+	r.Path("/mailbox").Handler(httpd.Handler(MailboxIndex)).Name("MailboxIndex").Methods("GET")
+	r.Path("/mailbox/{name}").Handler(httpd.Handler(MailboxList)).Name("MailboxList").Methods("GET")
+	r.Path("/mailbox/{name}").Handler(httpd.Handler(MailboxPurge)).Name("MailboxPurge").Methods("DELETE")
+	r.Path("/mailbox/{name}/{id}").Handler(httpd.Handler(MailboxShow)).Name("MailboxShow").Methods("GET")
+	r.Path("/mailbox/{name}/{id}/html").Handler(httpd.Handler(MailboxHTML)).Name("MailboxHtml").Methods("GET")
+	r.Path("/mailbox/{name}/{id}/source").Handler(httpd.Handler(MailboxSource)).Name("MailboxSource").Methods("GET")
+	r.Path("/mailbox/{name}/{id}").Handler(httpd.Handler(MailboxDelete)).Name("MailboxDelete").Methods("DELETE")
+	r.Path("/mailbox/dattach/{name}/{id}/{num}/{file}").Handler(httpd.Handler(MailboxDownloadAttach)).Name("MailboxDownloadAttach").Methods("GET")
+	r.Path("/mailbox/vattach/{name}/{id}/{num}/{file}").Handler(httpd.Handler(MailboxViewAttach)).Name("MailboxViewAttach").Methods("GET")
+}