16523655282

Committed 25 Jul 2025 01:51PM UTC coverage: 81.777% (+0.06%) from 81.722%

Build # 16523655282

Build Type

push

github

Committed by

OliverMKing

Commit Message

fix tests

Run Details

3792 of 4637 relevant lines covered (81.78%)

21.93 hits per line

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

89.13

/pkg/controller/crd.go

package controller

import (
        "context"
        "errors"
        "fmt"
        "os"
        "path/filepath"

        "github.com/Azure/aks-app-routing-operator/pkg/config"
        "github.com/Azure/aks-app-routing-operator/pkg/util"
        "github.com/go-logr/logr"
        apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
        "sigs.k8s.io/controller-runtime/pkg/client"
        "sigs.k8s.io/yaml"
)

const (
        // should match the names in root config/crd/bases directory
        externalDnsCrdFilename            = "approuting.kubernetes.azure.com_externaldnses.yaml"
        clusterExternalDnsCrdFilename     = "approuting.kubernetes.azure.com_clusterexternaldnses.yaml"
        nginxIngresscontrollerCrdFilename = "approuting.kubernetes.azure.com_nginxingresscontrollers.yaml"
)

// loadCRDs loads the CRDs from the specified path into the cluster
func loadCRDs(c client.Client, cfg *config.Config, log logr.Logger) error {
        if cfg == nil {
                return errors.New("config cannot be nil")
        }

        log = log.WithValues("crdPath", cfg.CrdPath)
        log.Info("reading crd directory")
        files, err := os.ReadDir(cfg.CrdPath)
        if err != nil {
                return fmt.Errorf("reading crd directory %s: %w", cfg.CrdPath, err)
        }

        log.Info("applying crds")
        for _, file := range files {
                if file.IsDir() {
                        continue
                }

                filename := file.Name()
                if !shouldLoadCRD(cfg, filename) {
                        continue
                }

                path := filepath.Join(cfg.CrdPath, filename)
                log := log.WithValues("path", path)
                log.Info("reading crd file")
                var content []byte
                content, err := os.ReadFile(path)
                if err != nil {
                        return fmt.Errorf("reading crd file %s: %w", path, err)
                }

                log.Info("unmarshalling crd file")
                crd := &apiextensionsv1.CustomResourceDefinition{}
                if err := yaml.UnmarshalStrict(content, crd); err != nil {
                        return fmt.Errorf("unmarshalling crd file %s: %w", path, err)
                }

                log.Info("upserting crd")
                if err := util.Upsert(context.Background(), c, crd); err != nil {
                        return fmt.Errorf("upserting crd %s: %w", crd.Name, err)
                }
        }

        log.Info("crds loaded")
        return nil
}

func shouldLoadCRD(cfg *config.Config, filename string) bool {
        switch filename {
        case nginxIngresscontrollerCrdFilename:
                return true

        // namespaced ExternalDNS CRD not used yet
        case externalDnsCrdFilename:
                return false
        case clusterExternalDnsCrdFilename:
                return cfg.EnabledWorkloadIdentity

        default:
                return false
        }
}

1	package controller
2
3	import (
4	"context"
5	"errors"
6	"fmt"
7	"os"
8	"path/filepath"
9
10	"github.com/Azure/aks-app-routing-operator/pkg/config"
11	"github.com/Azure/aks-app-routing-operator/pkg/util"
12	"github.com/go-logr/logr"
13	apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
14	"sigs.k8s.io/controller-runtime/pkg/client"
15	"sigs.k8s.io/yaml"
16	)
17
18	const (
19	// should match the names in root config/crd/bases directory
20	externalDnsCrdFilename = "approuting.kubernetes.azure.com_externaldnses.yaml"
21	clusterExternalDnsCrdFilename = "approuting.kubernetes.azure.com_clusterexternaldnses.yaml"
22	nginxIngresscontrollerCrdFilename = "approuting.kubernetes.azure.com_nginxingresscontrollers.yaml"
23	)
24
25	// loadCRDs loads the CRDs from the specified path into the cluster
26	func loadCRDs(c client.Client, cfg *config.Config, log logr.Logger) error {	7✔
27	if cfg == nil {	8✔
28	return errors.New("config cannot be nil")	1✔
29	}	1✔
30
31	log = log.WithValues("crdPath", cfg.CrdPath)	6✔
32	log.Info("reading crd directory")	6✔
33	files, err := os.ReadDir(cfg.CrdPath)	6✔
34	if err != nil {	7✔
35	return fmt.Errorf("reading crd directory %s: %w", cfg.CrdPath, err)	1✔
36	}	1✔
37
38	log.Info("applying crds")	5✔
39	for _, file := range files {	22✔
40	if file.IsDir() {	17✔
41	continue	×
42	}
43
44	filename := file.Name()	17✔
45	if !shouldLoadCRD(cfg, filename) {	28✔
46	continue	11✔
47	}
48
49	path := filepath.Join(cfg.CrdPath, filename)	6✔
50	log := log.WithValues("path", path)	6✔
51	log.Info("reading crd file")	6✔
52	var content []byte	6✔
53	content, err := os.ReadFile(path)	6✔
54	if err != nil {	6✔
55	return fmt.Errorf("reading crd file %s: %w", path, err)	×
56	}	×
57
58	log.Info("unmarshalling crd file")	6✔
59	crd := &apiextensionsv1.CustomResourceDefinition{}	6✔
60	if err := yaml.UnmarshalStrict(content, crd); err != nil {	7✔
61	return fmt.Errorf("unmarshalling crd file %s: %w", path, err)	1✔
62	}	1✔
63
64	log.Info("upserting crd")	5✔
65	if err := util.Upsert(context.Background(), c, crd); err != nil {	5✔
66	return fmt.Errorf("upserting crd %s: %w", crd.Name, err)	×
67	}	×
68	}
69
70	log.Info("crds loaded")	4✔
71	return nil	4✔
72	}
73
74	func shouldLoadCRD(cfg *config.Config, filename string) bool {	25✔
75	switch filename {	25✔
76	case nginxIngresscontrollerCrdFilename:	7✔
77	return true	7✔
78
79	// namespaced ExternalDNS CRD not used yet
80	case externalDnsCrdFilename:	6✔
81	return false	6✔
82	case clusterExternalDnsCrdFilename:	6✔
83	return cfg.EnabledWorkloadIdentity	6✔
84
85	default:	6✔
86	return false	6✔
87	}
88	}

Azure / aks-app-routing-operator / 16523655282

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