testing

type Action interface {
	GetNamespace() string
	GetVerb() string
	GetResource() schema.GroupVersionResource
	GetSubresource() string
	Matches(verb, resource string) bool

	// DeepCopy is used to copy an action to avoid any risk of accidental mutation.  Most people never need to call this
	// because the invocation logic deep copies before calls to storage and reactors.
	DeepCopy() Action
}

type ActionImpl struct {
	Namespace   string
	Verb        string
	Resource    schema.GroupVersionResource
	Subresource string
}

type CreateAction interface {
	Action
	GetObject() runtime.Object
}

type CreateActionImpl struct {
	ActionImpl
	Name   string
	Object runtime.Object
}

type DeleteAction interface {
	Action
	GetName() string
}

type DeleteActionImpl struct {
	ActionImpl
	Name string
}

type DeleteCollectionAction interface {
	Action
	GetListRestrictions() ListRestrictions
}

type DeleteCollectionActionImpl struct {
	ActionImpl
	ListRestrictions ListRestrictions
}

type Fake struct {
	sync.RWMutex

	// ReactionChain is the list of reactors that will be attempted for every
	// request in the order they are tried.
	ReactionChain []Reactor
	// WatchReactionChain is the list of watch reactors that will be attempted
	// for every request in the order they are tried.
	WatchReactionChain []WatchReactor
	// ProxyReactionChain is the list of proxy reactors that will be attempted
	// for every request in the order they are tried.
	ProxyReactionChain []ProxyReactor

	Resources []*metav1.APIResourceList
	// contains filtered or unexported fields
}

type GenericAction interface {
	Action
	GetValue() interface{}
}

type GenericActionImpl struct {
	ActionImpl
	Value interface{}
}

type GetAction interface {
	Action
	GetName() string
}

type GetActionImpl struct {
	ActionImpl
	Name string
}

type ListAction interface {
	Action
	GetListRestrictions() ListRestrictions
}

type ListActionImpl struct {
	ActionImpl
	Kind             schema.GroupVersionKind
	Name             string
	ListRestrictions ListRestrictions
}

type ListRestrictions struct {
	Labels labels.Selector
	Fields fields.Selector
}

type ObjectScheme interface {
	runtime.ObjectCreater
	runtime.ObjectTyper
}

type ObjectTracker interface {
	// Add adds an object to the tracker. If object being added
	// is a list, its items are added separately.
	Add(obj runtime.Object) error

	// Get retrieves the object by its kind, namespace and name.
	Get(gvr schema.GroupVersionResource, ns, name string) (runtime.Object, error)

	// Create adds an object to the tracker in the specified namespace.
	Create(gvr schema.GroupVersionResource, obj runtime.Object, ns string) error

	// Update updates an existing object in the tracker in the specified namespace.
	Update(gvr schema.GroupVersionResource, obj runtime.Object, ns string) error

	// List retrieves all objects of a given kind in the given
	// namespace. Only non-List kinds are accepted.
	List(gvr schema.GroupVersionResource, gvk schema.GroupVersionKind, ns string) (runtime.Object, error)

	// Delete deletes an existing object from the tracker. If object
	// didn't exist in the tracker prior to deletion, Delete returns
	// no error.
	Delete(gvr schema.GroupVersionResource, ns, name string) error

	// Watch watches objects from the tracker. Watch returns a channel
	// which will push added / modified / deleted object.
	Watch(gvr schema.GroupVersionResource, ns string) (watch.Interface, error)
}

type PatchAction interface {
	Action
	GetName() string
	GetPatch() []byte
}

type PatchActionImpl struct {
	ActionImpl
	Name  string
	Patch []byte
}

type ProxyGetAction interface {
	Action
	GetScheme() string
	GetName() string
	GetPort() string
	GetPath() string
	GetParams() map[string]string
}

type ProxyGetActionImpl struct {
	ActionImpl
	Scheme string
	Name   string
	Port   string
	Path   string
	Params map[string]string
}

type ProxyReactionFunc func(action Action) (handled bool, ret restclient.ResponseWrapper, err error)

type ProxyReactor interface {
	// Handles indicates whether or not this Reactor deals with a given
	// action.
	Handles(action Action) bool
	// React handles a watch action and returns results.  It may choose to
	// delegate by indicating handled=false.
	React(action Action) (handled bool, ret restclient.ResponseWrapper, err error)
}

type ReactionFunc func(action Action) (handled bool, ret runtime.Object, err error)

type Reactor interface {
	// Handles indicates whether or not this Reactor deals with a given
	// action.
	Handles(action Action) bool
	// React handles the action and returns results.  It may choose to
	// delegate by indicated handled=false.
	React(action Action) (handled bool, ret runtime.Object, err error)
}

type SimpleProxyReactor struct {
	Resource string

	Reaction ProxyReactionFunc
}

type SimpleReactor struct {
	Verb     string
	Resource string

	Reaction ReactionFunc
}

type SimpleWatchReactor struct {
	Resource string

	Reaction WatchReactionFunc
}

type UpdateAction interface {
	Action
	GetObject() runtime.Object
}

type UpdateActionImpl struct {
	ActionImpl
	Object runtime.Object
}

type WatchAction interface {
	Action
	GetWatchRestrictions() WatchRestrictions
}

type WatchActionImpl struct {
	ActionImpl
	WatchRestrictions WatchRestrictions
}

type WatchReactionFunc func(action Action) (handled bool, ret watch.Interface, err error)

type WatchReactor interface {
	// Handles indicates whether or not this Reactor deals with a given
	// action.
	Handles(action Action) bool
	// React handles a watch action and returns results.  It may choose to
	// delegate by indicating handled=false.
	React(action Action) (handled bool, ret watch.Interface, err error)
}

type WatchRestrictions struct {
	Labels          labels.Selector
	Fields          fields.Selector
	ResourceVersion string
}