server
/
new-api
1
0
Bifurcation 0
Code Tickets 0 Demandes d'ajout 0 Versions 0 Wiki Activité
Vous ne pouvez pas sélectionner plus de 25 sujets Les noms de sujets doivent commencer par une lettre ou un nombre, peuvent contenir des tirets ('-') et peuvent comporter jusqu'à 35 caractères.
297 Révisions
2 Branches
106 MiB
 
 
 
Aborescence: 17c12fd41e
Branches Tags
${ item.name }
Créer la branche ${ searchTerm }
de '17c12fd41e'
${ noResults }
new-api/controller/doubao_asset_test.go

420 lignes
16 KiB
Brut Annotations Historique 

  1. package controller

  2. 

  3. import (

  4. 	"context"

  5. 	"fmt"

  6. 	"net/http"

  7. 	"net/http/httptest"

  8. 	"os"

  9. 	"strings"

  10. 	"testing"

  11. 

  12. 	"github.com/QuantumNous/new-api/common"

  13. 	"github.com/QuantumNous/new-api/constant"

  14. 	"github.com/QuantumNous/new-api/model"

  15. 	"github.com/QuantumNous/new-api/service"

  16. 	"github.com/gin-gonic/gin"

  17. 	"github.com/stretchr/testify/assert"

  18. 	"github.com/stretchr/testify/require"

  19. 	"gorm.io/gorm"

  20. 	"gorm.io/gorm/logger"

  21. )

  22. 

  23. func setupDoubaoAssetProxyRouter(t *testing.T) *gin.Engine {

  24. 	t.Helper()

  25. 

  26. 	oldMode := gin.Mode()

  27. 	gin.SetMode(gin.TestMode)

  28. 	t.Cleanup(func() {

  29. 		gin.SetMode(oldMode)

  30. 	})

  31. 

  32. 	r := gin.New()

  33. 	r.POST("/api/v1/volcengine/asset", DoubaoAssetProxy)

  34. 	return r

  35. }

  36. 

  37. func decodeDoubaoAssetErrorMessage(t *testing.T, body string) string {

  38. 	t.Helper()

  39. 

  40. 	var payload struct {

  41. 		Error struct {

  42. 			Message string `json:"message"`

  43. 			Type    string `json:"type"`

  44. 		} `json:"error"`

  45. 	}

  46. 	require.NoError(t, common.Unmarshal([]byte(body), &payload))

  47. 	return payload.Error.Message

  48. }

  49. 

  50. func setupDoubaoAssetProxyDB(t *testing.T) *gorm.DB {

  51. 	t.Helper()

  52. 

  53. 	oldDB := model.DB

  54. 	oldSQLitePath := common.SQLitePath

  55. 	oldMemoryCacheEnabled := common.MemoryCacheEnabled

  56. 	oldIsMasterNode := common.IsMasterNode

  57. 	oldUsingSQLite := common.UsingSQLite

  58. 	oldUsingMySQL := common.UsingMySQL

  59. 	oldUsingPostgreSQL := common.UsingPostgreSQL

  60. 	oldSQLDSN, hadSQLDSN := os.LookupEnv("SQL_DSN")

  61. 

  62. 	common.SQLitePath = "file:" + strings.NewReplacer("/", "_", " ", "_").Replace(t.Name()) + "?mode=memory&cache=shared"

  63. 	common.MemoryCacheEnabled = false

  64. 	common.IsMasterNode = false

  65. 	common.UsingSQLite = false

  66. 	common.UsingMySQL = false

  67. 	common.UsingPostgreSQL = false

  68. 	require.NoError(t, os.Setenv("SQL_DSN", "local"))

  69. 	require.NoError(t, model.InitDB())

  70. 

  71. 	model.DB = model.DB.Session(&gorm.Session{Logger: logger.Default.LogMode(logger.Silent)})

  72. 	db := model.DB

  73. 	sqlDB, err := db.DB()

  74. 	require.NoError(t, err)

  75. 	sqlDB.SetMaxOpenConns(1)

  76. 	require.NoError(t, db.AutoMigrate(&model.Channel{}, &model.Ability{}, &model.UserAssetChannel{}, &model.UserAssetGroup{}))

  77. 

  78. 	t.Cleanup(func() {

  79. 		_ = sqlDB.Close()

  80. 		model.DB = oldDB

  81. 		common.SQLitePath = oldSQLitePath

  82. 		common.MemoryCacheEnabled = oldMemoryCacheEnabled

  83. 		common.IsMasterNode = oldIsMasterNode

  84. 		common.UsingSQLite = oldUsingSQLite

  85. 		common.UsingMySQL = oldUsingMySQL

  86. 		common.UsingPostgreSQL = oldUsingPostgreSQL

  87. 		if hadSQLDSN {

  88. 			_ = os.Setenv("SQL_DSN", oldSQLDSN)

  89. 		} else {

  90. 			_ = os.Unsetenv("SQL_DSN")

  91. 		}

  92. 	})

  93. 

  94. 	return db

  95. }

  96. 

  97. func createDoubaoAssetProxyChannel(t *testing.T, db *gorm.DB, id int, channelType int, group string, key string, status int) {

  98. 	t.Helper()

  99. 

  100. 	priority := int64(id)

  101. 	weight := uint(10)

  102. 	autoBan := 1

  103. 	require.NoError(t, db.Create(&model.Channel{

  104. 		Id:          id,

  105. 		Type:        channelType,

  106. 		Key:         key,

  107. 		Status:      status,

  108. 		Name:        fmt.Sprintf("channel-%d", id),

  109. 		Group:       group,

  110. 		Models:      "seedance-2",

  111. 		Priority:    &priority,

  112. 		Weight:      &weight,

  113. 		AutoBan:     &autoBan,

  114. 		CreatedTime: int64(id),

  115. 	}).Error)

  116. }

  117. 

  118. func TestDoubaoAssetProxyMissingActionReturns400(t *testing.T) {

  119. 	router := setupDoubaoAssetProxyRouter(t)

  120. 

  121. 	req := httptest.NewRequest(http.MethodPost, "/api/v1/volcengine/asset?Version=2024-01-01", nil)

  122. 	w := httptest.NewRecorder()

  123. 	router.ServeHTTP(w, req)

  124. 

  125. 	assert.Equal(t, http.StatusBadRequest, w.Code)

  126. 	assert.Equal(t, "Action query parameter is required", decodeDoubaoAssetErrorMessage(t, w.Body.String()))

  127. }

  128. 

  129. func TestDoubaoAssetProxyUnknownActionReturns400(t *testing.T) {

  130. 	router := setupDoubaoAssetProxyRouter(t)

  131. 

  132. 	req := httptest.NewRequest(http.MethodPost, "/api/v1/volcengine/asset?Action=CreateRealPersonAuthSession", nil)

  133. 	w := httptest.NewRecorder()

  134. 	router.ServeHTTP(w, req)

  135. 

  136. 	assert.Equal(t, http.StatusBadRequest, w.Code)

  137. 	assert.Contains(t, decodeDoubaoAssetErrorMessage(t, w.Body.String()), "unsupported asset Action")

  138. }

  139. 

  140. func TestDoubaoAssetProxyInvalidJSONReturns400(t *testing.T) {

  141. 	router := setupDoubaoAssetProxyRouter(t)

  142. 

  143. 	req := httptest.NewRequest(http.MethodPost, "/api/v1/volcengine/asset?Action=ListAssets", strings.NewReader(`{"PageNumber":`))

  144. 	w := httptest.NewRecorder()

  145. 	router.ServeHTTP(w, req)

  146. 

  147. 	assert.Equal(t, http.StatusBadRequest, w.Code)

  148. 	assert.Contains(t, decodeDoubaoAssetErrorMessage(t, w.Body.String()), "invalid JSON body")

  149. }

  150. 

  151. func TestDoubaoAssetProxyRejectsChinaMobileAssetGroupActions(t *testing.T) {

  152. 	db := setupDoubaoAssetProxyDB(t)

  153. 	fake := &fakeDoubaoAssetAdapter{}

  154. 	t.Cleanup(service.OverrideAssetAdapterForTest(constant.ChannelTypeChinaMobileSeedance, fake))

  155. 	createDoubaoAssetProxyChannel(t, db, 61, constant.ChannelTypeChinaMobileSeedance, "default", "video-generation-key", common.ChannelStatusEnabled)

  156. 	router := gin.New()

  157. 	router.Use(func(c *gin.Context) {

  158. 		c.Set("id", 10)

  159. 		common.SetContextKey(c, constant.ContextKeyUsingGroup, "default")

  160. 		c.Next()

  161. 	})

  162. 	router.POST("/api/v1/volcengine/asset", DoubaoAssetProxy)

  163. 

  164. 	for _, action := range []string{"CreateAssetGroup", "ListAssetGroups", "GetAssetGroup", "UpdateAssetGroup", "DeleteAssetGroup"} {

  165. 		t.Run(action, func(t *testing.T) {

  166. 			req := httptest.NewRequest(http.MethodPost, "/api/v1/volcengine/asset?Action="+action, strings.NewReader(`{"Id":"group-1","GroupType":"AIGC","Name":"g"}`))

  167. 			w := httptest.NewRecorder()

  168. 			req.Header.Set("Content-Type", "application/json")

  169. 			router.ServeHTTP(w, req)

  170. 

  171. 			assert.Equal(t, http.StatusForbidden, w.Code)

  172. 			assert.Equal(t, 0, fake.calls)

  173. 		})

  174. 	}

  175. }

  176. 

  177. func TestDoubaoAssetProxyDoesNotBlockNonChinaMobileAssetGroupAction(t *testing.T) {

  178. 	db := setupDoubaoAssetProxyDB(t)

  179. 	fake := &fakeDoubaoAssetAdapter{}

  180. 	t.Cleanup(service.OverrideAssetAdapterForTest(constant.ChannelTypeDoubaoVideoCompatibleAiping, fake))

  181. 	createDoubaoAssetProxyChannel(t, db, 63, constant.ChannelTypeDoubaoVideoCompatibleAiping, "default", "video-generation-key", common.ChannelStatusEnabled)

  182. 	router := newDoubaoAssetProxyTestRouter()

  183. 

  184. 	req := httptest.NewRequest(http.MethodPost, "/api/v1/volcengine/asset?Action=ListAssetGroups", strings.NewReader(`{"PageNumber":1,"PageSize":10}`))

  185. 	w := httptest.NewRecorder()

  186. 	router.ServeHTTP(w, req)

  187. 

  188. 	assert.Equal(t, http.StatusOK, w.Code)

  189. 	assert.Equal(t, service.AssetOperationAssetGroupList, fake.operation)

  190. }

  191. 

  192. func TestDoubaoAssetProxyAutoGroupContinuesAfterMissingGroup(t *testing.T) {

  193. 	db := setupDoubaoAssetProxyDB(t)

  194. 	fake := &fakeDoubaoAssetAdapter{}

  195. 	t.Cleanup(service.OverrideAssetAdapterForTest(constant.ChannelTypeChinaMobileSeedance, fake))

  196. 	createDoubaoAssetProxyChannel(t, db, 62, constant.ChannelTypeChinaMobileSeedance, "vip", "video-generation-key", common.ChannelStatusEnabled)

  197. 	router := gin.New()

  198. 	router.Use(func(c *gin.Context) {

  199. 		c.Set("id", 10)

  200. 		common.SetContextKey(c, constant.ContextKeyUsingGroup, "auto")

  201. 		common.SetContextKey(c, constant.ContextKeyUserGroup, "default")

  202. 		c.Next()

  203. 	})

  204. 	router.POST("/api/v1/volcengine/asset", DoubaoAssetProxy)

  205. 	oldAutoGroups := doubaoAssetAutoGroups

  206. 	doubaoAssetAutoGroups = func(string) []string {

  207. 		return []string{"default", "vip"}

  208. 	}

  209. 	t.Cleanup(func() {

  210. 		doubaoAssetAutoGroups = oldAutoGroups

  211. 	})

  212. 

  213. 	req := httptest.NewRequest(http.MethodPost, "/api/v1/volcengine/asset?Action=ListAssets", strings.NewReader(`{"Filter":{"GroupType":"AIGC"},"PageNumber":1,"PageSize":10}`))

  214. 	w := httptest.NewRecorder()

  215. 	req.Header.Set("Content-Type", "application/json")

  216. 	router.ServeHTTP(w, req)

  217. 

  218. 	assert.Equal(t, http.StatusOK, w.Code)

  219. 	assert.Equal(t, service.AssetOperationAssetList, fake.operation)

  220. }

  221. 

  222. func TestDoubaoAssetProxyForwardsAdapterResponseHeaders(t *testing.T) {

  223. 	db := setupDoubaoAssetProxyDB(t)

  224. 	fake := &fakeDoubaoAssetAdapter{responseHeader: http.Header{"X-Upstream-Request-Id": []string{"upstream-1"}, "Content-Length": []string{"999"}}}

  225. 	t.Cleanup(service.OverrideAssetAdapterForTest(constant.ChannelTypeChinaMobileSeedance, fake))

  226. 	createDoubaoAssetProxyChannel(t, db, 62, constant.ChannelTypeChinaMobileSeedance, "default", "video-generation-key", common.ChannelStatusEnabled)

  227. 	router := gin.New()

  228. 	router.Use(func(c *gin.Context) {

  229. 		c.Set("id", 10)

  230. 		common.SetContextKey(c, constant.ContextKeyUsingGroup, "default")

  231. 		c.Next()

  232. 	})

  233. 	router.POST("/api/v1/volcengine/asset", DoubaoAssetProxy)

  234. 

  235. 	req := httptest.NewRequest(http.MethodPost, "/api/v1/volcengine/asset?Action=ListAssets", strings.NewReader(`{"Filter":{"GroupType":"AIGC"},"PageNumber":1,"PageSize":10}`))

  236. 	w := httptest.NewRecorder()

  237. 	req.Header.Set("Content-Type", "application/json")

  238. 	router.ServeHTTP(w, req)

  239. 

  240. 	assert.Equal(t, http.StatusOK, w.Code)

  241. 	assert.Equal(t, "upstream-1", w.Header().Get("X-Upstream-Request-Id"))

  242. 	assert.NotEqual(t, "999", w.Header().Get("Content-Length"))

  243. }

  244. 

  245. func TestDoubaoAssetProxyScopesChinaMobileCreateAndListRequests(t *testing.T) {

  246. 	db := setupDoubaoAssetProxyDB(t)

  247. 	fake := &fakeDoubaoAssetAdapter{}

  248. 	t.Cleanup(service.OverrideAssetAdapterForTest(constant.ChannelTypeChinaMobileSeedance, fake))

  249. 	createDoubaoAssetProxyChannel(t, db, 71, constant.ChannelTypeChinaMobileSeedance, "default", "video-generation-key", common.ChannelStatusEnabled)

  250. 	require.NoError(t, model.CreateUserAssetGroup(10, 71, "owned"))

  251. 	router := newDoubaoAssetProxyTestRouter()

  252. 

  253. 	for _, tc := range []struct {

  254. 		action string

  255. 		body   string

  256. 	}{

  257. 		{"CreateAsset", `{"GroupId":"forged","Name":"n","URL":"https://example.com/a.png","AssetType":"Image"}`},

  258. 		{"ListAssets", `{"Filter":{"GroupType":"AIGC","GroupIds":["forged"]},"PageNumber":1,"PageSize":10}`},

  259. 	} {

  260. 		t.Run(tc.action, func(t *testing.T) {

  261. 			fake.requests = nil

  262. 			req := httptest.NewRequest(http.MethodPost, "/api/v1/volcengine/asset?Action="+tc.action, strings.NewReader(tc.body))

  263. 			w := httptest.NewRecorder()

  264. 			router.ServeHTTP(w, req)

  265. 			require.Equal(t, http.StatusOK, w.Code)

  266. 			require.Len(t, fake.requests, 1)

  267. 			if tc.action == "CreateAsset" {

  268. 				assert.Equal(t, "owned", fake.requests[0].Body["GroupId"])

  269. 			} else {

  270. 				assert.Equal(t, []string{"owned"}, fake.requests[0].Body["Filter"].(map[string]any)["GroupIds"])

  271. 			}

  272. 		})

  273. 	}

  274. }

  275. 

  276. func TestDoubaoAssetProxyRejectsChinaMobileListAssetsWithoutFilter(t *testing.T) {

  277. 	db := setupDoubaoAssetProxyDB(t)

  278. 	createDoubaoAssetProxyChannel(t, db, 73, constant.ChannelTypeChinaMobileSeedance, "default", "video-generation-key", common.ChannelStatusEnabled)

  279. 	require.NoError(t, model.CreateUserAssetGroup(10, 73, "owned"))

  280. 	router := newDoubaoAssetProxyTestRouter()

  281. 

  282. 	for _, body := range []string{`{"PageNumber":1,"PageSize":10}`, `{"Filter":null,"PageNumber":1,"PageSize":10}`} {

  283. 		w := httptest.NewRecorder()

  284. 		req := httptest.NewRequest(http.MethodPost, "/api/v1/volcengine/asset?Action=ListAssets", strings.NewReader(body))

  285. 		router.ServeHTTP(w, req)

  286. 

  287. 		assert.Equal(t, http.StatusBadRequest, w.Code)

  288. 		assert.Contains(t, decodeDoubaoAssetErrorMessage(t, w.Body.String()), "Filter.GroupType is required")

  289. 	}

  290. }

  291. 

  292. func TestDoubaoAssetProxyHidesChinaMobileAssetsOwnedByAnotherUser(t *testing.T) {

  293. 	db := setupDoubaoAssetProxyDB(t)

  294. 	fake := &fakeDoubaoAssetAdapter{getAssetGroupID: "other"}

  295. 	t.Cleanup(service.OverrideAssetAdapterForTest(constant.ChannelTypeChinaMobileSeedance, fake))

  296. 	createDoubaoAssetProxyChannel(t, db, 72, constant.ChannelTypeChinaMobileSeedance, "default", "video-generation-key", common.ChannelStatusEnabled)

  297. 	require.NoError(t, model.CreateUserAssetGroup(10, 72, "owned"))

  298. 	router := newDoubaoAssetProxyTestRouter()

  299. 

  300. 	for _, action := range []string{"GetAsset", "UpdateAsset", "DeleteAsset"} {

  301. 		t.Run(action, func(t *testing.T) {

  302. 			fake.requests = nil

  303. 			req := httptest.NewRequest(http.MethodPost, "/api/v1/volcengine/asset?Action="+action, strings.NewReader(`{"Id":"asset-other","Name":"n"}`))

  304. 			w := httptest.NewRecorder()

  305. 			router.ServeHTTP(w, req)

  306. 

  307. 			assert.Equal(t, http.StatusNotFound, w.Code)

  308. 			require.Len(t, fake.requests, 1)

  309. 			assert.Equal(t, service.AssetOperationAssetGet, fake.requests[0].Action.Operation)

  310. 		})

  311. 	}

  312. }

  313. 

  314. func newDoubaoAssetProxyTestRouter() *gin.Engine {

  315. 	router := gin.New()

  316. 	router.Use(func(c *gin.Context) {

  317. 		c.Set("id", 10)

  318. 		common.SetContextKey(c, constant.ContextKeyUsingGroup, "default")

  319. 		c.Next()

  320. 	})

  321. 	router.POST("/api/v1/volcengine/asset", DoubaoAssetProxy)

  322. 	return router

  323. }

  324. 

  325. func TestDoubaoAssetProxyAutoGroupDoesNotBypassInvalidBinding(t *testing.T) {

  326. 	db := setupDoubaoAssetProxyDB(t)

  327. 	createDoubaoAssetProxyChannel(t, db, 1, constant.ChannelTypeChinaMobileSeedance, "other", "bad-key", common.ChannelStatusEnabled)

  328. 	createDoubaoAssetProxyChannel(t, db, 2, constant.ChannelTypeChinaMobileSeedance, "vip", "video-generation-key", common.ChannelStatusEnabled)

  329. 	require.NoError(t, model.BindUserAssetChannel(10, constant.ChannelTypeChinaMobileSeedance, "default", 1))

  330. 	router := gin.New()

  331. 	router.Use(func(c *gin.Context) {

  332. 		c.Set("id", 10)

  333. 		common.SetContextKey(c, constant.ContextKeyUsingGroup, "auto")

  334. 		common.SetContextKey(c, constant.ContextKeyUserGroup, "default")

  335. 		c.Next()

  336. 	})

  337. 	router.POST("/api/v1/volcengine/asset", DoubaoAssetProxy)

  338. 	oldAutoGroups := doubaoAssetAutoGroups

  339. 	doubaoAssetAutoGroups = func(string) []string {

  340. 		return []string{"default", "vip"}

  341. 	}

  342. 	t.Cleanup(func() {

  343. 		doubaoAssetAutoGroups = oldAutoGroups

  344. 	})

  345. 

  346. 	req := httptest.NewRequest(http.MethodPost, "/api/v1/volcengine/asset?Action=ListAssets", strings.NewReader(`{"Filter":{"GroupType":"AIGC"},"PageNumber":1,"PageSize":10}`))

  347. 	w := httptest.NewRecorder()

  348. 	req.Header.Set("Content-Type", "application/json")

  349. 	router.ServeHTTP(w, req)

  350. 

  351. 	assert.Equal(t, http.StatusBadGateway, w.Code)

  352. 	assert.Contains(t, w.Body.String(), service.AssetErrorBindingInvalid)

  353. }

  354. 

  355. func TestEffectiveDoubaoAssetGroupUsesUsingGroupBeforeBlankTokenGroup(t *testing.T) {

  356. 	c, _ := gin.CreateTestContext(httptest.NewRecorder())

  357. 	common.SetContextKey(c, constant.ContextKeyTokenGroup, "")

  358. 	common.SetContextKey(c, constant.ContextKeyUsingGroup, "default")

  359. 

  360. 	assert.Equal(t, "default", effectiveDoubaoAssetGroup(c))

  361. }

  362. 

  363. func TestConcreteDoubaoAssetGroupsForAutoUsesUserAutoGroups(t *testing.T) {

  364. 	c, _ := gin.CreateTestContext(httptest.NewRecorder())

  365. 	common.SetContextKey(c, constant.ContextKeyUsingGroup, "auto")

  366. 	common.SetContextKey(c, constant.ContextKeyTokenGroup, "")

  367. 

  368. 	groups := concreteDoubaoAssetGroupsForRequest(c, func(string) []string {

  369. 		return []string{"default", "vip"}

  370. 	})

  371. 

  372. 	assert.Equal(t, []string{"default", "vip"}, groups)

  373. }

  374. 

  375. type fakeDoubaoAssetAdapter struct {

  376. 	operation       service.AssetOperation

  377. 	responseHeader  http.Header

  378. 	requests        []service.AssetRequest

  379. 	getAssetGroupID string

  380. 	calls           int

  381. }

  382. 

  383. func (a *fakeDoubaoAssetAdapter) Name() string {

  384. 	return "fake_asset"

  385. }

  386. 

  387. func (a *fakeDoubaoAssetAdapter) Supports(operation service.AssetOperation) bool {

  388. 	return true

  389. }

  390. 

  391. func (a *fakeDoubaoAssetAdapter) DoAssetRequest(_ context.Context, _ *model.Channel, req service.AssetRequest) (*service.AssetUpstreamResponse, *service.AssetError) {

  392. 	a.operation = req.Action.Operation

  393. 	a.requests = append(a.requests, req)

  394. 	a.calls++

  395. 	if req.Action.Operation == service.AssetOperationAssetGroupCreate {

  396. 		body, err := service.BuildAssetSuccessResponse(req.Action.Action, req.Version, map[string]any{"GroupId": "generated-group"})

  397. 		if err != nil {

  398. 			return nil, &service.AssetError{Type: service.AssetErrorServer, Message: err.Error(), HTTPStatus: http.StatusInternalServerError}

  399. 		}

  400. 		return &service.AssetUpstreamResponse{StatusCode: http.StatusOK, Header: a.responseHeader, Body: body}, nil

  401. 	}

  402. 	if req.Action.Operation == service.AssetOperationAssetGet {

  403. 		body, err := service.BuildAssetSuccessResponse(req.Action.Action, req.Version, map[string]any{"Id": "asset-1", "GroupId": a.getAssetGroupID})

  404. 		if err != nil {

  405. 			return nil, &service.AssetError{Type: service.AssetErrorServer, Message: err.Error(), HTTPStatus: http.StatusInternalServerError}

  406. 		}

  407. 		return &service.AssetUpstreamResponse{StatusCode: http.StatusOK, Header: a.responseHeader, Body: body}, nil

  408. 	}

  409. 	body, err := service.BuildAssetSuccessResponse(req.Action.Action, req.Version, map[string]any{

  410. 		"Items": []map[string]any{

  411. 			{"Id": "group-1", "Name": "g", "GroupType": "AIGC"},

  412. 		},

  413. 		"TotalCount": 1,

  414. 	})

  415. 	if err != nil {

  416. 		return nil, &service.AssetError{Type: service.AssetErrorServer, Message: err.Error(), HTTPStatus: http.StatusInternalServerError}

  417. 	}

  418. 	return &service.AssetUpstreamResponse{StatusCode: http.StatusOK, Header: a.responseHeader, Body: body}, nil

  419. }