fp-ts로 Typescript 함수형 프로그래밍 시작하기 0

import { Option, none, some } from 'fp-ts/Option';

function findIndex<A>(
  as: Array<A>,
  predicate: (a: A) => boolean
): Option<number> {
  const index = as.findIndex(predicate);
  return index === -1 ? none : some(index);
}

import * as N from 'fp-ts/number';
import { isSome, none, some, getEq, Option, isNone } from 'fp-ts/lib/Option';
import { findIndex } from '../findIndex';

describe('findIndex함수 테스트 (Sentinels)', () => {
  let array: number[] = [1, 2, 3, 5];
  let result: Option<number>;
  const E = getEq(N.Eq);
  it('findIndex함수가 존재하는 값을 찾았을 경우', () => {
    result = findIndex(array, a => a === 1);
    expect(isSome(result)).toBeTruthy();
    expect(E.equals(result, some(0))).toBeTruthy();
  });
  it('findIndex함수가 값을 찾지 못했을 경우', () => {
    result = findIndex(array, a => a === 4);
    expect(isNone(result)).toBeTruthy();
    expect(E.equals(result, none)).toBeTruthy();
  });
});

import { Option, fromNullable } from 'fp-ts/Option';

export function find<A>(as: Array<A>, predicate: (a: A) => boolean): Option<A> {
  return fromNullable(as.find(predicate));
}

import * as N from 'fp-ts/number';
import { isSome, none, some, getEq, Option, isNone } from 'fp-ts/lib/Option';
import { find } from '../find';

describe('find함수 테스트 (undefined와 null)', () => {
  let array: number[] = [1, 2, 3, 5];
  let result: Option<number>;
  const E = getEq(N.Eq);
  it('find함수가 존재하는 값을 찾았을 경우', () => {
    result = find(array, a => a === 1);
    expect(isSome(result)).toBeTruthy();
    expect(E.equals(result, some(1))).toBeTruthy();
  });
  it('find함수가 값을 찾지 못했을 경우', () => {
    result = find(array, a => a === 4);
    expect(isNone(result)).toBeTruthy();
    expect(E.equals(result, none)).toBeTruthy();
  });
});

import { Either, tryCatch } from 'fp-ts/Either';

function parse(s: string): Either<Error, unknown> {
  return tryCatch(
    () => JSON.parse(s),
    reason => new Error(String(reason))
  );
}

import { isLeft, isRight, getOrElse } from 'fp-ts/Either';
import { parse } from '../parse';

describe('parse함수 테스트 (예외)', () => {
  const success = '{"a": 1, "b": 2}';
  const fail = '{"a": 1, "b"}';
  let result;
  it('parse함수가 정상적으로 실행됐을 경우', () => {
    result = parse(success);
    expect(isRight(result)).toBeTruthy();
    expect(getOrElse(() => ({ error: true }))(result)).toMatchObject({
      a: 1,
      b: 2,
    });
  });
  it('parse함수 실행 중 예외가 발생했을 경우', () => {
    result = parse(fail);
    expect(isLeft(result)).toBeTruthy();
    expect(getOrElse(() => ({ a: 1 }))(result)).toMatchObject({
      a: 1,
    });
  });
});

import { IO } from 'fp-ts/IO';

const random: IO<number> = () => Math.random();

import { random } from '../random';

describe('random함수 테스트 (랜덤)', () => {
  let result;
  it('Math.random함수를 mocking해 테스트하기', () => {
    Math.random = jest.fn().mockReturnValue(0.5);
    result = random();
    expect(result).toBe(0.5);
  });
});

import { Option, fromNullable } from 'fp-ts/Option';
import { IO } from 'fp-ts/IO';

function getItem(key: string): IO<Option<string>> {
  return () => fromNullable(localStorage.getItem(key));
}

import * as S from 'fp-ts/string';
import { isSome, isNone, none, some, getEq, Option } from 'fp-ts/Option';
import { getItem } from '../getItem';

