640 lines
15 KiB
Go
640 lines
15 KiB
Go
package test
|
|
|
|
import (
|
|
"amocrm/internal/models"
|
|
"amocrm/internal/tools"
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"github.com/pioz/faker"
|
|
"github.com/stretchr/testify/assert"
|
|
"penahub.gitlab.yandexcloud.net/backend/quiz/common.git/dal"
|
|
"penahub.gitlab.yandexcloud.net/backend/quiz/common.git/model"
|
|
"strconv"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func Test_Repository(t *testing.T) {
|
|
ctx := context.Background()
|
|
repo, err := dal.NewAmoDal(ctx, "host=localhost port=35432 user=squiz password=Redalert2 dbname=squiz sslmode=disable")
|
|
|
|
if err != nil {
|
|
fmt.Println("err init mongo")
|
|
panic(err)
|
|
}
|
|
|
|
err = webhookCreate(ctx, repo)
|
|
assert.NoError(t, err)
|
|
err = webhookUpdate(ctx, repo)
|
|
assert.NoError(t, err)
|
|
|
|
count := 0
|
|
for {
|
|
if count == 8 {
|
|
break
|
|
}
|
|
time.Sleep(time.Second)
|
|
tokens, err := checkExpired(ctx, repo)
|
|
assert.NoError(t, err)
|
|
if len(tokens) > 0 {
|
|
fmt.Println(tokens)
|
|
count++
|
|
}
|
|
}
|
|
|
|
err = getAllTokens(ctx, t, repo)
|
|
assert.NoError(t, err)
|
|
//err = createUser(ctx, repo)
|
|
//assert.NoError(t, err)
|
|
err = updateUser(ctx, repo)
|
|
assert.NoError(t, err)
|
|
err = checkUsers(ctx, repo)
|
|
assert.NoError(t, err)
|
|
err = gettingUserFromCash(ctx, t, repo)
|
|
assert.NoError(t, err)
|
|
err = checkPipelines(ctx, repo)
|
|
assert.NoError(t, err)
|
|
err = gettingPipelinesFromCash(ctx, t, repo)
|
|
assert.NoError(t, err)
|
|
err = checkSteps(ctx, repo)
|
|
assert.NoError(t, err)
|
|
err = gettingStepsFromCash(ctx, t, repo)
|
|
assert.NoError(t, err)
|
|
err = checkTags(ctx, repo)
|
|
assert.NoError(t, err)
|
|
err = gettingTagsFromCash(ctx, t, repo)
|
|
assert.NoError(t, err)
|
|
err = checkFields(ctx, repo)
|
|
assert.NoError(t, err)
|
|
err = gettingFieldsFromCash(ctx, t, repo)
|
|
assert.NoError(t, err)
|
|
err = saveUtms(ctx, repo)
|
|
assert.NoError(t, err)
|
|
err = gettingUserUtm(ctx, t, repo)
|
|
assert.NoError(t, err)
|
|
err = deleteUserUTM(ctx, t, repo)
|
|
assert.NoError(t, err)
|
|
}
|
|
|
|
//func createUser(ctx context.Context, repo *dal.AmoDal) error {
|
|
// for i := 1; i < 10; i++ {
|
|
// accID := strconv.Itoa(i)
|
|
// err := repo.AmoRepo.CreateAccount(ctx, accID)
|
|
// if err != nil {
|
|
// return err
|
|
// }
|
|
// }
|
|
// return nil
|
|
//}
|
|
|
|
func updateUser(ctx context.Context, repo *dal.AmoDal) error {
|
|
var testUserInfo models.AmocrmUserInformation
|
|
err := json.Unmarshal([]byte(jsonUserInfo), &testUserInfo)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for i := 1; i < 10; i++ {
|
|
accID := strconv.Itoa(i)
|
|
info := model.User{
|
|
Name: faker.String(),
|
|
Subdomain: "pena",
|
|
AmoID: 666,
|
|
Amouserid: int32(i),
|
|
Email: faker.Email(),
|
|
Group: tools.ConvertUserGroups(&testUserInfo),
|
|
Country: "Russia",
|
|
}
|
|
|
|
if i%2 == 0 {
|
|
role := faker.String()
|
|
role2 := &role
|
|
info.Role = *role2
|
|
info.ID = faker.Int64()
|
|
}
|
|
|
|
err = repo.AmoRepo.CreateAccount(ctx, accID, info)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func checkUsers(ctx context.Context, repo *dal.AmoDal) error {
|
|
var testUserInfo models.AmocrmUserInformation
|
|
err := json.Unmarshal([]byte(jsonUserInfo), &testUserInfo)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for i := 1; i < 10; i++ {
|
|
if i%2 != 0 {
|
|
info := model.User{
|
|
Name: faker.String(),
|
|
Email: faker.Email(),
|
|
Group: tools.ConvertUserGroups(&testUserInfo),
|
|
}
|
|
role := faker.String()
|
|
role2 := &role
|
|
info.Role = *role2
|
|
|
|
err = repo.AmoRepo.CheckUsers(ctx, int32(i), info)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
return err
|
|
}
|
|
|
|
func gettingUserFromCash(ctx context.Context, t *testing.T, repo *dal.AmoDal) error {
|
|
for i := 1; i < 10; i++ {
|
|
req := model.PaginationReq{
|
|
Page: 1,
|
|
Size: i,
|
|
}
|
|
|
|
resp, err := repo.AmoRepo.GettingUserWithPagination(ctx, &req)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
assert.Equal(t, i, len(resp.Items))
|
|
fmt.Println(len(resp.Items))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func checkPipelines(ctx context.Context, repo *dal.AmoDal) error {
|
|
var testPipeline1 models.PipelineResponse
|
|
err := json.Unmarshal([]byte(jsonPipelines), &testPipeline1)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var testPipeline2 models.PipelineResponse
|
|
err = json.Unmarshal([]byte(jsonPipelines2), &testPipeline2)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
for i := 0; i < 9; i++ {
|
|
accID := strconv.Itoa(i)
|
|
err = repo.AmoRepo.CheckPipelines(ctx, accID, tools.ToPipeline(testPipeline1.Embedded.Pipelines))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
for i := 0; i < 9; i++ {
|
|
accID := strconv.Itoa(i)
|
|
err = repo.AmoRepo.CheckPipelines(ctx, accID, tools.ToPipeline(testPipeline2.Embedded.Pipelines))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func gettingPipelinesFromCash(ctx context.Context, t *testing.T, repo *dal.AmoDal) error {
|
|
for i := 1; i < 28; i++ {
|
|
req := model.PaginationReq{
|
|
Page: 1,
|
|
Size: i,
|
|
}
|
|
|
|
resp, err := repo.AmoRepo.GettingPipelinesFromCash(ctx, &req)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
assert.Equal(t, i, len(resp.Items))
|
|
fmt.Println(resp.Items)
|
|
fmt.Println(len(resp.Items))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func checkSteps(ctx context.Context, repo *dal.AmoDal) error {
|
|
var testStep1 models.ResponseGetListSteps
|
|
err := json.Unmarshal([]byte(jsonStep1), &testStep1)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var testStep2 models.ResponseGetListSteps
|
|
err = json.Unmarshal([]byte(jsonStep2), &testStep2)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
for i := 0; i < 9; i++ {
|
|
accID := strconv.Itoa(i)
|
|
err = repo.AmoRepo.CheckSteps(ctx, accID, tools.ToStep(testStep1.Embedded.Statuses))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
for i := 0; i < 9; i++ {
|
|
accID := strconv.Itoa(i)
|
|
err = repo.AmoRepo.CheckSteps(ctx, accID, tools.ToStep(testStep2.Embedded.Statuses))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func gettingStepsFromCash(ctx context.Context, t *testing.T, repo *dal.AmoDal) error {
|
|
for i := 1; i < 46; i++ {
|
|
req := model.PaginationReq{
|
|
Page: 1,
|
|
Size: i,
|
|
}
|
|
|
|
resp, err := repo.AmoRepo.GettingStepsFromCash(ctx, &req)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
assert.Equal(t, i, len(resp.Items))
|
|
fmt.Println(resp.Items)
|
|
fmt.Println(len(resp.Items))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func checkTags(ctx context.Context, repo *dal.AmoDal) error {
|
|
var testLeadsTags models.ResponseGetListTags
|
|
err := json.Unmarshal([]byte(jsonLeadsTags), &testLeadsTags)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var testLeadsTags2 models.ResponseGetListTags
|
|
err = json.Unmarshal([]byte(jsonLeadsTags2), &testLeadsTags2)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var testContactsTags models.ResponseGetListTags
|
|
err = json.Unmarshal([]byte(jsonContactsTags), &testContactsTags)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var testContactsTags2 models.ResponseGetListTags
|
|
err = json.Unmarshal([]byte(jsonContactsTags2), &testContactsTags2)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var testCompaniesTags models.ResponseGetListTags
|
|
err = json.Unmarshal([]byte(jsonCompaniesTags), &testCompaniesTags)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var testCompaniesTags2 models.ResponseGetListTags
|
|
err = json.Unmarshal([]byte(jsonCompaniesTags2), &testCompaniesTags2)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var testCustomersTags models.ResponseGetListTags
|
|
err = json.Unmarshal([]byte(jsonCustomersTags), &testCustomersTags)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var testCustomersTags2 models.ResponseGetListTags
|
|
err = json.Unmarshal([]byte(jsonCustomersTags2), &testCustomersTags2)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
id := 666666
|
|
for i := 0; i < 9; i++ {
|
|
accID := strconv.Itoa(i)
|
|
err = repo.AmoRepo.CheckTags(ctx, tools.ToTag(testLeadsTags.Embedded.Tags, model.LeadsTags, id), accID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = repo.AmoRepo.CheckTags(ctx, tools.ToTag(testCompaniesTags.Embedded.Tags, model.CompaniesTags, id), accID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = repo.AmoRepo.CheckTags(ctx, tools.ToTag(testCustomersTags.Embedded.Tags, model.CustomersTags, id), accID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = repo.AmoRepo.CheckTags(ctx, tools.ToTag(testContactsTags.Embedded.Tags, model.ContactsTags, id), accID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
for i := 0; i < 9; i++ {
|
|
accID := strconv.Itoa(i)
|
|
err = repo.AmoRepo.CheckTags(ctx, tools.ToTag(testLeadsTags2.Embedded.Tags, model.LeadsTags, id), accID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = repo.AmoRepo.CheckTags(ctx, tools.ToTag(testCompaniesTags2.Embedded.Tags, model.CompaniesTags, id), accID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = repo.AmoRepo.CheckTags(ctx, tools.ToTag(testCustomersTags2.Embedded.Tags, model.CustomersTags, id), accID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = repo.AmoRepo.CheckTags(ctx, tools.ToTag(testContactsTags2.Embedded.Tags, model.ContactsTags, id), accID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func gettingTagsFromCash(ctx context.Context, t *testing.T, repo *dal.AmoDal) error {
|
|
for i := 1; i < 73; i++ {
|
|
req := model.PaginationReq{
|
|
Page: 1,
|
|
Size: i,
|
|
}
|
|
|
|
resp, err := repo.AmoRepo.GettingTagsFromCash(ctx, &req)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
assert.Equal(t, i, len(resp.Items))
|
|
fmt.Println(resp.Items)
|
|
fmt.Println(len(resp.Items))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func checkFields(ctx context.Context, repo *dal.AmoDal) error {
|
|
var testLeadsFields models.ResponseGetListFields
|
|
err := json.Unmarshal([]byte(jsonLeadsFields), &testLeadsFields)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var testLeadsFields2 models.ResponseGetListFields
|
|
err = json.Unmarshal([]byte(jsonLeadsFields2), &testLeadsFields2)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var testContactsFields models.ResponseGetListFields
|
|
err = json.Unmarshal([]byte(jsonContactsFields), &testContactsFields)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var testContactsFields2 models.ResponseGetListFields
|
|
err = json.Unmarshal([]byte(jsonContactsFields2), &testContactsFields2)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var testCompaniesFields models.ResponseGetListFields
|
|
err = json.Unmarshal([]byte(jsonCompaniesFields), &testCompaniesFields)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var testCompaniesFields2 models.ResponseGetListFields
|
|
err = json.Unmarshal([]byte(jsonCompaniesFields2), &testCompaniesFields2)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var testCustomersFields models.ResponseGetListFields
|
|
err = json.Unmarshal([]byte(jsonCustomersFields), &testCustomersFields)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var testCustomersFields2 models.ResponseGetListFields
|
|
err = json.Unmarshal([]byte(jsonCustomersFields2), &testCustomersFields2)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
id := 666666
|
|
for i := 0; i < 9; i++ {
|
|
accID := strconv.Itoa(i)
|
|
err = repo.AmoRepo.CheckFields(ctx, tools.ToField(testLeadsFields.Embedded.CustomFields, model.LeadsTags, id), accID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = repo.AmoRepo.CheckFields(ctx, tools.ToField(testCompaniesFields.Embedded.CustomFields, model.CompaniesTags, id), accID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = repo.AmoRepo.CheckFields(ctx, tools.ToField(testCustomersFields.Embedded.CustomFields, model.CustomersTags, id), accID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = repo.AmoRepo.CheckFields(ctx, tools.ToField(testContactsFields.Embedded.CustomFields, model.ContactsTags, id), accID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
for i := 0; i < 9; i++ {
|
|
accID := strconv.Itoa(i)
|
|
err = repo.AmoRepo.CheckFields(ctx, tools.ToField(testLeadsFields2.Embedded.CustomFields, model.LeadsTags, id), accID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = repo.AmoRepo.CheckFields(ctx, tools.ToField(testCompaniesFields2.Embedded.CustomFields, model.CompaniesTags, id), accID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = repo.AmoRepo.CheckFields(ctx, tools.ToField(testCustomersFields2.Embedded.CustomFields, model.CustomersTags, id), accID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = repo.AmoRepo.CheckFields(ctx, tools.ToField(testContactsFields2.Embedded.CustomFields, model.ContactsTags, id), accID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func gettingFieldsFromCash(ctx context.Context, t *testing.T, repo *dal.AmoDal) error {
|
|
for i := 1; i < 73; i++ {
|
|
req := model.PaginationReq{
|
|
Page: 1,
|
|
Size: i,
|
|
}
|
|
|
|
resp, err := repo.AmoRepo.GettingFieldsFromCash(ctx, &req)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
assert.Equal(t, i, len(resp.Items))
|
|
fmt.Println(resp.Items)
|
|
fmt.Println(len(resp.Items))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func webhookCreate(ctx context.Context, repo *dal.AmoDal) error {
|
|
for i := 1; i < 10; i++ {
|
|
accID := strconv.Itoa(i)
|
|
err := repo.AmoRepo.WebhookCreate(ctx, model.Token{
|
|
RefreshToken: faker.UUID(),
|
|
AccessToken: faker.UUID(),
|
|
AccountID: accID,
|
|
AuthCode: faker.String(),
|
|
Expiration: time.Now().Unix() + 10,
|
|
CreatedAt: time.Now().Unix(),
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func webhookUpdate(ctx context.Context, repo *dal.AmoDal) error {
|
|
for i := 1; i < 10; i++ {
|
|
accID := strconv.Itoa(i)
|
|
err := repo.AmoRepo.WebhookUpdate(ctx, model.Token{
|
|
RefreshToken: faker.UUID(),
|
|
AccessToken: faker.UUID(),
|
|
AccountID: accID,
|
|
Expiration: time.Now().Unix() + int64(i),
|
|
CreatedAt: time.Now().Unix(),
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func checkExpired(ctx context.Context, repo *dal.AmoDal) ([]model.Token, error) {
|
|
tokens, err := repo.AmoRepo.CheckExpired(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return tokens, nil
|
|
}
|
|
|
|
func getAllTokens(ctx context.Context, t *testing.T, repo *dal.AmoDal) error {
|
|
tokens, err := repo.AmoRepo.GetAllTokens(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
assert.Equal(t, len(tokens), 9)
|
|
|
|
return nil
|
|
}
|
|
|
|
func saveUtms(ctx context.Context, repo *dal.AmoDal) error {
|
|
for i := 1; i < 10; i++ {
|
|
var utms []model.UTM
|
|
quizId := i
|
|
for j := 1; j < 50; j++ {
|
|
utm := model.UTM{
|
|
Name: strconv.Itoa(i),
|
|
Quizid: j,
|
|
Accountid: faker.Int(),
|
|
Amofieldid: j,
|
|
Createdat: time.Now().Unix(),
|
|
ID: i,
|
|
}
|
|
utms = append(utms, utm)
|
|
}
|
|
resp, err := repo.AmoRepo.SavingUserUtm(ctx, &model.SaveUserListUTMReq{
|
|
Utms: utms,
|
|
}, strconv.Itoa(i), quizId)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
fmt.Println(resp)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func gettingUserUtm(ctx context.Context, t *testing.T, repo *dal.AmoDal) error {
|
|
for i := 1; i < 50; i++ {
|
|
req := model.PaginationReq{
|
|
Page: 1,
|
|
Size: i,
|
|
}
|
|
|
|
resp, err := repo.AmoRepo.GettingUserUtm(ctx, &req, "1", 1)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
assert.Equal(t, i, len(resp.Items))
|
|
fmt.Println(resp.Items)
|
|
fmt.Println(len(resp.Items))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func deleteUserUTM(ctx context.Context, t *testing.T, repo *dal.AmoDal) error {
|
|
req := model.PaginationReq{
|
|
Page: 1,
|
|
Size: 50,
|
|
}
|
|
|
|
resp, err := repo.AmoRepo.GettingUserUtm(ctx, &req, "5", 5)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var fordetete []int
|
|
for _, r := range resp.Items {
|
|
fordetete = append(fordetete, r.ID)
|
|
}
|
|
err = repo.AmoRepo.DeletingUserUtm(ctx, &model.ListDeleteUTMIDsReq{
|
|
fordetete,
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
for i := 1; i < 50; i++ {
|
|
req := model.PaginationReq{
|
|
Page: 1,
|
|
Size: i,
|
|
}
|
|
|
|
resp, err := repo.AmoRepo.GettingUserUtm(ctx, &req, "5", 5)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
assert.Equal(t, 0, len(resp.Items))
|
|
fmt.Println(resp.Items)
|
|
fmt.Println(len(resp.Items))
|
|
}
|
|
|
|
return nil
|
|
}
|