event-factory_test.go

Documentation: sigs.k8s.io/cli-utils/pkg/apply/prune

     1  // Copyright 2019 The Kubernetes Authors.
     2  // SPDX-License-Identifier: Apache-2.0
     3  
     4  package prune
     5  
     6  import (
     7  	"fmt"
     8  	"testing"
     9  
    10  	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
    11  	"sigs.k8s.io/cli-utils/pkg/apply/event"
    12  	"sigs.k8s.io/cli-utils/pkg/object"
    13  )
    14  
    15  func TestEventFactory(t *testing.T) {
    16  	tests := map[string]struct {
    17  		destroy      bool
    18  		obj          *unstructured.Unstructured
    19  		skippedErr   error
    20  		failedErr    error
    21  		expectedType event.Type
    22  	}{
    23  		"prune events": {
    24  			destroy:      false,
    25  			obj:          pod,
    26  			skippedErr:   fmt.Errorf("fake reason"),
    27  			expectedType: event.PruneType,
    28  		},
    29  		"delete events": {
    30  			destroy:      true,
    31  			obj:          pdb,
    32  			skippedErr:   fmt.Errorf("fake reason"),
    33  			expectedType: event.DeleteType,
    34  		},
    35  	}
    36  	for name, tc := range tests {
    37  		t.Run(name, func(t *testing.T) {
    38  			id := object.UnstructuredToObjMetadata(tc.obj)
    39  			eventFactory := CreateEventFactory(tc.destroy, "task-0")
    40  			// Validate the "success" event"
    41  			actualEvent := eventFactory.CreateSuccessEvent(tc.obj)
    42  			if tc.expectedType != actualEvent.Type {
    43  				t.Errorf("success event expected type (%s), got (%s)",
    44  					tc.expectedType, actualEvent.Type)
    45  			}
    46  			var actualObj *unstructured.Unstructured
    47  			var err error
    48  			if tc.expectedType == event.PruneType {
    49  				if event.PruneSuccessful != actualEvent.PruneEvent.Status {
    50  					t.Errorf("success event expected status (PruneSuccessful), got (%s)",
    51  						actualEvent.PruneEvent.Status)
    52  				}
    53  				actualObj = actualEvent.PruneEvent.Object
    54  				err = actualEvent.PruneEvent.Error
    55  			} else {
    56  				if event.DeleteSuccessful != actualEvent.DeleteEvent.Status {
    57  					t.Errorf("success event expected status (DeleteSuccessful), got (%s)",
    58  						actualEvent.DeleteEvent.Status)
    59  				}
    60  				actualObj = actualEvent.DeleteEvent.Object
    61  				err = actualEvent.DeleteEvent.Error
    62  			}
    63  			if tc.obj != actualObj {
    64  				t.Errorf("expected event object (%v), got (%v)", tc.obj, actualObj)
    65  			}
    66  			if err != nil {
    67  				t.Errorf("success event expected nil error, got (%s)", err)
    68  			}
    69  			// Validate the "skipped" event"
    70  			actualEvent = eventFactory.CreateSkippedEvent(tc.obj, tc.skippedErr)
    71  			if tc.expectedType != actualEvent.Type {
    72  				t.Errorf("skipped event expected type (%s), got (%s)",
    73  					tc.expectedType, actualEvent.Type)
    74  			}
    75  			if tc.expectedType == event.PruneType {
    76  				if event.PruneSkipped != actualEvent.PruneEvent.Status {
    77  					t.Errorf("skipped event expected status (PruneSkipped), got (%s)",
    78  						actualEvent.PruneEvent.Status)
    79  				}
    80  				actualObj = actualEvent.PruneEvent.Object
    81  				err = actualEvent.PruneEvent.Error
    82  			} else {
    83  				if event.DeleteSkipped != actualEvent.DeleteEvent.Status {
    84  					t.Errorf("skipped event expected status (DeleteSkipped), got (%s)",
    85  						actualEvent.DeleteEvent.Status)
    86  				}
    87  				actualObj = actualEvent.DeleteEvent.Object
    88  				err = actualEvent.DeleteEvent.Error
    89  			}
    90  			if tc.obj != actualObj {
    91  				t.Errorf("expected event object (%v), got (%v)", tc.obj, actualObj)
    92  			}
    93  			if tc.skippedErr != err {
    94  				t.Errorf("skipped event expected error (%s), got (%s)", tc.skippedErr, err)
    95  			}
    96  			// Validate the "failed" event"
    97  			actualEvent = eventFactory.CreateFailedEvent(id, tc.failedErr)
    98  			if tc.expectedType != actualEvent.Type {
    99  				t.Errorf("failed event expected type (%s), got (%s)",
   100  					tc.expectedType, actualEvent.Type)
   101  			}
   102  			if tc.expectedType != actualEvent.Type {
   103  				t.Errorf("failed event expected type (%s), got (%s)",
   104  					tc.expectedType, actualEvent.Type)
   105  			}
   106  			if tc.expectedType == event.PruneType {
   107  				err = actualEvent.PruneEvent.Error
   108  			} else {
   109  				err = actualEvent.DeleteEvent.Error
   110  			}
   111  			if tc.failedErr != err {
   112  				t.Errorf("failed event expected error (%s), got (%s)", tc.failedErr, err)
   113  			}
   114  		})
   115  	}
   116  }
   117
View as plain text