lex-agentic-affect 0.1.0

data/spec/legion/extensions/agentic/affect/cognitive_empathy/helpers/empathy_engine_spec.rb

@@ -0,0 +1,316 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::CognitiveEmpathy::Helpers::EmpathyEngine do
+  subject(:engine) { described_class.new }
+
+  describe '#initialize' do
+    it 'starts with empty perspectives' do
+      expect(engine.perspectives).to be_empty
+    end
+
+    it 'starts with zero contagion level' do
+      expect(engine.contagion_level).to eq(0.0)
+    end
+
+    it 'starts with empty history' do
+      expect(engine.history).to be_empty
+    end
+  end
+
+  describe '#take_perspective' do
+    it 'creates and stores a perspective' do
+      p = engine.take_perspective(
+        agent_id:         :alice,
+        perspective_type: :cognitive,
+        predicted_state:  { valence: 0.6 },
+        confidence:       0.7
+      )
+      expect(p).to be_a(Legion::Extensions::Agentic::Affect::CognitiveEmpathy::Helpers::Perspective)
+      expect(engine.perspectives.size).to eq(1)
+    end
+
+    it 'returns nil for invalid perspective_type' do
+      result = engine.take_perspective(
+        agent_id:         :alice,
+        perspective_type: :bogus,
+        predicted_state:  {},
+        confidence:       0.5
+      )
+      expect(result).to be_nil
+    end
+
+    it 'enforces MAX_PERSPECTIVES limit' do
+      50.times do |i|
+        engine.take_perspective(
+          agent_id:         :"agent_#{i}",
+          perspective_type: :cognitive,
+          predicted_state:  {},
+          confidence:       0.5
+        )
+      end
+      result = engine.take_perspective(
+        agent_id:         :overflow,
+        perspective_type: :cognitive,
+        predicted_state:  {},
+        confidence:       0.5
+      )
+      expect(result).to be_nil
+    end
+
+    it 'records event in history' do
+      engine.take_perspective(
+        agent_id:         :bob,
+        perspective_type: :affective,
+        predicted_state:  {},
+        confidence:       0.5
+      )
+      expect(engine.history.size).to eq(1)
+    end
+
+    it 'assigns unique ids' do
+      p1 = engine.take_perspective(
+        agent_id:         :a,
+        perspective_type: :cognitive,
+        predicted_state:  {},
+        confidence:       0.5
+      )
+      p2 = engine.take_perspective(
+        agent_id:         :b,
+        perspective_type: :cognitive,
+        predicted_state:  {},
+        confidence:       0.5
+      )
+      expect(p1.id).not_to eq(p2.id)
+    end
+  end
+
+  describe '#record_outcome' do
+    it 'updates the perspective with actual state' do
+      p = engine.take_perspective(
+        agent_id:         :carol,
+        perspective_type: :cognitive,
+        predicted_state:  { valence: 0.7 },
+        confidence:       0.8
+      )
+      perspective_id = p.id
+      result = engine.record_outcome(perspective_id: perspective_id, actual_state: { valence: 0.7 })
+      expect(result).to be_a(Legion::Extensions::Agentic::Affect::CognitiveEmpathy::Helpers::Perspective)
+      expect(result.resolved?).to be true
+    end
+
+    it 'returns nil for unknown perspective_id' do
+      result = engine.record_outcome(perspective_id: :bogus_id, actual_state: {})
+      expect(result).to be_nil
+    end
+
+    it 'records event in history' do
+      p = engine.take_perspective(
+        agent_id:         :dave,
+        perspective_type: :motivational,
+        predicted_state:  {},
+        confidence:       0.5
+      )
+      perspective_id = p.id
+      engine.record_outcome(perspective_id: perspective_id, actual_state: {})
+      expect(engine.history.size).to eq(2)
+    end
+  end
+
+  describe '#empathic_accuracy' do
+    it 'returns default accuracy when no resolved perspectives exist' do
+      engine.take_perspective(
+        agent_id:         :eve,
+        perspective_type: :cognitive,
+        predicted_state:  {},
+        confidence:       0.5
+      )
+      acc = engine.empathic_accuracy(agent_id: :eve)
+      expect(acc).to eq(Legion::Extensions::Agentic::Affect::CognitiveEmpathy::Helpers::Constants::DEFAULT_ACCURACY)
+    end
+
+    it 'returns average accuracy for resolved perspectives' do
+      p = engine.take_perspective(
+        agent_id:         :frank,
+        perspective_type: :cognitive,
+        predicted_state:  { v: 0.5 },
+        confidence:       0.8
+      )
+      perspective_id = p.id
+      engine.record_outcome(perspective_id: perspective_id, actual_state: { v: 0.5 })
+      acc = engine.empathic_accuracy(agent_id: :frank)
+      expect(acc).to be_a(Float)
+      expect(acc).to be > 0.0
+    end
+
+    it 'returns default for unknown agent' do
+      acc = engine.empathic_accuracy(agent_id: :nobody)
+      expect(acc).to eq(Legion::Extensions::Agentic::Affect::CognitiveEmpathy::Helpers::Constants::DEFAULT_ACCURACY)
+    end
+  end
+
+  describe '#overall_accuracy' do
+    it 'returns default when no resolved perspectives' do
+      expect(engine.overall_accuracy).to eq(
+        Legion::Extensions::Agentic::Affect::CognitiveEmpathy::Helpers::Constants::DEFAULT_ACCURACY
+      )
+    end
+
+    it 'returns average across all agents after outcomes recorded' do
+      p1 = engine.take_perspective(
+        agent_id: :g, perspective_type: :cognitive, predicted_state: { v: 0.5 }, confidence: 0.8
+      )
+      p2 = engine.take_perspective(
+        agent_id: :h, perspective_type: :affective, predicted_state: { v: 0.5 }, confidence: 0.8
+      )
+      engine.record_outcome(perspective_id: p1.id, actual_state: { v: 0.5 })
+      engine.record_outcome(perspective_id: p2.id, actual_state: { v: 0.5 })
+      expect(engine.overall_accuracy).to be > 0.5
+    end
+  end
+
+  describe '#emotional_contagion' do
+    it 'increases contagion_level' do
+      engine.emotional_contagion(emotion_valence: 0.8, intensity: 1.0)
+      expect(engine.contagion_level).to be > 0.0
+    end
+
+    it 'clamps intensity to 0..1' do
+      engine.emotional_contagion(emotion_valence: 0.5, intensity: 5.0)
+      expect(engine.contagion_level).to be <= 1.0
+    end
+
+    it 'records event in history' do
+      engine.emotional_contagion(emotion_valence: 0.5, intensity: 0.5)
+      expect(engine.history).not_to be_empty
+    end
+
+    it 'returns the new contagion level' do
+      level = engine.emotional_contagion(emotion_valence: 0.5, intensity: 0.5)
+      expect(level).to be_a(Float)
+      expect(level).to be > 0.0
+    end
+  end
+
+  describe '#contagion_decay' do
+    it 'reduces contagion_level' do
+      engine.emotional_contagion(emotion_valence: 0.8, intensity: 1.0)
+      before = engine.contagion_level
+      engine.contagion_decay
+      expect(engine.contagion_level).to be < before
+    end
+
+    it 'does not go below 0' do
+      engine.contagion_decay
+      expect(engine.contagion_level).to eq(0.0)
+    end
+  end
+
+  describe '#empathic_state' do
+    it 'returns :detached when contagion is near zero' do
+      expect(engine.empathic_state).to eq(:detached)
+    end
+
+    it 'returns :observing when contagion is moderate' do
+      10.times { engine.emotional_contagion(emotion_valence: 0.5, intensity: 0.3) }
+      state = engine.empathic_state
+      expect(%i[observing resonating immersed detached]).to include(state)
+    end
+
+    it 'returns :immersed when contagion is very high' do
+      100.times { engine.emotional_contagion(emotion_valence: 0.9, intensity: 1.0) }
+      expect(engine.empathic_state).to eq(:immersed)
+    end
+
+    it 'returns :resonating at mid-range contagion' do
+      # Manually set by absorbing enough
+      50.times { engine.emotional_contagion(emotion_valence: 0.5, intensity: 0.7) }
+      state = engine.empathic_state
+      expect(%i[resonating immersed]).to include(state)
+    end
+  end
+
+  describe '#perspectives_for' do
+    it 'returns perspectives matching agent_id' do
+      engine.take_perspective(
+        agent_id:         :ivan,
+        perspective_type: :cognitive,
+        predicted_state:  {},
+        confidence:       0.5
+      )
+      engine.take_perspective(
+        agent_id:         :jane,
+        perspective_type: :affective,
+        predicted_state:  {},
+        confidence:       0.5
+      )
+      results = engine.perspectives_for(agent_id: :ivan)
+      expect(results.size).to eq(1)
+      expect(results.first.agent_id).to eq(:ivan)
+    end
+
+    it 'returns empty array for unknown agent' do
+      expect(engine.perspectives_for(agent_id: :nobody)).to be_empty
+    end
+  end
+
+  describe '#most_accurate_agent and #least_accurate_agent' do
+    it 'returns nil when no resolved perspectives exist' do
+      expect(engine.most_accurate_agent).to be_nil
+      expect(engine.least_accurate_agent).to be_nil
+    end
+
+    context 'with resolved perspectives for two agents' do
+      before do
+        # Agent A: perfect prediction
+        pa = engine.take_perspective(
+          agent_id: :agent_a, perspective_type: :cognitive,
+          predicted_state: { v: 0.5 }, confidence: 0.9
+        )
+        engine.record_outcome(perspective_id: pa.id, actual_state: { v: 0.5 })
+
+        # Agent B: terrible prediction
+        pb = engine.take_perspective(
+          agent_id: :agent_b, perspective_type: :cognitive,
+          predicted_state: { v: 1.0 }, confidence: 0.9
+        )
+        engine.record_outcome(perspective_id: pb.id, actual_state: { v: 0.0 })
+      end
+
+      it 'identifies most accurate agent' do
+        expect(engine.most_accurate_agent).to eq(:agent_a)
+      end
+
+      it 'identifies least accurate agent' do
+        expect(engine.least_accurate_agent).to eq(:agent_b)
+      end
+    end
+  end
+
+  describe '#tick' do
+    it 'decays contagion level' do
+      engine.emotional_contagion(emotion_valence: 0.5, intensity: 1.0)
+      before = engine.contagion_level
+      engine.tick
+      expect(engine.contagion_level).to be < before
+    end
+
+    it 'returns self' do
+      expect(engine.tick).to be(engine)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns expected keys' do
+      h = engine.to_h
+      expect(h).to include(
+        :perspective_count, :resolved_count, :overall_accuracy,
+        :contagion_level, :empathic_state, :history_size
+      )
+    end
+
+    it 'rounds overall_accuracy to 4 places' do
+      h = engine.to_h
+      expect(h[:overall_accuracy]).to be_a(Float)
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/cognitive_empathy/helpers/perspective_spec.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::CognitiveEmpathy::Helpers::Perspective do
+  subject(:perspective) do
+    described_class.new(
+      id:               :persp_one,
+      agent_id:         :agent_a,
+      perspective_type: :cognitive,
+      predicted_state:  { valence: 0.7, arousal: 0.5 },
+      confidence:       0.8
+    )
+  end
+
+  describe '#initialize' do
+    it 'sets id' do
+      expect(perspective.id).to eq(:persp_one)
+    end
+
+    it 'sets agent_id' do
+      expect(perspective.agent_id).to eq(:agent_a)
+    end
+
+    it 'sets perspective_type' do
+      expect(perspective.perspective_type).to eq(:cognitive)
+    end
+
+    it 'sets predicted_state' do
+      expect(perspective.predicted_state).to eq({ valence: 0.7, arousal: 0.5 })
+    end
+
+    it 'sets confidence' do
+      expect(perspective.confidence).to eq(0.8)
+    end
+
+    it 'clamps confidence to 0..1' do
+      p = described_class.new(id: :x, agent_id: :a, confidence: 1.5)
+      expect(p.confidence).to eq(1.0)
+    end
+
+    it 'starts with nil actual_state' do
+      expect(perspective.actual_state).to be_nil
+    end
+
+    it 'starts with default accuracy' do
+      expect(perspective.accuracy).to eq(Legion::Extensions::Agentic::Affect::CognitiveEmpathy::Helpers::Constants::DEFAULT_ACCURACY)
+    end
+
+    it 'is not resolved initially' do
+      expect(perspective.resolved?).to be false
+    end
+  end
+
+  describe '#record_actual' do
+    context 'when prediction matches well' do
+      it 'increases accuracy above default' do
+        perspective.record_actual(actual_state: { valence: 0.7, arousal: 0.5 })
+        expect(perspective.accuracy).to be > 0.5
+      end
+    end
+
+    context 'when prediction is off' do
+      it 'lowers accuracy below default' do
+        perspective.record_actual(actual_state: { valence: 0.0, arousal: 0.0 })
+        expect(perspective.accuracy).to be < 0.5
+      end
+    end
+
+    it 'sets actual_state' do
+      actual = { valence: 0.6, arousal: 0.4 }
+      perspective.record_actual(actual_state: actual)
+      expect(perspective.actual_state).to eq(actual)
+    end
+
+    it 'marks as resolved' do
+      perspective.record_actual(actual_state: { valence: 0.6 })
+      expect(perspective.resolved?).to be true
+    end
+
+    it 'returns self for chaining' do
+      result = perspective.record_actual(actual_state: {})
+      expect(result).to be(perspective)
+    end
+
+    it 'clamps accuracy to floor' do
+      p = described_class.new(id: :x, agent_id: :a, predicted_state: { v: 1.0 })
+      100.times { p.record_actual(actual_state: { v: 0.0 }) }
+      expect(p.accuracy).to be >= Legion::Extensions::Agentic::Affect::CognitiveEmpathy::Helpers::Constants::ACCURACY_FLOOR
+    end
+
+    it 'clamps accuracy to ceiling' do
+      p = described_class.new(id: :x, agent_id: :a, predicted_state: { v: 0.5 })
+      100.times { p.record_actual(actual_state: { v: 0.5 }) }
+      expect(p.accuracy).to be <= Legion::Extensions::Agentic::Affect::CognitiveEmpathy::Helpers::Constants::ACCURACY_CEILING
+    end
+  end
+
+  describe '#accurate?' do
+    it 'returns false at default accuracy (0.5)' do
+      expect(perspective.accurate?).to be false
+    end
+
+    it 'returns true when accuracy is above 0.6 after repeated correct predictions' do
+      p = described_class.new(id: :y, agent_id: :b, predicted_state: { v: 0.5 }, confidence: 0.9)
+      10.times { p.record_actual(actual_state: { v: 0.5 }) }
+      expect(p.accurate?).to be true
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with expected keys' do
+      h = perspective.to_h
+      expect(h).to include(
+        :id, :agent_id, :perspective_type, :predicted_state, :actual_state,
+        :confidence, :accuracy, :accurate, :resolved, :created_at, :resolved_at
+      )
+    end
+
+    it 'rounds accuracy to 4 decimal places' do
+      h = perspective.to_h
+      expect(h[:accuracy].to_s).to match(/\A\d+\.\d{1,4}\z/)
+    end
+
+    it 'resolved_at is nil before recording actual' do
+      expect(perspective.to_h[:resolved_at]).to be_nil
+    end
+
+    it 'resolved_at is set after recording actual' do
+      perspective.record_actual(actual_state: {})
+      expect(perspective.to_h[:resolved_at]).not_to be_nil
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/cognitive_empathy/runners/cognitive_empathy_spec.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::CognitiveEmpathy::Runners::CognitiveEmpathy do
+  let(:runner) do
+    obj = Object.new
+    obj.extend(described_class)
+    obj
+  end
+
+  describe '#take_empathic_perspective' do
+    it 'creates a perspective and returns success' do
+      result = runner.take_empathic_perspective(
+        agent_id:         :alice,
+        perspective_type: :cognitive,
+        predicted_state:  { valence: 0.7 },
+        confidence:       0.8
+      )
+      expect(result[:success]).to be true
+      expect(result[:perspective_id]).to be_a(Symbol)
+      expect(result[:agent_id]).to eq(:alice)
+    end
+
+    it 'returns failure for invalid perspective_type' do
+      result = runner.take_empathic_perspective(
+        agent_id:         :alice,
+        perspective_type: :invalid_type,
+        predicted_state:  {},
+        confidence:       0.5
+      )
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:limit_or_invalid_type)
+    end
+
+    it 'uses default confidence when not provided' do
+      result = runner.take_empathic_perspective(
+        agent_id:         :bob,
+        perspective_type: :affective,
+        predicted_state:  {}
+      )
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#record_empathic_outcome' do
+    it 'records actual state and returns accuracy' do
+      created = runner.take_empathic_perspective(
+        agent_id:         :carol,
+        perspective_type: :motivational,
+        predicted_state:  { drive: 0.8 },
+        confidence:       0.7
+      )
+      perspective_id = created[:perspective_id]
+      result = runner.record_empathic_outcome(
+        perspective_id: perspective_id,
+        actual_state:   { drive: 0.8 }
+      )
+      expect(result[:success]).to be true
+      expect(result[:accuracy]).to be_a(Float)
+      expect(result[:accurate]).to be(true).or be(false)
+    end
+
+    it 'returns failure for unknown perspective_id' do
+      result = runner.record_empathic_outcome(
+        perspective_id: :nonexistent_perspective,
+        actual_state:   {}
+      )
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:not_found)
+    end
+  end
+
+  describe '#empathic_accuracy_for' do
+    it 'returns accuracy for an agent with no history' do
+      result = runner.empathic_accuracy_for(agent_id: :dave)
+      expect(result[:success]).to be true
+      expect(result[:agent_id]).to eq(:dave)
+      expect(result[:accuracy]).to be_a(Float)
+      expect(result[:label]).to be_a(Symbol)
+    end
+
+    it 'returns updated accuracy after recording outcome' do
+      created = runner.take_empathic_perspective(
+        agent_id:         :eve,
+        perspective_type: :situational,
+        predicted_state:  { stress: 0.3 },
+        confidence:       0.6
+      )
+      perspective_id = created[:perspective_id]
+      runner.record_empathic_outcome(
+        perspective_id: perspective_id,
+        actual_state:   { stress: 0.3 }
+      )
+      result = runner.empathic_accuracy_for(agent_id: :eve)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#overall_empathic_accuracy' do
+    it 'returns success with accuracy and label' do
+      result = runner.overall_empathic_accuracy
+      expect(result[:success]).to be true
+      expect(result[:accuracy]).to be_a(Float)
+      expect(result[:label]).to be_a(Symbol)
+    end
+  end
+
+  describe '#apply_emotional_contagion' do
+    it 'increases contagion level and returns empathic_state' do
+      result = runner.apply_emotional_contagion(emotion_valence: 0.8, intensity: 0.9)
+      expect(result[:success]).to be true
+      expect(result[:contagion_level]).to be > 0.0
+      expect(Legion::Extensions::Agentic::Affect::CognitiveEmpathy::Helpers::Constants::EMPATHIC_STATES)
+        .to include(result[:empathic_state])
+    end
+  end
+
+  describe '#current_empathic_state' do
+    it 'returns empathic_state and contagion_level' do
+      result = runner.current_empathic_state
+      expect(result[:success]).to be true
+      expect(Legion::Extensions::Agentic::Affect::CognitiveEmpathy::Helpers::Constants::EMPATHIC_STATES)
+        .to include(result[:empathic_state])
+      expect(result[:contagion_level]).to be_a(Float)
+    end
+  end
+
+  describe '#perspectives_for_agent' do
+    it 'returns empty list for agent with no perspectives' do
+      result = runner.perspectives_for_agent(agent_id: :nobody)
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(0)
+      expect(result[:perspectives]).to be_empty
+    end
+
+    it 'returns perspectives after taking some' do
+      runner.take_empathic_perspective(
+        agent_id:         :frank,
+        perspective_type: :cognitive,
+        predicted_state:  {},
+        confidence:       0.5
+      )
+      runner.take_empathic_perspective(
+        agent_id:         :frank,
+        perspective_type: :affective,
+        predicted_state:  {},
+        confidence:       0.5
+      )
+      result = runner.perspectives_for_agent(agent_id: :frank)
+      expect(result[:count]).to eq(2)
+    end
+  end
+
+  describe '#empathic_blind_spots' do
+    it 'returns nil agents when no perspectives exist' do
+      result = runner.empathic_blind_spots
+      expect(result[:success]).to be true
+      expect(result[:least_accurate_agent]).to be_nil
+      expect(result[:most_accurate_agent]).to be_nil
+    end
+
+    it 'returns blind spot info after recording outcomes' do
+      p1 = runner.take_empathic_perspective(
+        agent_id:         :good_agent,
+        perspective_type: :cognitive,
+        predicted_state:  { v: 0.5 },
+        confidence:       0.9
+      )
+      runner.record_empathic_outcome(perspective_id: p1[:perspective_id], actual_state: { v: 0.5 })
+
+      p2 = runner.take_empathic_perspective(
+        agent_id:         :bad_agent,
+        perspective_type: :cognitive,
+        predicted_state:  { v: 1.0 },
+        confidence:       0.9
+      )
+      runner.record_empathic_outcome(perspective_id: p2[:perspective_id], actual_state: { v: 0.0 })
+
+      result = runner.empathic_blind_spots
+      expect(result[:success]).to be true
+      expect(result[:least_accurate_agent]).to eq(:bad_agent)
+      expect(result[:most_accurate_agent]).to eq(:good_agent)
+    end
+  end
+
+  describe '#update_cognitive_empathy' do
+    it 'ticks and returns stats' do
+      result = runner.update_cognitive_empathy
+      expect(result[:success]).to be true
+      expect(result).to include(:perspective_count, :empathic_state)
+    end
+  end
+
+  describe '#cognitive_empathy_stats' do
+    it 'returns current stats' do
+      result = runner.cognitive_empathy_stats
+      expect(result[:success]).to be true
+      expect(result).to include(:perspective_count, :overall_accuracy, :empathic_state)
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/contagion/client_spec.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/affect/contagion/client'
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Contagion::Client do
+  let(:client) { described_class.new }
+
+  it 'responds to create_meme' do
+    expect(client).to respond_to(:create_meme)
+  end
+
+  it 'responds to register_agent' do
+    expect(client).to respond_to(:register_agent)
+  end
+
+  it 'responds to attempt_transmission' do
+    expect(client).to respond_to(:attempt_transmission)
+  end
+
+  it 'responds to recover_agent' do
+    expect(client).to respond_to(:recover_agent)
+  end
+
+  it 'responds to infect_agent' do
+    expect(client).to respond_to(:infect_agent)
+  end
+
+  it 'responds to immunize_agent' do
+    expect(client).to respond_to(:immunize_agent)
+  end
+
+  it 'responds to spread_step' do
+    expect(client).to respond_to(:spread_step)
+  end
+
+  it 'responds to epidemic_report' do
+    expect(client).to respond_to(:epidemic_report)
+  end
+
+  it 'responds to most_viral' do
+    expect(client).to respond_to(:most_viral)
+  end
+
+  it 'responds to agent_status' do
+    expect(client).to respond_to(:agent_status)
+  end
+
+  it 'responds to susceptible_agents' do
+    expect(client).to respond_to(:susceptible_agents)
+  end
+
+  it 'responds to contagion_status' do
+    expect(client).to respond_to(:contagion_status)
+  end
+
+  it 'can perform a full create->infect->report cycle' do
+    client.register_agent(agent_id: 'agent-a', resistance: 0.0)
+    meme = client.create_meme(label: 'fear', virulence: 0.8)
+    client.infect_agent(meme_id: meme[:id], agent_id: 'agent-a')
+    report = client.epidemic_report(meme_id: meme[:id])
+    expect(report[:infected]).to eq(1)
+  end
+end