lex-agentic-attention 0.1.0

data/spec/legion/extensions/agentic/attention/synesthesia/helpers/synesthesia_engine_spec.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Attention::Synesthesia::Helpers::SynesthesiaEngine do
+  subject(:engine) { described_class.new }
+
+  def register(source: :auditory, target: :visual, trigger: { freq: :high },
+               response: { color: :red }, strength: 0.6)
+    engine.register_mapping(
+      source_modality:  source,
+      target_modality:  target,
+      trigger_pattern:  trigger,
+      response_pattern: response,
+      strength:         strength
+    )
+  end
+
+  describe '#register_mapping' do
+    it 'returns success with mapping_id' do
+      result = register
+      expect(result[:success]).to be true
+      expect(result[:mapping_id]).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores the mapping' do
+      register
+      expect(engine.mappings.size).to eq(1)
+    end
+
+    it 'rejects invalid source_modality' do
+      result = engine.register_mapping(source_modality: :unknown, target_modality: :visual,
+                                       trigger_pattern: {}, response_pattern: {})
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:invalid_modality)
+      expect(result[:field]).to eq(:source_modality)
+    end
+
+    it 'rejects invalid target_modality' do
+      result = engine.register_mapping(source_modality: :auditory, target_modality: :unknown,
+                                       trigger_pattern: {}, response_pattern: {})
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:invalid_modality)
+      expect(result[:field]).to eq(:target_modality)
+    end
+
+    it 'accepts all valid modalities' do
+      pairs = [%i[visual auditory], %i[tactile emotional], %i[semantic temporal],
+               %i[spatial abstract], %i[abstract visual]]
+      pairs.each do |src, tgt|
+        result = engine.register_mapping(source_modality: src, target_modality: tgt,
+                                         trigger_pattern: {}, response_pattern: {})
+        expect(result[:success]).to be true
+      end
+    end
+
+    it 'prunes when exceeding MAX_MAPPINGS' do
+      201.times { register }
+      expect(engine.mappings.size).to eq(200)
+    end
+  end
+
+  describe '#trigger' do
+    it 'returns success with empty events when no active mappings' do
+      result = engine.trigger(source_modality: :auditory, input: { note: :C4 })
+      expect(result[:success]).to be true
+      expect(result[:events]).to be_empty
+      expect(result[:triggered_count]).to eq(0)
+    end
+
+    it 'fires events for matching active mappings' do
+      register(source: :auditory, target: :visual, strength: 0.6)
+      result = engine.trigger(source_modality: :auditory, input: { note: :C4 })
+      expect(result[:triggered_count]).to eq(1)
+      expect(result[:events].first[:mapping_id]).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'does not fire events for different source modality' do
+      register(source: :visual, target: :auditory, strength: 0.6)
+      result = engine.trigger(source_modality: :tactile, input: { pressure: :high })
+      expect(result[:triggered_count]).to eq(0)
+    end
+
+    it 'does not fire events for below-threshold mappings' do
+      register(source: :auditory, target: :visual, strength: 0.1)
+      result = engine.trigger(source_modality: :auditory, input: { note: :C4 })
+      expect(result[:triggered_count]).to eq(0)
+    end
+
+    it 'strengthens the mapping on each trigger' do
+      register(source: :auditory, target: :visual, strength: 0.6)
+      before = engine.mappings.values.first.strength
+      engine.trigger(source_modality: :auditory, input: {})
+      expect(engine.mappings.values.first.strength).to be > before
+    end
+
+    it 'fires from multiple active mappings for the same modality' do
+      register(source: :auditory, target: :visual, strength: 0.6)
+      register(source: :auditory, target: :emotional, strength: 0.7)
+      result = engine.trigger(source_modality: :auditory, input: { note: :D4 })
+      expect(result[:triggered_count]).to eq(2)
+    end
+
+    it 'stores events in @events' do
+      register(source: :auditory, target: :visual, strength: 0.6)
+      engine.trigger(source_modality: :auditory, input: {})
+      expect(engine.events.size).to eq(1)
+    end
+
+    it 'caps events at MAX_EVENTS' do
+      register(source: :auditory, target: :visual, strength: 1.0)
+      501.times { engine.trigger(source_modality: :auditory, input: {}) }
+      expect(engine.events.size).to eq(500)
+    end
+
+    it 'event has involuntary: true by default' do
+      register(source: :auditory, target: :visual, strength: 0.6)
+      engine.trigger(source_modality: :auditory, input: {})
+      expect(engine.events.first.involuntary).to be true
+    end
+
+    it 'event target_output contains modality and response_pattern' do
+      register(source: :auditory, target: :visual, strength: 0.6,
+               response: { color: :blue })
+      engine.trigger(source_modality: :auditory, input: { note: :E4 })
+      output = engine.events.first.target_output
+      expect(output[:modality]).to eq(:visual)
+      expect(output[:response_pattern]).to eq({ color: :blue })
+    end
+  end
+
+  describe '#decay_mappings!' do
+    it 'returns success' do
+      result = engine.decay_mappings!
+      expect(result[:success]).to be true
+    end
+
+    it 'decays all mapping strengths' do
+      register(strength: 0.6)
+      before = engine.mappings.values.first.strength
+      engine.decay_mappings!
+      expect(engine.mappings.values.first.strength).to be < before
+    end
+
+    it 'removes mappings that decay to 0' do
+      register(strength: 0.01)
+      engine.decay_mappings!
+      expect(engine.mappings).to be_empty
+    end
+
+    it 'reports removed and remaining counts' do
+      2.times { register }
+      result = engine.decay_mappings!
+      expect(result).to have_key(:mappings_removed)
+      expect(result).to have_key(:mappings_remaining)
+    end
+  end
+
+  describe '#cross_modal_richness' do
+    it 'returns 0.0 with no mappings' do
+      expect(engine.cross_modal_richness).to eq(0.0)
+    end
+
+    it 'returns a value between 0 and 1' do
+      register(source: :auditory, target: :visual, strength: 0.6)
+      register(source: :visual, target: :emotional, strength: 0.6)
+      expect(engine.cross_modal_richness).to be_between(0.0, 1.0)
+    end
+
+    it 'increases as more unique pairs are added' do
+      register(source: :auditory, target: :visual, strength: 0.6)
+      richness_before = engine.cross_modal_richness
+      register(source: :tactile, target: :emotional, strength: 0.6)
+      richness_after = engine.cross_modal_richness
+      expect(richness_after).to be >= richness_before
+    end
+  end
+
+  describe '#dominant_modality_pairs' do
+    it 'returns empty when no mappings' do
+      expect(engine.dominant_modality_pairs).to be_empty
+    end
+
+    it 'returns pairs sorted by activation count' do
+      register(source: :auditory, target: :visual, strength: 0.6)
+      3.times { engine.trigger(source_modality: :auditory, input: {}) }
+      register(source: :tactile, target: :emotional, strength: 0.6)
+      engine.trigger(source_modality: :tactile, input: {})
+
+      pairs = engine.dominant_modality_pairs
+      expect(pairs.first[:pair]).to eq('auditory->visual')
+    end
+
+    it 'respects the limit' do
+      5.times do |i|
+        mods = Legion::Extensions::Agentic::Attention::Synesthesia::Helpers::Constants::MODALITIES
+        src  = mods[i]
+        tgt  = mods[i + 1]
+        register(source: src, target: tgt, strength: 0.6)
+      end
+      pairs = engine.dominant_modality_pairs(limit: 3)
+      expect(pairs.size).to be <= 3
+    end
+  end
+
+  describe '#event_history' do
+    it 'returns empty when no events' do
+      result = engine.event_history
+      expect(result[:success]).to be true
+      expect(result[:events]).to be_empty
+      expect(result[:count]).to eq(0)
+    end
+
+    it 'returns recent events up to limit' do
+      register(source: :auditory, target: :visual, strength: 0.6)
+      5.times { engine.trigger(source_modality: :auditory, input: {}) }
+      result = engine.event_history(limit: 3)
+      expect(result[:count]).to eq(3)
+    end
+  end
+
+  describe '#modality_coverage' do
+    it 'returns 0 covered with no active mappings' do
+      result = engine.modality_coverage
+      expect(result[:coverage_count]).to eq(0)
+      expect(result[:total_modalities]).to eq(8)
+    end
+
+    it 'returns covered modalities from active mappings' do
+      register(source: :auditory, target: :visual, strength: 0.6)
+      result = engine.modality_coverage
+      expect(result[:covered_modalities]).to include(:auditory, :visual)
+      expect(result[:coverage_count]).to eq(2)
+    end
+
+    it 'does not double-count modalities' do
+      register(source: :auditory, target: :visual, strength: 0.6)
+      register(source: :auditory, target: :emotional, strength: 0.6)
+      result = engine.modality_coverage
+      expect(result[:covered_modalities].count(:auditory)).to eq(1)
+    end
+  end
+
+  describe '#synesthesia_report' do
+    it 'returns a comprehensive hash' do
+      result = engine.synesthesia_report
+      expect(result).to include(:mapping_count, :active_mapping_count, :event_count,
+                                :cross_modal_richness, :richness_label,
+                                :dominant_modality_pairs, :modality_coverage)
+    end
+
+    it 'reflects registered mappings' do
+      register
+      result = engine.synesthesia_report
+      expect(result[:mapping_count]).to eq(1)
+    end
+
+    it 'includes a richness_label' do
+      expect(engine.synesthesia_report[:richness_label]).to be_a(Symbol)
+    end
+  end
+end

