yt-function-sdk-go/ytfunction_test.go

package ytfunction

import (
	"fmt"
	"os"
	"testing"

	"git.ymnuktech.ru/ymnuk/yt-function-sdk-go/network"
)

var serve *Serve

func setup() {
	/*host, exists := os.LookupEnv("NATS_HOST")
	if !exists {
		host = "localhost"
	}*/
	addr, exists := os.LookupEnv("NATS_ADDR")
	if !exists {
		addr = "nats://localhost:4222"
	}
	/*port, exists := os.LookupEnv("NATS_PORT")
	if !exists {
		port = "4222"
	}*/

	serve = NewServe(addr, "", "test", nil, nil, nil)
	if serve == nil {
		panic(fmt.Errorf(`serve is not created`))
	}
	serve.AddAccept("*")
	err := serve.Run()
	if err != nil {
		panic(err)
	}
}

func shutdown() {
	serve.Shutdown()
}

func TestMain(m *testing.M) {
	setup()
	code := m.Run()
	shutdown()
	os.Exit(code)
}

func TestRegisterFunction(t *testing.T) {
	err := serve.RegisterFunction("testFunc", func(header *network.Header, paylod []byte) (result []byte, err error) {
		return []byte("Hello world"), nil
	})
	if err != nil {
		t.Error("Has error: ", err)
	} else if !serve.HasFunction("testFunc") {
		t.Error(`Function "testFunc" not found`)
	}
}

func TestCallFunctionAsync(t *testing.T) {
	err := serve.RegisterFunction("testFuncSimpleAsync", func(header *network.Header, paylod []byte) (result []byte, err error) {
		header.ResponseHeaders["test"] = "my test"
		return []byte("world"), nil
	})
	if err != nil {
		t.Error("Has error: ", err)
		return
	}
	type ChanRes struct {
		res    []byte
		header *network.Header
		err    error
	}
	chanRes := make(chan ChanRes)
	serve.CallAsync("default.test.testFuncSimpleAsync", nil, []byte("Hello"), func(err error, header *network.Header, result []byte) {
		chanRes <- ChanRes{
			res:    result,
			header: header,
			err:    err,
		}
	})
	res := <-chanRes
	if res.err != nil {
		t.Error(err)
		return
	}
	if string(res.res) != "world" {
		t.Error("Function not returned \"world\"")
		return
	}
	if v, ok := res.header.ResponseHeaders["test"]; !ok {
		t.Errorf("not set response header")
	} else if v != "my test" {
		t.Errorf("got \"my test\", but expect \"%s\"", v)
	}
}

func TestCallFunction(t *testing.T) {
	var err error
	err = serve.RegisterFunction("testFuncSimple", func(header *network.Header, paylod []byte) (result []byte, err error) {
		header.ResponseHeaders["test"] = "my test"
		return []byte("world"), nil
	})
	if err != nil {
		t.Error("Has error: ", err)
		return
	}
	var result []byte
	var header *network.Header
	result, header, err = serve.Call("default.test.testFuncSimple", nil, []byte("Hello"))
	if err != nil {
		t.Error(err)
		return
	}
	if string(result) != "world" {
		t.Error("Function not returned \"world\"")
		return
	}
	if v, ok := header.ResponseHeaders["test"]; !ok {
		t.Errorf("not set response header")
	} else if v != "my test" {
		t.Errorf("got \"my test\", but expect \"%s\"", v)
	}
}

func TestCallFunctionDouble(t *testing.T) {
	var err error
	err = serve.RegisterFunction("testFuncSimple1", func(header *network.Header, paylod []byte) (result []byte, err error) {
		/*header.ResponseHeaders["test"] = "my test"
		return []byte("world"), nil*/
		result, _, err = serve.Call("default.test.testFuncSimple2", header, []byte("Hello"))
		return result, err
	})
	if err != nil {
		t.Error("Has error: ", err)
		return
	}
	err = serve.RegisterFunction("testFuncSimple2", func(header *network.Header, paylod []byte) (result []byte, err error) {
		header.ResponseHeaders["test"] = "my test"
		return []byte("world"), nil
	})
	if err != nil {
		t.Error("Has error: ", err)
		return
	}
	var result []byte
	var header *network.Header
	result, header, err = serve.Call("default.test.testFuncSimple1", nil, []byte("Hello"))
	if err != nil {
		t.Error(err)
		return
	}
	if string(result) != "world" {
		t.Error("Function not returned \"world\"")
		return
	}
	if v, ok := header.ResponseHeaders["test"]; !ok {
		t.Errorf("not set response header")
	} else if v != "my test" {
		t.Errorf("got \"my test\", but expect \"%s\"", v)
	}
}