// limitations under the License.

package resource

import (
	"testing"

	. "github.com/onsi/gomega"
	"google.golang.org/protobuf/types/known/emptypb"
)

func TestInstance_IsEmpty_False(t *testing.T) {
	g := NewWithT(t)

	e := Instance{
		Message: &emptypb.Empty{},
	}

	g.Expect(e.IsEmpty()).To(BeFalse())
}

func TestInstance_IsEmpty_True(t *testing.T) {
	g := NewWithT(t)
	e := Instance{}

	rname := resource.NewFullName(resource.Namespace(ns), resource.LocalName(name))
	return &resource.Instance{
		Metadata: resource.Metadata{
			FullName: rname,
			Version:  resource.Version(version),
		},
		Message: &emptypb.Empty{},
		Origin: &kube.Origin{
			FullName: rname,
		},
	}

																ProviderName: "origins-0",
															},
														},
														{
															RequiresType: &envoy_jwt.JwtRequirement_AllowMissing{
																AllowMissing: &emptypb.Empty{},
															},
														},
													},
												},
											},
										},
									},
								},
							},
							Providers: map[string]*envoy_jwt.JwtProvider{

	typ, err := r.Types.FindMessageByURL(url)
	if err != nil {
		// Here we ignore the error since we want istioctl to ignore unknown types due to the Envoy version change
		msg := exprpb.Type{TypeKind: &exprpb.Type_Dyn{Dyn: &emptypb.Empty{}}}
		return msg.ProtoReflect().Type(), nil
	}
	return typ, nil
}

// Wrapper is a wrapper around the Envoy ConfigDump
// It has extra helper functions for handling any/struct/marshal protobuf pain

}

func TestNewProtoInstance(t *testing.T) {
	s := Builder{
		Kind:         "Empty",
		Plural:       "Empties",
		ProtoPackage: "google.golang.org/protobuf/types/known/emptypb",
		Proto:        "google.protobuf.Empty",
	}.MustBuild()

	p, err := s.NewInstance()
	assert.NoError(t, err)
	assert.Equal(t, p, config.Spec(&emptypb.Empty{}))
}

func TestMustNewProtoInstance_Panic_Nil(t *testing.T) {
	g := NewWithT(t)

	}{
		{
			name: "valid",
			schemas: []resource.Schema{
				resource.Builder{
					Kind:   "Empty1",
					Plural: "Empty1s",
					Proto:  "google.protobuf.Empty",
				}.MustBuild(),
				resource.Builder{
					Kind:   "Empty2",
					Plural: "Empty2s",
					Proto:  "google.protobuf.Empty",
				}.MustBuild(),
			},
			expectError: false,
		},
	}

	for _, c := range cases {

	if err != nil {
		// istioctl should keep going if it encounters new Envoy versions; ignore unknown types
		return &exprpb.Type{TypeKind: &exprpb.Type_Dyn{Dyn: &emptypb.Empty{}}}, nil
	}
	return legacyproto.MessageV1(mt.New().Interface()), nil

	(*Match)(nil),         // 5: istio.security.Match
	(*Address)(nil),       // 6: istio.security.Address
	(*StringMatch)(nil),   // 7: istio.security.StringMatch
	(*emptypb.Empty)(nil), // 8: google.protobuf.Empty
}
var file_workloadapi_security_authorization_proto_depIdxs = []int32{
	0,  // 0: istio.security.Authorization.scope:type_name -> istio.security.Scope

	cases := []struct {
		name     string
		input    []*anypb.Any
		wantNack bool
	}{
		{
			name:     "wrong typed config",
			input:    []*anypb.Any{protoconv.MessageToAny(&emptypb.Empty{})},
			wantNack: true,
		},
		{
			name: "wrong value in typed struct",
			input: []*anypb.Any{protoconv.MessageToAny(&core.TypedExtensionConfig{
				Name: "wrong-input",

						{
							RequiresType: &envoy_jwt.JwtRequirement_ProviderName{
								ProviderName: name,
							},
						},
						{
							RequiresType: &envoy_jwt.JwtRequirement_AllowMissing{
								AllowMissing: &emptypb.Empty{},
							},
						},
					},
				},
			},
		})
		outterOrList = append(outterOrList, &envoy_jwt.JwtRequirement{
			RequiresType: &envoy_jwt.JwtRequirement_ProviderName{
				ProviderName: name,