Source file src/edge-infra.dev/pkg/sds/emergencyaccess/rules/server/integration/service_rules_test.go

Documentation: edge-infra.dev/pkg/sds/emergencyaccess/rules/server/integration

     1  package rulestest
     2  
     3  import (
     4  	"bytes"
     5  	"testing"
     6  
     7  	"github.com/stretchr/testify/assert"
     8  
     9  	"edge-infra.dev/pkg/lib/fog"
    10  	rulesengine "edge-infra.dev/pkg/sds/emergencyaccess/rules"
    11  	"edge-infra.dev/pkg/sds/emergencyaccess/rules/storage/database"
    12  	"edge-infra.dev/test/f2"
    13  	"edge-infra.dev/test/f2/x/postgres"
    14  )
    15  
    16  func setupRulesEngineNoServer(ctx f2.Context, t *testing.T) rulesengine.RulesEngine {
    17  	buf := new(bytes.Buffer)
    18  	db := postgres.FromContextT(ctx, t).DB()
    19  	log := fog.New(fog.To(buf))
    20  	ds := database.New(log, db)
    21  	return rulesengine.New(ds)
    22  }
    23  
    24  // TestDefaultRulesForPrivs is a test function that tests the behavior of the GetDefaultRules function
    25  // in the context of default rules for privileges. It sets up a new rules engine service, adds new data
    26  // to the database, retrieves the command and privilege with IDs from the database, and performs various tests
    27  // to validate the functionality of the GetDefaultRules and AddDefaultRulesForPrivileges functions.
    28  func TestDefaultRulesForPrivs(t *testing.T) {
    29  	var (
    30  		reng          = rulesengine.RulesEngine{}
    31  		testPrivilege rulesengine.Privilege
    32  		testCommand   rulesengine.Command
    33  	)
    34  	feat := f2.NewFeature("GetDefaultRules tests").
    35  		Setup("Setup a new rules engine service", func(ctx f2.Context, t *testing.T) f2.Context {
    36  			reng = setupRulesEngineNoServer(ctx, t)
    37  			return ctx
    38  		}).
    39  		Setup("Add new data to database", func(ctx f2.Context, t *testing.T) f2.Context {
    40  			res, err := reng.AddPrivileges(ctx, []rulesengine.PostPrivilegePayload{
    41  				{
    42  					Name: "test",
    43  				},
    44  			})
    45  			assert.NoError(t, err)
    46  			assert.Len(t, res.Conflicts, 0)
    47  			res, err = reng.AddCommands(ctx, []rulesengine.PostCommandPayload{
    48  				{
    49  					Name: "test",
    50  				},
    51  			})
    52  			assert.NoError(t, err)
    53  			assert.Len(t, res.Conflicts, 0)
    54  			return ctx
    55  		}).
    56  		Setup("Get Command and Privilege from database with IDs", func(ctx f2.Context, t *testing.T) f2.Context {
    57  			priv, err := reng.ReadPrivilege(ctx, "test")
    58  			assert.NoError(t, err)
    59  			assert.NotEqual(t, rulesengine.Privilege{}, priv)
    60  			testPrivilege = priv
    61  			com, err := reng.ReadCommand(ctx, "test")
    62  			assert.NoError(t, err)
    63  			assert.NotEqual(t, rulesengine.Command{}, com)
    64  			testCommand = com
    65  			return ctx
    66  		}).
    67  		Test("GetDefaultRules no rules", func(ctx f2.Context, t *testing.T) f2.Context {
    68  			res, err := reng.GetDefaultRules(ctx)
    69  			assert.NoError(t, err)
    70  			assert.Len(t, res, 0)
    71  			return ctx
    72  		}).
    73  		Test("AddDefaultRulesForPrivileges", func(ctx f2.Context, t *testing.T) f2.Context {
    74  			data := rulesengine.RuleSets{
    75  				{
    76  					Privilege: "test",
    77  					Commands:  []string{"test"},
    78  				},
    79  			}
    80  			res, err := reng.AddDefaultRulesForPrivileges(ctx, data)
    81  			assert.NoError(t, err)
    82  			assert.Len(t, res.Errors, 0)
    83  			return ctx
    84  		}).
    85  		Test("GetDefaultRules with rules", func(ctx f2.Context, t *testing.T) f2.Context {
    86  			res, err := reng.GetDefaultRules(ctx, "test")
    87  			assert.NoError(t, err)
    88  			assert.EqualValues(t, []rulesengine.ReturnRuleSet{
    89  				{
    90  					Privilege: testPrivilege,
    91  					Commands: []rulesengine.Command{
    92  						testCommand,
    93  					},
    94  				},
    95  			}, res)
    96  			return ctx
    97  		}).
    98  		Feature()
    99  	f.Test(t, feat)
   100  }
   101  
   102  func TestIdempotentAPIs(t *testing.T) {
   103  	var (
   104  		reng = rulesengine.RulesEngine{}
   105  	)
   106  	feat := f2.NewFeature("Idempotent APIs").
   107  		Setup("Setup a new rules engine service", func(ctx f2.Context, t *testing.T) f2.Context {
   108  			reng = setupRulesEngineNoServer(ctx, t)
   109  			return ctx
   110  		},
   111  		).
   112  		Setup("Add new data to database", func(ctx f2.Context, t *testing.T) f2.Context {
   113  			res, err := reng.AddPrivileges(ctx, []rulesengine.PostPrivilegePayload{
   114  				{
   115  					Name: "test",
   116  				},
   117  			})
   118  			assert.NoError(t, err)
   119  			assert.Len(t, res.Conflicts, 0)
   120  			res, err = reng.AddCommands(ctx, []rulesengine.PostCommandPayload{
   121  				{
   122  					Name: "test",
   123  				},
   124  			})
   125  			assert.NoError(t, err)
   126  			assert.Len(t, res.Conflicts, 0)
   127  			return ctx
   128  		},
   129  		).
   130  		Test("AddPrivilege", func(ctx f2.Context, t *testing.T) f2.Context {
   131  			res, err := reng.AddPrivileges(ctx, []rulesengine.PostPrivilegePayload{
   132  				{
   133  					Name: "test",
   134  				},
   135  			})
   136  			assert.NoError(t, err)
   137  			assert.Len(t, res.Conflicts, 0)
   138  			return ctx
   139  		}).
   140  		Test("AddCommand", func(ctx f2.Context, t *testing.T) f2.Context {
   141  			res, err := reng.AddCommands(ctx, []rulesengine.PostCommandPayload{
   142  				{
   143  					Name: "test",
   144  				},
   145  			})
   146  			assert.NoError(t, err)
   147  			assert.Len(t, res.Conflicts, 0)
   148  			return ctx
   149  		},
   150  		).
   151  		Feature()
   152  	f.Test(t, feat)
   153  }
   154  

View as plain text