growthbook 0.3.0 → 1.0.0

data/spec/client_spec.rb

@@ -1,57 +0,0 @@
-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

@@ -1,124 +0,0 @@
-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({
-        "featureId" => "feature1",
-        "hashAttribute" => "id",
-        "hashValue" => "123",
-        "inExperiment" => true,
-        "hashUsed" => true,
-        "value" => 2,
-        "variationId" => 0,
-      })
-
-      expect(listener.tracked).to eq([
-        {
-          "key" => "feature1",
-          "variations" => [2, 3]
-        },
-        {
-          "featureId" => "feature1",
-          "hashAttribute" => "id",
-          "hashValue" => "123",
-          "inExperiment" => true,
-          "hashUsed" => true,
-          "value" => 2,
-          "variationId" => 0,
-        }
-      ])
-    end
-  end
-end

data/spec/json_spec.rb

@@ -1,160 +0,0 @@
-# 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, hash_used = 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)
-        expect(result.hash_used).to eq(hash_used)
-      end
-    end
-  end
-end

data/spec/user_spec.rb

@@ -1,213 +0,0 @@
-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