tyler.durden/gitea
1
0
Fork 0
mirror of https://github.com/go-gitea/gitea.git synced 2025-07-29 08:45:31 +02:00
Code Issues Packages Projects Releases Wiki Activity

Fit TF tests

Browse Source
This commit is contained in:
Shurkys 2025-01-17 16:03:52 +02:00 committed by GitHub
parent b5dd7ea6e1
commit 98775acb60
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
1 changed files with 89 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

202
tests/integration/api_packages_terraform_test.go
View File

@ -4,151 +4,127 @@
package integration package integration
import ( import (
"archive/tar"
"bytes" "bytes"
"compress/gzip"
"fmt" "fmt"
"io"
"net/http" "net/http"
"strings" "strings"
"testing" "testing"
auth_model "code.gitea.io/gitea/models/auth" "code.gitea.io/gitea/models/auth"
"code.gitea.io/gitea/models/db"
"code.gitea.io/gitea/models/packages"
"code.gitea.io/gitea/models/unittest" "code.gitea.io/gitea/models/unittest"
user_model "code.gitea.io/gitea/models/user" user_model "code.gitea.io/gitea/models/user"
"code.gitea.io/gitea/modules/json" "code.gitea.io/gitea/modules/json"
terraform_module "code.gitea.io/gitea/modules/packages/terraform"
"code.gitea.io/gitea/tests" "code.gitea.io/gitea/tests"
gouuid "github.com/google/uuid"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestPackageTerraform(t *testing.T) { func TestPackageTerraform(t *testing.T) {
defer tests.PrepareTestEnv(t)() defer tests.PrepareTestEnv(t)()
user := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 2}) user := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 2})
token := "Bearer " + getUserToken(t, user.Name, auth_model.AccessTokenScopeWritePackage) // Get token for the user
token := "Bearer " + getUserToken(t, user.Name, auth.AccessTokenScopeWritePackage)
packageName := "test_module" // Define important values
packageVersion := "1.0.1" lineage := "bca3c5f6-01dc-cdad-5310-d1b12e02e430"
packageDescription := "Test Terraform Module" terraformVersion := "1.10.4"
serial := float64(1)
resourceName := "hello"
resourceType := "null_resource"
id := gouuid.New().String() // Generate a unique ID
filename := "terraform_module.tar.gz" // Build the state JSON
buildState := func() string {
infoContent, _ := json.Marshal(map[string]string{ return `{
"description": packageDescription, "version": 4,
}) "terraform_version": "` + terraformVersion + `",
"serial": ` + fmt.Sprintf("%.0f", serial) + `,
var buf bytes.Buffer "lineage": "` + lineage + `",
zw := gzip.NewWriter(&buf) "outputs": {},
archive := tar.NewWriter(zw) "resources": [{
archive.WriteHeader(&tar.Header{ "mode": "managed",
Name: "info.json", "type": "` + resourceType + `",
Mode: 0o600, "name": "` + resourceName + `",
Size: int64(len(infoContent)), "provider": "provider[\"registry.terraform.io/hashicorp/null\"]",
}) "instances": [{
archive.Write(infoContent) "schema_version": 0,
archive.Close() "attributes": {
zw.Close() "id": "3832416504545530133",
content := buf.Bytes() "triggers": null
},
root := fmt.Sprintf("/api/packages/%s/terraform", user.Name) "sensitive_attributes": []
}]
t.Run("Authenticate", func(t *testing.T) { }],
defer tests.PrintCurrentTest(t)() "check_results": null
}`
authenticateURL := fmt.Sprintf("%s/authenticate", root) }
state := buildState()
req := NewRequest(t, "GET", authenticateURL) content := []byte(state)
MakeRequest(t, req, http.StatusUnauthorized) root := fmt.Sprintf("/api/packages/%s/terraform/state", user.Name)
stateURL := fmt.Sprintf("%s/providers-gitea.tfstate", root)
req = NewRequest(t, "GET", authenticateURL).
AddTokenAuth(token)
MakeRequest(t, req, http.StatusOK)
})
moduleURL := fmt.Sprintf("%s/%s", root, packageName)
// Upload test
t.Run("Upload", func(t *testing.T) { t.Run("Upload", func(t *testing.T) {
defer tests.PrintCurrentTest(t)() uploadURL := fmt.Sprintf("%s?ID=%s", stateURL, id)
req := NewRequestWithBody(t, "POST", uploadURL, bytes.NewReader(content)).AddTokenAuth(token)
resp := MakeRequest(t, req, http.StatusOK) // Expecting 200 OK
assert.Equal(t, http.StatusOK, resp.Code)
assert.Contains(t, resp.Header().Get("Content-Type"), "application/json")
bodyBytes, err := io.ReadAll(resp.Body)
require.NoError(t, err)
require.NotEmpty(t, bodyBytes)
})
req := NewRequest(t, "HEAD", moduleURL) // Download test
MakeRequest(t, req, http.StatusNotFound) t.Run("Download", func(t *testing.T) {
downloadURL := fmt.Sprintf("%s?ID=%s", stateURL, id)
uploadURL := fmt.Sprintf("%s/%s/%s", moduleURL, packageVersion, filename) req := NewRequest(t, "GET", downloadURL)
req = NewRequestWithBody(t, "PUT", uploadURL, bytes.NewReader(content))
MakeRequest(t, req, http.StatusUnauthorized)
req = NewRequestWithBody(t, "PUT", uploadURL, bytes.NewReader(content)).
AddTokenAuth(token)
MakeRequest(t, req, http.StatusCreated)
req = NewRequest(t, "HEAD", moduleURL)
resp := MakeRequest(t, req, http.StatusOK) resp := MakeRequest(t, req, http.StatusOK)
assert.True(t, strings.HasPrefix(resp.Header().Get("Content-Type"), "application/json")) assert.True(t, strings.HasPrefix(resp.Header().Get("Content-Type"), "application/json"))
pvs, err := packages.GetVersionsByPackageType(db.DefaultContext, user.ID, packages.TypeTerraform) bodyBytes, err := io.ReadAll(resp.Body)
assert.NoError(t, err) require.NoError(t, err)
assert.Len(t, pvs, 1) require.NotEmpty(t, bodyBytes)
pd, err := packages.GetPackageDescriptor(db.DefaultContext, pvs[0]) var jsonResponse map[string]any
assert.NoError(t, err) err = json.Unmarshal(bodyBytes, &jsonResponse)
assert.NotNil(t, pd.SemVer) require.NoError(t, err)
assert.IsType(t, &terraform_module.Metadata{}, pd.Metadata)
assert.Equal(t, packageName, pd.Package.Name)
assert.Equal(t, packageVersion, pd.Version.Version)
pfs, err := packages.GetFilesByVersionID(db.DefaultContext, pvs[0].ID) // Validate the response
assert.NoError(t, err) assert.Equal(t, lineage, jsonResponse["lineage"])
assert.Len(t, pfs, 1) assert.Equal(t, terraformVersion, jsonResponse["terraform_version"])
assert.Equal(t, filename, pfs[0].Name) assert.Equal(t, serial, jsonResponse["serial"])
assert.True(t, pfs[0].IsLead) resource := jsonResponse["resources"].([]any)[0].(map[string]any)
assert.Equal(t, resourceName, resource["name"])
pb, err := packages.GetBlobByID(db.DefaultContext, pfs[0].BlobID) assert.Equal(t, resourceType, resource["type"])
assert.NoError(t, err) assert.NotContains(t, resource, "sensitive_attributes")
assert.Equal(t, int64(len(content)), pb.Size)
req = NewRequestWithBody(t, "PUT", uploadURL, bytes.NewReader(content)).
AddTokenAuth(token)
MakeRequest(t, req, http.StatusConflict)
}) })
t.Run("Download", func(t *testing.T) { // Lock state test
defer tests.PrintCurrentTest(t)() t.Run("LockState", func(t *testing.T) {
lockURL := fmt.Sprintf("%s/lock?ID=%s", stateURL, id)
req := NewRequest(t, "GET", fmt.Sprintf("%s/%s/%s", moduleURL, packageVersion, filename)) req := NewRequestWithBody(t, "POST", lockURL, bytes.NewReader(content)).AddTokenAuth(token)
resp := MakeRequest(t, req, http.StatusOK) resp := MakeRequest(t, req, http.StatusOK) // Expecting 200 OK
assert.Equal(t, http.StatusOK, resp.Code)
assert.Equal(t, content, resp.Body.Bytes())
}) })
t.Run("EnumeratePackageVersions", func(t *testing.T) { // Unlock state test
defer tests.PrintCurrentTest(t)() t.Run("UnlockState", func(t *testing.T) {
unlockURL := fmt.Sprintf("%s/lock?ID=%s", stateURL, id)
req := NewRequestWithBody(t, "DELETE", unlockURL, bytes.NewReader(content)).AddTokenAuth(token)
resp := MakeRequest(t, req, http.StatusOK) // Expecting 200 OK
assert.Equal(t, http.StatusOK, resp.Code)
})
req := NewRequest(t, "GET", moduleURL) // Download not found test
resp := MakeRequest(t, req, http.StatusOK) t.Run("DownloadNotFound", func(t *testing.T) {
invalidStateURL := fmt.Sprintf("%s/invalid-state.tfstate?ID=%s", root, id)
type versionMetadata struct { req := NewRequest(t, "GET", invalidStateURL)
Version string `json:"version"` resp := MakeRequest(t, req, http.StatusNoContent) // Expecting 204 No Content
Status string `json:"status"` assert.Equal(t, http.StatusNoContent, resp.Code)
}
type packageMetadata struct {
Name string `json:"name"`
Description string `json:"description,omitempty"`
Versions []*versionMetadata `json:"versions"`
}
var result packageMetadata
DecodeJSON(t, resp, &result)
assert.Equal(t, packageName, result.Name)
assert.Equal(t, packageDescription, result.Description)
assert.Len(t, result.Versions, 1)
version := result.Versions[0]
assert.Equal(t, packageVersion, version.Version)
assert.Equal(t, "active", version.Status)
}) })
} }