🎲 random_once router type

flows/routers/random_once.go

@@ -0,0 +1,115 @@
+package routers
+
+import (
+	"encoding/json"
+	"strconv"
+
+	"github.com/nyaruka/gocommon/jsonx"
+	"github.com/nyaruka/gocommon/random"
+	"github.com/nyaruka/goflow/flows"
+	"github.com/nyaruka/goflow/utils"
+
+	"github.com/pkg/errors"
+)
+
+func init() {
+	registerType(TypeRandomOnce, readRandomOnceRouter)
+}
+
+// TypeRandomOnce is the type for a random once router
+const TypeRandomOnce string = "random_once"
+
+// RandomOnceRouter is a router which will choose one of it's exits at random, but only using each exit once
+type RandomOnceRouter struct {
+	baseRouter
+
+	defaultCategoryUUID flows.CategoryUUID
+}
+
+// NewRandomOnce creates a new random once router
+func NewRandomOnce(wait flows.Wait, resultName string, categories []flows.Category, defaultCategoryUUID flows.CategoryUUID) *RandomOnceRouter {
+	return &RandomOnceRouter{
+		baseRouter:          newBaseRouter(TypeRandom, wait, resultName, categories),
+		defaultCategoryUUID: defaultCategoryUUID,
+	}
+}
+
+// Validate validates that the fields on this router are valid
+func (r *RandomOnceRouter) Validate(flow flows.Flow, exits []flows.Exit) error {
+	// check the done category is valid
+	if r.defaultCategoryUUID != "" && !r.isValidCategory(r.defaultCategoryUUID) {
+		return errors.Errorf("default category %s is not a valid category", r.defaultCategoryUUID)
+	}
+
+	return r.validate(flow, exits)
+}
+
+// Route determines which exit to take from a node
+func (r *RandomOnceRouter) Route(run flows.FlowRun, step flows.Step, logEvent flows.EventCallback) (flows.ExitUUID, error) {
+	// find all the exits we have taken in the past
+	exitsTaken := make(map[flows.ExitUUID]bool)
+	for _, s := range run.Path() {
+		if s.NodeUUID() == step.NodeUUID() {
+			exitsTaken[s.ExitUUID()] = true
+		}
+	}
+
+	// convert that to bucket categories remaining
+	bucketsRemaining := make([]flows.Category, 0)
+	for _, c := range r.categories {
+		if !exitsTaken[c.ExitUUID()] && c.UUID() != r.defaultCategoryUUID {
+			bucketsRemaining = append(bucketsRemaining, c)
+		}
+	}
+
+	// take the default route if we've been to all the other bucket categories
+	if len(bucketsRemaining) == 0 {
+		return r.routeToCategory(run, step, r.defaultCategoryUUID, "", "", nil, logEvent)
+	}
+
+	// pick a random remaining bucket category
+	categoryNum := random.IntN(len(bucketsRemaining))
+	categoryUUID := bucketsRemaining[categoryNum].UUID()
+
+	return r.routeToCategory(run, step, categoryUUID, strconv.Itoa(categoryNum), "", nil, logEvent)
+}
+
+//------------------------------------------------------------------------------------------
+// JSON Encoding / Decoding
+//------------------------------------------------------------------------------------------
+
+type randomOnceRouterEnvelope struct {
+	baseRouterEnvelope
+
+	DefaultCategoryUUID flows.CategoryUUID `json:"default_category_uuid" validate:"required,uuid4"`
+}
+
+func readRandomOnceRouter(data json.RawMessage) (flows.Router, error) {
+	e := &randomOnceRouterEnvelope{}
+	if err := utils.UnmarshalAndValidate(data, e); err != nil {
+		return nil, err
+	}
+
+	r := &RandomOnceRouter{
+		defaultCategoryUUID: e.DefaultCategoryUUID,
+	}
+
+	if err := r.unmarshal(&e.baseRouterEnvelope); err != nil {
+		return nil, err
+	}
+
+	return r, nil
+}
+
+// MarshalJSON marshals this resume into JSON
+func (r *RandomOnceRouter) MarshalJSON() ([]byte, error) {
+	e := &randomOnceRouterEnvelope{
+		DefaultCategoryUUID: r.defaultCategoryUUID,
+	}
+
+	if err := r.marshal(&e.baseRouterEnvelope); err != nil {
+		return nil, err
+	}
+
+	return jsonx.Marshal(e)
+}

flows/routers/testdata/random_once.json

