Extract Grammaratur, Dregarnuhr, Geduldh, Mestionora, Ordoschnellic, Schutzaria, Kunstzeal and Seheweit behind compatible application contracts. Include accumulated editor resilience, navigation and theme UX, remote CLI, storage/schema and DR groundwork, tests and design/operations documentation. Verified: uncached full Go suite; go vet ./...; race tests for all eight components; 11 targeted Chromium tests; Node suites; 19 Python CLI tests; reproducible editor build. No push, release tag or deployment in this checkpoint.
168 lines
6.4 KiB
Go
168 lines
6.4 KiB
Go
package kunstzeal
|
|
|
|
import (
|
|
"context"
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"errors"
|
|
"io"
|
|
"net/http"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
var _ DiagramProvider = Kroki{}
|
|
|
|
type clientFixture func(*http.Request) (*http.Response, error)
|
|
|
|
func (f clientFixture) Do(r *http.Request) (*http.Response, error) { return f(r) }
|
|
|
|
type trackedReader struct {
|
|
io.Reader
|
|
closed bool
|
|
}
|
|
|
|
func (r *trackedReader) Close() error { r.closed = true; return nil }
|
|
|
|
func TestDiagramIdentityAndKinds(t *testing.T) {
|
|
for _, kind := range []string{"mermaid", "plantuml", "graphviz", "dot", "d2"} {
|
|
if !AllowedDiagramType(kind) {
|
|
t.Fatal(kind)
|
|
}
|
|
for _, source := range []string{"", "graph LR; A-->B;", "日本語\x00source"} {
|
|
sum := sha256.Sum256([]byte(kind + "\x00svg\x00" + source))
|
|
if DiagramHash(kind, source, "svg") != hex.EncodeToString(sum[:]) {
|
|
t.Fatal("cache identity changed")
|
|
}
|
|
}
|
|
}
|
|
for _, kind := range []string{"", "nwdiag", "../mermaid", "Mermaid", "svg", "graphviz/svg"} {
|
|
if AllowedDiagramType(kind) {
|
|
t.Fatal("unknown kind", kind)
|
|
}
|
|
}
|
|
if NormalizeDiagramType("dot") != "graphviz" || NormalizeDiagramType("mermaid") != "mermaid" {
|
|
t.Fatal("normalization changed")
|
|
}
|
|
}
|
|
|
|
func TestKrokiBoundedRequestAndOutput(t *testing.T) {
|
|
for _, kind := range []string{"mermaid", "dot", "d2"} {
|
|
body := &trackedReader{Reader: strings.NewReader("<svg>fixture</svg>")}
|
|
k := Kroki{Endpoint: "http://renderer.example/prefix/", Client: clientFixture(func(r *http.Request) (*http.Response, error) {
|
|
b, err := io.ReadAll(r.Body)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if r.Method != "POST" || r.URL.String() != "http://renderer.example/prefix/"+NormalizeDiagramType(kind)+"/svg" || string(b) != "source" || r.Header.Get("Content-Type") != "text/plain; charset=utf-8" {
|
|
t.Fatal("request contract changed")
|
|
}
|
|
if r.Header.Get("Authorization") != "" || r.Header.Get("Cookie") != "" {
|
|
t.Fatal("credentials forwarded")
|
|
}
|
|
deadline, ok := r.Context().Deadline()
|
|
if !ok || time.Until(deadline) > DiagramTimeout {
|
|
t.Fatal("unbounded provider")
|
|
}
|
|
return &http.Response{StatusCode: 200, Body: body}, nil
|
|
})}
|
|
b, err := k.Render(context.Background(), kind, "source")
|
|
if err != nil || string(b) != "<svg>fixture</svg>" || !body.closed {
|
|
t.Fatal(string(b), err, body.closed)
|
|
}
|
|
}
|
|
for _, size := range []int{DiagramOutputLimit, DiagramOutputLimit + 1} {
|
|
body := &trackedReader{Reader: strings.NewReader(strings.Repeat("x", size))}
|
|
k := Kroki{Endpoint: "https://renderer.example", Client: clientFixture(func(*http.Request) (*http.Response, error) { return &http.Response{StatusCode: 200, Body: body}, nil })}
|
|
b, err := k.Render(context.Background(), "mermaid", strings.Repeat("x", DiagramSourceLimit))
|
|
if size == DiagramOutputLimit {
|
|
if err != nil || len(b) != size {
|
|
t.Fatal(len(b), err)
|
|
}
|
|
} else if !errors.Is(err, ErrDiagramOutput) || b != nil {
|
|
t.Fatal("oversized output escaped", err)
|
|
}
|
|
if !body.closed {
|
|
t.Fatal("response leaked")
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestKrokiFailsClosedBeforeIO(t *testing.T) {
|
|
client := clientFixture(func(*http.Request) (*http.Response, error) { t.Fatal("invalid request performed I/O"); return nil, nil })
|
|
for _, endpoint := range []string{"", "file:///etc/passwd", "https://user:secret@renderer.example", "https://renderer.example?token=secret", "https://renderer.example#fragment", "https://renderer.example?", "https:///path", "http://%zz"} {
|
|
b, err := (Kroki{Endpoint: endpoint, Client: client}).Render(context.Background(), "mermaid", "source")
|
|
if !errors.Is(err, ErrProviderConfig) || b != nil {
|
|
t.Fatal("bad provider accepted", err)
|
|
}
|
|
}
|
|
k := Kroki{Endpoint: "http://renderer.example", Client: client}
|
|
if _, err := k.Render(context.Background(), "../../secret", "source"); !errors.Is(err, ErrDiagramKind) {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := k.Render(context.Background(), "mermaid", strings.Repeat("x", DiagramSourceLimit+1)); !errors.Is(err, ErrDiagramSource) {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := (Kroki{Endpoint: k.Endpoint}).Render(context.Background(), "mermaid", "source"); !errors.Is(err, ErrProviderConfig) {
|
|
t.Fatal("default HTTP client used", err)
|
|
}
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
cancel()
|
|
if _, err := k.Render(ctx, "mermaid", "source"); !errors.Is(err, context.Canceled) {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func TestKrokiFailuresAreOpaqueAndCloseBodies(t *testing.T) {
|
|
for _, code := range []int{301, 302, 307, 308, 400, 401, 403, 404, 429, 500} {
|
|
body := &trackedReader{Reader: strings.NewReader("PRIVATE SOURCE OR INTERNAL DIAGNOSTICS")}
|
|
k := Kroki{Endpoint: "https://private-renderer.example", Client: clientFixture(func(*http.Request) (*http.Response, error) { return &http.Response{StatusCode: code, Body: body}, nil })}
|
|
b, err := k.Render(context.Background(), "mermaid", "PRIVATE SOURCE")
|
|
if !errors.Is(err, ErrProviderFailed) || b != nil || !body.closed {
|
|
t.Fatal(code, err, body.closed)
|
|
}
|
|
}
|
|
for _, mode := range []string{"network", "nil-response", "nil-body", "read-error"} {
|
|
k := Kroki{Endpoint: "https://private-renderer.example", Client: clientFixture(func(*http.Request) (*http.Response, error) {
|
|
switch mode {
|
|
case "network":
|
|
return nil, errors.New("https://private-renderer.example: secret")
|
|
case "nil-response":
|
|
return nil, nil
|
|
case "nil-body":
|
|
return &http.Response{StatusCode: 200}, nil
|
|
default:
|
|
return &http.Response{StatusCode: 200, Body: io.NopCloser(errorReader{})}, nil
|
|
}
|
|
})}
|
|
b, err := k.Render(context.Background(), "mermaid", "PRIVATE SOURCE")
|
|
if b != nil || err == nil || strings.Contains(err.Error(), "secret") || strings.Contains(err.Error(), "private-renderer") {
|
|
t.Fatal(mode, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
type errorReader struct{}
|
|
|
|
func (errorReader) Read([]byte) (int, error) { return 0, errors.New("secret body read failure") }
|
|
|
|
func TestKrokiCancellationDuringSendAndRead(t *testing.T) {
|
|
for _, duringRead := range []bool{false, true} {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
body := &trackedReader{Reader: strings.NewReader("<svg/>")}
|
|
k := Kroki{Endpoint: "https://renderer.example", Client: clientFixture(func(*http.Request) (*http.Response, error) {
|
|
cancel()
|
|
if duringRead {
|
|
return &http.Response{StatusCode: 200, Body: body}, nil
|
|
}
|
|
return &http.Response{StatusCode: 200, Body: body}, errors.New("cancelled network")
|
|
})}
|
|
b, err := k.Render(ctx, "mermaid", "source")
|
|
cancel()
|
|
if !errors.Is(err, context.Canceled) || b != nil || !body.closed {
|
|
t.Fatal(duringRead, err, body.closed)
|
|
}
|
|
}
|
|
}
|