8738031909

Committed 19 Mar 2024 06:41PM UTC coverage: 51.212% (-0.9%) from 52.101%

Build # 8738031909

Build Type

Pull #593

github

Committed by

linki

Commit Message

some labels

Pull Request Pull Request #593: [2/3] Add Inline Solution for ConfigMaps

Run Details

5 of 143 new or added lines in 5 files covered. (3.5%)

766 existing lines in 14 files now uncovered.

3084 of 6022 relevant lines covered (51.21%)

0.58 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

90.91

/controller/test_helpers.go

package controller

import (
        "context"
        "time"

        "github.com/prometheus/client_golang/prometheus"
        rgv1 "github.com/szuecs/routegroup-client/apis/zalando.org/v1"
        rginterface "github.com/szuecs/routegroup-client/client/clientset/versioned"
        rgfake "github.com/szuecs/routegroup-client/client/clientset/versioned/fake"
        rgi "github.com/szuecs/routegroup-client/client/clientset/versioned/typed/zalando.org/v1"
        zv1 "github.com/zalando-incubator/stackset-controller/pkg/apis/zalando.org/v1"
        ssinterface "github.com/zalando-incubator/stackset-controller/pkg/client/clientset/versioned"
        ssfake "github.com/zalando-incubator/stackset-controller/pkg/client/clientset/versioned/fake"
        zi "github.com/zalando-incubator/stackset-controller/pkg/client/clientset/versioned/typed/zalando.org/v1"
        ssunified "github.com/zalando-incubator/stackset-controller/pkg/clientset"
        "github.com/zalando-incubator/stackset-controller/pkg/core"
        apps "k8s.io/api/apps/v1"
        autoscaling "k8s.io/api/autoscaling/v2"
        v1 "k8s.io/api/core/v1"
        networking "k8s.io/api/networking/v1"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        "k8s.io/apimachinery/pkg/types"
        "k8s.io/client-go/kubernetes"
        "k8s.io/client-go/kubernetes/fake"
)

var (
        timeNow = time.Now().Format(time.RFC3339)
        // ttl for the test environment is time.Minute, here
        // timeOldEnough is set to twice this value.
        timeOldEnough = time.Now().Add(-2 * time.Minute).Format(time.RFC3339)
)

type testClient struct {
        kubernetes.Interface
        ssClient ssinterface.Interface
        rgClient rginterface.Interface
}

func (c *testClient) ZalandoV1() zi.ZalandoV1Interface {
        return c.ssClient.ZalandoV1()
}

func (c *testClient) RouteGroupV1() rgi.ZalandoV1Interface {
        return c.rgClient.ZalandoV1()
}

type testEnvironment struct {
        client     ssunified.Interface
        controller *StackSetController
}

func NewTestEnvironment() *testEnvironment {
        client := &testClient{
                Interface: fake.NewSimpleClientset(),
                ssClient:  ssfake.NewSimpleClientset(),
                rgClient:  rgfake.NewSimpleClientset(),
        }

        controller, err := NewStackSetController(
                client,
                v1.NamespaceAll,
                "",
                10,
                "",
                nil,
                prometheus.NewPedanticRegistry(),
                time.Minute,
                true,
                true,
                true,
                []string{},
                true,
                true,
                time.Minute,
        )

        if err != nil {
                panic(err)
        }

        controller.now = func() string {
                return timeNow
        }

        return &testEnvironment{
                client:     client,
                controller: controller,
        }
}

func (f *testEnvironment) CreateStacksets(ctx context.Context, stacksets []zv1.StackSet) error {
        for _, stackset := range stacksets {
                _, err := f.client.ZalandoV1().StackSets(stackset.Namespace).Create(ctx, &stackset, metav1.CreateOptions{})
                if err != nil {
                        return err
                }

                // Controller can't be tested properly due to https://github.com/kubernetes/client-go/issues/352
                f.controller.stacksetStore[stackset.UID] = stackset
        }
        return nil
}

func (f *testEnvironment) CreateStacks(ctx context.Context, stacks []zv1.Stack) error {
        for _, stack := range stacks {
                _, err := f.client.ZalandoV1().Stacks(stack.Namespace).Create(ctx, &stack, metav1.CreateOptions{})
                if err != nil {
                        return err
                }
        }
        return nil
}

