networkPolicy := obj.(*networking.NetworkPolicy)
	networkPolicy.Generation = 1
}

// PrepareForUpdate clears fields that are not allowed to be set by end users on update.
func (networkPolicyStrategy) PrepareForUpdate(ctx context.Context, obj, old runtime.Object) {
	newNetworkPolicy := obj.(*networking.NetworkPolicy)
	oldNetworkPolicy := old.(*networking.NetworkPolicy)

		NewListFunc:               func() runtime.Object { return &networkingapi.NetworkPolicyList{} },
		DefaultQualifiedResource:  networkingapi.Resource("networkpolicies"),
		SingularQualifiedResource: networkingapi.Resource("networkpolicy"),

		CreateStrategy: networkpolicy.Strategy,
		UpdateStrategy: networkpolicy.Strategy,
		DeleteStrategy: networkpolicy.Strategy,

	tests := []struct {
		original *networkingv1.NetworkPolicy
		expected *networkingv1.NetworkPolicy
	}{
		{ // Empty NetworkPolicy should be set to PolicyTypes Ingress
			original: &networkingv1.NetworkPolicy{
				Spec: networkingv1.NetworkPolicySpec{
					PodSelector: metav1.LabelSelector{
						MatchLabels: map[string]string{"a": "b"},
					},
				},
			},
			expected: &networkingv1.NetworkPolicy{
				Spec: networkingv1.NetworkPolicySpec{

{{- if and (.Values.networkPolicy.enabled) (eq .Values.networkPolicy.flavor "cilium") }}
kind: CiliumNetworkPolicy
apiVersion: cilium.io/v2
metadata:
  name: {{ template "minio.fullname" . }}
  labels:
    app: {{ template "minio.name" . }}
    chart: {{ template "minio.chart" . }}
    release: {{ .Release.Name }}
    heritage: {{ .Release.Service }}
spec:
  endpointSelector:
    matchLabels:
      app: {{ template "minio.name" . }}

	}
}

func TestSetDefaultNetworkPolicy(t *testing.T) {
	tests := []struct {
		original *extensionsv1beta1.NetworkPolicy
		expected *extensionsv1beta1.NetworkPolicy
	}{
		{ // Empty NetworkPolicy should be set to PolicyTypes Ingress
			original: &extensionsv1beta1.NetworkPolicy{
				Spec: extensionsv1beta1.NetworkPolicySpec{
					PodSelector: metav1.LabelSelector{
						MatchLabels: map[string]string{"a": "b"},

	}
	rest, err := NewREST(restOptions)
	if err != nil {
		t.Fatalf("unexpected error from REST storage: %v", err)
	}
	return rest, server
}

func validNetworkPolicy() *networking.NetworkPolicy {
	return &networking.NetworkPolicy{
		ObjectMeta: metav1.ObjectMeta{
			Name:      "foo",
			Namespace: "default",
		},
		Spec: networking.NetworkPolicySpec{
			PodSelector: metav1.LabelSelector{

	client := kube.NewFakeClient(ns)

	inf := GetInformerFiltered[*v1.NetworkPolicy](client, ktypes.InformerOptions{})
	if inf.Informer == nil {
		t.Errorf("Expected valid informer, got empty")
	}
}

      "verbs": [
        "get",
        "patch",
        "update"
      ]
    },
    {
      "kind": "NetworkPolicy",
      "name": "networkpolicies",
      "namespaced": true,
      "shortNames": [
        "netpol"
      ],
      "singularName": "networkpolicy",
      "storageVersionHash": "YpfwF18m1G8=",
      "verbs": [
        "create",
        "delete",
        "deletecollection",

}

func TestUnregisteredTypeCollection(t *testing.T) {
	np := &v1.NetworkPolicy{
		ObjectMeta: metav1.ObjectMeta{
			Name:      "netpol",
			Namespace: "default",
		},
	}
	c := kube.NewFakeClient(np)

	kubeclient.Register[*v1.NetworkPolicy](
		v1.SchemeGroupVersion.WithResource("networkpolicies"),
		v1.SchemeGroupVersion.WithKind("NetworkPolicy"),

limitations under the License.
*/

package networkpolicy

import (
	"context"
	"testing"

	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/util/intstr"
	api "k8s.io/kubernetes/pkg/apis/core"
	"k8s.io/kubernetes/pkg/apis/networking"
)

func makeNetworkPolicy(isIngress, isEgress, hasEndPort bool) *networking.NetworkPolicy {

	protocolTCP := api.ProtocolTCP
	endPort := int32(32000)