1 package progress
2
3 import (
4 "math"
5 "os"
6 "testing"
7 "time"
8
9 "github.com/stretchr/testify/assert"
10 )
11
12 func TestProgress_AppendTracker(t *testing.T) {
13 p := Progress{}
14 assert.Equal(t, 0, len(p.trackersInQueue))
15
16 tracker := &Tracker{}
17 assert.Equal(t, int64(0), tracker.Total)
18 p.AppendTracker(tracker)
19 assert.Equal(t, 1, len(p.trackersInQueue))
20 assert.Equal(t, int64(0), tracker.Total)
21
22 tracker2 := &Tracker{Total: -1}
23 assert.Equal(t, int64(-1), tracker2.Total)
24 p.AppendTracker(tracker2)
25 assert.Equal(t, 2, len(p.trackersInQueue))
26 assert.Equal(t, int64(math.MaxInt64), tracker2.Total)
27 }
28
29 func TestProgress_AppendTrackers(t *testing.T) {
30 p := Progress{}
31 assert.Equal(t, 0, len(p.trackersInQueue))
32
33 p.AppendTrackers([]*Tracker{{}, {}})
34 assert.Equal(t, 2, len(p.trackersInQueue))
35 }
36
37 func TestProgress_IsRenderInProgress(t *testing.T) {
38 p := Progress{}
39 assert.False(t, p.IsRenderInProgress())
40
41 p.renderInProgress = true
42 assert.True(t, p.IsRenderInProgress())
43 }
44
45 func TestProgress_Length(t *testing.T) {
46 p := Progress{}
47 assert.Equal(t, 0, p.Length())
48
49 p.trackersActive = append(p.trackersActive, &Tracker{})
50 assert.Equal(t, 1, p.Length())
51 p.trackersInQueue = append(p.trackersInQueue, &Tracker{})
52 assert.Equal(t, 2, p.Length())
53 p.trackersDone = append(p.trackersDone, &Tracker{})
54 assert.Equal(t, 3, p.Length())
55 }
56
57 func TestProgress_LengthActive(t *testing.T) {
58 p := Progress{}
59 assert.Equal(t, 0, p.Length())
60 assert.Equal(t, 0, p.LengthActive())
61
62 p.trackersActive = append(p.trackersActive, &Tracker{})
63 assert.Equal(t, 1, p.Length())
64 assert.Equal(t, 1, p.LengthActive())
65 p.trackersInQueue = append(p.trackersInQueue, &Tracker{})
66 assert.Equal(t, 2, p.Length())
67 assert.Equal(t, 2, p.LengthActive())
68 }
69
70 func TestProgress_LengthDone(t *testing.T) {
71 p := Progress{}
72 assert.Equal(t, 0, p.Length())
73 assert.Equal(t, 0, p.LengthDone())
74
75 p.trackersDone = append(p.trackersDone, &Tracker{})
76 assert.Equal(t, 1, p.Length())
77 assert.Equal(t, 1, p.LengthDone())
78 }
79
80 func TestProgress_LengthInQueue(t *testing.T) {
81 p := Progress{}
82 assert.Equal(t, 0, p.Length())
83 assert.Equal(t, 0, p.LengthInQueue())
84
85 p.trackersInQueue = append(p.trackersInQueue, &Tracker{})
86 assert.Equal(t, 1, p.Length())
87 assert.Equal(t, 1, p.LengthInQueue())
88 }
89
90 func TestProgress_Log(t *testing.T) {
91 p := Progress{}
92 assert.Len(t, p.logsToRender, 0)
93
94 p.Log("testing log")
95 assert.Len(t, p.logsToRender, 1)
96 }
97
98 func TestProgress_SetAutoStop(t *testing.T) {
99 p := Progress{}
100 assert.False(t, p.autoStop)
101
102 p.SetAutoStop(true)
103 assert.True(t, p.autoStop)
104 }
105
106 func TestProgress_SetNumTrackersExpected(t *testing.T) {
107 p := Progress{}
108 assert.Equal(t, int64(0), p.numTrackersExpected)
109
110 p.SetNumTrackersExpected(5)
111 assert.Equal(t, int64(5), p.numTrackersExpected)
112 }
113
114 func TestProgress_SetOutputWriter(t *testing.T) {
115 p := Progress{}
116 assert.Nil(t, p.outputWriter)
117
118 p.SetOutputWriter(os.Stdout)
119 assert.Equal(t, os.Stdout, p.outputWriter)
120 }
121
122 func TestProgress_SetSortBy(t *testing.T) {
123 p := Progress{}
124 assert.Zero(t, p.sortBy)
125
126 p.SetSortBy(SortByMessage)
127 assert.Equal(t, SortByMessage, p.sortBy)
128 }
129
130 func TestProgress_SetStyle(t *testing.T) {
131 p := Progress{}
132 assert.Nil(t, p.style)
133
134 p.SetStyle(StyleCircle)
135 assert.Equal(t, StyleCircle.Name, p.Style().Name)
136 }
137
138 func TestProgress_SetTrackerLength(t *testing.T) {
139 p := Progress{}
140 assert.Equal(t, 0, p.lengthTracker)
141
142 p.initForRender()
143 assert.Equal(t, DefaultLengthTracker, p.lengthTracker)
144
145 p.SetTrackerLength(80)
146 assert.Equal(t, 80, p.lengthTracker)
147 }
148
149 func TestProgress_SetTrackerPosition(t *testing.T) {
150 p := Progress{}
151 assert.Equal(t, PositionLeft, p.trackerPosition)
152
153 p.SetTrackerPosition(PositionRight)
154 assert.Equal(t, PositionRight, p.trackerPosition)
155 }
156
157 func TestProgress_SetUpdateFrequency(t *testing.T) {
158 p := Progress{}
159 assert.Equal(t, time.Duration(0), p.updateFrequency)
160
161 p.initForRender()
162 assert.Equal(t, DefaultUpdateFrequency, p.updateFrequency)
163
164 p.SetUpdateFrequency(time.Duration(time.Second))
165 assert.Equal(t, time.Duration(time.Second), p.updateFrequency)
166 }
167
168 func TestProgress_ShowETA(t *testing.T) {
169 p := Progress{}
170 assert.False(t, p.Style().Visibility.ETA)
171
172 p.ShowETA(true)
173 assert.True(t, p.Style().Visibility.ETA)
174 }
175
176 func TestProgress_ShowOverallTracker(t *testing.T) {
177 p := Progress{}
178 assert.False(t, p.Style().Visibility.TrackerOverall)
179
180 p.ShowOverallTracker(true)
181 assert.True(t, p.Style().Visibility.TrackerOverall)
182 }
183
184 func TestProgress_ShowPercentage(t *testing.T) {
185 p := Progress{}
186 assert.True(t, p.Style().Visibility.Percentage)
187
188 p.ShowPercentage(false)
189 assert.False(t, p.Style().Visibility.Percentage)
190 }
191
192 func TestProgress_ShowTime(t *testing.T) {
193 p := Progress{}
194 assert.True(t, p.Style().Visibility.Time)
195
196 p.ShowTime(false)
197 assert.False(t, p.Style().Visibility.Time)
198 }
199
200 func TestProgress_ShowTracker(t *testing.T) {
201 p := Progress{}
202 assert.True(t, p.Style().Visibility.Tracker)
203
204 p.ShowTracker(false)
205 assert.False(t, p.Style().Visibility.Tracker)
206 }
207
208 func TestProgress_ShowValue(t *testing.T) {
209 p := Progress{}
210 assert.True(t, p.Style().Visibility.Value)
211
212 p.ShowValue(false)
213 assert.False(t, p.Style().Visibility.Value)
214 }
215
216 func TestProgress_Stop(t *testing.T) {
217 doneChannel := make(chan bool, 1)
218
219 p := Progress{}
220 p.done = doneChannel
221 p.renderInProgress = true
222 p.Stop()
223 assert.True(t, <-doneChannel)
224 }
225
226 func TestProgress_Style(t *testing.T) {
227 p := Progress{}
228 assert.Nil(t, p.style)
229
230 assert.NotNil(t, p.Style())
231 assert.Equal(t, StyleDefault.Name, p.Style().Name)
232 }
233
View as plain text