diff --git a/worker/worker.go b/worker/worker.go
index f4d926e..a81f4ab 100644
--- a/worker/worker.go
+++ b/worker/worker.go
@@ -183,7 +183,11 @@ func (worker *Worker) Ready() (err error) {
 // Most of time, this should be evaluated in goroutine.
 func (worker *Worker) Work() {
 	if ! worker.ready {
-		panic( "worker: Work() called before Ready()")
+		// didn't run Ready beforehand, so we'll have to do it:
+		err := worker.Ready()
+		if err != nil {
+			panic( err )
+		}
 	}
 
 	defer func() {
diff --git a/worker/worker_test.go b/worker/worker_test.go
index 7fa8f0b..06ce15f 100644
--- a/worker/worker_test.go
+++ b/worker/worker_test.go
@@ -3,6 +3,7 @@ package worker
 import (
 	"sync"
 	"testing"
+	"time"
 )
 
 var worker *Worker
@@ -77,6 +78,92 @@ func TestWork(t *testing.T) {
 	wg.Wait()
 }
 
+
 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 := 3
+		for( tries > 0 ){
+			if other_worker.ready {
+				other_worker.Echo([]byte("Hello"))
+				break
+			}
+
+			// still waiting for it to be ready..
+			time.Sleep(1 * time.Second)
+			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:
+	}
+
+}