|)$`)
for _, tag := range regexp.MustCompile(`<[^>]*>`).FindAllString(desc, -1) {
if !anchor.MatchString(tag) {
t.Errorf("unexpected markup %q in the rendered description: %s", tag, desc)
}
}
// Escaped, the description still says exactly what was stored.
if got := html.UnescapeString(regexp.MustCompile(`]*>`).ReplaceAllString(desc, "")); got !=
"blocked by beta-46c.2, and by alpha-2.\nnosuch-9z is nobody's.\n" {
t.Errorf("the rendered description does not decode to the stored text: %q", got)
}
}
// The ids in a comment body and in a history summary are linked too: they are
// where a hand-off between two trackers is usually written.
func TestBeadsDetailLinksCommentsAndHistory(t *testing.T) {
h, _, _ := linkHarness(t)
rec := h.do("GET", "/~alice/alpha/view/beads?issue=alpha-1", nil, nil)
if rec.Code != http.StatusOK {
t.Fatalf("detail: got %d, want 200; body=%s", rec.Code, rec.Body.String())
}
body := rec.Body.String()
comment := ``
if !strings.Contains(body, comment) {
t.Errorf("a comment body's id did not link; body=%s", body)
}
summary := `updated design to the shape is beta-nex's`
if !strings.Contains(body, summary) {
t.Errorf("a history summary's id did not link; body=%s", body)
}
}
// The index is bounded exactly as /ready is: a second render whose heads have
// not moved reads no rows again. Counted on the fake, never timed.
func TestBeadsDetailPrefixIndexIsBounded(t *testing.T) {
h, beta, _ := linkHarness(t)
first := h.do("GET", "/~alice/alpha/view/beads?issue=alpha-1", nil, nil)
if first.Code != http.StatusOK {
t.Fatalf("first detail: got %d", first.Code)
}
reads := beta.rowReads
if reads == 0 {
t.Fatalf("the first render must read the sibling's config")
}
second := h.do("GET", "/~alice/alpha/view/beads?issue=alpha-1", nil, nil)
if second.Code != http.StatusOK {
t.Fatalf("second detail: got %d", second.Code)
}
if beta.rowReads != reads {
t.Errorf("an unmoved head must cost no row reads: %d then %d", reads, beta.rowReads)
}
// The store is still opened and its branches listed — that is what the gate
// is gated on, and it is the cheap half.
if beta.opens != 2 {
t.Errorf("the sibling should be opened once per render, got %d", beta.opens)
}
// And the page is the same page, cache or not.
if first.Body.String() != second.Body.String() {
t.Errorf("the cached render differs from the first one")
}
}
// The board carries no stored prose, so it builds no index and opens no other
// database. The index is paid for by the one rendering that needs it.
func TestBeadsBoardBuildsNoLinkIndex(t *testing.T) {
h, beta, _ := linkHarness(t)
rec := h.do("GET", "/~alice/alpha/view/beads", nil, nil)
if rec.Code != http.StatusOK {
t.Fatalf("board: got %d; body=%s", rec.Code, rec.Body.String())
}
if beta.opens != 0 {
t.Errorf("the board opened another database %d times", beta.opens)
}
if strings.Contains(rec.Body.String(), "/~bob/beta/view/beads") {
t.Errorf("the board linked into another database; body=%s", rec.Body.String())
}
}
// An index that could not be built at all costs the page its links and not the
// page: the ids are text, exactly as they were before this existed.
func TestBeadsDetailSurvivesAnUnbuildableIndex(t *testing.T) {
h, _, _ := linkHarness(t)
h.store.listErr = errors.New("db: list repositories: connection refused")
rec := h.do("GET", "/~alice/alpha/view/beads?issue=alpha-1", nil, nil)
if rec.Code != http.StatusOK {
t.Fatalf("detail: got %d, want 200; body=%s", rec.Code, rec.Body.String())
}
body := rec.Body.String()
if !strings.Contains(body, "blocked by beta-46c.2, and by alpha-2.") {
t.Errorf("the description is missing; body=%s", body)
}
if strings.Contains(body, "issue=beta-46c.2") {
t.Errorf("an index that was never built linked something; body=%s", body)
}
if strings.Contains(body, "connection refused") {
t.Errorf("the listing error reached the reader; body=%s", body)
}
}
// fieldBody returns the contents of the that follows
// the named field label.
func fieldBody(t *testing.T, body, label string) string {
t.Helper()
head := `` + label + `
`
i := strings.Index(body, head)
if i < 0 {
t.Fatalf("no %s body in the page: %s", label, body)
}
rest := body[i+len(head):]
j := strings.Index(rest, "")
if j < 0 {
t.Fatalf("unterminated %s body", label)
}
return rest[:j]
}
// --- the stored rows section ---------------------------------------------------
// beadsNullFixture is one issue carrying, in one row, the three states a raw
// view may never conflate: a cell that holds no value (closed_at), a cell that
// stores the four characters "NULL" (assignee), and a cell that stores the empty
// string (notes). The mask is what tells the first two apart, so it is set here
// exactly as browse fills it for a real read.
func beadsNullFixture() *fakeSession {
issues := &browse.RowPage{
Columns: []string{"id", "title", "status", "assignee", "closed_at", "notes"},
Rows: [][]string{
{"i-null", "Three states", "open", "NULL", "NULL", ""},
},
Nulls: [][]bool{
{false, false, false, false, true, false},
},
Total: 1,
}
return &fakeSession{
branches: []browse.Branch{{Name: "main", Head: "abcdef1234567890"}},
tables: beadsTables(),
rowsByTable: map[string]*browse.RowPage{
"issues": issues,
"dependencies": {
Columns: []string{"id", "issue_id", "depends_on_issue_id", "type"},
Nulls: [][]bool{},
Total: 0,
},
},
}
}
// rawSection returns the markup of the collapsed stored-rows block.
func rawSection(t *testing.T, body string) string {
t.Helper()
i := strings.Index(body, ``)
if i < 0 {
t.Fatalf("no stored-rows section in the page: %s", body)
}
rest := body[i:]
j := strings.Index(rest, " ")
if j < 0 {
t.Fatalf("unterminated stored-rows section")
}
return rest[:j]
}
// rawTableBlock returns one table's markup inside the stored-rows section.
func rawTableBlock(t *testing.T, body, table string) string {
t.Helper()
sec := rawSection(t, body)
head := ``
i := strings.Index(sec, head)
if i < 0 {
t.Fatalf("no %s rows in the stored-rows section: %s", table, sec)
}
rest := sec[i+len(head):]
if j := strings.Index(rest, `
= 0 {
rest = rest[:j]
}
return rest
}
// rawCellValue returns the rendered value cell for one column of one table's
// first row in the stored-rows section.
func rawCellValue(t *testing.T, body, table, column string) string {
t.Helper()
block := rawTableBlock(t, body, table)
head := `
` + column + ` | `
i := strings.Index(block, head)
if i < 0 {
t.Fatalf("no %s.%s cell in the stored-rows section: %s", table, column, block)
}
rest := block[i+len(head):]
open := `
`
k := strings.Index(rest, open)
if k < 0 {
t.Fatalf("no value cell after %s.%s", table, column)
}
rest = rest[k+len(open):]
j := strings.Index(rest, " | ")
if j < 0 {
t.Fatalf("unterminated value cell for %s.%s", table, column)
}
return rest[:j]
}
// The detail pane carries the rows it was built from, and carries them closed:
// this is a tool for checking the rendering, not the reason a reader opened the
// page, so it is a
with no open attribute — the stream layout's Past
// Stand idiom.
func TestBeadsDetailShowsTheStoredRowsCollapsed(t *testing.T) {
h := newHarness(t)
h.store.add(&core.Repo{Name: "db", OwnerID: 1, OwnerName: "alice", Path: "/d", Visibility: core.VisibilityPublic})
h.browse.sess = beadsFixture()
setViews(t, h, &beadsView{})
rec := h.do("GET", "/~alice/db/view/beads?issue=i-open", nil, nil)
if rec.Code != http.StatusOK {
t.Fatalf("detail: got %d, want 200; body=%s", rec.Code, rec.Body.String())
}
body := rec.Body.String()
if !strings.Contains(body, ``) {
t.Fatalf("no stored-rows section on the detail pane; body=%s", body)
}
if strings.Contains(body, `Ready to roll` {
t.Errorf("issues.title rendered as %q", got)
}
if got := rawCellValue(t, body, "comments", "text"); got != `first!` {
t.Errorf("comments.text rendered as %q", got)
}
}
// The three states, on the page. A cell that holds no value renders as a NULL
// chip, a cell storing those four characters renders as the text it stores, and
// a cell storing the empty string says it is empty — the rendering used to make
// the first two identical and the last two indistinguishable.
func TestBeadsDetailStoredRowsSeparateNullFromEmpty(t *testing.T) {
h := newHarness(t)
h.store.add(&core.Repo{Name: "db", OwnerID: 1, OwnerName: "alice", Path: "/d", Visibility: core.VisibilityPublic})
h.browse.sess = beadsNullFixture()
setViews(t, h, &beadsView{})
rec := h.do("GET", "/~alice/db/view/beads?issue=i-null", nil, nil)
if rec.Code != http.StatusOK {
t.Fatalf("detail: got %d, want 200; body=%s", rec.Code, rec.Body.String())
}
body := rec.Body.String()
absent := rawCellValue(t, body, "issues", "closed_at")
stored := rawCellValue(t, body, "issues", "assignee")
empty := rawCellValue(t, body, "issues", "notes")
if absent != `NULL` {
t.Errorf("a cell holding no value rendered as %q", absent)
}
if stored != `NULL` {
t.Errorf("a cell storing the text \"NULL\" rendered as %q", stored)
}
if empty != `` {
t.Errorf("a cell storing the empty string rendered as %q", empty)
}
if absent == stored || absent == empty || stored == empty {
t.Errorf("the three states are not three renderings: %q / %q / %q", absent, stored, empty)
}
}
// Stored values are escaped, and they are not linkified. A script tag stored in
// a description reaches this section as text, and the ids in it stay the
// characters that are stored — the bodies above the section link them, but a raw
// view whose values have been rewritten is no longer showing what is stored.
func TestBeadsDetailStoredRowsEscapeAndDoNotLink(t *testing.T) {
h, _, _ := linkHarness(t)
rec := h.do("GET", "/~alice/alpha/view/beads?issue=alpha-1", nil, nil)
if rec.Code != http.StatusOK {
t.Fatalf("detail: got %d, want 200; body=%s", rec.Code, rec.Body.String())
}
body := rec.Body.String()
desc := rawCellValue(t, body, "issues", "description")
if strings.Contains(desc, "`) {
t.Errorf("the description above the section stopped linking; body=%s", body)
}
// Escaped and unlinked, the cell still decodes to exactly what is stored.
want := "blocked by beta-46c.2, and by alpha-2.\nnosuch-9z is nobody's.\n"
got := html.UnescapeString(strings.TrimSuffix(strings.TrimPrefix(desc, ``), ""))
if got != want {
t.Errorf("the stored description does not render as stored: %q", got)
}
}
// The board renders no stored rows: it is not a detail pane, and a board that
// carried every row behind every card would be the table browser with lanes
// drawn on it.
func TestBeadsBoardHasNoStoredRowsSection(t *testing.T) {
h := newHarness(t)
h.store.add(&core.Repo{Name: "db", OwnerID: 1, OwnerName: "alice", Path: "/d", Visibility: core.VisibilityPublic})
h.browse.sess = beadsFixture()
setViews(t, h, &beadsView{})
rec := h.do("GET", "/~alice/db/view/beads", nil, nil)
if rec.Code != http.StatusOK {
t.Fatalf("board: got %d, want 200; body=%s", rec.Code, rec.Body.String())
}
body := rec.Body.String()
for _, notWant := range []string{`class="bead-raw"`, "Stored rows", `| `} {
if strings.Contains(body, notWant) {
t.Errorf("the board rendered the stored-rows section (%q); body=%s", notWant, body)
}
}
}
func TestBeadsEpicViewRender(t *testing.T) {
h := newHarness(t)
h.store.add(&core.Repo{Name: "db", OwnerID: 1, OwnerName: "alice", Path: "/d", Visibility: core.VisibilityPublic})
h.browse.sess = beadsEpicFixture()
setViews(t, h, &beadsView{})
rec := h.do("GET", "/~alice/db/view/beads?issue=i-epic", nil, nil)
if rec.Code != http.StatusOK {
t.Fatalf("epic view: got %d, want 200; body=%s", rec.Code, rec.Body.String())
}
body := rec.Body.String()
for _, want := range []string{"Subtasks", "1 of 3 done", "epic-progress", "Child three", "History", "changed status to in_progress"} {
if !strings.Contains(body, want) {
t.Errorf("epic render missing %q", want)
}
}
}
|