diff --git a/.gitignore b/.gitignore index 78b3074d..2a04f75e 100644 --- a/.gitignore +++ b/.gitignore @@ -10,6 +10,7 @@ # Output of the go coverage tool, specifically when used with LiteIDE *.out +go-carpet-coverage-out* # Dependency directories (remove the comment below to include it) # vendor/ diff --git a/act/registry.go b/act/registry.go index 0887d7a5..b9cdb324 100644 --- a/act/registry.go +++ b/act/registry.go @@ -32,8 +32,8 @@ type Registry struct { var _ IRegistry = (*Registry)(nil) -// NewRegistry creates a new registry with the specified default policy and timeout. -func NewRegistry( +// NewActRegistry creates a new act registry with the specified default policy and timeout. +func NewActRegistry( builtinSignals map[string]*sdkAct.Signal, builtinsPolicies map[string]*sdkAct.Policy, builtinActions map[string]*sdkAct.Action, @@ -42,14 +42,26 @@ func NewRegistry( logger zerolog.Logger, ) *Registry { for _, signal := range builtinSignals { + if signal == nil { + logger.Warn().Msg("Signal is nil, not adding") + return nil + } logger.Debug().Str("name", signal.Name).Msg("Registered builtin signal") } for _, policy := range builtinsPolicies { + if policy == nil { + logger.Warn().Msg("Policy is nil, not adding") + return nil + } logger.Debug().Str("name", policy.Name).Msg("Registered builtin policy") } for _, action := range builtinActions { + if action == nil { + logger.Warn().Msg("Action is nil, not adding") + return nil + } logger.Debug().Str("name", action.Name).Msg("Registered builtin action") } diff --git a/act/registry_test.go b/act/registry_test.go index c3269a08..ccff581c 100644 --- a/act/registry_test.go +++ b/act/registry_test.go @@ -17,7 +17,7 @@ import ( func Test_NewRegistry(t *testing.T) { logger := zerolog.Logger{} - actRegistry := NewRegistry( + actRegistry := NewActRegistry( BuiltinSignals(), BuiltinPolicies(), BuiltinActions(), config.DefaultPolicy, config.DefaultPolicyTimeout, logger) assert.NotNil(t, actRegistry) @@ -28,9 +28,9 @@ func Test_NewRegistry(t *testing.T) { assert.Equal(t, config.DefaultPolicy, actRegistry.DefaultSignal.Name) } -// Test_Add tests the Add function of the policy registry. +// Test_Add tests the Add function of the act registry. func Test_Add(t *testing.T) { - actRegistry := NewRegistry( + actRegistry := NewActRegistry( BuiltinSignals(), BuiltinPolicies(), BuiltinActions(), config.DefaultPolicy, config.DefaultPolicyTimeout, zerolog.Logger{}) assert.NotNil(t, actRegistry) @@ -44,11 +44,11 @@ func Test_Add(t *testing.T) { assert.Len(t, actRegistry.Policies, len(BuiltinPolicies())+1) } -// Test_Add_NilPolicy tests the Add function of the policy registry with a nil policy. +// Test_Add_NilPolicy tests the Add function of the act registry with a nil policy. func Test_Add_NilPolicy(t *testing.T) { buf := bytes.Buffer{} logger := zerolog.New(&buf) - actRegistry := NewRegistry( + actRegistry := NewActRegistry( BuiltinSignals(), map[string]*sdkAct.Policy{}, BuiltinActions(), config.DefaultPolicy, config.DefaultPolicyTimeout, logger) assert.NotNil(t, actRegistry) @@ -59,11 +59,11 @@ func Test_Add_NilPolicy(t *testing.T) { assert.Contains(t, buf.String(), "Policy is nil, not adding") } -// Test_Add_ExistentPolicy tests the Add function of the policy registry with an existent policy. +// Test_Add_ExistentPolicy tests the Add function of the act registry with an existent policy. func Test_Add_ExistentPolicy(t *testing.T) { buf := bytes.Buffer{} logger := zerolog.New(&buf) - actRegistry := NewRegistry( + actRegistry := NewActRegistry( BuiltinSignals(), BuiltinPolicies(), BuiltinActions(), config.DefaultPolicy, config.DefaultPolicyTimeout, logger) assert.NotNil(t, actRegistry) @@ -74,9 +74,9 @@ func Test_Add_ExistentPolicy(t *testing.T) { assert.Contains(t, buf.String(), "Policy already exists, overwriting") } -// Test_Apply tests the Apply function of the policy registry. +// Test_Apply tests the Apply function of the act registry. func Test_Apply(t *testing.T) { - actRegistry := NewRegistry( + actRegistry := NewActRegistry( BuiltinSignals(), BuiltinPolicies(), BuiltinActions(), config.DefaultPolicy, config.DefaultPolicyTimeout, zerolog.Logger{}) assert.NotNil(t, actRegistry) @@ -93,12 +93,12 @@ func Test_Apply(t *testing.T) { assert.False(t, outputs[0].Terminal) } -// Test_Apply_NoSignals tests the Apply function of the policy registry with no signals. +// Test_Apply_NoSignals tests the Apply function of the act registry with no signals. // It should apply the default policy. func Test_Apply_NoSignals(t *testing.T) { buf := bytes.Buffer{} logger := zerolog.New(&buf) - actRegistry := NewRegistry( + actRegistry := NewActRegistry( BuiltinSignals(), BuiltinPolicies(), BuiltinActions(), config.DefaultPolicy, config.DefaultPolicyTimeout, logger) assert.NotNil(t, actRegistry) @@ -114,7 +114,7 @@ func Test_Apply_NoSignals(t *testing.T) { assert.Contains(t, buf.String(), "No signals provided, applying default signal") } -// Test_Apply_ContradictorySignals tests the Apply function of the policy registry +// Test_Apply_ContradictorySignals tests the Apply function of the act registry // with contradictory signals. The terminate signal should take precedence over // the passthrough signal because it is a terminal action. The passthrough // signal should be ignored. @@ -137,7 +137,7 @@ func Test_Apply_ContradictorySignals(t *testing.T) { buf := bytes.Buffer{} logger := zerolog.New(&buf) - actRegistry := NewRegistry( + actRegistry := NewActRegistry( BuiltinSignals(), BuiltinPolicies(), BuiltinActions(), config.DefaultPolicy, config.DefaultPolicyTimeout, logger) assert.NotNil(t, actRegistry) @@ -169,13 +169,13 @@ func Test_Apply_ContradictorySignals(t *testing.T) { } } -// Test_Apply_ActionNotMatched tests the Apply function of the policy registry +// Test_Apply_ActionNotMatched tests the Apply function of the act registry // with a signal that does not match any action. The signal should be ignored. // The default policy should be applied instead. func Test_Apply_ActionNotMatched(t *testing.T) { buf := bytes.Buffer{} logger := zerolog.New(&buf) - actRegistry := NewRegistry( + actRegistry := NewActRegistry( BuiltinSignals(), BuiltinPolicies(), BuiltinActions(), config.DefaultPolicy, config.DefaultPolicyTimeout, logger) assert.NotNil(t, actRegistry) @@ -193,13 +193,13 @@ func Test_Apply_ActionNotMatched(t *testing.T) { assert.Contains(t, buf.String(), "{\"level\":\"error\",\"error\":\"no matching action\",\"name\":\"non-existent\",\"message\":\"Error applying signal\"}") //nolint:lll } -// Test_Apply_PolicyNotMatched tests the Apply function of the policy registry +// Test_Apply_PolicyNotMatched tests the Apply function of the act registry // with a signal that does not match any policy. The signal should be ignored. // The default policy should be applied instead. func Test_Apply_PolicyNotMatched(t *testing.T) { buf := bytes.Buffer{} logger := zerolog.New(&buf) - actRegistry := NewRegistry( + actRegistry := NewActRegistry( BuiltinSignals(), map[string]*sdkAct.Policy{ "passthrough": BuiltinPolicies()["passthrough"], @@ -221,7 +221,7 @@ func Test_Apply_PolicyNotMatched(t *testing.T) { assert.Contains(t, buf.String(), "{\"level\":\"error\",\"error\":\"no matching policy\",\"name\":\"terminate\",\"message\":\"Error applying signal\"}") //nolint:lll } -// Test_Apply_NonBoolPolicy tests the Apply function of the policy registry +// Test_Apply_NonBoolPolicy tests the Apply function of the act registry // with a non-bool policy. func Test_Apply_NonBoolPolicy(t *testing.T) { badPolicies := []map[string]*sdkAct.Policy{ @@ -244,7 +244,7 @@ func Test_Apply_NonBoolPolicy(t *testing.T) { for _, policies := range badPolicies { buf := bytes.Buffer{} logger := zerolog.New(&buf) - actRegistry := NewRegistry( + actRegistry := NewActRegistry( BuiltinSignals(), policies, BuiltinActions(), @@ -264,10 +264,42 @@ func Test_Apply_NonBoolPolicy(t *testing.T) { } } -// Test_Run tests the Run function of the policy registry with a non-terminal action. +// Test_Apply_BadPolicy tests the NewRegistry function with a bad policy, +// which should return a nil registry. +func Test_Apply_BadPolicy(t *testing.T) { + badPolicies := []map[string]*sdkAct.Policy{ + { + "passthrough": sdkAct.MustNewPolicy( + "passthrough", + "2/0 + 'test'", + nil, + ), + }, + { + "passthrough": sdkAct.MustNewPolicy( + "passthrough", + "2+2+true", + nil, + ), + }, + } + + for _, policies := range badPolicies { + buf := bytes.Buffer{} + logger := zerolog.New(&buf) + actRegistry := NewActRegistry( + BuiltinSignals(), + policies, + BuiltinActions(), + config.DefaultPolicy, config.DefaultPolicyTimeout, logger) + assert.Nil(t, actRegistry) + } +} + +// Test_Run tests the Run function of the act registry with a non-terminal action. func Test_Run(t *testing.T) { logger := zerolog.Logger{} - actRegistry := NewRegistry( + actRegistry := NewActRegistry( BuiltinSignals(), BuiltinPolicies(), BuiltinActions(), config.DefaultPolicy, config.DefaultPolicyTimeout, logger) assert.NotNil(t, actRegistry) @@ -282,10 +314,10 @@ func Test_Run(t *testing.T) { assert.True(t, cast.ToBool(result)) } -// Test_Run_Terminate tests the Run function of the policy registry with a terminal action. +// Test_Run_Terminate tests the Run function of the act registry with a terminal action. func Test_Run_Terminate(t *testing.T) { logger := zerolog.Logger{} - actRegistry := NewRegistry( + actRegistry := NewActRegistry( BuiltinSignals(), BuiltinPolicies(), BuiltinActions(), config.DefaultPolicy, config.DefaultPolicyTimeout, logger) assert.NotNil(t, actRegistry) @@ -307,11 +339,11 @@ func Test_Run_Terminate(t *testing.T) { assert.NotEmpty(t, resultMap["response"]) } -// Test_Run_Async tests the Run function of the policy registry with an asynchronous action. +// Test_Run_Async tests the Run function of the act registry with an asynchronous action. func Test_Run_Async(t *testing.T) { out := bytes.Buffer{} logger := zerolog.New(&out) - actRegistry := NewRegistry( + actRegistry := NewActRegistry( BuiltinSignals(), BuiltinPolicies(), BuiltinActions(), config.DefaultPolicy, config.DefaultPolicyTimeout, logger) assert.NotNil(t, actRegistry) @@ -350,7 +382,7 @@ func Test_Run_Async(t *testing.T) { func Test_Run_NilOutput(t *testing.T) { buf := bytes.Buffer{} logger := zerolog.New(&buf) - actRegistry := NewRegistry( + actRegistry := NewActRegistry( BuiltinSignals(), BuiltinPolicies(), BuiltinActions(), config.DefaultPolicy, config.DefaultPolicyTimeout, logger) assert.NotNil(t, actRegistry) @@ -365,7 +397,7 @@ func Test_Run_NilOutput(t *testing.T) { func Test_Run_ActionNotExist(t *testing.T) { buf := bytes.Buffer{} logger := zerolog.New(&buf) - actRegistry := NewRegistry( + actRegistry := NewActRegistry( BuiltinSignals(), BuiltinPolicies(), BuiltinActions(), config.DefaultPolicy, config.DefaultPolicyTimeout, logger) assert.NotNil(t, actRegistry) diff --git a/api/api_test.go b/api/api_test.go index 9d264a92..7beec0db 100644 --- a/api/api_test.go +++ b/api/api_test.go @@ -106,7 +106,7 @@ func TestGetPluginConfig(t *testing.T) { } func TestGetPlugins(t *testing.T) { - actRegistry := act.NewRegistry( + actRegistry := act.NewActRegistry( act.BuiltinSignals(), act.BuiltinPolicies(), act.BuiltinActions(), config.DefaultPolicy, config.DefaultPolicyTimeout, zerolog.Logger{}) pluginRegistry := plugin.NewRegistry( @@ -135,7 +135,7 @@ func TestGetPlugins(t *testing.T) { } func TestGetPluginsWithEmptyPluginRegistry(t *testing.T) { - actRegistry := act.NewRegistry( + actRegistry := act.NewActRegistry( act.BuiltinSignals(), act.BuiltinPolicies(), act.BuiltinActions(), config.DefaultPolicy, config.DefaultPolicyTimeout, zerolog.Logger{}) pluginRegistry := plugin.NewRegistry( @@ -243,7 +243,7 @@ func TestGetServers(t *testing.T) { config.DefaultPluginTimeout, ) - actRegistry := act.NewRegistry( + actRegistry := act.NewActRegistry( act.BuiltinSignals(), act.BuiltinPolicies(), act.BuiltinActions(), config.DefaultPolicy, config.DefaultPolicyTimeout, zerolog.Logger{}) diff --git a/cmd/run.go b/cmd/run.go index d4452ca9..7ad42f48 100644 --- a/cmd/run.go +++ b/cmd/run.go @@ -57,7 +57,7 @@ var ( globalConfigFile string conf *config.Config pluginRegistry *plugin.Registry - policiesRegistry *act.Registry + actRegistry *act.Registry metricsServer *http.Server UsageReportURL = "localhost:59091" @@ -253,12 +253,17 @@ var runCmd = &cobra.Command{ "Running GatewayD in development mode (not recommended for production)") } - // Create a new policy registry given the built-in signals, policies, and actions. - policiesRegistry = act.NewRegistry( + // Create a new act registry given the built-in signals, policies, and actions. + actRegistry = act.NewActRegistry( act.BuiltinSignals(), act.BuiltinPolicies(), act.BuiltinActions(), conf.Plugin.DefaultPolicy, conf.Plugin.PolicyTimeout, logger, ) + if actRegistry == nil { + logger.Error().Msg("Failed to create act registry") + os.Exit(gerr.FailedToCreateActRegistry) + } + // Load policies from the configuration file and add them to the registry. for _, plc := range conf.Plugin.Policies { if policy, err := sdkAct.NewPolicy( @@ -266,19 +271,19 @@ var runCmd = &cobra.Command{ ); err != nil || policy == nil { logger.Error().Err(err).Str("name", plc.Name).Msg("Failed to create policy") } else { - policiesRegistry.Add(policy) + actRegistry.Add(policy) } } logger.Info().Fields(map[string]interface{}{ - "policies": maps.Keys(policiesRegistry.Policies), + "policies": maps.Keys(actRegistry.Policies), }).Msg("Policies are loaded") // Create a new plugin registry. // The plugins are loaded and hooks registered before the configuration is loaded. pluginRegistry = plugin.NewRegistry( runCtx, - policiesRegistry, + actRegistry, config.If[config.CompatibilityPolicy]( config.Exists[string, config.CompatibilityPolicy]( config.CompatibilityPolicies, conf.Plugin.CompatibilityPolicy), diff --git a/errors/errors.go b/errors/errors.go index 84b631f0..c7cf7ae1 100644 --- a/errors/errors.go +++ b/errors/errors.go @@ -158,10 +158,11 @@ var ( ) const ( - FailedToLoadPluginConfig = 1 - FailedToLoadGlobalConfig = 2 - FailedToCreateClient = 3 - FailedToInitializePool = 4 - FailedToStartServer = 5 - FailedToStartTracer = 6 + FailedToLoadPluginConfig = 1 + FailedToLoadGlobalConfig = 2 + FailedToCreateClient = 3 + FailedToInitializePool = 4 + FailedToStartServer = 5 + FailedToStartTracer = 6 + FailedToCreateActRegistry = 7 ) diff --git a/network/proxy.go b/network/proxy.go index 3bf5f81b..0a3f500d 100644 --- a/network/proxy.go +++ b/network/proxy.go @@ -860,7 +860,7 @@ func (pr *Proxy) shouldTerminate(result map[string]interface{}) (bool, map[strin if slices.Contains(keys, sdkAct.Terminal) { var actionResult map[string]interface{} for _, output := range outputs { - actRes, err := pr.pluginRegistry.PolicyRegistry().Run( + actRes, err := pr.pluginRegistry.ActRegistry().Run( output, act.WithResult(result)) // If the action is async and we received a sentinel error, // don't log the error. diff --git a/network/proxy_test.go b/network/proxy_test.go index 7110e430..e340fae2 100644 --- a/network/proxy_test.go +++ b/network/proxy_test.go @@ -44,8 +44,8 @@ func TestNewProxy(t *testing.T) { err := newPool.Put(client.ID, client) assert.Nil(t, err) - // Create a new Act registry - actRegistry := act.NewRegistry( + // Create a new act registry + actRegistry := act.NewActRegistry( act.BuiltinSignals(), act.BuiltinPolicies(), act.BuiltinActions(), config.DefaultPolicy, config.DefaultPolicyTimeout, logger) @@ -90,8 +90,8 @@ func BenchmarkNewProxy(b *testing.B) { // Create a connection newPool newPool := pool.NewPool(context.Background(), config.EmptyPoolCapacity) - // Create a new Act registry - actRegistry := act.NewRegistry( + // Create a new act registry + actRegistry := act.NewActRegistry( act.BuiltinSignals(), act.BuiltinPolicies(), act.BuiltinActions(), config.DefaultPolicy, config.DefaultPolicyTimeout, logger) @@ -139,8 +139,8 @@ func BenchmarkProxyConnectDisconnect(b *testing.B) { } newPool.Put("client", NewClient(context.Background(), &clientConfig, logger, nil)) //nolint:errcheck - // Create a new Act registry - actRegistry := act.NewRegistry( + // Create a new act registry + actRegistry := act.NewActRegistry( act.BuiltinSignals(), act.BuiltinPolicies(), act.BuiltinActions(), config.DefaultPolicy, config.DefaultPolicyTimeout, logger) @@ -194,8 +194,8 @@ func BenchmarkProxyPassThrough(b *testing.B) { } newPool.Put("client", NewClient(context.Background(), &clientConfig, logger, nil)) //nolint:errcheck - // Create a new Act registry - actRegistry := act.NewRegistry( + // Create a new act registry + actRegistry := act.NewActRegistry( act.BuiltinSignals(), act.BuiltinPolicies(), act.BuiltinActions(), config.DefaultPolicy, config.DefaultPolicyTimeout, logger) @@ -254,8 +254,8 @@ func BenchmarkProxyIsHealthyAndIsExhausted(b *testing.B) { client := NewClient(context.Background(), &clientConfig, logger, nil) newPool.Put("client", client) //nolint:errcheck - // Create a new Act registry - actRegistry := act.NewRegistry( + // Create a new act registry + actRegistry := act.NewActRegistry( act.BuiltinSignals(), act.BuiltinPolicies(), act.BuiltinActions(), config.DefaultPolicy, config.DefaultPolicyTimeout, logger) @@ -312,8 +312,8 @@ func BenchmarkProxyAvailableAndBusyConnections(b *testing.B) { client := NewClient(context.Background(), &clientConfig, logger, nil) newPool.Put("client", client) //nolint:errcheck - // Create a new Act registry - actRegistry := act.NewRegistry( + // Create a new act registry + actRegistry := act.NewActRegistry( act.BuiltinSignals(), act.BuiltinPolicies(), act.BuiltinActions(), config.DefaultPolicy, config.DefaultPolicyTimeout, logger) diff --git a/network/server_test.go b/network/server_test.go index 7ca01905..95658778 100644 --- a/network/server_test.go +++ b/network/server_test.go @@ -39,7 +39,7 @@ func TestRunServer(t *testing.T) { FileName: "server_test.log", }) - actRegistry := act.NewRegistry( + actRegistry := act.NewActRegistry( act.BuiltinSignals(), act.BuiltinPolicies(), act.BuiltinActions(), config.DefaultPolicy, config.DefaultPolicyTimeout, logger) pluginRegistry := plugin.NewRegistry( @@ -55,12 +55,12 @@ func TestRunServer(t *testing.T) { pluginRegistry.AddHook(v1.HookName_HOOK_NAME_ON_TRAFFIC_FROM_SERVER, 1, onOutgoingTraffic) pluginRegistry.AddHook(v1.HookName_HOOK_NAME_ON_TRAFFIC_TO_CLIENT, 1, onOutgoingTraffic) - assert.NotNil(t, pluginRegistry.PolicyRegistry()) - assert.NotNil(t, pluginRegistry.PolicyRegistry().Signals) - assert.NotNil(t, pluginRegistry.PolicyRegistry().Policies) - assert.NotNil(t, pluginRegistry.PolicyRegistry().Actions) - assert.Equal(t, config.DefaultPolicy, pluginRegistry.PolicyRegistry().DefaultPolicy.Name) - assert.Equal(t, config.DefaultPolicy, pluginRegistry.PolicyRegistry().DefaultSignal.Name) + assert.NotNil(t, pluginRegistry.ActRegistry()) + assert.NotNil(t, pluginRegistry.ActRegistry().Signals) + assert.NotNil(t, pluginRegistry.ActRegistry().Policies) + assert.NotNil(t, pluginRegistry.ActRegistry().Actions) + assert.Equal(t, config.DefaultPolicy, pluginRegistry.ActRegistry().DefaultPolicy.Name) + assert.Equal(t, config.DefaultPolicy, pluginRegistry.ActRegistry().DefaultSignal.Name) clientConfig := config.Client{ Network: "tcp", diff --git a/plugin/plugin_registry.go b/plugin/plugin_registry.go index 3a54ce43..7272f010 100644 --- a/plugin/plugin_registry.go +++ b/plugin/plugin_registry.go @@ -50,7 +50,7 @@ type IRegistry interface { LoadPlugins(ctx context.Context, plugins []config.Plugin, startTimeout time.Duration) RegisterHooks(ctx context.Context, pluginID sdkPlugin.Identifier) Apply(hookName string, result *v1.Struct) ([]*sdkAct.Output, bool) - PolicyRegistry() *act.Registry + ActRegistry() *act.Registry // Hook management IHook @@ -365,7 +365,7 @@ func (reg *Registry) Apply(hookName string, result *v1.Struct) ([]*sdkAct.Output // Apply policies to the signals. // The outputs contains the verdicts of the policies and their metadata. // And using this list, the caller can take further actions. - outputs := applyPolicies(hookName, signals, reg.Logger, reg.PolicyRegistry()) + outputs := applyPolicies(hookName, signals, reg.Logger, reg.ActRegistry()) // If no policies are found, return a default output. // Note: this should never happen, as the default policy is always loaded. @@ -729,9 +729,9 @@ func (reg *Registry) RegisterHooks(ctx context.Context, pluginID sdkPlugin.Ident } } -// PolicyRegistry returns the policy registry. -func (reg *Registry) PolicyRegistry() *act.Registry { - _, span := otel.Tracer(config.TracerName).Start(reg.ctx, "PolicyRegistry") +// ActRegistry returns the act registry. +func (reg *Registry) ActRegistry() *act.Registry { + _, span := otel.Tracer(config.TracerName).Start(reg.ctx, "ActRegistry") defer span.End() return reg.policiesRegistry } diff --git a/plugin/plugin_registry_test.go b/plugin/plugin_registry_test.go index fcde9c44..ff8b911b 100644 --- a/plugin/plugin_registry_test.go +++ b/plugin/plugin_registry_test.go @@ -26,7 +26,7 @@ func NewPluginRegistry(t *testing.T) *Registry { NoColor: true, } logger := logging.NewLogger(context.Background(), cfg) - actRegistry := act.NewRegistry( + actRegistry := act.NewActRegistry( act.BuiltinSignals(), act.BuiltinPolicies(), act.BuiltinActions(), config.DefaultPolicy, config.DefaultPolicyTimeout, logger) reg := NewRegistry( @@ -128,7 +128,7 @@ func BenchmarkHookRun(b *testing.B) { NoColor: true, } logger := logging.NewLogger(context.Background(), cfg) - actRegistry := act.NewRegistry( + actRegistry := act.NewActRegistry( act.BuiltinSignals(), act.BuiltinPolicies(), act.BuiltinActions(), config.DefaultPolicy, config.DefaultPolicyTimeout, logger) reg := NewRegistry( diff --git a/plugin/utils_test.go b/plugin/utils_test.go index 9bdd2761..e123c8ad 100644 --- a/plugin/utils_test.go +++ b/plugin/utils_test.go @@ -90,7 +90,7 @@ func Test_getSignals_empty(t *testing.T) { // It also tests the Run function of the registered passthrough (built-in) action. func Test_applyPolicies(t *testing.T) { logger := zerolog.Logger{} - actRegistry := act.NewRegistry( + actRegistry := act.NewActRegistry( act.BuiltinSignals(), act.BuiltinPolicies(), act.BuiltinActions(), config.DefaultPolicy, config.DefaultPolicyTimeout, logger, )