Added tournament backups to the database and added pages to restore and create backups

test/controllers/tournament_backups_controller_test.rb

@@ -0,0 +1,220 @@
+require "test_helper"
+
+class TournamentBackupsControllerTest < ActionController::TestCase
+  include Devise::Test::ControllerHelpers
+
+  setup do
+    @tournament = Tournament.find(1)
+    TournamentBackupService.new(@tournament, 'Manual backup').create_backup
+    @backup = @tournament.tournament_backups.first
+  end
+
+  def sign_in_owner
+    sign_in users(:one)
+  end
+
+  def sign_in_non_owner
+    sign_in users(:two)
+  end
+  
+  def sign_in_delegate
+    sign_in users(:three)
+  end
+  
+  def sign_in_school_delegate
+    sign_in users(:four)
+  end
+
+  def success
+    assert_response :success
+  end
+
+  def redirect
+    assert_redirected_to '/static_pages/not_allowed'
+  end
+
+  # Index endpoint tests
+  test "logged in tournament owner can access index" do
+    sign_in_owner
+    get :index, params: { tournament_id: @tournament.id }
+    assert_response :success
+  end
+
+  test "logged in delegate can access index" do
+    sign_in_delegate
+    get :index, params: { tournament_id: @tournament.id }
+    assert_response :success
+  end
+
+  test "non-tournament owner cannot access index" do
+    sign_in_non_owner
+    get :index, params: { tournament_id: @tournament.id }
+    redirect
+  end
+
+  test "school delegate cannot access index" do
+    sign_in_school_delegate
+    get :index, params: { tournament_id: @tournament.id }
+    redirect
+  end
+
+  # Show endpoint tests
+  test "tournament owner can view a backup" do
+    sign_in_owner
+    get :show, params: { tournament_id: @tournament.id, id: @backup.id }
+    assert_response :success
+  end
+
+  test "delegate can view a backup" do
+    sign_in_delegate
+    get :show, params: { tournament_id: @tournament.id, id: @backup.id }
+    assert_response :success
+  end
+
+  test "non-tournament owner cannot view a backup" do
+    sign_in_non_owner
+    get :show, params: { tournament_id: @tournament.id, id: @backup.id }
+    redirect
+  end
+
+  test "school delegate cannot view a backup" do
+    sign_in_school_delegate
+    get :show, params: { tournament_id: @tournament.id, id: @backup.id }
+    redirect
+  end
+
+  # Destroy endpoint tests
+  test "tournament owner can delete a backup" do
+    sign_in_owner
+    assert_difference("TournamentBackup.count", -1) do
+      delete :destroy, params: { tournament_id: @tournament.id, id: @backup.id }
+    end
+    assert_redirected_to tournament_tournament_backups_path(@tournament)
+  end
+
+  test "delegate can delete a backup" do
+    sign_in_delegate
+    assert_difference("TournamentBackup.count", -1) do
+      delete :destroy, params: { tournament_id: @tournament.id, id: @backup.id }
+    end
+    assert_redirected_to tournament_tournament_backups_path(@tournament)
+  end
+
+  test "non-tournament owner cannot delete a backup" do
+    sign_in_non_owner
+    assert_no_difference("TournamentBackup.count") do
+      delete :destroy, params: { tournament_id: @tournament.id, id: @backup.id }
+    end
+    redirect
+  end
+
+  test "school delegate cannot delete a backup" do
+    sign_in_school_delegate
+    assert_no_difference("TournamentBackup.count") do
+      delete :destroy, params: { tournament_id: @tournament.id, id: @backup.id }
+    end
+    redirect
+  end
+
+  # Restore endpoint tests
+  test "tournament owner can restore a backup" do
+    sign_in_owner
+    post :restore, params: { tournament_id: @tournament.id, id: @backup.id }
+    assert_redirected_to tournament_path(@tournament)
+  end
+
+  test "delegate can restore a backup" do
+    sign_in_delegate
+    post :restore, params: { tournament_id: @tournament.id, id: @backup.id }
+    assert_redirected_to tournament_path(@tournament)
+  end
+
+  test "non-tournament owner cannot restore a backup" do
+    sign_in_non_owner
+    post :restore, params: { tournament_id: @tournament.id, id: @backup.id }
+    redirect
+  end
+
+  test "school delegate cannot restore a backup" do
+    sign_in_school_delegate
+    post :restore, params: { tournament_id: @tournament.id, id: @backup.id }
+    redirect
+  end
+
+  # Import manual tests
+  test "tournament owner can manually import a backup" do
+    sign_in_owner
+    post :import_manual, params: { tournament_id: @tournament.id, tournament: { import_text: Base64.decode64(@backup.backup_data) } }
+    assert_redirected_to tournament_path(@tournament)
+  end
+
+  test "delegate can manually import a backup" do
+    sign_in_delegate
+    post :import_manual, params: { tournament_id: @tournament.id, tournament: { import_text: Base64.decode64(@backup.backup_data) } }
+    assert_redirected_to tournament_path(@tournament)
+  end
+
+  test "non-tournament owner cannot manually import a backup" do
+    sign_in_non_owner
+    post :import_manual, params: { tournament_id: @tournament.id, tournament: { import_text: Base64.decode64(@backup.backup_data) } }
+    redirect
+  end
+
+  test "school delegate cannot manually import a backup" do
+    sign_in_school_delegate
+    post :import_manual, params: { tournament_id: @tournament.id, tournament: { import_text: Base64.decode64(@backup.backup_data) } }
+    redirect
+  end
+
+  test "index shows empty list when no backups exist" do
+    @tournament.tournament_backups.destroy_all
+    sign_in_owner
+    get :index, params: { tournament_id: @tournament.id }
+    assert_response :success
+    assert_select 'tbody tr', 0 # Ensure no rows are rendered in the table
+  end
+
+  test "show action for non-existent backup" do
+    sign_in_owner
+    assert_raises(ActiveRecord::RecordNotFound) do
+      get :show, params: { tournament_id: @tournament.id, id: 9999 } # Use a non-existent backup ID
+    end
+  end
+  
+  test "destroy action for non-existent backup" do
+    sign_in_owner
+    assert_no_difference("TournamentBackup.count") do
+      assert_raises(ActiveRecord::RecordNotFound) do
+        delete :destroy, params: { tournament_id: @tournament.id, id: 9999 } # Use a non-existent backup ID
+      end
+    end
+  end
+
+  test "restore action for non-existent backup" do
+    sign_in_owner
+    assert_raises(ActiveRecord::RecordNotFound) do
+      post :restore, params: { tournament_id: @tournament.id, id: 9999 } # Use a non-existent backup ID
+    end
+  end
+
+  test "manual import with blank input" do
+    sign_in_owner
+    post :import_manual, params: { tournament_id: @tournament.id, tournament: { import_text: '' } }
+    assert_redirected_to tournament_tournament_backups_path(@tournament)
+    assert_equal 'Import text cannot be blank.', flash[:alert]
+  end
+
+  test "manual import restores associations" do
+    schools_count = @tournament.schools.count
+    wrestlers_count = @tournament.wrestlers.count
+    matches_count = @tournament.matches.count
+    sign_in_owner
+    valid_backup_data = Base64.decode64(@backup.backup_data)
+    post :import_manual, params: { tournament_id: @tournament.id, tournament: { import_text: valid_backup_data } }
+  
+    @tournament.reload
+    assert_equal schools_count, @tournament.schools.count
+    assert_equal wrestlers_count, @tournament.wrestlers.count
+    assert_equal matches_count, @tournament.matches.count
+  end  
+end