rule_test.go

Documentation: edge-infra.dev/pkg/edge/edgeadmin/commands/operatorintervention/delete

     1  //nolint:dupl
     2  package delete
     3  
     4  import (
     5  	"context"
     6  	"encoding/json"
     7  	"errors"
     8  	"strings"
     9  	"testing"
    10  	"time"
    11  
    12  	"github.com/stretchr/testify/require"
    13  
    14  	"edge-infra.dev/pkg/edge/api/fake"
    15  	"edge-infra.dev/pkg/edge/api/graph/model"
    16  	"edge-infra.dev/pkg/edge/edgecli"
    17  	"edge-infra.dev/pkg/edge/edgecli/flagutil"
    18  	"edge-infra.dev/pkg/lib/cli/rags"
    19  )
    20  
    21  type DeleteOperatorInterventionRuleResponse struct {
    22  	DeleteCommandFromOperatorInterventionRule model.DeleteOperatorInterventionRuleResponse `json:"deleteCommandFromOperatorInterventionRule"`
    23  }
    24  
    25  // Mocks the DeleteOperatorInterventionRuleResponse. Returns an error
    26  // response when the privilege `bad-privilege` is sent, otherwise returns a
    27  // non-error response
    28  func DeleteCommandFromOperatorInterventionRule(body []byte) (interface{}, bool, error) {
    29  	if !strings.Contains(string(body), "deleteCommandFromOperatorInterventionRule(rule: $rule)") {
    30  		return nil, false, nil
    31  	}
    32  
    33  	// This callback should handle the response
    34  	var ok = true
    35  
    36  	var m struct {
    37  		Query     string
    38  		Variables struct {
    39  			Rule struct {
    40  				Command   string
    41  				Privilege string
    42  			}
    43  		}
    44  	}
    45  	err := json.Unmarshal(body, &m)
    46  	if err != nil {
    47  		return nil, ok, err
    48  	}
    49  
    50  	var errors []*model.OperatorInterventionErrorResponse
    51  	if m.Variables.Rule.Privilege == "bad-privilege" {
    52  		errors = []*model.OperatorInterventionErrorResponse{{
    53  			Type:      model.OperatorInterventionErrorTypeUnknownRule,
    54  			Privilege: &m.Variables.Rule.Privilege,
    55  			Command:   &m.Variables.Rule.Command,
    56  		}}
    57  	}
    58  	return DeleteOperatorInterventionRuleResponse{
    59  		DeleteCommandFromOperatorInterventionRule: model.DeleteOperatorInterventionRuleResponse{
    60  			Errors: errors,
    61  		},
    62  	}, ok, nil
    63  }
    64  
    65  func TestDeleteRule(t *testing.T) {
    66  	t.Parallel()
    67  
    68  	edgeAPIMockSvr := fake.GetMockAPIServer(DeleteCommandFromOperatorInterventionRule)
    69  	edgeAPIMockURL := edgeAPIMockSvr.URL + "/api/v2"
    70  	t.Cleanup(func() {
    71  		edgeAPIMockSvr.Close()
    72  	})
    73  
    74  	tests := map[string]struct {
    75  		flagsFunc func(*rags.RagSet) error
    76  		expError  require.ErrorAssertionFunc
    77  	}{
    78  		"No Flags": {
    79  			flagsFunc: func(*rags.RagSet) error { return nil },
    80  			expError:  require.Error,
    81  		},
    82  		"Only privilege flag": {
    83  			flagsFunc: func(c *rags.RagSet) error {
    84  				return flagutil.SetFlag(c, flagutil.OIPrivilege, "abcd")
    85  			},
    86  			expError: require.Error,
    87  		},
    88  		"Only command flag": {
    89  			flagsFunc: func(c *rags.RagSet) error {
    90  				return flagutil.SetFlag(c, flagutil.OICommand, "abcd")
    91  			},
    92  			expError: require.Error,
    93  		},
    94  		"Delete with no errors": {
    95  			flagsFunc: func(c *rags.RagSet) error {
    96  				return errors.Join(
    97  					flagutil.SetFlag(c, flagutil.OIPrivilege, "abcd"),
    98  					flagutil.SetFlag(c, flagutil.OICommand, "efgh"),
    99  				)
   100  			},
   101  			expError: require.NoError,
   102  		},
   103  		"Delete returned error": {
   104  			flagsFunc: func(c *rags.RagSet) error {
   105  				return errors.Join(
   106  					flagutil.SetFlag(c, flagutil.OIPrivilege, "bad-privilege"),
   107  					flagutil.SetFlag(c, flagutil.OICommand, "efgh"),
   108  				)
   109  			},
   110  			expError: require.Error,
   111  		},
   112  	}
   113  
   114  	for name, tc := range tests {
   115  		tc := tc
   116  		t.Run(name, func(t *testing.T) {
   117  			t.Parallel()
   118  
   119  			// Set a dummy token in a fake banner context so that we bypass the
   120  			// ValidateConnectionFlags check which would otherwise do a login
   121  			// mutation to the api server, something which is not supported by
   122  			// the fake server
   123  			future := time.Now().Add(time.Hour * 24)
   124  			testConfig := edgecli.Config{
   125  				CurrentBannerContext: "fakeBanner",
   126  				BannerContexts: map[string]*edgecli.BannerContext{
   127  					"fakeBanner": {
   128  						TokenTime: future.Format(time.RFC3339),
   129  						Token:     "fakeToken",
   130  						Endpoint:  edgeAPIMockURL,
   131  					},
   132  				},
   133  			}
   134  
   135  			cmd := NewDeleteRule(&testConfig)
   136  			cmd.Command() // Required to initialise cmd.Rags
   137  
   138  			require.NoError(t, tc.flagsFunc(cmd.Rags))
   139  
   140  			err := cmd.Command().Exec(context.Background(), []string{})
   141  			tc.expError(t, err)
   142  		})
   143  	}
   144  }
   145
View as plain text