func TestScanWireTypesZero(t *testing.T) {
    pr := PRRef{Repo: "o/r", Number: 5, Author: "bot", HeadSHA: "abc", Labels: []string{"p"}}
    if pr.Repo != "o/r" || pr.Number != 5 || pr.Author != "bot" || pr.HeadSHA != "abc" || pr.Labels[0] != "p" {
        t.Fatalf("PRRef fields not wired: %+v", pr)
    }
    iss := IssueRef2{Repo: "o/r", Number: 7, Labels: []string{"p"}, IsPR: true}
    if iss.Repo != "o/r" || iss.Number != 7 || !iss.IsPR {
        t.Fatalf("IssueRef2 fields not wired: %+v", iss)
    }
    bi := BoardItem{Repo: "o/r", Number: 9, Column: "Todo"}
    if bi.Repo != "o/r" || bi.Number != 9 || bi.Column != "Todo" {
        t.Fatalf("BoardItem fields not wired: %+v", bi)
    }
}

// CreatedIssue identifies a created issue (internal return type, not a wire type).
type CreatedIssue struct {
    Ref string // owner/repo#n (github) or group/proj#iid (gitlab)
    URL string // html/web url
}

    CreateIssue(ctx context.Context, repoURL, token string, req IssueReq) (CreatedIssue, error)

func TestScanWireTypesZero(t *testing.T) {
    pr := PRRef{Repo: "o/r", Number: 5, Author: "bot", HeadSHA: "abc", Labels: []string{"p"}}
    if pr.Repo != "o/r" || pr.Number != 5 || pr.Author != "bot" || pr.HeadSHA != "abc" || pr.Labels[0] != "p" {
        t.Fatalf("PRRef fields not wired: %+v", pr)
    }
    iss := IssueRef{Repo: "o/r", Number: 7, Labels: []string{"p"}, IsPR: true}
    if iss.Repo != "o/r" || iss.Number != 7 || !iss.IsPR {
        t.Fatalf("IssueRef fields not wired: %+v", iss)
    }
    bi := BoardItem{Repo: "o/r", Number: 9, Column: "Todo"}
    if bi.Repo != "o/r" || bi.Number != 9 || bi.Column != "Todo" {
        t.Fatalf("BoardItem fields not wired: %+v", bi)
    }
}

// PRRef is one open PR/MR listed for cron MR-triage.
type PRRef struct {
    Repo      string    `json:"repo"`
    Number    int       `json:"number"`
    Author    string    `json:"author"`
    HeadSHA   string    `json:"headSha"`
    Labels    []string  `json:"labels,omitempty"`
    UpdatedAt time.Time `json:"updatedAt"`
}

// IssueRef is one open issue listed for cron issue-triage.
type IssueRef struct {
    Repo      string    `json:"repo"`
    Number    int       `json:"number"`
    Labels    []string  `json:"labels,omitempty"`
    UpdatedAt time.Time `json:"updatedAt"`
    IsPR      bool      `json:"isPr"` // GitHub /issues returns PRs; filter these out
}

// BoardItem is one project-board item listed for cron issue-triage.
type BoardItem struct {
    Repo      string    `json:"repo"`
    Number    int       `json:"number"` // 0 for draft/non-issue items -> skipped
    Column    string    `json:"column"`
    UpdatedAt time.Time `json:"updatedAt"`
}

func TestProvidersSatisfySCMReader(t *testing.T) {
    var _ SCMReader = (*GitHub)(nil)
    var _ SCMReader = (*GitLab)(nil)
}

func TestProvidersSatisfyCloseIssue(t *testing.T) {
    var w SCMWriter = (*GitHub)(nil)
    _ = w
    var w2 SCMWriter = (*GitLab)(nil)
    _ = w2
}

    CloseIssue(ctx context.Context, repo string, number int, comment string) error

// SCMReader lists open work for the cron scan loop; *GitHub and *GitLab satisfy it.
type SCMReader interface {
    ListOpenPRs(ctx context.Context, owner, repo string) ([]PRRef, error)
    ListOpenIssues(ctx context.Context, owner, repo string) ([]IssueRef, error)
    ListBoardItems(ctx context.Context, board BoardRef) ([]BoardItem, error)
}

package scm

import (
    "context"
    "encoding/json"
    "net/http"
    "net/http/httptest"
    "testing"
)

