8633798479

Committed 10 Apr 2024 03:22PM UTC coverage: 50.624% (-1.2%) from 51.844%

Build # 8633798479

Build Type

Pull #620

github

Committed by

gargravarr

Commit Message

Remove central ingress/routegroup logic; remove ingress source switch ttl logic.

Signed-off-by: Rodrigo Reis <rodrigo.gargravarr@gmail.com>

Pull Request Pull Request #620: Remove central ingress/routegroup logic

Run Details

16 of 55 new or added lines in 4 files covered. (29.09%)

134 existing lines in 3 files now uncovered.

2839 of 5608 relevant lines covered (50.62%)

0.57 hits per line

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

89.39

/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.
)

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,
                nil,
                true,
                true,
        )

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

zalando-incubator / stackset-controller / 8633798479

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