func TestFullNameString(t *testing.T) {
	n := NewFullName("ns1", "l1")
	if n.String() != "ns1/l1" {
		t.Fatalf("unexpected name string: %v", n.String())
	}
}

func TestFullNameString_NoName(t *testing.T) {
	n := NewFullName("ns1", "")
	if n.String() != "ns1/" {
		t.Fatalf("unexpected name string: %v", n.String())
	}
}

func TestFullNameString_NoNamespace(t *testing.T) {
	n := NewFullName("", "l1")
	if n.String() != "l1" {

	g.Expect(GetResourceNameFromHost("default", "foo.default.svc.cluster.local")).To(Equal(resource.NewFullName("default", "foo")))
	// FQDN, cross namespace
	g.Expect(GetResourceNameFromHost("default", "foo.other.svc.cluster.local")).To(Equal(resource.NewFullName("other", "foo")))
	// short name
	g.Expect(GetResourceNameFromHost("default", "foo")).To(Equal(resource.NewFullName("default", "foo")))
	// bogus FQDN (gets treated like a short name)

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

	m := Metadata{
		FullName: NewFullName("ns1", "rs1"),
		Version:  Version("v1"),
	}

	c := m.Clone()
	g.Expect(m).To(Equal(c))
}

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

	m := Metadata{
		FullName:    NewFullName("ns1", "rs1"),
		Version:     Version("v1"),
		Annotations: map[string]string{"foo": "bar"},

func (n FullName) Validate() error {
	if len(n.Name) == 0 {
		return fmt.Errorf("invalid name '%s': name must not be empty", n.String())
	}
	return nil
}

// NewFullName creates a new FullName from the given Namespace and Name.
func NewFullName(ns Namespace, n LocalName) FullName {
	return FullName{
		Namespace: ns,
		Name:      n,
	}
}

	ClusterScoped: false,
	ValidateProto: validation.EmptyValidate,
}.MustBuild()

func createTestResource(t *testing.T, ns, name, version string) *resource.Instance {
	t.Helper()
	rname := resource.NewFullName(resource.Namespace(ns), resource.LocalName(name))
	return &resource.Instance{
		Metadata: resource.Metadata{
			FullName: rname,
			Version:  resource.Version(version),
		},
		Message: &emptypb.Empty{},

		return
	}
	for name, whs := range webhooks {
		for _, wh := range whs {
			if wh.ClientConfig.Service == nil {
				// it is an url, skip it
				continue
			}
			fname := resource.NewFullName(
				resource.Namespace(wh.ClientConfig.Service.Namespace),
				resource.LocalName(wh.ClientConfig.Service.Name))
			if !context.Exists(gvk.Service, fname) {

	// Generate blank test data
	store := memory.MakeSkipValidation(collections.All)
	collections.All.ForEach(func(s resource2.Schema) bool {
		for i := 0; i < count; i++ {
			name := resource.NewFullName("default", resource.LocalName(fmt.Sprintf("%s-%d", s.Kind(), i)))
			_, _ = store.Create(config.Config{
				Meta: config.Meta{
					GroupVersionKind: s.GroupVersionKind(),
					Name:             name.Name.String(),

		return nil, nil
	})
	ctx := &fixtures.Context{
		Resources: []*resource.Instance{
			{
				Message: &v1alpha3.VirtualService{},
				Metadata: resource.Metadata{
					FullName: resource.NewFullName("ns", "name"),
				},
				Origin: fakeOrigin{},
			},
		},
	}
	a := ValidationAnalyzer{s: testSchema}
	a.Analyze(ctx)
}

func TestSchemaValidationWrapper(t *testing.T) {

		}
	}
	return false
}

func getNamespaceLabels(c analysis.Context, nsName string) map[string]string {
	if nsName == "" {
		nsName = "default"
	}
	ns := c.Find(gvk.Namespace, resource.NewFullName("", resource.LocalName(nsName)))
	if ns == nil {
		return nil
	}
	return ns.Metadata.Labels
}

func matchesWebhooks(nsLabels, podLabels map[string]string, istioWebhooks []admitv1.MutatingWebhook) bool {

func getNamesSidecarInjectionStatus(ns resource.Namespace, c analysis.Context) (enabled bool, ok bool) {
	enabled, ok = false, false

	namespace := c.Find(gvk.Namespace, resource.NewFullName("", resource.LocalName(ns)))
	if namespace != nil {
		enabled, ok = namespace.Metadata.Labels[InjectionLabelName] == InjectionLabelEnableValue, true
	}

	return enabled, ok
}