package model

import (
	"fmt"
	"testing"
	"time"

	"github.com/pingcap/diag/pkg/models"

	"github.com/pingcap-inc/clinic/pkg/cluster"

	"github.com/onsi/gomega"

	"github.com/pingcap-inc/clinic/pkg/config"
	"github.com/pingcap-inc/clinic/pkg/db"
)

func Test_InsertUploadFileRecord(t *testing.T) {
	fileUUID := "123"
	uf := &db.UploadFile{
		FileUUID:         fileUUID,
		FileOriginalName: "1",
		Alias:            "test",
		StorageType:      string(config.AWSStorageType),
		UploadID:         "Qb9fLCuWNCNsim713mWLmDd0RzpHqImRVqdYYBInvKOv5eyvdY..9iZHraFwcbGFL0Pkbr7cKpzwPKJMVaehP.GJ9WIwXUsOHcxwvJ99VE2jLKGPlLu3T13fJLfGygY5",
		ClusterID:        "123",
	}

	err := InsertUploadFile(uf)

	g := gomega.NewGomegaWithT(t)
	g.Expect(err).To(gomega.Succeed())
}

func Test_InsertDuplicateRecord(t *testing.T) {
	fileUUID := "123"
	uf := &db.UploadFile{
		FileUUID:         fileUUID,
		FileOriginalName: "1",
		Alias:            "test",
		StorageType:      string(config.AWSStorageType),
		UploadID:         "Qb9fLCuWNCNsim713mWLmDd0RzpHqImRVqdYYBInvKOv5eyvdY..9iZHraFwcbGFL0Pkbr7cKpzwPKJMVaehP.GJ9WIwXUsOHcxwvJ99VE2jLKGPlLu3T13fJLfGygY5",
		ClusterID:        "123",
	}
	err := InsertUploadFile(uf)

	g := gomega.NewGomegaWithT(t)
	g.Expect(err).To(gomega.Succeed())

	uf = &db.UploadFile{
		FileUUID:         fileUUID,
		FileOriginalName: "1",
		Alias:            "",
		StorageType:      string(config.AWSStorageType),
		UploadID:         "Qb9fLCuWNCNsim713mWLmDd0RzpHqImRVqdYYBInvKOv5eyvdY..9iZHraFwcbGFL0Pkbr7cKpzwPKJMVaehP.GJ9WIwXUsOHcxwvJ99VE2jLKGPlLu3T13fJLfGygY5",
		ClusterID:        "123",
	}
	err = InsertUploadFile(uf)
	g = gomega.NewGomegaWithT(t)

	g.Expect(err).To(gomega.Succeed())
}

//func Test_UpdateDuplicateUploadFile(t *testing.T) {
//	fileUUID := "Test_UpdateDuplicateUploadFile"
//	err := InsertUploadFile(fileUUID, "test",123)
//
//	g := gomega.NewGomegaWithT(t)
//	g.Expect(err).To(gomega.Succeed())
//
//	g.Expect(UpdateUploadFile(fileUUID, 111)).To(gomega.Succeed())
//	g.Expect(UploadFileCompleted(fileUUID)).To(gomega.Succeed())
//
//	g.Expect(UpdateUploadFile(fileUUID, 111)).To(gomega.MatchError(fmt.Sprintf("the file is completed, file=%s", fileUUID)))
//
//}
//
//func Test_QueryEmptyFile(t *testing.T) {
//	fileUUID := "Test_QueryEmptyFile"
//	num, err := QuerySerialNumByfileUUID(fileUUID)
//
//	g := gomega.NewGomegaWithT(t)
//	g.Expect(err).To(gomega.Succeed())
//	g.Expect(num).To(gomega.Equal(0))
//}

func Test_UploadFileCompleted(t *testing.T) {
	fileUUID := "Test_UploadFileCompleted"

	uf := &db.UploadFile{
		FileUUID:         fileUUID,
		FileOriginalName: "1",
		Alias:            "test",
		StorageType:      string(config.AWSStorageType),
		UploadID:         "Qb9fLCuWNCNsim713mWLmDd0RzpHqImRVqdYYBInvKOv5eyvdY..9iZHraFwcbGFL0Pkbr7cKpzwPKJMVaehP.GJ9WIwXUsOHcxwvJ99VE2jLKGPlLu3T13fJLfGygY5",
		ClusterID:        "123",
		//"1", , "", alias, 123
	}
	err := InsertUploadFile(uf)

	g := gomega.NewGomegaWithT(t)
	g.Expect(err).To(gomega.Succeed())

	g.Expect(UploadFileCompleted(fileUUID)).To(gomega.Succeed())
}

