growthbook 0.0.1 → 0.1.0

data/spec/client_spec.rb

@@ -0,0 +1,57 @@
+require 'growthbook'
+require 'json'
+
+describe 'client' do
+  describe ".enabled" do
+    it "chooses variation -1 when client is disabled" do
+      client = Growthbook::Client.new(enabled: false)
+      user = client.user(id: "1")
+      experiment = Growthbook::Experiment.new("my-test", 2)
+      expect(user.experiment(experiment).variation).to eq(-1)
+    end
+  end
+  describe ".importExperimentsHash" do
+    it("imports correctly") do
+      client = Growthbook::Client.new
+
+      # Example JSON response from the GrowthBook API
+      json = '{
+        "status": 200,
+        "experiments": {
+          "my-test": {
+            "variations": 2,
+            "coverage": 0.6,
+            "weights": [0.8, 0.2],
+            "anon": true,
+            "force": 1,
+            "targeting": [
+              "source = google"
+            ],
+            "data": {
+              "color": ["blue", "green"]
+            }
+          },
+          "my-stopped-test": {
+            "variations": 3,
+            "force": 1
+          }
+        }
+      }'
+
+      parsed = JSON.parse(json)
+      client.importExperimentsHash(parsed["experiments"])
+
+      expect(client.experiments.length).to eq(2)
+
+      experiment = client.experiments[0]
+      expect(experiment.id).to eq("my-test")
+      expect(experiment.variations).to eq(2)
+      expect(experiment.coverage).to eq(0.6)
+      expect(experiment.weights[0]).to eq(0.8)
+      expect(experiment.anon).to eq(true)
+      expect(experiment.force).to eq(1)
+      expect(experiment.targeting[0]).to eq("source = google")
+      expect(experiment.data["color"][0]).to eq("blue")
+    end
+  end
+end

data/spec/context_spec.rb

@@ -0,0 +1,120 @@
+require 'growthbook'
+require 'json'
+
+describe 'context' do
+  describe "feature helper methods" do
+    gb = Growthbook::Context.new(
+      features: {
+        feature1: {
+          defaultValue: 1
+        },
+        feature2: {
+          defaultValue: 0
+        }
+      }
+    )
+
+    it ".on?" do
+      expect(gb.on?(:feature1)).to eq(true)
+      expect(gb.on?(:feature2)).to eq(false)
+    end
+    it ".off?" do
+      expect(gb.off?(:feature1)).to eq(false)
+      expect(gb.off?(:feature2)).to eq(true)
+    end
+    it ".feature_value" do
+      expect(gb.feature_value(:feature1)).to eq(1)
+      expect(gb.feature_value(:feature2)).to eq(0)
+    end
+  end
+
+  describe "forced feature values" do
+    it "uses forced values" do
+      gb = Growthbook::Context.new(
+        features: {
+          feature: {
+            defaultValue: "a"
+          },
+          feature2: {
+            defaultValue: true
+          }
+        }
+      )
+
+      gb.forced_features = {
+        feature: "b",
+        another: 2
+      }
+
+      expect(gb.feature_value(:feature)).to eq("b")
+      expect(gb.feature_value(:feature2)).to eq(true)
+      expect(gb.feature_value(:another)).to eq(2)
+      expect(gb.feature_value(:unknown)).to eq(nil)
+    end
+  end
+
+  describe "tracking" do
+    it "queues up impressions" do
+      class MyImpressionListener
+        attr_accessor :tracked
+        def on_experiment_viewed(exp, res)
+          @tracked = [exp.to_json, res.to_json]
+        end
+      end
+
+      listener = MyImpressionListener.new
+
+      gb = Growthbook::Context.new(
+        attributes: {
+          id: "123"
+        },
+        features: {
+          feature1: {
+            defaultValue: 1,
+            rules: [
+              {
+                variations: [2, 3]
+              }
+            ]
+          },
+          feature2: {
+            defaultValue: 0,
+            rules: [
+              {
+                variations: [4, 5]
+              }
+            ]
+          }
+        },
+        listener: listener
+      )
+
+      expect(gb.impressions).to eq({})
+      expect(listener.tracked).to eq(nil)
+
+      gb.on? :feature1
+
+      expect(gb.impressions["feature1"].to_json).to eq({
+        "hashAttribute" => "id",
+        "hashValue" => "123",
+        "inExperiment" => true,
+        "value" => 2,
+        "variationId" => 0,
+      })
+
+      expect(listener.tracked).to eq([
+        {
+          "key" => "feature1",
+          "variations" => [2, 3]
+        },
+        {
+          "hashAttribute" => "id",
+          "hashValue" => "123",
+          "inExperiment" => true,
+          "value" => 2,
+          "variationId" => 0,
+        }
+      ])
+    end
+  end
+end

