knative.dev/pkg@v0.0.0-20260602142205-ac97e43f6622/codegen/cmd/injection-gen/generators/client/fake.go (about)

     1  /*
     2  Copyright 2019 The Knative Authors
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8      http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package client
    18  
    19  import (
    20  	"io"
    21  	"path/filepath"
    22  
    23  	"k8s.io/gengo/v2/generator"
    24  	"k8s.io/gengo/v2/namer"
    25  	"k8s.io/gengo/v2/types"
    26  	"k8s.io/klog/v2"
    27  	"knative.dev/pkg/codegen/cmd/injection-gen/args"
    28  )
    29  
    30  func NewFake(args *args.Args) *fakeClientGenerator {
    31  	client := New(args)
    32  	return &fakeClientGenerator{
    33  		GoGenerator: generator.GoGenerator{
    34  			OutputFilename: "fake.go",
    35  		},
    36  		clientInjectionPkg: client.OutputPackagePath(),
    37  		fakeClientPkg:      filepath.Join(args.VersionedClientSetPackage, "fake"),
    38  		imports:            generator.NewImportTracker(),
    39  		outputPackage:      filepath.Join(args.OutputPackagePath, "client", "fake"),
    40  	}
    41  }
    42  
    43  // fakeClientGenerator produces a file of listers for a given GroupVersion and
    44  // type.
    45  type fakeClientGenerator struct {
    46  	generator.GoGenerator
    47  	outputPackage string
    48  	imports       namer.ImportTracker
    49  	filtered      bool
    50  
    51  	fakeClientPkg      string
    52  	clientInjectionPkg string
    53  }
    54  
    55  func (g *fakeClientGenerator) OutputPackagePath() string {
    56  	return g.outputPackage
    57  }
    58  
    59  var _ generator.Generator = (*fakeClientGenerator)(nil)
    60  
    61  func (g *fakeClientGenerator) Filter(c *generator.Context, t *types.Type) bool {
    62  	// We generate a single client, so return true once.
    63  	if !g.filtered {
    64  		g.filtered = true
    65  		return true
    66  	}
    67  	return false
    68  }
    69  
    70  func (g *fakeClientGenerator) Namers(c *generator.Context) namer.NameSystems {
    71  	return namer.NameSystems{
    72  		"raw": namer.NewRawNamer(g.outputPackage, g.imports),
    73  	}
    74  }
    75  
    76  func (g *fakeClientGenerator) Imports(c *generator.Context) (imports []string) {
    77  	imports = append(imports, g.imports.ImportLines()...)
    78  	return
    79  }
    80  
    81  func (g *fakeClientGenerator) GenerateType(c *generator.Context, t *types.Type, w io.Writer) error {
    82  	sw := generator.NewSnippetWriter(w, c, "{{", "}}")
    83  
    84  	klog.V(5).Info("processing type ", t)
    85  
    86  	m := map[string]interface{}{
    87  		"clientKey":  c.Universe.Type(types.Name{Package: g.clientInjectionPkg, Name: "Key"}),
    88  		"fakeClient": c.Universe.Type(types.Name{Package: g.fakeClientPkg, Name: "Clientset"}),
    89  		"injectionRegisterClient": c.Universe.Function(types.Name{
    90  			Package: "knative.dev/pkg/injection",
    91  			Name:    "Fake.RegisterClient",
    92  		}),
    93  		"injectionRegisterClientFetcher": c.Universe.Function(types.Name{
    94  			Package: "knative.dev/pkg/injection",
    95  			Name:    "Fake.RegisterClientFetcher",
    96  		}),
    97  		"loggingFromContext": c.Universe.Function(types.Name{
    98  			Package: "knative.dev/pkg/logging",
    99  			Name:    "FromContext",
   100  		}),
   101  		"contextContext": c.Universe.Type(types.Name{
   102  			Package: "context",
   103  			Name:    "Context",
   104  		}),
   105  		"restConfig":    c.Universe.Type(types.Name{Package: "k8s.io/client-go/rest", Name: "Config"}),
   106  		"runtimeObject": c.Universe.Type(types.Name{Package: "k8s.io/apimachinery/pkg/runtime", Name: "Object"}),
   107  	}
   108  
   109  	sw.Do(injectionFakeClient, m)
   110  
   111  	return sw.Error()
   112  }
   113  
   114  var injectionFakeClient = `
   115  func init() {
   116  	{{.injectionRegisterClient|raw}}(withClient)
   117  	{{.injectionRegisterClientFetcher|raw}}(func(ctx context.Context) interface{} {
   118  		return Get(ctx)
   119  	})
   120  }
   121  
   122  func withClient(ctx {{.contextContext|raw}}, cfg *{{.restConfig|raw}}) {{.contextContext|raw}} {
   123  	ctx, _ = With(ctx)
   124  	return ctx
   125  }
   126  
   127  func With(ctx {{.contextContext|raw}}, objects ...{{.runtimeObject|raw}}) ({{.contextContext|raw}}, *{{.fakeClient|raw}}) {
   128  	cs := fake.NewSimpleClientset(objects...)
   129  	return context.WithValue(ctx, {{.clientKey|raw}}{}, cs), cs
   130  }
   131  
   132  // Get extracts the Kubernetes client from the context.
   133  func Get(ctx {{.contextContext|raw}}) *{{.fakeClient|raw}} {
   134  	untyped := ctx.Value({{.clientKey|raw}}{})
   135  	if untyped == nil {
   136  		{{.loggingFromContext|raw}}(ctx).Panic(
   137  			"Unable to fetch {{.fakeClient}} from context.")
   138  	}
   139  	return untyped.(*fake.Clientset)
   140  }
   141  `