feat: support customized package key (#14)

Co-authored-by: viney-shih <[email protected]>

event.go

@@ -41,7 +41,7 @@ func init() {
 
 // Topic generates the topic for specified event.
 func (x eventType) Topic() string {
-	return customKey(topicDelim, packageKey, topicKey, x.String())
+	return getTopic(x.String())
 }
 
 type event struct {

factory.go

@@ -17,9 +17,9 @@ var (
 	uuidString = uuid.New().String
 )
 
-func newFactory(sharedCache Adapter, localCache Adapter, options ...ServiceOptions) Factory {
+func newFactory(sharedCache Adapter, localCache Adapter, options ...FactoryOptions) Factory {
 	// load options
-	o := loadServiceOptions(options...)
+	o := loadFactoryOptions(options...)
 	// need to specify marshalFunc and unmarshalFunc at the same time
 	if o.marshalFunc == nil && o.unmarshalFunc != nil {
 		panic(errors.New("both of Marshal and Unmarshal functions need to be specified"))

factory_test.go

@@ -5,7 +5,6 @@ import (
 	"encoding/json"
 	"encoding/xml"
 	"errors"
-	"fmt"
 	"reflect"
 	"testing"
 	"time"
@@ -249,39 +248,3 @@ func (s *factorySuite) TestNewCacheWithOnlyUnmarshal() {
 		},
 	})
 }
-
-func (s *factorySuite) TestGetPrefixAndKey() {
-	tests := []struct {
-		Desc     string
-		CacheKey string
-		ExpPfx   string
-		ExpKey   string
-	}{
-		{
-			Desc:     "invalid cache key without delimiter",
-			CacheKey: "12345",
-			ExpPfx:   "12345",
-			ExpKey:   "",
-		},
-		{
-			Desc:     "invalid cache key with only one delimiter",
-			CacheKey: fmt.Sprintf("%s%s%s", "123", cacheDelim, "abc"),
-			ExpPfx:   "abc",
-			ExpKey:   "",
-		},
-		{
-			Desc:     "normal case",
-			CacheKey: getCacheKey("prefix", "key"),
-			ExpPfx:   "prefix",
-			ExpKey:   "key",
-		},
-	}
-
-	for _, t := range tests {
-		pfx, key := getPrefixAndKey(t.CacheKey)
-		s.Require().Equal(t.ExpPfx, pfx, t.Desc)
-		s.Require().Equal(t.ExpKey, key, t.Desc)
-
-		s.TearDownTest()
-	}
-}

interface.go

@@ -50,7 +50,7 @@ type Factory interface {
 }
 
 // NewFactory returns the Factory initialized in the main.go.
-func NewFactory(sharedCache Adapter, localCache Adapter, options ...ServiceOptions) Factory {
+func NewFactory(sharedCache Adapter, localCache Adapter, options ...FactoryOptions) Factory {
 	return newFactory(sharedCache, localCache, options...)
 }
 
@@ -110,3 +110,8 @@ type Result interface {
 func ClearPrefix() {
 	usedPrefixs = map[string]struct{}{}
 }
+
+// Register registers customized parameters in the package.
+func Register(packageKey string) {
+	registerKey(packageKey)
+}

key.go

@@ -1,6 +1,9 @@
 package cache
 
-import "strings"
+import (
+	"strings"
+	"sync"
+)
 
 const (
 	packageKey = "ca"
@@ -11,12 +14,32 @@ const (
 	topicDelim = "#"
 )
 
+var (
+	regPkgKey = packageKey
+	// regKeyOnce limits key registeration happening once
+	regKeyOnce = sync.Once{}
+)
+
+func registerKey(pkgKey string) {
+	regKeyOnce.Do(func() {
+		regPkgKey = pkgKey
+	})
+}
+
 func customKey(delimiter string, components ...string) string {
 	return strings.Join(components, delimiter)
 }
 
+func getTopic(topic string) string {
+	return customKey(topicDelim, regPkgKey, topicKey, topic)
+}
+
 func getCacheKey(pfx, key string) string {
-	return customKey(cacheDelim, packageKey, pfx, key)
+	if regPkgKey == "" {
+		return customKey(cacheDelim, pfx, key)
+	}
+
+	return customKey(cacheDelim, regPkgKey, pfx, key)
 }
 
 func getCacheKeys(pfx string, keys []string) []string {
@@ -29,10 +52,15 @@ func getCacheKeys(pfx string, keys []string) []string {
 }
 
 func getPrefixAndKey(cacheKey string) (string, string) {
-	// cacheKey = packageKey + prefix + key
+	// 1) cacheKey = regPkgKey + prefix + key (normal case)
+	// 2) cacheKey = prefix + key (if customized package key is empty)
 	idx := strings.Index(cacheKey, cacheDelim)
 	if idx < 0 {
-		return cacheKey, ""
+		return cacheKey, "" // should not happen
+	}
+
+	if regPkgKey == "" {
+		return cacheKey[:idx], cacheKey[idx+len(cacheDelim):]
 	}
 
 	// mixedKey = prefix + key

key_test.go

@@ -0,0 +1,107 @@
+package cache
+
+import (
+	"fmt"
+	"sync"
+	"testing"
+
+	"github.com/stretchr/testify/suite"
+)
+
+type keySuite struct {
+	suite.Suite
+}
+
+func (s *keySuite) SetupSuite() {}
+
+func (s *keySuite) TearDownSuite() {}
+
+func (s *keySuite) SetupTest() {}
+
+func (s *keySuite) TearDownTest() {
+	clearRegisteredKey()
+}
+
+func TestKeySuite(t *testing.T) {
+	suite.Run(t, new(keySuite))
+}
+
+func clearRegisteredKey() {
+	regPkgKey = packageKey
+	regKeyOnce = sync.Once{}
+}
+
+func (s *keySuite) TestGetPrefixAndKey() {
+	tests := []struct {
+		Desc     string
+		CacheKey string
+		ExpPfx   string
+		ExpKey   string
+	}{
+		{
+			Desc:     "invalid cache key without delimiter",
+			CacheKey: "12345",
+			ExpPfx:   "12345",
+			ExpKey:   "",
+		},
+		{
+			Desc:     "invalid cache key with only one delimiter",
+			CacheKey: fmt.Sprintf("%s%s%s", "123", cacheDelim, "abc"),
+			ExpPfx:   "abc",
+			ExpKey:   "",
+		},
+		{
+			Desc:     "normal case",
+			CacheKey: getCacheKey("prefix", "key"),
+			ExpPfx:   "prefix",
+			ExpKey:   "key",
+		},
+	}
+
+	for _, t := range tests {
+		pfx, key := getPrefixAndKey(t.CacheKey)
+		s.Require().Equal(t.ExpPfx, pfx, t.Desc)
+		s.Require().Equal(t.ExpKey, key, t.Desc)
+
+		s.TearDownTest()
+	}
+}
+
+func (s *keySuite) TestRegister() {
+	s.Require().Equal(packageKey, regPkgKey)
+
+	Register("specified")
+	s.Require().Equal("specified", regPkgKey)
+
+	Register("another")
+	s.Require().Equal("specified", regPkgKey) // no change
+
+	clearRegisteredKey()
+	s.Require().Equal(packageKey, regPkgKey) // set to default
+
+	Register("another")
+	s.Require().Equal("another", regPkgKey) // set to another
+}
+
+func (s *keySuite) TestRegisterAndGetCacheKey() {
+	var cKey, pfx, key string
+
+	s.Require().Equal(fmt.Sprintf("%s:pfx:key", packageKey), getCacheKey("pfx", "key"))
+
+	Register("my")
+	cKey = getCacheKey("pfx", "key")
+	s.Require().Equal("my:pfx:key", cKey)
+	pfx, key = getPrefixAndKey(cKey)
+	s.Require().Equal(pfx, "pfx")
+	s.Require().Equal(key, "key")
+
+	clearRegisteredKey()
+	s.Require().Equal(fmt.Sprintf("%s:pfx:key", packageKey), getCacheKey("pfx", "key")) // set to default
+
+	Register("") // empty package key
+	cKey = getCacheKey("pfx", "key")
+	s.Require().Equal("pfx:key", cKey)
+	pfx, key = getPrefixAndKey(cKey)
+	s.Require().Equal(pfx, "pfx")
+	s.Require().Equal(key, "key")
+}

options.go

@@ -8,11 +8,11 @@ type MarshalFunc func(interface{}) ([]byte, error)
 // The default is json.Unmarshal
 type UnmarshalFunc func([]byte, interface{}) error
 
-// ServiceOptions is an alias for functional argument.
-type ServiceOptions func(opts *serviceOptions)
+// FactoryOptions is an alias for functional argument.
+type FactoryOptions func(opts *factoryOptions)
 
-// serviceOptions contains all options which will be applied when calling New().
-type serviceOptions struct {
+// factoryOptions contains all options which will be applied when calling NewFactory().
+type factoryOptions struct {
 	marshalFunc   MarshalFunc
 	unmarshalFunc UnmarshalFunc
 	onCacheHit    func(prefix string, key string, count int)
@@ -24,57 +24,57 @@ type serviceOptions struct {
 
 // WithMarshalFunc sets up the specified marshal function.
 // Needs to consider with unmarshal function at the same time.
-func WithMarshalFunc(f MarshalFunc) ServiceOptions {
-	return func(opts *serviceOptions) {
+func WithMarshalFunc(f MarshalFunc) FactoryOptions {
+	return func(opts *factoryOptions) {
 		opts.marshalFunc = f
 	}
 }
 
 // WithUnmarshalFunc sets up the specified unmarshal function.
 // Needs to consider with marshal function at the same time.
-func WithUnmarshalFunc(f UnmarshalFunc) ServiceOptions {
-	return func(opts *serviceOptions) {
+func WithUnmarshalFunc(f UnmarshalFunc) FactoryOptions {
+	return func(opts *factoryOptions) {
 		opts.unmarshalFunc = f
 	}
 }
 
 // WithPubSub is used to evict keys in local cache
-func WithPubSub(pb Pubsub) ServiceOptions {
-	return func(opts *serviceOptions) {
+func WithPubSub(pb Pubsub) FactoryOptions {
+	return func(opts *factoryOptions) {
 		opts.pubsub = pb
 	}
 }
 
 // OnCacheHitFunc sets up the callback function on cache hitted
-func OnCacheHitFunc(f func(prefix string, key string, count int)) ServiceOptions {
-	return func(opts *serviceOptions) {
+func OnCacheHitFunc(f func(prefix string, key string, count int)) FactoryOptions {
+	return func(opts *factoryOptions) {
 		opts.onCacheHit = f
 	}
 }
 
 // OnCacheMissFunc sets up the callback function on cache missed
-func OnCacheMissFunc(f func(prefix string, key string, count int)) ServiceOptions {
-	return func(opts *serviceOptions) {
+func OnCacheMissFunc(f func(prefix string, key string, count int)) FactoryOptions {
+	return func(opts *factoryOptions) {
 		opts.onCacheMiss = f
 	}
 }
 
 // OnLocalCacheCostAddFunc sets up the callback function on adding the cost of key in local cache
-func OnLocalCacheCostAddFunc(f func(prefix string, key string, cost int)) ServiceOptions {
-	return func(opts *serviceOptions) {
+func OnLocalCacheCostAddFunc(f func(prefix string, key string, cost int)) FactoryOptions {
+	return func(opts *factoryOptions) {
 		opts.onLCCostAdd = f
 	}
 }
 
 // OnLocalCacheCostEvictFunc sets up the callback function on evicting the cost of key in local cache
-func OnLocalCacheCostEvictFunc(f func(prefix string, key string, cost int)) ServiceOptions {
-	return func(opts *serviceOptions) {
+func OnLocalCacheCostEvictFunc(f func(prefix string, key string, cost int)) FactoryOptions {
+	return func(opts *factoryOptions) {
 		opts.onLCCostEvict = f
 	}
 }
 
-func loadServiceOptions(options ...ServiceOptions) *serviceOptions {
-	opts := &serviceOptions{}
+func loadFactoryOptions(options ...FactoryOptions) *factoryOptions {
+	opts := &factoryOptions{}
 	for _, option := range options {
 		option(opts)
 	}