diff --git a/README.md b/README.md
index 131195b..a3b2606 100644
--- a/README.md
+++ b/README.md
@@ -184,10 +184,16 @@ You can also connect using your IDE's remote debugging features (VS Code, GoLand
 # Unit tests
 make test
 
-# E2E tests
+# E2E tests (requires Kind cluster with Gitea)
+make create-kind-cluster  # Sets up cluster with Gitea
 make test-e2e
+
+# Bundle tests
+make test-e2e-bundle
 ```
 
+E2E tests use an in-cluster Gitea instance instead of GitHub, providing complete test isolation. See [Gitea Integration](docs/development/gitea-integration.md) for details on the test infrastructure.
+
 ### Linting
 
 ```bash
diff --git a/docs/development/gitea-integration.md b/docs/development/gitea-integration.md
new file mode 100644
index 0000000..034e782
--- /dev/null
+++ b/docs/development/gitea-integration.md
@@ -0,0 +1,200 @@
+# Gitea Integration for E2E Tests
+
+## Overview
+
+The e2e test suite uses an in-cluster Gitea instance to provide git repository functionality. This eliminates external dependencies on GitHub and provides complete isolation for testing.
+
+## Architecture
+
+- **Gitea Installation**: Deployed via Helm during cluster setup
+- **Network Access**: NodePort on port 30000 (HTTP) and 30022 (SSH)
+- **Service Discovery**: ConfigMap in kube-public namespace contains endpoint
+- **Authentication**: Admin user (giteaadmin/giteapass) for test operations
+- **Provider Abstraction**: Tests use `RepositoryProvider` interface, allowing easy switching between Gitea/GitHub/GitLab
+
+## Using Repository Provider in Tests
+
+### Basic Pattern
+
+```go
+var (
+    repoURL    string
+    repoDir    string
+)
+
+BeforeEach(func() {
+    var err error
+
+    // Create repository provider resources with automatic cleanup
+    username, password, _, cleanup, err := repoProvider.CreateRandomUser()
+    Expect(err).NotTo(HaveOccurred())
+    DeferCleanup(cleanup)
+
+    _, repoURL, cleanup, err = repoProvider.CreateRandomRepo(username, false)
+    Expect(err).NotTo(HaveOccurred())
+    DeferCleanup(cleanup)
+
+    // Initialize with function code
+    repoDir, err = InitializeRepoWithFunction(repoURL, username, password, "go")
+    Expect(err).NotTo(HaveOccurred())
+    DeferCleanup(os.RemoveAll, repoDir)
+})
+```
+
+### Available Helper Methods
+
+**RepositoryProvider Interface:**
+- `CreateUser(username, password, email string) (cleanup func(), err error)` - Create user with cleanup function
+- `CreateRandomUser() (username, password, email string, cleanup func(), err error)` - Create user with random credentials
+- `CreateRepo(owner, name string, private bool) (url string, cleanup func(), err error)` - Create repository
+- `CreateRandomRepo(owner string, private bool) (name, url string, cleanup func(), err error)` - Create repo with random name
+- `CreateAccessToken(username, password, tokenName string) (string, error)` - Generate access token
+
+**E2E Helper Functions:**
+- `InitializeRepoWithFunction(url, user, pass, lang)` - Clone, init function, push
+- `CommitAndPush(repoDir, msg, file, ...otherFiles)` - Commit and push files
+
+### DeferCleanup Pattern
+
+All Create methods return cleanup functions that can be used with Ginkgo's `DeferCleanup`:
+
+```go
+username, password, _, cleanup, err := repoProvider.CreateRandomUser()
+Expect(err).NotTo(HaveOccurred())
+DeferCleanup(cleanup)  // Automatically deletes user after test
+```
+
+This ensures resources are cleaned up even if tests fail.
+
+## Accessing Gitea UI
+
+During development, you can access the Gitea web UI:
+
+1. Get the Gitea endpoint:
+   ```bash
+   kubectl get configmap gitea-endpoint -n kube-public -o jsonpath='{.data.http}'
+   ```
+
+2. Open in browser and login:
+   - Username: `giteaadmin`
+   - Password: `giteapass`
+
+## Testing Private Repositories
+
+```go
+// Create private repo
+_, repoURL, cleanup, err := repoProvider.CreateRandomRepo(username, true)
+Expect(err).NotTo(HaveOccurred())
+DeferCleanup(cleanup)
+
+// Create access token
+token, err := repoProvider.CreateAccessToken(username, password, "test-token")
+
+// Use token in Function spec
+Spec: functionsdevv1alpha1.FunctionSpec{
+    Source: functionsdevv1alpha1.FunctionSpecSource{
+        RepositoryURL: repoURL,
+        Credentials: &functionsdevv1alpha1.Credentials{
+            Token: token,
+        },
+    },
+}
+```
+
+## Bundle Test Pattern
+
+Bundle tests use the `TestNamespace` struct for better organization:
+
+```go
+type TestNamespace struct {
+    Name    string
+    RepoURL string
+}
+
+func createNamespaceAndDeployFunction() TestNamespace {
+    // Creates namespace and deploys function
+    // Returns TestNamespace with both namespace and repo URL
+}
+
+// Usage
+testNs := createNamespaceAndDeployFunction()
+CreateFunctionAndWaitForReady(testNs)
+```
+
+## Troubleshooting
+
+### Gitea not accessible
+
+```bash
+kubectl get pods -n gitea
+kubectl logs -n gitea deployment/gitea
+```
+
+### ConfigMap missing
+
+```bash
+kubectl get configmap -n kube-public
+./hack/create-kind-cluster.sh  # Recreate cluster
+```
+
+### Test failures with git operations
+
+- Check Gitea pod is running
+- Verify network connectivity to NodePort:
+  ```bash
+  GITEA_IP=$(kubectl get configmap gitea-endpoint -n kube-public -o jsonpath='{.data.http}')
+  curl $GITEA_IP
+  ```
+- Check git credentials in test
+
+### Repository cleanup issues
+
+If tests leave behind repositories, you can clean them manually:
+
+```bash
+# List all users
+curl -u giteaadmin:giteapass http://<gitea-endpoint>/api/v1/admin/users
+
+# Delete user (includes their repos)
+curl -X DELETE -u giteaadmin:giteapass http://<gitea-endpoint>/api/v1/admin/users/<username>
+```
+
+## Implementation Details
+
+### Cluster Setup
+
+Gitea is installed during cluster creation in `hack/create-kind-cluster.sh`:
+
+```bash
+helm install gitea gitea-charts/gitea --namespace gitea --create-namespace \
+  --set service.http.type=NodePort \
+  --set service.http.nodePort=30000 \
+  --set gitea.admin.username=giteaadmin \
+  --set gitea.admin.password=giteapass \
+  --set persistence.enabled=false
+```
+
+### Service Discovery
+
+The cluster setup creates a ConfigMap with the Gitea endpoint:
+
+```yaml
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: gitea-endpoint
+  namespace: kube-public
+data:
+  http: "http://<node-ip>:30000"
+  ssh: "<node-ip>:30022"
+```
+
+Tests read this ConfigMap to discover where Gitea is running.
+
+### Networking
+
+- **Kind Node IP**: Retrieved via Docker inspect of control-plane node
+- **NodePort**: Fixed ports 30000 (HTTP) and 30022 (SSH)
+- **Accessibility**: Node IP is reachable from both host machine and cluster pods
+
+This allows the same repository URL to work in both test code (running on host) and Function resources (running in cluster).
\ No newline at end of file
diff --git a/go.mod b/go.mod
index 30769a0..82757c0 100644
--- a/go.mod
+++ b/go.mod
@@ -3,6 +3,7 @@ module github.com/functions-dev/func-operator
 go 1.25.0
 
 require (
+	code.gitea.io/sdk/gitea v0.23.2
 	github.com/go-git/go-git/v6 v6.0.0-20260114124804-a8db3a6585a6
 	github.com/go-logr/logr v1.4.3
 	github.com/onsi/ginkgo/v2 v2.27.5
@@ -21,6 +22,7 @@ require (
 require (
 	cel.dev/expr v0.24.0 // indirect
 	dario.cat/mergo v1.0.2 // indirect
+	github.com/42wim/httpsig v1.2.3 // indirect
 	github.com/BurntSushi/toml v1.5.0 // indirect
 	github.com/Masterminds/semver/v3 v3.4.0 // indirect
 	github.com/Microsoft/go-winio v0.6.2 // indirect
@@ -37,6 +39,7 @@ require (
 	github.com/coreos/go-semver v0.3.1 // indirect
 	github.com/cyphar/filepath-securejoin v0.6.1 // indirect
 	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
+	github.com/davidmz/go-pageant v1.0.2 // indirect
 	github.com/docker/cli v28.3.0+incompatible // indirect
 	github.com/docker/distribution v2.8.3+incompatible // indirect
 	github.com/docker/docker-credential-helpers v0.9.3 // indirect
@@ -46,6 +49,7 @@ require (
 	github.com/felixge/httpsnoop v1.0.4 // indirect
 	github.com/fsnotify/fsnotify v1.9.0 // indirect
 	github.com/fxamacker/cbor/v2 v2.9.0 // indirect
+	github.com/go-fed/httpsig v1.1.0 // indirect
 	github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 // indirect
 	github.com/go-git/gcfg/v2 v2.0.2 // indirect
 	github.com/go-git/go-billy/v5 v5.6.2 // indirect
@@ -77,6 +81,7 @@ require (
 	github.com/google/pprof v0.0.0-20260115054156-294ebfa9ad83 // indirect
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.3 // indirect
+	github.com/hashicorp/go-version v1.7.0 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
diff --git a/go.sum b/go.sum
index 6148abb..9146fd2 100644
--- a/go.sum
+++ b/go.sum
@@ -2,8 +2,12 @@ cel.dev/expr v0.24.0 h1:56OvJKSH3hDGL0ml5uSxZmz3/3Pq4tJ+fb1unVLAFcY=
 cel.dev/expr v0.24.0/go.mod h1:hLPLo1W4QUmuYdA72RBX06QTs6MXw941piREPl3Yfiw=
 cloud.google.com/go/compute/metadata v0.9.0 h1:pDUj4QMoPejqq20dK0Pg2N4yG9zIkYGdBtwLoEkH9Zs=
 cloud.google.com/go/compute/metadata v0.9.0/go.mod h1:E0bWwX5wTnLPedCKqk3pJmVgCBSM6qQI1yTBdEb3C10=
+code.gitea.io/sdk/gitea v0.23.2 h1:iJB1FDmLegwfwjX8gotBDHdPSbk/ZR8V9VmEJaVsJYg=
+code.gitea.io/sdk/gitea v0.23.2/go.mod h1:yyF5+GhljqvA30sRDreoyHILruNiy4ASufugzYg0VHM=
 dario.cat/mergo v1.0.2 h1:85+piFYR1tMbRrLcDwR18y4UKJ3aH1Tbzi24VRW1TK8=
 dario.cat/mergo v1.0.2/go.mod h1:E/hbnu0NxMFBjpMIE34DRGLWqDy0g5FuKDhCb31ngxA=
+github.com/42wim/httpsig v1.2.3 h1:xb0YyWhkYj57SPtfSttIobJUPJZB9as1nsfo7KWVcEs=
+github.com/42wim/httpsig v1.2.3/go.mod h1:nZq9OlYKDrUBhptd77IHx4/sZZD+IxTBADvAPI9G/EM=
 github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c h1:udKWzYgxTojEKWjV8V+WSxDXJ4NFATAsZjh8iIbsQIg=
 github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E=
 github.com/BurntSushi/toml v1.5.0 h1:W5quZX/G/csjUnuI8SUYlsHs9M38FC7znL0lIO+DvMg=
@@ -72,6 +76,8 @@ github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSs
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davidmz/go-pageant v1.0.2 h1:bPblRCh5jGU+Uptpz6LgMZGD5hJoOt7otgT454WvHn0=
+github.com/davidmz/go-pageant v1.0.2/go.mod h1:P2EDDnMqIwG5Rrp05dTRITj9z2zpGcD9efWSkTNKLIE=
 github.com/distribution/reference v0.6.0 h1:0IXCQ5g4/QMHHkarYzh5l+u8T3t73zM5QvfrDyIgxBk=
 github.com/distribution/reference v0.6.0/go.mod h1:BbU0aIcezP1/5jX/8MP0YiH4SdvB5Y4f/wlDRiLyi3E=
 github.com/docker/cli v28.3.0+incompatible h1:s+ttruVLhB5ayeuf2BciwDVxYdKi+RoUlxmwNHV3Vfo=
@@ -112,6 +118,8 @@ github.com/gliderlabs/ssh v0.3.8 h1:a4YXD1V7xMF9g5nTkdfnja3Sxy1PVDCj1Zg4Wb8vY6c=
 github.com/gliderlabs/ssh v0.3.8/go.mod h1:xYoytBv1sV0aL3CavoDuJIQNURXkkfPA/wxQ1pL1fAU=
 github.com/go-errors/errors v1.4.2 h1:J6MZopCL4uSllY1OfXM374weqZFFItUbrImctkmUxIA=
 github.com/go-errors/errors v1.4.2/go.mod h1:sIVyrIiJhuEF+Pj9Ebtd6P/rEYROXFi3BopGUQ5a5Og=
+github.com/go-fed/httpsig v1.1.0 h1:9M+hb0jkEICD8/cAiNqEB66R87tTINszBRTjwjQzWcI=
+github.com/go-fed/httpsig v1.1.0/go.mod h1:RCMrTZvN1bJYtofsG4rd5NaO5obxQ5xBkdiS7xsT7bM=
 github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 h1:+zs/tPmkDkHx3U66DAb0lQFJrpS6731Oaa12ikc+DiI=
 github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376/go.mod h1:an3vInlBmSxCcxctByoQdvwPiA7DTK7jaaFDBTtu0ic=
 github.com/go-git/gcfg/v2 v2.0.2 h1:MY5SIIfTGGEMhdA7d7JePuVVxtKL7Hp+ApGDJAJ7dpo=
@@ -204,6 +212,8 @@ github.com/gregjones/httpcache v0.0.0-20190611155906-901d90724c79 h1:+ngKgrYPPJr
 github.com/gregjones/httpcache v0.0.0-20190611155906-901d90724c79/go.mod h1:FecbI9+v66THATjSRHfNgh1IVFe/9kFxbXtjV0ctIMA=
 github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.3 h1:NmZ1PKzSTQbuGHw9DGPFomqkkLWMC+vZCkfs+FHv1Vg=
 github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.3/go.mod h1:zQrxl1YP88HQlA6i9c63DSVPFklWpGX4OWAc9bFuaH4=
+github.com/hashicorp/go-version v1.7.0 h1:5tqGy27NaOTB8yJKUZELlFAS/LTKJkrmONwQKeRZfjY=
+github.com/hashicorp/go-version v1.7.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
 github.com/hashicorp/golang-lru v1.0.2 h1:dV3g9Z/unq5DpblPpw+Oqcv4dU/1omnb4Ok8iPY6p1c=
 github.com/hashicorp/golang-lru v1.0.2/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
@@ -402,6 +412,9 @@ go.yaml.in/yaml/v2 v2.4.3 h1:6gvOSjQoTB3vt1l+CU+tSyi/HOjfOjRLJ4YwYZGwRO0=
 go.yaml.in/yaml/v2 v2.4.3/go.mod h1:zSxWcmIDjOzPXpjlTTbAsKokqkDNAVtZO0WOMiT90s8=
 go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
 go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20210513164829-c07d793c2f9a/go.mod h1:P+XmwS30IXTQdn5tA2iutPOUgjI07+tq3H3K9MVA1s8=
 golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
 golang.org/x/crypto v0.47.0 h1:V6e3FRj+n4dbpw86FJ8Fv7XVOql7TEwpHapKoMJ/GO8=
 golang.org/x/crypto v0.47.0/go.mod h1:ff3Y9VzzKbwSSEzWqJsJVBnWmRwRSHt/6Op5n9bQc4A=
@@ -409,6 +422,8 @@ golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0 h1:R84qjqJb5nVJMxqWYb3np9L5Z
 golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0/go.mod h1:S9Xr4PYopiDyqSyp5NjCrhFrqg6A5zA2E/iPHPhqnS8=
 golang.org/x/mod v0.32.0 h1:9F4d3PHLljb6x//jOyokMv3eX+YDeepZSEo3mFJy93c=
 golang.org/x/mod v0.32.0/go.mod h1:SgipZ/3h2Ci89DlEtEXWUk/HteuRin+HHhN+WbNhguU=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/net v0.49.0 h1:eeHFmOGUTtaaPSGNmjBKpbng9MulQsJURQUAfUwY++o=
 golang.org/x/net v0.49.0/go.mod h1:/ysNB2EvaqvesRkuLAyjI1ycPZlQHM3q01F02UY/MV8=
@@ -416,6 +431,8 @@ golang.org/x/oauth2 v0.34.0 h1:hqK/t4AKgbqWkdkcAeI8XLmbK+4m4G5YeQRrmiotGlw=
 golang.org/x/oauth2 v0.34.0/go.mod h1:lzm5WQJQwKZ3nwavOZ3IS5Aulzxi68dUSgRHujetwEA=
 golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4=
 golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -427,6 +444,8 @@ golang.org/x/sys v0.40.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.39.0 h1:RclSuaJf32jOqZz74CkPA9qFuVTX7vhLlpfj/IGWlqY=
 golang.org/x/term v0.39.0/go.mod h1:yxzUCTP/U+FzoxfdKmLaA0RV1WgE0VY7hXBwKtY/4ww=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.33.0 h1:B3njUFyqtHDUI5jMn1YIr5B0IE2U0qck04r6d4KPAxE=
 golang.org/x/text v0.33.0/go.mod h1:LuMebE6+rBincTi9+xWTY8TztLzKHc/9C1uBCG27+q8=
diff --git a/hack/create-kind-cluster.sh b/hack/create-kind-cluster.sh
index a0331f0..9920c2e 100755
--- a/hack/create-kind-cluster.sh
+++ b/hack/create-kind-cluster.sh
@@ -164,6 +164,40 @@ function install_keda() {
   kubectl wait deployment --all --timeout=-1s --for=condition=Available --namespace keda
 }
 
+function install_gitea() {
+  header_text "Installing Gitea"
+
+  helm repo add gitea-charts https://dl.gitea.com/charts/
+  helm repo update
+  helm install gitea gitea-charts/gitea --namespace gitea --create-namespace \
+    --set service.http.type=NodePort \
+    --set service.http.nodePort=30000 \
+    --set service.ssh.type=NodePort \
+    --set service.ssh.nodePort=30022 \
+    --set gitea.admin.username=giteaadmin \
+    --set gitea.admin.password=giteapass \
+    --set gitea.admin.email=admin@gitea.local \
+    --set persistence.enabled=false
+
+  header_text "Waiting for Gitea to become ready"
+  kubectl wait deployment --all --timeout=-1s --for=condition=Available --namespace gitea
+
+  # Get Gitea endpoint for tests
+  GITEA_NODE_IP=$(docker inspect kind-control-plane --format '{{.NetworkSettings.Networks.kind.IPAddress}}')
+
+  # Create ConfigMap with Gitea endpoint info
+  kubectl apply -f - <<EOF
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: gitea-endpoint
+  namespace: kube-public
+data:
+  http: "http://${GITEA_NODE_IP}:30000"
+  ssh: "${GITEA_NODE_IP}:30022"
+EOF
+}
+
 if [ "$DELETE_CLUSTER_BEFORE" = "true" ]; then
   delete_existing_cluster
 fi
@@ -175,5 +209,6 @@ install_tekton
 install_knative_serving
 install_knative_eventing
 install_keda
+install_gitea
 
-header_text "All components installed"
\ No newline at end of file
+header_text "All components installed"
diff --git a/test/e2e/bundle_test.go b/test/e2e/bundle_test.go
index 726c3d0..a0f5a70 100644
--- a/test/e2e/bundle_test.go
+++ b/test/e2e/bundle_test.go
@@ -29,18 +29,23 @@ import (
 	. "github.com/onsi/gomega"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/types"
-	"k8s.io/apimachinery/pkg/util/rand"
 )
 
 // The bundle e2e test run with a dedicated build tag to not infer with the other tests, as the bundle offers different
 // installation modes and also can make the operator to run in multiple namespaces
 
+// TestNamespace represents a test namespace with its associated repository
+type TestNamespace struct {
+	Name    string
+	RepoURL string
+}
+
 var _ = Describe("Bundle", Label("bundle"), Ordered, func() {
 
 	var (
 		bundleImage string // set in BeforeAll
 
-		namespaces []string
+		testNamespaces []TestNamespace
 	)
 
 	SetDefaultEventuallyTimeout(5 * time.Minute)
@@ -56,9 +61,9 @@ var _ = Describe("Bundle", Label("bundle"), Ordered, func() {
 		if specReport.Failed() {
 			// collect logs in case it failed
 			By("Collecting logs from deployed operators")
-			for _, ns := range namespaces {
-				By("Logs from operator in namespace " + ns)
-				cmd := exec.Command("kubectl", "logs", "-l", "control-plane=controller-manager", "--namespace", ns)
+			for _, testNs := range testNamespaces {
+				By("Logs from operator in namespace " + testNs.Name)
+				cmd := exec.Command("kubectl", "logs", "-l", "control-plane=controller-manager", "--namespace", testNs.Name)
 				controllerLogs, err := utils.Run(cmd)
 				if err == nil {
 					_, _ = fmt.Fprintf(GinkgoWriter, "Controller logs:\n %s", controllerLogs)
@@ -81,11 +86,11 @@ var _ = Describe("Bundle", Label("bundle"), Ordered, func() {
 	Context("with OwnNamespace installMode", func() {
 
 		BeforeAll(func() {
-			namespaces = createMultipleNamespaceAndDeployFunction(2)
+			testNamespaces = createMultipleNamespaceAndDeployFunction(2)
 
-			By("Installing the operator into " + namespaces[0])
+			By("Installing the operator into " + testNamespaces[0].Name)
 			out, err := utils.OperatorSdkRun("run", "bundle",
-				"--namespace", namespaces[0],
+				"--namespace", testNamespaces[0].Name,
 				"--install-mode", "OwnNamespace",
 				fmt.Sprintf("--skip-tls-verify=%v", registryInsecure),
 				bundleImage)
@@ -99,32 +104,32 @@ var _ = Describe("Bundle", Label("bundle"), Ordered, func() {
 				By("Uninstalling the operator")
 				out, err := utils.OperatorSdkRun("cleanup",
 					"func-operator",
-					"--namespace", namespaces[0])
+					"--namespace", testNamespaces[0].Name)
 				Expect(err).NotTo(HaveOccurred())
 				_, _ = fmt.Fprint(GinkgoWriter, out)
 
 				By("Cleanup resources")
-				cleanupNamespaces(namespaces)
+				cleanupTestNamespaces(testNamespaces...)
 			}
 		})
 
 		It("should reconcile function in own namespace", func() {
-			CreateFunctionAndWaitForReady(namespaces[0])
+			CreateFunctionAndWaitForReady(testNamespaces[0])
 		})
 		It("should not reconcile function in other namespace", func() {
-			CreateFunctionAndWaitForConsistentlyNotReconciled(namespaces[1])
+			CreateFunctionAndWaitForConsistentlyNotReconciled(testNamespaces[1])
 		})
 	})
 
 	Context("with SingleNamespace installMode", func() {
 		BeforeAll(func() {
 			By("Setting up test namespaces")
-			namespaces = createMultipleNamespaceAndDeployFunction(3)
+			testNamespaces = createMultipleNamespaceAndDeployFunction(3)
 
-			By("Installing the operator into " + namespaces[0] + " for " + namespaces[1])
+			By("Installing the operator into " + testNamespaces[0].Name + " for " + testNamespaces[1].Name)
 			out, err := utils.OperatorSdkRun("run", "bundle",
-				"--namespace", namespaces[0],
-				"--install-mode", fmt.Sprintf("SingleNamespace=%s", namespaces[1]),
+				"--namespace", testNamespaces[0].Name,
+				"--install-mode", fmt.Sprintf("SingleNamespace=%s", testNamespaces[1].Name),
 				fmt.Sprintf("--skip-tls-verify=%v", registryInsecure),
 				bundleImage)
 			Expect(err).NotTo(HaveOccurred())
@@ -137,33 +142,34 @@ var _ = Describe("Bundle", Label("bundle"), Ordered, func() {
 				By("Uninstalling the operator")
 				out, err := utils.OperatorSdkRun("cleanup",
 					"func-operator",
-					"--namespace", namespaces[0])
+					"--namespace", testNamespaces[0].Name)
 				Expect(err).NotTo(HaveOccurred())
 				_, _ = fmt.Fprint(GinkgoWriter, out)
 
 				By("Cleanup resources")
-				cleanupNamespaces(namespaces)
+				cleanupTestNamespaces(testNamespaces...)
 			}
 		})
 
 		It("should reconcile function in dedicated namespace", func() {
-			CreateFunctionAndWaitForReady(namespaces[1])
+			CreateFunctionAndWaitForReady(testNamespaces[1])
 		})
 		It("should not reconcile function in other namespace", func() {
-			CreateFunctionAndWaitForConsistentlyNotReconciled(namespaces[0])
-			CreateFunctionAndWaitForConsistentlyNotReconciled(namespaces[2])
+			CreateFunctionAndWaitForConsistentlyNotReconciled(testNamespaces[0])
+			CreateFunctionAndWaitForConsistentlyNotReconciled(testNamespaces[2])
 		})
 	})
 
 	Context("with MultiNamespace installMode", func() {
 		BeforeAll(func() {
 			By("Setting up test namespaces")
-			namespaces = createMultipleNamespaceAndDeployFunction(4)
+			testNamespaces = createMultipleNamespaceAndDeployFunction(4)
 
-			By("Installing the operator into " + namespaces[0] + " for " + namespaces[1] + " and " + namespaces[2])
+			By("Installing the operator into " + testNamespaces[0].Name +
+				" for " + testNamespaces[1].Name + " and " + testNamespaces[2].Name)
 			out, err := utils.OperatorSdkRun("run", "bundle",
-				"--namespace", namespaces[0],
-				"--install-mode", fmt.Sprintf("MultiNamespace=%s,%s", namespaces[1], namespaces[2]),
+				"--namespace", testNamespaces[0].Name,
+				"--install-mode", fmt.Sprintf("MultiNamespace=%s,%s", testNamespaces[1].Name, testNamespaces[2].Name),
 				fmt.Sprintf("--skip-tls-verify=%v", registryInsecure),
 				bundleImage)
 			Expect(err).NotTo(HaveOccurred())
@@ -176,43 +182,43 @@ var _ = Describe("Bundle", Label("bundle"), Ordered, func() {
 				By("Uninstalling the operator")
 				out, err := utils.OperatorSdkRun("cleanup",
 					"func-operator",
-					"--namespace", namespaces[0])
+					"--namespace", testNamespaces[0].Name)
 				Expect(err).NotTo(HaveOccurred())
 				_, _ = fmt.Fprint(GinkgoWriter, out)
 
 				By("Cleanup resources")
-				cleanupNamespaces(namespaces)
+				cleanupTestNamespaces(testNamespaces...)
 			}
 		})
 
 		It("should reconcile function in dedicated namespaces", func() {
-			CreateFunctionAndWaitForReady(namespaces[1])
-			CreateFunctionAndWaitForReady(namespaces[2])
+			CreateFunctionAndWaitForReady(testNamespaces[1])
+			CreateFunctionAndWaitForReady(testNamespaces[2])
 		})
 		It("should not reconcile function in other namespace", func() {
-			CreateFunctionAndWaitForConsistentlyNotReconciled(namespaces[0])
-			CreateFunctionAndWaitForConsistentlyNotReconciled(namespaces[3])
+			CreateFunctionAndWaitForConsistentlyNotReconciled(testNamespaces[0])
+			CreateFunctionAndWaitForConsistentlyNotReconciled(testNamespaces[3])
 		})
 	})
 
 	Context("with two instances with SingleNamespace installMode installed into two distinct namespaces", func() {
 		BeforeAll(func() {
 			By("Setting up test namespaces")
-			namespaces = createMultipleNamespaceAndDeployFunction(4)
+			testNamespaces = createMultipleNamespaceAndDeployFunction(4)
 
-			By("Installing the operator into " + namespaces[0] + " for " + namespaces[1])
+			By("Installing the operator into " + testNamespaces[0].Name + " for " + testNamespaces[1].Name)
 			out, err := utils.OperatorSdkRun("run", "bundle",
-				"--namespace", namespaces[0],
-				"--install-mode", fmt.Sprintf("SingleNamespace=%s", namespaces[1]),
+				"--namespace", testNamespaces[0].Name,
+				"--install-mode", fmt.Sprintf("SingleNamespace=%s", testNamespaces[1].Name),
 				fmt.Sprintf("--skip-tls-verify=%v", registryInsecure),
 				bundleImage)
 			Expect(err).NotTo(HaveOccurred())
 			_, _ = fmt.Fprint(GinkgoWriter, out)
 
-			By("Installing the operator into " + namespaces[2] + " for " + namespaces[3])
+			By("Installing the operator into " + testNamespaces[2].Name + " for " + testNamespaces[3].Name)
 			out, err = utils.OperatorSdkRun("run", "bundle",
-				"--namespace", namespaces[2],
-				"--install-mode", fmt.Sprintf("SingleNamespace=%s", namespaces[3]),
+				"--namespace", testNamespaces[2].Name,
+				"--install-mode", fmt.Sprintf("SingleNamespace=%s", testNamespaces[3].Name),
 				fmt.Sprintf("--skip-tls-verify=%v", registryInsecure),
 				bundleImage)
 			Expect(err).NotTo(HaveOccurred())
@@ -222,44 +228,44 @@ var _ = Describe("Bundle", Label("bundle"), Ordered, func() {
 		AfterAll(func() {
 			specReport := CurrentSpecReport()
 			if !specReport.Failed() {
-				By("Uninstalling the operator from " + namespaces[0])
+				By("Uninstalling the operator from " + testNamespaces[0].Name)
 				out, err := utils.OperatorSdkRun("cleanup",
 					"func-operator",
-					"--namespace", namespaces[0],
+					"--namespace", testNamespaces[0].Name,
 					"--delete-operator-groups") // dont delete CRDs, as operator in ns3 still has them
 				Expect(err).NotTo(HaveOccurred())
 				_, _ = fmt.Fprint(GinkgoWriter, out)
 
-				By("Uninstalling the operator from " + namespaces[2])
+				By("Uninstalling the operator from " + testNamespaces[2].Name)
 				out, err = utils.OperatorSdkRun("cleanup",
 					"func-operator",
-					"--namespace", namespaces[2])
+					"--namespace", testNamespaces[2].Name)
 				Expect(err).NotTo(HaveOccurred())
 				_, _ = fmt.Fprint(GinkgoWriter, out)
 
 				By("Cleanup resources")
-				cleanupNamespaces(namespaces)
+				cleanupTestNamespaces(testNamespaces...)
 			}
 		})
 
 		It("should reconcile function in dedicated namespaces", func() {
-			CreateFunctionAndWaitForReady(namespaces[1])
-			CreateFunctionAndWaitForReady(namespaces[3])
+			CreateFunctionAndWaitForReady(testNamespaces[1])
+			CreateFunctionAndWaitForReady(testNamespaces[3])
 		})
 		It("should not reconcile function in other namespace", func() {
-			CreateFunctionAndWaitForConsistentlyNotReconciled(namespaces[0])
-			CreateFunctionAndWaitForConsistentlyNotReconciled(namespaces[2])
+			CreateFunctionAndWaitForConsistentlyNotReconciled(testNamespaces[0])
+			CreateFunctionAndWaitForConsistentlyNotReconciled(testNamespaces[2])
 		})
 	})
 
 	Context("with AllNamespace installMode", func() {
 		BeforeAll(func() {
 			By("Setting up test namespaces")
-			namespaces = createMultipleNamespaceAndDeployFunction(2)
+			testNamespaces = createMultipleNamespaceAndDeployFunction(2)
 
-			By("Installing the operator into " + namespaces[0])
+			By("Installing the operator into " + testNamespaces[0].Name)
 			out, err := utils.OperatorSdkRun("run", "bundle",
-				"--namespace", namespaces[0],
+				"--namespace", testNamespaces[0].Name,
 				"--install-mode", "AllNamespaces",
 				fmt.Sprintf("--skip-tls-verify=%v", registryInsecure),
 				bundleImage)
@@ -273,32 +279,32 @@ var _ = Describe("Bundle", Label("bundle"), Ordered, func() {
 				By("Uninstalling the operator")
 				out, err := utils.OperatorSdkRun("cleanup",
 					"func-operator",
-					"--namespace", namespaces[0])
+					"--namespace", testNamespaces[0].Name)
 				Expect(err).NotTo(HaveOccurred())
 				_, _ = fmt.Fprint(GinkgoWriter, out)
 
 				By("Cleanup resources")
-				cleanupNamespaces(namespaces)
+				cleanupTestNamespaces(testNamespaces...)
 			}
 		})
 
 		It("should reconcile function in all namespaces", func() {
-			CreateFunctionAndWaitForReady(namespaces[0])
-			CreateFunctionAndWaitForReady(namespaces[1])
+			CreateFunctionAndWaitForReady(testNamespaces[0])
+			CreateFunctionAndWaitForReady(testNamespaces[1])
 		})
 	})
 })
 
-func CreateFunctionAndWaitForReady(namespace string) {
+func CreateFunctionAndWaitForReady(testNs TestNamespace) {
 	// Create a Function resource
 	function := &functionsdevv1alpha1.Function{
 		ObjectMeta: metav1.ObjectMeta{
 			GenerateName: "my-function-",
-			Namespace:    namespace,
+			Namespace:    testNs.Name,
 		},
 		Spec: functionsdevv1alpha1.FunctionSpec{
 			Source: functionsdevv1alpha1.FunctionSpecSource{
-				RepositoryURL: "https://github.com/creydr/func-go-hello-world",
+				RepositoryURL: testNs.RepoURL,
 			},
 			Registry: functionsdevv1alpha1.FunctionSpecRegistry{
 				Path:     registry,
@@ -327,16 +333,16 @@ func CreateFunctionAndWaitForReady(namespace string) {
 	Eventually(funcBecomeReady, 5*time.Minute).Should(Succeed())
 }
 
-func CreateFunctionAndWaitForConsistentlyNotReconciled(namespace string) {
+func CreateFunctionAndWaitForConsistentlyNotReconciled(testNs TestNamespace) {
 	// Create a Function resource
 	function := &functionsdevv1alpha1.Function{
 		ObjectMeta: metav1.ObjectMeta{
 			GenerateName: "my-function-",
-			Namespace:    namespace,
+			Namespace:    testNs.Name,
 		},
 		Spec: functionsdevv1alpha1.FunctionSpec{
 			Source: functionsdevv1alpha1.FunctionSpecSource{
-				RepositoryURL: "https://github.com/creydr/func-go-hello-world",
+				RepositoryURL: testNs.RepoURL,
 			},
 			Registry: functionsdevv1alpha1.FunctionSpecRegistry{
 				Path:     registry,
@@ -360,19 +366,28 @@ func CreateFunctionAndWaitForConsistentlyNotReconciled(namespace string) {
 	Consistently(funcNotReconciled, time.Minute).Should(Succeed())
 }
 
-func createNamespaceAndDeployFunction() string {
+func createNamespaceAndDeployFunction() TestNamespace {
+	var err error
 	ns, err := utils.GetTestNamespace()
 	Expect(err).NotTo(HaveOccurred())
 
-	tempDir := fmt.Sprintf("%s/func-operator-e2e-%s", os.TempDir(), rand.String(10))
+	// Create repository provider resources
+	username, password, _, cleanup, err := repoProvider.CreateRandomUser()
 	Expect(err).NotTo(HaveOccurred())
+	DeferCleanup(cleanup)
 
-	cmd := exec.Command("git", "clone", "https://github.com/creydr/func-go-hello-world", tempDir)
-	_, err = utils.Run(cmd)
+	_, repoURL, cleanup, err := repoProvider.CreateRandomRepo(username, false)
 	Expect(err).NotTo(HaveOccurred())
+	DeferCleanup(cleanup)
 
-	cmd = exec.Command("func", "deploy",
-		"--path", tempDir,
+	// Initialize repo with function code
+	repoDir, err := InitializeRepoWithFunction(repoURL, username, password, "go")
+	Expect(err).NotTo(HaveOccurred())
+	DeferCleanup(os.RemoveAll, repoDir)
+
+	// Deploy function
+	cmd := exec.Command("func", "deploy",
+		"--path", repoDir,
 		"--registry", registry,
 		"--registry-insecure", strconv.FormatBool(registryInsecure),
 		"--namespace", ns)
@@ -380,29 +395,31 @@ func createNamespaceAndDeployFunction() string {
 	Expect(err).NotTo(HaveOccurred())
 	_, _ = fmt.Fprint(GinkgoWriter, out)
 
-	// cleanup the repo to not run into resource issues
-	cmd = exec.Command("rm", "-rf", tempDir)
-	_, err = utils.Run(cmd)
-	Expect(err).NotTo(HaveOccurred())
-
-	return ns
+	return TestNamespace{Name: ns, RepoURL: repoURL}
 }
 
 // createMultipleNamespaceAndDeployFunction creates multiple namespaces with functions
-func createMultipleNamespaceAndDeployFunction(count int) []string {
-	namespaces := make([]string, count)
+func createMultipleNamespaceAndDeployFunction(count int) []TestNamespace {
+	testNamespaces := make([]TestNamespace, count)
 
 	for i := 0; i < count; i++ {
 		// parallelizing this via goroutines seems to lead to resource issues, therefore keeping it sequential
-		namespaces[i] = createNamespaceAndDeployFunction()
+		testNamespaces[i] = createNamespaceAndDeployFunction()
 	}
 
-	return namespaces
+	return testNamespaces
+}
+
+func cleanupTestNamespaces(testNamespaces ...TestNamespace) {
+	By("Cleaning up test namespaces resources")
+	for _, testNs := range testNamespaces {
+		cleanupNamespaces(testNs.Name)
+	}
 }
 
-func cleanupNamespaces(namespaces []string) {
-	By("Cleaning up all resources")
+func cleanupNamespaces(namespaces ...string) {
 	for _, ns := range namespaces {
+		By("Cleaning up namespace " + ns)
 		cmd := exec.Command("kubectl", "delete", "namespace", ns, "--ignore-not-found")
 		_, err := utils.Run(cmd)
 		Expect(err).NotTo(HaveOccurred())
diff --git a/test/e2e/e2e_suite_test.go b/test/e2e/e2e_suite_test.go
index 1604222..a6ebafd 100644
--- a/test/e2e/e2e_suite_test.go
+++ b/test/e2e/e2e_suite_test.go
@@ -30,6 +30,7 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/client"
 
 	functionsdevv1alpha1 "github.com/functions-dev/func-operator/api/v1alpha1"
+	"github.com/functions-dev/func-operator/test/utils"
 )
 
 var (
@@ -38,6 +39,8 @@ var (
 
 	registry         string
 	registryInsecure bool
+
+	repoProvider utils.RepositoryProvider
 )
 
 // TestE2E runs the end-to-end (e2e) test suite for the project. These tests execute in an isolated,
@@ -79,4 +82,9 @@ var _ = BeforeSuite(func() {
 	if sec := os.Getenv("REGISTRY_INSECURE"); strings.ToLower(sec) == "true" {
 		registryInsecure = true
 	}
+
+	// Initialize repository provider (Gitea)
+	repoProvider, err = utils.NewGiteaClient()
+	Expect(err).NotTo(HaveOccurred())
+	Expect(repoProvider).NotTo(BeNil())
 })
diff --git a/test/e2e/e2e_test.go b/test/e2e/e2e_test.go
index b500437..bcd5ba3 100644
--- a/test/e2e/e2e_test.go
+++ b/test/e2e/e2e_test.go
@@ -39,7 +39,7 @@ const metricsServiceName = "func-operator-controller-manager-metrics-service"
 // metricsPort is the port of the metrics service providing the managers metrics
 const metricsPort = "8080"
 
-var _ = Describe("Manager", Ordered, func() {
+var _ = Describe("Manager", func() {
 	var controllerPodName string
 
 	// After each test, check for failures and collect logs, events,
diff --git a/test/e2e/func_deploy_test.go b/test/e2e/func_deploy_test.go
index 699f259..9ea5115 100644
--- a/test/e2e/func_deploy_test.go
+++ b/test/e2e/func_deploy_test.go
@@ -29,35 +29,58 @@ import (
 	. "github.com/onsi/gomega"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/types"
-	"k8s.io/apimachinery/pkg/util/rand"
 )
 
-var _ = Describe("Operator", Ordered, func() {
+var _ = Describe("Operator", func() {
 
 	SetDefaultEventuallyTimeout(2 * time.Minute)
 	SetDefaultEventuallyPollingInterval(time.Second)
 
 	Context("with a deployed function", func() {
-		var tempDir string
+		var repoURL string
+		var repoDir string
 		var functionName, functionNamespace string
 
 		BeforeEach(func() {
 			var err error
-			// deploy function
-			tempDir = fmt.Sprintf("%s/func-operator-e2e-%s", os.TempDir(), rand.String(10))
+
+			// Create repository provider resources with automatic cleanup
+			username, password, _, cleanup, err := repoProvider.CreateRandomUser()
+			Expect(err).NotTo(HaveOccurred())
+			DeferCleanup(cleanup)
+
+			_, repoURL, cleanup, err = repoProvider.CreateRandomRepo(username, false)
 			Expect(err).NotTo(HaveOccurred())
+			DeferCleanup(cleanup)
 
-			cmd := exec.Command("git", "clone", "https://github.com/creydr/func-go-hello-world", tempDir)
-			_, err = utils.Run(cmd)
+			// Initialize repository with function code
+			repoDir, err = InitializeRepoWithFunction(repoURL, username, password, "go")
 			Expect(err).NotTo(HaveOccurred())
+			DeferCleanup(os.RemoveAll, repoDir)
 
-			cmd = exec.Command("func", "deploy",
-				"--path", tempDir,
+			functionNamespace, err = utils.GetTestNamespace()
+			Expect(err).NotTo(HaveOccurred())
+			DeferCleanup(cleanupNamespaces, functionNamespace)
+
+			// Deploy function using func CLI
+			cmd := exec.Command("func", "deploy",
+				"--namespace", functionNamespace,
+				"--path", repoDir,
 				"--registry", registry,
 				"--registry-insecure", strconv.FormatBool(registryInsecure))
 			out, err := utils.Run(cmd)
 			Expect(err).NotTo(HaveOccurred())
 			_, _ = fmt.Fprint(GinkgoWriter, out)
+
+			// Cleanup func deployment
+			DeferCleanup(func() {
+				cmd := exec.Command("func", "delete", "--path", repoDir, "--namespace", functionNamespace)
+				_, _ = utils.Run(cmd)
+			})
+
+			// Commit func.yaml changes
+			err = CommitAndPush(repoDir, "Update func.yaml after deploy", "func.yaml")
+			Expect(err).NotTo(HaveOccurred())
 		})
 
 		AfterEach(func() {
@@ -83,15 +106,12 @@ var _ = Describe("Operator", Ordered, func() {
 				}
 			}
 
-			if tempDir != "" {
-				cmd := exec.Command("func", "delete", "--path", tempDir)
+			// Cleanup function resource
+			if functionName != "" {
+				cmd := exec.Command("kubectl", "delete", "function", functionName, "-n", functionNamespace, "--ignore-not-found")
 				_, err := utils.Run(cmd)
 				Expect(err).NotTo(HaveOccurred())
 			}
-
-			cmd := exec.Command("kubectl", "delete", "function", functionName, "-n", functionNamespace, "--ignore-not-found")
-			_, err := utils.Run(cmd)
-			Expect(err).NotTo(HaveOccurred())
 		})
 
 		It("should mark the function as ready", func() {
@@ -99,11 +119,11 @@ var _ = Describe("Operator", Ordered, func() {
 			function := &functionsdevv1alpha1.Function{
 				ObjectMeta: metav1.ObjectMeta{
 					GenerateName: "my-function-",
-					Namespace:    "default",
+					Namespace:    functionNamespace,
 				},
 				Spec: functionsdevv1alpha1.FunctionSpec{
 					Source: functionsdevv1alpha1.FunctionSpecSource{
-						RepositoryURL: "https://github.com/creydr/func-go-hello-world",
+						RepositoryURL: repoURL,
 					},
 					Registry: functionsdevv1alpha1.FunctionSpecRegistry{
 						Path:     registry,
@@ -116,7 +136,6 @@ var _ = Describe("Operator", Ordered, func() {
 			Expect(err).NotTo(HaveOccurred())
 
 			functionName = function.Name
-			functionNamespace = function.Namespace
 
 			funcBecomeReady := func(g Gomega) {
 				fn := &functionsdevv1alpha1.Function{}
@@ -137,12 +156,39 @@ var _ = Describe("Operator", Ordered, func() {
 		})
 	})
 	Context("with a not yet deployed function", func() {
+		var repoURL string
+		var repoDir string
 		var functionName, functionNamespace string
 
-		AfterEach(func() {
-			cmd := exec.Command("kubectl", "delete", "function", functionName, "-n", functionNamespace, "--ignore-not-found")
-			_, err := utils.Run(cmd)
+		BeforeEach(func() {
+			var err error
+
+			// Create repository with function code but don't deploy
+			username, password, _, cleanup, err := repoProvider.CreateRandomUser()
+			Expect(err).NotTo(HaveOccurred())
+			DeferCleanup(cleanup)
+
+			_, repoURL, cleanup, err = repoProvider.CreateRandomRepo(username, false)
+			Expect(err).NotTo(HaveOccurred())
+			DeferCleanup(cleanup)
+
+			// Initialize repository with function code
+			repoDir, err = InitializeRepoWithFunction(repoURL, username, password, "go")
+			Expect(err).NotTo(HaveOccurred())
+			DeferCleanup(os.RemoveAll, repoDir)
+
+			functionNamespace, err = utils.GetTestNamespace()
 			Expect(err).NotTo(HaveOccurred())
+			DeferCleanup(cleanupNamespaces, functionNamespace)
+		})
+
+		AfterEach(func() {
+			// Cleanup function resource
+			if functionName != "" {
+				cmd := exec.Command("kubectl", "delete", "function", functionName, "-n", functionNamespace, "--ignore-not-found")
+				_, err := utils.Run(cmd)
+				Expect(err).NotTo(HaveOccurred())
+			}
 		})
 
 		It("should mark the function as not ready", func() {
@@ -150,11 +196,11 @@ var _ = Describe("Operator", Ordered, func() {
 			function := &functionsdevv1alpha1.Function{
 				ObjectMeta: metav1.ObjectMeta{
 					GenerateName: "my-undeployed-function-",
-					Namespace:    "default",
+					Namespace:    functionNamespace,
 				},
 				Spec: functionsdevv1alpha1.FunctionSpec{
 					Source: functionsdevv1alpha1.FunctionSpecSource{
-						RepositoryURL: "https://github.com/creydr/func-go-hello-world",
+						RepositoryURL: repoURL,
 					},
 					Registry: functionsdevv1alpha1.FunctionSpecRegistry{
 						Path:     registry,
@@ -167,7 +213,6 @@ var _ = Describe("Operator", Ordered, func() {
 			Expect(err).NotTo(HaveOccurred())
 
 			functionName = function.Name
-			functionNamespace = function.Namespace
 
 			funcBecomeReady := func(g Gomega) {
 				fn := &functionsdevv1alpha1.Function{}
diff --git a/test/e2e/gitea_helpers.go b/test/e2e/gitea_helpers.go
new file mode 100644
index 0000000..abc6263
--- /dev/null
+++ b/test/e2e/gitea_helpers.go
@@ -0,0 +1,117 @@
+/*
+Copyright 2025.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package e2e
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+
+	"github.com/functions-dev/func-operator/test/utils"
+	"k8s.io/apimachinery/pkg/util/rand"
+)
+
+// buildAuthURL embeds credentials into git URL for authenticated operations
+func buildAuthURL(repoURL, username, password string) string {
+	return strings.Replace(repoURL, "http://",
+		fmt.Sprintf("http://%s:%s@", username, password), 1)
+}
+
+// InitializeRepoWithFunction creates a function project and pushes it to the Gitea repo
+func InitializeRepoWithFunction(repoURL, username, password, language string) (repoDir string, err error) {
+	repoDir = fmt.Sprintf("%s/func-test-%s", os.TempDir(), rand.String(10))
+
+	// Build authenticated URL
+	authURL := buildAuthURL(repoURL, username, password)
+
+	// Initialize function (func init creates the directory)
+	cmd := exec.Command("func", "init", "-l", language, repoDir)
+	if _, err = utils.Run(cmd); err != nil {
+		return "", fmt.Errorf("failed to init function: %w", err)
+	}
+
+	// Initialize git repo with main as default branch
+	cmd = exec.Command("git", "-C", repoDir, "init", "-b", "main")
+	if _, err = utils.Run(cmd); err != nil {
+		return "", fmt.Errorf("failed to git init: %w", err)
+	}
+
+	// Configure git user
+	cmd = exec.Command("git", "-C", repoDir, "config", "user.name", "Test User")
+	if _, err = utils.Run(cmd); err != nil {
+		return "", fmt.Errorf("failed to set git user.name: %w", err)
+	}
+	cmd = exec.Command("git", "-C", repoDir, "config", "user.email", "test@example.com")
+	if _, err = utils.Run(cmd); err != nil {
+		return "", fmt.Errorf("failed to set git user.email: %w", err)
+	}
+
+	// Add remote
+	cmd = exec.Command("git", "-C", repoDir, "remote", "add", "origin", authURL)
+	if _, err = utils.Run(cmd); err != nil {
+		return "", fmt.Errorf("failed to add remote: %w", err)
+	}
+
+	// Commit and push
+	cmd = exec.Command("git", "-C", repoDir, "add", ".")
+	if _, err = utils.Run(cmd); err != nil {
+		return "", fmt.Errorf("failed to git add: %w", err)
+	}
+	cmd = exec.Command("git", "-C", repoDir, "commit", "-m", "Initial function")
+	if _, err = utils.Run(cmd); err != nil {
+		return "", fmt.Errorf("failed to git commit: %w", err)
+	}
+	cmd = exec.Command("git", "-C", repoDir, "push", "-u", "origin", "main")
+	if _, err = utils.Run(cmd); err != nil {
+		return "", fmt.Errorf("failed to push initial commit: %w", err)
+	}
+
+	return repoDir, nil
+}
+
+// CommitAndPush commits and pushes specified files with a custom message
+// Requires at least one file to be specified
+func CommitAndPush(repoDir string, msg string, file string, otherFiles ...string) error {
+	// Add first file
+	cmd := exec.Command("git", "-C", repoDir, "add", file)
+	if _, err := utils.Run(cmd); err != nil {
+		return fmt.Errorf("failed to git add %s: %w", file, err)
+	}
+
+	// Add other files if provided
+	for _, f := range otherFiles {
+		cmd = exec.Command("git", "-C", repoDir, "add", f)
+		if _, err := utils.Run(cmd); err != nil {
+			return fmt.Errorf("failed to git add %s: %w", f, err)
+		}
+	}
+
+	// Commit
+	cmd = exec.Command("git", "-C", repoDir, "commit", "-m", msg)
+	if _, err := utils.Run(cmd); err != nil {
+		return fmt.Errorf("failed to git commit: %w", err)
+	}
+
+	// Push
+	cmd = exec.Command("git", "-C", repoDir, "push")
+	if _, err := utils.Run(cmd); err != nil {
+		return fmt.Errorf("failed to push: %w", err)
+	}
+
+	return nil
+}
diff --git a/test/utils/gitea.go b/test/utils/gitea.go
new file mode 100644
index 0000000..32ede3b
--- /dev/null
+++ b/test/utils/gitea.go
@@ -0,0 +1,195 @@
+/*
+Copyright 2025.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package utils
+
+import (
+	"context"
+	"fmt"
+
+	"code.gitea.io/sdk/gitea"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/util/rand"
+	"k8s.io/client-go/kubernetes"
+	"k8s.io/client-go/tools/clientcmd"
+)
+
+const (
+	giteaAdminUser = "giteaadmin"
+	giteaAdminPass = "giteapass"
+)
+
+// RepositoryProvider defines the interface for interacting with Git repository hosting providers
+type RepositoryProvider interface {
+	// User management
+	CreateUser(username, password, email string) (cleanup func(), err error)
+	DeleteUser(username string) error
+	CreateRandomUser() (username, password, email string, cleanup func(), err error)
+
+	// Repository management
+	CreateRepo(owner, name string, private bool) (url string, cleanup func(), err error)
+	DeleteRepo(owner, name string) error
+	CreateRandomRepo(owner string, private bool) (name, url string, cleanup func(), err error)
+
+	// Authentication
+	CreateAccessToken(username, password, tokenName string) (string, error)
+}
+
+// GiteaClient wraps the Gitea SDK client and provides helper methods
+type GiteaClient struct {
+	client    *gitea.Client
+	baseURL   string
+	adminUser string
+	adminPass string
+}
+
+// NewGiteaClient discovers Gitea endpoint from ConfigMap and creates client
+func NewGiteaClient() (*GiteaClient, error) {
+	// Load kubeconfig
+	loadingRules := clientcmd.NewDefaultClientConfigLoadingRules()
+	configOverrides := &clientcmd.ConfigOverrides{}
+	kubeConfig := clientcmd.NewNonInteractiveDeferredLoadingClientConfig(loadingRules, configOverrides)
+
+	cfg, err := kubeConfig.ClientConfig()
+	if err != nil {
+		return nil, fmt.Errorf("failed to load kubeconfig: %w", err)
+	}
+
+	// Create Kubernetes client
+	clientset, err := kubernetes.NewForConfig(cfg)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create kubernetes client: %w", err)
+	}
+
+	// Get gitea-endpoint ConfigMap
+	cm, err := clientset.CoreV1().
+		ConfigMaps("kube-public").
+		Get(context.Background(), "gitea-endpoint", metav1.GetOptions{})
+	if err != nil {
+		return nil, fmt.Errorf("failed to get gitea-endpoint configmap: %w", err)
+	}
+
+	baseURL, ok := cm.Data["http"]
+	if !ok {
+		return nil, fmt.Errorf("gitea-endpoint configmap missing 'http' key")
+	}
+
+	// Create Gitea SDK client
+	giteaClient, err := gitea.NewClient(baseURL, gitea.SetBasicAuth(giteaAdminUser, giteaAdminPass))
+	if err != nil {
+		return nil, fmt.Errorf("failed to create gitea client: %w", err)
+	}
+
+	return &GiteaClient{
+		client:    giteaClient,
+		baseURL:   baseURL,
+		adminUser: giteaAdminUser,
+		adminPass: giteaAdminPass,
+	}, nil
+}
+
+// CreateUser creates a new Gitea user
+func (g *GiteaClient) CreateUser(username, password, email string) (cleanup func(), err error) {
+	mustChangePassword := false
+	_, _, err = g.client.AdminCreateUser(gitea.CreateUserOption{
+		Username:           username,
+		Password:           password,
+		Email:              email,
+		MustChangePassword: &mustChangePassword,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("failed to create user %s: %w", username, err)
+	}
+
+	cleanup = func() {
+		_ = g.DeleteUser(username)
+	}
+	return cleanup, nil
+}
+
+// DeleteUser deletes a Gitea user
+func (g *GiteaClient) DeleteUser(username string) error {
+	_, err := g.client.AdminDeleteUser(username)
+	if err != nil {
+		return fmt.Errorf("failed to delete user %s: %w", username, err)
+	}
+	return nil
+}
+
+// CreateRandomUser creates a user with random credentials
+func (g *GiteaClient) CreateRandomUser() (username, password, email string, cleanup func(), err error) {
+	username = "user-" + rand.String(8)
+	password = "pass-" + rand.String(8)
+	email = username + "@test.local"
+
+	cleanup, err = g.CreateUser(username, password, email)
+	return username, password, email, cleanup, err
+}
+
+// CreateRepo creates a new repository and returns its URL
+func (g *GiteaClient) CreateRepo(owner, name string, private bool) (url string, cleanup func(), err error) {
+	// Use admin client to create repo for the specified owner
+	_, _, err = g.client.AdminCreateRepo(owner, gitea.CreateRepoOption{
+		Name:    name,
+		Private: private,
+	})
+	if err != nil {
+		return "", nil, fmt.Errorf("failed to create repo %s/%s: %w", owner, name, err)
+	}
+
+	// Build repository URL
+	url = fmt.Sprintf("%s/%s/%s.git", g.baseURL, owner, name)
+
+	cleanup = func() {
+		_ = g.DeleteRepo(owner, name)
+	}
+	return url, cleanup, nil
+}
+
+// DeleteRepo deletes a repository
+func (g *GiteaClient) DeleteRepo(owner, name string) error {
+	_, err := g.client.DeleteRepo(owner, name)
+	if err != nil {
+		return fmt.Errorf("failed to delete repo %s/%s: %w", owner, name, err)
+	}
+	return nil
+}
+
+// CreateRandomRepo creates a repo with a random name
+func (g *GiteaClient) CreateRandomRepo(owner string, private bool) (name, url string, cleanup func(), err error) {
+	name = "repo-" + rand.String(8)
+	url, cleanup, err = g.CreateRepo(owner, name, private)
+	return name, url, cleanup, err
+}
+
+// CreateAccessToken creates a personal access token for a user
+func (g *GiteaClient) CreateAccessToken(username, password, tokenName string) (string, error) {
+	// Create a client authenticated as the user
+	userClient, err := gitea.NewClient(g.baseURL, gitea.SetBasicAuth(username, password))
+	if err != nil {
+		return "", fmt.Errorf("failed to create user client: %w", err)
+	}
+
+	// Create token
+	token, _, err := userClient.CreateAccessToken(gitea.CreateAccessTokenOption{
+		Name: tokenName,
+	})
+	if err != nil {
+		return "", fmt.Errorf("failed to create access token for %s: %w", username, err)
+	}
+
+	return token.Token, nil
+}