tasklog/log_test.go

   1 package tasklog
   2
   3 import (
   4         "bytes"
   5         "strings"
   6         "testing"
   7         "time"
   8
   9         "github.com/stretchr/testify/assert"
  10 )
  11
  12 type ChanTask chan *Update
  13
  14 func (e ChanTask) Updates() <-chan *Update { return e }
  15
  16 func (e ChanTask) Throttled() bool { return true }
  17
  18 type UnthrottledChanTask chan *Update
  19
  20 func (e UnthrottledChanTask) Updates() <-chan *Update { return e }
  21
  22 func (e UnthrottledChanTask) Throttled() bool { return false }
  23
  24 func TestLoggerLogsTasks(t *testing.T) {
  25         var buf bytes.Buffer
  26
  27         task := make(chan *Update)
  28         go func() {
  29                 task <- &Update{"first", time.Now(), false}
  30                 task <- &Update{"second", time.Now(), false}
  31                 close(task)
  32         }()
  33
  34         l := NewLogger(&buf)
  35         l.throttle = 0
  36         l.widthFn = func() int { return 0 }
  37         l.Enqueue(ChanTask(task))
  38         l.Close()
  39
  40         assert.Equal(t, "first\rsecond\rsecond, done\n", buf.String())
  41 }
  42
  43 func TestLoggerLogsMultipleTasksInOrder(t *testing.T) {
  44         var buf bytes.Buffer
  45
  46         t1 := make(chan *Update)
  47         go func() {
  48                 t1 <- &Update{"first", time.Now(), false}
  49                 t1 <- &Update{"second", time.Now(), false}
  50                 close(t1)
  51         }()
  52         t2 := make(chan *Update)
  53         go func() {
  54                 t2 <- &Update{"third", time.Now(), false}
  55                 t2 <- &Update{"fourth", time.Now(), false}
  56                 close(t2)
  57         }()
  58
  59         l := NewLogger(&buf)
  60         l.throttle = 0
  61         l.widthFn = func() int { return 0 }
  62         l.Enqueue(ChanTask(t1), ChanTask(t2))
  63         l.Close()
  64
  65         assert.Equal(t, strings.Join([]string{
  66                 "first\r",
  67                 "second\r",
  68                 "second, done\n",
  69                 "third\r",
  70                 "fourth\r",
  71                 "fourth, done\n",
  72         }, ""), buf.String())
  73 }
  74
  75 func TestLoggerLogsMultipleTasksWithoutBlocking(t *testing.T) {
  76         var buf bytes.Buffer
  77
  78         l := NewLogger(&buf)
  79         l.throttle = 0
  80         t1, t2 := make(chan *Update), make(chan *Update)
  81
  82         l.widthFn = func() int { return 0 }
  83         l.Enqueue(ChanTask(t1))
  84
  85         t1 <- &Update{"first", time.Now(), false}
  86         l.Enqueue(ChanTask(t2))
  87         close(t1)
  88         t2 <- &Update{"second", time.Now(), false}
  89         close(t2)
  90
  91         l.Close()
  92
  93         assert.Equal(t, strings.Join([]string{
  94                 "first\r",
  95                 "first, done\n",
  96                 "second\r",
  97                 "second, done\n",
  98         }, ""), buf.String())
  99 }
 100
 101 func TestLoggerThrottlesWrites(t *testing.T) {
 102         var buf bytes.Buffer
 103
 104         t1 := make(chan *Update)
 105         go func() {
 106                 start := time.Now()
 107
 108                 t1 <- &Update{"first", start, false}                             // t = 0     ms, throttle was open
 109                 t1 <- &Update{"forced", start.Add(10 * time.Millisecond), true}  // t = 10+ε  ms, throttle is closed
 110                 t1 <- &Update{"second", start.Add(10 * time.Millisecond), false} // t = 10+ε  ms, throttle is closed
 111                 t1 <- &Update{"third", start.Add(26 * time.Millisecond), false}  // t = 20+ε  ms, throttle was open
 112                 close(t1)                                                        // t = 20+2ε ms, throttle is closed
 113         }()
 114
 115         l := NewLogger(&buf)
 116         l.widthFn = func() int { return 0 }
 117         l.throttle = 15 * time.Millisecond
 118
 119         l.Enqueue(ChanTask(t1))
 120         l.Close()
 121
 122         assert.Equal(t, strings.Join([]string{
 123                 "first\r",
 124                 "forced\r",
 125                 "third\r",
 126                 "third, done\n",
 127         }, ""), buf.String())
 128 }
 129
 130 func TestLoggerThrottlesLastWrite(t *testing.T) {
 131         var buf bytes.Buffer
 132
 133         t1 := make(chan *Update)
 134         go func() {
 135                 start := time.Now()
 136
 137                 t1 <- &Update{"first", start, false}                             // t = 0     ms, throttle was open
 138                 t1 <- &Update{"second", start.Add(10 * time.Millisecond), false} // t = 10+ε  ms, throttle is closed
 139                 close(t1)                                                        // t = 10+2ε ms, throttle is closed
 140         }()
 141
 142         l := NewLogger(&buf)
 143         l.widthFn = func() int { return 0 }
 144         l.throttle = 15 * time.Millisecond
 145
 146         l.Enqueue(ChanTask(t1))
 147         l.Close()
 148
 149         assert.Equal(t, strings.Join([]string{
 150                 "first\r",
 151                 "second, done\n",
 152         }, ""), buf.String())
 153 }
 154
 155 func TestLoggerLogsAllDurableUpdates(t *testing.T) {
 156         var buf bytes.Buffer
 157
 158         l := NewLogger(&buf)
 159         l.widthFn = func() int { return 0 }
 160         l.throttle = 15 * time.Minute
 161
 162         t1 := make(chan *Update)
 163         go func() {
 164                 t1 <- &Update{"first", time.Now(), false}  // t = 0+ε  ms, throttle is open
 165                 t1 <- &Update{"second", time.Now(), false} // t = 0+2ε ms, throttle is closed
 166                 close(t1)                                  // t = 0+3ε ms, throttle is closed
 167         }()
 168
 169         l.Enqueue(UnthrottledChanTask(t1))
 170         l.Close()
 171
 172         assert.Equal(t, strings.Join([]string{
 173                 "first\r",
 174                 "second\r",
 175                 "second, done\n",
 176         }, ""), buf.String())
 177 }
 178
 179 func TestLoggerHandlesSilentTasks(t *testing.T) {
 180         var buf bytes.Buffer
 181
 182         task := make(chan *Update)
 183         close(task)
 184
 185         l := NewLogger(&buf)
 186         l.Enqueue(ChanTask(task))
 187         l.Close()
 188
 189         assert.Equal(t, "", buf.String())
 190 }