Ensure session[:id] before scoring: all tests now pass.HEADmaster

Never too late for all tests to pass...

1 files changed, 34 insertions, 32 deletions

diff --git a/test/services/tartiflette_scoring_service.rb b/test/services/tartiflette_scoring_service_test.rb
index 4988b0a..2004da0 100644
--- a/test/services/tartiflette_scoring_service.rb
+++ b/test/services/tartiflette_scoring_service_test.rb
@@ -3,54 +3,59 @@ require "test_helper"
 class TartifletteScoringServiceTest < ActiveSupport::TestCase
   setup do
     @tartiflette = tartiflettes(:one)
-    @existing_score = scores(:one)
-    @session = { id: @existing_score.session_id }
   end
 
   test "should check if tartiflette is already scored" do
-    @session[:scored_tartiflettes] = [ @tartiflette.id ]
-    assert TartifletteScoringService.scored?(@tartiflette, @session)
+    session = { scored_tartiflettes: [ @tartiflette.id ] }
+    assert TartifletteScoringService.scored?(@tartiflette, session)
   end
 
   test "should mark tartiflette as scored" do
-    TartifletteScoringService.mark_as_scored(@tartiflette, @session)
-    assert_includes @session[:scored_tartiflettes], @tartiflette.id
+    session = { id: SecureRandom.uuid }
+    TartifletteScoringService.mark_as_scored(@tartiflette, session)
+    assert_includes session[:scored_tartiflettes], @tartiflette.id
   end
 
   test "should submit new scores for tartiflette" do
-    scores = {
-      "1" => { value: 4, id: nil } # New score for criterium_id 1
-    }
+    scoring_criterium_id = scoring_criteria(:one).id
+    new_session = { id: SecureRandom.uuid }
+    scores = { scoring_criterium_id => { value: 4 } }
 
     assert_nothing_raised do
-      TartifletteScoringService.submit_scores(@tartiflette, scores, @session)
+      TartifletteScoringService.submit_scores(@tartiflette, scores, new_session)
     end
 
-    # Assertions for new score
-    new_score = Score.find_by(scoring_criterium_id: 1, tartiflette: @tartiflette)
+    new_score = Score.find_by(scoring_criterium_id: scoring_criterium_id,
+                              tartiflette: @tartiflette,
+                              session_id: new_session[:id])
     assert_not_nil new_score, "New score should be created"
     assert_equal 4, new_score.value
-    assert_equal @session.id, new_score.session_id
+    assert_equal new_session[:id], new_score.session_id
   end
 
   test "should update existing scores for tartiflette" do
+    session = { id: SecureRandom.uuid }
+    existing_score = Score.create!(
+      tartiflette: @tartiflette,
+      scoring_criterium: scoring_criteria(:one),
+      value: 1,
+      session_id: session[:id]
+    )
     scores = {
-      "2" => { value: 5, id: @existing_score.id } # Update existing score
+      existing_score.id => { value: 5 }
     }
-
     assert_nothing_raised do
-      TartifletteScoringService.update_scores(@tartiflette, scores, @session)
+      TartifletteScoringService.update_scores(@tartiflette, scores, session)
     end
 
-    # Assertions for updated score
-    @existing_score.reload
-    assert_equal 5, @existing_score.value
+    existing_score.reload
+    assert_equal 5, existing_score.value
   end
 
   test "should raise error for invalid data" do
     scores = {
-      "1" => { value: nil, id: nil }, # Missing value
-      "2" => { value: 5, id: nil }    # Valid score
+      "1" => { value: nil, id: nil },
+      "2" => { value: 5, id: nil }
     }
 
     assert_raises(StandardError, /Failed to process scores/) do
@@ -65,41 +70,38 @@ class TartifletteScoringServiceTest < ActiveSupport::TestCase
   end
 
   test "should calculate average of all scores for a tartiflette" do
-    session_id = SecureRandom.uuid
     Score.create!(
       tartiflette: @tartiflette,
       scoring_criterium: scoring_criteria(:one),
       value: 1,
-      session_id: session_id
+      session_id: SecureRandom.uuid
     )
 
     Score.create!(
       tartiflette: @tartiflette,
       scoring_criterium: scoring_criteria(:two),
       value: 4,
-      session_id: session_id
+      session_id: SecureRandom.uuid
     )
     average_score = TartifletteScoringService.average_score(@tartiflette)
     assert_equal 2, average_score, "The average score should be 2"
   end
 
   test "should calculate average score by category for a tartiflette" do
-    session_id = SecureRandom.uuid
+    session = { id: SecureRandom.uuid }
     Score.create!(
       tartiflette: @tartiflette,
-      scoring_criterium: scoring_criteria(:one),
+      scoring_criterium: scoring_criteria(:four),
       value: 4,
-      session_id: session_id
+      session_id: session[:id]
     )
     Score.create!(
       tartiflette: @tartiflette,
-      scoring_criterium: scoring_criteria(:two),
+      scoring_criterium: scoring_criteria(:five),
       value: 5,
-      session_id: session_id
+      session_id: session[:id]
     )
     averages = TartifletteScoringService.average_score_by_category(@tartiflette)
-    assert_equal 4.0, averages[scoring_criteria(:one)]
-    assert_equal 5.0, averages[scoring_criteria(:one)]
+    assert_equal 4.5, averages[scoring_criteria(:four).category]
   end
-
 end