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  }