github.com/xmidt-org/webpa-common@v1.11.9/xhttp/gate/gate_test.go (about)

     1  package gate
     2  
     3  import (
     4  	"testing"
     5  	"time"
     6  
     7  	"github.com/go-kit/kit/metrics/generic"
     8  	"github.com/stretchr/testify/assert"
     9  	"github.com/stretchr/testify/require"
    10  )
    11  
    12  func testNewString(t *testing.T) {
    13  	var (
    14  		assert  = assert.New(t)
    15  		require = require.New(t)
    16  
    17  		g1 = New(true)
    18  		g2 = New(false)
    19  	)
    20  
    21  	require.NotNil(g1)
    22  	require.NotNil(g2)
    23  	assert.NotEqual(g2.String(), g1.String())
    24  }
    25  
    26  func testNewInitiallyOpen(t *testing.T, g Interface) {
    27  	var (
    28  		assert  = assert.New(t)
    29  		require = require.New(t)
    30  
    31  		expectedTimestamp = time.Now()
    32  	)
    33  
    34  	g.(*gate).now = func() time.Time { return expectedTimestamp }
    35  
    36  	require.NotNil(g)
    37  	assert.True(g.Open())
    38  	state, initialTimestamp := g.State()
    39  	assert.True(state)
    40  	assert.False(initialTimestamp.IsZero())
    41  
    42  	assert.False(g.Raise())
    43  	assert.True(g.Open())
    44  	state, actualTimestamp := g.State()
    45  	assert.True(state)
    46  	assert.Equal(initialTimestamp, actualTimestamp)
    47  
    48  	assert.True(g.Lower())
    49  	assert.False(g.Open())
    50  	state, actualTimestamp = g.State()
    51  	assert.False(state)
    52  	assert.Equal(expectedTimestamp.UTC(), actualTimestamp)
    53  
    54  	assert.False(g.Lower())
    55  	assert.False(g.Open())
    56  	state, actualTimestamp = g.State()
    57  	assert.False(state)
    58  	assert.Equal(expectedTimestamp.UTC(), actualTimestamp)
    59  
    60  	assert.True(g.Raise())
    61  	assert.True(g.Open())
    62  	state, actualTimestamp = g.State()
    63  	assert.True(state)
    64  	assert.Equal(expectedTimestamp.UTC(), actualTimestamp)
    65  }
    66  
    67  func testNewInitiallyClosed(t *testing.T, g Interface) {
    68  	var (
    69  		assert  = assert.New(t)
    70  		require = require.New(t)
    71  
    72  		expectedTimestamp = time.Now()
    73  	)
    74  
    75  	g.(*gate).now = func() time.Time { return expectedTimestamp }
    76  
    77  	require.NotNil(g)
    78  	assert.False(g.Open())
    79  	state, initialTimestamp := g.State()
    80  	assert.False(state)
    81  	assert.False(initialTimestamp.IsZero())
    82  
    83  	assert.False(g.Lower())
    84  	assert.False(g.Open())
    85  	state, actualTimestamp := g.State()
    86  	assert.False(state)
    87  	assert.Equal(initialTimestamp, actualTimestamp)
    88  
    89  	assert.True(g.Raise())
    90  	assert.True(g.Open())
    91  	state, actualTimestamp = g.State()
    92  	assert.True(state)
    93  	assert.Equal(expectedTimestamp.UTC(), actualTimestamp)
    94  
    95  	assert.False(g.Raise())
    96  	assert.True(g.Open())
    97  	state, actualTimestamp = g.State()
    98  	assert.True(state)
    99  	assert.Equal(expectedTimestamp.UTC(), actualTimestamp)
   100  
   101  	assert.True(g.Lower())
   102  	assert.False(g.Open())
   103  	state, actualTimestamp = g.State()
   104  	assert.False(state)
   105  	assert.Equal(expectedTimestamp.UTC(), actualTimestamp)
   106  }
   107  
   108  func testNewInitiallyOpenWithGauge(t *testing.T) {
   109  	var (
   110  		assert  = assert.New(t)
   111  		require = require.New(t)
   112  
   113  		gauge = generic.NewGauge("test")
   114  		g     = New(true, WithGauge(gauge))
   115  	)
   116  
   117  	require.NotNil(g)
   118  	assert.True(g.Open())
   119  	assert.Equal(Open, gauge.Value())
   120  
   121  	assert.False(g.Raise())
   122  	assert.True(g.Open())
   123  	assert.Equal(Open, gauge.Value())
   124  
   125  	assert.True(g.Lower())
   126  	assert.False(g.Open())
   127  	assert.Equal(Closed, gauge.Value())
   128  
   129  	assert.False(g.Lower())
   130  	assert.False(g.Open())
   131  	assert.Equal(Closed, gauge.Value())
   132  
   133  	assert.True(g.Raise())
   134  	assert.True(g.Open())
   135  	assert.Equal(Open, gauge.Value())
   136  }
   137  
   138  func testNewInitiallyClosedWithGauge(t *testing.T) {
   139  	var (
   140  		assert  = assert.New(t)
   141  		require = require.New(t)
   142  
   143  		gauge = generic.NewGauge("test")
   144  		g     = New(false, WithGauge(gauge))
   145  	)
   146  
   147  	require.NotNil(g)
   148  	assert.False(g.Open())
   149  	assert.Equal(Closed, gauge.Value())
   150  
   151  	assert.False(g.Lower())
   152  	assert.False(g.Open())
   153  	assert.Equal(Closed, gauge.Value())
   154  
   155  	assert.True(g.Raise())
   156  	assert.True(g.Open())
   157  	assert.Equal(Open, gauge.Value())
   158  
   159  	assert.False(g.Raise())
   160  	assert.True(g.Open())
   161  	assert.Equal(Open, gauge.Value())
   162  
   163  	assert.True(g.Lower())
   164  	assert.False(g.Open())
   165  	assert.Equal(Closed, gauge.Value())
   166  }
   167  
   168  func TestNew(t *testing.T) {
   169  	t.Run("String", testNewString)
   170  
   171  	t.Run("InitiallyOpen", func(t *testing.T) {
   172  		testNewInitiallyOpen(t, New(true))
   173  		testNewInitiallyOpen(t, New(true, WithGauge(nil)))
   174  
   175  		t.Run("WithGauge", testNewInitiallyOpenWithGauge)
   176  	})
   177  
   178  	t.Run("InitiallyClosed", func(t *testing.T) {
   179  		testNewInitiallyClosed(t, New(false))
   180  		testNewInitiallyClosed(t, New(false, WithGauge(nil)))
   181  
   182  		t.Run("WithGauge", testNewInitiallyClosedWithGauge)
   183  	})
   184  }