Untitled

New test file. 
Create `product_handheld_service_test.go` a table-driven unit test in Go using testify/suite and gomock for this file:

```
package services

import (
    "context"
    _ "embed"
    "errors"
    "sort"
    "storm-products/lib"
    "storm-products/models"
    "storm-products/repository"

    cjError "storm-products/errors"

    log "gitlab.cjexpress.io/cjexpress/pos-admin/api-common-lib/log"
    commonModel "gitlab.cjexpress.io/cjexpress/pos-admin/api-common-model/models"
)

// service layer
type ProductHandheldService struct {
    logger            log.ZLogger
    readerClient      *lib.DBReaderClient
    skuRepository     repository.ISKURepository
    barcodeRepository repository.IBarcodeRepository
    env               lib.Env
}

// creates a NewProductService
func NewProductHandheldService(logger log.ZLogger,
    readerClient *lib.DBReaderClient,
    skuRepository repository.ISKURepository,
    barcodeRepository repository.IBarcodeRepository,
    env lib.Env) ProductHandheldService {
    return ProductHandheldService{
        logger:            logger,
        readerClient:      readerClient,
        skuRepository:     skuRepository,
        barcodeRepository: barcodeRepository,
        env:               env,
    }
}

func (p ProductHandheldService) FindBarcodeBySupplier(c context.Context, supplierCode string, barcode string, userInfo commonModel.JWTUserInfo) ([]models.HandheldBarcode, error, error) {
    db := lib.Database{
        Database: p.readerClient.Database,
    }

    productBarcode, errP := p.barcodeRepository.FindByBarcode(c, db, barcode, userInfo.Branch)
    if errP != nil {
        return []models.HandheldBarcode{}, errors.New(cjError.ProductBarcodeNotFoundCode), nil
    }

    skuCode := productBarcode.SkuCode

    // check product sku is active
    branchCode := userInfo.Branch
    validateBarcodeAndSuppliers, err := p.barcodeRepository.ValidateBarcodeAndSupplier(c, db, skuCode, supplierCode, branchCode)
    if err != nil {
        p.logger.Errorf("ValidateBarcodeAndSupplier Error :%s", err)
        return []models.HandheldBarcode{}, nil, err
    }
    if len(validateBarcodeAndSuppliers) == 0 {
        return []models.HandheldBarcode{}, errors.New("supplier has not this barcode"), nil
    }

    filterByIsActive := []models.ValidateBarcodeAndSupplier{}
    for _, val := range validateBarcodeAndSuppliers {
        if val.IsActive {
            val.Barcode = barcode
            filterByIsActive = append(filterByIsActive, val)
        }
    }

    if len(filterByIsActive) == 0 {
        return []models.HandheldBarcode{}, errors.New("product sku is in active"), nil
    }

    skuCode = filterByIsActive[0].SkuCode

    // get barcode all by sku code
    barcodes, err := p.barcodeRepository.FindByHandheldProductBarcode(c, db, skuCode, branchCode)
    if err != nil {
        p.logger.Errorf("FindBySku Error :%s", err)
        return []models.HandheldBarcode{}, nil, err
    }

    // get barcode
    result := []models.HandheldBarcode{}
    var resultIsAllowBuy []models.HandheldBarcode
    for _, val := range barcodes {
        if val.Barcode == barcode && val.IsAllowBuy {
            temp := p.mappingResultsFindBarcodeBySupplier(filterByIsActive[0], *val)
            result = append(result, temp)
            return result, nil, nil
        } else if val.IsAllowBuy {
            temp := p.mappingResultsFindBarcodeBySupplier(filterByIsActive[0], *val)
            resultIsAllowBuy = append(resultIsAllowBuy, temp)
        }
    }

    if len(resultIsAllowBuy) > 0 {
        sort.Slice(resultIsAllowBuy, func(i, j int) bool {
            return resultIsAllowBuy[i].BarFactor < resultIsAllowBuy[j].BarFactor
        })
        result = make([]models.HandheldBarcode, 0)
        result = append(result, resultIsAllowBuy[0])
    }

    for _, val := range barcodes {
        if val.Barcode == barcode {
            temp := p.mappingResultsFindBarcodeBySupplier(filterByIsActive[0], *val)
            result = append(result, temp)
        }
    }

    if len(result) > 0 {
        return result, nil, nil
    }

    return []models.HandheldBarcode{}, nil, nil
}

func (p ProductHandheldService) mappingResultsFindBarcodeBySupplier(productSku models.ValidateBarcodeAndSupplier, productBarcode models.Barcode) models.HandheldBarcode {
    return models.HandheldBarcode{
        IsAllowBuy:        productBarcode.IsAllowBuy,
        IsAllowCoupon:     productSku.IsAllowCoupon,
        IsAllowDiscount:   productSku.IsAllowDiscount,
        IsAllowEditPrice:  productSku.IsAllowEditPrice,
        IsAllowTopup:      productSku.IsAllowTopup,
        IsCalVat:          productSku.IsCalVat,
        IsSpecialRegulate: productSku.IsSpecialRegulate,
        IsCtrlStock:       productSku.IsCtrlStock,
        IsAllowFreebie:    productSku.IsAllowFreebie,
        IsPointCal:        productSku.IsPointCal,
        IsFreshLife:       productSku.IsFreshLife,
        Barcode:           productBarcode.Barcode,
        ProductName:       productSku.ProductName,
        BarcodeName:       productBarcode.BarcodeName,
        BarFactor:         productBarcode.BarFactor,
        UnitCode:          productBarcode.UnitFactor,
        UnitName:          productBarcode.UnitName,
    }
}

func (p ProductHandheldService) GetAllowToBuyBarcode(ctx context.Context, barcode string, userInfo commonModel.JWTUserInfo) (interface{}, error) {
    db := lib.Database{
        Database: p.readerClient.Database,
    }

    branchCode := userInfo.Branch
    productBarcode, err := p.barcodeRepository.FindByBarcode(ctx, db, barcode, branchCode)
    if err != nil {
        p.logger.Errorf("FindByBarcode Error :%s", err)
        return nil, err
    }
    codes := []string{productBarcode.SkuCode}
    productsSku, err := p.skuRepository.FindBySKUCodes(ctx, db, codes, branchCode)
    if err != nil {
        p.logger.Errorf("FindBySKUCodes Error :%s", err)
        return nil, err
    }

    if !productBarcode.IsAllowBuy {
        return nil, errors.New("data not found")
    }

    results := models.ProductBarcodeDetailDTO{
        Barcode:           productBarcode.Barcode,
        SkuCode:           productBarcode.SkuCode,
        UnitCode:          productBarcode.UnitCode,
        UnitName:          productBarcode.UnitName,
        UnitFactor:        productBarcode.BarFactor,
        BarcodeName:       productBarcode.BarcodeName,
        IsAllowBuy:        productBarcode.IsAllowBuy,
        Qty:               productBarcode.Qty,
        ProductName:       productsSku[0].ProductNamePrime,
        UnitPrice:         productsSku[0].SkuCostLast,
        UnitPriceText:     lib.MoneyFormat(productsSku[0].SkuCostLast),
        IsCalVat:          productsSku[0].IsCalVat,
        IsControlStock:    productsSku[0].IsCtrlStock,
        IsAllowDiscount:   productsSku[0].IsAllowDiscount,
        IsFreshLife:       productsSku[0].IsFreshLife,
        FreshLifeBuyPrice: productBarcode.FreshLifeBuyPrice,
        IsActive:          productsSku[0].IsActive,
    }

    return results, nil
}

func (p ProductHandheldService) GetBarCodeBySupplier(ctx context.Context, supplierCode string, barcode string, userInfo commonModel.JWTUserInfo) ([]models.ProductBarcodeDTO, error) {
    db := lib.Database{
        Database: p.readerClient.Database,
    }

    branchCode := userInfo.Branch
    productBarcode, errPOriginal := p.barcodeRepository.FindOriginalByBarcode(ctx, db, barcode, userInfo.Branch)
    if errPOriginal != nil {
        return nil, errors.New(cjError.ProductBarcodeNotFoundCode)
    }
    if !productBarcode.IsActive {
        return nil, errors.New(cjError.ProductBarcodeNotActiveCode)
    }
    if !productBarcode.IsAllowBuy {
        return nil, errors.New(cjError.ProductBarcodeNotAllowBuyCode)
    }

    skus, err := p.skuRepository.FindBySupplierCode(ctx, db, supplierCode, branchCode)
    if err != nil {
        p.logger.Errorf("FindBySupplierCode Error :%s", err)
        return nil, errors.New(cjError.DataNotFoundCode)
    }
    if len(skus) > 0 {
        productBarcodes, err := p.barcodeRepository.FindInSKUCodeAndProductName(ctx, db, skus, barcode, userInfo.Branch, false)
        if err != nil {
            p.logger.Errorf("FindInSKUCodeAndProductName Error :%s", err)
            return nil, errors.New(cjError.ProductBarcodeNotMatchSupplierCode)
        }
        return productBarcodes, nil
    } else {
        return nil, errors.New("data not found")
    }

}



```


