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

     1  package rockscache
     2  
     3  import (
     4  	"context"
     5  	"errors"
     6  	"fmt"
     7  	"testing"
     8  	"time"
     9  
    10  	"github.com/stretchr/testify/assert"
    11  )
    12  
    13  func TestBadOptions(t *testing.T) {
    14  	assert.Panics(t, func() {
    15  		NewClient(nil, Options{})
    16  	})
    17  }
    18  
    19  func TestDisable(t *testing.T) {
    20  	rc := NewClient(nil, NewDefaultOptions())
    21  	rc.Options.DisableCacheDelete = true
    22  	rc.Options.DisableCacheRead = true
    23  	fn := func() (string, error) { return "", nil }
    24  	_, err := rc.Fetch2(context.Background(), "key", 60, fn)
    25  	assert.Nil(t, err)
    26  	err = rc.TagAsDeleted2(context.Background(), "key")
    27  	assert.Nil(t, err)
    28  }
    29  
    30  func TestEmptyExpire(t *testing.T) {
    31  	testEmptyExpire(t, 0)
    32  	testEmptyExpire(t, 10*time.Second)
    33  }
    34  
    35  func testEmptyExpire(t *testing.T, expire time.Duration) {
    36  	clearCache()
    37  	rc := NewClient(rdb, NewDefaultOptions())
    38  	rc.Options.EmptyExpire = expire
    39  	fn := func() (string, error) { return "", nil }
    40  	fetchError := errors.New("fetch error")
    41  	errFn := func() (string, error) {
    42  		return "", fetchError
    43  	}
    44  	_, err := rc.Fetch("key1", 600, fn)
    45  	assert.Nil(t, err)
    46  	_, err = rc.Fetch("key1", 600, errFn)
    47  	if expire == 0 {
    48  		assert.ErrorIs(t, err, fetchError)
    49  	} else {
    50  		assert.Nil(t, err)
    51  	}
    52  
    53  	rc.Options.StrongConsistency = true
    54  	_, err = rc.Fetch("key2", 600, fn)
    55  	assert.Nil(t, err)
    56  	_, err = rc.Fetch("key2", 600, errFn)
    57  	if expire == 0 {
    58  		assert.ErrorIs(t, err, fetchError)
    59  	} else {
    60  		assert.Nil(t, err)
    61  	}
    62  }
    63  
    64  func TestErrorFetch(t *testing.T) {
    65  	fn := func() (string, error) { return "", fmt.Errorf("error") }
    66  	clearCache()
    67  	rc := NewClient(rdb, NewDefaultOptions())
    68  	_, err := rc.Fetch("key1", 60, fn)
    69  	assert.Equal(t, fmt.Errorf("error"), err)
    70  
    71  	rc.Options.StrongConsistency = true
    72  	_, err = rc.Fetch("key2", 60, fn)
    73  	assert.Equal(t, fmt.Errorf("error"), err)
    74  }
    75  
    76  func TestPanicFetch(t *testing.T) {
    77  	fn := func() (string, error) { return "abc", nil }
    78  	pfn := func() (string, error) { panic(fmt.Errorf("error")) }
    79  	clearCache()
    80  	rc := NewClient(rdb, NewDefaultOptions())
    81  	_, err := rc.Fetch("key1", 60*time.Second, fn)
    82  	assert.Nil(t, err)
    83  	rc.TagAsDeleted("key1")
    84  	_, err = rc.Fetch("key1", 60*time.Second, pfn)
    85  	assert.Nil(t, err)
    86  	time.Sleep(20 * time.Millisecond)
    87  }
    88  
    89  func TestTagAsDeletedWait(t *testing.T) {
    90  	clearCache()
    91  	rc := NewClient(rdb, NewDefaultOptions())
    92  	rc.Options.WaitReplicas = 1
    93  	rc.Options.WaitReplicasTimeout = 10
    94  	err := rc.TagAsDeleted("key1")
    95  	if getCluster() != nil {
    96  		assert.Nil(t, err)
    97  	} else {
    98  		assert.Error(t, err, fmt.Errorf("wait replicas 1 failed. result replicas: 0"))
    99  	}
   100  }