func Test_ListFilesByAlias(t *testing.T) {
	fileUUID := "Test_ListFilesByAlias"
	alias := "Test_ListFilesByAlias"

	g := gomega.NewGomegaWithT(t)

	uf := &db.UploadFile{
		FileUUID:         fileUUID + "1",
		FileOriginalName: "1",
		Alias:            alias,
		StorageType:      string(config.AWSStorageType),
		UploadID:         "Qb9fLCuWNCNsim713mWLmDd0RzpHqImRVqdYYBInvKOv5eyvdY..9iZHraFwcbGFL0Pkbr7cKpzwPKJMVaehP.GJ9WIwXUsOHcxwvJ99VE2jLKGPlLu3T13fJLfGygY5",
		ClusterID:        "123",
		//"1", , "", alias, 123
	}
	err := InsertUploadFile(uf)
	g.Expect(err).To(gomega.Succeed())

	uf = &db.UploadFile{
		FileUUID:         fileUUID + "2",
		FileOriginalName: "1",
		Alias:            alias,
		StorageType:      string(config.AWSStorageType),
		UploadID:         "Qb9fLCuWNCNsim713mWLmDd0RzpHqImRVqdYYBInvKOv5eyvdY..9iZHraFwcbGFL0Pkbr7cKpzwPKJMVaehP.GJ9WIwXUsOHcxwvJ99VE2jLKGPlLu3T13fJLfGygY5",
		ClusterID:        "123",
	}
	err = InsertUploadFile(uf)
	g.Expect(err).To(gomega.Succeed())

	uf = &db.UploadFile{
		FileUUID:         fileUUID + "3",
		FileOriginalName: "1",
		Alias:            alias,
		StorageType:      string(config.AWSStorageType),
		UploadID:         "Qb9fLCuWNCNsim713mWLmDd0RzpHqImRVqdYYBInvKOv5eyvdY..9iZHraFwcbGFL0Pkbr7cKpzwPKJMVaehP.GJ9WIwXUsOHcxwvJ99VE2jLKGPlLu3T13fJLfGygY5",
		ClusterID:        "123",
	}
	err = InsertUploadFile(uf)
	g.Expect(err).To(gomega.Succeed())

	result, err := ListFilesByAlias("111122223333_Test_ListFilesByAlias", 3)
	g.Expect(err).To(gomega.Succeed())
	g.Expect(len(result)).To(gomega.Equal(0))

	result, err = ListFilesByAlias(alias, 2)
	g.Expect(err).To(gomega.Succeed())
	g.Expect(len(result)).To(gomega.Equal(2))
	g.Expect(result[0]).To(gomega.Equal(fileUUID + "3"))
	g.Expect(result[1]).To(gomega.Equal(fileUUID + "2"))
}

func Test_SetFileInfo(t *testing.T) {
	fileUUID := "Test_SetClusterID"
	alias := "Test_SetClusterIDByAlias"
	originalName := "test.diag"

	g := gomega.NewGomegaWithT(t)

	_, err := AddClusterIfPresent(&db.Cluster{
		ClusterID: "Test_SetFileInfo123",
		Name:      "test",
	})
	g.Expect(err).To(gomega.Succeed())

	currentTime := time.Now()
	uf := &db.UploadFile{
		FileUUID:         fileUUID,
		FileOriginalName: originalName,
		Alias:            alias,
		StorageType:      string(config.AWSStorageType),
		UploadID:         "Qb9fLCuWNCNsim713mWLmDd0RzpHqImRVqdYYBInvKOv5eyvdY..9iZHraFwcbGFL0Pkbr7cKpzwPKJMVaehP.GJ9WIwXUsOHcxwvJ99VE2jLKGPlLu3T13fJLfGygY5",
		ClusterID:        "Test_SetFileInfo123",
		BeginTime:        &currentTime,
		EndTime:          &currentTime,
	}
	err = InsertUploadFile(uf)
	g.Expect(err).To(gomega.Succeed())

	clusterInfo := cluster.ClusterInfo{
		Topology: &models.TiDBCluster{
			Version: "v999",
		},
	}
	err = UpdateFileInfoAfterSubmitRebuild(fileUUID, &clusterInfo)
	g.Expect(err).To(gomega.Succeed())

	f, err := QueryUploadFile(fileUUID)
	g.Expect(err).To(gomega.Succeed())
	g.Expect(f.FileOriginalName).To(gomega.Equal(originalName + ".tar.zst"))

	cluster, err := GetCluster("Test_SetFileInfo123")
	g.Expect(err).To(gomega.Succeed())
	g.Expect(cluster.Version).To(gomega.Equal("v999"))
}

