使用github的七牛SDK，配置名称Kodo->Qiniu

vendor/github.com/qiniu/api.v7/cdn/anti_leech.go

@@ -7,10 +7,9 @@ import (
 	"time"
 )
 
-// CreateTimestampAntileechURL 构建带时间戳防盗链的链接
-// encryptKey 七牛防盗链key
-func CreateTimestampAntileechURL(urlStr string, encryptKey string, durationInSeconds int64) (antileechURL string, err error) {
-
+// CreateTimestampAntileechURL 用来构建七牛CDN时间戳防盗链的访问链接
+func CreateTimestampAntileechURL(urlStr string, encryptKey string,
+	durationInSeconds int64) (antileechURL string, err error) {
 	u, err := url.Parse(urlStr)
 	if err != nil {
 		return
@@ -27,7 +26,6 @@ func CreateTimestampAntileechURL(urlStr string, encryptKey string, durationInSec
 	if u.RawQuery == "" {
 		antileechURL = u.String() + "?" + q.Encode()
 	} else {
-
 		antileechURL = u.String() + "&" + q.Encode()
 	}
 

vendor/github.com/qiniu/api.v7/cdn/anti_leech_test.go

@@ -6,7 +6,7 @@ import (
 
 func TestCreateTimestampAntiLeech(t *testing.T) {
 	type args struct {
-		urlStr              string
+		urlStr            string
 		encryptKey        string
 		durationInSeconds int64
 	}
@@ -18,20 +18,21 @@ func TestCreateTimestampAntiLeech(t *testing.T) {
 		{
 			name: "antileech_1",
 			args: args{
-				urlStr:     "http://www.abc.com/abc.jpg?stat",
-				encryptKey:        "abc",
-				durationInSeconds: 20,
+				urlStr:            "http://www.example.com/testfile.jpg",
+				encryptKey:        "abc123",
+				durationInSeconds: 3600,
 			},
 			wantErr: false,
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			_, err := CreateTimestampAntileechURL(tt.args.urlStr, tt.args.encryptKey, tt.args.durationInSeconds)
+			targetUrl, err := CreateTimestampAntileechURL(tt.args.urlStr, tt.args.encryptKey, tt.args.durationInSeconds)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("CreateTimestampAntiLeech() error = %v, wantErr %v", err, tt.wantErr)
 				return
 			}
+			t.Log(targetUrl)
 		})
 	}
 }

vendor/github.com/qiniu/api.v7/cdn/api.go

@@ -3,73 +3,72 @@ package cdn
 import (
 	"bytes"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io/ioutil"
 	"net/http"
 	"strings"
 
 	"github.com/qiniu/api.v7/auth/qbox"
-	. "github.com/qiniu/api.v7/conf"
 )
 
+// Fusion CDN服务域名
 var (
-	FUSION_HOST = "http://fusion.qiniuapi.com"
+	FusionHost = "http://fusion.qiniuapi.com"
 )
 
-/* TrafficReqBody
+// CdnManager 提供了文件和目录刷新，文件预取，获取域名带宽和流量数据，获取域名日志列表等功能
+type CdnManager struct {
+	mac *qbox.Mac
+}
 
-批量查询带宽/流量 请求内容
+// NewCdnManager 用来构建一个新的 CdnManager
+func NewCdnManager(mac *qbox.Mac) *CdnManager {
+	return &CdnManager{mac: mac}
+}
 
-	StartDate	string	开始日期，例如：2016-07-01
-	EndDate		string	结束日期，例如：2016-07-03
-	Granularity	string	粒度，取值：5min ／ hour ／day
-	Domains	 	string	域名列表，以 ；分割
-*/
-type TrafficReqBody struct {
+// TrafficReq 为批量查询带宽/流量的API请求内容
+//	StartDate 	开始日期，格式例如：2016-07-01
+//	EndDate 	结束日期，格式例如：2016-07-03
+//	Granularity	取值粒度，取值可选值：5min/hour/day
+//	Domains 	域名列表，彼此用 ; 连接
+type TrafficReq struct {
 	StartDate   string `json:"startDate"`
 	EndDate     string `json:"endDate"`
 	Granularity string `json:"granularity"`
 	Domains     string `json:"domains"`
 }
 
-// TrafficResp
-// 带宽/流量查询响应内容
+// TrafficResp 为带宽/流量查询响应内容
 type TrafficResp struct {
-	Code  int                        `json:"code"`
-	Error string                     `json:"error"`
-	Time  []string                   `json:"time,omitempty"`
-	Data  map[string]TrafficRespData `json:"data,omitempty"`
+	Code  int                    `json:"code"`
+	Error string                 `json:"error"`
+	Time  []string               `json:"time,omitempty"`
+	Data  map[string]TrafficData `json:"data,omitempty"`
 }
 
-// TrafficRespData
-// 带宽/流量数据
-type TrafficRespData struct {
+// TrafficData 为带宽/流量数据
+type TrafficData struct {
 	DomainChina   []int `json:"china"`
 	DomainOversea []int `json:"oversea"`
 }
 
-/*
-// BandWidth
-
-获取域名访问带宽数据
-http://developer.qiniu.com/article/fusion/api/traffic-bandwidth.html
-
-	StartDate		string		必须	开始日期，例如：2016-07-01
-	EndDate			string		必须	结束日期，例如：2016-07-03
-	Granularity		string		必须	粒度，取值：5min ／ hour ／day
-	Domains			[]string	必须	域名列表
-*/
-func GetBandWidthData(startDate, endDate, granularity string, domainList []string) (bandwidthData TrafficResp, err error) {
-
+// GetBandwidthData 方法用来获取域名访问带宽数据
+//	StartDate	string		必须	开始日期，例如：2016-07-01
+//	EndDate		string		必须	结束日期，例如：2016-07-03
+//	Granularity	string		必须	粒度，取值：5min ／ hour ／day
+//	Domains		[]string	必须	域名列表
+func (m *CdnManager) GetBandwidthData(startDate, endDate, granularity string,
+	domainList []string) (bandwidthData TrafficResp, err error) {
 	domains := strings.Join(domainList, ";")
-	reqBody := TrafficReqBody{
+	reqBody := TrafficReq{
 		StartDate:   startDate,
 		EndDate:     endDate,
 		Granularity: granularity,
 		Domains:     domains,
 	}
 
-	resData, reqErr := postRequest("v2/tune/bandwidth", reqBody)
+	resData, reqErr := postRequest(m.mac, "/v2/tune/bandwidth", reqBody)
 	if reqErr != nil {
 		err = reqErr
 		return
@@ -82,27 +81,22 @@ func GetBandWidthData(startDate, endDate, granularity string, domainList []strin
 	return
 }
 
-/* Flux
-
-获取域名访问流量数据
-http://developer.qiniu.com/article/fusion/api/traffic-bandwidth.html
-
-	StartDate		string		必须	开始日期，例如：2016-07-01
-	EndDate			string		必须	结束日期，例如：2016-07-03
-	Granularity		string		必须	粒度，取值：5min ／ hour ／day
-	Domains			[]string	必须	域名列表
-*/
-func GetFluxData(startDate, endDate, granularity string, domainList []string) (fluxData TrafficResp, err error) {
-
+// GetFluxData 方法用来获取域名访问流量数据
+//	StartDate	string		必须	开始日期，例如：2016-07-01
+//	EndDate		string		必须	结束日期，例如：2016-07-03
+//	Granularity	string		必须	粒度，取值：5min ／ hour ／day
+//	Domains		[]string	必须	域名列表
+func (m *CdnManager) GetFluxData(startDate, endDate, granularity string,
+	domainList []string) (fluxData TrafficResp, err error) {
 	domains := strings.Join(domainList, ";")
-	reqBody := TrafficReqBody{
+	reqBody := TrafficReq{
 		StartDate:   startDate,
 		EndDate:     endDate,
 		Granularity: granularity,
 		Domains:     domains,
 	}
 
-	resData, reqErr := postRequest("v2/tune/flux", reqBody)
+	resData, reqErr := postRequest(m.mac, "/v2/tune/flux", reqBody)
 	if reqErr != nil {
 		err = reqErr
 		return
@@ -117,43 +111,46 @@ func GetFluxData(startDate, endDate, granularity string, domainList []string) (f
 	return
 }
 
-// RefreshReq
-// 缓存刷新请求内容
+// RefreshReq 为缓存刷新请求内容
 type RefreshReq struct {
 	Urls []string `json:"urls"`
 	Dirs []string `json:"dirs"`
 }
 
-// RefreshResp
-// 缓存刷新响应内容
+// RefreshResp 缓存刷新响应内容
 type RefreshResp struct {
 	Code          int      `json:"code"`
 	Error         string   `json:"error"`
 	RequestID     string   `json:"requestId,omitempty"`
 	InvalidUrls   []string `json:"invalidUrls,omitempty"`
 	InvalidDirs   []string `json:"invalidDirs,omitempty"`
-	UrlQuotaDay   int      `json:"urlQuotaDay,omitempty"`
-	UrlSurplusDay int      `json:"urlSurplusDay,omitempty"`
+	URLQuotaDay   int      `json:"urlQuotaDay,omitempty"`
+	URLSurplusDay int      `json:"urlSurplusDay,omitempty"`
 	DirQuotaDay   int      `json:"dirQuotaDay,omitempty"`
 	DirSurplusDay int      `json:"dirSurplusDay,omitempty"`
 }
 
-/* RefreshUrlsAndDirs
-
-刷新链接列表，每次最多不可以超过100条链接
-http://developer.qiniu.com/article/fusion/api/refresh.html
-
-	urls	要刷新的单个url列表，总数不超过100条；单个url，即一个具体的url，例如：http://bar.foo.com/index.html
-	dirs	要刷新的目录url列表，总数不超过10条；目录dir，即表示一个目录级的url，例如：http://bar.foo.com/dir/，也支持在尾部使用通配符，例如：http://bar.foo.com/dir/*
-*/
-func RefreshUrlsAndDirs(urls, dirs []string) (result RefreshResp, err error) {
+// RefreshUrlsAndDirs 方法用来刷新文件或目录
+// urls	要刷新的单个url列表，单次方法调用总数不超过100条；单个url，即一个具体的url，
+// 例如：http://bar.foo.com/index.html
+// dirs	要刷新的目录url列表，单次方法调用总数不超过10条；目录dir，即表示一个目录级的url，
+// 例如：http://bar.foo.com/dir/，
+func (m *CdnManager) RefreshUrlsAndDirs(urls, dirs []string) (result RefreshResp, err error) {
+	if len(urls) > 100 {
+		err = errors.New("urls count exceeds the limit of 100")
+		return
+	}
+	if len(dirs) > 10 {
+		err = errors.New("dirs count exceeds the limit of 10")
+		return
+	}
 
 	reqBody := RefreshReq{
 		Urls: urls,
 		Dirs: dirs,
 	}
 
-	resData, reqErr := postRequest("v2/tune/refresh", reqBody)
+	resData, reqErr := postRequest(m.mac, "/v2/tune/refresh", reqBody)
 	if reqErr != nil {
 		err = reqErr
 		return
@@ -167,26 +164,22 @@ func RefreshUrlsAndDirs(urls, dirs []string) (result RefreshResp, err error) {
 	return
 }
 
-// RefreshUrls
-// 刷新文件
-func RefreshUrls(urls []string) (result RefreshResp, err error) {
-	return RefreshUrlsAndDirs(urls, nil)
+// RefreshUrls 刷新文件
+func (m *CdnManager) RefreshUrls(urls []string) (result RefreshResp, err error) {
+	return m.RefreshUrlsAndDirs(urls, nil)
 }
 
-// RefreshDirs
-// 刷新目录
-func RefreshDirs(dirs []string) (result RefreshResp, err error) {
-	return RefreshUrlsAndDirs(nil, dirs)
+// RefreshDirs 刷新目录
+func (m *CdnManager) RefreshDirs(dirs []string) (result RefreshResp, err error) {
+	return m.RefreshUrlsAndDirs(nil, dirs)
 }
 
-// PrefetchReq
-// 文件预取请求内容
+// PrefetchReq 文件预取请求内容
 type PrefetchReq struct {
 	Urls []string `json:"urls"`
 }
 
-// PrefetchResp
-// 文件预取响应内容
+// PrefetchResp 文件预取响应内容
 type PrefetchResp struct {
 	Code        int      `json:"code"`
 	Error       string   `json:"error"`
@@ -196,16 +189,18 @@ type PrefetchResp struct {
 	SurplusDay  int      `json:"surplusDay,omitempty"`
 }
 
-// PrefetchUrls
-// 预取文件链接，每次最多不可以超过100条
-// http://developer.qiniu.com/article/fusion/api/prefetch.html
-func PrefetchUrls(urls []string) (result PrefetchResp, err error) {
+// PrefetchUrls 预取文件链接，每次最多不可以超过100条
+func (m *CdnManager) PrefetchUrls(urls []string) (result PrefetchResp, err error) {
+	if len(urls) > 100 {
+		err = errors.New("urls count exceeds the limit of 100")
+		return
+	}
 
 	reqBody := PrefetchReq{
 		Urls: urls,
 	}
 
-	resData, reqErr := postRequest("v2/tune/prefetch", reqBody)
+	resData, reqErr := postRequest(m.mac, "/v2/tune/prefetch", reqBody)
 	if reqErr != nil {
 		err = reqErr
 		return
@@ -220,12 +215,59 @@ func PrefetchUrls(urls []string) (result PrefetchResp, err error) {
 	return
 }
 
-// RequestWithBody
-// 带body对api发出请求并且返回response body
-func postRequest(path string, body interface{}) (resData []byte, err error) {
+// ListLogRequest 日志下载请求内容
+type ListLogRequest struct {
+	Day     string `json:"day"`
+	Domains string `json:"domains"`
+}
 
-	urlStr := fmt.Sprintf("%s/%s", FUSION_HOST, path)
+// ListLogResult 日志下载相应内容
+type ListLogResult struct {
+	Code  int                        `json:"code"`
+	Error string                     `json:"error"`
+	Data  map[string][]LogDomainInfo `json:"data"`
+}
 
+// LogDomainInfo 日志下载信息
+type LogDomainInfo struct {
+	Name         string `json:"name"`
+	Size         int64  `json:"size"`
+	ModifiedTime int64  `json:"mtime"`
+	URL          string `json:"url"`
+}
+
+// GetCdnLogList 获取CDN域名访问日志的下载链接
+func (m *CdnManager) GetCdnLogList(day string, domains []string) (
+	listLogResult ListLogResult, err error) {
+	//new log query request
+	logReq := ListLogRequest{
+		Day:     day,
+		Domains: strings.Join(domains, ";"),
+	}
+
+	resData, reqErr := postRequest(m.mac, "/v2/tune/log/list", logReq)
+	if reqErr != nil {
+		err = fmt.Errorf("get response error, %s", reqErr)
+		return
+	}
+
+	if decodeErr := json.Unmarshal(resData, &listLogResult); decodeErr != nil {
+		err = fmt.Errorf("get response error, %s", decodeErr)
+		return
+	}
+
+	if listLogResult.Error != "" {
+		err = fmt.Errorf("get log list error, %d %s", listLogResult.Code, listLogResult.Error)
+		return
+	}
+
+	return
+}
+
+// RequestWithBody 带body对api发出请求并且返回response body
+func postRequest(mac *qbox.Mac, path string, body interface{}) (resData []byte,
+	err error) {
+	urlStr := fmt.Sprintf("%s%s", FusionHost, path)
 	reqData, _ := json.Marshal(body)
 	req, reqErr := http.NewRequest("POST", urlStr, bytes.NewReader(reqData))
 	if reqErr != nil {
@@ -233,8 +275,7 @@ func postRequest(path string, body interface{}) (resData []byte, err error) {
 		return
 	}
 
-	mac := qbox.NewMac(ACCESS_KEY, SECRET_KEY)
-	accessToken, signErr := mac.SignRequest(req, false)
+	accessToken, signErr := mac.SignRequest(req)
 	if signErr != nil {
 		err = signErr
 		return
@@ -243,9 +284,9 @@ func postRequest(path string, body interface{}) (resData []byte, err error) {
 	req.Header.Add("Authorization", "QBox "+accessToken)
 	req.Header.Add("Content-Type", "application/json")
 
-	resp, httpErr := http.DefaultClient.Do(req)
-	if httpErr != nil {
-		err = httpErr
+	resp, respErr := http.DefaultClient.Do(req)
+	if respErr != nil {
+		err = respErr
 		return
 	}
 	defer resp.Body.Close()

vendor/github.com/qiniu/api.v7/cdn/api_test.go

@@ -1,75 +1,86 @@
 package cdn
 
 import (
-	"math/rand"
 	"os"
-	"reflect"
-	"strconv"
 	"testing"
-
 	"time"
 
-	"github.com/qiniu/api.v7/kodo"
+	"github.com/qiniu/api.v7/auth/qbox"
 )
 
+//global variables
+
 var (
-	ak             = os.Getenv("QINIU_ACCESS_KEY")
-	sk             = os.Getenv("QINIU_SECRET_KEY")
-	domain         = os.Getenv("QINIU_TEST_DOMAIN")
-	testBucketName = os.Getenv("QINIU_TEST_BUCKET")
+	ak     = os.Getenv("QINIU_ACCESS_KEY")
+	sk     = os.Getenv("QINIU_SECRET_KEY")
+	domain = os.Getenv("QINIU_TEST_DOMAIN")
 
-	testDate = time.Now().AddDate(0, 0, -3).Format("2006-01-02")
-	bucket   = newBucket()
-	client   *kodo.Client
-	testKey  = "fusionTest"
-	testURL  string
+	layout    = "2006-01-02"
+	now       = time.Now()
+	startDate = now.AddDate(0, 0, -2).Format(layout)
+	endDate   = now.AddDate(0, 0, -1).Format(layout)
+	logDate   = now.AddDate(0, 0, -1).Format(layout)
+
+	testUrls = []string{
+		"http://gosdk.qiniudn.com/qiniu1.png",
+		"http://gosdk.qiniudn.com/qiniu2.png",
+	}
+	testDirs = []string{
+		"http://gosdk.qiniudn.com/dir1/",
+		"http://gosdk.qiniudn.com/dir2/",
+	}
 )
 
-func init() {
-	kodo.SetMac(ak, sk)
-	rand.Seed(time.Now().UnixNano())
-	testKey += strconv.Itoa(rand.Int())
-	bucket.PutFile(nil, nil, testKey, "doc.go", nil)
-	testURL = domain + "/" + testKey
+var mac *qbox.Mac
+var cdnManager *CdnManager
 
+func init() {
+	if ak == "" || sk == "" {
+		panic("please run ./test-env.sh first")
+	}
+	mac = qbox.NewMac(ak, sk)
+	cdnManager = NewCdnManager(mac)
 }
 
-func TestGetBandWidthData(t *testing.T) {
+//TestGetBandwidthData
+func TestGetBandwidthData(t *testing.T) {
 	type args struct {
 		startDate   string
 		endDate     string
 		granularity string
 		domainList  []string
 	}
-	tests := []struct {
-		name        string
-		args        args
-		wantTraffic TrafficResp
-		wantErr     bool
+
+	testCases := []struct {
+		name     string
+		args     args
+		wantCode int
 	}{
 		{
-			name: "BandWidthTest_1",
+			name: "CdnManager_TestGetBandwidthData",
 			args: args{
-				testDate,
-				testDate,
+				startDate,
+				endDate,
 				"5min",
 				[]string{domain},
 			},
+			wantCode: 200,
 		},
 	}
-	kodo.SetMac(ak, sk)
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			_, err := GetBandWidthData(tt.args.startDate, tt.args.endDate, tt.args.granularity, tt.args.domainList)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("GetBandWidthData() error = %v, wantErr %v", err, tt.wantErr)
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			ret, err := cdnManager.GetBandwidthData(tc.args.startDate, tc.args.endDate,
+				tc.args.granularity, tc.args.domainList)
+			if err != nil || ret.Code != tc.wantCode {
+				t.Errorf("GetBandwidth() error = %v, %v", err, ret.Error)
 				return
 			}
-
 		})
 	}
 }
 
+//TestGetFluxData
 func TestGetFluxData(t *testing.T) {
 	type args struct {
 		startDate   string
@@ -77,167 +88,160 @@ func TestGetFluxData(t *testing.T) {
 		granularity string
 		domainList  []string
 	}
-	tests := []struct {
-		name        string
-		args        args
-		wantTraffic TrafficResp
-		wantErr     bool
+
+	testCases := []struct {
+		name     string
+		args     args
+		wantCode int
 	}{
 		{
-			name: "BandWidthTest_1",
+			name: "CdnManager_TestGetFluxData",
 			args: args{
-				testDate,
-				testDate,
+				startDate,
+				endDate,
 				"5min",
 				[]string{domain},
 			},
+			wantCode: 200,
 		},
 	}
-	kodo.SetMac(ak, sk)
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			_, err := GetFluxData(tt.args.startDate, tt.args.endDate, tt.args.granularity, tt.args.domainList)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("GetFluxData() error = %v, wantErr %v", err, tt.wantErr)
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			ret, err := cdnManager.GetFluxData(tc.args.startDate, tc.args.endDate,
+				tc.args.granularity, tc.args.domainList)
+			if err != nil || ret.Code != tc.wantCode {
+				t.Errorf("GetFlux() error = %v, %v", err, ret.Error)
 				return
 			}
 		})
 	}
 }
 
-func TestRefreshUrlsAndDirs(t *testing.T) {
-	kodo.SetMac(ak, sk)
-
-	type args struct {
-		urls []string
-		dirs []string
-	}
-	tests := []struct {
-		name       string
-		args       args
-		wantResult RefreshResp
-		wantErr    bool
-	}{
-		{
-			name: "refresh_test_1",
-			args: args{
-				urls: []string{testURL},
-			},
-			wantErr: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			_, err := RefreshUrlsAndDirs(tt.args.urls, tt.args.dirs)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("RefreshUrlsAndDirs() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-
-		})
-	}
-}
-
+//TestRefreshUrls
 func TestRefreshUrls(t *testing.T) {
 	type args struct {
 		urls []string
 	}
-	tests := []struct {
-		name       string
-		args       args
-		wantResult RefreshResp
-		wantErr    bool
+
+	testCases := []struct {
+		name     string
+		args     args
+		wantCode int
 	}{
 		{
-			name: "refresh_test_1",
+			name: "CdnManager_TestRefresUrls",
 			args: args{
-				urls: []string{testURL},
+				urls: testUrls,
 			},
-			wantErr: false,
+			wantCode: 200,
 		},
 	}
 
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			_, err := RefreshUrls(tt.args.urls)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("RefreshUrls() error = %v, wantErr %v", err, tt.wantErr)
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			ret, err := cdnManager.RefreshUrls(tc.args.urls)
+			if err != nil || ret.Code != tc.wantCode {
+				t.Errorf("RefreshUrls() error = %v, %v", err, ret.Error)
 				return
 			}
 		})
 	}
 }
 
+//TestRefreshDirs
 func TestRefreshDirs(t *testing.T) {
 	type args struct {
 		dirs []string
 	}
-	tests := []struct {
-		name       string
-		args       args
-		wantResult RefreshResp
-		wantErr    bool
-	}{}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			gotResult, err := RefreshDirs(tt.args.dirs)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("RefreshDirs() error = %v, wantErr %v", err, tt.wantErr)
+
+	testCases := []struct {
+		name     string
+		args     args
+		wantCode int
+	}{
+		{
+			name: "CdnManager_TestRefreshDirs",
+			args: args{
+				dirs: testDirs,
+			},
+			wantCode: 200,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			ret, err := cdnManager.RefreshDirs(tc.args.dirs)
+			if err != nil || ret.Code != tc.wantCode {
+				if ret.Error == "refresh dir limit error" {
+					t.Logf("RefreshDirs() error=%v", ret.Error)
+				} else {
+					t.Errorf("RefreshDirs() error = %v, %v", err, ret.Error)
+				}
 				return
 			}
-			if !reflect.DeepEqual(gotResult, tt.wantResult) {
-				t.Errorf("RefreshDirs() = %v, want %v", gotResult, tt.wantResult)
-			}
 		})
 	}
 }
 
+//TestPrefetchUrls
 func TestPrefetchUrls(t *testing.T) {
 	type args struct {
 		urls []string
 	}
-	tests := []struct {
-		name       string
-		args       args
-		wantResult PrefetchResp
-		wantErr    bool
+
+	testCases := []struct {
+		name     string
+		args     args
+		wantCode int
 	}{
 		{
-			name: "refresh_test_1",
+			name: "CdnManager_PrefetchUrls",
 			args: args{
-				urls: []string{testURL},
+				urls: testUrls,
 			},
-			wantErr: false,
+			wantCode: 200,
 		},
 	}
-	kodo.SetMac(ak, sk)
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			_, err := PrefetchUrls(tt.args.urls)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("PrefetchUrls() error = %v, wantErr %v", err, tt.wantErr)
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			ret, err := cdnManager.PrefetchUrls(tc.args.urls)
+			if err != nil || ret.Code != tc.wantCode {
+				t.Errorf("PrefetchUrls() error = %v, %v", err, ret.Error)
 				return
 			}
 		})
 	}
 }
 
-func newBucket() (bucket kodo.Bucket) {
-
-	ak := os.Getenv("QINIU_ACCESS_KEY")
-	sk := os.Getenv("QINIU_SECRET_KEY")
-	if ak == "" || sk == "" {
-		panic("require ACCESS_KEY & SECRET_KEY")
+//TestGetCdnLogList
+func TestGetCdnLogList(t *testing.T) {
+	type args struct {
+		date    string
+		domains []string
 	}
-	kodo.SetMac(ak, sk)
 
-	testBucketName = os.Getenv("QINIU_TEST_BUCKET")
-	domain = os.Getenv("QINIU_TEST_DOMAIN")
-	if testBucketName == "" || domain == "" {
-		panic("require test env")
+	testCases := []struct {
+		name string
+		args args
+	}{
+		{
+			name: "CdnManager_TestGetCdnLogList",
+			args: args{
+				date:    logDate,
+				domains: []string{domain},
+			},
+		},
 	}
-	client = kodo.NewWithoutZone(nil)
 
-	return client.Bucket(testBucketName)
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			_, err := cdnManager.GetCdnLogList(tc.args.date, tc.args.domains)
+			if err != nil {
+				t.Errorf("GetCdnLogList() error = %v", err)
+				return
+			}
+		})
+	}
 }

vendor/github.com/qiniu/api.v7/cdn/doc.go

@@ -1,25 +1,3 @@
-/*
-包 github.com/qiniu/api.v7/cdn 提供了七牛CDN的API功能
-首先，我们要配置下 AccessKey/SecretKey,
-	import "github.com/qiniu/api.v7/kodo"
-
-	kodo.SetMac("ak", "sk")
-设置了AccessKey/SecretKey 就可以使用cdn的各类功能
-
-比如我们要生成一个带时间戳防盗链的链接：
-	q :=url.Values{}// url.Values 请求参数
-	link, err := cdn.CreateTimestampAntileechURL(""http://www.qiniu.com/abc/bcc/aa-s.mp4?x=2&y=3", "encryptedkey", 20)
-	if err != nil {
-		fmt.Println(err)
-	}
-	fmt.Println(link)
-
-又或者我们要列出CDN日志及其下载地址：
-	resp, err := cdn.GetCdnLogList("2016-12-26", "x-mas.com")
-	if err != nil {
-		fmt.Println(err)
-	}
-	fmt.Println(resp)
-
-*/
+// cdn 包提供了 Fusion CDN的常见功能。相关功能的文档参考：https://developer.qiniu.com/fusion。
+// 目前提供了文件和目录刷新，文件预取，获取域名带宽和流量数据，获取域名日志列表等功能。
 package cdn

vendor/github.com/qiniu/api.v7/cdn/logs.go

@@ -1,92 +0,0 @@
-package cdn
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"strings"
-
-	"github.com/qiniu/api.v7/auth/qbox"
-)
-
-const (
-	LIST_LOG_API = "http://fusion.qiniuapi.com/v2/tune/log/list"
-)
-
-// ListLogRequest 日志下载请求内容
-type ListLogRequest struct {
-	Day     string `json:"day"`
-	Domains string `json:"domains"`
-}
-
-// ListLogResult 日志下载相应内容
-type ListLogResult struct {
-	Code  int                        `json:"code"`
-	Error string                     `json:"error"`
-	Data  map[string][]LogDomainInfo `json:"data"`
-}
-
-// LogDomainInfo 日志下载信息
-type LogDomainInfo struct {
-	Name         string `json:"name"`
-	Size         int64  `json:"size"`
-	ModifiedTime int64  `json:"mtime"`
-	URL          string `json:"url"`
-}
-
-// GetCdnLogList 获取CDN域名访问日志的下载链接
-// http://developer.qiniu.com/article/fusion/api/log.html
-func GetCdnLogList(date, domains string) (domainLogs []LogDomainInfo, err error) {
-
-	//new log query request
-	logReq := ListLogRequest{
-		Day:     date,
-		Domains: domains,
-	}
-
-	logReqBytes, _ := json.Marshal(&logReq)
-	req, reqErr := http.NewRequest("POST", LIST_LOG_API, bytes.NewReader(logReqBytes))
-	if reqErr != nil {
-		err = fmt.Errorf("New request error, %s", reqErr)
-		return
-	}
-
-	mac := qbox.NewMac("", "")
-	token, signErr := mac.SignRequest(req, false)
-	if signErr != nil {
-		err = signErr
-		return
-	}
-
-	req.Header.Add("Authorization", "QBox "+token)
-	req.Header.Add("Content-Type", "application/json")
-
-	resp, respErr := http.DefaultClient.Do(req)
-	if respErr != nil {
-		err = fmt.Errorf("Get response error, %s", respErr)
-		return
-	}
-	defer resp.Body.Close()
-
-	listLogResult := ListLogResult{}
-	decoder := json.NewDecoder(resp.Body)
-	if decodeErr := decoder.Decode(&listLogResult); decodeErr != nil {
-		err = fmt.Errorf("Parse response error, %s", decodeErr)
-		return
-	}
-	if resp.StatusCode != http.StatusOK {
-		err = fmt.Errorf("Get log list error, %d %s", listLogResult.Code, listLogResult.Error)
-		return
-	}
-
-	domainItems := strings.Split(domains, ";")
-
-	for _, domain := range domainItems {
-		for _, v := range listLogResult.Data[domain] {
-			domainLogs = append(domainLogs, v)
-		}
-	}
-	return
-
-}

vendor/github.com/qiniu/api.v7/cdn/logs_test.go

@@ -1,48 +0,0 @@
-package cdn
-
-import (
-	"fmt"
-	"reflect"
-	"testing"
-
-	"github.com/qiniu/api.v7/kodo"
-)
-
-func init() {
-	kodo.SetMac(ak, sk)
-}
-
-func TestGetCdnLogList(t *testing.T) {
-	type args struct {
-		date    string
-		domains string
-	}
-	tests := []struct {
-		name           string
-		args           args
-		wantDomainLogs []LogDomainInfo
-		wantErr        bool
-	}{
-		{
-			name: "getCdnLogListTest",
-			args: args{
-				date:    testDate,
-				domains: domain,
-			},
-			wantErr: false,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			gotDomainLogs, err := GetCdnLogList(tt.args.date, tt.args.domains)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("GetCdnLogList() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-			fmt.Println(domain, gotDomainLogs)
-			if !reflect.DeepEqual(gotDomainLogs, tt.wantDomainLogs) {
-				t.Errorf("GetCdnLogList() = %v, want %v", gotDomainLogs, tt.wantDomainLogs)
-			}
-		})
-	}
-}