yggdrasil-engine 0.0.7-x64-mingw32 → 0.0.8-x64-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 680c78a8637ea4a1c5ea08875bbab78218560c040e90108db06c7f9f1e7435a3
-  data.tar.gz: 8638abe970e52200ab1ac3981c3eb92192d4f34f3018855d96c4bec5e85180ef
+  metadata.gz: '083efa0b70e64d6b20ab1830502ea60637bfa0cb4fc9e57ae14c1cfff73f7155'
+  data.tar.gz: 43e4d0e94d318a809e64d355bb35d844c7fc47d9dc922731795dfde2852fa7b3
 SHA512:
-  metadata.gz: f19bdcfc73e75276d2f15e14787ed336a0d9320a68e25478ffe5cc5d680184a63c9dcf02d61e91b0c3e55914d31faccb3f6c46a1cd70519c870539bfc6b8f2b3
-  data.tar.gz: 0c59099f9a165ba9050a9392073420255d64fc9d816ad575e2672528dccb445df46de348c4eb2b394de055767b63151b2751e3ac551a51dd14d418bb28e6b6da
+  metadata.gz: 0f91c3b1086f00d445e958ca0557da4ecf9c523c9a5acae1931275a96fb4633021b91f6f7264eaf8bf559f852b51e70aa147ba908d63875d51743f6b4924ecd2
+  data.tar.gz: 5783acb521bdf228c30a2abb31d8dbcf95be95a6530413c5e998a283c48cb42a02606830d81eefcaab41d674273fb884a1a60d6ea99f1b69b46e9eaeff4d2444

data/README.md

@@ -1,36 +1,36 @@
-# Ruby Bindings to Yggdrasil
-
-## Running the tests
-
-First make sure that you have built the native FFI code and it's located in the right place. This can be done with the build script in `build.sh`:
-
-
-```bash
-./build.sh
-```
-
-Then you can run the tests with:
-
-```bash
-rspec
-```
-
-There's also a `mem_check.rb` in the scripts folder. This is not a bullet proof test, but it can be helpful for detecting large leaks. This requires human interaction - you need to read the output and understand what it's telling you, so it's not run as part of the test suite.
-
-```bash
-ruby scripts/mem_check.rb
-```
-
-## Build
-
-You can build the gem with:
-
-```bash
-gem build yggdrasil-engine.gemspec
-```
-
-Then you can install the gem for local development with:
-
-```
-gem install yggdrasil-engine-0.0.1.gem
-```
+# Ruby Bindings to Yggdrasil
+
+## Running the tests
+
+First make sure that you have built the native FFI code and it's located in the right place. This can be done with the build script in `build.sh`:
+
+
+```bash
+./build.sh
+```
+
+Then you can run the tests with:
+
+```bash
+rspec
+```
+
+There's also a `mem_check.rb` in the scripts folder. This is not a bullet proof test, but it can be helpful for detecting large leaks. This requires human interaction - you need to read the output and understand what it's telling you, so it's not run as part of the test suite.
+
+```bash
+ruby scripts/mem_check.rb
+```
+
+## Build
+
+You can build the gem with:
+
+```bash
+gem build yggdrasil-engine.gemspec
+```
+
+Then you can install the gem for local development with:
+
+```
+gem install yggdrasil-engine-0.0.1.gem
+```

data/lib/custom_strategy.rb