func Test_SetClusterIDWithZst(t *testing.T) {
	fileUUID := "Test_SetClusterIDWithZst"
	alias := "Test_SetClusterIDWithZstByAlias"
	originalName := "Test_SetClusterIDWithZst.zst"

	g := gomega.NewGomegaWithT(t)
	startTime, err := time.Parse("2006-01-02 15:04:05", "2017-04-11 15:01:37")
	g.Expect(err).To(gomega.Succeed())
	endTime, err := time.Parse("2006-01-02 15:04:05", "2017-04-12 12:01:37")
	g.Expect(err).To(gomega.Succeed())
	uf := &db.UploadFile{
		FileUUID:         fileUUID,
		FileOriginalName: originalName,
		Alias:            alias,
		StorageType:      string(config.AWSStorageType),
		UploadID:         "Qb9fLCuWNCNsim713mWLmDd0RzpHqImRVqdYYBInvKOv5eyvdY..9iZHraFwcbGFL0Pkbr7cKpzwPKJMVaehP.GJ9WIwXUsOHcxwvJ99VE2jLKGPlLu3T13fJLfGygY5",
		ClusterID:        "Test_01_0",
		BeginTime:        &startTime,
		EndTime:          &endTime,
	}
	err = InsertUploadFile(uf)
	g.Expect(err).To(gomega.Succeed())

	clusterInfo := cluster.ClusterInfo{
		Topology: &models.TiDBCluster{
			Version: "v5",
		},
	}
	err = UpdateFileInfoAfterSubmitRebuild(fileUUID, &clusterInfo)
	g.Expect(err).To(gomega.Succeed())

	f, err := QueryUploadFile(fileUUID)
	g.Expect(err).To(gomega.Succeed())
	g.Expect(f.FileOriginalName).To(gomega.Equal(originalName))
}

func Test_SetClusterIDWithTar(t *testing.T) {
	fileUUID := "Test_SetClusterIDWithTar"
	alias := "Test_SetClusterIDWithZstByAlias"
	originalName := "Test_SetClusterIDWithTar.tar"

	g := gomega.NewGomegaWithT(t)

	startTime, err := time.Parse("2006-01-02 15:04:05", "2017-04-11 15:01:37")
	g.Expect(err).To(gomega.Succeed())
	endTime, err := time.Parse("2006-01-02 15:04:05", "2017-04-12 12:01:37")
	g.Expect(err).To(gomega.Succeed())
	uf := &db.UploadFile{
		FileUUID:         fileUUID,
		FileOriginalName: originalName,
		Alias:            alias,
		StorageType:      string(config.AWSStorageType),
		UploadID:         "Qb9fLCuWNCNsim713mWLmDd0RzpHqImRVqdYYBInvKOv5eyvdY..9iZHraFwcbGFL0Pkbr7cKpzwPKJMVaehP.GJ9WIwXUsOHcxwvJ99VE2jLKGPlLu3T13fJLfGygY5",
		ClusterID:        "Test_01_0",
		BeginTime:        &startTime,
		EndTime:          &endTime,
	}

	err = InsertUploadFile(uf)
	g.Expect(err).To(gomega.Succeed())

	clusterInfo := cluster.ClusterInfo{
		Topology: &models.TiDBCluster{
			Version: "V",
		},
	}
	err = UpdateFileInfoAfterSubmitRebuild(fileUUID, &clusterInfo)
	g.Expect(err).To(gomega.Succeed())

	f, err := QueryUploadFile(fileUUID)
	g.Expect(err).To(gomega.Succeed())
	g.Expect(f.FileOriginalName).To(gomega.Equal(originalName + ".zst"))
}

