Reorganize packages, closes #79

- All packages go into either cmd or pkg directories - Most packages renamed - Server packages moved into pkg/server - sanitize moved into webui, as that's the only place it's used - filestore moved into pkg/storage/file - Makefile updated, and PKG variable use fixed
2025-12-17 17:47:03 +00:00 · 2018-03-09 19:32:45 -08:00
parent f00b9ddef0
commit f8c30a678a
55 changed files with 225 additions and 220 deletions
--- a/pkg/rest/apiv1_controller.go
+++ b/pkg/rest/apiv1_controller.go
@@ -0,0 +1,201 @@
+package rest
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+
+	"crypto/md5"
+	"encoding/hex"
+	"io/ioutil"
+	"strconv"
+
+	"github.com/jhillyerd/inbucket/pkg/log"
+	"github.com/jhillyerd/inbucket/pkg/rest/model"
+	"github.com/jhillyerd/inbucket/pkg/server/web"
+	"github.com/jhillyerd/inbucket/pkg/storage"
+	"github.com/jhillyerd/inbucket/pkg/stringutil"
+)
+
+// MailboxListV1 renders a list of messages in a mailbox
+func MailboxListV1(w http.ResponseWriter, req *http.Request, ctx *web.Context) (err error) {
+	// Don't have to validate these aren't empty, Gorilla returns 404
+	name, err := stringutil.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))
+
+	jmessages := make([]*model.JSONMessageHeaderV1, len(messages))
+	for i, msg := range messages {
+		jmessages[i] = &model.JSONMessageHeaderV1{
+			Mailbox: name,
+			ID:      msg.ID(),
+			From:    msg.From(),
+			To:      msg.To(),
+			Subject: msg.Subject(),
+			Date:    msg.Date(),
+			Size:    msg.Size(),
+		}
+	}
+	return web.RenderJSON(w, jmessages)
+}
+
+// MailboxShowV1 renders a particular message from a mailbox
+func MailboxShowV1(w http.ResponseWriter, req *http.Request, ctx *web.Context) (err error) {
+	// Don't have to validate these aren't empty, Gorilla returns 404
+	id := ctx.Vars["id"]
+	name, err := stringutil.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 == datastore.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)
+	}
+
+	attachments := make([]*model.JSONMessageAttachmentV1, len(mime.Attachments))
+	for i, att := range mime.Attachments {
+		var content []byte
+		content, err = ioutil.ReadAll(att)
+		var checksum = md5.Sum(content)
+		attachments[i] = &model.JSONMessageAttachmentV1{
+			ContentType:  att.ContentType,
+			FileName:     att.FileName,
+			DownloadLink: "http://" + req.Host + "/mailbox/dattach/" + name + "/" + id + "/" + strconv.Itoa(i) + "/" + att.FileName,
+			ViewLink:     "http://" + req.Host + "/mailbox/vattach/" + name + "/" + id + "/" + strconv.Itoa(i) + "/" + att.FileName,
+			MD5:          hex.EncodeToString(checksum[:]),
+		}
+	}
+
+	return web.RenderJSON(w,
+		&model.JSONMessageV1{
+			Mailbox: name,
+			ID:      msg.ID(),
+			From:    msg.From(),
+			To:      msg.To(),
+			Subject: msg.Subject(),
+			Date:    msg.Date(),
+			Size:    msg.Size(),
+			Header:  header.Header,
+			Body: &model.JSONMessageBodyV1{
+				Text: mime.Text,
+				HTML: mime.HTML,
+			},
+			Attachments: attachments,
+		})
+}
+
+// MailboxPurgeV1 deletes all messages from a mailbox
+func MailboxPurgeV1(w http.ResponseWriter, req *http.Request, ctx *web.Context) (err error) {
+	// Don't have to validate these aren't empty, Gorilla returns 404
+	name, err := stringutil.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)
+
+	return web.RenderJSON(w, "OK")
+}
+
+// MailboxSourceV1 displays the raw source of a message, including headers. Renders text/plain
+func MailboxSourceV1(w http.ResponseWriter, req *http.Request, ctx *web.Context) (err error) {
+	// Don't have to validate these aren't empty, Gorilla returns 404
+	id := ctx.Vars["id"]
+	name, err := stringutil.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 == datastore.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
+}
+
+// MailboxDeleteV1 removes a particular message from a mailbox
+func MailboxDeleteV1(w http.ResponseWriter, req *http.Request, ctx *web.Context) (err error) {
+	// Don't have to validate these aren't empty, Gorilla returns 404
+	id := ctx.Vars["id"]
+	name, err := stringutil.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 == datastore.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)
+	}
+
+	return web.RenderJSON(w, "OK")
+}
--- a/pkg/rest/apiv1_controller_test.go
+++ b/pkg/rest/apiv1_controller_test.go
@@ -0,0 +1,266 @@
+package rest
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/mail"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/jhillyerd/inbucket/pkg/storage"
+)
+
+const (
+	baseURL = "http://localhost/api/v1"
+
+	// JSON map keys
+	mailboxKey = "mailbox"
+	idKey      = "id"
+	fromKey    = "from"
+	toKey      = "to"
+	subjectKey = "subject"
+	dateKey    = "date"
+	sizeKey    = "size"
+	headerKey  = "header"
+	bodyKey    = "body"
+	textKey    = "text"
+	htmlKey    = "html"
+)
+
+func TestRestMailboxList(t *testing.T) {
+	// Setup
+	ds := &datastore.MockDataStore{}
+	logbuf := setupWebServer(ds)
+
+	// Test invalid mailbox name
+	w, err := testRestGet(baseURL + "/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 := &datastore.MockMailbox{}
+	ds.On("MailboxFor", "empty").Return(emptybox, nil)
+	emptybox.On("GetMessages").Return([]datastore.Message{}, nil)
+
+	w, err = testRestGet(baseURL + "/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(&datastore.MockMailbox{}, fmt.Errorf("Internal error"))
+	w, err = testRestGet(baseURL + "/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 := &datastore.MockMailbox{}
+	ds.On("MailboxFor", "error2").Return(error2box, nil)
+	error2box.On("GetMessages").Return([]datastore.Message{}, fmt.Errorf("Internal error 2"))
+
+	w, err = testRestGet(baseURL + "/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",
+		To:      []string{"to1"},
+		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",
+		To:      []string{"to1"},
+		Subject: "subject 2",
+		Date:    time.Date(2012, 7, 1, 10, 11, 12, 253, time.FixedZone("PDT", -700)),
+	}
+	goodbox := &datastore.MockMailbox{}
+	ds.On("MailboxFor", "good").Return(goodbox, nil)
+	msg1 := data1.MockMessage()
+	msg2 := data2.MockMessage()
+	goodbox.On("GetMessages").Return([]datastore.Message{msg1, msg2}, nil)
+
+	// Check return code
+	w, err = testRestGet(baseURL + "/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 []interface{}
+	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.CompareToJSONHeaderMap(result[0]); len(errors) > 0 {
+		t.Logf("%v", result[0])
+		for _, e := range errors {
+			t.Error(e)
+		}
+	}
+	if errors := data2.CompareToJSONHeaderMap(result[1]); len(errors) > 0 {
+		t.Logf("%v", result[1])
+		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 := &datastore.MockDataStore{}
+	logbuf := setupWebServer(ds)
+
+	// Test invalid mailbox name
+	w, err := testRestGet(baseURL + "/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 := &datastore.MockMailbox{}
+	ds.On("MailboxFor", "empty").Return(emptybox, nil)
+	emptybox.On("GetMessage", "0001").Return(&datastore.MockMessage{}, datastore.ErrNotExist)
+
+	w, err = testRestGet(baseURL + "/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(&datastore.MockMailbox{}, fmt.Errorf("Internal error"))
+	w, err = testRestGet(baseURL + "/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 := &datastore.MockMailbox{}
+	ds.On("MailboxFor", "error2").Return(error2box, nil)
+	error2box.On("GetMessage", "0001").Return(&datastore.MockMessage{}, fmt.Errorf("Internal error 2"))
+
+	w, err = testRestGet(baseURL + "/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"},
+			"From": []string{"noreply@inbucket.org"},
+		},
+		Text: "This is some text",
+		HTML: "This is some HTML",
+	}
+	goodbox := &datastore.MockMailbox{}
+	ds.On("MailboxFor", "good").Return(goodbox, nil)
+	msg1 := data1.MockMessage()
+	goodbox.On("GetMessage", "0001").Return(msg1, nil)
+
+	// Check return code
+	w, err = testRestGet(baseURL + "/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 map[string]interface{}
+	if err := dec.Decode(&result); err != nil {
+		t.Errorf("Failed to decode JSON: %v", err)
+	}
+
+	if errors := data1.CompareToJSONMessageMap(result); len(errors) > 0 {
+		t.Logf("%v", result)
+		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)
+	}
+}
--- a/pkg/rest/client/apiv1_client.go
+++ b/pkg/rest/client/apiv1_client.go
@@ -0,0 +1,144 @@
+// Package client provides a basic REST client for Inbucket
+package client
+
+import (
+	"bytes"
+	"fmt"
+	"net/http"
+	"net/url"
+	"time"
+
+	"github.com/jhillyerd/inbucket/pkg/rest/model"
+)
+
+// Client accesses the Inbucket REST API v1
+type Client struct {
+	restClient
+}
+
+// New creates a new v1 REST API client given the base URL of an Inbucket server, ex:
+// "http://localhost:9000"
+func New(baseURL string) (*Client, error) {
+	parsedURL, err := url.Parse(baseURL)
+	if err != nil {
+		return nil, err
+	}
+	c := &Client{
+		restClient{
+			client: &http.Client{
+				Timeout: 30 * time.Second,
+			},
+			baseURL: parsedURL,
+		},
+	}
+	return c, nil
+}
+
+// ListMailbox returns a list of messages for the requested mailbox
+func (c *Client) ListMailbox(name string) (headers []*MessageHeader, err error) {
+	uri := "/api/v1/mailbox/" + url.QueryEscape(name)
+	err = c.doJSON("GET", uri, &headers)
+	if err != nil {
+		return nil, err
+	}
+	for _, h := range headers {
+		h.client = c
+	}
+	return
+}
+
+// GetMessage returns the message details given a mailbox name and message ID.
+func (c *Client) GetMessage(name, id string) (message *Message, err error) {
+	uri := "/api/v1/mailbox/" + url.QueryEscape(name) + "/" + id
+	err = c.doJSON("GET", uri, &message)
+	if err != nil {
+		return nil, err
+	}
+	message.client = c
+	return
+}
+
+// GetMessageSource returns the message source given a mailbox name and message ID.
+func (c *Client) GetMessageSource(name, id string) (*bytes.Buffer, error) {
+	uri := "/api/v1/mailbox/" + url.QueryEscape(name) + "/" + id + "/source"
+	resp, err := c.do("GET", uri)
+	if err != nil {
+		return nil, err
+	}
+
+	defer func() {
+		_ = resp.Body.Close()
+	}()
+	if resp.StatusCode != http.StatusOK {
+		return nil,
+			fmt.Errorf("Unexpected HTTP response status %v: %s", resp.StatusCode, resp.Status)
+	}
+	buf := new(bytes.Buffer)
+	_, err = buf.ReadFrom(resp.Body)
+	return buf, err
+}
+
+// DeleteMessage deletes a single message given the mailbox name and message ID.
+func (c *Client) DeleteMessage(name, id string) error {
+	uri := "/api/v1/mailbox/" + url.QueryEscape(name) + "/" + id
+	resp, err := c.do("DELETE", uri)
+	if err != nil {
+		return err
+	}
+	_ = resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("Unexpected HTTP response status %v: %s", resp.StatusCode, resp.Status)
+	}
+	return nil
+}
+
+// PurgeMailbox deletes all messages in the given mailbox
+func (c *Client) PurgeMailbox(name string) error {
+	uri := "/api/v1/mailbox/" + url.QueryEscape(name)
+	resp, err := c.do("DELETE", uri)
+	if err != nil {
+		return err
+	}
+	_ = resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("Unexpected HTTP response status %v: %s", resp.StatusCode, resp.Status)
+	}
+	return nil
+}
+
+// MessageHeader represents an Inbucket message sans content
+type MessageHeader struct {
+	*model.JSONMessageHeaderV1
+	client *Client
+}
+
+// GetMessage returns this message with content
+func (h *MessageHeader) GetMessage() (message *Message, err error) {
+	return h.client.GetMessage(h.Mailbox, h.ID)
+}
+
+// GetSource returns the source for this message
+func (h *MessageHeader) GetSource() (*bytes.Buffer, error) {
+	return h.client.GetMessageSource(h.Mailbox, h.ID)
+}
+
+// Delete deletes this message from the mailbox
+func (h *MessageHeader) Delete() error {
+	return h.client.DeleteMessage(h.Mailbox, h.ID)
+}
+
+// Message represents an Inbucket message including content
+type Message struct {
+	*model.JSONMessageV1
+	client *Client
+}
+
+// GetSource returns the source for this message
+func (m *Message) GetSource() (*bytes.Buffer, error) {
+	return m.client.GetMessageSource(m.Mailbox, m.ID)
+}
+
+// Delete deletes this message from the mailbox
+func (m *Message) Delete() error {
+	return m.client.DeleteMessage(m.Mailbox, m.ID)
+}
--- a/pkg/rest/client/apiv1_client_test.go
+++ b/pkg/rest/client/apiv1_client_test.go
@@ -0,0 +1,323 @@
+package client
+
+import "testing"
+
+func TestClientV1ListMailbox(t *testing.T) {
+	var want, got string
+
+	c, err := New(baseURLStr)
+	if err != nil {
+		t.Fatal(err)
+	}
+	mth := &mockHTTPClient{}
+	c.client = mth
+
+	// Method under test
+	_, _ = c.ListMailbox("testbox")
+
+	want = "GET"
+	got = mth.req.Method
+	if got != want {
+		t.Errorf("req.Method == %q, want %q", got, want)
+	}
+
+	want = baseURLStr + "/api/v1/mailbox/testbox"
+	got = mth.req.URL.String()
+	if got != want {
+		t.Errorf("req.URL == %q, want %q", got, want)
+	}
+}
+
+func TestClientV1GetMessage(t *testing.T) {
+	var want, got string
+
+	c, err := New(baseURLStr)
+	if err != nil {
+		t.Fatal(err)
+	}
+	mth := &mockHTTPClient{}
+	c.client = mth
+
+	// Method under test
+	_, _ = c.GetMessage("testbox", "20170107T224128-0000")
+
+	want = "GET"
+	got = mth.req.Method
+	if got != want {
+		t.Errorf("req.Method == %q, want %q", got, want)
+	}
+
+	want = baseURLStr + "/api/v1/mailbox/testbox/20170107T224128-0000"
+	got = mth.req.URL.String()
+	if got != want {
+		t.Errorf("req.URL == %q, want %q", got, want)
+	}
+}
+
+func TestClientV1GetMessageSource(t *testing.T) {
+	var want, got string
+
+	c, err := New(baseURLStr)
+	if err != nil {
+		t.Fatal(err)
+	}
+	mth := &mockHTTPClient{
+		body: "message source",
+	}
+	c.client = mth
+
+	// Method under test
+	source, err := c.GetMessageSource("testbox", "20170107T224128-0000")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	want = "GET"
+	got = mth.req.Method
+	if got != want {
+		t.Errorf("req.Method == %q, want %q", got, want)
+	}
+
+	want = baseURLStr + "/api/v1/mailbox/testbox/20170107T224128-0000/source"
+	got = mth.req.URL.String()
+	if got != want {
+		t.Errorf("req.URL == %q, want %q", got, want)
+	}
+
+	want = "message source"
+	got = source.String()
+	if got != want {
+		t.Errorf("Source == %q, want: %q", got, want)
+	}
+}
+
+func TestClientV1DeleteMessage(t *testing.T) {
+	var want, got string
+
+	c, err := New(baseURLStr)
+	if err != nil {
+		t.Fatal(err)
+	}
+	mth := &mockHTTPClient{}
+	c.client = mth
+
+	// Method under test
+	err = c.DeleteMessage("testbox", "20170107T224128-0000")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	want = "DELETE"
+	got = mth.req.Method
+	if got != want {
+		t.Errorf("req.Method == %q, want %q", got, want)
+	}
+
+	want = baseURLStr + "/api/v1/mailbox/testbox/20170107T224128-0000"
+	got = mth.req.URL.String()
+	if got != want {
+		t.Errorf("req.URL == %q, want %q", got, want)
+	}
+}
+
+func TestClientV1PurgeMailbox(t *testing.T) {
+	var want, got string
+
+	c, err := New(baseURLStr)
+	if err != nil {
+		t.Fatal(err)
+	}
+	mth := &mockHTTPClient{}
+	c.client = mth
+
+	// Method under test
+	err = c.PurgeMailbox("testbox")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	want = "DELETE"
+	got = mth.req.Method
+	if got != want {
+		t.Errorf("req.Method == %q, want %q", got, want)
+	}
+
+	want = baseURLStr + "/api/v1/mailbox/testbox"
+	got = mth.req.URL.String()
+	if got != want {
+		t.Errorf("req.URL == %q, want %q", got, want)
+	}
+}
+
+func TestClientV1MessageHeader(t *testing.T) {
+	var want, got string
+	response := `[
+		{
+			"mailbox":"mailbox1",
+			"id":"id1",
+			"from":"from1",
+			"subject":"subject1",
+			"date":"2017-01-01T00:00:00.000-07:00",
+			"size":100
+		}
+	]`
+
+	c, err := New(baseURLStr)
+	if err != nil {
+		t.Fatal(err)
+	}
+	mth := &mockHTTPClient{body: response}
+	c.client = mth
+
+	// Method under test
+	headers, err := c.ListMailbox("testbox")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	want = "GET"
+	got = mth.req.Method
+	if got != want {
+		t.Errorf("req.Method == %q, want %q", got, want)
+	}
+
+	want = baseURLStr + "/api/v1/mailbox/testbox"
+	got = mth.req.URL.String()
+	if got != want {
+		t.Errorf("req.URL == %q, want %q", got, want)
+	}
+
+	if len(headers) != 1 {
+		t.Fatalf("len(headers) == %v, want 1", len(headers))
+	}
+	header := headers[0]
+
+	want = "mailbox1"
+	got = header.Mailbox
+	if got != want {
+		t.Errorf("Mailbox == %q, want %q", got, want)
+	}
+
+	want = "id1"
+	got = header.ID
+	if got != want {
+		t.Errorf("ID == %q, want %q", got, want)
+	}
+
+	want = "from1"
+	got = header.From
+	if got != want {
+		t.Errorf("From == %q, want %q", got, want)
+	}
+
+	want = "subject1"
+	got = header.Subject
+	if got != want {
+		t.Errorf("Subject == %q, want %q", got, want)
+	}
+
+	// Test MessageHeader.Delete()
+	mth.body = ""
+	err = header.Delete()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	want = "DELETE"
+	got = mth.req.Method
+	if got != want {
+		t.Errorf("req.Method == %q, want %q", got, want)
+	}
+
+	want = baseURLStr + "/api/v1/mailbox/mailbox1/id1"
+	got = mth.req.URL.String()
+	if got != want {
+		t.Errorf("req.URL == %q, want %q", got, want)
+	}
+
+	// Test MessageHeader.GetSource()
+	mth.body = "source1"
+	_, err = header.GetSource()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	want = "GET"
+	got = mth.req.Method
+	if got != want {
+		t.Errorf("req.Method == %q, want %q", got, want)
+	}
+
+	want = baseURLStr + "/api/v1/mailbox/mailbox1/id1/source"
+	got = mth.req.URL.String()
+	if got != want {
+		t.Errorf("req.URL == %q, want %q", got, want)
+	}
+
+	// Test MessageHeader.GetMessage()
+	mth.body = `{
+		"mailbox":"mailbox1",
+		"id":"id1",
+		"from":"from1",
+		"subject":"subject1",
+		"date":"2017-01-01T00:00:00.000-07:00",
+		"size":100
+	}`
+	message, err := header.GetMessage()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if message == nil {
+		t.Fatalf("message was nil, wanted a value")
+	}
+
+	want = "GET"
+	got = mth.req.Method
+	if got != want {
+		t.Errorf("req.Method == %q, want %q", got, want)
+	}
+
+	want = baseURLStr + "/api/v1/mailbox/mailbox1/id1"
+	got = mth.req.URL.String()
+	if got != want {
+		t.Errorf("req.URL == %q, want %q", got, want)
+	}
+
+	// Test Message.Delete()
+	mth.body = ""
+	err = message.Delete()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	want = "DELETE"
+	got = mth.req.Method
+	if got != want {
+		t.Errorf("req.Method == %q, want %q", got, want)
+	}
+
+	want = baseURLStr + "/api/v1/mailbox/mailbox1/id1"
+	got = mth.req.URL.String()
+	if got != want {
+		t.Errorf("req.URL == %q, want %q", got, want)
+	}
+
+	// Test MessageHeader.GetSource()
+	mth.body = "source1"
+	_, err = message.GetSource()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	want = "GET"
+	got = mth.req.Method
+	if got != want {
+		t.Errorf("req.Method == %q, want %q", got, want)
+	}
+
+	want = baseURLStr + "/api/v1/mailbox/mailbox1/id1/source"
+	got = mth.req.URL.String()
+	if got != want {
+		t.Errorf("req.URL == %q, want %q", got, want)
+	}
+}
--- a/pkg/rest/client/rest.go
+++ b/pkg/rest/client/rest.go
@@ -0,0 +1,59 @@
+package client
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+)
+
+// httpClient allows http.Client to be mocked for tests
+type httpClient interface {
+	Do(*http.Request) (*http.Response, error)
+}
+
+// Generic REST restClient
+type restClient struct {
+	client  httpClient
+	baseURL *url.URL
+}
+
+// do performs an HTTP request with this client and returns the response
+func (c *restClient) do(method, uri string) (*http.Response, error) {
+	rel, err := url.Parse(uri)
+	if err != nil {
+		return nil, err
+	}
+
+	url := c.baseURL.ResolveReference(rel)
+
+	// Build the request
+	req, err := http.NewRequest(method, url.String(), nil)
+	if err != nil {
+		return nil, err
+	}
+
+	// Send the request
+	return c.client.Do(req)
+}
+
+// doGet performs an HTTP request with this client and marshalls the JSON response into v
+func (c *restClient) doJSON(method string, uri string, v interface{}) error {
+	resp, err := c.do(method, uri)
+	if err != nil {
+		return err
+	}
+
+	defer func() {
+		_ = resp.Body.Close()
+	}()
+	if resp.StatusCode == http.StatusOK {
+		if v == nil {
+			return nil
+		}
+		// Decode response body
+		return json.NewDecoder(resp.Body).Decode(v)
+	}
+
+	return fmt.Errorf("Unexpected HTTP response status %v: %s", resp.StatusCode, resp.Status)
+}
--- a/pkg/rest/client/rest_test.go
+++ b/pkg/rest/client/rest_test.go
@@ -0,0 +1,125 @@
+package client
+
+import (
+	"bytes"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"testing"
+)
+
+const baseURLStr = "http://test.local:8080"
+
+var baseURL *url.URL
+
+func init() {
+	var err error
+	baseURL, err = url.Parse(baseURLStr)
+	if err != nil {
+		panic(err)
+	}
+}
+
+type mockHTTPClient struct {
+	req        *http.Request
+	statusCode int
+	body       string
+}
+
+func (m *mockHTTPClient) Do(req *http.Request) (resp *http.Response, err error) {
+	m.req = req
+	if m.statusCode == 0 {
+		m.statusCode = 200
+	}
+	resp = &http.Response{
+		StatusCode: m.statusCode,
+		Body:       ioutil.NopCloser(bytes.NewBufferString(m.body)),
+	}
+
+	return
+}
+
+func TestDo(t *testing.T) {
+	var want, got string
+
+	mth := &mockHTTPClient{}
+	c := &restClient{mth, baseURL}
+
+	_, err := c.do("POST", "/dopost")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	want = "POST"
+	got = mth.req.Method
+	if got != want {
+		t.Errorf("req.Method == %q, want %q", got, want)
+	}
+
+	want = baseURLStr + "/dopost"
+	got = mth.req.URL.String()
+	if got != want {
+		t.Errorf("req.URL == %q, want %q", got, want)
+	}
+}
+
+func TestDoJSON(t *testing.T) {
+	var want, got string
+
+	mth := &mockHTTPClient{
+		body: `{"foo": "bar"}`,
+	}
+	c := &restClient{mth, baseURL}
+
+	var v map[string]interface{}
+	err := c.doJSON("GET", "/doget", &v)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	want = "GET"
+	got = mth.req.Method
+	if got != want {
+		t.Errorf("req.Method == %q, want %q", got, want)
+	}
+
+	want = baseURLStr + "/doget"
+	got = mth.req.URL.String()
+	if got != want {
+		t.Errorf("req.URL == %q, want %q", got, want)
+	}
+
+	want = "bar"
+	if val, ok := v["foo"]; ok {
+		got = val.(string)
+		if got != want {
+			t.Errorf("map[foo] == %q, want: %q", got, want)
+		}
+	} else {
+		t.Errorf("Map did not contain key foo, want: %q", want)
+	}
+}
+
+func TestDoJSONNilV(t *testing.T) {
+	var want, got string
+
+	mth := &mockHTTPClient{}
+	c := &restClient{mth, baseURL}
+
+	err := c.doJSON("GET", "/doget", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	want = "GET"
+	got = mth.req.Method
+	if got != want {
+		t.Errorf("req.Method == %q, want %q", got, want)
+	}
+
+	want = baseURLStr + "/doget"
+	got = mth.req.URL.String()
+	if got != want {
+		t.Errorf("req.URL == %q, want %q", got, want)
+	}
+}
--- a/pkg/rest/model/apiv1_model.go
+++ b/pkg/rest/model/apiv1_model.go
@@ -0,0 +1,45 @@
+package model
+
+import (
+	"net/mail"
+	"time"
+)
+
+// JSONMessageHeaderV1 contains the basic header data for a message
+type JSONMessageHeaderV1 struct {
+	Mailbox string    `json:"mailbox"`
+	ID      string    `json:"id"`
+	From    string    `json:"from"`
+	To      []string  `json:"to"`
+	Subject string    `json:"subject"`
+	Date    time.Time `json:"date"`
+	Size    int64     `json:"size"`
+}
+
+// JSONMessageV1 contains the same data as the header plus a JSONMessageBody
+type JSONMessageV1 struct {
+	Mailbox     string                     `json:"mailbox"`
+	ID          string                     `json:"id"`
+	From        string                     `json:"from"`
+	To          []string                   `json:"to"`
+	Subject     string                     `json:"subject"`
+	Date        time.Time                  `json:"date"`
+	Size        int64                      `json:"size"`
+	Body        *JSONMessageBodyV1         `json:"body"`
+	Header      mail.Header                `json:"header"`
+	Attachments []*JSONMessageAttachmentV1 `json:"attachments"`
+}
+
+type JSONMessageAttachmentV1 struct {
+	FileName     string `json:"filename"`
+	ContentType  string `json:"content-type"`
+	DownloadLink string `json:"download-link"`
+	ViewLink     string `json:"view-link"`
+	MD5          string `json:"md5"`
+}
+
+// JSONMessageBodyV1 contains the Text and HTML versions of the message body
+type JSONMessageBodyV1 struct {
+	Text string `json:"text"`
+	HTML string `json:"html"`
+}
--- a/pkg/rest/routes.go
+++ b/pkg/rest/routes.go
@@ -0,0 +1,23 @@
+package rest
+
+import "github.com/gorilla/mux"
+import "github.com/jhillyerd/inbucket/pkg/server/web"
+
+// SetupRoutes populates the routes for the REST interface
+func SetupRoutes(r *mux.Router) {
+	// API v1
+	r.Path("/api/v1/mailbox/{name}").Handler(
+		web.Handler(MailboxListV1)).Name("MailboxListV1").Methods("GET")
+	r.Path("/api/v1/mailbox/{name}").Handler(
+		web.Handler(MailboxPurgeV1)).Name("MailboxPurgeV1").Methods("DELETE")
+	r.Path("/api/v1/mailbox/{name}/{id}").Handler(
+		web.Handler(MailboxShowV1)).Name("MailboxShowV1").Methods("GET")
+	r.Path("/api/v1/mailbox/{name}/{id}").Handler(
+		web.Handler(MailboxDeleteV1)).Name("MailboxDeleteV1").Methods("DELETE")
+	r.Path("/api/v1/mailbox/{name}/{id}/source").Handler(
+		web.Handler(MailboxSourceV1)).Name("MailboxSourceV1").Methods("GET")
+	r.Path("/api/v1/monitor/messages").Handler(
+		web.Handler(MonitorAllMessagesV1)).Name("MonitorAllMessagesV1").Methods("GET")
+	r.Path("/api/v1/monitor/messages/{name}").Handler(
+		web.Handler(MonitorMailboxMessagesV1)).Name("MonitorMailboxMessagesV1").Methods("GET")
+}
--- a/pkg/rest/socketv1_controller.go
+++ b/pkg/rest/socketv1_controller.go
@@ -0,0 +1,195 @@
+package rest
+
+import (
+	"net/http"
+	"time"
+
+	"github.com/gorilla/websocket"
+	"github.com/jhillyerd/inbucket/pkg/log"
+	"github.com/jhillyerd/inbucket/pkg/msghub"
+	"github.com/jhillyerd/inbucket/pkg/rest/model"
+	"github.com/jhillyerd/inbucket/pkg/server/web"
+	"github.com/jhillyerd/inbucket/pkg/stringutil"
+)
+
+const (
+	// Time allowed to write a message to the peer.
+	writeWait = 10 * time.Second
+
+	// Send pings to peer with this period. Must be less than pongWait.
+	pingPeriod = (pongWait * 9) / 10
+
+	// Time allowed to read the next pong message from the peer.
+	pongWait = 60 * time.Second
+
+	// Maximum message size allowed from peer.
+	maxMessageSize = 512
+)
+
+// options for gorilla connection upgrader
+var upgrader = websocket.Upgrader{
+	ReadBufferSize:  1024,
+	WriteBufferSize: 1024,
+}
+
+// msgListener handles messages from the msghub
+type msgListener struct {
+	hub     *msghub.Hub         // Global message hub
+	c       chan msghub.Message // Queue of messages from Receive()
+	mailbox string              // Name of mailbox to monitor, "" == all mailboxes
+}
+
+// newMsgListener creates a listener and registers it.  Optional mailbox parameter will restrict
+// messages sent to WebSocket to that mailbox only.
+func newMsgListener(hub *msghub.Hub, mailbox string) *msgListener {
+	ml := &msgListener{
+		hub:     hub,
+		c:       make(chan msghub.Message, 100),
+		mailbox: mailbox,
+	}
+	hub.AddListener(ml)
+	return ml
+}
+
+// Receive handles an incoming message
+func (ml *msgListener) Receive(msg msghub.Message) error {
+	if ml.mailbox != "" && ml.mailbox != msg.Mailbox {
+		// Did not match mailbox name
+		return nil
+	}
+	ml.c <- msg
+	return nil
+}
+
+// WSReader makes sure the websocket client is still connected, discards any messages from client
+func (ml *msgListener) WSReader(conn *websocket.Conn) {
+	defer ml.Close()
+	conn.SetReadLimit(maxMessageSize)
+	conn.SetReadDeadline(time.Now().Add(pongWait))
+	conn.SetPongHandler(func(string) error {
+		log.Tracef("HTTP[%v] Got WebSocket pong", conn.RemoteAddr())
+		conn.SetReadDeadline(time.Now().Add(pongWait))
+		return nil
+	})
+
+	for {
+		if _, _, err := conn.ReadMessage(); err != nil {
+			if websocket.IsUnexpectedCloseError(
+				err,
+				websocket.CloseNormalClosure,
+				websocket.CloseGoingAway,
+				websocket.CloseNoStatusReceived,
+			) {
+				// Unexpected close code
+				log.Warnf("HTTP[%v] WebSocket error: %v", conn.RemoteAddr(), err)
+			} else {
+				log.Tracef("HTTP[%v] Closing WebSocket", conn.RemoteAddr())
+			}
+			break
+		}
+	}
+}
+
+// WSWriter makes sure the websocket client is still connected
+func (ml *msgListener) WSWriter(conn *websocket.Conn) {
+	ticker := time.NewTicker(pingPeriod)
+	defer func() {
+		ticker.Stop()
+		ml.Close()
+	}()
+
+	// Handle messages from hub until msgListener is closed
+	for {
+		select {
+		case msg, ok := <-ml.c:
+			conn.SetWriteDeadline(time.Now().Add(writeWait))
+			if !ok {
+				// msgListener closed, exit
+				conn.WriteMessage(websocket.CloseMessage, []byte{})
+				return
+			}
+			header := &model.JSONMessageHeaderV1{
+				Mailbox: msg.Mailbox,
+				ID:      msg.ID,
+				From:    msg.From,
+				To:      msg.To,
+				Subject: msg.Subject,
+				Date:    msg.Date,
+				Size:    msg.Size,
+			}
+			if conn.WriteJSON(header) != nil {
+				// Write failed
+				return
+			}
+		case <-ticker.C:
+			// Send ping
+			conn.SetWriteDeadline(time.Now().Add(writeWait))
+			if conn.WriteMessage(websocket.PingMessage, []byte{}) != nil {
+				// Write error
+				return
+			}
+			log.Tracef("HTTP[%v] Sent WebSocket ping", conn.RemoteAddr())
+		}
+	}
+}
+
+// Close removes the listener registration
+func (ml *msgListener) Close() {
+	select {
+	case <-ml.c:
+		// Already closed
+	default:
+		ml.hub.RemoveListener(ml)
+		close(ml.c)
+	}
+}
+
+func MonitorAllMessagesV1(
+	w http.ResponseWriter, req *http.Request, ctx *web.Context) (err error) {
+	// Upgrade to Websocket
+	conn, err := upgrader.Upgrade(w, req, nil)
+	if err != nil {
+		return err
+	}
+	web.ExpWebSocketConnectsCurrent.Add(1)
+	defer func() {
+		_ = conn.Close()
+		web.ExpWebSocketConnectsCurrent.Add(-1)
+	}()
+
+	log.Tracef("HTTP[%v] Upgraded to websocket", req.RemoteAddr)
+
+	// Create, register listener; then interact with conn
+	ml := newMsgListener(ctx.MsgHub, "")
+	go ml.WSWriter(conn)
+	ml.WSReader(conn)
+
+	return nil
+}
+
+func MonitorMailboxMessagesV1(
+	w http.ResponseWriter, req *http.Request, ctx *web.Context) (err error) {
+	name, err := stringutil.ParseMailboxName(ctx.Vars["name"])
+	if err != nil {
+		return err
+	}
+	// Upgrade to Websocket
+	conn, err := upgrader.Upgrade(w, req, nil)
+	if err != nil {
+		return err
+	}
+	web.ExpWebSocketConnectsCurrent.Add(1)
+	defer func() {
+		_ = conn.Close()
+		web.ExpWebSocketConnectsCurrent.Add(-1)
+	}()
+
+	log.Tracef("HTTP[%v] Upgraded to websocket", req.RemoteAddr)
+
+	// Create, register listener; then interact with conn
+	ml := newMsgListener(ctx.MsgHub, name)
+	go ml.WSWriter(conn)
+	ml.WSReader(conn)
+
+	return nil
+}
--- a/pkg/rest/testutils_test.go
+++ b/pkg/rest/testutils_test.go
@@ -0,0 +1,207 @@
+package rest
+
+import (
+	"bytes"
+	"fmt"
+	"log"
+	"net/http"
+	"net/http/httptest"
+	"net/mail"
+	"time"
+
+	"github.com/jhillyerd/enmime"
+	"github.com/jhillyerd/inbucket/pkg/config"
+	"github.com/jhillyerd/inbucket/pkg/msghub"
+	"github.com/jhillyerd/inbucket/pkg/server/web"
+	"github.com/jhillyerd/inbucket/pkg/storage"
+)
+
+type InputMessageData struct {
+	Mailbox, ID, From, Subject string
+	To                         []string
+	Date                       time.Time
+	Size                       int
+	Header                     mail.Header
+	HTML, Text                 string
+}
+
+func (d *InputMessageData) MockMessage() *datastore.MockMessage {
+	msg := &datastore.MockMessage{}
+	msg.On("ID").Return(d.ID)
+	msg.On("From").Return(d.From)
+	msg.On("To").Return(d.To)
+	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.Envelope{
+		Text: d.Text,
+		HTML: d.HTML,
+	}
+	msg.On("ReadBody").Return(body, nil)
+	return msg
+}
+
+// isJSONStringEqual is a utility function to return a nicely formatted message when
+// comparing a string to a value received from a JSON map.
+func isJSONStringEqual(key, expected string, received interface{}) (message string, ok bool) {
+	if value, ok := received.(string); ok {
+		if expected == value {
+			return "", true
+		}
+		return fmt.Sprintf("Expected value of key %v to be %q, got %q", key, expected, value), false
+	}
+	return fmt.Sprintf("Expected value of key %v to be a string, got %T", key, received), false
+}
+
+// isJSONNumberEqual is a utility function to return a nicely formatted message when
+// comparing an float64 to a value received from a JSON map.
+func isJSONNumberEqual(key string, expected float64, received interface{}) (message string, ok bool) {
+	if value, ok := received.(float64); ok {
+		if expected == value {
+			return "", true
+		}
+		return fmt.Sprintf("Expected %v to be %v, got %v", key, expected, value), false
+	}
+	return fmt.Sprintf("Expected %v to be a string, got %T", key, received), false
+}
+
+// CompareToJSONHeaderMap compares InputMessageData to a header map decoded from JSON,
+// returning a list of things that did not match.
+func (d *InputMessageData) CompareToJSONHeaderMap(json interface{}) (errors []string) {
+	if m, ok := json.(map[string]interface{}); ok {
+		if msg, ok := isJSONStringEqual(mailboxKey, d.Mailbox, m[mailboxKey]); !ok {
+			errors = append(errors, msg)
+		}
+		if msg, ok := isJSONStringEqual(idKey, d.ID, m[idKey]); !ok {
+			errors = append(errors, msg)
+		}
+		if msg, ok := isJSONStringEqual(fromKey, d.From, m[fromKey]); !ok {
+			errors = append(errors, msg)
+		}
+		for i, inputTo := range d.To {
+			if msg, ok := isJSONStringEqual(toKey, inputTo, m[toKey].([]interface{})[i]); !ok {
+				errors = append(errors, msg)
+			}
+		}
+		if msg, ok := isJSONStringEqual(subjectKey, d.Subject, m[subjectKey]); !ok {
+			errors = append(errors, msg)
+		}
+		exDate := d.Date.Format("2006-01-02T15:04:05.999999999-07:00")
+		if msg, ok := isJSONStringEqual(dateKey, exDate, m[dateKey]); !ok {
+			errors = append(errors, msg)
+		}
+		if msg, ok := isJSONNumberEqual(sizeKey, float64(d.Size), m[sizeKey]); !ok {
+			errors = append(errors, msg)
+		}
+		return errors
+	}
+	panic(fmt.Sprintf("Expected map[string]interface{} in json, got %T", json))
+}
+
+// CompareToJSONMessageMap compares InputMessageData to a message map decoded from JSON,
+// returning a list of things that did not match.
+func (d *InputMessageData) CompareToJSONMessageMap(json interface{}) (errors []string) {
+	// We need to check the same values as header first
+	errors = d.CompareToJSONHeaderMap(json)
+
+	if m, ok := json.(map[string]interface{}); ok {
+		// Get nested body map
+		if m[bodyKey] != nil {
+			if body, ok := m[bodyKey].(map[string]interface{}); ok {
+				if msg, ok := isJSONStringEqual(textKey, d.Text, body[textKey]); !ok {
+					errors = append(errors, msg)
+				}
+				if msg, ok := isJSONStringEqual(htmlKey, d.HTML, body[htmlKey]); !ok {
+					errors = append(errors, msg)
+				}
+			} else {
+				panic(fmt.Sprintf("Expected map[string]interface{} in json key %q, got %T",
+					bodyKey, m[bodyKey]))
+			}
+		} else {
+			errors = append(errors, fmt.Sprintf("Expected body in JSON %q but it was nil", bodyKey))
+		}
+		exDate := d.Date.Format("2006-01-02T15:04:05.999999999-07:00")
+		if msg, ok := isJSONStringEqual(dateKey, exDate, m[dateKey]); !ok {
+			errors = append(errors, msg)
+		}
+		if msg, ok := isJSONNumberEqual(sizeKey, float64(d.Size), m[sizeKey]); !ok {
+			errors = append(errors, msg)
+		}
+
+		// Get nested header map
+		if m[headerKey] != nil {
+			if header, ok := m[headerKey].(map[string]interface{}); ok {
+				// Loop over input (expected) header names
+				for name, keyInputHeaders := range d.Header {
+					// Make sure expected header name exists in received JSON
+					if keyOutputVals, ok := header[name]; ok {
+						if keyOutputHeaders, ok := keyOutputVals.([]interface{}); ok {
+							// Loop over input (expected) header values
+							for _, inputHeader := range keyInputHeaders {
+								hasValue := false
+								// Look for expected value in received headers
+								for _, outputHeader := range keyOutputHeaders {
+									if inputHeader == outputHeader {
+										hasValue = true
+										break
+									}
+								}
+								if !hasValue {
+									errors = append(errors, fmt.Sprintf(
+										"JSON %v[%q] missing value %q", headerKey, name, inputHeader))
+								}
+							}
+						} else {
+							// keyOutputValues was not a slice of interface{}
+							panic(fmt.Sprintf("Expected []interface{} in %v[%q], got %T", headerKey,
+								name, keyOutputVals))
+						}
+					} else {
+						errors = append(errors, fmt.Sprintf("JSON %v missing key %q", headerKey, name))
+					}
+				}
+			}
+		} else {
+			errors = append(errors, fmt.Sprintf("Expected header in JSON %q but it was nil", headerKey))
+		}
+	} else {
+		panic(fmt.Sprintf("Expected map[string]interface{} in json, got %T", json))
+	}
+
+	return errors
+}
+
+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()
+	web.Router.ServeHTTP(w, req)
+	return w, nil
+}
+
+func setupWebServer(ds datastore.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/bootstrap/templates",
+		PublicDir:   "../themes/bootstrap/public",
+	}
+	shutdownChan := make(chan bool)
+	web.Initialize(cfg, shutdownChan, ds, &msghub.Hub{})
+	SetupRoutes(web.Router)
+
+	return buf
+}