@@ -1,60 +1,60 @@
-STANDARD_STRATEGIES = [
-  "default",
-  "userWithId",
-  "gradualRolloutUserId",
-  "gradualRolloutSessionId",
-  "gradualRolloutRandom",
-  "flexibleRollout",
-  "remoteAddress",
-].freeze
-
-class CustomStrategyHandler
-  def initialize
-    @custom_strategies_definitions = {}
-    @custom_strategy_implementations = {}
-  end
-
-  def update_strategies(json_str)
-    custom_strategies = {}
-    parsed_json = JSON.parse(json_str)
-
-    parsed_json["features"].each do |feature|
-      toggle_name = feature["name"]
-      strategies = feature["strategies"]
-
-      custom_strategies_for_toggle = strategies.select do |strategy|
-        !STANDARD_STRATEGIES.include?(strategy["name"])
-      end
-
-      unless custom_strategies_for_toggle.empty?
-        custom_strategies[toggle_name] = custom_strategies_for_toggle
-      end
-    end
-
-    @custom_strategies_definitions = custom_strategies
-  end
-
-  def register_custom_strategies(strategies)
-    strategies.each do |strategy|
-      if strategy.respond_to?(:name) && strategy.name.is_a?(String) &&
-         strategy.respond_to?(:enabled?)
-        @custom_strategy_implementations[strategy.name] = strategy
-      else
-        raise "Invalid strategy object. Must have a name method that returns a String and an enabled? method."
-      end
-    end
-  end
-
-  def evaluate_custom_strategies(toggle_name, context)
-    results = {}
-
-    @custom_strategies_definitions[toggle_name]&.each_with_index do |strategy, index|
-      key = "customStrategy#{index + 1}"
-      strategy_impl = @custom_strategy_implementations[strategy["name"]]
-      result = strategy_impl&.enabled?(strategy["parameters"], context) || false
-      results[key] = result
-    end
-
-    results
-  end
-end
+STANDARD_STRATEGIES = [
+  "default",
+  "userWithId",
+  "gradualRolloutUserId",
+  "gradualRolloutSessionId",
+  "gradualRolloutRandom",
+  "flexibleRollout",
+  "remoteAddress",
+].freeze
+
+class CustomStrategyHandler
+  def initialize
+    @custom_strategies_definitions = {}
+    @custom_strategy_implementations = {}
+  end
+
+  def update_strategies(json_str)
+    custom_strategies = {}
+    parsed_json = JSON.parse(json_str)
+
+    parsed_json["features"].each do |feature|
+      toggle_name = feature["name"]
+      strategies = feature["strategies"]
+
+      custom_strategies_for_toggle = strategies.select do |strategy|
+        !STANDARD_STRATEGIES.include?(strategy["name"])
+      end
+
+      unless custom_strategies_for_toggle.empty?
+        custom_strategies[toggle_name] = custom_strategies_for_toggle
+      end
+    end
+
+    @custom_strategies_definitions = custom_strategies
+  end
+
+  def register_custom_strategies(strategies)
+    strategies.each do |strategy|
+      if strategy.respond_to?(:name) && strategy.name.is_a?(String) &&
+         strategy.respond_to?(:enabled?)
+        @custom_strategy_implementations[strategy.name] = strategy
+      else
+        raise "Invalid strategy object. Must have a name method that returns a String and an enabled? method."
+      end
+    end
+  end
+
+  def evaluate_custom_strategies(toggle_name, context)
+    results = {}
+
+    @custom_strategies_definitions[toggle_name]&.each_with_index do |strategy, index|
+      key = "customStrategy#{index + 1}"
+      strategy_impl = @custom_strategy_implementations[strategy["name"]]
+      result = strategy_impl&.enabled?(strategy["parameters"], context) || false
+      results[key] = result
+    end
+
+    results
+  end
+end

data/lib/yggdrasil_engine.rb