func (f *testEnvironment) CreateDeployments(ctx context.Context, deployments []apps.Deployment) error {
        for _, deployment := range deployments {
                _, err := f.client.AppsV1().Deployments(deployment.Namespace).Create(ctx, &deployment, metav1.CreateOptions{})
                if err != nil {
                        return err
                }
        }
        return nil
}

func (f *testEnvironment) CreateIngresses(ctx context.Context, ingresses []networking.Ingress) error {
        for _, ingress := range ingresses {
                _, err := f.client.NetworkingV1().Ingresses(ingress.Namespace).Create(ctx, &ingress, metav1.CreateOptions{})
                if err != nil {
                        return err
                }
        }
        return nil
}

func (f *testEnvironment) CreateRouteGroups(ctx context.Context, routegroups []rgv1.RouteGroup) error {
        for _, routegroup := range routegroups {
                _, err := f.client.RouteGroupV1().RouteGroups(routegroup.Namespace).Create(ctx, &routegroup, metav1.CreateOptions{})
                if err != nil {
                        return err
                }
        }
        return nil
}

func (f *testEnvironment) CreateServices(ctx context.Context, services []v1.Service) error {
        for _, service := range services {
                _, err := f.client.CoreV1().Services(service.Namespace).Create(ctx, &service, metav1.CreateOptions{})
                if err != nil {
                        return err
                }
        }
        return nil
}

func (f *testEnvironment) CreateHPAs(ctx context.Context, hpas []autoscaling.HorizontalPodAutoscaler) error {
        for _, hpa := range hpas {
                _, err := f.client.AutoscalingV2().HorizontalPodAutoscalers(hpa.Namespace).Create(ctx, &hpa, metav1.CreateOptions{})
                if err != nil {
                        return err
                }
        }
        return nil
}

func (f *testEnvironment) CreateConfigMaps(ctx context.Context, configMaps []v1.ConfigMap) error {
        for _, configMap := range configMaps {
                _, err := f.client.CoreV1().ConfigMaps(configMap.Namespace).Create(ctx, &configMap, metav1.CreateOptions{})
                if err != nil {
                        return err
                }
        }
        return nil
}

func (f *testEnvironment) CreateSecrets(ctx context.Context, secrets []v1.Secret) error {
        for _, secret := range secrets {
                _, err := f.client.CoreV1().Secrets(secret.Namespace).Create(ctx, &secret, metav1.CreateOptions{})
                if err != nil {
                        return err
                }
        }
        return nil
}

func testStackset(name, namespace string, uid types.UID) zv1.StackSet {
        return zv1.StackSet{
                ObjectMeta: metav1.ObjectMeta{
                        Name:      name,
                        Namespace: namespace,
                        UID:       uid,
                },
        }
}

func testStacksetAnnotatedSegment(name, namespace string, uid types.UID) zv1.StackSet {
        res := testStackset(name, namespace, uid)
        res.Annotations = map[string]string{TrafficSegmentsAnnotationKey: "true"}
        return res
}

func testStack(name, namespace string, uid types.UID, ownerStack zv1.StackSet) zv1.Stack {
        return zv1.Stack{
                TypeMeta: metav1.TypeMeta{
                        APIVersion: "zalando.org/v1",
                        Kind:       "Stack",
                },
                ObjectMeta: metav1.ObjectMeta{
                        Name:      name,
                        Namespace: namespace,
                        UID:       uid,
                        OwnerReferences: []metav1.OwnerReference{
                                {
                                        APIVersion: "zalando.org/v1",
                                        Kind:       "StackSet",
                                        Name:       ownerStack.Name,
                                        UID:        ownerStack.UID,
                                },
                        },
                },
        }
}

func stackOwned(owner zv1.Stack) metav1.ObjectMeta {
        return metav1.ObjectMeta{
                Name:      owner.Name,
                Namespace: owner.Namespace,
                OwnerReferences: []metav1.OwnerReference{
                        {
                                APIVersion: "zalando.org/v1",
                                Kind:       "Stack",
                                Name:       owner.Name,
                                UID:        owner.UID,
                        },
                },
        }
}

