SWAMPy

✎ CARVE FLESH

EDITING: utils.test.js

/*
 * Copyright (C) 2023 - present Instructure, Inc.
 *
 * This file is part of Canvas.
 *
 * Canvas is free software: you can redistribute it and/or modify it under
 * the terms of the GNU Affero General Public License as published by the Free
 * Software Foundation, version 3 of the License.
 *
 * Canvas is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 * A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Affero General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */

import React from 'react'

import {IconCheckLine, IconXLine} from '@instructure/ui-icons'
import {Pill} from '@instructure/ui-pill'

import {Assignment} from '../../../graphql/Assignment'
import {AssignmentGroup} from '../../../graphql/AssignmentGroup'
import {GradingStandard} from '../../../graphql/GradingStandard'
import {GradingPeriod} from '../../../graphql/GradingPeriod'
import {Submission} from '../../../graphql/Submission'

import {ASSIGNMENT_SORT_OPTIONS, ASSIGNMENT_NOT_APPLICABLE} from '../constants'
import {
  nullGradingPeriodAssignments,
  nullGradingPeriodAssignmentGroup,
  nullGradingPeriodGradingPeriods,
} from './largeDataMocks'

import {
  formatNumber,
  submissionCommentsPresent,
  getDisplayStatus,
  getDisplayScore,
  getZeroPointAssignmentDisplayScore,
  getNoSubmissionStatus,
  scorePercentageToLetterGrade,
  getAssignmentTotalPoints,
  getAssignmentEarnedPoints,
  getAssignmentPercentage,
  getAssignmentLetterGrade,
  getAssignmentGroupScore,
  getAssignmentGroupTotalPoints,
  getAssignmentGroupEarnedPoints,
  getAssignmentGroupPercentage,
  getAssignmentGroupPercentageWithPartialWeight,
  getAssignmentGroupLetterGrade,
  getGradingPeriodTotalPoints,
  getGradingPeriodEarnedPoints,
  getGradingPeriodPercentage,
  getCourseTotalPoints,
  getCourseEarnedPoints,
  getCoursePercentage,
  calculateTotalPercentageWithPartialWeight,
  getTotal,
  sortAssignments,
  filteredAssignments,
} from '../utils'

const createAssignment = (score, pointsPossible) => {
  return Assignment.mock({
    pointsPossible,
    submissionsConnection: {nodes: [Submission.mock({score})]},
  })
}

const mockAssignments = (possibleScores = []) => {
  return possibleScores.length === 0
    ? [
        createAssignment(10, 10),
        createAssignment(8, 10),
        createAssignment(7, 10),
        createAssignment(6, 10),
      ]
    : possibleScores.map(score => createAssignment(10, score))
}

const getTime = past => {
  const date = new Date()
  if (past) {
    date.setDate(date.getDate() - 1)
  } else {
    date.setDate(date.getDate() + 1)
  }

return date.toISOString()
}