data/spec/json_spec.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require 'growthbook'
+require 'json'
+
+file = File.read(File.join(File.dirname(__FILE__), 'cases.json'))
+test_cases = JSON.parse(file)
+
+def roundArray(arr)
+  arr.map do |v|
+    v.is_a?(Float) || v.is_a?(Integer) ? v.round(5) : roundArray(v)
+  end
+end
+
+describe 'test suite' do
+  describe 'hash' do
+    test_cases['hash'].each do |test_case|
+      value, expected = test_case
+
+      it value do
+        result = Growthbook::Util.hash(value)
+        expect(result.round(5)).to eq expected.round(5)
+      end
+    end
+  end
+
+  describe 'getBucketRanges' do
+    # Loop through each test case in the JSON file
+    test_cases['getBucketRange'].each do |test_case|
+      # Extract data about the test case
+      test_name, args, expected = test_case
+      num_variations, coverage, weights = args
+
+      # Run the actual test case
+      it test_name do
+        result = Growthbook::Util.get_bucket_ranges(
+          num_variations,
+          coverage,
+          weights
+        )
+
+        expect(roundArray(result)).to eq(roundArray(expected))
+      end
+    end
+  end
+
+  describe 'chooseVariation' do
+    # Loop through each test case in the JSON file
+    test_cases['chooseVariation'].each do |test_case|
+      # Extract data about the test case
+      test_name, n, ranges, expected = test_case
+
+      # Run the actual test case
+      it test_name do
+        result = Growthbook::Util.choose_variation(n, ranges)
+        expect(result).to eq(expected)
+      end
+    end
+  end
+
+  describe 'getQueryStringOverride' do
+    # Loop through each test case in the JSON file
+    test_cases['getQueryStringOverride'].each do |test_case|
+      # Extract data about the test case
+      test_name, key, url, num_variations, expected = test_case
+
+      # Run the actual test case
+      it test_name do
+        result = Growthbook::Util.get_query_string_override(
+          key,
+          url,
+          num_variations
+        )
+        expect(result).to eq(expected)
+      end
+    end
+  end
+
+  describe 'inNamespace' do
+    # Loop through each test case in the JSON file
+    test_cases['inNamespace'].each do |test_case|
+      # Extract data about the test case
+      test_name, id, namespace, expected = test_case
+
+      # Run the actual test case
+      it test_name do
+        result = Growthbook::Util.in_namespace(
+          id,
+          namespace
+        )
+        expect(result).to eq(expected)
+      end
+    end
+  end
+
+  describe 'getEqualWeights' do
+    # Loop through each test case in the JSON file
+    test_cases['getEqualWeights'].each do |test_case|
+      # Extract data about the test case
+      num_variations, expected = test_case
+
+      # Run the actual test case
+      it num_variations.to_s do
+        result = Growthbook::Util.get_equal_weights(
+          num_variations
+        )
+        expect(roundArray(result)).to eq(roundArray(expected))
+      end
+    end
+  end
+
+  describe 'evalCondition' do
+    # Loop through each test case in the JSON file
+    test_cases['evalCondition'].each do |test_case|
+      # Extract data about the test case
+      test_name, condition, attributes, expected = test_case
+
+      # Run the actual test case
+      it test_name do
+        result = Growthbook::Conditions.eval_condition(
+          attributes,
+          condition
+        )
+        expect(result).to eq(expected)
+      end
+    end
+  end
+  describe 'feature' do
+    # Loop through each test case in the JSON file
+    test_cases['feature'].each do |test_case|
+      # Extract data about the test case
+      test_name, context, key, expected = test_case
+
+      # Run the actual test case
+      it test_name do
+        gb = Growthbook::Context.new(context)
+        result = gb.eval_feature(key)
+        expect(result.to_json).to eq(expected)
+      end
+    end
+  end
+
+  describe 'run' do
+    # Loop through each test case in the JSON file
+    test_cases['run'].each do |test_case|
+      # Extract data about the test case
+      test_name, context, experiment, value, in_experiment = test_case
+
+      # Run the actual test case
+      it test_name do
+        gb = Growthbook::Context.new(context)
+        exp = Growthbook::InlineExperiment.new(experiment)
+        result = gb.run(exp)
+        expect(result.value).to eq(value)
+        expect(result.in_experiment).to eq(in_experiment)
+      end
+    end
+  end
+end

