提交改动

all_backend_api/answer_request.yaml

@@ -10,24 +10,24 @@ detail:
   # isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
 
 #回答详情页——点赞
-vote:
-  method: post
-  url: /api/answer/vote
-  params:
-    current_city_id: ${current_city_id}
-  data:
-    answer_id: ${answer_id}
-  json: {}
-  isLogin: 1
+#vote:
+#  method: post
+#  url: /api/answer/vote
+#  params:
+#    current_city_id: ${current_city_id}
+#  data:
+#    answer_id: ${answer_id}
+#  json: {}
+#  isLogin: 1
 
 #回答详情页——取消点赞
-cancel_vote:
-  method: post
-  url: /api/answer/cancel_vote
-  params:
-    current_city_id: ${current_city_id}
-  data:
-    answer_id: ${answer_id}
-  json: {}
-  isLogin: 1
+#cancel_vote:
+#  method: post
+#  url: /api/answer/cancel_vote
+#  params:
+#    current_city_id: ${current_city_id}
+#  data:
+#    answer_id: ${answer_id}
+#  json: {}
+#  isLogin: 1
 

all_backend_api/common_request.py

@@ -5,23 +5,31 @@ from in_common.base_request import BaseRequest
 class common_request(BaseRequest):
     def __init__(self):
         self.data = self.api_load(path_setting.DIARY_COMMON_CONFIG)
+        print("00000000000000",self.data)
 
     # 日记贴评论列表--一级评论列表
-    def diary_common_reply(self, id, type):
+    def diary_common_reply(self, id, type, data_type, offset ,start_num):
         self.params["id"] = id
         self.params["type"] = type
+        self.params["data_type"] = data_type
+        self.params["offset"] = offset
+        self.params["start_num"] = start_num
+
         return self.api_send(self.data["reply_detail"])
 
     # 日记贴评论列表--二级评论
-    def topic_sub_common(self, id, type, reply_id):
+    def topic_sub_common(self, id, type, reply_id,offset,start_num):
         self.params["id"] = id
         self.params["type"] = type
         self.params["reply_id"] = reply_id
+        self.params["offset"] = offset
+        self.params["start_num"] = start_num
         return self.api_send(self.data["sub_common"])
 
 
 
-
+if __name__ == '__main__':
+    common_request().diary_common_reply(21250007,2)
 
 
 

all_backend_api/common_request.yaml

@@ -5,6 +5,9 @@ reply_detail:
   params:
     id: ${id}
     type: ${type}
+    offset: ${offset}
+    start_num: ${start_num}
+    data_type: ${data_type}
   data: {}
   json: {}
   isLogin: 0  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
@@ -18,6 +21,8 @@ sub_common:
     id: ${id}
     type: ${type}
     reply_id: ${reply_id}
+    start_num: ${start_num}
+    offset: ${offset}
   data: {}
   json: {}
   isLogin: 0  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段

all_backend_api/conversation_request.py

@@ -6,12 +6,12 @@ class conversation_request(BaseRequest):
     def __init__(self):
         self.messageread = self.api_load(path_setting.MESSAGE_READ_CONFIG)
 
-    def message_read(self,current_city_id,release,message_ids):
-        self.params["current_city_id"] = current_city_id
-        self.params["release"] = release
-        #self.params["uqid"] = uqid
-        self.params["message_ids"] = message_ids
-        return self.api_send(self.messageread["message_read"])
+    # def message_read(self,current_city_id,release,message_ids):
+    #     self.params["current_city_id"] = current_city_id
+    #     self.params["release"] = release
+    #     #self.params["uqid"] = uqid
+    #     self.params["message_ids"] = message_ids
+    #     return self.api_send(self.messageread["message_read"])
 
     def detail_messageid(self, os_version, last_msg_id, offset_msg_id):
         self.params["os_version"] = os_version

all_backend_api/conversation_request.yaml

-message_read:
-  method: post
-  url: /api/conversation/message/read
-  params:
-    current_city_id: ${current_city_id}
-    release: ${release}
-    #uqid: ${uqid}
-  data:
-    message_ids: ${message_ids}
-
-  json: {}
-  isLogin: 1 #需要登录的接口
+#message_read:
+#  method: post
+#  url: /api/conversation/message/read
+#  params:
+#    current_city_id: ${current_city_id}
+#    release: ${release}
+#    #uqid: ${uqid}
+#  data:
+#    message_ids: ${message_ids}
+#
+#  json: {}
+#  isLogin: 1 #需要登录的接口
 
 detail_messageid:
   method: get

all_backend_api/diary_request.py

@@ -15,13 +15,10 @@ class diary_request(BaseRequest):
         return self.api_send(self.data["cancelfavor"])
 
     # 更新日记本
-    def diary_operation(self, diary_id, title, operation_timestamp, doctor_name, hospital_name):
-        self.params["diary_id"] = diary_id
-        self.params["title"] = title
-        self.params["operation_timestamp"] = operation_timestamp
-        self.params["doctor_name"] = doctor_name
-        self.params["hospital_name"] = hospital_name
-        return self.api_send(self.data["operation"])
+    def diary_operation(self, start_num, count):
+        self.params["start_num"] = start_num
+        self.params["count"] = count
+        return self.api_send(self.data["diary_operation"])
 
     # 添加信息--待争议
     def diary_additional_info(self):
@@ -48,3 +45,6 @@ class diary_request(BaseRequest):
         return self.api_send(self.data["update"])
 
 
+    def diary_pre_create_topic(self,diary_id):
+        self.params["diary_id"] = diary_id
+        return self.api_send(self.data["diary_pre_create_topic"])

all_backend_api/diary_request.yaml

 #日记本收藏
-isfavor:
-  method: post
-  url: /api/diary/favor/17586195
-  params:
-  data: {}
-  json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
+#isfavor:
+#  method: post
+#  url: /api/diary/favor/17586195
+#  params:
+#  data: {}
+#  json: {}
+#  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
 
 #日记本取消收藏
-cancelfavor:
-  method: delete
-  url: /api/diary/favor/17586195
-  params:
-  data: {}
-  json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
+#cancelfavor:
+#  method: delete
+#  url: /api/diary/favor/17586195
+#  params:
+#  data: {}
+#  json: {}
+#  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
 #
 
 #日记本修改信息
-operation:
-  method: post
-  url: /api/diary/additional_info/v2
-  params:
-  data:
-    diary_id: ${diary_id}
-    title: ${title}
-    operation_timestamp: ${operation_timestamp}
-    doctor_name: ${doctor_name}
-    hospital_name: ${hospital_name}
-
-  json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
-
-
-#查看日记修改信息页面
-additional_info:
-  method: get
-  url: /api/diary/operation/17586198/
-  params:
-  data: {}
-  json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
+#operation:
+#  method: post
+#  url: /api/diary/additional_info/v2
+#  params:
+#  data:
+#    diary_id: ${diary_id}
+#    title: ${title}
+#    operation_timestamp: ${operation_timestamp}
+#    doctor_name: ${doctor_name}
+#    hospital_name: ${hospital_name}
+#
+#  json: {}
+#  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
 
 
 #详情页内容
@@ -69,11 +59,31 @@ diary_service:
 
 
 #更新日记本的修改信息
-update:
-  method: post
-  url: /api/diary/update_v2/17586198
+#update:
+#  method: post
+#  url: /api/diary/update_v2/17586198
+#  params:
+#  data:
+#    topic_list: ${topic_list}
+#  json: {}
+#  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
+diary_operation:
+  method: get
+  url: /api/diary/operation/17878325
   params:
-  data:
-    topic_list: ${topic_list}
+    count: ${count}
+    start_num: ${start_num}
+    current_city_id: beijing
+  data: {}
+  json: {}
+  isLogin: 1
+
+diary_pre_create_topic:
+  method: get
+  url: /api/diary/pre_create_topic/v2
+  params:
+    current_city_id: beijing
+    diary_id: ${diary_id}
+  data: {}
   json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
+  isLogin: 1
\ No newline at end of file

all_backend_api/doctor_request.yaml

@@ -8,14 +8,16 @@ article:
     page: 1
     own_page: 0
     doctor_type: 0
+    current_city_id: beijing
   data: {}
   json: {}
 
 #医生主页详情
 detail:
   method: get
-  url: /api/doctor/5bd9f05cad51403d853ba8c881989e23/detail
-  params: {}
+  url: /api/doctor/a1ee69fad0794022b8f2b1517bf46eba/detail
+  params:
+    current_city_id: beijing
   data: {}
   json: {}
 

all_backend_api/gmai_request.yaml

-skin_newReport:
-  method: post
-  url: /gm_ai/skin/new_report
-  params:
-    version: ${version}
-  data:
-    image_url: ${image_url}
-
-
-eyelids_plastic:
-  method: post
-  url: /gm_ai/eyelids/plastic
-  params:
-    version: ${version}
-  data:
-    image_url: ${image_url}
-    style_id: ${style_id}
-
-
-analysis_v3:
-  method: post
-  url: /gm_ai/plastic/analysis_v3
-  params:
-    device_id: ${device_id}
-  data:
-    image_url: ${image_url}
-    landmark: ${landmark}
-    cheek_style_classify_id: ${cheek_style_classify_id}
-
-
-
-simulate_analyze:
-  method: post
-  url: /gm_ai/simulate/analyze
-  params:
-    device_id: ${device_id}
-  data:
-    image_url: ${image_url}
-    style_id: ${style_id}
-    type_id: ${type_id}
+#skin_newReport:
+#  method: post
+#  url: /gm_ai/skin/new_report
+#  params:
+#    version: ${version}
+#  data:
+#    image_url: ${image_url}
+#
+#
+#eyelids_plastic:
+#  method: post
+#  url: /gm_ai/eyelids/plastic
+#  params:
+#    version: ${version}
+#  data:
+#    image_url: ${image_url}
+#    style_id: ${style_id}
+#
+
+#analysis_v3:
+#  method: post
+#  url: /gm_ai/plastic/analysis_v3
+#  params:
+#    device_id: ${device_id}
+#  data:
+#    image_url: ${image_url}
+#    landmark: ${landmark}
+#    cheek_style_classify_id: ${cheek_style_classify_id}
+
+
+
+#simulate_analyze:
+#  method: post
+#  url: /gm_ai/simulate/analyze
+#  params:
+#    device_id: ${device_id}
+#  data:
+#    image_url: ${image_url}
+#    style_id: ${style_id}
+#    type_id: ${type_id}
 
 
 simulate_conf:
@@ -48,15 +48,15 @@ simulate_conf:
 
 
 
-plastic_analystic_v2:
-  method: post
-  url: /gm_ai/plastic/analysis_v2
-  params:
-    device_id: ${device_id}
-  data:
-    image_url: ${image_url}
-    landmark: ${landmark}
-    cheek_style_classify_id: ${cheek_style_classify_id}
+#plastic_analystic_v2:
+#  method: post
+#  url: /gm_ai/plastic/analysis_v2
+#  params:
+#    device_id: ${device_id}
+#  data:
+#    image_url: ${image_url}
+#    landmark: ${landmark}
+#    cheek_style_classify_id: ${cheek_style_classify_id}
 
 
 plastic_cheek_style_classify:

all_backend_api/hybrid_api_topic_request.yaml

 #日记本列表--日记贴点赞
-vote:
-  method: post
-  url: /hybrid/api/topic/vote/_data
-  params:
-  data:
-    id: ${id}
-  json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
+#vote:
+#  method: post
+#  url: /hybrid/api/topic/vote/_data
+#  params:
+#  data:
+#    id: ${id}
+#  json: {}
+#  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
 
 #取消点赞
-canclevote:
-  method: post
-  url: /hybrid/api/topic/cancel_vote/_data
-  params:
-  data:
-    id: ${id}
-  json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
+#canclevote:
+#  method: post
+#  url: /hybrid/api/topic/cancel_vote/_data
+#  params:
+#  data:
+#    id: ${id}
+#  json: {}
+#  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
 #
 detail:
   method: get

all_backend_api/hybrid_get_gift_request.yaml

 #商祥页-优惠券列表-领取
-get_gift_data:
-  method: post
-  url: /hybrid/get_gift/_data
-  params: {}
-  data:
-    gift_id: ${gift_id}
-  json: {}
-  isLogin: 1
+#get_gift_data:
+#  method: post
+#  url: /hybrid/get_gift/_data
+#  params: {}
+#  data:
+#    gift_id: ${gift_id}
+#  json: {}
+#  isLogin: 1
\ No newline at end of file

all_backend_api/im_request.yaml

@@ -12,31 +12,31 @@ conversation_detail:
   json: {}
   isLogin: 1 #需要登录的接口
 
-auto_msg:
-  method: post
-  url: /api/im/auto_msg
-  params:
-    trace_id: ${trace_id}
-
-  data:
-    conversation_id: ${conversation_id}
-
-  json: {}
-  isLogin: 1 #需要登录的接口
+#auto_msg:
+#  method: post
+#  url: /api/im/auto_msg
+#  params:
+#    trace_id: ${trace_id}
+#
+#  data:
+#    conversation_id: ${conversation_id}
+#
+#  json: {}
+#  isLogin: 1 #需要登录的接口
 
-send_msg:
-  method: post
-  url: /api/im/send_msg
-  params: {}
-
-  data:
-    conversation_id: ${conversation_id}
-    is_system: ${is_system}
-    referrer: ${referrer}
-    referrer_id: ${referrer_id}
-    msg_type: ${msg_type}
-    content: ${content}
-    extra: ${extra}
-
-  json: {}
-  isLogin: 1 #需要登录的接口
+#send_msg:
+#  method: post
+#  url: /api/im/send_msg
+#  params: {}
+#
+#  data:
+#    conversation_id: ${conversation_id}
+#    is_system: ${is_system}
+#    referrer: ${referrer}
+#    referrer_id: ${referrer_id}
+#    msg_type: ${msg_type}
+#    content: ${content}
+#    extra: ${extra}
+#
+#  json: {}
+#  isLogin: 1 #需要登录的接口
\ No newline at end of file

all_backend_api/janus_request.py

@@ -7,24 +7,6 @@ class janus_request(BaseRequest):
         #捜索结果页-综合/百科tab
         self.data = self.api_load(path_setting.CONTENTV7_CONFIG)
 
-        #医院主页捜索
-        self.data = self.api_load(path_setting.HOSPITALSEARCH_CONFIG)
-
-        #品类聚合页面商品列表
-        self.data = self.api_load(path_setting.TAG_SERVICE_CONFIG)
-
-        #品类聚合页面标签和专场
-        self.data = self.api_load(path_setting.POLYMER_CONFIG)
-
-        #医生医院sug列表
-        self.data = self.api_load(path_setting.KEYWORDTIP_CONFIG)
-
-        #次卡商详页
-        self.data = self.api_load(path_setting.BEAUTY_CARD_DETAIL_CONFIG)
-
-        #直播-点击【设置封面】
-        self.data = self.api_load(path_setting.PAGE_RULES_CONFIG)
-
     #搜索结果页-综合/百科tab
     def content_v7(self, query, device_id, current_city_id, version, is_first, tab_type, offset):
         #搜索词

all_backend_api/janus_request.yaml

@@ -108,30 +108,30 @@ keyword_tip:
   json: {}
 
 #次卡-确认订单
-beauty_card_order_confirm:
-  method: post
-  url: /api/janus/beauty_card/order/confirm
-  params: {}
-  data:
-    sku_id: ${sku_id}
-    number: ${number}
-    bctraceid: ""
-    use_bc_coupon: ${use_bc_coupon}
-    bc_coupon_id: ${bc_coupon_id}
-  json: {}
-  isLogin: 1
+#beauty_card_order_confirm:
+#  method: post
+#  url: /api/janus/beauty_card/order/confirm
+#  params: {}
+#  data:
+#    sku_id: ${sku_id}
+#    number: ${number}
+#    bctraceid: ""
+#    use_bc_coupon: ${use_bc_coupon}
+#    bc_coupon_id: ${bc_coupon_id}
+#  json: {}
+#  isLogin: 1
 
 #次卡-确认订单页面-修改手机号
-beauty_card_update_phone:
-  method: post
-  url: /api/janus/beauty_card/update_phone
-  params: {}
-  data:
-    authorize_phone: ${authorize_phone}
-    authorize_phone_type: ${authorize_phone_type}
-    vfc_code: ${vfc_code}
-  json: {}
-  isLogin: 1
+#beauty_card_update_phone:
+#  method: post
+#  url: /api/janus/beauty_card/update_phone
+#  params: {}
+#  data:
+#    authorize_phone: ${authorize_phone}
+#    authorize_phone_type: ${authorize_phone_type}
+#    vfc_code: ${vfc_code}
+#  json: {}
+#  isLogin: 1
 #次卡商详页
 beauty_card_detail:
   method: GET
@@ -165,19 +165,19 @@ service_hospital:
 
 
 #次卡-提交订单
-beauty_card_order_submit:
-  method: post
-  url: /api/janus/beauty_card/order/submit
-  params: {}
-  data:
-    phone: ${phone}
-    sku_id: ${sku_id}
-    number: ${number}
-    is_doctor_see: ${is_doctor_see}
-    gain_coupon_id: ${gain_coupon_id}
-    deduction_price: ${deduction_price}
-  json: {}
-  isLogin: 1
+#beauty_card_order_submit:
+#  method: post
+#  url: /api/janus/beauty_card/order/submit
+#  params: {}
+#  data:
+#    phone: ${phone}
+#    sku_id: ${sku_id}
+#    number: ${number}
+#    is_doctor_see: ${is_doctor_see}
+#    gain_coupon_id: ${gain_coupon_id}
+#    deduction_price: ${deduction_price}
+#  json: {}
+#  isLogin: 1
 
 #次卡-支付平台
 beauty_card_payment_method:
@@ -190,25 +190,25 @@ beauty_card_payment_method:
   isLogin: 1
 
 #次卡-微信支付
-beauty_card_prepay_wechat:
-  method: post
-  url: /api/janus/beauty_card/prepay/wechat
-  params: {}
-  data:
-    payment_id: ${payment_id}
-  json: {}
-  isLogin: 1
+#beauty_card_prepay_wechat:
+#  method: post
+#  url: /api/janus/beauty_card/prepay/wechat
+#  params: {}
+#  data:
+#    payment_id: ${payment_id}
+#  json: {}
+#  isLogin: 1
 
 #次卡-支付宝支付
-beauty_card_prepay_alipay:
-  method: post
-  url: /api/janus/beauty_card/prepay/alipay
-  params: {}
-  data:
-    is_huabei: ${is_huabei}
-    payment_id: ${payment_id}
-  json: {}
-  isLogin: 1
+#beauty_card_prepay_alipay:
+#  method: post
+#  url: /api/janus/beauty_card/prepay/alipay
+#  params: {}
+#  data:
+#    is_huabei: ${is_huabei}
+#    payment_id: ${payment_id}
+#  json: {}
+#  isLogin: 1
 
 ##次卡-支付宝支付-花呗分期
 #beauty_card_prepay_alipay_huabei:
@@ -233,14 +233,14 @@ beauty_card_payment_detail:
   isLogin: 1
 
 #次卡-取消订单
-beauty_card_payment_delete:
-  method: post
-  url: /api/janus/beauty_card/payment/delete
-  params: {}
-  data:
-    payment_id: ${payment_id}
-  json: {}
-  isLogin: 1
+#beauty_card_payment_delete:
+#  method: post
+#  url: /api/janus/beauty_card/payment/delete
+#  params: {}
+#  data:
+#    payment_id: ${payment_id}
+#  json: {}
+#  isLogin: 1
 
 #次卡-申请退款
 beauty_card_refund_info:
@@ -253,17 +253,17 @@ beauty_card_refund_info:
   isLogin: 1
 
 #次卡-提交退款申请
-beauty_card_refund_submit:
-  method: post
-  url: /api/janus/beauty_card/refund/submit
-  params: {}
-  data:
-    order_id: ${order_id}
-    reason_id: ${reason_id}
-    reason_text: ${reason_text}
-    reason_type: ${reason_type}
-  json: {}
-  isLogin: 1
+#beauty_card_refund_submit:
+#  method: post
+#  url: /api/janus/beauty_card/refund/submit
+#  params: {}
+#  data:
+#    order_id: ${order_id}
+#    reason_id: ${reason_id}
+#    reason_text: ${reason_text}
+#    reason_type: ${reason_type}
+#  json: {}
+#  isLogin: 1
 
 #新版本我的美券
 coupon_my_list:

all_backend_api/notification_request.yaml

@@ -11,14 +11,14 @@ unread:
   isLogin: 1 #需要登录的接口
 
 #标记为已读
-readall:
-  method: post
-  url: /api/notification/readall
-  params:
-    uqid: ${uqid}
-    trace_id: ${trace_id}
-    ua: ${ua}
-
-  data: {}
-  json: {}
-  isLogin: 1 #需要登录的接口
+#readall:
+#  method: post
+#  url: /api/notification/readall
+#  params:
+#    uqid: ${uqid}
+#    trace_id: ${trace_id}
+#    ua: ${ua}
+#
+#  data: {}
+#  json: {}
+#  isLogin: 1 #需要登录的接口
\ No newline at end of file

all_backend_api/oneimage_request.yaml

 #测肤结果页
-share_v4:
-  method: post
-  url: /api/one_image/share/v4
-  params:
-    version: ${version}
-  data:
-    face_id: ${face_id}
-  json: {}
+#share_v4:
+#  method: post
+#  url: /api/one_image/share/v4
+#  params:
+#    version: ${version}
+#  data:
+#    face_id: ${face_id}
+#  json: {}
 
 #测肤结果根据五官推荐美购
 recomend_services:

all_backend_api/pay_request.yaml

-wechat_prepay:
-  method: post
-  url: /pay/wechat/prepay
-  params:
-    current_city_id: "beijing"
-    version: 7.44.0
-  data:
-    settlement_id: ${settlement_id}
-  isLogin: 1
-
-alipay_prepay:
-  method: post
-  url: /pay/alipay/prepay
-  params:
-    current_city_id: "beijing"
-    version: 7.44.0
-  data:
-    settlement_id: ${settlement_id}
-    version: ${version}
-    is_huabei: ${is_huabei}
-    huabei_period: ${huabei_period}
-  isLogin: 1
-
-jump:
-  method: post
-  url: /pay/jump
-  params:
-    current_city_id: "beijing"
-    version: 7.44.0
-  data:
-    settlement_id: ${settlement_id}
-  isLogin: 1
+#wechat_prepay:
+#  method: post
+#  url: /pay/wechat/prepay
+#  params:
+#    current_city_id: "beijing"
+#    version: 7.44.0
+#  data:
+#    settlement_id: ${settlement_id}
+#  isLogin: 1
+#
+#alipay_prepay:
+#  method: post
+#  url: /pay/alipay/prepay
+#  params:
+#    current_city_id: "beijing"
+#    version: 7.44.0
+#  data:
+#    settlement_id: ${settlement_id}
+#    version: ${version}
+#    is_huabei: ${is_huabei}
+#    huabei_period: ${huabei_period}
+#  isLogin: 1
+#
+#jump:
+#  method: post
+#  url: /pay/jump
+#  params:
+#    current_city_id: "beijing"
+#    version: 7.44.0
+#  data:
+#    settlement_id: ${settlement_id}
+#  isLogin: 1

all_backend_api/private_conversation_request.yaml

-private_conversation:
-  method: post
-  url: /api/private_conversation/
-  params: {}
-  data:
-    content: ${content}
-    target_uid: ${target_uid}
-    referrer: ${referrer}
-    referrer_id: ${referrer_id}
-    is_system: ${is_system}
-    quick_consultation_id: ${quick_consultation_id}
-    diary_id: ${diary_id}
-    from_live: ${from_live}
-
-  json: {}
-  isLogin: 1 #需要登录的接口
+#private_conversation:
+#  method: post
+#  url: /api/private_conversation/
+#  params: {}
+#  data:
+#    content: ${content}
+#    target_uid: ${target_uid}
+#    referrer: ${referrer}
+#    referrer_id: ${referrer_id}
+#    is_system: ${is_system}
+#    quick_consultation_id: ${quick_consultation_id}
+#    diary_id: ${diary_id}
+#    from_live: ${from_live}
+#
+#  json: {}
+#  isLogin: 1 #需要登录的接口
\ No newline at end of file

all_backend_api/qa_request.yaml

 #问题收藏
-favor:
-  method: post
-  url:     /api/qa/favor
-  params:
-  data:
-    answer_id: ${answer_id}
-  json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
+#favor:
+#  method: post
+#  url:     /api/qa/favor
+#  params:
+#  data:
+#    answer_id: ${answer_id}
+#  json: {}
+#  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
 
 
 #问题取消收藏
-cancelfavor:
-  method: post
-  url:     /api/qa/favor/cancel
-  params:
-  data:
-    answer_id: ${answer_id}
-  json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
+#cancelfavor:
+#  method: post
+#  url:     /api/qa/favor/cancel
+#  params:
+#  data:
+#    answer_id: ${answer_id}
+#  json: {}
+#  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
 
 

all_backend_api/question_request.yaml

 #回答详情页-  一/二级评论
-reply_answer:
-  method: post
-  url: /api/question/reply_answer
-  params:
-    current_city_id: ${current_city_id}
-  data:
-    answer_id: ${answer_id}
-    content: ${content}
-    user_id: ${user_id}
-  json: {}
-  isLogin: 1
+#reply_answer:
+#  method: post
+#  url: /api/question/reply_answer
+#  params:
+#    current_city_id: ${current_city_id}
+#  data:
+#    answer_id: ${answer_id}
+#    content: ${content}
+#    user_id: ${user_id}
+#  json: {}
+#  isLogin: 1
\ No newline at end of file

all_backend_api/service_request.yaml

@@ -9,10 +9,10 @@ home_v5:
 
 
 #商祥页-收藏
-service_favor:
-  method: post
-  url: /api/service/favor/5857263/
-  params: {}
-  data: {}
-  json: {}
-  isLogin: 1
+#service_favor:
+#  method: post
+#  url: /api/service/favor/5857263/
+#  params: {}
+#  data: {}
+#  json: {}
+#  isLogin: 1
\ No newline at end of file

all_backend_api/settlement_request.yaml

-preview_v1:
-  method: post
-  url: /api/settlement/preview/v1
-  params:
-    current_city_id: ${current_city_id}
-  data:
-    service_item_id: ${service_item_id}
-    number: ${number}
-    use_platform_coupon: ${use_platform_coupon}
-    use_doctor_coupon: ${use_doctor_coupon}
-    use_coupon_grey: ${use_coupon_grey}
-    is_create_groupbuy: ${is_create_groupbuy}
-  json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
+#preview_v1:
+#  method: post
+#  url: /api/settlement/preview/v1
+#  params:
+#    current_city_id: ${current_city_id}
+#  data:
+#    service_item_id: ${service_item_id}
+#    number: ${number}
+#    use_platform_coupon: ${use_platform_coupon}
+#    use_doctor_coupon: ${use_doctor_coupon}
+#    use_coupon_grey: ${use_coupon_grey}
+#    is_create_groupbuy: ${is_create_groupbuy}
+#  json: {}
+#  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
 
 pay_v1:
   method: get
@@ -26,23 +26,23 @@ pay_v1:
   json: {}
   isLogin: 1
 
-create_v1:
-  method: post
-  url: /api/settlement/create/v1
-  params:
-    current_city_id: "beijing"
-    version: 7.44.0
-  data:
-    service_item_id: ${service_item_id}
-    number: ${number}
-    phone: "18301089978"
-    platform_coupon_id: ${platform_coupon_id}
-    use_point: ${use_point}
-    is_doctor_see: ${is_doctor_see}
-    doctor_coupon_id: ${doctor_coupon_id}
-    insurance_info: ${insurance_info}
-    is_create_groupbuy: ${is_create_groupbuy}
-  isLogin: 1
+#create_v1:
+#  method: post
+#  url: /api/settlement/create/v1
+#  params:
+#    current_city_id: "beijing"
+#    version: 7.44.0
+#  data:
+#    service_item_id: ${service_item_id}
+#    number: ${number}
+#    phone: "18301089978"
+#    platform_coupon_id: ${platform_coupon_id}
+#    use_point: ${use_point}
+#    is_doctor_see: ${is_doctor_see}
+#    doctor_coupon_id: ${doctor_coupon_id}
+#    insurance_info: ${insurance_info}
+#    is_create_groupbuy: ${is_create_groupbuy}
+#  isLogin: 1
 
 pay:
   method: get
@@ -64,15 +64,15 @@ detail:
   data: {}
   isLogin: 1
 
-delete:
-  method: post
-  url: /api/settlement/delete
-  params:
-    current_city_id: "beijing"
-    version: 7.44.0
-  data:
-    id: ${id}
-    cancel_reason_value: ${cancel_reason_value}
-  json: {}
-  isLogin: 1
+#delete:
+#  method: post
+#  url: /api/settlement/delete
+#  params:
+#    current_city_id: "beijing"
+#    version: 7.44.0
+#  data:
+#    id: ${id}
+#    cancel_reason_value: ${cancel_reason_value}
+#  json: {}
+#  isLogin: 1
 

all_backend_api/shopcart_request.yaml

@@ -8,13 +8,13 @@ list:
   isLogin: 1
 
 #商祥页-加入购物车
-add:
-  method: post
-  url: /api/shopcart/add/v1
-  params: {}
-  data:
-    from_live: ${from_live}
-    number: ${number}
-    service_item_id: ${service_item_id}
-  json: {}
-  isLogin: 1
+#add:
+#  method: post
+#  url: /api/shopcart/add/v1
+#  params: {}
+#  data:
+#    from_live: ${from_live}
+#    number: ${number}
+#    service_item_id: ${service_item_id}
+#  json: {}
+#  isLogin: 1
\ No newline at end of file

all_backend_api/topic_reply_create.yaml

 #日记贴一级评论创建[这个是非本身日记贴：21116006]--暂时未解决复写yaml文件的问题所以单独把创建评论踢出去
-reply_create:
-  method: post
-  url:  /api/topic/reply/create/21249632/
-  params:
-    channel: ${channel}
-  data:
-    content: ${content}
-  json: {}
+#reply_create:
+#  method: post
+#  url:  /api/topic/reply/create/21249632/
+#  params:
+#    channel: ${channel}
+#  data:
+#    content: ${content}
+#  json: {}
   isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
 
 
 #日记贴二级评论创建[这个是非本身日记贴：21116006]
-sub_reply_create:
-  method: post
-  url:  /api/topic/reply/create/21249632/
-  params:
-    channel: ${channel}
-  data:
-    content: ${content}
-    replied_id: ${replied_id}
-  json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
+#sub_reply_create:
+#  method: post
+#  url:  /api/topic/reply/create/21249632/
+#  params:
+#    channel: ${channel}
+#  data:
+#    content: ${content}
+#    replied_id: ${replied_id}
+#  json: {}
+#  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
\ No newline at end of file

all_backend_api/topic_request.yaml

 #日记贴详情页--日记贴点赞
-vote:
-  method: post
-  url: /api/topic/vote/
-  params:
-  data:
-    topic_id: ${topic_id}
-  json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
-
-#取消点赞
-cancelvote:
-  method: delete
-  url: /api/topic/vote/
-  params:
-    topic_id: ${topic_id}
-  data: {}
-  json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
+#vote:
+#  method: post
+#  url: /api/topic/vote/
+#  params:
+#  data:
+#    topic_id: ${topic_id}
+#  json: {}
+#  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
+#
+##取消点赞
+#cancelvote:
+#  method: delete
+#  url: /api/topic/vote/
+#  params:
+#    topic_id: ${topic_id}
+#  data: {}
+#  json: {}
+#  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
 
 #详情页内容
 detail:

