feedback/internal/controller/feedback_test.go

package controller

import (
	"bytes"
	"encoding/json"
	tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5"
	"github.com/gofiber/fiber/v2"
	"github.com/stretchr/testify/suite"
	"go.etcd.io/bbolt"
	"go.uber.org/zap"
	"net/http"
	"os"
	"penahub.gitlab.yandexcloud.net/backend/templategen_feedback/internal/client"
	"penahub.gitlab.yandexcloud.net/backend/templategen_feedback/internal/config"
	"penahub.gitlab.yandexcloud.net/backend/templategen_feedback/internal/models"
	"penahub.gitlab.yandexcloud.net/backend/templategen_feedback/internal/repository"
	"testing"
)

type FeedbackTestSuite struct {
	controller *FeedbackController
	db         *bbolt.DB
	suite.Suite
}

func (suite *FeedbackTestSuite) SetupSuite() {
	cfg, err := config.NewConfig("test.env")
	suite.NoError(err)

	logger := zap.NewNop()

	db, err := bbolt.Open("test.db", 0666, nil)
	suite.NoError(err)
	suite.db = db

	repFeedback := repository.NewFeedback(logger, db)
	err = repFeedback.CreateBucket()
	suite.NoError(err)

	bot, err := tgbotapi.NewBotAPI(cfg.TelegramToken)
	suite.NoError(err)

	tgClient := client.NewTelegram(logger, bot, cfg.TelegramChannelID, cfg.TemplatePath)

	suite.controller = NewFeedbackController(logger, repFeedback, tgClient)
}

func (suite *FeedbackTestSuite) TearDownSuite() {
	suite.NoError(suite.db.Close())
	suite.NoError(os.Remove("test.db"))
}

func (suite *FeedbackTestSuite) TestFeedback_Register() {
	wantMethod := "GET"
	wantPath := "/callme"

	gotMethod, gotPath, _, _ := suite.controller.Register()

	suite.Equal(wantMethod, gotMethod)
	suite.Equal(wantPath, gotPath)
}

func (suite *FeedbackTestSuite) TestFeedback_Handler() {
	tests := []struct {
		name string
		args *models.ReqFeedback
		want int
	}{
		{
			name: "status 200",
			args: &models.ReqFeedback{
				Contact: "test.controller.feedback.handler",
				WhoAmi:  "suite test",
			},
			want: fiber.StatusOK,
		},
		{
			name: "status 400",
			args: &models.ReqFeedback{},
			want: fiber.StatusBadRequest,
		},
	}

	for _, tt := range tests {
		suite.Run(tt.name, func() {
			app := fiber.New()

			method, path, name, handler := suite.controller.Register()
			app.Add(method, path, handler).Name(name)

			b, err := json.Marshal(tt.args)
			suite.NoError(err)

			req, err := http.NewRequest("GET", "/callme", bytes.NewBuffer(b))
			suite.NoError(err)

			req.Header.Set("Content-Type", "application/json")

			resp, err := app.Test(req, 10)
			suite.NoError(err)

			suite.Equal(tt.want, resp.StatusCode)
		})
	}
}

func (suite *FeedbackTestSuite) TestFeedback_WarmUpService() {
	err := suite.controller.WarmUpService()
	suite.NoError(err)
}

func (suite *FeedbackTestSuite) TestFeedback_do() {
	args := models.NewFeedback("test.controller.feedback.do", "suite test", "suite test")
	err := suite.controller.do(args)
	suite.NoError(err)
}

func (suite *FeedbackTestSuite) TestFeedback_StopService() {
	done := make(chan bool)
	go func() {
		go suite.controller.RunService()
		done <- true
	}()

	suite.controller.StopService()
	suite.True(<-done)
}

func TestFeedbackTestSuite(t *testing.T) {
	suite.Run(t, new(FeedbackTestSuite))
}