-
Notifications
You must be signed in to change notification settings - Fork 0
/
gfile_test.go
211 lines (167 loc) · 4.76 KB
/
gfile_test.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
package gfile_test
import (
"io/ioutil"
"os"
"time"
"github.com/BooleanCat/gfile"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/onsi/gomega/gbytes"
)
var Say = gbytes.Say
var _ = Describe("gfile", func() {
var (
err error
file *os.File
buffer *gfile.Buffer
)
Describe("#NewBuffer", func() {
BeforeEach(func() {
var fileErr error
file, fileErr = ioutil.TempFile("", "gfile")
Expect(fileErr).NotTo(HaveOccurred())
file.Close()
})
AfterEach(func() {
bufErr := buffer.Close()
Expect(bufErr).NotTo(HaveOccurred())
fileErr := os.Remove(file.Name())
Expect(fileErr).NotTo(HaveOccurred())
})
JustBeforeEach(func() {
buffer, err = gfile.NewBuffer(file.Name())
})
Context("when the target file exists", func() {
It("does not return an error", func() {
Expect(err).NotTo(HaveOccurred())
})
})
Context("when the target file does not exist", func() {
var badBuffer *gfile.Buffer
JustBeforeEach(func() {
badBuffer, err = gfile.NewBuffer("/foo/bar/baz")
})
It("returns an error", func() {
Expect(err).To(HaveOccurred())
})
It("returns nil", func() {
Expect(badBuffer).To(BeNil())
})
})
})
Describe("Buffer", func() {
BeforeEach(func() {
var fileErr error
file, fileErr = ioutil.TempFile("", "gfile")
Expect(fileErr).NotTo(HaveOccurred())
})
AfterEach(func() {
buffer.Close()
file.Close()
os.Remove(file.Name())
})
JustBeforeEach(func() {
buffer, err = gfile.NewBuffer(file.Name())
})
It("does not return an error", func() {
Expect(err).NotTo(HaveOccurred())
})
Context("when the target file has static contents", func() {
BeforeEach(func() {
_, err := file.WriteString("This is a line of text")
Expect(err).NotTo(HaveOccurred())
})
It("reads the contents of the file", func() {
Eventually(buffer).Should(Say("This is a line of text"))
})
})
Context("when the target file has multi-line static contents", func() {
var lines = "This is a line of text\nand this is another"
BeforeEach(func() {
_, err := file.WriteString(lines)
Expect(err).NotTo(HaveOccurred())
})
It("reads the contents of the file", func() {
Eventually(buffer).Should(Say(lines))
})
It("doesn't re-read the earlier file contents", func() {
Eventually(buffer).Should(Say("This is a line of text"))
Expect(buffer).NotTo(Say("This is a line of text"))
})
It("reads contents in sequence", func() {
Eventually(buffer).Should(Say("This is a line of text"))
Eventually(buffer).Should(Say("\nand this is another"))
})
})
Context("when the target file is continuously written to", func() {
var longLivedBuffer *gfile.Buffer
BeforeEach(func() {
var err error
longLivedBuffer, err = gfile.NewBuffer(file.Name())
Expect(err).NotTo(HaveOccurred())
_, err = file.WriteString("An initial line\n")
Expect(err).NotTo(HaveOccurred())
Eventually(longLivedBuffer).Should(Say("An initial line\n"))
_, err = file.WriteString("And then another line")
Expect(err).NotTo(HaveOccurred())
})
It("reads the new contents", func() {
Eventually(longLivedBuffer).Should(Say("And then another line"))
})
})
Context("when the target file is written to asynchronously", func() {
var syncChan chan bool
BeforeEach(func() {
syncChan = make(chan bool)
go func() {
time.Sleep(time.Millisecond * 250)
_, fileErr := file.WriteString("I came from a go func!")
Expect(fileErr).NotTo(HaveOccurred())
syncChan <- true
}()
})
AfterEach(func() {
<-syncChan
close(syncChan)
})
It("reads the new contents", func() {
Eventually(buffer).Should(Say("I came from a go func!"))
})
})
Context("when there are multiple buffers", func() {
BeforeEach(func() {
secondBuffer, err := gfile.NewBuffer(file.Name())
Expect(err).NotTo(HaveOccurred())
_, err = file.WriteString("Some line of text")
Expect(err).NotTo(HaveOccurred())
Eventually(secondBuffer).Should(Say("Some line of text"))
})
It("can read independently", func() {
Eventually(buffer).Should(Say("Some line of text"))
})
})
Describe("#Close", func() {
var closeErr error
JustBeforeEach(func() {
closeErr = buffer.Close()
})
It("does not return an error", func() {
Expect(closeErr).NotTo(HaveOccurred())
})
Context("when closed repeatedly", func() {
JustBeforeEach(func() {
Expect(closeErr).NotTo(HaveOccurred())
closeErr = buffer.Close()
})
It("does not return an error", func() {
Expect(closeErr).NotTo(HaveOccurred())
})
})
})
Describe("#Buffer", func() {
It("is a gbytes.Buffer", func() {
Expect(buffer.Buffer()).To(BeAssignableToTypeOf(gbytes.NewBuffer()))
})
})
})
})