package weapp
import (
"encoding/base64"
"encoding/json"
"net/http"
"net/http/httptest"
"strings"
"testing"
)
func TestAbnormalConfirm(t *testing.T) {
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
t.Error("UnExpect request method")
}
if r.URL.EscapedPath() != "/cgi-bin/express/local/business/order/confirm_return" {
t.Error("Unexpected path")
}
if err := r.ParseForm(); err != nil {
t.Fatal(err)
}
if r.Form.Get("access_token") == "" {
t.Fatalf("access_token can not be empty")
}
params := struct {
ShopID string `json:"shopid"` // 商家id， 由配送公司分配的appkey
ShopOrderID string `json:"shop_order_id"` // 唯一标识订单的 ID，由商户生成
ShopNo string `json:"shop_no"` // 商家门店编号， 在配送公司登记，如果只有一个门店，可以不填
DeliverySign string `json:"delivery_sign"` // 用配送公司提供的appSecret加密的校验串
WaybillID string `json:"waybill_id"` // 配送单id
Remark string `json:"remark"` // 备注
}{}
if err := json.NewDecoder(r.Body).Decode(¶ms); err != nil {
t.Fatal(err)
}
if params.ShopID == "" {
t.Error("Response column shopid can not be empty")
}
if params.ShopOrderID == "" {
t.Error("Response column shop_order_id can not be empty")
}
if params.ShopNo == "" {
t.Error("Response column shop_no can not be empty")
}
if params.DeliverySign == "" {
t.Error("Response column delivery_sign can not be empty")
}
if params.WaybillID == "" {
t.Error("Response column waybill_id can not be empty")
}
if params.Remark == "" {
t.Error("Response column remark can not be empty")
}
w.WriteHeader(http.StatusOK)
raw := `{
"errcode": 1,
"errmsg": "ok"
}`
if _, err := w.Write([]byte(raw)); err != nil {
t.Fatal(err)
}
}))
defer ts.Close()
raw := `{
"shopid": "123456",
"shop_order_id": "123456",
"shop_no": "shop_no_111",
"waybill_id": "123456",
"remark": "remark",
"delivery_sign": "123456"
}`
confirmer := new(AbnormalConfirmer)
err := json.Unmarshal([]byte(raw), confirmer)
if err != nil {
t.Fatal(err)
}
_, err = confirmer.confirm(ts.URL+apiAbnormalConfirm, "mock-access-token")
if err != nil {
t.Fatal(err)
}
}
func TestAddDeliveryOrder(t *testing.T) {
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
t.Error("UnExpect request method")
}
if r.URL.EscapedPath() != "/cgi-bin/express/local/business/order/add" {
t.Error("Unexpected path")
}
if err := r.ParseForm(); err != nil {
t.Fatal(err)
}
if r.Form.Get("access_token") == "" {
t.Fatalf("access_token can not be empty")
}
params := struct {
DeliveryToken string `json:"delivery_token"` // 预下单接口返回的参数，配送公司可保证在一段时间内运费不变
ShopID string `json:"shopid"` // 商家id， 由配送公司分配的appkey
ShopOrderID string `json:"shop_order_id"` // 唯一标识订单的 ID，由商户生成
ShopNo string `json:"shop_no"` // 商家门店编号， 在配送公司登记，如果只有一个门店，可以不填
DeliverySign string `json:"delivery_sign"` // 用配送公司提供的appSecret加密的校验串
DeliveryID string `json:"delivery_id"` // 配送公司ID
OpenID string `json:"openid"` // 下单用户的openid
SubBizID string `json:"sub_biz_id"` // 子商户id，区分小程序内部多个子商户
Sender struct {
Name string `json:"name"` // 姓名，最长不超过256个字符
City string `json:"city"` // 城市名称，如广州市
Address string `json:"address"` // 地址(街道、小区、大厦等，用于定位)
AddressDetail string `json:"address_detail"` // 地址详情(楼号、单元号、层号)
Phone string `json:"phone"` // 电话/手机号，最长不超过64个字符
Lng float64 `json:"lng"` // 经度（火星坐标或百度坐标，和 coordinate_type 字段配合使用，确到小数点后6位
Lat float64 `json:"lat"` // 纬度（火星坐标或百度坐标，和 coordinate_type 字段配合使用，精确到小数点后6位）
CoordinateType uint8 `json:"coordinate_type"` // 坐标类型，0：火星坐标（高德，腾讯地图均采用火星坐标） 1：百度坐标
} `json:"sender"` // 发件人信息，闪送、顺丰同城急送必须填写，美团配送、达达，若传了shop_no的值可不填该字段
Receiver struct {
Name string `json:"name"` // 姓名，最长不超过256个字符
City string `json:"city"` // 城市名称，如广州市
Address string `json:"address"` // 地址(街道、小区、大厦等，用于定位)
AddressDetail string `json:"address_detail"` // 地址详情(楼号、单元号、层号)
Phone string `json:"phone"` // 电话/手机号，最长不超过64个字符
Lng float64 `json:"lng"` // 经度（火星坐标或百度坐标，和 coordinate_type 字段配合使用，确到小数点后6位
Lat float64 `json:"lat"` // 纬度（火星坐标或百度坐标，和 coordinate_type 字段配合使用，精确到小数点后6位）
CoordinateType uint8 `json:"coordinate_type"` // 坐标类型，0：火星坐标（高德，腾讯地图均采用火星坐标） 1：百度坐标
} `json:"receiver"` // 收件人信息
Cargo struct {
GoodsValue float64 `json:"goods_value"` // 货物价格，单位为元，精确到小数点后两位（如果小数点后位数多于两位，则四舍五入保留两位小数），范围为(0-5000]
GoodsHeight float64 `json:"goods_height"` // 货物高度，单位为cm，精确到小数点后两位（如果小数点后位数多于两位，则四舍五入保留两位小数），范围为(0-45]
GoodsLength float64 `json:"goods_length"` // 货物长度，单位为cm，精确到小数点后两位（如果小数点后位数多于两位，则四舍五入保留两位小数），范围为(0-65]
GoodsWidth float64 `json:"goods_width"` // 货物宽度，单位为cm，精确到小数点后两位（如果小数点后位数多于两位，则四舍五入保留两位小数），范围为(0-50]
GoodsWeight float64 `json:"goods_weight"` // 货物重量，单位为kg，精确到小数点后两位（如果小数点后位数多于两位，则四舍五入保留两位小数），范围为(0-50]
GoodsDetail struct {
Goods []struct {
Count uint `json:"good_count"` // 货物数量
Name string `json:"good_name"` // 货品名称
Price float32 `json:"good_price"` // 货品单价，精确到小数点后两位（如果小数点后位数多于两位，则四舍五入保留两位小数）
Unit string `json:"good_unit"` // 货品单位，最长不超过20个字符
} `json:"goods"` // 货物交付信息，最长不超过100个字符
} `json:"goods_detail"` // 货物详情，最长不超过10240个字符
GoodsPickupInfo string `json:"goods_pickup_info"` // 货物取货信息，用于骑手到店取货，最长不超过100个字符
GoodsDeliveryInfo string `json:"goods_delivery_info"` // 货物交付信息，最长不超过100个字符
CargoFirstClass string `json:"cargo_first_class"` // 品类一级类目
CargoSecondClass string `json:"cargo_second_class"` // 品类二级类目
} `json:"cargo"` // 货物信息
OrderInfo struct {
DeliveryServiceCode string `json:"delivery_service_code"` // 配送服务代码 不同配送公司自定义,微信侧不理解
OrderType uint8 `json:"order_type"` // 订单类型, 0: 即时单 1 预约单，如预约单，需要设置expected_delivery_time或expected_finish_time或expected_pick_time
ExpectedDeliveryTime uint `json:"expected_delivery_time"` // 期望派单时间(顺丰同城急送、达达、支持)，unix-timestamp
ExpectedFinishTime uint `json:"expected_finish_time"` // 期望送达时间(顺丰同城急送、美团配送支持），unix-timestamp
ExpectedPickTime uint `json:"expected_pick_time"` // 期望取件时间（闪送支持），unix-timestamp
PoiSeq string `json:"poi_seq"` // 门店订单流水号，建议提供，方便骑手门店取货，最长不超过32个字符
Note string `json:"note"` // 备注，最长不超过200个字符
OrderTime uint `json:"order_time"` // 用户下单付款时间
IsInsured uint8 `json:"is_insured"` // 是否保价，0，非保价，1.保价
DeclaredValue float64 `json:"declared_value"` // 保价金额，单位为元，精确到分
Tips float64 `json:"tips"` // 小费，单位为元, 下单一般不加小费
IsDirectDelivery uint `json:"is_direct_delivery"` // 是否选择直拿直送（0：不需要；1：需要。选择直拿直送后，同一时间骑手只能配送此订单至完成，配送费用也相应高一些，闪送必须选1，达达可选0或1，其余配送公司不支持直拿直送）
CashOnDelivery uint `json:"cash_on_delivery"` // 骑手应付金额，单位为元，精确到分
CashOnPickup uint `json:"cash_on_pickup"` // 骑手应收金额，单位为元，精确到分
RiderPickMethod uint8 `json:"rider_pick_method"` // 物流流向，1：从门店取件送至用户；2：从用户取件送至门店
IsFinishCodeNeeded uint8 `json:"is_finish_code_needed"` // 收货码（0：不需要；1：需要。收货码的作用是：骑手必须输入收货码才能完成订单妥投）
IsPickupCodeNeeded uint8 `json:"is_pickup_code_needed"` // 取货码（0：不需要；1：需要。取货码的作用是：骑手必须输入取货码才能从商家取货）
} `json:"order_info"` // 订单信息
Shop struct {
WxaPath string `json:"wxa_path"` // 商家小程序的路径，建议为订单页面
ImgURL string `json:"img_url"` // 商品缩略图 url
GoodsName string `json:"goods_name"` // 商品名称
GoodsCount uint `json:"goods_count"` // 商品数量
} `json:"shop"` // 商品信息，会展示到物流通知消息中
}{}
if err := json.NewDecoder(r.Body).Decode(¶ms); err != nil {
t.Fatal(err)
}
if params.DeliveryToken == "" {
t.Error("Response column 'delivery_token' can not be empty")
}
if params.ShopID == "" {
t.Error("Response column 'shopid' can not be empty")
}
if params.ShopOrderID == "" {
t.Error("Response column 'shop_order_id' can not be empty")
}
if params.ShopNo == "" {
t.Error("Response column 'shop_no' can not be empty")
}
if params.DeliverySign == "" {
t.Error("Response column 'delivery_sign' can not be empty")
}
if params.DeliveryID == "" {
t.Error("Response column 'delivery_id' can not be empty")
}
if params.OpenID == "" {
t.Error("Response column 'openid' can not be empty")
}
if params.SubBizID == "" {
t.Error("Response column 'sub_biz_id' can not be empty")
}
if params.Sender.Name == "" {
t.Error("Param 'sender.name' can not be empty")
}
if params.Sender.City == "" {
t.Error("Param 'sender.city' can not be empty")
}
if params.Sender.Address == "" {
t.Error("Param 'sender.address' can not be empty")
}
if params.Sender.AddressDetail == "" {
t.Error("Param 'sender.address_detail' can not be empty")
}
if params.Sender.Phone == "" {
t.Error("Param 'sender.phone' can not be empty")
}
if params.Sender.Lng == 0 {
t.Error("Param 'sender.lng' can not be empty")
}
if params.Sender.Lat == 0 {
t.Error("Param 'sender.lat' can not be empty")
}
if params.Sender.CoordinateType == 0 {
t.Error("Param 'sender.coordinate_type' can not be empty")
}
if params.Receiver.Name == "" {
t.Error("Param 'receiver.name' can not be empty")
}
if params.Receiver.City == "" {
t.Error("Param 'receiver.city' can not be empty")
}
if params.Receiver.Address == "" {
t.Error("Param 'receiver.address' can not be empty")
}
if params.Receiver.AddressDetail == "" {
t.Error("Param 'receiver.address_detail' can not be empty")
}
if params.Receiver.Phone == "" {
t.Error("Param 'receiver.phone' can not be empty")
}
if params.Receiver.Lng == 0 {
t.Error("Param 'receiver.lng' can not be empty")
}
if params.Receiver.Lat == 0 {
t.Error("Param 'receiver.lat' can not be empty")
}
if params.Receiver.CoordinateType == 0 {
t.Error("Param 'receiver.coordinate_type' can not be empty")
}
if params.Cargo.GoodsValue == 0 {
t.Error("Param 'cargo.goods_value' can not be empty")
}
if params.Cargo.GoodsHeight == 0 {
t.Error("Param 'cargo.goods_height' can not be empty")
}
if params.Cargo.GoodsLength == 0 {
t.Error("Param 'cargo.goods_length' can not be empty")
}
if params.Cargo.GoodsWidth == 0 {
t.Error("Param 'cargo.goods_width' can not be empty")
}
if params.Cargo.GoodsWeight == 0 {
t.Error("Param 'cargo.goods_weight' can not be empty")
}
if params.Cargo.CargoFirstClass == "" {
t.Error("Param 'cargo.cargo_first_class' can not be empty")
}
if params.Cargo.CargoSecondClass == "" {
t.Error("Param 'cargo.cargo_second_class' can not be empty")
}
if len(params.Cargo.GoodsDetail.Goods) > 0 {
if params.Cargo.GoodsDetail.Goods[0].Count == 0 {
t.Error("Param 'cargo.goods_detail.goods.good_count' can not be empty")
}
if params.Cargo.GoodsDetail.Goods[0].Name == "" {
t.Error("Param 'cargo.goods_detail.goods.good_name' can not be empty")
}
if params.Cargo.GoodsDetail.Goods[0].Price == 0 {
t.Error("Param 'cargo.goods_detail.goods.good_price' can not be empty")
}
if params.Cargo.GoodsDetail.Goods[0].Unit == "" {
t.Error("Param 'cargo.goods_detail.goods.good_unit' can not be empty")
}
}
if params.OrderInfo.DeliveryServiceCode == "" {
t.Error("Param 'order_info.delivery_service_code' can not be empty")
}
if params.Shop.WxaPath == "" {
t.Error("Param 'shop.wxa_path' can not be empty")
}
if params.Shop.ImgURL == "" {
t.Error("Param 'shop.img_url' can not be empty")
}
if params.Shop.GoodsName == "" {
t.Error("Param 'shop.goods_name' can not be empty")
}
if params.Shop.GoodsCount == 0 {
t.Error("Param 'shop.goods_count' can not be empty")
}
w.WriteHeader(http.StatusOK)
raw := `{
"resultcode": 1,
"resultmsg": "ok",
"fee": 11,
"deliverfee": 11,
"couponfee": 1,
"tips": 1,
"insurancefee": 1000,
"insurancfee": 1,
"distance": 1001,
"waybill_id": "123456789",
"order_status": 101,
"finish_code": 1024,
"pickup_code": 2048,
"dispatch_duration": 300
}`
if _, err := w.Write([]byte(raw)); err != nil {
t.Fatal(err)
}
}))
defer ts.Close()
raw := `{
"cargo": {
"cargo_first_class": "美食宵夜",
"cargo_second_class": "零食小吃",
"goods_detail": {
"goods": [
{
"good_count": 1,
"good_name": "水果",
"good_price": 11,
"good_unit": "元"
},
{
"good_count": 2,
"good_name": "蔬菜",
"good_price": 21,
"good_unit": "元"
}
]
},
"goods_height": 1,
"goods_length": 3,
"goods_value": 5,
"goods_weight": 1,
"goods_width": 2
},
"delivery_id": "SFTC",
"delivery_sign": "01234567890123456789",
"openid": "oABC123456",
"order_info": {
"delivery_service_code": "xxx",
"expected_delivery_time": 1,
"is_direct_delivery": 1,
"is_finish_code_needed": 1,
"is_insured": 1,
"is_pickup_code_needed": 1,
"note": "test_note",
"order_time": 1555220757,
"order_type": 1,
"poi_seq": "1111",
"tips": 0
},
"receiver": {
"address": "xxx地铁站",
"address_detail": "2号楼202",
"city": "北京市",
"coordinate_type": 1,
"lat": 40.1529600001,
"lng": 116.5060300001,
"name": "老王",
"phone": "18512345678"
},
"sender": {
"address": "xx大厦",
"address_detail": "1号楼101",
"city": "北京市",
"coordinate_type": 1,
"lat": 40.4486120001,
"lng": 116.3830750001,
"name": "刘一",
"phone": "13712345678"
},
"shop": {
"goods_count": 2,
"goods_name": "宝贝",
"img_url": "https://mmbiz.qpic.cn/mmbiz_png/xxxxxxxxx/0?wx_fmt=png",
"wxa_path": "/page/index/index"
},
"shop_no": "12345678",
"sub_biz_id": "sub_biz_id_1",
"shop_order_id": "SFTC_001",
"shopid": "122222222",
"delivery_token": "xxxxxxxx"
}`
creator := new(DeliveryOrderCreator)
err := json.Unmarshal([]byte(raw), creator)
if err != nil {
t.Fatal(err)
}
res, err := creator.create(ts.URL+apiAddDeliveryOrder, "mock-access-token")
if err != nil {
t.Fatal(err)
}
if res.Fee == 0 {
t.Error("Response 'fee' can not be empty")
}
if res.Deliverfee == 0 {
t.Error("Response 'deliverfee' can not be empty")
}
if res.Couponfee == 0 {
t.Error("Response 'couponfee' can not be empty")
}
if res.Tips == 0 {
t.Error("Response 'tips' can not be empty")
}
if res.Insurancefee == 0 {
t.Error("Response 'insurancefee' can not be empty")
}
if res.Distance == 0 {
t.Error("Response 'distance' can not be empty")
}
if res.WaybillID == "" {
t.Error("Response 'waybill_id' can not be empty")
}
if res.OrderStatus == 0 {
t.Error("Response 'order_status' can not be empty")
}
if res.FinishCode == 0 {
t.Error("Response 'finish_code' can not be empty")
}
if res.PickupCode == 0 {
t.Error("Response 'pickup_code' can not be empty")
}
if res.DispatchDuration == 0 {
t.Error("Response 'dispatch_duration' can not be empty")
}
if res.ResultCode == 0 {
t.Error("Response 'resultcode' can not be empty")
}
if res.ResultMsg == "" {
t.Error("Response 'resultmsg' can not be empty")
}
}
func TestAddDeliveryTip(t *testing.T) {
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
t.Error("UnExpect request method")
}
if r.URL.EscapedPath() != "/cgi-bin/express/local/business/order/addtips" {
t.Error("Unexpected path")
}
if err := r.ParseForm(); err != nil {
t.Fatal(err)
}
if r.Form.Get("access_token") == "" {
t.Fatalf("Query 'access_token' can not be empty")
}
params := struct {
ShopID string `json:"shopid"`
ShopOrderID string `json:"shop_order_id"`
ShopNo string `json:"shop_no"`
DeliverySign string `json:"delivery_sign"`
WaybillID string `json:"waybill_id"`
OpenID string `json:"openid"`
Tips float64 `json:"tips"`
Remark string `json:"remark"`
}{}
if err := json.NewDecoder(r.Body).Decode(¶ms); err != nil {
t.Fatal(err)
}
if params.ShopID == "" {
t.Error("Param 'shopid' can not be empty")
}
if params.ShopOrderID == "" {
t.Error("Param 'shop_order_id' can not be empty")
}
if params.ShopNo == "" {
t.Error("Param 'shop_no' can not be empty")
}
if params.DeliverySign == "" {
t.Error("Param 'delivery_sign' can not be empty")
}
if params.WaybillID == "" {
t.Error("Param 'waybill_id' can not be empty")
}
if params.OpenID == "" {
t.Error("Param 'openid' can not be empty")
}
if params.Tips == 0 {
t.Error("Param 'tips' can not be empty")
}
if params.Remark == "" {
t.Error("Param 'remark' can not be empty")
}
w.WriteHeader(http.StatusOK)
raw := `{
"resultcode": 1,
"resultmsg": "ok"
}`
if _, err := w.Write([]byte(raw)); err != nil {
t.Fatal(err)
}
}))
defer ts.Close()
raw := `{
"shopid": "123456",
"shop_order_id": "123456",
"waybill_id": "123456",
"tips": 5,
"openid": "mock-open-id",
"remark": "gogogo",
"delivery_sign": "123456",
"shop_no": "shop_no_111"
}`
adder := new(DeliveryTipAdder)
err := json.Unmarshal([]byte(raw), adder)
if err != nil {
t.Fatal(err)
}
res, err := adder.add(ts.URL+apiAddDeliveryTip, "mock-access-token")
if err != nil {
t.Fatal(err)
}
if res.ResultCode == 0 {
t.Error("Response 'resultcode' can not be empty")
}
if res.ResultMsg == "" {
t.Error("Response 'resultmsg' can not be empty")
}
}
func TestCancelDeliveryOrder(t *testing.T) {
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
t.Error("UnExpect request method")
}
if r.URL.EscapedPath() != "/cgi-bin/express/local/business/order/cancel" {
t.Error("Unexpected path")
}
if err := r.ParseForm(); err != nil {
t.Fatal(err)
}
if r.Form.Get("access_token") == "" {
t.Fatalf("Query 'access_token' can not be empty")
}
params := struct {
ShopID string `json:"shopid"` // 商家id， 由配送公司分配的appkey
ShopOrderID string `json:"shop_order_id"` // 唯一标识订单的 ID，由商户生成
ShopNo string `json:"shop_no"` // 商家门店编号， 在配送公司登记，如果只有一个门店，可以不填
DeliverySign string `json:"delivery_sign"` // 用配送公司提供的appSecret加密的校验串
DeliveryID string `json:"delivery_id"` // 快递公司ID
WaybillID string `json:"waybill_id"` // 配送单id
ReasonID uint8 `json:"cancel_reason_id"` // 取消原因Id
Reason string `json:"cancel_reason"` // 取消原因
}{}
if err := json.NewDecoder(r.Body).Decode(¶ms); err != nil {
t.Fatal(err)
}
if params.ShopID == "" {
t.Error("Param 'shopid' can not be empty")
}
if params.ShopOrderID == "" {
t.Error("Param 'shop_order_id' can not be empty")
}
if params.ShopNo == "" {
t.Error("Param 'shop_no' can not be empty")
}
if params.DeliverySign == "" {
t.Error("Param 'delivery_sign' can not be empty")
}
if params.WaybillID == "" {
t.Error("Param 'waybill_id' can not be empty")
}
if params.DeliveryID == "" {
t.Error("Param 'delivery_id' can not be empty")
}
if params.ReasonID == 0 {
t.Error("Param 'cancel_reason_id' can not be empty")
}
if params.Reason == "" {
t.Error("Param 'cancel_reason' can not be empty")
}
w.WriteHeader(http.StatusOK)
raw := `{
"resultcode": 1,
"resultmsg": "ok",
"deduct_fee": 5,
"desc": "blabla"
}`
if _, err := w.Write([]byte(raw)); err != nil {
t.Fatal(err)
}
}))
defer ts.Close()
raw := `{
"shopid": "123456",
"shop_order_id": "123456",
"waybill_id": "123456",
"delivery_id": "123456",
"cancel_reason_id": 1,
"cancel_reason": "mock-cancel-reson",
"delivery_sign": "123456",
"shop_no": "shop_no_111"
}`
canceler := new(DeliveryOrderCanceler)
err := json.Unmarshal([]byte(raw), canceler)
if err != nil {
t.Fatal(err)
}
res, err := canceler.cancel(ts.URL+apiCancelDeliveryOrder, "mock-access-token")
if err != nil {
t.Fatal(err)
}
if res.ResultCode == 0 {
t.Error("Response 'resultcode' can not be empty")
}
if res.ResultMsg == "" {
t.Error("Response 'resultmsg' can not be empty")
}
if res.DeductFee == 0 {
t.Error("Response 'deduct_fee' can not be empty")
}
if res.Desc == "" {
t.Error("Response 'desc' can not be empty")
}
}
func TestGetAllImmediateDelivery(t *testing.T) {
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
t.Error("UnExpect request method")
}
if r.URL.EscapedPath() != "/cgi-bin/express/local/business/delivery/getall" {
t.Error("Unexpected path")
}
if err := r.ParseForm(); err != nil {
t.Fatal(err)
}
if r.Form.Get("access_token") == "" {
t.Fatalf("Query 'access_token' can not be empty")
}
w.WriteHeader(http.StatusOK)
raw := `{
"resultcode": 1,
"resultmsg": "ok",
"list": [
{
"delivery_id": "SFTC",
"delivery_name": "顺发同城"
},
{
"delivery_id": "MTPS",
"delivery_name": "美团配送"
}
]
}`
if _, err := w.Write([]byte(raw)); err != nil {
t.Fatal(err)
}
}))
res, err := getAllImmediateDelivery(ts.URL+apiGetAllImmediateDelivery, "mock-access-token")
if err != nil {
t.Fatal(err)
}
if res.ResultCode == 0 {
t.Error("Response 'resultcode' can not be empty")
}
if res.ResultMsg == "" {
t.Error("Response 'resultmsg' can not be empty")
}
if len(res.List) == 0 {
t.Error("Response 'list' can not be empty")
} else {
for _, item := range res.List {
if item.ID == "" {
t.Error("Response 'list.delivery_id' can not be empty")
}
if item.Name == "" {
t.Error("Response 'list.delivery_name' can not be empty")
}
}
}
}
func TestGetBindAccount(t *testing.T) {
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
t.Error("UnExpect request method")
}
if r.URL.EscapedPath() != "/cgi-bin/express/local/business/shop/get" {
t.Error("Unexpected path")
}
if err := r.ParseForm(); err != nil {
t.Fatal(err)
}
if r.Form.Get("access_token") == "" {
t.Fatalf("Query 'access_token' can not be empty")
}
w.WriteHeader(http.StatusOK)
raw := `{
"resultcode": 1,
"resultmsg": "ok",
"shop_list": [
{
"delivery_id": "SFTC",
"shopid": "123456",
"audit_result": 1
},
{
"delivery_id": "MTPS",
"shopid": "123456",
"audit_result": 1
}
]
}`
if _, err := w.Write([]byte(raw)); err != nil {
t.Fatal(err)
}
}))
res, err := getBindAccount(ts.URL+apiGetDeliveryBindAccount, "mock-access-token")
if err != nil {
t.Fatal(err)
}
if res.ResultCode == 0 {
t.Error("Response 'resultcode' can not be empty")
}
if res.ResultMsg == "" {
t.Error("Response 'resultmsg' can not be empty")
}
if len(res.ShopList) == 0 {
t.Error("Response 'shop_list' can not be empty")
} else {
for _, item := range res.ShopList {
if item.DeliveryID == "" {
t.Error("Response 'shop_list.delivery_id' can not be empty")
}
if item.ShopID == "" {
t.Error("Response 'shop_list.shopid' can not be empty")
}
if item.AuditResult == 0 {
t.Error("Response 'audit_result.shopid' can not be empty")
}
}
}
}
func TestGetDeliveryOrder(t *testing.T) {
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
t.Error("UnExpect request method")
}
if r.URL.EscapedPath() != "/cgi-bin/express/local/business/order/get" {
t.Error("Unexpected path")
}
if err := r.ParseForm(); err != nil {
t.Fatal(err)
}
if r.Form.Get("access_token") == "" {
t.Fatalf("Query 'access_token' can not be empty")
}
params := struct {
ShopID string `json:"shopid"`
ShopOrderID string `json:"shop_order_id"`
ShopNo string `json:"shop_no"`
DeliverySign string `json:"delivery_sign"`
}{}
if err := json.NewDecoder(r.Body).Decode(¶ms); err != nil {
t.Fatal(err)
}
if params.ShopID == "" {
t.Error("Response column shopid can not be empty")
}
if params.ShopOrderID == "" {
t.Error("Response column shop_order_id can not be empty")
}
if params.ShopNo == "" {
t.Error("Response column shop_no can not be empty")
}
if params.DeliverySign == "" {
t.Error("Response column delivery_sign can not be empty")
}
w.WriteHeader(http.StatusOK)
raw := `{
"resultcode": 1,
"resultmsg": "ok",
"order_status": 1,
"waybill_id": "string",
"rider_name": "string",
"rider_phone": "string",
"rider_lng": 3.14,
"rider_lat": 3.14
}`
if _, err := w.Write([]byte(raw)); err != nil {
t.Fatal(err)
}
}))
raw := `{
"shopid": "xxxxxx",
"shop_order_id": "xxxxxx",
"shop_no": "xxxxxx",
"delivery_sign": "xxxxxx"
}`
getter := new(DeliveryOrderGetter)
err := json.Unmarshal([]byte(raw), getter)
if err != nil {
t.Fatal(err)
}
res, err := getter.get(ts.URL+apiGetDeliveryOrder, "mock-access-token")
if err != nil {
t.Fatal(err)
}
if res.ResultCode == 0 {
t.Error("Response 'resultcode' can not be empty")
}
if res.ResultMsg == "" {
t.Error("Response 'resultmsg' can not be empty")
}
if res.WaybillID == "" {
t.Error("Response 'waybill_id' can not be empty")
}
if res.OrderStatus == 0 {
t.Error("Response 'order_status' can not be empty")
}
if res.RiderName == "" {
t.Error("Response 'rider_name' can not be empty")
}
if res.RiderPhone == "" {
t.Error("Response 'rider_phone' can not be empty")
}
if res.RiderLng == 0 {
t.Error("Response 'rider_lng' can not be empty")
}
if res.RiderLat == 0 {
t.Error("Response 'rider_lat' can not be empty")
}
}
func TestMockUpdateDeliveryOrder(t *testing.T) {
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
t.Error("UnExpect request method")
}
if r.URL.EscapedPath() != "/cgi-bin/express/local/business/test_update_order" {
t.Error("Unexpected path")
}
if err := r.ParseForm(); err != nil {
t.Fatal(err)
}
if r.Form.Get("access_token") == "" {
t.Fatalf("Query 'access_token' can not be empty")
}
params := struct {
ShopID string `json:"shopid"`
ShopOrderID string `json:"shop_order_id"`
ActionTime uint `json:"action_time"`
OrderStatus int `json:"order_status"`
ActionMsg string `json:"action_msg"`
}{}
if err := json.NewDecoder(r.Body).Decode(¶ms); err != nil {
t.Fatal(err)
}
if params.ShopID == "" {
t.Error("Response column shopid can not be empty")
}
if params.ShopOrderID == "" {
t.Error("Response column shop_order_id can not be empty")
}
if params.ActionTime == 0 {
t.Error("Response column action_time can not be empty")
}
if params.OrderStatus == 0 {
t.Error("Response column order_status can not be empty")
}
if params.ActionMsg == "" {
t.Error("Response column action_msg can not be empty")
}
w.WriteHeader(http.StatusOK)
raw := `{
"resultcode": 1,
"resultmsg": "ok"
}`
if _, err := w.Write([]byte(raw)); err != nil {
t.Fatal(err)
}
}))
raw := `{
"shopid": "test_shop_id",
"shop_order_id": "xxxxxxxxxxx",
"waybill_id": "xxxxxxxxxxxxx",
"action_time": 12345678,
"order_status": 101,
"action_msg": "xxxxxx"
}`
mocker := new(UpdateDeliveryOrderMocker)
err := json.Unmarshal([]byte(raw), mocker)
if err != nil {
t.Fatal(err)
}
res, err := mocker.mock(ts.URL+apiMockUpdateDeliveryOrder, "mock-access-token")
if err != nil {
t.Fatal(err)
}
if res.ResultCode == 0 {
t.Error("Response 'resultcode' can not be empty")
}
if res.ResultMsg == "" {
t.Error("Response 'resultmsg' can not be empty")
}
}
func TestPreAddDeliveryOrder(t *testing.T) {
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
t.Error("UnExpect request method")
}
if r.URL.EscapedPath() != "/cgi-bin/express/local/business/order/pre_add" {
t.Error("Unexpected path")
}
if err := r.ParseForm(); err != nil {
t.Fatal(err)
}
if r.Form.Get("access_token") == "" {
t.Fatalf("access_token can not be empty")
}
params := struct {
ShopID string `json:"shopid"` // 商家id， 由配送公司分配的appkey
ShopOrderID string `json:"shop_order_id"` // 唯一标识订单的 ID，由商户生成
ShopNo string `json:"shop_no"` // 商家门店编号， 在配送公司登记，如果只有一个门店，可以不填
DeliverySign string `json:"delivery_sign"` // 用配送公司提供的appSecret加密的校验串
DeliveryID string `json:"delivery_id"` // 配送公司ID
OpenID string `json:"openid"` // 下单用户的openid
SubBizID string `json:"sub_biz_id"` // 子商户id，区分小程序内部多个子商户
Sender struct {
Name string `json:"name"` // 姓名，最长不超过256个字符
City string `json:"city"` // 城市名称，如广州市
Address string `json:"address"` // 地址(街道、小区、大厦等，用于定位)
AddressDetail string `json:"address_detail"` // 地址详情(楼号、单元号、层号)
Phone string `json:"phone"` // 电话/手机号，最长不超过64个字符
Lng float64 `json:"lng"` // 经度（火星坐标或百度坐标，和 coordinate_type 字段配合使用，确到小数点后6位
Lat float64 `json:"lat"` // 纬度（火星坐标或百度坐标，和 coordinate_type 字段配合使用，精确到小数点后6位）
CoordinateType uint8 `json:"coordinate_type"` // 坐标类型，0：火星坐标（高德，腾讯地图均采用火星坐标） 1：百度坐标
} `json:"sender"` // 发件人信息，闪送、顺丰同城急送必须填写，美团配送、达达，若传了shop_no的值可不填该字段
Receiver struct {
Name string `json:"name"` // 姓名，最长不超过256个字符
City string `json:"city"` // 城市名称，如广州市
Address string `json:"address"` // 地址(街道、小区、大厦等，用于定位)
AddressDetail string `json:"address_detail"` // 地址详情(楼号、单元号、层号)
Phone string `json:"phone"` // 电话/手机号，最长不超过64个字符
Lng float64 `json:"lng"` // 经度（火星坐标或百度坐标，和 coordinate_type 字段配合使用，确到小数点后6位
Lat float64 `json:"lat"` // 纬度（火星坐标或百度坐标，和 coordinate_type 字段配合使用，精确到小数点后6位）
CoordinateType uint8 `json:"coordinate_type"` // 坐标类型，0：火星坐标（高德，腾讯地图均采用火星坐标） 1：百度坐标
} `json:"receiver"` // 收件人信息
Cargo struct {
GoodsValue float64 `json:"goods_value"` // 货物价格，单位为元，精确到小数点后两位（如果小数点后位数多于两位，则四舍五入保留两位小数），范围为(0-5000]
GoodsHeight float64 `json:"goods_height"` // 货物高度，单位为cm，精确到小数点后两位（如果小数点后位数多于两位，则四舍五入保留两位小数），范围为(0-45]
GoodsLength float64 `json:"goods_length"` // 货物长度，单位为cm，精确到小数点后两位（如果小数点后位数多于两位，则四舍五入保留两位小数），范围为(0-65]
GoodsWidth float64 `json:"goods_width"` // 货物宽度，单位为cm，精确到小数点后两位（如果小数点后位数多于两位，则四舍五入保留两位小数），范围为(0-50]
GoodsWeight float64 `json:"goods_weight"` // 货物重量，单位为kg，精确到小数点后两位（如果小数点后位数多于两位，则四舍五入保留两位小数），范围为(0-50]
GoodsDetail struct {
Goods []struct {
Count uint `json:"good_count"` // 货物数量
Name string `json:"good_name"` // 货品名称
Price float32 `json:"good_price"` // 货品单价，精确到小数点后两位（如果小数点后位数多于两位，则四舍五入保留两位小数）
Unit string `json:"good_unit"` // 货品单位，最长不超过20个字符
} `json:"goods"` // 货物交付信息，最长不超过100个字符
} `json:"goods_detail"` // 货物详情，最长不超过10240个字符
GoodsPickupInfo string `json:"goods_pickup_info"` // 货物取货信息，用于骑手到店取货，最长不超过100个字符
GoodsDeliveryInfo string `json:"goods_delivery_info"` // 货物交付信息，最长不超过100个字符
CargoFirstClass string `json:"cargo_first_class"` // 品类一级类目
CargoSecondClass string `json:"cargo_second_class"` // 品类二级类目
} `json:"cargo"` // 货物信息
OrderInfo struct {
DeliveryServiceCode string `json:"delivery_service_code"` // 配送服务代码 不同配送公司自定义,微信侧不理解
OrderType uint8 `json:"order_type"` // 订单类型, 0: 即时单 1 预约单，如预约单，需要设置expected_delivery_time或expected_finish_time或expected_pick_time
ExpectedDeliveryTime uint `json:"expected_delivery_time"` // 期望派单时间(顺丰同城急送、达达、支持)，unix-timestamp
ExpectedFinishTime uint `json:"expected_finish_time"` // 期望送达时间(顺丰同城急送、美团配送支持），unix-timestamp
ExpectedPickTime uint `json:"expected_pick_time"` // 期望取件时间（闪送支持），unix-timestamp
PoiSeq string `json:"poi_seq"` // 门店订单流水号，建议提供，方便骑手门店取货，最长不超过32个字符
Note string `json:"note"` // 备注，最长不超过200个字符
OrderTime uint `json:"order_time"` // 用户下单付款时间
IsInsured uint8 `json:"is_insured"` // 是否保价，0，非保价，1.保价
DeclaredValue float64 `json:"declared_value"` // 保价金额，单位为元，精确到分
Tips float64 `json:"tips"` // 小费，单位为元, 下单一般不加小费
IsDirectDelivery uint `json:"is_direct_delivery"` // 是否选择直拿直送（0：不需要；1：需要。选择直拿直送后，同一时间骑手只能配送此订单至完成，配送费用也相应高一些，闪送必须选1，达达可选0或1，其余配送公司不支持直拿直送）
CashOnDelivery uint `json:"cash_on_delivery"` // 骑手应付金额，单位为元，精确到分
CashOnPickup uint `json:"cash_on_pickup"` // 骑手应收金额，单位为元，精确到分
RiderPickMethod uint8 `json:"rider_pick_method"` // 物流流向，1：从门店取件送至用户；2：从用户取件送至门店
IsFinishCodeNeeded uint8 `json:"is_finish_code_needed"` // 收货码（0：不需要；1：需要。收货码的作用是：骑手必须输入收货码才能完成订单妥投）
IsPickupCodeNeeded uint8 `json:"is_pickup_code_needed"` // 取货码（0：不需要；1：需要。取货码的作用是：骑手必须输入取货码才能从商家取货）
} `json:"order_info"` // 订单信息
Shop struct {
WxaPath string `json:"wxa_path"` // 商家小程序的路径，建议为订单页面
ImgURL string `json:"img_url"` // 商品缩略图 url
GoodsName string `json:"goods_name"` // 商品名称
GoodsCount uint `json:"goods_count"` // 商品数量
} `json:"shop"` // 商品信息，会展示到物流通知消息中
}{}
if err := json.NewDecoder(r.Body).Decode(¶ms); err != nil {
t.Fatal(err)
}
if params.ShopID == "" {
t.Error("Response column 'shopid' can not be empty")
}
if params.ShopOrderID == "" {
t.Error("Response column 'shop_order_id' can not be empty")
}
if params.ShopNo == "" {
t.Error("Response column 'shop_no' can not be empty")
}
if params.DeliverySign == "" {
t.Error("Response column 'delivery_sign' can not be empty")
}
if params.DeliveryID == "" {
t.Error("Response column 'delivery_id' can not be empty")
}
if params.OpenID == "" {
t.Error("Response column 'openid' can not be empty")
}
if params.SubBizID == "" {
t.Error("Response column 'sub_biz_id' can not be empty")
}
if params.Sender.Name == "" {
t.Error("Param 'sender.name' can not be empty")
}
if params.Sender.City == "" {
t.Error("Param 'sender.city' can not be empty")
}
if params.Sender.Address == "" {
t.Error("Param 'sender.address' can not be empty")
}
if params.Sender.AddressDetail == "" {
t.Error("Param 'sender.address_detail' can not be empty")
}
if params.Sender.Phone == "" {
t.Error("Param 'sender.phone' can not be empty")
}
if params.Sender.Lng == 0 {
t.Error("Param 'sender.lng' can not be empty")
}
if params.Sender.Lat == 0 {
t.Error("Param 'sender.lat' can not be empty")
}
if params.Sender.CoordinateType == 0 {
t.Error("Param 'sender.coordinate_type' can not be empty")
}
if params.Receiver.Name == "" {
t.Error("Param 'receiver.name' can not be empty")
}
if params.Receiver.City == "" {
t.Error("Param 'receiver.city' can not be empty")
}
if params.Receiver.Address == "" {
t.Error("Param 'receiver.address' can not be empty")
}
if params.Receiver.AddressDetail == "" {
t.Error("Param 'receiver.address_detail' can not be empty")
}
if params.Receiver.Phone == "" {
t.Error("Param 'receiver.phone' can not be empty")
}
if params.Receiver.Lng == 0 {
t.Error("Param 'receiver.lng' can not be empty")
}
if params.Receiver.Lat == 0 {
t.Error("Param 'receiver.lat' can not be empty")
}
if params.Receiver.CoordinateType == 0 {
t.Error("Param 'receiver.coordinate_type' can not be empty")
}
if params.Cargo.GoodsValue == 0 {
t.Error("Param 'cargo.goods_value' can not be empty")
}
if params.Cargo.GoodsHeight == 0 {
t.Error("Param 'cargo.goods_height' can not be empty")
}
if params.Cargo.GoodsLength == 0 {
t.Error("Param 'cargo.goods_length' can not be empty")
}
if params.Cargo.GoodsWidth == 0 {
t.Error("Param 'cargo.goods_width' can not be empty")
}
if params.Cargo.GoodsWeight == 0 {
t.Error("Param 'cargo.goods_weight' can not be empty")
}
if params.Cargo.CargoFirstClass == "" {
t.Error("Param 'cargo.cargo_first_class' can not be empty")
}
if params.Cargo.CargoSecondClass == "" {
t.Error("Param 'cargo.cargo_second_class' can not be empty")
}
if len(params.Cargo.GoodsDetail.Goods) > 0 {
if params.Cargo.GoodsDetail.Goods[0].Count == 0 {
t.Error("Param 'cargo.goods_detail.goods.good_count' can not be empty")
}
if params.Cargo.GoodsDetail.Goods[0].Name == "" {
t.Error("Param 'cargo.goods_detail.goods.good_name' can not be empty")
}
if params.Cargo.GoodsDetail.Goods[0].Price == 0 {
t.Error("Param 'cargo.goods_detail.goods.good_price' can not be empty")
}
if params.Cargo.GoodsDetail.Goods[0].Unit == "" {
t.Error("Param 'cargo.goods_detail.goods.good_unit' can not be empty")
}
}
if params.OrderInfo.DeliveryServiceCode == "" {
t.Error("Param 'order_info.delivery_service_code' can not be empty")
}
if params.Shop.WxaPath == "" {
t.Error("Param 'shop.wxa_path' can not be empty")
}
if params.Shop.ImgURL == "" {
t.Error("Param 'shop.img_url' can not be empty")
}
if params.Shop.GoodsName == "" {
t.Error("Param 'shop.goods_name' can not be empty")
}
if params.Shop.GoodsCount == 0 {
t.Error("Param 'shop.goods_count' can not be empty")
}
w.WriteHeader(http.StatusOK)
raw := `{
"resultcode": 1,
"resultmsg": "ok",
"fee": 11,
"deliverfee": 11,
"couponfee": 1,
"insurancefee": 1000,
"tips": 1,
"insurancfee": 1,
"distance": 1001,
"dispatch_duration": 301,
"delivery_token": "1111111"
}`
if _, err := w.Write([]byte(raw)); err != nil {
t.Fatal(err)
}
}))
defer ts.Close()
raw := `{
"cargo": {
"cargo_first_class": "美食宵夜",
"cargo_second_class": "零食小吃",
"goods_detail": {
"goods": [
{
"good_count": 1,
"good_name": "水果",
"good_price": 11,
"good_unit": "元"
},
{
"good_count": 2,
"good_name": "蔬菜",
"good_price": 21,
"good_unit": "元"
}
]
},
"goods_height": 1,
"goods_length": 3,
"goods_value": 5,
"goods_weight": 1,
"goods_width": 2
},
"delivery_id": "SFTC",
"delivery_sign": "01234567890123456789",
"openid": "oABC123456",
"order_info": {
"delivery_service_code": "xxx",
"expected_delivery_time": 1,
"is_direct_delivery": 1,
"is_finish_code_needed": 1,
"is_insured": 1,
"is_pickup_code_needed": 1,
"note": "test_note",
"order_time": 1555220757,
"order_type": 1,
"poi_seq": "1111",
"tips": 0
},
"receiver": {
"address": "xxx地铁站",
"address_detail": "2号楼202",
"city": "北京市",
"coordinate_type": 1,
"lat": 40.1529600001,
"lng": 116.5060300001,
"name": "老王",
"phone": "18512345678"
},
"sender": {
"address": "xx大厦",
"address_detail": "1号楼101",
"city": "北京市",
"coordinate_type": 1,
"lat": 40.4486120001,
"lng": 116.3830750001,
"name": "刘一",
"phone": "13712345678"
},
"shop": {
"goods_count": 2,
"goods_name": "宝贝",
"img_url": "https://mmbiz.qpic.cn/mmbiz_png/xxxxxxxxx/0?wx_fmt=png",
"wxa_path": "/page/index/index"
},
"shop_no": "12345678",
"sub_biz_id": "sub_biz_id_1",
"shop_order_id": "SFTC_001",
"shopid": "122222222"
}`
creator := new(DeliveryOrderCreator)
err := json.Unmarshal([]byte(raw), creator)
if err != nil {
t.Fatal(err)
}
res, err := creator.prepare(ts.URL+apiPreAddDeliveryOrder, "mock-access-token")
if err != nil {
t.Fatal(err)
}
if res.Fee == 0 {
t.Error("Response 'fee' can not be empty")
}
if res.Deliverfee == 0 {
t.Error("Response 'deliverfee' can not be empty")
}
if res.Couponfee == 0 {
t.Error("Response 'couponfee' can not be empty")
}
if res.Tips == 0 {
t.Error("Response 'tips' can not be empty")
}
if res.Insurancefee == 0 {
t.Error("Response 'insurancefee' can not be empty")
}
if res.Distance == 0 {
t.Error("Response 'distance' can not be empty")
}
if res.DispatchDuration == 0 {
t.Error("Response 'dispatch_duration' can not be empty")
}
}
func TestPreCancelDeliveryOrder(t *testing.T) {
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
t.Error("UnExpect request method")
}
if r.URL.EscapedPath() != "/cgi-bin/express/local/business/order/precancel" {
t.Error("Unexpected path")
}
if err := r.ParseForm(); err != nil {
t.Fatal(err)
}
if r.Form.Get("access_token") == "" {
t.Fatalf("Query 'access_token' can not be empty")
}
params := struct {
ShopID string `json:"shopid"` // 商家id， 由配送公司分配的appkey
ShopOrderID string `json:"shop_order_id"` // 唯一标识订单的 ID，由商户生成
ShopNo string `json:"shop_no"` // 商家门店编号， 在配送公司登记，如果只有一个门店，可以不填
DeliverySign string `json:"delivery_sign"` // 用配送公司提供的appSecret加密的校验串
DeliveryID string `json:"delivery_id"` // 快递公司ID
WaybillID string `json:"waybill_id"` // 配送单id
ReasonID uint8 `json:"cancel_reason_id"` // 取消原因Id
Reason string `json:"cancel_reason"` // 取消原因
}{}
if err := json.NewDecoder(r.Body).Decode(¶ms); err != nil {
t.Fatal(err)
}
if params.ShopID == "" {
t.Error("Param 'shopid' can not be empty")
}
if params.ShopOrderID == "" {
t.Error("Param 'shop_order_id' can not be empty")
}
if params.ShopNo == "" {
t.Error("Param 'shop_no' can not be empty")
}
if params.DeliverySign == "" {
t.Error("Param 'delivery_sign' can not be empty")
}
if params.WaybillID == "" {
t.Error("Param 'waybill_id' can not be empty")
}
if params.DeliveryID == "" {
t.Error("Param 'delivery_id' can not be empty")
}
if params.ReasonID == 0 {
t.Error("Param 'cancel_reason_id' can not be empty")
}
if params.Reason == "" {
t.Error("Param 'cancel_reason' can not be empty")
}
w.WriteHeader(http.StatusOK)
raw := `{
"resultcode": 1,
"resultmsg": "ok",
"deduct_fee": 5,
"desc": "blabla"
}`
if _, err := w.Write([]byte(raw)); err != nil {
t.Fatal(err)
}
}))
defer ts.Close()
raw := `{
"shopid": "123456",
"shop_order_id": "123456",
"waybill_id": "123456",
"delivery_id": "123456",
"cancel_reason_id": 1,
"cancel_reason": "xxxxxx",
"delivery_sign": "123456",
"shop_no": "shop_no_111"
}`
canceler := new(DeliveryOrderCanceler)
err := json.Unmarshal([]byte(raw), canceler)
if err != nil {
t.Fatal(err)
}
res, err := canceler.prepare(ts.URL+apiPreCancelDeliveryOrder, "mock-access-token")
if err != nil {
t.Fatal(err)
}
if res.ResultCode == 0 {
t.Error("Response 'resultcode' can not be empty")
}
if res.ResultMsg == "" {
t.Error("Response 'resultmsg' can not be empty")
}
if res.DeductFee == 0 {
t.Error("Response 'deduct_fee' can not be empty")
}
if res.Desc == "" {
t.Error("Response 'desc' can not be empty")
}
}
func TestReAddDeliveryOrder(t *testing.T) {
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
t.Error("UnExpect request method")
}
if r.URL.EscapedPath() != "/cgi-bin/express/local/business/order/readd" {
t.Error("Unexpected path")
}
if err := r.ParseForm(); err != nil {
t.Fatal(err)
}
if r.Form.Get("access_token") == "" {
t.Fatalf("access_token can not be empty")
}
params := struct {
DeliveryToken string `json:"delivery_token"` // 预下单接口返回的参数，配送公司可保证在一段时间内运费不变
ShopID string `json:"shopid"` // 商家id， 由配送公司分配的appkey
ShopOrderID string `json:"shop_order_id"` // 唯一标识订单的 ID，由商户生成
ShopNo string `json:"shop_no"` // 商家门店编号， 在配送公司登记，如果只有一个门店，可以不填
DeliverySign string `json:"delivery_sign"` // 用配送公司提供的appSecret加密的校验串
DeliveryID string `json:"delivery_id"` // 配送公司ID
OpenID string `json:"openid"` // 下单用户的openid
SubBizID string `json:"sub_biz_id"` // 子商户id，区分小程序内部多个子商户
Sender struct {
Name string `json:"name"` // 姓名，最长不超过256个字符
City string `json:"city"` // 城市名称，如广州市
Address string `json:"address"` // 地址(街道、小区、大厦等，用于定位)
AddressDetail string `json:"address_detail"` // 地址详情(楼号、单元号、层号)
Phone string `json:"phone"` // 电话/手机号，最长不超过64个字符
Lng float64 `json:"lng"` // 经度（火星坐标或百度坐标，和 coordinate_type 字段配合使用，确到小数点后6位
Lat float64 `json:"lat"` // 纬度（火星坐标或百度坐标，和 coordinate_type 字段配合使用，精确到小数点后6位）
CoordinateType uint8 `json:"coordinate_type"` // 坐标类型，0：火星坐标（高德，腾讯地图均采用火星坐标） 1：百度坐标
} `json:"sender"` // 发件人信息，闪送、顺丰同城急送必须填写，美团配送、达达，若传了shop_no的值可不填该字段
Receiver struct {
Name string `json:"name"` // 姓名，最长不超过256个字符
City string `json:"city"` // 城市名称，如广州市
Address string `json:"address"` // 地址(街道、小区、大厦等，用于定位)
AddressDetail string `json:"address_detail"` // 地址详情(楼号、单元号、层号)
Phone string `json:"phone"` // 电话/手机号，最长不超过64个字符
Lng float64 `json:"lng"` // 经度（火星坐标或百度坐标，和 coordinate_type 字段配合使用，确到小数点后6位
Lat float64 `json:"lat"` // 纬度（火星坐标或百度坐标，和 coordinate_type 字段配合使用，精确到小数点后6位）
CoordinateType uint8 `json:"coordinate_type"` // 坐标类型，0：火星坐标（高德，腾讯地图均采用火星坐标） 1：百度坐标
} `json:"receiver"` // 收件人信息
Cargo struct {
GoodsValue float64 `json:"goods_value"` // 货物价格，单位为元，精确到小数点后两位（如果小数点后位数多于两位，则四舍五入保留两位小数），范围为(0-5000]
GoodsHeight float64 `json:"goods_height"` // 货物高度，单位为cm，精确到小数点后两位（如果小数点后位数多于两位，则四舍五入保留两位小数），范围为(0-45]
GoodsLength float64 `json:"goods_length"` // 货物长度，单位为cm，精确到小数点后两位（如果小数点后位数多于两位，则四舍五入保留两位小数），范围为(0-65]
GoodsWidth float64 `json:"goods_width"` // 货物宽度，单位为cm，精确到小数点后两位（如果小数点后位数多于两位，则四舍五入保留两位小数），范围为(0-50]
GoodsWeight float64 `json:"goods_weight"` // 货物重量，单位为kg，精确到小数点后两位（如果小数点后位数多于两位，则四舍五入保留两位小数），范围为(0-50]
GoodsDetail struct {
Goods []struct {
Count uint `json:"good_count"` // 货物数量
Name string `json:"good_name"` // 货品名称
Price float32 `json:"good_price"` // 货品单价，精确到小数点后两位（如果小数点后位数多于两位，则四舍五入保留两位小数）
Unit string `json:"good_unit"` // 货品单位，最长不超过20个字符
} `json:"goods"` // 货物交付信息，最长不超过100个字符
} `json:"goods_detail"` // 货物详情，最长不超过10240个字符
GoodsPickupInfo string `json:"goods_pickup_info"` // 货物取货信息，用于骑手到店取货，最长不超过100个字符
GoodsDeliveryInfo string `json:"goods_delivery_info"` // 货物交付信息，最长不超过100个字符
CargoFirstClass string `json:"cargo_first_class"` // 品类一级类目
CargoSecondClass string `json:"cargo_second_class"` // 品类二级类目
} `json:"cargo"` // 货物信息
OrderInfo struct {
DeliveryServiceCode string `json:"delivery_service_code"` // 配送服务代码 不同配送公司自定义,微信侧不理解
OrderType uint8 `json:"order_type"` // 订单类型, 0: 即时单 1 预约单，如预约单，需要设置expected_delivery_time或expected_finish_time或expected_pick_time
ExpectedDeliveryTime uint `json:"expected_delivery_time"` // 期望派单时间(顺丰同城急送、达达、支持)，unix-timestamp
ExpectedFinishTime uint `json:"expected_finish_time"` // 期望送达时间(顺丰同城急送、美团配送支持），unix-timestamp
ExpectedPickTime uint `json:"expected_pick_time"` // 期望取件时间（闪送支持），unix-timestamp
PoiSeq string `json:"poi_seq"` // 门店订单流水号，建议提供，方便骑手门店取货，最长不超过32个字符
Note string `json:"note"` // 备注，最长不超过200个字符
OrderTime uint `json:"order_time"` // 用户下单付款时间
IsInsured uint8 `json:"is_insured"` // 是否保价，0，非保价，1.保价
DeclaredValue float64 `json:"declared_value"` // 保价金额，单位为元，精确到分
Tips float64 `json:"tips"` // 小费，单位为元, 下单一般不加小费
IsDirectDelivery uint `json:"is_direct_delivery"` // 是否选择直拿直送（0：不需要；1：需要。选择直拿直送后，同一时间骑手只能配送此订单至完成，配送费用也相应高一些，闪送必须选1，达达可选0或1，其余配送公司不支持直拿直送）
CashOnDelivery uint `json:"cash_on_delivery"` // 骑手应付金额，单位为元，精确到分
CashOnPickup uint `json:"cash_on_pickup"` // 骑手应收金额，单位为元，精确到分
RiderPickMethod uint8 `json:"rider_pick_method"` // 物流流向，1：从门店取件送至用户；2：从用户取件送至门店
IsFinishCodeNeeded uint8 `json:"is_finish_code_needed"` // 收货码（0：不需要；1：需要。收货码的作用是：骑手必须输入收货码才能完成订单妥投）
IsPickupCodeNeeded uint8 `json:"is_pickup_code_needed"` // 取货码（0：不需要；1：需要。取货码的作用是：骑手必须输入取货码才能从商家取货）
} `json:"order_info"` // 订单信息
Shop struct {
WxaPath string `json:"wxa_path"` // 商家小程序的路径，建议为订单页面
ImgURL string `json:"img_url"` // 商品缩略图 url
GoodsName string `json:"goods_name"` // 商品名称
GoodsCount uint `json:"goods_count"` // 商品数量
} `json:"shop"` // 商品信息，会展示到物流通知消息中
}{}
if err := json.NewDecoder(r.Body).Decode(¶ms); err != nil {
t.Fatal(err)
}
if params.DeliveryToken == "" {
t.Error("Response column 'delivery_token' can not be empty")
}
if params.ShopID == "" {
t.Error("Response column 'shopid' can not be empty")
}
if params.ShopOrderID == "" {
t.Error("Response column 'shop_order_id' can not be empty")
}
if params.ShopNo == "" {
t.Error("Response column 'shop_no' can not be empty")
}
if params.DeliverySign == "" {
t.Error("Response column 'delivery_sign' can not be empty")
}
if params.DeliveryID == "" {
t.Error("Response column 'delivery_id' can not be empty")
}
if params.OpenID == "" {
t.Error("Response column 'openid' can not be empty")
}
if params.SubBizID == "" {
t.Error("Response column 'sub_biz_id' can not be empty")
}
if params.Sender.Name == "" {
t.Error("Param 'sender.name' can not be empty")
}
if params.Sender.City == "" {
t.Error("Param 'sender.city' can not be empty")
}
if params.Sender.Address == "" {
t.Error("Param 'sender.address' can not be empty")
}
if params.Sender.AddressDetail == "" {
t.Error("Param 'sender.address_detail' can not be empty")
}
if params.Sender.Phone == "" {
t.Error("Param 'sender.phone' can not be empty")
}
if params.Sender.Lng == 0 {
t.Error("Param 'sender.lng' can not be empty")
}
if params.Sender.Lat == 0 {
t.Error("Param 'sender.lat' can not be empty")
}
if params.Sender.CoordinateType == 0 {
t.Error("Param 'sender.coordinate_type' can not be empty")
}
if params.Receiver.Name == "" {
t.Error("Param 'receiver.name' can not be empty")
}
if params.Receiver.City == "" {
t.Error("Param 'receiver.city' can not be empty")
}
if params.Receiver.Address == "" {
t.Error("Param 'receiver.address' can not be empty")
}
if params.Receiver.AddressDetail == "" {
t.Error("Param 'receiver.address_detail' can not be empty")
}
if params.Receiver.Phone == "" {
t.Error("Param 'receiver.phone' can not be empty")
}
if params.Receiver.Lng == 0 {
t.Error("Param 'receiver.lng' can not be empty")
}
if params.Receiver.Lat == 0 {
t.Error("Param 'receiver.lat' can not be empty")
}
if params.Receiver.CoordinateType == 0 {
t.Error("Param 'receiver.coordinate_type' can not be empty")
}
if params.Cargo.GoodsValue == 0 {
t.Error("Param 'cargo.goods_value' can not be empty")
}
if params.Cargo.GoodsHeight == 0 {
t.Error("Param 'cargo.goods_height' can not be empty")
}
if params.Cargo.GoodsLength == 0 {
t.Error("Param 'cargo.goods_length' can not be empty")
}
if params.Cargo.GoodsWidth == 0 {
t.Error("Param 'cargo.goods_width' can not be empty")
}
if params.Cargo.GoodsWeight == 0 {
t.Error("Param 'cargo.goods_weight' can not be empty")
}
if params.Cargo.CargoFirstClass == "" {
t.Error("Param 'cargo.cargo_first_class' can not be empty")
}
if params.Cargo.CargoSecondClass == "" {
t.Error("Param 'cargo.cargo_second_class' can not be empty")
}
if len(params.Cargo.GoodsDetail.Goods) > 0 {
if params.Cargo.GoodsDetail.Goods[0].Count == 0 {
t.Error("Param 'cargo.goods_detail.goods.good_count' can not be empty")
}
if params.Cargo.GoodsDetail.Goods[0].Name == "" {
t.Error("Param 'cargo.goods_detail.goods.good_name' can not be empty")
}
if params.Cargo.GoodsDetail.Goods[0].Price == 0 {
t.Error("Param 'cargo.goods_detail.goods.good_price' can not be empty")
}
if params.Cargo.GoodsDetail.Goods[0].Unit == "" {
t.Error("Param 'cargo.goods_detail.goods.good_unit' can not be empty")
}
}
if params.OrderInfo.DeliveryServiceCode == "" {
t.Error("Param 'order_info.delivery_service_code' can not be empty")
}
if params.Shop.WxaPath == "" {
t.Error("Param 'shop.wxa_path' can not be empty")
}
if params.Shop.ImgURL == "" {
t.Error("Param 'shop.img_url' can not be empty")
}
if params.Shop.GoodsName == "" {
t.Error("Param 'shop.goods_name' can not be empty")
}
if params.Shop.GoodsCount == 0 {
t.Error("Param 'shop.goods_count' can not be empty")
}
w.WriteHeader(http.StatusOK)
raw := `{
"resultcode": 1,
"resultmsg": "ok",
"fee": 11,
"deliverfee": 11,
"couponfee": 1,
"tips": 1,
"insurancefee": 1000,
"insurancfee": 1,
"distance": 1001,
"waybill_id": "123456789",
"order_status": 101,
"finish_code": 1024,
"pickup_code": 2048,
"dispatch_duration": 300
}`
if _, err := w.Write([]byte(raw)); err != nil {
t.Fatal(err)
}
}))
defer ts.Close()
raw := `{
"cargo": {
"cargo_first_class": "美食宵夜",
"cargo_second_class": "零食小吃",
"goods_detail": {
"goods": [
{
"good_count": 1,
"good_name": "水果",
"good_price": 11,
"good_unit": "元"
},
{
"good_count": 2,
"good_name": "蔬菜",
"good_price": 21,
"good_unit": "元"
}
]
},
"goods_height": 1,
"goods_length": 3,
"goods_value": 5,
"goods_weight": 1,
"goods_width": 2
},
"delivery_id": "SFTC",
"delivery_sign": "01234567890123456789",
"openid": "oABC123456",
"order_info": {
"delivery_service_code": "xxx",
"expected_delivery_time": 1,
"is_direct_delivery": 1,
"is_finish_code_needed": 1,
"is_insured": 1,
"is_pickup_code_needed": 1,
"note": "test_note",
"order_time": 1555220757,
"order_type": 1,
"poi_seq": "1111",
"tips": 0
},
"receiver": {
"address": "xxx地铁站",
"address_detail": "2号楼202",
"city": "北京市",
"coordinate_type": 1,
"lat": 40.1529600001,
"lng": 116.5060300001,
"name": "老王",
"phone": "18512345678"
},
"sender": {
"address": "xx大厦",
"address_detail": "1号楼101",
"city": "北京市",
"coordinate_type": 1,
"lat": 40.4486120001,
"lng": 116.3830750001,
"name": "刘一",
"phone": "13712345678"
},
"shop": {
"goods_count": 2,
"goods_name": "宝贝",
"img_url": "https://mmbiz.qpic.cn/mmbiz_png/xxxxxxxxx/0?wx_fmt=png",
"wxa_path": "/page/index/index"
},
"shop_no": "12345678",
"sub_biz_id": "sub_biz_id_1",
"shop_order_id": "SFTC_001",
"shopid": "122222222",
"delivery_token": "xxxxxxxx"
}`
creator := new(DeliveryOrderCreator)
err := json.Unmarshal([]byte(raw), creator)
if err != nil {
t.Fatal(err)
}
res, err := creator.recreate(ts.URL+apiReAddDeliveryOrder, "mock-access-token")
if err != nil {
t.Fatal(err)
}
if res.Fee == 0 {
t.Error("Response 'fee' can not be empty")
}
if res.Deliverfee == 0 {
t.Error("Response 'deliverfee' can not be empty")
}
if res.Couponfee == 0 {
t.Error("Response 'couponfee' can not be empty")
}
if res.Tips == 0 {
t.Error("Response 'tips' can not be empty")
}
if res.Insurancefee == 0 {
t.Error("Response 'insurancefee' can not be empty")
}
if res.Distance == 0 {
t.Error("Response 'distance' can not be empty")
}
if res.WaybillID == "" {
t.Error("Response 'waybill_id' can not be empty")
}
if res.OrderStatus == 0 {
t.Error("Response 'order_status' can not be empty")
}
if res.FinishCode == 0 {
t.Error("Response 'finish_code' can not be empty")
}
if res.PickupCode == 0 {
t.Error("Response 'pickup_code' can not be empty")
}
if res.DispatchDuration == 0 {
t.Error("Response 'dispatch_duration' can not be empty")
}
if res.ResultCode == 0 {
t.Error("Response 'resultcode' can not be empty")
}
if res.ResultMsg == "" {
t.Error("Response 'resultmsg' can not be empty")
}
}
func TestUpdateDeliveryOrder(t *testing.T) {
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
t.Error("UnExpect request method")
}
if r.URL.EscapedPath() != "/cgi-bin/express/local/delivery/update_order" {
t.Error("Unexpected path")
}
if err := r.ParseForm(); err != nil {
t.Fatal(err)
}
if r.Form.Get("access_token") == "" {
t.Fatalf("Query 'access_token' can not be empty")
}
params := struct {
WxToken string `json:"wx_token"`
ShopID string `json:"shopid"`
ShopOrderID string `json:"shop_order_id"`
ShopNo string `json:"shop_no"`
WaybillID string `json:"waybill_id"`
ActionTime uint `json:"action_time"`
OrderStatus int `json:"order_status"`
ActionMsg string `json:"action_msg"`
WxaPath string `json:"wxa_path"`
Agent struct {
Name string `json:"name"`
Phone string `json:"phone"`
IsPhoneEncrypted uint8 `json:"is_phone_encrypted"`
} `json:"agent"`
ExpectedDeliveryTime uint `json:"expected_delivery_time"`
}{}
if err := json.NewDecoder(r.Body).Decode(¶ms); err != nil {
t.Fatal(err)
}
if params.WxToken == "" {
t.Error("Response column wx_token can not be empty")
}
if params.Agent.Name == "" {
t.Error("Response column agent.name can not be empty")
}
if params.Agent.Phone == "" {
t.Error("Response column agent.phone can not be empty")
}
if params.Agent.IsPhoneEncrypted == 0 {
t.Error("Response column agent.is_phone_encrypted can not be empty")
}
if params.ShopID == "" {
t.Error("Response column shopid can not be empty")
}
if params.ShopNo == "" {
t.Error("Response column shop_no can not be empty")
}
if params.WaybillID == "" {
t.Error("Response column waybill_id can not be empty")
}
if params.ShopOrderID == "" {
t.Error("Response column expected_delivery_time can not be empty")
}
if params.ExpectedDeliveryTime == 0 {
t.Error("Response column action_time can not be empty")
}
if params.ActionTime == 0 {
t.Error("Response column action_time can not be empty")
}
if params.OrderStatus == 0 {
t.Error("Response column order_status can not be empty")
}
if params.ActionMsg == "" {
t.Error("Response column action_msg can not be empty")
}
w.WriteHeader(http.StatusOK)
raw := `{
"resultcode": 1,
"resultmsg": "ok"
}`
if _, err := w.Write([]byte(raw)); err != nil {
t.Fatal(err)
}
}))
raw := `{
"wx_token": "xxxxxx",
"shopid": "test_shop_id",
"shop_no": "test_shop_id",
"shop_order_id": "xxxxxxxxxxx",
"waybill_id": "xxxxxxxxxxxxx",
"action_time": 12345678,
"order_status": 101,
"action_msg": "xxxxxx",
"wxa_path": "xxxxxx",
"expected_delivery_time": 123456,
"agent": {
"name": "xxxxxx",
"phone": "xxxxxx",
"is_phone_encrypted": 1
}
}`
updater := new(DeliveryOrderUpdater)
err := json.Unmarshal([]byte(raw), updater)
if err != nil {
t.Fatal(err)
}
res, err := updater.update(ts.URL+apiUpdateDeliveryOrder, "mock-access-token")
if err != nil {
t.Fatal(err)
}
if res.ResultCode == 0 {
t.Error("Response 'resultcode' can not be empty")
}
if res.ResultMsg == "" {
t.Error("Response 'resultmsg' can not be empty")
}
}
func TestOnDeliveryOrderStatusUpdate(t *testing.T) {
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
aesKey := base64.StdEncoding.EncodeToString([]byte("mock-aes-key"))
srv, err := NewServer("mock-app-id", "mock-access-token", aesKey, "mock-mch-id", "mock-api-key", false)
if err != nil {
t.Fatal(err)
}
srv.OnDeliveryOrderStatusUpdate(func(mix *DeliveryOrderStatusUpdateResult) *DeliveryOrderStatusUpdateReturn {
if mix.ToUserName == "" {
t.Error("ToUserName can not be empty")
}
if mix.FromUserName == "" {
t.Error("FromUserName can not be empty")
}
if mix.CreateTime == 0 {
t.Error("CreateTime can not be zero")
}
if mix.MsgType != "event" {
t.Error("Unexpected message type")
}
if mix.Event != "update_waybill_status" {
t.Error("Unexpected message event")
}
if mix.ShopID == "" {
t.Error("Result 'shopid' can not be zero")
}
if mix.ShopOrderID == "" {
t.Error("Result 'shop_order_id' can not be zero")
}
if mix.ShopNo == "" {
t.Error("Result 'shop_no' can not be zero")
}
if mix.WaybillID == "" {
t.Error("Result 'waybill_id' can not be zero")
}
if mix.ActionTime == 0 {
t.Error("Result 'action_time' can not be zero")
}
if mix.OrderStatus == 0 {
t.Error("Result 'order_status' can not be zero")
}
if mix.ActionMsg == "" {
t.Error("Result 'action_msg' can not be zero")
}
if mix.Agent.Name == "" {
t.Error("Result 'agent.name' can not be zero")
}
if mix.Agent.Phone == "" {
t.Error("Result 'agent.phone' can not be zero")
}
return &DeliveryOrderStatusUpdateReturn{
"mock-to-user-name",
"mock-from-user-name",
20060102150405,
"mock-message-type",
"mock-event",
0,
"mock-result-message",
}
})
if err := srv.Serve(w, r); err != nil {
t.Fatal(err)
}
}))
defer ts.Close()
jsonData := `{
"ToUserName": "toUser",
"FromUserName": "fromUser",
"CreateTime": 1546924844,
"MsgType": "event",
"Event": "update_waybill_status",
"shopid": "123456",
"shop_order_id": "123456",
"waybill_id": "123456",
"action_time": 1546924844,
"order_status": 102,
"action_msg": "xxx",
"shop_no": "123456",
"agent": {
"name": "xxx",
"phone": "1234567"
}
}`
res, err := http.Post(ts.URL, "application/json", strings.NewReader(jsonData))
if err != nil {
t.Fatal(err)
}
defer res.Body.Close()
}