@@ -0,0 +1,118 @@
+[
+    {
+        "description": "Random bucket category chosen and result created",
+        "router": {
+            "type": "random_once",
+            "result_name": "Random Result",
+            "categories": [
+                {
+                    "uuid": "598ae7a5-2f81-48f1-afac-595262514aa1",
+                    "name": "Question 1",
+                    "exit_uuid": "49a47f31-ec90-42b5-a0d8-6efb5b1fa57b"
+                },
+                {
+                    "uuid": "c70fe86c-9aac-4cc2-a5cb-d35cbe3fed6e",
+                    "name": "Question 2",
+                    "exit_uuid": "5bd6a427-2b9a-4a4d-ad3f-eb39eaaa7e5a"
+                },
+                {
+                    "uuid": "78ae8f05-f92e-43b2-a886-406eaea1b8e0",
+                    "name": "Done",
+                    "exit_uuid": "b787ffe3-c21a-46ad-9475-954614b52477"
+                }
+            ],
+            "default_category_uuid": "78ae8f05-f92e-43b2-a886-406eaea1b8e0"
+        },
+        "results": {
+            "random_result": {
+                "name": "Random Result",
+                "value": "1",
+                "category": "Question 2",
+                "node_uuid": "64373978-e8f6-4973-b6ff-a2993f3376fc",
+                "created_on": "2018-10-18T14:20:30.000123456Z"
+            }
+        },
+        "events": [
+            {
+                "type": "run_result_changed",
+                "created_on": "2018-10-18T14:20:30.000123456Z",
+                "step_uuid": "59d74b86-3e2f-4a93-aece-b05d2fdcde0c",
+                "name": "Random Result",
+                "value": "1",
+                "category": "Question 2"
+            }
+        ],
+        "inspection": {
+            "dependencies": [],
+            "issues": [],
+            "results": [
+                {
+                    "key": "random_result",
+                    "name": "Random Result",
+                    "categories": [
+                        "Question 1",
+                        "Question 2",
+                        "Done"
+                    ],
+                    "node_uuids": [
+                        "64373978-e8f6-4973-b6ff-a2993f3376fc"
+                    ]
+                }
+            ],
+            "waiting_exits": [],
+            "parent_refs": []
+        }
+    },
+    {
+        "description": "Default category taken if no bucket categories",
+        "router": {
+            "type": "random_once",
+            "result_name": "Random Result",
+            "categories": [
+                {
+                    "uuid": "78ae8f05-f92e-43b2-a886-406eaea1b8e0",
+                    "name": "Done",
+                    "exit_uuid": "b787ffe3-c21a-46ad-9475-954614b52477"
+                }
+            ],
+            "default_category_uuid": "78ae8f05-f92e-43b2-a886-406eaea1b8e0"
+        },
+        "results": {
+            "random_result": {
+                "name": "Random Result",
+                "value": "",
+                "category": "Done",
+                "node_uuid": "64373978-e8f6-4973-b6ff-a2993f3376fc",
+                "created_on": "2018-10-18T14:20:30.000123456Z"
+            }
+        },
+        "events": [
+            {
+                "type": "run_result_changed",
+                "created_on": "2018-10-18T14:20:30.000123456Z",
+                "step_uuid": "59d74b86-3e2f-4a93-aece-b05d2fdcde0c",
+                "name": "Random Result",
+                "category": "Done",
+                "value": ""
+            }
+        ],
+        "inspection": {
+            "dependencies": [],
+            "issues": [],
+            "results": [
+                {
+                    "key": "random_result",
+                    "name": "Random Result",
+                    "categories": [
+                        "Done"
+                    ],
+                    "node_uuids": [
+                        "64373978-e8f6-4973-b6ff-a2993f3376fc"
+                    ]
+                }
+            ],
+            "waiting_exits": [],
+            "parent_refs": []
+        }
+    }
+]

test/runner_test.go

@@ -14,6 +14,7 @@ import (
 	"github.com/nyaruka/gocommon/dates"
 	"github.com/nyaruka/gocommon/httpx"
 	"github.com/nyaruka/gocommon/jsonx"
+	"github.com/nyaruka/gocommon/random"
 	"github.com/nyaruka/gocommon/uuids"
 	"github.com/nyaruka/goflow/assets"
 	"github.com/nyaruka/goflow/envs"
@@ -191,6 +192,7 @@ func TestFlows(t *testing.T) {
 	require.NoError(t, err)
 	require.True(t, len(testCases) > 0)
 
+	defer random.SetGenerator(random.DefaultGenerator)
 	defer uuids.SetGenerator(uuids.DefaultGenerator)
 	defer dates.SetNowSource(dates.DefaultNowSource)
 	defer httpx.SetRequestor(httpx.DefaultRequestor)
@@ -200,6 +202,7 @@ func TestFlows(t *testing.T) {
 		var httpMocksCopy *httpx.MockRequestor
 		fmt.Printf("running %s\n", tc)
 
+		random.SetGenerator(random.NewSeededGenerator(123456))
 		uuids.SetGenerator(uuids.NewSeededGenerator(123456))
 		dates.SetNowSource(dates.NewSequentialNowSource(time.Date(2018, 7, 6, 12, 30, 0, 123456789, time.UTC)))
 		smtpx.SetSender(smtpx.NewMockSender(""))