Merge pull request #124 from graph-gophers/fix-failing-example-tests

test: fix failing example tests

Author: pavelnikolov

README.md

@@ -51,7 +51,7 @@ This implementation contains a very basic cache that is intended only to be used
 > it also has a `NoCache` type that implements the cache interface but all methods are noop. If you do not wish to cache anything.
 
 ## Examples
-There are a few basic examples in the example folder.
+There are a few basic examples in the package root.
 
 ## See also
 - [TRACE](TRACE.md)

example/ttl_cache/go_cache_test.go

@@ -0,0 +1,75 @@
+package dataloader_test
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	dataloader "github.com/graph-gophers/dataloader/v7"
+
+	cache "github.com/patrickmn/go-cache"
+)
+
+type goCacheAdapter[K comparable, V any] struct {
+	c *cache.Cache
+}
+
+func (c *goCacheAdapter[K, V]) Get(_ context.Context, key K) (dataloader.Thunk[V], bool) {
+	k := fmt.Sprintf("%v", key)
+	v, ok := c.c.Get(k)
+	if ok {
+		return v.(dataloader.Thunk[V]), ok
+	}
+	return nil, ok
+}
+
+func (c *goCacheAdapter[K, V]) Set(_ context.Context, key K, value dataloader.Thunk[V]) {
+	k := fmt.Sprintf("%v", key)
+	c.c.Set(k, value, 0)
+}
+
+func (c *goCacheAdapter[K, V]) Delete(_ context.Context, key K) bool {
+	k := fmt.Sprintf("%v", key)
+	if _, found := c.c.Get(k); found {
+		c.c.Delete(k)
+		return true
+	}
+	return false
+}
+
+func (c *goCacheAdapter[K, V]) Clear() {
+	c.c.Flush()
+}
+
+func ExampleNewBatchedLoader_goCache() {
+	type User struct {
+		ID        int
+		Email     string
+		FirstName string
+		LastName  string
+	}
+
+	m := map[int]*User{
+		5: {ID: 5, FirstName: "John", LastName: "Smith", Email: "john@example.com"},
+	}
+
+	batchFunc := func(_ context.Context, keys []int) []*dataloader.Result[*User] {
+		var results []*dataloader.Result[*User]
+		for _, k := range keys {
+			results = append(results, &dataloader.Result[*User]{Data: m[k]})
+		}
+		return results
+	}
+
+	c := cache.New(15*time.Minute, 15*time.Minute)
+	adapter := &goCacheAdapter[int, *User]{c}
+	loader := dataloader.NewBatchedLoader(batchFunc, dataloader.WithCache[int, *User](adapter))
+
+	result, err := loader.Load(context.Background(), 5)()
+	if err != nil {
+		// handle error
+	}
+
+	fmt.Printf("result: %+v", result)
+	// Output: result: &{ID:5 Email:john@example.com FirstName:John LastName:Smith}
+}

example_go_cache_test.go

@@ -1,5 +1,4 @@
-// package lru_cache_test contains an exmaple of using go-cache as a long term cache solution for dataloader.
-package lru_cache_test
+package dataloader_test
 
 import (
 	"context"
@@ -10,40 +9,35 @@ import (
 	lru "github.com/hashicorp/golang-lru"
 )
 
-// Cache implements the dataloader.Cache interface
-type cache[K comparable, V any] struct {
+type lruCacheAdapter[K comparable, V any] struct {
 	*lru.ARCCache
 }
 
-// Get gets an item from the cache
-func (c *cache[K, V]) Get(_ context.Context, key K) (dataloader.Thunk[V], bool) {
+func (c *lruCacheAdapter[K, V]) Get(_ context.Context, key K) (dataloader.Thunk[V], bool) {
 	v, ok := c.ARCCache.Get(key)
 	if ok {
 		return v.(dataloader.Thunk[V]), ok
 	}
 	return nil, ok
 }
 
-// Set sets an item in the cache
-func (c *cache[K, V]) Set(_ context.Context, key K, value dataloader.Thunk[V]) {
+func (c *lruCacheAdapter[K, V]) Set(_ context.Context, key K, value dataloader.Thunk[V]) {
 	c.ARCCache.Add(key, value)
 }
 
-// Delete deletes an item in the cache
-func (c *cache[K, V]) Delete(_ context.Context, key K) bool {
+func (c *lruCacheAdapter[K, V]) Delete(_ context.Context, key K) bool {
 	if c.ARCCache.Contains(key) {
 		c.ARCCache.Remove(key)
 		return true
 	}
 	return false
 }
 
-// Clear clears the cache
-func (c *cache[K, V]) Clear() {
+func (c *lruCacheAdapter[K, V]) Clear() {
 	c.ARCCache.Purge()
 }
 
-func ExampleGolangLRU() {
+func ExampleNewBatchedLoader_golangLRU() {
 	type User struct {
 		ID        int
 		Email     string
@@ -57,19 +51,16 @@ func ExampleGolangLRU() {
 
 	batchFunc := func(_ context.Context, keys []int) []*dataloader.Result[*User] {
 		var results []*dataloader.Result[*User]
-		// do some pretend work to resolve keys
 		for _, k := range keys {
 			results = append(results, &dataloader.Result[*User]{Data: m[k]})
 		}
 		return results
 	}
 
-	// go-cache will automatically cleanup expired items on given duration.
 	c, _ := lru.NewARC(100)
-	cache := &cache[int, *User]{ARCCache: c}
-	loader := dataloader.NewBatchedLoader(batchFunc, dataloader.WithCache[int, *User](cache))
+	adapter := &lruCacheAdapter[int, *User]{ARCCache: c}
+	loader := dataloader.NewBatchedLoader(batchFunc, dataloader.WithCache[int, *User](adapter))
 
-	// immediately call the future function from loader
 	result, err := loader.Load(context.TODO(), 5)()
 	if err != nil {
 		// handle error

example/lru_cache/golang_lru_test.go example_golang_lru_test.goexample/lru_cache/golang_lru_test.go renamed to example_golang_lru_test.go

@@ -1,4 +1,4 @@
-package no_cache_test
+package dataloader_test
 
 import (
 	"context"
@@ -21,14 +21,12 @@ func ExampleNoCache() {
 
 	batchFunc := func(_ context.Context, keys []int) []*dataloader.Result[*User] {
 		var results []*dataloader.Result[*User]
-		// do some pretend work to resolve keys
 		for _, k := range keys {
 			results = append(results, &dataloader.Result[*User]{Data: m[k]})
 		}
 		return results
 	}
 
-	// go-cache will automatically cleanup expired items on given duration
 	cache := &dataloader.NoCache[int, *User]{}
 	loader := dataloader.NewBatchedLoader(batchFunc, dataloader.WithCache[int, *User](cache))