Skip to content

armgit / memos

Public Imported from GitHub
0

Memos is an open-source, self-hosted note-taking app that brings your everyday thoughts together in a personal timeline. Your data stays yours, and you choose what to keep private or share.

14.4 KB
Raw Blame
package memoexport

import (
	"archive/zip"
	"bytes"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"flag"
	"io"
	"os"
	"path/filepath"
	"testing"
	"time"

	"github.com/stretchr/testify/require"
)

var updateGolden = flag.Bool("update", false, "rewrite the golden archives under testdata")

// goldenFixture is the content of every golden archive. Changing it changes
// the golden file, so bump it deliberately.
type goldenFixture struct {
	manifest    Manifest
	memos       []*Memo
	contents    map[string][]byte
	attachments map[string][]byte
}

// fixtureExportTime keeps golden archives byte-stable across runs.
var fixtureExportTime = time.Date(2026, 9, 16, 8, 30, 0, 0, time.UTC)

func newGoldenFixture() goldenFixture {
	photo := []byte("not really a jpeg")
	photoDigest := sha256.Sum256(photo)
	return goldenFixture{
		manifest: Manifest{
			Format:     Format,
			Generator:  Generator{Name: "memos", Version: "0.31.0"},
			ExportTime: "2026-09-16T08:30:00Z",
			Scope:      Scope{Kind: ScopeKindUser, User: &ScopeUser{Username: "steven", DisplayName: "Steven"}},
			Counts:     &Counts{Memos: 3, Attachments: 1},
		},
		memos: []*Memo{
			{
				UID:        "Xy7LmN01",
				Creator:    "steven",
				CreateTime: "2026-03-01T09:00:00Z",
				UpdateTime: "2026-03-01T09:00:00Z",
				State:      "NORMAL",
				Visibility: "PUBLIC",
				Pinned:     false,
				Tags:       []string{"work"},
			},
			{
				UID:        "Ab3kZ9q2",
				Creator:    "steven",
				CreateTime: "2026-03-02T14:05:11Z",
				UpdateTime: "2026-03-02T14:20:47Z",
				State:      "NORMAL",
				Visibility: "SPACE",
				Pinned:     true,
				Tags:       []string{"work", "work/q3"},
				Location:   &Location{Placeholder: "Office", Latitude: 52.52, Longitude: 13.405},
				Space:      &Space{UID: "team-notes", Title: "Team Notes"},
				Relations:  []Relation{{Type: RelationReference, Memo: "Xy7LmN01"}},
				Attachments: []Attachment{{
					UID:           "att1c9d",
					Filename:      "whiteboard photo.jpg",
					Type:          "image/jpeg",
					Size:          int64(len(photo)),
					SHA256:        hex.EncodeToString(photoDigest[:]),
					Path:          AttachmentPath("att1c9d", "whiteboard photo.jpg"),
					CreateTime:    "2026-03-02T14:05:30Z",
					MediaMetadata: json.RawMessage(`{"width":4032,"height":3024}`),
				}, {
					UID:          "att77e0",
					Filename:     "spec.pdf",
					Type:         "application/pdf",
					Size:         120400,
					ExternalLink: "https://files.example.com/spec.pdf",
					CreateTime:   "2026-03-02T14:06:02Z",
				}},
				Reactions: []Reaction{{ReactionType: "👍", Creator: "alice", CreateTime: "2026-03-03T09:00:00Z"}},
			},
			{
				UID:        "Cm9Rt4v7",
				Creator:    "steven",
				CreateTime: "2026-02-28T08:00:00Z", // older than its parent on purpose
				UpdateTime: "2026-02-28T08:00:00Z",
				State:      "ARCHIVED",
				Visibility: "PRIVATE",
				Parent:     "Xy7LmN01",
			},
		},
		contents: map[string][]byte{
			"Xy7LmN01": []byte("Top-level memo #work"),
			"Ab3kZ9q2": []byte("# Whiteboard\n\nSee the photo. No trailing newline"),
			"Cm9Rt4v7": []byte("A comment"),
		},
		attachments: map[string][]byte{"att1c9d": photo},
	}
}