describe('util', () => {
  describe('getAssignmentScorePercentage', () => {
    it('should return override score percentage if available', () => {
      const assignmentGroupWithOverrideScore = {
        gradesConnection: {
          nodes: [
            {
              overrideScore: 90,
              currentScore: 80,
            },
          ],
        },
      }
      expect(getAssignmentGroupScore(assignmentGroupWithOverrideScore)).toBe('90%')
    })

it('should return current score percentage if override score is not available', () => {
      const assignmentGroupWithCurrentScore = {
        gradesConnection: {
          nodes: [
            {
              currentScore: 75,
            },
          ],
        },
      }
      expect(getAssignmentGroupScore(assignmentGroupWithCurrentScore)).toBe('75%')
    })

it('should return N/A if no scores are available', () => {
      const assignmentGroupWithNoScores = {
        gradesConnection: {
          nodes: [{}],
        },
      }
      expect(getAssignmentGroupScore(assignmentGroupWithNoScores)).toBe(ASSIGNMENT_NOT_APPLICABLE)
    })
  })

describe('sortAssignments', () => {
    describe('by due date', () => {
      it('should sort assignments by due date ascending', () => {
        const assignments = [
          Assignment.mock({dueAt: getTime(false)}),
          Assignment.mock({dueAt: getTime(true)}),
          Assignment.mock({dueAt: getTime(false)}),
          Assignment.mock({dueAt: getTime(true)}),
        ]
        const sortedAssignments = sortAssignments(ASSIGNMENT_SORT_OPTIONS.DUE_DATE, assignments)
        expect(sortedAssignments).toEqual([
          assignments[1],
          assignments[3],
          assignments[0],
          assignments[2],
        ])
      })
    })

describe('by name', () => {
      it('should sort assignments by name ascending', () => {
        const assignments = [
          Assignment.mock({name: 'A'}),
          Assignment.mock({name: 'C'}),
          Assignment.mock({name: 'B'}),
          Assignment.mock({name: 'D'}),
        ]
        const sortedAssignments = sortAssignments(ASSIGNMENT_SORT_OPTIONS.NAME, assignments)
        expect(sortedAssignments).toEqual([
          assignments[0],
          assignments[2],
          assignments[1],
          assignments[3],
        ])
      })
    })

describe('by assignment group', () => {
      it('should sort assignments by assignment group ascending', () => {
        const assignments = [
          Assignment.mock({assignmentGroup: AssignmentGroup.mock({name: 'A'})}),
          Assignment.mock({assignmentGroup: AssignmentGroup.mock({name: 'C'})}),
          Assignment.mock({assignmentGroup: AssignmentGroup.mock({name: 'B'})}),
          Assignment.mock({assignmentGroup: AssignmentGroup.mock({name: 'C'})}),
        ]
        const sortedAssignments = sortAssignments(
          ASSIGNMENT_SORT_OPTIONS.ASSIGNMENT_GROUP,
          assignments
        )
        expect(sortedAssignments).toEqual([
          assignments[0],
          assignments[2],
          assignments[1],
          assignments[3],
        ])
      })
    })
  })

describe('formatNumber', () => {
    it('should format a positive number with two decimal places', () => {
      expect(formatNumber(1234.5678)).toBe('1,234.57')
    })

it('should format a negative number with two decimal places', () => {
      expect(formatNumber(-9876.5432)).toBe('-9,876.54')
    })

it('should format zero with two decimal places', () => {
      expect(formatNumber(0)).toBe('0.00')
    })

it('should format a number with no decimal places', () => {
      expect(formatNumber(123)).toBe('123.00')
    })

it('should format a large number with two decimal places', () => {
      expect(formatNumber(1234567890.1234)).toBe('1,234,567,890.12')
    })

it('should return undefined if the input is undefined', () => {
      expect(formatNumber(undefined)).toBeUndefined()
    })

it('should return undefined if the input is null', () => {
      expect(formatNumber(null)).toBeUndefined()
    })

it('should format a string with two decimal places', () => {
      expect(formatNumber('1234.5678')).toBe('1,234.57')
    })
  })

describe('submissionCommentsPresent', () => {
    it('should return true if at least one submission has comments', () => {
      const assignment = {
        submissionsConnection: {
          nodes: [
            {
              commentsConnection: {
                nodes: [
                  {
                    id: 1,
                    text: 'Comment 1',
                  },
                ],
              },
            },
            {
              commentsConnection: {
                nodes: [],
              },
            },
          ],
        },
      }
      expect(submissionCommentsPresent(assignment)).toBe(true)
    })

it('should return false if no submission has comments', () => {
      const assignment = {
        submissionsConnection: {
          nodes: [
            {
              commentsConnection: {
                nodes: [],
              },
            },
            {
              commentsConnection: {
                nodes: [],
              },
            },
          ],
        },
      }
      expect(submissionCommentsPresent(assignment)).toBe(false)
    })

it('should return false if assignment is undefined', () => {
      expect(submissionCommentsPresent(undefined)).toBe(false)
    })

it('should return false if assignment is null', () => {
      expect(submissionCommentsPresent(null)).toBe(false)
    })
  })

describe('getDisplayStatus', () => {
    it('should return "Excused" status when gradingStatus is "excused"', () => {
      const assignment = {
        submissionsConnection: {
          nodes: [
            {
              gradingStatus: 'excused',
            },
          ],
        },
      }
      const expectedOutput = <Pill color="primary">Excused</Pill>
      expect(getDisplayStatus(assignment)).toStrictEqual(expectedOutput)
    })

it('should return "Not Graded" status when gradingType is "not_graded"', () => {
      const assignment = {
        gradingType: 'not_graded',
      }
      const expectedOutput = <Pill color="primary">Not Graded</Pill>
      expect(getDisplayStatus(assignment)).toStrictEqual(expectedOutput)
    })

it('should return "Not Submission" status when no submissions exist', () => {
      const assignment = {
        submissionsConnection: {
          nodes: [],
        },
        dueAt: getTime(false),
      }
      const expectedOutput = <Pill color="primary">Not Submitted</Pill>
      expect(getDisplayStatus(assignment)).toStrictEqual(expectedOutput)
    })

it('should return "Late" status when the first submission is late', () => {
      const assignment = {
        submissionsConnection: {
          nodes: [
            {
              late: true,
            },
          ],
        },
      }
      const expectedOutput = <Pill color="warning">Late</Pill>
      expect(getDisplayStatus(assignment)).toStrictEqual(expectedOutput)
    })

it('should return "Graded" status when gradingStatus is "graded"', () => {
      const assignment = {
        submissionsConnection: {
          nodes: [
            {
              gradingStatus: 'graded',
            },
          ],
        },
      }
      const expectedOutput = <Pill color="success">Graded</Pill>
      expect(getDisplayStatus(assignment)).toStrictEqual(expectedOutput)
    })

it('should return "Not Graded" status for other cases', () => {
      const assignment = {}
      const expectedOutput = <Pill>Not Graded</Pill>
      expect(getDisplayStatus(assignment)).toStrictEqual(expectedOutput)
    })
  })

describe('getDisplayScore', () => {
    it('returns "-" when assignment has no submissions or needs grading or is excused', () => {
      const assignment = Assignment.mock({
        submissionsConnection: {
          nodes: [],
        },
      })