lex-agentic-inference 0.1.0

data/spec/legion/extensions/agentic/inference/perceptual_inference/helpers/perceptual_hypothesis_spec.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::PerceptualInference::Helpers::PerceptualHypothesis do
+  subject(:hypothesis) do
+    described_class.new(content: 'red cube', modality: :visual, domain: :objects, prior: 0.6)
+  end
+
+  describe '#initialize' do
+    it 'assigns a UUID id' do
+      expect(hypothesis.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores content' do
+      expect(hypothesis.content).to eq('red cube')
+    end
+
+    it 'stores modality' do
+      expect(hypothesis.modality).to eq(:visual)
+    end
+
+    it 'stores domain' do
+      expect(hypothesis.domain).to eq(:objects)
+    end
+
+    it 'clamps prior to PRIOR_CEILING' do
+      h = described_class.new(content: 'x', modality: :visual, prior: 1.5)
+      expect(h.prior).to be_within(0.001).of(0.99)
+    end
+
+    it 'clamps prior to PRIOR_FLOOR' do
+      h = described_class.new(content: 'x', modality: :visual, prior: -0.5)
+      expect(h.prior).to be_within(0.001).of(0.01)
+    end
+
+    it 'initializes state as :active' do
+      expect(hypothesis.state).to eq(:active)
+    end
+
+    it 'initializes likelihood at 0.5' do
+      expect(hypothesis.likelihood).to be_within(0.001).of(0.5)
+    end
+
+    it 'initializes posterior equal to prior' do
+      expect(hypothesis.posterior).to be_within(0.001).of(0.6)
+    end
+
+    it 'sets created_at' do
+      expect(hypothesis.created_at).to be_a(Time)
+    end
+
+    it 'uses DEFAULT_PRIOR when no prior given' do
+      h = described_class.new(content: 'x', modality: :visual)
+      expect(h.prior).to be_within(0.001).of(0.5)
+    end
+  end
+
+  describe '#compute_posterior' do
+    it 'returns a float between 0 and 1' do
+      result = hypothesis.compute_posterior(evidence_weight: 0.8)
+      expect(result).to be_between(0.0, 1.0)
+    end
+
+    it 'updates the posterior attribute' do
+      hypothesis.compute_posterior(evidence_weight: 0.8)
+      expect(hypothesis.posterior).to be_between(0.0, 1.0)
+    end
+
+    it 'uses EVIDENCE_STRENGTH_FLOOR when weight is too low' do
+      result = hypothesis.compute_posterior(evidence_weight: 0.001)
+      expect(result).to be_between(0.0, 1.0)
+    end
+  end
+
+  describe '#select!' do
+    it 'transitions state to :selected' do
+      hypothesis.select!
+      expect(hypothesis.state).to eq(:selected)
+    end
+  end
+
+  describe '#suppress!' do
+    it 'transitions state to :suppressed' do
+      hypothesis.suppress!
+      expect(hypothesis.state).to eq(:suppressed)
+    end
+  end
+
+  describe '#selected?' do
+    it 'returns false when active' do
+      expect(hypothesis.selected?).to be false
+    end
+
+    it 'returns true after select!' do
+      hypothesis.select!
+      expect(hypothesis.selected?).to be true
+    end
+
+    it 'returns false after suppress!' do
+      hypothesis.suppress!
+      expect(hypothesis.selected?).to be false
+    end
+  end
+
+  describe '#rival_with?' do
+    it 'returns true when posteriors are within RIVALRY_MARGIN' do
+      other = described_class.new(content: 'blue cube', modality: :visual, prior: 0.6)
+      other.instance_variable_set(:@posterior, hypothesis.posterior + 0.05)
+      expect(hypothesis.rival_with?(other)).to be true
+    end
+
+    it 'returns false when posteriors differ by more than RIVALRY_MARGIN' do
+      other = described_class.new(content: 'blue cube', modality: :visual, prior: 0.1)
+      other.instance_variable_set(:@posterior, 0.1)
+      hypothesis.instance_variable_set(:@posterior, 0.9)
+      expect(hypothesis.rival_with?(other)).to be false
+    end
+
+    it 'returns false for non-hypothesis argument' do
+      expect(hypothesis.rival_with?('not a hypothesis')).to be false
+    end
+  end
+
+  describe '#adapt_prior' do
+    it 'increases prior on :correct outcome' do
+      old_prior = hypothesis.prior
+      hypothesis.adapt_prior(outcome: :correct)
+      expect(hypothesis.prior).to be > old_prior
+    end
+
+    it 'decreases prior on :incorrect outcome' do
+      old_prior = hypothesis.prior
+      hypothesis.adapt_prior(outcome: :incorrect)
+      expect(hypothesis.prior).to be < old_prior
+    end
+
+    it 'stays within bounds after many correct outcomes' do
+      20.times { hypothesis.adapt_prior(outcome: :correct) }
+      expect(hypothesis.prior).to be <= 0.99
+    end
+
+    it 'stays within bounds after many incorrect outcomes' do
+      20.times { hypothesis.adapt_prior(outcome: :incorrect) }
+      expect(hypothesis.prior).to be >= 0.01
+    end
+  end
+
+  describe '#decay' do
+    it 'moves prior toward DEFAULT_PRIOR' do
+      h = described_class.new(content: 'x', modality: :visual, prior: 0.9)
+      h.decay
+      expect(h.prior).to be < 0.9
+    end
+
+    it 'moves prior up from very low values' do
+      h = described_class.new(content: 'x', modality: :visual, prior: 0.05)
+      h.decay
+      expect(h.prior).to be > 0.04
+    end
+
+    it 'marks state as :decayed when suppressed and prior hits floor' do
+      h = described_class.new(content: 'x', modality: :visual, prior: 0.5)
+      h.suppress!
+      30.times { h.decay }
+      expect(h.state).to eq(:decayed)
+    end
+  end
+
+  describe '#percept_label' do
+    it 'returns :vivid for posterior >= 0.8' do
+      hypothesis.instance_variable_set(:@posterior, 0.85)
+      expect(hypothesis.percept_label).to eq(:vivid)
+    end
+
+    it 'returns :clear for posterior in 0.6..0.8' do
+      hypothesis.instance_variable_set(:@posterior, 0.7)
+      expect(hypothesis.percept_label).to eq(:clear)
+    end
+
+    it 'returns :ambiguous for posterior around 0.5' do
+      hypothesis.instance_variable_set(:@posterior, 0.5)
+      expect(hypothesis.percept_label).to eq(:ambiguous)
+    end
+
+    it 'returns :faint for posterior in 0.2..0.4' do
+      hypothesis.instance_variable_set(:@posterior, 0.3)
+      expect(hypothesis.percept_label).to eq(:faint)
+    end
+
+    it 'returns :subliminal for posterior < 0.2' do
+      hypothesis.instance_variable_set(:@posterior, 0.1)
+      expect(hypothesis.percept_label).to eq(:subliminal)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with required keys' do
+      h = hypothesis.to_h
+      expect(h.keys).to include(:id, :content, :modality, :domain, :prior, :likelihood, :posterior, :state, :label, :created_at)
+    end
+
+    it 'rounds prior to 4 decimal places' do
+      h = hypothesis.to_h
+      expect(h[:prior].to_s).to match(/\A\d+\.\d{1,4}\z/)
+    end
+  end
+end

data/spec/legion/extensions/agentic/inference/perceptual_inference/runners/perceptual_inference_spec.rb

@@ -0,0 +1,305 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/perceptual_inference/client'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::PerceptualInference::Runners::PerceptualInference do
+  let(:client) { Legion::Extensions::Agentic::Inference::PerceptualInference::Client.new }
+
+  describe '#register_percept_hypothesis' do
+    it 'returns success: true for valid modality' do
+      result = client.register_percept_hypothesis(content: 'red square', modality: :visual)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns a hypothesis_id UUID' do
+      result = client.register_percept_hypothesis(content: 'red square', modality: :visual)
+      expect(result[:hypothesis_id]).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'returns the modality in the result' do
+      result = client.register_percept_hypothesis(content: 'red square', modality: :visual)
+      expect(result[:modality]).to eq(:visual)
+    end
+
+    it 'returns success: false for unknown modality' do
+      result = client.register_percept_hypothesis(content: 'x', modality: :unknown)
+      expect(result[:success]).to be false
+      expect(result[:error]).to be_a(String)
+    end
+
+    it 'uses DEFAULT_PRIOR when no prior given' do
+      result = client.register_percept_hypothesis(content: 'cat', modality: :visual)
+      expect(result[:prior]).to be_within(0.001).of(0.5)
+    end
+
+    it 'accepts custom prior' do
+      result = client.register_percept_hypothesis(content: 'dog', modality: :visual, prior: 0.8)
+      expect(result[:prior]).to be_within(0.001).of(0.8)
+    end
+
+    it 'accepts all valid modalities' do
+      Legion::Extensions::Agentic::Inference::PerceptualInference::Helpers::MODALITIES.each do |mod|
+        result = client.register_percept_hypothesis(content: 'x', modality: mod)
+        expect(result[:success]).to be true
+      end
+    end
+  end
+
+  describe '#present_perceptual_evidence' do
+    before { client.register_percept_hypothesis(content: 'cat', modality: :visual) }
+
+    it 'returns success: true' do
+      result = client.present_perceptual_evidence(modality: :visual, content: 'cat', strength: 0.8)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns hypotheses_updated count' do
+      result = client.present_perceptual_evidence(modality: :visual, content: 'cat', strength: 0.8)
+      expect(result[:hypotheses_updated]).to eq(1)
+    end
+
+    it 'includes rivalry status' do
+      result = client.present_perceptual_evidence(modality: :visual, content: 'cat', strength: 0.8)
+      expect(result).to have_key(:rivalry)
+    end
+
+    it 'returns success: false for unknown modality' do
+      result = client.present_perceptual_evidence(modality: :bogus, content: 'cat', strength: 0.5)
+      expect(result[:success]).to be false
+    end
+
+    it 'defaults strength to 0.5' do
+      result = client.present_perceptual_evidence(modality: :visual, content: 'cat')
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#select_percept' do
+    it 'returns success: true' do
+      result = client.select_percept(modality: :visual)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns selected: false when no hypotheses' do
+      result = client.select_percept(modality: :visual)
+      expect(result[:selected]).to be false
+    end
+
+    it 'selects a strong hypothesis' do
+      client.register_percept_hypothesis(content: 'bright light', modality: :visual, prior: 0.95)
+      client.present_perceptual_evidence(modality: :visual, content: 'bright light', strength: 0.99)
+      result = client.select_percept(modality: :visual)
+      expect(result[:selected]).to be true
+      expect(result[:hypothesis]).to be_a(Hash)
+    end
+
+    it 'returns selected: false for weak hypothesis' do
+      client.register_percept_hypothesis(content: 'faint', modality: :visual, prior: 0.1)
+      result = client.select_percept(modality: :visual)
+      expect(result[:selected]).to be false
+    end
+
+    it 'returns success: false for unknown modality' do
+      result = client.select_percept(modality: :unknown)
+      expect(result[:success]).to be false
+    end
+
+    it 'returns percept label when selected' do
+      client.register_percept_hypothesis(content: 'vivid image', modality: :visual, prior: 0.95)
+      client.present_perceptual_evidence(modality: :visual, content: 'vivid image', strength: 0.99)
+      result = client.select_percept(modality: :visual)
+      expect(result[:hypothesis][:label]).to be_a(Symbol)
+    end
+  end
+
+  describe '#check_rivalry' do
+    it 'returns success: true' do
+      result = client.check_rivalry(modality: :visual)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns rivalry: false with no hypotheses' do
+      result = client.check_rivalry(modality: :visual)
+      expect(result[:rivalry]).to be false
+    end
+
+    it 'returns top_hypotheses array' do
+      result = client.check_rivalry(modality: :visual)
+      expect(result[:top_hypotheses]).to be_an(Array)
+    end
+
+    it 'detects rivalry between two evenly matched hypotheses' do
+      client.register_percept_hypothesis(content: 'necker left', modality: :visual, prior: 0.6)
+      client.register_percept_hypothesis(content: 'necker right', modality: :visual, prior: 0.6)
+      client.present_perceptual_evidence(modality: :visual, content: 'necker', strength: 0.5)
+      result = client.check_rivalry(modality: :visual)
+      expect(result[:rivalry]).to be(true).or be(false)
+    end
+
+    it 'returns success: false for invalid modality' do
+      result = client.check_rivalry(modality: :nonexistent)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#current_percept' do
+    it 'returns success: true' do
+      result = client.current_percept(modality: :visual)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns found: false when nothing selected' do
+      result = client.current_percept(modality: :visual)
+      expect(result[:found]).to be false
+    end
+
+    it 'returns found: true after selection' do
+      client.register_percept_hypothesis(content: 'clear sky', modality: :visual, prior: 0.95)
+      client.present_perceptual_evidence(modality: :visual, content: 'clear sky', strength: 0.99)
+      client.select_percept(modality: :visual)
+      result = client.current_percept(modality: :visual)
+      expect(result[:found]).to be true
+    end
+
+    it 'returns the percept hash when found' do
+      client.register_percept_hypothesis(content: 'bright', modality: :visual, prior: 0.95)
+      client.present_perceptual_evidence(modality: :visual, content: 'bright', strength: 0.99)
+      client.select_percept(modality: :visual)
+      result = client.current_percept(modality: :visual)
+      expect(result[:percept]).to be_a(Hash)
+    end
+
+    it 'returns success: false for invalid modality' do
+      result = client.current_percept(modality: :invalid)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#adapt_perception' do
+    it 'returns success: true for valid modality' do
+      h = client.register_percept_hypothesis(content: 'cat', modality: :visual)
+      result = client.adapt_perception(modality: :visual, correct_hypothesis_id: h[:hypothesis_id])
+      expect(result[:success]).to be true
+    end
+
+    it 'includes modality and correct_hypothesis_id' do
+      h = client.register_percept_hypothesis(content: 'cat', modality: :visual)
+      result = client.adapt_perception(modality: :visual, correct_hypothesis_id: h[:hypothesis_id])
+      expect(result[:modality]).to eq(:visual)
+      expect(result[:correct_hypothesis_id]).to eq(h[:hypothesis_id])
+    end
+
+    it 'returns success: false for invalid modality' do
+      result = client.adapt_perception(modality: :bogus, correct_hypothesis_id: 'some-id')
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#suppress_percept' do
+    it 'returns success: true' do
+      h = client.register_percept_hypothesis(content: 'cat', modality: :visual)
+      result = client.suppress_percept(hypothesis_id: h[:hypothesis_id])
+      expect(result[:success]).to be true
+    end
+
+    it 'returns suppressed: true for existing hypothesis' do
+      h = client.register_percept_hypothesis(content: 'cat', modality: :visual)
+      result = client.suppress_percept(hypothesis_id: h[:hypothesis_id])
+      expect(result[:suppressed]).to be true
+    end
+
+    it 'returns suppressed: false for unknown hypothesis' do
+      result = client.suppress_percept(hypothesis_id: 'unknown-uuid')
+      expect(result[:suppressed]).to be false
+    end
+  end
+
+  describe '#perceptual_ambiguity' do
+    it 'returns success: true' do
+      result = client.perceptual_ambiguity
+      expect(result[:success]).to be true
+    end
+
+    it 'returns ambiguity_level as a float' do
+      result = client.perceptual_ambiguity
+      expect(result[:ambiguity_level]).to be_a(Float)
+    end
+
+    it 'returns a label' do
+      result = client.perceptual_ambiguity
+      expect(%i[none low moderate high]).to include(result[:label])
+    end
+
+    it 'returns :none when no hypotheses exist' do
+      result = client.perceptual_ambiguity
+      expect(result[:label]).to eq(:none)
+    end
+
+    it 'returns ambiguity_level of 0.0 with no hypotheses' do
+      result = client.perceptual_ambiguity
+      expect(result[:ambiguity_level]).to be_within(0.001).of(0.0)
+    end
+  end
+
+  describe '#update_perceptual_inference' do
+    it 'returns success: true' do
+      result = client.update_perceptual_inference
+      expect(result[:success]).to be true
+    end
+
+    it 'returns remaining_hypotheses count' do
+      client.register_percept_hypothesis(content: 'cat', modality: :visual)
+      result = client.update_perceptual_inference
+      expect(result[:remaining_hypotheses]).to be_a(Integer)
+    end
+
+    it 'reduces count of very-low-prior hypotheses over many cycles' do
+      h = client.register_percept_hypothesis(content: 'ghost', modality: :visual, prior: 0.011)
+      h_id = h[:hypothesis_id]
+      30.times { client.update_perceptual_inference }
+      result = client.perceptual_inference_stats
+      ids = result[:stats][:by_modality][:visual]&.dig(:percept, :id)
+      expect(ids).not_to eq(h_id)
+    end
+  end
+
+  describe '#perceptual_inference_stats' do
+    it 'returns success: true' do
+      result = client.perceptual_inference_stats
+      expect(result[:success]).to be true
+    end
+
+    it 'returns stats hash' do
+      result = client.perceptual_inference_stats
+      expect(result[:stats]).to be_a(Hash)
+    end
+
+    it 'includes hypotheses_total in stats' do
+      client.register_percept_hypothesis(content: 'cat', modality: :visual)
+      result = client.perceptual_inference_stats
+      expect(result[:stats][:hypotheses_total]).to eq(1)
+    end
+
+    it 'includes ambiguity_level in stats' do
+      result = client.perceptual_inference_stats
+      expect(result[:stats]).to have_key(:ambiguity_level)
+    end
+  end
+
+  describe 'integration: hypothesis lifecycle' do
+    it 'registers, presents evidence, selects, and adapts priors' do
+      reg_one = client.register_percept_hypothesis(content: 'bright cube', modality: :visual, prior: 0.95)
+      reg_two = client.register_percept_hypothesis(content: 'dark sphere', modality: :visual, prior: 0.1)
+
+      client.present_perceptual_evidence(modality: :visual, content: 'bright cube', strength: 0.99)
+      selection = client.select_percept(modality: :visual)
+      expect(selection[:selected]).to be true
+
+      client.adapt_perception(modality: :visual, correct_hypothesis_id: reg_one[:hypothesis_id])
+
+      stats = client.perceptual_inference_stats
+      expect(stats[:stats][:hypotheses_total]).to eq(2)
+      _ = reg_two
+    end
+  end
+end

data/spec/legion/extensions/agentic/inference/prediction/actors/expire_predictions_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# Stub the base class before loading the actor
+module Legion
+  module Extensions
+    module Actors
+      class Every; end # rubocop:disable Lint/EmptyClass
+    end
+  end
+end
+
+$LOADED_FEATURES << 'legion/extensions/actors/every'
+
+require_relative '../../../../../../../lib/legion/extensions/agentic/inference/prediction/actors/expire_predictions'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Prediction::Actor::ExpirePredictions do
+  subject(:actor) { described_class.new }
+
+  describe '#runner_class' do
+    it { expect(actor.runner_class).to eq Legion::Extensions::Agentic::Inference::Prediction::Runners::Prediction }
+  end
+
+  describe '#runner_function' do
+    it { expect(actor.runner_function).to eq 'expire_stale_predictions' }
+  end
+
+  describe '#time' do
+    it { expect(actor.time).to eq 300 }
+  end
+
+  describe '#run_now?' do
+    it { expect(actor.run_now?).to be false }
+  end
+
+  describe '#use_runner?' do
+    it { expect(actor.use_runner?).to be false }
+  end
+
+  describe '#check_subtask?' do
+    it { expect(actor.check_subtask?).to be false }
+  end
+
+  describe '#generate_task?' do
+    it { expect(actor.generate_task?).to be false }
+  end
+end

data/spec/legion/extensions/agentic/inference/prediction/client_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/prediction/client'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Prediction::Client do
+  it 'responds to prediction runner methods' do
+    client = described_class.new
+    expect(client).to respond_to(:predict)
+    expect(client).to respond_to(:resolve_prediction)
+    expect(client).to respond_to(:pending_predictions)
+    expect(client).to respond_to(:prediction_accuracy)
+    expect(client).to respond_to(:get_prediction)
+  end
+end

data/spec/legion/extensions/agentic/inference/prediction/helpers/modes_spec.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Prediction::Helpers::Modes do
+  describe 'REASONING_MODES' do
+    it 'is a frozen array of symbols' do
+      expect(described_class::REASONING_MODES).to be_a(Array)
+      expect(described_class::REASONING_MODES).to be_frozen
+    end
+
+    it 'contains exactly four modes' do
+      expect(described_class::REASONING_MODES.size).to eq(4)
+    end
+
+    it 'includes fault_localization' do
+      expect(described_class::REASONING_MODES).to include(:fault_localization)
+    end
+
+    it 'includes functional_mapping' do
+      expect(described_class::REASONING_MODES).to include(:functional_mapping)
+    end
+
+    it 'includes boundary_testing' do
+      expect(described_class::REASONING_MODES).to include(:boundary_testing)
+    end
+
+    it 'includes counterfactual' do
+      expect(described_class::REASONING_MODES).to include(:counterfactual)
+    end
+
+    it 'contains only symbols' do
+      expect(described_class::REASONING_MODES).to all(be_a(Symbol))
+    end
+  end
+
+  describe 'PREDICTION_CONFIDENCE_MIN' do
+    it 'is 0.65' do
+      expect(described_class::PREDICTION_CONFIDENCE_MIN).to eq(0.65)
+    end
+
+    it 'is a float' do
+      expect(described_class::PREDICTION_CONFIDENCE_MIN).to be_a(Float)
+    end
+
+    it 'is in the valid 0.0-1.0 range' do
+      expect(described_class::PREDICTION_CONFIDENCE_MIN).to be_between(0.0, 1.0)
+    end
+  end
+
+  describe 'MAX_PREDICTIONS_PER_TICK' do
+    it 'is 5' do
+      expect(described_class::MAX_PREDICTIONS_PER_TICK).to eq(5)
+    end
+
+    it 'is an integer' do
+      expect(described_class::MAX_PREDICTIONS_PER_TICK).to be_an(Integer)
+    end
+
+    it 'is positive' do
+      expect(described_class::MAX_PREDICTIONS_PER_TICK).to be > 0
+    end
+  end
+
+  describe 'PREDICTION_HORIZON' do
+    it 'is 3600' do
+      expect(described_class::PREDICTION_HORIZON).to eq(3600)
+    end
+
+    it 'is an integer' do
+      expect(described_class::PREDICTION_HORIZON).to be_an(Integer)
+    end
+
+    it 'represents one hour in seconds' do
+      expect(described_class::PREDICTION_HORIZON).to eq(60 * 60)
+    end
+  end
+
+  describe '.valid_mode?' do
+    it 'returns true for fault_localization' do
+      expect(described_class.valid_mode?(:fault_localization)).to be true
+    end
+
+    it 'returns true for functional_mapping' do
+      expect(described_class.valid_mode?(:functional_mapping)).to be true
+    end
+
+    it 'returns true for boundary_testing' do
+      expect(described_class.valid_mode?(:boundary_testing)).to be true
+    end
+
+    it 'returns true for counterfactual' do
+      expect(described_class.valid_mode?(:counterfactual)).to be true
+    end
+
+    it 'returns false for an unknown mode symbol' do
+      expect(described_class.valid_mode?(:neural_network)).to be false
+    end
+
+    it 'returns false for a string form of a valid mode' do
+      expect(described_class.valid_mode?('fault_localization')).to be false
+    end
+
+    it 'returns false for nil' do
+      expect(described_class.valid_mode?(nil)).to be false
+    end
+
+    it 'returns false for an integer' do
+      expect(described_class.valid_mode?(42)).to be false
+    end
+
+    it 'returns true for all REASONING_MODES members' do
+      described_class::REASONING_MODES.each do |mode|
+        expect(described_class.valid_mode?(mode)).to be true
+      end
+    end
+  end
+end