func segmentStackOwned(owner zv1.Stack) metav1.ObjectMeta {
        meta := stackOwned(owner)
        meta.Name += core.SegmentSuffix

        return meta
}

func deploymentOwned(owner apps.Deployment) metav1.ObjectMeta {
        return metav1.ObjectMeta{
                Name:      owner.Name,
                Namespace: owner.Namespace,
                OwnerReferences: []metav1.OwnerReference{
                        {
                                APIVersion: "apps/v1",
                                Kind:       "Deployment",
                                Name:       owner.Name,
                                UID:        owner.UID,
                        },
                },
        }
}

func stacksetOwned(owner zv1.StackSet) metav1.ObjectMeta {
        return metav1.ObjectMeta{
                Name:      owner.Name,
                Namespace: owner.Namespace,
                OwnerReferences: []metav1.OwnerReference{
                        {
                                APIVersion: "zalando.org/v1",
                                Kind:       "StackSet",
                                Name:       owner.Name,
                                UID:        owner.UID,
                        },
                },
        }
}

1	package controller
2
3	import (
4	"context"
5	"time"
6
7	"github.com/prometheus/client_golang/prometheus"
8	rgv1 "github.com/szuecs/routegroup-client/apis/zalando.org/v1"
9	rginterface "github.com/szuecs/routegroup-client/client/clientset/versioned"
10	rgfake "github.com/szuecs/routegroup-client/client/clientset/versioned/fake"
11	rgi "github.com/szuecs/routegroup-client/client/clientset/versioned/typed/zalando.org/v1"
12	zv1 "github.com/zalando-incubator/stackset-controller/pkg/apis/zalando.org/v1"
13	ssinterface "github.com/zalando-incubator/stackset-controller/pkg/client/clientset/versioned"
14	ssfake "github.com/zalando-incubator/stackset-controller/pkg/client/clientset/versioned/fake"
15	zi "github.com/zalando-incubator/stackset-controller/pkg/client/clientset/versioned/typed/zalando.org/v1"
16	ssunified "github.com/zalando-incubator/stackset-controller/pkg/clientset"
17	"github.com/zalando-incubator/stackset-controller/pkg/core"
18	apps "k8s.io/api/apps/v1"
19	autoscaling "k8s.io/api/autoscaling/v2"
20	v1 "k8s.io/api/core/v1"
21	networking "k8s.io/api/networking/v1"
22	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
23	"k8s.io/apimachinery/pkg/types"
24	"k8s.io/client-go/kubernetes"
25	"k8s.io/client-go/kubernetes/fake"
26	)
27
28	var (
29	timeNow = time.Now().Format(time.RFC3339)
30	// ttl for the test environment is time.Minute, here
31	// timeOldEnough is set to twice this value.
32	timeOldEnough = time.Now().Add(-2 * time.Minute).Format(time.RFC3339)
33	)
34
35	type testClient struct {
36	kubernetes.Interface
37	ssClient ssinterface.Interface
38	rgClient rginterface.Interface
39	}
40
41	func (c *testClient) ZalandoV1() zi.ZalandoV1Interface {	1✔
42	return c.ssClient.ZalandoV1()	1✔
43	}	1✔
44
45	func (c *testClient) RouteGroupV1() rgi.ZalandoV1Interface {	1✔
46	return c.rgClient.ZalandoV1()	1✔
47	}	1✔
48
49	type testEnvironment struct {
50	client ssunified.Interface
51	controller *StackSetController
52	}
53
54	func NewTestEnvironment() *testEnvironment {	1✔
55	client := &testClient{	1✔
56	Interface: fake.NewSimpleClientset(),	1✔
57	ssClient: ssfake.NewSimpleClientset(),	1✔
58	rgClient: rgfake.NewSimpleClientset(),	1✔
59	}	1✔
60		1✔
61	controller, err := NewStackSetController(	1✔
62	client,	1✔
63	v1.NamespaceAll,	1✔
64	"",	1✔
65	10,	1✔
66	"",	1✔
67	nil,	1✔
68	prometheus.NewPedanticRegistry(),	1✔
69	time.Minute,	1✔
70	true,	1✔
71	true,	1✔
72	true,	1✔
73	[]string{},	1✔
74	true,	1✔
75	true,	1✔
76	time.Minute,	1✔
77	)	1✔
78		1✔
79	if err != nil {	1✔
80	panic(err)	×
81	}
82
83	controller.now = func() string {	2✔
84	return timeNow	1✔
85	}	1✔
86
87	return &testEnvironment{	1✔
88	client: client,	1✔
89	controller: controller,	1✔
90	}	1✔
91	}
92
93	func (f *testEnvironment) CreateStacksets(ctx context.Context, stacksets []zv1.StackSet) error {	1✔
94	for _, stackset := range stacksets {	2✔
95	_, err := f.client.ZalandoV1().StackSets(stackset.Namespace).Create(ctx, &stackset, metav1.CreateOptions{})	1✔
96	if err != nil {	1✔
UNCOV 97	return err	×
UNCOV 98	}	×
99
100	// Controller can't be tested properly due to https://github.com/kubernetes/client-go/issues/352
101	f.controller.stacksetStore[stackset.UID] = stackset	1✔
102	}
103	return nil	1✔
104	}
105
106	func (f *testEnvironment) CreateStacks(ctx context.Context, stacks []zv1.Stack) error {	1✔
107	for _, stack := range stacks {	2✔
108	_, err := f.client.ZalandoV1().Stacks(stack.Namespace).Create(ctx, &stack, metav1.CreateOptions{})	1✔
109	if err != nil {	1✔
UNCOV 110	return err	×
UNCOV 111	}	×
112	}
113	return nil	1✔
114	}
115
116	func (f *testEnvironment) CreateDeployments(ctx context.Context, deployments []apps.Deployment) error {	1✔
117	for _, deployment := range deployments {	2✔
118	_, err := f.client.AppsV1().Deployments(deployment.Namespace).Create(ctx, &deployment, metav1.CreateOptions{})	1✔
119	if err != nil {	1✔
UNCOV 120	return err	×
UNCOV 121	}	×
122	}
123	return nil	1✔
124	}
125
126	func (f *testEnvironment) CreateIngresses(ctx context.Context, ingresses []networking.Ingress) error {	1✔
127	for _, ingress := range ingresses {	2✔
128	_, err := f.client.NetworkingV1().Ingresses(ingress.Namespace).Create(ctx, &ingress, metav1.CreateOptions{})	1✔
129	if err != nil {	1✔
UNCOV 130	return err	×
UNCOV 131	}	×
132	}
133	return nil	1✔
134	}
135
136	func (f *testEnvironment) CreateRouteGroups(ctx context.Context, routegroups []rgv1.RouteGroup) error {	1✔
137	for _, routegroup := range routegroups {	2✔
138	_, err := f.client.RouteGroupV1().RouteGroups(routegroup.Namespace).Create(ctx, &routegroup, metav1.CreateOptions{})	1✔
139	if err != nil {	1✔
UNCOV 140	return err	×
UNCOV 141	}	×
142	}
143	return nil	1✔
144	}
145
146	func (f *testEnvironment) CreateServices(ctx context.Context, services []v1.Service) error {	1✔
147	for _, service := range services {	2✔
148	_, err := f.client.CoreV1().Services(service.Namespace).Create(ctx, &service, metav1.CreateOptions{})	1✔
149	if err != nil {	1✔
UNCOV 150	return err	×
UNCOV 151	}	×
152	}
153	return nil	1✔
154	}
155
156	func (f *testEnvironment) CreateHPAs(ctx context.Context, hpas []autoscaling.HorizontalPodAutoscaler) error {	1✔
157	for _, hpa := range hpas {	2✔
158	_, err := f.client.AutoscalingV2().HorizontalPodAutoscalers(hpa.Namespace).Create(ctx, &hpa, metav1.CreateOptions{})	1✔
159	if err != nil {	1✔
UNCOV 160	return err	×
UNCOV 161	}	×
162	}
163	return nil	1✔
164	}
165
166	func (f *testEnvironment) CreateConfigMaps(ctx context.Context, configMaps []v1.ConfigMap) error {	1✔
167	for _, configMap := range configMaps {	2✔
168	_, err := f.client.CoreV1().ConfigMaps(configMap.Namespace).Create(ctx, &configMap, metav1.CreateOptions{})	1✔
169	if err != nil {	1✔
UNCOV 170	return err	×
UNCOV 171	}	×
172	}
173	return nil	1✔
174	}
175
176	func (f *testEnvironment) CreateSecrets(ctx context.Context, secrets []v1.Secret) error {	1✔
177	for _, secret := range secrets {	2✔
178	_, err := f.client.CoreV1().Secrets(secret.Namespace).Create(ctx, &secret, metav1.CreateOptions{})	1✔
179	if err != nil {	2✔
180	return err	1✔
181	}	1✔
182	}
183	return nil	1✔
184	}
185
186	func testStackset(name, namespace string, uid types.UID) zv1.StackSet {	1✔
187	return zv1.StackSet{	1✔
188	ObjectMeta: metav1.ObjectMeta{	1✔
189	Name: name,	1✔
190	Namespace: namespace,	1✔
191	UID: uid,	1✔
192	},	1✔
193	}	1✔
194	}	1✔
195
196	func testStacksetAnnotatedSegment(name, namespace string, uid types.UID) zv1.StackSet {	1✔
197	res := testStackset(name, namespace, uid)	1✔
198	res.Annotations = map[string]string{TrafficSegmentsAnnotationKey: "true"}	1✔
199	return res	1✔
200	}	1✔
201
202	func testStack(name, namespace string, uid types.UID, ownerStack zv1.StackSet) zv1.Stack {	1✔
203	return zv1.Stack{	1✔
204	TypeMeta: metav1.TypeMeta{	1✔
205	APIVersion: "zalando.org/v1",	1✔
206	Kind: "Stack",	1✔
207	},	1✔
208	ObjectMeta: metav1.ObjectMeta{	1✔
209	Name: name,	1✔
210	Namespace: namespace,	1✔
211	UID: uid,	1✔
212	OwnerReferences: []metav1.OwnerReference{	1✔
213	{	1✔
214	APIVersion: "zalando.org/v1",	1✔
215	Kind: "StackSet",	1✔
216	Name: ownerStack.Name,	1✔
217	UID: ownerStack.UID,	1✔
218	},	1✔
219	},	1✔
220	},	1✔
221	}	1✔
222	}	1✔
223
224	func stackOwned(owner zv1.Stack) metav1.ObjectMeta {	1✔
225	return metav1.ObjectMeta{	1✔
226	Name: owner.Name,	1✔
227	Namespace: owner.Namespace,	1✔
228	OwnerReferences: []metav1.OwnerReference{	1✔
229	{	1✔
230	APIVersion: "zalando.org/v1",	1✔
231	Kind: "Stack",	1✔
232	Name: owner.Name,	1✔
233	UID: owner.UID,	1✔
234	},	1✔
235	},	1✔
236	}	1✔
237	}	1✔
238
239	func segmentStackOwned(owner zv1.Stack) metav1.ObjectMeta {	1✔
240	meta := stackOwned(owner)	1✔
241	meta.Name += core.SegmentSuffix	1✔
242		1✔
243	return meta	1✔
244	}	1✔
245
246	func deploymentOwned(owner apps.Deployment) metav1.ObjectMeta {	1✔
247	return metav1.ObjectMeta{	1✔
248	Name: owner.Name,	1✔
249	Namespace: owner.Namespace,	1✔
250	OwnerReferences: []metav1.OwnerReference{	1✔
251	{	1✔
252	APIVersion: "apps/v1",	1✔
253	Kind: "Deployment",	1✔
254	Name: owner.Name,	1✔
255	UID: owner.UID,	1✔
256	},	1✔
257	},	1✔
258	}	1✔
259	}	1✔
260
261	func stacksetOwned(owner zv1.StackSet) metav1.ObjectMeta {	1✔
262	return metav1.ObjectMeta{	1✔
263	Name: owner.Name,	1✔
264	Namespace: owner.Namespace,	1✔
265	OwnerReferences: []metav1.OwnerReference{	1✔
266	{	1✔
267	APIVersion: "zalando.org/v1",	1✔
268	Kind: "StackSet",	1✔
269	Name: owner.Name,	1✔
270	UID: owner.UID,	1✔
271	},	1✔
272	},	1✔
273	}	1✔
274	}	1✔

zalando-incubator / stackset-controller / 8738031909

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous