kuma

1
package meshcircuitbreaker
2

3
import (
4
	"fmt"
5

6
	"github.com/gruntwork-io/terratest/modules/k8s"
7
	. "github.com/onsi/ginkgo/v2"
8
	. "github.com/onsi/gomega"
9

10
	"github.com/kumahq/kuma/pkg/plugins/policies/meshcircuitbreaker/api/v1alpha1"
11
	. "github.com/kumahq/kuma/test/framework"
12
	"github.com/kumahq/kuma/test/framework/envs/kubernetes"
13
)
14

15
func API() {
16
	meshName := "meshcircuitbreaker-api"
17

18
	BeforeAll(func() {
19
		err := NewClusterSetup().
20
			Install(MeshKubernetes(meshName)).
21
			Setup(kubernetes.Cluster)
22
		Expect(err).ToNot(HaveOccurred())
23

24
		// Delete the default meshcricuitbreaker policy
25
		Expect(DeleteMeshPolicyOrError(
26
			kubernetes.Cluster,
27
			v1alpha1.MeshCircuitBreakerResourceTypeDescriptor,
28
			fmt.Sprintf("mesh-circuit-breaker-all-%s", meshName),
29
		)).To(Succeed())
30
	})
31

32
	E2EAfterEach(func() {
33
		Expect(DeleteMeshResources(kubernetes.Cluster, meshName, v1alpha1.MeshCircuitBreakerResourceTypeDescriptor)).To(Succeed())
34
	})
35

36
	E2EAfterAll(func() {
37
		Expect(kubernetes.Cluster.DeleteMesh(meshName)).To(Succeed())
38
	})
39

40
	It("should create MeshCircuitBreaker policy", func() {
41
		// given no MeshCircuitBreakers
42
		mcb, err := kubernetes.Cluster.GetKumactlOptions().KumactlList("meshcircuitbreakers", meshName)
43
		Expect(err).ToNot(HaveOccurred())
44
		Expect(mcb).To(BeEmpty())
45

46
		// when
47
		Expect(YamlK8s(fmt.Sprintf(`
48
apiVersion: kuma.io/v1alpha1
49
kind: MeshCircuitBreaker
50
metadata:
51
  name: mcb-api-1
52
  namespace: %s
53
  labels:
54
    kuma.io/mesh: meshcircuitbreaker-api
55
spec:
56
  targetRef:
57
    kind: MeshService
58
    name: backend
59
  from:
60
    - targetRef:
61
        kind: Mesh
62
      default:
63
        connectionLimits:
64
          maxConnectionPools: 5
65
          maxConnections: 10
66
          maxPendingRequests: 2
67
          maxRetries: 1
68
          maxRequests: 32
69
  to:
70
    - targetRef:
71
        kind: MeshService
72
        name: frontend
73
      default:
74
        outlierDetection:
75
          disabled: false
76
          interval: 5s
77
          baseEjectionTime: 30s
78
          maxEjectionPercent: 20
79
          splitExternalAndLocalErrors: true
80
          detectors:
81
            totalFailures:
82
              consecutive: 10
83
            gatewayFailures:
84
              consecutive: 10
85
            localOriginFailures:
86
              consecutive: 10
87
            successRate:
88
              minimumHosts: 5
89
              requestVolume: 10
90
              standardDeviationFactor: 1900
91
            failurePercentage:
92
              requestVolume: 10
93
              minimumHosts: 5
94
              threshold: 85
95
`, Config.KumaNamespace))(kubernetes.Cluster)).To(Succeed())
96

97
		// then
98
		mcb, err = kubernetes.Cluster.GetKumactlOptions().KumactlList("meshcircuitbreakers", meshName)
99
		Expect(err).ToNot(HaveOccurred())
100
		Expect(mcb).To(HaveLen(1))
101
		Expect(mcb[0]).To(Equal(fmt.Sprintf("mcb-api-1.%s", Config.KumaNamespace)))
102
	})
103

104
	It("should deny creating policy in the non-system namespace", func() {
105
		// given no MeshCircuitBreakers
106
		mcb, err := kubernetes.Cluster.GetKumactlOptions().KumactlList("meshcircuitbreakers", meshName)
107
		Expect(err).ToNot(HaveOccurred())
108
		Expect(mcb).To(BeEmpty())
109

110
		// when
111
		err = k8s.KubectlApplyFromStringE(
112
			kubernetes.Cluster.GetTesting(),
113
			kubernetes.Cluster.GetKubectlOptions(), `
114
apiVersion: kuma.io/v1alpha1
115
kind: MeshCircuitBreaker
116
metadata:
117
  name: mcb-api-invalid
118
  namespace: default
119
  labels:
120
    kuma.io/mesh: meshcircuitbreaker-api
121
spec:
122
  targetRef:
123
    kind: MeshService
124
    name: backend
125
  from:
126
    - targetRef:
127
        kind: Mesh
128
      default:
129
        connectionLimits:
130
          maxConnectionPools: 5
131
          maxConnections: 10
132
          maxPendingRequests: 2
133
          maxRetries: 1
134
          maxRequests: 32
135
  to:
136
    - targetRef:
137
        kind: MeshService
138
        name: frontend
139
      default:
140
        outlierDetection:
141
          disabled: false
142
          interval: 5s
143
          baseEjectionTime: 30s
144
          maxEjectionPercent: 20
145
          splitExternalAndLocalErrors: true
146
          detectors:
147
            totalFailures:
148
              consecutive: 10
149
            gatewayFailures:
150
              consecutive: 10
151
            localOriginFailures:
152
              consecutive: 10
153
            successRate:
154
              minimumHosts: 5
155
              requestVolume: 10
156
              standardDeviationFactor: 1900
157
            failurePercentage:
158
              requestVolume: 10
159
              minimumHosts: 5
160
              threshold: 85
161
`)
162

163
		Expect(err).To(HaveOccurred())
164
		Expect(err.Error()).To(ContainSubstring(fmt.Sprintf("policy can only be created in the system namespace:%s", Config.KumaNamespace)))
165
	})
166
}
167