describe('getItem함수 테스트 (동기 부수 효과)', () => {
  window.localStorage.__proto__.getItem = jest.fn(key => {
    if (key === 'success') return 'success';
    return null;
  });
  let result: Option<string>;
  const E = getEq(S.Eq);
  it('getItem함수가 값을 정상적으로 가져온 경우', () => {
    result = getItem('success')();
    expect(isSome(result)).toBeTruthy();
    expect(E.equals(result, some('success'))).toBeTruthy();
  });
  it('getItem함수가 값을 가져오지 못했을 경우', () => {
    result = getItem('fail')();
    expect(isNone(result)).toBeTruthy();
    expect(E.equals(result, none)).toBeTruthy();
  });
});

import * as fs from 'fs';
import { IOEither, tryCatch } from 'fp-ts/IOEither';

function readFileSync(path: string): IOEither<Error, string> {
  return tryCatch(
    () => fs.readFileSync(path, 'utf8'),
    reason => new Error(String(reason))
  );
}

import * as fs from 'fs';
import { Either, isRight, getOrElse, isLeft } from 'fp-ts/lib/Either';
import { readFileSync } from '../readFileSync';

describe('readFileSync함수 테스트 (동기 부수 효과)', () => {
  jest.spyOn(fs, 'readFileSync').mockImplementation(path => {
    if (path === 'success.txt') return 'success';
    throw new Error(`${path} is not found.`);
  });
  let result: Either<Error, string>;
  it('readFileSync가 정상적으로 값을 가져왔을 경우', () => {
    result = readFileSync('success.txt')();
    expect(isRight(result)).toBeTruthy();
    expect(getOrElse(() => 'fail')(result)).toBe('success');
  });
  it('readFileSync함수 실행 중 예외가 발생했을 경우', () => {
    result = readFileSync('fail.txt')();
    expect(isLeft(result)).toBeTruthy();
    expect(getOrElse(() => 'fail')(result)).toBe('fail');
  });
});

import { createInterface } from 'readline';
import { Task } from 'fp-ts/Task';

const read: Task<string> = () =>
  new Promise<string>(resolve => {
    const rl = createInterface({
      input: process.stdin,
      output: process.stdout,
    });
    rl.question('', answer => {
      rl.close();
      resolve(answer);
    });
  });

module.exports = {
  createInterface: jest.fn().mockReturnValue({
    question: jest.fn().mockImplementationOnce((questionText, cb) => {
      cb('success');
    }),
    close: () => undefined,
  }),
};

import { read } from '../read';

jest.mock('readline');

describe('read함수 테스트 (비동기 부수 효과)', () => {
  it('read가 정상적으로 값을 읽었을 경우', async () => {
    const result = await read();
    expect(result).toBe('success');
  });
});

import { TaskEither, tryCatch } from 'fp-ts/TaskEither';

function get(url: string): TaskEither<Error, string> {
  return tryCatch(
    () => fetch(url).then(res => res.text()),
    reason => new Error(String(reason))
  );
}

import { Either, getOrElse, isLeft, isRight } from 'fp-ts/lib/Either';
import { get } from '../get';

describe('get함수 테스트 (비동기 부수 효과)', () => {
  global.fetch = jest.fn(url => {
    if (url === 'https://success.com') {
      return Promise.resolve({
        text: () => Promise.resolve('success'),
      }) as Promise<Response>;
    }
    return Promise.reject('fail');
  });
  let result: Either<Error, string>;
  it('get함수가 정상적으로 값을 가져왔을 경우', async () => {
    result = await get('https://success.com')();
    expect(isRight(result)).toBeTruthy();
    expect(getOrElse(() => 'fail')(result)).toBe('success');
  });
  it('get함수 실행 중 예외가 발생했을 경우', async () => {
    result = await get('https://fail.com')();
    expect(isLeft(result)).toBeTruthy();
    expect(getOrElse(() => 'fail')(result)).toBe('fail');
  });
});