func writeFixture(t *testing.T, fixture goldenFixture) []byte {
	t.Helper()
	var buffer bytes.Buffer
	writer := NewWriter(&buffer, fixtureExportTime)
	require.NoError(t, writer.WriteManifest(&fixture.manifest))
	for _, memo := range fixture.memos {
		for _, attachment := range memo.Attachments {
			if attachment.Path == "" {
				continue
			}
			digest, size, err := writer.WriteAttachment(attachment.Path, bytes.NewReader(fixture.attachments[attachment.UID]))
			require.NoError(t, err)
			require.Equal(t, attachment.SHA256, digest)
			require.Equal(t, attachment.Size, size)
		}
		require.NoError(t, writer.WriteMemo(memo, fixture.contents[memo.UID]))
	}
	require.NoError(t, writer.Close())
	return buffer.Bytes()
}

func readArchive(t *testing.T, data []byte) *File {
	t.Helper()
	archive, err := Read(bytes.NewReader(data), int64(len(data)))
	require.NoError(t, err)
	return archive
}

func requireFixtureRoundTrip(t *testing.T, fixture goldenFixture, archive *File) {
	t.Helper()
	require.Equal(t, fixture.manifest.Format, archive.Manifest.Format)
	require.Equal(t, FormatVersion, archive.Manifest.FormatVersion)
	require.Equal(t, fixture.manifest.Scope, archive.Manifest.Scope)
	require.Empty(t, archive.Warnings)

	uids := make([]string, 0, len(archive.Memos))
	for _, memo := range archive.Memos {
		uids = append(uids, memo.UID)
	}
	// Cm9Rt4v7 is older than its parent Xy7LmN01 but must follow it.
	require.Equal(t, []string{"Xy7LmN01", "Cm9Rt4v7", "Ab3kZ9q2"}, uids)

	byUID := make(map[string]*Memo, len(archive.Memos))
	for _, memo := range archive.Memos {
		byUID[memo.UID] = memo
	}
	for _, want := range fixture.memos {
		got := byUID[want.UID]
		require.NotNil(t, got, want.UID)
		expected := *want
		expected.ContentPath = ContentPath(want.UID)
		require.Equal(t, &expected, got)
		content, err := archive.Content(got)
		require.NoError(t, err)
		require.Equal(t, fixture.contents[want.UID], content)
		for i := range got.Attachments {
			attachment := &got.Attachments[i]
			if attachment.Path == "" {
				continue
			}
			bytesRead, err := archive.ReadAttachment(attachment)
			require.NoError(t, err)
			require.Equal(t, fixture.attachments[attachment.UID], bytesRead)
		}
	}
}

func TestRoundTrip(t *testing.T) {
	fixture := newGoldenFixture()
	data := writeFixture(t, fixture)

	reader, err := zip.NewReader(bytes.NewReader(data), int64(len(data)))
	require.NoError(t, err)
	require.Equal(t, ManifestEntry, reader.File[0].Name)
	for _, file := range reader.File {
		// macOS Archive Utility refuses an all-zero DOS date, and treats a
		// leading "mimetype" entry as an unknown document package.
		require.NotEqual(t, "mimetype", file.Name)
		require.NotZero(t, file.ModifiedDate, file.Name)
		require.Equal(t, fixtureExportTime, file.Modified.UTC(), file.Name)
	}

	requireFixtureRoundTrip(t, fixture, readArchive(t, data))
}

// TestGoldenArchives reads every golden archive ever published. A reader
// change that breaks an older archive fails here.
func TestGoldenArchives(t *testing.T) {
	fixture := newGoldenFixture()
	goldenPath := filepath.Join("testdata", "1.0", "golden.zip")
	if *updateGolden {
		require.NoError(t, os.MkdirAll(filepath.Dir(goldenPath), 0o755))
		require.NoError(t, os.WriteFile(goldenPath, writeFixture(t, fixture), 0o644))
	}
	versions, err := filepath.Glob(filepath.Join("testdata", "*", "*.zip"))
	require.NoError(t, err)
	require.NotEmpty(t, versions, "no golden archives found; run with -update")
	for _, path := range versions {
		t.Run(filepath.Join(filepath.Base(filepath.Dir(path)), filepath.Base(path)), func(t *testing.T) {
			data, err := os.ReadFile(path)
			require.NoError(t, err)
			archive := readArchive(t, data)
			if filepath.Base(filepath.Dir(path)) == FormatVersion {
				fixture := newGoldenFixture()
				if filepath.Base(path) == "legacy.zip" {
					fixture.manifest.Format = legacyFormat
				}
				requireFixtureRoundTrip(t, fixture, archive)
			}
		})
	}
}