func Test_ListPackages(t *testing.T) {
	g := gomega.NewGomegaWithT(t)

	b1 := time.Unix(1647927192, 0)
	e1 := time.Unix(1647928192, 0)
	uf := &db.UploadFile{
		FileUUID:         "Test_ListPackages1",
		FileOriginalName: "1",
		Alias:            "test",
		StorageType:      string(config.AWSStorageType),
		UploadID:         "Qb9fLCuWNCNsim713mWLmDd0RzpHqImRVqdYYBInvKOv5eyvdY..9iZHraFwcbGFL0Pkbr7cKpzwPKJMVaehP.GJ9WIwXUsOHcxwvJ99VE2jLKGPlLu3T13fJLfGygY5",
		ClusterID:        "Test_ListPackages",
		BeginTime:        &b1,
		EndTime:          &e1,
		OrgID:            1111,
		UploadStatus:     string(db.StatusSuccess),
	}
	err := InsertUploadFile(uf)
	g.Expect(err).To(gomega.Succeed())

	b2 := time.Unix(1647921192, 0)
	e2 := time.Unix(1647925192, 0)
	uf = &db.UploadFile{
		FileUUID:         "Test_ListPackages2",
		FileOriginalName: "1",
		Alias:            "test",
		StorageType:      string(config.AWSStorageType),
		UploadID:         "Qb9fLCuWNCNsim713mWLmDd0RzpHqImRVqdYYBInvKOv5eyvdY..9iZHraFwcbGFL0Pkbr7cKpzwPKJMVaehP.GJ9WIwXUsOHcxwvJ99VE2jLKGPlLu3T13fJLfGygY5",
		ClusterID:        "Test_ListPackages",
		BeginTime:        &b2,
		EndTime:          &e2,
		OrgID:            1111,
		UploadStatus:     string(db.StatusSuccess),
	}
	err = InsertUploadFile(uf)
	g.Expect(err).To(gomega.Succeed())

	files, total, err := ListUploadFiles(1111, "Test_ListPackages", 0, 0, 1647921192, 1647923192)
	g.Expect(err).To(gomega.Succeed())
	g.Expect(len(files)).To(gomega.Equal(1))
	g.Expect(files[0].FileUUID).To(gomega.Equal("Test_ListPackages2"))
	g.Expect(int(total)).To(gomega.Equal(len(files)))

	files, total, err = ListUploadFiles(1111, "Test_ListPackages", 0, 0, 1647921192, 1647926192)
	g.Expect(err).To(gomega.Succeed())
	g.Expect(len(files)).To(gomega.Equal(1))
	g.Expect(files[0].FileUUID).To(gomega.Equal("Test_ListPackages2"))
	g.Expect(int(total)).To(gomega.Equal(len(files)))

	files, total, err = ListUploadFiles(1111, "Test_ListPackages", 0, 0, 1647921192, 1647928192)
	g.Expect(err).To(gomega.Succeed())
	g.Expect(len(files)).To(gomega.Equal(2))
	g.Expect(int(total)).To(gomega.Equal(len(files)))
}

func Test_ListUploadFilesInOrg(t *testing.T) {
	g := gomega.NewGomegaWithT(t)

	now := time.Unix(1647927192, 0)

	orgID := uint(1231231321)

	c, err := AddClusterIfPresent(&db.Cluster{
		ClusterID: "Test_ListUploadFilesInOrg",
	})
	g.Expect(err).To(gomega.Succeed())

	for i := 0; i < 20; i++ {
		uf := &db.UploadFile{
			FileUUID:         fmt.Sprintf("Test_ListUploadFilesInOrg%d", i),
			FileOriginalName: "1",
			Alias:            "test",
			OrgID:            1231231321,
			Creator:          orgID,
			ClusterID:        c.ClusterID,
			BeginTime:        &now,
			EndTime:          &now,
		}

		err := InsertUploadFile(uf)
		g.Expect(err).To(gomega.Succeed())

		time.Sleep(time.Microsecond * 100)
	}

	for i := 0; i < 12; i++ {
		err = UploadFileCompleted(fmt.Sprintf("Test_ListUploadFilesInOrg%d", i))
		g.Expect(err).To(gomega.Succeed())
	}

	updatedByFiles, err := ListUploadFilesInOrg(orgID, orgID, 5, SortedByUpdatedAt, true, true, true)
	g.Expect(err).To(gomega.Succeed())
	g.Expect(len(updatedByFiles)).To(gomega.Equal(0))
	clusterInfo := cluster.ClusterInfo{
		Topology: &models.TiDBCluster{
			Version: "v5",
		},
	}
	for i := 9; i < 14; i++ {
		err = UpdateFileInfoAfterSubmitRebuild(fmt.Sprintf("Test_ListUploadFilesInOrg%d", i), &clusterInfo)
		g.Expect(err).To(gomega.Succeed())
		time.Sleep(time.Microsecond * 100)
	}

	updatedByFiles, err = ListUploadFilesInOrg(orgID, orgID, 5, SortedByUpdatedAt, true, true, true)
	g.Expect(err).To(gomega.Succeed())
	g.Expect(len(updatedByFiles)).To(gomega.Equal(3))

	for i := 0; i < 3; i++ {
		g.Expect(updatedByFiles[i].FileUUID).To(gomega.Equal(fmt.Sprintf("Test_ListUploadFilesInOrg%d", 11-i)))
	}

	createdByFiles, err := ListUploadFilesInOrg(orgID, orgID, 5, SortedByCreatedAt, false, false, false)
	g.Expect(err).To(gomega.Succeed())
	g.Expect(len(createdByFiles)).To(gomega.Equal(5))

	for i := 0; i < 5; i++ {
		g.Expect(createdByFiles[i].FileUUID).To(gomega.Equal(fmt.Sprintf("Test_ListUploadFilesInOrg%d", 19-i)))
	}
}

