Start of diamond heart kata using property based testing (Code Retreat 2021-01-16)

property-based-testing.ts

import {
  allOf,
  assertThat,
  describe,
  equalTo,
  everyItem,
  greaterThanOrEqualTo,
  hasProperty, hasSize,
  lessThanOrEqualTo
} from 'hamjest';


// Input: C -> 3 * 2 - 1
//   A
//  B B
// C   C
//  B B
//   A

// Input: B
//   A
//  B B
//   A

// Input: A
//   A


function getOrdinal(char: string) {
  return char.charCodeAt(0) - 'A'.charCodeAt(0) + 1;
}

const CHARACTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
function randomChar() {
  return CHARACTERS[Math.floor(CHARACTERS.length * Math.random())]
}

function diamondSideLength(char: string) {
  return getOrdinal(char) * 2 - 1;
}


function getLines(string: String) {
  return string.split('\n')
}


function createDiamondForCharacter(char: string) {
  let strings = []
  let sideLength = diamondSideLength(char);

  for(let i = 0; i < sideLength; i++) {
    strings.push(Array(sideLength).join(' ') + 'U')
  }

  return strings.join('\n')
}

function testPropertiesOf(char:string) {
  it(`height of diamond ${char} is related on character`, () => {

    const diamond = createDiamondForCharacter(char)
    assertThat(getLines(diamond).length, equalTo(diamondSideLength(char)))
  })

  it(`width of diamond ${char} is related to character`, () => {
    const diamond = createDiamondForCharacter(char)
    assertThat(getLines(diamond),
        everyItem(hasSize(diamondSideLength(char))))
  })

  it('corner character only exists once', () => {
    const diamond = createDiamondForCharacter(char)
    const lines = getLines(diamond);

    assertThat(lines[0].trim(), hasSize(1))
    assertThat(lines[lines.length - 1].trim(), hasSize(1))
  })
}

for (let i = 0; i < 100; i++) {
  testPropertiesOf(randomChar())
}

it('getOrdinal A', () => {
  assertThat(getOrdinal('A'), equalTo(1))
})

it('getOrdinal B', () => {
  assertThat(getOrdinal('B'), equalTo(2))
})

it('randomChar returns latin character', () => {
  for (let i = 0; i < 1000; i++) {
    assertThat(getOrdinal(randomChar()), allOf(
        greaterThanOrEqualTo(getOrdinal('A')),
        lessThanOrEqualTo(getOrdinal('Z'))
    ))
  }
})

it('randomChar returns distinct characters', () => {
  const chars: Record<string, boolean> = {}
  for (let i = 0; i < 1000; i++) {
    chars[randomChar()] = true
  }
  assertThat(Object.keys(chars), hasProperty('length', greaterThanOrEqualTo(26)))
})