gearman-go/worker/worker_test.go

170 lines
3.2 KiB
Go
Raw Normal View History

package worker
2013-12-23 17:01:01 +08:00
import (
2013-12-23 17:05:42 +08:00
"sync"
"testing"
"time"
2013-12-23 17:01:01 +08:00
)
var worker *Worker
func init() {
2013-08-30 12:36:57 +08:00
worker = New(Unlimited)
}
2013-12-26 12:06:47 +08:00
func TestWorkerErrNoneAgents(t *testing.T) {
err := worker.Ready()
if err != ErrNoneAgents {
t.Error("ErrNoneAgents expected.")
}
}
func TestWorkerAddServer(t *testing.T) {
2013-08-30 12:36:57 +08:00
t.Log("Add local server 127.0.0.1:4730.")
if err := worker.AddServer(Network, "127.0.0.1:4730"); err != nil {
2013-08-30 12:36:57 +08:00
t.Error(err)
}
if l := len(worker.agents); l != 1 {
t.Log(worker.agents)
t.Error("The length of server list should be 1.")
}
}
2013-12-26 12:06:47 +08:00
func TestWorkerErrNoneFuncs(t *testing.T) {
err := worker.Ready()
if err != ErrNoneFuncs {
t.Error("ErrNoneFuncs expected.")
}
}
2013-08-30 18:01:10 +08:00
func foobar(job Job) ([]byte, error) {
2013-08-30 12:36:57 +08:00
return nil, nil
}
func TestWorkerAddFunction(t *testing.T) {
2013-08-30 12:36:57 +08:00
if err := worker.AddFunc("foobar", foobar, 0); err != nil {
t.Error(err)
}
if err := worker.AddFunc("timeout", foobar, 5); err != nil {
t.Error(err)
}
if l := len(worker.funcs); l != 2 {
t.Log(worker.funcs)
t.Errorf("The length of function map should be %d.", 2)
}
}
2012-05-24 19:21:30 +08:00
func TestWorkerRemoveFunc(t *testing.T) {
2013-08-30 12:36:57 +08:00
if err := worker.RemoveFunc("foobar"); err != nil {
t.Error(err)
}
}
2013-08-30 18:01:10 +08:00
func TestWork(t *testing.T) {
2013-12-23 17:01:01 +08:00
var wg sync.WaitGroup
worker.JobHandler = func(job Job) error {
t.Logf("%s", job.Data())
wg.Done()
return nil
}
if err := worker.Ready(); err != nil {
t.Error(err)
return
}
2013-08-30 18:01:10 +08:00
go worker.Work()
2013-12-23 17:01:01 +08:00
wg.Add(1)
worker.Echo([]byte("Hello"))
wg.Wait()
2013-08-30 18:01:10 +08:00
}
2013-08-30 18:01:10 +08:00
func TestWorkerClose(t *testing.T) {
worker.Close()
}
func TestWorkWithoutReady(t * testing.T){
other_worker := New(Unlimited)
if err := other_worker.AddServer(Network, "127.0.0.1:4730"); err != nil {
t.Error(err)
}
if err := other_worker.AddFunc("gearman-go-workertest", foobar, 0); err != nil {
t.Error(err)
}
timeout := make(chan bool, 1)
done := make( chan bool, 1)
other_worker.JobHandler = func( j Job ) error {
if( ! other_worker.ready ){
t.Error("Worker not ready as expected");
}
done <-true
return nil
}
go func() {
time.Sleep(5 * time.Second)
timeout <- true
}()
go func(){
other_worker.Work();
}()
// With the all-in-one Work() we don't know if the
// worker is ready at this stage so we may have to wait a sec:
go func(){
tries := 5
for( tries > 0 ){
if other_worker.ready {
other_worker.Echo([]byte("Hello"))
break
}
// still waiting for it to be ready..
time.Sleep(250 * time.Millisecond)
tries--
}
}()
// determine if we've finished or timed out:
select{
case <- timeout:
t.Error("Test timed out waiting for the worker")
case <- done:
}
}
func TestWorkWithoutReadyWithPanic(t * testing.T){
other_worker := New(Unlimited)
timeout := make(chan bool, 1)
done := make( chan bool, 1)
// Going to work with no worker setup.
// when Work (hopefully) calls Ready it will get an error which should cause it to panic()
go func(){
defer func() {
if err := recover(); err != nil {
done <- true
return
}
t.Error("Work should raise a panic.")
done <- true
}()
other_worker.Work();
}()
go func() {
time.Sleep(2 * time.Second)
timeout <- true
}()
select{
case <- timeout:
t.Error("Test timed out waiting for the worker")
case <- done:
}
}