heruvym/test/main_test.go

package test

import (
	"bufio"
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"github.com/skeris/appInit"
	"heruvym/internal/utils/jwt_adapter"
	"heruvym/model"
	"io"
	"io/ioutil"
	"mime/multipart"
	"net/http"
	"os"
	"strings"
	"testing"
	"time"

	"heruvym/app"
	"heruvym/service"

	"github.com/stretchr/testify/assert"
	"github.com/themakers/bdd"
)

///create+
///subscribe todo
///ticket+
///send+
///sendFile+
///getTickets+
///getMessages+

func TestTicket(t *testing.T) {
	fmt.Println("start test")
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()
	bdd.Scenario(t, "SupportChat", func(t *testing.T, runID string) {
		var ticket service.CreateTicketResp
		var msgs = make(chan []byte)
		var token string
		go func() {

			time.Sleep(3 * time.Second)
			fmt.Println("start service")
			_, err := app.New(ctx, app.Options{
				MongoURI:         "mongodb://localhost:27017",
				NumberPortLocal:  "1488",
				AccountAddress:   ":8931",
				LoggerDevMode:    false,
				MinioEndpoint:    "localhost:9000",
				MinioAccessKey:   "minioadmin",
				MinioSecretKey:   "minioadmin",
				MinioRegion:      "",
				MinioToken:       "",
				MongoDbTable:     "profile",
				MongoCollections: "profile,role",
				TgToken:          "6712573453:AAFddRtlsF4ZH977xZDexWj6DhqeJD66hYw",
				TgChatID:         542073142,
				RedisDB:          1,
				RedisPassword:    "admin",
				RedisHost:        "localhost:6379",
			}, appInit.Version{})
			if err != nil {
				panic(err)
			}
		}()
		time.Sleep(time.Second * 15)

		bdd.Act(t, "client", func() {
			fmt.Println("client")
			bdd.Test(t, "CreateTicket", func() {

				buf, err := json.Marshal(service.CreateTicketReq{
					Title:   "TestTitle",
					Message: "test",
				})
				if err != nil {
					panic(err)
				}
				req, err := http.NewRequestWithContext(
					ctx,
					"POST",
					"http://localhost:1488/create", bytes.NewBuffer(buf))
				if err != nil {
					panic(err)
				}

				req.Header.Add(jwt_adapter.DefaultHeaderKey, "Bearer "+token)
				req.Header.Set("Referer", "http://localhost:1488")

				resp, err := http.DefaultClient.Do(req)

				if err != nil {
					assert.NoError(t, err)
				}

				if resp.StatusCode != http.StatusOK {
					panic("NotAccepted")
				}

				token = resp.Header.Get(jwt_adapter.DefaultHeaderKey)
				fmt.Println("token", token)

				assert.NoError(t, json.NewDecoder(resp.Body).Decode(&ticket))
			})
			bdd.Test(t, "subscribe for tiket", func() {
				client := &http.Client{}

				r, err := http.NewRequest("GET", "http://localhost:1488/ticket?Authorization="+token+"&ticket="+ticket.Ticket, nil)
				assert.NoError(t, err)
				r.Header.Set("Referer", "http://localhost:1488")
				r.Header.Set("Accept", "text/event-stream")
				r.Header.Set("Cache-Control", "no-cache")
				r.Header.Set("Connection", "keep-alive")
				resp, err := client.Do(r)
				assert.NoError(t, err)

				assert.Equal(t, http.StatusOK, resp.StatusCode)

				sc := bufio.NewScanner(resp.Body)
				split := func(data []byte, atEOF bool) (int, []byte, error) {
					if atEOF && len(data) == 0 {
						return 0, nil, nil
					}

					if strings.Contains(string(data), ":ping") {
						return 0, nil, nil
					}

					if len(data) <= 6 {
						return 0, nil, errors.New(fmt.Sprintf("got bad body: %v", string(data)))
					}
					// Мы получили данные для обработки
					// Начинаем с 6 байта, чтобы убрать "data: "

					if i, nlen := containsDoubleNewline(data); i >= 0 {
						return i + nlen, data[6:i], nil
					}

					// Если получен EOF, то мы получили все что необходимо
					if atEOF {
						return len(data), data, nil
					}

					return 0, nil, nil
				}
				sc.Split(split)

				go func() {
					for sc.Scan() {
						body := sc.Bytes()
						msgs <- body
						fmt.Println("data from", string(body))
					}

					if err = sc.Err(); err != nil {
						fmt.Println("scanner.Err()", err)
						if err != bufio.ErrTooLong {
							fmt.Println("toolong")
						}
					}
				}()

			})
			bdd.Test(t, "send message", func() {

				buf, err := json.Marshal(service.ReqPutMessage{
					Message:  "test",
					TicketID: ticket.Ticket,
					Lang:     "ru",
				})
				if err != nil {
					panic(err)
				}

				req, err := http.NewRequestWithContext(ctx, http.MethodPost, "http://localhost:1488/send", bytes.NewBuffer(buf))
				assert.NoError(t, err)
				req.Header.Set("Referer", "http://localhost:1488")
				req.Header.Add(jwt_adapter.DefaultHeaderKey, "Bearer "+token)
				fmt.Println("token", token)
				resp, err := http.DefaultClient.Do(req)
				fmt.Println("resp", resp)
				assert.NoError(t, err)

				assert.Equal(t, http.StatusOK, resp.StatusCode)

				//var msg, channed model.Message
				//assert.NoError(t, json.NewDecoder(resp.Body).Decode(&msg))
				//err = json.Unmarshal(<-msgs, &channed)
				//assert.NoError(t, err)
				//assert.Equal(t, "test", channed.Message)
			})
			bdd.Test(t, "send file passed", func() {
				body := &bytes.Buffer{}
				writer := multipart.NewWriter(body)

				partf, _ := writer.CreateFormFile("image.jpg", "image.jpg")
				f, err := os.OpenFile("./testfiles/image.jpg", os.O_RDWR, 0644)
				assert.NoError(t, err)
				defer f.Close()
				io.Copy(partf, f)

				partf, _ = writer.CreateFormFile("image2.png", "image2.png")
				f, err = os.OpenFile("./testfiles/image2.png", os.O_RDWR, 0644)
				assert.NoError(t, err)
				defer f.Close()
				io.Copy(partf, f)

				partf, _ = writer.CreateFormFile("gtaV.mp4", "gtaV.mp4")
				f, err = os.OpenFile("./testfiles/gtaV.mp4", os.O_RDWR, 0644)
				assert.NoError(t, err)
				defer f.Close()
				io.Copy(partf, f)

				partf, _ = writer.CreateFormFile("test.csv", "test.csv")
				f, err = os.OpenFile("./testfiles/test.csv", os.O_RDWR, 0644)
				assert.NoError(t, err)
				defer f.Close()
				io.Copy(partf, f)

				partf, _ = writer.CreateFormFile("test.doc", "test.doc")
				f, err = os.OpenFile("./testfiles/test.doc", os.O_RDWR, 0644)
				assert.NoError(t, err)
				defer f.Close()
				io.Copy(partf, f)

				partf, _ = writer.CreateFormFile("test.docx", "test.docx")
				f, err = os.OpenFile("./testfiles/test.docx", os.O_RDWR, 0644)
				assert.NoError(t, err)
				defer f.Close()
				io.Copy(partf, f)

				partf, _ = writer.CreateFormFile("test.pdf", "test.pdf")
				f, err = os.OpenFile("./testfiles/test.pdf", os.O_RDWR, 0644)
				assert.NoError(t, err)
				defer f.Close()
				io.Copy(partf, f)

				partf, _ = writer.CreateFormFile("test.txt", "test.txt")
				f, err = os.OpenFile("./testfiles/test.txt", os.O_RDWR, 0644)
				assert.NoError(t, err)
				defer f.Close()
				io.Copy(partf, f)

				partf, _ = writer.CreateFormFile("test.xlsx", "test.xlsx")
				f, err = os.OpenFile("./testfiles/test.xlsx", os.O_RDWR, 0644)
				assert.NoError(t, err)
				defer f.Close()
				io.Copy(partf, f)

				assert.NoError(t, writer.WriteField("ticket", ticket.Ticket))

				writer.Close()
				req, err := http.NewRequestWithContext(ctx, http.MethodPost, "http://localhost:1488/sendFiles", body)
				req.Header.Set("Content-Type", "multipart/form-data; boundary="+writer.Boundary())
				req.Header.Set("Referer", "http://localhost:1488")
				req.Header.Add(jwt_adapter.DefaultHeaderKey, "Bearer "+token)

				resp, err := http.DefaultClient.Do(req)
				assert.NoError(t, err)
				assert.Equal(t, http.StatusOK, resp.StatusCode)

				str, err := ioutil.ReadAll(resp.Body)
				fmt.Println("resp files", err, string(str))
			})
			bdd.Test(t, "send mp3 file", func() {
				body := &bytes.Buffer{}
				writer := multipart.NewWriter(body)

				partf, _ := writer.CreateFormFile("audio.mp3", "audio.mp3")
				f, err := os.OpenFile("./testfiles/audio.mp3", os.O_RDWR, 0644)
				assert.NoError(t, err)
				io.Copy(partf, f)

				assert.NoError(t, writer.WriteField("ticket", ticket.Ticket))

				writer.Close()
				req, err := http.NewRequestWithContext(ctx, http.MethodPost, "http://localhost:1488/sendFiles", body)
				req.Header.Set("Content-Type", "multipart/form-data; boundary="+writer.Boundary())
				req.Header.Set("Referer", "http://localhost:1488")
				req.Header.Add(jwt_adapter.DefaultHeaderKey, "Bearer "+token)

				resp, err := http.DefaultClient.Do(req)
				assert.NoError(t, err)
				assert.Equal(t, http.StatusNotAcceptable, resp.StatusCode)

				str, err := ioutil.ReadAll(resp.Body)
				fmt.Println("resp files", err, string(str))
			})
			bdd.Test(t, "send file big size", func() {
				body := &bytes.Buffer{}
				writer := multipart.NewWriter(body)

				partf, _ := writer.CreateFormFile("gtaV+size.mp4", "gtaV+size.mp4")
				f, err := os.OpenFile("./testfiles/gtaV+size.mp4", os.O_RDWR, 0644)
				assert.NoError(t, err)
				io.Copy(partf, f)

				assert.NoError(t, writer.WriteField("ticket", ticket.Ticket))

				writer.Close()
				req, err := http.NewRequestWithContext(ctx, http.MethodPost, "http://localhost:1488/sendFiles", body)
				req.Header.Set("Content-Type", "multipart/form-data; boundary="+writer.Boundary())
				req.Header.Set("Referer", "http://localhost:1488")
				req.Header.Add(jwt_adapter.DefaultHeaderKey, "Bearer "+token)

				resp, err := http.DefaultClient.Do(req)
				assert.NoError(t, err)
				assert.Equal(t, http.StatusRequestEntityTooLarge, resp.StatusCode)

				str, err := ioutil.ReadAll(resp.Body)
				fmt.Println("resp files", err, string(str))
			})
			//todo
			bdd.Test(t, "/subscribe, tools.SseWrapper(h.GetList)", func() {
				client := &http.Client{}

				r, err := http.NewRequest("GET", "http://localhost:1488/subscribe?Authorization=eyJhbGciOiJIUzUxMiIsInR5cCI6IkpXVCJ9.eyJhdWQiOiJwZW5hIiwiZXhwIjoxNzA4NjAyNDUxLCJpc3MiOiJwZW5hLWF1dGgtc2VydmljZSIsInN1YiI6InRlc3QifQ.Ipa3ZQt184AyyZFCKAIgU9ijYuvGLQClfyF7cJ74CxzV2NvCMIQU0dImPRwglnY1C3rmhjYxnV_AIHVxxXu-nQ", nil)
				assert.NoError(t, err)
				r.Header.Set("Referer", "http://localhost:1488")
				r.Header.Set("Accept", "text/event-stream")
				r.Header.Set("Cache-Control", "no-cache")
				r.Header.Set("Connection", "keep-alive")
				resp, err := client.Do(r)
				assert.NoError(t, err)

				//assert.Equal(t, http.StatusOK, resp.StatusCode)

				sc := bufio.NewScanner(resp.Body)

				fmt.Println(sc.Bytes())
			})
			bdd.Test(t, "/getTickets, tools.HandlerWrapper(h.GetTickets)", func() {
				client := &http.Client{}
				reqBody := service.GetTicketsReq{
					Amount: 10,
					Page:   1,
					Search: "test",
					Status: "open",
				}
				reqBytes, err := json.Marshal(reqBody)
				assert.NoError(t, err)

				req, err := http.NewRequest("POST", "http://localhost:1488/getTickets", bytes.NewBuffer(reqBytes))
				assert.NoError(t, err)
				req.Header.Set("Referer", "sadmin.pena")
				req.Header.Add(jwt_adapter.DefaultHeaderKey, "Bearer "+token)

				resp, err := client.Do(req)

				assert.Equal(t, http.StatusOK, resp.StatusCode)

				var respBody service.GetTicketsResp
				err = json.NewDecoder(resp.Body).Decode(&respBody)
				assert.NoError(t, err)
				fmt.Println(respBody)
			})
			bdd.Test(t, "/getMessages, tools.HandlerWrapper(h.GetMessages)", func() {
				client := &http.Client{}
				reqBody := service.GetMessagesReq{
					Amount:   0,
					Page:     0,
					Search:   "test",
					TicketID: ticket.Ticket,
				}
				reqBytes, err := json.Marshal(reqBody)
				assert.NoError(t, err)

				req, err := http.NewRequest("POST", "http://localhost:1488/getMessages", bytes.NewBuffer(reqBytes))
				assert.NoError(t, err)
				req.Header.Set("Referer", "http://localhost:1488")
				req.Header.Add(jwt_adapter.DefaultHeaderKey, "Bearer "+token)

				resp, err := client.Do(req)

				assert.Equal(t, http.StatusOK, resp.StatusCode)

				var respBody []model.Message
				err = json.NewDecoder(resp.Body).Decode(&respBody)
				assert.NoError(t, err)
				fmt.Println(respBody)
			})
		})
	})
}

func containsDoubleNewline(data []byte) (int, int) {
	// Ищем все возможные переносы строки
	crcr := bytes.Index(data, []byte("\r\r"))
	lflf := bytes.Index(data, []byte("\n\n"))
	crlflf := bytes.Index(data, []byte("\r\n\n"))
	lfcrlf := bytes.Index(data, []byte("\n\r\n"))
	crlfcrlf := bytes.Index(data, []byte("\r\n\r\n"))
	// Находим первый двойной перенос строки
	minPos := minPosInt(crcr, minPosInt(lflf, minPosInt(crlflf, minPosInt(lfcrlf, crlfcrlf))))
	// Определяем длину
	nlen := 2
	if minPos == crlfcrlf {
		nlen = 4
	} else if minPos == crlflf || minPos == lfcrlf {
		nlen = 3
	}
	return minPos, nlen
}

func minPosInt(a, b int) int {
	if a < 0 {
		return b
	}
	if b < 0 {
		return a
	}
	if a > b {
		return b
	}
	return a
}