func TestReaderAppliesFallbacksAndIgnoresUnknowns(t *testing.T) {
	fixture := newGoldenFixture()
	memo := fixture.memos[0]
	memo.State = "DELETED"
	memo.Visibility = "SECRET"
	memo.Relations = []Relation{{Type: "FOLLOWS", Memo: "Ab3kZ9q2"}}

	memo.ContentPath = ContentPath(memo.UID)
	var buffer bytes.Buffer
	writer := NewWriter(&buffer, fixtureExportTime)
	require.NoError(t, writer.WriteManifest(&fixture.manifest))
	// Bypass the writer's validation so the record carries the unknown values.
	raw, err := json.Marshal(struct {
		*Memo
		Future string `json:"future"`
	}{Memo: memo, Future: "from a later minor"})
	require.NoError(t, err)
	entry, err := writer.zip.Create(RecordPath(memo.UID))
	require.NoError(t, err)
	_, err = entry.Write(raw)
	require.NoError(t, err)
	entry, err = writer.zip.Create(ContentPath(memo.UID))
	require.NoError(t, err)
	_, err = entry.Write([]byte("x"))
	require.NoError(t, err)
	entry, err = writer.zip.Create("extra/ignored.txt")
	require.NoError(t, err)
	_, err = entry.Write([]byte("ignored"))
	require.NoError(t, err)
	require.NoError(t, writer.Close())

	archive := readArchive(t, buffer.Bytes())
	require.Len(t, archive.Memos, 1)
	got := archive.Memos[0]
	require.Equal(t, "NORMAL", got.State)
	require.Equal(t, "PRIVATE", got.Visibility)
	require.Empty(t, got.Relations)
	messages := make([]string, 0, len(archive.Warnings))
	for _, warning := range archive.Warnings {
		messages = append(messages, warning.Message)
	}
	require.Len(t, messages, 4) // state, visibility, relation, manifest count
	require.Contains(t, messages[0], "unknown state")
	require.Contains(t, messages[1], "unknown visibility")
	require.Contains(t, messages[2], "unknown relation type")
	require.Contains(t, messages[3], "manifest counts")
}

func TestReaderRejectsUnsafeArchives(t *testing.T) {
	fixture := newGoldenFixture()
	base := writeFixture(t, fixture)

	rewrite := func(t *testing.T, mutate func(*zip.Writer, *zip.File, []byte) bool) []byte {
		t.Helper()
		reader, err := zip.NewReader(bytes.NewReader(base), int64(len(base)))
		require.NoError(t, err)
		var buffer bytes.Buffer
		writer := zip.NewWriter(&buffer)
		for _, file := range reader.File {
			rc, err := file.Open()
			require.NoError(t, err)
			content, err := io.ReadAll(rc)
			require.NoError(t, err)
			require.NoError(t, rc.Close())
			if mutate(writer, file, content) {
				continue
			}
			entry, err := writer.CreateHeader(&zip.FileHeader{Name: file.Name, Method: file.Method})
			require.NoError(t, err)
			_, err = entry.Write(content)
			require.NoError(t, err)
		}
		require.NoError(t, writer.Close())
		return buffer.Bytes()
	}

	cases := map[string]struct {
		mutate func(*zip.Writer, *zip.File, []byte) bool
		want   string
	}{
		"dot-dot entry": {
			mutate: func(w *zip.Writer, f *zip.File, _ []byte) bool {
				if f.Name == ManifestEntry {
					entry, _ := w.Create("../escape.txt")
					_, _ = entry.Write([]byte("x"))
				}
				return false
			},
			want: "dot segment",
		},
		"absolute entry": {
			mutate: func(w *zip.Writer, f *zip.File, _ []byte) bool {
				if f.Name == ManifestEntry {
					entry, _ := w.Create("/etc/passwd")
					_, _ = entry.Write([]byte("x"))
				}
				return false
			},
			want: "is absolute",
		},
		"backslash entry": {
			mutate: func(w *zip.Writer, f *zip.File, _ []byte) bool {
				if f.Name == ManifestEntry {
					entry, _ := w.Create(`memos\x.md`)
					_, _ = entry.Write([]byte("x"))
				}
				return false
			},
			want: "forbidden character",
		},
		"missing manifest": {
			mutate: func(_ *zip.Writer, f *zip.File, _ []byte) bool { return f.Name == ManifestEntry },
			want:   "manifest.json is missing",
		},
		"unknown format": {
			mutate: func(w *zip.Writer, f *zip.File, content []byte) bool {
				if f.Name != ManifestEntry {
					return false
				}
				entry, _ := w.Create(ManifestEntry)
				_, _ = entry.Write(bytes.ReplaceAll(content, []byte(`"format":"memos-export"`), []byte(`"format":"other-export"`)))
				return true
			},
			want: `format "other-export" is not "memos-export"`,
		},
		"unsupported major": {
			mutate: func(w *zip.Writer, f *zip.File, content []byte) bool {
				if f.Name != ManifestEntry {
					return false
				}
				entry, _ := w.Create(ManifestEntry)
				_, _ = entry.Write(bytes.ReplaceAll(content, []byte(`"formatVersion":"1.0"`), []byte(`"formatVersion":"2.0"`)))
				return true
			},
			want: "format version 2.0 is not supported",
		},
		"uid mismatch": {
			mutate: func(w *zip.Writer, f *zip.File, content []byte) bool {
				if f.Name != RecordPath("Cm9Rt4v7") {
					return false
				}
				entry, _ := w.Create(RecordPath("Cm9Rt4v7"))
				_, _ = entry.Write(bytes.ReplaceAll(content, []byte(`"uid":"Cm9Rt4v7"`), []byte(`"uid":"Other001"`)))
				return true
			},
			want: "does not match the file name",
		},
		"content without record": {
			mutate: func(w *zip.Writer, f *zip.File, _ []byte) bool {
				if f.Name == ManifestEntry {
					entry, _ := w.Create(ContentPath("orphan01"))
					_, _ = entry.Write([]byte("x"))
				}
				return false
			},
			want: "has no memo record",
		},
		"missing attachment entry": {
			mutate: func(_ *zip.Writer, f *zip.File, _ []byte) bool {
				return f.Name == AttachmentPath("att1c9d", "whiteboard photo.jpg")
			},
			want: "attachment entry",
		},
	}
	for name, tc := range cases {
		t.Run(name, func(t *testing.T) {
			data := rewrite(t, tc.mutate)
			_, err := Read(bytes.NewReader(data), int64(len(data)))
			require.Error(t, err)
			require.Contains(t, err.Error(), tc.want)
		})
	}
}

