assignment-codeval 0.0.14__tar.gz → 0.0.16__tar.gz

{assignment_codeval-0.0.14 → assignment_codeval-0.0.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: assignment-codeval
-Version: 0.0.14
+Version: 0.0.16
 Summary: CodEval for evaluating programming assignments
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown

{assignment_codeval-0.0.14 → assignment_codeval-0.0.16}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "assignment-codeval"
-version = "0.0.14"
+version = "0.0.16"
 description = "CodEval for evaluating programming assignments"
 readme = "README.md"
 requires-python = ">=3.12"

{assignment_codeval-0.0.14 → assignment_codeval-0.0.16}/src/assignment_codeval/cli.py

@@ -4,7 +4,8 @@ from assignment_codeval.ai_benchmark import get_benchmark_command
 from assignment_codeval.create_assignment import create_assignment
 from assignment_codeval.evaluate import run_evaluation
 from assignment_codeval.github_connect import github_setup_repo
-from assignment_codeval.submissions import download_submissions, upload_submission_comments, evaluate_submissions
+from assignment_codeval.install_assignment import install_assignment
+from assignment_codeval.submissions import download_submissions, upload_submission_comments, evaluate_submissions, list_codeval_assignments
 
 
 @click.group()
@@ -17,6 +18,8 @@ cli.add_command(upload_submission_comments)
 cli.add_command(github_setup_repo)
 cli.add_command(evaluate_submissions)
 cli.add_command(create_assignment)
+cli.add_command(list_codeval_assignments)
+cli.add_command(install_assignment)
 cli.add_command(get_benchmark_command())
 
 if __name__ == "__main__":

{assignment_codeval-0.0.14 → assignment_codeval-0.0.16}/src/assignment_codeval/github_connect.py

@@ -1,4 +1,4 @@
-import os.path
+import os
 import re
 import subprocess
 from configparser import ConfigParser
@@ -13,8 +13,8 @@ HEX_DIGITS = "0123456789abcdefABCDEF"
 
 
 @click.command()
-@click.argument("course_name", metavar="COURSE")
-@click.argument("assignment_name", metavar="ASSIGNMENT")
+@click.argument("course_name", metavar="COURSE", required=False)
+@click.argument("assignment_name", metavar="ASSIGNMENT", required=False)
 @click.option("--all-repos", is_flag=True,
               help="download all repositories, even if they don't have a valid commit hash")
 @click.option("--target-dir", help="directory to download submissions to", default='./submissions', show_default=True)
@@ -28,14 +28,47 @@ def github_setup_repo(course_name, assignment_name, target_dir, github_field, al
 
     COURSE can be a unique substring of the actual course name.
 
+    If COURSE and ASSIGNMENT are not specified, will process all course/assignment
+    subdirectories found in the submissions directory.
     """
     canvas, user = connect_to_canvas()
     parser = ConfigParser()
     config_file = click.get_app_dir("codeval.ini")
     parser.read(config_file)
     parser.config_file = config_file
-    course = get_course(canvas, course_name, True)
-    assignment = get_assignment(course, assignment_name)
+
+    if course_name and assignment_name:
+        # Explicit course and assignment specified
+        course = get_course(canvas, course_name, True)
+        assignment = get_assignment(course, assignment_name)
+        _setup_repo_for_assignment(
+            canvas, parser, course, assignment, target_dir, github_field, all_repos, clone_delay
+        )
+    elif course_name or assignment_name:
+        raise click.UsageError("Both COURSE and ASSIGNMENT must be specified, or neither")
+    else:
+        # Scan submissions directory for course/assignment subdirectories
+        if not os.path.isdir(target_dir):
+            error(f"submissions directory {target_dir} does not exist")
+            return
+        for course_dir in sorted(os.listdir(target_dir)):
+            course_path = os.path.join(target_dir, course_dir)
+            if not os.path.isdir(course_path):
+                continue
+            for assignment_dir in sorted(os.listdir(course_path)):
+                assignment_path = os.path.join(course_path, assignment_dir)
+                if not os.path.isdir(assignment_path):
+                    continue
+                info(f"processing {course_dir}/{assignment_dir}")
+                course = get_course(canvas, course_dir, True)
+                assignment = get_assignment(course, assignment_dir)
+                _setup_repo_for_assignment(
+                    canvas, parser, course, assignment, target_dir, github_field, all_repos, clone_delay
+                )
+
+
+def _setup_repo_for_assignment(canvas, parser, course, assignment, target_dir, github_field, all_repos, clone_delay):
+    """Set up GitHub repos for a single assignment."""
     submission_dir = os.path.join(target_dir, despace(course.name), despace(assignment.name))
     os.makedirs(submission_dir, exist_ok=True)
 

assignment_codeval-0.0.16/src/assignment_codeval/install_assignment.py

@@ -0,0 +1,143 @@
+#! /usr/bin/python3
+"""Install a codeval assignment file and its referenced zip files to a destination."""
+
+import os
+import re
+import shutil
+import subprocess
+
+import click
+
+
+def parse_z_tags(codeval_path: str) -> list[str]:
+    """Parse a codeval file and return a list of zip files referenced by Z tags.
+
+    Arguments:
+        codeval_path: Path to the codeval file
+
+    Returns:
+        List of zip file paths referenced by Z tags
+    """
+    zip_files = []
+    with open(codeval_path, 'r') as f:
+        for line in f:
+            line = line.strip()
+            if line.startswith('Z '):
+                zip_file = line[2:].strip()
+                if zip_file:
+                    zip_files.append(zip_file)
+    return zip_files
+
+
+def is_remote_destination(destination: str) -> bool:
+    """Check if destination is a remote path (host:path format).
+
+    Arguments:
+        destination: The destination path
+
+    Returns:
+        True if destination is remote (contains : but not a Windows drive letter)
+    """
+    # Match host:path pattern but not Windows drive letters like C:\
+    if ':' not in destination:
+        return False
+    # Windows drive letter check (e.g., C:\path)
+    if re.match(r'^[A-Za-z]:\\', destination):
+        return False
+    return True
+
+
+def copy_file(source: str, destination: str, verbose: bool = False) -> None:
+    """Copy a file to a local or remote destination.
+
+    Arguments:
+        source: Path to the source file
+        destination: Destination path (local or host:path for remote)
+        verbose: Print verbose output
+
+    Raises:
+        click.ClickException: If copy fails
+    """
+    if is_remote_destination(destination):
+        # Use scp for remote destinations
+        cmd = ['scp', source, destination]
+        if verbose:
+            click.echo(f"Running: {' '.join(cmd)}")
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        if result.returncode != 0:
+            raise click.ClickException(f"scp failed: {result.stderr}")
+    else:
+        # Local copy
+        if verbose:
+            click.echo(f"Copying {source} to {destination}")
+        os.makedirs(destination, exist_ok=True)
+        shutil.copy2(source, destination)
+
+
+@click.command()
+@click.argument('codeval_file', type=click.Path(exists=True))
+@click.argument('destination')
+@click.option('--verbose', '-v', is_flag=True, help='Show detailed output')
+def install_assignment(codeval_file: str, destination: str, verbose: bool):
+    """Install a codeval file and its referenced zip files to a destination.
+
+    CODEVAL_FILE is the path to the codeval specification file.
+
+    DESTINATION is either a local path or a remote path in host:path format.
+    If remote, scp will be used to copy files.
+
+    \b
+    Examples:
+        # Local install
+        assignment-codeval install-assignment myassign.codeval /path/to/dest
+
+        # Remote install
+        assignment-codeval install-assignment myassign.codeval server:/home/user/assignments
+    """
+    codeval_path = os.path.abspath(codeval_file)
+    codeval_dir = os.path.dirname(codeval_path)
+    codeval_name = os.path.basename(codeval_path)
+
+    # Parse Z tags to find referenced zip files
+    zip_files = parse_z_tags(codeval_path)
+
+    # Build list of files to copy
+    files_to_copy = [codeval_path]
+
+    for zip_file in zip_files:
+        # Zip files are relative to the codeval file's directory
+        zip_path = os.path.join(codeval_dir, zip_file)
+        if os.path.exists(zip_path):
+            files_to_copy.append(zip_path)
+        else:
+            click.echo(f"Warning: Referenced zip file not found: {zip_path}", err=True)
+
+    # Show summary
+    click.echo(f"Codeval file: {codeval_name}")
+    if zip_files:
+        click.echo(f"Referenced zip files: {', '.join(zip_files)}")
+    else:
+        click.echo("No zip files referenced")
+    click.echo(f"Destination: {destination}")
+
+    if is_remote_destination(destination):
+        click.echo("Using scp for remote copy")
+
+    # Copy files
+    for source_path in files_to_copy:
+        filename = os.path.basename(source_path)
+        if is_remote_destination(destination):
+            # For remote, append filename to destination
+            dest_path = f"{destination}/{filename}"
+        else:
+            dest_path = destination
+
+        try:
+            copy_file(source_path, dest_path, verbose)
+            click.echo(f"Copied: {filename}")
+        except click.ClickException as e:
+            raise e
+        except Exception as e:
+            raise click.ClickException(f"Failed to copy {filename}: {e}")
+
+    click.echo("Done")

{assignment_codeval-0.0.14 → assignment_codeval-0.0.16}/src/assignment_codeval/submissions.py

@@ -4,7 +4,7 @@ import shutil
 import subprocess
 import time
 from configparser import ConfigParser
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, timezone
 from functools import cache
 from tempfile import TemporaryDirectory
 from zipfile import ZipFile
@@ -12,7 +12,7 @@ from zipfile import ZipFile
 import click
 import requests
 
-from assignment_codeval.canvas_utils import connect_to_canvas, get_course, get_assignment
+from assignment_codeval.canvas_utils import connect_to_canvas, get_course, get_courses, get_assignment
 from assignment_codeval.commons import debug, error, info, warn, despace
 
 
@@ -90,9 +90,11 @@ def evaluate_submissions(codeval_dir, submissions_dir):
             warn(f"no codeval file found for {assignment_name} in {codeval_file}")
             continue
 
-        # get the zipfiles (Z tag) and timeout (CTO tag)
+        # First pass: get CTO, CD tags, and collect Z files (don't extract yet)
         compile_timeout = 20
         assignment_working_dir = "."
+        has_cd_tag = False
+        zip_files = []
         move_to_next_submission = False
         with open(codeval_file, "r") as fd:
             for line in fd:
@@ -103,6 +105,7 @@ def evaluate_submissions(codeval_dir, submissions_dir):
                     except Exception:
                         warn(f"could not parse compile timeout from {line}, using default {compile_timeout}")
                 if line.startswith("CD"):
+                    has_cd_tag = True
                     assignment_working_dir = os.path.normpath(
                         os.path.join(assignment_working_dir, line.split()[1].strip()))
                     if not os.path.isdir(os.path.join(submission_dir, assignment_working_dir)):
@@ -110,16 +113,26 @@ def evaluate_submissions(codeval_dir, submissions_dir):
                         move_to_next_submission = True
                         break
                 if line.startswith("Z"):
-                    zipfile = line.split(None, 1)[1]
-                    # unzip into the submission directory
-                    with ZipFile(os.path.join(codeval_dir, zipfile)) as zf:
-                        for f in zf.infolist():
-                            dest_dir = os.path.join(submission_dir, assignment_working_dir)
-                            zf.extract(f, dest_dir)
-                            if not f.is_dir():
-                                perms = f.external_attr >> 16
-                                if perms:
-                                    os.chmod(os.path.join(dest_dir, f.filename), perms)
+                    zip_files.append(line.split(None, 1)[1])
+
+        # If no CD tag and this is a GitHub submission (has .git), use assignment name as working dir
+        if not has_cd_tag and os.path.exists(os.path.join(submission_dir, assignment_name, ".git")):
+            assignment_working_dir = assignment_name
+            if not os.path.isdir(os.path.join(submission_dir, assignment_working_dir)):
+                out = f"{assignment_working_dir} does not exist or is not a directory\n".encode('utf-8')
+                move_to_next_submission = True
+
+        # Now extract zip files to the correct working directory
+        if not move_to_next_submission:
+            for zf_name in zip_files:
+                with ZipFile(os.path.join(codeval_dir, zf_name)) as zf:
+                    for f in zf.infolist():
+                        dest_dir = os.path.join(submission_dir, assignment_working_dir)
+                        zf.extract(f, dest_dir)
+                        if not f.is_dir():
+                            perms = f.external_attr >> 16
+                            if perms:
+                                os.chmod(os.path.join(dest_dir, f.filename), perms)
 
         if not move_to_next_submission:
             command = raw_command.replace("EVALUATE", "cd /submissions; assignment-codeval run-evaluation codeval.txt")
@@ -151,14 +164,17 @@ def evaluate_submissions(codeval_dir, submissions_dir):
                         info("finished executing docker")
 
         info("writing results")
-        with open(f"{dirpath}/comments.txt", "wb") as fd:
+        with open(f"{dirpath}/comments.txt", "ab") as fd:
             fd.write(out)
         info("continuing")
 
 
 @click.command()
-@click.argument("course_name", metavar="COURSE")
-@click.argument("assignment_name", metavar="ASSIGNMENT")
+@click.argument("course_name", metavar="COURSE", required=False)
+@click.argument("assignment_name", metavar="ASSIGNMENT", required=False)
+@click.option("--active", is_flag=True, help="download from all active assignments in all active courses")
+@click.option("--until-window", default=24, show_default=True,
+              help="hours after the until date to still consider an assignment active")
 @click.option("--target-dir", help="directory to download submissions to", default='./submissions', show_default=True)
 @click.option("--include-commented", is_flag=True,
               help="even download submissionsthat already have codeval comments since last submission")
@@ -168,17 +184,78 @@ def evaluate_submissions(codeval_dir, submissions_dir):
 @click.option("--codeval-prefix", help="prefix for codeval comments", default="codeval: ", show_default=True)
 @click.option("--include-empty", is_flag=True, help="include empty submissions")
 @click.option("--for-name", help="only download submissions for this student name")
-def download_submissions(course_name, assignment_name, target_dir, include_commented, codeval_prefix, include_empty,
-                         uncommented_for, for_name):
+def download_submissions(course_name, assignment_name, active, until_window, target_dir, include_commented,
+                         codeval_prefix, include_empty, uncommented_for, for_name):
     """
     Download submissions for a given assignment in a course from Canvas.
 
-    the COURSE and ASSIGNMENT arguments can be partial names.
+    The COURSE and ASSIGNMENT arguments can be partial names.
+
+    Use --active to download from all active assignments in all active courses
+    (COURSE and ASSIGNMENT are not required when --active is used).
     """
+    if not active and (not course_name or not assignment_name):
+        raise click.UsageError("COURSE and ASSIGNMENT are required unless --active is specified")
+
     (canvas, user) = connect_to_canvas()
 
+    if active:
+        # Load codeval directory from config
+        parser = ConfigParser()
+        config_file = click.get_app_dir("codeval.ini")
+        parser.read(config_file)
+        if 'CODEVAL' not in parser or 'directory' not in parser['CODEVAL']:
+            raise click.UsageError(f"[CODEVAL] section with directory= is required in {config_file}")
+        codeval_dir = parser['CODEVAL']['directory']
+
+        courses = get_courses(canvas, course_name or "", is_active=True)
+        if not courses:
+            error("no active courses found")
+            return
+
+        now = datetime.now(timezone.utc)
+        for course in courses:
+            for assignment in course.get_assignments():
+                if assignment_name and assignment_name.lower() not in despace(assignment.name).lower():
+                    continue
+                # Check if assignment is active: availability date passed and until date + window not passed
+                unlock_at = getattr(assignment, 'unlock_at_date', None)
+                lock_at = getattr(assignment, 'lock_at_date', None)
+                if unlock_at and unlock_at > now:
+                    continue  # not yet available
+                if lock_at:
+                    window = timedelta(hours=until_window)
+                    if lock_at + window < now:
+                        continue  # past the until window
+
+                # Filter by submission type: only text_entry (GitHub) or file upload assignments
+                submission_types = getattr(assignment, 'submission_types', [])
+                if "online_text_entry" not in submission_types and "online_upload" not in submission_types:
+                    continue
+
+                # Only download if a corresponding codeval file exists
+                codeval_file = os.path.join(codeval_dir, f"{despace(assignment.name)}.codeval")
+                if not os.path.exists(codeval_file):
+                    continue
+
+                info(f"downloading submissions for {course.name}: {assignment.name}")
+                _download_assignment_submissions(
+                    course, assignment, target_dir, include_commented, codeval_prefix,
+                    include_empty, uncommented_for, for_name
+                )
+        return
+
     course = get_course(canvas, course_name)
     assignment = get_assignment(course, assignment_name)
+    _download_assignment_submissions(
+        course, assignment, target_dir, include_commented, codeval_prefix,
+        include_empty, uncommented_for, for_name
+    )
+
+
+def _download_assignment_submissions(course, assignment, target_dir, include_commented, codeval_prefix,
+                                     include_empty, uncommented_for, for_name):
+    """Download submissions for a single assignment."""
     submission_dir = os.path.join(target_dir, despace(course.name), despace(assignment.name))
     os.makedirs(submission_dir, exist_ok=True)
 
@@ -221,6 +298,18 @@ attempt={submission.attempt}
 late={submission.late}
 date={submission.submitted_at}
 last_comment={last_comment_date}""", file=fd)
+
+        # Save the last comment (any comment, not just codeval ones) to last-comment.txt
+        if submission.submission_comments:
+            all_comments = sorted(submission.submission_comments, key=lambda c: c['created_at'])
+            last_comment = all_comments[-1]
+            last_comment_path = os.path.join(student_submission_dir, "last-comment.txt")
+            with open(last_comment_path, "w") as fd:
+                print(f"date={last_comment['created_at']}", file=fd)
+                print(f"author={last_comment.get('author_name', 'unknown')}", file=fd)
+                print("", file=fd)
+                print(last_comment.get('comment', ''), file=fd)
+
         body = submission.body
         if body:
             filepath = os.path.join(student_submission_dir, "content.txt")
@@ -246,3 +335,46 @@ def get_submissions_by_id(assignment):
         student_id = str(submission.user_id)
         submissions_by_id[student_id] = submission
     return submissions_by_id
+
+
+@click.command()
+@click.argument("course_name", metavar="COURSE", required=False)
+def list_codeval_assignments(course_name):
+    """
+    List all assignments that have corresponding codeval files.
+
+    Optionally filter by COURSE (partial name match).
+    Reports errors for codeval files that don't match any assignment.
+    """
+    # Load codeval directory from config
+    parser = ConfigParser()
+    config_file = click.get_app_dir("codeval.ini")
+    parser.read(config_file)
+    if 'CODEVAL' not in parser or 'directory' not in parser['CODEVAL']:
+        raise click.UsageError(f"[CODEVAL] section with directory= is required in {config_file}")
+    codeval_dir = parser['CODEVAL']['directory']
+
+    if not os.path.isdir(codeval_dir):
+        raise click.UsageError(f"CODEVAL directory does not exist: {codeval_dir}")
+
+    # Get all codeval files in the directory
+    codeval_files = {f[:-8] for f in os.listdir(codeval_dir) if f.endswith('.codeval')}
+    matched_codeval_files = set()
+
+    (canvas, user) = connect_to_canvas()
+    courses = get_courses(canvas, course_name or "", is_active=True)
+    if not courses:
+        error("no active courses found")
+        return
+
+    for course in courses:
+        for assignment in course.get_assignments():
+            assignment_key = despace(assignment.name)
+            if assignment_key in codeval_files:
+                matched_codeval_files.add(assignment_key)
+                info(f"{course.name}: {assignment.name}")
+
+    # Report codeval files that don't match any assignment
+    unmatched = codeval_files - matched_codeval_files
+    for codeval_name in sorted(unmatched):
+        error(f"codeval file has no matching assignment: {codeval_name}.codeval")

{assignment_codeval-0.0.14 → assignment_codeval-0.0.16}/src/assignment_codeval.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: assignment-codeval
-Version: 0.0.14
+Version: 0.0.16
 Summary: CodEval for evaluating programming assignments
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown

{assignment_codeval-0.0.14 → assignment_codeval-0.0.16}/src/assignment_codeval.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ src/assignment_codeval/create_assignment.py
 src/assignment_codeval/evaluate.py
 src/assignment_codeval/file_utils.py
 src/assignment_codeval/github_connect.py
+src/assignment_codeval/install_assignment.py
 src/assignment_codeval/submissions.py
 src/assignment_codeval.egg-info/PKG-INFO
 src/assignment_codeval.egg-info/SOURCES.txt
@@ -18,4 +19,6 @@ src/assignment_codeval.egg-info/entry_points.txt
 src/assignment_codeval.egg-info/requires.txt
 src/assignment_codeval.egg-info/top_level.txt
 tests/test_codeval.py
-tests/test_create_assignment.py
+tests/test_create_assignment.py
+tests/test_evaluate_submissions.py
+tests/test_install_assignment.py

assignment_codeval-0.0.16/tests/test_evaluate_submissions.py

@@ -0,0 +1,158 @@
+"""Tests for evaluate_submissions command."""
+
+import os
+import tempfile
+import zipfile
+
+import pytest
+
+
+class TestGitHubSubmissionWorkingDir:
+    """Tests for GitHub submission working directory detection."""
+
+    def test_zip_extracted_to_assignment_dir_for_github(self):
+        """Verify zip files are extracted to assignment directory for GitHub submissions.
+
+        When a GitHub submission exists (has .git directory) and no CD tag is specified,
+        zip files should be extracted to the assignment_name subdirectory, not the root.
+        """
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Setup directory structure:
+            # tmpdir/
+            #   codeval/
+            #     TestAssignment.codeval
+            #     support.zip
+            #   submissions/
+            #     Course/
+            #       TestAssignment/
+            #         12345/
+            #           submission/
+            #             TestAssignment/
+            #               .git/
+            #               main.py
+
+            codeval_dir = os.path.join(tmpdir, "codeval")
+            submissions_dir = os.path.join(tmpdir, "submissions")
+            os.makedirs(codeval_dir)
+
+            assignment_name = "TestAssignment"
+            student_dir = os.path.join(submissions_dir, "Course", assignment_name, "12345")
+            submission_dir = os.path.join(student_dir, "submission")
+            git_repo_dir = os.path.join(submission_dir, assignment_name)
+            os.makedirs(os.path.join(git_repo_dir, ".git"))
+
+            # Create a dummy file in the git repo
+            with open(os.path.join(git_repo_dir, "main.py"), "w") as f:
+                f.write("print('hello')\n")
+
+            # Create a zip file with a helper file
+            zip_path = os.path.join(codeval_dir, "support.zip")
+            with zipfile.ZipFile(zip_path, 'w') as zf:
+                zf.writestr("helper.txt", "helper content")
+
+            # Create codeval file with Z tag but NO CD tag
+            codeval_path = os.path.join(codeval_dir, f"{assignment_name}.codeval")
+            with open(codeval_path, "w") as f:
+                f.write("Z support.zip\n")
+                f.write("T echo test\n")
+                f.write("O test\n")
+
+            # Parse the codeval file and check where zip would be extracted
+            # This simulates what evaluate_submissions does
+            from assignment_codeval.submissions import evaluate_submissions
+            from zipfile import ZipFile
+
+            # Manually trace through the logic to verify the bug
+            assignment_working_dir = "."
+            has_cd_tag = False
+            zip_files = []
+
+            with open(codeval_path, "r") as fd:
+                for line in fd:
+                    line = line.strip()
+                    if line.startswith("CD"):
+                        has_cd_tag = True
+                    if line.startswith("Z"):
+                        zip_files.append(line.split(None, 1)[1])
+
+            # Check for GitHub submission BEFORE extracting
+            is_github = os.path.exists(os.path.join(submission_dir, assignment_name, ".git"))
+            assert is_github, "Test setup: .git directory should exist"
+
+            if not has_cd_tag and is_github:
+                assignment_working_dir = assignment_name
+
+            # Now extract zip files to the correct location
+            for zf_name in zip_files:
+                with ZipFile(os.path.join(codeval_dir, zf_name)) as zf:
+                    dest_dir = os.path.join(submission_dir, assignment_working_dir)
+                    zf.extractall(dest_dir)
+
+            # Verify helper.txt was extracted to the assignment directory, not root
+            correct_path = os.path.join(submission_dir, assignment_name, "helper.txt")
+            wrong_path = os.path.join(submission_dir, "helper.txt")
+
+            assert os.path.exists(correct_path), \
+                f"helper.txt should be at {correct_path}"
+            assert not os.path.exists(wrong_path), \
+                f"helper.txt should NOT be at {wrong_path} (root of submission_dir)"
+
+    def test_zip_extracted_to_root_when_cd_tag_present(self):
+        """Verify zip files respect CD tag even for GitHub submissions."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            codeval_dir = os.path.join(tmpdir, "codeval")
+            submissions_dir = os.path.join(tmpdir, "submissions")
+            os.makedirs(codeval_dir)
+
+            assignment_name = "TestAssignment"
+            student_dir = os.path.join(submissions_dir, "Course", assignment_name, "12345")
+            submission_dir = os.path.join(student_dir, "submission")
+
+            # Create custom directory specified by CD tag
+            custom_dir = os.path.join(submission_dir, "custom_dir")
+            os.makedirs(os.path.join(custom_dir, ".git"))
+
+            # Create codeval file WITH CD tag
+            codeval_path = os.path.join(codeval_dir, f"{assignment_name}.codeval")
+            with open(codeval_path, "w") as f:
+                f.write("CD custom_dir\n")
+                f.write("Z support.zip\n")
+                f.write("T echo test\n")
+                f.write("O test\n")
+
+            # Create zip file
+            zip_path = os.path.join(codeval_dir, "support.zip")
+            with zipfile.ZipFile(zip_path, 'w') as zf:
+                zf.writestr("helper.txt", "helper content")
+
+            # Trace through logic
+            from zipfile import ZipFile
+
+            assignment_working_dir = "."
+            has_cd_tag = False
+            zip_files = []
+
+            with open(codeval_path, "r") as fd:
+                for line in fd:
+                    line = line.strip()
+                    if line.startswith("CD"):
+                        has_cd_tag = True
+                        assignment_working_dir = os.path.normpath(
+                            os.path.join(assignment_working_dir, line.split()[1].strip()))
+                    if line.startswith("Z"):
+                        zip_files.append(line.split(None, 1)[1])
+
+            # CD tag should take precedence
+            assert has_cd_tag
+            assert assignment_working_dir == "custom_dir"
+
+            # Extract zip files
+            for zf_name in zip_files:
+                with ZipFile(os.path.join(codeval_dir, zf_name)) as zf:
+                    dest_dir = os.path.join(submission_dir, assignment_working_dir)
+                    zf.extractall(dest_dir)
+
+            # Verify helper.txt was extracted to custom_dir
+            correct_path = os.path.join(submission_dir, "custom_dir", "helper.txt")
+            assert os.path.exists(correct_path), \
+                f"helper.txt should be at {correct_path}"

assignment_codeval-0.0.16/tests/test_install_assignment.py

@@ -0,0 +1,183 @@
+"""Tests for install_assignment command."""
+
+import os
+import tempfile
+import zipfile
+from unittest.mock import patch, MagicMock
+
+import pytest
+from click.testing import CliRunner
+
+from assignment_codeval.install_assignment import (
+    install_assignment,
+    is_remote_destination,
+    parse_z_tags,
+)
+
+
+class TestIsRemoteDestination:
+    """Tests for is_remote_destination function."""
+
+    def test_local_path(self):
+        assert is_remote_destination('/home/user/path') is False
+
+    def test_relative_path(self):
+        assert is_remote_destination('relative/path') is False
+
+    def test_remote_path(self):
+        assert is_remote_destination('server:/home/user/path') is True
+
+    def test_remote_path_with_user(self):
+        assert is_remote_destination('user@server:/path') is True
+
+    def test_windows_drive_letter(self):
+        assert is_remote_destination('C:\\Users\\path') is False
+
+    def test_windows_drive_lowercase(self):
+        assert is_remote_destination('c:\\Users\\path') is False
+
+
+class TestParseZTags:
+    """Tests for parse_z_tags function."""
+
+    def test_no_z_tags(self):
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.codeval', delete=False) as f:
+            f.write('C gcc -o test test.c\n')
+            f.write('T ./test\n')
+            f.name
+        try:
+            result = parse_z_tags(f.name)
+            assert result == []
+        finally:
+            os.unlink(f.name)
+
+    def test_single_z_tag(self):
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.codeval', delete=False) as f:
+            f.write('Z support.zip\n')
+            f.write('C gcc -o test test.c\n')
+        try:
+            result = parse_z_tags(f.name)
+            assert result == ['support.zip']
+        finally:
+            os.unlink(f.name)
+
+    def test_multiple_z_tags(self):
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.codeval', delete=False) as f:
+            f.write('Z first.zip\n')
+            f.write('Z second.zip\n')
+            f.write('C gcc -o test test.c\n')
+        try:
+            result = parse_z_tags(f.name)
+            assert result == ['first.zip', 'second.zip']
+        finally:
+            os.unlink(f.name)
+
+    def test_z_tag_with_whitespace(self):
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.codeval', delete=False) as f:
+            f.write('Z   support.zip  \n')
+        try:
+            result = parse_z_tags(f.name)
+            assert result == ['support.zip']
+        finally:
+            os.unlink(f.name)
+
+
+class TestInstallAssignmentCommand:
+    """Tests for the install_assignment CLI command."""
+
+    def test_local_install_codeval_only(self):
+        runner = CliRunner()
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create a codeval file
+            codeval_path = os.path.join(tmpdir, 'test.codeval')
+            with open(codeval_path, 'w') as f:
+                f.write('C gcc -o test test.c\n')
+                f.write('T ./test\n')
+
+            # Create destination directory
+            dest_dir = os.path.join(tmpdir, 'dest')
+            os.makedirs(dest_dir)
+
+            result = runner.invoke(install_assignment, [codeval_path, dest_dir])
+            assert result.exit_code == 0
+            assert 'No zip files referenced' in result.output
+            assert 'Done' in result.output
+            assert os.path.exists(os.path.join(dest_dir, 'test.codeval'))
+
+    def test_local_install_with_zip(self):
+        runner = CliRunner()
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create a zip file
+            zip_path = os.path.join(tmpdir, 'support.zip')
+            with zipfile.ZipFile(zip_path, 'w') as zf:
+                zf.writestr('helper.txt', 'test content')
+
+            # Create a codeval file referencing the zip
+            codeval_path = os.path.join(tmpdir, 'test.codeval')
+            with open(codeval_path, 'w') as f:
+                f.write('Z support.zip\n')
+                f.write('C gcc -o test test.c\n')
+
+            # Create destination directory
+            dest_dir = os.path.join(tmpdir, 'dest')
+            os.makedirs(dest_dir)
+
+            result = runner.invoke(install_assignment, [codeval_path, dest_dir])
+            assert result.exit_code == 0
+            assert 'support.zip' in result.output
+            assert 'Done' in result.output
+            assert os.path.exists(os.path.join(dest_dir, 'test.codeval'))
+            assert os.path.exists(os.path.join(dest_dir, 'support.zip'))
+
+    def test_missing_zip_warning(self):
+        runner = CliRunner()
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create a codeval file referencing a non-existent zip
+            codeval_path = os.path.join(tmpdir, 'test.codeval')
+            with open(codeval_path, 'w') as f:
+                f.write('Z missing.zip\n')
+                f.write('C gcc -o test test.c\n')
+
+            # Create destination directory
+            dest_dir = os.path.join(tmpdir, 'dest')
+            os.makedirs(dest_dir)
+
+            result = runner.invoke(install_assignment, [codeval_path, dest_dir])
+            assert result.exit_code == 0
+            assert 'Warning: Referenced zip file not found' in result.output
+
+    def test_verbose_output(self):
+        runner = CliRunner()
+        with tempfile.TemporaryDirectory() as tmpdir:
+            codeval_path = os.path.join(tmpdir, 'test.codeval')
+            with open(codeval_path, 'w') as f:
+                f.write('C gcc -o test test.c\n')
+
+            dest_dir = os.path.join(tmpdir, 'dest')
+            os.makedirs(dest_dir)
+
+            result = runner.invoke(install_assignment, [codeval_path, dest_dir, '--verbose'])
+            assert result.exit_code == 0
+            assert 'Copying' in result.output
+
+    @patch('assignment_codeval.install_assignment.subprocess.run')
+    def test_remote_destination_detected(self, mock_run):
+        # Mock successful scp
+        mock_run.return_value = MagicMock(returncode=0)
+
+        runner = CliRunner()
+        with tempfile.TemporaryDirectory() as tmpdir:
+            codeval_path = os.path.join(tmpdir, 'test.codeval')
+            with open(codeval_path, 'w') as f:
+                f.write('C gcc -o test test.c\n')
+
+            result = runner.invoke(install_assignment, [codeval_path, 'server:/path'])
+            assert result.exit_code == 0
+            assert 'Using scp for remote copy' in result.output
+            # Verify scp was called
+            mock_run.assert_called()
+
+    def test_nonexistent_codeval_file(self):
+        runner = CliRunner()
+        result = runner.invoke(install_assignment, ['/nonexistent/file.codeval', '/dest'])
+        assert result.exit_code != 0