Add caller package

2015-10-14 00:08:45 +03:00
commit 3c6ef613f5
4 changed files with 331 additions and 0 deletions
@@ -0,0 +1,30 @@
+# Caller
+
+Package caller is used to dynamicly call functions with data unmarshalled
+into the functions' first argument. It's main purpose is to hide common
+unmarshalling code from each function's implementation thus reducing
+boilerplate and making the code sexier.
+
+[Documentation](https://godoc.org/github.com/localhots/uberdaemon/caller)
+
+```go
+package main
+
+import (
+    "github.com/localhots/uberdaemon/caller"
+)
+
+type message struct {
+    Title string `json:"title"`
+    Body  string `json:"body"`
+}
+
+func processMessage(m message) {
+    fmt.Printf("Title: %s\nBody: %s\n", m.Title, m.Body)
+}
+
+func main() {
+    c, _ := caller.New(processMessage)
+    c.Call(`{"title": "Hello", "body": "World"}`)
+}
+```
@@ -0,0 +1,81 @@
+// Package caller is used to dynamicly call functions with data unmarshalled
+// into the functions' first argument. It's main purpose is to hide common
+// unmarshalling code from each function's implementation thus reducing
+// boilerplate and making the code sexier.
+package caller
+
+import (
+	"encoding/json"
+	"errors"
+	"reflect"
+)
+
+// Caller wraps a function and makes it ready to be dynamically called.
+type Caller struct {
+	fun    reflect.Value
+	argtyp reflect.Type
+}
+
+var (
+	// ErrInvalidFunctionType is an error that is returned by the New function
+	// when its argument is not a function.
+	ErrInvalidFunctionType = errors.New("argument must be function")
+	// ErrInvalidFunctionInArguments is an error that is returned by the New
+	// function when its argument-function has a number of input arguments other
+	// than 1.
+	ErrInvalidFunctionInArguments = errors.New("function must have only one input argument")
+	// ErrInvalidFunctionOutArguments is an error that is returned by the New
+	// function when its argument-function returs any values.
+	ErrInvalidFunctionOutArguments = errors.New("function must not have output arguments")
+)
+
+// New creates a new Caller instance using the function given as an argument.
+// It returns the Caller instance and an error if something is wrong with the
+// argument-function.
+func New(fun interface{}) (c *Caller, err error) {
+	fval := reflect.ValueOf(fun)
+	ftyp := reflect.TypeOf(fun)
+	if ftyp.Kind() != reflect.Func {
+		return nil, ErrInvalidFunctionType
+	}
+	if ftyp.NumIn() != 1 {
+		return nil, ErrInvalidFunctionInArguments
+	}
+	if ftyp.NumOut() != 0 {
+		return nil, ErrInvalidFunctionOutArguments
+	}
+
+	c = &Caller{
+		fun:    fval,
+		argtyp: ftyp.In(0),
+	}
+
+	return c, nil
+}
+
+// Call creates an instance of the Caller function's argument type, unmarshalls
+// the JSON payload into it and dynamically calls the Caller function with this
+// instance.
+func (c *Caller) Call(data []byte) error {
+	val, err := c.unmarshal(data)
+	if err != nil {
+		return err
+	}
+
+	c.makeDynamicCall(val)
+	return nil
+}
+
+func (c *Caller) unmarshal(data []byte) (val reflect.Value, err error) {
+	val = c.newValue()
+	err = json.Unmarshal(data, val.Interface())
+	return
+}
+
+func (c *Caller) makeDynamicCall(val reflect.Value) {
+	c.fun.Call([]reflect.Value{val.Elem()})
+}
+
+func (c *Caller) newValue() reflect.Value {
+	return reflect.New(c.argtyp)
+}
@@ -0,0 +1,198 @@
+package caller
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"testing"
+)
+
+//
+// Testing targets
+//
+
+type testMessage struct {
+	Body string `json:"body"`
+}
+
+const testPayload = `{"body":"Success!"}`
+
+func testFun(m testMessage) {
+	fmt.Print(m.Body)
+}
+
+func testFunSilent(_ testMessage) {}
+
+//
+// Tests
+//
+
+func TestNewCallerSuccess(t *testing.T) {
+	c, err := New(testFun)
+	if err != nil {
+		t.Errorf("Expected no error, got: %v", err)
+	}
+	if c == nil {
+		t.Error("Expected an instance of Caller, got nil")
+	}
+}
+
+func TestNewCallerWithNonFunc(t *testing.T) {
+	c, err := New(1)
+	if err != ErrInvalidFunctionType {
+		t.Errorf("Expected ErrInvalidFunctionType, got: %v", err)
+	}
+	if c != nil {
+		t.Error("Expected nil, got an instance of Caller")
+	}
+}
+
+func TestNewCallerWithFuncMultipleArgs(t *testing.T) {
+	fun := func(a, b int) {}
+	c, err := New(fun)
+	if err != ErrInvalidFunctionInArguments {
+		t.Errorf("Expected ErrInvalidFunctionInArguments, got: %v", err)
+	}
+	if c != nil {
+		t.Error("Expected nil, got an instance of Caller")
+	}
+}
+
+func TestNewCallerWithFuncReturnValue(t *testing.T) {
+	fun := func(a int) int { return 0 }
+	c, err := New(fun)
+	if err != ErrInvalidFunctionOutArguments {
+		t.Errorf("Expected ErrInvalidFunctionOutArguments, got: %v", err)
+	}
+	if c != nil {
+		t.Error("Expected nil, got an instance of Caller")
+	}
+}
+
+func TestCallSuccess(t *testing.T) {
+	c, err := New(testFun)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	out := captureStdoutAround(func() {
+		if err := c.Call([]byte(testPayload)); err != nil {
+			t.Fatal(err.Error())
+		}
+	})
+
+	if string(out) != "Success!" {
+		t.Errorf("Expected output to be %q, got %q", "Success!", out)
+	}
+}
+
+func TestCallFalure(t *testing.T) {
+	c, _ := New(testFunSilent)
+
+	err := c.Call([]byte("{"))
+	if err == nil {
+		t.Error("Expected unmarshalling error, got nil")
+	}
+}
+
+func TestUnmarshalSuccess(t *testing.T) {
+	c, _ := New(testFunSilent)
+
+	_, err := c.unmarshal([]byte(testPayload))
+	if err != nil {
+		t.Errorf("Expected no error, got: %v", err)
+	}
+}
+
+func TestUnmarshalFailure(t *testing.T) {
+	c, _ := New(testFunSilent)
+
+	_, err := c.unmarshal([]byte("{"))
+	if err == nil {
+		t.Error("Expected unmarshalling error, got nil")
+	}
+}
+
+func captureStdoutAround(f func()) []byte {
+	origStdout := os.Stdout
+	r, w, _ := os.Pipe()
+	os.Stdout = w
+
+	f()
+
+	w.Close()
+	out, _ := ioutil.ReadAll(r)
+	r.Close()
+	os.Stdout = origStdout
+
+	return out
+}
+
+//
+// Benchmarks
+//
+
+func BenchmarkCaller(b *testing.B) {
+	c, _ := New(testFunSilent)
+
+	for i := 0; i < b.N; i++ {
+		c.Call([]byte(testPayload))
+	}
+}
+
+func BenchmarkNoCaller(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		var msg testMessage
+		json.Unmarshal([]byte(testPayload), &msg)
+		testFunSilent(msg)
+	}
+}
+
+func BenchmarkDynamicNew(b *testing.B) {
+	c, _ := New(testFunSilent)
+
+	for i := 0; i < b.N; i++ {
+		_ = c.newValue()
+	}
+}
+
+func BenchmarkStaticNew(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		_ = testMessage{}
+	}
+}
+
+func BenchmarkDynamicCall(b *testing.B) {
+	c, _ := New(testFunSilent)
+	val, _ := c.unmarshal([]byte(testPayload))
+
+	for i := 0; i < b.N; i++ {
+		c.makeDynamicCall(val)
+	}
+}
+
+func BenchmarkStaticCall(b *testing.B) {
+	var msg testMessage
+
+	for i := 0; i < b.N; i++ {
+		testFunSilent(msg)
+	}
+}
+
+func BenchmarkUnmarshalIntoInterface(b *testing.B) {
+	c, _ := New(testFunSilent)
+	val := c.newValue()
+
+	for i := 0; i < b.N; i++ {
+		json.Unmarshal([]byte(testPayload), val.Interface())
+	}
+}
+
+func BenchmarkUnmarshalIntoTypedValue(b *testing.B) {
+	var msg testMessage
+
+	for i := 0; i < b.N; i++ {
+		json.Unmarshal([]byte(testPayload), &msg)
+	}
+}