all_backend_api/topicreply_vote.yaml

 #日记贴评论点赞
-topic_reply_vote:
-  method: post
-  url: /hybrid/api/topicreply/vote/_data
-  params:
-  data:
-    id: ${id}
-  json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
-
-topic_reply_cancelvote:
-  method: post
-  url: /hybrid/api/topicreply/cancel_vote/_data
-  params:
-  data:
-    id: ${id}
-  json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
+#topic_reply_vote:
+#  method: post
+#  url: /hybrid/api/topicreply/vote/_data
+#  params:
+#  data:
+#    id: ${id}
+#  json: {}
+#  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
 #
+#topic_reply_cancelvote:
+#  method: post
+#  url: /hybrid/api/topicreply/cancel_vote/_data
+#  params:
+#  data:
+#    id: ${id}
+#  json: {}
+#  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
+##
 
 

all_backend_api/tractate_request.yaml

@@ -39,65 +39,65 @@ reply:
 
 
 #帖子收藏
-favor:
-  method: post
-  url:    /api/tractate/favor
-  params:
-  data:
-    data_type:  ${data_type}
-    tractate_id: ${tractate_id}
-  json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
+#favor:
+#  method: post
+#  url:    /api/tractate/favor
+#  params:
+#  data:
+#    data_type:  ${data_type}
+#    tractate_id: ${tractate_id}
+#  json: {}
+#  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
 
 
 #帖子取消收藏
-cancelfavor:
-  method: post
-  url:     /api/tractate/favor/cancel
-  params:
-  data:
-    data_type: ${data_type}
-    tractate_id: ${tractate_id}
-  json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
+#cancelfavor:
+#  method: post
+#  url:     /api/tractate/favor/cancel
+#  params:
+#  data:
+#    data_type: ${data_type}
+#    tractate_id: ${tractate_id}
+#  json: {}
+#  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
 
 
 #帖子点赞
-tractate_vote:
-  method: post
-  url: /api/tractate/vote
-  params:
-  data:
-    tractate_id: ${tractate_id}
-    data_type: ${data_type}
-    reply_id: ${reply_id}
-  json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
+#tractate_vote:
+#  method: post
+#  url: /api/tractate/vote
+#  params:
+#  data:
+#    tractate_id: ${tractate_id}
+#    data_type: ${data_type}
+#    reply_id: ${reply_id}
+#  json: {}
+#  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
 
 #帖子取消点赞
-tractate_cancelvote:
-  method: post
-  url: /api/tractate/vote/cancel
-  params:
-  data:
-    tractate_id: ${tractate_id}
-    data_type: ${data_type}
-    reply_id: ${reply_id}
-  json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
-#
+#tractate_cancelvote:
+#  method: post
+#  url: /api/tractate/vote/cancel
+#  params:
+#  data:
+#    tractate_id: ${tractate_id}
+#    data_type: ${data_type}
+#    reply_id: ${reply_id}
+#  json: {}
+#  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
+##
 
 
 #帖子创建一级评论
-publish_reply:
-  method: post
-  url: /api/tractate/publish_reply
-  params:
-  data:
-    tractate_id: ${tractate_id}
-    data_type: ${data_type}
-    reply_id: ${reply_id}
-    content: ${content}
-  json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
+#publish_reply:
+#  method: post
+#  url: /api/tractate/publish_reply
+#  params:
+#  data:
+#    tractate_id: ${tractate_id}
+#    data_type: ${data_type}
+#    reply_id: ${reply_id}
+#    content: ${content}
+#  json: {}
+#  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
 #
\ No newline at end of file

all_backend_api/user_request.yaml

@@ -21,20 +21,20 @@ answer:
   json: {}
 
 #日记贴--收藏
-favor:
-  method: post
-  url: /api/user/problem_favor/21249632/
-  params:
-  data: {}
-  json: {}
-  isLogin: 1
-
-#日记贴--取消收藏
-canclefavor:
-  method: delete
-  url: /api/user/problem_favor/21249632/
-  params:
-  data: {}
-  json: {}
-  isLogin: 1
+#favor:
+#  method: post
+#  url: /api/user/problem_favor/21249632/
+#  params:
+#  data: {}
+#  json: {}
+#  isLogin: 1
+#
+##日记贴--取消收藏
+#canclefavor:
+#  method: delete
+#  url: /api/user/problem_favor/21249632/
+#  params:
+#  data: {}
+#  json: {}
+#  isLogin: 1
 

all_doctor_api/glmer_request.py

-import path_setting
-from in_common.base_request import BaseRequest
-
-
-class glmer_request(BaseRequest):
-    def __init__(self):
-        self.REGISTER_URL = self.api_load(path_setting.REGISTER_URL)
-
-    def service_register(self,name,project_type,upgrade,short_description,doctor_id,start_time,end_time,photo_details,image_header,video_token,service_type,is_specialreview,reservation,have_extra_pay,is_draft,items,csrfmiddlewaretoken):
-        self.params["name"] = name
-        self.params["project_type"] = project_type
-        self.params["upgrade"] = upgrade
-        self.params["short_description"] = short_description
-        self.params["doctor_id"] = doctor_id
-        self.params["start_time"] = start_time
-        self.params["end_time"] = end_time
-        self.params["photo_details"] = photo_details
-        self.params["image_header"] = image_header
-        self.params["video_token"] = video_token
-        self.params["service_type"] = service_type
-        self.params["is_specialreview"] = is_specialreview
-        self.params["reservation"] = reservation
-        self.params["have_extra_pay"] = have_extra_pay
-        self.params["is_draft"] = is_draft
-        self.params["items"] = items
-        self.params["csrfmiddlewaretoken"] = csrfmiddlewaretoken
-        return self.api_send(self.REGISTER_URL["service_register"])
-
-
-
-    def service_detail(self) :
-        return self.api_send(self.REGISTER_URL["service_detail"])
-
-    def tag_properties(self,catalog_ids):
-        #我的商品-编辑可标准化商品
-        self.params["catalog_ids"] = catalog_ids
-        return self.api_send(self.REGISTER_URL["tag_properties"])
-
-
-
-
-if __name__ == '__main__':
-    print(glmer_request().service_register("激光溶脂瘦脸", "[236]", "true", "测试", "wangyang", "1624377600", "1627660800", "<p>12</p>", "https://heras.igengmei.com/service/2021/06/01/0b9b110e60", "UPCOYIJkZOMcdd9FDzpBqYjzWUh55fBpVi3AhWpL:nBdvXYz_CR7wNcuroo3TLyvuQiY=:eyJzY29wZSI6InZpZGVvIiwiZGVhZGxpbmUiOjE2MjI1MTg2NTd9", "0", "false", "1", "false", "0", '[{"gengmei_price":100,"original_price":200,"is_online":true}]',"PC8uTySuxipukIMuqNV1OPB376C2ZZ3g"))
-    print(glmer_request().service_detail())
-    print(glmer_request().tag_properties("[115,141]"))

all_doctor_api/glmer_request.yaml

-service_register:
-  method: POST
-  url: /api/glmer/service/register
-  params: {}
-  data:
-    name: ${name}
-    project_type: ${project_type}
-    upgrade: ${upgrade}
-    short_description: ${short_description}
-    doctor_id: ${doctor_id}
-    start_time: ${start_time}
-    end_time: ${end_time}
-    photo_details: ${photo_details}
-    image_header: ${image_header}
-    video_token: ${video_token}
-    service_type: ${service_type}
-    is_specialreview: ${is_specialreview}
-    reservation: ${reservation}
-    have_extra_pay: ${have_extra_pay}
-    is_draft: ${is_draft}
-    items: ${items}
-    csrfmiddlewaretoken: ${csrfmiddlewaretoken}
-    phone_num: ${phone_num}
-    vfc_code: ${vfc_code}
-    face_token: ${face_token}
-  json: {}
-  isLogin: 1
-
-
-service_detail:
-   method: get
-   url: /api/glmer/service/detail/5885425
-   params: {}
-   data: {}
-   json: {}
-   isLogin: 1
-
-tag_properties:
-   method: get
-   url: /api/glmer/tag/properties
-   params:
-     catalog_ids: ${catalog_ids}
-   data: {}
-   json: {}
-   isLogin: 1
-

all_doctor_api/web2_request.py

-import path_setting
-from in_common.base_request import BaseRequest
-
-
-class web2_request(BaseRequest):
-    def __init__(self):
-        self.SERVICE_URL = self.api_load(path_setting.SERVICE_URL)
-        # self.SERVICE_REVIEW_URL = self.api_load(path_setting.SERVICE_REVIEW_URL)
-
-    def service_list(self, page,pagesize,is_online,extra_filter_choice):
-        #我的商品查询列表
-        self.params["page"] = page
-        self.params["pagesize"] = pagesize
-        self.params["is_online"] = is_online
-        self.params["extra_filter_choice"] = extra_filter_choice
-        return self.api_send(self.SERVICE_URL["service_list"])
-
-    def service_review_list(self,page,pagesize,type):
-        #商品审核查询列表
-        self.params["page"] = page
-        self.params["pagesize"] = pagesize
-        self.params["type"] = type
-        return self.api_send(self.SERVICE_URL["service_review_list"])
-
-    def servicereview_option(self,id, type,csrfmiddlewaretoken):
-        #商品审核-撤回审核、取消申请
-        self.params["id"] = id
-        self.params["type"] = type
-        self.params["csrfmiddlewaretoken"] = csrfmiddlewaretoken
-        return self.api_send(self.SERVICE_URL["servicereview_option"])
-
-    def tag_all(self) :
-        #发布商品-选择类目跳转发布商品页面tag接口
-        return self.api_send(self.SERVICE_URL["tag_all"])
-
-    def service_delete(self,is_delete,service_register_id,csrfmiddlewaretoken):
-        #我的商品-删除商品
-        self.params["is_delete"] = is_delete
-        self.params["service_register_id"] = service_register_id
-        self.params["csrfmiddlewaretoken"] = csrfmiddlewaretoken
-        return self.api_send(self.SERVICE_URL["service_delete"])
-
-    def service_deletelist(self,page):
-        #我的商品-商品回收站
-        self.params["page"] = page
-        return self.api_send(self.SERVICE_URL["service_deletelist"])
-
-    def artemis_ad_add_shopping_cart_info(self):
-        #我的购物车
-        return self.api_send(self.SERVICE_URL["artemis_ad_add_shopping_cart_info"])
-    def artemis_add_value_order_id_detail(self):
-        "我的服务订单-已购买"
-        return self.api_send(self.SERVICE_URL["artemis_add_value_order_id_detail"])
-
-
-
-
-
-
-if __name__ == '__main__':
-    print(web2_request().service_list("1", "10", "-1", "-1"))
-    print(web2_request().service_review_list("1", "10", "0"))
-    print(web2_request().servicereview_option("209989", "1", "PC8uTySuxipukIMuqNV1OPB376C2ZZ3g"))
-    print(web2_request().tag_all())
-    print(web2_request().service_delete("1","209863","PC8uTySuxipukIMuqNV1OPB376C2ZZ3g"))
-    print(web2_request().service_deletelist("1"))#商品回收站
-    print(web2_request().artemis_ad_add_shopping_cart_info())
-    print(web2_request().artemis_add_value_order_id_detail())
-

all_doctor_api/web2_request.yaml

-service_list:
-  method: get
-  url: /api/web2/service/list
-  params:
-    page: ${page}
-    pagesize: ${pagesize}
-    is_online: ${is_online}
-    extra_filter_choice: ${extra_filter_choice}
-  data: {}
-  json: {}
-  isLogin: 1
-
-
-service_review_list:
-   method: get
-   url: /api/web2/service/review/list
-   params:
-     page: ${page}
-     pagesize: ${pagesize}
-     type: ${type}
-   data: {}
-   json: {}
-   isLogin: 1
-
-
-servicereview_option:
-   method: POST
-   url: /api/web2/servicereview/option
-   params: {}
-   data:
-     id: ${id}
-     type: ${type}
-     csrfmiddlewaretoken: ${csrfmiddlewaretoken}
-   json: {}
-   isLogin: 1
-
-
-tag_all:
-  method: get
-  url: /api/web2/tag/all
-  param: {}
-  data: {}
-  json: {}
-  isLogin: 1
-
-service_delete:
-  method: POST
-  url: /api/web2/service/delete
-  params: {}
-  data:
-    is_delete: ${is_delete}
-    service_register_id: ${service_register_id}
-    csrfmiddlewaretoken: ${csrfmiddlewaretoken}
-  json: {}
-  isLogin: 1
-
-
-
-
-
-service_deletelist:
-   method: get
-   url: /api/web2/service/delete/list
-   params:
-     page: ${page}
-   data: {}
-   json: {}
-   isLogin: 1
-
-artemis_ad_add_shopping_cart_info:
-  method: get
-  url: /api/web2/artemis/ad/add_shopping_cart/info
-  params: {}
-  data: {}
-  json: {}
-  isLogin: 1 #需要登录
-artemis_add_value_order_id_detail:
-  method: get
-  url: /api/web2/artemis/add_value_order/957727877165/detail
-  params: {}
-  data: {}
-  json: {}
-  isLogin: 1 #需要登录
\ No newline at end of file

all_doctor_api/web_request.py

-import path_setting
-from in_common.base_request import BaseRequest
-
-
-class web_request(BaseRequest):
-    def __init__(self):
-        self.ACCOUNT_URL = self.api_load(path_setting.ACCOUNT_URL)
-
-    def account_unreadbadgecount(self) :
-        return self.api_send(self.ACCOUNT_URL["account_unreadbadgecount"])
-
-    def article_videotoken(self) :
-        return self.api_send(self.ACCOUNT_URL["article_videotoken"])
-
-    def doctor_submechanisms(self) :
-        return self.api_send(self.ACCOUNT_URL["doctor_submechanisms"])
-
-    def service_offline(self,id,csrfmiddlewaretoken):
-        self.params["id"] = id
-        self.params["csrfmiddlewaretoken"] = csrfmiddlewaretoken
-        return self.api_send(self.ACCOUNT_URL["service_offline"])
-
-    def conversation(self, is_star, page):
-        self.params["is_star"] = is_star
-        self.params["page"] = page
-        return self.api_send(self.ACCOUNT_URL["conversation"])
-
-    def conversation_unread_list(self, page):
-        self.params["page"] = page
-        return self.api_send(self.ACCOUNT_URL["conversation_unread_list"])
-
-    def service(self):
-        return self.api_send(self.ACCOUNT_URL["service"])
-
-    def conversation_diary(self, doctor_user_id):
-        self.params["doctor_user_id"] = doctor_user_id
-        return self.api_send(self.ACCOUNT_URL["conversation_diary"])
-
-    def conversation_coupon(self, doctor_user_id):
-        self.params["doctor_user_id"] = doctor_user_id
-        return self.api_send(self.ACCOUNT_URL["conversation_coupon"])
-
-    def service_all(self):
-        return self.api_send(self.ACCOUNT_URL["service_all"])
-
-    def conversation_user_id(self, type, content, doctor_user_id, t, csrfmiddlewaretoken):
-        self.params["type"] = type
-        self.params["content"] = content
-        self.params["doctor_user_id"] = doctor_user_id
-        self.params["t"] = t
-        self.params["csrfmiddlewaretoken"] = csrfmiddlewaretoken
-        return self.api_send(self.ACCOUNT_URL["conversation_user_id"])
-
-    # def file_upload(self, img_type,csrfmiddlewaretoken,id,name,type,lastModifiedDate,size,file):
-    #     self.params["img_type"] = img_type
-    #     self.params["csrfmiddlewaretoken"] = csrfmiddlewaretoken
-    #     self.params["id"] = id
-    #     self.params["name"] = name
-    #     self.params["type"] = type
-    #     self.params["lastModifiedDate"] = lastModifiedDate
-    #     self.params["size"] = size
-    #     self.params["file"] = file
-    #     return self.api_send(self.ACCOUNT_URL["file_upload"])
-    def cpc_homepage(self):
-        return self.api_send(self.ACCOUNT_URL["cpc_homepage"])
-    def artemis_ad_type_list(self):
-        return self.api_send(self.ACCOUNT_URL["artemis_ad_type_list"])
-    def artemis_order_list(self, status, page):
-        self.params["status"] = status
-        self.params["page"] = page
-        return self.api_send(self.ACCOUNT_URL["artemis_order_list"])
-    def artemis_order_id_detail(self):
-        "上线中订单详情页"
-        return self.api_send(self.ACCOUNT_URL["artemis_order_id_detail"])
-
-
-
-
-
-if __name__ == '__main__':
-    print(web_request().account_unreadbadgecount())
-    print(web_request().article_videotoken())
-    print(web_request().doctor_submechanisms())
-    print(web_request().service_offline("209992", "PC8uTySuxipukIMuqNV1OPB376C2ZZ3g"))
-    print(web_request().conversation(0, 1))
-    print(web_request().conversation_unread_list(1))
-    print(web_request().service())
-    print(web_request().conversation_diary(602329))
-    print(web_request().conversation_coupon(602329))
-    print(web_request().service_all())
-    # print(web_request().file_upload("19","PC8uTySuxipukIMuqNV1OPB376C2ZZ3g","WU_FILE_0","lADPDg7mQdiUTiLNAZDNAZA_400_400.jpg_720x720g.jpg","image/jpeg","Mon Apr 26 2021 11:29:45 GMT+0800 (中国标准时间)","17688","(binary)"))
-    print(web_request().conversation_user_id(0, "您好", 602329, "271caac2ae1687ca0a56ee18115b8183", "NLeTxEx1BOQo1zjv2us9BQ00ViMAHGpJ"))
-    print(web_request().cpc_homepage())
-    print(web_request().artemis_ad_type_list())
-    print("发送")
-    print(web_request().artemis_order_list(0, 1))
-    print(web_request().artemis_order_list(1, 1))
-    print(web_request().artemis_order_list(2, 1))
-    print(web_request().artemis_order_id_detail())
\ No newline at end of file

all_doctor_api/web_request.yaml

-account_unreadbadgecount:
-  method: get
-  url: /api/web/account/unread_badge_count
-  param: {}
-  data: {}
-  json: {}
-  isLogin: 1
-
-
-
-article_videotoken:
-  method: get
-  url: /api/web/article/video_token
-  param: {}
-  data: {}
-  json: {}
-  isLogin: 1
-
-
-
-doctor_submechanisms:
-  method: get
-  url: /api/web/doctor/submechanisms
-  param: {}
-  data: {}
-  json: {}
-  isLogin: 1
-
-
-service_offline:
-  method: post
-  url: /api/web/service/offline
-  param: {}
-  data:
-    id: ${id}
-    csrfmiddlewaretoken: ${csrfmiddlewaretoken}
-  json: {}
-  isLogin: 1
-
-conversation:
-  method: get
-  url: /api/web/conversation
-  params:
-    is_star: ${is_star}
-    page: ${page}
-  data: {}
-  json: {}
-  isLogin: 1 #需要登录
-
-conversation_unread_list:
-  method: get
-  url: /api/web/conversation/unread_list
-  params:
-    page: ${page}
-  data: {}
-  json: {}
-  isLogin: 1 #需要登录
-
-service:
-  method: get
-  url: /api/web/service
-  params: {}
-  data: {}
-  json: {}
-  isLogin: 1 #需要登录
-
-conversation_diary:
-  method: get
-  url: /api/web/conversation/diary
-  params:
-    doctor_user_id: ${doctor_user_id}
-  data: {}
-  json: {}
-  isLogin: 1 #需要登录
-
-conversation_coupon:
-  method: get
-  url: /api/web/conversation/coupon
-  params:
-    doctor_user_id: ${doctor_user_id}
-  data: {}
-  json: {}
-  isLogin: 1 #需要登录
-
-
-service_all:
-  method: get
-  url: /api/web/service/all
-  params: {}
-  data: {}
-  json: {}
-  isLogin: 1
-
-
-#file_upload:
-#  method: post
-#  url: /api/web/file/upload
-#  param: {}
-#  data:
-#    img_type: ${img_type}
-#    csrfmiddlewaretoken: ${csrfmiddlewaretoken}
-#    id: ${id}
-#    name: ${name}
-#    type: ${type}
-#    lastModifiedDate: ${lastModifiedDate}
-#    size: ${size}
-#    file: ${file}
-#  json: {}
-#  isLogin: 1
-
-conversation_user_id:
-  method: post
-  url: /api/web/conversation/602329_33909952
-  params: {}
-  data:
-    type: ${type}
-    content: ${content}
-    doctor_user_id: ${doctor_user_id}
-    t: ${t}
-    csrfmiddlewaretoken: ${csrfmiddlewaretoken}
-  json: {}
-  isLogin: 1 #需要登录
-
-cpc_homepage:
-  method: get
-  url: /api/web/cpc/homepage
-  params: {}
-  data: {}
-  json: {}
-  isLogin: 1 #需要登录
-
-artemis_ad_type_list:
-  method: get
-  url: /api/web/artemis/ad/type_list
-  params: {}
-  data: {}
-  json: {}
-  isLogin: 1 #需要登录
-
-artemis_order_list:
-  method: get
-  url: /api/web/artemis/order/list
-  params:
-    status: ${status}
-    page: ${page}
-  data: {}
-  json: {}
-  isLogin: 1 #需要登录
-
-artemis_order_id_detail:
-  method: get
-  url: /api/web/artemis/order/509151034657/detail
-  params: {}
-  data: {}
-  json: {}
-  isLogin: 1 #需要登录
\ No newline at end of file

all_om_api/beautycard_request.py

-import path_setting
-from in_common.base_request import BaseRequest
-
-
-class beautycard_request(BaseRequest):
-    def __init__(self):
-        #更美次卡-获取已添加页面次卡spu/sku列表
-        self.data = self.api_load(path_setting.GET_RELATED_BC_CONFIG)
-        #更美次卡-删除/批量删除已添加页面次卡
-        self.data = self.api_load(path_setting.DELETE_RELATED_BC_CONFIG)
-        #更美次卡-已添加页面全部导出
-        self.data = self.api_load(path_setting.EXPORT_RELATED_BC_CONFIG)
-        #更美次卡-更改次卡排序
-        self.data = self.api_load(path_setting.UPDATE_BC_RANK_CONFIG)
-        #更美次卡-按次卡sku_id导入，导入校验
-        self.data = self.api_load(path_setting.CHECK_SKU_IDS_CONFIG)
-
-    #更美次卡-获取已添加页面次卡spu/sku列表
-    def get_related_bc(self, unit_id, bc_sku_id, bc_spu_id, page, page_size):
-        self.params["unit_id"] = unit_id
-        self.params["bc_sku_id"] = bc_sku_id
-        self.params["bc_spu_id"] = bc_spu_id
-        self.params["page"] = page
-        self.params["page_size"] = page_size
-
-        return self.api_send(self.data["get_related_bc"])
-
-    #更美次卡-删除/批量删除已添加页面次卡
-    def delete_related_bc(self, unit_id, bc_sku_ids, bc_spu_ids, related_type):
-        self.params["unit_id"] = unit_id
-        self.params["bc_sku_ids"] = bc_sku_ids
-        self.params["bc_spu_ids"] = bc_spu_ids
-        self.params["related_type"] = related_type
-
-        return self.api_send(self.data["delete_related_bc"])
-
-    #更美次卡-已添加页面全部导出
-    def export_related_bc(self, unit_id, bc_sku_id, bc_spu_id):
-        self.params["unit_id"] = unit_id
-        self.params["bc_sku_id"] = bc_sku_id
-        self.params["bc_spu_id"] = bc_spu_id
-
-        return self.api_send(self.data["export_related_bc"])
-
-    #更美次卡-更改次卡排序
-    def update_bc_rank(self, unit_id, related_id, related_type, rank):
-        self.params["unit_id"] = unit_id
-        self.params["related_id"] = related_id
-        self.params["related_type"] = related_type
-        self.params["rank"] = rank
-
-        return self.api_send(self.data["update_bc_rank"])
-
-    #更美次卡-按次卡sku_id导入，导入校验
-    def check_sku_ids(self, bc_skus):
-        self.params["bc_skus"] = bc_skus
-
-        return self.api_send(self.data["check_sku_ids"])
-
-    #更美次卡-按次卡spu_id导入，导入校验
-    def check_spu_ids(self, bc_spus):
-        self.params["bc_spus"] = bc_spus
-
-        return self.api_send(self.data["check_spu_ids"])
-
-if __name__ == '__main__':
-    print(beautycard_request().get_related_bc("20105", "", "", "0", "10"))
-    print(beautycard_request().delete_related_bc("19931", "[10163]", "[]", "8"))
-    print(beautycard_request().export_related_bc("19933", "", ""))
-    print(beautycard_request().update_bc_rank("20105", "100023", "7", "11"))
\ No newline at end of file

all_om_api/beautycard_request.yaml

-#更美次卡-获取已添加页面次卡spu/sku列表
-get_related_bc:
-  method : GET
-  url : /achelous/visual/beauty_card/get_related_bc
-  params :
-    unit_id : ${unit_id}
-    bc_sku_id : ${bc_sku_id}
-    bc_spu_id : ${bc_spu_id}
-    page : ${page}
-    page_size : ${page_size}
-  data : {}
-  json : {}
-  isLogin : 1
-
-#更美次卡-删除/批量删除已添加页面次卡
-delete_related_bc:
-  method : POST
-  url : /achelous/visual/beauty_card/delete_related_bc
-  params : {}
-  data :
-    unit_id : ${unit_id}
-    bc_sku_ids : ${bc_sku_ids}
-    bc_spu_ids : ${bc_spu_ids}
-    related_type : ${related_type}
-  json : {}
-  isLogin : 1
-
-#更美次卡-已添加页面全部导出
-export_related_bc:
-  method : GET
-  url : /achelous/visual/beauty_card/export_related_bc
-  params :
-    unit_id : ${unit_id}
-    bc_sku_id : ${bc_sku_id}
-    bc_spu_id : ${bc_spu_id}
-  data : {}
-  json : {}
-  isLogin : 1
-
-#更美次卡-更改次卡排序
-update_bc_rank:
-  method : POST
-  url : /achelous/visual/beauty_card/update_bc_rank
-  params : {}
-  data :
-    unit_id: ${unit_id}
-    related_id: ${related_id}
-    related_type: ${related_type}
-    rank: ${rank}
-  json : {}
-  isLogin : 1
-
-#更美次卡-按次卡sku_id导入，导入校验
-check_sku_ids:
-  method : POST
-  url : /achelous/visual/beauty_card/check_sku_ids
-  params : {}
-  data :
-    bc_skus: ${bc_skus}
-  json : {}
-  isLogin : 1
-
-#更美次卡-按次卡spu_id导入，导入校验
-check_spu_ids:
-  method : POST
-  url : /achelous/visual/beauty_card/check_spu_ids
-  params : {}
-  data :
-    bc_spus: ${bc_spus}
-  json : {}
-  isLogin : 1
\ No newline at end of file

all_om_api/login_request.py

-import path_setting
-from in_common.base_request import BaseRequest
-
-
-class login_request(BaseRequest):
-    def __init__(self):
-        #om后台-登录
-        self.data = self.api_load(path_setting.OMLOGIN_CONFIG)
-
-    #om后台-登录
-    def om_login(self, username, password):
-        self.params["username"] = username
-        self.params["password"] = password
-
-        return self.api_send(self.data["om_login"])
-
-if __name__ == '__main__':
-    print(login_request().om_login("admin", "123123"))
\ No newline at end of file

all_om_api/login_request.yaml

-#om后台-登录
-om_login:
-  method : POST
-  url : /achelous/account/login
-  params: {}
-  data :
-    username: ${username}
-    password: ${password}
-  json : {}

in_common/base_request.py

@@ -45,7 +45,7 @@ class BaseRequest:
         if host_service not in host['develop_host']:
             host_service = 'backend'
         url_host = host['develop_host'][host_service]
-
+        print("-----------",url_host)
         # if host["develop_host"].get("doctor") is not None:
         #     url_host = host['develop_host']['doctor']
         # elif host["develop_host"].get("backend") is not None:
@@ -73,7 +73,7 @@ class BaseRequest:
             # proxies={"http":"172.30.9.226:8888"}
 
         )
-        print("0000000",r)
+        # print("0000000",r.json())
         # return r.json()
         try:
             content_type = r.headers.get("content-type").split(";")[0]

login_session_function.yaml

 backend_login:
   method: POST
-  url: /api/account/login/login_vfc
+  url: /api/accounts/login/password
   params:
     current_city_id: "beijing"
   data:
-    phone_num: "+8612345678912"
-    vfc_code: 1234
-    vfc_type:
-    face_token:
-
-#backend_login:
-#  method: POST
-#  url: /api/accounts/login/password
-#  params:
-#    current_city_id: "beijing"
-#  data:
-#    phone: "+8618646292152"
-#    password: 111111
-
-
-doctor_login:
-  method: post
-  url: /api/web/account/login
-  params: {}
-  data:
-    name: "12345654321"
+    phone: "18301089928"
     password: 123456
-    method: password
-    csrfmiddlewaretoken: "PKHywf6cMBZUkc5WfklO71bQNoMztAfv"
-
-
-om_login:
-  method: post
-  url: /achelous/account/login
-  params: {}
-  data:
-    username: "admin"
-    password: "123123"
+    lng: 116.4879672787569
+    lat: 39.98338452087316
+    face_token:
\ No newline at end of file

path_setting.py

@@ -3,525 +3,526 @@ import os, sys
 BASE_DIR = os.path.dirname(os.path.dirname(__file__))
 sys.path.append(BASE_DIR)
 
-HOSTYAML_CONFIG = os.path.join(BASE_DIR, "backend_auto", "host.yaml")
-LOGIN_FUNCTION_DATA = os.path.join(BASE_DIR, "backend_auto", "login_session_function.yaml")
+HOSTYAML_CONFIG = os.path.join(BASE_DIR, "on_line_product", "host.yaml")
+LOGIN_FUNCTION_DATA = os.path.join(BASE_DIR, "on_line_product", "login_session_function.yaml")
 
-APYAML_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "account_request.yaml")
-LOGIN_VFC = os.path.join(BASE_DIR, "backend_auto/test_backend_data/account_data", "login_vfc.yaml")
+APYAML_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "account_request.yaml")
+LOGIN_VFC = os.path.join(BASE_DIR, "on_line_product/test_backend_data/account_data", "login_vfc.yaml")
 
 
 # 日记本总接口配置
-DIARY_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "diary_request.yaml")
+DIARY_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "diary_request.yaml")
 #日记本详情页--字段判空
-DIARY_DATA = os.path.join(BASE_DIR, "backend_auto/test_backend_data/diary_data", "topic_data.yaml")
+DIARY_DATA = os.path.join(BASE_DIR, "on_line_product/test_backend_data/diary_data", "topic_data.yaml")
 #日记本关联美购
-DIARY_SERVICE_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "diary_service.yaml")
-DIARY_SERVICE = os.path.join(BASE_DIR, "backend_auto/test_backend_data/diary_data", "diary_service.yaml")
+DIARY_SERVICE_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "diary_service.yaml")
+DIARY_SERVICE = os.path.join(BASE_DIR, "on_line_product/test_backend_data/diary_data", "diary_service.yaml")
 
 #日记本收藏&取消收藏
