Sudoku Solver test #6 not passing

Wherever I put the “{ error: “Puzzle cannot be solved” }”, test is not passing, even though I can see the JSON object say “{ error: “Puzzle cannot be solved” }” on the screen. This is the only test that I have not been able to make pass.
sudoku-solver.js code:

class SudokuSolver {

  validate(puzzleString) {
    if(puzzleString.length === 81) {
      return true;
    }

    return false;
  }

  checkRowPlacement(puzzleString, row, column, value) {
    for(let i = (row - 1) * 9; i < row * 9; i++) {
      if(puzzleString[i] == value && column!== i % 9 + 1) {
        return false;
      }
    }

    return true;
  }

  checkColPlacement(puzzleString, row, column, value) {
    for(let i = column - 1; i < 81; i += 9) {
      if(puzzleString[i] == value && Math.floor(i / 9) !== row - 1) {
        return false;
      }
    }

    return true;
  }

  checkRegionPlacement(puzzleString, row, column, value) {
    let k = 0;
    let l = 0;
    
    if(row <= 3) {
      k = 0;
      if(column <= 3) {
        l = 0;
      } else if(column <= 6) {
        l = 3;
      } else if(column <= 9) {
        l = 6;
      }
    } else if(row <= 6) {
      k = 3;
      if(column <= 3) {
        l = 0;
      } else if(column <= 6) {
        l = 3;
      } else if(column <= 9) {
        l = 6;
      }
    } else if(row <= 9) {
      k = 6;
      if(column <= 3) {
        l = 0;
      } else if(column <= 6) {
        l = 3;
      } else if(column <= 9) {
        l = 6;
      }
    }

    for(let i = k; i < k + 3; i++) {
      for(let j = l; j < l + 3; j++) {
        if(puzzleString[i * 9 + j] == value && !(row - 1 == k && column - 1 == l)) {
          return false;
        }
      }
    }

    return true;
  }

  solve(puzzleString) {
    let arr = [];

    for(let i = 0; i < 81; i++) {
      if(puzzleString[i] !== "." && puzzleString[i] !== "9" && puzzleString[i] !== "8" && puzzleString[i] !== "7" && puzzleString[i] !== "6" && puzzleString[i] !== "5" && puzzleString[i] !== "4" && puzzleString[i] !== "3" && puzzleString[i] !== "2" && puzzleString[i] !== "1") {
        return false;
      }
    }

    if(puzzleString.length !== 81) {
      return false;
    }

    for(let i = 0; i < 81; i++) {
      arr.push([]);
      if(puzzleString[i] === '.') {
        for(let j = 1; j <= 9; j++) {
          if(this.checkRowPlacement(puzzleString, Math.floor(i / 9) + 1, i % 9 + 1, j)) {
            if(this.checkColPlacement(puzzleString, Math.floor(i / 9) + 1, i % 9 + 1, j)) {
              if(this.checkRegionPlacement(puzzleString, Math.floor(i / 9) + 1, i % 9 + 1, j)) {
                arr[i].push(j);
              }
            }
          }
        }
      }
    }

    for(let a = 0; a < arr.length; a++) {
      for(let i = 0; i < arr.length; i++) {
        if(arr[i].length === 1 && arr[i][0]) {
          puzzleString = puzzleString.split('');
          puzzleString[i] = arr[i][0];
          puzzleString = puzzleString.join('');

          for(let j = Math.floor(i / 9) * 9; j < Math.floor(i / 9) * 9 + 9; j++) {
            if(arr[j].includes(arr[i][0]) && j !== i) {
              arr[j].splice(arr[j].indexOf(arr[i][0]), 1);
            }
          }

          for(let j = i % 9; j <= i % 9 + 72; j += 9) {
            if(arr[j].includes(arr[i][0]) && i !== j) {
              arr[j].splice(arr[j].indexOf(arr[i][0]), 1);
            }
          }

          let k = 0;
          let l = 0;
          
          if(Math.floor(i / 9) + 1 <= 3) {
            k = 0;
            if(i % 9 + 1 <= 3) {
              l = 0;
            } else if(i % 9 + 1 <= 6) {
              l = 3;
            } else if(i % 9 + 1 <= 9) {
              l = 6;
            }
          } else if(Math.floor(i / 9) + 1 <= 6) {
            k = 3;
            if(i % 9 + 1 <= 3) {
              l = 0;
            } else if(i % 9 + 1 <= 6) {
              l = 3;
            } else if(i % 9 + 1 <= 9) {
              l = 6;
            }
          } else if(Math.floor(i / 9) + 1 <= 9) {
            k = 6;
            if(i % 9 + 1 <= 3) {
              l = 0;
            } else if(i % 9 + 1 <= 6) {
              l = 3;
            } else if(i % 9 + 1 <= 9) {
              l = 6;
            }
          }
      
          for(let b = k; b < k + 3; b++) {
            for(let j = l; j < l + 3; j++) {
              if(arr[b * 9 + j].includes(arr[i][0]) && b * 9 + j !== i) {
                arr[b * 9 + j].splice(arr[b * 9 + j].indexOf(arr[i][0]), 1);
              }
            }
          }

          arr[i].pop();
        }
      }
    }

    for(let i = 0; i < arr.length; i++) {
      if(arr[i].length > 0) {
        return false;
      }
    }

    return puzzleString;
  }
}