data/spec/user_spec.rb

@@ -0,0 +1,213 @@
+require 'growthbook'
+
+describe 'user' do
+  describe ".experiment" do
+    it "uses experiment overrides in client first" do
+      client = Growthbook::Client.new
+      override = Growthbook::Experiment.new("my-test", 2)
+      client.experiments << override
+
+      experiment = Growthbook::Experiment.new("my-test", 2)
+      user = client.user(id: "1")
+      result = user.experiment(experiment)
+
+      expect(result.experiment).to eq(override)
+    end
+
+    it "assigns properly with both user id and anonymous ids" do
+      client = Growthbook::Client.new
+      userOnly = client.user(id: "1")
+      anonOnly = client.user(anonId: "2")
+      both = client.user(id: "1", anonId: "2")
+
+      experimentAnon = Growthbook::Experiment.new("my-test", 2, anon:true)
+      experimentUser = Growthbook::Experiment.new("my-test", 2, anon:false)
+
+      expect(userOnly.experiment(experimentUser).variation).to eq(1)
+      expect(both.experiment(experimentUser).variation).to eq(1)
+      expect(anonOnly.experiment(experimentUser).variation).to eq(-1)
+
+      expect(userOnly.experiment(experimentAnon).variation).to eq(-1)
+      expect(both.experiment(experimentAnon).variation).to eq(0)
+      expect(anonOnly.experiment(experimentAnon).variation).to eq(0)
+    end
+
+    it "returns variation config data" do
+      client = Growthbook::Client.new
+      user = client.user(id: "1")
+      experiment = Growthbook::Experiment.new("my-test", 2, data: {
+        :color => ["blue", "green"],
+        :size => ["small", "large"]
+      })
+
+      # Get correct config data
+      result = user.experiment(experiment)
+      expect(result.data[:color]).to eq("green")
+      expect(result.data[:size]).to eq("large")
+
+      # Fallback to control config data if not in test
+      experiment.coverage = 0.01
+      result = user.experiment(experiment)
+      expect(result.data[:color]).to eq("blue")
+      expect(result.data[:size]).to eq("small")
+
+      # Null for undefined keys
+      expect(result.data[:unknown]).to eq(nil)
+    end
+
+    it "uses forced variations properly" do
+      client = Growthbook::Client.new
+      experiment = Growthbook::Experiment.new("my-test", 2, force: -1)
+      user = client.user(id: "1")
+
+      expect(user.experiment(experiment).variation).to eq(-1)
+      experiment.force = 0
+      expect(user.experiment(experiment).variation).to eq(0)
+      experiment.force = 1
+      expect(user.experiment(experiment).variation).to eq(1)
+    end
+
+    it "evaluates targeting before forced variation" do
+      client = Growthbook::Client.new
+      experiment = Growthbook::Experiment.new("my-test", 2, force: 1, targeting: ["age > 18"])
+      user = client.user(id: "1")
+
+      expect(user.experiment(experiment).variation).to eq(-1)
+    end
+
+    it "sets the shouldTrack flag on results" do
+      client = Growthbook::Client.new
+      experiment = Growthbook::Experiment.new("my-test", 2, data: {"color" => ["blue", "green"]})
+      client.experiments << experiment
+      user = client.user(id: "1")
+
+      # Normal
+      expect(user.experiment("my-test").shouldTrack?).to eq(true)
+      expect(user.experiment("my-test").forced?).to eq(false)
+      expect(user.lookupByDataKey("color").shouldTrack?).to eq(true)
+      expect(user.lookupByDataKey("color").forced?).to eq(false)
+
+      # Failed coverage
+      experiment.coverage = 0.01
+      expect(user.experiment("my-test").shouldTrack?).to eq(false)
+      expect(user.experiment("my-test").forced?).to eq(false)
+      expect(user.lookupByDataKey("color")).to eq(nil)
+
+      # Forced variation
+      experiment.coverage = 1.0
+      experiment.force = 1
+      expect(user.experiment("my-test").shouldTrack?).to eq(false)
+      expect(user.experiment("my-test").forced?).to eq(true)
+      expect(user.lookupByDataKey("color").shouldTrack?).to eq(false)
+      expect(user.lookupByDataKey("color").forced?).to eq(true)
+    end
+
+    it "can target an experiment given rules and attributes" do
+      client = Growthbook::Client.new
+      experiment = Growthbook::Experiment.new("my-test", 2, targeting: [
+        "member = true",
+        "age > 18",
+        "source ~ (google|yahoo)",
+        "name != matt",
+        "email !~ ^.*@exclude.com$"
+      ])
+
+      attributes = {
+        :member => true,
+        :age => 21,
+        :source => 'yahoo',
+        :name => 'george',
+        :email => 'test@example.com'
+      }
+
+      # Matches all
+      user = client.user(id: "1", attributes: attributes)
+      expect(user.experiment(experiment).variation).to eq(1)
+
+      # Missing negative checks
+      user.attributes={
+        :member => true,
+        :age => 21,
+        :source => "yahoo"
+      }
+      expect(user.experiment(experiment).variation).to eq(1)
+
+      # Fails boolean
+      user.attributes=attributes.merge({
+        :member => false
+      })
+      expect(user.experiment(experiment).variation).to eq(-1)
+    end
+  end
+
+  describe "resultsToTrack" do
+    it "queues up results" do
+      client = Growthbook::Client.new
+      user = client.user(id: "1")
+
+      user.experiment(Growthbook::Experiment.new("my-test", 2))
+      user.experiment(Growthbook::Experiment.new("my-test2", 2))
+      user.experiment(Growthbook::Experiment.new("my-test3", 2))
+
+      expect(user.resultsToTrack.length).to eq(3)
+    end
+    it "ignores duplicates" do
+      client = Growthbook::Client.new
+      user = client.user(id: "1")
+      user.experiment(Growthbook::Experiment.new("my-test", 2))
+      user.experiment(Growthbook::Experiment.new("my-test", 2))
+
+      expect(user.resultsToTrack.length).to eq(1)
+    end
+  end
+
+  describe ".lookupByDataKey" do
+    before(:all) do
+      @client = Growthbook::Client.new
+      @client.experiments << Growthbook::Experiment.new(
+        "button-color-size-chrome", 
+        2,
+        :targeting => ["browser = chrome"],
+        :data => {
+          "button.color" => ["blue", "green"],
+          "button.size" => ["small", "large"]
+        }
+      )
+      @client.experiments <<  Growthbook::Experiment.new(
+        "button-color-safari", 
+        2,
+        :targeting => ["browser = safari"],
+        :data => {
+          "button.color" => ["blue", "green"]
+        }
+      )
+    end
+    it "returns nil when there are no matches" do
+      user = @client.user(id: "1")
+
+      # No matches
+      expect(user.lookupByDataKey("button.unknown")).to eq(nil)
+    end
+    it "returns the first matching experiment" do
+      user = @client.user(id: "1", attributes: {:browser => "chrome"})
+
+      color = user.lookupByDataKey("button.color")
+      expect(color.value).to eq("blue")
+      expect(color.experiment.id).to eq("button-color-size-chrome")
+
+      size = user.lookupByDataKey("button.size")
+      expect(size.value).to eq("small")
+      expect(size.experiment.id).to eq("button-color-size-chrome")
+    end
+    it "skips experiments that fail targeting rules" do
+      user = @client.user(id: "1", attributes: {:browser => "safari"})
+
+      color = user.lookupByDataKey("button.color")
+      expect(color.value).to eq("blue")
+      expect(color.experiment.id).to eq("button-color-safari")
+
+      size = user.lookupByDataKey("button.size")
+      expect(size).to eq(nil)
+    end
+  end
+end

