github.com/xmidt-org/webpa-common@v1.11.9/hash/serviceHash_test.go (about)

     1  package hash
     2  
     3  import (
     4  	"errors"
     5  	"github.com/stretchr/testify/assert"
     6  	"github.com/xmidt-org/webpa-common/concurrent"
     7  	"sync"
     8  	"testing"
     9  	"time"
    10  )
    11  
    12  const (
    13  	testKey = "this value does not matter"
    14  )
    15  
    16  var (
    17  	successMessage1 = "first success message"
    18  	successMessage2 = "second success message"
    19  	errorMessage1   = "first error message"
    20  	errorMessage2   = "second error message"
    21  )
    22  
    23  type errorServiceHash string
    24  
    25  func (hash errorServiceHash) Get([]byte) (string, error) {
    26  	return "", errors.New(string(hash))
    27  }
    28  
    29  type successServiceHash string
    30  
    31  func (hash successServiceHash) Get([]byte) (string, error) {
    32  	return string(hash), nil
    33  }
    34  
    35  func TestServiceHashHolderUninitialized(t *testing.T) {
    36  	assert := assert.New(t)
    37  	var holder ServiceHashHolder
    38  	assert.False(holder.Connected())
    39  
    40  	value, err := holder.Get([]byte(testKey))
    41  	assert.Equal(ServiceHashHolderUninitialized, err)
    42  	assert.Empty(value)
    43  }
    44  
    45  func TestServiceHashHolderGet(t *testing.T) {
    46  	assert := assert.New(t)
    47  	var gets = []struct {
    48  		value        *string
    49  		errorMessage *string
    50  	}{
    51  		{&successMessage1, nil},
    52  		{nil, &errorMessage1},
    53  		{&successMessage2, nil},
    54  		{nil, &errorMessage2},
    55  		{&successMessage2, nil},
    56  		{&successMessage1, nil},
    57  		{nil, &errorMessage2},
    58  	}
    59  
    60  	var holder ServiceHashHolder
    61  	assert.False(holder.Connected())
    62  
    63  	for _, record := range gets {
    64  		if record.value != nil {
    65  			holder.Update(successServiceHash(*record.value))
    66  			actual, err := holder.Get([]byte(testKey))
    67  			assert.Equal(*record.value, actual)
    68  			assert.Nil(err)
    69  		} else {
    70  			holder.Update(errorServiceHash(*record.errorMessage))
    71  			actual, err := holder.Get([]byte(testKey))
    72  			assert.Empty(actual)
    73  			assert.NotNil(err)
    74  		}
    75  	}
    76  }
    77  
    78  func TestServiceHashHolderConcurrent(t *testing.T) {
    79  	assert := assert.New(t)
    80  
    81  	var holder ServiceHashHolder
    82  	assert.False(holder.Connected())
    83  
    84  	available := []ServiceHash{
    85  		successServiceHash(successMessage1),
    86  		errorServiceHash(errorMessage1),
    87  		successServiceHash(successMessage2),
    88  		errorServiceHash(errorMessage2),
    89  	}
    90  
    91  	const getCount int = 100
    92  	updates := make(chan ServiceHash, getCount)
    93  	for index := 0; index < getCount; index++ {
    94  		updates <- available[index%len(available)]
    95  	}
    96  
    97  	close(updates)
    98  	const routineCount int = 3
    99  	waitGroup := &sync.WaitGroup{}
   100  	waitGroup.Add(routineCount)
   101  	for index := 0; index < routineCount; index++ {
   102  		go func() {
   103  			defer waitGroup.Done()
   104  			holder.Get([]byte(testKey))
   105  
   106  			for update := range updates {
   107  				holder.Update(update)
   108  				holder.Get([]byte(testKey))
   109  			}
   110  		}()
   111  	}
   112  
   113  	assert.True(concurrent.WaitTimeout(waitGroup, 15*time.Second))
   114  }