-DIARY_FAVOR = os.path.join(BASE_DIR, "backend_auto/test_backend_data/diary_data", "favor.yaml")
+DIARY_FAVOR = os.path.join(BASE_DIR, "on_line_product/test_backend_data/diary_data", "favor.yaml")
 # 日记本修改日记信息operation--目前好像直接用接口写无权限稍后解决
-DIARY_OPERATION_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "diary_operation.yaml")
-DIARY_OPERATION = os.path.join(BASE_DIR, "backend_auto/test_backend_data/diary_data", "diary_operation.yaml")
+DIARY_OPERATION_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "diary_operation.yaml")
+DIARY_OPERATION = os.path.join(BASE_DIR, "on_line_product/test_backend_data/diary_data", "diary_operation.yaml")
 # 日记本创建日记贴信息-
-DIARY_UPDATE_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "diary_update.yaml")
-DIARY_UPDATE = os.path.join(BASE_DIR, "backend_auto/test_backend_data/diary_data", "diary_update.yaml")
-
+DIARY_UPDATE_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "diary_update.yaml")
+DIARY_UPDATE = os.path.join(BASE_DIR, "on_line_product/test_backend_data/diary_data", "diary_update.yaml")
 
+DIARY_PRE_CREATE_TOPIC = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "diary_update.yaml")
+DIARY_PRE_CREATE_TOPIC_DATE = os.path.join(BASE_DIR, "on_line_product/test_backend_data/diary_data", "diary_pre_create_topic.yaml")
 # 日记本进入相册页
-DIARY_ALBUM_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "hybrid_diary_request.yaml")
-DIARY_ALBUM = os.path.join(BASE_DIR, "backend_auto/test_backend_data/hybrid_data", "diary_album.yaml")
+DIARY_ALBUM_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "hybrid_diary_request.yaml")
+DIARY_ALBUM = os.path.join(BASE_DIR, "on_line_product/test_backend_data/hybrid_data", "diary_album.yaml")
 
 
 
 
 # 日记本列表-日记贴点赞相关（）
-DIARY_VOTE_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "hybrid_api_topic_request.yaml")
-DIARY_VOTE = os.path.join(BASE_DIR, "backend_auto/test_backend_data/hybrid_data", "api_topic_vote.yaml")
+DIARY_VOTE_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "hybrid_api_topic_request.yaml")
+DIARY_VOTE = os.path.join(BASE_DIR, "on_line_product/test_backend_data/hybrid_data", "api_topic_vote.yaml")
 
 
 # 日记本&帖子&日记贴&帖子&问答各个详情页下方推荐内容
-PERSONAL_RECOMMENDS_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "personal_recommends.yaml")
-PERSONAL_RECOMMENDS = os.path.join(BASE_DIR, "backend_auto/test_backend_data/personal_data", "personal_recommends.yaml")
+PERSONAL_RECOMMENDS_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "personal_recommends.yaml")
+PERSONAL_RECOMMENDS = os.path.join(BASE_DIR, "on_line_product/test_backend_data/personal_data", "personal_recommends.yaml")
 
 
 # 日记本列表-展示评论列表---也是总的common的配置
-DIARY_COMMON_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "common_request.yaml")
+DIARY_COMMON_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "common_request.yaml")
 # 日记本列表-一级评论展示评论列表
-DIARY_COMMON_REPLY = os.path.join(BASE_DIR, "backend_auto/test_backend_data/common_data", "reply.yaml")
+DIARY_COMMON_REPLY = os.path.join(BASE_DIR, "on_line_product/test_backend_data/common_data", "reply.yaml")
 # 日记贴-子评论列表
-TOPIC_SUB_COMMON = os.path.join(BASE_DIR, "backend_auto/test_backend_data/common_data", "sub_common.yaml")
+TOPIC_SUB_COMMON = os.path.join(BASE_DIR, "on_line_product/test_backend_data/common_data", "sub_common.yaml")
 
 
 # 日记贴-创建一级评论&二级评论
-TOPIC_REPLY_CREATE_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "topic_reply_create.yaml")
-TOPIC_REPLY_CREATE = os.path.join(BASE_DIR, "backend_auto/test_backend_data/topic_data", "topic_reply_create.yaml")
+TOPIC_REPLY_CREATE_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "topic_reply_create.yaml")
+TOPIC_REPLY_CREATE = os.path.join(BASE_DIR, "on_line_product/test_backend_data/topic_data", "topic_reply_create.yaml")
 
 
 # 日记贴-一级评论点赞&取消点赞topicreply
-TOPIC_REPLY_VOTE_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "topicreply_vote.yaml")
-TOPIC_REPLY_VOTE = os.path.join(BASE_DIR, "backend_auto/test_backend_data/topic_data", "reply_vote.yaml")
+TOPIC_REPLY_VOTE_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "topicreply_vote.yaml")
+TOPIC_REPLY_VOTE = os.path.join(BASE_DIR, "on_line_product/test_backend_data/topic_data", "reply_vote.yaml")
 
 
 # 日记贴-收藏&取消收藏--config文件代表，data代表接口
-TOPIC_FAVOR_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "user_request.yaml")
-TOPIC_FAVOR = os.path.join(BASE_DIR, "backend_auto/test_backend_data/user_data", "problem_favor.yaml")
+TOPIC_FAVOR_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "user_request.yaml")
+TOPIC_FAVOR = os.path.join(BASE_DIR, "on_line_product/test_backend_data/user_data", "problem_favor.yaml")
 
 
 # 日记贴-topic总的接口的请求配置
-TOPIC_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "topic_request.yaml")
+TOPIC_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "topic_request.yaml")
 # 日记贴-详情页内容
-TOPIC_DETAIL = os.path.join(BASE_DIR, "backend_auto/test_backend_data/topic_data", "v1.yaml")
+TOPIC_DETAIL = os.path.join(BASE_DIR, "on_line_product/test_backend_data/topic_data", "v1.yaml")
 # 日记贴-点赞&取消点赞--详情页内部
-TOPIC_VOTE = os.path.join(BASE_DIR, "backend_auto/test_backend_data/topic_data", "vote.yaml")
+TOPIC_VOTE = os.path.join(BASE_DIR, "on_line_product/test_backend_data/topic_data", "vote.yaml")
 
 
 
 
 # 帖子详情页内容--也是总的tractate接口的配置
-TRACTATE_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "tractate_request.yaml")
+TRACTATE_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "tractate_request.yaml")
 # 帖子详情页内容
-TRACTATE_DETAIL = os.path.join(BASE_DIR, "backend_auto/test_backend_data/tractate_data", "new_detail.yaml")
+TRACTATE_DETAIL = os.path.join(BASE_DIR, "on_line_product/test_backend_data/tractate_data", "new_detail.yaml")
 # 帖子详情页--相关美购&推荐美购
-TRACTATE_RELATED_SERVICE = os.path.join(BASE_DIR, "backend_auto/test_backend_data/tractate_data", "related_service.yaml")
+TRACTATE_RELATED_SERVICE = os.path.join(BASE_DIR, "on_line_product/test_backend_data/tractate_data", "related_service.yaml")
 # 帖子详情页--外显评论
-TRACTATE_REPLY = os.path.join(BASE_DIR, "backend_auto/test_backend_data/tractate_data", "reply.yaml")
+TRACTATE_REPLY = os.path.join(BASE_DIR, "on_line_product/test_backend_data/tractate_data", "reply.yaml")
 # 帖子详情页--收藏&取消收藏
-TRACTATE_FAVOR = os.path.join(BASE_DIR, "backend_auto/test_backend_data/tractate_data", "favor.yaml")
+TRACTATE_FAVOR = os.path.join(BASE_DIR, "on_line_product/test_backend_data/tractate_data", "favor.yaml")
 # 帖子详情页--点赞&取消点赞
-TRACTATE_VOTE = os.path.join(BASE_DIR, "backend_auto/test_backend_data/tractate_data", "vote.yaml")
+TRACTATE_VOTE = os.path.join(BASE_DIR, "on_line_product/test_backend_data/tractate_data", "vote.yaml")
 # 帖子详情页--一级评论创建
-TRACTATE_PUBLISH_REPLY = os.path.join(BASE_DIR, "backend_auto/test_backend_data/tractate_data", "publish_reply.yaml")
+TRACTATE_PUBLISH_REPLY = os.path.join(BASE_DIR, "on_line_product/test_backend_data/tractate_data", "publish_reply.yaml")
 
 
 # 问答详情页--问题详情
-QUESTION_DETAIL = os.path.join(BASE_DIR, "backend_auto/test_backend_data/hybrid_data", "question_v1.yaml")
+QUESTION_DETAIL = os.path.join(BASE_DIR, "on_line_product/test_backend_data/hybrid_data", "question_v1.yaml")
 # 问答详情页--回答列表
-ANSWER_LIST = os.path.join(BASE_DIR, "backend_auto/test_backend_data/hybrid_data", "question_new_answer_list.yaml")
+ANSWER_LIST = os.path.join(BASE_DIR, "on_line_product/test_backend_data/hybrid_data", "question_new_answer_list.yaml")
 
 
 # qa接口总的配置项--问答·相关
-QA_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "qa_request.yaml")
+QA_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "qa_request.yaml")
 # -问题的收藏&取消收藏
-QA_FAVOR = os.path.join(BASE_DIR, "backend_auto/test_backend_data/qa_data", "favor.yaml")
+QA_FAVOR = os.path.join(BASE_DIR, "on_line_product/test_backend_data/qa_data", "favor.yaml")
 # -test的文件，尝试在不动原函数的基础上加参数而不是用默认参数。--没必要
-# TEST_QA = os.path.join(BASE_DIR, "backend_auto/test_backend_data/qa_data", "test.yaml")
+# TEST_QA = os.path.join(BASE_DIR, "on_line_product/test_backend_data/qa_data", "test.yaml")
 
 
 
 #搜索首页-热门搜索
-KEYWORDS_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "search_request.yaml")
-KEYWORDS = os.path.join(BASE_DIR, "backend_auto/test_backend_data/search_data", "keywords.yaml")
+KEYWORDS_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "search_request.yaml")
+KEYWORDS = os.path.join(BASE_DIR, "on_line_product/test_backend_data/search_data", "keywords.yaml")
 
 #医生后台-我的商品
-SERVICE_DATA=os.path.join(BASE_DIR, "backend_auto/test_doctor_data/web2_data", "service_list.yaml")
+SERVICE_DATA=os.path.join(BASE_DIR, "on_line_product/test_doctor_data/web2_data", "service_list.yaml")
 
-SERVICE_URL=os.path.join(BASE_DIR, "backend_auto/all_doctor_api", "web2_request.yaml")
+SERVICE_URL=os.path.join(BASE_DIR, "on_line_product/all_doctor_api", "web2_request.yaml")
 
 #医生后台-商品审核流程
 
-SERVICE_REVIEW_DATA=os.path.join(BASE_DIR, "backend_auto/test_doctor_data/web2_data", "service_review_list.yaml")
+SERVICE_REVIEW_DATA=os.path.join(BASE_DIR, "on_line_product/test_doctor_data/web2_data", "service_review_list.yaml")
 
 #医生后台-新商品审核-撤回审核流程
 
-SERVICEREVIEW_OPTION_DATA=os.path.join(BASE_DIR, "backend_auto/test_doctor_data/web2_data", "servicereview_option.yaml")
+SERVICEREVIEW_OPTION_DATA=os.path.join(BASE_DIR, "on_line_product/test_doctor_data/web2_data", "servicereview_option.yaml")
 
 #医生后台-发布商品选择类目ACCOUNT
-ACCOUNT_URL=os.path.join(BASE_DIR, "backend_auto/all_doctor_api", "web_request.yaml")
-ACCOUNT_DATA=os.path.join(BASE_DIR, "backend_auto/test_doctor_data/web_data", "account_unreadbadgecount.yaml")
+ACCOUNT_URL=os.path.join(BASE_DIR, "on_line_product/all_doctor_api", "web_request.yaml")
+ACCOUNT_DATA=os.path.join(BASE_DIR, "on_line_product/test_doctor_data/web_data", "account_unreadbadgecount.yaml")
 
 # 医生后台-发布商品选择类目article
-ARTICLE_DATA=os.path.join(BASE_DIR, "backend_auto/test_doctor_data/web_data", "article_videotoken.yaml")
+ARTICLE_DATA=os.path.join(BASE_DIR, "on_line_product/test_doctor_data/web_data", "article_videotoken.yaml")
 
 #医生后台 - 发布商品选择类目tag
-TAG_DATA=os.path.join(BASE_DIR, "backend_auto/test_doctor_data/web2_data", "tag_all.yaml")
+TAG_DATA=os.path.join(BASE_DIR, "on_line_product/test_doctor_data/web2_data", "tag_all.yaml")
 
 #医生后台 - 发布商品选择类目doctor
-DOCTOR_DATA=os.path.join(BASE_DIR, "backend_auto/test_doctor_data/web_data", "doctor_submechanisms.yaml")
+DOCTOR_DATA=os.path.join(BASE_DIR, "on_line_product/test_doctor_data/web_data", "doctor_submechanisms.yaml")
 
 #搜索首页-热门搜索
-KEYWORDS_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "search_request.yaml")
-KEYWORDS = os.path.join(BASE_DIR, "backend_auto/test_backend_data/search_data", "keywords.yaml")
+KEYWORDS_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "search_request.yaml")
+KEYWORDS = os.path.join(BASE_DIR, "on_line_product/test_backend_data/search_data", "keywords.yaml")
 
 #医生后台-保存新增商品
-REGISTER_URL=os.path.join(BASE_DIR, "backend_auto/all_doctor_api", "glmer_request.yaml")
-REGISTER_DATA=os.path.join(BASE_DIR, "backend_auto/test_doctor_data/glmer_data", "service_register.yaml")
+REGISTER_URL=os.path.join(BASE_DIR, "on_line_product/all_doctor_api", "glmer_request.yaml")
+REGISTER_DATA=os.path.join(BASE_DIR, "on_line_product/test_doctor_data/glmer_data", "service_register.yaml")
 
 #医生后台-编辑商品
-DETAIL_DATA=os.path.join(BASE_DIR, "backend_auto/test_doctor_data/glmer_data", "service_detail.yaml")
+DETAIL_DATA=os.path.join(BASE_DIR, "on_line_product/test_doctor_data/glmer_data", "service_detail.yaml")
 
 #医生后台-我的商品-下线商品
-OFFLINE_DATA=os.path.join(BASE_DIR, "backend_auto/test_doctor_data/web_data", "service_offline.yaml")
+OFFLINE_DATA=os.path.join(BASE_DIR, "on_line_product/test_doctor_data/web_data", "service_offline.yaml")
 
 #医生后台-我的商品-删除商品
-DELETE_DATA=os.path.join(BASE_DIR, "backend_auto/test_doctor_data/web2_data", "service_delete.yaml")
+DELETE_DATA=os.path.join(BASE_DIR, "on_line_product/test_doctor_data/web2_data", "service_delete.yaml")
 
 #医生后台-编辑可标准化商品
-PROPERTIES_DATA=os.path.join(BASE_DIR, "backend_auto/test_doctor_data/glmer_data", "tag_properties.yaml")
+PROPERTIES_DATA=os.path.join(BASE_DIR, "on_line_product/test_doctor_data/glmer_data", "tag_properties.yaml")
 
 #医生后台-商品回收站
-DELETELIST_DATA=os.path.join(BASE_DIR, "backend_auto/test_doctor_data/web2_data", "service_deletelist.yaml")
+DELETELIST_DATA=os.path.join(BASE_DIR, "on_line_product/test_doctor_data/web2_data", "service_deletelist.yaml")
 
 #医生后台-上线商品、编辑商品
-SERVICEALL_DATA=os.path.join(BASE_DIR, "backend_auto/test_doctor_data/web_data", "service_all.yaml")
+SERVICEALL_DATA=os.path.join(BASE_DIR, "on_line_product/test_doctor_data/web_data", "service_all.yaml")
 
 #搜索首页-热门搜索
-KEYWORDS_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "search_request.yaml")
-KEYWORDS = os.path.join(BASE_DIR, "backend_auto/test_backend_data/search_data", "keywords.yaml")
+KEYWORDS_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "search_request.yaml")
+KEYWORDS = os.path.join(BASE_DIR, "on_line_product/test_backend_data/search_data", "keywords.yaml")
 
 # 首页灰度v9，精选tab
-FEED_INDEXV9_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "feed_request.yaml")
-FEED_INDEXV9_DATA = os.path.join(BASE_DIR, "backend_auto/test_backend_data/feed_data", "index_v9.yaml")
+FEED_INDEXV9_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "feed_request.yaml")
+FEED_INDEXV9_DATA = os.path.join(BASE_DIR, "on_line_product/test_backend_data/feed_data", "index_v9.yaml")
 
 # 测颜值结果页
-ONEIMAGE_SHARE_V4_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "oneimage_request.yaml")
-ONEIMAGE_SHARE_V4_DATA = os.path.join(BASE_DIR, "backend_auto/test_backend_data/oneimage_data", "share_v4.yaml")
+ONEIMAGE_SHARE_V4_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "oneimage_request.yaml")
+ONEIMAGE_SHARE_V4_DATA = os.path.join(BASE_DIR, "on_line_product/test_backend_data/oneimage_data", "share_v4.yaml")
 # 测颜值根据五官推荐美购
-ONEIMAGE_RECOMEND_SERVICES_DATA = os.path.join(BASE_DIR, "backend_auto/test_backend_data/oneimage_data", "recomend_services.yaml")
+ONEIMAGE_RECOMEND_SERVICES_DATA = os.path.join(BASE_DIR, "on_line_product/test_backend_data/oneimage_data", "recomend_services.yaml")
 # 测颜值结果页获取小程序二维码
-XCX_GENGMEI_GET_WXACODE_UNLIMITED_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "xcx_request.yaml")
-XCX_GENGMEI_GET_WXACODE_UNLIMITED_DATA = os.path.join(BASE_DIR, "backend_auto/test_backend_data/xcx_data", "gengmei_get_wxacode_unlimited.yaml")
+XCX_GENGMEI_GET_WXACODE_UNLIMITED_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "xcx_request.yaml")
+XCX_GENGMEI_GET_WXACODE_UNLIMITED_DATA = os.path.join(BASE_DIR, "on_line_product/test_backend_data/xcx_data", "gengmei_get_wxacode_unlimited.yaml")
 # 测颜值根据标签召回日记
-FACE_DIARY_CARDS_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "face_request.yaml")
-FACE_DIARY_CARDS_DATA = os.path.join(BASE_DIR, "backend_auto/test_backend_data/face_data", "diary_cards.yaml")
+FACE_DIARY_CARDS_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "face_request.yaml")
+FACE_DIARY_CARDS_DATA = os.path.join(BASE_DIR, "on_line_product/test_backend_data/face_data", "diary_cards.yaml")
 # 3D变脸下feed流
-FACE_PLASTIC_FEEDS_DATA = os.path.join(BASE_DIR, "backend_auto/test_backend_data/face_data", "plastic_feeds.yaml")
+FACE_PLASTIC_FEEDS_DATA = os.path.join(BASE_DIR, "on_line_product/test_backend_data/face_data", "plastic_feeds.yaml")
 
 # 测颜值底部feed流
-SCAN_DIARY_CARDS_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "scan_request.yaml")
-SCAN_DIARY_CARDS_DATA = os.path.join(BASE_DIR, "backend_auto/test_backend_data/scan_data", "diary_cards.yaml")
+SCAN_DIARY_CARDS_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "scan_request.yaml")
+SCAN_DIARY_CARDS_DATA = os.path.join(BASE_DIR, "on_line_product/test_backend_data/scan_data", "diary_cards.yaml")
 
 # 测肤质feed流
-SKIN_RECOMMEND_SERVICE_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "skin_request.yaml")
-SKIN_RECOMMEND_SERVICE_DATA = os.path.join(BASE_DIR, "backend_auto/test_backend_data/skin_data", "recommend_service.yaml")
+SKIN_RECOMMEND_SERVICE_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "skin_request.yaml")
+SKIN_RECOMMEND_SERVICE_DATA = os.path.join(BASE_DIR, "on_line_product/test_backend_data/skin_data", "recommend_service.yaml")
 
 # 测肤结果页 / AI变脸结果页
-GMAI_SKIN_NEWREPORT_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "gmai_request.yaml")
-GMAI_SKIN_NEWREPORT_DATA = os.path.join(BASE_DIR, "backend_auto/test_backend_data/gmai_data", "skin_newReport.yaml")
+GMAI_SKIN_NEWREPORT_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "gmai_request.yaml")
+GMAI_SKIN_NEWREPORT_DATA = os.path.join(BASE_DIR, "on_line_product/test_backend_data/gmai_data", "skin_newReport.yaml")
 # 用户之前是否使用过测肤功能
-GMAI_SKIN_USER_HAD_TEST_DATA = os.path.join(BASE_DIR, "backend_auto/test_backend_data/gmai_data", "skin_user_had_test.yaml")
+GMAI_SKIN_USER_HAD_TEST_DATA = os.path.join(BASE_DIR, "on_line_product/test_backend_data/gmai_data", "skin_user_had_test.yaml")
 
 # 模拟双眼皮
-GMAI_EYELIDS_PLASTIC_DATA = os.path.join(BASE_DIR, "backend_auto/test_backend_data/gmai_data", "eyelids_plastic.yaml")
+GMAI_EYELIDS_PLASTIC_DATA = os.path.join(BASE_DIR, "on_line_product/test_backend_data/gmai_data", "eyelids_plastic.yaml")
 # 模拟发型
-GMAI_SIMULATE_ANALYZE_DATA = os.path.join(BASE_DIR, "backend_auto/test_backend_data/gmai_data", "simulate_analyze.yaml")
+GMAI_SIMULATE_ANALYZE_DATA = os.path.join(BASE_DIR, "on_line_product/test_backend_data/gmai_data", "simulate_analyze.yaml")
 # 获取模拟整形相关配置文件
-GMAI_SIMULATE_CONF_DATA = os.path.join(BASE_DIR, "backend_auto/test_backend_data/gmai_data", "simulate_conf.yaml")
+GMAI_SIMULATE_CONF_DATA = os.path.join(BASE_DIR, "on_line_product/test_backend_data/gmai_data", "simulate_conf.yaml")
 # 模拟双眼皮，发型，美瞳，眉毛下日记推荐（根据标签）
-EYELIDS_DIARY_CARDS_CONFIG = os.path.join(BASE_DIR,"backend_auto/all_backend_api", "eyelids_request.yaml")
-EYELIDS_DIARY_CARDS_DATA = os.path.join(BASE_DIR, "backend_auto/test_backend_data/eyelids_data", "diary_cards.yaml")
+EYELIDS_DIARY_CARDS_CONFIG = os.path.join(BASE_DIR,"on_line_product/all_backend_api", "eyelids_request.yaml")
+EYELIDS_DIARY_CARDS_DATA = os.path.join(BASE_DIR, "on_line_product/test_backend_data/eyelids_data", "diary_cards.yaml")
 
 # AI变脸结果
-GMAI_PLASTIC_ANALYSIS_V3_DATA = os.path.join(BASE_DIR, "backend_auto/test_backend_data/gmai_data", "plastic_analysis_v3.yaml")
+GMAI_PLASTIC_ANALYSIS_V3_DATA = os.path.join(BASE_DIR, "on_line_product/test_backend_data/gmai_data", "plastic_analysis_v3.yaml")
 # 3D变脸获取参数
-GMAI_PLASTIC_CHECCK_STYLE_CLASSTIFY_DATA = os.path.join(BASE_DIR, "backend_auto/test_backend_data/gmai_data", "plastic_cheek_style_classify.yaml")
+GMAI_PLASTIC_CHECCK_STYLE_CLASSTIFY_DATA = os.path.join(BASE_DIR, "on_line_product/test_backend_data/gmai_data", "plastic_cheek_style_classify.yaml")
 # 3D变脸
-GMAI_PLASTIC_ANALYSIS_V2_DATA = os.path.join(BASE_DIR, "backend_auto/test_backend_data/gmai_data", "plastic_analysis_v2.yaml")
+GMAI_PLASTIC_ANALYSIS_V2_DATA = os.path.join(BASE_DIR, "on_line_product/test_backend_data/gmai_data", "plastic_analysis_v2.yaml")
 
 # 新版本我的美券列表
-JANUS_PRODUCT_MY_LIST_DATA = os.path.join(BASE_DIR, "backend_auto/test_backend_data/janus_data", "product_my_list.yaml")
+JANUS_PRODUCT_MY_LIST_DATA = os.path.join(BASE_DIR, "on_line_product/test_backend_data/janus_data", "product_my_list.yaml")
 # 我的订单列表
-ORDERS_MY_V2_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "orders_request.yaml")
+ORDERS_MY_V2_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "orders_request.yaml")
 # 订单列表
-ORDERS_MY_V2_DATA = os.path.join(BASE_DIR, "backend_auto/test_backend_data/orders_data", "my_v2.yaml")
+ORDERS_MY_V2_DATA = os.path.join(BASE_DIR, "on_line_product/test_backend_data/orders_data", "my_v2.yaml")
 #我的订单-各状态订单数量
-ORDER_MY_STATUS = os.path.join(BASE_DIR, "backend_auto/test_backend_data/orders_data", "my_status.yaml")
+ORDER_MY_STATUS = os.path.join(BASE_DIR, "on_line_product/test_backend_data/orders_data", "my_status.yaml")
 
-LOGIN_PASSWD = os.path.join(BASE_DIR, "backend_auto/test_backend_data/accounts_data", "login_passwd.yaml")
-LOGIN_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "accounts_request.yaml")
+LOGIN_PASSWD = os.path.join(BASE_DIR, "on_line_product/test_backend_data/accounts_data", "login_passwd.yaml")
+LOGIN_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "accounts_request.yaml")
 
 #医院主页详情
-HDYAML_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "hospitals_request.yaml")
-HOSPITAL_DETAIL = os.path.join(BASE_DIR, "backend_auto/test_backend_data/hospitals_data", "detail.yaml")
+HDYAML_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "hospitals_request.yaml")
+HOSPITAL_DETAIL = os.path.join(BASE_DIR, "on_line_product/test_backend_data/hospitals_data", "detail.yaml")
 #医院主页医生列表
-HOSPITAL_DOCTOR = os.path.join(BASE_DIR, "backend_auto/test_backend_data/hospitals_data", "doctor.yaml")
+HOSPITAL_DOCTOR = os.path.join(BASE_DIR, "on_line_product/test_backend_data/hospitals_data", "doctor.yaml")
 #医院主页商品列表
-HOSPITAL_SERVICE_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "hospitals_v2_request.yaml")
-HOSPITAL_SERVICE = os.path.join(BASE_DIR, "backend_auto/test_backend_data/hospitals_v2_data", "services.yaml")
+HOSPITAL_SERVICE_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "hospitals_v2_request.yaml")
+HOSPITAL_SERVICE = os.path.join(BASE_DIR, "on_line_product/test_backend_data/hospitals_v2_data", "services.yaml")
 #医院主页日记列表
-HOSPITAL_DIARY_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "hospital_request.yaml")
-HOSPITAL_DIARY = os.path.join(BASE_DIR, "backend_auto/test_backend_data/hospital_data", "diary.yaml")
+HOSPITAL_DIARY_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "hospital_request.yaml")
+HOSPITAL_DIARY = os.path.join(BASE_DIR, "on_line_product/test_backend_data/hospital_data", "diary.yaml")
 #医生/医院主页-医生/医院说列表
-DOCTOR_ARTICLE_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "doctor_request.yaml")
-DOCTOR_ARTICLE = os.path.join(BASE_DIR, "backend_auto/test_backend_data/doctor_data", "article.yaml")
+DOCTOR_ARTICLE_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "doctor_request.yaml")
+DOCTOR_ARTICLE = os.path.join(BASE_DIR, "on_line_product/test_backend_data/doctor_data", "article.yaml")
 #医生主页详情
-DOCTOR_DETAIL = os.path.join(BASE_DIR, "backend_auto/test_backend_data/doctor_data", "detail.yaml")
+DOCTOR_DETAIL = os.path.join(BASE_DIR, "on_line_product/test_backend_data/doctor_data", "detail.yaml")
 #医生主页案例列表
-DOCTOR_DIARY = os.path.join(BASE_DIR, "backend_auto/test_backend_data/doctor_data", "diary.yaml")
+DOCTOR_DIARY = os.path.join(BASE_DIR, "on_line_product/test_backend_data/doctor_data", "diary.yaml")
 #医生主页商品列表
-DOCTOR_V2_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "doctor_v2_request.yaml")
-DOCTOR_V2_SERVICE = os.path.join(BASE_DIR, "backend_auto/test_backend_data/doctor_v2_data", "services.yaml")
+DOCTOR_V2_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "doctor_v2_request.yaml")
+DOCTOR_V2_SERVICE = os.path.join(BASE_DIR, "on_line_product/test_backend_data/doctor_v2_data", "services.yaml")
 #医生/医院主页-问答列表
-USER_ANSWER_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "user_request.yaml")
-USER_ANSWER = os.path.join(BASE_DIR, "backend_auto/test_backend_data/user_data", "answer.yaml")
+USER_ANSWER_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "user_request.yaml")
+USER_ANSWER = os.path.join(BASE_DIR, "on_line_product/test_backend_data/user_data", "answer.yaml")
 
 #购物车列表
-SHOPCART_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "shopcart_request.yaml")
-SHOPCART_LIST = os.path.join(BASE_DIR, "backend_auto/test_backend_data/shopcart_data", "list.yaml")
+SHOPCART_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "shopcart_request.yaml")
+SHOPCART_LIST = os.path.join(BASE_DIR, "on_line_product/test_backend_data/shopcart_data", "list.yaml")
 #购物车-猜你喜欢列表
-JANUS_MINE_GUESS_YOU_LIKE = os.path.join(BASE_DIR, "backend_auto/test_backend_data/janus_data", "mine_guess_you_like.yaml")
+JANUS_MINE_GUESS_YOU_LIKE = os.path.join(BASE_DIR, "on_line_product/test_backend_data/janus_data", "mine_guess_you_like.yaml")
 
 #消息列表
-MY_CONVERSATION_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "my_conversation_request.yaml")
-MY_CONVERSATION = os.path.join(BASE_DIR, "backend_auto/test_backend_data/my_conversation_data", "my_conversation.yaml")
-DETAIL_MESSAGEID = os.path.join(BASE_DIR, "backend_auto/test_backend_data/conversation_data", "detail_messageid.yaml")
+MY_CONVERSATION_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "my_conversation_request.yaml")
+MY_CONVERSATION = os.path.join(BASE_DIR, "on_line_product/test_backend_data/my_conversation_data", "my_conversation.yaml")
+DETAIL_MESSAGEID = os.path.join(BASE_DIR, "on_line_product/test_backend_data/conversation_data", "detail_messageid.yaml")
 
 #消息
-MESSAGE_READ_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "conversation_request.yaml")
-MESSAGE_READ = os.path.join(BASE_DIR, "backend_auto/test_backend_data/conversation_data", "message_read.yaml")
+MESSAGE_READ_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "conversation_request.yaml")
+MESSAGE_READ = os.path.join(BASE_DIR, "on_line_product/test_backend_data/conversation_data", "message_read.yaml")
 
 #消息页未读数
