Example of testing

a_tst.go

package kv_test

import (
	_ "embed"

	"github.com/freshteapot/learnalist-api/server/pkg/kv"
	"github.com/freshteapot/learnalist-api/server/pkg/testutils"
	"github.com/freshteapot/learnalist-api/server/pkg/utils"
	"github.com/nats-io/nats.go"

	// https://github.com/nats-io/nats.go/blob/main/jetstream/test/helper_test.go
	"github.com/nats-io/nats-server/v2/server"

	. "github.com/onsi/ginkgo/v2"
	. "github.com/onsi/gomega"
)

var _ = Describe("Testing kvRepo", func() {
	var (
		natsServer *server.Server
	)

	BeforeEach(func() {
		natsServer = testutils.RunBasicJetStreamServer()
	})

	AfterEach(func() {
		testutils.ShutdownJSServerAndRemoveStorage(natsServer)
	})

	It("Getting a key that is not found", func() {
		userUUID := "fake"
		nc, err := nats.Connect(natsServer.ClientURL())
		Expect(err).To(BeNil())
		storeKVCache := kv.InitBucketWithOptions(nc, kv.ConfigCache(), false)
		kvRepo := kv.NewKVReaderWriter(storeKVCache)

		key := kv.GetKeyForSpacedRepetitionStatsStreak(userUUID)
		_, err = kvRepo.Get(key)
		Expect(err).ToNot(BeNil())
		Expect(err).To(Equal(utils.ErrNotFound))
	})
})

b_tst.go

rs := sqlmock.NewRows([]string{
				"uuid",
				"body",
				"user_uuid",
				"when_next",
				"created",
			}).
				AddRow(entry.UUID, entry.Body, entry.UserUUID, whenNext, created)

			mockSql.ExpectQuery(spaced_repetition.SqlGetNext).
				WithArgs(userUUID).
				WillReturnRows(rs)
			item, err := repo.GetNext(userUUID)
			Expect(err).To(BeNil())
			var entry openapi.SpacedRepetitionV1
			json.Unmarshal([]byte(item.Body), &entry)
			Expect(entry.Kind).To(Equal(alist.Simple))
			Expect(entry.Uuid).To(Equal(entryUUID))

c_tst.go

It("Delete existing entry with appIdentifier and token", func() {
				user2Device := openapiv6.MobileDeviceInfo{
					Token:         token,
					AppIdentifier: apps.RemindV1,
					UserUuid:      bUserUUID,
				}

				c, _, rec := testutils.SetupJSONEndpointForEchoWithUserUUID(aUserUUID, method, uri, remindV1RawJSON)

				repo.On("GetDeviceInfoByToken", token).Return(user2Device, nil)
				repo.On("DeleteByToken", bUserUUID, user2Device.Token).Return(nil)

				repo.On("SaveDeviceInfo", aUserAppRemind).Return(http.StatusCreated, nil)

				eventMessageBus.On("Publish", mock.AnythingOfTypeArgument("string"), mock.AnythingOfTypeArgument("event.Eventlog"))

				service.RegisterDevice(c)
				Expect(rec.Code).To(Equal(http.StatusOK))

				eventLog := eventMessageBus.Calls[1].Arguments.Get(1).(event.Eventlog)
				Expect(eventLog.Kind).To(Equal(event.MobileDeviceRemoved))
				Expect(eventLog.Data.(openapiv6.MobileDeviceInfo).UserUuid).To(Equal(user2Device.UserUuid))

				eventLog = eventMessageBus.Calls[2].Arguments.Get(1).(event.Eventlog)
				Expect(eventLog.Kind).To(Equal(event.MobileDeviceRegistered))
				device := eventLog.Data.(openapiv6.MobileDeviceInfo)
				Expect(device.UserUuid).To(Equal(aUserUUID))
				Expect(device.AppIdentifier).To(Equal(apps.RemindV1))
				Expect(device.Token).To(Equal(token))

				testutils.CheckMessageResponseFromResponseRecorder(rec, "Device registered")
				eventMessageBus.AssertNumberOfCalls(GinkgoT(), "Publish", 2)
			})

vscode_settings_go.json

{
    "go.coverageDecorator": {
        "type": "gutter",
        "coveredBorderColor": "rgba(64,128,128,0.8)",
        "coveredHighlightColor": "rgba(64,128,128,0.8)",
        "uncoveredHighlightColor": "rgba(128,64,64,0.5)",
        //"coveredGutterStyle": "blockgreen",
        "uncoveredGutterStyle": "verticalred"
    },
    "go.testEnvVars": {
        "GINKGO_EDITOR_INTEGRATION": true,
    },
    "go.enableCodeLens": {
        "runtest": true
    },
    "go.testTimeout": "30s",
    "go.delveConfig": {
        "debugAdapter": "dlv-dap",
    }
}