python+requests 인터페이스 자동화 프레임 워 크 의 실현
1.업무 와 배치 의 분리
2.데이터 와 프로그램의 분리;데이터 변경 은 프로그램 에 영향 을 주지 않 습 니 다.
3.로그 기능 이 있어 무인 당직 실현
4、테스트 보고서 자동 발송
5.프로 그래 밍 을 모 르 는 테스트 인원 도 테스트 할 수 있 습 니 다.
정상 인터페이스 테스트 의 절 차 는 무엇 입 니까?
인터페이스 테스트 에 사용 할 도 구 를 확인 합 니 다.->필요 한 인터페이스 매개 변 수 를 설정 합 니 다.->테스트 를 진행 합 니 다.->테스트 결 과 를 검사 합 니 다.->테스트 보고 서 를 생 성 합 니 다.
테스트 도구:python+requests
인터페이스 테스트 용례:excel
1.인터페이스 프레임 은 다음 과 같다.
1.action 패키지:키워드 함수 저장
2.config 패키지:설정 파일 저장
3.TestData:테스트 데 이 터 를 저장 하 는 데 사용 되 는 excel 표
4.로그 패키지:로그 파일 저장
5.utils 패키지:공공 을 저장 하 는 클래스
6.주 프로그램 인터페이스 실행auto_test.py
7.Readme.txt:팀 원 들 에 게 프레임 워 크 를 바 꾸 는 데 주의해 야 할 부분 을 알려 준다.
2.인터페이스의 데이터 규범 디자인-Case 디자인
데이터베이스 에 대응 하 는 시트
API sheet 저장
번호1 부터.
인터페이스의 이름(APIName);
요청 한 url(RequestUrl);
요청 한 방법(RequestMethod);
전송 방식(paramsType):post/get 요청 방법 이 다 릅 니 다.
용례 설명(APITEstCase)
실행 여부(Active)부분 인터페이스 가 연결 되 었 습 니 다.다음 에는 테스트 하지 않 고 여 기 를 N 으로 설정 하고 이 인 터 페 이 스 를 건 너 뛰 십시오.
post 와 get 의 차이
게시 물 정보 보기
post 요청 매개 변 수 는 일반적으로 json 문자열 이 고 매개 변 수 는 from 폼 에 넣 습 니 다.파 라 메 터 는 일반적으로 보이 지 않 고 상대 적 으로 안전성 이 높다.
get 상세 보기
get 요청 매개 변 수 는 보통 url 에 직접 넣 습 니 다.
2.1 등록 인터페이스 사례
RequestData:요청 한 데이터
(개 발 된 전 참 방식)
RelyData:데이터 의존
ResponseCode:응답 코드
ResponseData:응답 데이터
DataStore:저 장 된 의존 데이터;데이터베이스 에 존재 한다 면,표 에 의존 하 는 데 이 터 를 저장 할 필드 를 추가 합 니 다.
(저장 방식 은 인터페이스 자동 화 를 작성 하 는 사람 이 설정 하 는 저장 방식 입 니 다)
CheckPoint:검사 점
Active:실행 여부
Status:실행 사례 의 상태 입 니 다.실행 사례 가 성공 적 인지 확인 할 수 있 습 니 다.
ErrorInfo:case 실행 실패,실패 한 오류 정보;eg:그 자체 의 원인 인지 케이스 설정 이 실 패 했 는 지,아니면 다른 원인 인지
2.2 로그 인 인터페이스 사례
RequestData:요청 한 데이터
(개 발 된 전 참 방식)
RelyData:데이터 의존
(저장 방식 은 인터페이스 자동 화 를 작성 하 는 사람 이 설정 하 는 저장 방식 입 니 다)
ResponseCode:응답 코드
ResponseData:응답 데이터
DataStore:저 장 된 의존 데이터;데이터베이스 에 존재 한다 면,표 에 의존 하 는 데 이 터 를 저장 할 필드 를 추가 합 니 다.
(저장 방식 은 인터페이스 자동 화 를 작성 하 는 사람 이 설정 하 는 저장 방식 입 니 다)
CheckPoint:검사 점
Active:실행 여부
Status:실행 사례 의 상태 입 니 다.실행 사례 가 성공 적 인지 확인 할 수 있 습 니 다.
ErrorInfo:case 실행 실패,실패 한 오류 정보;eg:그 자체 의 원인 인지 케이스 설정 이 실 패 했 는 지,아니면 다른 원인 인지
RelyData:데이터 의존
사전:key:value 를 사용 하여 데이터 형식 을 저장 합 니 다.
{"request":{"username":"register->1","password":"register->1"},"response":{"code":"register->1"}}
포맷 후:
{
"request":{
"username":"register->1",
"password":"register->1"
},
"response":{
"code":"register->1"
}
}
3.utils 패키지 만 들 기:공공 클래스 를 저장 하 는 데 사용 합 니 다.3.1 ParseExcel.py 작업 패키지 엑셀 클래스(ParseExcel.py)
#encoding=utf-8
import openpyxl
from openpyxl.styles import Border, Side, Font
import time
class ParseExcel(object):
def __init__(self):
self.workbook = None
self.excelFile = None
self.font = Font(color = None) #
# RGB
self.RGBDict = {'red': 'FFFF3030', 'green': 'FF008B00'}
def loadWorkBook(self, excelPathAndName):
# excel , workbook
try:
self.workbook = openpyxl.load_workbook(excelPathAndName)
except Exception as err:
raise err
self.excelFile = excelPathAndName
return self.workbook
def getSheetByName(self, sheetName):
# sheet sheet
try:
# sheet = self.workbook.get_sheet_by_name(sheetName)
sheet = self.workbook[sheetName]
return sheet
except Exception as err:
raise err
def getSheetByIndex(self, sheetIndex):
# sheet sheet
try:
# sheetname = self.workbook.get_sheet_names()[sheetIndex]
sheetname = self.workbook.sheetnames[sheetIndex]
except Exception as err:
raise err
# sheet = self.workbook.get_sheet_by_name(sheetname)
sheet = self.workbook[sheetname]
return sheet
def getRowsNumber(self, sheet):
# sheet
return sheet.max_row
def getColsNumber(self, sheet):
# sheet
return sheet.max_column
def getStartRowNumber(self, sheet):
# sheet
return sheet.min_row
def getStartColNumber(self, sheet):
# sheet
return sheet.min_column
def getRow(self, sheet, rowNo):
# sheet , tuple,
# 1 ,sheet.rows[1]
try:
rows = []
for row in sheet.iter_rows():
rows.append(row)
return rows[rowNo - 1]
except Exception as err:
raise err
def getColumn(self, sheet, colNo):
# sheet , tuple,
# 1 ,sheet.columns[1]
try:
cols = []
for col in sheet.iter_cols():
cols.append(col)
return cols[colNo - 1]
except Exception as err:
raise err
def getCellOfValue(self, sheet, coordinate = None,
rowNo = None, colsNo = None):
# , 1 ,
# sheet.cell(row = 1, column = 1).value,
# excel
if coordinate != None:
try:
return sheet[coordinate]
except Exception as err:
raise err
elif coordinate is None and rowNo is not None and \
colsNo is not None:
try:
return sheet.cell(row = rowNo, column = colsNo).value
except Exception as err:
raise err
else:
raise Exception("Insufficient Coordinates of cell !")
def getCellOfObject(self, sheet, coordinate = None,
rowNo = None, colsNo = None):
# , ,
# excel
# getCellObject(sheet, coordinate = 'A1') or
# getCellObject(sheet, rowNo = 1, colsNo = 2)
if coordinate != None:
try:
# return sheet.cell(coordinate = coordinate)
return sheet[coordinate]
except Exception as err:
raise err
elif coordinate == None and rowNo is not None and \
colsNo is not None:
try:
return sheet.cell(row = rowNo,column = colsNo)
except Exception as err:
raise err
else:
raise Exception("Insufficient Coordinates of cell !")
def writeCell(self, sheet, content, coordinate = None,
rowNo = None, colsNo = None, style = None):
# excel ,
# 1 , style , red,green
if coordinate is not None:
try:
# sheet.cell(coordinate = coordinate).value = content
sheet[coordinate] = content
if style is not None:
sheet[coordinate].\
font = Font(color = self.RGBDict[style])
self.workbook.save(self.excelFile)
except Exception as e:
raise e
elif coordinate == None and rowNo is not None and \
colsNo is not None:
try:
sheet.cell(row = rowNo,column = colsNo).value = content
if style:
sheet.cell(row = rowNo,column = colsNo).\
font = Font(color = self.RGBDict[style])
self.workbook.save(self.excelFile)
except Exception as e:
raise e
else:
raise Exception("Insufficient Coordinates of cell !")
def writeCellCurrentTime(self, sheet, coordinate = None,
rowNo = None, colsNo = None):
# , 1
now = int(time.time()) #
timeArray = time.localtime(now)
currentTime = time.strftime("%Y-%m-%d %H:%M:%S", timeArray)
if coordinate is not None:
try:
sheet.cell(coordinate = coordinate).value = currentTime
self.workbook.save(self.excelFile)
except Exception as e:
raise e
elif coordinate == None and rowNo is not None \
and colsNo is not None:
try:
sheet.cell(row = rowNo, column = colsNo
).value = currentTime
self.workbook.save(self.excelFile)
except Exception as e:
raise e
else:
raise Exception("Insufficient Coordinates of cell !")
if __name__ == '__main__':
#
pe = ParseExcel()
pe.loadWorkBook(r'D:\ProgramSourceCode\Python Source Code\WorkSpace\InterfaceFrame2018\inter_test_data.xlsx')
sheetObj = pe.getSheetByName(u"API")
print(" sheet :", sheetObj.title)
# print help(sheetObj.rows)
print(" index sheet :", pe.getSheetByIndex(0).title)
sheet = pe.getSheetByIndex(0)
print(type(sheet))
print(pe.getRowsNumber(sheet)) #
print(pe.getColsNumber(sheet)) #
rows = pe.getRow(sheet, 1) #
for i in rows:
print(i.value)
# #
# print pe.getCellOfValue(sheet, rowNo = 1, colsNo = 1)
# pe.writeCell(sheet, u' ', rowNo = 10, colsNo = 10)
# pe.writeCellCurrentTime(sheet, rowNo = 10, colsNo = 11)
3.2 패키지 get/post 요청(HttpClient.py)
import requests
import json
class HttpClient(object):
def __init__(self):
pass
def request(self, requestMethod, requestUrl, paramsType,
requestData, headers =None, **kwargs):
if requestMethod == "post":
print("---", requestData, type(requestData))
if paramsType == "form":
response = self.__post(url = requestUrl, data = json.dumps(eval(requestData)),
headers = headers, **kwargs)
return response
elif paramsType == "json":
response = self.__post(url = requestUrl, json = json.dumps(eval(requestData)),
headers = headers, **kwargs)
return response
elif requestMethod == "get":
request_url = requestUrl
if paramsType == "url":
request_url = "%s%s" %(requestUrl, requestData)
response = self.__get(url = request_url, params = requestData, **kwargs)
return response
def __post(self, url, data = None, json = None, headers=None,**kwargs):
print("----")
response = requests.post(url=url, data = data, json=json, headers=headers)
return response
def __get(self, url, params = None, **kwargs):
response = requests.get(url, params = params, **kwargs)
return response
if __name__ == "__main__":
hc = HttpClient()
res = hc.request("get", "http://39.106.41.11:8080/getBlogContent/", "url",'2')
print(res.json())
3.3 봉인 MD5(md5encrypt)
import hashlib
def md5_encrypt(text):
m5 = hashlib.md5()
m5.update(text.encode("utf-8"))
value = m5.hexdigest()
return value
if __name__ == "__main__":
print(md5_encrypt("sfwe"))
3.4 패키지 로그
import logging
import logging.config
from config.public_data import baseDir
#
logging.config.fileConfig(baseDir + "\config\Logger.conf")
#
logger = logging.getLogger("example02")# example01
def debug(message):
# dubug
logger.debug(message)
def info(message):
# info
logger.info(message)
def warning(message):
# warning
logger.warning(message)
3.5 패키지 발송 이메일 클래스
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from email.header import Header
from ProjVar.var import *
import os
import smtplib
from email import encoders
from email.mime.base import MIMEBase
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from email.header import Header
from email.utils import formataddr
def send_mail():
mail_host="smtp.126.com" #
mail_user="testman1980" #
mail_pass="wulaoshi1980" #
sender = '[email protected]'
receivers = ['[email protected]',"[email protected]"] # , QQ
#
message = MIMEMultipart()
message['From'] = formataddr([" ", "[email protected]"])
message['To'] = ','.join(receivers)
subject = ' '
message['Subject'] = Header(subject, 'utf-8')
message["Accept-Language"]="zh-CN"
message["Accept-Charset"]="ISO-8859-1,utf-8,gbk"
#
message.attach(MIMEText(' , !', 'plain', 'utf-8'))
# 1, excel
att = MIMEBase('application', 'octet-stream')
att.set_payload(open(ProjDirPath+"\\testdata\\testdata.xlsx", 'rb').read())
att.add_header('Content-Disposition', 'attachment', filename=('gbk', '', " .xlsx"))
encoders.encode_base64(att)
message.attach(att)
"""
# 2, runoob.txt
att2 = MIMEText(open('e:\\a.py','rb').read(), 'base64', 'utf-8')
att2["Content-Type"] = 'application/octet-stream'
att2["Content-Disposition"] = 'attachment; filename="a.py"'
message.attach(att2)
"""
try:
smtpObj = smtplib.SMTP(mail_host)
smtpObj.login(mail_user, mail_pass)
smtpObj.sendmail(sender, receivers, message.as_string())
print(" ")
except smtplib.SMTPException as e:
print("Error: ", e)
if __name__ == "__main__":
send_mail()
4.config 패 키 지 를 만들어 서 공공 매개 변수,프로필,장시간 변 하지 않 는 변수 값 을 저장 합 니 다.public 생 성data.py
import os
#
baseDir = os.path.dirname(os.path.dirname(__file__))
#
file_path = baseDir + "/TestData/inter_test_data.xlsx"
API_apiName = 2
API_requestUrl = 3
API_requestMothod = 4
API_paramsType = 5
API_apiTestCaseFileName = 6
API_active = 7
CASE_requestData = 1
CASE_relyData = 2
CASE_responseCode = 3
CASE_responseData = 4
CASE_dataStore = 5
CASE_checkPoint = 6
CASE_active = 7
CASE_status = 8
CASE_errorInfo = 9
#
REQUEST_DATA = {}
#
RESPONSE_DATA = {}
if __name__=="__main__":
print(file_path)
print(baseDir)
5.테스트 파일 을 저장 하기 위해 TestData 디 렉 터 리 를 만 듭 니 다.inter_test_data.xlsx
6.action 패 키 지 를 만 들 고 키워드 함 수 를 저장 합 니 다.
6.1 데이터 의존 해결(GetRely.py)
from config.public_data import REQUEST_DATA, RESPONSE_DATA
from utils.md5_encrypt import md5_encrypt
REQUEST_DATA = {" ":{"1":{"username":"zhangsan", "password":"dfsdf23"},
"headers":{"cookie":"asdfwerw"}}}
RESPONSE_DATA = {" ":{"1":{"code":"00"}, "headers":{"age":2342}}}
class GetRely(object):
def __init__(self):
pass
@classmethod
def get(self, dataSource, relyData, headSource = {}):
print(type(dataSource))
print(dataSource)
data = dataSource.copy()
for key, value in relyData.items():
if key == "request":
# REQUEST_DATA
for k, v in value.items():
interfaceName, case_idx = v.split("->")
val = REQUEST_DATA[interfaceName][case_idx][k]
if k == "password":
data[k] = md5_encrypt(val)
else:
data[k] = val
elif key == "response":
# RESPONSE_DATA
for k, v in value.items():
interfaceName, case_idx = v.split("->")
data[k] = RESPONSE_DATA[interfaceName][case_idx][k]
elif key == "headers":
if headSource:
for key, value in value.items():
if key == "request":
for k, v in value.items():
for i in v:
headSource[i] = REQUEST_DATA[k]["headers"][i]
elif key == "response":
for i, val in value.items():
for j in val:
headSource[j] = RESPONSE_DATA[i]["headers"][j]
return "%s" %data
if __name__ == "__main__":
s = {"username": "", "password": "","code":""}
h = {"cookie":"123", "age":332}
rely = {"request": {"username": " ->1", "password": " ->1"},
"response":{"code":" ->1"},
"headers":{"request":{" ":["cookie"]},"response":{" ":["age"]}}
}
print(GetRely.get(s, rely, h))
6.2 데이터 저장 해결(RelyDataStore.py)
from config.public_data import RESPONSE_DATA, REQUEST_DATA
class RelyDataStore(object):
def __init__(self):
pass
@classmethod
def do(cls, storePoint, apiName, caseId, request_source = {}, response_source = {}, req_headers={}, res_headers = {}):
for key, value in storePoint.items():
if key == "request":
# , REQUEST_DATA
for i in value:
if i in request_source:
val = request_source[i]
if apiName not in REQUEST_DATA:
# ,
REQUEST_DATA[apiName]={str(caseId): {i: val}}
else:
#
if str(caseId) in REQUEST_DATA[apiName]:
REQUEST_DATA[apiName][str(caseId)][i] = val
else:
# ,
REQUEST_DATA[apiName][str(caseId)] = {i: val}
else:
print(" " + i)
elif key == "response":
# body, RESPONSE_DATA
for j in value:
if j in response_source:
val = response_source[j]
if apiName not in RESPONSE_DATA:
# ,
RESPONSE_DATA[apiName]={str(caseId): {j: val}}
else:
#
if str(caseId) in RESPONSE_DATA[apiName]:
RESPONSE_DATA[apiName][str(caseId)][j] = val
else:
# ,
RESPONSE_DATA[apiName][str(caseId)] = {j: val}
else:
print(" body " + j)
elif key == "headers":
for k, v in value.items():
if k == "request":
# REQUEST_DATA
for item in v:
if item in req_headers:
header = req_headers[item]
if "headers" in REQUEST_DATA[apiName]:
REQUEST_DATA[apiName]["headers"][item] = header
else:
REQUEST_DATA[apiName]["headers"] = {item: header}
elif k == "response":
# RESPONSE_DATA
for it in v:
if it in res_headers:
header = res_headers[it]
if "headers" in RESPONSE_DATA[apiName]:
RESPONSE_DATA[apiName]["headers"][it] = header
else:
RESPONSE_DATA[apiName]["headers"] = {item: header}
print(REQUEST_DATA)
print(RESPONSE_DATA)
if __name__ == "__main__":
r = {"username": "srwcx01", "password": "wcx123wac1", "email": "[email protected]"}
req_h = {"cookie":"csdfw23"}
res_h = {"age":597232}
s = {"request": ["username", "password"], "response": ["userid"],"headers":{"request":["cookie"],
"response":["age"]}}
res = {"userid": 12, "code": "00"}
RelyDataStore.do(s, "register", 1, r, res, req_headers=req_h, res_headers=res_h)
print(REQUEST_DATA)
print(RESPONSE_DATA)
6.3 데이터 검사 결과(CheckResult.py)
import re
class CheckResult(object):
def __init__(self):
pass
@classmethod
def check(self, responseObj, checkPoint):
responseBody = responseObj.json()
# responseBody = {"code": "", "userid": 12, "id": "12"}
errorKey = {}
for key, value in checkPoint.items():
if key in responseBody:
if isinstance(value, (str, int)):
#
if responseBody[key] != value:
errorKey[key] = responseBody[key]
elif isinstance(value, dict):
sourceData = responseBody[key]
if "value" in value:
#
regStr = value["value"]
rg = re.match(regStr, "%s" %sourceData)
if not rg:
errorKey[key] = sourceData
elif "type" in value:
#
typeS = value["type"]
if typeS == "N":
#
if not isinstance(sourceData, int):
errorKey[key] = sourceData
else:
errorKey[key] = "[%s] not exist" %key
return errorKey
if __name__ == "__main__":
r = {"code": "00", "userid": 12, "id": 12}
c = {"code": "00", "userid": {"type": "N"}, "id": {"value": "\d+"}}
print(CheckResult.check(r, c))
6.4 엑셀 에 결 과 를 적 는 다.
from config.public_data import *
def write_result(wbObj, sheetObj, responseData, errorKey, rowNum):
try:
# body
wbObj.writeCell(sheetObj, content="%s" %responseData,
rowNo = rowNum, colsNo=CASE_responseData)
#
if errorKey:
wbObj.writeCell(sheetObj, content="%s" %errorKey,
rowNo=rowNum, colsNo=CASE_errorInfo)
wbObj.writeCell(sheetObj, content="faild",
rowNo=rowNum, colsNo=CASE_status, style="red")
else:
wbObj.writeCell(sheetObj, content="pass",
rowNo=rowNum, colsNo=CASE_status, style="green")
except Exception as err:
raise err
7.로그 디 렉 터 리 를 만들어 로 그 를 저장 합 니 다.8.주 함수
#encoding=utf-8
import requests
import json
from action.get_rely import GetRely
from config.public_data import *
from utils.ParseExcel import ParseExcel
from utils.HttpClient import HttpClient
from action.data_store import RelyDataStore
from action.check_result import CheckResult
from action.write_result import write_result
from utils.Log import *
def main():
parseE = ParseExcel()
parseE.loadWorkBook(file_path)
sheetObj = parseE.getSheetByName("API")
activeList = parseE.getColumn(sheetObj, API_active)
for idx, cell in enumerate(activeList[1:], 2):
if cell.value == "y":
#
RowObj = parseE.getRow(sheetObj, idx)
apiName = RowObj[API_apiName -1].value
requestUrl = RowObj[API_requestUrl - 1].value
requestMethod = RowObj[API_requestMothod - 1].value
paramsType = RowObj[API_paramsType - 1].value
apiTestCaseFileName = RowObj[API_apiTestCaseFileName - 1].value
# sheet ,
caseSheetObj = parseE.getSheetByName(apiTestCaseFileName)
caseActiveObj = parseE.getColumn(caseSheetObj, CASE_active)
for c_idx, col in enumerate(caseActiveObj[1:], 2):
if col.value == "y":
#
caseRowObj = parseE.getRow(caseSheetObj, c_idx)
requestData = caseRowObj[CASE_requestData - 1].value
relyData = caseRowObj[CASE_relyData - 1].value
responseCode = caseRowObj[CASE_responseCode - 1].value
responseData = caseRowObj[CASE_responseData - 1].value
dataStore = caseRowObj[CASE_dataStore -1].value
checkPoint = caseRowObj[CASE_checkPoint - 1].value
#
if relyData:
logging.info(" %s %s !")
requestData = GetRely.get(eval(requestData), eval(relyData))
httpC = HttpClient()
response = httpC.request(requestMethod=requestMethod,
requestData=requestData,
requestUrl=requestUrl,
paramsType=paramsType
)
# ,
if response.status_code == 200:
responseData = response.json()
#
if dataStore:
RelyDataStore.do(eval(dataStore), apiName, c_idx - 1, eval(requestData), responseData)
#
else:
logging.info(" 【%s】 【%s】 , !" %(apiName, c_idx))
if checkPoint:
errorKey = CheckResult.check(response, eval(checkPoint))
write_result(parseE, caseSheetObj, responseData, errorKey, c_idx)
else:
logging.info(" 【%s】 【%s】 , , code 200!" %(apiName, c_idx))
else:
logging.info(" %s %s , !" %(idx -1, c_idx-1))
else:
logging.info(" %s !" %(idx -1))
if __name__=="__main__":
main()
프레임 이 완벽 해 야 합 니 다~~각 분야 의 신선 들 께 서 잘 부탁드립니다~~python+requests 인터페이스 자동화 프레임 워 크 의 실현 에 관 한 이 글 은 여기까지 소개 되 었 습 니 다.더 많은 관련 python requests 인터페이스 자동화 내용 은 우리 의 이전 글 을 검색 하거나 아래 의 관련 글 을 계속 찾 아 보 세 요.앞으로 많은 응원 바 랍 니 다!
이 내용에 흥미가 있습니까?
현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:
로마 숫자를 정수로 또는 그 반대로 변환그 중 하나는 로마 숫자를 정수로 변환하는 함수를 만드는 것이었고 두 번째는 그 반대를 수행하는 함수를 만드는 것이었습니다. 문자만 포함합니다'I', 'V', 'X', 'L', 'C', 'D', 'M' ; 문자열이 ...
텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.
CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.