github.com/dcarley/cf-cli@v6.24.1-0.20170220111324-4225ff346898+incompatible/actor/v2action/logging_test.go (about)

     1  package v2action_test
     2  
     3  import (
     4  	"errors"
     5  	"time"
     6  
     7  	. "code.cloudfoundry.org/cli/actor/v2action"
     8  	"code.cloudfoundry.org/cli/actor/v2action/v2actionfakes"
     9  	"github.com/cloudfoundry/sonde-go/events"
    10  	. "github.com/onsi/ginkgo"
    11  	. "github.com/onsi/gomega"
    12  )
    13  
    14  var _ = Describe("Logging Actions", func() {
    15  	var (
    16  		actor          Actor
    17  		fakeNOAAClient *v2actionfakes.FakeNOAAClient
    18  	)
    19  
    20  	BeforeEach(func() {
    21  		fakeNOAAClient = new(v2actionfakes.FakeNOAAClient)
    22  		actor = NewActor(nil, nil)
    23  	})
    24  
    25  	Describe("GetStreamingLogs", func() {
    26  		var (
    27  			expectedAppGUID string
    28  
    29  			messages    <-chan *LogMessage
    30  			errs        <-chan error
    31  			eventStream chan *events.LogMessage
    32  			errStream   chan error
    33  		)
    34  
    35  		BeforeEach(func() {
    36  			expectedAppGUID = "some-app-guid"
    37  
    38  			eventStream = make(chan *events.LogMessage)
    39  			errStream = make(chan error)
    40  		})
    41  
    42  		// If tests panic due to this close, it is likely you have a failing
    43  		// expectation and the channels are being closed because the test has
    44  		// failed/short circuited and is going through teardown.
    45  		AfterEach(func() {
    46  			close(eventStream)
    47  			close(errStream)
    48  
    49  			Eventually(messages).Should(BeClosed())
    50  			Eventually(errs).Should(BeClosed())
    51  		})
    52  
    53  		Context("when receiving events", func() {
    54  			BeforeEach(func() {
    55  				fakeNOAAClient.TailingLogsStub = func(appGUID string, authToken string) (<-chan *events.LogMessage, <-chan error) {
    56  					Expect(appGUID).To(Equal(expectedAppGUID))
    57  					Expect(authToken).To(BeEmpty())
    58  
    59  					go func() {
    60  						outMessage := events.LogMessage_OUT
    61  						ts1 := int64(10)
    62  						sourceType := "some-source-type"
    63  						sourceInstance := "some-source-instance"
    64  
    65  						eventStream <- &events.LogMessage{
    66  							Message:        []byte("message-1"),
    67  							MessageType:    &outMessage,
    68  							Timestamp:      &ts1,
    69  							SourceType:     &sourceType,
    70  							SourceInstance: &sourceInstance,
    71  						}
    72  
    73  						errMessage := events.LogMessage_ERR
    74  						ts2 := int64(20)
    75  
    76  						eventStream <- &events.LogMessage{
    77  							Message:        []byte("message-2"),
    78  							MessageType:    &errMessage,
    79  							Timestamp:      &ts2,
    80  							SourceType:     &sourceType,
    81  							SourceInstance: &sourceInstance,
    82  						}
    83  					}()
    84  
    85  					return eventStream, errStream
    86  				}
    87  			})
    88  
    89  			It("converts them to log messages and passes them through the messages channel", func() {
    90  				messages, errs = actor.GetStreamingLogs(expectedAppGUID, fakeNOAAClient)
    91  
    92  				message := <-messages
    93  				Expect(message.Message()).To(Equal("message-1"))
    94  				Expect(message.Type()).To(Equal("OUT"))
    95  				Expect(message.Timestamp()).To(Equal(time.Unix(0, 10)))
    96  				Expect(message.SourceType()).To(Equal("some-source-type"))
    97  				Expect(message.SourceInstance()).To(Equal("some-source-instance"))
    98  
    99  				message = <-messages
   100  				Expect(message.Message()).To(Equal("message-2"))
   101  				Expect(message.Type()).To(Equal("ERR"))
   102  				Expect(message.Timestamp()).To(Equal(time.Unix(0, 20)))
   103  				Expect(message.SourceType()).To(Equal("some-source-type"))
   104  				Expect(message.SourceInstance()).To(Equal("some-source-instance"))
   105  			})
   106  		})
   107  
   108  		Context("when receiving errors", func() {
   109  			var err1, err2 error
   110  
   111  			BeforeEach(func() {
   112  				err1 = errors.New("ZOMG")
   113  				err2 = errors.New("Fiddlesticks")
   114  
   115  				fakeNOAAClient.TailingLogsStub = func(_ string, _ string) (<-chan *events.LogMessage, <-chan error) {
   116  					go func() {
   117  						errStream <- err1
   118  						errStream <- err2
   119  					}()
   120  
   121  					return eventStream, errStream
   122  				}
   123  			})
   124  
   125  			It("passes them through the errors channel", func() {
   126  				messages, errs = actor.GetStreamingLogs(expectedAppGUID, fakeNOAAClient)
   127  
   128  				err := <-errs
   129  				Expect(err).To(MatchError(err1))
   130  
   131  				err = <-errs
   132  				Expect(err).To(MatchError(err2))
   133  			})
   134  		})
   135  	})
   136  })