func TestGitHubListOpenPRs(t *testing.T) {
    srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if r.URL.Path != "/repos/o/r/pulls" || r.URL.Query().Get("state") != "open" {
            t.Fatalf("path=%q query=%q", r.URL.Path, r.URL.RawQuery)
        }
        _ = json.NewEncoder(w).Encode([]map[string]any{
            {"number": 5, "user": map[string]any{"login": "alice"},
                "head": map[string]any{"sha": "abc"},
                "labels": []map[string]any{{"name": "tatara/priority"}},
                "updated_at": "2026-06-10T12:00:00Z"},
        })
    }))
    defer srv.Close()
    c := &GitHub{apiBase: srv.URL}
    prs, err := c.ListOpenPRs(context.Background(), "o", "r")
    if err != nil {
        t.Fatalf("ListOpenPRs: %v", err)
    }
    if len(prs) != 1 || prs[0].Repo != "o/r" || prs[0].Number != 5 || prs[0].Author != "alice" || prs[0].HeadSHA != "abc" || prs[0].Labels[0] != "tatara/priority" {
        t.Fatalf("prs = %+v", prs)
    }
    if prs[0].UpdatedAt.IsZero() {
        t.Fatalf("updatedAt not parsed: %+v", prs[0])
    }
}

func TestGitHubListOpenIssuesFiltersPRs(t *testing.T) {
    srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if r.URL.Path != "/repos/o/r/issues" || r.URL.Query().Get("state") != "open" {
            t.Fatalf("path=%q query=%q", r.URL.Path, r.URL.RawQuery)
        }
        _ = json.NewEncoder(w).Encode([]map[string]any{
            {"number": 7, "labels": []map[string]any{{"name": "bug"}}, "updated_at": "2026-06-10T12:00:00Z"},
            {"number": 8, "pull_request": map[string]any{"url": "x"}, "updated_at": "2026-06-10T12:00:00Z"},
        })
    }))
    defer srv.Close()
    c := &GitHub{apiBase: srv.URL}
    iss, err := c.ListOpenIssues(context.Background(), "o", "r")
    if err != nil {
        t.Fatalf("ListOpenIssues: %v", err)
    }
    if len(iss) != 2 {
        t.Fatalf("want 2 items (IsPR set), got %+v", iss)
    }
    if iss[0].Number != 7 || iss[0].IsPR {
        t.Fatalf("issue 7 should not be PR: %+v", iss[0])
    }
    if iss[1].Number != 8 || !iss[1].IsPR {
        t.Fatalf("issue 8 should be flagged IsPR: %+v", iss[1])
    }
}

func TestGitHubCloseIssue(t *testing.T) {
    paths := map[string]string{} // "METHOD path" -> body state
    srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        paths[r.Method+" "+r.URL.Path] = ""
    }))
    defer srv.Close()
    c := &GitHub{apiBase: srv.URL}
    if err := c.CloseIssue(context.Background(), "o/r", 7, "closing: out of scope"); err != nil {
        t.Fatalf("CloseIssue: %v", err)
    }
    if _, ok := paths["POST /repos/o/r/issues/7/comments"]; !ok {
        t.Fatalf("missing comment POST; got %+v", paths)
    }
    if _, ok := paths["PATCH /repos/o/r/issues/7"]; !ok {
        t.Fatalf("missing PATCH close; got %+v", paths)
    }
}

package scm

import (
    "context"
    "fmt"
    "net/http"
    "time"
)

type ghPR struct {
    Number int `json:"number"`
    User   struct {
        Login string `json:"login"`
    } `json:"user"`
    Head struct {
        SHA string `json:"sha"`
    } `json:"head"`
    Labels    []ghLabel `json:"labels"`
    UpdatedAt time.Time `json:"updated_at"`
}

type ghIssue struct {
    Number      int       `json:"number"`
    Labels      []ghLabel `json:"labels"`
    UpdatedAt   time.Time `json:"updated_at"`
    PullRequest *struct {
        URL string `json:"url"`
    } `json:"pull_request"`
}

func ghLabelNames(in []ghLabel) []string {
    out := make([]string, 0, len(in))
    for _, l := range in {
        out = append(out, l.Name)
    }
    return out
}

