666 lines
21 KiB
Go
666 lines
21 KiB
Go
package tests
|
||
|
||
//import (
|
||
// "context"
|
||
// "github.com/pioz/faker"
|
||
// "math"
|
||
// "math/rand"
|
||
// "penahub.gitlab.yandexcloud.net/backend/quiz/common.git/dal"
|
||
// "penahub.gitlab.yandexcloud.net/backend/quiz/common.git/model"
|
||
// "penahub.gitlab.yandexcloud.net/backend/quiz/common.git/repository/quiz"
|
||
// "penahub.gitlab.yandexcloud.net/backend/quiz/common.git/repository/result"
|
||
// "penahub.gitlab.yandexcloud.net/backend/quiz/core.git/clients/auth"
|
||
//
|
||
// //"database/sql"
|
||
// "fmt"
|
||
// "testing"
|
||
// "time"
|
||
//
|
||
// "github.com/stretchr/testify/assert"
|
||
// bdd "github.com/themakers/bdd"
|
||
//)
|
||
//
|
||
//const baseURL = "http://localhost:"
|
||
//const authClientUrl = "test.com"
|
||
//const postgresCred string = "host=localhost port=35432 user=squiz password=Redalert2 dbname=squiz sslmode=disable"
|
||
//const appPort = "1488"
|
||
//const storerPort = "1489"
|
||
//const answererPort = "1490"
|
||
//const healthChecksPort = "5489"
|
||
//
|
||
//var types4testing = []string{
|
||
// model.TypeVariant,
|
||
// model.TypeImages,
|
||
// model.TypeVarImages,
|
||
// model.TypeFile,
|
||
// model.TypeText,
|
||
// model.TypeEmoji,
|
||
// model.TypeSelect,
|
||
// model.TypeDate,
|
||
// model.TypeNumber,
|
||
// model.TypePage,
|
||
// model.TypeRating,
|
||
//}
|
||
//
|
||
//func TestDAL(t *testing.T) {
|
||
// //login := "D" + strconv.FormatInt(time.Now().Unix(), 10)
|
||
// //token := registerUser(login)
|
||
// //
|
||
// //m, ok := token.Claims.(jwt.MapClaims)
|
||
// //if !ok {
|
||
// // panic("malformed JWT")
|
||
// //}
|
||
// //
|
||
// //id, ok := m["id"].(string)
|
||
// //if !ok || id == "" {
|
||
// // panic("missing id claim in JWT")
|
||
// //}
|
||
//
|
||
// id := "123"
|
||
//
|
||
// ctx := context.Background()
|
||
// authClient := auth.NewAuthClient(authClientUrl)
|
||
// fmt.Println(id)
|
||
//
|
||
// bdd.Scenario(t, "DAL testing", func(t *testing.T, runID string) {
|
||
// var (
|
||
// err error
|
||
// d *dal.DAL
|
||
// records []model.Quiz
|
||
// questions []model.Question
|
||
// answersSession string
|
||
// )
|
||
// bdd.Act(t, "Postgres Tables Creating", func() {
|
||
//
|
||
// bdd.Test(t, "test dbconnect", func() {
|
||
// d, err = dal.New(ctx, postgresCred, authClient)
|
||
// assert.NoError(t, err, nil)
|
||
// assert.NotNil(t, d, nil)
|
||
// })
|
||
//
|
||
// //bdd.Test(t, "positive test of table creating", func() {
|
||
// // err = d.Init()
|
||
// // assert.NoError(t, err, nil)
|
||
// //})
|
||
// //
|
||
// //bdd.Test(t, "negative test of table creating", func() {
|
||
// // err = d.Init()
|
||
// // assert.NoError(t, err, nil)
|
||
// //})
|
||
// })
|
||
//
|
||
// bdd.Act(t, "create quiz testing", func() {
|
||
// record := model.Quiz{
|
||
// AccountId: id,
|
||
// Fingerprinting: true,
|
||
// Repeatable: true,
|
||
// NotePrevented: true,
|
||
// MailNotifications: true,
|
||
// UniqueAnswers: true,
|
||
// Name: "test",
|
||
// Description: "test",
|
||
// Config: `{"Mailing": {"When": "test","Theme": "Quiz test","Reply": "test","ReplName": "test"}}`,
|
||
// Status: model.StatusDraft,
|
||
// Limit: 100,
|
||
// DueTo: uint64(time.Now().Add(time.Hour).Unix()),
|
||
// TimeOfPassing: 60,
|
||
// Pausable: true,
|
||
// GroupId: 2,
|
||
// }
|
||
// statuses4creating := []string{
|
||
// model.StatusDraft,
|
||
// model.StatusStart,
|
||
// model.StatusStop,
|
||
// model.StatusOffLimit,
|
||
// model.StatusTimeout,
|
||
// model.StatusTemplate,
|
||
// }
|
||
//
|
||
// for i := 0; i < 100; i++ {
|
||
//
|
||
// record2 := model.Quiz{
|
||
// AccountId: id,
|
||
// Fingerprinting: true,
|
||
// Repeatable: true,
|
||
// NotePrevented: true,
|
||
// MailNotifications: true,
|
||
// UniqueAnswers: true,
|
||
// Name: record.Name + fmt.Sprint(i),
|
||
// Description: "test",
|
||
// Config: `{"Mailing": {"When": "test","Theme": "Quiz test","Reply": "test","ReplName": "test"}}`,
|
||
// Status: statuses4creating[rand.Intn(len(statuses4creating))],
|
||
// Limit: 100,
|
||
// DueTo: uint64(time.Now().Add(time.Hour).Unix()),
|
||
// ParentIds: []int32{},
|
||
// TimeOfPassing: 60,
|
||
// Pausable: true,
|
||
// GroupId: 1,
|
||
// }
|
||
//
|
||
// bdd.Test(t, "positive quiz storing", func() {
|
||
// err := d.QuizRepo.CreateQuiz(ctx, &record2)
|
||
// assert.NoError(t, err, nil)
|
||
// assert.NotZero(t, record2.Id, nil)
|
||
// assert.NotEqual(t, record2.CreatedAt, nil)
|
||
// assert.NotEqual(t, record2.UpdatedAt, nil)
|
||
// records = append(records, record2)
|
||
// })
|
||
// }
|
||
//
|
||
// for i := 0; i < len(records)-1; i++ {
|
||
// if records[i].Status == model.StatusStart {
|
||
//
|
||
// bdd.Test(t, "get quiz by qid", func() {
|
||
// qu, err := d.QuizRepo.GetQuizByQid(ctx, records[i].Qid)
|
||
// assert.Equal(t, records[i].Id, qu.Id)
|
||
// assert.NoError(t, err, nil)
|
||
// })
|
||
// }
|
||
//
|
||
// bdd.Test(t, "get quiz by id", func() {
|
||
// qu, err := d.QuizRepo.GetQuizById(ctx, id, records[i].Id)
|
||
// assert.Equal(t, records[i].Id, qu.Id)
|
||
// assert.Equal(t, records[i].Qid, qu.Qid)
|
||
// assert.NoError(t, err, nil)
|
||
// })
|
||
//
|
||
// bdd.Test(t, "get quiz config", func() {
|
||
// _, _, err := d.QuizRepo.GetQuizConfig(ctx, records[i].Id)
|
||
// assert.NoError(t, err, nil)
|
||
// })
|
||
// }
|
||
//
|
||
// for i := 0; i < len(records)%80; i++ {
|
||
// bdd.Test(t, "update quiz", func() {
|
||
// updquiz := model.Quiz{
|
||
// Id: records[i].Id,
|
||
// Qid: records[i].Qid,
|
||
// AccountId: id,
|
||
// Deleted: records[i].Deleted,
|
||
// Archived: records[i].Archived,
|
||
// Fingerprinting: records[i].Fingerprinting,
|
||
// Repeatable: records[i].Repeatable,
|
||
// NotePrevented: records[i].NotePrevented,
|
||
// MailNotifications: records[i].MailNotifications,
|
||
// UniqueAnswers: records[i].UniqueAnswers,
|
||
// Name: faker.String() + records[i].Name,
|
||
// Description: faker.String() + records[i].Description,
|
||
// Config: faker.String() + records[i].Config,
|
||
// Status: records[i].Status,
|
||
// Limit: records[i].Limit,
|
||
// DueTo: records[i].DueTo,
|
||
// TimeOfPassing: records[i].TimeOfPassing,
|
||
// Pausable: records[i].Pausable,
|
||
// Version: records[i].Version,
|
||
// VersionComment: records[i].VersionComment,
|
||
// ParentIds: records[i].ParentIds,
|
||
// CreatedAt: records[i].CreatedAt,
|
||
// UpdatedAt: records[i].UpdatedAt,
|
||
// QuestionsCount: records[i].QuestionsCount,
|
||
// SessionCount: records[i].SessionCount,
|
||
// PassedCount: records[i].PassedCount,
|
||
// AverageTime: records[i].AverageTime,
|
||
// Super: records[i].Super,
|
||
// GroupId: records[i].GroupId,
|
||
// }
|
||
// err := d.QuizRepo.UpdateQuiz(ctx, id, updquiz)
|
||
// assert.NoError(t, err, nil)
|
||
// })
|
||
// bdd.Test(t, "move to history quiz", func() {
|
||
// qu, err := d.QuizRepo.MoveToHistoryQuiz(ctx, records[i].Id, id)
|
||
// assert.Equal(t, records[i].Id+100, qu.Id)
|
||
// assert.NoError(t, err, nil)
|
||
// })
|
||
// }
|
||
//
|
||
// bdd.Test(t, "negative test quiz storing1", func() {
|
||
// record.Name = faker.StringWithSize(300)
|
||
// err := d.QuizRepo.CreateQuiz(ctx, &record)
|
||
// assert.Error(t, err, nil)
|
||
// })
|
||
//
|
||
// bdd.Test(t, "negative test quiz storing2", func() {
|
||
// record.Status = model.StatusTemplate
|
||
// err := d.QuizRepo.CreateQuiz(ctx, &record)
|
||
// assert.Error(t, err, nil)
|
||
// })
|
||
// })
|
||
//
|
||
// bdd.Act(t, "get list of quizes", func() {
|
||
// bdd.Test(t, "get list of quizes", func() {
|
||
// res, _, err := d.QuizRepo.GetQuizList(ctx, quiz.GetQuizListDeps{
|
||
// Limit: 10,
|
||
// Offset: 0,
|
||
// From: 0,
|
||
// To: 0,
|
||
// Group: 0,
|
||
// Deleted: false,
|
||
// Archived: false,
|
||
// Super: true,
|
||
// Search: "",
|
||
// Status: "",
|
||
// AccountId: id,
|
||
// })
|
||
// assert.NoError(t, err, nil)
|
||
// assert.Equal(t, 0, len(res), nil)
|
||
// //assert.Greater(t, cnt, uint64(0), nil)
|
||
// })
|
||
// })
|
||
//
|
||
// bdd.Act(t, "create question testing", func() {
|
||
// quix4filling := records[rand.Intn(len(records))]
|
||
// for _, questionType := range types4testing {
|
||
// bdd.Test(t, fmt.Sprintf("positive question creating: %s", questionType), func() {
|
||
// question := model.Question{
|
||
// Id: 0,
|
||
// QuizId: quix4filling.Id,
|
||
// Title: "testNone",
|
||
// Description: "sample text",
|
||
// Type: questionType,
|
||
// Required: true,
|
||
// Deleted: false,
|
||
// Page: 0,
|
||
// Content: "test",
|
||
// Version: 0,
|
||
// ParentIds: nil,
|
||
// CreatedAt: time.Now(),
|
||
// UpdatedAt: time.Now(),
|
||
// }
|
||
// err := d.QuestionRepo.CreateQuestion(ctx, &question)
|
||
// assert.NoError(t, err, nil)
|
||
// assert.NotZero(t, question.Id, nil)
|
||
// questions = append(questions, question)
|
||
//
|
||
// bdd.Test(t, "get question list", func() {
|
||
// ques, count, err := d.QuestionRepo.GetQuestionList(ctx, 0, 10, 1226358000, 1289430000, quix4filling.Id, false, true, "", questionType)
|
||
// fmt.Println(ques)
|
||
// fmt.Println(count)
|
||
// assert.NoError(t, err, nil)
|
||
// })
|
||
// })
|
||
// }
|
||
//
|
||
// bdd.Test(t, "test create answers", func() {
|
||
// testanswers := make([]model.Answer, 0)
|
||
// for i := 0; i < 15; i++ {
|
||
// recAns := model.Answer{
|
||
// Content: "test",
|
||
// QuestionId: questions[0].Id,
|
||
// Result: false,
|
||
// Email: faker.String(),
|
||
// QuizId: faker.Uint64(),
|
||
// }
|
||
// testanswers = append(testanswers, recAns)
|
||
// }
|
||
// answersSession = faker.String()
|
||
//
|
||
// anss, err := d.AnswerRepo.CreateAnswers(ctx, testanswers, answersSession, "seeeeeeeesssion", questions[0].QuizId)
|
||
// if len(err) != 0 {
|
||
// assert.NoError(t, err[0], nil)
|
||
// }
|
||
//
|
||
// if len(anss) != len(testanswers) {
|
||
// panic("test create answers crushed")
|
||
// }
|
||
// })
|
||
//
|
||
// bdd.Test(t, "Get All Answers By Quiz ID(session)", func() {
|
||
// ansss, err := d.AnswerRepo.GetAllAnswersByQuizID(ctx, answersSession)
|
||
// assert.NoError(t, err, nil)
|
||
// assert.Equal(t, 1, len(ansss))
|
||
// })
|
||
//
|
||
// bdd.Test(t, "update question", func() {
|
||
// for i := 0; i < len(questions)%80; i++ {
|
||
//
|
||
// bdd.Test(t, "get question title", func() {
|
||
// title, tipe, err := d.QuestionRepo.GetQuestionTitleByID(ctx, questions[i].Id)
|
||
// assert.NoError(t, err, nil)
|
||
// assert.Equal(t, questions[i].Title, title)
|
||
// assert.Equal(t, questions[i].Type, tipe)
|
||
// })
|
||
//
|
||
// updateques := model.Question{
|
||
// Id: questions[i].Id,
|
||
// QuizId: questions[i].QuizId,
|
||
// Title: faker.String() + questions[i].Title,
|
||
// Description: faker.String() + questions[i].Description,
|
||
// Type: questions[i].Type,
|
||
// Required: questions[i].Required,
|
||
// Deleted: questions[i].Deleted,
|
||
// Page: questions[i].Page,
|
||
// Content: faker.String() + questions[i].Content,
|
||
// Version: questions[i].Version,
|
||
// ParentIds: questions[i].ParentIds,
|
||
// CreatedAt: questions[i].CreatedAt,
|
||
// UpdatedAt: questions[i].UpdatedAt,
|
||
// }
|
||
//
|
||
// err := d.QuestionRepo.UpdateQuestion(ctx, updateques)
|
||
// assert.NoError(t, err, nil)
|
||
//
|
||
// bdd.Test(t, "move to history question", func() {
|
||
// que, err := d.QuestionRepo.MoveToHistoryQuestion(ctx, questions[i].Id)
|
||
// assert.NoError(t, err, nil)
|
||
// assert.Equal(t, questions[i].Id+11, que.Id)
|
||
// })
|
||
// }
|
||
// })
|
||
//
|
||
// bdd.Test(t, "negative question creating: overflow title", func() {
|
||
// question := model.Question{
|
||
// Id: 0,
|
||
// QuizId: quix4filling.Id,
|
||
// Title: faker.StringWithSize(1024),
|
||
// Description: "sample text",
|
||
// Type: model.TypeText,
|
||
// Required: true,
|
||
// Deleted: false,
|
||
// Page: 0,
|
||
// Content: "test",
|
||
// Version: 0,
|
||
// ParentIds: nil,
|
||
// CreatedAt: time.Time{},
|
||
// UpdatedAt: time.Time{},
|
||
// }
|
||
// err := d.QuestionRepo.CreateQuestion(ctx, &question)
|
||
// assert.Error(t, err, nil)
|
||
// })
|
||
// bdd.Test(t, "negative question creating: invalid status", func() {
|
||
// question := model.Question{
|
||
// Id: 0,
|
||
// QuizId: quix4filling.Id,
|
||
// Title: `testNonete`,
|
||
// Description: "sample text",
|
||
// Type: "test",
|
||
// Required: true,
|
||
// Deleted: true,
|
||
// Page: 0,
|
||
// Content: "test",
|
||
// Version: 0,
|
||
// ParentIds: nil,
|
||
// CreatedAt: time.Time{},
|
||
// UpdatedAt: time.Time{},
|
||
// }
|
||
// err := d.QuestionRepo.CreateQuestion(ctx, &question)
|
||
// assert.Error(t, err, nil)
|
||
// })
|
||
// })
|
||
//
|
||
// bdd.Act(t, "edit some questions", func() {
|
||
// bdd.Test(t, "positive delete question", func() {
|
||
// question, err := d.QuestionRepo.DeleteQuestion(ctx, questions[0].Id)
|
||
// assert.NoError(t, err)
|
||
// assert.True(t, question.Deleted)
|
||
// questions[0] = question
|
||
// })
|
||
// bdd.Test(t, "negative delete question", func() {
|
||
// question, err := d.QuestionRepo.DeleteQuestion(ctx, math.MaxUint64)
|
||
// assert.Error(t, err)
|
||
// assert.Zero(t, question.Id)
|
||
// })
|
||
// bdd.Test(t, "positive create new version of question", func() {
|
||
// questions[0].Deleted = true
|
||
// questions[0].Version += 1
|
||
// questions[0].ParentIds = append(questions[0].ParentIds, int32(questions[0].Id))
|
||
// questions[0].Title = faker.StringWithSize(100)
|
||
//
|
||
// err := d.QuestionRepo.CreateQuestion(ctx, &questions[0])
|
||
// assert.NoError(t, err)
|
||
// })
|
||
// })
|
||
//
|
||
// bdd.Act(t, "edit some quizes", func() {
|
||
// bdd.Test(t, "positive delete quiz", func() {
|
||
// quiz, err := d.QuizRepo.DeleteQuiz(ctx, id, records[0].Id)
|
||
// fmt.Println(quiz)
|
||
// assert.NoError(t, err)
|
||
// assert.True(t, quiz.Deleted)
|
||
// records[0].Id = quiz.Id
|
||
// })
|
||
// bdd.Test(t, "negative delete question", func() {
|
||
// quiz, err := d.QuizRepo.DeleteQuiz(ctx, id, math.MaxUint64)
|
||
// assert.Error(t, err)
|
||
// assert.Zero(t, quiz.Id)
|
||
// })
|
||
// bdd.Test(t, "positive create new version of question", func() {
|
||
// records[0].Deleted = true
|
||
// records[0].Version += 1
|
||
// records[0].ParentIds = append(records[0].ParentIds, int32(records[0].Id))
|
||
// records[0].Name = faker.StringWithSize(100)
|
||
//
|
||
// err := d.QuizRepo.CreateQuiz(ctx, &records[0])
|
||
// assert.NoError(t, err)
|
||
// })
|
||
// })
|
||
//
|
||
// bdd.Act(t, "update expired quizes", func() {
|
||
// bdd.Test(t, "check that we have quizes for expiration", func() {
|
||
// record2 := model.Quiz{
|
||
// AccountId: id,
|
||
// Fingerprinting: true,
|
||
// Repeatable: true,
|
||
// NotePrevented: true,
|
||
// MailNotifications: true,
|
||
// UniqueAnswers: true,
|
||
// Name: faker.StringWithSize(100),
|
||
// Description: "test",
|
||
// Config: "test",
|
||
// Status: model.StatusStart,
|
||
// Limit: 0,
|
||
// DueTo: uint64(time.Now().Add(-time.Hour).Unix()),
|
||
// TimeOfPassing: 0,
|
||
// Pausable: false,
|
||
// }
|
||
// err := d.QuizRepo.CreateQuiz(ctx, &record2)
|
||
// assert.NoError(t, err, nil)
|
||
// assert.NotZero(t, record2.Id, nil)
|
||
// assert.NotEqual(t, record2.CreatedAt, nil)
|
||
// assert.NotEqual(t, record2.UpdatedAt, nil)
|
||
// })
|
||
// })
|
||
//
|
||
// bdd.Act(t, "copy question flow", func() {
|
||
// bdd.Test(t, "duplicate question", func() {
|
||
// copiedQuestion, err := d.QuestionRepo.CopyQuestion(ctx, questions[4].Id, 0)
|
||
// assert.NoError(t, err)
|
||
// assert.Equal(t, questions[4].QuizId, copiedQuestion.QuizId)
|
||
// assert.NotEqual(t, questions[4].Id, copiedQuestion.Id)
|
||
// })
|
||
// bdd.Test(t, "copy question to another quiz", func() {
|
||
// copiedQuestion, err := d.QuestionRepo.CopyQuestion(ctx, questions[4].Id, records[10].Id)
|
||
// assert.NoError(t, err)
|
||
// assert.Equal(t, records[10].Id, copiedQuestion.QuizId)
|
||
// assert.NotEqual(t, questions[4].Id, copiedQuestion.Id)
|
||
// })
|
||
// })
|
||
//
|
||
// bdd.Act(t, "copy quiz flow", func() {
|
||
// bdd.Test(t, "quiz duplication", func() {
|
||
// copiesQuiz, err := d.QuizRepo.CopyQuiz(ctx, records[10].AccountId, records[10].Id)
|
||
// assert.NoError(t, err)
|
||
// assert.NotEqual(t, records[10].Id, copiesQuiz.Id)
|
||
// })
|
||
// })
|
||
//
|
||
// bdd.Act(t, "get history for quiz", func() {
|
||
// bdd.Test(t, "positive quiz history", func() {
|
||
// hist, err := d.QuizRepo.QuizHistory(ctx, quiz.QuizHistoryDeps{
|
||
// Id: records[0].Id,
|
||
// Limit: 100,
|
||
// Offset: 0,
|
||
// AccountId: id,
|
||
// })
|
||
// assert.NoError(t, err)
|
||
// assert.Equal(t, len(hist), 2)
|
||
// })
|
||
// bdd.Test(t, "negative quiz history", func() {
|
||
// _, err := d.QuizRepo.QuizHistory(ctx, quiz.QuizHistoryDeps{
|
||
// Id: math.MaxUint64,
|
||
// Limit: 100,
|
||
// Offset: 0,
|
||
// AccountId: id,
|
||
// })
|
||
// assert.NoError(t, err)
|
||
// assert.Equal(t, nil, nil)
|
||
// })
|
||
// })
|
||
//
|
||
// bdd.Act(t, "get history for question", func() {
|
||
// bdd.Test(t, "positive question history", func() {
|
||
// hist, err := d.QuestionRepo.QuestionHistory(ctx, questions[0].Id, 100, 0)
|
||
// assert.NoError(t, err)
|
||
// assert.Equal(t, len(hist), 2)
|
||
// })
|
||
// bdd.Test(t, "negative question history", func() {
|
||
// _, err := d.QuestionRepo.QuestionHistory(ctx, math.MaxUint64, 100, 0)
|
||
// assert.NoError(t, err)
|
||
// })
|
||
// })
|
||
//
|
||
// bdd.Act(t, "Worker Stat Process", func() {
|
||
// err := d.WorkerRepo.WorkerStatProcess(ctx)
|
||
// assert.NoError(t, err, nil)
|
||
// })
|
||
//
|
||
// bdd.Act(t, "Worker Timeout Process", func() {
|
||
// err := d.WorkerRepo.WorkerTimeoutProcess(ctx)
|
||
// assert.NoError(t, err, nil)
|
||
// })
|
||
// // todo нужно будет обновить эти тесты связать с выше стоящими
|
||
// bdd.Act(t, "Get Account By ID", func() {
|
||
// account, err := d.AccountRepo.GetAccountByID(ctx, "64eb6ce57047f28fdabf69ec")
|
||
// assert.NoError(t, err, nil)
|
||
// fmt.Println(account)
|
||
// })
|
||
//
|
||
// bdd.Act(t, "Get Privileges By Account ID", func() {
|
||
// privileges, err := d.AccountRepo.GetPrivilegesByAccountID(ctx, "64eb6ce57047f28fdabf69ec")
|
||
// assert.NoError(t, err, nil)
|
||
// fmt.Println(privileges)
|
||
// })
|
||
//
|
||
// bdd.Act(t, "Get Accounts", func() {
|
||
// accounts, count, err := d.AccountRepo.GetAccounts(ctx, 10, 0)
|
||
// assert.NoError(t, err, nil)
|
||
// fmt.Println(accounts)
|
||
// fmt.Println(len(accounts))
|
||
// fmt.Println(count)
|
||
// })
|
||
//
|
||
// bdd.Act(t, "Update Privilege", func() {
|
||
// priv := model.ShortPrivilege{
|
||
// PrivilegeID: "quizCnt",
|
||
// PrivilegeName: "Количество Заявок",
|
||
// Amount: 0,
|
||
// CreatedAt: time.Now(),
|
||
// }
|
||
// err := d.AccountRepo.UpdatePrivilege(ctx, &priv, "047c1109-1fba-47d8-b4ec-6ded153a2ea9")
|
||
// assert.NoError(t, err, nil)
|
||
//
|
||
// })
|
||
//
|
||
// bdd.Act(t, "Insert Privilege", func() {
|
||
// priv := model.ShortPrivilege{
|
||
// PrivilegeID: "quizCnt",
|
||
// PrivilegeName: "123",
|
||
// Amount: 123,
|
||
// CreatedAt: time.Now(),
|
||
// }
|
||
//
|
||
// err := d.AccountRepo.InsertPrivilege(ctx, &priv, "047c1109-1fba-47d8-b4ec-6ded153a2ea9")
|
||
// assert.NoError(t, err, nil)
|
||
// })
|
||
//
|
||
// bdd.Act(t, "Get Expired", func() {
|
||
//
|
||
// priv, err := d.AccountRepo.GetExpired(ctx, "quizCnt")
|
||
// fmt.Println(priv)
|
||
// assert.NoError(t, err, nil)
|
||
// })
|
||
//
|
||
// bdd.Act(t, "Delete Privilege By ID", func() {
|
||
// err := d.AccountRepo.DeletePrivilegeByID(ctx, "10")
|
||
// assert.NoError(t, err, nil)
|
||
// })
|
||
//
|
||
// bdd.Act(t, "Update Privilege Amount", func() {
|
||
// err := d.AccountRepo.UpdatePrivilegeAmount(ctx, "2", 100000)
|
||
// assert.NoError(t, err, nil)
|
||
// })
|
||
//
|
||
// bdd.Act(t, "Get Acc And Privilege By Email(userid)", func() {
|
||
// acc, priv, err := d.AccountRepo.GetAccAndPrivilegeByEmail(ctx, "650061935ad320604ff24cc2")
|
||
// fmt.Println(acc, priv)
|
||
// assert.NoError(t, err, nil)
|
||
// })
|
||
//
|
||
// bdd.Act(t, "Get Quiz Results", func() {
|
||
// now := time.Now()
|
||
//
|
||
// yearAgo := now.AddDate(-1, 0, 0)
|
||
//
|
||
// yearAhead := now.AddDate(1, 0, 0)
|
||
// ansexp, count, err := d.ResultRepo.GetQuizResults(ctx, 9422, result.GetQuizResDeps{
|
||
// To: yearAhead,
|
||
// From: yearAgo,
|
||
// New: false,
|
||
// Page: 1,
|
||
// Limit: 10,
|
||
// }, true)
|
||
// assert.NoError(t, err, nil)
|
||
// fmt.Println(ansexp)
|
||
// fmt.Println(count)
|
||
// })
|
||
//
|
||
// bdd.Act(t, "Update Answers Status", func() {
|
||
// err := d.ResultRepo.UpdateAnswersStatus(ctx, "64eb6ce57047f28fdabf69ec", []uint64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10})
|
||
// assert.NoError(t, err, nil)
|
||
// })
|
||
//
|
||
// bdd.Act(t, "Get Quiz Results CSV", func() {
|
||
// now := time.Now()
|
||
//
|
||
// yearAgo := now.AddDate(-1, 0, 0)
|
||
//
|
||
// yearAhead := now.AddDate(1, 0, 0)
|
||
// ans, err := d.ResultRepo.GetQuizResultsCSV(ctx, 14734, result.GetQuizResDeps{
|
||
// To: yearAhead,
|
||
// From: yearAgo,
|
||
// New: false,
|
||
// })
|
||
// fmt.Println(ans)
|
||
// assert.NoError(t, err, nil)
|
||
// })
|
||
//
|
||
// bdd.Act(t, "Get Questions", func() {
|
||
// ques, err := d.ResultRepo.GetQuestions(ctx, 14734)
|
||
// fmt.Println(ques)
|
||
// assert.NoError(t, err, nil)
|
||
// })
|
||
//
|
||
// bdd.Act(t, "Check Results Owner", func() {
|
||
// anss, err := d.ResultRepo.CheckResultsOwner(ctx, []int64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, "64eb6ce57047f28fdabf69ec")
|
||
// fmt.Println(anss)
|
||
// assert.NoError(t, err, nil)
|
||
// })
|
||
//
|
||
// bdd.Act(t, "Get Result Answers", func() {
|
||
// anss, err := d.ResultRepo.GetResultAnswers(ctx, 1)
|
||
// fmt.Println(anss)
|
||
// assert.NoError(t, err, nil)
|
||
// })
|
||
//
|
||
// bdd.Act(t, "Check Result Owner", func() {
|
||
// anss, err := d.ResultRepo.CheckResultOwner(ctx, 1, "64eb6ce57047f28fdabf69ec")
|
||
// assert.Equal(t, anss, true)
|
||
// assert.NoError(t, err, nil)
|
||
// })
|
||
//
|
||
// bdd.Act(t, "Soft Delete Result By ID", func() {
|
||
// err := d.ResultRepo.SoftDeleteResultByID(ctx, 10)
|
||
// assert.NoError(t, err, nil)
|
||
// })
|
||
// })
|
||
//}
|