package share import ( "context" "encoding/json" "errors" "net/http" "net/http/httptest" "strings" "testing" "github.com/gin-gonic/gin" "github.com/kandev/kandev/internal/i18n" "github.com/kandev/kandev/internal/task/models" ) func init() { gin.SetMode(gin.TestMode) } func newHandlersForTest(t *testing.T, reader TaskReader, backend Backend, authed bool) (*HTTPHandlers, *Service) { t.Helper() repo := newTestRepo(t) svc := New(repo, reader, pairShareAccess{}, backend, nil, "v-test") if mock, ok := backend.(*mockBackend); ok && !authed { mock.accessErr = errors.New("connect a GitHub account to share tasks publicly") } return NewHTTPHandlers(svc, nil), svc } func newGinRouter(h *HTTPHandlers) *gin.Engine { r := gin.New() h.RegisterRoutes(r) return r } func TestHTTP_Create_HappyPath(t *testing.T) { t.Parallel() reader := completedSession() // Real GistBackend returns the gist.githack.com rendered URL — match // that shape so the test mirrors production. backend := &mockBackend{nextID: "gist-x", nextURL: "https://gist.githack.com/jane/gist-x/raw/share.html"} handlers, _ := newHandlersForTest(t, reader, backend, true) router := newGinRouter(handlers) req := httptest.NewRequest(http.MethodPost, "/api/v1/tasks/t-1/sessions/s-1/shares", nil) rec := httptest.NewRecorder() router.ServeHTTP(rec, req) if rec.Code != http.StatusCreated { t.Fatalf("want 201, got %d: %s", rec.Code, rec.Body.String()) } var body shareResponse if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil { t.Fatalf("decode: %v", err) } if body.URL != "https://gist.githack.com/jane/gist-x/raw/share.html" { t.Fatalf("unexpected url: %s", body.URL) } if len(backend.accessWorkspaces) != 1 || backend.accessWorkspaces[0] != "workspace-1" { t.Fatalf("access workspaces = %v, want workspace-1", backend.accessWorkspaces) } } func TestHTTP_Create_RejectsMismatchedTaskSession(t *testing.T) { t.Parallel() reader := completedSession() backend := &mockBackend{nextID: "gist-mismatch"} handlers, _ := newHandlersForTest(t, reader, backend, true) router := newGinRouter(handlers) req := httptest.NewRequest(http.MethodPost, "/api/v1/tasks/other-task/sessions/s-1/shares", nil) rec := httptest.NewRecorder() router.ServeHTTP(rec, req) if rec.Code != http.StatusNotFound { t.Fatalf("want 404 for mismatched task/session, got %d: %s", rec.Code, rec.Body.String()) } if backend.uploads != 0 || len(backend.accessWorkspaces) != 0 { t.Fatalf("mismatched request reached backend: uploads=%d access=%v", backend.uploads, backend.accessWorkspaces) } } func TestHTTP_List_RejectsMismatchedTaskSession(t *testing.T) { t.Parallel() reader := completedSession() backend := &mockBackend{nextID: "gist-list"} handlers, svc := newHandlersForTest(t, reader, backend, true) router := newGinRouter(handlers) share, err := svc.CreateShare(context.Background(), "t-1", "s-1", "en") if err != nil { t.Fatalf("create: %v", err) } req := httptest.NewRequest(http.MethodGet, "/api/v1/tasks/other-task/sessions/s-1/shares", nil) rec := httptest.NewRecorder() router.ServeHTTP(rec, req) if rec.Code != http.StatusNotFound { t.Fatalf("want 404 for mismatched task/session, got %d: %s", rec.Code, rec.Body.String()) } if strings.Contains(rec.Body.String(), share.ID) || strings.Contains(rec.Body.String(), "gist-list") { t.Fatalf("mismatched list exposed share metadata: %s", rec.Body.String()) } } func TestHTTP_Create_RejectsCreatedSessionWith409(t *testing.T) { t.Parallel() reader := completedSession() reader.session.State = models.TaskSessionStateCreated backend := &mockBackend{} handlers, _ := newHandlersForTest(t, reader, backend, true) router := newGinRouter(handlers) req := httptest.NewRequest(http.MethodPost, "/api/v1/tasks/t-1/sessions/s-1/shares", nil) rec := httptest.NewRecorder() router.ServeHTTP(rec, req) if rec.Code != http.StatusConflict { t.Fatalf("want 409, got %d: %s", rec.Code, rec.Body.String()) } var body errorBody _ = json.Unmarshal(rec.Body.Bytes(), &body) if body.Code != "session_not_shareable" { t.Fatalf("expected code session_not_shareable, got %q", body.Code) } } func TestHTTP_Create_BlocksWhenGitHubUnauthenticated(t *testing.T) { t.Parallel() reader := completedSession() backend := &mockBackend{} handlers, _ := newHandlersForTest(t, reader, backend, false) router := newGinRouter(handlers) req := httptest.NewRequest(http.MethodPost, "/api/v1/tasks/t-1/sessions/s-1/shares", nil) rec := httptest.NewRecorder() router.ServeHTTP(rec, req) if rec.Code != http.StatusPreconditionFailed { t.Fatalf("want 412, got %d", rec.Code) } var body errorBody _ = json.Unmarshal(rec.Body.Bytes(), &body) if body.Code != "github_credential_missing" { t.Fatalf("expected code github_credential_missing, got %q", body.Code) } } func TestHTTP_Create_HidesAuthorizationInfrastructureErrors(t *testing.T) { t.Parallel() reader := completedSession() backend := &mockBackend{} handlers, svc := newHandlersForTest(t, reader, backend, true) svc.authorizer = &recordingShareAccess{taskSessionErr: errors.New("db transient")} router := newGinRouter(handlers) req := httptest.NewRequest(http.MethodPost, "/api/v1/tasks/t-1/sessions/s-1/shares", nil) rec := httptest.NewRecorder() router.ServeHTTP(rec, req) if rec.Code != http.StatusInternalServerError { t.Fatalf("want 500, got %d: %s", rec.Code, rec.Body.String()) } var body errorBody if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil { t.Fatalf("decode: %v", err) } if body.Error != "failed to authorize share access" || body.Code != "" { t.Fatalf("unexpected authorization error body: %+v", body) } if strings.Contains(rec.Body.String(), "db transient") { t.Fatalf("authorization infrastructure error leaked: %s", rec.Body.String()) } if backend.uploads != 0 || len(backend.accessWorkspaces) != 0 { t.Fatalf("authorization infrastructure error reached backend: uploads=%d access=%v", backend.uploads, backend.accessWorkspaces) } } func TestHTTP_Create_DryRun_HidesAuthorizationInfrastructureErrors(t *testing.T) { t.Parallel() reader := completedSession() backend := &mockBackend{} handlers, svc := newHandlersForTest(t, reader, backend, true) svc.authorizer = &recordingShareAccess{taskSessionErr: errors.New("db transient")} router := newGinRouter(handlers) req := httptest.NewRequest(http.MethodPost, "/api/v1/tasks/t-1/sessions/s-1/shares?dry_run=true", nil) rec := httptest.NewRecorder() router.ServeHTTP(rec, req) if rec.Code != http.StatusInternalServerError { t.Fatalf("want 500, got %d: %s", rec.Code, rec.Body.String()) } var body errorBody if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil { t.Fatalf("decode: %v", err) } if body.Error != "failed to authorize share access" || body.Code != "" { t.Fatalf("unexpected authorization error body: %+v", body) } if strings.Contains(rec.Body.String(), "db transient") { t.Fatalf("authorization infrastructure error leaked: %s", rec.Body.String()) } if backend.uploads != 0 || len(backend.accessWorkspaces) != 0 { t.Fatalf("authorization infrastructure error reached backend: uploads=%d access=%v", backend.uploads, backend.accessWorkspaces) } } func TestHTTP_Create_SecondAuthorization_HidesInfrastructureErrors(t *testing.T) { t.Parallel() reader := completedSession() backend := &mockBackend{} handlers, svc := newHandlersForTest(t, reader, backend, true) svc.authorizer = &recordingShareAccess{taskSessionErrs: []error{nil, errors.New("db transient")}} router := newGinRouter(handlers) req := httptest.NewRequest(http.MethodPost, "/api/v1/tasks/t-1/sessions/s-1/shares", nil) rec := httptest.NewRecorder() router.ServeHTTP(rec, req) if rec.Code != http.StatusInternalServerError { t.Fatalf("want 500, got %d: %s", rec.Code, rec.Body.String()) } var body errorBody if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil { t.Fatalf("decode: %v", err) } if body.Error != "failed to authorize share access" || body.Code != "" { t.Fatalf("unexpected authorization error body: %+v", body) } if strings.Contains(rec.Body.String(), "db transient") { t.Fatalf("authorization infrastructure error leaked: %s", rec.Body.String()) } if backend.uploads != 0 { t.Fatalf("second authorization failure reached backend Upload: %d", backend.uploads) } } func TestHTTP_Create_DryRunReturnsSnapshotWithoutUpload(t *testing.T) { t.Parallel() reader := completedSession() backend := &mockBackend{} // Auth check is skipped for dry-run; flip authed to false to prove that. handlers, _ := newHandlersForTest(t, reader, backend, false) router := newGinRouter(handlers) req := httptest.NewRequest(http.MethodPost, "/api/v1/tasks/t-1/sessions/s-1/shares?dry_run=true", nil) rec := httptest.NewRecorder() router.ServeHTTP(rec, req) if rec.Code != http.StatusOK { t.Fatalf("want 200, got %d: %s", rec.Code, rec.Body.String()) } var snap Snapshot if err := json.Unmarshal(rec.Body.Bytes(), &snap); err != nil { t.Fatalf("decode: %v", err) } if snap.Task.Title == "" { t.Fatalf("expected non-empty snapshot, got %+v", snap) } if backend.uploads != 0 { t.Fatalf("dry-run must not call backend Upload, got %d uploads", backend.uploads) } } func TestHTTP_List_ReturnsSharesNewestFirst(t *testing.T) { t.Parallel() reader := completedSession() backend := &mockBackend{nextID: "gist-a"} handlers, svc := newHandlersForTest(t, reader, backend, true) router := newGinRouter(handlers) if _, err := svc.CreateShare(context.Background(), "t-1", "s-1", "en"); err != nil { t.Fatalf("create: %v", err) } req := httptest.NewRequest(http.MethodGet, "/api/v1/tasks/t-1/sessions/s-1/shares", nil) rec := httptest.NewRecorder() router.ServeHTTP(rec, req) if rec.Code != http.StatusOK { t.Fatalf("want 200, got %d", rec.Code) } var body listSharesResponse if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil { t.Fatalf("decode: %v", err) } if len(body.Shares) != 1 { t.Fatalf("expected 1 share, got %d", len(body.Shares)) } } func TestHTTP_Revoke_Success(t *testing.T) { t.Parallel() reader := completedSession() backend := &mockBackend{nextID: "gist-z"} handlers, svc := newHandlersForTest(t, reader, backend, true) router := newGinRouter(handlers) share, err := svc.CreateShare(context.Background(), "t-1", "s-1", "en") if err != nil { t.Fatalf("create: %v", err) } req := httptest.NewRequest(http.MethodDelete, "/api/v1/shares/"+share.ID, nil) rec := httptest.NewRecorder() router.ServeHTTP(rec, req) if rec.Code != http.StatusNoContent { t.Fatalf("want 204, got %d: %s", rec.Code, rec.Body.String()) } if len(backend.deletes) != 1 { t.Fatalf("expected 1 backend delete, got %d", len(backend.deletes)) } } func TestHTTP_Revoke_RejectsUnauthorizedShare(t *testing.T) { t.Parallel() reader := completedSession() backend := &mockBackend{nextID: "gist-denied"} handlers, svc := newHandlersForTest(t, reader, backend, true) router := newGinRouter(handlers) share, err := svc.CreateShare(context.Background(), "t-1", "s-1", "en") if err != nil { t.Fatalf("create: %v", err) } svc.authorizer = &recordingShareAccess{sessionErr: ErrNotFound} req := httptest.NewRequest(http.MethodDelete, "/api/v1/shares/"+share.ID, nil) rec := httptest.NewRecorder() router.ServeHTTP(rec, req) if rec.Code != http.StatusNotFound { t.Fatalf("want 404 for unauthorized revoke, got %d: %s", rec.Code, rec.Body.String()) } if len(backend.deletes) != 0 { t.Fatalf("unauthorized revoke called backend Delete: %v", backend.deletes) } row, err := svc.GetByID(context.Background(), share.ID) if err != nil { t.Fatalf("get share: %v", err) } if row.RevokedAt != nil { t.Fatal("unauthorized revoke mutated the share row") } } func TestHTTP_Revoke_HidesAuthorizationInfrastructureErrors(t *testing.T) { t.Parallel() reader := completedSession() backend := &mockBackend{nextID: "gist-infra"} handlers, svc := newHandlersForTest(t, reader, backend, true) router := newGinRouter(handlers) share, err := svc.CreateShare(context.Background(), "t-1", "s-1", "en") if err != nil { t.Fatalf("create: %v", err) } svc.authorizer = &recordingShareAccess{sessionErr: errors.New("db transient")} req := httptest.NewRequest(http.MethodDelete, "/api/v1/shares/"+share.ID, nil) rec := httptest.NewRecorder() router.ServeHTTP(rec, req) if rec.Code != http.StatusInternalServerError { t.Fatalf("want 500, got %d: %s", rec.Code, rec.Body.String()) } var body errorBody if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil { t.Fatalf("decode: %v", err) } if body.Error != "failed to authorize share access" || body.Code != "" { t.Fatalf("unexpected authorization error body: %+v", body) } if strings.Contains(rec.Body.String(), "db transient") { t.Fatalf("authorization infrastructure error leaked: %s", rec.Body.String()) } if len(backend.deletes) != 0 { t.Fatalf("authorization infrastructure error reached backend Delete: %v", backend.deletes) } row, err := svc.GetByID(context.Background(), share.ID) if err != nil { t.Fatalf("get share: %v", err) } if row.RevokedAt != nil { t.Fatal("authorization infrastructure error mutated the share row") } } func TestDisplayURL_NormalizesAllFormats(t *testing.T) { t.Parallel() cases := []struct { name string input string want string }{ { "bare_gist_url_converted_to_githack", "https://gist.github.com/jane/abc123", "https://gist.githack.com/jane/abc123/raw/share.html", }, { "githack_url_passthrough", "https://gist.githack.com/jane/abc123/raw/share.html", "https://gist.githack.com/jane/abc123/raw/share.html", }, { "githack_without_filename_repinned", "https://gist.githack.com/jane/abc123", "https://gist.githack.com/jane/abc123/raw/share.html", }, { // Legacy gistpreview rows (written before the githack switch) // lack the owner segment we need to build a githack URL, so // they pass through. Users on those rows still get a working // link for small tasks; revoking + re-sharing surfaces the // githack URL going forward. "legacy_gistpreview_with_share_html_passthrough", "https://gistpreview.github.io/?abc123/share.html", "https://gistpreview.github.io/?abc123/share.html", }, { // Older gistpreview rows stored without /share.html still get // re-pinned so gistpreview doesn't silently fall back to // rendering README.md. "legacy_gistpreview_without_filename_repinned", "https://gistpreview.github.io/?abc123", "https://gistpreview.github.io/?abc123/share.html", }, { "empty_string", "", "", }, { "unknown_url_passthrough", "https://example.com/foo", "https://example.com/foo", }, } for _, tc := range cases { tc := tc t.Run(tc.name, func(t *testing.T) { if got := displayURL(tc.input); got != tc.want { t.Fatalf("got %q, want %q", got, tc.want) } }) } } func TestHTTP_List_NormalizesLegacyURLsOnDisplay(t *testing.T) { t.Parallel() reader := completedSession() backend := &mockBackend{} handlers, svc := newHandlersForTest(t, reader, backend, true) router := newGinRouter(handlers) // Seed two legacy rows from earlier URL formats — bare gist and a // githack URL with no filename pinned. Both should surface as the // canonical /raw/share.html githack form. for _, row := range []*Share{ {ID: "old-1", TaskSessionID: "s-1", Backend: BackendGitHubGist, ExternalID: "abc123", ExternalURL: "https://gist.github.com/jane/abc123"}, {ID: "old-2", TaskSessionID: "s-1", Backend: BackendGitHubGist, ExternalID: "def456", ExternalURL: "https://gist.githack.com/jane/def456"}, } { if err := svc.repo.Create(context.Background(), row); err != nil { t.Fatalf("seed %s: %v", row.ID, err) } } req := httptest.NewRequest(http.MethodGet, "/api/v1/tasks/t-1/sessions/s-1/shares", nil) rec := httptest.NewRecorder() router.ServeHTTP(rec, req) if rec.Code != http.StatusOK { t.Fatalf("want 200, got %d", rec.Code) } var body listSharesResponse if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil { t.Fatalf("decode: %v", err) } if len(body.Shares) != 2 { t.Fatalf("expected 2 shares, got %d", len(body.Shares)) } for _, s := range body.Shares { if !strings.HasSuffix(s.URL, "/raw/share.html") || !strings.HasPrefix(s.URL, "https://gist.githack.com/") { t.Fatalf("expected gist.githack.com /raw/share.html URL, got %q", s.URL) } } } func TestHTTP_Revoke_NotFound(t *testing.T) { t.Parallel() reader := completedSession() backend := &mockBackend{} handlers, _ := newHandlersForTest(t, reader, backend, true) router := newGinRouter(handlers) req := httptest.NewRequest(http.MethodDelete, "/api/v1/shares/does-not-exist", nil) rec := httptest.NewRecorder() router.ServeHTTP(rec, req) if rec.Code != http.StatusNotFound { t.Fatalf("want 404, got %d", rec.Code) } } // TestHTTP_Create_ResolvesCreatorLocale pins the whole chain end to end: the // creator's locale is read off the request and reaches the backend, because // that is the only moment a static gist can be given a language. Table covers // the two ways a locale arrives and the two ways it degrades to English. func TestHTTP_Create_ResolvesCreatorLocale(t *testing.T) { t.Parallel() for _, tc := range []struct { name string cookie string acceptLanguage string want string }{ {name: "cookie wins over accept-language", cookie: "pseudo", acceptLanguage: "en", want: "pseudo"}, {name: "accept-language when no cookie", acceptLanguage: "pseudo;q=1.0, en;q=0.8", want: "pseudo"}, {name: "no signal falls back to en", want: "en"}, {name: "unsupported cookie falls back to en", cookie: "klingon", want: "en"}, } { tc := tc t.Run(tc.name, func(t *testing.T) { t.Parallel() backend := &mockBackend{nextID: "gist-loc"} handlers, _ := newHandlersForTest(t, completedSession(), backend, true) router := newGinRouter(handlers) req := httptest.NewRequest(http.MethodPost, "/api/v1/tasks/t-1/sessions/s-1/shares", nil) if tc.cookie != "" { req.AddCookie(&http.Cookie{Name: i18n.LocaleCookie, Value: tc.cookie}) } if tc.acceptLanguage != "" { req.Header.Set("Accept-Language", tc.acceptLanguage) } rec := httptest.NewRecorder() router.ServeHTTP(rec, req) if rec.Code != http.StatusCreated { t.Fatalf("want 201, got %d: %s", rec.Code, rec.Body.String()) } if len(backend.uploadLocales) != 1 || backend.uploadLocales[0] != tc.want { t.Fatalf("backend received locales %v, want [%s]", backend.uploadLocales, tc.want) } }) } }