github.com/xmidt-org/webpa-common@v1.11.9/service/monitor/monitor_test.go (about) 1 package monitor 2 3 import ( 4 "errors" 5 "testing" 6 "time" 7 8 "github.com/go-kit/kit/sd" 9 "github.com/stretchr/testify/assert" 10 "github.com/stretchr/testify/mock" 11 "github.com/stretchr/testify/require" 12 "github.com/xmidt-org/webpa-common/logging" 13 "github.com/xmidt-org/webpa-common/service" 14 ) 15 16 func testNewNoInstances(t *testing.T) { 17 var ( 18 assert = assert.New(t) 19 20 m, err = New( 21 WithLogger(nil), 22 WithFilter(NopFilter), 23 WithClosed(nil), 24 WithListeners(), 25 ) 26 ) 27 28 assert.Nil(m) 29 assert.Error(err) 30 } 31 32 func testNewStop(t *testing.T) { 33 var ( 34 assert = assert.New(t) 35 require = require.New(t) 36 logger = logging.NewTestLogger(nil, t) 37 38 instancer = new(service.MockInstancer) 39 listener = new(mockListener) 40 registerQueue = make(chan chan<- sd.Event, 1) 41 sdEvents chan<- sd.Event 42 expectedError = errors.New("expected") 43 expectedInstances = []string{"instance1", "instance2"} 44 45 monitorEvents = make(chan Event, 5) 46 ) 47 48 instancer.On("Register", mock.AnythingOfType("chan<- sd.Event")). 49 Run(func(arguments mock.Arguments) { 50 registerQueue <- arguments.Get(0).(chan<- sd.Event) 51 }).Once() 52 53 instancer.On("Deregister", mock.AnythingOfType("chan<- sd.Event")). 54 Run(func(arguments mock.Arguments) { 55 registerQueue <- arguments.Get(0).(chan<- sd.Event) 56 }).Once() 57 58 listener.On("MonitorEvent", mock.MatchedBy(func(Event) bool { return true })).Run(func(arguments mock.Arguments) { 59 monitorEvents <- arguments.Get(0).(Event) 60 }) 61 62 m, err := New( 63 WithLogger(logger), 64 WithFilter(nil), 65 WithListeners(listener), 66 WithInstancers(service.Instancers{"test": instancer}), 67 ) 68 69 require.NoError(err) 70 require.NotNil(m) 71 72 select { 73 case sdEvents = <-registerQueue: 74 case <-time.After(5 * time.Second): 75 m.Stop() 76 require.Fail("Failed to receive registered event channel") 77 return 78 } 79 80 sdEvents <- sd.Event{Err: expectedError} 81 select { 82 case event := <-monitorEvents: 83 assert.Equal("test", event.Key) 84 assert.Equal(instancer, event.Instancer) 85 assert.Equal(expectedError, event.Err) 86 assert.Len(event.Instances, 0) 87 assert.False(event.Stopped) 88 assert.Equal(1, event.EventCount) 89 90 case <-time.After(5 * time.Second): 91 assert.Fail("Failed to receive monitor event") 92 } 93 94 sdEvents <- sd.Event{Instances: expectedInstances} 95 select { 96 case event := <-monitorEvents: 97 assert.Equal("test", event.Key) 98 assert.Equal(instancer, event.Instancer) 99 assert.NoError(event.Err) 100 assert.Equal(expectedInstances, event.Instances) 101 assert.False(event.Stopped) 102 assert.Equal(2, event.EventCount) 103 104 case <-time.After(5 * time.Second): 105 assert.Fail("Failed to receive monitor event") 106 } 107 108 m.Stop() 109 select { 110 case deregistered := <-registerQueue: 111 assert.Equal(sdEvents, deregistered) 112 case <-time.After(5 * time.Second): 113 assert.Fail("Failed to deregister") 114 } 115 116 select { 117 case finalEvent := <-monitorEvents: 118 assert.Equal("test", finalEvent.Key) 119 assert.Equal(instancer, finalEvent.Instancer) 120 assert.NoError(finalEvent.Err) 121 assert.Len(finalEvent.Instances, 0) 122 assert.True(finalEvent.Stopped) 123 assert.Equal(2, finalEvent.EventCount) 124 125 case <-time.After(5 * time.Second): 126 assert.Fail("No stopped event received") 127 } 128 129 select { 130 case <-m.Stopped(): 131 // passing 132 case <-time.After(5 * time.Second): 133 assert.Fail("Failed to signal stopped channel") 134 } 135 136 // idempotency 137 m.Stop() 138 select { 139 case <-m.Stopped(): 140 // passing 141 case <-time.After(5 * time.Second): 142 assert.Fail("Failed to signal stopped channel") 143 } 144 145 instancer.AssertExpectations(t) 146 listener.AssertExpectations(t) 147 } 148 149 func testNewWithEnvironment(t *testing.T) { 150 var ( 151 assert = assert.New(t) 152 require = require.New(t) 153 logger = logging.NewTestLogger(nil, t) 154 155 instancer = new(service.MockInstancer) 156 listener = new(mockListener) 157 registerQueue = make(chan chan<- sd.Event, 1) 158 sdEvents chan<- sd.Event 159 expectedError = errors.New("expected") 160 expectedInstances = []string{"instance1", "instance2"} 161 162 monitorEvents = make(chan Event, 5) 163 ) 164 165 e := service.NewEnvironment( 166 service.WithInstancers(service.Instancers{"test": instancer}), 167 ) 168 169 require.NotNil(e) 170 171 instancer.On("Register", mock.AnythingOfType("chan<- sd.Event")). 172 Run(func(arguments mock.Arguments) { 173 registerQueue <- arguments.Get(0).(chan<- sd.Event) 174 }).Once() 175 176 instancer.On("Deregister", mock.AnythingOfType("chan<- sd.Event")). 177 Run(func(arguments mock.Arguments) { 178 registerQueue <- arguments.Get(0).(chan<- sd.Event) 179 }).Once() 180 181 instancer.On("Stop").Once() 182 183 listener.On("MonitorEvent", mock.MatchedBy(func(Event) bool { return true })).Run(func(arguments mock.Arguments) { 184 monitorEvents <- arguments.Get(0).(Event) 185 }) 186 187 m, err := New( 188 WithLogger(logger), 189 WithFilter(nil), 190 WithListeners(listener), 191 WithEnvironment(e), 192 ) 193 194 require.NoError(err) 195 require.NotNil(m) 196 197 select { 198 case sdEvents = <-registerQueue: 199 case <-time.After(5 * time.Second): 200 m.Stop() 201 require.Fail("Failed to receive registered event channel") 202 return 203 } 204 205 sdEvents <- sd.Event{Err: expectedError} 206 select { 207 case event := <-monitorEvents: 208 assert.Equal("test", event.Key) 209 assert.Equal(instancer, event.Instancer) 210 assert.Equal(expectedError, event.Err) 211 assert.Len(event.Instances, 0) 212 assert.False(event.Stopped) 213 assert.Equal(1, event.EventCount) 214 215 case <-time.After(5 * time.Second): 216 assert.Fail("Failed to receive monitor event") 217 } 218 219 sdEvents <- sd.Event{Instances: expectedInstances} 220 select { 221 case event := <-monitorEvents: 222 assert.Equal("test", event.Key) 223 assert.Equal(instancer, event.Instancer) 224 assert.NoError(event.Err) 225 assert.Equal(expectedInstances, event.Instances) 226 assert.False(event.Stopped) 227 assert.Equal(2, event.EventCount) 228 229 case <-time.After(5 * time.Second): 230 assert.Fail("Failed to receive monitor event") 231 } 232 233 assert.NoError(e.Close()) 234 select { 235 case deregistered := <-registerQueue: 236 assert.Equal(sdEvents, deregistered) 237 case <-time.After(5 * time.Second): 238 assert.Fail("Failed to deregister") 239 } 240 241 select { 242 case finalEvent := <-monitorEvents: 243 assert.Equal("test", finalEvent.Key) 244 assert.Equal(instancer, finalEvent.Instancer) 245 assert.NoError(finalEvent.Err) 246 assert.Len(finalEvent.Instances, 0) 247 assert.True(finalEvent.Stopped) 248 assert.Equal(2, finalEvent.EventCount) 249 250 case <-time.After(5 * time.Second): 251 assert.Fail("No stopped event received") 252 } 253 254 select { 255 case <-m.Stopped(): 256 // passing 257 case <-time.After(5 * time.Second): 258 assert.Fail("Failed to signal stopped channel") 259 } 260 261 // idempotency 262 m.Stop() 263 select { 264 case <-m.Stopped(): 265 // passing 266 case <-time.After(5 * time.Second): 267 assert.Fail("Failed to signal stopped channel") 268 } 269 270 instancer.AssertExpectations(t) 271 listener.AssertExpectations(t) 272 } 273 274 func TestNew(t *testing.T) { 275 t.Run("NoInstances", testNewNoInstances) 276 t.Run("Stop", testNewStop) 277 t.Run("WithEnvironment", testNewWithEnvironment) 278 }