data/spec/legion/extensions/agentic/attention/synesthesia/helpers/synesthetic_event_spec.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Attention::Synesthesia::Helpers::SynestheticEvent do
+  subject(:event) do
+    described_class.new(
+      mapping_id:    'abc-123',
+      source_input:  { note: :C4 },
+      target_output: { color: :red },
+      intensity:     0.75
+    )
+  end
+
+  describe '#initialize' do
+    it 'assigns a UUID id' do
+      expect(event.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores mapping_id' do
+      expect(event.mapping_id).to eq('abc-123')
+    end
+
+    it 'stores source_input' do
+      expect(event.source_input).to eq({ note: :C4 })
+    end
+
+    it 'stores target_output' do
+      expect(event.target_output).to eq({ color: :red })
+    end
+
+    it 'clamps intensity to [0, 1]' do
+      over  = described_class.new(mapping_id: 'x', source_input: {}, target_output: {}, intensity: 2.0)
+      under = described_class.new(mapping_id: 'x', source_input: {}, target_output: {}, intensity: -1.0)
+      expect(over.intensity).to eq(1.0)
+      expect(under.intensity).to eq(0.0)
+    end
+
+    it 'defaults involuntary to true' do
+      expect(event.involuntary).to be true
+    end
+
+    it 'accepts involuntary: false' do
+      voluntary = described_class.new(mapping_id: 'x', source_input: {}, target_output: {},
+                                      intensity: 0.5, involuntary: false)
+      expect(voluntary.involuntary).to be false
+    end
+
+    it 'sets triggered_at' do
+      expect(event.triggered_at).to be_a(Time)
+    end
+  end
+
+  describe '#intensity_label' do
+    it 'returns :intense for intensity 0.75' do
+      expect(event.intensity_label).to eq(:intense)
+    end
+
+    it 'returns :subliminal for very low intensity' do
+      soft = described_class.new(mapping_id: 'x', source_input: {}, target_output: {}, intensity: 0.05)
+      expect(soft.intensity_label).to eq(:subliminal)
+    end
+
+    it 'returns :overwhelming for intensity 0.9' do
+      loud = described_class.new(mapping_id: 'x', source_input: {}, target_output: {}, intensity: 0.9)
+      expect(loud.intensity_label).to eq(:overwhelming)
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all expected keys' do
+      h = event.to_h
+      expect(h).to include(:id, :mapping_id, :source_input, :target_output,
+                           :intensity, :intensity_label, :involuntary, :triggered_at)
+    end
+
+    it 'reflects correct intensity' do
+      expect(event.to_h[:intensity]).to eq(0.75)
+    end
+
+    it 'reflects involuntary flag' do
+      expect(event.to_h[:involuntary]).to be true
+    end
+  end
+end

data/spec/legion/extensions/agentic/attention/synesthesia/runners/cognitive_synesthesia_spec.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/attention/synesthesia/client'
+
+RSpec.describe Legion::Extensions::Agentic::Attention::Synesthesia::Runners::CognitiveSynesthesia do
+  let(:client) { Legion::Extensions::Agentic::Attention::Synesthesia::Client.new }
+
+  def register_mapping(source: :auditory, target: :visual, trigger: { freq: :high },
+                       response: { color: :red }, strength: 0.6)
+    client.register_mapping(
+      source_modality:  source,
+      target_modality:  target,
+      trigger_pattern:  trigger,
+      response_pattern: response,
+      strength:         strength
+    )
+  end
+
+  describe '#register_mapping' do
+    it 'returns success with mapping_id' do
+      result = register_mapping
+      expect(result[:success]).to be true
+      expect(result[:mapping_id]).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'includes source and target modalities in result' do
+      result = register_mapping(source: :tactile, target: :emotional)
+      expect(result[:source_modality]).to eq(:tactile)
+      expect(result[:target_modality]).to eq(:emotional)
+    end
+
+    it 'rejects invalid source_modality' do
+      result = client.register_mapping(source_modality: :unknown, target_modality: :visual,
+                                       trigger_pattern: {}, response_pattern: {})
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:invalid_modality)
+    end
+
+    it 'accepts injected engine kwarg' do
+      engine = Legion::Extensions::Agentic::Attention::Synesthesia::Helpers::SynesthesiaEngine.new
+      result = client.register_mapping(source_modality: :auditory, target_modality: :visual,
+                                       trigger_pattern: {}, response_pattern: {}, engine: engine)
+      expect(result[:success]).to be true
+      expect(engine.mappings.size).to eq(1)
+    end
+  end
+
+  describe '#trigger' do
+    it 'returns success with empty events when no mappings' do
+      result = client.trigger(source_modality: :auditory, input: { note: :C4 })
+      expect(result[:success]).to be true
+      expect(result[:triggered_count]).to eq(0)
+    end
+
+    it 'fires events when active mapping exists' do
+      register_mapping(source: :auditory, target: :visual, strength: 0.6)
+      result = client.trigger(source_modality: :auditory, input: { note: :A4 })
+      expect(result[:triggered_count]).to eq(1)
+    end
+
+    it 'returns event hashes' do
+      register_mapping(source: :auditory, target: :visual, strength: 0.6)
+      result = client.trigger(source_modality: :auditory, input: { note: :A4 })
+      expect(result[:events].first).to include(:id, :mapping_id, :intensity, :involuntary)
+    end
+
+    it 'uses injected engine' do
+      engine = Legion::Extensions::Agentic::Attention::Synesthesia::Helpers::SynesthesiaEngine.new
+      engine.register_mapping(source_modality: :tactile, target_modality: :emotional,
+                              trigger_pattern: {}, response_pattern: {}, strength: 0.7)
+      result = client.trigger(source_modality: :tactile, input: { pressure: :soft }, engine: engine)
+      expect(result[:triggered_count]).to eq(1)
+    end
+  end
+
+  describe '#decay_mappings' do
+    it 'returns success' do
+      result = client.decay_mappings
+      expect(result[:success]).to be true
+    end
+
+    it 'reports removed count' do
+      result = client.decay_mappings
+      expect(result).to have_key(:mappings_removed)
+      expect(result).to have_key(:mappings_remaining)
+    end
+
+    it 'decays mappings over multiple calls' do
+      register_mapping(strength: 0.4)
+      20.times { client.decay_mappings }
+      result = client.decay_mappings
+      expect(result[:mappings_remaining]).to eq(0)
+    end
+  end
+
+  describe '#cross_modal_richness' do
+    it 'returns success with richness 0.0 initially' do
+      result = client.cross_modal_richness
+      expect(result[:success]).to be true
+      expect(result[:richness]).to eq(0.0)
+    end
+
+    it 'returns richness > 0 after adding active mappings' do
+      register_mapping(source: :auditory, target: :visual, strength: 0.6)
+      result = client.cross_modal_richness
+      expect(result[:richness]).to be > 0.0
+    end
+
+    it 'includes richness_label' do
+      result = client.cross_modal_richness
+      expect(result[:richness_label]).to be_a(Symbol)
+    end
+  end
+
+  describe '#dominant_modality_pairs' do
+    it 'returns success with empty pairs initially' do
+      result = client.dominant_modality_pairs
+      expect(result[:success]).to be true
+      expect(result[:pairs]).to be_empty
+    end
+
+    it 'returns pairs after triggers' do
+      register_mapping(source: :auditory, target: :visual, strength: 0.6)
+      3.times { client.trigger(source_modality: :auditory, input: {}) }
+      result = client.dominant_modality_pairs
+      expect(result[:pairs].first[:pair]).to eq('auditory->visual')
+    end
+
+    it 'respects limit' do
+      result = client.dominant_modality_pairs(limit: 2)
+      expect(result[:count]).to be <= 2
+    end
+  end
+
+  describe '#event_history' do
+    it 'returns success with empty events initially' do
+      result = client.event_history
+      expect(result[:success]).to be true
+      expect(result[:events]).to be_empty
+    end
+
+    it 'returns events after triggering' do
+      register_mapping(source: :auditory, target: :visual, strength: 0.6)
+      client.trigger(source_modality: :auditory, input: {})
+      result = client.event_history
+      expect(result[:count]).to eq(1)
+    end
+
+    it 'respects limit' do
+      register_mapping(source: :auditory, target: :visual, strength: 0.8)
+      5.times { client.trigger(source_modality: :auditory, input: {}) }
+      result = client.event_history(limit: 2)
+      expect(result[:count]).to eq(2)
+    end
+  end
+
+  describe '#modality_coverage' do
+    it 'returns success with 0 coverage initially' do
+      result = client.modality_coverage
+      expect(result[:success]).to be true
+      expect(result[:coverage_count]).to eq(0)
+    end
+
+    it 'reflects active mappings' do
+      register_mapping(source: :auditory, target: :visual, strength: 0.6)
+      result = client.modality_coverage
+      expect(result[:covered_modalities]).to include(:auditory, :visual)
+    end
+  end
+
+  describe '#synesthesia_report' do
+    it 'returns success with full report hash' do
+      result = client.synesthesia_report
+      expect(result[:success]).to be true
+      expect(result).to include(:mapping_count, :active_mapping_count, :event_count,
+                                :cross_modal_richness, :richness_label)
+    end
+
+    it 'reflects registered mappings' do
+      register_mapping
+      result = client.synesthesia_report
+      expect(result[:mapping_count]).to eq(1)
+    end
+
+    it 'reflects triggered events' do
+      register_mapping(source: :auditory, target: :visual, strength: 0.6)
+      client.trigger(source_modality: :auditory, input: { note: :G4 })
+      result = client.synesthesia_report
+      expect(result[:event_count]).to eq(1)
+    end
+  end
+end

