@instructure/quiz-interactions/src/records/interactions/__tests__/categorization.test.js

A React UI component Library for quiz interaction types.

import {expect} from '@instructure/ui-test-utils'
import isuuid from 'isuuid'

import CategorizationInteractionType from '../categorization'
import checkUserResponseTransform from '../../__tests__/sharedRecordTests'

describe('CategorizationInteractionType', () => {
  const IntTypeRecord = CategorizationInteractionType
  const intType = new IntTypeRecord()

  describe('#getDefaultInteractionData', () => {
    it('returns categorization options when slug is "categorization" ', () => {
      const options = intType.getDefaultInteractionData()
      expect(Object.keys(options.categories).length).to.be.equal(2)
      expect(Object.keys(options.distractors).length).to.be.equal(2)
    })
  })

  describe('#getDefaultScoringData', () => {
    it('returns the correct scoringData object with default scoreMethod', () => {
      const intData = intType.getDefaultInteractionData()
      const scoring = intType.getDefaultScoringData(intData)
      const [catId1, catId2] = Object.keys(intData.categories)
      const [distId1, distId2] = Object.keys(intData.distractors)
      expect(scoring).to.deep.equal({
        scoreMethod: 'all_or_nothing',
        value: [
          {id: catId1, scoringAlgorithm: 'AllOrNothing', scoringData: {value: [distId1]}},
          {id: catId2, scoringAlgorithm: 'AllOrNothing', scoringData: {value: [distId2]}},
        ],
      })
    })

    it('returns scoreMethod "partial_credit" when passed as parameter', () => {
      const intData = intType.getDefaultInteractionData()
      const scoring = intType.getDefaultScoringData(intData, 'partial_credit')
      const [catId1, catId2] = Object.keys(intData.categories)
      const [distId1, distId2] = Object.keys(intData.distractors)
      expect(scoring).to.deep.equal({
        scoreMethod: 'partial_credit',
        value: [
          {id: catId1, scoringAlgorithm: 'AllOrNothing', scoringData: {value: [distId1]}},
          {id: catId2, scoringAlgorithm: 'AllOrNothing', scoringData: {value: [distId2]}},
        ],
      })
    })

    it('returns scoreMethod "all_or_nothing" when explicitly passed as parameter', () => {
      const intData = intType.getDefaultInteractionData()
      const scoring = intType.getDefaultScoringData(intData, 'all_or_nothing')
      const [catId1, catId2] = Object.keys(intData.categories)
      const [distId1, distId2] = Object.keys(intData.distractors)
      expect(scoring).to.deep.equal({
        scoreMethod: 'all_or_nothing',
        value: [
          {id: catId1, scoringAlgorithm: 'AllOrNothing', scoringData: {value: [distId1]}},
          {id: catId2, scoringAlgorithm: 'AllOrNothing', scoringData: {value: [distId2]}},
        ],
      })
    })
  })

  describe('#getDefaultUserResponse', () => {
    it('returns a well-formatted response', () => {
      const intData = intType.getDefaultInteractionData()
      const userResponse = intType.getDefaultUserResponse(intData)

      expect(isuuid(userResponse.value[0].id)).to.be.true()
      expect(userResponse.value[0].value).to.be.eql([])
      expect(userResponse.value[0].type).to.be.equal('ArrayText')
    })
  })

  describe('#validations', () => {
    const IntTypeRecord = CategorizationInteractionType
    const validations = IntTypeRecord.validations({
      interactionData: {
        categories: {
          1: {id: 1, itemBody: ''},
          2: {id: 2, itemBody: ''},
        },
        distractors: {
          1: {id: 1, itemBody: ''},
          2: {id: 2, itemBody: ''},
          3: {id: 3, itemBody: ''},
        },
      },
      scoringData: {value: []},
    })

    it('outputs a hash that gives category, distractor, and scoringData validation rules', () => {
      expect(validations.interactionData.categories.length).to.be.equal(2)
      expect(validations.interactionData.distractors.length).to.be.equal(2)
      expect(validations.scoringData.value.length).to.be.equal(1)
    })
  })

  describe('#hasResponse', () => {
    it('returns true when there is at least one item in a category', () => {
      const resp = [{value: []}, {value: [5]}]
      expect(intType.hasResponse(resp)).to.be.true()
    })

    it('returns false when all categories are empty', () => {
      const resp = [{value: []}, {value: []}]
      expect(intType.hasResponse(resp)).to.be.false()
    })
  })

  const interactionData = {
    categories: {
      uuid1: {id: 'uuid1', itemBody: 'a'},
      uuid2: {id: 'uuid2', itemBody: 'b'},
    },
    distractors: {
      uuid3: {id: 'uuid3', itemBody: 'c'},
      uuid4: {id: 'uuid4', itemBody: 'd'},
      uuid5: {id: 'uuid5', itemBody: 'e'},
    },
  }
  const validResponse = [
    {
      id: 'uuid1',
      value: ['uuid3', 'uuid5'],
      type: 'ArrayText',
    },
  ]
  const invalidResponse = [
    {
      id: 'uuid1',
      value: ['uuid6', 'uuid5'],
      type: 'ArrayText',
    },
  ]

  checkUserResponseTransform(
    new CategorizationInteractionType(),
    {response: validResponse, interactionData, expected: 'Category: a | Distractors: c, e'},
    {response: invalidResponse, interactionData, expected: 'Category: a | Distractors: , e'},
    out => out.props.children,
  )
})