1 package matchers_test
2
3 import (
4 "time"
5
6 . "github.com/onsi/gomega/matchers"
7
8 . "github.com/onsi/ginkgo/v2"
9 . "github.com/onsi/gomega"
10 )
11
12 var _ = Describe("BeSent", func() {
13 When("passed a channel and a matching type", func() {
14 When("the channel is ready to receive", func() {
15 It("should succeed and send the value down the channel", func() {
16 c := make(chan string)
17 d := make(chan string)
18 go func() {
19 val := <-c
20 d <- val
21 }()
22
23 time.Sleep(10 * time.Millisecond)
24
25 Expect(c).Should(BeSent("foo"))
26 Eventually(d).Should(Receive(Equal("foo")))
27 })
28
29 It("should succeed (with a buffered channel)", func() {
30 c := make(chan string, 1)
31 Expect(c).Should(BeSent("foo"))
32 Expect(<-c).Should(Equal("foo"))
33 })
34 })
35
36 When("the channel is not ready to receive", func() {
37 It("should fail and not send down the channel", func() {
38 c := make(chan string)
39 Expect(c).ShouldNot(BeSent("foo"))
40 Consistently(c).ShouldNot(Receive())
41 })
42 })
43
44 When("the channel is eventually ready to receive", func() {
45 It("should succeed", func() {
46 c := make(chan string)
47 d := make(chan string)
48 go func() {
49 time.Sleep(30 * time.Millisecond)
50 val := <-c
51 d <- val
52 }()
53
54 Eventually(c).Should(BeSent("foo"))
55 Eventually(d).Should(Receive(Equal("foo")))
56 })
57 })
58
59 When("the channel is closed", func() {
60 It("should error", func() {
61 c := make(chan string)
62 close(c)
63 success, err := (&BeSentMatcher{Arg: "foo"}).Match(c)
64 Expect(success).Should(BeFalse())
65 Expect(err).Should(HaveOccurred())
66 })
67
68 It("should short-circuit Eventually", func() {
69 c := make(chan string)
70 close(c)
71
72 t := time.Now()
73 failures := InterceptGomegaFailures(func() {
74 Eventually(c, 10.0).Should(BeSent("foo"))
75 })
76 Expect(failures).Should(HaveLen(1))
77 Expect(time.Since(t)).Should(BeNumerically("<", time.Second))
78 })
79 })
80 })
81
82 When("passed a channel and a non-matching type", func() {
83 It("should error", func() {
84 success, err := (&BeSentMatcher{Arg: "foo"}).Match(make(chan int, 1))
85 Expect(success).Should(BeFalse())
86 Expect(err).Should(HaveOccurred())
87 })
88 })
89
90 When("passed a receive-only channel", func() {
91 It("should error", func() {
92 var c <-chan string
93 c = make(chan string, 1)
94 success, err := (&BeSentMatcher{Arg: "foo"}).Match(c)
95 Expect(success).Should(BeFalse())
96 Expect(err).Should(HaveOccurred())
97 })
98 })
99
100 When("passed a nonchannel", func() {
101 It("should error", func() {
102 success, err := (&BeSentMatcher{Arg: "foo"}).Match("bar")
103 Expect(success).Should(BeFalse())
104 Expect(err).Should(HaveOccurred())
105 })
106 })
107 })
108
View as plain text