nodeName types.NodeName
}

func isSubpath(subpath, path string) bool {
	path = strings.TrimSuffix(path, "/")
	return subpath == path || (strings.HasPrefix(subpath, path) && subpath[len(path)] == '/')
}

// GetRequestAttributes populates authorizer attributes for the requests to the kubelet API.
// Default attributes are: {apiVersion=v1,verb=<http verb from request>,resource=nodes,name=<node name>,subresource=proxy}

            calculatedValueContainerFactory,
            allowNoMatchingVariants
        );
        this.requestAttributes = requestAttributes;
    }

    @Override
    public ImmutableAttributes getRequestAttributes() {
        return requestAttributes;
    }

            fileDependency,
            spec.getComponentFilter(),
            variantSelector,
            artifactTypeRegistry,
            calculatedValueContainerFactory,
            spec.getRequestAttributes(),
            spec.getAllowNoMatchingVariants()
        );
    }

            try {
                if (!spec.getSelectFromAllVariants()) {
                    variants = ownArtifacts.get();
                } else {
                    variants = getArtifactVariantsForReselection(spec.getRequestAttributes());
                }
            } catch (Exception e) {
                return new BrokenResolvedArtifactSet(e);
            }

            if (variants.isEmpty() && spec.getAllowNoMatchingVariants()) {

        this.sortOrder = sortOrder;
    }

    /**
     * The request attributes used to determine which variant of each graph node to select.
     */
    public ImmutableAttributes getRequestAttributes() {
        return requestAttributes;
    }

    /**
     * Filters the selected artifacts to only contain those which originated from a component matching this filter.
     */

        return variantSelector;
    }

    public boolean getAllowNoMatchingVariants() {
        return allowNoMatchingVariants;
    }

    public abstract ImmutableAttributes getRequestAttributes();

    @Override
    public void visit(Visitor listener) {
        FileCollectionStructureVisitor.VisitType visitType = listener.prepareForVisit(this);

}

// RequestAttributesGetter provides a function that extracts Attributes from an http.Request
type RequestAttributesGetter interface {
	GetRequestAttributes(user.Info, *http.Request) Attributes
}

// AttributesRecord implements Attributes interface.
type AttributesRecord struct {
	User            user.Info
	Verb            string
	Namespace       string

			getter := NewNodeAuthorizerAttributesGetter(authzTestNodeName)

			req, err := http.NewRequest(test.Method, "https://localhost:1234"+test.Path, nil)
			require.NoError(t, err)
			attrs := getter.GetRequestAttributes(AuthzTestUser(), req)

			test.AssertAttributes(t, attrs)
		})
	}
}

const (
	authzTestNodeName = "test"
	authzTestUserName = "phibby"
)

type AuthzTestCase struct {
	Method, Path string

    variantSelector,
    artifactTypeRegistry,
    calculatedValueContainerFactory,
    allowNoMatchingVariants
) {
    // These attributes are ignored by the fixed artifact variant selectors
    override fun getRequestAttributes(): ImmutableAttributes = ImmutableAttributes.EMPTY
}


private
class RecordingVariantSet(
    private val source: FileCollectionInternal,
    private val attributes: ImmutableAttributes

}

func (f *fakeAuth) AuthenticateRequest(req *http.Request) (*authenticator.Response, bool, error) {
	return f.authenticateFunc(req)
}
func (f *fakeAuth) GetRequestAttributes(u user.Info, req *http.Request) authorizer.Attributes {
	return f.attributesFunc(u, req)
}