Merge pull request 'feat(sub-banner): 가로형 서브 배너 관리 화면 추가' (#107) from test into main

Reviewed-on: #107
This commit was merged in pull request #107.
This commit is contained in:
2026-10-30 04:45:13 +00:00
7 changed files with 1524 additions and 0 deletions
+1
View File
@@ -9,6 +9,7 @@
"build_development": "vue-cli-service build --mode development",
"test:gift": "node tests/gift.test.js && node tests/gift_category.test.js && node tests/gift_size.test.js && node tests/gift_mailbox.test.js",
"test:banner": "node tests/audio_content_banner.test.js",
"test:sub-banner": "node tests/sub_banner.test.js",
"lint": "vue-cli-service lint"
},
"dependencies": {
+27
View File
@@ -0,0 +1,27 @@
import Vue from 'vue';
async function getSubBanners(placement) {
return Vue.axios.get('/admin/sub-banners', {params: {placement}})
}
async function saveSubBanner(formData) {
return Vue.axios.post('/admin/sub-banners', formData, {
headers: {
"Content-Type": "multipart/form-data",
},
});
}
async function modifySubBanner(id, formData) {
return Vue.axios.put('/admin/sub-banners/' + id, formData, {
headers: {
"Content-Type": "multipart/form-data",
},
});
}
async function deleteSubBanner(id) {
return Vue.axios.delete('/admin/sub-banners/' + id)
}
export {getSubBanners, saveSubBanner, modifySubBanner, deleteSubBanner}
+22
View File
@@ -155,6 +155,28 @@ export default {
// ignore
}
// 프로모션 메뉴에 '가로형 서브 배너' 하위 메뉴 추가
try {
const promotionMenu = this.items.find(m => m && Array.isArray(m.items)
&& m.items.some(ci => ci && ci.route === '/promotion/event'))
const subBannerItem = { title: '가로형 서브 배너', route: '/promotion/sub-banner', items: null }
if (promotionMenu) {
if (!promotionMenu.items.some(ci => ci && ci.route === subBannerItem.route)) {
promotionMenu.items.push(subBannerItem)
}
} else {
this.items.push({
title: '프로모션 관리',
route: null,
icon: 'mdi-bullhorn',
items: [subBannerItem]
})
}
} catch (e) {
// ignore
}
// 캐릭터 챗봇 메뉴 추가
this.items.push({
title: '캐릭터 챗봇',
+5
View File
@@ -182,6 +182,11 @@ const routes = [
name: 'EventView',
component: () => import(/* webpackChunkName: "promotion" */ '../views/Promotion/EventView.vue')
},
{
path: '/promotion/sub-banner',
name: 'SubBannerView',
component: () => import(/* webpackChunkName: "promotion" */ '../views/Promotion/SubBannerView.vue')
},
{
path: '/promotion/push',
name: 'Push',
+291
View File
@@ -0,0 +1,291 @@
const DATE_TIME_PATTERN = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}$/
const SCHEME_PATTERN = /^[A-Za-z][A-Za-z0-9+.-]*:/
const DENIED_SCHEMES = ['javascript', 'data', 'file', 'content']
// 변환된 경계 instant 가 UTC 1970-01-01 00:00:01 ~ 2038-01-19 03:14:07 사이여야 하므로
// KST 분 단위 입력의 허용 범위는 아래와 같다.
export const START_DATE_MIN = '1970-01-01 09:01'
export const START_DATE_MAX = '2038-01-19 12:14'
export const END_DATE_MIN = '1970-01-01 09:00'
export const END_DATE_MAX = '2038-01-19 12:13'
// 과거 한국 서머타임(KST)으로 존재하지 않는 현지 시각 구간
const NON_EXISTENT_KST_RANGES = [
{from: '1987-05-10 02:00', to: '1987-05-10 02:59'},
{from: '1988-05-08 02:00', to: '1988-05-08 02:59'}
]
export const SUB_BANNER_PLACEMENTS = [
{value: 'HOME_RECOMMENDATION', text: '홈'},
{value: 'CONTENT_RECOMMENDATION', text: '콘텐츠'}
]
export function placementLabel(placement) {
const found = SUB_BANNER_PLACEMENTS.find((item) => item.value === placement)
return found ? found.text : ''
}
export function isSubBannerPlacement(placement) {
return SUB_BANNER_PLACEMENTS.some((item) => item.value === placement)
}
export function toDateTimeLocalInput(value) {
if (value === null || value === undefined) return ''
const text = String(value).trim()
if (!text || text === 'null') return ''
return text.replace(' ', 'T').slice(0, 16)
}
export function toServerDateTime(value) {
if (value === null || value === undefined) return null
const text = String(value).trim()
if (!text || text === 'null') return null
return text.replace('T', ' ')
}
export function formatScheduleRange(startDate, endDate) {
const start = toServerDateTime(startDate)
const end = toServerDateTime(endDate)
if (!start && !end) return '상시 노출 (기간 제한 없음)'
if (start && !end) return `${start} ~ (KST)`
if (!start && end) return `~ ${end} (KST)`
return `${start} ~ ${end} (KST)`
}
export function scheduleStatus(banner = {}, now = null) {
const start = toServerDateTime(banner.startDate)
const end = toServerDateTime(banner.endDate)
const current = now === null || now === undefined ? nowKstMinute() : toServerDateTime(now)
if (!start && !end) return '무기간'
if (start && current < start) return '예정'
if (end && current > end) return '만료'
return '노출중'
}
export function nowKstMinute(date = new Date()) {
const kst = new Date(date.getTime() + (9 * 60 + date.getTimezoneOffset()) * 60000)
const pad = (value) => String(value).padStart(2, '0')
return `${kst.getFullYear()}-${pad(kst.getMonth() + 1)}-${pad(kst.getDate())} ${pad(kst.getHours())}:${pad(kst.getMinutes())}`
}
export function normalizeUrl(value) {
if (value === null || value === undefined) return null
const text = String(value).trim()
if (!text) return null
return text
}
function schemeOf(value) {
const matched = SCHEME_PATTERN.exec(value)
return matched ? matched[0].slice(0, -1).toLowerCase() : null
}
export function isValidWebUrl(value) {
const url = normalizeUrl(value)
if (url === null) return false
try {
const parsed = new URL(url)
if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') return false
return !!parsed.host
} catch (e) {
return false
}
}
export function isValidDeepLink(value) {
const url = normalizeUrl(value)
if (url === null) return false
const scheme = schemeOf(url)
if (scheme === null) return false
if (DENIED_SCHEMES.indexOf(scheme) >= 0) return false
try {
new URL(url)
return true
} catch (e) {
return false
}
}
function isRealDateTime(value) {
if (!DATE_TIME_PATTERN.test(value)) return false
const year = Number(value.slice(0, 4))
const month = Number(value.slice(5, 7))
const day = Number(value.slice(8, 10))
const hour = Number(value.slice(11, 13))
const minute = Number(value.slice(14, 16))
if (month < 1 || month > 12) return false
if (hour > 23 || minute > 59) return false
const lastDay = new Date(Date.UTC(year, month, 0)).getUTCDate()
if (day < 1 || day > lastDay) return false
return !NON_EXISTENT_KST_RANGES.some((range) => value >= range.from && value <= range.to)
}
export function validateDateBoundary(value, boundary) {
const text = toServerDateTime(value)
if (text === null) return null
const label = boundary === 'end' ? '종료 일시' : '시작 일시'
if (!isRealDateTime(text)) {
return `${label} 형식이 올바르지 않습니다. 한국 시간(KST) yyyy-MM-dd HH:mm 분 단위로 입력하세요.`
}
const min = boundary === 'end' ? END_DATE_MIN : START_DATE_MIN
const max = boundary === 'end' ? END_DATE_MAX : START_DATE_MAX
if (text < min || text > max) {
return `${label}는 ${min} ~ ${max} (KST) 범위 안이어야 합니다.`
}
return null
}
export function createSubBannerForm(banner = {}) {
return {
id: banner.id === undefined ? null : banner.id,
placement: banner.placement || SUB_BANNER_PLACEMENTS[0].value,
image: null,
image_url: banner.imageUrl || null,
web_url: banner.webUrl === null || banner.webUrl === undefined ? '' : String(banner.webUrl),
android_deep_link: banner.androidDeepLink === null || banner.androidDeepLink === undefined
? ''
: String(banner.androidDeepLink),
ios_deep_link: banner.iosDeepLink === null || banner.iosDeepLink === undefined
? ''
: String(banner.iosDeepLink),
start_date: toDateTimeLocalInput(banner.startDate),
end_date: toDateTimeLocalInput(banner.endDate)
}
}
export function normalizeUrls(form = {}) {
return {
webUrl: normalizeUrl(form.web_url),
androidDeepLink: normalizeUrl(form.android_deep_link),
iosDeepLink: normalizeUrl(form.ios_deep_link)
}
}
export function validateSubBannerUrls(form = {}) {
const errors = {}
const urls = normalizeUrls(form)
if (urls.webUrl !== null && !isValidWebUrl(urls.webUrl)) {
errors.web_url = '웹 URL은 host 가 있는 절대 http(s) URL 이어야 합니다.'
}
if (urls.androidDeepLink !== null && !isValidDeepLink(urls.androidDeepLink)) {
errors.android_deep_link = 'Android 딥링크는 유효한 절대 URI 여야 하며 javascript, data, file, content scheme 은 사용할 수 없습니다.'
}
if (urls.iosDeepLink !== null && !isValidDeepLink(urls.iosDeepLink)) {
errors.ios_deep_link = 'iOS 딥링크는 유효한 절대 URI 여야 하며 javascript, data, file, content scheme 은 사용할 수 없습니다.'
}
if (urls.webUrl === null && urls.androidDeepLink === null && urls.iosDeepLink === null) {
errors.web_url = '웹 URL, Android 딥링크, iOS 딥링크 중 최소 한 개는 입력해야 합니다.'
}
return errors
}
export function validateSubBannerSchedule(form = {}, banner = null) {
const errors = {}
const startError = validateDateBoundary(form.start_date, 'start')
const endError = validateDateBoundary(form.end_date, 'end')
if (startError) errors.start_date = startError
if (endError) errors.end_date = endError
if (startError || endError) return errors
const request = banner === null
? buildSubBannerCreateRequest(form)
: buildSubBannerUpdateRequest(form, banner)
const effective = effectiveSchedule(request, banner)
if (effective.startDate !== null && effective.endDate !== null && effective.startDate > effective.endDate) {
errors.end_date = '종료 일시는 시작 일시보다 빠를 수 없습니다.'
}
return errors
}
export function effectiveSchedule(request = {}, banner = null) {
const saved = banner === null ? {} : banner
const startDate = Object.prototype.hasOwnProperty.call(request, 'startDate')
? request.startDate
: toServerDateTime(saved.startDate)
const endDate = Object.prototype.hasOwnProperty.call(request, 'endDate')
? request.endDate
: toServerDateTime(saved.endDate)
return {startDate, endDate}
}
export function validateSubBannerForm(form = {}, banner = null) {
return {...validateSubBannerUrls(form), ...validateSubBannerSchedule(form, banner)}
}
function baseRequest(form) {
const urls = normalizeUrls(form)
return {
placement: form.placement,
webUrl: urls.webUrl,
androidDeepLink: urls.androidDeepLink,
iosDeepLink: urls.iosDeepLink
}
}
export function buildSubBannerCreateRequest(form = {}) {
const request = baseRequest(form)
const startDate = toServerDateTime(form.start_date)
const endDate = toServerDateTime(form.end_date)
if (startDate !== null) request.startDate = startDate
if (endDate !== null) request.endDate = endDate
return request
}
export function buildSubBannerUpdateRequest(form = {}, banner = {}) {
const request = baseRequest(form)
const startDate = toServerDateTime(form.start_date)
const endDate = toServerDateTime(form.end_date)
const savedStartDate = toServerDateTime(banner.startDate)
const savedEndDate = toServerDateTime(banner.endDate)
// 값이 그대로면 생략해 서버의 저장 값을 보존하고, 사용자가 지웠으면 명시적 null 로 해당 경계만 해제한다.
if (startDate !== savedStartDate) request.startDate = startDate
if (endDate !== savedEndDate) request.endDate = endDate
return request
}
export function appendSubBannerRequestPart(formData, request) {
const json = JSON.stringify(request)
// request 파트는 Content-Type: application/json 으로 전송한다.
if (typeof Blob === 'function') {
formData.append('request', new Blob([json], {type: 'application/json'}))
} else {
formData.append('request', json)
}
return formData
}
export function resolveSubBannerTarget(banner = {}, os = 'android') {
const webUrl = normalizeUrl(banner.webUrl)
const deepLink = os === 'ios'
? normalizeUrl(banner.iosDeepLink)
: normalizeUrl(banner.androidDeepLink)
if (deepLink !== null && webUrl !== null) return 'DEEP_LINK_WITH_WEB_FALLBACK'
if (deepLink !== null) return 'DEEP_LINK'
if (webUrl !== null) return 'WEB'
return 'NONE'
}
+615
View File
@@ -0,0 +1,615 @@
<template>
<div>
<v-toolbar dark>
<v-spacer />
<v-toolbar-title>가로형 서브 배너</v-toolbar-title>
<v-spacer />
</v-toolbar>
<br>
<v-dialog
v-model="show_write_dialog"
max-width="1000px"
persistent
>
<template v-slot:activator="{ on, attrs }">
<v-container>
<v-row align="center">
<v-col cols="9">
<v-radio-group
v-model="selected_placement"
row
@change="getSubBanners"
>
<v-radio
v-for="placement in placements"
:key="placement.value"
:label="placement.text"
:value="placement.value"
/>
</v-radio-group>
</v-col>
<v-spacer />
<v-col>
<v-btn
block
color="#3BB9F1"
dark
depressed
v-bind="attrs"
v-on="on"
@click="showCreateDialog"
>
배너 등록
</v-btn>
<v-btn
block
class="mt-2"
depressed
:disabled="is_loading"
@click="getSubBanners"
>
목록 새로고침
</v-btn>
</v-col>
</v-row>
<v-row>
<v-col>
<v-simple-table class="elevation-10">
<template>
<thead>
<tr>
<th class="text-center">
번호
</th>
<th class="text-center">
이미지
</th>
<th class="text-center">
웹 URL
</th>
<th class="text-center">
Android 딥링크
</th>
<th class="text-center">
iOS 딥링크
</th>
<th class="text-center">
노출 기간 (KST)
</th>
<th class="text-center">
상태
</th>
<th class="text-center">
관리
</th>
</tr>
</thead>
<tbody>
<tr
v-for="item in sub_banners"
:key="item.id"
>
<td>{{ item.id }}</td>
<td>
<img
:src="item.imageUrl"
alt=""
class="list-image"
>
</td>
<td>{{ item.webUrl || '-' }}</td>
<td>{{ item.androidDeepLink || '-' }}</td>
<td>{{ item.iosDeepLink || '-' }}</td>
<td>{{ scheduleRangeText(item) }}</td>
<td>{{ statusText(item) }}</td>
<td>
<v-btn
text
@click="showModifyDialog(item)"
>
수정
</v-btn>
<v-btn
text
@click="deleteConfirm(item)"
>
삭제
</v-btn>
</td>
</tr>
<tr v-if="sub_banners.length === 0">
<td
colspan="8"
class="text-center"
>
등록된 배너가 없습니다.
</td>
</tr>
</tbody>
</template>
</v-simple-table>
</v-col>
</v-row>
</v-container>
</template>
<v-card>
<v-card-title v-if="is_modify === true">
서브 배너 수정
</v-card-title>
<v-card-title v-else>
서브 배너 등록
</v-card-title>
<v-card-text>
<v-row align="center">
<v-col cols="4">
노출 위치
</v-col>
<v-col cols="8">
<v-radio-group
v-model="sub_banner.placement"
row
>
<v-radio
v-for="placement in placements"
:key="placement.value"
:label="placement.text"
:value="placement.value"
/>
</v-radio-group>
</v-col>
</v-row>
</v-card-text>
<v-card-text>
<v-row align="center">
<v-col cols="4">
웹 URL
</v-col>
<v-col cols="8">
<v-text-field
v-model="sub_banner.web_url"
label="https://example.com/promo"
:error-messages="form_errors.web_url"
/>
</v-col>
</v-row>
<v-row align="center">
<v-col cols="4">
Android 딥링크
</v-col>
<v-col cols="8">
<v-text-field
v-model="sub_banner.android_deep_link"
label="sampleapp://promo"
:error-messages="form_errors.android_deep_link"
/>
</v-col>
</v-row>
<v-row align="center">
<v-col cols="4">
iOS 딥링크
</v-col>
<v-col cols="8">
<v-text-field
v-model="sub_banner.ios_deep_link"
label="sampleapp://promo"
:error-messages="form_errors.ios_deep_link"
/>
</v-col>
</v-row>
<v-row>
<v-col class="guide-text">
웹 URL, Android 딥링크, iOS 딥링크 중 최소 한 개는 입력해야 합니다. 비워둔 주소는 null 로 저장되어 해제됩니다.
</v-col>
</v-row>
</v-card-text>
<v-card-text>
<v-row align="center">
<v-col cols="4">
노출 기간 (한국 시간 KST 기준)
</v-col>
<v-col cols="4">
<v-text-field
v-model="sub_banner.start_date"
type="datetime-local"
label="시작 일시 (KST, 선택)"
:error-messages="form_errors.start_date"
clearable
@click:clear="sub_banner.start_date = ''"
/>
</v-col>
<v-col cols="4">
<v-text-field
v-model="sub_banner.end_date"
type="datetime-local"
label="종료 일시 (KST, 선택)"
:error-messages="form_errors.end_date"
clearable
@click:clear="sub_banner.end_date = ''"
/>
</v-col>
</v-row>
<v-row>
<v-col class="guide-text">
입력한 시간은 한국 시간(KST) 분 단위로 저장됩니다. 비워두면 해당 경계의 기간 제한이 없습니다.
(시작만 있으면 시작 분의 :00 부터, 종료만 있으면 종료 분의 :59 까지 노출)
</v-col>
</v-row>
</v-card-text>
<div class="image-select">
<label for="image">
배너 이미지 등록
</label>
<v-file-input
id="image"
v-model="sub_banner.image"
accept="image/*"
@change="imageAdd"
/>
</div>
<img
v-if="sub_banner.image_url"
:src="sub_banner.image_url"
alt=""
class="image-preview"
>
<v-card-text
v-if="is_modify === true"
class="guide-text"
>
이미지를 새로 등록하지 않으면 기존 이미지가 그대로 유지됩니다.
</v-card-text>
<v-card-text
v-if="submit_blocked === true"
class="guide-text"
>
응답을 받지 못해 저장 여부를 알 수 없습니다. 중복 저장을 막기 위해 다시 보내지 않습니다. 목록에서 결과를 확인한 뒤 진행해 주세요.
</v-card-text>
<v-card-actions v-show="!is_loading">
<v-spacer />
<v-btn
color="blue darken-1"
text
@click="cancel"
>
취소
</v-btn>
<v-btn
v-if="is_modify === true"
color="blue darken-1"
text
:disabled="is_loading || submit_blocked"
@click="modify"
>
수정
</v-btn>
<v-btn
v-else
color="blue darken-1"
text
:disabled="is_loading || submit_blocked"
@click="submit"
>
등록
</v-btn>
</v-card-actions>
</v-card>
</v-dialog>
<v-dialog
v-model="show_delete_confirm_dialog"
max-width="400px"
persistent
>
<v-card>
<v-card-text />
<v-card-text>
삭제하시겠습니까?
</v-card-text>
<v-card-actions v-show="!is_loading">
<v-spacer />
<v-btn
color="blue darken-1"
text
@click="deleteCancel"
>
취소
</v-btn>
<v-btn
color="blue darken-1"
text
:disabled="is_loading"
@click="deleteSubBanner"
>
확인
</v-btn>
</v-card-actions>
</v-card>
</v-dialog>
</div>
</template>
<script>
import * as api from "@/api/sub_banner"
import {
appendSubBannerRequestPart,
buildSubBannerCreateRequest,
buildSubBannerUpdateRequest,
createSubBannerForm,
formatScheduleRange,
scheduleStatus,
SUB_BANNER_PLACEMENTS,
validateSubBannerForm
} from "@/utils/sub_banner"
export default {
name: "SubBannerView",
data() {
return {
is_loading: false,
is_modify: false,
submit_blocked: false,
show_write_dialog: false,
show_delete_confirm_dialog: false,
placements: SUB_BANNER_PLACEMENTS,
selected_placement: SUB_BANNER_PLACEMENTS[0].value,
sub_banners: [],
selected_sub_banner: {},
sub_banner: createSubBannerForm(),
form_errors: {}
}
},
async created() {
await this.getSubBanners()
},
methods: {
notifyError(message) {
this.$dialog.notify.error(message)
},
notifySuccess(message) {
this.$dialog.notify.success(message)
},
imageAdd(payload) {
const file = payload
if (!file) {
// 새 이미지를 해제하면 기존 이미지 상태로 되돌린다.
this.sub_banner.image = null
this.sub_banner.image_url = this.selected_sub_banner.imageUrl || null
return
}
this.sub_banner.image = file
this.sub_banner.image_url = URL.createObjectURL(file)
},
showCreateDialog() {
this.is_modify = false
this.selected_sub_banner = {}
this.sub_banner = createSubBannerForm({placement: this.selected_placement})
this.form_errors = {}
this.submit_blocked = false
this.show_write_dialog = true
},
showModifyDialog(subBanner) {
// 별도 상세 조회가 없으므로 목록의 전체 객체로 form 을 채운다.
this.is_modify = true
this.selected_sub_banner = subBanner
this.sub_banner = createSubBannerForm(subBanner)
this.form_errors = {}
this.submit_blocked = false
this.show_write_dialog = true
},
cancel() {
this.is_modify = false
this.show_write_dialog = false
this.show_delete_confirm_dialog = false
this.selected_sub_banner = {}
this.sub_banner = createSubBannerForm({placement: this.selected_placement})
this.form_errors = {}
this.submit_blocked = false
},
scheduleRangeText(subBanner) {
return formatScheduleRange(subBanner.startDate, subBanner.endDate)
},
statusText(subBanner) {
return scheduleStatus(subBanner)
},
validate() {
const errors = validateSubBannerForm(
this.sub_banner,
this.is_modify === true ? this.selected_sub_banner : null
)
this.form_errors = errors
const messages = Object.keys(errors).map((key) => errors[key])
if (messages.length > 0) {
this.notifyError(messages[0])
return false
}
if (this.is_modify !== true && !this.sub_banner.image) {
this.notifyError('배너 이미지를 등록하세요.')
return false
}
return true
},
deleteConfirm(subBanner) {
this.selected_sub_banner = subBanner
this.show_delete_confirm_dialog = true
},
deleteCancel() {
this.show_delete_confirm_dialog = false
this.selected_sub_banner = {}
},
async submit() {
if (this.is_loading === true || this.submit_blocked === true) return
if (!this.validate()) return
this.is_loading = true
try {
const formData = new FormData()
formData.append("image", this.sub_banner.image)
appendSubBannerRequestPart(formData, buildSubBannerCreateRequest(this.sub_banner))
const res = await api.saveSubBanner(formData)
if (res.status === 200 && res.data.success === true) {
this.selected_placement = this.sub_banner.placement
this.cancel()
this.notifySuccess('등록되었습니다.')
await this.getSubBanners()
} else {
// 실패 시 입력값과 기존 이미지 상태를 그대로 보존한다.
this.notifyError(res.data.message || '알 수 없는 오류가 발생했습니다. 다시 시도해 주세요.')
}
} catch (e) {
// 결과가 불명확하므로 자동 재시도 없이 중복 전송을 막고 목록으로 상태를 확인한다.
this.submit_blocked = true
this.notifyError('응답을 받지 못했습니다. 등록 여부를 목록에서 확인해 주세요.')
} finally {
this.is_loading = false
}
if (this.submit_blocked === true) {
await this.getSubBanners()
}
},
async modify() {
if (this.is_loading === true || this.submit_blocked === true) return
if (!this.validate()) return
this.is_loading = true
try {
const formData = new FormData()
// 이미지를 새로 선택하지 않으면 image 파트를 생략해 기존 이미지를 유지한다.
if (this.sub_banner.image) {
formData.append("image", this.sub_banner.image)
}
appendSubBannerRequestPart(
formData,
buildSubBannerUpdateRequest(this.sub_banner, this.selected_sub_banner)
)
const res = await api.modifySubBanner(this.sub_banner.id, formData)
if (res.status === 200 && res.data.success === true) {
this.selected_placement = this.sub_banner.placement
this.cancel()
this.notifySuccess('수정되었습니다.')
await this.getSubBanners()
} else {
this.notifyError(res.data.message || '알 수 없는 오류가 발생했습니다. 다시 시도해 주세요.')
}
} catch (e) {
this.submit_blocked = true
this.notifyError('응답을 받지 못했습니다. 수정 여부를 목록에서 확인해 주세요.')
} finally {
this.is_loading = false
}
if (this.submit_blocked === true) {
await this.getSubBanners()
}
},
async deleteSubBanner() {
if (this.is_loading === true) return
this.is_loading = true
try {
const res = await api.deleteSubBanner(this.selected_sub_banner.id)
if (res.status === 200 && res.data.success === true) {
this.cancel()
this.notifySuccess('삭제되었습니다.')
await this.getSubBanners()
} else {
this.notifyError(res.data.message || '알 수 없는 오류가 발생했습니다. 다시 시도해 주세요.')
}
} catch (e) {
this.notifyError('알 수 없는 오류가 발생했습니다. 다시 시도해 주세요.')
} finally {
this.is_loading = false
}
},
async getSubBanners() {
this.is_loading = true
try {
const res = await api.getSubBanners(this.selected_placement)
if (res.status === 200 && res.data.success === true) {
// 서버가 id 오름차순으로 내려주므로 재정렬하지 않고 전부 표시한다.
this.sub_banners = Array.isArray(res.data.data) ? res.data.data : []
} else {
// 조회 실패를 빈 목록으로 오인하지 않는다.
this.notifyError(res.data.message || '목록을 불러오지 못했습니다. 다시 시도해 주세요.')
}
} catch (e) {
this.notifyError('목록을 불러오지 못했습니다. 다시 시도해 주세요.')
} finally {
this.is_loading = false
}
}
}
}
</script>
<style scoped>
.image-select label {
display: inline-block;
padding: 10px 20px;
background-color: #232d4a;
color: #fff;
vertical-align: middle;
font-size: 15px;
cursor: pointer;
border-radius: 5px;
}
.v-file-input {
position: absolute;
width: 0;
height: 0;
padding: 0;
overflow: hidden;
border: 0;
}
.guide-text {
font-size: 12px;
color: #666;
}
.list-image {
width: 160px;
object-fit: cover;
}
.image-preview {
max-width: 100%;
width: 320px;
object-fit: cover;
margin-top: 10px;
}
</style>
+563
View File
@@ -0,0 +1,563 @@
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,
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',
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
})
})
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
})
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
}
// 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,
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,
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)
})
;(async () => {
for (const { name, run } of tests) {
try {
await run()
console.log(`PASS ${name}`)
} catch (error) {
process.exitCode = 1
console.error(`FAIL ${name}`, error)
}
}
})()