@@ -1,131 +1,145 @@
-require 'ffi'
-require 'json'
-require 'custom_strategy'
-
-TOGGLE_MISSING_RESPONSE = 'NotFound'.freeze
-ERROR_RESPONSE = 'Error'.freeze
-OK_RESPONSE = 'Ok'.freeze
-
-def platform_specific_lib
-  os = RbConfig::CONFIG['host_os']
-  cpu = RbConfig::CONFIG['host_cpu']
-
-  extension = case os
-  when /darwin|mac os/
-    'dylib'
-  when /linux/
-    'so'
-  when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
-    'dll'
-  else
-    raise "unsupported platform #{os}"
-  end
-
-  arch_suffix = case cpu
-  when /x86_64/
-    'x86_64'
-  when /arm/
-    'arm64'
-  when /aarch64/
-    'aarch64'
-  else
-    raise "unsupported architecture #{cpu}"
-  end
-
-  "libyggdrasilffi_#{arch_suffix}.#{extension}"
-end
-
-def to_variant(raw_variant)
-  payload = raw_variant[:payload] && raw_variant[:payload].transform_keys(&:to_s)
-  {
-    name: raw_variant[:name],
-    enabled: raw_variant[:enabled],
-    feature_enabled: raw_variant[:featureEnabled],
-    payload: payload,
-  }
-end
-
-class YggdrasilEngine
-  extend FFI::Library
-  ffi_lib File.expand_path(platform_specific_lib, __dir__)
-
-  attach_function :new_engine, [], :pointer
-  attach_function :free_engine, [:pointer], :void
-
-  attach_function :take_state, %i[pointer string], :pointer
-  attach_function :check_enabled, %i[pointer string string string], :pointer
-  attach_function :check_variant, %i[pointer string string string], :pointer
-  attach_function :get_metrics, [:pointer], :pointer
-  attach_function :free_response, [:pointer], :void
-
-  attach_function :count_toggle, %i[pointer string bool], :void
-  attach_function :count_variant, %i[pointer string string], :void
-
-  def initialize
-    @engine = YggdrasilEngine.new_engine
-    @custom_strategy_handler = CustomStrategyHandler.new
-    ObjectSpace.define_finalizer(self, self.class.finalize(@engine))
-  end
-
-  def self.finalize(engine)
-    proc { YggdrasilEngine.free_engine(engine) }
-  end
-
-  def take_state(toggles)
-    @custom_strategy_handler.update_strategies(toggles)
-    response_ptr = YggdrasilEngine.take_state(@engine, toggles)
-    take_toggles_response = JSON.parse(response_ptr.read_string, symbolize_names: true)
-    YggdrasilEngine.free_response(response_ptr)
-  end
-
-  def get_variant(name, context)
-    context_json = (context || {}).to_json
-    custom_strategy_results = @custom_strategy_handler.evaluate_custom_strategies(name, context).to_json
-
-    variant_def_json_ptr = YggdrasilEngine.check_variant(@engine, name, context_json, custom_strategy_results)
-    variant_def_json = variant_def_json_ptr.read_string
-    YggdrasilEngine.free_response(variant_def_json_ptr)
-    variant_response = JSON.parse(variant_def_json, symbolize_names: true)
-
-    return nil if variant_response[:status_code] == TOGGLE_MISSING_RESPONSE
-    variant = variant_response[:value]
-
-    return to_variant(variant) if variant_response[:status_code] == OK_RESPONSE
-  end
-
-  def enabled?(toggle_name, context)
-    context_json = (context || {}).to_json
-    custom_strategy_results = @custom_strategy_handler.evaluate_custom_strategies(toggle_name, context).to_json
-
-    response_ptr = YggdrasilEngine.check_enabled(@engine, toggle_name, context_json, custom_strategy_results)
-    response_json = response_ptr.read_string
-    YggdrasilEngine.free_response(response_ptr)
-    response = JSON.parse(response_json, symbolize_names: true)
-
-    raise "Error: #{response[:error_message]}" if response[:status_code] == ERROR_RESPONSE
-    return nil if response[:status_code] == TOGGLE_MISSING_RESPONSE
-
-    return response[:value] == true
-  end
-
-  def count_toggle(toggle_name, enabled)
-    response_ptr = YggdrasilEngine.count_toggle(@engine, toggle_name, enabled)
-    YggdrasilEngine.free_response(response_ptr)
-  end
-
-  def count_variant(toggle_name, variant_name)
-    response_ptr = YggdrasilEngine.count_variant(@engine, toggle_name, variant_name)
-    YggdrasilEngine.free_response(response_ptr)
-  end
-
-  def get_metrics
-    metrics_ptr = YggdrasilEngine.get_metrics(@engine)
-    metrics = JSON.parse(metrics_ptr.read_string, symbolize_names: true)
-    YggdrasilEngine.free_response(metrics_ptr)
-    metrics[:value]
-  end
-
-  def register_custom_strategies(strategies)
-    @custom_strategy_handler.register_custom_strategies(strategies)
-  end
-end
+require 'ffi'
+require 'json'
+require 'custom_strategy'
+
+TOGGLE_MISSING_RESPONSE = 'NotFound'.freeze
+ERROR_RESPONSE = 'Error'.freeze
+OK_RESPONSE = 'Ok'.freeze
+
+def platform_specific_lib
+  os = RbConfig::CONFIG['host_os']
+  cpu = RbConfig::CONFIG['host_cpu']
+
+  extension, prefix = case os
+  when /darwin|mac os/
+    ['dylib', 'lib']
+  when /linux/
+    ['so', 'lib']
+  when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+    ['dll', '']
+  else
+    raise "unsupported platform #{os}"
+  end
+
+  arch_suffix = case cpu
+  when /x86_64/
+    'x86_64'
+  when /arm|aarch64/
+    'arm64'
+  else
+    raise "unsupported architecture #{cpu}"
+  end
+
+  lib_type_suffix = if os =~ /linux/
+    musl = system("ldd /bin/sh | grep -q musl")
+    musl ? "-musl" : ""
+  else
+    ""
+  end
+
+  "#{prefix}yggdrasilffi_#{arch_suffix}#{lib_type_suffix}.#{extension}"
+end
+
+def to_variant(raw_variant)
+  payload = raw_variant[:payload] && raw_variant[:payload].transform_keys(&:to_s)
+  {
+    name: raw_variant[:name],
+    enabled: raw_variant[:enabled],
+    feature_enabled: raw_variant[:featureEnabled],
+    payload: payload,
+  }
+end
+
+class YggdrasilEngine
+  extend FFI::Library
+  ffi_lib File.expand_path(platform_specific_lib, __dir__)
+
+  attach_function :new_engine, [], :pointer
+  attach_function :free_engine, [:pointer], :void
+
+  attach_function :take_state, %i[pointer string], :pointer
+  attach_function :check_enabled, %i[pointer string string string], :pointer
+  attach_function :check_variant, %i[pointer string string string], :pointer
+  attach_function :get_metrics, [:pointer], :pointer
+  attach_function :free_response, [:pointer], :void
+
+  attach_function :count_toggle, %i[pointer string bool], :void
+  attach_function :count_variant, %i[pointer string string], :void
+
+  attach_function :list_known_toggles, [:pointer], :pointer
+
+  def initialize
+    @engine = YggdrasilEngine.new_engine
+    @custom_strategy_handler = CustomStrategyHandler.new
+    ObjectSpace.define_finalizer(self, self.class.finalize(@engine))
+  end
+
+  def self.finalize(engine)
+    proc { YggdrasilEngine.free_engine(engine) }
+  end
+
+  def take_state(toggles)
+    @custom_strategy_handler.update_strategies(toggles)
+    response_ptr = YggdrasilEngine.take_state(@engine, toggles)
+    take_toggles_response = JSON.parse(response_ptr.read_string, symbolize_names: true)
+    YggdrasilEngine.free_response(response_ptr)
+  end
+
+  def get_variant(name, context)
+    context_json = (context || {}).to_json
+    custom_strategy_results = @custom_strategy_handler.evaluate_custom_strategies(name, context).to_json
+
+    variant_def_json_ptr = YggdrasilEngine.check_variant(@engine, name, context_json, custom_strategy_results)
+    variant_def_json = variant_def_json_ptr.read_string
+    YggdrasilEngine.free_response(variant_def_json_ptr)
+    variant_response = JSON.parse(variant_def_json, symbolize_names: true)
+
+    return nil if variant_response[:status_code] == TOGGLE_MISSING_RESPONSE
+    variant = variant_response[:value]
+
+    return to_variant(variant) if variant_response[:status_code] == OK_RESPONSE
+  end
+
+  def enabled?(toggle_name, context)
+    context_json = (context || {}).to_json
+    custom_strategy_results = @custom_strategy_handler.evaluate_custom_strategies(toggle_name, context).to_json
+
+    response_ptr = YggdrasilEngine.check_enabled(@engine, toggle_name, context_json, custom_strategy_results)
+    response_json = response_ptr.read_string
+    YggdrasilEngine.free_response(response_ptr)
+    response = JSON.parse(response_json, symbolize_names: true)
+
+    raise "Error: #{response[:error_message]}" if response[:status_code] == ERROR_RESPONSE
+    return nil if response[:status_code] == TOGGLE_MISSING_RESPONSE
+
+    return response[:value] == true
+  end
+
+  def count_toggle(toggle_name, enabled)
+    response_ptr = YggdrasilEngine.count_toggle(@engine, toggle_name, enabled)
+    YggdrasilEngine.free_response(response_ptr)
+  end
+
+  def count_variant(toggle_name, variant_name)
+    response_ptr = YggdrasilEngine.count_variant(@engine, toggle_name, variant_name)
+    YggdrasilEngine.free_response(response_ptr)
+  end
+
+  def get_metrics
+    metrics_ptr = YggdrasilEngine.get_metrics(@engine)
+    metrics = JSON.parse(metrics_ptr.read_string, symbolize_names: true)
+    YggdrasilEngine.free_response(metrics_ptr)
+    metrics[:value]
+  end
+
+  def list_known_toggles
+    response_ptr = YggdrasilEngine.list_known_toggles(@engine)
+    response_json = response_ptr.read_string
+    YggdrasilEngine.free_response(response_ptr)
+    JSON.parse(response_json, symbolize_names: true)
+  end
+
+  def register_custom_strategies(strategies)
+    @custom_strategy_handler.register_custom_strategies(strategies)
+  end
+end

