Files
sodalive-vuejs-admin/tests/sub_banner.test.js
T
Yu Sung 1ba1311373 feat(sub-banner): 서브 배너 생성·수정 폼에 언어 선택 추가
- 생성·수정 폼에 KO/JA/EN 언어 select 추가 (신규 기본값 KO, 수정은 저장된 lang 유지)
- multipart request JSON 파트에 정규 대문자 lang 을 항상 포함해 전송
- 목록에 언어 열 추가, lang 누락 응답은 KO 로 간주하지 않고 계약 미충족 안내
- EN 은 현재 앱 공개 국가 매핑에서 미노출됨을 폼에 안내
- 400 등 4xx 거부 시 입력값·선택 파일·날짜를 보존하고 재전송을 막지 않도록 처리
- 언어 관련 focused test 추가
2026-11-03 02:17:03 +09:00

709 lines
29 KiB
JavaScript

const assert = require('assert').strict
const fs = require('fs')
const path = require('path')
const Module = require('module')
const { transformSync } = require('@babel/core')
const compiler = require('vue-template-compiler')
const Vue = require('vue')
const root = path.resolve(__dirname, '..')
const originalResolve = Module._resolveFilename
Module._resolveFilename = function(request, parent, ...rest) {
return originalResolve.call(this, request.startsWith('@/') ? path.join(root, 'src', request.slice(2)) : request, parent, ...rest)
}
const originalJs = require.extensions['.js']
function compileScript(source, filename) {
return transformSync(source, {
filename,
babelrc: false,
configFile: false,
plugins: ['@babel/plugin-transform-modules-commonjs']
}).code
}
require.extensions['.js'] = (module, filename) => {
if (!filename.startsWith(path.join(root, 'src') + path.sep)) return originalJs(module, filename)
module._compile(compileScript(fs.readFileSync(filename, 'utf8'), filename), filename)
}
require.extensions['.vue'] = (module, filename) => {
const { script, template } = compiler.parseComponent(fs.readFileSync(filename, 'utf8'))
const compiled = compiler.compile(template.content)
assert.deepEqual(compiled.errors, [], `${filename}: 템플릿 컴파일`)
module._compile(compileScript(script.content, filename), filename)
Object.assign(module.exports.default, compiler.compileToFunctions(template.content))
}
const utils = require('../src/utils/sub_banner')
const {
buildSubBannerCreateRequest,
buildSubBannerUpdateRequest,
createSubBannerForm,
formatScheduleRange,
langLabel,
normalizeUrls,
placementLabel,
resolveSubBannerTarget,
scheduleStatus,
toDateTimeLocalInput,
toServerDateTime,
validateSubBannerForm,
validateSubBannerUrls
} = utils
const SubBanner = require('../src/views/Promotion/SubBannerView.vue').default
const tests = []
const test = (name, run) => tests.push({ name, run })
const envelope = (data, success = true, message = null) => ({ success, message, data, errorProperty: null })
const subBanner = (overrides = {}) => ({
id: 1,
placement: 'HOME_RECOMMENDATION',
lang: 'KO',
imageUrl: 'https://cdn.example.test/promo.jpg',
webUrl: 'https://example.test/promo',
androidDeepLink: null,
iosDeepLink: null,
startDate: null,
endDate: null,
...overrides
})
const form = (overrides = {}) => ({ ...createSubBannerForm(), ...overrides })
function nodes(vnode) {
if (!vnode) return []
return [vnode].concat((vnode.children || (vnode.componentOptions && vnode.componentOptions.children) || []).flatMap(nodes))
}
const text = vnode => nodes(vnode).map(node => node.text || '').join(' ')
function activatorNodes(vm) {
const dialog = nodes(vm._render()).find(node => node.tag === 'v-dialog' && node.data.scopedSlots && node.data.scopedSlots.activator)
return [].concat(dialog.data.scopedSlots.activator({ on: {}, attrs: {} }))
}
const activatorText = vm => activatorNodes(vm).flatMap(nodes).map(node => node.text || '').join(' ')
function page() {
const errors = []
const successes = []
const vm = new Vue({ ...SubBanner, created: undefined })
vm.$dialog = { notify: { error: message => errors.push(message), success: message => successes.push(message) } }
return { vm, errors, successes }
}
function stubFormData() {
global.Blob = class {
constructor(parts, options) { this.parts = parts; this.type = options && options.type }
toString() { return this.parts.join('') }
}
global.FormData = class {
constructor() { this.store = new Map() }
append(key, value) { this.store.set(key, value) }
get(key) { return this.store.has(key) ? this.store.get(key) : null }
has(key) { return this.store.has(key) }
}
global.URL.createObjectURL = () => 'blob:preview'
}
function requestPart(formData) {
return formData.get('request')
}
function requestOf(formData) {
return JSON.parse(String(requestPart(formData)))
}
const URL_COMBINATIONS = [
{ web: false, android: false, ios: false, valid: false, androidTarget: 'NONE', iosTarget: 'NONE' },
{ web: true, android: false, ios: false, valid: true, androidTarget: 'WEB', iosTarget: 'WEB' },
{ web: false, android: true, ios: false, valid: true, androidTarget: 'DEEP_LINK', iosTarget: 'NONE' },
{ web: false, android: false, ios: true, valid: true, androidTarget: 'NONE', iosTarget: 'DEEP_LINK' },
{ web: true, android: true, ios: false, valid: true, androidTarget: 'DEEP_LINK_WITH_WEB_FALLBACK', iosTarget: 'WEB' },
{ web: true, android: false, ios: true, valid: true, androidTarget: 'WEB', iosTarget: 'DEEP_LINK_WITH_WEB_FALLBACK' },
{ web: false, android: true, ios: true, valid: true, androidTarget: 'DEEP_LINK', iosTarget: 'DEEP_LINK' },
{ web: true, android: true, ios: true, valid: true, androidTarget: 'DEEP_LINK_WITH_WEB_FALLBACK', iosTarget: 'DEEP_LINK_WITH_WEB_FALLBACK' }
]
test('placement: 두 값만 사용하고 레이블은 홈/콘텐츠로 표시한다', () => {
assert.deepEqual(utils.SUB_BANNER_PLACEMENTS.map(item => item.value), ['HOME_RECOMMENDATION', 'CONTENT_RECOMMENDATION'])
assert.equal(placementLabel('HOME_RECOMMENDATION'), '홈')
assert.equal(placementLabel('CONTENT_RECOMMENDATION'), '콘텐츠')
assert.equal(utils.isSubBannerPlacement('ETC'), false)
const { vm } = page()
const labels = nodes(vm._render()).filter(node => node.tag === 'v-radio').map(node => node.data.attrs.label)
assert.ok(labels.includes('홈') && labels.includes('콘텐츠'))
})
test('주소 조합 여덟 가지: 최소 한 개 요구와 Android/iOS 대상 판단', () => {
for (const combination of URL_COMBINATIONS) {
const current = form({
web_url: combination.web ? 'https://example.test/promo' : '',
android_deep_link: combination.android ? 'sampleapp://promo' : '',
ios_deep_link: combination.ios ? 'sampleapp://promo' : ''
})
const errors = validateSubBannerUrls(current)
assert.equal(Object.keys(errors).length === 0, combination.valid, JSON.stringify(combination))
const urls = normalizeUrls(current)
assert.equal(resolveSubBannerTarget(urls, 'android'), combination.androidTarget, JSON.stringify(combination))
assert.equal(resolveSubBannerTarget(urls, 'ios'), combination.iosTarget, JSON.stringify(combination))
}
})
test('주소 정규화: 공백 trim 후 blank 는 null, nonblank 는 원형을 보존한다', () => {
const raw = 'https://example.test/promo?q=%ED%95%9C%EA%B8%80&a=b+c#frag'
assert.deepEqual(
normalizeUrls(form({ web_url: ` ${raw} `, android_deep_link: ' ', ios_deep_link: '' })),
{ webUrl: raw, androidDeepLink: null, iosDeepLink: null }
)
const request = buildSubBannerCreateRequest(form({ web_url: ` ${raw} `, placement: 'HOME_RECOMMENDATION' }))
assert.equal(request.webUrl, raw)
assert.equal(request.androidDeepLink, null)
assert.equal(request.iosDeepLink, null)
})
test('주소 검증: 절대 http(s) 웹 URL 과 거부 scheme 딥링크를 가린다', () => {
for (const valid of ['https://example.test/promo', 'http://example.test']) {
assert.deepEqual(validateSubBannerUrls(form({ web_url: valid })), {})
}
for (const invalid of ['example.test/promo', '/promo', 'ftp://example.test', 'https://']) {
assert.deepEqual(Object.keys(validateSubBannerUrls(form({ web_url: invalid }))), ['web_url'], invalid)
}
for (const denied of ['javascript:alert(1)', 'JavaScript:alert(1)', 'DATA:text/html,1', 'file:///etc/passwd', 'content://media/1']) {
assert.deepEqual(
Object.keys(validateSubBannerUrls(form({ android_deep_link: denied }))),
['android_deep_link'],
denied
)
assert.deepEqual(Object.keys(validateSubBannerUrls(form({ ios_deep_link: denied }))), ['ios_deep_link'], denied)
}
assert.deepEqual(validateSubBannerUrls(form({ ios_deep_link: 'sampleapp://promo/1?a=b' })), {})
assert.deepEqual(Object.keys(validateSubBannerUrls(form({ ios_deep_link: 'promo' }))), ['ios_deep_link'])
})
test('주소 수정: 전부 비우면 오류, 한 필드만 비우면 해당 값만 null 로 보낸다', () => {
const saved = subBanner({ androidDeepLink: 'sampleapp://promo', iosDeepLink: 'sampleapp://ios' })
const cleared = createSubBannerForm(saved)
cleared.web_url = ''
cleared.android_deep_link = ''
cleared.ios_deep_link = ''
assert.deepEqual(Object.keys(validateSubBannerForm(cleared, saved)), ['web_url'])
const one = createSubBannerForm(saved)
one.ios_deep_link = ' '
assert.deepEqual(validateSubBannerForm(one, saved), {})
assert.deepEqual(buildSubBannerUpdateRequest(one, saved), {
placement: 'HOME_RECOMMENDATION',
webUrl: 'https://example.test/promo',
androidDeepLink: 'sampleapp://promo',
iosDeepLink: null,
lang: 'KO'
})
})
test('기간 변환: KST 분 문자열을 시간대 변환 없이 왕복한다', () => {
assert.equal(toDateTimeLocalInput('2026-11-01 09:30'), '2026-11-01T09:30')
assert.equal(toServerDateTime('2026-11-01T09:30'), '2026-11-01 09:30')
assert.equal(toServerDateTime(toDateTimeLocalInput('2026-11-01 09:30')), '2026-11-01 09:30')
for (const empty of [null, undefined, '', ' ', 'null']) {
assert.equal(toDateTimeLocalInput(empty), '')
assert.equal(toServerDateTime(empty), null)
}
})
test('기간 표시/상태: 무기간, 시작만, 종료만, 양끝과 미래/현재/만료', () => {
assert.equal(formatScheduleRange(null, null), '상시 노출 (기간 제한 없음)')
assert.equal(formatScheduleRange('2026-11-01 09:30', null), '2026-11-01 09:30 ~ (KST)')
assert.equal(formatScheduleRange(null, '2026-11-30 23:59'), '~ 2026-11-30 23:59 (KST)')
assert.equal(formatScheduleRange('2026-11-01 09:30', '2026-11-30 23:59'), '2026-11-01 09:30 ~ 2026-11-30 23:59 (KST)')
const now = '2026-11-10 00:00'
assert.equal(scheduleStatus(subBanner(), now), '무기간')
assert.equal(scheduleStatus(subBanner({ startDate: '2026-12-01 00:00' }), now), '예정')
assert.equal(scheduleStatus(subBanner({ endDate: '2026-11-09 23:59' }), now), '만료')
assert.equal(scheduleStatus(subBanner({ startDate: '2026-11-01 00:00', endDate: '2026-11-30 23:59' }), now), '노출중')
})
test('기간 검증: 두 날짜 null, 한쪽만, 같은 분, 경계값, 과거 날짜를 허용한다', () => {
const valid = [
{ start_date: '', end_date: '' },
{ start_date: '2026-11-01T09:30', end_date: '' },
{ start_date: '', end_date: '2026-11-30T23:59' },
{ start_date: '2026-11-01T09:30', end_date: '2026-11-01T09:30' },
{ start_date: '2026-11-01T00:00', end_date: '2026-11-01T23:59' },
{ start_date: '1970-01-01T09:01', end_date: '1970-01-01T09:01' },
{ start_date: '2038-01-19T12:14', end_date: '' },
{ start_date: '', end_date: '2038-01-19T12:13' },
{ start_date: '1970-01-01T09:01', end_date: '2038-01-19T12:13' },
{ start_date: '2020-01-01T00:00', end_date: '2021-01-01T00:00' }
]
for (const current of valid) {
assert.deepEqual(validateSubBannerForm(form({ ...current, web_url: 'https://example.test/promo' })), {}, JSON.stringify(current))
}
assert.deepEqual(validateSubBannerForm(form({ end_date: '2038-01-19T12:13', web_url: 'https://example.test/promo' })), {})
})
test('기간 검증: 잘못된 형식/범위/역전은 거부하고 값을 보정하지 않는다', () => {
const invalidStart = [
'2026-11-01T09:30:00', '2026-11-01T09:30:30Z', '2026-11-01T09:30+09:00', '2026-11-01',
'2026-13-01T09:30', '2026-02-30T09:30', '1988-05-08T02:30', '1970-01-01T09:00', '2038-01-19T12:15'
]
for (const start_date of invalidStart) {
const errors = validateSubBannerForm(form({ start_date, web_url: 'https://example.test/promo' }))
assert.deepEqual(Object.keys(errors), ['start_date'], start_date)
}
for (const end_date of ['2038-01-19T12:14', '1969-12-31T23:59', '2026-11-01T09:30:00']) {
const errors = validateSubBannerForm(form({ end_date, web_url: 'https://example.test/promo' }))
assert.deepEqual(Object.keys(errors), ['end_date'], end_date)
}
const reversed = validateSubBannerForm(form({
web_url: 'https://example.test/promo',
start_date: '2026-11-01T09:31',
end_date: '2026-11-01T09:30'
}))
assert.deepEqual(Object.keys(reversed), ['end_date'])
assert.deepEqual(
buildSubBannerCreateRequest(form({ start_date: '2026-11-01T09:31', end_date: '2026-11-01T09:30' })).startDate,
'2026-11-01 09:31'
)
})
test('등록 요청: 네 기본 필드는 항상 보내고 날짜 미입력은 생략한다', () => {
const base = form({
placement: 'CONTENT_RECOMMENDATION',
web_url: 'https://example.test/promo',
android_deep_link: 'sampleapp://promo'
})
assert.deepEqual(buildSubBannerCreateRequest(base), {
placement: 'CONTENT_RECOMMENDATION',
webUrl: 'https://example.test/promo',
androidDeepLink: 'sampleapp://promo',
iosDeepLink: null,
lang: 'KO'
})
assert.deepEqual(buildSubBannerCreateRequest({ ...base, start_date: '2026-11-01T09:30' }).startDate, '2026-11-01 09:30')
assert.deepEqual(buildSubBannerCreateRequest({ ...base, end_date: '2026-11-30T23:59' }).endDate, '2026-11-30 23:59')
})
test('수정 요청: 미변경 경계는 생략해 보존하고 지운 경계만 null 로 해제한다', () => {
const saved = subBanner({
androidDeepLink: 'sampleapp://promo',
startDate: '2026-11-01 09:30',
endDate: '2026-11-30 23:59'
})
const base = {
placement: 'HOME_RECOMMENDATION',
webUrl: 'https://example.test/promo',
androidDeepLink: 'sampleapp://promo',
iosDeepLink: null,
lang: 'KO'
}
// loaded date 재전송: 값이 같으면 생략해 저장 값을 보존한다.
assert.deepEqual(buildSubBannerUpdateRequest(createSubBannerForm(saved), saved), base)
const clearedEnd = createSubBannerForm(saved)
clearedEnd.end_date = ''
assert.deepEqual(buildSubBannerUpdateRequest(clearedEnd, saved), { ...base, endDate: null })
const clearedBoth = createSubBannerForm(saved)
clearedBoth.start_date = ''
clearedBoth.end_date = ''
assert.deepEqual(buildSubBannerUpdateRequest(clearedBoth, saved), { ...base, startDate: null, endDate: null })
const changed = createSubBannerForm(saved)
changed.start_date = '2026-12-01T00:00'
assert.deepEqual(buildSubBannerUpdateRequest(changed, saved), { ...base, startDate: '2026-12-01 00:00' })
})
test('수정 검증: 저장된 값과 새 값의 조합으로 범위를 판단한다', () => {
const saved = subBanner({ startDate: '2026-11-01 09:30', endDate: '2026-11-30 23:59' })
const lateStart = createSubBannerForm(saved)
lateStart.start_date = '2026-12-01T00:00'
assert.deepEqual(Object.keys(validateSubBannerForm(lateStart, saved)), ['end_date'])
const clearedEnd = createSubBannerForm(saved)
clearedEnd.start_date = '2026-12-01T00:00'
clearedEnd.end_date = ''
assert.deepEqual(validateSubBannerForm(clearedEnd, saved), {})
const savedStartOnly = subBanner({ startDate: '2026-11-01 09:30' })
const earlyEnd = createSubBannerForm(savedStartOnly)
earlyEnd.end_date = '2026-10-01T00:00'
assert.deepEqual(Object.keys(validateSubBannerForm(earlyEnd, savedStartOnly)), ['end_date'])
})
test('목록: placement 별로 조회하고 서버 순서대로 모두 표시한다', async () => {
const { vm, errors } = page()
const calls = []
Vue.axios = {
get: async (...args) => {
calls.push(args)
return {
status: 200,
data: envelope([
subBanner({ id: 7, startDate: '2030-01-01 00:00' }),
subBanner({ id: 3, endDate: '2020-01-01 00:00' }),
subBanner({ id: 11, startDate: '2026-11-01 09:30', endDate: '2026-11-30 23:59' }),
subBanner({ id: 5 })
])
}
}
}
await vm.getSubBanners()
assert.deepEqual(calls[0], ['/admin/sub-banners', { params: { placement: 'HOME_RECOMMENDATION' } }])
assert.deepEqual(vm.sub_banners.map(item => item.id), [7, 3, 11, 5])
const rendered = activatorText(vm)
assert.ok(rendered.includes('2030-01-01 00:00 ~ (KST)'))
assert.ok(rendered.includes('~ 2020-01-01 00:00 (KST)'))
assert.ok(rendered.includes('상시 노출 (기간 제한 없음)'))
assert.ok(rendered.includes('KST'))
vm.selected_placement = 'CONTENT_RECOMMENDATION'
await vm.getSubBanners()
assert.deepEqual(calls[1], ['/admin/sub-banners', { params: { placement: 'CONTENT_RECOMMENDATION' } }])
assert.deepEqual(errors, [])
})
test('목록 실패: success=false 와 예외를 빈 목록 성공으로 오인하지 않는다', async () => {
const { vm, errors } = page()
vm.sub_banners = [subBanner()]
Vue.axios = { get: async () => ({ status: 200, data: envelope(null, false, '권한이 없습니다.') }) }
await vm.getSubBanners()
assert.deepEqual(errors, ['권한이 없습니다.'])
assert.deepEqual(vm.sub_banners.map(item => item.id), [1])
Vue.axios = { get: async () => { throw new Error('401') } }
await vm.getSubBanners()
assert.equal(errors.length, 2)
assert.deepEqual(vm.sub_banners.map(item => item.id), [1])
})
test('등록: image 와 application/json request 파트를 보내고 목록을 갱신한다', async () => {
stubFormData()
const { vm, successes } = page()
const calls = []
Vue.axios = {
post: async (...args) => { calls.push(args); return { status: 200, data: envelope(subBanner()) } },
get: async () => ({ status: 200, data: envelope([subBanner()]) })
}
vm.showCreateDialog()
vm.sub_banner.placement = 'CONTENT_RECOMMENDATION'
vm.sub_banner.web_url = ' https://example.test/promo '
vm.sub_banner.start_date = '2026-11-01T09:30'
vm.imageAdd({ name: 'promo.jpg', type: 'image/jpeg' })
await vm.submit()
assert.equal(calls.length, 1)
assert.equal(calls[0][0], '/admin/sub-banners')
assert.equal(calls[0][1].get('image').name, 'promo.jpg')
assert.equal(calls[0][1].get('request').type, 'application/json')
assert.deepEqual(requestOf(calls[0][1]), {
placement: 'CONTENT_RECOMMENDATION',
webUrl: 'https://example.test/promo',
androidDeepLink: null,
iosDeepLink: null,
lang: 'KO',
startDate: '2026-11-01 09:30'
})
assert.deepEqual(successes, ['등록되었습니다.'])
assert.equal(vm.selected_placement, 'CONTENT_RECOMMENDATION')
assert.deepEqual(vm.sub_banners.map(item => item.id), [1])
})
test('등록 검증: 이미지와 최소 한 주소가 없으면 전송하지 않는다', async () => {
stubFormData()
const { vm, errors } = page()
const calls = []
Vue.axios = { post: async () => { calls.push('POST'); return { status: 200, data: envelope(subBanner()) } } }
vm.showCreateDialog()
await vm.submit()
assert.deepEqual(calls, [])
assert.equal(errors.length, 1)
vm.sub_banner.web_url = 'https://example.test/promo'
await vm.submit()
assert.deepEqual(calls, [])
assert.deepEqual(errors[1], '배너 이미지를 등록하세요.')
})
test('수정: 목록 객체로 폼을 채우고 일정만 바꾸면 image 를 생략한다', async () => {
stubFormData()
const { vm, successes } = page()
const calls = []
Vue.axios = {
put: async (...args) => { calls.push(args); return { status: 200, data: envelope(subBanner()) } },
get: async () => ({ status: 200, data: envelope([subBanner()]) })
}
const saved = subBanner({
id: 123,
androidDeepLink: 'sampleapp://promo',
startDate: '2026-11-01 09:30',
endDate: '2026-11-30 23:59'
})
vm.showModifyDialog(saved)
assert.equal(vm.sub_banner.web_url, 'https://example.test/promo')
assert.equal(vm.sub_banner.android_deep_link, 'sampleapp://promo')
assert.equal(vm.sub_banner.ios_deep_link, '')
assert.equal(vm.sub_banner.start_date, '2026-11-01T09:30')
assert.equal(vm.sub_banner.end_date, '2026-11-30T23:59')
assert.equal(vm.sub_banner.image_url, 'https://cdn.example.test/promo.jpg')
vm.sub_banner.end_date = '2026-12-31T23:59'
await vm.modify()
assert.equal(calls[0][0], '/admin/sub-banners/123')
assert.equal(calls[0][1].has('image'), false)
assert.deepEqual(requestOf(calls[0][1]), {
placement: 'HOME_RECOMMENDATION',
webUrl: 'https://example.test/promo',
androidDeepLink: 'sampleapp://promo',
iosDeepLink: null,
lang: 'KO',
endDate: '2026-12-31 23:59'
})
assert.deepEqual(successes, ['수정되었습니다.'])
})
test('수정 실패: 입력값과 기존 이미지 상태를 보존하고 실패를 알린다', async () => {
stubFormData()
const { vm, errors, successes } = page()
Vue.axios = { put: async () => ({ status: 200, data: envelope(null, false, '저장에 실패했습니다.') }) }
vm.showModifyDialog(subBanner({ id: 9 }))
vm.sub_banner.web_url = 'https://example.test/changed'
await vm.modify()
assert.deepEqual(errors, ['저장에 실패했습니다.'])
assert.deepEqual(successes, [])
assert.equal(vm.show_write_dialog, true)
assert.equal(vm.sub_banner.web_url, 'https://example.test/changed')
assert.equal(vm.sub_banner.image_url, 'https://cdn.example.test/promo.jpg')
})
test('삭제: 확인 후 호출하고 성공하면 목록에서 사라진다', async () => {
const { vm, successes, errors } = page()
const calls = []
let remaining = [subBanner({ id: 1 }), subBanner({ id: 2 })]
Vue.axios = {
delete: async (...args) => {
calls.push(args)
remaining = remaining.filter(item => item.id !== 2)
return { status: 200, data: envelope(null) }
},
get: async () => ({ status: 200, data: envelope(remaining) })
}
vm.sub_banners = remaining
vm.deleteConfirm(subBanner({ id: 2 }))
assert.equal(vm.show_delete_confirm_dialog, true)
vm.deleteCancel()
assert.equal(vm.show_delete_confirm_dialog, false)
assert.deepEqual(calls, [])
vm.deleteConfirm(subBanner({ id: 2 }))
await vm.deleteSubBanner()
assert.deepEqual(calls, [['/admin/sub-banners/2']])
assert.deepEqual(vm.sub_banners.map(item => item.id), [1])
assert.deepEqual(successes, ['삭제되었습니다.'])
assert.deepEqual(errors, [])
})
test('삭제 실패: 404 이후 응답은 success=false 로 알리고 목록을 유지한다', async () => {
const { vm, errors } = page()
Vue.axios = { delete: async () => ({ status: 200, data: envelope(null, false, '존재하지 않는 배너입니다.') }) }
vm.sub_banners = [subBanner({ id: 1 })]
vm.deleteConfirm(subBanner({ id: 1 }))
await vm.deleteSubBanner()
assert.deepEqual(errors, ['존재하지 않는 배너입니다.'])
assert.deepEqual(vm.sub_banners.map(item => item.id), [1])
})
test('중복 제출 방지: 진행 중 재호출과 timeout 이후 재전송을 막는다', async () => {
stubFormData()
const { vm, errors } = page()
let posts = 0
let resolvePost = null
Vue.axios = {
post: async () => {
posts += 1
await new Promise(resolve => { resolvePost = resolve })
return { status: 200, data: envelope(subBanner()) }
},
get: async () => ({ status: 200, data: envelope([subBanner()]) })
}
vm.showCreateDialog()
vm.sub_banner.web_url = 'https://example.test/promo'
vm.imageAdd({ name: 'promo.jpg', type: 'image/jpeg' })
const first = vm.submit()
await Promise.resolve()
await vm.submit()
assert.equal(posts, 1)
resolvePost()
await first
// timeout 등으로 결과가 불명확하면 자동 재시도 없이 전송을 차단한다.
const timeoutPage = page()
let timeoutPosts = 0
Vue.axios = {
post: async () => { timeoutPosts += 1; throw new Error('timeout of 0ms exceeded') },
get: async () => ({ status: 200, data: envelope([subBanner()]) })
}
timeoutPage.vm.showCreateDialog()
timeoutPage.vm.sub_banner.web_url = 'https://example.test/promo'
timeoutPage.vm.imageAdd({ name: 'promo.jpg', type: 'image/jpeg' })
await timeoutPage.vm.submit()
await timeoutPage.vm.submit()
assert.equal(timeoutPosts, 1)
assert.equal(timeoutPage.vm.submit_blocked, true)
assert.deepEqual(timeoutPage.vm.sub_banners.map(item => item.id), [1])
assert.equal(timeoutPage.errors.length, 1)
})
test('언어: 신규 기본값은 KO 이고 선택한 코드가 정규 대문자로 직렬화된다', () => {
assert.equal(createSubBannerForm().lang, 'KO')
assert.equal(langLabel('KO'), '한국어')
assert.equal(langLabel('JA'), '일본어')
assert.equal(langLabel('EN'), '영어')
assert.equal(langLabel('ko'), '')
for (const lang of ['KO', 'JA', 'EN']) {
const created = buildSubBannerCreateRequest(form({ lang, web_url: 'https://example.test/promo' }))
assert.deepEqual(created, {
placement: 'HOME_RECOMMENDATION',
webUrl: 'https://example.test/promo',
androidDeepLink: null,
iosDeepLink: null,
lang
})
const saved = subBanner({ lang })
const updated = buildSubBannerUpdateRequest(createSubBannerForm(saved), saved)
assert.deepEqual(Object.keys(updated), ['placement', 'webUrl', 'androidDeepLink', 'iosDeepLink', 'lang'])
assert.equal(updated.lang, lang)
}
})
test('언어: 수정 폼은 저장된 JA/EN 으로 미리 선택되고 다른 값만 바꿔도 보존된다', async () => {
stubFormData()
const { vm } = page()
const calls = []
Vue.axios = {
put: async (...args) => { calls.push(args); return { status: 200, data: envelope(subBanner({ lang: 'JA' })) } },
get: async () => ({ status: 200, data: envelope([subBanner({ lang: 'JA' })]) })
}
const saved = subBanner({ id: 55, lang: 'JA', startDate: '2026-11-01 09:30', endDate: '2026-11-30 23:59' })
vm.showModifyDialog(saved)
assert.equal(vm.sub_banner.lang, 'JA')
// 이미지와 종료 일시만 바꿔도 저장된 언어가 그대로 전송된다.
vm.imageAdd({ name: 'new.jpg', type: 'image/jpeg' })
vm.sub_banner.end_date = '2026-12-31T23:59'
await vm.modify()
assert.equal(calls[0][0], '/admin/sub-banners/55')
assert.equal(calls[0][1].get('image').name, 'new.jpg')
assert.deepEqual(requestOf(calls[0][1]), {
placement: 'HOME_RECOMMENDATION',
webUrl: 'https://example.test/promo',
androidDeepLink: null,
iosDeepLink: null,
lang: 'JA',
endDate: '2026-12-31 23:59'
})
const en = subBanner({ id: 56, lang: 'EN' })
vm.showModifyDialog(en)
assert.equal(vm.sub_banner.lang, 'EN')
// 언어만 바꿔도 나머지 값은 그대로다.
vm.sub_banner.lang = 'KO'
await vm.modify()
assert.deepEqual(requestOf(calls[1][1]), {
placement: 'HOME_RECOMMENDATION',
webUrl: 'https://example.test/promo',
androidDeepLink: null,
iosDeepLink: null,
lang: 'KO'
})
assert.equal(calls[1][1].has('image'), false)
})
test('언어 오류: 400 Boot body 와 success=false 모두 입력·이미지·날짜를 보존한다', async () => {
stubFormData()
const bootError = {
response: {
status: 400,
data: { timestamp: '2026-11-01T00:00:00.000+00:00', status: 400, error: 'Bad Request', message: '지원하지 않는 언어입니다.', path: '/admin/sub-banners' }
}
}
const { vm, errors, successes } = page()
Vue.axios = {
post: async () => { throw bootError },
get: async () => ({ status: 200, data: envelope([subBanner()]) })
}
vm.showCreateDialog()
vm.sub_banner.lang = 'EN'
vm.sub_banner.web_url = 'https://example.test/promo'
vm.sub_banner.start_date = '2026-11-01T09:30'
vm.imageAdd({ name: 'promo.jpg', type: 'image/jpeg' })
await vm.submit()
assert.deepEqual(errors, ['지원하지 않는 언어입니다.'])
assert.deepEqual(successes, [])
// 400 은 서버가 확실히 거부한 것이므로 재전송을 막지 않고 상태를 보존한다.
assert.equal(vm.submit_blocked, false)
assert.equal(vm.show_write_dialog, true)
assert.equal(vm.sub_banner.lang, 'EN')
assert.equal(vm.sub_banner.web_url, 'https://example.test/promo')
assert.equal(vm.sub_banner.start_date, '2026-11-01T09:30')
assert.equal(vm.sub_banner.image.name, 'promo.jpg')
const failed = page()
Vue.axios = { put: async () => ({ status: 200, data: envelope(null, false, '언어 값이 올바르지 않습니다.') }) }
failed.vm.showModifyDialog(subBanner({ id: 9, lang: 'JA', startDate: '2026-11-01 09:30' }))
failed.vm.sub_banner.lang = 'EN'
await failed.vm.modify()
assert.deepEqual(failed.errors, ['언어 값이 올바르지 않습니다.'])
assert.equal(failed.vm.sub_banner.lang, 'EN')
assert.equal(failed.vm.sub_banner.start_date, '2026-11-01T09:30')
assert.equal(failed.vm.sub_banner.image_url, 'https://cdn.example.test/promo.jpg')
})
test('목록: 언어를 표시하고 lang 이 없는 응답은 KO 로 간주하지 않는다', async () => {
const { vm, errors } = page()
Vue.axios = {
get: async () => ({
status: 200,
data: envelope([subBanner({ id: 1, lang: 'KO' }), subBanner({ id: 2, lang: 'JA' }), subBanner({ id: 3, lang: 'EN' })])
})
}
await vm.getSubBanners()
const rendered = activatorText(vm)
assert.ok(rendered.includes('한국어'))
assert.ok(rendered.includes('일본어'))
assert.ok(rendered.includes('영어'))
assert.deepEqual(errors, [])
const missing = subBanner({ id: 4 })
delete missing.lang
Vue.axios = { get: async () => ({ status: 200, data: envelope([missing]) }) }
await vm.getSubBanners()
assert.equal(errors.length, 1)
assert.equal(vm.langText(missing), '-')
})
;(async () => {
for (const { name, run } of tests) {
try {
await run()
console.log(`PASS ${name}`)
} catch (error) {
process.exitCode = 1
console.error(`FAIL ${name}`, error)
}
}
})()