new fixture generation

Author: a1012112796

contrib/dev/dev.go

@@ -5,11 +5,13 @@ package main
 
 import (
 	"context"
+	"fmt"
 	"io/fs"
 	"net/http"
 	"os"
 	"path"
 	"path/filepath"
+	"strings"
 
 	_ "code.gitea.io/gitea/models"
 	"code.gitea.io/gitea/models/db"
@@ -19,6 +21,7 @@ import (
 	"code.gitea.io/gitea/modules/setting"
 	"code.gitea.io/gitea/modules/util"
 	"code.gitea.io/gitea/routers"
+	"code.gitea.io/gitea/routers/common"
 	"gopkg.in/yaml.v3"
 )
 
@@ -50,15 +53,82 @@ func main() {
 	<-graceful.GetManager().Done()
 	log.Info("PID: %d Gitea Web Finished", os.Getpid())
 	fixGitReops()
-	err = unittest.DumpAllFixtures()
+
+	ctxDb, cancel := context.WithCancel(context.Background())
+	err = common.InitDBEngine(ctxDb)
+	if err != nil {
+		log.Fatal("common.InitDBEngine: %v", err)
+	}
+	err = unittest.DumpAllFixtures(filepath.Join(pwd, "models", "fixtures"))
+	cancel()
+
 	if err != nil {
 		log.Fatal("unittest.DumpAllFixtures: %v", err)
 	}
 	removeNotNeededFixtures(pwd)
+	recheckFixtures(pwd)
 
 	log.GetManager().Close()
 }
 
+func buildInterfacesSlice(records interface{}) ([]interface{}, error) {
+	switch records := records.(type) {
+	case []interface{}:
+		return records, nil
+	case map[string]interface{}:
+		var result []interface{}
+		for _, record := range records {
+			result = append(result, record)
+		}
+		return result, nil
+	}
+
+	return nil, fmt.Errorf("testfixtures: fixture is not a slice or map")
+}
+
+func recheckFixtures(pathToGiteaRoot string) {
+	err := filepath.Walk(path.Join(pathToGiteaRoot, "models", "fixtures"), func(pth string, info fs.FileInfo, _ error) error {
+		if info.IsDir() {
+			return nil
+		}
+
+		fileName := path.Base(pth)
+		if !strings.HasSuffix(fileName, ".yml") {
+			return nil
+		}
+
+		log.Info("recheck %s", fileName)
+
+		content, err := os.ReadFile(pth)
+		if err != nil {
+			return err
+		}
+
+		var records interface{}
+		if err := yaml.Unmarshal(content, &records); err != nil {
+			return fmt.Errorf("could not unmarshal YAML: %w", err)
+		}
+
+		result, err := buildInterfacesSlice(records)
+		if err != nil {
+			return err
+		}
+
+		for _, record := range result {
+			_, ok := record.(map[string]interface{})
+			if !ok {
+				return fmt.Errorf("testfixtures: could not cast record: not a map[interface{}]interface{}")
+			}
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		log.Fatal("recheckFixtures: %v", err)
+	}
+}
+
 func listSubDir(dirname string, onDir func(path, name string) error) error {
 	fileInfos, err := os.ReadDir(dirname)
 	if err != nil {
@@ -228,8 +298,7 @@ func initDev(pathToGiteaRoot string) {
 
 	fixturesDir := filepath.Join(pathToGiteaRoot, "models", "fixtures")
 	if err := unittest.InitFixtures(unittest.FixturesOptions{
-		Dir:        fixturesDir,
-		InitDumper: true,
+		Dir: fixturesDir,
 	}); err != nil {
 		log.Fatal("CreateTestEngine: %+v", err)
 	}
@@ -271,6 +340,10 @@ func removeNotNeededFixtures(pathToGiteaRoot string) {
 		}
 
 		fileName := path.Base(pth)
+		if !strings.HasSuffix(fileName, ".yml") {
+			return nil
+		}
+
 		if util.SliceContains(nootNeededFixtures, fileName) {
 			return os.Remove(pth)
 		}

models/db/engine.go

@@ -299,3 +299,24 @@ func SetLogSQL(ctx context.Context, on bool) {
 		sess.Engine().ShowSQL(on)
 	}
 }
+
+func AllTablesForEach(hanle func(info *schemas.Table, bean any) error) error {
+	for _, table := range tables {
+		info, err := TableInfo(table)
+		if err != nil {
+			return err
+		}
+
+		err = hanle(info, table)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// FixtureDumper custom interface to generate a fixture file
+type FixtureDumper interface {
+	FixtureDumper(dbCtx context.Context, fd io.Writer) error
+}

models/fixture_generation.go

@@ -35,10 +35,11 @@ func GetYamlFixturesAccess() (string, error) {
 	}
 
 	for i, a := range accesses {
-		fmt.Fprintf(&b, "- id: %d\n", i+1)
-		fmt.Fprintf(&b, "  mode: %d\n", a.Mode)
-		fmt.Fprintf(&b, "  repo_id: %d\n", a.RepoID)
+		fmt.Fprintf(&b, "-\n")
+		fmt.Fprintf(&b, "  id: %d\n", i+1)
 		fmt.Fprintf(&b, "  user_id: %d\n", a.UserID)
+		fmt.Fprintf(&b, "  repo_id: %d\n", a.RepoID)
+		fmt.Fprintf(&b, "  mode: %d\n\n", a.Mode)
 	}
 
 	return b.String(), nil

models/issues/pull.go

@@ -320,6 +320,10 @@ func (pr *PullRequest) LoadRequestedReviewers(ctx context.Context) error {
 		return err
 	}
 	for _, review := range reviews {
+		if review.Type != ReviewTypeRequest {
+			continue
+		}
+
 		pr.RequestedReviewers = append(pr.RequestedReviewers, review.Reviewer)
 	}
 

models/issues/pull_test.go

@@ -88,6 +88,9 @@ func TestLoadRequestedReviewers(t *testing.T) {
 	user1, err := user_model.GetUserByID(db.DefaultContext, 1)
 	assert.NoError(t, err)
 
+	assert.NoError(t, pull.LoadRequestedReviewers(db.DefaultContext))
+	assert.Len(t, pull.RequestedReviewers, 0)
+
 	comment, err := issues_model.AddReviewRequest(db.DefaultContext, issue, user1, &user_model.User{})
 	assert.NoError(t, err)
 	assert.NotNil(t, comment)

models/issues/review.go

@@ -159,6 +159,11 @@ func (r *Review) LoadReviewer(ctx context.Context) (err error) {
 		return err
 	}
 	r.Reviewer, err = user_model.GetPossibleUserByID(ctx, r.ReviewerID)
+	if user_model.IsErrUserNotExist(err) {
+		r.Reviewer = user_model.NewGhostUser()
+		return nil
+	}
+
 	return err
 }
 

models/issues/review_list.go

@@ -33,6 +33,9 @@ func (reviews ReviewList) LoadReviewers(ctx context.Context) error {
 	}
 	for _, review := range reviews {
 		review.Reviewer = userMap[review.ReviewerID]
+		if review.Reviewer == nil {
+			review.Reviewer = user_model.NewGhostUser()
+		}
 	}
 	return nil
 }

models/issues/review_test.go

@@ -142,14 +142,19 @@ func TestGetReviewersByIssueID(t *testing.T) {
 			Reviewer:    user2,
 			Type:        issues_model.ReviewTypeReject,
 			UpdatedUnix: 946684814,
+		},
+		&issues_model.Review{
+			Reviewer:    user_model.NewGhostUser(),
+			Type:        issues_model.ReviewTypeReject,
+			UpdatedUnix: 946684815,
 		})
 
 	allReviews, err := issues_model.GetReviewsByIssueID(issue.ID)
 	assert.NoError(t, err)
 	for _, review := range allReviews {
 		assert.NoError(t, review.LoadReviewer(db.DefaultContext))
 	}
-	if assert.Len(t, allReviews, 3) {
+	if assert.Len(t, allReviews, 4) {
 		for i, review := range allReviews {
 			assert.Equal(t, expectedReviews[i].Reviewer, review.Reviewer)
 			assert.Equal(t, expectedReviews[i].Type, review.Type)
@@ -160,7 +165,7 @@ func TestGetReviewersByIssueID(t *testing.T) {
 	allReviews, err = issues_model.GetReviewsByIssueID(issue.ID)
 	assert.NoError(t, err)
 	assert.NoError(t, allReviews.LoadReviewers(db.DefaultContext))
-	if assert.Len(t, allReviews, 3) {
+	if assert.Len(t, allReviews, 4) {
 		for i, review := range allReviews {
 			assert.Equal(t, expectedReviews[i].Reviewer, review.Reviewer)
 			assert.Equal(t, expectedReviews[i].Type, review.Type)