-UNREAD_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "notification_request.yaml")
-UNREAD = os.path.join(BASE_DIR, "backend_auto/test_backend_data/notification_data", "unread.yaml")
+UNREAD_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "notification_request.yaml")
+UNREAD = os.path.join(BASE_DIR, "on_line_product/test_backend_data/notification_data", "unread.yaml")
 #标记为已读
-READALL = os.path.join(BASE_DIR, "backend_auto/test_backend_data/notification_data", "readall.yaml")
+READALL = os.path.join(BASE_DIR, "on_line_product/test_backend_data/notification_data", "readall.yaml")
 #咨询顾问相关
-CONVERSATION_DETAIL_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "im_request.yaml")
-CONVERSATION_DETAIL = os.path.join(BASE_DIR, "backend_auto/test_backend_data/im_data", "conversation_detail.yaml")
-AUTO_MSG = os.path.join(BASE_DIR, "backend_auto/test_backend_data/im_data", "auto_msg.yaml")
-SEND_MSG = os.path.join(BASE_DIR, "backend_auto/test_backend_data/im_data", "send_msg.yaml")
+CONVERSATION_DETAIL_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "im_request.yaml")
+CONVERSATION_DETAIL = os.path.join(BASE_DIR, "on_line_product/test_backend_data/im_data", "conversation_detail.yaml")
+AUTO_MSG = os.path.join(BASE_DIR, "on_line_product/test_backend_data/im_data", "auto_msg.yaml")
+SEND_MSG = os.path.join(BASE_DIR, "on_line_product/test_backend_data/im_data", "send_msg.yaml")
 #发送消息
-PRIVATE_CONVERSATION_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "private_conversation_request.yaml")
-PRIVATE_CONVERSATION = os.path.join(BASE_DIR, "backend_auto/test_backend_data/private_conversation_data", "private_conversation.yaml")
+PRIVATE_CONVERSATION_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "private_conversation_request.yaml")
+PRIVATE_CONVERSATION = os.path.join(BASE_DIR, "on_line_product/test_backend_data/private_conversation_data", "private_conversation.yaml")
 
-HOME_V5_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "service_request.yaml")
-HOME_V5=os.path.join(BASE_DIR,"backend_auto/test_backend_data/service_data","home_v5.yaml")
+HOME_V5_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "service_request.yaml")
+HOME_V5=os.path.join(BASE_DIR,"on_line_product/test_backend_data/service_data","home_v5.yaml")
 
 
-PERSONAL_CENTER_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "user_request.yaml")
-PERSONAL_CENTER = os.path.join(BASE_DIR, "backend_auto/test_backend_data/user_data", "personal_center.yaml")
+PERSONAL_CENTER_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "user_request.yaml")
+PERSONAL_CENTER = os.path.join(BASE_DIR, "on_line_product/test_backend_data/user_data", "personal_center.yaml")
 
 #搜索结果页-综合/百科
-CONTENTV7_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "janus_request.yaml")
-CONTENTV7 = os.path.join(BASE_DIR, "backend_auto/test_backend_data/janus_data", "content_v7.yaml")
+CONTENTV7_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "janus_request.yaml")
+CONTENTV7 = os.path.join(BASE_DIR, "on_line_product/test_backend_data/janus_data", "content_v7.yaml")
 
 #医院主页搜索
-HOSPITALSEARCH_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "janus_request.yaml")
-HOSPITALSEARCH = os.path.join(BASE_DIR, "backend_auto/test_backend_data/janus_data", "hospital_search.yaml")
+HOSPITALSEARCH_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "janus_request.yaml")
+HOSPITALSEARCH = os.path.join(BASE_DIR, "on_line_product/test_backend_data/janus_data", "hospital_search.yaml")
 
 #直播
-LIVEYAML_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "live_request.yaml")
+LIVEYAML_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "live_request.yaml")
 #直播-获取弹幕
-DANMU_V2 = os.path.join(BASE_DIR, "backend_auto/test_backend_data/live_data", "danmu_v2.yaml")
+DANMU_V2 = os.path.join(BASE_DIR, "on_line_product/test_backend_data/live_data", "danmu_v2.yaml")
 #直播-主播开播
-PUSH_LIVE_INFO = os.path.join(BASE_DIR, "backend_auto/test_backend_data/live_data", "pushlive_info.yaml")
+PUSH_LIVE_INFO = os.path.join(BASE_DIR, "on_line_product/test_backend_data/live_data", "pushlive_info.yaml")
 
 
 
 #商祥页-详情
-JANUS_PRODUCT_DETAIL = os.path.join(BASE_DIR, "backend_auto/test_backend_data/janus_data", "product_detail.yaml")
+JANUS_PRODUCT_DETAIL = os.path.join(BASE_DIR, "on_line_product/test_backend_data/janus_data", "product_detail.yaml")
 #商祥页-sku信息
-JANUS_SKU_INFO = os.path.join(BASE_DIR, "backend_auto/test_backend_data/janus_data", "sku_info.yaml")
+JANUS_SKU_INFO = os.path.join(BASE_DIR, "on_line_product/test_backend_data/janus_data", "sku_info.yaml")
 #商祥页-收藏
-SERVICE_FAVOR = os.path.join(BASE_DIR, "backend_auto/test_backend_data/service_data", "service_favor.yaml")
+SERVICE_FAVOR = os.path.join(BASE_DIR, "on_line_product/test_backend_data/service_data", "service_favor.yaml")
 #商祥页-分享
-SERVICES_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "services_request.yaml")
-SERVICES_SHARE_DATA = os.path.join(BASE_DIR, "backend_auto/test_backend_data/services_data", "share_data.yaml")
+SERVICES_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "services_request.yaml")
+SERVICES_SHARE_DATA = os.path.join(BASE_DIR, "on_line_product/test_backend_data/services_data", "share_data.yaml")
 #商祥页-加入购物车
-SHOPCART_ADD = os.path.join(BASE_DIR, "backend_auto/test_backend_data/shopcart_data", "add.yaml")
+SHOPCART_ADD = os.path.join(BASE_DIR, "on_line_product/test_backend_data/shopcart_data", "add.yaml")
 #商祥页-美券列表
-HYBRID_GIFT_LIST_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "hybrid_gift_list_request.yaml")
-GIFT_LIST_DATA = os.path.join(BASE_DIR, "backend_auto/test_backend_data/hybrid_gift_list_data", "gift_list_data.yaml")
+HYBRID_GIFT_LIST_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "hybrid_gift_list_request.yaml")
+GIFT_LIST_DATA = os.path.join(BASE_DIR, "on_line_product/test_backend_data/hybrid_gift_list_data", "gift_list_data.yaml")
 #商祥页-优惠券列表-领取
-HYBRID_GET_GIFT_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "hybrid_get_gift_request.yaml")
-GET_GIFT_DATA = os.path.join(BASE_DIR, "backend_auto/test_backend_data/hybrid_get_gift_data", "get_gift_data.yaml")
+HYBRID_GET_GIFT_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "hybrid_get_gift_request.yaml")
+GET_GIFT_DATA = os.path.join(BASE_DIR, "on_line_product/test_backend_data/hybrid_get_gift_data", "get_gift_data.yaml")
 #商祥页-美券列表-我的美券点击-744版本及以后-新接口
-PRODUCT_COUPON_MY_LIST = os.path.join(BASE_DIR, "backend_auto/test_backend_data/janus_data", "product_coupon_my_list.yaml")
+PRODUCT_COUPON_MY_LIST = os.path.join(BASE_DIR, "on_line_product/test_backend_data/janus_data", "product_coupon_my_list.yaml")
 #商祥页-推荐商品列表
-HYBRID_PROMOTION_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "hybrid_promotion_request.yaml")
-RELATED_SERVICE_DATA = os.path.join(BASE_DIR, "backend_auto/test_backend_data/hybrid_promotion_data", "related_service_data.yaml")
+HYBRID_PROMOTION_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "hybrid_promotion_request.yaml")
+RELATED_SERVICE_DATA = os.path.join(BASE_DIR, "on_line_product/test_backend_data/hybrid_promotion_data", "related_service_data.yaml")
 
 #次卡-确认订单
-BEAUTY_CARD_ORDER_CONFIRM = os.path.join(BASE_DIR, "backend_auto/test_backend_data/janus_data", "beauty_card_order_confirm.yaml")
+BEAUTY_CARD_ORDER_CONFIRM = os.path.join(BASE_DIR, "on_line_product/test_backend_data/janus_data", "beauty_card_order_confirm.yaml")
 #次卡-确认订单页面-修改手机号接口
-BEAUTY_CARD_UPDATE_PHONE = os.path.join(BASE_DIR, "backend_auto/test_backend_data/janus_data", "beauty_card_update_phone.yaml")
+BEAUTY_CARD_UPDATE_PHONE = os.path.join(BASE_DIR, "on_line_product/test_backend_data/janus_data", "beauty_card_update_phone.yaml")
 #次卡-提交订单
-BEAUTY_CARD_ORDER_SUBMIT = os.path.join(BASE_DIR, "backend_auto/test_backend_data/janus_data", "beauty_card_order_submit.yaml")
+BEAUTY_CARD_ORDER_SUBMIT = os.path.join(BASE_DIR, "on_line_product/test_backend_data/janus_data", "beauty_card_order_submit.yaml")
 #次卡-支付平台
-BEAUTY_CARD_PAYMENT_METHOD = os.path.join(BASE_DIR, "backend_auto/test_backend_data/janus_data", "beauty_card_payment_method.yaml")
+BEAUTY_CARD_PAYMENT_METHOD = os.path.join(BASE_DIR, "on_line_product/test_backend_data/janus_data", "beauty_card_payment_method.yaml")
 #次卡-微信支付
-BEAUTY_CARD_PREPAY_WECHAT = os.path.join(BASE_DIR, "backend_auto/test_backend_data/janus_data", "beauty_card_prepay_wechat.yaml")
+BEAUTY_CARD_PREPAY_WECHAT = os.path.join(BASE_DIR, "on_line_product/test_backend_data/janus_data", "beauty_card_prepay_wechat.yaml")
 #次卡-支付宝支付
-BEAUTY_CARD_PREPAY_ALIPAY = os.path.join(BASE_DIR, "backend_auto/test_backend_data/janus_data", "beauty_card_prepay_alipay.yaml")
+BEAUTY_CARD_PREPAY_ALIPAY = os.path.join(BASE_DIR, "on_line_product/test_backend_data/janus_data", "beauty_card_prepay_alipay.yaml")
 #次卡-订单详情
-BEAUTY_CARD_PAYMENT_DETAIL = os.path.join(BASE_DIR, "backend_auto/test_backend_data/janus_data", "beauty_card_payment_detail.yaml")
+BEAUTY_CARD_PAYMENT_DETAIL = os.path.join(BASE_DIR, "on_line_product/test_backend_data/janus_data", "beauty_card_payment_detail.yaml")
 #次卡-取消订单
-BEAUTY_CARD_PAYMENT_DELETE = os.path.join(BASE_DIR, "backend_auto/test_backend_data/janus_data", "beauty_card_payment_delete.yaml")
+BEAUTY_CARD_PAYMENT_DELETE = os.path.join(BASE_DIR, "on_line_product/test_backend_data/janus_data", "beauty_card_payment_delete.yaml")
 #次卡-申请退款
-BEAUTY_CARD_REFUND_INFO = os.path.join(BASE_DIR, "backend_auto/test_backend_data/janus_data", "beauty_card_refund_info.yaml")
+BEAUTY_CARD_REFUND_INFO = os.path.join(BASE_DIR, "on_line_product/test_backend_data/janus_data", "beauty_card_refund_info.yaml")
 #次卡-提交退款申请
-BEAUTY_CARD_REFUND_SUBMIT = os.path.join(BASE_DIR, "backend_auto/test_backend_data/janus_data", "beauty_card_refund_submit.yaml")
+BEAUTY_CARD_REFUND_SUBMIT = os.path.join(BASE_DIR, "on_line_product/test_backend_data/janus_data", "beauty_card_refund_submit.yaml")
 
 # 次卡订单详情页（未使用 部分使用 和 已使用）
-BEAUTY_CARD_ORDER_DETAIL_DATA = os.path.join(BASE_DIR, "backend_auto/test_backend_data/janus_data", "beauty_card_order_detail.yaml")
+BEAUTY_CARD_ORDER_DETAIL_DATA = os.path.join(BASE_DIR, "on_line_product/test_backend_data/janus_data", "beauty_card_order_detail.yaml")
 
 #捜索结果页-医生/医院tab
-CONTENTV6_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "search_request.yaml")
-CONTENTV6 = os.path.join(BASE_DIR, "backend_auto/test_backend_data/search_data", "content_v6.yaml")
+CONTENTV6_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "search_request.yaml")
+CONTENTV6 = os.path.join(BASE_DIR, "on_line_product/test_backend_data/search_data", "content_v6.yaml")
 
 
 #品类聚合页面商品列表
-TAG_SERVICE_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "janus_request.yaml")
-TAG_SERVICE = os.path.join(BASE_DIR, "backend_auto/test_backend_data/janus_data", "tag_service.yaml")
+TAG_SERVICE_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "janus_request.yaml")
+TAG_SERVICE = os.path.join(BASE_DIR, "on_line_product/test_backend_data/janus_data", "tag_service.yaml")
 
 #社区tab签到和招募活动
-CONFIG_LIST_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "feed_request.yaml")
-CONFIG_LIST = os.path.join(BASE_DIR, "backend_auto/test_backend_data/feed_data", "config_list.yaml")
+CONFIG_LIST_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "feed_request.yaml")
+CONFIG_LIST = os.path.join(BASE_DIR, "on_line_product/test_backend_data/feed_data", "config_list.yaml")
 
 #社区tabfeed流
-COMMUNITY_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "feed_request.yaml")
-COMMUNITY = os.path.join(BASE_DIR, "backend_auto/test_backend_data/feed_data", "community.yaml")
+COMMUNITY_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "feed_request.yaml")
+COMMUNITY = os.path.join(BASE_DIR, "on_line_product/test_backend_data/feed_data", "community.yaml")
 
 #品类聚合页面标签和专场
-POLYMER_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "janus_request.yaml")
-POLYMER = os.path.join(BASE_DIR, "backend_auto/test_backend_data/janus_data", "polymer.yaml")
+POLYMER_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "janus_request.yaml")
+POLYMER = os.path.join(BASE_DIR, "on_line_product/test_backend_data/janus_data", "polymer.yaml")
 
-THIRD_PHONE_LOGIN_CONFIG = os.path.join(BASE_DIR,"backend_auto/all_backend_api", "thirdphonelogin_request")
-THIRD_PHONE_LOGIN =os.path.join(BASE_DIR,"backend_auto/test_backend_data/account_data","login_thirdphone.yaml")
+THIRD_PHONE_LOGIN_CONFIG = os.path.join(BASE_DIR,"on_line_product/all_backend_api", "thirdphonelogin_request")
+THIRD_PHONE_LOGIN =os.path.join(BASE_DIR,"on_line_product/test_backend_data/account_data","login_thirdphone.yaml")
 
 #医生医院sug列表
-KEYWORDTIP_CONFIG = os.path.join(BASE_DIR,"backend_auto/all_backend_api", "janus_request.yaml")
-KEYWORDTIP = os.path.join(BASE_DIR, "backend_auto/test_backend_data/janus_data", "keyword_tip.yaml")
+KEYWORDTIP_CONFIG = os.path.join(BASE_DIR,"on_line_product/all_backend_api", "janus_request.yaml")
+KEYWORDTIP = os.path.join(BASE_DIR, "on_line_product/test_backend_data/janus_data", "keyword_tip.yaml")
 
 #搜索首页-更美热门榜
-HOT_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "search_request.yaml")
-HOT = os.path.join(BASE_DIR, "backend_auto/test_backend_data/search_data", "hot.yaml")
+HOT_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "search_request.yaml")
+HOT = os.path.join(BASE_DIR, "on_line_product/test_backend_data/search_data", "hot.yaml")
 
 #回答详情页点赞
-VOTE = os.path.join(BASE_DIR, "backend_auto/test_backend_data/answer_data", "vote.yaml")
+VOTE = os.path.join(BASE_DIR, "on_line_product/test_backend_data/answer_data", "vote.yaml")
 #回答详情页取消点赞
-CANCEL_VOTE = os.path.join(BASE_DIR, "backend_auto/test_backend_data/answer_data", "cancel_vote.yaml")
+CANCEL_VOTE = os.path.join(BASE_DIR, "on_line_product/test_backend_data/answer_data", "cancel_vote.yaml")
 #回答详情页-  一/二级评论
-QUESTION_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "question_request.yaml")
-REPLY_ANSWER = os.path.join(BASE_DIR, "backend_auto/test_backend_data/question_data", "reply_answer.yaml")
+QUESTION_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "question_request.yaml")
+REPLY_ANSWER = os.path.join(BASE_DIR, "on_line_product/test_backend_data/question_data", "reply_answer.yaml")
 
 #回答详情页
-DETAIL_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "answer_request.yaml")
-DETAIL = os.path.join(BASE_DIR, "backend_auto/test_backend_data/answer_data", "detail.yaml")
+DETAIL_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "answer_request.yaml")
+DETAIL = os.path.join(BASE_DIR, "on_line_product/test_backend_data/answer_data", "detail.yaml")
 #品类聚合页面医生tab列表
-HOSPITAL_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "search_request.yaml")
-HOSPITAL = os.path.join(BASE_DIR, "backend_auto/test_backend_data/search_data", "hospital.yaml")
+HOSPITAL_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "search_request.yaml")
+HOSPITAL = os.path.join(BASE_DIR, "on_line_product/test_backend_data/search_data", "hospital.yaml")
 
 
 #城市筛选器
-FILTER_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "filter_request.yaml")
-FILTER = os.path.join(BASE_DIR, "backend_auto/test_backend_data/filter_data", "service_home_city_v2.yaml")
+FILTER_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "filter_request.yaml")
+FILTER = os.path.join(BASE_DIR, "on_line_product/test_backend_data/filter_data", "service_home_city_v2.yaml")
 
 #医生后台-全部私信列表
-CONVERSATION=os.path.join(BASE_DIR, "backend_auto/test_doctor_data/web_data", "conversation.yaml")
+CONVERSATION=os.path.join(BASE_DIR, "on_line_product/test_doctor_data/web_data", "conversation.yaml")
 #医生后台-未读私信列表
-CONVERSATIONUNREADLIST=os.path.join(BASE_DIR, "backend_auto/test_doctor_data/web_data", "conversation_unread_list.yaml")
+CONVERSATIONUNREADLIST=os.path.join(BASE_DIR, "on_line_product/test_doctor_data/web_data", "conversation_unread_list.yaml")
 #医生后台-发送商品按钮
-SERVICE=os.path.join(BASE_DIR, "backend_auto/test_doctor_data/web_data", "service.yaml")
+SERVICE=os.path.join(BASE_DIR, "on_line_product/test_doctor_data/web_data", "service.yaml")
 #医生后台-发送案例
-CONVERSATIONDIARY=os.path.join(BASE_DIR, "backend_auto/test_doctor_data/web_data", "conversation_diary.yaml")
+CONVERSATIONDIARY=os.path.join(BASE_DIR, "on_line_product/test_doctor_data/web_data", "conversation_diary.yaml")
 #医生后台-发送优惠券
-CONVERSATIONCOUPON=os.path.join(BASE_DIR, "backend_auto/test_doctor_data/web_data", "conversation_coupon.yaml")
+CONVERSATIONCOUPON=os.path.join(BASE_DIR, "on_line_product/test_doctor_data/web_data", "conversation_coupon.yaml")
 #医生后台-发送私信
-CONVERSATIONUSERID=os.path.join(BASE_DIR, "backend_auto/test_doctor_data/web_data", "conversation_user_id.yaml")
+CONVERSATIONUSERID=os.path.join(BASE_DIR, "on_line_product/test_doctor_data/web_data", "conversation_user_id.yaml")
 
 #医生后台-服务资源
-ADTYPELIST=os.path.join(BASE_DIR, "backend_auto/test_doctor_data/web_data", "artemis_ad_type_list.yaml")
+ADTYPELIST=os.path.join(BASE_DIR, "on_line_product/test_doctor_data/web_data", "artemis_ad_type_list.yaml")
 #医生后台-我的购物车
-ADADDSHOPPINGCARTINFO=os.path.join(BASE_DIR, "backend_auto/test_doctor_data/web2_data", "artemis_ad_add_shopping_cart_info.yaml")
+ADADDSHOPPINGCARTINFO=os.path.join(BASE_DIR, "on_line_product/test_doctor_data/web2_data", "artemis_ad_add_shopping_cart_info.yaml")
 #医生后台-我的服务订单
-ORDERLIST=os.path.join(BASE_DIR, "backend_auto/test_doctor_data/web_data", "artemis_order_list.yaml")
+ORDERLIST=os.path.join(BASE_DIR, "on_line_product/test_doctor_data/web_data", "artemis_order_list.yaml")
 #医生后台-我的服务订单-已上线订单
-ORDERIDDETAIL=os.path.join(BASE_DIR, "backend_auto/test_doctor_data/web_data", "artemis_order_id_detail.yaml")
+ORDERIDDETAIL=os.path.join(BASE_DIR, "on_line_product/test_doctor_data/web_data", "artemis_order_id_detail.yaml")
 #医生后台-我的服务订单-已购买订单
-VALUEORDERIDDETAIL=os.path.join(BASE_DIR, "backend_auto/test_doctor_data/web2_data", "artemis_add_value_order_id_detail.yaml")
+VALUEORDERIDDETAIL=os.path.join(BASE_DIR, "on_line_product/test_doctor_data/web2_data", "artemis_add_value_order_id_detail.yaml")
 #医生后台-点点通商品-概览
-CPCHOMEPAGE=os.path.join(BASE_DIR, "backend_auto/test_doctor_data/web_data", "cpc_homepage.yaml")
+CPCHOMEPAGE=os.path.join(BASE_DIR, "on_line_product/test_doctor_data/web_data", "cpc_homepage.yaml")
 
 #更美次卡橱窗组件商品
-VISUAL_BEAUTY_CARD_SERVICES_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "visual_beauty_card.yaml")
-VISUAL_BEAUTY_CARD_SERVICES = os.path.join(BASE_DIR, "backend_auto/test_backend_data/visual_beauty_card_data", "visual_beauty_card_services.yaml")
+VISUAL_BEAUTY_CARD_SERVICES_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "visual_beauty_card.yaml")
+VISUAL_BEAUTY_CARD_SERVICES = os.path.join(BASE_DIR, "on_line_product/test_backend_data/visual_beauty_card_data", "visual_beauty_card_services.yaml")
 
 #次卡商品列表组件筛选器
-BEAUTYCARD_FILTERS_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "visual_beauty_card.yaml")
-BEAUTYCARD_FILTERS = os.path.join(BASE_DIR, "backend_auto/test_backend_data/visual_beauty_card_data", "beautycard_filters.yaml")
+BEAUTYCARD_FILTERS_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "visual_beauty_card.yaml")
+BEAUTYCARD_FILTERS = os.path.join(BASE_DIR, "on_line_product/test_backend_data/visual_beauty_card_data", "beautycard_filters.yaml")
 
 #次卡商品列表组件商品
-BEAUTYCARD_SKUS_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "visual_beauty_card.yaml")
-BEAUTYCARD_SKUS = os.path.join(BASE_DIR, "backend_auto/test_backend_data/visual_beauty_card_data", "beautycard_skus.yaml")
+BEAUTYCARD_SKUS_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "visual_beauty_card.yaml")
+BEAUTYCARD_SKUS = os.path.join(BASE_DIR, "on_line_product/test_backend_data/visual_beauty_card_data", "beautycard_skus.yaml")
 
 #百科详情页-项目聚合百科
-SUBWIKI_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "hybrid_request.yaml")
-SUBWIKI = os.path.join(BASE_DIR, "backend_auto/test_backend_data/hybrid_data", "sub_wiki.yaml")
+SUBWIKI_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "hybrid_request.yaml")
+SUBWIKI = os.path.join(BASE_DIR, "on_line_product/test_backend_data/hybrid_data", "sub_wiki.yaml")
 
 #百科详情页-项目百科
-BASEWIKI_ITEM_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "hybrid_request.yaml")
-BASEWIKI_ITEM = os.path.join(BASE_DIR, "backend_auto/test_backend_data/hybrid_data", "basewiki_item.yaml")
+BASEWIKI_ITEM_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "hybrid_request.yaml")
+BASEWIKI_ITEM = os.path.join(BASE_DIR, "on_line_product/test_backend_data/hybrid_data", "basewiki_item.yaml")
 
 #百科详情页-药品（仪器、材料）百科
-BASEWIKI_PRODUCT_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "hybrid_request.yaml")
-BASEWIKI_PRODUCT = os.path.join(BASE_DIR, "backend_auto/test_backend_data/hybrid_data", "basewiki_product.yaml")
+BASEWIKI_PRODUCT_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "hybrid_request.yaml")
+BASEWIKI_PRODUCT = os.path.join(BASE_DIR, "on_line_product/test_backend_data/hybrid_data", "basewiki_product.yaml")
 
 #百科详情页-品牌百科
-BRAND_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "hybrid_request.yaml")
-BRAND = os.path.join(BASE_DIR, "backend_auto/test_backend_data/hybrid_data", "brand.yaml")
+BRAND_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "hybrid_request.yaml")
+BRAND = os.path.join(BASE_DIR, "on_line_product/test_backend_data/hybrid_data", "brand.yaml")
 
 #普通美购提交订单页
-PREVIEW_V1 = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "settlement_request.yaml")
-WECHAT_PAY = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "pay_request.yaml")
-PREVIEW = os.path.join(BASE_DIR, "backend_auto/test_backend_data/settlement_data", "preview_v1.yaml")
-PAY_V1 = os.path.join(BASE_DIR, "backend_auto/test_backend_data/settlement_data", "pay_v1.yaml")
-CREATE = os.path.join(BASE_DIR, "backend_auto/test_backend_data/settlement_data", "create_v1.yaml")
-PAY = os.path.join(BASE_DIR, "backend_auto/test_backend_data/settlement_data", "pay.yaml")
-SETTLEMENTDETAIL = os.path.join(BASE_DIR, "backend_auto/test_backend_data/settlement_data", "settlement_detail.yaml")
-WECHARTPAYDATA = os.path.join(BASE_DIR, "backend_auto/test_backend_data/pay_data", "wechat_prepay.yaml")
-ALIPAYDATA = os.path.join(BASE_DIR, "backend_auto/test_backend_data/pay_data", "alipay_prepay.yaml")
-JUMPDATA = os.path.join(BASE_DIR, "backend_auto/test_backend_data/pay_data", "jump.yaml")
-SETTLEMENTDELETE = os.path.join(BASE_DIR, "backend_auto/test_backend_data/settlement_data", "settlement_delete.yaml")
+PREVIEW_V1 = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "settlement_request.yaml")
+WECHAT_PAY = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "pay_request.yaml")
+PREVIEW = os.path.join(BASE_DIR, "on_line_product/test_backend_data/settlement_data", "preview_v1.yaml")
+PAY_V1 = os.path.join(BASE_DIR, "on_line_product/test_backend_data/settlement_data", "pay_v1.yaml")
+CREATE = os.path.join(BASE_DIR, "on_line_product/test_backend_data/settlement_data", "create_v1.yaml")
+PAY = os.path.join(BASE_DIR, "on_line_product/test_backend_data/settlement_data", "pay.yaml")
+SETTLEMENTDETAIL = os.path.join(BASE_DIR, "on_line_product/test_backend_data/settlement_data", "settlement_detail.yaml")
+WECHARTPAYDATA = os.path.join(BASE_DIR, "on_line_product/test_backend_data/pay_data", "wechat_prepay.yaml")
+ALIPAYDATA = os.path.join(BASE_DIR, "on_line_product/test_backend_data/pay_data", "alipay_prepay.yaml")
+JUMPDATA = os.path.join(BASE_DIR, "on_line_product/test_backend_data/pay_data", "jump.yaml")
+SETTLEMENTDELETE = os.path.join(BASE_DIR, "on_line_product/test_backend_data/settlement_data", "settlement_delete.yaml")
 
 #OM后台-登录
-OMLOGIN_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_om_api", "login_request.yaml")
-OMLOGIN = os.path.join(BASE_DIR, "backend_auto/test_om_data/om_login_data", "om_login.yaml")
+OMLOGIN_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_om_api", "login_request.yaml")
+OMLOGIN = os.path.join(BASE_DIR, "on_line_product/test_om_data/om_login_data", "om_login.yaml")
 
 #更美次卡-获取已添加页面次卡spu/sku列表
-GET_RELATED_BC_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_om_api", "beautycard_request.yaml")
-GET_RELATED_BC = os.path.join(BASE_DIR, "backend_auto/test_om_data/beautycard_data", "get_related_bc.yaml")
+GET_RELATED_BC_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_om_api", "beautycard_request.yaml")
+GET_RELATED_BC = os.path.join(BASE_DIR, "on_line_product/test_om_data/beautycard_data", "get_related_bc.yaml")
 
 #更美次卡-删除/批量删除已添加页面次卡
-DELETE_RELATED_BC_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_om_api", "beautycard_request.yaml")
-DELETE_RELATED_BC = os.path.join(BASE_DIR, "backend_auto/test_om_data/beautycard_data", "delete_related_bc.yaml")
+DELETE_RELATED_BC_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_om_api", "beautycard_request.yaml")
+DELETE_RELATED_BC = os.path.join(BASE_DIR, "on_line_product/test_om_data/beautycard_data", "delete_related_bc.yaml")
 
 #更美次卡-已添加页面全部导出
-EXPORT_RELATED_BC_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_om_api", "beautycard_request.yaml")
-EXPORT_RELATED_BC = os.path.join(BASE_DIR, "backend_auto/test_om_data/beautycard_data", "export_related_bc.yaml")
+EXPORT_RELATED_BC_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_om_api", "beautycard_request.yaml")
+EXPORT_RELATED_BC = os.path.join(BASE_DIR, "on_line_product/test_om_data/beautycard_data", "export_related_bc.yaml")
 
 #更美次卡-已添加页面全部导出
-UPDATE_BC_RANK_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_om_api", "beautycard_request.yaml")
-UPDATE_BC_RANK = os.path.join(BASE_DIR, "backend_auto/test_om_data/beautycard_data", "update_bc_rank.yaml")
+UPDATE_BC_RANK_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_om_api", "beautycard_request.yaml")
+UPDATE_BC_RANK = os.path.join(BASE_DIR, "on_line_product/test_om_data/beautycard_data", "update_bc_rank.yaml")
 
 #更美次卡-按次卡sku_id导入，导入校验
-CHECK_SKU_IDS_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_om_api", "beautycard_request.yaml")
-CHECK_SKU_IDS = os.path.join(BASE_DIR, "backend_auto/test_om_data/beautycard_data", "check_sku_ids.yaml")
+CHECK_SKU_IDS_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_om_api", "beautycard_request.yaml")
+CHECK_SKU_IDS = os.path.join(BASE_DIR, "on_line_product/test_om_data/beautycard_data", "check_sku_ids.yaml")
 
 #更美次卡-按次卡spu_id导入，导入校验
-CHECK_SPU_IDS_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_om_api", "beautycard_request.yaml")
-CHECK_SPU_IDS = os.path.join(BASE_DIR, "backend_auto/test_om_data/beautycard_data", "check_spu_ids.yaml")
+CHECK_SPU_IDS_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_om_api", "beautycard_request.yaml")
+CHECK_SPU_IDS = os.path.join(BASE_DIR, "on_line_product/test_om_data/beautycard_data", "check_spu_ids.yaml")
 
 
 #次卡商详页