data/spec/custom_strategy_spec.rb

@@ -1,136 +1,136 @@
-require_relative '../lib/custom_strategy'
-
-RSpec.describe "custom strategies" do
-  let(:raw_state) do
-    {
-      "version": 1,
-      "features": [
-        {
-          "name": "Feature.A",
-          "enabled": true,
-          "strategies": [
-            {
-              "name": "default",
-              "parameters": {}
-            },
-            {
-              "name": "custom",
-              "parameters": {
-                "gerkhins": "yes"
-              }
-            },
-            {
-              "name": "some-other-custom",
-              "parameters": {
-                "gerkhins": "yes"
-              }
-            },
-          ]
-        }
-      ]
-    }
-  end
-
-  let(:handler) { CustomStrategyHandler.new }
-
-  before do
-    handler.update_strategies(raw_state.to_json)
-  end
-
-  describe 'computing custom strategies' do
-    it 'respects the logic contained in the enabled function' do
-      class TestStrategy
-        attr_reader :name
-
-        def initialize(name)
-          @name = name
-        end
-
-        def enabled?(params, context)
-          params["gerkhins"] == "yes"
-        end
-      end
-
-      handler.register_custom_strategies([TestStrategy.new("custom")])
-      strategy_results = handler.evaluate_custom_strategies("Feature.A", {})
-      expect(strategy_results.length).to eq(2)
-      expect(strategy_results["customStrategy1"]).to eq(true)
-      expect(strategy_results["customStrategy2"]).to eq(false)
-    end
-
-    it 'creates a strategy result for every custom strategy thats implemented and defined' do
-      class TestStrategy
-        attr_reader :name
-
-        def initialize(name)
-          @name = name
-        end
-
-        def enabled?(params, context)
-          params["gerkhins"] == "yes"
-        end
-      end
-
-      handler.register_custom_strategies([TestStrategy.new("custom"), TestStrategy.new("some-other-custom")])
-      strategy_results = handler.evaluate_custom_strategies("Feature.A", {})
-      expect(strategy_results.length).to eq(2)
-      expect(strategy_results["customStrategy1"]).to eq(true)
-      expect(strategy_results["customStrategy2"]).to eq(true)
-    end
-
-    it 'returns false for missing implementations' do
-      handler.register_custom_strategies([])
-      strategy_results = handler.evaluate_custom_strategies("Feature.A", {})
-      expect(strategy_results.length).to eq(2)
-      expect(strategy_results["customStrategy1"]).to eq(false)
-    end
-
-    it "should calculate custom strategies e2e" do
-      class TestStrategy
-        attr_reader :name
-
-        def initialize(name)
-          @name = name
-        end
-
-        def enabled?(params, context)
-          context[:userId] == "123"
-        end
-      end
-
-      state = {
-        "version": 1,
-        "features": [
-          {
-            "name": "Feature.A",
-            "enabled": true,
-            "strategies": [
-              {
-                "name": "custom",
-                "parameters": {
-                  "gerkhins": "yes"
-                }
-              }
-            ]
-          }
-        ]
-      }
-
-      engine = YggdrasilEngine.new
-      engine.register_custom_strategies([TestStrategy.new("custom")])
-
-      engine.take_state(state.to_json)
-
-      should_be_enabled = engine.enabled?("Feature.A", {
-                                            userId: "123"
-                                          })
-
-      should_not_be_enabled = engine.enabled?("Feature.A", {
-                                                userId: "456"
-                                              })
-
-      expect(should_be_enabled).to eq(true)
-      expect(should_not_be_enabled).to eq(false)
-    end
-  end
-end
+require_relative '../lib/custom_strategy'
+
+RSpec.describe "custom strategies" do
+  let(:raw_state) do
+    {
+      "version": 1,
+      "features": [
+        {
+          "name": "Feature.A",
+          "enabled": true,
+          "strategies": [
+            {
+              "name": "default",
+              "parameters": {}
+            },
+            {
+              "name": "custom",
+              "parameters": {
+                "gerkhins": "yes"
+              }
+            },
+            {
+              "name": "some-other-custom",
+              "parameters": {
+                "gerkhins": "yes"
+              }
+            },
+          ]
+        }
+      ]
+    }
+  end
+
+  let(:handler) { CustomStrategyHandler.new }
+
+  before do
+    handler.update_strategies(raw_state.to_json)
+  end
+
+  describe 'computing custom strategies' do
+    it 'respects the logic contained in the enabled function' do
+      class TestStrategy
+        attr_reader :name
+
+        def initialize(name)
+          @name = name
+        end
+
+        def enabled?(params, context)
+          params["gerkhins"] == "yes"
+        end
+      end
+
+      handler.register_custom_strategies([TestStrategy.new("custom")])
+      strategy_results = handler.evaluate_custom_strategies("Feature.A", {})
+      expect(strategy_results.length).to eq(2)
+      expect(strategy_results["customStrategy1"]).to eq(true)
+      expect(strategy_results["customStrategy2"]).to eq(false)
+    end
+
+    it 'creates a strategy result for every custom strategy thats implemented and defined' do
+      class TestStrategy
+        attr_reader :name
+
+        def initialize(name)
+          @name = name
+        end
+
+        def enabled?(params, context)
+          params["gerkhins"] == "yes"
+        end
+      end
+
+      handler.register_custom_strategies([TestStrategy.new("custom"), TestStrategy.new("some-other-custom")])
+      strategy_results = handler.evaluate_custom_strategies("Feature.A", {})
+      expect(strategy_results.length).to eq(2)
+      expect(strategy_results["customStrategy1"]).to eq(true)
+      expect(strategy_results["customStrategy2"]).to eq(true)
+    end
+
+    it 'returns false for missing implementations' do
+      handler.register_custom_strategies([])
+      strategy_results = handler.evaluate_custom_strategies("Feature.A", {})
+      expect(strategy_results.length).to eq(2)
+      expect(strategy_results["customStrategy1"]).to eq(false)
+    end
+
+    it "should calculate custom strategies e2e" do
+      class TestStrategy
+        attr_reader :name
+
+        def initialize(name)
+          @name = name
+        end
+
+        def enabled?(params, context)
+          context[:userId] == "123"
+        end
+      end
+
+      state = {
+        "version": 1,
+        "features": [
+          {
+            "name": "Feature.A",
+            "enabled": true,
+            "strategies": [
+              {
+                "name": "custom",
+                "parameters": {
+                  "gerkhins": "yes"
+                }
+              }
+            ]
+          }
+        ]
+      }
+
+      engine = YggdrasilEngine.new
+      engine.register_custom_strategies([TestStrategy.new("custom")])
+
+      engine.take_state(state.to_json)
+
+      should_be_enabled = engine.enabled?("Feature.A", {
+                                            userId: "123"
+                                          })
+
+      should_not_be_enabled = engine.enabled?("Feature.A", {
+                                                userId: "456"
+                                              })
+
+      expect(should_be_enabled).to eq(true)
+      expect(should_not_be_enabled).to eq(false)
+    end
+  end
+end

