lex-agentic-affect 0.1.0

data/spec/legion/extensions/agentic/affect/contagion/helpers/constants_spec.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Contagion::Helpers::Constants do
+  describe 'numeric constants' do
+    it 'defines MAX_AGENTS' do
+      expect(described_class::MAX_AGENTS).to eq(200)
+    end
+
+    it 'defines MAX_MEMES' do
+      expect(described_class::MAX_MEMES).to eq(500)
+    end
+
+    it 'defines DEFAULT_VIRULENCE' do
+      expect(described_class::DEFAULT_VIRULENCE).to eq(0.3)
+    end
+
+    it 'defines DEFAULT_RESISTANCE' do
+      expect(described_class::DEFAULT_RESISTANCE).to eq(0.5)
+    end
+
+    it 'defines TRANSMISSION_RATE' do
+      expect(described_class::TRANSMISSION_RATE).to eq(0.15)
+    end
+
+    it 'defines RECOVERY_RATE' do
+      expect(described_class::RECOVERY_RATE).to eq(0.05)
+    end
+
+    it 'defines IMMUNITY_BOOST' do
+      expect(described_class::IMMUNITY_BOOST).to eq(0.1)
+    end
+  end
+
+  describe 'VIRULENCE_LABELS' do
+    let(:labels) { described_class::VIRULENCE_LABELS }
+
+    it 'maps 0.9 to pandemic' do
+      result = labels.find { |range, _| range.cover?(0.9) }&.last
+      expect(result).to eq(:pandemic)
+    end
+
+    it 'maps 0.7 to epidemic' do
+      result = labels.find { |range, _| range.cover?(0.7) }&.last
+      expect(result).to eq(:epidemic)
+    end
+
+    it 'maps 0.5 to endemic' do
+      result = labels.find { |range, _| range.cover?(0.5) }&.last
+      expect(result).to eq(:endemic)
+    end
+
+    it 'maps 0.3 to sporadic' do
+      result = labels.find { |range, _| range.cover?(0.3) }&.last
+      expect(result).to eq(:sporadic)
+    end
+
+    it 'maps 0.1 to contained' do
+      result = labels.find { |range, _| range.cover?(0.1) }&.last
+      expect(result).to eq(:contained)
+    end
+
+    it 'is frozen' do
+      expect(labels).to be_frozen
+    end
+  end
+
+  describe 'STATUS_LABELS' do
+    it 'contains all five states' do
+      expect(described_class::STATUS_LABELS).to eq(%i[susceptible exposed infected recovered immune])
+    end
+
+    it 'is frozen' do
+      expect(described_class::STATUS_LABELS).to be_frozen
+    end
+  end
+
+  describe 'CONTAGION_TYPES' do
+    it 'contains four types' do
+      expect(described_class::CONTAGION_TYPES).to eq(%i[emotional belief behavioral cognitive])
+    end
+
+    it 'is frozen' do
+      expect(described_class::CONTAGION_TYPES).to be_frozen
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/contagion/helpers/contagion_engine_spec.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Contagion::Helpers::ContagionEngine do
+  subject(:engine) { described_class.new }
+
+  let(:meme)    { engine.create_meme(label: 'panic', contagion_type: :emotional, virulence: 0.9) }
+  let(:meme_id) { meme.id }
+
+  before do
+    engine.register_agent(agent_id: 'alice', resistance: 0.0)
+    engine.register_agent(agent_id: 'bob',   resistance: 0.0)
+    engine.register_agent(agent_id: 'carol', resistance: 0.0)
+  end
+
+  describe '#create_meme' do
+    it 'returns a Meme object' do
+      expect(meme).to be_a(Legion::Extensions::Agentic::Affect::Contagion::Helpers::Meme)
+    end
+
+    it 'stores the meme in the engine' do
+      expect(engine.memes[meme_id]).to eq(meme)
+    end
+
+    it 'applies default virulence when not specified' do
+      m = engine.create_meme(label: 'quiet')
+      expect(m.virulence).to eq(Legion::Extensions::Agentic::Affect::Contagion::Helpers::Constants::DEFAULT_VIRULENCE)
+    end
+  end
+
+  describe '#register_agent' do
+    it 'stores agent resistance' do
+      expect(engine.agent_resistance['alice']).to eq(0.0)
+    end
+
+    it 'clamps resistance to [0,1]' do
+      engine.register_agent(agent_id: 'dave', resistance: 2.0)
+      expect(engine.agent_resistance['dave']).to eq(1.0)
+    end
+
+    it 'applies default resistance when not specified' do
+      engine.register_agent(agent_id: 'eve')
+      expect(engine.agent_resistance['eve']).to eq(
+        Legion::Extensions::Agentic::Affect::Contagion::Helpers::Constants::DEFAULT_RESISTANCE
+      )
+    end
+  end
+
+  describe '#attempt_transmission' do
+    before { meme.infect!(agent_id: 'alice') }
+
+    it 'returns meme_not_found for unknown meme' do
+      result = engine.attempt_transmission(meme_id: 'bad-id', source_agent_id: 'alice',
+                                           target_agent_id: 'bob')
+      expect(result[:reason]).to eq(:meme_not_found)
+    end
+
+    it 'returns source_not_carrying if source does not carry' do
+      result = engine.attempt_transmission(meme_id: meme_id, source_agent_id: 'bob',
+                                           target_agent_id: 'carol')
+      expect(result[:reason]).to eq(:source_not_carrying)
+    end
+
+    it 'includes probability in result' do
+      result = engine.attempt_transmission(meme_id: meme_id, source_agent_id: 'alice',
+                                           target_agent_id: 'bob')
+      expect(result[:probability]).to be_a(Float)
+      expect(result[:probability]).to be >= 0.0
+    end
+
+    it 'transmits with probability approaching 1.0 at max virulence and zero resistance' do
+      transmitted = (1..100).count do
+        e = described_class.new
+        e.register_agent(agent_id: 'src', resistance: 0.0)
+        e.register_agent(agent_id: 'tgt', resistance: 0.0)
+        m = e.create_meme(label: 'x', virulence: 1.0)
+        m.infect!(agent_id: 'src')
+        r = e.attempt_transmission(meme_id: m.id, source_agent_id: 'src', target_agent_id: 'tgt')
+        r[:transmitted]
+      end
+      expect(transmitted).to be > 0
+    end
+  end
+
+  describe '#recover_agent' do
+    before { meme.infect!(agent_id: 'alice') }
+
+    it 'recovers the agent from the meme' do
+      result = engine.recover_agent(meme_id: meme_id, agent_id: 'alice')
+      expect(result[:recovered]).to be true
+    end
+
+    it 'boosts agent resistance after recovery' do
+      before_resistance = engine.agent_resistance['alice']
+      engine.recover_agent(meme_id: meme_id, agent_id: 'alice')
+      expect(engine.agent_resistance['alice']).to be > before_resistance
+    end
+
+    it 'returns meme_not_found for unknown meme' do
+      result = engine.recover_agent(meme_id: 'bad-id', agent_id: 'alice')
+      expect(result[:recovered]).to be false
+      expect(result[:reason]).to eq(:meme_not_found)
+    end
+  end
+
+  describe '#immunize_agent' do
+    it 'immunizes the agent' do
+      result = engine.immunize_agent(meme_id: meme_id, agent_id: 'alice')
+      expect(result[:immunized]).to be true
+    end
+
+    it 'prevents future infection' do
+      engine.immunize_agent(meme_id: meme_id, agent_id: 'alice')
+      infect_result = meme.infect!(agent_id: 'alice')
+      expect(infect_result).to eq(:immune)
+    end
+  end
+
+  describe '#spread_step' do
+    before { meme.infect!(agent_id: 'alice') }
+
+    it 'returns a result hash with transmissions key' do
+      result = engine.spread_step(meme_id: meme_id)
+      expect(result).to have_key(:transmissions)
+    end
+
+    it 'returns meme_not_found for unknown meme' do
+      result = engine.spread_step(meme_id: 'bad-id')
+      expect(result[:reason]).to eq(:meme_not_found)
+    end
+
+    it 'tracks carrier_count in result' do
+      result = engine.spread_step(meme_id: meme_id)
+      expect(result[:carrier_count]).to be_a(Integer)
+    end
+  end
+
+  describe '#epidemic_report' do
+    before { meme.infect!(agent_id: 'alice') }
+
+    it 'returns SIR counts' do
+      report = engine.epidemic_report(meme_id: meme_id)
+      expect(report[:infected]).to eq(1)
+      expect(report[:susceptible]).to be >= 0
+    end
+
+    it 'includes virulence_label' do
+      report = engine.epidemic_report(meme_id: meme_id)
+      expect(report[:virulence_label]).to eq(:pandemic)
+    end
+
+    it 'returns meme_not_found for unknown meme' do
+      result = engine.epidemic_report(meme_id: 'bad-id')
+      expect(result[:error]).to eq(:meme_not_found)
+    end
+  end
+
+  describe '#most_viral' do
+    before do
+      engine.create_meme(label: 'high',   virulence: 0.9)
+      engine.create_meme(label: 'medium', virulence: 0.5)
+      engine.create_meme(label: 'low',    virulence: 0.1)
+    end
+
+    it 'returns hashes sorted by virulence descending' do
+      results = engine.most_viral(limit: 3)
+      virulences = results.map { |m| m[:virulence] }
+      expect(virulences).to eq(virulences.sort.reverse)
+    end
+
+    it 'respects the limit' do
+      results = engine.most_viral(limit: 2)
+      expect(results.size).to be <= 2
+    end
+  end
+
+  describe '#agent_status' do
+    it 'returns susceptible for uninfected agent' do
+      result = engine.agent_status(agent_id: 'bob', meme_id: meme_id)
+      expect(result[:status]).to eq(:susceptible)
+    end
+
+    it 'returns infected for carrying agent' do
+      meme.infect!(agent_id: 'bob')
+      result = engine.agent_status(agent_id: 'bob', meme_id: meme_id)
+      expect(result[:status]).to eq(:infected)
+    end
+
+    it 'returns recovered for recovered agent' do
+      meme.infect!(agent_id: 'bob')
+      meme.recover!(agent_id: 'bob')
+      result = engine.agent_status(agent_id: 'bob', meme_id: meme_id)
+      expect(result[:status]).to eq(:recovered)
+    end
+
+    it 'returns immune for immunized agent' do
+      engine.immunize_agent(meme_id: meme_id, agent_id: 'bob')
+      result = engine.agent_status(agent_id: 'bob', meme_id: meme_id)
+      expect(result[:status]).to eq(:immune)
+    end
+
+    it 'returns unknown with meme_not_found for bad meme id' do
+      result = engine.agent_status(agent_id: 'bob', meme_id: 'bad-id')
+      expect(result[:status]).to eq(:unknown)
+    end
+  end
+
+  describe '#susceptible_agents' do
+    it 'returns all agents when no one is infected or immune' do
+      agents = engine.susceptible_agents(meme_id: meme_id)
+      expect(agents).to match_array(%w[alice bob carol])
+    end
+
+    it 'excludes carriers' do
+      meme.infect!(agent_id: 'alice')
+      agents = engine.susceptible_agents(meme_id: meme_id)
+      expect(agents).not_to include('alice')
+    end
+
+    it 'excludes immune agents' do
+      engine.immunize_agent(meme_id: meme_id, agent_id: 'bob')
+      agents = engine.susceptible_agents(meme_id: meme_id)
+      expect(agents).not_to include('bob')
+    end
+
+    it 'returns empty array for unknown meme' do
+      expect(engine.susceptible_agents(meme_id: 'bad-id')).to eq([])
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns meme_count and agent_count' do
+      h = engine.to_h
+      expect(h[:meme_count]).to eq(engine.memes.size)
+      expect(h[:agent_count]).to eq(engine.agent_resistance.size)
+    end
+
+    it 'includes memes array' do
+      expect(engine.to_h[:memes]).to be_an(Array)
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/contagion/helpers/meme_spec.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Contagion::Helpers::Meme do
+  subject(:meme) { described_class.new(label: 'test-meme', contagion_type: :belief, virulence: 0.6) }
+
+  describe '#initialize' do
+    it 'assigns a uuid id' do
+      expect(meme.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores the label' do
+      expect(meme.label).to eq('test-meme')
+    end
+
+    it 'stores the contagion_type' do
+      expect(meme.contagion_type).to eq(:belief)
+    end
+
+    it 'clamps virulence to [0,1]' do
+      m = described_class.new(label: 'x', virulence: 1.5)
+      expect(m.virulence).to eq(1.0)
+    end
+
+    it 'clamps virulence lower bound' do
+      m = described_class.new(label: 'x', virulence: -0.5)
+      expect(m.virulence).to eq(0.0)
+    end
+
+    it 'starts with empty carrier set' do
+      expect(meme.carriers).to be_empty
+    end
+
+    it 'starts with empty recovered set' do
+      expect(meme.recovered).to be_empty
+    end
+
+    it 'starts with empty immune set' do
+      expect(meme.immune).to be_empty
+    end
+
+    it 'starts with zero total_transmissions' do
+      expect(meme.total_transmissions).to eq(0)
+    end
+
+    it 'defaults unknown contagion_type to :cognitive' do
+      m = described_class.new(label: 'x', contagion_type: :invalid)
+      expect(m.contagion_type).to eq(:cognitive)
+    end
+  end
+
+  describe '#virulence_label' do
+    it 'returns :epidemic for 0.6' do
+      expect(meme.virulence_label).to eq(:epidemic)
+    end
+
+    it 'returns :pandemic for 0.9' do
+      m = described_class.new(label: 'x', virulence: 0.9)
+      expect(m.virulence_label).to eq(:pandemic)
+    end
+
+    it 'returns :contained for 0.1' do
+      m = described_class.new(label: 'x', virulence: 0.1)
+      expect(m.virulence_label).to eq(:contained)
+    end
+  end
+
+  describe '#infect!' do
+    it 'adds agent to carriers and returns :infected' do
+      result = meme.infect!(agent_id: 'agent-1')
+      expect(result).to eq(:infected)
+      expect(meme.carriers).to include('agent-1')
+    end
+
+    it 'returns :already_carrier for a second infect call' do
+      meme.infect!(agent_id: 'agent-1')
+      expect(meme.infect!(agent_id: 'agent-1')).to eq(:already_carrier)
+    end
+
+    it 'returns :immune if agent is immune' do
+      meme.immunize!(agent_id: 'agent-1')
+      expect(meme.infect!(agent_id: 'agent-1')).to eq(:immune)
+    end
+
+    it 'increments total_transmissions' do
+      meme.infect!(agent_id: 'agent-1')
+      expect(meme.total_transmissions).to eq(1)
+    end
+  end
+
+  describe '#recover!' do
+    before { meme.infect!(agent_id: 'agent-1') }
+
+    it 'removes from carriers and adds to recovered' do
+      result = meme.recover!(agent_id: 'agent-1')
+      expect(result).to eq(:recovered)
+      expect(meme.carriers).not_to include('agent-1')
+      expect(meme.recovered).to include('agent-1')
+    end
+
+    it 'returns :not_a_carrier if not carrying' do
+      expect(meme.recover!(agent_id: 'nobody')).to eq(:not_a_carrier)
+    end
+  end
+
+  describe '#immunize!' do
+    it 'adds to immune set' do
+      meme.immunize!(agent_id: 'agent-1')
+      expect(meme.immune).to include('agent-1')
+    end
+
+    it 'removes from carriers if carrying' do
+      meme.infect!(agent_id: 'agent-1')
+      meme.immunize!(agent_id: 'agent-1')
+      expect(meme.carriers).not_to include('agent-1')
+    end
+  end
+
+  describe '#carrying?' do
+    it 'returns true when agent is a carrier' do
+      meme.infect!(agent_id: 'agent-1')
+      expect(meme.carrying?(agent_id: 'agent-1')).to be true
+    end
+
+    it 'returns false when agent is not a carrier' do
+      expect(meme.carrying?(agent_id: 'nobody')).to be false
+    end
+  end
+
+  describe '#carrier_count' do
+    it 'returns zero initially' do
+      expect(meme.carrier_count).to eq(0)
+    end
+
+    it 'returns count after infection' do
+      meme.infect!(agent_id: 'a')
+      meme.infect!(agent_id: 'b')
+      expect(meme.carrier_count).to eq(2)
+    end
+  end
+
+  describe '#transmission_rate' do
+    it 'returns 0.0 with no carriers' do
+      expect(meme.transmission_rate).to eq(0.0)
+    end
+
+    it 'returns ratio of transmissions to carriers' do
+      meme.infect!(agent_id: 'a')
+      expect(meme.transmission_rate).to be > 0.0
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with expected keys' do
+      h = meme.to_h
+      expect(h.keys).to include(:id, :label, :contagion_type, :virulence, :virulence_label,
+                                :carrier_count, :recovered_count, :immune_count,
+                                :total_transmissions, :transmission_rate, :created_at)
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/contagion/runners/cognitive_contagion_spec.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/affect/contagion/client'
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Contagion::Runners::CognitiveContagion do
+  let(:client) { Legion::Extensions::Agentic::Affect::Contagion::Client.new }
+
+  let(:meme_result) { client.create_meme(label: 'test-meme', contagion_type: :belief, virulence: 0.7) }
+  let(:meme_id)     { meme_result[:id] }
+
+  before do
+    client.register_agent(agent_id: 'alice', resistance: 0.0)
+    client.register_agent(agent_id: 'bob',   resistance: 0.0)
+    client.register_agent(agent_id: 'carol', resistance: 0.8)
+  end
+
+  describe '#create_meme' do
+    it 'returns a hash with id' do
+      expect(meme_result[:id]).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'returns the label' do
+      expect(meme_result[:label]).to eq('test-meme')
+    end
+
+    it 'returns virulence_label' do
+      expect(meme_result[:virulence_label]).to eq(:epidemic)
+    end
+
+    it 'uses default virulence when not provided' do
+      result = client.create_meme(label: 'quiet')
+      expect(result[:virulence]).to eq(Legion::Extensions::Agentic::Affect::Contagion::Helpers::Constants::DEFAULT_VIRULENCE)
+    end
+  end
+
+  describe '#register_agent' do
+    it 'returns agent_id and resistance' do
+      result = client.register_agent(agent_id: 'dave', resistance: 0.3)
+      expect(result[:agent_id]).to eq('dave')
+      expect(result[:resistance]).to eq(0.3)
+    end
+
+    it 'uses default resistance when not provided' do
+      result = client.register_agent(agent_id: 'eve')
+      expect(result[:resistance]).to eq(
+        Legion::Extensions::Agentic::Affect::Contagion::Helpers::Constants::DEFAULT_RESISTANCE
+      )
+    end
+  end
+
+  describe '#infect_agent' do
+    it 'infects the agent and returns infected: true' do
+      result = client.infect_agent(meme_id: meme_id, agent_id: 'alice')
+      expect(result[:infected]).to be true
+      expect(result[:result]).to eq(:infected)
+    end
+
+    it 'returns already_carrier on second call' do
+      client.infect_agent(meme_id: meme_id, agent_id: 'alice')
+      result = client.infect_agent(meme_id: meme_id, agent_id: 'alice')
+      expect(result[:result]).to eq(:already_carrier)
+    end
+
+    it 'returns meme_not_found for unknown meme' do
+      result = client.infect_agent(meme_id: 'bad-id', agent_id: 'alice')
+      expect(result[:infected]).to be false
+      expect(result[:reason]).to eq(:meme_not_found)
+    end
+  end
+
+  describe '#attempt_transmission' do
+    before { client.infect_agent(meme_id: meme_id, agent_id: 'alice') }
+
+    it 'returns a result with transmitted key' do
+      result = client.attempt_transmission(meme_id: meme_id, source_agent_id: 'alice',
+                                           target_agent_id: 'bob')
+      expect(result).to have_key(:transmitted)
+    end
+
+    it 'returns meme_not_found for unknown meme' do
+      result = client.attempt_transmission(meme_id: 'bad', source_agent_id: 'alice',
+                                           target_agent_id: 'bob')
+      expect(result[:reason]).to eq(:meme_not_found)
+    end
+  end
+
+  describe '#recover_agent' do
+    before { client.infect_agent(meme_id: meme_id, agent_id: 'alice') }
+
+    it 'returns recovered true' do
+      result = client.recover_agent(meme_id: meme_id, agent_id: 'alice')
+      expect(result[:recovered]).to be true
+    end
+
+    it 'handles unknown meme gracefully' do
+      result = client.recover_agent(meme_id: 'bad', agent_id: 'alice')
+      expect(result[:recovered]).to be false
+    end
+  end
+
+  describe '#immunize_agent' do
+    it 'returns immunized true' do
+      result = client.immunize_agent(meme_id: meme_id, agent_id: 'alice')
+      expect(result[:immunized]).to be true
+    end
+  end
+
+  describe '#spread_step' do
+    before { client.infect_agent(meme_id: meme_id, agent_id: 'alice') }
+
+    it 'returns a hash with transmissions' do
+      result = client.spread_step(meme_id: meme_id)
+      expect(result).to have_key(:transmissions)
+      expect(result[:transmissions]).to be_a(Integer)
+    end
+
+    it 'returns meme_not_found reason for bad meme' do
+      result = client.spread_step(meme_id: 'bad')
+      expect(result[:reason]).to eq(:meme_not_found)
+    end
+  end
+
+  describe '#epidemic_report' do
+    before { client.infect_agent(meme_id: meme_id, agent_id: 'alice') }
+
+    it 'returns SIR statistics' do
+      report = client.epidemic_report(meme_id: meme_id)
+      expect(report[:infected]).to eq(1)
+      expect(report[:susceptible]).to be >= 0
+      expect(report[:recovered]).to eq(0)
+    end
+
+    it 'includes virulence_label' do
+      report = client.epidemic_report(meme_id: meme_id)
+      expect(report).to have_key(:virulence_label)
+    end
+  end
+
+  describe '#most_viral' do
+    before do
+      client.create_meme(label: 'high',   virulence: 0.95)
+      client.create_meme(label: 'low',    virulence: 0.05)
+    end
+
+    it 'returns a hash with memes array' do
+      result = client.most_viral
+      expect(result[:memes]).to be_an(Array)
+    end
+
+    it 'returns count of memes' do
+      result = client.most_viral(limit: 2)
+      expect(result[:count]).to be <= 2
+    end
+
+    it 'sorts by virulence descending' do
+      result = client.most_viral
+      virulences = result[:memes].map { |m| m[:virulence] }
+      expect(virulences).to eq(virulences.sort.reverse)
+    end
+  end
+
+  describe '#agent_status' do
+    it 'returns susceptible for uninfected registered agent' do
+      result = client.agent_status(agent_id: 'bob', meme_id: meme_id)
+      expect(result[:status]).to eq(:susceptible)
+    end
+
+    it 'returns infected after infection' do
+      client.infect_agent(meme_id: meme_id, agent_id: 'bob')
+      result = client.agent_status(agent_id: 'bob', meme_id: meme_id)
+      expect(result[:status]).to eq(:infected)
+    end
+
+    it 'returns immune after immunization' do
+      client.immunize_agent(meme_id: meme_id, agent_id: 'carol')
+      result = client.agent_status(agent_id: 'carol', meme_id: meme_id)
+      expect(result[:status]).to eq(:immune)
+    end
+  end
+
+  describe '#susceptible_agents' do
+    it 'returns agents and count' do
+      result = client.susceptible_agents(meme_id: meme_id)
+      expect(result[:agents]).to be_an(Array)
+      expect(result[:count]).to eq(result[:agents].size)
+    end
+
+    it 'returns meme_id in result' do
+      result = client.susceptible_agents(meme_id: meme_id)
+      expect(result[:meme_id]).to eq(meme_id)
+    end
+  end
+
+  describe '#contagion_status' do
+    it 'returns meme_count and agent_count' do
+      result = client.contagion_status
+      expect(result[:meme_count]).to be_a(Integer)
+      expect(result[:agent_count]).to be_a(Integer)
+    end
+
+    it 'returns contagion_types list' do
+      expect(client.contagion_status[:contagion_types]).to eq(%i[emotional belief behavioral cognitive])
+    end
+
+    it 'returns max_agents and max_memes' do
+      result = client.contagion_status
+      expect(result[:max_agents]).to eq(200)
+      expect(result[:max_memes]).to eq(500)
+    end
+  end
+end