store_test.go

Documentation: github.com/prometheus/alertmanager/store

     1  // Copyright 2018 Prometheus Team
     2  // Licensed under the Apache License, Version 2.0 (the "License");
     3  // you may not use this file except in compliance with the License.
     4  // You may obtain a copy of the License at
     5  //
     6  // http://www.apache.org/licenses/LICENSE-2.0
     7  //
     8  // Unless required by applicable law or agreed to in writing, software
     9  // distributed under the License is distributed on an "AS IS" BASIS,
    10  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    11  // See the License for the specific language governing permissions and
    12  // limitations under the License.
    13  
    14  package store
    15  
    16  import (
    17  	"context"
    18  	"testing"
    19  	"time"
    20  
    21  	"github.com/prometheus/common/model"
    22  	"github.com/stretchr/testify/require"
    23  
    24  	"github.com/prometheus/alertmanager/types"
    25  )
    26  
    27  func TestSetGet(t *testing.T) {
    28  	a := NewAlerts()
    29  	alert := &types.Alert{
    30  		UpdatedAt: time.Now(),
    31  	}
    32  	require.NoError(t, a.Set(alert))
    33  	want := alert.Fingerprint()
    34  	got, err := a.Get(want)
    35  
    36  	require.NoError(t, err)
    37  	require.Equal(t, want, got.Fingerprint())
    38  }
    39  
    40  func TestDelete(t *testing.T) {
    41  	a := NewAlerts()
    42  	alert := &types.Alert{
    43  		UpdatedAt: time.Now(),
    44  	}
    45  	require.NoError(t, a.Set(alert))
    46  
    47  	fp := alert.Fingerprint()
    48  
    49  	err := a.Delete(fp)
    50  	require.NoError(t, err)
    51  
    52  	got, err := a.Get(fp)
    53  	require.Nil(t, got)
    54  	require.Equal(t, ErrNotFound, err)
    55  }
    56  
    57  func TestGC(t *testing.T) {
    58  	now := time.Now()
    59  	newAlert := func(key string, start, end time.Duration) *types.Alert {
    60  		return &types.Alert{
    61  			Alert: model.Alert{
    62  				Labels:   model.LabelSet{model.LabelName(key): "b"},
    63  				StartsAt: now.Add(start * time.Minute),
    64  				EndsAt:   now.Add(end * time.Minute),
    65  			},
    66  		}
    67  	}
    68  	active := []*types.Alert{
    69  		newAlert("b", 10, 20),
    70  		newAlert("c", -10, 10),
    71  	}
    72  	resolved := []*types.Alert{
    73  		newAlert("a", -10, -5),
    74  		newAlert("d", -10, -1),
    75  	}
    76  	s := NewAlerts()
    77  	var (
    78  		n           int
    79  		done        = make(chan struct{})
    80  		ctx, cancel = context.WithCancel(context.Background())
    81  	)
    82  	s.SetGCCallback(func(a []*types.Alert) {
    83  		n += len(a)
    84  		if n >= len(resolved) {
    85  			cancel()
    86  		}
    87  	})
    88  	for _, alert := range append(active, resolved...) {
    89  		require.NoError(t, s.Set(alert))
    90  	}
    91  	go func() {
    92  		s.Run(ctx, 10*time.Millisecond)
    93  		close(done)
    94  	}()
    95  	select {
    96  	case <-done:
    97  		break
    98  	case <-time.After(1 * time.Second):
    99  		t.Fatal("garbage collection didn't complete in time")
   100  	}
   101  
   102  	for _, alert := range active {
   103  		if _, err := s.Get(alert.Fingerprint()); err != nil {
   104  			t.Errorf("alert %v should not have been gc'd", alert)
   105  		}
   106  	}
   107  	for _, alert := range resolved {
   108  		if _, err := s.Get(alert.Fingerprint()); err == nil {
   109  			t.Errorf("alert %v should have been gc'd", alert)
   110  		}
   111  	}
   112  	require.Equal(t, len(resolved), n)
   113  }
   114
View as plain text