lex-cognitive-quicksilver 0.1.0

data/spec/legion/extensions/cognitive_quicksilver/helpers/droplet_spec.rb

@@ -0,0 +1,310 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::CognitiveQuicksilver::Helpers::Droplet do
+  let(:droplet) { described_class.new(form: :droplet, content: 'test idea') }
+
+  describe '#initialize' do
+    it 'assigns a uuid id' do
+      expect(droplet.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'sets form' do
+      expect(droplet.form).to eq(:droplet)
+    end
+
+    it 'sets content' do
+      expect(droplet.content).to eq('test idea')
+    end
+
+    it 'defaults mass to 0.3' do
+      expect(droplet.mass).to eq(0.3)
+    end
+
+    it 'defaults fluidity to FLUIDITY_BASE' do
+      expect(droplet.fluidity).to eq(Legion::Extensions::CognitiveQuicksilver::Helpers::Constants::FLUIDITY_BASE)
+    end
+
+    it 'defaults surface to :glass' do
+      expect(droplet.surface).to eq(:glass)
+    end
+
+    it 'defaults captured to false' do
+      expect(droplet.captured).to be false
+    end
+
+    it 'clamps mass above 1.0' do
+      d = described_class.new(form: :liquid, content: 'x', mass: 1.5)
+      expect(d.mass).to eq(1.0)
+    end
+
+    it 'clamps mass below 0.0' do
+      d = described_class.new(form: :liquid, content: 'x', mass: -0.5)
+      expect(d.mass).to eq(0.0)
+    end
+
+    it 'raises ArgumentError for invalid form' do
+      expect { described_class.new(form: :vapor, content: 'x') }.to raise_error(ArgumentError, /invalid form/)
+    end
+
+    it 'raises ArgumentError for invalid surface' do
+      expect do
+        described_class.new(form: :droplet, content: 'x', surface: :air)
+      end.to raise_error(ArgumentError, /invalid surface/)
+    end
+
+    it 'sets created_at' do
+      expect(droplet.created_at).to be_a(Time)
+    end
+  end
+
+  describe '#shift_form!' do
+    it 'changes the form' do
+      droplet.shift_form!(:liquid)
+      expect(droplet.form).to eq(:liquid)
+    end
+
+    it 'adjusts fluidity based on form' do
+      droplet.shift_form!(:liquid)
+      expect(droplet.fluidity).to eq(0.9)
+    end
+
+    it 'sets low fluidity for pool form' do
+      droplet.shift_form!(:pool)
+      expect(droplet.fluidity).to eq(0.3)
+    end
+
+    it 'returns self for chaining' do
+      expect(droplet.shift_form!(:bead)).to be(droplet)
+    end
+
+    it 'raises ArgumentError for invalid form' do
+      expect { droplet.shift_form!(:fog) }.to raise_error(ArgumentError, /invalid form/)
+    end
+  end
+
+  describe '#merge!' do
+    let(:other) { described_class.new(form: :liquid, content: 'other', mass: 0.4) }
+
+    it 'combines mass with coalescence bonus' do
+      bonus         = Legion::Extensions::CognitiveQuicksilver::Helpers::Constants::COALESCENCE_BONUS
+      original_mass = droplet.mass
+      droplet.merge!(other)
+      expected = [original_mass + other.mass + bonus, 1.0].min
+      expect(droplet.mass).to be_within(0.001).of(expected)
+    end
+
+    it 'clamps merged mass to 1.0' do
+      heavy_a = described_class.new(form: :pool, content: 'a', mass: 0.7)
+      heavy_b = described_class.new(form: :pool, content: 'b', mass: 0.7)
+      heavy_a.merge!(heavy_b)
+      expect(heavy_a.mass).to eq(1.0)
+    end
+
+    it 'returns self for chaining' do
+      expect(droplet.merge!(other)).to be(droplet)
+    end
+
+    it 'averages fluidity' do
+      original_fluidity = droplet.fluidity
+      expected_fluidity = (original_fluidity + other.fluidity) / 2.0
+      droplet.merge!(other)
+      expect(droplet.fluidity).to be_within(0.001).of(expected_fluidity)
+    end
+  end
+
+  describe '#split!' do
+    context 'when mass is sufficient (> 0.2)' do
+      let(:heavy_droplet) { described_class.new(form: :droplet, content: 'big idea', mass: 0.6) }
+
+      it 'returns a twin droplet' do
+        twin = heavy_droplet.split!
+        expect(twin).to be_a(described_class)
+      end
+
+      it 'halves the original mass' do
+        heavy_droplet.split!
+        expect(heavy_droplet.mass).to be_within(0.001).of(0.3)
+      end
+
+      it 'twin has half the original mass' do
+        original_mass = heavy_droplet.mass
+        twin = heavy_droplet.split!
+        expect(twin.mass).to be_within(0.001).of(original_mass / 2.0)
+      end
+
+      it 'twin has a different id' do
+        twin = heavy_droplet.split!
+        expect(twin.id).not_to eq(heavy_droplet.id)
+      end
+
+      it 'twin inherits form and surface' do
+        twin = heavy_droplet.split!
+        expect(twin.form).to eq(heavy_droplet.form)
+        expect(twin.surface).to eq(heavy_droplet.surface)
+      end
+    end
+
+    context 'when mass is too small (<= 0.2)' do
+      let(:tiny_droplet) { described_class.new(form: :bead, content: 'tiny', mass: 0.15) }
+
+      it 'returns nil' do
+        expect(tiny_droplet.split!).to be_nil
+      end
+
+      it 'does not change the mass' do
+        original = tiny_droplet.mass
+        tiny_droplet.split!
+        expect(tiny_droplet.mass).to eq(original)
+      end
+    end
+  end
+
+  describe '#capture!' do
+    it 'sets captured to true' do
+      droplet.capture!
+      expect(droplet.captured).to be true
+    end
+
+    it 'halves the fluidity' do
+      original_fluidity = droplet.fluidity
+      droplet.capture!
+      expect(droplet.fluidity).to be_within(0.001).of(original_fluidity / 2.0)
+    end
+
+    it 'returns self' do
+      expect(droplet.capture!).to be(droplet)
+    end
+  end
+
+  describe '#release!' do
+    before { droplet.capture! }
+
+    it 'sets captured to false' do
+      droplet.release!
+      expect(droplet.captured).to be false
+    end
+
+    it 'restores fluidity (doubles it, clamped)' do
+      fluidity_after_capture = droplet.fluidity
+      droplet.release!
+      expect(droplet.fluidity).to be_within(0.001).of([fluidity_after_capture * 2.0, 1.0].min)
+    end
+
+    it 'returns self' do
+      expect(droplet.release!).to be(droplet)
+    end
+  end
+
+  describe '#evaporate!' do
+    it 'reduces mass by EVAPORATION_RATE' do
+      original_mass = droplet.mass
+      droplet.evaporate!
+      expected = original_mass - Legion::Extensions::CognitiveQuicksilver::Helpers::Constants::EVAPORATION_RATE
+      expect(droplet.mass).to be_within(0.001).of(expected)
+    end
+
+    it 'does not go below 0.0' do
+      tiny = described_class.new(form: :bead, content: 'x', mass: 0.01)
+      tiny.evaporate!
+      expect(tiny.mass).to be >= 0.0
+    end
+
+    it 'returns self' do
+      expect(droplet.evaporate!).to be(droplet)
+    end
+  end
+
+  describe '#elusive?' do
+    it 'returns true when fluidity >= 0.7 and not captured' do
+      d = described_class.new(form: :liquid, content: 'elusive', fluidity: 0.8)
+      expect(d.elusive?).to be true
+    end
+
+    it 'returns false when captured' do
+      droplet.capture!
+      expect(droplet.elusive?).to be false
+    end
+
+    it 'returns false when fluidity < 0.7' do
+      d = described_class.new(form: :pool, content: 'slow', fluidity: 0.3)
+      expect(d.elusive?).to be false
+    end
+  end
+
+  describe '#stable?' do
+    it 'returns true when captured' do
+      droplet.capture!
+      expect(droplet.stable?).to be true
+    end
+
+    it 'returns true when fluidity < 0.4' do
+      d = described_class.new(form: :pool, content: 'stable', fluidity: 0.2)
+      expect(d.stable?).to be true
+    end
+
+    it 'returns false for default high-fluidity uncaptured droplet' do
+      d = described_class.new(form: :liquid, content: 'free', fluidity: 0.8)
+      expect(d.stable?).to be false
+    end
+  end
+
+  describe '#vanishing?' do
+    it 'returns true when mass < 0.1' do
+      d = described_class.new(form: :bead, content: 'fading', mass: 0.05)
+      expect(d.vanishing?).to be true
+    end
+
+    it 'returns false for normal mass' do
+      expect(droplet.vanishing?).to be false
+    end
+  end
+
+  describe '#cohesion_label' do
+    it 'returns a symbol' do
+      expect(droplet.cohesion_label).to be_a(Symbol)
+    end
+
+    it 'returns :unified for mass 1.0' do
+      d = described_class.new(form: :pool, content: 'x', mass: 1.0)
+      expect(d.cohesion_label).to eq(:unified)
+    end
+
+    it 'returns :atomized for mass near 0.0' do
+      d = described_class.new(form: :bead, content: 'x', mass: 0.05)
+      expect(d.cohesion_label).to eq(:atomized)
+    end
+  end
+
+  describe '#fluidity_label' do
+    it 'returns a symbol' do
+      expect(droplet.fluidity_label).to be_a(Symbol)
+    end
+
+    it 'returns :liquid for fluidity 0.9' do
+      d = described_class.new(form: :liquid, content: 'x', fluidity: 0.9)
+      expect(d.fluidity_label).to eq(:liquid)
+    end
+
+    it 'returns :solid for fluidity 0.1' do
+      d = described_class.new(form: :bead, content: 'x', fluidity: 0.1)
+      expect(d.fluidity_label).to eq(:solid)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with all expected keys' do
+      h = droplet.to_h
+      expect(h.keys).to include(:id, :form, :content, :mass, :fluidity, :surface, :captured,
+                                :elusive, :stable, :vanishing, :cohesion, :fluidity_lbl, :created_at)
+    end
+
+    it 'id matches droplet id' do
+      expect(droplet.to_h[:id]).to eq(droplet.id)
+    end
+
+    it 'reflects captured state' do
+      droplet.capture!
+      expect(droplet.to_h[:captured]).to be true
+    end
+  end
+end

data/spec/legion/extensions/cognitive_quicksilver/helpers/pool_spec.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::CognitiveQuicksilver::Helpers::Pool do
+  let(:pool) { described_class.new(surface_type: :glass) }
+
+  describe '#initialize' do
+    it 'assigns a uuid id' do
+      expect(pool.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'sets surface_type' do
+      expect(pool.surface_type).to eq(:glass)
+    end
+
+    it 'defaults depth to 0.5' do
+      expect(pool.depth).to eq(0.5)
+    end
+
+    it 'starts with empty droplet_ids' do
+      expect(pool.droplet_ids).to be_empty
+    end
+
+    it 'defaults surface_tension to SURFACE_TENSION' do
+      expect(pool.surface_tension).to eq(Legion::Extensions::CognitiveQuicksilver::Helpers::Constants::SURFACE_TENSION)
+    end
+
+    it 'sets created_at' do
+      expect(pool.created_at).to be_a(Time)
+    end
+
+    it 'raises ArgumentError for invalid surface_type' do
+      expect { described_class.new(surface_type: :vapor) }.to raise_error(ArgumentError, /invalid surface_type/)
+    end
+
+    it 'clamps depth at 1.0' do
+      p = described_class.new(surface_type: :metal, depth: 1.5)
+      expect(p.depth).to eq(1.0)
+    end
+  end
+
+  describe '#add_droplet' do
+    it 'adds a droplet id' do
+      pool.add_droplet('abc-123')
+      expect(pool.droplet_ids).to include('abc-123')
+    end
+
+    it 'increases depth' do
+      original = pool.depth
+      pool.add_droplet('abc-123')
+      expect(pool.depth).to be > original
+    end
+
+    it 'does not duplicate ids' do
+      pool.add_droplet('dup-id')
+      pool.add_droplet('dup-id')
+      expect(pool.droplet_ids.count('dup-id')).to eq(1)
+    end
+
+    it 'returns self' do
+      expect(pool.add_droplet('xyz')).to be(pool)
+    end
+  end
+
+  describe '#remove_droplet' do
+    before { pool.add_droplet('remove-me') }
+
+    it 'removes the droplet id' do
+      pool.remove_droplet('remove-me')
+      expect(pool.droplet_ids).not_to include('remove-me')
+    end
+
+    it 'decreases depth' do
+      depth_before = pool.depth
+      pool.remove_droplet('remove-me')
+      expect(pool.depth).to be < depth_before
+    end
+
+    it 'does not raise when removing non-existent id' do
+      expect { pool.remove_droplet('ghost-id') }.not_to raise_error
+    end
+  end
+
+  describe '#agitate!' do
+    before do
+      5.times { |i| pool.add_droplet("droplet-#{i}") }
+      # Set low surface tension so more droplets are likely to be released
+      pool.settle!
+    end
+
+    it 'reduces surface tension' do
+      tension_before = pool.surface_tension
+      pool.agitate!
+      expect(pool.surface_tension).to be < tension_before
+    end
+
+    it 'returns an array' do
+      result = pool.agitate!
+      expect(result).to be_an(Array)
+    end
+
+    it 'does not raise when pool is empty' do
+      empty_pool = described_class.new(surface_type: :stone)
+      expect { empty_pool.agitate! }.not_to raise_error
+    end
+  end
+
+  describe '#settle!' do
+    it 'increases surface tension' do
+      pool.agitate! # lower it first
+      tension_after_agitate = pool.surface_tension
+      pool.settle!
+      expect(pool.surface_tension).to be > tension_after_agitate
+    end
+
+    it 'clamps surface tension at 1.0' do
+      high_tension_pool = described_class.new(surface_type: :glass, surface_tension: 0.99)
+      high_tension_pool.settle!
+      expect(high_tension_pool.surface_tension).to eq(1.0)
+    end
+
+    it 'returns self' do
+      expect(pool.settle!).to be(pool)
+    end
+  end
+
+  describe '#reflective?' do
+    it 'returns true when deep and high tension' do
+      deep_pool = described_class.new(surface_type: :glass, depth: 0.8, surface_tension: 0.6)
+      expect(deep_pool.reflective?).to be true
+    end
+
+    it 'returns false when shallow' do
+      shallow = described_class.new(surface_type: :glass, depth: 0.3, surface_tension: 0.8)
+      expect(shallow.reflective?).to be false
+    end
+
+    it 'returns false when low tension' do
+      tense = described_class.new(surface_type: :glass, depth: 0.9, surface_tension: 0.2)
+      expect(tense.reflective?).to be false
+    end
+  end
+
+  describe '#shallow?' do
+    it 'returns true when depth < 0.2' do
+      shallow = described_class.new(surface_type: :wood, depth: 0.1)
+      expect(shallow.shallow?).to be true
+    end
+
+    it 'returns false for normal depth' do
+      expect(pool.shallow?).to be false
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with all expected keys' do
+      h = pool.to_h
+      expect(h.keys).to include(:id, :surface_type, :depth, :droplet_ids, :droplet_count,
+                                :surface_tension, :reflective, :shallow, :created_at)
+    end
+
+    it 'reflects droplet_count' do
+      pool.add_droplet('d1')
+      pool.add_droplet('d2')
+      expect(pool.to_h[:droplet_count]).to eq(2)
+    end
+
+    it 'droplet_ids is a copy' do
+      pool.add_droplet('original')
+      h = pool.to_h
+      h[:droplet_ids] << 'injected'
+      expect(pool.droplet_ids).not_to include('injected')
+    end
+  end
+end

data/spec/legion/extensions/cognitive_quicksilver/helpers/quicksilver_engine_spec.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::CognitiveQuicksilver::Helpers::QuicksilverEngine do
+  let(:engine) { described_class.new }
+
+  describe '#create_droplet' do
+    it 'creates and stores a droplet' do
+      droplet = engine.create_droplet(form: :liquid, content: 'thought')
+      expect(droplet).to be_a(Legion::Extensions::CognitiveQuicksilver::Helpers::Droplet)
+    end
+
+    it 'accepts optional kwargs' do
+      droplet = engine.create_droplet(form: :bead, content: 'idea', mass: 0.5, surface: :metal)
+      expect(droplet.mass).to eq(0.5)
+      expect(droplet.surface).to eq(:metal)
+    end
+
+    it 'raises ArgumentError when limit reached' do
+      stub_const('Legion::Extensions::CognitiveQuicksilver::Helpers::Constants::MAX_DROPLETS', 1)
+      engine.create_droplet(form: :liquid, content: 'first')
+      expect { engine.create_droplet(form: :bead, content: 'second') }.to raise_error(ArgumentError, /limit/)
+    end
+  end
+
+  describe '#create_pool' do
+    it 'creates and stores a pool' do
+      pool = engine.create_pool(surface_type: :glass)
+      expect(pool).to be_a(Legion::Extensions::CognitiveQuicksilver::Helpers::Pool)
+    end
+
+    it 'raises ArgumentError when limit reached' do
+      stub_const('Legion::Extensions::CognitiveQuicksilver::Helpers::Constants::MAX_POOLS', 1)
+      engine.create_pool(surface_type: :glass)
+      expect { engine.create_pool(surface_type: :metal) }.to raise_error(ArgumentError, /limit/)
+    end
+  end
+
+  describe '#shift_form' do
+    let(:droplet) { engine.create_droplet(form: :droplet, content: 'shifting') }
+
+    it 'changes the droplet form' do
+      engine.shift_form(droplet_id: droplet.id, new_form: :liquid)
+      expect(droplet.form).to eq(:liquid)
+    end
+
+    it 'raises ArgumentError for unknown droplet' do
+      expect { engine.shift_form(droplet_id: 'nope', new_form: :liquid) }.to raise_error(ArgumentError, /not found/)
+    end
+  end
+
+  describe '#merge_droplets' do
+    let(:a) { engine.create_droplet(form: :droplet, content: 'a', mass: 0.3) }
+    let(:b) { engine.create_droplet(form: :liquid, content: 'b', mass: 0.2) }
+
+    it 'merges b into a' do
+      result = engine.merge_droplets(droplet_a_id: a.id, droplet_b_id: b.id)
+      expect(result.id).to eq(a.id)
+    end
+
+    it 'removes droplet b from store' do
+      b_id = b.id
+      engine.merge_droplets(droplet_a_id: a.id, droplet_b_id: b_id)
+      expect { engine.shift_form(droplet_id: b_id, new_form: :bead) }.to raise_error(ArgumentError)
+    end
+
+    it 'increases merged mass' do
+      original_a_mass = a.mass
+      engine.merge_droplets(droplet_a_id: a.id, droplet_b_id: b.id)
+      expect(a.mass).to be > original_a_mass
+    end
+  end
+
+  describe '#split_droplet' do
+    context 'when droplet is large enough' do
+      let(:big) { engine.create_droplet(form: :stream, content: 'big', mass: 0.8) }
+
+      it 'returns an array of two droplets' do
+        result = engine.split_droplet(droplet_id: big.id)
+        expect(result).to be_an(Array)
+        expect(result.length).to eq(2)
+      end
+
+      it 'adds twin to engine' do
+        result = engine.split_droplet(droplet_id: big.id)
+        twin = result[1]
+        expect { engine.shift_form(droplet_id: twin.id, new_form: :bead) }.not_to raise_error
+      end
+    end
+
+    context 'when droplet is too small' do
+      let(:tiny) { engine.create_droplet(form: :bead, content: 'tiny', mass: 0.1) }
+
+      it 'returns nil' do
+        expect(engine.split_droplet(droplet_id: tiny.id)).to be_nil
+      end
+    end
+
+    it 'raises ArgumentError for unknown droplet' do
+      expect { engine.split_droplet(droplet_id: 'unknown') }.to raise_error(ArgumentError, /not found/)
+    end
+  end
+
+  describe '#capture_droplet' do
+    let(:droplet) { engine.create_droplet(form: :liquid, content: 'free') }
+
+    it 'captures the droplet' do
+      engine.capture_droplet(droplet_id: droplet.id)
+      expect(droplet.captured).to be true
+    end
+
+    it 'raises for unknown id' do
+      expect { engine.capture_droplet(droplet_id: 'ghost') }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#release_droplet' do
+    let(:droplet) { engine.create_droplet(form: :liquid, content: 'trapped') }
+    before { engine.capture_droplet(droplet_id: droplet.id) }
+
+    it 'releases the droplet' do
+      engine.release_droplet(droplet_id: droplet.id)
+      expect(droplet.captured).to be false
+    end
+  end
+
+  describe '#add_to_pool' do
+    let(:droplet) { engine.create_droplet(form: :droplet, content: 'pooling') }
+    let(:pool)    { engine.create_pool(surface_type: :stone) }
+
+    it 'adds droplet to pool' do
+      engine.add_to_pool(droplet_id: droplet.id, pool_id: pool.id)
+      expect(pool.droplet_ids).to include(droplet.id)
+    end
+
+    it 'raises for unknown pool' do
+      expect { engine.add_to_pool(droplet_id: droplet.id, pool_id: 'ghost') }.to raise_error(ArgumentError)
+    end
+
+    it 'raises for unknown droplet' do
+      expect { engine.add_to_pool(droplet_id: 'ghost', pool_id: pool.id) }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#agitate_pool' do
+    let(:pool) { engine.create_pool(surface_type: :fabric) }
+
+    it 'returns an array of released droplet ids' do
+      result = engine.agitate_pool(pool_id: pool.id)
+      expect(result).to be_an(Array)
+    end
+
+    it 'raises for unknown pool' do
+      expect { engine.agitate_pool(pool_id: 'nope') }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#evaporate_all!' do
+    it 'reduces all droplet masses' do
+      d = engine.create_droplet(form: :droplet, content: 'evap', mass: 0.5)
+      original = d.mass
+      engine.evaporate_all!
+      expect(d.mass).to be < original
+    end
+
+    it 'removes vanishing droplets' do
+      d = engine.create_droplet(form: :bead, content: 'fading', mass: 0.05)
+      d_id = d.id
+      engine.evaporate_all!
+      expect { engine.capture_droplet(droplet_id: d_id) }.to raise_error(ArgumentError)
+    end
+
+    it 'returns array of removed ids' do
+      d = engine.create_droplet(form: :bead, content: 'ghost', mass: 0.05)
+      removed = engine.evaporate_all!
+      expect(removed).to include(d.id)
+    end
+  end
+
+  describe '#quicksilver_report' do
+    it 'returns a hash with expected keys' do
+      report = engine.quicksilver_report
+      expect(report.keys).to include(:total_droplets, :total_pools, :captured_count,
+                                     :elusive_count, :vanishing_count, :avg_mass, :avg_fluidity)
+    end
+
+    it 'counts droplets' do
+      engine.create_droplet(form: :liquid, content: 'a')
+      engine.create_droplet(form: :bead, content: 'b')
+      expect(engine.quicksilver_report[:total_droplets]).to eq(2)
+    end
+
+    it 'counts pools' do
+      engine.create_pool(surface_type: :glass)
+      expect(engine.quicksilver_report[:total_pools]).to eq(1)
+    end
+
+    it 'computes avg_mass as 0.0 when empty' do
+      expect(engine.quicksilver_report[:avg_mass]).to eq(0.0)
+    end
+
+    it 'counts captured droplets' do
+      d = engine.create_droplet(form: :liquid, content: 'captured', mass: 0.5)
+      engine.capture_droplet(droplet_id: d.id)
+      expect(engine.quicksilver_report[:captured_count]).to eq(1)
+    end
+  end
+
+  describe '#droplets' do
+    it 'returns array of droplet hashes' do
+      engine.create_droplet(form: :stream, content: 'flowing')
+      result = engine.droplets
+      expect(result).to be_an(Array)
+      expect(result.first).to be_a(Hash)
+      expect(result.first[:form]).to eq(:stream)
+    end
+  end
+
+  describe '#pools' do
+    it 'returns array of pool hashes' do
+      engine.create_pool(surface_type: :wood)
+      result = engine.pools
+      expect(result).to be_an(Array)
+      expect(result.first[:surface_type]).to eq(:wood)
+    end
+  end
+end