This is an automated email from the ASF dual-hosted git repository.

klesh pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/devlake.git


The following commit(s) were added to refs/heads/main by this push:
     new c6eab87de fix(github): preserve bot classification across collection 
paths (#9387)
c6eab87de is described below

commit c6eab87de5cca79b1d48433deb9cf72732f9daed
Author: Christian Ternes <[email protected]>
AuthorDate: Sat Nov 14 08:08:07 2026 +0100

    fix(github): preserve bot classification across collection paths (#9387)
---
 backend/plugins/github/e2e/account_test.go         | 105 ++++++++++++++
 .../plugins/github/tasks/account_pre_extractor.go  |  10 +-
 .../github/tasks/account_pre_extractor_test.go     |  48 +++++++
 .../tasks/account_graphql_pre_extractor.go         |  16 ++-
 .../tasks/account_graphql_pre_extractor_test.go    | 154 ++++++++++++++++++---
 5 files changed, 312 insertions(+), 21 deletions(-)

diff --git a/backend/plugins/github/e2e/account_test.go 
b/backend/plugins/github/e2e/account_test.go
index 03f71ecb4..07fddbc20 100644
--- a/backend/plugins/github/e2e/account_test.go
+++ b/backend/plugins/github/e2e/account_test.go
@@ -18,15 +18,20 @@ limitations under the License.
 package e2e
 
 import (
+       "encoding/json"
+       "fmt"
        "testing"
+       "time"
 
        "github.com/apache/devlake/core/dal"
        "github.com/apache/devlake/core/models/domainlayer/crossdomain"
        "github.com/apache/devlake/core/models/domainlayer/didgen"
        "github.com/apache/devlake/helpers/e2ehelper"
+       "github.com/apache/devlake/helpers/pluginhelper/api"
        "github.com/apache/devlake/plugins/github/impl"
        "github.com/apache/devlake/plugins/github/models"
        "github.com/apache/devlake/plugins/github/tasks"
+       graphqlTasks "github.com/apache/devlake/plugins/github_graphql/tasks"
        "github.com/stretchr/testify/assert"
        "github.com/stretchr/testify/require"
 )
@@ -142,3 +147,103 @@ func TestAccountDataFlow(t *testing.T) {
        }
        assert.True(t, sawOrphanCase, "fixture should include the non-committer 
orphan case (milichev)")
 }
+
+// Without profile enrichment, bot classification must survive every 
repository's
+// conversion of the shared account, including REST aliases of a GraphQL actor.
+func TestAccountDataFlowBotWithoutProfile(t *testing.T) {
+       t.Setenv("GITHUB_PR_EXCLUDELIST", "")
+       tasks.ResetExcludedUsernamesForTest()
+       t.Cleanup(tasks.ResetExcludedUsernamesForTest)
+       df := e2ehelper.NewDataFlowTester(t, "github", impl.Github{})
+       for _, model := range []interface{ TableName() string }{
+               &models.GithubAccount{}, &models.GithubAccountOrg{}, 
&models.GithubRepoAccount{},
+               &crossdomain.Account{}, &models.GithubPullRequest{}, 
&models.GithubPrReview{},
+               &models.GithubReviewer{}, &models.GithubPrLabel{}, 
&models.GithubPrCommit{},
+               &models.GithubCommit{}, &models.GithubPrComment{},
+       } {
+               df.FlushTabler(model)
+       }
+       graphqlTable := "_raw_" + graphqlTasks.RAW_PRS_TABLE
+       restTable := "_raw_" + tasks.RAW_PR_REVIEW_COMMENTS_TABLE
+       df.FlushRawTable(graphqlTable)
+       df.FlushRawTable(restTable)
+
+       accountIdGen := didgen.NewDomainIdGenerator(&models.GithubAccount{})
+       for step, run := range []struct {
+               repoID  int
+               graphql bool
+       }{
+               {101, true}, {102, false}, {101, false}, {102, true},
+       } {
+               t.Run(fmt.Sprintf("%d/repo-%d/graphql-%t", step, run.repoID, 
run.graphql), func(t *testing.T) {
+                       name := fmt.Sprintf("owner/repo-%d", run.repoID)
+                       data := &tasks.GithubTaskData{Options: 
&tasks.GithubOptions{
+                               ConnectionId: 1, GithubId: run.repoID, Name: 
name,
+                       }}
+                       params, err := 
json.Marshal(tasks.GithubApiParams{ConnectionId: 1, Name: name})
+                       require.NoError(t, err)
+                       wantBotLogin := "Copilot[bot]"
+                       if run.graphql {
+                               // Match the real decoder's overlapping 
fragment fields and the
+                               // collector's JSON serialization, rather than 
a Bot-only fragment.
+                               raw := fmt.Sprintf(`{
+                                       "DatabaseId":%d, "Number":1, 
"State":"OPEN",
+                                       "CreatedAt":"2026-01-01T00:00:00Z", 
"UpdatedAt":"2026-01-02T00:00:00Z",
+                                       "Author":{
+                                               "TypeName":"User", 
"Login":"octocat", "Id":583231,
+                                               "Bot":{"Login":"octocat", 
"Id":583231}
+                                       },
+                                       "Reviews":{"Nodes":[{
+                                               "databaseId":%d, 
"state":"COMMENTED",
+                                               "Author":{
+                                                       "TypeName":"Bot", 
"Login":"copilot-pull-request-reviewer", "Id":175728472,
+                                                       
"Bot":{"Login":"copilot-pull-request-reviewer", "Id":175728472}
+                                               }
+                                       }]}
+                               }`, run.repoID, run.repoID)
+                               var pr graphqlTasks.GraphqlQueryPr
+                               require.NoError(t, json.Unmarshal([]byte(raw), 
&pr))
+                               serialized, err := json.Marshal(pr)
+                               require.NoError(t, err)
+                               require.NoError(t, 
df.Db.Table(graphqlTable).Create(&api.RawData{
+                                       Params: string(params), Data: 
serialized, CreatedAt: time.Now().UTC(),
+                               }).Error)
+                               df.Subtask(graphqlTasks.ExtractPrsMeta, data)
+                               wantBotLogin = 
"copilot-pull-request-reviewer[bot]"
+                       } else {
+                               for i, user := range []string{
+                                       
`{"login":"Copilot","id":175728472,"type":"Bot"}`,
+                                       
`{"login":"octocat","id":583231,"type":"User"}`,
+                               } {
+                                       raw := 
fmt.Sprintf(`{"id":%d,"body":"review","user":%s,"pull_request_url":"https://api.github.com/repos/%s/pulls/1","created_at":"2026-01-01T00:00:00Z","updated_at":"2026-01-02T00:00:00Z"}`,
 run.repoID*10+i, user, name)
+                                       require.NoError(t, 
df.Db.Table(restTable).Create(&api.RawData{
+                                               Params: string(params), Data: 
[]byte(raw), CreatedAt: time.Now().UTC(),
+                                       }).Error)
+                               }
+                               
df.Subtask(tasks.ExtractApiPrReviewCommentsMeta, data)
+                       }
+                       df.Subtask(tasks.ConvertAccountsMeta, data)
+                       for _, expected := range []struct {
+                               id    int
+                               login string
+                               bot   bool
+                       }{
+                               {175728472, wantBotLogin, true}, {583231, 
"octocat", false},
+                       } {
+                               var mapping models.GithubRepoAccount
+                               require.NoError(t, df.Dal.First(&mapping, 
dal.Where("connection_id = ? AND repo_github_id = ? AND account_id = ?", 1, 
run.repoID, expected.id)))
+                               assert.Equal(t, expected.login, mapping.Login)
+                               var account crossdomain.Account
+                               require.NoError(t, df.Dal.First(&account, 
dal.Where("id = ?", accountIdGen.Generate(uint64(1), expected.id))))
+                               assert.Equal(t, expected.login, 
account.UserName)
+                               assert.Equal(t, expected.bot, account.IsBot)
+                       }
+               })
+       }
+       count, err := df.Dal.Count(dal.From(&models.GithubAccount{}))
+       require.NoError(t, err)
+       assert.Zero(t, count, "profile enrichment must remain absent throughout 
the test")
+       count, err = df.Dal.Count(dal.From(&crossdomain.Account{}))
+       require.NoError(t, err)
+       assert.Equal(t, int64(2), count, "repositories must share the same 
numeric account identities")
+}
diff --git a/backend/plugins/github/tasks/account_pre_extractor.go 
b/backend/plugins/github/tasks/account_pre_extractor.go
index ef60312d3..cab6ddc1a 100644
--- a/backend/plugins/github/tasks/account_pre_extractor.go
+++ b/backend/plugins/github/tasks/account_pre_extractor.go
@@ -18,6 +18,8 @@ limitations under the License.
 package tasks
 
 import (
+       "strings"
+
        "github.com/apache/devlake/core/errors"
        "github.com/apache/devlake/plugins/github/models"
 )
@@ -44,10 +46,16 @@ type GithubAccountResponse struct {
 }
 
 func convertAccount(res *GithubAccountResponse, repoId int, connId uint64) 
(*models.GithubRepoAccount, errors.Error) {
+       login := res.Login
+       // Some REST endpoints return bot aliases without the usual suffix. Keep
+       // the explicit type available to conversion even without profile 
enrichment.
+       if res.Type == "Bot" && !strings.HasSuffix(login, "[bot]") {
+               login += "[bot]"
+       }
        githubAccount := &models.GithubRepoAccount{
                ConnectionId: connId,
                RepoGithubId: repoId,
-               Login:        res.Login,
+               Login:        login,
                AccountId:    res.Id,
        }
        return githubAccount, nil
diff --git a/backend/plugins/github/tasks/account_pre_extractor_test.go 
b/backend/plugins/github/tasks/account_pre_extractor_test.go
new file mode 100644
index 000000000..1617e4d9b
--- /dev/null
+++ b/backend/plugins/github/tasks/account_pre_extractor_test.go
@@ -0,0 +1,48 @@
+/*
+Licensed to the Apache Software Foundation (ASF) under one or more
+contributor license agreements.  See the NOTICE file distributed with
+this work for additional information regarding copyright ownership.
+The ASF licenses this file to You under the Apache License, Version 2.0
+(the "License"); you may not use this file except in compliance with
+the License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package tasks
+
+import (
+       "encoding/json"
+       "testing"
+
+       "github.com/stretchr/testify/assert"
+       "github.com/stretchr/testify/require"
+)
+
+func TestConvertAccountBotType(t *testing.T) {
+       for _, tc := range []struct{ name, raw, wantLogin string }{
+               {"bot alias", 
`{"login":"Copilot","id":175728472,"type":"Bot"}`, "Copilot[bot]"},
+               {"suffixed bot", 
`{"login":"copilot-pull-request-reviewer[bot]","id":175728472,"type":"Bot"}`, 
"copilot-pull-request-reviewer[bot]"},
+               {"human", `{"login":"octocat","id":583231,"type":"User"}`, 
"octocat"},
+               {"no type", `{"login":"legacy","id":1}`, "legacy"},
+       } {
+               t.Run(tc.name, func(t *testing.T) {
+                       var response GithubAccountResponse
+                       require.NoError(t, json.Unmarshal([]byte(tc.raw), 
&response))
+                       original := response
+                       account, err := convertAccount(&response, 42, 7)
+                       require.NoError(t, err)
+                       assert.Equal(t, tc.wantLogin, account.Login)
+                       assert.Equal(t, response.Id, account.AccountId)
+                       assert.Equal(t, 42, account.RepoGithubId)
+                       assert.Equal(t, uint64(7), account.ConnectionId)
+                       assert.Equal(t, original, response, "normalization must 
not mutate the API response")
+               })
+       }
+}
diff --git 
a/backend/plugins/github_graphql/tasks/account_graphql_pre_extractor.go 
b/backend/plugins/github_graphql/tasks/account_graphql_pre_extractor.go
index 6e114cb32..3be41b021 100644
--- a/backend/plugins/github_graphql/tasks/account_graphql_pre_extractor.go
+++ b/backend/plugins/github_graphql/tasks/account_graphql_pre_extractor.go
@@ -70,6 +70,7 @@ func (q *GraphqlInlineAccountQuery) Account() 
GithubAccountEdge {
 // `User`-typed field makes GitHub reject the whole query with
 // "Fragment on Bot can't be spread inside User".
 type GraphqlInlineActorQuery struct {
+       TypeName          string `graphql:"__typename"`
        GithubAccountEdge `graphql:"... on User"`
        Bot               GithubBotEdge `graphql:"... on Bot"`
 }
@@ -79,8 +80,21 @@ func (q *GraphqlInlineActorQuery) Account() 
GithubAccountEdge {
        if q == nil {
                return GithubAccountEdge{}
        }
-       if q.GithubAccountEdge.Id != 0 {
+       // The GraphQL decoder populates overlapping fields in both fragments.
+       // Only __typename identifies which fragment actually resolved.
+       switch q.TypeName {
+       case "User":
                return q.GithubAccountEdge
+       case "Bot":
+               // Normalize the bot fragment below.
+       case "":
+               // Historical raw records lack a discriminator. Preserve their 
original
+               // user-first behavior, including when both fragments are 
populated.
+               if q.GithubAccountEdge.Id != 0 {
+                       return q.GithubAccountEdge
+               }
+       default:
+               return GithubAccountEdge{}
        }
        if q.Bot.Id == 0 {
                return GithubAccountEdge{}
diff --git 
a/backend/plugins/github_graphql/tasks/account_graphql_pre_extractor_test.go 
b/backend/plugins/github_graphql/tasks/account_graphql_pre_extractor_test.go
index 4979e5523..e09ee2423 100644
--- a/backend/plugins/github_graphql/tasks/account_graphql_pre_extractor_test.go
+++ b/backend/plugins/github_graphql/tasks/account_graphql_pre_extractor_test.go
@@ -18,12 +18,16 @@ limitations under the License.
 package tasks
 
 import (
+       "context"
        "encoding/json"
+       "io"
+       "net/http"
        "strings"
        "testing"
 
        "github.com/merico-ai/graphql"
        "github.com/stretchr/testify/assert"
+       "github.com/stretchr/testify/require"
 )
 
 func TestInlineAccountQueryAccount(t *testing.T) {
@@ -95,27 +99,139 @@ func TestExtractGraphqlPreAccountSkipsUnresolvedActors(t 
*testing.T) {
        assert.Len(t, results, 1)
 }
 
-// `... on Bot` may only be spread where the schema says `Actor`; on a `User` 
field
-// GitHub rejects the whole query with "Fragment on Bot can't be spread inside 
User"
+// The client decoder fills overlapping fields in both inline fragments. 
Exercise
+// that decoder, then the same JSON round trip used by collection and 
extraction.
+func TestInlineActorQueryClientRoundTrip(t *testing.T) {
+       for _, tc := range []struct {
+               name, actorType, login, wantLogin string
+               id                                int
+       }{
+               {"copilot", "Bot", "copilot-pull-request-reviewer", 
"copilot-pull-request-reviewer[bot]", 175728472},
+               {"human", "User", "octocat", "octocat", 583231},
+               {"suffixed bot", "Bot", "renovate[bot]", "renovate[bot]", 
29139614},
+       } {
+               t.Run(tc.name, func(t *testing.T) {
+                       client := 
graphql.NewClient("https://github.invalid/graphql";, &http.Client{
+                               Transport: actorRoundTripper(func(req 
*http.Request) (*http.Response, error) {
+                                       var request struct{ Query string }
+                                       require.NoError(t, 
json.NewDecoder(req.Body).Decode(&request))
+                                       assert.Contains(t, request.Query, 
"__typename")
+                                       actor := map[string]interface{}{
+                                               "login": tc.login, 
"databaseId": tc.id,
+                                               "avatarUrl": 
"https://github.invalid/avatar";, "url": "https://github.invalid/profile";,
+                                       }
+                                       // Return only requested fields, as 
GitHub would. This also lets the
+                                       // regression expose the old accessor's 
incorrect login before the fix.
+                                       if strings.Contains(request.Query, 
"__typename") {
+                                               actor["__typename"] = 
tc.actorType
+                                       }
+                                       if tc.actorType == "User" {
+                                               actor["name"], 
actor["company"], actor["email"] = "The Octocat", "GitHub", "[email protected]"
+                                       }
+                                       body, err := 
json.Marshal(map[string]interface{}{"data": map[string]interface{}{"author": 
actor}})
+                                       require.NoError(t, err)
+                                       return &http.Response{StatusCode: 
http.StatusOK, Header: make(http.Header), Body: 
io.NopCloser(strings.NewReader(string(body)))}, nil
+                               }),
+                       })
+                       var query struct{ Author *GraphqlInlineActorQuery }
+                       dataErrors, err := client.Query(context.Background(), 
&query, nil)
+                       require.NoError(t, err)
+                       require.Empty(t, dataErrors)
+                       require.NotNil(t, query.Author)
+                       // This is the decoder behavior that hand-built 
fragment tests missed.
+                       assert.Equal(t, tc.id, 
query.Author.GithubAccountEdge.Id)
+                       assert.Equal(t, tc.id, query.Author.Bot.Id)
+                       raw, err := json.Marshal(query)
+                       require.NoError(t, err)
+                       var extracted struct{ Author *GraphqlInlineActorQuery }
+                       require.NoError(t, json.Unmarshal(raw, &extracted))
+                       account := extracted.Author.Account()
+                       assert.Equal(t, tc.wantLogin, account.Login)
+                       assert.Equal(t, tc.id, account.Id)
+                       assert.Equal(t, "https://github.invalid/avatar";, 
account.AvatarUrl)
+                       assert.Equal(t, "https://github.invalid/profile";, 
account.HtmlUrl)
+                       if tc.actorType == "User" {
+                               assert.Equal(t, "The Octocat", account.Name)
+                               assert.Equal(t, "[email protected]", 
account.Email)
+                       } else {
+                               assert.Empty(t, account.Name)
+                               assert.Empty(t, account.Email)
+                       }
+               })
+       }
+}
+
+type actorRoundTripper func(*http.Request) (*http.Response, error)
+
+func (f actorRoundTripper) RoundTrip(req *http.Request) (*http.Response, 
error) { return f(req) }
+
+func TestInlineActorQueryRawCompatibility(t *testing.T) {
+       for _, tc := range []struct {
+               name, raw string
+               want      GithubAccountEdge
+       }{
+               {"null", `null`, GithubAccountEdge{}},
+               {"unresolved", `{}`, GithubAccountEdge{}},
+               {"unsupported explicit type", 
`{"TypeName":"Organization","Login":"org","Id":1,"Bot":{"Login":"org","Id":1}}`,
 GithubAccountEdge{}},
+               {"unresolved explicit bot", 
`{"TypeName":"Bot","Login":"stale-user","Id":1}`, GithubAccountEdge{}},
+               {"explicit user selects user only", 
`{"TypeName":"User","Bot":{"Login":"stale-bot","Id":1}}`, GithubAccountEdge{}},
+               {"legacy user", `{"Login":"octocat","Id":583231}`, 
GithubAccountEdge{Login: "octocat", Id: 583231}},
+               {"legacy bot", `{"Bot":{"Login":"dependabot","Id":49699333}}`, 
GithubAccountEdge{Login: "dependabot[bot]", Id: 49699333}},
+               // Old ambiguous records keep the historical user-first 
behavior; only a
+               // fresh collection can supply the missing type discriminator.
+               {"legacy overlapping fragments", 
`{"Login":"copilot-pull-request-reviewer","Id":175728472,"Bot":{"Login":"copilot-pull-request-reviewer","Id":175728472}}`,
 GithubAccountEdge{Login: "copilot-pull-request-reviewer", Id: 175728472}},
+       } {
+               t.Run(tc.name, func(t *testing.T) {
+                       var actor *GraphqlInlineActorQuery
+                       require.NoError(t, json.Unmarshal([]byte(tc.raw), 
&actor))
+                       assert.Equal(t, tc.want, actor.Account())
+               })
+       }
+}
+
+// Bot fragments and actor type discriminators must never reach User-only 
fields.
 func TestBotFragmentOnlySpreadOnActorFields(t *testing.T) {
-       prQuery, _ := graphql.ConstructQuery(&GraphqlQueryPrWrapper{}, 
map[string]interface{}{})
-       issueQuery, _ := graphql.ConstructQuery(&GraphqlQueryIssueWrapper{}, 
map[string]interface{}{})
-
-       assert.Contains(t, prQuery, `author{... on User{`)
-       assert.Contains(t, prQuery, `... on Bot{`)
-       assert.Contains(t, issueQuery, `... on Bot{`)
-
-       // assignees and commit authors are typed `User`, they must stay 
User-only
-       for _, userField := range []string{`assignees(first: 1){nodes{`, 
`assignees(first: 100){nodes{`} {
-               if idx := strings.Index(prQuery+issueQuery, userField); idx >= 
0 {
-                       tail := (prQuery + issueQuery)[idx : idx+120]
-                       assert.NotContains(t, tail, `... on Bot`)
+       for _, query := range []interface{}{
+               &GraphqlQueryPrWrapper{}, &GraphqlQueryPrDetailWrapper{},
+               &GraphqlQueryIssueWrapper{}, &GraphqlQueryIssueDetailWrapper{},
+       } {
+               generated, _ := graphql.ConstructQuery(query, 
map[string]interface{}{
+                       "pullRequest": []map[string]interface{}{{"number": 
graphql.Int(1)}},
+                       "issue":       []map[string]interface{}{{"number": 
graphql.Int(1)}},
+               })
+               actorSelection := `{__typename,... on 
User{login,databaseId,name,company,email,avatarUrl,url},... on 
Bot{login,databaseId,avatarUrl,url}}`
+               assert.Contains(t, generated, "author"+actorSelection)
+               if strings.Contains(generated, "mergedBy") {
+                       assert.Contains(t, generated, "mergedBy"+actorSelection)
+                       // PR authors, review authors and mergedBy are all 
Actor fields.
+                       assert.Equal(t, 3, strings.Count(generated, 
actorSelection))
+               }
+               for _, prefix := range []string{"assignees(first: 1){nodes", 
"assignees(first: 100){nodes", "user"} {
+                       if strings.Contains(generated, prefix+"{") {
+                               assert.Contains(t, generated, prefix+`{... on 
User{login,databaseId,name,company,email,avatarUrl,url}}`)
+                       }
                }
        }
-       commitAuthor := `commits(first: 100){`
-       if idx := strings.Index(prQuery, commitAuthor); idx >= 0 {
-               tail := prQuery[idx : idx+400]
-               assert.Contains(t, tail, `user{... on User{`)
-               assert.NotContains(t, tail, `user{... on 
User{login,databaseId,name,company,email,avatarUrl,url},... on Bot`)
+}
+
+func TestInlineActorQueryClientUnresolved(t *testing.T) {
+       for _, actorJSON := range []string{`null`, `{}`, 
`{"__typename":"Mannequin"}`} {
+               t.Run(actorJSON, func(t *testing.T) {
+                       client := 
graphql.NewClient("https://github.invalid/graphql";, &http.Client{
+                               Transport: actorRoundTripper(func(req 
*http.Request) (*http.Response, error) {
+                                       return &http.Response{StatusCode: 
http.StatusOK, Header: make(http.Header),
+                                               Body: 
io.NopCloser(strings.NewReader(`{"data":{"author":` + actorJSON + `}}`))}, nil
+                               }),
+                       })
+                       var query struct{ Author *GraphqlInlineActorQuery }
+                       dataErrors, err := client.Query(context.Background(), 
&query, nil)
+                       require.NoError(t, err)
+                       require.Empty(t, dataErrors)
+                       raw, err := json.Marshal(query)
+                       require.NoError(t, err)
+                       var extracted struct{ Author *GraphqlInlineActorQuery }
+                       require.NoError(t, json.Unmarshal(raw, &extracted))
+                       assert.Equal(t, GithubAccountEdge{}, 
extracted.Author.Account())
+               })
        }
 }

Reply via email to