v1.0.1; fix bug; update readme

fix issue where per job options were not overriding default options

Author: matthewoestreich

README.md

@@ -63,58 +63,52 @@ func main() {
 How do I know if a job timed out? How do I handle an error in my job?
 
 ```golang
-package main
-
 import (
-	"fmt"
-	"time"
-
 	wpxt "github.com/oze4/workerpoolxt"
+	// ...
 )
 
-func main() {
-	wp := wpxt.New(3, time.Duration(time.Second*10))
+wp := wpxt.New(3, time.Duration(time.Second*10))
 
-        // Uses default timeout
-	wp.SubmitXT(wpxt.Job{ 
-		Name: "Job 1 will pass",
-		Task: func(o wpxt.Options) wpxt.Response {
-			return wpxt.Response{Data: "yay"}
-		},
-	})
+// Uses default timeout
+wp.SubmitXT(wpxt.Job{ 
+	Name: "Job 1 will pass",
+	Task: func(o wpxt.Options) wpxt.Response {
+		return wpxt.Response{Data: "yay"}
+	},
+})
 
-        // Uses custom timeout
-	// This job is configured to timeout on purpose
-	wp.SubmitXT(wpxt.Job{ 
-		Name:    "Job 2 will timeout",
-		Timeout: time.Duration(time.Millisecond * 1),
-		Task: func(o wpxt.Options) wpxt.Response {
-		        // Simulate long running task
-			time.Sleep(time.Second * 20) 
-			return wpxt.Response{Data: "timedout"}
-		},
-	})
+// Uses custom timeout
+// This job is configured to timeout on purpose
+wp.SubmitXT(wpxt.Job{ 
+	Name:    "Job 2 will timeout",
+	Timeout: time.Duration(time.Millisecond * 1),
+	Task: func(o wpxt.Options) wpxt.Response {
+	  // Simulate long running task
+		time.Sleep(time.Second * 20) 
+		return wpxt.Response{Data: "timedout"}
+	},
+})
 
-        // Or if you encounter an error within the code in your job
-	wp.SubmitXT(wpxt.Job{ 
-		Name: "Job 3 will encounter an error",
-		Task: func(o wpxt.Options) wpxt.Response {
-			err := fmt.Errorf("ErrorPretendException : something failed")
-			if err != nil {
-				return wpxt.Response{Error: err}
-			}
-			return wpxt.Response{Data: "error"}
-		},
-	})
+// Or if you encounter an error within the code in your job
+wp.SubmitXT(wpxt.Job{ 
+	Name: "Job 3 will encounter an error",
+	Task: func(o wpxt.Options) wpxt.Response {
+		err := fmt.Errorf("ErrorPretendException : something failed")
+		if err != nil {
+			return wpxt.Response{Error: err}
+		}
+		return wpxt.Response{Data: "error"}
+	},
+})
 
-	results := wp.StopWaitXT()
+results := wp.StopWaitXT()
 
-	for _, r := range results {
-		if r.Error != nil {
-			fmt.Println(r.Name(), "has failed with error :", r.Error.Error())
-		} else {
-			fmt.Println(r.Name(), "has passed successfully")
-		}
+for _, r := range results {
+	if r.Error != nil {
+		fmt.Println(r.Name(), "has failed with error :", r.Error.Error())
+	} else {
+		fmt.Println(r.Name(), "has passed successfully")
 	}
 }
 
@@ -130,7 +124,7 @@ func main() {
  - Options are nothing more than `map[string]interface{}` so that you may supply anything you wish. This also simplifies accessing options within a job.
  - You can supply options along with the workerpool, or on a per job basis. 
  - **If a job has options set, it overrides the defaults**
- - **We do not merge options**.
+ - **We do not merge options**
 
 #### Supply default options
 
@@ -164,10 +158,13 @@ import (
 )
 
 wp := wpxt.New(10, time.Duration(time.Second*10))
-myclient := &http.Client{}
 
+httpclient := &http.Client{}
+k8s := kubernetes.Clientset{}
+
+// This Job Only Needs an HTTP Client
 wp.SubmitXT(wpxt.Job{
-    Name: "myjob",
+    Name: "This Job Only Needs an HTTP Client",
     Options: map[string]interface{}{
         "http": myclient 
     },
@@ -176,4 +173,16 @@ wp.SubmitXT(wpxt.Job{
         httpclient := o["http"]
     }, 
 })
+
+// This Job Only Needs Kubernetes Clientset
+wp.SubmitXT(wpxt.Job{
+    Name: "This Job Only Needs Kubernetes Clientset",
+    Options: map[string]interface{}{
+        "kube": k8s 
+    },
+    Task: func(o wpxt.Options) wpxt.Response {
+        // access options here
+        kubernetesclient := o["kube"]
+    }, 
+})
 ```

workerpoolxt.go

@@ -111,13 +111,13 @@ func (wp *WorkerPoolXT) getTimeout(job Job) time.Duration {
 
 // getOptions decides which options to use : default or job
 func (wp *WorkerPoolXT) getOptions(job Job) Options {
-	if wp.options == nil && job.Options == nil {
-		return make(Options)
+	if job.Options != nil {
+		return job.Options
 	}
 	if wp.options != nil {
 		return wp.options
 	}
-	return job.Options
+	return make(Options)
 }
 
 // processResponses listens for anything on the responses chan and appends the response to

workerpoolxt_test.go

@@ -269,3 +269,46 @@ func TestPerJobOptions(t *testing.T) {
 		}
 	}
 }
+
+func TestPerJobOptionsOverrideDefaultOptions(t *testing.T) {
+	wp := New(3, time.Duration(time.Second*10))
+	// set default options so we can verify they were overwritten by per job options
+	opts := map[string]interface{}{"default": "value"}
+	wp.WithOptions(opts)
+	wp.SubmitXT(Job{
+		Name: "job 1",
+		Task: func(o Options) Response {
+			// Set data to our opts myvar
+			return Response{Data: o["var"]}
+		},
+		Options: map[string]interface{}{"var": "job1value"},
+	})
+	wp.SubmitXT(Job{
+		Name: "job 2",
+		Task: func(o Options) Response {
+			// Set data to our opts myvar
+			return Response{Data: o["var"]}
+		},
+		Options: map[string]interface{}{"var": "job2value"},
+	})
+
+	res := wp.StopWaitXT()
+	for _, result := range res {
+		if result.Name() == "" {
+			t.Fatalf("Expected option %s to be %s but got %s", "var", "not ''", "''")
+		}
+		if result.Data == "" {
+			t.Fatalf("Expected data to not be null on : %s", result.Name())
+		}
+		if result.Name() == "job 1" {
+			if result.Data != "job1value" {
+				t.Fatalf("Expected %s option 'var' to be %s but got %s", result.Name(), "job1value", result.Data)
+			}
+		}
+		if result.Name() == "job 2" {
+			if result.Data != "job2value" {
+				t.Fatalf("Expected %s option 'var' to be %s but got %s", result.Name(), "job2value", result.Data)
+			}
+		}
+	}
+}