// ListOpenPRs lists open pull requests for owner/repo.
func (c *GitHub) ListOpenPRs(ctx context.Context, owner, repo string) ([]PRRef, error) {
    var raw []ghPR
    path := fmt.Sprintf("/repos/%s/%s/pulls?state=open", owner, repo)
    if err := ghDo(ctx, c.base(), http.MethodGet, path, "", nil, &raw); err != nil {
        return nil, err
    }
    slug := owner + "/" + repo
    out := make([]PRRef, 0, len(raw))
    for _, p := range raw {
        out = append(out, PRRef{
            Repo: slug, Number: p.Number, Author: p.User.Login,
            HeadSHA: p.Head.SHA, Labels: ghLabelNames(p.Labels), UpdatedAt: p.UpdatedAt,
        })
    }
    return out, nil
}

// ListOpenIssues lists open issues for owner/repo. GitHub returns PRs in the
// issues feed; IsPR is set so the caller can filter.
func (c *GitHub) ListOpenIssues(ctx context.Context, owner, repo string) ([]IssueRef, error) {
    var raw []ghIssue
    path := fmt.Sprintf("/repos/%s/%s/issues?state=open", owner, repo)
    if err := ghDo(ctx, c.base(), http.MethodGet, path, "", nil, &raw); err != nil {
        return nil, err
    }
    slug := owner + "/" + repo
    out := make([]IssueRef, 0, len(raw))
    for _, i := range raw {
        out = append(out, IssueRef{
            Repo: slug, Number: i.Number, Labels: ghLabelNames(i.Labels),
            UpdatedAt: i.UpdatedAt, IsPR: i.PullRequest != nil,
        })
    }
    return out, nil
}

// CloseIssue posts a comment then PATCHes the issue state to closed.
func (c *GitHub) CloseIssue(ctx context.Context, repo string, number int, comment string) error {
    owner, name, err := ghOwnerRepoFromSlug(repo)
    if err != nil {
        return err
    }
    if comment != "" {
        cpath := fmt.Sprintf("/repos/%s/%s/issues/%d/comments", owner, name, number)
        if err := ghDo(ctx, c.base(), http.MethodPost, cpath, "", map[string]string{"body": comment}, nil); err != nil {
            return err
        }
    }
    ipath := fmt.Sprintf("/repos/%s/%s/issues/%d", owner, name, number)
    return ghDo(ctx, c.base(), http.MethodPatch, ipath, "", map[string]string{"state": "closed"}, nil)
}

func ghOwnerRepoFromSlug(slug string) (string, string, error) {
    for i := len(slug) - 1; i >= 0; i-- {
        if slug[i] == '/' {
            if i == 0 || i == len(slug)-1 {
                break
            }
            return slug[:i], slug[i+1:], nil
        }
    }
    return "", "", fmt.Errorf("github: malformed repo slug %q", slug)
}

type GitHub struct {
    apiBase     string
    graphQLBase string
    token       string // bound for reader calls; empty for writer/webhook use
}

// ListBoardItems lists ProjectV2 board items via GraphQL, dual user/org query.
func (c *GitHub) ListBoardItems(ctx context.Context, board BoardRef) ([]BoardItem, error) {
    type itemNode struct {
        UpdatedAt   time.Time `json:"updatedAt"`
        FieldValueByName *struct {
            Name string `json:"name"`
        } `json:"fieldValueByName"`
        Content struct {
            Number     int    `json:"number"`
            Repository struct {
                NameWithOwner string `json:"nameWithOwner"`
            } `json:"repository"`
        } `json:"content"`
    }
    type projectV2Items struct {
        Items struct {
            Nodes []itemNode `json:"nodes"`
        } `json:"items"`
    }
    var resp struct {
        User struct {
            ProjectV2 projectV2Items `json:"projectV2"`
        } `json:"user"`
        Organization struct {
            ProjectV2 projectV2Items `json:"projectV2"`
        } `json:"organization"`
    }
    field := board.StatusField
    if field == "" {
        field = "Status"
    }
    sel := fmt.Sprintf(`projectV2(number:%d){ items(first:100){ nodes { updatedAt fieldValueByName(name:%q){ ... on ProjectV2ItemFieldSingleSelectValue { name } } content { ... on Issue { number repository { nameWithOwner } } ... on PullRequest { number repository { nameWithOwner } } } } } }`, board.GitHubProjectNumber, field)
    q := fmt.Sprintf(`query { user(login:%q){ %s } organization(login:%q){ %s } }`, board.Owner, sel, board.Owner, sel)
    if err := c.ghGraphQL(ctx, c.token, q, nil, &resp); err != nil {
        return nil, err
    }
    nodes := resp.Organization.ProjectV2.Items.Nodes
    if len(resp.User.ProjectV2.Items.Nodes) > 0 {
        nodes = resp.User.ProjectV2.Items.Nodes
    }
    out := make([]BoardItem, 0, len(nodes))
    for _, n := range nodes {
        col := ""
        if n.FieldValueByName != nil {
            col = n.FieldValueByName.Name
        }
        out = append(out, BoardItem{
            Repo: n.Content.Repository.NameWithOwner, Number: n.Content.Number,
            Column: col, UpdatedAt: n.UpdatedAt,
        })
    }
    return out, nil
}

