intojs

describe('calculateLoan', () => {
  let request: CalculateLoanReq;

  beforeEach(async () => {
    request = {
      emailAddress: 'john.doe@email.com',
      loanAmount: 10000,
      loanTerm: 5,
      lifeInsuranceOptIn: true,
    };

intojs

export const calculateLoan = async (request: CalculateLoanReq): Promise<CalculateLoanRes> => {
  const { lifeInsuranceOptIn } = request;

  const emailAddress = new EmailAddress(request.emailAddress);
  const loanAmount = new LoanAmount(request.loanAmount);
  const loanTerm = new LoanTerm(request.loanTerm);
  const interestRate = new InterestRate(loanTerm, lifeInsuranceOptIn);
  const monthlyPayment = new MonthlyPayment({
    interestRate,
    loanAmount,

intojs

import { createGameFactory } from './gameplay/createGameFactory';
import { PlayerManager } from './player/PlayerManager';
import { calculateScore } from './score/calculateScore';

export const createGame = createGameFactory(PlayerManager, calculateScore);

intojs

import { CalculateScore } from '../gameplay/CalculateScore';

const pointSynonyms = ['Love', 'Fifteen', 'Thirty', 'Forty'];

const getPointSynonym = (point: number) => pointSynonyms[point];

const pointsAreEqual = (playerOnePoints: number, playerTwoPoints: number) => playerOnePoints === playerTwoPoints;

const isAll = (playerOnePoints: number, playerTwoPoints: number) => {
  return pointsAreEqual(playerOnePoints, playerTwoPoints) && playerOnePoints < 3;

intojs

import { ManagePlayers } from '../gameplay/ManagePlayers';
import { Player } from '../gameplay/Player';

const createPlayer = (name: string, points?: number): Player => ({name, points: points || 0});

const getName = (player: Player): string => player.name;

const getPoints = (player: Player): number => player.points;

const hasName = (name: string, player: Player): boolean => name === player.name;

intojs

import { TennisGame } from './TennisGame';
import { ManagePlayers } from './ManagePlayers';
import { CalculateScore } from './CalculateScore';

export const createGameFactory = (playerManager: ManagePlayers, calculateScore: CalculateScore) =>
  (playerOneName: string, playerTwoName: string): TennisGame => {
    let playerOne = playerManager.createPlayer(playerOneName);
    let playerTwo = playerManager.createPlayer(playerTwoName);

    const wonPoint = (playerName: string): void => {

intojs

export type CalculateScore = (playerOnePoints: number, playerTwoPoints: number) => string;

intojs

export interface TennisGame {
  wonPoint(playerName: string): void;
  getScore(): void;
}

intojs

import { Player } from './Player';

export interface ManagePlayers {
  createPlayer(name: string, points?: number): Player;
  getName(player: Player): string;
  getPoints(player: Player): number;
  hasName(name: string, player: Player): boolean;
  incrementPoints(player: Player): Player;
}

intojs

export interface Player {
  name: string;
  points: number;
}