github.com/observiq/carbon@v0.9.11-0.20200820160507-1b872e368a5e/operator/buffer/buffer_test.go (about)

     1  package buffer
     2  
     3  import (
     4  	"context"
     5  	"encoding/json"
     6  	"sync"
     7  	"testing"
     8  	"time"
     9  
    10  	"github.com/observiq/carbon/entry"
    11  	"github.com/observiq/carbon/operator"
    12  	"github.com/stretchr/testify/require"
    13  	"go.uber.org/zap"
    14  	yaml "gopkg.in/yaml.v2"
    15  )
    16  
    17  type bufferHandler struct {
    18  	flushed []*entry.Entry
    19  	mux     sync.Mutex
    20  	notify  chan struct{}
    21  }
    22  
    23  func (b *bufferHandler) ProcessMulti(ctx context.Context, entries []*entry.Entry) error {
    24  	b.mux.Lock()
    25  	b.flushed = append(b.flushed, entries...)
    26  	b.mux.Unlock()
    27  	b.notify <- struct{}{}
    28  	return nil
    29  }
    30  
    31  func (b *bufferHandler) Logger() *zap.SugaredLogger {
    32  	return nil
    33  }
    34  
    35  func TestBuffer(t *testing.T) {
    36  	config := NewConfig()
    37  	config.DelayThreshold = operator.Duration{
    38  		Duration: 100 * time.Millisecond,
    39  	}
    40  
    41  	buf := NewMemoryBuffer(&config)
    42  	numEntries := 10000
    43  
    44  	bh := bufferHandler{
    45  		flushed: make([]*entry.Entry, 0),
    46  		notify:  make(chan struct{}),
    47  	}
    48  	buf.SetHandler(&bh)
    49  
    50  	for i := 0; i < numEntries; i++ {
    51  		err := buf.AddWait(context.Background(), entry.New(), 0)
    52  		require.NoError(t, err)
    53  	}
    54  
    55  	for {
    56  		select {
    57  		case <-bh.notify:
    58  			bh.mux.Lock()
    59  			if len(bh.flushed) == numEntries {
    60  				bh.mux.Unlock()
    61  				return
    62  			}
    63  			bh.mux.Unlock()
    64  		case <-time.After(time.Second):
    65  			require.FailNow(t, "timed out waiting for all entries to be flushed")
    66  		}
    67  	}
    68  }
    69  
    70  func TestBufferSerializationRoundtrip(t *testing.T) {
    71  	cases := []struct {
    72  		name   string
    73  		config Config
    74  	}{
    75  		{
    76  			"zeros",
    77  			Config{},
    78  		},
    79  		{
    80  			"defaults",
    81  			NewConfig(),
    82  		},
    83  	}
    84  
    85  	for _, tc := range cases {
    86  		t.Run("yaml "+tc.name, func(t *testing.T) {
    87  			cfgBytes, err := yaml.Marshal(tc.config)
    88  			require.NoError(t, err)
    89  
    90  			var cfg Config
    91  			err = yaml.UnmarshalStrict(cfgBytes, &cfg)
    92  			require.NoError(t, err)
    93  
    94  			require.Equal(t, tc.config, cfg)
    95  		})
    96  
    97  		t.Run("json "+tc.name, func(t *testing.T) {
    98  			tc := tc
    99  			cfgBytes, err := json.Marshal(tc.config)
   100  			require.NoError(t, err)
   101  
   102  			var cfg Config
   103  			err = json.Unmarshal(cfgBytes, &cfg)
   104  			require.NoError(t, err)
   105  
   106  			require.Equal(t, tc.config, cfg)
   107  		})
   108  	}
   109  }