func TestGitHubListBoardItems(t *testing.T) {
    srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        _ = json.NewEncoder(w).Encode(map[string]any{
            "data": map[string]any{
                "user": map[string]any{
                    "projectV2": map[string]any{
                        "items": map[string]any{"nodes": []map[string]any{
                            {"updatedAt": "2026-06-10T12:00:00Z",
                                "fieldValueByName": map[string]any{"name": "Todo"},
                                "content": map[string]any{"number": 9, "repository": map[string]any{"nameWithOwner": "o/r"}}},
                        }},
                    },
                },
                "organization": map[string]any{"projectV2": map[string]any{"items": map[string]any{"nodes": []any{}}}},
            },
        })
    }))
    defer srv.Close()
    c := &GitHub{graphQLBase: srv.URL}
    items, err := c.ListBoardItems(context.Background(), BoardRef{Owner: "o", GitHubProjectNumber: 3})
    if err != nil {
        t.Fatalf("ListBoardItems: %v", err)
    }
    if len(items) != 1 || items[0].Repo != "o/r" || items[0].Number != 9 || items[0].Column != "Todo" {
        t.Fatalf("items = %+v", items)
    }
}

package scm

import (
    "context"
    "encoding/json"
    "net/http"
    "net/http/httptest"
    "testing"
)

func TestGitLabListOpenPRs(t *testing.T) {
    srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if r.URL.Path != "/projects/g%2Fp/merge_requests" || r.URL.Query().Get("state") != "opened" {
            t.Fatalf("path=%q query=%q", r.URL.Path, r.URL.RawQuery)
        }
        _ = json.NewEncoder(w).Encode([]map[string]any{
            {"iid": 5, "sha": "abc", "author": map[string]any{"username": "alice"},
                "labels": []string{"tatara/priority"}, "updated_at": "2026-06-10T12:00:00Z"},
        })
    }))
    defer srv.Close()
    c := &GitLab{apiBase: srv.URL, token: "tok"}
    prs, err := c.ListOpenPRs(context.Background(), "g", "p")
    if err != nil {
        t.Fatalf("ListOpenPRs: %v", err)
    }
    if len(prs) != 1 || prs[0].Repo != "g/p" || prs[0].Number != 5 || prs[0].Author != "alice" || prs[0].HeadSHA != "abc" || prs[0].Labels[0] != "tatara/priority" {
        t.Fatalf("prs = %+v", prs)
    }
}

func TestGitLabListOpenIssues(t *testing.T) {
    srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if r.URL.Path != "/projects/g%2Fp/issues" || r.URL.Query().Get("state") != "opened" {
            t.Fatalf("path=%q query=%q", r.URL.Path, r.URL.RawQuery)
        }
        _ = json.NewEncoder(w).Encode([]map[string]any{
            {"iid": 7, "labels": []string{"bug"}, "updated_at": "2026-06-10T12:00:00Z"},
        })
    }))
    defer srv.Close()
    c := &GitLab{apiBase: srv.URL, token: "tok"}
    iss, err := c.ListOpenIssues(context.Background(), "g", "p")
    if err != nil {
        t.Fatalf("ListOpenIssues: %v", err)
    }
    if len(iss) != 1 || iss[0].Repo != "g/p" || iss[0].Number != 7 || iss[0].IsPR || iss[0].Labels[0] != "bug" {
        t.Fatalf("iss = %+v", iss)
    }
}

func TestGitLabCloseIssue(t *testing.T) {
    paths := map[string]bool{}
    srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        paths[r.Method+" "+r.URL.Path] = true
    }))
    defer srv.Close()
    c := &GitLab{apiBase: srv.URL, token: "tok"}
    if err := c.CloseIssue(context.Background(), "g/p", 7, "closing"); err != nil {
        t.Fatalf("CloseIssue: %v", err)
    }
    if !paths["POST /projects/g%2Fp/issues/7/notes"] {
        t.Fatalf("missing note POST; got %+v", paths)
    }
    if !paths["PUT /projects/g%2Fp/issues/7"] {
        t.Fatalf("missing PUT close; got %+v", paths)
    }
}

