github.com/cloudfoundry-community/cloudfoundry-cli@v6.44.1-0.20240130060226-cda5ed8e89a5+incompatible/actor/v7action/feature_flag_test.go (about)

     1  package v7action_test
     2  
     3  import (
     4  	"code.cloudfoundry.org/cli/resources"
     5  	"errors"
     6  
     7  	"code.cloudfoundry.org/cli/actor/actionerror"
     8  	. "code.cloudfoundry.org/cli/actor/v7action"
     9  	"code.cloudfoundry.org/cli/actor/v7action/v7actionfakes"
    10  	"code.cloudfoundry.org/cli/api/cloudcontroller/ccerror"
    11  	"code.cloudfoundry.org/cli/api/cloudcontroller/ccv3"
    12  	. "github.com/onsi/ginkgo"
    13  	. "github.com/onsi/gomega"
    14  )
    15  
    16  var _ = Describe("FeatureFlag", func() {
    17  	var (
    18  		actor                     *Actor
    19  		fakeCloudControllerClient *v7actionfakes.FakeCloudControllerClient
    20  	)
    21  
    22  	BeforeEach(func() {
    23  		actor, fakeCloudControllerClient, _, _, _ = NewTestActor()
    24  	})
    25  
    26  	Describe("GetFeatureFlagByName", func() {
    27  		var (
    28  			featureFlagName = "flag1"
    29  			featureFlag     FeatureFlag
    30  			warnings        Warnings
    31  			executeErr      error
    32  		)
    33  
    34  		JustBeforeEach(func() {
    35  			featureFlag, warnings, executeErr = actor.GetFeatureFlagByName(featureFlagName)
    36  		})
    37  
    38  		When("getting feature flag fails", func() {
    39  			BeforeEach(func() {
    40  				fakeCloudControllerClient.GetFeatureFlagReturns(
    41  					resources.FeatureFlag{},
    42  					ccv3.Warnings{"this is a warning"},
    43  					errors.New("some-error"))
    44  			})
    45  
    46  			It("returns warnings and error", func() {
    47  				Expect(executeErr).To(MatchError("some-error"))
    48  				Expect(warnings).To(ConsistOf("this is a warning"))
    49  				Expect(fakeCloudControllerClient.GetFeatureFlagCallCount()).To(Equal(1))
    50  				nameArg := fakeCloudControllerClient.GetFeatureFlagArgsForCall(0)
    51  				Expect(nameArg).To(Equal(featureFlagName))
    52  			})
    53  		})
    54  
    55  		When("no feature flag is returned", func() {
    56  			BeforeEach(func() {
    57  				var ccFeatureFlag resources.FeatureFlag
    58  
    59  				fakeCloudControllerClient.GetFeatureFlagReturns(
    60  					ccFeatureFlag,
    61  					ccv3.Warnings{"this is a warning"},
    62  					ccerror.FeatureFlagNotFoundError{})
    63  			})
    64  
    65  			It("returns warnings and a FeatureFlagNotFoundError", func() {
    66  				Expect(executeErr).To(MatchError(actionerror.FeatureFlagNotFoundError{FeatureFlagName: featureFlagName}))
    67  				Expect(warnings).To(ConsistOf("this is a warning"))
    68  			})
    69  		})
    70  
    71  		When("getting feature flag is successful", func() {
    72  
    73  			BeforeEach(func() {
    74  				featureFlagName = "flag1"
    75  				ccFeatureFlag := resources.FeatureFlag{Name: "flag1"}
    76  				fakeCloudControllerClient.GetFeatureFlagReturns(
    77  					ccFeatureFlag,
    78  					ccv3.Warnings{"this is a warning"},
    79  					nil)
    80  			})
    81  
    82  			It("Returns the proper featureFlag", func() {
    83  				Expect(executeErr).ToNot(HaveOccurred())
    84  				Expect(warnings).To(ConsistOf("this is a warning"))
    85  				Expect(featureFlag).To(Equal(FeatureFlag{Name: "flag1"}))
    86  			})
    87  		})
    88  	})
    89  
    90  	Describe("GetFeatureFlags", func() {
    91  		var (
    92  			featureFlags []FeatureFlag
    93  			warnings     Warnings
    94  			executeErr   error
    95  		)
    96  
    97  		JustBeforeEach(func() {
    98  			featureFlags, warnings, executeErr = actor.GetFeatureFlags()
    99  		})
   100  
   101  		When("The client is successful", func() {
   102  			BeforeEach(func() {
   103  				fakeCloudControllerClient.GetFeatureFlagsReturns(
   104  					[]resources.FeatureFlag{
   105  						{
   106  							Name:    "flag1",
   107  							Enabled: false,
   108  						},
   109  						{
   110  							Name:    "flag2",
   111  							Enabled: true,
   112  						},
   113  					},
   114  					ccv3.Warnings{"some-cc-warning"},
   115  					nil,
   116  				)
   117  			})
   118  
   119  			It("Returns the list of feature flags", func() {
   120  				Expect(executeErr).ToNot(HaveOccurred())
   121  				Expect(warnings).To(ConsistOf(Warnings{"some-cc-warning"}))
   122  				Expect(featureFlags).To(ConsistOf(
   123  					FeatureFlag{
   124  						Name:    "flag1",
   125  						Enabled: false,
   126  					},
   127  					FeatureFlag{
   128  						Name:    "flag2",
   129  						Enabled: true,
   130  					},
   131  				))
   132  			})
   133  		})
   134  
   135  		When("The client errors", func() {
   136  			BeforeEach(func() {
   137  				fakeCloudControllerClient.GetFeatureFlagsReturns(nil, ccv3.Warnings{"some-cc-warning"}, errors.New("some-error"))
   138  			})
   139  
   140  			It("Returns the error", func() {
   141  				Expect(executeErr).To(MatchError(errors.New("some-error")))
   142  				Expect(warnings).To(ConsistOf("some-cc-warning"))
   143  			})
   144  		})
   145  	})
   146  
   147  	Describe("EnableFeatureFlag", func() {
   148  		var (
   149  			flagName        string
   150  			ccFlag          resources.FeatureFlag
   151  			expectedArgFlag resources.FeatureFlag
   152  			warnings        Warnings
   153  			executeErr      error
   154  		)
   155  
   156  		BeforeEach(func() {
   157  			flagName = "flag1"
   158  			ccFlag = resources.FeatureFlag{Name: flagName, Enabled: true}
   159  			expectedArgFlag = resources.FeatureFlag{Name: flagName, Enabled: true}
   160  		})
   161  
   162  		JustBeforeEach(func() {
   163  			warnings, executeErr = actor.EnableFeatureFlag(flagName)
   164  		})
   165  
   166  		When("The flag exists", func() {
   167  			BeforeEach(func() {
   168  				fakeCloudControllerClient.UpdateFeatureFlagReturns(
   169  					ccFlag,
   170  					ccv3.Warnings{"update-warning"},
   171  					nil,
   172  				)
   173  			})
   174  
   175  			It("returns warnings and no error", func() {
   176  				Expect(executeErr).ToNot(HaveOccurred())
   177  				Expect(warnings).To(Equal(Warnings{"update-warning"}))
   178  				Expect(fakeCloudControllerClient.UpdateFeatureFlagCallCount()).To(Equal(1))
   179  				argFlag := fakeCloudControllerClient.UpdateFeatureFlagArgsForCall(0)
   180  				Expect(argFlag).To(Equal(expectedArgFlag))
   181  			})
   182  		})
   183  
   184  		When("the flag doesn't exist", func() {
   185  			BeforeEach(func() {
   186  				fakeCloudControllerClient.UpdateFeatureFlagReturns(
   187  					resources.FeatureFlag{},
   188  					ccv3.Warnings{"update-warning"},
   189  					ccerror.FeatureFlagNotFoundError{},
   190  				)
   191  			})
   192  			It("returns warnings and a FeatureFlagNotFoundError", func() {
   193  				Expect(executeErr).To(MatchError(actionerror.FeatureFlagNotFoundError{FeatureFlagName: flagName}))
   194  				Expect(warnings).To(Equal(Warnings{"update-warning"}))
   195  				Expect(fakeCloudControllerClient.UpdateFeatureFlagCallCount()).To(Equal(1))
   196  				argFlag := fakeCloudControllerClient.UpdateFeatureFlagArgsForCall(0)
   197  				Expect(argFlag).To(Equal(expectedArgFlag))
   198  			})
   199  		})
   200  
   201  		When("the client errors", func() {
   202  			BeforeEach(func() {
   203  				fakeCloudControllerClient.UpdateFeatureFlagReturns(
   204  					resources.FeatureFlag{},
   205  					ccv3.Warnings{"update-warning"},
   206  					errors.New("some-random-error"),
   207  				)
   208  			})
   209  			It("returns warnings and a FeatureFlagNotFoundError", func() {
   210  				Expect(executeErr).To(MatchError(errors.New("some-random-error")))
   211  				Expect(warnings).To(Equal(Warnings{"update-warning"}))
   212  				Expect(fakeCloudControllerClient.UpdateFeatureFlagCallCount()).To(Equal(1))
   213  				argFlag := fakeCloudControllerClient.UpdateFeatureFlagArgsForCall(0)
   214  				Expect(argFlag).To(Equal(expectedArgFlag))
   215  			})
   216  		})
   217  	})
   218  
   219  	Describe("EnableFeatureFlag", func() {
   220  		var (
   221  			flagName        string
   222  			ccFlag          resources.FeatureFlag
   223  			expectedArgFlag resources.FeatureFlag
   224  			warnings        Warnings
   225  			executeErr      error
   226  		)
   227  
   228  		BeforeEach(func() {
   229  			flagName = "flag1"
   230  			ccFlag = resources.FeatureFlag{Name: flagName, Enabled: true}
   231  			expectedArgFlag = resources.FeatureFlag{Name: flagName, Enabled: false}
   232  		})
   233  
   234  		JustBeforeEach(func() {
   235  			warnings, executeErr = actor.DisableFeatureFlag(flagName)
   236  		})
   237  
   238  		When("The flag exists", func() {
   239  			BeforeEach(func() {
   240  				fakeCloudControllerClient.UpdateFeatureFlagReturns(
   241  					ccFlag,
   242  					ccv3.Warnings{"update-warning"},
   243  					nil,
   244  				)
   245  			})
   246  
   247  			It("returns warnings and no error", func() {
   248  				Expect(executeErr).ToNot(HaveOccurred())
   249  				Expect(warnings).To(Equal(Warnings{"update-warning"}))
   250  				Expect(fakeCloudControllerClient.UpdateFeatureFlagCallCount()).To(Equal(1))
   251  				argFlag := fakeCloudControllerClient.UpdateFeatureFlagArgsForCall(0)
   252  				Expect(argFlag).To(Equal(expectedArgFlag))
   253  			})
   254  		})
   255  
   256  		When("the flag doesn't exist", func() {
   257  			BeforeEach(func() {
   258  				fakeCloudControllerClient.UpdateFeatureFlagReturns(
   259  					resources.FeatureFlag{},
   260  					ccv3.Warnings{"update-warning"},
   261  					ccerror.FeatureFlagNotFoundError{},
   262  				)
   263  			})
   264  			It("returns warnings and a FeatureFlagNotFoundError", func() {
   265  				Expect(executeErr).To(MatchError(actionerror.FeatureFlagNotFoundError{FeatureFlagName: flagName}))
   266  				Expect(warnings).To(Equal(Warnings{"update-warning"}))
   267  				Expect(fakeCloudControllerClient.UpdateFeatureFlagCallCount()).To(Equal(1))
   268  				argFlag := fakeCloudControllerClient.UpdateFeatureFlagArgsForCall(0)
   269  				Expect(argFlag).To(Equal(expectedArgFlag))
   270  			})
   271  		})
   272  
   273  		When("the client errors", func() {
   274  			BeforeEach(func() {
   275  				fakeCloudControllerClient.UpdateFeatureFlagReturns(
   276  					resources.FeatureFlag{},
   277  					ccv3.Warnings{"update-warning"},
   278  					errors.New("some-random-error"),
   279  				)
   280  			})
   281  			It("returns warnings and a FeatureFlagNotFoundError", func() {
   282  				Expect(executeErr).To(MatchError(errors.New("some-random-error")))
   283  				Expect(warnings).To(Equal(Warnings{"update-warning"}))
   284  				Expect(fakeCloudControllerClient.UpdateFeatureFlagCallCount()).To(Equal(1))
   285  				argFlag := fakeCloudControllerClient.UpdateFeatureFlagArgsForCall(0)
   286  				Expect(argFlag).To(Equal(expectedArgFlag))
   287  			})
   288  		})
   289  	})
   290  })