data/spec/util_spec.rb

@@ -0,0 +1,154 @@
+require 'growthbook'
+
+describe 'util' do
+  describe "checkRule function" do
+    it "works for all operators and normal inputs" do
+      # =
+      expect(Growthbook::Util.checkRule("test", "=", "test")).to eq(true)
+      expect(Growthbook::Util.checkRule("test", "=", "other")).to eq(false)
+      # !=
+      expect(Growthbook::Util.checkRule("test", "!=", "other")).to eq(true)
+      expect(Growthbook::Util.checkRule("test", "!=", "test")).to eq(false)
+      # >
+      expect(Growthbook::Util.checkRule("b", ">", "a")).to eq(true)
+      expect(Growthbook::Util.checkRule("a", ">", "b")).to eq(false)
+      # <
+      expect(Growthbook::Util.checkRule("a", "<", "b")).to eq(true)
+      expect(Growthbook::Util.checkRule("b", "<", "a")).to eq(false)
+      # ~
+      expect(Growthbook::Util.checkRule("123-456-abc", "~", "^[0-9]{3}-[0-9]{3}-[a-z]{3}$")).to eq(true)
+      expect(Growthbook::Util.checkRule("123-abc-456", "~", "^[0-9]{3}-[0-9]{3}-[a-z]{3}$")).to eq(false)
+      # !~
+      expect(Growthbook::Util.checkRule("123-abc-456", "!~", "^[0-9]{3}-[0-9]{3}-[a-z]{3}$")).to eq(true)
+      expect(Growthbook::Util.checkRule("123-456-abc", "!~", "^[0-9]{3}-[0-9]{3}-[a-z]{3}$")).to eq(false)
+    end
+
+    it "returns true when there's an unknown operator" do
+      expect(Growthbook::Util.checkRule("abc", "*", "123")).to eq(true)
+    end
+
+    it "returns false when the regex is invalid" do
+      expect(Growthbook::Util.checkRule("abc", "~", "abc)")).to eq(false)
+    end
+
+    it "compares numeric strings with natural ordering" do
+      expect(Growthbook::Util.checkRule("10", ">", "9")).to eq(true)
+      expect(Growthbook::Util.checkRule("9", "<", "1000")).to eq(true)
+      expect(Growthbook::Util.checkRule("90", ">", "800")).to eq(false)
+      expect(Growthbook::Util.checkRule("-10", "<", "10")).to eq(true)
+      expect(Growthbook::Util.checkRule("10", ">", "abc")).to eq(false)
+    end
+
+    it "checks for numeric equality properly" do
+      expect(Growthbook::Util.checkRule("9.0", "=", "9")).to eq(true)
+      expect(Growthbook::Util.checkRule("1.3", "!=", "1.30000")).to eq(false)
+    end
+
+    it "handles empty strings" do
+      expect(Growthbook::Util.checkRule("", "=", "")).to eq(true)
+      expect(Growthbook::Util.checkRule("", "!=", "")).to eq(false)
+      expect(Growthbook::Util.checkRule("", ">", "")).to eq(false)
+      expect(Growthbook::Util.checkRule("", "<", "")).to eq(false)
+      expect(Growthbook::Util.checkRule("", "~", "")).to eq(true)
+      expect(Growthbook::Util.checkRule("", "!~", "")).to eq(false)
+    end
+  end
+
+  describe "chooseVariation function" do
+    it "does not have a sample ratio mismatch bug" do
+      # Full coverage
+      experiment = Growthbook::Experiment.new("my-test", 2)
+      variations = [0, 0]
+      for i in 0..999
+        variations[Growthbook::Util.chooseVariation(i.to_s, experiment)] += 1
+      end
+      expect(variations[0]).to eq(503)
+    end
+
+    it "does not have a sample ratio mismatch bug for reduced coverage" do
+      # Reduced coverage
+      experiment = Growthbook::Experiment.new("my-test", 2, coverage: 0.4)
+      var0 = 0
+      var1 = 0
+      varn = 0
+      for i in 0..999
+        result = Growthbook::Util.chooseVariation(i.to_s, experiment)
+        case result
+        when -1
+          varn += 1
+        when 0
+          var0 += 1
+        else
+          var1 += 1
+        end
+      end
+      expect(var0).to eq(200)
+      expect(var1).to eq(204)
+      expect(varn).to eq(596)
+    end
+
+    it "assigns variations with default weights" do
+      experiment = Growthbook::Experiment.new("my-test", 2)
+
+      expect(Growthbook::Util.chooseVariation('1', experiment)).to eq(1)
+      expect(Growthbook::Util.chooseVariation('2', experiment)).to eq(0)
+      expect(Growthbook::Util.chooseVariation('3', experiment)).to eq(0)
+      expect(Growthbook::Util.chooseVariation('4', experiment)).to eq(1)
+      expect(Growthbook::Util.chooseVariation('5', experiment)).to eq(1)
+      expect(Growthbook::Util.chooseVariation('6', experiment)).to eq(1)
+      expect(Growthbook::Util.chooseVariation('7', experiment)).to eq(0)
+      expect(Growthbook::Util.chooseVariation('8', experiment)).to eq(1)
+      expect(Growthbook::Util.chooseVariation('9', experiment)).to eq(0)
+    end
+
+    it "assigns variations with uneven weights" do
+      experiment = Growthbook::Experiment.new("my-test", 2, weights: [0.1, 0.9])
+
+      expect(Growthbook::Util.chooseVariation('1', experiment)).to eq(1)
+      expect(Growthbook::Util.chooseVariation('2', experiment)).to eq(1)
+      expect(Growthbook::Util.chooseVariation('3', experiment)).to eq(0)
+      expect(Growthbook::Util.chooseVariation('4', experiment)).to eq(1)
+      expect(Growthbook::Util.chooseVariation('5', experiment)).to eq(1)
+      expect(Growthbook::Util.chooseVariation('6', experiment)).to eq(1)
+      expect(Growthbook::Util.chooseVariation('7', experiment)).to eq(0)
+      expect(Growthbook::Util.chooseVariation('8', experiment)).to eq(1)
+      expect(Growthbook::Util.chooseVariation('9', experiment)).to eq(1)
+    end
+
+    it "assigns variations with reduced coverage" do
+      experiment = Growthbook::Experiment.new("my-test", 2, coverage: 0.4)
+
+      expect(Growthbook::Util.chooseVariation('1', experiment)).to eq(-1)
+      expect(Growthbook::Util.chooseVariation('2', experiment)).to eq(0)
+      expect(Growthbook::Util.chooseVariation('3', experiment)).to eq(0)
+      expect(Growthbook::Util.chooseVariation('4', experiment)).to eq(-1)
+      expect(Growthbook::Util.chooseVariation('5', experiment)).to eq(-1)
+      expect(Growthbook::Util.chooseVariation('6', experiment)).to eq(-1)
+      expect(Growthbook::Util.chooseVariation('7', experiment)).to eq(0)
+      expect(Growthbook::Util.chooseVariation('8', experiment)).to eq(-1)
+      expect(Growthbook::Util.chooseVariation('9', experiment)).to eq(1)
+    end
+
+    it "assigns variations with default 3 variations" do
+      experiment = Growthbook::Experiment.new("my-test", 3)
+
+      expect(Growthbook::Util.chooseVariation('1', experiment)).to eq(2)
+      expect(Growthbook::Util.chooseVariation('2', experiment)).to eq(0)
+      expect(Growthbook::Util.chooseVariation('3', experiment)).to eq(0)
+      expect(Growthbook::Util.chooseVariation('4', experiment)).to eq(2)
+      expect(Growthbook::Util.chooseVariation('5', experiment)).to eq(1)
+      expect(Growthbook::Util.chooseVariation('6', experiment)).to eq(2)
+      expect(Growthbook::Util.chooseVariation('7', experiment)).to eq(0)
+      expect(Growthbook::Util.chooseVariation('8', experiment)).to eq(1)
+      expect(Growthbook::Util.chooseVariation('9', experiment)).to eq(0)
+    end
+
+    it "uses experiment name to choose a variation" do
+      experiment1 = Growthbook::Experiment.new("my-test", 2)
+      experiment2 = Growthbook::Experiment.new("my-test-3", 2)
+
+      expect(Growthbook::Util.chooseVariation('1', experiment1)).to eq(1)
+      expect(Growthbook::Util.chooseVariation('1', experiment2)).to eq(0)
+    end
+  end
+end