type GitLab struct {
    apiBase string
    token   string // bound for reader calls; empty for writer/webhook use
}

package scm

import (
    "context"
    "net/http"
    "net/url"
    "strconv"
    "time"
)

type glMR struct {
    IID    int    `json:"iid"`
    SHA    string `json:"sha"`
    Author struct {
        Username string `json:"username"`
    } `json:"author"`
    Labels    []string  `json:"labels"`
    UpdatedAt time.Time `json:"updated_at"`
}

type glIssue struct {
    IID       int       `json:"iid"`
    Labels    []string  `json:"labels"`
    UpdatedAt time.Time `json:"updated_at"`
}

// ListOpenPRs lists opened merge requests for the project path owner/repo.
func (c *GitLab) ListOpenPRs(ctx context.Context, owner, repo string) ([]PRRef, error) {
    proj := owner + "/" + repo
    var raw []glMR
    path := "/projects/" + url.PathEscape(proj) + "/merge_requests?state=opened"
    if err := glDo(ctx, c.base(), http.MethodGet, path, c.token, nil, &raw); err != nil {
        return nil, err
    }
    out := make([]PRRef, 0, len(raw))
    for _, m := range raw {
        out = append(out, PRRef{
            Repo: proj, Number: m.IID, Author: m.Author.Username,
            HeadSHA: m.SHA, Labels: m.Labels, UpdatedAt: m.UpdatedAt,
        })
    }
    return out, nil
}

// ListOpenIssues lists opened issues for the project path owner/repo.
func (c *GitLab) ListOpenIssues(ctx context.Context, owner, repo string) ([]IssueRef, error) {
    proj := owner + "/" + repo
    var raw []glIssue
    path := "/projects/" + url.PathEscape(proj) + "/issues?state=opened"
    if err := glDo(ctx, c.base(), http.MethodGet, path, c.token, nil, &raw); err != nil {
        return nil, err
    }
    out := make([]IssueRef, 0, len(raw))
    for _, i := range raw {
        out = append(out, IssueRef{
            Repo: proj, Number: i.IID, Labels: i.Labels, UpdatedAt: i.UpdatedAt, IsPR: false,
        })
    }
    return out, nil
}

// ListBoardItems is the label-board mapping: GitLab issue boards are
// label-driven, so the board view is the open-issue set with their board::*
// scoped label as the column. The cron loop dedups board items against
// ListOpenIssues by (repo, number); GitLab returns no separate board feed, so
// this returns the open issues with their board:: column (empty when none).
func (c *GitLab) ListBoardItems(ctx context.Context, board BoardRef) ([]BoardItem, error) {
    // GitLab board membership = open issues; the operator's per-repo
    // ListOpenIssues already covers them. Returning empty keeps the contract
    // (board items deduped by repo/number) without a second source of truth.
    return nil, nil
}

// CloseIssue posts a note then PUTs the issue state_event=close.
func (c *GitLab) CloseIssue(ctx context.Context, repo string, number int, comment string) error {
    proj := repo
    if comment != "" {
        npath := "/projects/" + url.PathEscape(proj) + "/issues/" + strconv.Itoa(number) + "/notes"
        if err := glDo(ctx, c.base(), http.MethodPost, npath, c.token, map[string]string{"body": comment}, nil); err != nil {
            return err
        }
    }
    ipath := "/projects/" + url.PathEscape(proj) + "/issues/" + strconv.Itoa(number)
    return glDo(ctx, c.base(), http.MethodPut, ipath, c.token, map[string]string{"state_event": "close"}, nil)
}

func TestReaderByProvider(t *testing.T) {
    cases := []struct {
        name     string
        provider string
        wantErr  bool
    }{
        {"github", "github", false},
        {"gitlab", "gitlab", false},
        {"unknown", "bitbucket", true},
    }
    for _, tc := range cases {
        t.Run(tc.name, func(t *testing.T) {
            rd, err := ReaderByProvider(tc.provider, "tok")
            if tc.wantErr {
                if err == nil {
                    t.Fatalf("want error for %q", tc.provider)
                }
                return
            }
            if err != nil || rd == nil {
                t.Fatalf("ReaderByProvider(%q): %v", tc.provider, err)
            }
        })
    }
}

