lex-cognitive-pendulum 0.1.0

data/spec/legion/extensions/cognitive_pendulum/helpers/pendulum_engine_spec.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::CognitivePendulum::Helpers::PendulumEngine do
+  subject(:engine) { described_class.new }
+
+  describe '#initialize' do
+    it 'starts with empty pendulums hash' do
+      expect(engine.pendulums).to be_empty
+    end
+
+    it 'reports count of 0' do
+      expect(engine.count).to eq(0)
+    end
+  end
+
+  describe '#create_pendulum' do
+    it 'creates a pendulum and returns it' do
+      p = engine.create_pendulum(pole_pair: :certainty_doubt)
+      expect(p).to be_a(Legion::Extensions::CognitivePendulum::Helpers::Pendulum)
+    end
+
+    it 'stores the pendulum by id' do
+      p = engine.create_pendulum(pole_pair: :focus_diffusion)
+      expect(engine.pendulums[p.id]).to eq(p)
+    end
+
+    it 'increments count' do
+      engine.create_pendulum(pole_pair: :certainty_doubt)
+      expect(engine.count).to eq(1)
+    end
+
+    it 'accepts amplitude, period, and damping' do
+      p = engine.create_pendulum(pole_pair: :analysis_intuition, amplitude: 0.8, period: 20.0, damping: 0.05)
+      expect(p.amplitude).to eq(0.8)
+      expect(p.period).to eq(20.0)
+      expect(p.damping).to eq(0.05)
+    end
+
+    it 'raises when max pendulums reached' do
+      Legion::Extensions::CognitivePendulum::Helpers::Constants::MAX_PENDULUMS.times do
+        engine.create_pendulum(pole_pair: :certainty_doubt)
+      end
+      expect { engine.create_pendulum(pole_pair: :certainty_doubt) }.to raise_error(ArgumentError, /max pendulums/)
+    end
+  end
+
+  describe '#swing' do
+    let!(:pendulum) { engine.create_pendulum(pole_pair: :focus_diffusion) }
+
+    it 'swings the pendulum and returns it' do
+      result = engine.swing(pendulum.id, force: 0.5)
+      expect(result).to eq(pendulum)
+    end
+
+    it 'updates position on the pendulum' do
+      engine.swing(pendulum.id, force: 0.6)
+      expect(pendulum.current_position).to eq(0.6)
+    end
+
+    it 'returns nil for unknown id' do
+      expect(engine.swing('no-such-id', force: 0.1)).to be_nil
+    end
+  end
+
+  describe '#damp_all!' do
+    it 'damps every pendulum' do
+      p1 = engine.create_pendulum(pole_pair: :certainty_doubt, amplitude: 0.8)
+      p2 = engine.create_pendulum(pole_pair: :focus_diffusion, amplitude: 0.6)
+      engine.damp_all!
+      expect(p1.amplitude).to be < 0.8
+      expect(p2.amplitude).to be < 0.6
+    end
+
+    it 'does nothing with no pendulums' do
+      expect { engine.damp_all! }.not_to raise_error
+    end
+  end
+
+  describe '#check_resonance' do
+    it 'returns ids of resonant pendulums' do
+      p = engine.create_pendulum(pole_pair: :analysis_intuition, period: 10.0)
+      natural = 1.0 / 10.0
+      result = engine.check_resonance(natural)
+      expect(result).to include(p.id)
+    end
+
+    it 'returns empty array when no resonance' do
+      engine.create_pendulum(pole_pair: :analysis_intuition, period: 10.0)
+      expect(engine.check_resonance(99.0)).to be_empty
+    end
+
+    it 'returns empty array for zero or negative frequency' do
+      engine.create_pendulum(pole_pair: :analysis_intuition, period: 10.0)
+      expect(engine.check_resonance(0.0)).to be_empty
+    end
+  end
+
+  describe '#dominant_pole' do
+    let!(:pendulum) { engine.create_pendulum(pole_pair: :certainty_doubt) }
+
+    it 'returns :neutral at center' do
+      expect(engine.dominant_pole(pendulum.id)).to eq(:neutral)
+    end
+
+    it 'returns the correct pole after swinging' do
+      engine.swing(pendulum.id, force: 0.9)
+      expect(engine.dominant_pole(pendulum.id)).to eq(:doubt)
+    end
+
+    it 'returns nil for unknown id' do
+      expect(engine.dominant_pole('missing-id')).to be_nil
+    end
+  end
+
+  describe '#most_active' do
+    before do
+      engine.create_pendulum(pole_pair: :certainty_doubt, amplitude: 0.9)
+      engine.create_pendulum(pole_pair: :focus_diffusion, amplitude: 0.3)
+      engine.create_pendulum(pole_pair: :analysis_intuition, amplitude: 0.6)
+    end
+
+    it 'returns pendulums sorted by amplitude descending' do
+      result = engine.most_active(limit: 3)
+      amplitudes = result.map(&:amplitude)
+      expect(amplitudes).to eq(amplitudes.sort.reverse)
+    end
+
+    it 'respects limit' do
+      expect(engine.most_active(limit: 2).size).to eq(2)
+    end
+
+    it 'returns all if limit exceeds count' do
+      expect(engine.most_active(limit: 10).size).to eq(3)
+    end
+  end
+
+  describe '#most_damped' do
+    before do
+      engine.create_pendulum(pole_pair: :certainty_doubt, amplitude: 0.1)
+      engine.create_pendulum(pole_pair: :focus_diffusion, amplitude: 0.8)
+      engine.create_pendulum(pole_pair: :analysis_intuition, amplitude: 0.4)
+    end
+
+    it 'returns pendulums sorted by amplitude ascending' do
+      result = engine.most_damped(limit: 3)
+      amplitudes = result.map(&:amplitude)
+      expect(amplitudes).to eq(amplitudes.sort)
+    end
+
+    it 'respects limit' do
+      expect(engine.most_damped(limit: 1).size).to eq(1)
+    end
+  end
+
+  describe '#pendulum_report' do
+    before do
+      engine.create_pendulum(pole_pair: :certainty_doubt, amplitude: 0.8)
+      engine.create_pendulum(pole_pair: :certainty_doubt, amplitude: 0.5)
+      engine.create_pendulum(pole_pair: :focus_diffusion, amplitude: 0.3)
+    end
+
+    it 'includes total count' do
+      expect(engine.pendulum_report[:total]).to eq(3)
+    end
+
+    it 'includes max constant' do
+      expect(engine.pendulum_report[:max]).to eq(Legion::Extensions::CognitivePendulum::Helpers::Constants::MAX_PENDULUMS)
+    end
+
+    it 'groups pendulums by pole_pair' do
+      report = engine.pendulum_report
+      expect(report[:pole_pairs][:certainty_doubt]).to eq(2)
+      expect(report[:pole_pairs][:focus_diffusion]).to eq(1)
+    end
+
+    it 'includes most_active as hashes' do
+      report = engine.pendulum_report
+      expect(report[:most_active]).to be_an(Array)
+      expect(report[:most_active].first).to be_a(Hash)
+    end
+
+    it 'includes most_damped as hashes' do
+      report = engine.pendulum_report
+      expect(report[:most_damped]).to be_an(Array)
+    end
+  end
+
+  describe '#get' do
+    it 'returns the pendulum by id' do
+      p = engine.create_pendulum(pole_pair: :approach_avoidance)
+      expect(engine.get(p.id)).to eq(p)
+    end
+
+    it 'returns nil for unknown id' do
+      expect(engine.get('not-here')).to be_nil
+    end
+  end
+end

