modules_test.go

package modules

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"math"
	"net/http"
	"testing"

	"github.com/prebid/prebid-server/config"
	"github.com/prebid/prebid-server/hooks"
	"github.com/prebid/prebid-server/hooks/hookstage"
	"github.com/prebid/prebid-server/modules/moduledeps"
	"github.com/stretchr/testify/assert"
)

func TestModuleBuilderBuild(t *testing.T) {
	vendor := "acme"
	moduleName := "foobar"
	defaultModulesConfig := map[string]map[string]interface{}{vendor: {moduleName: map[string]interface{}{"enabled": true}}}
	defaultHookRepository, err := hooks.NewHookRepository(map[string]interface{}{vendor + "." + moduleName: module{}})
	if err != nil {
		t.Fatalf("Failed to init default hook repository: %s", err)
	}
	emptyHookRepository, err := hooks.NewHookRepository(map[string]interface{}{})
	if err != nil {
		t.Fatalf("Failed to init empty hook repository: %s", err)
	}

	testCases := map[string]struct {
		givenModule           interface{}
		givenConfig           config.Modules
		givenHookBuilderErr   error
		expectedHookRepo      hooks.HookRepository
		expectedModulesStages map[string][]string
		expectedErr           error
	}{
		"Can build module with config": {
			givenModule:           module{},
			givenConfig:           defaultModulesConfig,
			expectedModulesStages: map[string][]string{vendor + "_" + moduleName: {hooks.StageEntrypoint.String(), hooks.StageAuctionResponse.String()}},
			expectedHookRepo:      defaultHookRepository,
			expectedErr:           nil,
		},
		"Module is not added to hook repository if it's disabled": {
			givenModule:           module{},
			givenConfig:           map[string]map[string]interface{}{vendor: {moduleName: map[string]interface{}{"enabled": false, "attr": "val"}}},
			expectedModulesStages: map[string][]string{},
			expectedHookRepo:      emptyHookRepository,
			expectedErr:           nil,
		},
		"Module considered disabled if status property not defined in module config": {
			givenModule:           module{},
			givenConfig:           map[string]map[string]interface{}{vendor: {moduleName: map[string]interface{}{"foo": "bar"}}},
			expectedHookRepo:      emptyHookRepository,
			expectedModulesStages: map[string][]string{},
			expectedErr:           nil,
		},
		"Module considered disabled if its config not provided and as a result skipped from execution": {
			givenModule:           module{},
			givenConfig:           nil,
			expectedHookRepo:      emptyHookRepository,
			expectedModulesStages: map[string][]string{},
			expectedErr:           nil,
		},
		"Fails if module does not implement any hook interface": {
			givenModule:           struct{}{},
			givenConfig:           defaultModulesConfig,
			expectedHookRepo:      nil,
			expectedModulesStages: nil,
			expectedErr:           fmt.Errorf(`hook "%s.%s" does not implement any supported hook interface`, vendor, moduleName),
		},
		"Fails if module builder function returns error": {
			givenModule:           module{},
			givenConfig:           defaultModulesConfig,
			givenHookBuilderErr:   errors.New("failed to build module"),
			expectedHookRepo:      nil,
			expectedModulesStages: nil,
			expectedErr:           fmt.Errorf(`failed to init "%s.%s" module: %s`, vendor, moduleName, "failed to build module"),
		},
		"Fails if config marshaling returns error": {
			givenModule:           module{},
			givenConfig:           map[string]map[string]interface{}{vendor: {moduleName: math.Inf(1)}},
			expectedHookRepo:      nil,
			expectedModulesStages: nil,
			expectedErr:           fmt.Errorf(`failed to marshal "%s.%s" module config: json: unsupported value: +Inf`, vendor, moduleName),
		},
	}

	for name, test := range testCases {
		t.Run(name, func(t *testing.T) {
			builder := &builder{
				builders: ModuleBuilders{
					vendor: {
						moduleName: func(cfg json.RawMessage, deps moduledeps.ModuleDeps) (interface{}, error) {
							return test.givenModule, test.givenHookBuilderErr
						},
					},
				},
			}

			repo, modulesStages, err := builder.Build(test.givenConfig, moduledeps.ModuleDeps{HTTPClient: http.DefaultClient})
			assert.Equal(t, test.expectedErr, err)
			assert.Equal(t, test.expectedModulesStages, modulesStages)
			assert.Equal(t, test.expectedHookRepo, repo)
		})
	}
}

type module struct{}

func (h module) HandleEntrypointHook(_ context.Context, _ hookstage.ModuleInvocationContext, _ hookstage.EntrypointPayload) (hookstage.HookResult[hookstage.EntrypointPayload], error) {
	return hookstage.HookResult[hookstage.EntrypointPayload]{}, nil
}

func (h module) HandleAuctionResponseHook(_ context.Context, _ hookstage.ModuleInvocationContext, _ hookstage.AuctionResponsePayload) (hookstage.HookResult[hookstage.AuctionResponsePayload], error) {
	return hookstage.HookResult[hookstage.AuctionResponsePayload]{}, nil
}