Example #1
0
			var timesCh chan []time.Time
			var done chan struct{}

			BeforeEach(func() {
				keepAliveDuration = 100 * time.Millisecond

				times = []time.Time{}
				timesCh = make(chan []time.Time, 1)
				done = make(chan struct{}, 1)

				fakeConnection.SendRequestStub = func(reqName string, wantReply bool, message []byte) (bool, []byte, error) {
					Expect(reqName).To(Equal("*****@*****.**"))
					Expect(wantReply).To(BeTrue())
					Expect(message).To(BeNil())

					times = append(times, time.Now())
					if len(times) == 3 {
						timesCh <- times
						close(done)
					}
					return true, nil, nil
				}

				fakeSecureSession.WaitStub = func() error {
					Eventually(done).Should(BeClosed())
					return nil
				}
			})

			It("sends keep alive messages at the expected interval", func() {
				times := <-timesCh
				Expect(times[2]).To(BeTemporally("~", times[0].Add(200*time.Millisecond), 100*time.Millisecond))
Example #2
0
				Expect(payload).To(Equal([]byte("test-data")))

				reqType, wantReply, payload = sshConn.SendRequestArgsForCall(1)
				Expect(reqType).To(Equal("test"))
				Expect(wantReply).To(BeFalse())
				Expect(payload).To(Equal([]byte("test-data")))
			})
		})

		Context("when SendRequest fails", func() {
			BeforeEach(func() {
				callCount := 0
				sshConn.SendRequestStub = func(rt string, wr bool, p []byte) (bool, []byte, error) {
					callCount++
					if callCount == 1 {
						return false, nil, errors.New("woops")
					}
					return true, nil, nil
				}

				reqChan <- &ssh.Request{}
				reqChan <- &ssh.Request{}
			})

			AfterEach(func() {
				close(reqChan)
			})

			It("continues processing requests", func() {
				Eventually(sshConn.SendRequestCallCount).Should(Equal(2))
			})