func TestReadAttachmentVerifiesDigest(t *testing.T) {
	fixture := newGoldenFixture()
	fixture.memos[1].Attachments[0].SHA256 = hex.EncodeToString(bytes.Repeat([]byte{0xab}, 32))
	var buffer bytes.Buffer
	writer := NewWriter(&buffer, fixtureExportTime)
	require.NoError(t, writer.WriteManifest(&fixture.manifest))
	attachment := fixture.memos[1].Attachments[0]
	_, _, err := writer.WriteAttachment(attachment.Path, bytes.NewReader(fixture.attachments[attachment.UID]))
	require.NoError(t, err)
	require.NoError(t, writer.WriteMemo(fixture.memos[1], fixture.contents["Ab3kZ9q2"]))
	require.NoError(t, writer.Close())

	archive := readArchive(t, buffer.Bytes())
	_, err = archive.ReadAttachment(&archive.Memos[0].Attachments[0])
	require.ErrorContains(t, err, "digest does not match")
}

func TestSafeFilename(t *testing.T) {
	cases := map[string]string{
		"whiteboard photo.jpg": "whiteboard photo.jpg",
		"../../etc/passwd":     "_.._etc_passwd",
		"a:b\\c/d.txt":         "a_b_c_d.txt",
		"CON.txt":              "_CON.txt",
		"lpt9":                 "_lpt9",
		" .hidden. ":           "hidden",
		"":                     "file",
		"...":                  "file",
		"résumé.pdf":           "résumé.pdf",
		"tab\there":            "tab_here",
	}
	for input, want := range cases {
		require.Equal(t, want, SafeFilename(input), input)
	}
}

func TestValidateEntryName(t *testing.T) {
	require.NoError(t, ValidateEntryName("memos/a.md"))
	require.NoError(t, ValidateEntryName("attachments/x/a..b.jpg"))
	require.NoError(t, ValidateEntryName("attachments/x/résumé.pdf"))
	for _, bad := range []string{"", "/a", "a/", "a//b", "./a", "a/./b", "../a", "a/..", `a\b`, "a:b", "a\x00b", "a\x1fb", "\xff"} {
		require.Error(t, ValidateEntryName(bad), bad)
	}
}

func TestWriterRefusesRecordBeforeAttachment(t *testing.T) {
	fixture := newGoldenFixture()
	var buffer bytes.Buffer
	writer := NewWriter(&buffer, fixtureExportTime)
	require.NoError(t, writer.WriteManifest(&fixture.manifest))
	err := writer.WriteMemo(fixture.memos[1], nil)
	require.ErrorContains(t, err, "must be written before memo")
}