module.exports = SudokuSolver;


api.js code:

'use strict';

const SudokuSolver = require('../controllers/sudoku-solver.js');
const bodyParser = require("body-parser");

module.exports = function (app) {

  app.use(bodyParser());
  
  let solver = new SudokuSolver();

  app.route('/api/check')
    .post((req, res) => {
      let row = 0;
      let column = 0;
      let valid = true;
      let conflict = [];
      let value = req.body.value;
      let coordinate = req.body.coordinate;
      let puzzle = req.body.puzzle;
      let regexp = /[A-I][1-9]/gi;

      if(!coordinate || !puzzle || !value) {
        res.json({ error: "Required field(s) missing" });
      }

      if(!regexp.test(coordinate) || coordinate.length > 2) {
        res.json({ error: "Invalid coordinate" });
      }

      regexp = /[1-9]/gi;

      if(!regexp.test(value) || value.length > 1) {
        res.json({ error: "Invalid value" });
      }

      if(puzzle.length !== 81) {
        res.json({ error: "Expected puzzle to be 81 characters long" });
      }

      for(let i = 0; i < 81; i++) {
        if(puzzle[i] !== "." && puzzle[i] !== "9" && puzzle[i] !== "8" && puzzle[i] !== "7" && puzzle[i] !== "6" && puzzle[i] !== "5" && puzzle[i] !== "4" && puzzle[i] !== "3" && puzzle[i] !== "2" && puzzle[i] !== "1") {
          res.json({ error: "Invalid characters in puzzle" });
        }
      }

      if(req.body.coordinate[0] === 'A') {
        row = 1;
      } else if(req.body.coordinate[0] === 'B') {
        row = 2;
      } else if(req.body.coordinate[0] === 'C') {
        row = 3;
      } else if(req.body.coordinate[0] === 'D') {
        row = 4;
      } else if(req.body.coordinate[0] === 'E') {
        row = 5;
      } else if(req.body.coordinate[0] === 'F') {
        row = 6;
      } else if(req.body.coordinate[0] === 'G') {
        row = 7;
      } else if(req.body.coordinate[0] === 'H') {
        row = 8;
      } else if(req.body.coordinate[0] === 'I') {
        row = 9;
      }

      column = Number(req.body.coordinate[1]);

      if(!solver.checkRowPlacement(req.body.puzzle, row, column, Number(req.body.value))) {
        valid = false;
        conflict.push("row");
      }

      if(!solver.checkColPlacement(req.body.puzzle, row, column, Number(req.body.value))) {
        valid = false;
        conflict.push("column");
      }

      if(!solver.checkRegionPlacement(req.body.puzzle, row, column, Number(req.body.value))) {
        valid = false;
        conflict.push("region");
      }

        if(req.body.puzzle[(row - 1) * 9 + column - 1] !== ".") {
          if(solver.checkRegionPlacement && solver.checkColPlacement && solver.checkRowPlacement) {
            res.json({ valid: true });
          }

          res.json({ valid: false });
        }

      if(valid) {
        res.json({ valid: valid });
      }

      res.json({ valid: valid, conflict: conflict });
    });
    
  app.route('/api/solve')
    .post((req, res) => {
      let puzzle = req.body.puzzle;

      if(!puzzle) {
        res.json({ error: "Required field missing" });
      }

      if(puzzle.length !== 81) {
        res.json({ error: "Expected puzzle to be 81 characters long" });
      }

      for(let i = 0; i < 81; i++) {
        if(puzzle[i] !== "." && puzzle[i] !== "9" && puzzle[i] !== "8" && puzzle[i] !== "7" && puzzle[i] !== "6" && puzzle[i] !== "5" && puzzle[i] !== "4" && puzzle[i] !== "3" && puzzle[i] !== "2" && puzzle[i] !== "1") {
          res.json({ error: "Invalid characters in puzzle" });
        }
      }

      if(!solver.solve(puzzle)) {
        res.json({ error: "Puzzle cannot be solved" });
      }

      res.json({ solution: solver.solve(puzzle) });
    });
};