github.com/dtm-labs/rockscache@v0.1.1/batch_cover_test.go (about)

     1  package rockscache
     2  
     3  import (
     4  	"context"
     5  	"errors"
     6  	"fmt"
     7  	"math/rand"
     8  	"testing"
     9  	"time"
    10  
    11  	"github.com/stretchr/testify/assert"
    12  )
    13  
    14  var (
    15  	n = int(rand.Int31n(20) + 10)
    16  )
    17  
    18  func TestDisableForBatch(t *testing.T) {
    19  	idxs := genIdxs(n)
    20  	keys := genKeys(idxs)
    21  	getFn := func(idxs []int) (map[int]string, error) {
    22  		return nil, nil
    23  	}
    24  
    25  	rc := NewClient(nil, NewDefaultOptions())
    26  	rc.Options.DisableCacheDelete = true
    27  	rc.Options.DisableCacheRead = true
    28  
    29  	_, err := rc.FetchBatch2(context.Background(), keys, 60, getFn)
    30  	assert.Nil(t, err)
    31  	err = rc.TagAsDeleted2(context.Background(), keys[0])
    32  	assert.Nil(t, err)
    33  }
    34  
    35  func TestErrorFetchForBatch(t *testing.T) {
    36  	idxs := genIdxs(n)
    37  	keys := genKeys(idxs)
    38  	fetchError := errors.New("fetch error")
    39  	fn := func(idxs []int) (map[int]string, error) {
    40  		return nil, fetchError
    41  	}
    42  	clearCache()
    43  	rc := NewClient(rdb, NewDefaultOptions())
    44  	_, err := rc.FetchBatch(keys, 60, fn)
    45  	assert.ErrorIs(t, err, fetchError)
    46  
    47  	rc.Options.StrongConsistency = true
    48  	_, err = rc.FetchBatch(keys, 60, fn)
    49  	assert.ErrorIs(t, err, fetchError)
    50  }
    51  
    52  func TestEmptyExpireForBatch(t *testing.T) {
    53  	testEmptyExpireForBatch(t, 0)
    54  	testEmptyExpireForBatch(t, 10*time.Second)
    55  }
    56  
    57  func testEmptyExpireForBatch(t *testing.T, expire time.Duration) {
    58  	idxs := genIdxs(n)
    59  	keys := genKeys(idxs)
    60  	fn := func(idxs []int) (map[int]string, error) {
    61  		return nil, nil
    62  	}
    63  	fetchError := errors.New("fetch error")
    64  	errFn := func(idxs []int) (map[int]string, error) {
    65  		return nil, fetchError
    66  	}
    67  
    68  	clearCache()
    69  	rc := NewClient(rdb, NewDefaultOptions())
    70  	rc.Options.EmptyExpire = expire
    71  
    72  	_, err := rc.FetchBatch(keys, 60, fn)
    73  	assert.Nil(t, err)
    74  	_, err = rc.FetchBatch(keys, 60, errFn)
    75  	if expire == 0 {
    76  		assert.ErrorIs(t, err, fetchError)
    77  	} else {
    78  		assert.Nil(t, err)
    79  	}
    80  
    81  	clearCache()
    82  	rc.Options.StrongConsistency = true
    83  	_, err = rc.FetchBatch(keys, 60, fn)
    84  	assert.Nil(t, err)
    85  	_, err = rc.FetchBatch(keys, 60, errFn)
    86  	if expire == 0 {
    87  		assert.ErrorIs(t, err, fetchError)
    88  	} else {
    89  		assert.Nil(t, err)
    90  	}
    91  }
    92  
    93  func TestPanicFetchForBatch(t *testing.T) {
    94  	idxs := genIdxs(n)
    95  	keys := genKeys(idxs)
    96  	fn := func(idxs []int) (map[int]string, error) {
    97  		return nil, nil
    98  	}
    99  	fetchError := errors.New("fetch error")
   100  	errFn := func(idxs []int) (map[int]string, error) {
   101  		panic(fetchError)
   102  	}
   103  	clearCache()
   104  	rc := NewClient(rdb, NewDefaultOptions())
   105  
   106  	_, err := rc.FetchBatch(keys, 60, fn)
   107  	assert.Nil(t, err)
   108  	rc.TagAsDeleted("key1")
   109  	_, err = rc.FetchBatch(keys, 60, errFn)
   110  	assert.Nil(t, err)
   111  	time.Sleep(20 * time.Millisecond)
   112  }
   113  
   114  func TestTagAsDeletedBatchWait(t *testing.T) {
   115  	clearCache()
   116  	rc := NewClient(rdb, NewDefaultOptions())
   117  	rc.Options.WaitReplicas = 1
   118  	rc.Options.WaitReplicasTimeout = 10
   119  	err := rc.TagAsDeletedBatch([]string{"key1", "key2"})
   120  	if getCluster() != nil {
   121  		assert.Nil(t, err)
   122  	} else {
   123  		assert.Error(t, err, fmt.Errorf("wait replicas 1 failed. result replicas: 0"))
   124  	}
   125  }