data/spec/legion/extensions/cognitive_pendulum/helpers/pendulum_spec.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::CognitivePendulum::Helpers::Pendulum do
+  subject(:pendulum) { described_class.new(pole_pair: :certainty_doubt) }
+
+  describe '#initialize' do
+    it 'assigns a uuid id' do
+      expect(pendulum.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores the pole_pair' do
+      expect(pendulum.pole_pair).to eq(:certainty_doubt)
+    end
+
+    it 'defaults amplitude to 0.5' do
+      expect(pendulum.amplitude).to eq(0.5)
+    end
+
+    it 'defaults period to 10.0' do
+      expect(pendulum.period).to eq(10.0)
+    end
+
+    it 'defaults damping to DAMPING_RATE' do
+      expect(pendulum.damping).to eq(Legion::Extensions::CognitivePendulum::Helpers::Constants::DAMPING_RATE)
+    end
+
+    it 'initializes current_position to 0.0' do
+      expect(pendulum.current_position).to eq(0.0)
+    end
+
+    it 'initializes swings to 0' do
+      expect(pendulum.swings).to eq(0)
+    end
+
+    it 'sets created_at' do
+      expect(pendulum.created_at).to be_a(Time)
+    end
+
+    it 'raises for invalid pole_pair' do
+      expect { described_class.new(pole_pair: :nonsense) }.to raise_error(ArgumentError)
+    end
+
+    it 'raises when amplitude out of range' do
+      expect { described_class.new(pole_pair: :certainty_doubt, amplitude: 1.5) }.to raise_error(ArgumentError)
+    end
+
+    it 'raises when period is zero or negative' do
+      expect { described_class.new(pole_pair: :certainty_doubt, period: 0.0) }.to raise_error(ArgumentError)
+    end
+
+    it 'raises when damping is negative' do
+      expect { described_class.new(pole_pair: :certainty_doubt, damping: -0.1) }.to raise_error(ArgumentError)
+    end
+
+    it 'accepts custom amplitude' do
+      p = described_class.new(pole_pair: :focus_diffusion, amplitude: 0.8)
+      expect(p.amplitude).to eq(0.8)
+    end
+
+    it 'accepts custom period' do
+      p = described_class.new(pole_pair: :focus_diffusion, period: 30.0)
+      expect(p.period).to eq(30.0)
+    end
+
+    it 'accepts zero damping' do
+      p = described_class.new(pole_pair: :analysis_intuition, damping: 0.0)
+      expect(p.damping).to eq(0.0)
+    end
+  end
+
+  describe '#swing!' do
+    it 'moves position toward positive with positive force' do
+      pendulum.swing!(force: 0.5)
+      expect(pendulum.current_position).to be > 0.0
+    end
+
+    it 'moves position toward negative with negative force' do
+      pendulum.swing!(force: -0.5)
+      expect(pendulum.current_position).to be < 0.0
+    end
+
+    it 'clamps position to 1.0 maximum' do
+      5.times { pendulum.swing!(force: 1.0) }
+      expect(pendulum.current_position).to eq(1.0)
+    end
+
+    it 'clamps position to -1.0 minimum' do
+      5.times { pendulum.swing!(force: -1.0) }
+      expect(pendulum.current_position).to eq(-1.0)
+    end
+
+    it 'clamps force to valid range' do
+      pendulum.swing!(force: 99.0)
+      expect(pendulum.current_position).to be <= 1.0
+    end
+
+    it 'increments swing count' do
+      pendulum.swing!(force: 0.3)
+      expect(pendulum.swings).to eq(1)
+    end
+
+    it 'returns the new position' do
+      result = pendulum.swing!(force: 0.4)
+      expect(result).to eq(pendulum.current_position)
+    end
+  end
+
+  describe '#damp!' do
+    it 'reduces amplitude' do
+      original = pendulum.amplitude
+      pendulum.damp!
+      expect(pendulum.amplitude).to be < original
+    end
+
+    it 'reduces current_position magnitude' do
+      pendulum.swing!(force: 0.8)
+      original = pendulum.current_position.abs
+      pendulum.damp!
+      expect(pendulum.current_position.abs).to be < original
+    end
+
+    it 'returns the new amplitude' do
+      result = pendulum.damp!
+      expect(result).to eq(pendulum.amplitude)
+    end
+
+    it 'never goes below 0' do
+      100.times { pendulum.damp! }
+      expect(pendulum.amplitude).to be >= 0.0
+    end
+  end
+
+  describe '#position_at' do
+    let(:p) { described_class.new(pole_pair: :focus_diffusion, amplitude: 1.0, period: 10.0, damping: 0.0) }
+
+    it 'returns a float' do
+      expect(p.position_at(0.0)).to be_a(Float)
+    end
+
+    it 'returns amplitude at time 0 (cos(0) = 1)' do
+      expect(p.position_at(0.0)).to eq(1.0)
+    end
+
+    it 'returns a value within [-1.0, 1.0]' do
+      expect(p.position_at(5.0)).to be_between(-1.0, 1.0)
+    end
+
+    it 'decays with positive damping' do
+      damped = described_class.new(pole_pair: :focus_diffusion, amplitude: 1.0, period: 10.0, damping: 0.1)
+      expect(damped.position_at(10.0).abs).to be < p.position_at(10.0).abs
+    end
+  end
+
+  describe '#at_pole_a?' do
+    it 'is false at neutral position' do
+      expect(pendulum.at_pole_a?).to be false
+    end
+
+    it 'is true when position <= -0.5' do
+      3.times { pendulum.swing!(force: -1.0) }
+      expect(pendulum.at_pole_a?).to be true
+    end
+  end
+
+  describe '#at_pole_b?' do
+    it 'is false at neutral position' do
+      expect(pendulum.at_pole_b?).to be false
+    end
+
+    it 'is true when position >= 0.5' do
+      3.times { pendulum.swing!(force: 1.0) }
+      expect(pendulum.at_pole_b?).to be true
+    end
+  end
+
+  describe '#amplitude_label' do
+    it 'returns :moderate for default amplitude' do
+      expect(pendulum.amplitude_label).to eq(:moderate)
+    end
+
+    it 'returns :minimal for low amplitude' do
+      p = described_class.new(pole_pair: :certainty_doubt, amplitude: 0.1)
+      expect(p.amplitude_label).to eq(:minimal)
+    end
+
+    it 'returns :maximal for high amplitude' do
+      p = described_class.new(pole_pair: :certainty_doubt, amplitude: 0.9)
+      expect(p.amplitude_label).to eq(:maximal)
+    end
+  end
+
+  describe '#resonant_with?' do
+    let(:p) { described_class.new(pole_pair: :analysis_intuition, period: 10.0) }
+
+    it 'returns true when frequency matches natural frequency' do
+      natural = 1.0 / 10.0
+      expect(p.resonant_with?(natural)).to be true
+    end
+
+    it 'returns false when frequency is far off' do
+      expect(p.resonant_with?(0.5)).to be false
+    end
+
+    it 'returns false for zero or negative frequency' do
+      expect(p.resonant_with?(0.0)).to be false
+    end
+
+    it 'returns true within 5% tolerance' do
+      natural = 1.0 / 10.0
+      expect(p.resonant_with?(natural * 1.04)).to be true
+    end
+  end
+
+  describe '#dominant_pole' do
+    it 'returns :neutral near center' do
+      expect(pendulum.dominant_pole).to eq(:neutral)
+    end
+
+    it 'returns pole_a when position is negative' do
+      3.times { pendulum.swing!(force: -1.0) }
+      expect(pendulum.dominant_pole).to eq(:certainty)
+    end
+
+    it 'returns pole_b when position is positive' do
+      3.times { pendulum.swing!(force: 1.0) }
+      expect(pendulum.dominant_pole).to eq(:doubt)
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all expected keys' do
+      h = pendulum.to_h
+      %i[id pole_pair pole_a pole_b amplitude amplitude_label period damping
+         current_position dominant_pole at_pole_a at_pole_b swings created_at].each do |key|
+        expect(h).to have_key(key)
+      end
+    end
+
+    it 'pole_a is :certainty for certainty_doubt pair' do
+      expect(pendulum.to_h[:pole_a]).to eq(:certainty)
+    end
+
+    it 'pole_b is :doubt for certainty_doubt pair' do
+      expect(pendulum.to_h[:pole_b]).to eq(:doubt)
+    end
+  end
+end

data/spec/legion/extensions/cognitive_pendulum/runners/cognitive_pendulum_spec.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/cognitive_pendulum/client'
+
+RSpec.describe Legion::Extensions::CognitivePendulum::Runners::CognitivePendulum do
+  let(:client) { Legion::Extensions::CognitivePendulum::Client.new }
+
+  describe '#create_pendulum' do
+    it 'returns success with valid pole_pair' do
+      result = client.create_pendulum(pole_pair: :certainty_doubt)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns a pendulum_id uuid' do
+      result = client.create_pendulum(pole_pair: :focus_diffusion)
+      expect(result[:pendulum_id]).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'echoes the pole_pair' do
+      result = client.create_pendulum(pole_pair: :analysis_intuition)
+      expect(result[:pole_pair]).to eq(:analysis_intuition)
+    end
+
+    it 'returns the amplitude' do
+      result = client.create_pendulum(pole_pair: :certainty_doubt, amplitude: 0.7)
+      expect(result[:amplitude]).to eq(0.7)
+    end
+
+    it 'returns error for invalid pole_pair' do
+      result = client.create_pendulum(pole_pair: :bogus)
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:invalid_pole_pair)
+    end
+
+    it 'includes valid_pairs in error response' do
+      result = client.create_pendulum(pole_pair: :bogus)
+      expect(result[:valid_pairs]).to be_an(Array)
+    end
+
+    it 'returns argument_error for invalid amplitude' do
+      result = client.create_pendulum(pole_pair: :certainty_doubt, amplitude: 5.0)
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:argument_error)
+    end
+
+    it 'returns argument_error for non-positive period' do
+      result = client.create_pendulum(pole_pair: :certainty_doubt, period: -1.0)
+      expect(result[:success]).to be false
+    end
+
+    it 'accepts all five pole pairs' do
+      %i[certainty_doubt focus_diffusion analysis_intuition approach_avoidance convergent_divergent].each do |pair|
+        result = client.create_pendulum(pole_pair: pair)
+        expect(result[:success]).to be true
+      end
+    end
+  end
+
+  describe '#swing' do
+    let(:pendulum_id) { client.create_pendulum(pole_pair: :certainty_doubt)[:pendulum_id] }
+
+    it 'returns success for valid pendulum' do
+      result = client.swing(pendulum_id: pendulum_id, force: 0.5)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns the current_position' do
+      result = client.swing(pendulum_id: pendulum_id, force: 0.5)
+      expect(result[:current_position]).to eq(0.5)
+    end
+
+    it 'returns the dominant_pole' do
+      result = client.swing(pendulum_id: pendulum_id, force: 0.8)
+      expect(result).to have_key(:dominant_pole)
+    end
+
+    it 'returns not_found for unknown id' do
+      result = client.swing(pendulum_id: 'no-such-id', force: 0.1)
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:not_found)
+    end
+
+    it 'swings multiple times and accumulates position' do
+      client.swing(pendulum_id: pendulum_id, force: 0.3)
+      result = client.swing(pendulum_id: pendulum_id, force: 0.3)
+      expect(result[:current_position]).to be_within(0.001).of(0.6)
+    end
+  end
+
+  describe '#damp_all' do
+    it 'returns success' do
+      result = client.damp_all
+      expect(result[:success]).to be true
+    end
+
+    it 'reports number of damped pendulums' do
+      client.create_pendulum(pole_pair: :focus_diffusion)
+      client.create_pendulum(pole_pair: :analysis_intuition)
+      result = client.damp_all
+      expect(result[:damped]).to eq(2)
+    end
+
+    it 'reports zero when no pendulums exist' do
+      result = client.damp_all
+      expect(result[:damped]).to eq(0)
+    end
+  end
+
+  describe '#check_resonance' do
+    before { client.create_pendulum(pole_pair: :analysis_intuition, period: 10.0) }
+
+    it 'returns success' do
+      result = client.check_resonance(frequency: 0.1)
+      expect(result[:success]).to be true
+    end
+
+    it 'detects resonance at natural frequency' do
+      result = client.check_resonance(frequency: 0.1)
+      expect(result[:count]).to eq(1)
+    end
+
+    it 'returns empty when no resonance' do
+      result = client.check_resonance(frequency: 99.0)
+      expect(result[:count]).to eq(0)
+    end
+
+    it 'returns error for non-positive frequency' do
+      result = client.check_resonance(frequency: 0.0)
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:invalid_frequency)
+    end
+
+    it 'returns resonant_pendulum_ids array' do
+      result = client.check_resonance(frequency: 0.1)
+      expect(result[:resonant_pendulum_ids]).to be_an(Array)
+    end
+
+    it 'echoes the frequency' do
+      result = client.check_resonance(frequency: 0.1)
+      expect(result[:frequency]).to eq(0.1)
+    end
+  end
+
+  describe '#get_dominant_pole' do
+    let(:pendulum_id) { client.create_pendulum(pole_pair: :certainty_doubt)[:pendulum_id] }
+
+    it 'returns success for known pendulum' do
+      result = client.get_dominant_pole(pendulum_id: pendulum_id)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns :neutral for centered pendulum' do
+      result = client.get_dominant_pole(pendulum_id: pendulum_id)
+      expect(result[:dominant_pole]).to eq(:neutral)
+    end
+
+    it 'returns the active pole after swinging' do
+      client.swing(pendulum_id: pendulum_id, force: 0.8)
+      result = client.get_dominant_pole(pendulum_id: pendulum_id)
+      expect(result[:dominant_pole]).to eq(:doubt)
+    end
+
+    it 'returns not_found for unknown id' do
+      result = client.get_dominant_pole(pendulum_id: 'ghost')
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:not_found)
+    end
+  end
+
+  describe '#most_active' do
+    before do
+      client.create_pendulum(pole_pair: :certainty_doubt, amplitude: 0.9)
+      client.create_pendulum(pole_pair: :focus_diffusion, amplitude: 0.2)
+      client.create_pendulum(pole_pair: :analysis_intuition, amplitude: 0.6)
+    end
+
+    it 'returns success' do
+      expect(client.most_active[:success]).to be true
+    end
+
+    it 'returns pendulums sorted by descending amplitude' do
+      result = client.most_active(limit: 3)
+      amplitudes = result[:pendulums].map { |p| p[:amplitude] }
+      expect(amplitudes).to eq(amplitudes.sort.reverse)
+    end
+
+    it 'respects limit' do
+      result = client.most_active(limit: 2)
+      expect(result[:count]).to eq(2)
+    end
+  end
+
+  describe '#most_damped' do
+    before do
+      client.create_pendulum(pole_pair: :certainty_doubt, amplitude: 0.1)
+      client.create_pendulum(pole_pair: :focus_diffusion, amplitude: 0.7)
+    end
+
+    it 'returns success' do
+      expect(client.most_damped[:success]).to be true
+    end
+
+    it 'returns pendulums sorted by ascending amplitude' do
+      result = client.most_damped(limit: 2)
+      amplitudes = result[:pendulums].map { |p| p[:amplitude] }
+      expect(amplitudes).to eq(amplitudes.sort)
+    end
+  end
+
+  describe '#pendulum_report' do
+    before do
+      client.create_pendulum(pole_pair: :certainty_doubt)
+      client.create_pendulum(pole_pair: :focus_diffusion)
+    end
+
+    it 'returns success' do
+      expect(client.pendulum_report[:success]).to be true
+    end
+
+    it 'includes a report hash' do
+      result = client.pendulum_report
+      expect(result[:report]).to be_a(Hash)
+    end
+
+    it 'report has total of 2' do
+      expect(client.pendulum_report[:report][:total]).to eq(2)
+    end
+  end
+
+  describe '#get_pendulum' do
+    let(:pendulum_id) { client.create_pendulum(pole_pair: :approach_avoidance)[:pendulum_id] }
+
+    it 'returns success with the pendulum hash' do
+      result = client.get_pendulum(pendulum_id: pendulum_id)
+      expect(result[:success]).to be true
+      expect(result[:pendulum]).to be_a(Hash)
+    end
+
+    it 'returns not_found for unknown id' do
+      result = client.get_pendulum(pendulum_id: 'fake-id')
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:not_found)
+    end
+
+    it 'pendulum hash includes pole_pair' do
+      result = client.get_pendulum(pendulum_id: pendulum_id)
+      expect(result[:pendulum][:pole_pair]).to eq(:approach_avoidance)
+    end
+  end
+end