github.com/verrazzano/verrazzano@v1.7.1/tools/vz/test/helpers/fake_cmd_context.go

// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
// Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.

package helpers

import (
	"bytes"
	"encoding/json"
	"errors"
	"fmt"
	"github.com/stretchr/testify/assert"
	"io"
	"k8s.io/client-go/discovery"
	discoveryFake "k8s.io/client-go/discovery/fake"
	"testing"

	"net/http"
	"os"
	"strings"
	"time"

	"github.com/spf13/cobra"
	"github.com/verrazzano/verrazzano/tools/vz/pkg/github"
	"k8s.io/cli-runtime/pkg/genericclioptions"
	"k8s.io/client-go/dynamic"
	"k8s.io/client-go/kubernetes"
	"k8s.io/client-go/kubernetes/fake"
	"sigs.k8s.io/controller-runtime/pkg/client"
)

type FakeRootCmdContext struct {
	client        client.Client
	kubeClient    kubernetes.Interface
	dynamicClient dynamic.Interface
	genericclioptions.IOStreams
}

type FakeRootCmdContextWithFiles struct {
	FakeRootCmdContext
	Out    *os.File
	ErrOut *os.File
}

// GetOutputStream - return the output stream
func (rc *FakeRootCmdContext) GetOutputStream() io.Writer {
	return rc.IOStreams.Out
}

// GetErrorStream - return the error stream
func (rc *FakeRootCmdContext) GetErrorStream() io.Writer {
	return rc.IOStreams.ErrOut
}

// GetInputStream - return the input stream
func (rc *FakeRootCmdContext) GetInputStream() io.Reader {
	return rc.IOStreams.In
}

// GetClient - return a controller runtime client that supports the schemes used by the CLI
func (rc *FakeRootCmdContext) GetClient(cmd *cobra.Command) (client.Client, error) {
	return rc.client, nil
}

// GetKubeClient - return a Kubernetes clientset for use with the fake go-client
func (rc *FakeRootCmdContext) GetKubeClient(cmd *cobra.Command) (kubernetes.Interface, error) {
	return rc.kubeClient, nil
}

// SetClient - set the client
func (rc *FakeRootCmdContext) SetClient(client client.Client) {
	rc.client = client
}

// SetKubeClient - set the kubeclient
func (rc *FakeRootCmdContext) SetKubeClient(kubeClient kubernetes.Interface) {
	rc.kubeClient = kubeClient
}

// RoundTripFunc - define the type for the Transport function
type RoundTripFunc func(req *http.Request) *http.Response

// RoundTrip - define the implementation for the Transport function
func (f RoundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) {
	return f(req), nil
}

// GetHTTPClient - return an HTTP client for testing that always responds with a 200
// and a pre-defined list of releases
func (rc *FakeRootCmdContext) GetHTTPClient() *http.Client {
	// Predefined response for the list of releases
	releaseResponse := []github.ReleaseAsset{
		{
			TagName: "v1.3.0",
		},
		{
			TagName: "v1.2.0",
		},
		{
			TagName: "v1.3.1",
		},
	}
	jsonResp, _ := json.Marshal(releaseResponse)

	// Predefined response for getting operator.yaml
	jsonOperResp, err := os.ReadFile("../../test/testdata/operator-file-fake.yaml")
	if err != nil {
		panic(err)
	}

	return &http.Client{
		Timeout: time.Second * 30,
		Transport: RoundTripFunc(func(req *http.Request) *http.Response {
			if strings.Contains(req.URL.Path, "/releases/download") {
				return &http.Response{
					StatusCode: http.StatusOK,
					Body:       io.NopCloser(bytes.NewBuffer(jsonOperResp)),
					Header:     http.Header{"Content-Type": {"application/octet-stream"}},
				}
			}
			return &http.Response{
				StatusCode: http.StatusOK,
				Body:       io.NopCloser(bytes.NewBuffer(jsonResp)),
				Header:     http.Header{"Content-Type": {"application/json"}},
			}
		}),
	}
}

// GetDynamicClient - return a dynamic client for use with the fake go-client
func (rc *FakeRootCmdContext) GetDynamicClient(cmd *cobra.Command) (dynamic.Interface, error) {
	return rc.dynamicClient, nil
}

// SetDynamicClient - set a dynamic client for use with the fake go-client (used for testing)
func (rc *FakeRootCmdContext) SetDynamicClient(dynClient dynamic.Interface) {
	rc.dynamicClient = dynClient
}

func NewFakeRootCmdContext(streams genericclioptions.IOStreams) *FakeRootCmdContext {
	return &FakeRootCmdContext{
		IOStreams:  streams,
		kubeClient: fake.NewSimpleClientset(),
	}
}

// NewFakeRootCmdContextWithFiles creates a newFakeRootCmdContext with the out stream and the error stream set to two separate files
func NewFakeRootCmdContextWithFiles(t *testing.T) *FakeRootCmdContextWithFiles {
	stdOutFile, stdErrfile, err := createStdTempFiles()
	assert.Nil(t, err)
	return &FakeRootCmdContextWithFiles{
		FakeRootCmdContext: FakeRootCmdContext{
			IOStreams:  genericclioptions.IOStreams{In: os.Stdin, Out: stdOutFile, ErrOut: stdErrfile},
			kubeClient: fake.NewSimpleClientset(),
		},
		Out:    stdOutFile,
		ErrOut: stdErrfile,
	}
}

// CleanUpFakeRootCmdContextWithFiles removes the standard out and standard error files from the local file system
func CleanUpNewFakeRootCmdContextWithFiles(context *FakeRootCmdContextWithFiles) {
	_, err := os.Stat(context.Out.Name())
	if !(errors.Is(err, os.ErrNotExist)) {
		os.Remove(context.Out.Name())
	}
	_, err = os.Stat(context.ErrOut.Name())
	if !(errors.Is(err, os.ErrNotExist)) {
		os.Remove(context.ErrOut.Name())
	}
}

// createStdTempFiles creates temporary files for stdout and stderr.
func createStdTempFiles() (*os.File, *os.File, error) {
	stdoutFile, err := os.CreateTemp("", "tmpstdout")
	if err != nil {
		return nil, nil, err
	}

	stderrFile, err := os.CreateTemp("", "tmpstderr")
	if err != nil {
		return nil, nil, err
	}

	return stdoutFile, stderrFile, nil
}

func (rc *FakeRootCmdContext) GetDiscoveryClient(cmd *cobra.Command) (discovery.DiscoveryInterface, error) {
	client := rc.kubeClient
	discoveryClient, ok := client.Discovery().(*discoveryFake.FakeDiscovery)
	if !ok {
		return nil, fmt.Errorf("DiscoveryClient was not successfully created")
	}
	return discoveryClient, nil
}

func (rc *FakeRootCmdContext) VerifyCLIArgsNil(cmd *cobra.Command) error {
	cmd.Args = func(cmd *cobra.Command, args []string) error {
		// In unit-tests the TestName is an arg. So to avoid tests failing because of the TestName
		// we're now checking that the arg list is greater than 1.
		if len(args) > 1 {
			return fmt.Errorf("invalid arguments specified: %s", args)
		}
		return nil
	}
	return nil
}