data/spec/legion/extensions/agentic/attention/telescope/client_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Attention::Telescope::Client do
+  subject(:client) { described_class.new }
+
+  let(:engine) { Legion::Extensions::Agentic::Attention::Telescope::Helpers::ObservatoryEngine.new }
+
+  it 'includes runner methods' do
+    expect(client).to respond_to(:create_telescope)
+    expect(client).to respond_to(:zoom_in)
+    expect(client).to respond_to(:zoom_out)
+    expect(client).to respond_to(:observe)
+    expect(client).to respond_to(:focus)
+    expect(client).to respond_to(:survey_mode)
+    expect(client).to respond_to(:deep_focus)
+    expect(client).to respond_to(:list_observations)
+    expect(client).to respond_to(:observatory_status)
+  end
+
+  it 'delegates create_telescope to runner' do
+    result = client.create_telescope(lens_type: :refractor, engine: engine)
+    expect(result[:success]).to be true
+  end
+
+  it 'delegates observatory_status to runner' do
+    result = client.observatory_status(engine: engine)
+    expect(result[:success]).to be true
+    expect(result[:report]).to have_key(:total_telescopes)
+  end
+end

data/spec/legion/extensions/agentic/attention/telescope/helpers/constants_spec.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Attention::Telescope::Helpers::Constants do
+  describe 'LENS_TYPES' do
+    it 'contains expected lens types' do
+      expect(described_class::LENS_TYPES).to include(:refractor, :reflector, :catadioptric, :radio, :adaptive)
+    end
+
+    it 'is frozen' do
+      expect(described_class::LENS_TYPES).to be_frozen
+    end
+  end
+
+  describe 'OBSERVATION_MODES' do
+    it 'contains expected modes' do
+      expect(described_class::OBSERVATION_MODES).to include(:survey, :focused, :tracking, :spectral)
+    end
+
+    it 'is frozen' do
+      expect(described_class::OBSERVATION_MODES).to be_frozen
+    end
+  end
+
+  describe 'numeric constants' do
+    it 'MAX_TELESCOPES is 100' do
+      expect(described_class::MAX_TELESCOPES).to eq(100)
+    end
+
+    it 'MAX_OBSERVATIONS is 500' do
+      expect(described_class::MAX_OBSERVATIONS).to eq(500)
+    end
+
+    it 'BASE_MAGNIFICATION is 1.0' do
+      expect(described_class::BASE_MAGNIFICATION).to eq(1.0)
+    end
+
+    it 'MAX_MAGNIFICATION is 100.0' do
+      expect(described_class::MAX_MAGNIFICATION).to eq(100.0)
+    end
+
+    it 'FIELD_OF_VIEW_BASE is 1.0' do
+      expect(described_class::FIELD_OF_VIEW_BASE).to eq(1.0)
+    end
+
+    it 'ATMOSPHERIC_DISTORTION is 0.1' do
+      expect(described_class::ATMOSPHERIC_DISTORTION).to eq(0.1)
+    end
+  end
+
+  describe 'CLARITY_LABELS' do
+    it 'is an array of range-label pairs' do
+      expect(described_class::CLARITY_LABELS).to be_an(Array)
+      described_class::CLARITY_LABELS.each do |pair|
+        expect(pair.size).to eq(2)
+        expect(pair.first).to be_a(Range)
+        expect(pair.last).to be_a(Symbol)
+      end
+    end
+
+    it 'includes crystal, clear, hazy, blurry, blind labels' do
+      labels = described_class::CLARITY_LABELS.map(&:last)
+      expect(labels).to include(:crystal, :clear, :hazy, :blurry, :blind)
+    end
+  end
+
+  describe 'DISTANCE_LABELS' do
+    it 'is an array of range-label pairs' do
+      expect(described_class::DISTANCE_LABELS).to be_an(Array)
+    end
+
+    it 'includes cosmic, deep, medium, near, myopic labels' do
+      labels = described_class::DISTANCE_LABELS.map(&:last)
+      expect(labels).to include(:cosmic, :deep, :medium, :near, :myopic)
+    end
+  end
+
+  describe '.label_for' do
+    it 'returns :crystal for high clarity' do
+      result = described_class.label_for(described_class::CLARITY_LABELS, 0.95)
+      expect(result).to eq(:crystal)
+    end
+
+    it 'returns :blind for very low clarity' do
+      result = described_class.label_for(described_class::CLARITY_LABELS, 0.1)
+      expect(result).to eq(:blind)
+    end
+
+    it 'returns :clear for mid-high clarity' do
+      result = described_class.label_for(described_class::CLARITY_LABELS, 0.75)
+      expect(result).to eq(:clear)
+    end
+
+    it 'returns :cosmic for high distance' do
+      result = described_class.label_for(described_class::DISTANCE_LABELS, 0.9)
+      expect(result).to eq(:cosmic)
+    end
+
+    it 'returns :myopic for very low distance' do
+      result = described_class.label_for(described_class::DISTANCE_LABELS, 0.05)
+      expect(result).to eq(:myopic)
+    end
+
+    it 'returns last label as fallback' do
+      result = described_class.label_for(described_class::CLARITY_LABELS, -999.0)
+      expect(result).to eq(described_class::CLARITY_LABELS.last.last)
+    end
+  end
+end