-BEAUTY_CARD_DETAIL_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "janus_request.yaml")
-BEAUTY_CARD_DETAIL = os.path.join(BASE_DIR, "backend_auto/test_backend_data/janus_data", "beauty_card_detail.yaml")
+BEAUTY_CARD_DETAIL_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "janus_request.yaml")
+BEAUTY_CARD_DETAIL = os.path.join(BASE_DIR, "on_line_product/test_backend_data/janus_data", "beauty_card_detail.yaml")
 
 #次卡商详页-适应机构列表
-SERVICE_HOSPITAL_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "janus_request.yaml")
-SERVICE_HOSPITAL = os.path.join(BASE_DIR, "backend_auto/test_backend_data/janus_data", "service_hospital.yaml")
+SERVICE_HOSPITAL_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "janus_request.yaml")
+SERVICE_HOSPITAL = os.path.join(BASE_DIR, "on_line_product/test_backend_data/janus_data", "service_hospital.yaml")
 
 #免费招募背景图片
-FREE_RECRUIT_BANNER_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "feed_request.yaml")
-FREE_RECRUIT_BANNER = os.path.join(BASE_DIR, "backend_auto/test_backend_data/feed_data", "free_recruit_banner.yaml")
+FREE_RECRUIT_BANNER_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "feed_request.yaml")
+FREE_RECRUIT_BANNER = os.path.join(BASE_DIR, "on_line_product/test_backend_data/feed_data", "free_recruit_banner.yaml")
 
 #免费招募活动列表
-FREE_RECRUIT_LIST_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "feed_request.yaml")
-FREE_RECRUIT_LIST = os.path.join(BASE_DIR, "backend_auto/test_backend_data/feed_data", "free_recruit_list.yaml")
+FREE_RECRUIT_LIST_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "feed_request.yaml")
+FREE_RECRUIT_LIST = os.path.join(BASE_DIR, "on_line_product/test_backend_data/feed_data", "free_recruit_list.yaml")
 
 #直播-点击【设置封面】
-PAGE_RULES_CONFIG = os.path.join(BASE_DIR, "backend_auto/all_backend_api", "janus_request.yaml")
-PAGE_RULES = os.path.join(BASE_DIR, "backend_auto/test_backend_data/janus_data", "page_rules.yaml")
+PAGE_RULES_CONFIG = os.path.join(BASE_DIR, "on_line_product/all_backend_api", "janus_request.yaml")
+PAGE_RULES = os.path.join(BASE_DIR, "on_line_product/test_backend_data/janus_data", "page_rules.yaml")
 
 if __name__ == '__main__':
     print("==========",LIVEYAML_CONFIG)

test_backend_case/answer_case/test_cancel_vote.py

-import pytest
-
-from ids_list import get_ids
-import path_setting
-from in_common.base_request import BaseRequest
-from all_backend_api.answer_request import answer_request
-
-class TestCancelVote:
-    data = BaseRequest().api_load(path_setting.CANCEL_VOTE)
-    cancelvote_case, cancelvote_data = get_ids(data, "cancel_vote")
-
-    @pytest.mark.parametrize("param", cancelvote_data, ids=cancelvote_case)
-    def test_cancel_vote(self, param):
-        r = answer_request().cancel_vote(param["answer_id"])
-        if r["error"] == 1:
-            assert r["message"] == param["assert"]

test_backend_case/answer_case/test_vote.py

@@ -9,6 +9,7 @@ class TestVote:
     data = BaseRequest().api_load(path_setting.VOTE)
     vote_case, vote_data = get_ids(data, "vote")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", vote_data, ids=vote_case)
     def test_vote(self, param):
         r = answer_request().vote(param["answer_id"])

test_backend_case/common_case/test_reply.py

@@ -13,22 +13,13 @@ class TestReply:
     @pytest.mark.parametrize("param", diary_common_reply_data, ids=diary_common_reply_case)
     def test_reply(self, param):
         # 日记贴的评论列表
-        r = common_request().diary_common_reply(param["id"], param["type"])
+        r = common_request().diary_common_reply(param["id"], param["type"],param["data_type"],param["offset"],param["start_num"])
         # print(r)
         if r["error"] == 0:
             assert r["error"] == param["assert1"]
             # 先判断有没有评论，然后判断里面需要的那些字段，如点赞字段，评论总数等，不传值，传空值
             if r["data"]["reply_data"]:
-                assert r["data"]["reply_data"][0]["user_id"] is not None and r["data"]["reply_data"][0]["user_id"] is not ""  # 用户id
-                assert r["data"]["reply_data"][0]["user_portrait"] is not None and r["data"]["reply_data"][0]["user_portrait"] is not ""  # 用户头像
-                assert r["data"]["reply_data"][0]["gm_url"] is not None and r["data"]["reply_data"][0]["gm_url"] is not ""  # 头像跳转链接
-                assert r["data"]["reply_data"][0]["user_nickname"] is not None and r["data"]["reply_data"][0]["user_nickname"] is not ""  # 用户名
-                assert r["data"]["reply_data"][0]["content"] is not None and r["data"]["reply_data"][0]["content"] is not ""  # 评论内容
-                assert r["data"]["reply_data"][0]["reply_count"] is not None and r["data"]["reply_data"][0]["reply_count"] is not ""  # 评论总数
-                assert r["data"]["reply_data"][0]["reply_id"] is not None and r["data"]["reply_data"][0]["reply_id"] is not ""  # 评论id
-                assert r["data"]["reply_data"][0]["is_voted"] is not None and r["data"]["reply_data"][0]["is_voted"] is not ""  # 是否点赞
-                assert r["data"]["reply_data"][0]["_type"] == param["type"]  # 校验评论列表返回类型
-
+                assert r["data"]["reply_data"][0]["user"]["user_portrait"] is not None and r["data"]["reply_data"][0]["user"]["user_portrait"] is not ""  # 用户头像
 
 
 

test_backend_case/common_case/test_reply_sub_reply.py

@@ -12,21 +12,10 @@ class TestRrplySubReply:
 
     @pytest.mark.parametrize("param", topic_sub_common_data, ids=topic_sub_common_case)
     def test_reply_sub_reply(self, param):
-        # print(2)
-        r = common_request().topic_sub_common(param["id"], param["type"], param["reply_id"])
-        # print(r)
+        r = common_request().topic_sub_common(param["id"], param["type"], param["reply_id"],param["start_num"],param["offset"])
         if r["error"] == 0:
             assert r["error"] == param["assert1"]
-            # 先判断有没有评论，然后判断里面需要的那些字段，如点赞字段，评论总数等，不传值，传空值
-            if r["data"]:
-                assert r["data"][0]["at_user_id"] is not None and r["data"][0]["at_user_id"] is not ""  # 用户id
-                assert r["data"][0]["comment_user_gm_url"] is not None and r["data"][0]["comment_user_gm_url"] is not ""  # 点击评论跳转链接
-                assert r["data"][0]["at_user_gm_url"] is not None and r["data"][0]["at_user_gm_url"] is not ""  # 用户名跳转链接
-                assert r["data"][0]["nickname"] is not None and r["data"][0]["nickname"] is not ""  # 用户名
-                assert r["data"][0]["content"] is not None and r["data"][0]["content"] is not ""  # 评论内容
-                assert r["data"][0]["comment_user_id"] is not None and r["data"][0]["comment_user_id"] is not ""  # 评论人
-                assert r["data"][0]["comment_id"] is not None and r["data"][0]["comment_id"] is not ""  # 评论id
-                assert r["data"]["reply_data"][0]["_type"] == param["type"]  # 校验评论列表返回类型
+
 
 
 

test_backend_case/diary_case/test_favor.py

-import pytest
-
-from ids_list import get_ids
-import path_setting
-from in_common.base_request import BaseRequest
-from all_backend_api.diary_request import diary_request
-
-
-class TestFavor:
-    data = BaseRequest().api_load(path_setting.DIARY_FAVOR)
-    diary_favor_case, diary_favor_data = get_ids(data, "diary_favor")
-
-    @pytest.mark.parametrize("param", diary_favor_data, ids=diary_favor_case)
-    def test_favor(self, param):
-        r = diary_request().diary_isfavor()
-        # print(r)
-        if r["error"] == 0:
-            assert r["message"] == param["assert"]
-        if r["error"] == 1:
-            assert r["message"] ==param["assert2"]
-
-        r = diary_request().diary_cancelfavor()
-        # print(r)
-        if r["error"] == 0:
-            assert r["message"] == param["assert3"]
-        if r["error"] == 1:
-            assert r["message"] == param["assert2"]
-
-
-
-
-
-
-
-
-
-

test_backend_case/diary_case/test_operation.py

@@ -11,9 +11,9 @@ class TestDiaryOperation:
     diary_operation_case, diary_operation_data = get_ids(data, "diary_operation")
     @pytest.mark.parametrize("param", diary_operation_data, ids=diary_operation_case)
     def test_diary_operation(self, param):
-        r = diary_request().diary_operation(param["diary_id"], param["title"], param["operation_timestamp"], param["doctor_name"], param["hospital_name"])
-        result = diary_request().diary_additional_info()
-        if result["error"] == 1:
+        r = diary_request().diary_operation(param["start_num"], param["count"])
+        # result = diary_request().diary_operation()
+        if r["error"] == 1:
             assert r["message"] == param["assert"]
         # if r["error"] == 1:
         #     assert r["message"] ==param["assert2"]

test_backend_case/diary_case/test_pre_create_topic.py

+import pytest
+
+from ids_list import get_ids
+import path_setting
+from in_common.base_request import BaseRequest
+from all_backend_api.diary_request import diary_request
+
+
+class TestDiaryPreCreateTop:
+    data = BaseRequest().api_load(path_setting.DIARY_PRE_CREATE_TOPIC_DATE)
+    diary_pre_create_topic_case, diary_pre_create_topic_data = get_ids(data, "pre_create_topic")
+    @pytest.mark.parametrize("param", diary_pre_create_topic_data, ids=diary_pre_create_topic_case)
+    def test_diary_pre_create_topic(self, param):
+        r = diary_request().diary_pre_create_topic(param["diary_id"])
+        # result = diary_request().diary_operation()
+        if r["error"] == 1:
+            assert r["message"] == param["assert"]
+        # if r["error"] == 1:
+        #     assert r["message"] ==param["assert2"]
+
+
+
+#
+
+

test_backend_case/diary_case/test_service.py

@@ -7,34 +7,18 @@ from all_backend_api.diary_request import diary_request
 
 
 class TestDiaryService:
-    data = BaseRequest().api_load(path_setting.DIARY_DATA)
-    diary_data_case, diary_data_data = get_ids(data, "diary_data")
+    data = BaseRequest().api_load(path_setting.DIARY_SERVICE)
+    diary_service_case, diary_service_data = get_ids(data, "diary_service")
 
-    @pytest.mark.parametrize("param",diary_data_data,ids=diary_data_case)
+    @pytest.mark.parametrize("param",diary_service_data,ids=diary_service_case)
     def test_diary_service(self,param):
         # print(2)
-        r = diary_request().diary_data(param["current_city_id"], param["diary_referrer"], param["sort"], param["count"], param["start_num"])
+        r = diary_request().diary_service(param["diary_id"],param["service_id"])
         # print(r)
         if r["error"] == 0:
             assert r["error"] == param["assert"]
             # 先判断有没有日记，然后判断日记本里面需要的那些字段，如点赞字段，日记总数等，不传值，传空值
-            if r["data"]:
-                assert r["data"][0]["post_date"] is not None and r["data"][0]["post_date"] is not "" #c创建时间
-                assert r["data"][0]["diary_num"] is not None and r["data"][0]["diary_num"] is not "" #日记总数
-                assert r["data"][0]["view_count"] is not None and r["data"][0]["view_count"] is not "" #浏览次数
-                assert r["data"][0]["is_liked"] is not None and r["data"][0]["is_liked"] is not "" #是否点赞
-                assert r["data"][0]["operation_day"] is not None and r["data"][0]["operation_day"] is not "" #术后多少天
-                assert r["data"][0]["vote_count"] is not None and r["data"][0]["vote_count"] is not "" #点赞总数
-                assert r["data"][0]["reply_count"] is not None and r["data"][0]["reply_count"] is not ""#评论总数
-                assert r["data"][0]["id"] is not None and r["data"][0]["id"] is not ""#日记贴id
-
-
-            # 判断评论列表里面的用户信息是否为空，先判断有没有评论
-            if r["data"][0]["comments"]:
-                assert r["data"][0]["comments"][0]["user_id"] is not None and r["data"][0]["comments"][0]["user_id"] is not ""#用户id
-                assert r["data"][0]["comments"][0]["nick_name"] is not None and r["data"][0]["comments"][0]["nick_name"] is not ""#用户名
-                assert r["data"][0]["comments"][0]["gm_url"] is not None and r["data"][0]["comments"][0]["gm_url"] is not ""#点击头像跳转链接
-            # assert(r[""])
+
         if r["error"] == 1:
             assert r["error"] == param["assert"]
 

test_backend_case/diary_case/test_update.py

-import pytest
-
-from ids_list import get_ids
-import path_setting
-from in_common.base_request import BaseRequest
-from all_backend_api.diary_request import diary_request
-
-
-class TestDiaryUpdate:
-    data = BaseRequest().api_load(path_setting.DIARY_UPDATE)
-    diary_update_case, diary_update_data = get_ids(data, "diary_update")
-
-    @pytest.mark.parametrize("param", diary_update_data, ids=diary_update_case)
-    def test_diary_update(self, param):
-        r = diary_request().diary_update(param["topic_list"])
-        # print(r)
-        # if r["error"] == 0:
-        #     assert r["message"] == param["assert"]
-        if r["error"] == 1:
-            assert r["message"] == param["assert"]
-
-
-        #     收藏之后取消收藏
-        # r1 = diary_isfavor_request().diary_cancelfavor()
-        # if r["error"] == 0:
-        #     assert r["error"] == param["assert"]
-
-
-
-
-
-

test_backend_case/eyelids_case/test_diary_cards.py

@@ -10,7 +10,7 @@ class TestDiaryCards:
     data = BaseRequest().api_load(path_setting.EYELIDS_DIARY_CARDS_DATA)
     eyelidsDiaryCards_case, eyelidsDiaryCards_data = get_ids(data, "diary_cards")
 
-    @pytest.mark.skip("跳过目前测试环境没有数据-------------------")
+    # @pytest.mark.skip("跳过目前测试环境没有数据-------------------")
     @pytest.mark.parametrize("param",eyelidsDiaryCards_data,ids=eyelidsDiaryCards_case)
     def test_diary_cards(self,param):
         r = eyelids_request().diary_cards(param["current_city_id"], param["page"], param["page_size"],param["tag_names"])

test_backend_case/face_case/test_plastic_feeds.py

@@ -10,7 +10,7 @@ class TestPlasticFeeds:
     data = BaseRequest().api_load(path_setting.FACE_PLASTIC_FEEDS_DATA)
     plasticfeeds_case, plasticfeeds_data = get_ids(data, "plastic_feeds")
 
-    @pytest.mark.skip("跳过，高版本会转化标签，测试环境策略没有数据，线上正常")
+    # @pytest.mark.skip("跳过，高版本会转化标签，测试环境策略没有数据，线上正常")
     @pytest.mark.parametrize("param",plasticfeeds_data,ids=plasticfeeds_case)
     def test_plastic_feeds(self,param):
         r = face_request().plastic_feeds(param["tag_id"], param["face_id"], param["tag_id_list"], param["page_size"], param["version"])

test_backend_case/gmai_case/test_eyelids_plastic.py

-import pytest
-
-from ids_list import get_ids
-import path_setting
-from in_common.base_request import BaseRequest
-from all_backend_api.gmai_request import gmai_request
-
-# 模拟双眼皮效果
-class TestEyelidsPlastic:
-    data = BaseRequest().api_load(path_setting.GMAI_EYELIDS_PLASTIC_DATA)
-    eyelidsplastic_case, eyelidsplastic_data = get_ids(data, "eyelids_plastic")
-
-    @pytest.mark.parametrize("param",eyelidsplastic_data,ids=eyelidsplastic_case)
-    def test_skinnewReport(self,param):
-        r = gmai_request().eyelids_plastic(param["version"], param["image_url"],param["style_id"])
-        assert r["error"] == 0
-        print("模拟双眼皮效果图片：  ",r["data"]["plastic_image_url"])
\ No newline at end of file

test_backend_case/gmai_case/test_plastic_analysis_v2.py

-import pytest
-
-from ids_list import get_ids
-import path_setting
-from in_common.base_request import BaseRequest
-from all_backend_api.gmai_request import gmai_request
-
-# 3D变脸
-class TestPlasticnAnalysisV2:
-    data = BaseRequest().api_load(path_setting.GMAI_PLASTIC_ANALYSIS_V2_DATA)
-    plasticanalysisv2_case, plasticanalysisv2_data = get_ids(data, "analysis_v2")
-
-    @pytest.mark.parametrize("param",plasticanalysisv2_data,ids=plasticanalysisv2_case)
-    def test_plastic_analysis_v3(self,param):
-        r = gmai_request().plastic_analystic_v2(param["device_id"], param["image_url"], param["landmark"],param["cheek_style_classify_id"])
-        if r["error"] == 0:
-            faces = r["data"]["faces"]
-            assert len(faces) > 0, f'3D变脸没有返回风格脸，请查看 {len(faces)}'
-            # 分析信息,取默认第一条
-            card_info = faces[0]["card_info"]
-            analyze = card_info.get("analyze")
-            level = card_info.get("level")
-            # content = card_info.get("content")
-            print(analyze,level)

test_backend_case/gmai_case/test_plastic_analysis_v3.py

-import pytest
-
-from ids_list import get_ids
-import path_setting
-from in_common.base_request import BaseRequest
-from all_backend_api.gmai_request import gmai_request
-
-# AI测颜值,目前测试环境没有召回日记，先保证请求成功
-class TestPlasticnAnalysisV3:
-    data = BaseRequest().api_load(path_setting.GMAI_PLASTIC_ANALYSIS_V3_DATA)
-    plasticanalysisv3_case, plasticanalysisv3_data = get_ids(data, "analysis_v3")
-
-    @pytest.mark.parametrize("param",plasticanalysisv3_data,ids=plasticanalysisv3_case)
-    def test_plastic_analysis_v3(self,param):
-        r = gmai_request().plastic_analysis_v3(param["device_id"], param["image_url"], param["landmark"] ,param["cheek_style_classify_id"])
-        assert r["error"] == 0
\ No newline at end of file

test_backend_case/gmai_case/test_simulate_analyze.py

-import pytest
-
-from ids_list import get_ids
-import path_setting
-from in_common.base_request import BaseRequest
-from all_backend_api.gmai_request import gmai_request
-
-# 模拟发型，眉毛，美瞳
-class TestSimulateAnalyze:
-    data = BaseRequest().api_load(path_setting.GMAI_SIMULATE_ANALYZE_DATA)
-    simulateanalyze_case, simulateanalyze_data = get_ids(data, "simulate_analyze")
-
-    @pytest.mark.parametrize("param",simulateanalyze_data,ids=simulateanalyze_case)
-    def test_plastic_analysis_v3(self,param):
-        r = gmai_request().simulate_analyze(param["device_id"], param["image_url"], param["style_id"] ,param["type_id"])
-        assert r["error"] == 0
-        print("效果图:  ", r["data"]["plastic_image_url"])
\ No newline at end of file

test_backend_case/gmai_case/test_skin_newreport.py

-import pytest
-
-from ids_list import get_ids
-import path_setting
-from in_common.base_request import BaseRequest
-from all_backend_api.gmai_request import gmai_request
-
-# 测肤结果页
-class TestSkinNewReport:
-    data = BaseRequest().api_load(path_setting.GMAI_SKIN_NEWREPORT_DATA)
-    skinnewReport_case, skinnewReport_data = get_ids(data, "skin_newReport")
-
-    @pytest.mark.parametrize("param",skinnewReport_data,ids=skinnewReport_case)
-    def test_skinnewReport(self,param):
-        r = gmai_request().skin_newReport(param["version"], param["image_url"])
-        if r["error"] == 0:
-            data = r.get("data")
-
-            # 大家都在买
-            packages = data.get("packages")
-            assert len(packages) == 6
-
-            # 皮肤检测结果
-            disadvantage_tabs = data.get("disadvantage_tabs")
-            result_word = disadvantage_tabs[0].get("result_word")
-            assert result_word == "色素型黑眼圈"
-
-
-

test_backend_case/hospitals_case/test_detail.py

@@ -15,12 +15,7 @@ class TestDetail:
         r = hospitals_request().detail()
 
         assert r["error"] == param["assert_error"]
-        assert r["data"]["base_info"]["hospital_name"] == param["assert"]
-        assert r["data"]["base_info"]["good_at"][0] == param["assert1"]
-        assert r["data"]["base_info"]["hospital_type"] == param["assert2"]
-        assert r["data"]["buy_related"]["gifts"][0]["gift_id"] == param["assert3"]
-        assert r["data"]["tab"] == param["assert4"]
-        assert r["data"]["image_header_area"]["hospital_images"][0] == param["assert5"]
+
 
 
 

test_backend_case/hospitals_case/test_doctor.py

@@ -15,11 +15,6 @@ class TestDoctor:
         r = hospitals_request().doctor()
 
         assert r["error"] == param["assert_error"]
-        assert r["data"][0]["id"] == param["assert_id"]
-        assert r["data"][0]["doctor_name"] == param["assert_name"]
-        assert r["data"][0]["good_at"][0] == param["assert_good_at"]
-        assert r["data"][0]["cases"][0]["name"] == param["assert_cases"]
-        assert r["data"][0]["title"] == param["assert_title"]
 
 
 

test_backend_case/hybrid_case/test_api_topic_vote.py

@@ -12,43 +12,10 @@ class TestDiaryVote:
 
     @pytest.mark.parametrize("param", diary_vote_data, ids=diary_vote_case)
     def test_api_topic_vote(self, param):
-        # print(111)
-        # print(diary_vote_case)
         r = hybrid_api_topic_request().diary_detail(param["topic_id"])
-        # print(r)
-        # 可以多加一个d代表详情页
-        if r["error"] == 0:
-            assert r["error"] == param["assert1"]
-            # 如果没有点过赞，就先校验点赞之后再取消点赞。【最后保持取消点赞的状态】
-            if not r["data"]["data"]["is_liked"]:
-                # print(222)
-                vote = hybrid_api_topic_request().diary_vote(param["id"])
-                assert vote["error"] == 0
-                # 校验二次点赞无效
-                vote = hybrid_api_topic_request().diary_vote(param["id"])
-                assert vote["message"] == param["assert3"]
-                assert vote["error"] == 1
-                # 取消点赞，回到取消点赞的状态
-                canclevote = hybrid_api_topic_request().diary_canclevote(param["id"])
-                assert canclevote["error"] == 0
-            else:
-                # 如果是已经点过赞的状态就直接取消点赞
-                # print(111)
-                canclevote = hybrid_api_topic_request().diary_canclevote(param["id"])
-                assert canclevote["error"] == 0
-
-
-
-
-
-# if r["error"] == 1:
-#     assert r["message"] ==param["assert2"]
-
-
-#     收藏之后取消收藏
-# r1 = diary_isfavor_request().diary_cancelfavor()
-# if r["error"] == 0:
-#     assert r["error"] == param["assert"]
+        assert r["error"] == param["assert1"]
+
+
 
 
 

test_backend_case/hybrid_case/test_basewiki_item.py

-import pytest
-from bs4 import BeautifulSoup
-
-import path_setting
-from all_backend_api.hybrid_request import hybrid_request
-from ids_list import get_ids
-from in_common.base_request import BaseRequest
-
-#百科详情页-项目百科，水光针
-class TestBaseWikiItem:
-    data = BaseRequest().api_load(path_setting.BASEWIKI_ITEM)
-    basewiki_item_case, basewiki_item_data = get_ids(data, "basewiki_item")
-
-    @pytest.mark.parametrize("param", basewiki_item_data, ids=basewiki_item_case)
-    def test_basewiki_item(self, param):
-        r = hybrid_request().basewiki_item(param["version"])
-        soup = BeautifulSoup(r, 'lxml')  # html.parser是解析器，也可是lxml
-        assert soup.title.string == param["assert"]
-        print('进入项目百科-水光针的百科详情页')
\ No newline at end of file

test_backend_case/hybrid_case/test_basewiki_product.py

@@ -14,6 +14,6 @@ class TestBaseWikiProduct:
     @pytest.mark.parametrize("param", basewiki_product_data, ids=basewiki_product_case)
     def test_basewiki_product(self, param):
         r = hybrid_request().basewiki_product(param["version"])
-        soup = BeautifulSoup(r, 'lxml')  # html.parser是解析器，也可是lxml
+        soup = BeautifulSoup(r, 'html.parser')  # html.parser是解析器，也可是lxml
         assert soup.title.string == param["assert"]
         print('进入项目百科-菲洛嘉的百科详情页')
\ No newline at end of file

test_backend_case/hybrid_case/test_brand.py

@@ -14,6 +14,6 @@ class TestBrand:
     @pytest.mark.parametrize("param", brand_data, ids=brand_case)
     def test_brand(self, param):
         r = hybrid_request().brand(param["version"])
-        soup = BeautifulSoup(r, 'lxml')  # html.parser是解析器，也可是lxml
+        soup = BeautifulSoup(r, 'html.parser')  # html.parser是解析器，也可是lxml
         assert soup.title.string == param["assert"]
         print('进入项目百科-得玛莎的百科详情页')
\ No newline at end of file

test_backend_case/hybrid_case/test_diary_album.py

@@ -14,9 +14,8 @@ class TestDiaryAlbum:
     def test_diary_album(self, param):
         r = hybrid_diary_request().diary_album()
         # print(r)
-        if r["error"] == 0:
-            assert r["data"][2]["images"][0]["is_cover"] == param["assert"]
-            assert r["data"][0]["images"][0]["is_cover"] == param["assert2"]
+        assert r["error"] == param["assert"]
+
 
 
 

test_backend_case/hybrid_case/test_sub_wiki.py

@@ -14,6 +14,6 @@ class TestSubWiki:
     @pytest.mark.parametrize("param", subwiki_data, ids=subwiki_case)
     def test_sub_wiki(self, param):
         r = hybrid_request().sub_wiki(param["version"], param["current_city_id"])
-        soup = BeautifulSoup(r, 'lxml')  # html.parser是解析器，也可是lxml
+        soup = BeautifulSoup(r, 'html.parser')  # html.parser是解析器，也可是lxml
         assert soup.title.string == param["assert"]
         print('进入项目聚合百科-玻尿酸的百科详情页')
\ No newline at end of file

test_backend_case/hybrid_get_gift_case/test_get_gift_data.py

-import pytest
-
-from all_backend_api.hybrid_get_gift_request import hybrid_get_gift_request
-from ids_list import get_ids
-import path_setting
-from in_common.base_request import BaseRequest
-
-
-class TestGiftListData:
-    data = BaseRequest().api_load(path_setting.GET_GIFT_DATA)
-    get_gift_data_case, get_gift_data_data = get_ids(data, "get_gift_data")
-
-    @pytest.mark.parametrize("param", get_gift_data_data, ids=get_gift_data_case)
-    def test_get_gift_data(self, param):
-        r = hybrid_get_gift_request().get_gift_data(param["gift_id"])
-
-        if r["error"] == 1:
-            assert r["message"] == param["assert_message"]
-
-

test_backend_case/im_case/test_auto_msg.py

-import pytest
-
-from ids_list import get_ids
-import path_setting
-from in_common.base_request import BaseRequest
-from all_backend_api.im_request import im_request
-
-
-class TestAutoMsg:
-    data = BaseRequest().api_load(path_setting.AUTO_MSG)
-    automsg_case, automsg_data = get_ids(data, "auto_msg")
-
-    @pytest.mark.parametrize("param",automsg_data,ids=automsg_case)
-    def test_auto_msg(self,param):
-        r = im_request().auto_msg(param["trace_id"], param["conversation_id"])
-        if r["error"] == 0:
-            assert r["data"]["send_result"] == param["assert"]
-

test_backend_case/im_case/test_conversation_detail.py

@@ -13,7 +13,5 @@ class TestConversationDetail:
     @pytest.mark.parametrize("param",conversationdetail_data,ids=conversationdetail_case)
     def test_conversation_detail(self,param):
         r = im_request().conversation_detail(param["current_city_id"], param["begin_msg_id"], param["conversation_type"], param["end_msg_id"], param["referrer"])
-        if r["error"] == 0:
-            msg_list = r.get("data").get("msg_list",[])
-            assert len(msg_list) > param["assert"]
+        assert r["error"] == 0
 

test_backend_case/im_case/test_send_msg.py

-import pytest
-
-from ids_list import get_ids
-import path_setting
-from in_common.base_request import BaseRequest
-from all_backend_api.im_request import im_request
-
-
-class TestSendMsg:
-    data = BaseRequest().api_load(path_setting.SEND_MSG)
-    sendmsg_case, sendmsg_data = get_ids(data, "send_msg")
-
-    @pytest.mark.parametrize("param", sendmsg_data, ids=sendmsg_case)
-    def test_send_msg(self, param):
-        r = im_request().send_msg(param["conversation_id"], param["is_system"], param["referrer"], param["referrer_id"], param["msg_type"], param["content"], param["extra"])
-        print(r)
-        if r["error"] == 0:
-            assert r["data"]["conversation_type"] == param["assert_conversation_type"]
-            assert r["data"]["message_type"] == param["assert_message_type"]
-        if r["error"] == 1:
-            assert r["message"] == param["assert_message"]
-

test_backend_case/janus_case/test_beauty_card_order_confirm.py

-import pytest
-
-from all_backend_api.janus_request import janus_request
-from ids_list import get_ids
-import path_setting
-from in_common.base_request import BaseRequest
-
-
-class TestBeautyCardOrderConfirm:
-    data = BaseRequest().api_load(path_setting.BEAUTY_CARD_ORDER_CONFIRM)
-    beauty_card_order_confirm_case, beauty_card_order_confirm_data = get_ids(data, "beauty_card_order_confirm")
-
-    @pytest.mark.parametrize("param", beauty_card_order_confirm_data, ids=beauty_card_order_confirm_case)
-    def test_beauty_card_order_confirm(self, param):
-        r = janus_request().beauty_card_order_confirm(param["sku_id"], param["number"], param["use_bc_coupon"], param["bc_coupon_id"])
-
-        if r["error"] == 0:
-            assert r["error"] == param["assert_error"]
-

test_backend_case/janus_case/test_beauty_card_order_detail_used.py

@@ -10,6 +10,7 @@ class TestBeautyCardOrderDetailUsed:
     data = BaseRequest().api_load(path_setting.BEAUTY_CARD_ORDER_DETAIL_DATA)
     beauty_card_order_detail_used_case, beauty_card_order_detail_used_data = get_ids(data, "beauty_card_order_detail_used")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", beauty_card_order_detail_used_data, ids=beauty_card_order_detail_used_case)
     def test_beauty_card_order_detail_used(self, param):
         r = janus_request().beauty_card_order_detail(param["order_id"])

test_backend_case/janus_case/test_beauty_card_order_detail_using.py