data/spec/yggdrasil_engine_spec.rb

@@ -1,151 +1,161 @@
-require 'rspec'
-require 'json'
-require_relative '../lib/yggdrasil_engine'
-
-index_file_path = '../client-specification/specifications/index.json'
-test_suites = JSON.parse(File.read(index_file_path))
-
-def test_suite_variant(base_variant)
-  payload = base_variant[:payload] && base_variant[:payload].transform_keys(&:to_s)
-  {
-    name: base_variant[:name],
-    enabled: base_variant[:enabled],
-    feature_enabled: base_variant[:feature_enabled],
-    payload: payload,
-  }
-end
-
-RSpec.describe YggdrasilEngine do
-  let(:yggdrasil_engine) { YggdrasilEngine.new }
-
-  describe '#checking a toggle' do
-    it 'that does not exist should yield a not found' do
-      is_enabled = yggdrasil_engine.enabled?('missing-toggle', {})
-      expect(is_enabled).to be_nil
-    end
-  end
-
-  describe '#metrics' do
-    it 'should clear metrics when get_metrics is called' do
-      feature_name = 'Feature.A'
-
-      suite_path = File.join('../client-specification/specifications', '01-simple-examples.json')
-      suite_data = JSON.parse(File.read(suite_path))
-
-      yggdrasil_engine.take_state(suite_data['state'].to_json)
-
-      yggdrasil_engine.count_toggle(feature_name, true)
-      yggdrasil_engine.count_toggle(feature_name, false)
-
-      metrics = yggdrasil_engine.get_metrics() # This should clear the metrics buffer
-
-      metric = metrics[:toggles][feature_name.to_sym]
-      expect(metric[:yes]).to eq(1)
-      expect(metric[:no]).to eq(1)
-
-      metrics = yggdrasil_engine.get_metrics()
-      expect(metrics).to be_nil
-    end
-
-    it 'should increment toggle count when it exists' do
-      toggle_name = 'Feature.A'
-
-      suite_path = File.join('../client-specification/specifications', '01-simple-examples.json')
-      suite_data = JSON.parse(File.read(suite_path))
-
-      yggdrasil_engine.take_state(suite_data['state'].to_json)
-
-      yggdrasil_engine.count_toggle(toggle_name, true)
-      yggdrasil_engine.count_toggle(toggle_name, false)
-
-      metrics = yggdrasil_engine.get_metrics()
-      metric = metrics[:toggles][toggle_name.to_sym]
-
-      expect(metric[:yes]).to eq(1)
-      expect(metric[:no]).to eq(1)
-    end
-
-    it 'should increment toggle count when the toggle does not exist' do
-      toggle_name = 'Feature.X'
-
-      yggdrasil_engine.count_toggle(toggle_name, true)
-      yggdrasil_engine.count_toggle(toggle_name, false)
-
-      metrics = yggdrasil_engine.get_metrics()
-      metric = metrics[:toggles][toggle_name.to_sym]
-
-      expect(metric[:yes]).to eq(1)
-      expect(metric[:no]).to eq(1)
-    end
-
-    it 'should increment variant' do
-      toggle_name = 'Feature.Q'
-
-      suite_path = File.join('../client-specification/specifications', '01-simple-examples.json')
-      suite_data = JSON.parse(File.read(suite_path))
-
-      yggdrasil_engine.take_state(suite_data['state'].to_json)
-
-      yggdrasil_engine.count_variant(toggle_name, 'disabled')
-
-      metrics = yggdrasil_engine.get_metrics()
-      metric = metrics[:toggles][toggle_name.to_sym]
-
-      expect(metric[:variants][:disabled]).to eq(1)
-    end
-  end
-end
-
-RSpec.describe 'Client Specification' do
-  let(:yggdrasil_engine) { YggdrasilEngine.new }
-
-  test_suites.each do |suite|
-    suite_path = File.join('../client-specification/specifications', suite)
-    suite_data = JSON.parse(File.read(suite_path), symbolize_names: true)
-
-    describe "Suite '#{suite}'" do
-      before(:each) do
-        yggdrasil_engine.take_state(suite_data[:state].to_json)
-      end
-
-      suite_data.fetch(:tests, []).each do |test|
-        describe "Test '#{test[:description]}'" do
-          let(:context) { test[:context] }
-          let(:toggle_name) { test[:toggleName] }
-          let(:expected_result) { test[:expectedResult] }
-
-          it 'returns correct result for `is_enabled?` method' do
-            result = yggdrasil_engine.enabled?(toggle_name, context) || false
-
-            expect(result).to eq(expected_result),
-                              "Failed test '#{test['description']}': expected #{expected_result}, got #{result}"
-          end
-        end
-      end
-
-      suite_data.fetch(:variantTests, []).each do |test|
-        next unless test[:expectedResult]
-
-        describe "Variant Test '#{test[:description]}'" do
-          let(:context) { test[:context] }
-          let(:toggle_name) { test[:toggleName] }
-          let(:expected_result) { test_suite_variant(test[:expectedResult]) }
-
-          it 'returns correct result for `get_variant` method' do
-            result = yggdrasil_engine.get_variant(toggle_name, context) || {
-              :name => 'disabled',
-              :payload => nil,
-              :enabled => false,
-              :feature_enabled => false
-            }
-
-            expect(result[:name]).to eq(expected_result[:name])
-            expect(result[:payload]).to eq(expected_result[:payload])
-            expect(result[:enabled]).to eq(expected_result[:enabled])
-            expect(result[:feature_enabled]).to eq(expected_result[:feature_enabled])
-          end
-        end
-      end
-    end
-  end
-end
+require 'rspec'
+require 'json'
+require_relative '../lib/yggdrasil_engine'
+
+index_file_path = '../client-specification/specifications/index.json'
+test_suites = JSON.parse(File.read(index_file_path))
+
+def test_suite_variant(base_variant)
+  payload = base_variant[:payload] && base_variant[:payload].transform_keys(&:to_s)
+  {
+    name: base_variant[:name],
+    enabled: base_variant[:enabled],
+    feature_enabled: base_variant[:feature_enabled],
+    payload: payload,
+  }
+end
+
+RSpec.describe YggdrasilEngine do
+  let(:yggdrasil_engine) { YggdrasilEngine.new }
+
+  describe '#checking a toggle' do
+    it 'that does not exist should yield a not found' do
+      is_enabled = yggdrasil_engine.enabled?('missing-toggle', {})
+      expect(is_enabled).to be_nil
+    end
+  end
+
+  describe '#metrics' do
+    it 'should clear metrics when get_metrics is called' do
+      feature_name = 'Feature.A'
+
+      suite_path = File.join('../client-specification/specifications', '01-simple-examples.json')
+      suite_data = JSON.parse(File.read(suite_path))
+
+      yggdrasil_engine.take_state(suite_data['state'].to_json)
+
+      yggdrasil_engine.count_toggle(feature_name, true)
+      yggdrasil_engine.count_toggle(feature_name, false)
+
+      metrics = yggdrasil_engine.get_metrics() # This should clear the metrics buffer
+
+      metric = metrics[:toggles][feature_name.to_sym]
+      expect(metric[:yes]).to eq(1)
+      expect(metric[:no]).to eq(1)
+
+      metrics = yggdrasil_engine.get_metrics()
+      expect(metrics).to be_nil
+    end
+
+    it 'should increment toggle count when it exists' do
+      toggle_name = 'Feature.A'
+
+      suite_path = File.join('../client-specification/specifications', '01-simple-examples.json')
+      suite_data = JSON.parse(File.read(suite_path))
+
+      yggdrasil_engine.take_state(suite_data['state'].to_json)
+
+      yggdrasil_engine.count_toggle(toggle_name, true)
+      yggdrasil_engine.count_toggle(toggle_name, false)
+
+      metrics = yggdrasil_engine.get_metrics()
+      metric = metrics[:toggles][toggle_name.to_sym]
+
+      expect(metric[:yes]).to eq(1)
+      expect(metric[:no]).to eq(1)
+    end
+
+    it 'should increment toggle count when the toggle does not exist' do
+      toggle_name = 'Feature.X'
+
+      yggdrasil_engine.count_toggle(toggle_name, true)
+      yggdrasil_engine.count_toggle(toggle_name, false)
+
+      metrics = yggdrasil_engine.get_metrics()
+      metric = metrics[:toggles][toggle_name.to_sym]
+
+      expect(metric[:yes]).to eq(1)
+      expect(metric[:no]).to eq(1)
+    end
+
+    it 'should increment variant' do
+      toggle_name = 'Feature.Q'
+
+      suite_path = File.join('../client-specification/specifications', '01-simple-examples.json')
+      suite_data = JSON.parse(File.read(suite_path))
+
+      yggdrasil_engine.take_state(suite_data['state'].to_json)
+
+      yggdrasil_engine.count_variant(toggle_name, 'disabled')
+
+      metrics = yggdrasil_engine.get_metrics()
+      metric = metrics[:toggles][toggle_name.to_sym]
+
+      expect(metric[:variants][:disabled]).to eq(1)
+    end
+
+    it 'should list all the features that were loaded' do
+      suite_path = File.join('../client-specification/specifications', '01-simple-examples.json')
+      suite_data = JSON.parse(File.read(suite_path))
+
+      yggdrasil_engine.take_state(suite_data['state'].to_json)
+
+      toggles = yggdrasil_engine.list_known_toggles()
+      expect(toggles.length).to eq(3)
+    end
+  end
+end
+
+RSpec.describe 'Client Specification' do
+  let(:yggdrasil_engine) { YggdrasilEngine.new }
+
+  test_suites.each do |suite|
+    suite_path = File.join('../client-specification/specifications', suite)
+    suite_data = JSON.parse(File.read(suite_path), symbolize_names: true)
+
+    describe "Suite '#{suite}'" do
+      before(:each) do
+        yggdrasil_engine.take_state(suite_data[:state].to_json)
+      end
+
+      suite_data.fetch(:tests, []).each do |test|
+        describe "Test '#{test[:description]}'" do
+          let(:context) { test[:context] }
+          let(:toggle_name) { test[:toggleName] }
+          let(:expected_result) { test[:expectedResult] }
+
+          it 'returns correct result for `is_enabled?` method' do
+            result = yggdrasil_engine.enabled?(toggle_name, context) || false
+
+            expect(result).to eq(expected_result),
+                              "Failed test '#{test['description']}': expected #{expected_result}, got #{result}"
+          end
+        end
+      end
+
+      suite_data.fetch(:variantTests, []).each do |test|
+        next unless test[:expectedResult]
+
+        describe "Variant Test '#{test[:description]}'" do
+          let(:context) { test[:context] }
+          let(:toggle_name) { test[:toggleName] }
+          let(:expected_result) { test_suite_variant(test[:expectedResult]) }
+
+          it 'returns correct result for `get_variant` method' do
+            result = yggdrasil_engine.get_variant(toggle_name, context) || {
+              :name => 'disabled',
+              :payload => nil,
+              :enabled => false,
+              :feature_enabled => false
+            }
+
+            expect(result[:name]).to eq(expected_result[:name])
+            expect(result[:payload]).to eq(expected_result[:payload])
+            expect(result[:enabled]).to eq(expected_result[:enabled])
+            expect(result[:feature_enabled]).to eq(expected_result[:feature_enabled])
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,11 +1,11 @@
 --- !ruby/object:Gem::Specification
 name: yggdrasil-engine
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
 platform: x64-mingw32
 authors:
 - Unleash
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
 date: 2023-06-28 00:00:00.000000000 Z
@@ -32,15 +32,16 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/custom_strategy.rb
-- lib/libyggdrasilffi_x86_64.dll
 - lib/yggdrasil_engine.rb
+- lib/yggdrasilffi_x86_64.dll
 - spec/custom_strategy_spec.rb
 - spec/yggdrasil_engine_spec.rb
 homepage: http://github.com/username/my_gem
 licenses:
 - MIT
-metadata: {}
-post_install_message:
+metadata:
+  yggdrasil_core_version: 0.14.0
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -55,8 +56,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.33
-signing_key:
+rubygems_version: 3.3.5
+signing_key: 
 specification_version: 4
 summary: Unleash engine for evaluating feature toggles
 test_files: []