Test file style reference (very important):
```
package testnew_test

import (
    "storm-products/lib"
    "storm-products/models"
    "storm-products/services"
    "storm-products/testnew/mock_repository"

    "testing"

    "github.com/gofiber/fiber/v2"
    "github.com/golang/mock/gomock"
    "github.com/stretchr/testify/suite"
    "github.com/valyala/fasthttp"
    commonModel "gitlab.cjexpress.io/cjexpress/pos-admin/api-common-model/models"
    "go.mongodb.org/mongo-driver/bson"
    "go.mongodb.org/mongo-driver/mongo/integration/mtest"

    log "gitlab.cjexpress.io/cjexpress/pos-admin/api-common-lib/log"
)

var productSweetnessCupService services.IProductSweetnessCupService
var productSweetnessCupCtrl *gomock.Controller

// logger                        log.ZLogger
//  productSweetnessCupRepository repository.IProductSweetnessCupRepository
//  readerClient                  *lib.DBReaderClient
//  env                           lib.Env

type ProductSweetnessCupTestSuite struct {
    suite.Suite
    ctx                           *fiber.Ctx
    logger                        log.ZLogger
    productSweetnessCupRepository *mock_repository.MockIProductSweetnessCupRepository
    readerClient                  *lib.DBReaderClient
    env                           lib.Env
}

func TestProductSweetnessCupSuite(t *testing.T) {
    suite.Run(t, new(ProductSweetnessCupTestSuite))
}

func (s *ProductSweetnessCupTestSuite) SetupSuite() {
    s.T().Log("Setup Suit Component")
    productSweetnessCupCtrl = gomock.NewController(s.T())

    s.env = lib.NewEnv(log.GetLogger())
    s.logger = log.GetLogger()

    mt := mtest.New(s.T(), mtest.NewOptions().ClientType(mtest.Mock).ShareClient(true))
    defer mt.Close()

    s.readerClient = &lib.DBReaderClient{Database: mt.Client.Database("test")}

    app := fiber.New()
    req := &fasthttp.Request{}
    fastHTTPReqCtx := &fasthttp.RequestCtx{}
    fastHTTPReqCtx.Init(req, nil, nil)

    ctx := app.AcquireCtx(fastHTTPReqCtx)

    jwtUserInfo := commonModel.JWTUserInfo{
        Name:              "testName",
        Group:             "",
        Username:          "testSurname",
        Branch:            "branchTest",
        AuthorityBranches: []commonModel.MasterBranchesDTO{},
    }

    MockJWTUserInfo(ctx, jwtUserInfo)

    s.NewMockServiceInject(productSweetnessCupCtrl)
    s.ctx = ctx

    productSweetnessCupService = services.NewProductSweetnessCupService(
        s.logger,
        s.productSweetnessCupRepository,
        s.readerClient,
        s.env,
    )
}

func (s *ProductSweetnessCupTestSuite) TearDownSubTest() {
    s.T().Log("TearDownSubTest")
    s.NewMockServiceInject(productSweetnessCupCtrl)
    productSweetnessCupService = services.NewProductSweetnessCupService(
        s.logger,
        s.productSweetnessCupRepository,
        s.readerClient,
        s.env,
    )
}
func (s *ProductSweetnessCupTestSuite) TearDownSuite() {
    s.T().Log("TearDownSuite")
    defer productSweetnessCupCtrl.Finish()
}

func (s *ProductSweetnessCupTestSuite) NewMockServiceInject(ctrl *gomock.Controller) {
    s.productSweetnessCupRepository = mock_repository.NewMockIProductSweetnessCupRepository(ctrl)
}

func (s *ProductSweetnessCupTestSuite) TestProductSweetnessCupFind() {
    type UseCase struct {
        Name           string
        Input          models.PaginationQueryParam
        typeCode       string
        brandCode      string
        MockFunc       func()
        ExpectedError  error
        ExpectedResult []commonModel.ProductSweetnessCupConfig
    }

    testCases := []UseCase{
        {
            Name:      "success-find-with-data",
            Input:     models.PaginationQueryParam{Limit: "10", Page: "1"},
            typeCode:  "SWEETNESS",
            brandCode: "B002",
            MockFunc: func() {
                s.productSweetnessCupRepository.EXPECT().FindByCriteria(
                    gomock.Any(),
                    gomock.Any(),
                    gomock.Any(),
                    bson.M{"typeCode": "SWEETNESS", "brandCode": "B002"},
                ).Return(
                    []commonModel.ProductSweetnessCupConfig{
                        {
                            Code:     "S001",
                            Name:     "ไม่หวาน",
                            Type:     "ระดับความหวาน",
                            TypeCode: "SWEETNESS",
                        },
                    }, nil, nil,
                )
            },
            ExpectedResult: []commonModel.ProductSweetnessCupConfig{
                {
                    Code:     "S001",
                    Name:     "ไม่หวาน",
                    Type:     "ระดับความหวาน",
                    TypeCode: "SWEETNESS",
                },
            },
            ExpectedError: nil,
        },
    }

    for _, tc := range testCases {
        s.Run(tc.Name, func() {
            tc.MockFunc()
            _, _, actualErr := productSweetnessCupService.Find(s.ctx.Context(), tc.Input, tc.typeCode, tc.brandCode)
            if tc.ExpectedError != nil {
                s.Assert().EqualError(actualErr, tc.ExpectedError.Error())
            } else {
                s.Assert().NoError(actualErr)
            }
        })
    }
}




```