func Test_CalFileTotalBytesByClusterID(t *testing.T) {
	g := gomega.NewGomegaWithT(t)

	b1 := time.Unix(1647927192, 0)
	e1 := time.Unix(1647928192, 0)
	uf1 := &db.UploadFile{
		FileUUID:         "Test_CalFileTotalPackages1",
		FileOriginalName: "1",
		Alias:            "test",
		StorageType:      string(config.AWSStorageType),
		UploadID:         "Qb9fLCuWNCNsim713mWLmDd0RzpHqImRVqdYYBInvKOv5eyvdY..9iZHraFwcbGFL0Pkbr7cKpzwPKJMVaehP.GJ9WIwXUsOHcxwvJ99VE2jLKGPlLu3T13fJLfGygY5",
		ClusterID:        "Test_CalFileTotalPackages",
		BeginTime:        &b1,
		EndTime:          &e1,
		OrgID:            1111,
		FileLen:          1024,
		UploadStatus:     "running",
	}
	err := InsertUploadFile(uf1)
	g.Expect(err).To(gomega.Succeed())
	b2 := time.Unix(1647921192, 0)
	e2 := time.Unix(1647925192, 0)
	uf2 := &db.UploadFile{
		FileUUID:         "Test_CalFileTotalPackages2",
		FileOriginalName: "1",
		Alias:            "test",
		StorageType:      string(config.AWSStorageType),
		UploadID:         "Qb9fLCuWNCNsim713mWLmDd0RzpHqImRVqdYYBInvKOv5eyvdY..9iZHraFwcbGFL0Pkbr7cKpzwPKJMVaehP.GJ9WIwXUsOHcxwvJ99VE2jLKGPlLu3T13fJLfGygY5",
		ClusterID:        "Test_CalFileTotalPackages",
		BeginTime:        &b2,
		EndTime:          &e2,
		OrgID:            1111,
		FileLen:          2048,
		UploadStatus:     "success",
	}
	err = InsertUploadFile(uf2)
	g.Expect(err).To(gomega.Succeed())

	b3 := time.Unix(1647921192, 0)
	e3 := time.Unix(1647925192, 0)
	uf3 := &db.UploadFile{
		FileUUID:         "Test_CalFileTotalPackages3",
		FileOriginalName: "1",
		Alias:            "test",
		StorageType:      string(config.AWSStorageType),
		UploadID:         "Qb9fLCuWNCNsim713mWLmDd0RzpHqImRVqdYYBInvKOv5eyvdY..9iZHraFwcbGFL0Pkbr7cKpzwPKJMVaehP.GJ9WIwXUsOHcxwvJ99VE2jLKGPlLu3T13fJLfGygY5",
		ClusterID:        "Test_CalFileTotalPackages",
		BeginTime:        &b3,
		EndTime:          &e3,
		OrgID:            1111,
		FileLen:          4096,
		UploadStatus:     "running",
	}
	err = InsertUploadFile(uf3)
	g.Expect(err).To(gomega.Succeed())
	totalInBytes, err := FetchTotalClusterDataSize("Test_CalFileTotalPackages")
	g.Expect(err).To(gomega.Succeed())
	g.Expect(totalInBytes).To(gomega.Equal(uint64(7168)))

	file, found, err := FindOldestCompletedFileByClusterID("Test_CalFileTotalPackages")
	g.Expect(err).To(gomega.Succeed())
	g.Expect(found).To(gomega.BeTrue())
	g.Expect(file.FileUUID).To(gomega.Equal("Test_CalFileTotalPackages2"))
}

