자바스크립트에 불시착

const TreatApplication = require("../../../src/applications/TreatApplication")
const application = new TreatApplication()

describe('디어쏘기 지역인지 확인하다', function () {
    beforeEach(() => {
        application._experimentAreaService._otherServerConnector.getAreaPolicy = jest.fn()
        application._experimentAreaService._experimentalAreaRepo.findAllByAreaId = jest.fn()
    })

describe('디어쏘기 지역인지 확인하다', function () {
    beforeEach(() => {
        application._experimentAreaService._otherServerConnector.getAreaPolicy = jest.fn()
        application._experimentAreaService._experimentalAreaRepo.findAllByAreaId = jest.fn()
    })

    test('디어쏘기 대상 지역이 아니라면 디어쏘기를 보여주지 않는다', async () => {
        // given
        application._experimentAreaService._otherServerConnector.getAreaPolicy.mockReturnValue(
            { areaId: 1 }
        )
        application._experimentAreaService._experimentalAreaRepo.findAllByAreaId.mockReturnValue(
            [ { area_id: 1, type: 'SHOP' } ]
        )

        // when
        const result = await application.shouldDisplay(37.123, 127.1234, moment())

        // then
        expect(result).toEqual(false)
    })

    test('디어쏘기 대상 지역이라면 디어쏘기를 보여준다', async () => {
        // given
        application._experimentAreaService._otherServerConnector.getAreaPolicy.mockReturnValue(
            { areaId: 1 }
        )
        application._experimentAreaService._experimentalAreaRepo.findAllByAreaId.mockReturnValue(
            [ { area_id: 1, type: 'TREAT' } ]
        )

        // when
        const result = await application.shouldDisplay(37.123, 127.1234, moment())

        // then
        expect(result).toEqual(true)
    })
})

describe('디어쏘기 공유 코드를 발급한다.', function () {

    // 코드를 발급하는 메서드 issueUrl(userId, latitude, longitude, now)
    
    test('디어쏘기 대상 지역이 아니라면 발급하지 않는다.', async () => {
        ...
        // when & then
        await expect(application.issueUrl(1, 37.123, 127.1234, moment()))
            .rejects.toThrowError(new IllegalArgumentError('디어쏘기 시행 지역이 아니에요.'))
    })

    test('미납 상태인 이용자에겐 발급하지 않는다.', async () => {
        ...
        // when & then
        await expect(application.issueUrl(1, 37.123, 127.1234, moment()))
            .rejects.toThrowError(new IllegalArgumentError('미납한 이용이 있으면 디어쏘기를 보낼 수 없어요. \n결제를 진행해주세요.'))
    })

describe('디어쏘기로 회원가입 또는 로그인했다면 기록을 남긴다', function () {

    test('기존 유저라면 로그인으로 기록을 남긴다', async () => {
        ...
        // when 
        await application.saveTreatAuthHistory(userId, false, now)

        // then
        expect(application._treatService._treatAuthHistoryRepo.save).toHaveBeenCalledWith(userId, LOGIN, toIsoDateTime(now))
    })

    test('신규 유저라면 회원가입으로 기록을 남긴다', async () => {
        ...
        // when
        await application.saveTreatAuthHistory(userId, true, now)

        // then
        expect(application._treatService._treatAuthHistoryRepo.save).toHaveBeenCalledWith(userId, SIGN_UP, toIsoDateTime(now))
    })
})

describe('결제수단 카드 등록 시 개인 카드라면 본인 명의인지 확인한다', function () {

    test('법인 카드라면 명의를 확인하지 않는다', async () => {
    })

    describe('개인 카드일 때, 유저의 생년월일과 카드의 생년월일이 일치하는지 확인한다', function () {

        test('일치하지 않으면 본인 명의가 아니라고 판단한다', async () => {
        })

        test('일치하면 본인 명의라고 판단한다', async () => {
        })
    })
})

async checkUnpaidOfUser (userId) {
    const unpaidUseAmount = await this._getUserUnpaidUsePayment(userId)
    return !!(unpaidUseAmount)
}

async _getUserUnpaidUsePayment (userId) {
    const lastUse = await this._useRepo.getLastUseByUserId(userId)
    if (!lastUse) {
        return 0
    }
    if (lastUse.pay_fail_at === null || lastUse.pay_at) {
        return 0
    }
    if (lastUse.pay_refund) {
        if (lastUse.pay_refund_amount !== null) {
            return lastUse.pay_riding + lastUse.pay_reservation + Number(lastUse.additional_charge) - lastUse.pay_discount - lastUse.pay_refund_amount
        }
        return 0
    }
    return lastUse.pay_final
}

/**
 * @param {number} userId
 * @return {Promise<boolean>}
 */
async checkUnpaidOfUser (userId) {
    return this._isUserHasUnpaidUse(userId)
}

/**
 * @param {number} userId
 * @return {Promise<boolean>}
 * @private
 */
async _isUserHasUnpaidUse (userId) {
    const lastUseRow = await this._useRepo.getLastUseByUserId(userId)
    if (!lastUseRow) {
        return false
    }
    const lastUse = new Use(lastUseRow)
    return !lastUse.isPaid()
}

class Use {

    /**
     * @return {boolean}
     */
    isPaid() {
        const paid = this.payAt || !this.payFailAt
        return paid || this._isFullRefunded() || this._doesNotHavePayRemainAfterPartialRefunded() || this.payFinal === 0
    }

    /**
     * @return {boolean}
     */
    _isFullRefunded() {
        return Boolean(this.payRefund && !this.payRefundAmount)
    }

    /**
     * @return {boolean}
     */
    _isPartialRefunded() {
        return Boolean(this.payRefund && this.payRefundAmount)
    }

    /**
     * @return {boolean}
     */
    _doesNotHavePayRemainAfterPartialRefunded() {
        return this._isPartialRefunded() &&
            (this.payRiding + this.payReservation + Number(this.additionalCharge) - this.payDiscount - this.payRefundAmount <= 0)
    }
}

// before
async getPolicy(requestAt) {
    try {
        const response = await this._client.get('/policy', { requestAt })
        return response.data;
    } catch (err) {
        throw new ExternalServerError(err.response.data.message);
    }
}

// after
/**
* @param {moment.Moment} requestAt
* @return {Promise<PolicyResponse>}
*/
async getPolicy(requestAt) {
    try {
        const response = await this._client.get('/policy', { requestAt })
        return new PolicyResponse(response.data);
    } catch (err) {
        throw new ExternalServerError(err.response.data.message);
    }
}

class PolicyResponse {

    constructor(data) {
        /**
         * @type {number}
         */
        this.id = data.id;

        /**
         * @type {string}
         */
        this.status = data.status;

        /**
         * @type {RuleResponse[]}
         */
        this.rules = data.rules.map((it) => new RuleResponse(it));
    }

    /**
     * @returns {boolean}
     */
    isStopped() {
        return this.status === 'STOP'
    }
}

class RuleResponse {

    constructor(data) {
        /**
         * @type {number}
         */
        this.id = data.id;

        /**
         * @type {string}
         */
        this.name = data.name;
    }
}

/**
 * @param {number} userId
 * @param {number} landmarkId
 * @param {moment.Moment} visitedAt
 * @return {Promise<void>}
*/
async visitLandmark(userId, landmarkId, visitedAt) { }

 /**
  * @param {() => Promise<*>} request
  * @param {number} retryCount
  * @return {Promise<*>}
 */
async requestWithRetry(request, retryCount) { ... }

/**
 * @param {number} count
 * @return {Promise<{useId: number, eventId: number}[]>}
 * @param {number} userId
*/
findByUserIdOrderByADesc(userId) {
    const queryString = `
        select u.id as useId, e.id as eventId
        from use u 
                left join event e on u.id = e.use_id
        where u.user_id = ?
        order by u.id desc
    `
    return this._selectPluralRead(queryString, [userId])
}

/**
 * @typedef {Object} UseEvent
 * @property {number} use_id
 * @property {number | undefined} event_id
*/

/**
 * @param {number} userId
 * @return {Promise<UseEvent[]>}
*/
findByUserIdOrderByUseDesc(userId) { ... }