// ReaderByProvider returns a token-bound SCMReader for a provider name.
func ReaderByProvider(name, token string) (SCMReader, error) {
    switch name {
    case "github":
        return &GitHub{token: token}, nil
    case "gitlab":
        return &GitLab{token: token}, nil
    default:
        return nil, fmt.Errorf("scm: unknown provider %q", name)
    }
}

package controller

import (
    "context"
    "testing"

    tataradevv1alpha1 "github.com/szymonrychu/tatara-operator/api/v1alpha1"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    "k8s.io/apimachinery/pkg/types"
)

func TestProjectCronFieldsRoundTrip(t *testing.T) {
    ctx := context.Background()
    mkSecret(t, "cron-scm", map[string][]byte{"token": []byte("t"), "webhookSecret": []byte("w")})
    p := &tataradevv1alpha1.Project{}
    p.Name = "cron-proj"
    p.Namespace = testNS
    p.Spec.ScmSecretRef = "cron-scm"
    p.Spec.Scm = &tataradevv1alpha1.ScmSpec{
        Provider: "github", Owner: "o", BotLogin: "bot",
        PriorityLabel: "tatara/priority",
        Cron: &tataradevv1alpha1.ScmCron{
            MRScan:    tataradevv1alpha1.CronActivity{Schedule: "0 * * * *", MaxPerCycle: 2},
            IssueScan: tataradevv1alpha1.CronActivity{Schedule: "0 * * * *", MaxPerCycle: 1},
            Brainstorm: tataradevv1alpha1.BrainstormActivity{
                Enabled: true, Schedule: "0 6 * * *", MaxPerCycle: 1,
                Sources: []string{"docs", "memory", "internet"},
            },
        },
    }
    if err := k8sClient.Create(ctx, p); err != nil {
        t.Fatalf("create project: %v", err)
    }
    got := &tataradevv1alpha1.Project{}
    if err := k8sClient.Get(ctx, types.NamespacedName{Namespace: testNS, Name: "cron-proj"}, got); err != nil {
        t.Fatalf("get project: %v", err)
    }
    if got.Spec.Scm.PriorityLabel != "tatara/priority" || got.Spec.Scm.Cron.MRScan.MaxPerCycle != 2 {
        t.Fatalf("cron fields not persisted: %+v", got.Spec.Scm)
    }
    if !got.Spec.Scm.Cron.Brainstorm.Enabled || got.Spec.Scm.Cron.Brainstorm.Sources[2] != "internet" {
        t.Fatalf("brainstorm fields not persisted: %+v", got.Spec.Scm.Cron.Brainstorm)
    }
    now := metav1.Now()
    got.Status.LastMRScan = &now
    got.Status.LastIssueScan = &now
    got.Status.LastBrainstorm = &now
    if err := k8sClient.Status().Update(ctx, got); err != nil {
        t.Fatalf("status update: %v", err)
    }
}

// CronActivity schedules one Project scan activity (mrScan or issueScan).
type CronActivity struct {
    // Schedule is a 5-field cron (robfig ParseStandard). Empty disables this activity.
    // +optional
    Schedule string `json:"schedule,omitempty"`
    // +kubebuilder:default=1
    // +optional
    MaxPerCycle int `json:"maxPerCycle,omitempty"`
}

// BrainstormActivity schedules the opt-in self-driven issue-proposal scan.
type BrainstormActivity struct {
    // +optional
    Enabled bool `json:"enabled,omitempty"`
    // +optional
    Schedule string `json:"schedule,omitempty"`
    // +kubebuilder:default=1
    // +optional
    MaxPerCycle int `json:"maxPerCycle,omitempty"`
    // +kubebuilder:validation:items:Enum=docs;memory;internet
    // +optional
    Sources []string `json:"sources,omitempty"`
}

// ScmCron groups the three cron-driven scan activities.
type ScmCron struct {
    // +optional
    MRScan CronActivity `json:"mrScan,omitempty"`
    // +optional
    IssueScan CronActivity `json:"issueScan,omitempty"`
    // +optional
    Brainstorm BrainstormActivity `json:"brainstorm,omitempty"`
}

    // +optional
    PriorityLabel string `json:"priorityLabel,omitempty"`
    // +optional
    Cron *ScmCron `json:"cron,omitempty"`

    // +optional
    LastMRScan *metav1.Time `json:"lastMRScan,omitempty"`
    // +optional
    LastIssueScan *metav1.Time `json:"lastIssueScan,omitempty"`
    // +optional
    LastBrainstorm *metav1.Time `json:"lastBrainstorm,omitempty"`