func TestListUploadFilesAndReportInCluster(t *testing.T) {
	type Result struct {
		FileUUID   string
		ReportUUID string
		Status     string
	}
	type listOption struct {
		ClusterID string

		Res     []Result
		uf1     *db.UploadFile
		Report1 *db.HealthReport

		uf2     *db.UploadFile
		Report2 *db.HealthReport

		uf3 *db.UploadFile

		beginTime time.Time
		endTime   time.Time
	}

	loc, _ := time.LoadLocation("Asia/Shanghai")
	beginTime, _ := time.ParseInLocation("2006-01-02 15:04:05", "2018-07-11 15:07:51", loc)
	endTime, _ := time.ParseInLocation("2006-01-02 15:04:05", "2018-07-10 15:07:51", loc)
	uf1 := db.UploadFile{
		FileUUID:         "Test_ListUpload1",
		FileOriginalName: "Test_ListUpload1",
		Alias:            "Test_ListUpload1",
		StorageType:      string(config.AWSStorageType),
		UploadID:         "Test_ListUpload1",
		ClusterID:        "123",
		BeginTime:        formatTime(beginTime.Add(time.Duration(2) * time.Hour)),
		EndTime:          formatTime(endTime.Add(time.Duration(-2) * time.Hour)),
		OrgID:            1111,
		FileLen:          4096,
		UploadStatus:     string(db.StatusSuccess),
	}
	report1 := db.HealthReport{
		ReportUUID: "Test_ListUpload1",
		FileUUID:   "Test_ListUpload1",
		Status:     "running",
	}

	uf2 := db.UploadFile{
		FileUUID:         "Test_ListUpload2",
		FileOriginalName: "Test_ListUpload2",
		Alias:            "Test_ListUpload2",
		StorageType:      string(config.AWSStorageType),
		UploadID:         "Test_ListUpload2",
		ClusterID:        "123",
		BeginTime:        formatTime(beginTime.Add(time.Duration(-2) * time.Hour)),
		EndTime:          formatTime(endTime.Add(time.Duration(2) * time.Hour)),
		OrgID:            1111,
		FileLen:          4096,
		UploadStatus:     string(db.StatusSuccess),
	}
	report2 := db.HealthReport{
		ReportUUID: "Test_ListUpload2",
		FileUUID:   "Test_ListUpload2",
		Status:     "success",
	}

	uf3 := db.UploadFile{
		FileUUID:         "Test_ListUpload3",
		FileOriginalName: "Test_ListUpload3",
		Alias:            "Test_ListUpload3",
		StorageType:      string(config.AWSStorageType),
		UploadID:         "Test_ListUpload3",
		ClusterID:        "123",
		BeginTime:        formatTime(beginTime.Add(time.Duration(2) * time.Hour)),
		EndTime:          formatTime(endTime.Add(time.Duration(-2) * time.Hour)),
		OrgID:            1111,
		FileLen:          4096,
		UploadStatus:     string(db.StatusSuccess),
	}

	testList := func(lo listOption) {
		if err := InsertUploadFile(lo.uf1); err != nil {
			t.Error("insertUpload file failed", err)
			return
		}
		if err := InsertUploadFile(lo.uf2); err != nil {
			t.Error("insertUpload file failed", err)
			return
		}
		if err := InsertUploadFile(lo.uf3); err != nil {
			t.Error("insertUpload file failed", err)
			return
		}

		if err := InsertOrUpdateReport(lo.Report1); err != nil {
			t.Error("insert report", err)
			return
		}
		if err := InsertOrUpdateReport(lo.Report2); err != nil {
			t.Error("insert report", err)
			return
		}

		if err := ListUploadFilesAndReportInCluster(lo.ClusterID, beginTime, endTime, &lo.Res); err != nil {
			t.Error("list upload file failed", err)
			return
		}

		if len(lo.Res) != 3 {
			t.Error("got res wrong", lo.Res)
			return
		}
		t.Log(lo.Res)
	}

	testList(listOption{
		ClusterID: "123",

		Res:     make([]Result, 0),
		uf1:     &uf1,
		Report1: &report1,

		uf2:     &uf2,
		Report2: &report2,

		uf3:       &uf3,
		beginTime: beginTime,
		endTime:   endTime,
	})
}

func formatTime(t time.Time) *time.Time {
	return &t
}