#46 - Experimental ExecMiddlewarer

middleware.go

@@ -1,7 +1,9 @@
 package goriak
 
 type ExecMiddlewarer interface {
- GetKey() string
+ Key() string
+ Bucket() string
+ BucketType() string
 }
 
 type ExecuteMiddleware func(cmd ExecMiddlewarer, next func() (*Result, error)) (*Result, error)
@@ -11,6 +13,18 @@ func (c *SetRawCommand) AddMiddleware(mid ExecuteMiddleware) *SetRawCommand {
  return c
 }
 
-func (c *SetRawCommand) GetKey() string {
- return c.key
+type setRawMiddlewarer struct {
+ cmd *SetRawCommand
+}
+
+func (c setRawMiddlewarer) Key() string {
+ return c.cmd.key
+}
+
+func (c setRawMiddlewarer) Bucket() string {
+ return c.cmd.c.bucket
+}
+
+func (c setRawMiddlewarer) BucketType() string {
+ return c.cmd.c.bucketType
 }

middleware_test.go

@@ -1,29 +1,90 @@
 package goriak
 
 import (
- //riak "github.com/basho/riak-go-client"
  "errors"
- "log"
  "testing"
 )
 
-func TestMiddlewareSet(t *testing.T) {
+func TestMiddlewareSetAbort(t *testing.T) {
+ m := func(cmd ExecMiddlewarer, next func() (*Result, error)) (*Result, error) {
+ return nil, errors.New("aborted middleware")
+ }
+
+ _, err := Bucket("middleware", "tests").
+ SetRaw([]byte{1, 2, 3, 4, 5}).
+ AddMiddleware(m).
+ Run(con())
+ if err == nil {
+ t.Error("no error")
+ }
+
+ if err.Error() != "aborted middleware" {
+ t.Error("unexpected error")
+ }
+}
+
+func TestMiddlewareSetKeyTest(t *testing.T) {
+ beforeEmpty := 0
+ afterWithKey := 0
 
  m := func(cmd ExecMiddlewarer, next func() (*Result, error)) (*Result, error) {
- log.Println("Middleware BEFORE:", cmd.GetKey())
- return nil, errors.New("abort!")
+ if cmd.Key() == "" {
+ beforeEmpty++
+ }
 
  res, err := next()
- log.Println("Middleware After:", cmd.GetKey())
+
+ if cmd.Key() != "" {
+ afterWithKey++
+ }
+
  return res, err
  }
 
- res, err := Bucket("middleware", "tests").
+ _, err := Bucket("middleware", "tests").
  SetRaw([]byte{1, 2, 3, 4, 5}).
- ///Key("abc123").
  AddMiddleware(m).
  AddMiddleware(m).
  Run(con())
+ if err != nil {
+ t.Error(err)
+ }
+
+ if beforeEmpty != 2 {
+ t.Error("wrong beforeEmpty count")
+ }
 
- t.Log(res, err)
+ if afterWithKey != 2 {
+ t.Error("wrong afterWithKey count")
+ }
+}
+
+func TestMiddlewareSetBucketType(t *testing.T) {
+ m := func(cmd ExecMiddlewarer, next func() (*Result, error)) (*Result, error) {
+ if cmd.Bucket() != "middleware" {
+ t.Error("unexpected before bucket")
+ }
+ if cmd.BucketType() != "tests" {
+ t.Error("unexpected before bucket type")
+ }
+
+ res, err := next()
+
+ if cmd.Bucket() != "middleware" {
+ t.Error("unexpected after bucket")
+ }
+ if cmd.BucketType() != "tests" {
+ t.Error("unexpected after bucket type")
+ }
+
+ return res, err
+ }
+
+ _, err := Bucket("middleware", "tests").
+ SetRaw([]byte{1, 2, 3, 4, 5}).
+ AddMiddleware(m).
+ Run(con())
+ if err != nil {
+ t.Error(err)
+ }
 }

query_store_value.go

@@ -3,7 +3,6 @@ package goriak
 import (
  "errors"
  riak "github.com/basho/riak-go-client"
- "log"
 )
 
 type SetRawCommand struct {
@@ -71,14 +70,18 @@ func (c *SetRawCommand) Run(session *Session) (*Result, error) {
  // Needed so that next can call itself
  var next2 func() (*Result, error)
 
+ middlewarer := setRawMiddlewarer{
+ cmd: c,
+ }
+
  next := func() (*Result, error) {
  if middlewareI == len(c.execMiddleware) {
  return c.riakExecute(session)
  }
 
  middlewareI++
 
- return c.execMiddleware[middlewareI-1](c, next2)
+ return c.execMiddleware[middlewareI-1](middlewarer, next2)
  }
 
  next2 = next
@@ -94,8 +97,6 @@ func (c *SetRawCommand) riakExecute(session *Session) (*Result, error) {
  return nil, err
  }
 
- log.Println("Riak Execute")
-
  err = session.riak.Execute(cmd)
  if err != nil {
  return nil, err
@@ -107,10 +108,7 @@ func (c *SetRawCommand) riakExecute(session *Session) (*Result, error) {
  return nil, errors.New("Not successful")
  }
 
- log.Println("Key:", c.key)
-
  if c.key == "" {
- log.Println("Added GeneratedKey")
  c.key = storeCmd.Response.GeneratedKey
  }