github.com/arunkumar7540/cli@v6.45.0+incompatible/actor/v7pushaction/actualize_test.go (about)

     1  package v7pushaction_test
     2  
     3  import (
     4  	"errors"
     5  	"fmt"
     6  
     7  	"code.cloudfoundry.org/cli/api/cloudcontroller/ccv3"
     8  
     9  	"code.cloudfoundry.org/cli/actor/sharedaction"
    10  	"code.cloudfoundry.org/cli/actor/v7action"
    11  	. "code.cloudfoundry.org/cli/actor/v7pushaction"
    12  	"code.cloudfoundry.org/cli/actor/v7pushaction/v7pushactionfakes"
    13  	. "github.com/onsi/ginkgo"
    14  	. "github.com/onsi/gomega"
    15  )
    16  
    17  func actualizedStreamsDrainedAndClosed(
    18  	configStream <-chan PushPlan,
    19  	eventStream <-chan Event,
    20  	warningsStream <-chan Warnings,
    21  	errorStream <-chan error,
    22  ) bool {
    23  	var configStreamClosed, eventStreamClosed, warningsStreamClosed, errorStreamClosed bool
    24  	for {
    25  		select {
    26  		case _, ok := <-configStream:
    27  			if !ok {
    28  				configStreamClosed = true
    29  			}
    30  		case _, ok := <-eventStream:
    31  			if !ok {
    32  				eventStreamClosed = true
    33  			}
    34  		case _, ok := <-warningsStream:
    35  			if !ok {
    36  				warningsStreamClosed = true
    37  			}
    38  		case _, ok := <-errorStream:
    39  			if !ok {
    40  				errorStreamClosed = true
    41  			}
    42  		}
    43  		if configStreamClosed && eventStreamClosed && warningsStreamClosed && errorStreamClosed {
    44  			break
    45  		}
    46  	}
    47  	return true
    48  }
    49  
    50  // TODO: for refactor: We can use the following style of code to validate that
    51  // each event is received in a specific order
    52  
    53  // Expect(nextEvent()).Should(Equal(SettingUpApplication))
    54  // Expect(nextEvent()).Should(Equal(CreatingApplication))
    55  // Expect(nextEvent()).Should(Equal(...))
    56  // Expect(nextEvent()).Should(Equal(...))
    57  // Expect(nextEvent()).Should(Equal(...))
    58  
    59  func buildV3Resource(name string) sharedaction.V3Resource {
    60  	return sharedaction.V3Resource{
    61  		FilePath:    name,
    62  		Checksum:    ccv3.Checksum{Value: fmt.Sprintf("checksum-%s", name)},
    63  		SizeInBytes: 6,
    64  	}
    65  }
    66  
    67  var _ = Describe("Actualize", func() {
    68  	var (
    69  		actor *Actor
    70  
    71  		plan            PushPlan
    72  		fakeProgressBar *v7pushactionfakes.FakeProgressBar
    73  
    74  		successfulChangeAppFuncCallCount int
    75  		warningChangeAppFuncCallCount    int
    76  		errorChangeAppFuncCallCount      int
    77  
    78  		planStream     <-chan PushPlan
    79  		eventStream    <-chan Event
    80  		warningsStream <-chan Warnings
    81  		errorStream    <-chan error
    82  
    83  		expectedPlan PushPlan
    84  	)
    85  
    86  	successfulChangeAppFunc := func(pushPlan PushPlan, eStream chan<- Event, progressBar ProgressBar) (PushPlan, Warnings, error) {
    87  		defer GinkgoRecover()
    88  
    89  		Expect(pushPlan).To(Equal(plan))
    90  		Expect(eStream).ToNot(BeNil())
    91  		Expect(progressBar).To(Equal(fakeProgressBar))
    92  
    93  		pushPlan.Application.GUID = "successful-app-guid"
    94  		successfulChangeAppFuncCallCount++
    95  		return pushPlan, nil, nil
    96  	}
    97  
    98  	warningChangeAppFunc := func(pushPlan PushPlan, eventStream chan<- Event, progressBar ProgressBar) (PushPlan, Warnings, error) {
    99  		pushPlan.Application.GUID = "warning-app-guid"
   100  		warningChangeAppFuncCallCount++
   101  		return pushPlan, Warnings{"warning-1", "warning-2"}, nil
   102  	}
   103  
   104  	errorChangeAppFunc := func(pushPlan PushPlan, eventStream chan<- Event, progressBar ProgressBar) (PushPlan, Warnings, error) {
   105  		pushPlan.Application.GUID = "error-app-guid"
   106  		errorChangeAppFuncCallCount++
   107  		return pushPlan, nil, errors.New("some error")
   108  	}
   109  
   110  	BeforeEach(func() {
   111  		actor, _, _, _ = getTestPushActor()
   112  
   113  		successfulChangeAppFuncCallCount = 0
   114  		warningChangeAppFuncCallCount = 0
   115  		errorChangeAppFuncCallCount = 0
   116  
   117  		fakeProgressBar = new(v7pushactionfakes.FakeProgressBar)
   118  		plan = PushPlan{
   119  			Application: v7action.Application{
   120  				Name: "some-app",
   121  				GUID: "some-app-guid",
   122  			},
   123  			SpaceGUID: "some-space-guid",
   124  		}
   125  
   126  		expectedPlan = plan
   127  	})
   128  
   129  	AfterEach(func() {
   130  		Eventually(actualizedStreamsDrainedAndClosed(planStream, eventStream, warningsStream, errorStream)).Should(BeTrue())
   131  	})
   132  
   133  	JustBeforeEach(func() {
   134  		planStream, eventStream, warningsStream, errorStream = actor.Actualize(plan, fakeProgressBar)
   135  	})
   136  
   137  	Describe("ChangeApplicationSequence", func() {
   138  		When("none of the ChangeApplicationSequence return errors", func() {
   139  			BeforeEach(func() {
   140  				actor.ChangeApplicationSequence = func(plan PushPlan) []ChangeApplicationFunc {
   141  					return []ChangeApplicationFunc{
   142  						successfulChangeAppFunc,
   143  						warningChangeAppFunc,
   144  					}
   145  				}
   146  			})
   147  
   148  			It("iterates over the actor's ChangeApplicationSequence", func() {
   149  				Eventually(warningsStream).Should(Receive(BeNil()))
   150  				expectedPlan.Application.GUID = "successful-app-guid"
   151  				Eventually(planStream).Should(Receive(Equal(expectedPlan)))
   152  
   153  				Eventually(warningsStream).Should(Receive(ConsistOf("warning-1", "warning-2")))
   154  				expectedPlan.Application.GUID = "warning-app-guid"
   155  				Eventually(planStream).Should(Receive(Equal(expectedPlan)))
   156  
   157  				Eventually(eventStream).Should(Receive(Equal(Complete)))
   158  
   159  				Expect(successfulChangeAppFuncCallCount).To(Equal(1))
   160  				Expect(warningChangeAppFuncCallCount).To(Equal(1))
   161  				Expect(errorChangeAppFuncCallCount).To(Equal(0))
   162  			})
   163  		})
   164  
   165  		When("the ChangeApplicationSequence return errors", func() {
   166  			BeforeEach(func() {
   167  				actor.ChangeApplicationSequence = func(plan PushPlan) []ChangeApplicationFunc {
   168  					return []ChangeApplicationFunc{
   169  						errorChangeAppFunc,
   170  						successfulChangeAppFunc,
   171  					}
   172  				}
   173  			})
   174  
   175  			It("iterates over the actor's ChangeApplicationSequence", func() {
   176  				Eventually(warningsStream).Should(Receive(BeNil()))
   177  				Eventually(errorStream).Should(Receive(MatchError("some error")))
   178  
   179  				Expect(successfulChangeAppFuncCallCount).To(Equal(0))
   180  				Expect(warningChangeAppFuncCallCount).To(Equal(0))
   181  				Expect(errorChangeAppFuncCallCount).To(Equal(1))
   182  
   183  				Consistently(eventStream).ShouldNot(Receive(Equal(Complete)))
   184  			})
   185  		})
   186  	})
   187  })