// NewCacheDriver creates a new memcache driver.
func (kind *Kind) NewCacheDriver(req *wcg.Request) *memcache.Driver {
driver := memcache.NewDriver(gae.NewContext(req), req.Logger)
if kind.Namespace != "" {
driver.Namespace(kind.Namespace)
}
return driver
}
func Test_Query_WithCache(t *testing.T) {
assert := gaetest.NewAssert(t)
gaetest.CleanupDatastore(ts.Context)
gaetest.FixtureFromMap(ts.Context, []map[string]interface{}{
map[string]interface{}{"_kind": testEntity.String(), "_key": "1", "ID": "1"},
map[string]interface{}{"_kind": testEntity.String(), "_key": "2", "ID": "2"},
map[string]interface{}{"_kind": testEntity.String(), "_key": "3", "ID": "3"},
map[string]interface{}{"_kind": testEntity.String(), "_key": "4", "ID": "4"},
map[string]interface{}{"_kind": testEntity.String(), "_key": "5", "ID": "5"},
map[string]interface{}{"_kind": testEntity.String(), "_key": "6", "ID": "6"},
map[string]interface{}{"_kind": testEntity.String(), "_key": "7", "ID": "7"},
})
page, err := testEntity.Query().Cache("123").Execute(ts.GET("/").Request)
got := page.Data.([]TEntity)
assert.Nil(err)
assert.EqInt(7, len(got), "len(Pagination.Data)")
driver := memcache.NewDriver(ts.Context, wcg.NewLogger(nil))
assert.OK(driver.Exists("query.TestEntity.123"))
// cache still exists even after removing data.
gaetest.CleanupDatastore(ts.Context)
page, err = testEntity.Query().Cache("123").Execute(ts.GET("/").Request)
got = page.Data.([]TEntity)
assert.Nil(err)
assert.EqInt(7, len(got))
assert.EqStr("1", got[0].ID)
}
func Test_Delete_CacheInvalidation(t *testing.T) {
assert := gaetest.NewAssert(t)
driver := memcache.NewDriver(ts.Context, wcg.NewLogger(nil))
gaetest.CleanupDatastore(ts.Context)
gaetest.FixtureFromMap(ts.Context, []map[string]interface{}{
map[string]interface{}{"_kind": testEntity.String(), "_key": "1", "ID": "1"},
map[string]interface{}{"_kind": testEntity.String(), "_key": "2", "ID": "2"},
map[string]interface{}{"_kind": testEntity.String(), "_key": "3", "ID": "3"},
map[string]interface{}{"_kind": testEntity.String(), "_key": "4", "ID": "4"},
map[string]interface{}{"_kind": testEntity.String(), "_key": "5", "ID": "5"},
map[string]interface{}{"_kind": testEntity.String(), "_key": "6", "ID": "6"},
})
// create caches
testEntity.Query().Cache("123").MustExecute(ts.GET("/").Request)
testEntity.Get().Key("1").Cache(true).MustOne(ts.GET("/").Request)
assert.OK(driver.Exists("ent.TestEntity.1"), "An entyty cache should exist")
assert.OK(driver.Exists("query.TestEntity.123"), "A query cache should exist")
testEntity.Delete().Key("1").Cache("123").MustCommit(ts.GET("/").Request)
assert.Not(driver.Exists("ent.TestEntity.1"), "Entity cache should be invalidated")
assert.Not(driver.Exists("query.TestEntity.123"), "Query cache should be invalidated")
}
func Test_GetMulti_Cache(t *testing.T) {
assert := gaetest.NewAssert(t)
gaetest.CleanupDatastore(ts.Context)
gaetest.FixtureFromMap(ts.Context, []map[string]interface{}{
map[string]interface{}{"_kind": testEntity.String(), "_key": "1", "ID": "1"},
})
driver := memcache.NewDriver(ts.Context, wcg.NewLogger(nil))
_, list, err := testEntity.GetMulti().Keys("1", "3").Cache(true).List(ts.GET("/").Request)
got := list.([]*TEntity)
assert.Nil(err)
assert.EqInt(2, len(got))
assert.EqStr("1", got[0].ID)
assert.Nil(got[1])
assert.OK(driver.Exists("ent.TestEntity.1"))
assert.OK(driver.Exists("ent.TestEntity.3"))
var t1, t3 TEntity
driver.Get("ent.TestEntity.1", &t1)
driver.Get("ent.TestEntity.3", &t3)
assert.EqStr("1", t1.ID)
assert.EqStr("", t3.ID)
got = make([]*TEntity, 2)
driver.GetMulti([]string{"ent.TestEntity.1", "ent.TestEntity.3"}, got)
assert.EqStr("1", got[0].ID)
assert.Nil(got[1])
}
// NewImageCacher cretes a new *ImageCacher available in a request.
func NewImageCacher(req *wcg.Request, kind *entities.Kind) (*ImageCacher, error) {
client, err := newMediaClient(req)
if err != nil {
return nil, err
}
logger := wcg.NewLoggerWithPrefix(req, "ImageCache")
return &ImageCacher{
kind: kind,
req: req,
client: client,
memc: memcache.NewDriver(gae.NewContext(req), logger),
logger: logger,
}, nil
}
func Test_Put_CacheInvalidation(t *testing.T) {
assert := gaetest.NewAssert(t)
driver := memcache.NewDriver(ts.Context, wcg.NewLogger(nil))
gaetest.CleanupDatastore(ts.Context)
gaetest.FixtureFromMap(ts.Context, []map[string]interface{}{
map[string]interface{}{"_kind": testEntity.String(), "_key": "1", "ID": "1"},
})
// create caches
testEntity.Query().Cache("123").MustExecute(ts.GET("/").Request)
testEntity.Get().Key("1").Cache(true).MustOne(ts.GET("/").Request)
assert.OK(driver.Exists("ent.TestEntity.1"), "An entyty cache should exist")
assert.OK(driver.Exists("query.TestEntity.123"), "A query cache should exist")
item := &TEntity{ID: "1", Digit: 30}
testEntity.Put().Cache("123").MustUpdate(ts.PUTForm("/", nil).Request, item)
assert.Not(driver.Exists("ent.TestEntity.1"), "Entity cache should be invalidated")
assert.Not(driver.Exists("query.TestEntity.123"), "Query cache should be invalidated")
}