632 lines
23 KiB
Go
632 lines
23 KiB
Go
package api
|
||
|
||
import (
|
||
"archive/zip"
|
||
"bytes"
|
||
"context"
|
||
"encoding/base64"
|
||
"encoding/json"
|
||
"fmt"
|
||
"io"
|
||
"net/http"
|
||
"net/http/httptest"
|
||
"strings"
|
||
"testing"
|
||
|
||
"fission-console/internal/billing"
|
||
"fission-console/internal/fission"
|
||
|
||
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
|
||
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
|
||
k8sruntime "k8s.io/apimachinery/pkg/runtime"
|
||
"k8s.io/apimachinery/pkg/runtime/schema"
|
||
dynamicfake "k8s.io/client-go/dynamic/fake"
|
||
)
|
||
|
||
// ─── helpers ────────────────────────────────────────────────────────────────
|
||
|
||
// newCloneTestServer создаёт Server с фиктивным k8s-клиентом и
|
||
// опциональным HTTP-сервером, имитирующим storagesvc.
|
||
func newCloneTestServer(t *testing.T, storagesvcHandler http.HandlerFunc, objs ...*unstructured.Unstructured) (*Server, *httptest.Server) {
|
||
t.Helper()
|
||
scheme := k8sruntime.NewScheme()
|
||
listKinds := map[schema.GroupVersionResource]string{
|
||
fission.FunctionGVR: "FunctionList",
|
||
fission.PackageGVR: "PackageList",
|
||
fission.HTTPTrigGVR: "HTTPTriggerList",
|
||
}
|
||
runtimeObjs := make([]k8sruntime.Object, len(objs))
|
||
for i, o := range objs {
|
||
runtimeObjs[i] = o
|
||
}
|
||
dynClient := dynamicfake.NewSimpleDynamicClientWithCustomListKinds(scheme, listKinds, runtimeObjs...)
|
||
|
||
var storagesvc *httptest.Server
|
||
httpClient := &http.Client{}
|
||
if storagesvcHandler != nil {
|
||
storagesvc = httptest.NewServer(storagesvcHandler)
|
||
httpClient = storagesvc.Client()
|
||
}
|
||
|
||
s := &Server{
|
||
dyn: dynClient,
|
||
ns: "fission-test",
|
||
http: httpClient,
|
||
billing: billing.NoopStore{},
|
||
}
|
||
return s, storagesvc
|
||
}
|
||
|
||
// cloneRequest выполняет POST /functions/:srcName/clone с телом body.
|
||
func cloneRequest(t *testing.T, s *Server, srcName, body string) *httptest.ResponseRecorder {
|
||
t.Helper()
|
||
req := httptest.NewRequest(http.MethodPost,
|
||
"/console/api/functions/"+srcName+"/clone",
|
||
strings.NewReader(body))
|
||
req.Header.Set("Content-Type", "application/json")
|
||
req.Header.Set("X-Auth-Token", "test-token")
|
||
rec := httptest.NewRecorder()
|
||
s.handleCloneFunction(rec, req, srcName)
|
||
return rec
|
||
}
|
||
|
||
// makeZip возвращает минимальный zip-архив с одним файлом filename/content.
|
||
func makeZip(t *testing.T, filename, content string) []byte {
|
||
t.Helper()
|
||
var buf bytes.Buffer
|
||
w := zip.NewWriter(&buf)
|
||
f, err := w.Create(filename)
|
||
if err != nil {
|
||
t.Fatalf("zip.Create: %v", err)
|
||
}
|
||
if _, err := io.WriteString(f, content); err != nil {
|
||
t.Fatalf("zip.Write: %v", err)
|
||
}
|
||
if err := w.Close(); err != nil {
|
||
t.Fatalf("zip.Close: %v", err)
|
||
}
|
||
return buf.Bytes()
|
||
}
|
||
|
||
// packageWithLiteral создаёт Package CRD с type:literal (base64-encoded bytes).
|
||
func packageWithLiteral(ns, name, fnName string, data []byte) *unstructured.Unstructured {
|
||
return &unstructured.Unstructured{Object: map[string]any{
|
||
"apiVersion": "fission.io/v1",
|
||
"kind": "Package",
|
||
"metadata": map[string]any{"name": name, "namespace": ns},
|
||
"spec": map[string]any{
|
||
"deployment": map[string]any{
|
||
"type": "literal",
|
||
"literal": base64.StdEncoding.EncodeToString(data),
|
||
},
|
||
"environment": map[string]any{"name": fnName, "namespace": ns},
|
||
"source": map[string]any{},
|
||
},
|
||
}}
|
||
}
|
||
|
||
// packageWithURL создаёт Package CRD с type:url.
|
||
func packageWithURL(ns, pkgName, envName, archiveURL string) *unstructured.Unstructured {
|
||
return &unstructured.Unstructured{Object: map[string]any{
|
||
"apiVersion": "fission.io/v1",
|
||
"kind": "Package",
|
||
"metadata": map[string]any{"name": pkgName, "namespace": ns},
|
||
"spec": map[string]any{
|
||
"deployment": map[string]any{
|
||
"type": "url",
|
||
"url": archiveURL,
|
||
},
|
||
"environment": map[string]any{"name": envName, "namespace": ns},
|
||
"source": map[string]any{},
|
||
},
|
||
}}
|
||
}
|
||
|
||
// functionWithPkg создаёт Function CRD, ссылающуюся на pkgName.
|
||
func functionWithPkg(ns, fnName, pkgName, envName, entrypoint string) *unstructured.Unstructured {
|
||
return &unstructured.Unstructured{Object: map[string]any{
|
||
"apiVersion": "fission.io/v1",
|
||
"kind": "Function",
|
||
"metadata": map[string]any{
|
||
"name": fnName,
|
||
"namespace": ns,
|
||
"annotations": map[string]any{
|
||
"fission-console/language": envName,
|
||
"fission-console/source-type": "code",
|
||
"fission-console/created-at": "2026-05-09T00:00:00Z",
|
||
"fission-console/updated-at": "2026-05-09T00:00:00Z",
|
||
},
|
||
},
|
||
"spec": map[string]any{
|
||
"environment": map[string]any{"name": envName, "namespace": ns},
|
||
"functionTimeout": int64(120),
|
||
"package": map[string]any{
|
||
"packageref": map[string]any{"name": pkgName, "namespace": ns},
|
||
"functionName": entrypoint,
|
||
},
|
||
"InvokeStrategy": map[string]any{
|
||
"ExecutionStrategy": map[string]any{"ExecutorType": "poolmgr"},
|
||
"StrategyType": "execution",
|
||
},
|
||
},
|
||
}}
|
||
}
|
||
|
||
// httpTriggerObject создаёт HTTPTrigger CRD для функции fnName.
|
||
func httpTriggerObject(ns, trigName, fnName, route string, methods []any) *unstructured.Unstructured {
|
||
return &unstructured.Unstructured{Object: map[string]any{
|
||
"apiVersion": "fission.io/v1",
|
||
"kind": "HTTPTrigger",
|
||
"metadata": map[string]any{"name": trigName, "namespace": ns},
|
||
"spec": map[string]any{
|
||
"relativeurl": route,
|
||
"methods": methods,
|
||
"createingress": true,
|
||
"functionref": map[string]any{"type": "name", "name": fnName},
|
||
},
|
||
}}
|
||
}
|
||
|
||
// ─── Тесты валидации имени ───────────────────────────────────────────────────
|
||
|
||
func TestHandleCloneFunction_InvalidName_EmptyName(t *testing.T) {
|
||
s, _ := newCloneTestServer(t, nil)
|
||
rec := cloneRequest(t, s, "src", `{"new_name":""}`)
|
||
if rec.Code != http.StatusBadRequest {
|
||
t.Fatalf("status = %d, want 400; body=%s", rec.Code, rec.Body)
|
||
}
|
||
if !strings.Contains(rec.Body.String(), "new_name is required") {
|
||
t.Fatalf("body should mention 'new_name is required', got: %s", rec.Body)
|
||
}
|
||
}
|
||
|
||
func TestHandleCloneFunction_InvalidName_UpperCase(t *testing.T) {
|
||
s, _ := newCloneTestServer(t, nil)
|
||
rec := cloneRequest(t, s, "src", `{"new_name":"MyFunc"}`)
|
||
if rec.Code != http.StatusBadRequest {
|
||
t.Fatalf("status = %d, want 400; body=%s", rec.Code, rec.Body)
|
||
}
|
||
}
|
||
|
||
func TestHandleCloneFunction_InvalidName_StartsWithDash(t *testing.T) {
|
||
s, _ := newCloneTestServer(t, nil)
|
||
rec := cloneRequest(t, s, "src", `{"new_name":"-bad"}`)
|
||
if rec.Code != http.StatusBadRequest {
|
||
t.Fatalf("status = %d, want 400; body=%s", rec.Code, rec.Body)
|
||
}
|
||
}
|
||
|
||
func TestHandleCloneFunction_InvalidName_EndsWithDash(t *testing.T) {
|
||
s, _ := newCloneTestServer(t, nil)
|
||
rec := cloneRequest(t, s, "src", `{"new_name":"bad-"}`)
|
||
if rec.Code != http.StatusBadRequest {
|
||
t.Fatalf("status = %d, want 400; body=%s", rec.Code, rec.Body)
|
||
}
|
||
}
|
||
|
||
func TestHandleCloneFunction_InvalidName_TooLong(t *testing.T) {
|
||
s, _ := newCloneTestServer(t, nil)
|
||
longName := strings.Repeat("a", 58)
|
||
rec := cloneRequest(t, s, "src", fmt.Sprintf(`{"new_name":%q}`, longName))
|
||
if rec.Code != http.StatusBadRequest {
|
||
t.Fatalf("status = %d, want 400; body=%s", rec.Code, rec.Body)
|
||
}
|
||
}
|
||
|
||
func TestHandleCloneFunction_ValidName_MaxLength(t *testing.T) {
|
||
// 57 символов — допустимо; но функция src не существует → 404
|
||
s, _ := newCloneTestServer(t, nil)
|
||
name57 := strings.Repeat("a", 57)
|
||
rec := cloneRequest(t, s, "src", fmt.Sprintf(`{"new_name":%q}`, name57))
|
||
// Ожидаем не 400 (прошло валидацию), а 404 (src не найден)
|
||
if rec.Code == http.StatusBadRequest {
|
||
t.Fatalf("57-char name should pass validation, got 400; body=%s", rec.Body)
|
||
}
|
||
if rec.Code != http.StatusNotFound {
|
||
t.Fatalf("status = %d, want 404; body=%s", rec.Code, rec.Body)
|
||
}
|
||
}
|
||
|
||
func TestHandleCloneFunction_ValidName_WithDashes(t *testing.T) {
|
||
// Имя вида "a-b-c" — допустимо
|
||
s, _ := newCloneTestServer(t, nil)
|
||
rec := cloneRequest(t, s, "nonexist", `{"new_name":"a-b-c"}`)
|
||
if rec.Code == http.StatusBadRequest {
|
||
t.Fatalf("'a-b-c' should pass validation, got 400; body=%s", rec.Body)
|
||
}
|
||
}
|
||
|
||
// ─── Тест: источник не существует ────────────────────────────────────────────
|
||
|
||
func TestHandleCloneFunction_SourceNotFound(t *testing.T) {
|
||
s, _ := newCloneTestServer(t, nil)
|
||
rec := cloneRequest(t, s, "ghost", `{"new_name":"ghost-copy"}`)
|
||
if rec.Code != http.StatusNotFound {
|
||
t.Fatalf("status = %d, want 404; body=%s", rec.Code, rec.Body)
|
||
}
|
||
if !strings.Contains(rec.Body.String(), "ghost") {
|
||
t.Fatalf("body should mention 'ghost', got: %s", rec.Body)
|
||
}
|
||
}
|
||
|
||
// ─── Тест: успешный клон с type:literal ──────────────────────────────────────
|
||
|
||
func TestHandleCloneFunction_Success_Literal(t *testing.T) {
|
||
const ns = "fission-test"
|
||
zipData := makeZip(t, "main.py", "def main():\n return 'hello'\n")
|
||
|
||
pkg := packageWithLiteral(ns, "src-pkg", "python", zipData)
|
||
fn := functionWithPkg(ns, "src", "src-pkg", "python", "main.main")
|
||
trig := httpTriggerObject(ns, "src-route", "src", "/test-ns/src", []any{"GET", "POST"})
|
||
|
||
// storagesvc принимает загрузку и возвращает URL
|
||
storagesvc := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||
if r.Method == http.MethodPost {
|
||
// Имитируем загрузку — возвращаем ID архива
|
||
w.Header().Set("Content-Type", "application/json")
|
||
fmt.Fprint(w, `{"id":"fission/new-archive-id-123"}`)
|
||
return
|
||
}
|
||
http.NotFound(w, r)
|
||
}))
|
||
defer storagesvc.Close()
|
||
|
||
s, _ := newCloneTestServer(t, nil, pkg, fn, trig)
|
||
s.storagesvcURL = storagesvc.URL
|
||
s.http = storagesvc.Client()
|
||
|
||
rec := cloneRequest(t, s, "src", `{"new_name":"src-copy"}`)
|
||
if rec.Code != http.StatusCreated {
|
||
t.Fatalf("status = %d, want 201; body=%s", rec.Code, rec.Body)
|
||
}
|
||
|
||
var resp map[string]any
|
||
if err := json.NewDecoder(rec.Body).Decode(&resp); err != nil {
|
||
t.Fatalf("decode response: %v", err)
|
||
}
|
||
if resp["name"] != "src-copy" {
|
||
t.Fatalf("response.name = %v, want 'src-copy'", resp["name"])
|
||
}
|
||
if resp["cloned_from"] != "src" {
|
||
t.Fatalf("response.cloned_from = %v, want 'src'", resp["cloned_from"])
|
||
}
|
||
if resp["package"] == "" || resp["package"] == nil {
|
||
t.Fatalf("response.package is empty")
|
||
}
|
||
|
||
ctx := context.Background()
|
||
|
||
// Проверяем что Function создана
|
||
cloneFn, err := s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Get(ctx, "src-copy", metav1.GetOptions{})
|
||
if err != nil {
|
||
t.Fatalf("clone Function not found: %v", err)
|
||
}
|
||
|
||
// Аннотация cloned-from
|
||
ann := cloneFn.GetAnnotations()
|
||
if ann["fission-console/cloned-from"] != "src" {
|
||
t.Fatalf("annotation cloned-from = %q, want 'src'", ann["fission-console/cloned-from"])
|
||
}
|
||
// Аннотации language и source-type скопированы
|
||
if ann["fission-console/language"] != "python" {
|
||
t.Fatalf("annotation language = %q, want 'python'", ann["fission-console/language"])
|
||
}
|
||
if ann["fission-console/source-type"] != "code" {
|
||
t.Fatalf("annotation source-type = %q, want 'code'", ann["fission-console/source-type"])
|
||
}
|
||
|
||
// Entrypoint скопирован
|
||
ep, _, _ := unstructured.NestedString(cloneFn.Object, "spec", "package", "functionName")
|
||
if ep != "main.main" {
|
||
t.Fatalf("entrypoint = %q, want 'main.main'", ep)
|
||
}
|
||
|
||
// Timeout скопирован
|
||
timeout, _, _ := unstructured.NestedInt64(cloneFn.Object, "spec", "functionTimeout")
|
||
if timeout != 120 {
|
||
t.Fatalf("timeout = %d, want 120", timeout)
|
||
}
|
||
|
||
// Проверяем что HTTPTrigger создан
|
||
trigName := "src-copy-route"
|
||
cloneTrig, err := s.dyn.Resource(fission.HTTPTrigGVR).Namespace(ns).Get(ctx, trigName, metav1.GetOptions{})
|
||
if err != nil {
|
||
t.Fatalf("clone HTTPTrigger not found: %v", err)
|
||
}
|
||
|
||
// Методы скопированы из оригинального триггера
|
||
methods, _, _ := unstructured.NestedStringSlice(cloneTrig.Object, "spec", "methods")
|
||
if len(methods) != 2 {
|
||
t.Fatalf("methods = %v, want [GET POST]", methods)
|
||
}
|
||
|
||
// Маршрут сгенерирован автоматически (содержит new_name)
|
||
route, _, _ := unstructured.NestedString(cloneTrig.Object, "spec", "relativeurl")
|
||
if !strings.HasSuffix(route, "/src-copy") {
|
||
t.Fatalf("route = %q, should end with '/src-copy'", route)
|
||
}
|
||
}
|
||
|
||
// ─── Тест: маршрут задан явно ────────────────────────────────────────────────
|
||
|
||
func TestHandleCloneFunction_CustomRoute(t *testing.T) {
|
||
const ns = "fission-test"
|
||
zipData := makeZip(t, "main.py", "def main():\n return 'hi'\n")
|
||
|
||
pkg := packageWithLiteral(ns, "fn-pkg", "python", zipData)
|
||
fn := functionWithPkg(ns, "fn", "fn-pkg", "python", "main.main")
|
||
|
||
storagesvc := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||
fmt.Fprint(w, `{"id":"fission/arc-456"}`)
|
||
}))
|
||
defer storagesvc.Close()
|
||
|
||
s, _ := newCloneTestServer(t, nil, pkg, fn)
|
||
s.storagesvcURL = storagesvc.URL
|
||
s.http = storagesvc.Client()
|
||
|
||
rec := cloneRequest(t, s, "fn", `{"new_name":"fn-clone","route":"/custom/path"}`)
|
||
if rec.Code != http.StatusCreated {
|
||
t.Fatalf("status = %d, want 201; body=%s", rec.Code, rec.Body)
|
||
}
|
||
|
||
ctx := context.Background()
|
||
trig, err := s.dyn.Resource(fission.HTTPTrigGVR).Namespace(ns).Get(ctx, "fn-clone-route", metav1.GetOptions{})
|
||
if err != nil {
|
||
t.Fatalf("HTTPTrigger not found: %v", err)
|
||
}
|
||
route, _, _ := unstructured.NestedString(trig.Object, "spec", "relativeurl")
|
||
if route != "/custom/path" {
|
||
t.Fatalf("route = %q, want '/custom/path'", route)
|
||
}
|
||
}
|
||
|
||
// ─── Тест: маршрут без слеша — добавляется автоматически ─────────────────────
|
||
|
||
func TestHandleCloneFunction_RouteWithoutLeadingSlash(t *testing.T) {
|
||
const ns = "fission-test"
|
||
zipData := makeZip(t, "main.py", "def main():\n return 'hi'\n")
|
||
|
||
pkg := packageWithLiteral(ns, "fn2-pkg", "python", zipData)
|
||
fn := functionWithPkg(ns, "fn2", "fn2-pkg", "python", "main.main")
|
||
|
||
storagesvc := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||
fmt.Fprint(w, `{"id":"fission/arc-789"}`)
|
||
}))
|
||
defer storagesvc.Close()
|
||
|
||
s, _ := newCloneTestServer(t, nil, pkg, fn)
|
||
s.storagesvcURL = storagesvc.URL
|
||
s.http = storagesvc.Client()
|
||
|
||
rec := cloneRequest(t, s, "fn2", `{"new_name":"fn2-clone","route":"no-leading-slash"}`)
|
||
if rec.Code != http.StatusCreated {
|
||
t.Fatalf("status = %d, want 201; body=%s", rec.Code, rec.Body)
|
||
}
|
||
|
||
ctx := context.Background()
|
||
trig, err := s.dyn.Resource(fission.HTTPTrigGVR).Namespace(ns).Get(ctx, "fn2-clone-route", metav1.GetOptions{})
|
||
if err != nil {
|
||
t.Fatalf("HTTPTrigger not found: %v", err)
|
||
}
|
||
route, _, _ := unstructured.NestedString(trig.Object, "spec", "relativeurl")
|
||
if !strings.HasPrefix(route, "/") {
|
||
t.Fatalf("route = %q, should start with '/'", route)
|
||
}
|
||
}
|
||
|
||
// ─── Тест: дублирующее имя → 409 ─────────────────────────────────────────────
|
||
|
||
func TestHandleCloneFunction_DuplicateName_Conflict(t *testing.T) {
|
||
const ns = "fission-test"
|
||
zipData := makeZip(t, "main.py", "def main():\n return 'a'\n")
|
||
|
||
pkg := packageWithLiteral(ns, "dup-pkg", "python", zipData)
|
||
fn := functionWithPkg(ns, "dup-src", "dup-pkg", "python", "main.main")
|
||
// Уже существующая функция с именем "dup-copy"
|
||
existingFn := functionWithPkg(ns, "dup-copy", "other-pkg", "python", "main.main")
|
||
|
||
storagesvc := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||
fmt.Fprint(w, `{"id":"fission/arc-dup"}`)
|
||
}))
|
||
defer storagesvc.Close()
|
||
|
||
s, _ := newCloneTestServer(t, nil, pkg, fn, existingFn)
|
||
s.storagesvcURL = storagesvc.URL
|
||
s.http = storagesvc.Client()
|
||
|
||
rec := cloneRequest(t, s, "dup-src", `{"new_name":"dup-copy"}`)
|
||
if rec.Code != http.StatusConflict {
|
||
t.Fatalf("status = %d, want 409; body=%s", rec.Code, rec.Body)
|
||
}
|
||
if !strings.Contains(rec.Body.String(), "dup-copy") {
|
||
t.Fatalf("body should mention 'dup-copy', got: %s", rec.Body)
|
||
}
|
||
}
|
||
|
||
// ─── Тест: откат при ошибке создания Function ────────────────────────────────
|
||
|
||
func TestHandleCloneFunction_Rollback_OnFunctionConflict(t *testing.T) {
|
||
const ns = "fission-test"
|
||
zipData := makeZip(t, "main.py", "def main():\n return 'rb'\n")
|
||
|
||
pkg := packageWithLiteral(ns, "rb-pkg", "python", zipData)
|
||
fn := functionWithPkg(ns, "rb-src", "rb-pkg", "python", "main.main")
|
||
// Уже существующая функция с именем клона
|
||
existingFn := functionWithPkg(ns, "rb-clone", "other-pkg", "python", "main.main")
|
||
|
||
storagesvc := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||
fmt.Fprint(w, `{"id":"fission/arc-rb"}`)
|
||
}))
|
||
defer storagesvc.Close()
|
||
|
||
s, _ := newCloneTestServer(t, nil, pkg, fn, existingFn)
|
||
s.storagesvcURL = storagesvc.URL
|
||
s.http = storagesvc.Client()
|
||
|
||
rec := cloneRequest(t, s, "rb-src", `{"new_name":"rb-clone"}`)
|
||
if rec.Code != http.StatusConflict {
|
||
t.Fatalf("status = %d, want 409; body=%s", rec.Code, rec.Body)
|
||
}
|
||
|
||
// После rollback Package с именем "rb-clone-*" не должен остаться
|
||
ctx := context.Background()
|
||
pkgs, err := s.dyn.Resource(fission.PackageGVR).Namespace(ns).List(ctx, metav1.ListOptions{})
|
||
if err != nil {
|
||
t.Fatalf("list packages: %v", err)
|
||
}
|
||
for _, p := range pkgs.Items {
|
||
if strings.HasPrefix(p.GetName(), "rb-clone-") {
|
||
t.Fatalf("rollback failed: package %q still exists", p.GetName())
|
||
}
|
||
}
|
||
}
|
||
|
||
// ─── Тест: downloadPackageBytes — type:literal ────────────────────────────────
|
||
|
||
func TestDownloadPackageBytes_Literal(t *testing.T) {
|
||
s, _ := newCloneTestServer(t, nil)
|
||
|
||
original := []byte("hello from literal")
|
||
pkg := packageWithLiteral("fission-test", "lit-pkg", "python", original)
|
||
|
||
got, err := s.downloadPackageBytes(context.Background(), pkg)
|
||
if err != nil {
|
||
t.Fatalf("downloadPackageBytes error: %v", err)
|
||
}
|
||
if !bytes.Equal(got, original) {
|
||
t.Fatalf("got %q, want %q", got, original)
|
||
}
|
||
}
|
||
|
||
// ─── Тест: downloadPackageBytes — type:url ────────────────────────────────────
|
||
|
||
func TestDownloadPackageBytes_URL(t *testing.T) {
|
||
const content = "archive-content-from-storagesvc"
|
||
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||
fmt.Fprint(w, content)
|
||
}))
|
||
defer srv.Close()
|
||
|
||
pkg := packageWithURL("fission-test", "url-pkg", "python", srv.URL+"/v1/archive?id=abc")
|
||
s := &Server{http: srv.Client()}
|
||
|
||
got, err := s.downloadPackageBytes(context.Background(), pkg)
|
||
if err != nil {
|
||
t.Fatalf("downloadPackageBytes error: %v", err)
|
||
}
|
||
if string(got) != content {
|
||
t.Fatalf("got %q, want %q", got, content)
|
||
}
|
||
}
|
||
|
||
// ─── Тест: downloadPackageBytes — пустой Package → ошибка ────────────────────
|
||
|
||
func TestDownloadPackageBytes_EmptyPackage_Error(t *testing.T) {
|
||
s, _ := newCloneTestServer(t, nil)
|
||
emptyPkg := &unstructured.Unstructured{Object: map[string]any{
|
||
"apiVersion": "fission.io/v1",
|
||
"kind": "Package",
|
||
"metadata": map[string]any{"name": "empty", "namespace": "fission-test"},
|
||
"spec": map[string]any{},
|
||
}}
|
||
_, err := s.downloadPackageBytes(context.Background(), emptyPkg)
|
||
if err == nil {
|
||
t.Fatal("expected error for empty package, got nil")
|
||
}
|
||
}
|
||
|
||
// ─── Тест: downloadFromStoragesvc — non-200 → ошибка ────────────────────────
|
||
|
||
func TestDownloadFromStoragesvc_Non200(t *testing.T) {
|
||
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||
w.WriteHeader(http.StatusNotFound)
|
||
}))
|
||
defer srv.Close()
|
||
|
||
s := &Server{http: srv.Client()}
|
||
_, err := s.downloadFromStoragesvc(context.Background(), srv.URL+"/v1/archive?id=gone")
|
||
if err == nil {
|
||
t.Fatal("expected error for 404 response, got nil")
|
||
}
|
||
if !strings.Contains(err.Error(), "404") {
|
||
t.Fatalf("error should mention 404, got: %v", err)
|
||
}
|
||
}
|
||
|
||
// ─── Тест: getTriggerMethods — триггер существует ────────────────────────────
|
||
|
||
func TestGetTriggerMethods_Found(t *testing.T) {
|
||
const ns = "fission-test"
|
||
trig := httpTriggerObject(ns, "my-trig", "my-fn", "/my", []any{"GET", "POST"})
|
||
s, _ := newCloneTestServer(t, nil, trig)
|
||
|
||
methods := s.getTriggerMethods(context.Background(), ns, "my-fn")
|
||
if len(methods) != 2 {
|
||
t.Fatalf("methods = %v, want 2 elements", methods)
|
||
}
|
||
}
|
||
|
||
// ─── Тест: getTriggerMethods — триггера нет → nil ────────────────────────────
|
||
|
||
func TestGetTriggerMethods_NotFound(t *testing.T) {
|
||
s, _ := newCloneTestServer(t, nil)
|
||
methods := s.getTriggerMethods(context.Background(), "fission-test", "no-such-fn")
|
||
if methods != nil {
|
||
t.Fatalf("expected nil, got %v", methods)
|
||
}
|
||
}
|
||
|
||
// ─── Тест: невалидный JSON body → 400 ────────────────────────────────────────
|
||
|
||
func TestHandleCloneFunction_InvalidJSON(t *testing.T) {
|
||
s, _ := newCloneTestServer(t, nil)
|
||
req := httptest.NewRequest(http.MethodPost, "/console/api/functions/src/clone",
|
||
strings.NewReader(`not-json`))
|
||
rec := httptest.NewRecorder()
|
||
s.handleCloneFunction(rec, req, "src")
|
||
if rec.Code != http.StatusBadRequest {
|
||
t.Fatalf("status = %d, want 400; body=%s", rec.Code, rec.Body)
|
||
}
|
||
}
|
||
|
||
// ─── Тест: успешный клон — Package содержит ссылку на Function ───────────────
|
||
|
||
func TestHandleCloneFunction_PackageRefsCloneFunction(t *testing.T) {
|
||
const ns = "fission-test"
|
||
zipData := makeZip(t, "main.py", "def main():\n return 'ref'\n")
|
||
pkg := packageWithLiteral(ns, "ref-pkg", "python", zipData)
|
||
fn := functionWithPkg(ns, "ref-src", "ref-pkg", "python", "main.main")
|
||
|
||
storagesvc := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||
fmt.Fprint(w, `{"id":"fission/arc-ref"}`)
|
||
}))
|
||
defer storagesvc.Close()
|
||
|
||
s, _ := newCloneTestServer(t, nil, pkg, fn)
|
||
s.storagesvcURL = storagesvc.URL
|
||
s.http = storagesvc.Client()
|
||
|
||
rec := cloneRequest(t, s, "ref-src", `{"new_name":"ref-clone"}`)
|
||
if rec.Code != http.StatusCreated {
|
||
t.Fatalf("status = %d, want 201; body=%s", rec.Code, rec.Body)
|
||
}
|
||
|
||
ctx := context.Background()
|
||
cloneFn, err := s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Get(ctx, "ref-clone", metav1.GetOptions{})
|
||
if err != nil {
|
||
t.Fatalf("clone function not found: %v", err)
|
||
}
|
||
|
||
pkgRef, _, _ := unstructured.NestedString(cloneFn.Object, "spec", "package", "packageref", "name")
|
||
if !strings.HasPrefix(pkgRef, "ref-clone-") {
|
||
t.Fatalf("clone Function.spec.package.packageref.name = %q, should start with 'ref-clone-'", pkgRef)
|
||
}
|
||
|
||
// Package с этим именем должен существовать
|
||
_, err = s.dyn.Resource(fission.PackageGVR).Namespace(ns).Get(ctx, pkgRef, metav1.GetOptions{})
|
||
if err != nil {
|
||
t.Fatalf("clone Package %q not found: %v", pkgRef, err)
|
||
}
|
||
}
|