feat: standalone targeting, fractional shorthand

Signed-off-by: Todd Baert <todd.baert@dynatrace.com>

Author: toddbaert

json/flagd_definitions_test.go

@@ -13,34 +13,51 @@ import (
 	"github.com/xeipuuv/gojsonschema"
 )
 
-var compiledSchema *gojsonschema.Schema
+var compiledFlagDefinitionSchema *gojsonschema.Schema
+var compiledTargetingSchema *gojsonschema.Schema
 
 func init() {
-	schemaLoader := gojsonschema.NewSchemaLoader()
-	schemaLoader.AddSchemas(gojsonschema.NewStringLoader(flagd_definitions.TargetingSchema))
+	flagDefinitionSchemaLoader := gojsonschema.NewSchemaLoader()
+	flagDefinitionSchemaLoader.AddSchemas(gojsonschema.NewStringLoader(flagd_definitions.TargetingSchema))
+	targetingSchemaLoader := gojsonschema.NewSchemaLoader()
 	var err error
-	compiledSchema, err = schemaLoader.Compile(gojsonschema.NewStringLoader(flagd_definitions.FlagSchema))
+	compiledFlagDefinitionSchema, err = flagDefinitionSchemaLoader.Compile(gojsonschema.NewStringLoader(flagd_definitions.FlagSchema))
+	compiledTargetingSchema, err = targetingSchemaLoader.Compile(gojsonschema.NewStringLoader(flagd_definitions.TargetingSchema))
 	if err != nil {
 		message := fmt.Errorf("err: %v", err)
 		log.Fatal(message)
 	}
 }
 
 func TestPositiveParsing(t *testing.T) {
-	if err := walkPath(true, "./test/positive"); err != nil {
+	if err := walkPath(true, "./test/positive", compiledFlagDefinitionSchema); err != nil {
 		t.Error(err)
 		t.FailNow()
 	}
 }
 
 func TestNegativeParsing(t *testing.T) {
-	if err := walkPath(false, "./test/negative"); err != nil {
+	if err := walkPath(false, "./test/negative", compiledFlagDefinitionSchema); err != nil {
 		t.Error(err)
 		t.FailNow()
 	}
 }
 
-func walkPath(shouldPass bool, root string) error {
+func TestPositiveTargetingParsing(t *testing.T) {
+	if err := walkPath(true, "./test/targeting-only/positive", compiledTargetingSchema); err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+}
+
+func TestNegativeTargetingParsing(t *testing.T) {
+	if err := walkPath(false, "./test/targeting-only/negative", compiledTargetingSchema); err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+}
+
+func walkPath(shouldPass bool, root string, schema *gojsonschema.Schema) error {
 	return filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
 		if err != nil {
 			return err
@@ -56,7 +73,7 @@ func walkPath(shouldPass bool, root string) error {
 
 		flagStringLoader := gojsonschema.NewStringLoader(string(file))
 
-		p, err := compiledSchema.Validate(flagStringLoader)
+		p, err := schema.Validate(flagStringLoader)
 		if err != nil {
 			return err
 		}

json/targeting.json

@@ -4,6 +4,11 @@
   "title": "flagd Targeting",
   "description": "Defines targeting logic for flagd; a extension of JSONLogic, including purpose-built feature-flagging operations.",
   "type": "object",
+  "properties": {
+    "targeting": {
+      "$ref": "#/definitions/targeting"
+    }
+  },
   "definitions": {
     "targeting": {
       "title": "Targeting",
@@ -462,7 +467,7 @@
       "$comment": "if we remove the \"sum to 100\" restriction, update the descriptions below!",
       "description": "Distribution for all possible variants, with their associated weighting out of 100.",
       "type": "array",
-      "minItems": 2,
+      "minItems": 1,
       "maxItems": 2,
       "items": [
         {

json/targeting.yaml

@@ -4,6 +4,9 @@ title: flagd Targeting
 description: Defines targeting logic for flagd; a extension of JSONLogic, including
   purpose-built feature-flagging operations.
 type: object
+properties: 
+  targeting:
+    $ref: "#/definitions/targeting"
 definitions:
   targeting:
     title: Targeting
@@ -363,7 +366,7 @@ definitions:
     description: Distribution for all possible variants, with their associated weighting
       out of 100.
     type: array
-    minItems: 2
+    minItems: 1
     maxItems: 2
     items:
     - description: If this bucket is randomly selected, this string is used to as

json/test/positive/custom-ops.json

@@ -25,6 +25,21 @@
         ]
       }
     },
+    "fractional-flag-shorthand": {
+      "state": "ENABLED",
+      "variants": {
+        "heads": "heads",
+        "tails": "tails",
+        "draw": "draw"
+      },
+      "defaultVariant": "draw",
+      "targeting": {
+        "fractional": [
+          [ "heads" ],
+          [ "tails", 1 ]
+        ]
+      }
+    },
     "shorthand-fractional-flag": {
       "state": "ENABLED",
       "variants": {

json/test/targeting-only/negative/invalid.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "../../../targeting.json",
+  "targeting": {
+    "not-a-valid-rule": "lol"
+  }
+}

json/test/targeting-only/positive/basic-json-ops.json

@@ -0,0 +1,64 @@
+{
+  "$schema": "../../../targeting.json",
+  "targeting": {
+    "*" : [
+      {"if" : [false, "false", false, "false", true, "true"] },
+      {"if" : [ true, "yes", "no" ]},
+      {"if" : [ true, "yes" ]},
+      {"if" : [ true ]},
+      {"==" : [1, 1]},
+      {"===" : [1, 1]},
+      {"!=" : [1, 2]},
+      {"!==" : [1, 2]},
+      {"!": [true]},
+      {"!": true},
+      {"!!": ["0"] },
+      {"or": [true, false]},
+      {"or":[false, 0, "a"]},
+      {"and": [true, true]},
+      {"and":[true, "a", 3]},
+      {">" : [2, 1]},
+      {">=" : [1, 1]},
+      {"<" : [1, 2]},
+      {"<=" : [1, 1]},
+      {"<" : [1, 2, 3]},
+      {"<" : [1, 4, 3]},
+      {"<=" : [1, 2, 3]},
+      {"<=" : [1, 1, 3]},
+      {"max":[1,2,3]},
+      {"min":[1,2,3]},
+      {"+":[4,2]},
+      {"+":[2,2,2,2,2]},
+      {"+" : [ "3.14" ]},
+      {"/":[4,2]},
+      {"*":[2,2,2,2,2]},
+      {"-": [ 2 ]},
+      {"-":[4, 2]},
+      {"%": [101,2]},
+      {"map":[
+        {"var":"integers"},
+        {"*":[{"var":""},2]}
+      ]},
+      {"filter":[
+        {"var":"integers"},
+        {"%":[{"var":""},2]}
+      ]},
+      {"reduce":[
+        {"var":"integers"},
+        {"+":[{"var":"current"}, {"var":"accumulator"}]},
+        0
+      ]},
+      {"all" : [ [1,2,3], {">":[{"var":""}, 0]} ]},
+      {"some" : [ [-1,0,1], {">":[{"var":""}, 0]} ]},
+      {"none" : [ [-3,-2,-1], {">":[{"var":""}, 0]} ]},
+      {"some" : [ {"var":"pies"}, {"==":[{"var":"filling"}, "apple"]} ]},
+      {"merge":[ [1,2], [3,4] ]},
+      {"merge":[ 1, 2, [3,4] ]},
+      {"in":[ "Ringo", ["John", "Paul", "George", "Ringo"] ]},
+      {"in":["Spring", "Springfield"]},
+      {"cat": ["I love", " pie"]},
+      {"substr": ["jsonlogic", 4]},
+      {"substr": ["jsonlogic", 1, 3]}
+    ]
+  }
+}