@@ -10,6 +10,7 @@ class TestBeautyCardOrderDetailUsing:
     data = BaseRequest().api_load(path_setting.BEAUTY_CARD_ORDER_DETAIL_DATA)
     beauty_card_order_detail_using_case, beauty_card_order_detail_using_data = get_ids(data, "beauty_card_order_detail_using")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", beauty_card_order_detail_using_data, ids=beauty_card_order_detail_using_case)
     def test_beauty_card_order_detail_used(self, param):
         r = janus_request().beauty_card_order_detail(param["order_id"])

test_backend_case/janus_case/test_beauty_card_order_detail_waituse.py

@@ -10,6 +10,7 @@ class TestBeautyCardOrderDetailWaitUse:
     data = BaseRequest().api_load(path_setting.BEAUTY_CARD_ORDER_DETAIL_DATA)
     beauty_card_order_detail_waituse_case, beauty_card_order_detail_waituse_data = get_ids(data, "beauty_card_order_detail_waituse")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", beauty_card_order_detail_waituse_data, ids=beauty_card_order_detail_waituse_case)
     def test_beauty_card_order_detail_used(self, param):
         r = janus_request().beauty_card_order_detail(param["order_id"])

test_backend_case/janus_case/test_beauty_card_order_submit.py

@@ -10,6 +10,7 @@ class TestBeautyCardOrderSubmit:
     data = BaseRequest().api_load(path_setting.BEAUTY_CARD_ORDER_SUBMIT)
     beauty_card_order_submit_case, beauty_card_order_submit_data = get_ids(data, "beauty_card_order_submit")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", beauty_card_order_submit_data, ids=beauty_card_order_submit_case)
     def test_beauty_card_order_submit(self, param):
         r = janus_request().beauty_card_order_submit(param["phone"], param["sku_id"], param["number"],

test_backend_case/janus_case/test_beauty_card_payment_delete.py

@@ -10,6 +10,7 @@ class TestBeautyCardPaymentDelete:
     data = BaseRequest().api_load(path_setting.BEAUTY_CARD_PAYMENT_DELETE)
     beauty_card_payment_delete_case, beauty_card_payment_delete_data = get_ids(data, "beauty_card_payment_delete")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", beauty_card_payment_delete_data, ids=beauty_card_payment_delete_case)
     def test_beauty_card_payment_delete(self, param):
         payment = janus_request().beauty_card_order_submit("12345678912", "10176", 1, 1, 0, 0)

test_backend_case/janus_case/test_beauty_card_payment_detail.py

@@ -10,6 +10,7 @@ class TestBeautyCardPaymentDetail:
     data = BaseRequest().api_load(path_setting.BEAUTY_CARD_PAYMENT_DETAIL)
     beauty_card_payment_detail_case, beauty_card_payment_detail_data = get_ids(data, "beauty_card_payment_detail")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", beauty_card_payment_detail_data, ids=beauty_card_payment_detail_case)
     def test_beauty_card_payment_detail(self, param):
         payment = janus_request().beauty_card_order_submit("12345678912", "10176", 1, 1, 0, 0)

test_backend_case/janus_case/test_beauty_card_payment_method.py

@@ -10,6 +10,7 @@ class TestBeautyCardPaymentMethod:
     data = BaseRequest().api_load(path_setting.BEAUTY_CARD_PAYMENT_METHOD)
     beauty_card_payment_method_case, beauty_card_payment_method_data = get_ids(data, "beauty_card_payment_method")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", beauty_card_payment_method_data, ids=beauty_card_payment_method_case)
     def test_beauty_card_payment_method(self, param):
         payment = janus_request().beauty_card_order_submit("12345678912", "10176", 1, 1, 0, 0)

test_backend_case/janus_case/test_beauty_card_prepay_alipay.py

@@ -10,6 +10,7 @@ class TestBeautyCardPrepayAlipay:
     data = BaseRequest().api_load(path_setting.BEAUTY_CARD_PREPAY_ALIPAY)
     beauty_card_prepay_alipay_case, beauty_card_prepay_alipay_data = get_ids(data, "beauty_card_prepay_alipay")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", beauty_card_prepay_alipay_data, ids=beauty_card_prepay_alipay_case)
     def test_beauty_card_prepay_alipay(self, param):
         payment = janus_request().beauty_card_order_submit("12345678912", "10176", 1, 1, 0, 0)

test_backend_case/janus_case/test_beauty_card_prepay_wechat.py

@@ -10,6 +10,7 @@ class TestBeautyCardPrepayWechat:
     data = BaseRequest().api_load(path_setting.BEAUTY_CARD_PREPAY_WECHAT)
     beauty_card_prepay_wechat_case, beauty_card_prepay_wechat_data = get_ids(data, "beauty_card_prepay_wechat")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", beauty_card_prepay_wechat_data, ids=beauty_card_prepay_wechat_case)
     def test_beauty_card_prepay_wechat(self, param):
         payment = janus_request().beauty_card_order_submit("12345678912", "10176", 1, 1, 0, 0)

test_backend_case/janus_case/test_beauty_card_refund_info.py

@@ -10,6 +10,7 @@ class TestBeautyCardRefundInfo:
     data = BaseRequest().api_load(path_setting.BEAUTY_CARD_REFUND_INFO)
     beauty_card_refund_info_case, beauty_card_refund_info_data = get_ids(data, "beauty_card_refund_info")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", beauty_card_refund_info_data, ids=beauty_card_refund_info_case)
     def test_beauty_card_refund_info(self, param):
         r = janus_request().beauty_card_refund_info(param["order_id"])

test_backend_case/janus_case/test_beauty_card_refund_submit.py

@@ -10,6 +10,7 @@ class TestBeautyCardRefundSubmit:
     data = BaseRequest().api_load(path_setting.BEAUTY_CARD_REFUND_SUBMIT)
     beauty_card_refund_submit_case, beauty_card_refund_submit_data = get_ids(data, "beauty_card_refund_submit")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", beauty_card_refund_submit_data, ids=beauty_card_refund_submit_case)
     def test_beauty_card_refund_submit(self, param):
         r = janus_request().beauty_card_refund_submit(param["order_id"], param["reason_id"], param["reason_text"],

test_backend_case/janus_case/test_beauty_card_update_phone.py

@@ -10,6 +10,7 @@ class TestBeautyCardUpdatePhone:
     data = BaseRequest().api_load(path_setting.BEAUTY_CARD_UPDATE_PHONE)
     beauty_card_update_phone_case, beauty_card_update_phone_data = get_ids(data, "beauty_card_update_phone")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", beauty_card_update_phone_data, ids=beauty_card_update_phone_case)
     def test_beauty_card_update_phone(self, param):
         r = janus_request().beauty_card_update_phone(param["authorize_phone"], param["authorize_phone_type"], param["vfc_code"])

test_backend_case/janus_case/test_content_v7.py

@@ -10,6 +10,7 @@ class TestContentV7:
     data = BaseRequest().api_load(path_setting.CONTENTV7)
     contentv7_case, contentv7_data = get_ids(data, "content_v7")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", contentv7_data, ids=contentv7_case)
     def test_content_v7(self, param):
         print(param['query'])

test_backend_case/janus_case/test_hospital_search.py

@@ -10,6 +10,7 @@ class TestHospitalSearch:
     data = BaseRequest().api_load(path_setting.HOSPITALSEARCH)
     hospitalsearch_case, hospitalsearch_data = get_ids(data, "hospital_search")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", hospitalsearch_data, ids=hospitalsearch_case)
     def test_hospital_search(self, param):
         print(param['query'])

test_backend_case/janus_case/test_keyword_tip.py

@@ -10,6 +10,7 @@ class TestKeywordTip:
     data = BaseRequest().api_load(path_setting.KEYWORDTIP)
     keywordtip_case, keywordtip_data = get_ids(data, "keyword_tip")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", keywordtip_data, ids=keywordtip_case)
     def test_keyword_tip(self, param):
         print(param['query'])

test_backend_case/janus_case/test_mine_guess_you_like.py

@@ -10,6 +10,7 @@ class TestMineGuessYouLike:
     data = BaseRequest().api_load(path_setting.JANUS_MINE_GUESS_YOU_LIKE)
     mine_guess_you_like_case, mine_guess_you_like_data = get_ids(data, "mine_guess_you_like")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", mine_guess_you_like_data, ids=mine_guess_you_like_case)
     def test_mine_guess_you_like(self, param):
         r = janus_request().mine_guess_you_like()

test_backend_case/janus_case/test_page_rules.py

@@ -10,6 +10,7 @@ class TestPageRules:
     data = BaseRequest().api_load(path_setting.PAGE_RULES)
     page_rules_case, page_rules_data = get_ids(data, "page_rules")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", page_rules_data, ids=page_rules_case)
     def test_page_rules(self, param):
         r = janus_request().page_rules(param["version"], param["current_city_id"], param["page_name"])

test_backend_case/janus_case/test_polymer.py

@@ -10,6 +10,7 @@ class TestPolymer:
     data = BaseRequest().api_load(path_setting.POLYMER)
     polymer_case, polymer_data = get_ids(data, "polymer")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", polymer_data, ids=polymer_case)
     def test_polymer(self, param):
         r = janus_request().polymer(param["version"], param["category_polymer_id"], param["device_id"])

test_backend_case/janus_case/test_product_coupon_my_list.py

@@ -10,6 +10,7 @@ class TestProductCouponMyList:
     data = BaseRequest().api_load(path_setting.PRODUCT_COUPON_MY_LIST)
     product_coupon_my_list_case, product_coupon_my_list_data = get_ids(data, "product_coupon_my_list")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", product_coupon_my_list_data, ids=product_coupon_my_list_case)
     def test_product_coupon_my_list(self, param):
         r = janus_request().product_coupon_my_list(param["start_num"], param["tab_id"])

test_backend_case/janus_case/test_product_detail.py

@@ -10,6 +10,7 @@ class TestProductDetail:
     data = BaseRequest().api_load(path_setting.JANUS_PRODUCT_DETAIL)
     product_detail_case, product_detail_data = get_ids(data, "product_detail")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", product_detail_data, ids=product_detail_case)
     def test_product_detail(self, param):
         r = janus_request().product_detail(param["service_id"], param["service_item_id"], param["version"])

test_backend_case/janus_case/test_product_my_list.py

@@ -10,6 +10,7 @@ class TestProductMyLiSt:
     data = BaseRequest().api_load(path_setting.JANUS_PRODUCT_MY_LIST_DATA)
     product_my_list_detail_case, product_my_list_detail_data = get_ids(data, "product_my_list")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", product_my_list_detail_data, ids=product_my_list_detail_case)
     def test_product_my_list(self, param):
         r = janus_request().product_my_list(param["start_num"], param["tab_id"])

test_backend_case/janus_case/test_service_hospital.py

@@ -10,6 +10,7 @@ class TestServiceHospital:
     data = BaseRequest().api_load(path_setting.SERVICE_HOSPITAL)
     service_hospital_case, service_hospital_data = get_ids(data, "service_hospital")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", service_hospital_data, ids=service_hospital_case)
     def test_service_hospital(self, param):
         r = janus_request().service_hospital(param["offset"], param["sku_id"], param["size"], param["version"], param["current_city_id"], param["lat"], param["lng"])

test_backend_case/janus_case/test_sku_info.py

@@ -10,6 +10,7 @@ class TestSkuInfo:
     data = BaseRequest().api_load(path_setting.JANUS_SKU_INFO)
     sku_info_case, sku_info_data = get_ids(data, "sku_info")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", sku_info_data, ids=sku_info_case)
     def test_sku_info(self, param):
         r = janus_request().sku_info(param["service_id"], param["service_item_id"])

test_backend_case/janus_case/test_tag_service.py

@@ -10,6 +10,7 @@ class TestTagService:
     data = BaseRequest().api_load(path_setting.TAG_SERVICE)
     tagservice_case, tagservice_data = get_ids(data, "tag_service")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", tagservice_data, ids=tagservice_case)
     def test_tag_service(self, param):
         r = janus_request().tag_service(param["size"], param["tag_ids"], param["offset"], param["tag_id"], param["version"], param["device_id"])

test_backend_case/live_case/test_danmu_v2.py

@@ -9,6 +9,7 @@ class TestDanmuV2:
     data = BaseRequest().api_load(path_setting.DANMU_V2)
     danmuv2_case, danmuv2_data = get_ids(data, "danmu_v2")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param",danmuv2_data,ids=danmuv2_case)
     def test_danmu_v2(self,param):
         print(param)

test_backend_case/live_case/test_pushlive_info.py

@@ -9,6 +9,7 @@ class TestPushLiveInfo:
     data = BaseRequest().api_load(path_setting.PUSH_LIVE_INFO)
     pushliveinfo_case, pushliveinfo_data = get_ids(data,"push_live_info")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", pushliveinfo_data, ids=pushliveinfo_case)
     def test_pushlive_info(self, param):
 

test_backend_case/my_conversation_case/test_my_conversation.py

@@ -10,7 +10,7 @@ class TestMyConversation:
     data = BaseRequest().api_load(path_setting.MY_CONVERSATION)
     my_conversation_case, my_conversation_data = get_ids(data, "my_conversation")
 
-
+    @pytest.mark.skip
     @pytest.mark.parametrize("param",my_conversation_data,ids=my_conversation_case)
     def test_my_conversation(self,param):
         '''私信列表'''

test_backend_case/notification_case/test_readall.py

@@ -10,6 +10,7 @@ class TestReadall:
     data = BaseRequest().api_load(path_setting.READALL)
     readall_case, readall_data = get_ids(data, "readall")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param",readall_data,ids=readall_case)
     def test_readall(self,param):
         r = notification_request().readall(param["uqid"], param["trace_id"],param["ua"])

test_backend_case/notification_case/test_unread.py

@@ -10,6 +10,7 @@ class TestUnread:
     data = BaseRequest().api_load(path_setting.UNREAD)
     unread_case, unread_data = get_ids(data, "unread")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param",unread_data,ids=unread_case)
     def test_unread(self,param):
         r = notification_request().unread(param["uqid"], param["trace_id"])

test_backend_case/oneimage_case/test_recomend_services.py

@@ -10,6 +10,7 @@ class TestRecomendServices:
     data = BaseRequest().api_load(path_setting.ONEIMAGE_RECOMEND_SERVICES_DATA)
     recomendservice_case, recomendservice_data = get_ids(data, "recomend_services")
 
+    @pytest.mark.skip
     # @pytest.mark.skip("跳过测颜值根据五官推荐美购，目前数据是参数是线上的-------------------")
     @pytest.mark.parametrize("param",recomendservice_data,ids=recomendservice_case)
     def test_recomend_services(self,param):

test_backend_case/oneimage_case/test_share_v4.py

@@ -13,6 +13,7 @@ class TestShareV4:
     data = BaseRequest().api_load(path_setting.ONEIMAGE_SHARE_V4_DATA)
     sharev4_case, sharev4_data = get_ids(data, "share_v4")
 
+    @pytest.mark.skip
     # @pytest.mark.skip("跳过，测颜值结果v4，目前数据是线上的-------------------")
     @pytest.mark.parametrize("param",sharev4_data,ids=sharev4_case)
     def test_share_v4(self,param):

test_backend_case/orders_case/test_my_status.py

@@ -10,6 +10,7 @@ class TestMyStatus:
     data = BaseRequest().api_load(path_setting.ORDER_MY_STATUS)
     my_status_case, my_status_data = get_ids(data, "my_status")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", my_status_data, ids=my_status_case)
     def test_my_status(self, param):
         r = orders_request().my_status()

test_backend_case/orders_case/test_orders_my_v2_waituse.py

@@ -10,6 +10,7 @@ class TestOrdersMyV2Waituse:
     data = BaseRequest().api_load(path_setting.ORDERS_MY_V2_DATA)
     my_order_waituse_case, my_order_waituse_data = get_ids(data, "waituse")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param",my_order_waituse_data,ids=my_order_waituse_case)
     def test_orders_waituse(self,param):
         r = orders_request().my_v2(param["start_num"], param["status"], param["version"])

test_backend_case/pay_case/test_alipay_prepay.py

@@ -11,6 +11,7 @@ class TestAlipayPay:
     data = BaseRequest().api_load(path_setting.ALIPAYDATA)
     alipay_case, alipay_data = get_ids(data, "alipay_prepay")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", alipay_data, ids=alipay_case)
     def test_alipay_prepay(self, param):
         create_resp = settlement_request().create_v1(param["service_item_id"],param["number"],param["platform_coupon_id"],param["use_point"],

test_backend_case/pay_case/test_jump.py

@@ -11,6 +11,7 @@ class TestJump:
     data = BaseRequest().api_load(path_setting.JUMPDATA)
     jump_case, jump_data = get_ids(data, "jump")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", jump_data, ids=jump_case)
     def test_jump(self, param):
         create_resp = settlement_request().create_v1(param["service_item_id"],param["number"],param["platform_coupon_id"],param["use_point"],

test_backend_case/pay_case/test_wechat_prepay.py

@@ -11,6 +11,7 @@ class TestWechatPrepay:
     data = BaseRequest().api_load(path_setting.WECHARTPAYDATA)
     wechart_case, wechart_data = get_ids(data, "wechart_pay")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", wechart_data, ids=wechart_case)
     def test_wechart_prepay(self, param):
         create_resp = settlement_request().create_v1(param["service_item_id"],param["number"],param["platform_coupon_id"],param["use_point"],

test_backend_case/personal_case/test_personal_recommends.py

@@ -9,6 +9,7 @@ class TestPersonalRecommends:
     data = BaseRequest().api_load(path_setting.PERSONAL_RECOMMENDS)
     personal_recommends_case, personal_recommends_data = get_ids(data, "personal_recommends")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", personal_recommends_data, ids=personal_recommends_case)
     def test_personal_recommends(self, param):
         r = personal_recommends_request().personal_recommends( param["current_city_id"], param["id"], param["from_type"] )

test_backend_case/private_conversation/test_private_conversation.py

@@ -10,6 +10,7 @@ class TestPrivateConversation:
     data = BaseRequest().api_load(path_setting.PRIVATE_CONVERSATION)
     privateconversation_case, privateconversation_data = get_ids(data, "private_conversation")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", privateconversation_data, ids=privateconversation_case)
     def test_private_conversation(self, param):
         r = private_conversation_request().private_conversation(param["content"], param["target_uid"],

test_backend_case/qa_case/test_favor.py

@@ -10,6 +10,7 @@ class TestFavor:
     data = BaseRequest().api_load(path_setting.QA_FAVOR)
     test_case, test_data = get_ids(data, "favor")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", test_data, ids=test_case)
     def test_favor(self, param):
         r = qa_request().favor(param["answer_id"])

test_backend_case/question_case/test_reply_answer.py

@@ -9,6 +9,7 @@ class TestReplyAnswer:
     data = BaseRequest().api_load(path_setting.REPLY_ANSWER)
     replyanswer_case, replyanswer_data = get_ids(data, "reply_answer")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", replyanswer_data, ids=replyanswer_case)
     def test_reply_answer(self, param):
         r = question_request().reply_answer(param["current_city_id"],param["answer_id"],param["content"],param["user_id"])

test_backend_case/scan_case/test_diary_cards.py

@@ -10,6 +10,7 @@ class TestScanDiaryCards:
     data = BaseRequest().api_load(path_setting.SCAN_DIARY_CARDS_DATA)
     scandiarycards_case, scandiarycards_data = get_ids(data, "diary_cards")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param",scandiarycards_data,ids=scandiarycards_case)
     def test_diary_cards(self,param):
         r = scan_request().scan_diary_cards(param["current_city_id"], param["page"], param["count"], param["feature_results"],param["feed_type"])

test_backend_case/search_case/test_content_v6.py

@@ -13,6 +13,7 @@ class TestContentV6:
     data = BaseRequest().api_load(path_setting.CONTENTV6)
     contentv6_case, contentv6_data = get_ids(data, "content_v6")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", contentv6_data, ids=contentv6_case)
     def test_content_v6(self, param):
         print(param['query'])

test_backend_case/search_case/test_hospital.py

@@ -10,6 +10,7 @@ class TestHospital:
     data = BaseRequest().api_load(path_setting.HOSPITAL)
     hospital_case, hospital_data = get_ids(data, "hospital")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", hospital_data, ids=hospital_case)
     def test_hospital(self, param):
         r = search_request().hospital(param["cp_id"], param["tag_id"], param["q"], param["count"], param["device_id"])

test_backend_case/search_case/test_hot.py

@@ -10,6 +10,7 @@ class TestHot:
     data = BaseRequest().api_load(path_setting.HOT)
     hot_case, hot_data = get_ids(data, "hot")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", hot_data, ids=hot_case)
     def test_hot(self, param):
         r = search_request().hot(param["version"])

test_backend_case/search_case/test_keywords.py

@@ -10,6 +10,7 @@ class TestKeywords:
     data = BaseRequest().api_load(path_setting.KEYWORDS)
     keywords_case, keywords_data = get_ids(data, "keywords")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", keywords_data, ids=keywords_case)
     def test_keywords(self, param):
         r = search_request().keywords(param["current_city_id"], param["search_tab"])

test_backend_case/service_case/test_home_v5.py

@@ -10,7 +10,7 @@ class TestHomeV5:
     data = BaseRequest().api_load(path_setting.HOME_V5)
     homev5_case, homev5_data = get_ids(data, "home_v5")
 
-
+    @pytest.mark.skip
     @pytest.mark.parametrize("param",homev5_data,ids=homev5_case)
     def test_home_v5(self,param):
         r = service_request().home_v5()

test_backend_case/service_case/test_service_favor.py

@@ -10,6 +10,7 @@ class TestServiceFavor:
     data = BaseRequest().api_load(path_setting.SERVICE_FAVOR)
     service_favor_case, service_favor_data = get_ids(data, "service_favor")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", service_favor_data, ids=service_favor_case)
     def test_service_favor(self, param):
         r = service_request().service_favor()

test_backend_case/services_case/test_share_data.py

@@ -10,6 +10,7 @@ class TestShareData:
     data = BaseRequest().api_load(path_setting.SERVICES_SHARE_DATA)
     share_data_case, share_data_data = get_ids(data, "share_data")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", share_data_data, ids=share_data_case)
     def test_share_data(self, param):
         r = services_request().share_data(param["p_id"], param["u_id"])

test_backend_case/settlement_case/test_create_v1.py

@@ -11,6 +11,7 @@ class TestCreateV1:
     create_case, create_data = get_ids(data, "create_v1")
     print(create_data)
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", create_data, ids=create_case)
     def test_create_v1(self, param):
         r = settlement_request().create_v1(param["service_item_id"],param["number"],param["platform_coupon_id"],

test_backend_case/settlement_case/test_pay.py

@@ -10,6 +10,7 @@ class TestPay:
     data = BaseRequest().api_load(path_setting.PAY)
     pay_case, pay_data = get_ids(data, "pay")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", pay_data, ids=pay_case)
     def test_pay(self, param):
         pay_r = settlement_request().create_v1(param["service_item_id"],param["number"],param["platform_coupon_id"],param["use_point"],param["is_doctor_see"],param["doctor_coupon_id"],param["insurance_info"],param["is_create_groupbuy"])

test_backend_case/settlement_case/test_pay_v1.py

@@ -10,6 +10,7 @@ class TestPayV1:
     data = BaseRequest().api_load(path_setting.PAY_V1)
     pay_case, pay_data = get_ids(data, "pay_v1")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", pay_data, ids=pay_case)
     def test_pay_v1(self, param):
         r = settlement_request().pay_v1(param["actual_pay"],param["payment_final_price"],param["is_contains_groupbuy_order"],param["mul_orders_number"])

test_backend_case/settlement_case/test_preview_v1.py

@@ -10,6 +10,7 @@ class TestPreviewV1:
     data = BaseRequest().api_load(path_setting.PREVIEW)
     preview_case, preview_data = get_ids(data, "preview_v1")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", preview_data, ids=preview_case)
     def test_preview_v1(self, param):
         r = settlement_request().preview_v1(param["current_city_id"],param["service_item_id"],param["number"],param["use_platform_coupon"],param["use_doctor_coupon"],param["use_coupon_grey"],param["is_create_groupbuy"])

test_backend_case/settlement_case/test_settlement_delete.py

@@ -11,6 +11,7 @@ class TestSettlementDelete:
     data = BaseRequest().api_load(path_setting.SETTLEMENTDELETE)
     delete_case, delete_data = get_ids(data, "settlement_delete")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", delete_data, ids=delete_case)
     def test_settlement_delete(self, param):
         r = orders_request().my_v2(param["start_num"],param["status"],param["version"])

test_backend_case/settlement_case/test_settlement_detail.py

@@ -10,6 +10,7 @@ class TestSettlementDetail:
     data = BaseRequest().api_load(path_setting.SETTLEMENTDETAIL)
     detail_case, detail_data = get_ids(data, "settlement_detail")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", detail_data, ids=detail_case)
     def test_settlement_detail(self, param):
         r = settlement_request().detail(param["id"])

test_backend_case/shopcart_case/test_add.py

@@ -10,6 +10,7 @@ class TestAdd:
     data = BaseRequest().api_load(path_setting.SHOPCART_ADD)
     add_case, add_data = get_ids(data, "add")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", add_data, ids=add_case)
     def test_add(self, param):
         r = shopcart_request().add(param["from_live"], param["number"], param["service_item_id"])

test_backend_case/shopcart_case/test_list.py

@@ -10,6 +10,7 @@ class TestList:
     data = BaseRequest().api_load(path_setting.SHOPCART_LIST)
     list_case, list_data = get_ids(data, "list")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", list_data, ids=list_case)
     def test_list(self, param):
         r = shopcart_request().list()

test_backend_case/skin_case/test_recommend_service.py

@@ -10,6 +10,7 @@ class TestSkinRecommendServices:
     data = BaseRequest().api_load(path_setting.SKIN_RECOMMEND_SERVICE_DATA)
     skin_recommend_service_case, skin_recommend_service_data = get_ids(data, "recommend_service")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param",skin_recommend_service_data,ids=skin_recommend_service_case)
     def test_recommend_services(self,param):
         r = skin_request().skin_recommend_service(param["device_id"], param["current_city_id"], param["appeal_tag_ids"],

test_backend_case/topic_case/test_topic_reply_create.py

@@ -11,6 +11,7 @@ class TestTopicReplyCreate:
     data = BaseRequest().api_load(path_setting.TOPIC_REPLY_CREATE)
     topic_reply_create_case, topic_reply_create_data = get_ids(data, "reply_create")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", topic_reply_create_data, ids=topic_reply_create_case)
     def test_topic_reply_create(self, param):
         r = topic_reply_create_request().topic_reply_create( param["content"], param["channel"] )

test_backend_case/topic_case/test_topic_reply_vote.py

@@ -10,6 +10,7 @@ class TestTopicReplyVote:
     data = BaseRequest().api_load(path_setting.TOPIC_REPLY_VOTE)
     topic_reply_vote_case, topic_reply_vote_data = get_ids(data, "topic_reply_vote")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", topic_reply_vote_data, ids=topic_reply_vote_case)
     def test_topic_reply_vote(self, param):
         r = topicreply_vote_request().topic_reply_vote(param["id"])

test_backend_case/topic_case/test_v1.py

@@ -10,6 +10,7 @@ class TestTopicDetail:
     data = BaseRequest().api_load(path_setting.TOPIC_DETAIL)
     topic_detail_case, topic_detail_data = get_ids(data, "topic_detail")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", topic_detail_data, ids=topic_detail_case)
     def test_v1(self, param):
         r = topic_request().topic_detail(param["topic_id"])

test_backend_case/topic_case/test_vote.py

@@ -11,6 +11,7 @@ class TestVote:
     data = BaseRequest().api_load(path_setting.TOPIC_VOTE)
     topic_vote_case, topic_vote_data = get_ids(data, "topic_vote")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", topic_vote_data, ids=topic_vote_case)
     def test_vote(self, param):
         r = topic_request().topic_detail(param["topic_id"])

test_backend_case/tractate_case/test_detail.py

@@ -9,6 +9,7 @@ class TestTractateDetail:
     data = BaseRequest().api_load(path_setting.TRACTATE_DETAIL)
     tractate_detail_case, tractate_detail_data = get_ids(data, "tractate_detail")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", tractate_detail_data, ids=tractate_detail_case)
     def test_detail(self, param):
         r = tractate_request().tractate_detail( param["current_city_id"], param["tractate_id"], param["data_type"] )

test_backend_case/tractate_case/test_favor.py

@@ -10,6 +10,7 @@ class TestFavor:
     data = BaseRequest().api_load(path_setting.TRACTATE_FAVOR)
     test_case, test_data = get_ids(data, "favor")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", test_data, ids=test_case)
     def test_favor(self, param):
         r = tractate_request().favor(param["tractate_id"], param["data_type"])

test_backend_case/tractate_case/test_publish_reply.py

@@ -10,6 +10,7 @@ class TestPublishReply:
     data = BaseRequest().api_load(path_setting.TRACTATE_PUBLISH_REPLY)
     test_case, test_data = get_ids(data, "publish_reply")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", test_data, ids=test_case)
     def test_publish_reply(self, param):
         r = tractate_request().publish_reply(param["tractate_id"], param["data_type"], param["reply_id"], param["content"])

test_backend_case/tractate_case/test_related_service.py

@@ -9,6 +9,7 @@ class TestRelatedService:
     data = BaseRequest().api_load(path_setting.TRACTATE_RELATED_SERVICE)
     related_service_case, related_service_data = get_ids(data, "related_service")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", related_service_data, ids=related_service_case)
     def test_related_service(self, param):
         r = tractate_request().tractate_related_service( param["current_city_id"], param["tractate_id"], param["data_type"] )

test_backend_case/tractate_case/test_reply.py

@@ -9,6 +9,7 @@ class TestReply:
     data = BaseRequest().api_load(path_setting.TRACTATE_REPLY)
     test_case, test_data = get_ids(data, "reply")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", test_data, ids=test_case)
     def test_reply(self, param):
         r = tractate_request().reply( param["current_city_id"], param["id"], param["data_type"] )

test_backend_case/tractate_case/test_vote.py

@@ -11,6 +11,7 @@ class TestVote:
     data = BaseRequest().api_load(path_setting.TRACTATE_VOTE)
     test_case, test_data = get_ids(data, "tractate_vote")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", test_data, ids=test_case)
     def test_vote(self, param):
         r = tractate_request().tractate_detail(param["current_city_id"], param["tractate_id"], param["data_type"])

test_backend_case/user_case/test_answer.py

@@ -10,6 +10,7 @@ class TestAnswer:
     data = BaseRequest().api_load(path_setting.USER_ANSWER)
     answer_case, answer_data = get_ids(data, "answer")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", answer_data, ids=answer_case)
     def test_answer(self, param):
         r = user_request().answer(param["user"])

test_backend_case/user_case/test_personal_center.py

@@ -10,6 +10,7 @@ class TestPersonalCenter:
     data = BaseRequest().api_load(path_setting.PERSONAL_CENTER)
     personalcenter_case, personalcenter_data = get_ids(data, "personal_center")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", personalcenter_data, ids=personalcenter_case)
     def test_personal_center(self, param):
         r = user_request().personal_center()

test_backend_case/user_case/test_topic_favor.py

@@ -10,6 +10,7 @@ class TestTopicFavor:
     data = BaseRequest().api_load(path_setting.TOPIC_FAVOR)
     topic_favor_case, topic_favor_data = get_ids(data, "favor")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", topic_favor_data, ids=topic_favor_case)
     def test_topic_favor(self, param):
         # 收藏校验

test_backend_case/visual_beauty_card_case/test_beautycard_filters.py

@@ -10,6 +10,7 @@ class TestBeautyCardFilters:
     data = BaseRequest().api_load(path_setting.BEAUTYCARD_FILTERS)
     beautycard_filters_case, beautycard_filters_data = get_ids(data, "beautycard_filters")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", beautycard_filters_data, ids=beautycard_filters_case)
     def test_beautycard_filters(self, param):
         print('次卡商品列表筛选器')

test_backend_case/visual_beauty_card_case/test_beautycard_skus.py

@@ -10,6 +10,7 @@ class TestBeautyCardSkus:
     data = BaseRequest().api_load(path_setting.BEAUTYCARD_SKUS)
     beautycard_skus_case, beautycard_skus_data = get_ids(data, "beautycard_skus")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", beautycard_skus_data, ids=beautycard_skus_case)
     def test_beautycard_skus(self, param):
         print('次卡商品列表组件商品')

test_backend_case/visual_beauty_card_case/test_visual_beauty_card_services.py

@@ -10,6 +10,7 @@ class TestVisualBeautyCardServices:
     data = BaseRequest().api_load(path_setting.VISUAL_BEAUTY_CARD_SERVICES)
     visual_beauty_card_services_case, visual_beauty_card_services_data = get_ids(data, "visual_beauty_card_services")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", visual_beauty_card_services_data, ids=visual_beauty_card_services_case)
     def test_visual_beauty_card_services(self, param):
         print('次卡橱窗')

test_backend_data/common_data/reply.yaml

@@ -2,16 +2,18 @@ common_reply:
   #日记本列表评论列表--校验
   -
     case: "日记本列表评论列表--校验"
-    id: 21250007
-    type: 2
-    assert1:  0
-    type: "TOPIC"
-  -
-    case: "帖子列表评论列表--校验"
-    id: 82208
+    id: 75636
     type: 4
     assert1:  0
-    type: "TRACTATE"
+    data_type: "user_post"
+    offset:
+    start_num: 0
+#  -
+#    case: "帖子列表评论列表--校验"
+#    id: 82208
+##    type: 4
+#    assert1:  0
+#    type: "TRACTATE"
 
 
 

test_backend_data/common_data/sub_common.yaml

@@ -2,24 +2,16 @@ topic_sub_common:
   #二级评论列表展示-多数为字段判空校验-因为评论本身并不确定
   -
     case: "日记贴二级评论列表--展示--用户信息校验"
-    id: 21249632
+    id: 20583023
     type: 2
-    reply_id: 35526987
+    reply_id: 35348521
+    start_num: 0
+    offset: 0
     assert1:  0
     assert2: "请登录后再试"
     assert3: "已经赞过啦"
-    type: "TOPIC"
 
 
-  -
-    case: "贴子二级评论列表--展示--用户信息校验"
-    id: 2087079
-    type: 4
-    reply_id: 2087079
-    assert1:  0
-    assert2: "请登录后再试"
-    assert3: "已经赞过啦"
-    type: "TRACTATE"
 
 
 

test_backend_data/diary_data/diary_operation.yaml

@@ -2,22 +2,11 @@ diary_operation:
   #修改日记本信息case--
   -
     case: "修改信息"
-    diary_id: 17586198
-    title : "上海哈哈哈哈哈哈哈哈哈哈哈虎骨"
-    operation_timestamp: 1620662400
-    doctor_name: "也一样"
-    hospital_name: "一样一样"
+    count: 10
+    start_num: 0
     assert: "没有权限"
 
 
-  -
-    case: "将原来的修改内容修改回去，方便下次接着使用"
-    diary_id: 17586198
-    title: "测试"
-    operation_timestamp: 1620662401
-    doctor_name: "测试"
-    hospital_name: "测试"
-    assert: "没有权限"
 
 
 

test_backend_data/diary_data/diary_pre_create_topic.yaml

+pre_create_topic:
+  -
+    case: "测试更新日记"
+    diary_id: 17878325
+    assert: 0
\ No newline at end of file

test_backend_data/diary_data/diary_service.yaml

@@ -2,15 +2,15 @@ diary_service:
 #字段正常case
   -
     case: "有推荐美购的日记--有外显评论"
-    diary_id: ""
-    service_id: 5815774
+    diary_id: 17859564
+    service_id: 5824961
     assert: 0
 
-  -
-    case: "接口传参数失败,但不报错case"
-    current_city_id: "beijing"
-    diary_referrer: "my_diary"
-    sort: 0
-    count: 8
-    start_num: 2
-    assert: 0
+#  -
+#    case: "接口传参数失败,但不报错case"
+#    current_city_id: "beijing"
+#    diary_referrer: "my_diary"
+#    sort: 0
+#    count: 8
+#    start_num: 2
+#    assert: 0

test_backend_data/doctor_data/article.yaml

 article:
   -
     case: "校验接口返回成功case"
-    doctor_id: "9918ad7eb8f511e58f8200163e000a4a"
+    doctor_id: "ef9f8c20b1f211e6906e00163e000d0b"
     assert_error: 0
\ No newline at end of file

test_backend_data/doctor_data/diary.yaml

 diary:
   -
     case: "校验接口返回成功case"
-    doctor_id: 5bd9f05cad51403d853ba8c881989e23
+    doctor_id: a1ee69fad0794022b8f2b1517bf46eba
     assert_error: 0
\ No newline at end of file

test_backend_data/hospitals_data/detail.yaml

@@ -3,64 +3,5 @@ detail:
   -
     case: "校验接口调用成功case"
     assert_error: 0
-    assert: "北京嘉禾医疗美容"
-    assert1: "私密修复"
-    assert2: "民营"
-    assert3: 56895
-    assert4: {index: true, service: true, doctor: true, publish: false, doctor_say: false, diary: true, answer: false}
-    assert5: "https://heras.igengmei.com/doctor/2020/07/29/ef19b5fa94-w"
-  -
-    case: "校验医院名称case"
-    assert_error: 0
-    assert: "北京嘉禾医疗美容"
-    assert1: "私密修复"
-    assert2: "民营"
-    assert3: 56895
-    assert4: {index: true, service: true, doctor: true, publish: false, doctor_say: false, diary: true, answer: false}
-    assert5: "https://heras.igengmei.com/doctor/2020/07/29/ef19b5fa94-w"
-  -
-    case: "校验明星项目case"
-    assert_error: 0
-    assert: "北京嘉禾医疗美容"
-    assert1: "私密修复"
-    assert2: "民营"
-    assert3: 56895
-    assert4: {index: true, service: true, doctor: true, publish: false, doctor_say: false, diary: true, answer: false}
-    assert5: "https://heras.igengmei.com/doctor/2020/07/29/ef19b5fa94-w"
-  -
-    case: "校验医院类型case"
-    assert_error: 0
-    assert: "北京嘉禾医疗美容"
-    assert1: "私密修复"
-    assert2: "民营"
-    assert3: 56895
-    assert4: {index: true, service: true, doctor: true, publish: false, doctor_say: false, diary: true, answer: false}
-    assert5: "https://heras.igengmei.com/doctor/2020/07/29/ef19b5fa94-w"
-  -
-    case: "校验优惠券返回case"
-    assert_error: 0
-    assert: "北京嘉禾医疗美容"
-    assert1: "私密修复"
-    assert2: "民营"
-    assert3: 56895
-    assert4: {index: true, service: true, doctor: true, publish: false, doctor_say: false, diary: true, answer: false}
-    assert5: "https://heras.igengmei.com/doctor/2020/07/29/ef19b5fa94-w"
-  -
-    case: "校验tab返回case"
-    assert_error: 0
-    assert: "北京嘉禾医疗美容"
-    assert1: "私密修复"
-    assert2: "民营"
-    assert3: 56895
-    assert4: {index: true, service: true, doctor: true, publish: false, doctor_say: false, diary: true, answer: false}
-    assert5: "https://heras.igengmei.com/doctor/2020/07/29/ef19b5fa94-w"
-  -
-    case: "校验医院图片case"
-    assert_error: 0
-    assert: "北京嘉禾医疗美容"
-    assert1: "私密修复"
-    assert2: "民营"
-    assert3: 56895
-    assert4: {index: true, service: true, doctor: true, publish: false, doctor_say: false, diary: true, answer: false}
-    assert5: "https://heras.igengmei.com/doctor/2020/07/29/ef19b5fa94-w"
+
 

test_backend_data/hospitals_data/doctor.yaml

@@ -2,48 +2,3 @@ doctor:
   -
     case: "校验接口返回成功case"
     assert_error: 0
-    assert_id: "ad99d0b0b6eb4a2c97ffadad48b7cdfd"
-    assert_name: "赵希军"
-    assert_good_at: "吸脂瘦身"
-    assert_cases: "自体脂肪填充面部 80例"
-    assert_title: "副主任"
-  -
-    case: "校验医生id case"
-    assert_error: 0
-    assert_id: "ad99d0b0b6eb4a2c97ffadad48b7cdfd"
-    assert_name: "赵希军"
-    assert_good_at: "吸脂瘦身"
-    assert_cases: "自体脂肪填充面部 80例"
-    assert_title: "副主任"
-  -
-    case: "校验医生名称case"
-    assert_error: 0
-    assert_id: "ad99d0b0b6eb4a2c97ffadad48b7cdfd"
-    assert_name: "赵希军"
-    assert_good_at: "吸脂瘦身"
-    assert_cases: "自体脂肪填充面部 80例"
-    assert_title: "副主任"
-  -
-    case: "校验医生明星项目case"
-    assert_error: 0
-    assert_id: "ad99d0b0b6eb4a2c97ffadad48b7cdfd"
-    assert_name: "赵希军"
-    assert_good_at: "吸脂瘦身"
-    assert_cases: "自体脂肪填充面部 80例"
-    assert_title: "副主任"
-  -
-    case: "校验医生案例case"
-    assert_error: 0
-    assert_id: "ad99d0b0b6eb4a2c97ffadad48b7cdfd"
-    assert_name: "赵希军"
-    assert_good_at: "吸脂瘦身"
-    assert_cases: "自体脂肪填充面部 80例"
-    assert_title: "副主任"
-  -
-    case: "校验医生title case"
-    assert_error: 0
-    assert_id: "ad99d0b0b6eb4a2c97ffadad48b7cdfd"
-    assert_name: "赵希军"
-    assert_good_at: "吸脂瘦身"
-    assert_cases: "自体脂肪填充面部 80例"
-    assert_title: "副主任"
\ No newline at end of file

test_backend_data/hybrid_data/api_topic_vote.yaml

@@ -5,8 +5,7 @@ diary_vote:
     id: 21249958
     topic_id: 21249958
     assert1:  0
-    assert2: "请登录后再试"
-    assert3: "已经赞过啦"
+
 
 
 

test_backend_data/hybrid_data/basewiki_item.yaml

@@ -2,5 +2,5 @@ basewiki_item:
   -
   #百科详情页-项目百科，水光针
     case: "百科详情页-项目百科，水光针"
-    version: "744.0"
+    version: "7.44.0"
     assert: 水光针
\ No newline at end of file

test_backend_data/hybrid_data/basewiki_product.yaml

@@ -2,5 +2,5 @@ basewiki_product:
   -
   #百科详情页-药品（仪器、材料）百科，菲洛嘉
     case: "百科详情页-药品（仪器、材料）百科，菲洛嘉"
-    version: "744.0"
+    version: "7.44.0"
     assert: 菲洛嘉
\ No newline at end of file

test_backend_data/hybrid_data/diary_album.yaml

@@ -2,8 +2,8 @@ diary_album:
   #进入日记本相册case--无须字段
   -
     case: "进入日记本相册case"
-    assert: false
-    assert2: true
+    assert: 0
+
 
 
 #

test_backend_data/janus_data/beauty_card_detail.yaml

 beauty_card_detail:
   #次卡商详页
   -
-    case: "次卡商详页spuid=100018"
+    case: "次卡商详页spuid=1025"
     assert: 0
-    spu_id: 100018
-    sku_id: 10046
-    welfareId: 100018
+    spu_id: 1025
+    sku_id: 11110
+    welfareId: 1025
     version: 7.44.0
     current_city_id: beijing
     lat: 40.001879
     lng: 116.487194
 
   -
-    case: "次卡商详页spuid=100021"
+    case: "次卡商详页spuid=1025"
     assert: 0
-    spu_id: 100021
-    sku_id: 10159
-    welfareId: 100021
+    spu_id: 1025
+    sku_id: 11111
+    welfareId: 1025
     version: 7.44.0
     current_city_id: beijing
     lat: 40.001879

test_doctor_case/glmer_case/test_service_detail.py

-import pytest
-
-import path_setting
-from all_doctor_api.glmer_request import glmer_request
-from ids_list import get_ids
-from in_common.base_request import BaseRequest
-
-
-class TestServiceDetail:
-    service_detail = BaseRequest().api_load(path_setting.DETAIL_DATA)
-    ServiceDetail_case, ServiceDetail_data = get_ids(service_detail, "service_detail")
-
-    @pytest.mark.parametrize("params",ServiceDetail_data,ids=ServiceDetail_case)
-    def test_ServiceDetail(self,params):
-
-        r =glmer_request().service_detail()
-        print("------",r)
-        if r["code"] == 0:
-            assert r["code"] == params["assert"]

test_doctor_case/glmer_case/test_service_register.py

-import pytest
-
-import path_setting
-from all_doctor_api.glmer_request import glmer_request
-from ids_list import get_ids
-from in_common.base_request import BaseRequest
-
-
-class TestServiceRegister:
-    service_register = BaseRequest().api_load(path_setting.REGISTER_DATA)
-    ServiceRegister_case, ServiceRegister_data = get_ids(service_register, "service_register")
-
-    @pytest.mark.parametrize("params",ServiceRegister_data,ids=ServiceRegister_case)
-    def test_ServiceRegister(self,params):
-
-        r =glmer_request().service_register(params['name'],params['project_type'],params['upgrade'],params['short_description'],params['doctor_id'],params['start_time'],params['end_time'],params['photo_details'],params['image_header'],params['video_token'],params['service_type'],params['is_specialreview'],params['reservation'],params['have_extra_pay'],params['is_draft'],params['items'],params['csrfmiddlewaretoken'])
-
-        if r["code"] == 0:
-            assert r["code"] == params["assert"]
-        # elif r["error"] == 1:
-        #     assert r["message"] == params["assert"]

test_doctor_case/glmer_case/test_tag_properties.py

-import pytest
-
-import path_setting
-from all_doctor_api.glmer_request import glmer_request
-from ids_list import get_ids
-from in_common.base_request import BaseRequest
-
-
-class TestTagProperties:
-    tag_properties = BaseRequest().api_load(path_setting.PROPERTIES_DATA)
-    TagProperties_case, TagProperties_data = get_ids(tag_properties, "tag_properties")
-
-    @pytest.mark.parametrize("params",TagProperties_data,ids=TagProperties_case)
-    def test_TagProperties(self,params):
-
-        r =glmer_request().tag_properties(params['catalog_ids'])
-        print("------",r)
-        if r["error"] == 0:
-            assert r["error"] == params["assert"]

test_doctor_case/web2_case/test_artemis_ad_add_shopping_cart_info.py

-import pytest
-
-from ids_list import get_ids
-import path_setting
-from in_common.base_request import BaseRequest
-from all_doctor_api.web2_request import web2_request
-
-
-class TestArtemisAdAddShoppingCartInfo:
-    data = BaseRequest().api_load(path_setting.ADADDSHOPPINGCARTINFO)
-    adaddshoppingcartinfo_case, adaddshoppingcartinfo_data = get_ids(data, "artemis_ad_add_shopping_cart_info")
-
-
-    @pytest.mark.parametrize("param",adaddshoppingcartinfo_data,ids=adaddshoppingcartinfo_case)
-    def test_artemis_ad_add_shopping_cart_info(self, param):
-        '''我的购物车列表'''
-        r = web2_request().artemis_ad_add_shopping_cart_info()
-        if r["error"] == 0:
-            data = r.get("data").get("data", [])
-            assert len(data) >= param["assert"]
-
-
-

test_doctor_case/web2_case/test_artemis_add_value_order_id_detail.py

-import pytest
-
-from ids_list import get_ids
-import path_setting
-from in_common.base_request import BaseRequest
-from all_doctor_api.web2_request import web2_request
-
-
-class TestArtemisAddValueOrderIdDetail:
-    data = BaseRequest().api_load(path_setting.VALUEORDERIDDETAIL)
-    addvalueorderiddetail_case, addvalueorderiddetail_data = get_ids(data, "artemis_add_value_order_id_detail")
-
-
-    @pytest.mark.parametrize("param",addvalueorderiddetail_data,ids=addvalueorderiddetail_case)
-    def test_artemis_add_value_order_id_detail(self, param):
-        '''我的服务订单-已购买'''
-        r = web2_request().artemis_add_value_order_id_detail()
-        if r["error"] == 0:
-            assert r["data"]["status"] == param["assert"]
-
-
-

test_doctor_case/web2_case/test_service_delete.py

-import pytest
-
-import path_setting
-from all_doctor_api.web2_request import web2_request
-from ids_list import get_ids
-from in_common.base_request import BaseRequest
-
-
-class TestServiceDelete:
-    service_delete=BaseRequest().api_load(path_setting.DELETE_DATA)
-
-    ServiceDelete_case, ServiceDeletet_data = get_ids(service_delete, "service_delete")
-
-    @pytest.mark.parametrize("params", ServiceDeletet_data, ids=ServiceDelete_case)
-
-    def test_ServiceDelete(self, params):
-
-        r = web2_request().service_delete(params['is_delete'], params['service_register_id'], params['csrfmiddlewaretoken'])
-        print("======", r)
-
-        if r["error"] == 0:
-            assert r["error"] == params["assert"]
-        # elif r["error"] == 1:
-        #     assert r["message"] == params["assert"]

test_doctor_case/web2_case/test_service_deletelist.py

-import pytest
-
-import path_setting
-from all_doctor_api.web2_request import web2_request
-from ids_list import get_ids
-from in_common.base_request import BaseRequest
-
-
-class TestServiceDeletelist:
-    service_deletelist = BaseRequest().api_load(path_setting.DELETELIST_DATA)
-    ServiceDeletelist_case, ServiceDeletelist_data = get_ids(service_deletelist, "service_deletelist")
-
-    @pytest.mark.parametrize("params" ,ServiceDeletelist_data ,ids=ServiceDeletelist_case)
-    def test_ServiceDeletelist(self ,params):
-
-        r = web2_request().service_deletelist(params['page'])
-        print("======" ,r)
-
-        # if r["error"] == 0:
-        #     assert r["error"] == params["assert"]
-

test_doctor_case/web2_case/test_service_list.py

-import pytest
-
-import path_setting
-from all_doctor_api.web2_request import web2_request
-from ids_list import get_ids
-from in_common.base_request import BaseRequest
-
-
-class TestServiceList:
-    service_list = BaseRequest().api_load(path_setting.SERVICE_DATA)
-    ServiceList_case, ServiceList_data = get_ids(service_list, "service_list")
-    
-    @pytest.mark.parametrize("params",ServiceList_data,ids=ServiceList_case)
-    def test_ServiceList(self,params):
-
-        r = web2_request().service_list(params['page'],params['pagesize'],params['is_online'],params['extra_filter_choice'])
-        print("======",r)
-
-        if r["error"] == 0:
-            assert r["data"]["page"] == params["assert"]
-        elif r["error"] == 1:
-            assert r["message"] == params["assert"]
-       # else:
-          #  assert r['error'] == 0
-
-
-

test_doctor_case/web2_case/test_service_review_list.py

-import pytest
-
-import path_setting
-from all_doctor_api.web2_request import web2_request
-from ids_list import get_ids
-from in_common.base_request import BaseRequest
-
-
-class TestServiceReviewList:
-
-    service_review_list = BaseRequest().api_load(path_setting.SERVICE_REVIEW_DATA)
-    ServiceReviewList_case, ServiceReviewList_data = get_ids(service_review_list, "service_review_list")
-
-    @pytest.mark.parametrize("params", ServiceReviewList_data, ids=ServiceReviewList_case)
-    def test_ServiceReviewList(self, params):
-
-        r = web2_request().service_review_list(params['page'], params['pagesize'], params['type'])
-        print("--------",r)
-
-        if r["error"] == 0:
-            assert r["data"]["page"] == params["assert"]
-        # elif r["error"] == 1:
-        #     assert r["message"] == params["assert"]
\ No newline at end of file

test_doctor_case/web2_case/test_servicereview_option.py

-import pytest
-
-import path_setting
-from all_doctor_api.web2_request import web2_request
-from ids_list import get_ids
-from in_common.base_request import BaseRequest
-
-
-class TestServicereviewOption:
-
-    servicereview_option = BaseRequest().api_load(path_setting.SERVICEREVIEW_OPTION_DATA)
-    ServicereviewOption_case, ServicereviewOption_data = get_ids(servicereview_option, "servicereview_option")
-
-    @pytest.mark.parametrize("params", ServicereviewOption_data, ids=ServicereviewOption_case)
-    def test_ServicereviewOption(self, params):
-
-        r = web2_request().servicereview_option(params['id'], params['type'], params['csrfmiddlewaretoken'])
-        print("--------",r)
-
-        if r["error"] == 0:
-            assert r["error"] == params["assert"]
-        print("....")
-
-        # elif r["error"] == 1:
-        #     assert r["data"] == params["assert"]
\ No newline at end of file

test_doctor_case/web2_case/test_tag_all.py

-import pytest
-
-import path_setting
-from all_doctor_api.web2_request import web2_request
-from ids_list import get_ids
-from in_common.base_request import BaseRequest
-
-
-class TestTagAll:
-
-    tag_all = BaseRequest().api_load(path_setting.TAG_DATA)
-    TagAll_case, TagAll_data = get_ids(tag_all, "tag_all")
-
-    @pytest.mark.parametrize("param", TagAll_data, ids=TagAll_case)
-    def test_TagAll(self, param):
-
-        r = web2_request().tag_all()
-        print("--------",r)
-
-        if r["error"] == 0:
-            assert r["error"] == param["assert"]
-
-        # elif r["error"] == 1:
-        #     assert r["data"] == params["assert"]
\ No newline at end of file

test_doctor_case/web_case/test_account_unreadbadgecount.py

-import pytest
-
-import path_setting
-from all_doctor_api.web_request import web_request
-from ids_list import get_ids
-from in_common.base_request import BaseRequest
-
-
-class TestAccountUnreadbadgecount:
-
-    account_unreadbadgecount = BaseRequest().api_load(path_setting.ACCOUNT_DATA)
-    AccountUnreadbadgecount_case, AccountUnreadbadgecount_data = get_ids(account_unreadbadgecount, "account_unreadbadgecount")
-
-    @pytest.mark.parametrize("param",AccountUnreadbadgecount_data,ids=AccountUnreadbadgecount_case)
-    def test_AccountUnreadbadgecount(self,param):
-
-        r = web_request().account_unreadbadgecount()
-        print("=====",r)
-        if r["error"] == 0:
-            assert r["error"] == param["assert"]
-        # elif r["error"] == 1:
-        #     assert r["message"] == params["assert"]
\ No newline at end of file

test_doctor_case/web_case/test_artemis_ad_type_list.py

-import pytest
-
-from ids_list import get_ids
-import path_setting
-from in_common.base_request import BaseRequest
-from all_doctor_api.web_request import web_request
-
-
-class TestArtemisAdTypeList:
-    data = BaseRequest().api_load(path_setting.ADTYPELIST)
-    adtypelist_case, adtypelist_data = get_ids(data, "artemis_ad_type_list")
-
-
-    @pytest.mark.parametrize("param",adtypelist_data,ids=adtypelist_case)
-    def test_artemis_ad_type_list(self, param):
-        '''服务资源列表'''
-        r = web_request().artemis_ad_type_list()
-        if r["error"] == 0:
-            adtypes = r.get("data").get("adtypes", [])
-            assert len(adtypes) >= param["assert"]
-

test_doctor_case/web_case/test_artemis_order_id_detail.py

-import pytest
-
-from ids_list import get_ids
-import path_setting
-from in_common.base_request import BaseRequest
-from all_doctor_api.web_request import web_request
-
-
-class TestArtemisOrderIdDetail:
-    data = BaseRequest().api_load(path_setting.ORDERIDDETAIL)
-    orderiddetail_case, orderiddetail_data = get_ids(data, "artemis_order_id_detail")
-
-
-    @pytest.mark.parametrize("param",orderiddetail_data,ids=orderiddetail_case)
-    def test_artemis_order_id_detail(self, param):
-        '''我的服务订单'''
-        r = web_request().artemis_order_id_detail()
-        if r["error"] == 0:
-            assert r["data"]["detail_type"] == param["assert_detail_type"]
-            assert r["data"]["status"] == param["assert_status"]
-
-
-
-

test_doctor_case/web_case/test_artemis_order_list.py

-import pytest
-
-from ids_list import get_ids
-import path_setting
-from in_common.base_request import BaseRequest
-from all_doctor_api.web_request import web_request
-
-
-class TestArtemisOrderList:
-    data = BaseRequest().api_load(path_setting.ORDERLIST)
-    orderlist_case, orderlist_data = get_ids(data, "artemis_order_list")
-
-
-    @pytest.mark.parametrize("param",orderlist_data,ids=orderlist_case)
-    def test_artemis_order_list(self, param):
-        '''我的服务订单'''
-        r = web_request().artemis_order_list(param["status"], param["page"])
-        if r["error"] == 0:
-            orders = r.get("data").get("orders", [])
-            assert len(orders) >= param["assert"]
-

test_doctor_case/web_case/test_article_videotoken.py

-import pytest
-
-import path_setting
-from all_doctor_api.web_request import web_request
-from ids_list import get_ids
-from in_common.base_request import BaseRequest
-
-
-class TestArticleVideotoken:
-
-    article_videotoken = BaseRequest().api_load(path_setting.ARTICLE_DATA)
-    ArticleVideotoken_case, ArticleVideotoken_data = get_ids(article_videotoken, "article_videotoken")
-
-    @pytest.mark.parametrize("param",ArticleVideotoken_data,ids=ArticleVideotoken_case)
-    def test_ArticleVideotokent(self,param):
-
-        r = web_request().article_videotoken()
-        print("=======",r)
-        if r["error"] == 0:
-            assert r["error"] == param["assert"]
-        # elif r["error"] == 1:
-        #     assert r["message"] == params["assert"]
\ No newline at end of file

test_doctor_case/web_case/test_conversation.py

-import pytest
-
-from ids_list import get_ids
-import path_setting
-from in_common.base_request import BaseRequest
-from all_doctor_api.web_request import web_request
-
-
-class TestConversation:
-    data = BaseRequest().api_load(path_setting.CONVERSATION)
-    conversation_case, conversation_data = get_ids(data, "conversation")
-
-
-    @pytest.mark.parametrize("param",conversation_data,ids=conversation_case)
-    def test_conversation(self, param):
-        '''全部私信列表'''
-        r = web_request().conversation(param["is_star"], param["page"])
-        if r["error"] == 0:
-            conversation = r.get("data").get("conversation", [])
-            assert len(conversation) <= param["assert"]
-            assert r["data"]["size"] <= param["assert_size"]
-

test_doctor_case/web_case/test_conversation_coupon.py

-import pytest
-
-from ids_list import get_ids
-import path_setting
-from in_common.base_request import BaseRequest
-from all_doctor_api.web_request import web_request
-
-
-class TestService:
-    data = BaseRequest().api_load(path_setting.CONVERSATIONCOUPON)
-    conversationcoupon_case, conversationcoupon_data = get_ids(data, "conversation_coupon")
-
-
-    @pytest.mark.parametrize("param",conversationcoupon_data,ids=conversationcoupon_case)
-    def test_conversation_coupon(self, param):
-        '''发送美券按钮'''
-        r = web_request().conversation_coupon(param["doctor_user_id"])
-        if r["error"] == 0:
-            data1 = r.get("data", [])
-            assert len(data1) >= param["assert"]

test_doctor_case/web_case/test_conversation_diary.py

-import pytest
-
-from ids_list import get_ids
-import path_setting
-from in_common.base_request import BaseRequest
-from all_doctor_api.web_request import web_request
-
-
-class TestConversationDiary:
-    data = BaseRequest().api_load(path_setting.CONVERSATIONDIARY)
-    conversationdiary_case, conversationdiary_data = get_ids(data, "conversation_diary")
-
-
-    @pytest.mark.parametrize("param",conversationdiary_data,ids=conversationdiary_case)
-    def test_conversation_diary(self, param):
-        '''点击发送案例按钮'''
-        r = web_request().conversation_diary(param["doctor_user_id"])
-        print(r)
-        if r["error"] == 0:
-            data = r.get("data", [])
-            assert len(data) >= param["assert"]
-

test_doctor_case/web_case/test_conversation_unread_list.py

-import pytest
-
-from ids_list import get_ids
-import path_setting
-from in_common.base_request import BaseRequest
-from all_doctor_api.web_request import web_request
-
-
-class TestConversationUnreadList:
-    data = BaseRequest().api_load(path_setting.CONVERSATIONUNREADLIST)
-    unreadlist_case, unreadlist_data = get_ids(data, "conversation_unread_list")
-
-
-    @pytest.mark.parametrize("param",unreadlist_data,ids=unreadlist_case)
-    def test_conversation_unread_list(self, param):
-        '''未读私信列表'''
-        r = web_request().conversation_unread_list(param["page"])
-        if r["error"] == 0:
-            conversation = r.get("data").get("conversation", [])
-            assert len(conversation) <= param["assert"]
-            assert r["data"]["size"] <= param["assert_size"]
-

test_doctor_case/web_case/test_conversation_user_id.py

-import pytest
-
-from ids_list import get_ids
-import path_setting
-from in_common.base_request import BaseRequest
-from all_doctor_api.web_request import web_request
-
-
-class TestConversationUserID:
-    data = BaseRequest().api_load(path_setting.CONVERSATIONUSERID)
-    userid_case, userid_data = get_ids(data, "conversation_user_id")
-
-
-    @pytest.mark.parametrize("param",userid_data,ids=userid_case)
-    def test_conversation_user_id(self, param):
-        '''发送私信'''
-        r = web_request().conversation_user_id(param["type"], param["content"], param["doctor_user_id"], param["t"], param["csrfmiddlewaretoken"])
-        print(r)
-        if r["error"] == 0:
-            assert r["data"]["name"] == param["assert_name"]
-            assert r["message"] == param["assert_message"]
-
-        if r["error"] == 300009:
-            assert r["message"] == param["assert_message1"]
-
-       # if r["error"] == 300005:
-         #   assert r["message"] == param["assert_message2"]#assert_message2: "该方法未经授权，无法访问"
-
-
-
-
-

test_doctor_case/web_case/test_cpc_homepage.py

-import pytest
-
-from ids_list import get_ids
-import path_setting
-from in_common.base_request import BaseRequest
-from all_doctor_api.web_request import web_request
-
-
-class TestCpcHomepage:
-    data = BaseRequest().api_load(path_setting.CPCHOMEPAGE)
-    cpchomepage_case, cpchomepage_data = get_ids(data, "cpc_homepage")
-
-
-    @pytest.mark.parametrize("param",cpchomepage_data,ids=cpchomepage_case)
-    def test_cpc_homepage(self, param):
-        '''点点通-概览'''
-        r = web_request().cpc_homepage()
-        if r["error"] == 0:
-            if r["data"]["account"] <= "0":
-                assert r["data"]["is_cpc"] == param["assert"]
-            else:
-                assert r["data"]["is_cpc"] == param["assert1"]
-

test_doctor_case/web_case/test_doctor_submechanisms.py

-import pytest
-
-import path_setting
-from all_doctor_api.web_request import web_request
-from ids_list import get_ids
-from in_common.base_request import BaseRequest
-
-
-class TestDoctorSubmechanisms:
-
-    doctor_submechanisms = BaseRequest().api_load(path_setting.DOCTOR_DATA)
-    DoctorSubmechanisms_case, DoctorSubmechanisms_data = get_ids(doctor_submechanisms, "doctor_submechanisms")
-
-    @pytest.mark.parametrize("param",DoctorSubmechanisms_data,ids=DoctorSubmechanisms_case)
-    def test_DoctorSubmechanisms_data(self,param):
-
-        r = web_request().doctor_submechanisms()
-        print("=======",r)
-        if r["error"] == 0:
-            assert r["error"] == param["assert"]
-        # elif r["error"] == 1:
-        #     assert r["message"] == params["assert"]
\ No newline at end of file

test_doctor_case/web_case/test_service.py

-import pytest
-
-from ids_list import get_ids
-import path_setting
-from in_common.base_request import BaseRequest
-from all_doctor_api.web_request import web_request
-
-
-class TestService:
-    data = BaseRequest().api_load(path_setting.SERVICE)
-    service_case, service_data = get_ids(data, "service")
-
-
-    @pytest.mark.parametrize("param",service_data,ids=service_case)
-    def test_service(self, param):
-        '''未读私信列表'''
-        r = web_request().service()
-        if r["error"] == 0:
-            data = r.get("data").get("data", [])
-            assert len(data) <= param["assert"]
-            assert r["data"]["size"] <= param["assert_size"]
-

test_doctor_case/web_case/test_service_all.py

-import pytest
-
-import path_setting
-from all_doctor_api.web_request import web_request
-from ids_list import get_ids
-from in_common.base_request import BaseRequest
-
-
-class TestServiceAll:
-
-    service_all = BaseRequest().api_load(path_setting.SERVICEALL_DATA)
-    ServiceAll_case, ServiceAll_data = get_ids(service_all, "service_all")
-
-    @pytest.mark.parametrize("param",ServiceAll_data,ids=ServiceAll_case)
-    def test_ServiceAll(self,param):
-
-        r = web_request().service_all()
-        print("=====",r)
-        if r["error"] == 0:
-            assert r["error"] == param["assert"]
\ No newline at end of file

test_doctor_case/web_case/test_service_offline.py

-import pytest
-
-import path_setting
-from all_doctor_api.web_request import web_request
-from ids_list import get_ids
-from in_common.base_request import BaseRequest
-
-
-class TestServiceOffline:
-
-    service_offline = BaseRequest().api_load(path_setting.OFFLINE_DATA)
-    ServiceOffline_case, ServiceOffline_data = get_ids(service_offline, "service_offline")
-
-    @pytest.mark.parametrize("params",ServiceOffline_data,ids=ServiceOffline_case)
-    def test_ServiceOffline_data(self,params):
-
-        r = web_request().service_offline(params['id'],params['csrfmiddlewaretoken'])
-        print("=======",r)
-        if r["error"] == 0:
-            assert r["error"] == params["assert"]

test_doctor_data/glmer_data/service_detail.yaml

-service_detail:
-  -
-    case:  "编辑商品-进入商品详情页 "
-    assert: 0

test_doctor_data/glmer_data/service_register.yaml

-service_register:
-#我的商品菜单下有数据返回1
-  -
-    case:  "发布（新增）商品-保存商品"
-    name: "激光溶脂瘦脸"
-    project_type: "[236]"
-    upgrade: "true"
-    short_description: "测试"
-    doctor_id: "wangyang"
-    start_time: "1624377600"
-    end_time: "1627660800"
-    photo_details: "<p>12</p>"
-    image_header: "https://heras.igengmei.com/service/2021/06/01/0b9b110e60"
-    video_token: "UPCOYIJkZOMcdd9FDzpBqYjzWUh55fBpVi3AhWpL:nBdvXYz_CR7wNcuroo3TLyvuQiY=:eyJzY29wZSI6InZpZGVvIiwiZGVhZGxpbmUiOjE2MjI1MTg2NTd9"
-    service_type: "0"
-    is_specialreview: "false"
-    reservation: "1"
-    have_extra_pay: "false"
-    is_draft: "0"
-    items: '[{"gengmei_price":100,"original_price":200,"is_online":true}]'
-    csrfmiddlewaretoken: "PC8uTySuxipukIMuqNV1OPB376C2ZZ3g"
-    assert: 0
-
-

test_doctor_data/glmer_data/tag_properties.yaml

-tag_properties:
-  -
-    case:  "我的商品-编辑可标准化商品 "
-    catalog_ids: "[115,141]"
-    assert: 0

test_doctor_data/web2_data/artemis_ad_add_shopping_cart_info.yaml

-artemis_ad_add_shopping_cart_info:
-  #我的购物车case
-  -
-    case: "我的购物车"
-    assert: 0

test_doctor_data/web2_data/artemis_add_value_order_id_detail.yaml

-artemis_add_value_order_id_detail:
-  #已购买case
-  -
-    case: "已购买"
-    assert: "已购买"

test_doctor_data/web2_data/service_delete.yaml

-service_delete:
-#我的商品-删除下线商品
-  -
-    case:  "我的商品-删除下线商品"
-    is_delete: "1"
-    service_register_id: "209863"
-    csrfmiddlewaretoken: "PC8uTySuxipukIMuqNV1OPB376C2ZZ3g"
-    assert: 0

test_doctor_data/web2_data/service_deletelist.yaml

-service_deletelist:
-#我的商品-商品回收站
-  -
-    case:  "我的商品-商品回收站"
-    page: "1"
-    assert: 0
\ No newline at end of file

test_doctor_data/web2_data/service_list.yaml

-service_list:
-#我的商品菜单下有数据返回1
-  -
-    case:  "我的商品-全部tab"
-    page: "1"
-    pagesize: "10"
-    is_online: "-1"
-    extra_filter_choice: "-1"
-    assert: 1
-
-
-  -
-    case:  "我的商品-上线tab"
-    page: "1"
-    pagesize: "10"
-    is_online: "-1"
-    extra_filter_choice: "-1"
-    assert: 1
-
-
-  -
-    case:  "我的商品-下线tab"
-    page: "1"
-    pagesize: "10"
-    is_online: "0"
-    extra_filter_choice: "-1"
-    assert: 1
-
-
-  -
-    case:  "我的商品-待升级（全部tab）"
-    page: "1"
-    pagesize: "10"
-    is_online: "-1"
-    extra_filter_choice: "0"
-    assert: 1
-
-
-
-  -
-    case:  "我的商品-待修改类目（全部tab）有数据返回"
-    page: "1"
-    pagesize: "10"
-    is_online: "-1"
-    extra_filter_choice: "1"
-    assert: 1
-

test_doctor_data/web2_data/service_review_list.yaml

-service_review_list:
-#有数据返回
-  -
-    case:  "商品审核-新商品审核 "
-    page: "1"
-    pagesize: "10"
-    type: "0"
-    assert: 1
-
-
-  -
-    case:  "商品审核-商品修改审核"
-    page: "1"
-    pagesize: "10"
-    type: "1"
-    assert: 1
-
-
-  -
-    case:  "商品审核-新商品审核"
-    page: "1"
-    pagesize: "10"
-    type: "2"
-    assert: 1
-
-

test_doctor_data/web2_data/servicereview_option.yaml

-servicereview_option:
-#有数据返回
-  -
-    case:  "新商品审核-撤回审核"
-    id: "209989"
-    type: "1"
-    csrfmiddlewaretoken: "PC8uTySuxipukIMuqNV1OPB376C2ZZ3g"
-    assert: 0
-
-
-  -
-    case:  "新商品审核-取消申请"
-    id: "209744"
-    type: "0"
-    csrfmiddlewaretoken: "PC8uTySuxipukIMuqNV1OPB376C2ZZ3g"
-    assert: 0
-
-
-  -
-    case:  "商品修改审核-撤回审核 "
-    id: "209866"
-    type: "1"
-    csrfmiddlewaretoken: "PC8uTySuxipukIMuqNV1OPB376C2ZZ3g"
-    assert: 0
-
-
-  -
-    case:  "新商品审核-取消申请"
-    id: "209996"
-    type: "0"
-    csrfmiddlewaretoken: "PC8uTySuxipukIMuqNV1OPB376C2ZZ3g"
-    assert: 0

test_doctor_data/web2_data/tag_all.yaml

-tag_all:
-  -
-    case:  "发布商品-选择类目跳转发布商品页面tag接口 "
-    assert: 0
\ No newline at end of file

test_doctor_data/web_data/account_unreadbadgecount.yaml

-account_unreadbadgecount:
-  -
-    case:  "发布商品-选择类目跳转发布商品页面account接口 "
-    assert: 0
\ No newline at end of file

test_doctor_data/web_data/artemis_ad_type_list.yaml

-artemis_ad_type_list:
-  #服务资源case
-  -
-    case: "服务资源"
-    assert: 0
-    assert_account: 0
-    assert1: True

test_doctor_data/web_data/artemis_order_id_detail.yaml

-artemis_order_id_detail:
-  #已上线订单服务订单详情页case
-  -
-    case: "已上线订单服务订单详情页case"
-    assert_status: 3
-    assert_detail_type: 6

test_doctor_data/web_data/artemis_order_list.yaml

-artemis_order_list:
-  #我的服务订单case
-  -
-    case: "我的服务订单请求失败case"
-    status: ""
-    page: 1
-    assert: 0
-  -
-    case: "我的服务订单-待支付广告包case"
-    status: 0
-    page: 1
-    assert: 0
-  -
-    case: "我的服务订单-已购买case"
-    status: 1
-    page: 1
-    assert: 0
-  -
-    case: "我的服务订单-待审核case"
-    status: 2
-    page: 1
-    assert: 0
-  -
-    case: "我的服务订单-待上线case"
-    status: 3
-    page: 1
-    assert: 0
-  -
-    case: "我的服务订单-上线中case"
-    status: 4
-    page: 1
-    assert: 0
-  -
-    case: "我的服务订单-已下线case"
-    status: 5
-    page: 1
-    assert: 0
-  -
-    case: "我的服务订单-已支付广告包case"
-    status: 6
-    page: 1
-    assert: 0
-  -
-    case: "我的服务订单-已关闭广告包case"
-    status: 7
-    page: 1
-    assert: 0

test_doctor_data/web_data/article_videotoken.yaml

-article_videotoken:
-  -
-    case:  "发布商品-选择类目跳转发布商品页面article接口 "
-    assert: 0
\ No newline at end of file

test_doctor_data/web_data/conversation.yaml

-conversation:
-  #全部私信case
-  -
-    case: "请求成功，有数据返回的第一页数据"
-    is_star: 0
-    page: 1
-    assert_size: 10
-    assert: 10

test_doctor_data/web_data/conversation_coupon.yaml

-conversation_coupon:
-  #私信点击发送优惠券case
-  -
-    case: "点击私信发送优惠券按钮"
-    doctor_user_id: "602329"
-    assert: 0
-  -
-    case: "点击私信发送优惠券按钮接口报错"
-    doctor_user_id: "602329"
-    assert: 0
-    assert_message: '缺少参数: doctor_user_id'
-    assert_data: None

test_doctor_data/web_data/conversation_diary.yaml

-conversation_diary:
-  #私信点击发送案例case
-  -
-    case: "点击私信发送案例按钮"
-    doctor_user_id: 602329
-    assert: 0

test_doctor_data/web_data/conversation_unread_list.yaml

-conversation_unread_list:
-  #未读私信case
-  -
-    case: "请求成功，有未读消息"
-    page: 1
-    assert_size: 10
-    assert: 10

test_doctor_data/web_data/conversation_user_id.yaml

-conversation_user_id:
-  #发送私信case
-  -
-    case: "发送成功"
-    type: 0
-    content: 您好
-    doctor_user_id: 602329
-    t: 271caac2ae1687ca0a56ee18115b8183
-    csrfmiddlewaretoken:  NLeTxEx1BOQo1zjv2us9BQ00ViMAHGpJ
-    assert_message: "消息发送成功"
-    assert_name: "露露2"
-
-  - case: "发送失败"
-    type: 0
-    content: 您好
-    doctor_user_id: 6023291
-    t: 271caac2ae1687ca0a56ee18115b8183
-    csrfmiddlewaretoken:  NLeTxEx1BOQo1zjv2us9BQ00ViMAHGpJ
-    assert_message1: "没有权限！"
-    assert_name1: "露露2"
-

test_doctor_data/web_data/cpc_homepage.yaml

-cpc_homepage:
-  #点点通商品-概览case
-  -
-    case: "点点通商品概览"
-    #doctor_user_id: "602329"
-    assert: False
-    assert_account: 0
-    assert1: True

test_doctor_data/web_data/doctor_submechanisms.yaml

-doctor_submechanisms:
-  -
-    case:  "发布商品-选择类目跳转发布商品页面doctor接口 "
-    assert: 0
\ No newline at end of file

test_doctor_data/web_data/service.yaml

-service:
-  #私信点击发送商品case
-  -
-    case: "点击私信发送商品按钮"
-    #page: 1
-    assert_size: 10
-    assert: 10

test_doctor_data/web_data/service_all.yaml

-service_all:
-
-  -
-    case: "编辑商品、上线商品"
-    assert: 0
\ No newline at end of file

test_doctor_data/web_data/service_offline.yaml

-service_offline:
-  -
-    case:  "我的商品-下线商品"
-    id: 209992
-    csrfmiddlewaretoken: PC8uTySuxipukIMuqNV1OPB376C2ZZ3g
-    assert: 0

test_om_case/beautycard_case/test_check_sku_ids.py

-import pytest
-
-import path_setting
-from all_om_api.beautycard_request import beautycard_request
-from ids_list import get_ids
-from in_common.base_request import BaseRequest
-
-#更美次卡-按次卡sku_id导入，导入校验
-class TestCheckSkuIds:
-    data = BaseRequest().api_load(path_setting.CHECK_SKU_IDS)
-    check_sku_ids_case, check_sku_ids_data = get_ids(data, "check_sku_ids")
-
-    @pytest.mark.parametrize("param",check_sku_ids_data,ids=check_sku_ids_case)
-    def test_check_sku_ids(self,param):
-        r = beautycard_request().check_sku_ids(param["sku_ids"])
-        if r["code"] == 0:
-            if r["data"][0]["status"] == 1:
-                print("成功导入次卡")
-                assert r["data"][0]["reason"] == param["assert"]
-            else:
-                print("次卡不能成功导入")
-                assert r["data"][0]["reason"] == param["assert"]
-        if r["code"] == 1:
-            print("接口有误")
\ No newline at end of file

test_om_case/beautycard_case/test_check_spu_ids.py

-import pytest
-
-import path_setting
-from all_om_api.beautycard_request import beautycard_request
-from ids_list import get_ids
-from in_common.base_request import BaseRequest
-
-#更美次卡-按次卡spu_id导入，导入校验
-class TestCheckSpuIds:
-    data = BaseRequest().api_load(path_setting.CHECK_SPU_IDS)
-    check_spu_ids_case, check_spu_ids_data = get_ids(data, "check_spu_ids")
-
-    @pytest.mark.parametrize("param",check_spu_ids_data,ids=check_spu_ids_case)
-    def test_check_spu_ids(self,param):
-        r = beautycard_request().check_spu_ids(param["spu_ids"])
-        if r["code"] == 0:
-            if r["data"][0]["status"] == 1:
-                print("成功导入次卡")
-                assert r["data"][0]["reason"] == param["assert"]
-            else:
-                print("次卡不能成功导入")
-                assert r["data"][0]["reason"] == param["assert"]
-        if r["code"] == 1:
-            print("接口有误")
\ No newline at end of file

test_om_case/beautycard_case/test_delete_related_bc.py

-import pytest
-
-import path_setting
-from all_om_api.beautycard_request import beautycard_request
-from ids_list import get_ids
-from in_common.base_request import BaseRequest
-
-#更美次卡-删除/批量删除已添加页面次卡
-class TestDeleteRelatedBc:
-    data = BaseRequest().api_load(path_setting.DELETE_RELATED_BC)
-    delete_related_bc_case, delete_related_bc_data = get_ids(data, "delete_related_bc")
-
-    @pytest.mark.parametrize("param",delete_related_bc_data,ids=delete_related_bc_case)
-    def test_delete_related_bc(self,param):
-        r = beautycard_request().delete_related_bc(param["unit_id"], param["bc_sku_ids"], param["bc_spu_ids"], param["related_type"])
-        if r["code"] == 0:
-            print("成功删除已添加页面次卡")
-            assert r["data"] == param["assert"]
-        if r["code"] == 1:
-            print("未删除已添加页面次卡")
\ No newline at end of file

test_om_case/beautycard_case/test_export_related_bc.py

-import pytest
-
-import path_setting
-from all_om_api.beautycard_request import beautycard_request
-from ids_list import get_ids
-from in_common.base_request import BaseRequest
-
-#更美次卡-获取已添加页面次卡spu/sku列表
-class TestExportRelatedBc:
-    data = BaseRequest().api_load(path_setting.EXPORT_RELATED_BC)
-    export_related_bc_case, export_related_bc_data = get_ids(data, "export_related_bc")
-
-    @pytest.mark.parametrize("param",export_related_bc_data,ids=export_related_bc_case)
-    def test_export_related_bc(self,param):
-        r = beautycard_request().export_related_bc(param["unit_id"], param["bc_sku_id"], param["bc_spu_id"])
-        if r["data"]:
-            print("成功导出已添加页面次卡信息")
-            assert len(r["data"]["beauty_cards"]) != param["assert"]
-        if not r["data"]:
-            print("未导出已添加页面次卡信息")
\ No newline at end of file

test_om_case/beautycard_case/test_get_related_bc.py

-import pytest
-
-import path_setting
-from all_om_api.beautycard_request import beautycard_request
-from ids_list import get_ids
-from in_common.base_request import BaseRequest
-
-#更美次卡-获取已添加页面次卡spu/sku列表
-class TestGetRelatedBc:
-    data = BaseRequest().api_load(path_setting.GET_RELATED_BC)
-    get_related_bc_case, get_related_bc_data = get_ids(data, "get_related_bc")
-
-    @pytest.mark.parametrize("param",get_related_bc_data,ids=get_related_bc_case)
-    def test_get_related_bc(self,param):
-        r = beautycard_request().get_related_bc(param["unit_id"], param["bc_sku_id"], param["bc_spu_id"], param["page"], param["page_size"])
-        if r["data"]:
-            print("成功获取已添加页面次卡spu/sku列表")
-            assert len(r["data"]["beauty_cards"]) != param["assert"]
-        if not r["data"]:
-            print("未获取到已添加页面次卡spu/sku列表")
\ No newline at end of file

test_om_case/beautycard_case/test_update_bc_rank.py

-import pytest
-
-import path_setting
-from all_om_api.beautycard_request import beautycard_request
-from ids_list import get_ids
-from in_common.base_request import BaseRequest
-
-#更美次卡-更改次卡排序
-class TestUpdateBcRank:
-    data = BaseRequest().api_load(path_setting.UPDATE_BC_RANK)
-    update_bc_rank_case, update_bc_rank_data = get_ids(data, "update_bc_rank")
-
-    @pytest.mark.parametrize("param",update_bc_rank_data,ids=update_bc_rank_case)
-    def test_update_bc_rank(self,param):
-        r = beautycard_request().update_bc_rank(param["unit_id"], param["related_id"], param["related_type"], param["rank"])
-        if r["code"] == 0:
-            print("成功修改已添加页面该次卡排序")
-            assert r["data"] == param["assert"]
-        if r["code"] == 1:
-            print("未能修改已添加页面该次卡排序")
\ No newline at end of file

test_om_case/om_login_case/test_om_login.py

-import pytest
-
-import path_setting
-from all_om_api.login_request import login_request
-from ids_list import get_ids
-from in_common.base_request import BaseRequest
-
-#om后台-登录
-class TestOmLogin:
-    data = BaseRequest().api_load(path_setting.OMLOGIN)
-    om_login_case, om_login_data = get_ids(data, "om_login")
-
-    @pytest.mark.parametrize("param",om_login_data,ids=om_login_case)
-    def test_om_login(self,param):
-        r = login_request().om_login(param["username"], param["password"])
-        if r["code"] == 0:
-            print("om后台成功登陆")
-            assert r["msg"] == param["assert"]
-        if r["code"] != 0:
-            print("om后台登陆出错")
-            assert r["msg"] == param["assert"]
\ No newline at end of file

test_om_data/beautycard_data/check_sku_ids.yaml

-#更美次卡-按次卡sku_id导入，导入校验
-check_sku_ids:
-  #按SKU导入-导入单条数据，导入成功
-  -
-    case : "按SKU导入-导入单条数据，导入成功"
-    sku_ids : '[{"import_id":"10066","rank":0,"row":1}]'
-    assert : ''
-
-  #按SKU导入-导入单条数据，ID不存在
-  - case: "按SKU导入-导入单条数据，ID不存在"
-    sku_ids: '[{"import_id":"100666","rank":0,"row":1}]'
-    assert: ID不存在
-
-  #按SKU导入-导入单条数据，暂无适用机构
-  - case: "按SKU导入-导入单条数据，暂无适用机构"
-    sku_ids: '[{"import_id":"10023","rank":0,"row":1}]'
-    assert: 暂无适用机构
-
-  #按SKU导入-导入单条数据，已下线
-  - case: "按SKU导入-导入单条数据，已下线"
-    sku_ids: '[{"import_id":"10022","rank":0,"row":1}]'
-    assert: 已下线
-
-  #按SKU导入-导入单条数据，ID格式错误
-  - case: "按SKU导入-导入单条数据，ID格式错误"
-    sku_ids: '[{"import_id":"我","rank":0,"row":1}]'
-    assert: ID格式错误
-
-  #按SKU导入-导入多条数据，导入成功
-  -
-    case : "按SKU导入-导入多条数据，导入成功"
-    sku_ids : '[{"import_id":"10242","rank":0,"row":1},{"import_id":"10243","rank":0,"row":1},{"import_id":"10244","rank":0,"row":1}]'
-    assert : ''
\ No newline at end of file

test_om_data/beautycard_data/check_spu_ids.yaml

-#更美次卡-按次卡spu_id导入，导入校验
-check_spu_ids:
-  #按SPU导入-导入单条数据，导入成功
-  -
-    case : "按SPU导入-导入单条数据，导入成功"
-    spu_ids : '[{"import_id":"100052","rank":0,"row":1}]'
-    assert : ''
-
-  #按SPU导入-导入单条数据，ID不存在
-  - case: "按SPU导入-导入单条数据，ID不存在"
-    spu_ids: '[{"import_id":"1000522","rank":0,"row":1}]'
-    assert: ID不存在
-
-  #按SPU导入-导入单条数据，暂无适用机构
-  - case: "按SPU导入-导入单条数据，暂无适用机构"
-    spu_ids: '[{"import_id":"100022","rank":0,"row":1}]'
-    assert: 暂无适用机构
-
-  #按SPU导入-导入单条数据，已下线
-  - case: "按SPU导入-导入单条数据，已下线"
-    spu_ids: '[{"import_id":"100035","rank":0,"row":1}]'
-    assert: 已下线
-
-  #按SPU导入-导入单条数据，ID格式错误
-  - case: "按SPU导入-导入单条数据，ID格式错误"
-    spu_ids: '[{"import_id":"我","rank":0,"row":1}]'
-    assert: ID格式错误
-
-  #按SPU导入-导入多条数据，导入成功
-  -
-    case : "按SPU导入-导入多条数据，导入成功"
-    spu_ids : '[{"import_id":"100055","rank":1,"row":1},{"import_id":"100056","rank":2,"row":1},{"import_id":"100057","rank":3,"row":1}]'
-    assert : ''
\ No newline at end of file

test_om_data/beautycard_data/delete_related_bc.yaml

-#更美次卡-删除/批量删除已添加页面次卡
-delete_related_bc:
-  #按SPU导入-已添加页面删除单条数据
-  -
-    case : "按SPU导入-已添加页面删除单条数据"
-    unit_id : "19896"
-    bc_sku_ids : "[]"
-    bc_spu_ids : "[28]"
-    related_type : "7"
-    assert: 1
-
-  #按SPU导入-已添加页面删除多条数据
-  -
-    case : "按SPU导入-已添加页面删除多条数据"
-    unit_id : "19896"
-    bc_sku_ids : "[]"
-    bc_spu_ids : "[30,31,33]"
-    related_type : "7"
-    assert: 3
-
-  #按SKU导入-已添加页面删除单条数据
-  -
-    case : "按SKU导入-已添加页面删除单条数据"
-    unit_id : "19933"
-    bc_sku_ids : "[10144]"
-    bc_spu_ids : "[]"
-    related_type : "8"
-    assert: 1
-
-  #按SKU导入-已添加页面删除多条数据
-  -
-    case : "按SKU导入-已添加页面删除多条数据"
-    unit_id : "19933"
-    bc_sku_ids : "[10141,10142]"
-    bc_spu_ids : "[]"
-    related_type : "8"
-    assert: 2
\ No newline at end of file

test_om_data/beautycard_data/export_related_bc.yaml

-#更美次卡-已添加页面全部导出
-export_related_bc:
-  #按SPU导入-已添加页面全部导出功能
-  -
-    case : "按SPU导入-已添加页面全部导出功能"
-    unit_id : "19896"
-    bc_sku_id : ""
-    bc_spu_id : ""
-    assert: 0
-
-  #按SKU导入-已添加页面全部导出功能
-  -
-    case : "按SKU导入-已添加页面全部导出功能"
-    unit_id : "19933"
-    bc_sku_id : ""
-    bc_spu_id : ""
-    assert: 0
\ No newline at end of file

test_om_data/beautycard_data/get_related_bc.yaml

-#更美次卡-获取已添加页面次卡spu/sku列表
-get_related_bc:
-  #按SPU导入-根据专题id获取已添加页面次卡spu列表
-  -
-    case : "按SPU导入-根据专题id获取已添加页面次卡spu列表"
-    unit_id : "20105"
-    bc_sku_id : ""
-    bc_spu_id : ""
-    page : "0"
-    page_size : "10"
-    assert: 0
-
-  #按SPU导入-根据专题和次卡spu_id获取已添加页面次卡spu列表
-  -
-    case : "按SPU导入-根据专题和次卡spu_id获取已添加页面次卡spu列表"
-    unit_id : "20105"
-    bc_sku_id : ""
-    bc_spu_id : "100023"
-    page : "0"
-    page_size : "10"
-    assert: 0
-
-  #按SKU导入-根据专题id获取已添加页面次卡spu列表
-  -
-    case : "按SKU导入-根据专题id获取已添加页面次卡spu列表"
-    unit_id : "20106"
-    bc_sku_id : ""
-    bc_spu_id : ""
-    page : "0"
-    page_size : "10"
-    assert: 0
-
-  #按SKU导入-根据专题和次卡spu_id获取已添加页面次卡spu列表
-  -
-    case : "按SKU导入-根据专题和次卡spu_id获取已添加页面次卡spu列表"
-    unit_id : "20106"
-    bc_sku_id : ""
-    bc_spu_id : "100023"
-    page : "0"
-    page_size : "10"
-    assert: 0
-
-  #按SKU导入-根据专题和次卡sku_id获取已添加页面次卡spu和sku列表
-  -
-    case : "按SKU导入-根据专题和次卡sku_id获取已添加页面次卡spu和sku列表"
-    unit_id : "20106"
-    bc_sku_id : "10066"
-    bc_spu_id : ""
-    page : "0"
-    page_size : "10"
-    assert: 0
-
-  #按SKU导入-根据专题和次卡spu_id、sku_id获取已添加页面次卡spu和sku列表
-  -
-    case : "按SKU导入-根据专题和次卡spu_id、sku_id获取已添加页面次卡spu和sku列表"
-    unit_id : "20106"
-    bc_sku_id : "10066"
-    bc_spu_id : "100023"
-    page : "0"
-    page_size : "10"
-    assert: 0
-
-  #按SPU导入-录入错误的spu_id，点击查询
-  -
-    case : "录入错误的spu_id，点击查询"
-    unit_id : "20105"
-    bc_sku_id : ""
-    bc_spu_id : "1111111111111"
-    page : "0"
-    page_size : "10"
-    assert: 0
-
-  #按SKU导入-录入错误的sku_id，点击查询
-  -
-    case : "录入错误的sku_id，点击查询"
-    unit_id : "20106"
-    bc_sku_id : "111111111111"
-    bc_spu_id : ""
-    page : "0"
-    page_size : "10"
-    assert: 0
\ No newline at end of file

test_om_data/beautycard_data/update_bc_rank.yaml

-#更美次卡-更改次卡排序
-update_bc_rank:
-  #按SPU导入-更改次卡排序
-  -
-    case : "按SPU导入-更改次卡排序"
-    unit_id : "20105"
-    related_id : "100023"
-    related_type : "7"
-    rank : "77"
-    assert: 1
-
-  #按SKU导入-更改次卡排序
-  -
-    case: "按SKU导入-更改次卡排序"
-    unit_id: "20106"
-    related_id: "10065"
-    related_type: "8"
-    rank: "11"
-    assert: 1
\ No newline at end of file

test_om_data/om_login_data/om_login.yaml

-om_login:
-  #om后台-登录-输入正确的用户名和正确的密码
-  -
-    case : "om后台-登录-输入正确的用户名和密码"
-    username : "admin"
-    password : "123123"
-    assert: success!
-
-  #om后台-登录-输入正确的用户名和错误的密码
-  -
-    case : "om后台-登录-输入正确的用户名和错误的密码"
-    username : "admin"
-    password : "1231234"
-    assert: Login failed!
-
-  #om后台-登录-输入正确的用户名和不输入密码
-  -
-    case : "om后台-登录-输入正确的用户名和不输入密码"
-    username : "admin"
-    password : ""
-    assert: Login failed!
-
-  #om后台-登录-输入正确的用户名和无效密码
-  -
-    case : "om后台-登录-输入正确的用户名和无效密码"
-    username : "admin"
-    password : "哈哈"
-    assert: Login failed!
-
-  #om后台-登录-输入错误的用户名和正确的密码
-  -
-    case : "om后台-登录-输入错误的用户名和正确的密码"
-    username : "admin1"
-    password : "123123"
-    assert: Login failed!
-
-  #om后台-登录-不输入用户名和输入正确的密码
-  -
-    case : "om后台-登录-不输入用户名和输入正确的密码"
-    username : ""
-    password : "123123"
-    assert: Login failed!
-
-  #om后台-登录-输入无效用户名和正确的密码
-  -
-    case : "om后台-登录-输入无效用户名和正确的密码"
-    username : "哈哈"
-    password : "123123"
-    assert: Login failed!
-
-  #om后台-登录-输入错误的用户名和输入错误的密码
-  -
-    case : "om后台-登录-输入错误的用户名和输入错误的密码"
-    username : "admin1"
-    password : "1231234"
-    assert: Login failed!
-
-  #om后台-登录-不输入用户名和密码
-  -
-    case : "om后台-登录-不输入用户名和密码"
-    username : ""
-    password : ""
-    assert: Login failed!
-
-
-
-