vendor files

vendor/k8s.io/kubernetes/pkg/registry/extensions/replicaset/BUILD

@@ -0,0 +1,71 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "doc.go",
+        "registry.go",
+        "strategy.go",
+    ],
+    importpath = "k8s.io/kubernetes/pkg/registry/extensions/replicaset",
+    deps = [
+        "//pkg/api/legacyscheme:go_default_library",
+        "//pkg/api/pod:go_default_library",
+        "//pkg/apis/extensions:go_default_library",
+        "//pkg/apis/extensions/validation:go_default_library",
+        "//vendor/k8s.io/api/apps/v1beta2:go_default_library",
+        "//vendor/k8s.io/api/extensions/v1beta1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/equality:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/validation:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/internalversion:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/fields:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/labels:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/validation/field:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/watch:go_default_library",
+        "//vendor/k8s.io/apiserver/pkg/endpoints/request:go_default_library",
+        "//vendor/k8s.io/apiserver/pkg/registry/generic:go_default_library",
+        "//vendor/k8s.io/apiserver/pkg/registry/rest:go_default_library",
+        "//vendor/k8s.io/apiserver/pkg/storage:go_default_library",
+        "//vendor/k8s.io/apiserver/pkg/storage/names:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["strategy_test.go"],
+    importpath = "k8s.io/kubernetes/pkg/registry/extensions/replicaset",
+    library = ":go_default_library",
+    deps = [
+        "//pkg/apis/core:go_default_library",
+        "//pkg/apis/extensions:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/validation/field:go_default_library",
+        "//vendor/k8s.io/apiserver/pkg/endpoints/request:go_default_library",
+        "//vendor/k8s.io/apiserver/pkg/registry/rest:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//pkg/registry/extensions/replicaset/storage:all-srcs",
+    ],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/registry/extensions/replicaset/doc.go

@@ -0,0 +1,19 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Package replicaset provides Registry interface and it's RESTStorage
+// implementation for storing ReplicaSet api objects.
+package replicaset // import "k8s.io/kubernetes/pkg/registry/extensions/replicaset"

vendor/k8s.io/kubernetes/pkg/registry/extensions/replicaset/registry.go

@@ -0,0 +1,95 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// If you make changes to this file, you should also make the corresponding change in ReplicationController.
+
+package replicaset
+
+import (
+	"fmt"
+
+	metainternalversion "k8s.io/apimachinery/pkg/apis/meta/internalversion"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/watch"
+	genericapirequest "k8s.io/apiserver/pkg/endpoints/request"
+	"k8s.io/apiserver/pkg/registry/rest"
+	"k8s.io/kubernetes/pkg/apis/extensions"
+)
+
+// Registry is an interface for things that know how to store ReplicaSets.
+type Registry interface {
+	ListReplicaSets(ctx genericapirequest.Context, options *metainternalversion.ListOptions) (*extensions.ReplicaSetList, error)
+	WatchReplicaSets(ctx genericapirequest.Context, options *metainternalversion.ListOptions) (watch.Interface, error)
+	GetReplicaSet(ctx genericapirequest.Context, replicaSetID string, options *metav1.GetOptions) (*extensions.ReplicaSet, error)
+	CreateReplicaSet(ctx genericapirequest.Context, replicaSet *extensions.ReplicaSet, createValidation rest.ValidateObjectFunc) (*extensions.ReplicaSet, error)
+	UpdateReplicaSet(ctx genericapirequest.Context, replicaSet *extensions.ReplicaSet, createValidation rest.ValidateObjectFunc, updateValidation rest.ValidateObjectUpdateFunc) (*extensions.ReplicaSet, error)
+	DeleteReplicaSet(ctx genericapirequest.Context, replicaSetID string) error
+}
+
+// storage puts strong typing around storage calls
+type storage struct {
+	rest.StandardStorage
+}
+
+// NewRegistry returns a new Registry interface for the given Storage. Any mismatched
+// types will panic.
+func NewRegistry(s rest.StandardStorage) Registry {
+	return &storage{s}
+}
+
+func (s *storage) ListReplicaSets(ctx genericapirequest.Context, options *metainternalversion.ListOptions) (*extensions.ReplicaSetList, error) {
+	if options != nil && options.FieldSelector != nil && !options.FieldSelector.Empty() {
+		return nil, fmt.Errorf("field selector not supported yet")
+	}
+	obj, err := s.List(ctx, options)
+	if err != nil {
+		return nil, err
+	}
+	return obj.(*extensions.ReplicaSetList), err
+}
+
+func (s *storage) WatchReplicaSets(ctx genericapirequest.Context, options *metainternalversion.ListOptions) (watch.Interface, error) {
+	return s.Watch(ctx, options)
+}
+
+func (s *storage) GetReplicaSet(ctx genericapirequest.Context, replicaSetID string, options *metav1.GetOptions) (*extensions.ReplicaSet, error) {
+	obj, err := s.Get(ctx, replicaSetID, options)
+	if err != nil {
+		return nil, err
+	}
+	return obj.(*extensions.ReplicaSet), nil
+}
+
+func (s *storage) CreateReplicaSet(ctx genericapirequest.Context, replicaSet *extensions.ReplicaSet, createValidation rest.ValidateObjectFunc) (*extensions.ReplicaSet, error) {
+	obj, err := s.Create(ctx, replicaSet, createValidation, false)
+	if err != nil {
+		return nil, err
+	}
+	return obj.(*extensions.ReplicaSet), nil
+}
+
+func (s *storage) UpdateReplicaSet(ctx genericapirequest.Context, replicaSet *extensions.ReplicaSet, createValidation rest.ValidateObjectFunc, updateValidation rest.ValidateObjectUpdateFunc) (*extensions.ReplicaSet, error) {
+	obj, _, err := s.Update(ctx, replicaSet.Name, rest.DefaultUpdatedObjectInfo(replicaSet), createValidation, updateValidation)
+	if err != nil {
+		return nil, err
+	}
+	return obj.(*extensions.ReplicaSet), nil
+}
+
+func (s *storage) DeleteReplicaSet(ctx genericapirequest.Context, replicaSetID string) error {
+	_, _, err := s.Delete(ctx, replicaSetID, nil)
+	return err
+}

vendor/k8s.io/kubernetes/pkg/registry/extensions/replicaset/storage/BUILD

@@ -0,0 +1,72 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["storage_test.go"],
+    importpath = "k8s.io/kubernetes/pkg/registry/extensions/replicaset/storage",
+    library = ":go_default_library",
+    deps = [
+        "//pkg/apis/autoscaling:go_default_library",
+        "//pkg/apis/core:go_default_library",
+        "//pkg/apis/extensions:go_default_library",
+        "//pkg/registry/registrytest:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/equality:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/errors:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/fields:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/labels:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/diff:go_default_library",
+        "//vendor/k8s.io/apiserver/pkg/endpoints/request:go_default_library",
+        "//vendor/k8s.io/apiserver/pkg/registry/generic:go_default_library",
+        "//vendor/k8s.io/apiserver/pkg/registry/generic/testing:go_default_library",
+        "//vendor/k8s.io/apiserver/pkg/registry/rest:go_default_library",
+        "//vendor/k8s.io/apiserver/pkg/storage/etcd/testing:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["storage.go"],
+    importpath = "k8s.io/kubernetes/pkg/registry/extensions/replicaset/storage",
+    deps = [
+        "//pkg/apis/apps/v1beta1:go_default_library",
+        "//pkg/apis/apps/v1beta2:go_default_library",
+        "//pkg/apis/autoscaling:go_default_library",
+        "//pkg/apis/autoscaling/v1:go_default_library",
+        "//pkg/apis/autoscaling/validation:go_default_library",
+        "//pkg/apis/extensions:go_default_library",
+        "//pkg/apis/extensions/v1beta1:go_default_library",
+        "//pkg/printers:go_default_library",
+        "//pkg/printers/internalversion:go_default_library",
+        "//pkg/printers/storage:go_default_library",
+        "//pkg/registry/extensions/replicaset:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/errors:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
+        "//vendor/k8s.io/apiserver/pkg/endpoints/request:go_default_library",
+        "//vendor/k8s.io/apiserver/pkg/registry/generic:go_default_library",
+        "//vendor/k8s.io/apiserver/pkg/registry/generic/registry:go_default_library",
+        "//vendor/k8s.io/apiserver/pkg/registry/rest:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/registry/extensions/replicaset/storage/storage.go

@@ -0,0 +1,229 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// If you make changes to this file, you should also make the corresponding change in ReplicationController.
+
+package storage
+
+import (
+	"fmt"
+
+	"k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	genericapirequest "k8s.io/apiserver/pkg/endpoints/request"
+	"k8s.io/apiserver/pkg/registry/generic"
+	genericregistry "k8s.io/apiserver/pkg/registry/generic/registry"
+	"k8s.io/apiserver/pkg/registry/rest"
+	appsv1beta1 "k8s.io/kubernetes/pkg/apis/apps/v1beta1"
+	appsv1beta2 "k8s.io/kubernetes/pkg/apis/apps/v1beta2"
+	"k8s.io/kubernetes/pkg/apis/autoscaling"
+	autoscalingv1 "k8s.io/kubernetes/pkg/apis/autoscaling/v1"
+	autoscalingvalidation "k8s.io/kubernetes/pkg/apis/autoscaling/validation"
+	"k8s.io/kubernetes/pkg/apis/extensions"
+	extensionsv1beta1 "k8s.io/kubernetes/pkg/apis/extensions/v1beta1"
+	"k8s.io/kubernetes/pkg/printers"
+	printersinternal "k8s.io/kubernetes/pkg/printers/internalversion"
+	printerstorage "k8s.io/kubernetes/pkg/printers/storage"
+	"k8s.io/kubernetes/pkg/registry/extensions/replicaset"
+)
+
+// ReplicaSetStorage includes dummy storage for ReplicaSets and for Scale subresource.
+type ReplicaSetStorage struct {
+	ReplicaSet *REST
+	Status     *StatusREST
+	Scale      *ScaleREST
+}
+
+func NewStorage(optsGetter generic.RESTOptionsGetter) ReplicaSetStorage {
+	replicaSetRest, replicaSetStatusRest := NewREST(optsGetter)
+	replicaSetRegistry := replicaset.NewRegistry(replicaSetRest)
+
+	return ReplicaSetStorage{
+		ReplicaSet: replicaSetRest,
+		Status:     replicaSetStatusRest,
+		Scale:      &ScaleREST{registry: replicaSetRegistry},
+	}
+}
+
+type REST struct {
+	*genericregistry.Store
+}
+
+// NewREST returns a RESTStorage object that will work against ReplicaSet.
+func NewREST(optsGetter generic.RESTOptionsGetter) (*REST, *StatusREST) {
+	store := &genericregistry.Store{
+		NewFunc:                  func() runtime.Object { return &extensions.ReplicaSet{} },
+		NewListFunc:              func() runtime.Object { return &extensions.ReplicaSetList{} },
+		PredicateFunc:            replicaset.MatchReplicaSet,
+		DefaultQualifiedResource: extensions.Resource("replicasets"),
+
+		CreateStrategy: replicaset.Strategy,
+		UpdateStrategy: replicaset.Strategy,
+		DeleteStrategy: replicaset.Strategy,
+
+		TableConvertor: printerstorage.TableConvertor{TablePrinter: printers.NewTablePrinter().With(printersinternal.AddHandlers)},
+	}
+	options := &generic.StoreOptions{RESTOptions: optsGetter, AttrFunc: replicaset.GetAttrs}
+	if err := store.CompleteWithOptions(options); err != nil {
+		panic(err) // TODO: Propagate error up
+	}
+
+	statusStore := *store
+	statusStore.UpdateStrategy = replicaset.StatusStrategy
+
+	return &REST{store}, &StatusREST{store: &statusStore}
+}
+
+// Implement ShortNamesProvider
+var _ rest.ShortNamesProvider = &REST{}
+
+// ShortNames implements the ShortNamesProvider interface. Returns a list of short names for a resource.
+func (r *REST) ShortNames() []string {
+	return []string{"rs"}
+}
+
+// Implement CategoriesProvider
+var _ rest.CategoriesProvider = &REST{}
+
+// Categories implements the CategoriesProvider interface. Returns a list of categories a resource is part of.
+func (r *REST) Categories() []string {
+	return []string{"all"}
+}
+
+// StatusREST implements the REST endpoint for changing the status of a ReplicaSet
+type StatusREST struct {
+	store *genericregistry.Store
+}
+
+func (r *StatusREST) New() runtime.Object {
+	return &extensions.ReplicaSet{}
+}
+
+// Get retrieves the object from the storage. It is required to support Patch.
+func (r *StatusREST) Get(ctx genericapirequest.Context, name string, options *metav1.GetOptions) (runtime.Object, error) {
+	return r.store.Get(ctx, name, options)
+}
+
+// Update alters the status subset of an object.
+func (r *StatusREST) Update(ctx genericapirequest.Context, name string, objInfo rest.UpdatedObjectInfo, createValidation rest.ValidateObjectFunc, updateValidation rest.ValidateObjectUpdateFunc) (runtime.Object, bool, error) {
+	return r.store.Update(ctx, name, objInfo, createValidation, updateValidation)
+}
+
+type ScaleREST struct {
+	registry replicaset.Registry
+}
+
+// ScaleREST implements Patcher
+var _ = rest.Patcher(&ScaleREST{})
+var _ = rest.GroupVersionKindProvider(&ScaleREST{})
+
+func (r *ScaleREST) GroupVersionKind(containingGV schema.GroupVersion) schema.GroupVersionKind {
+	switch containingGV {
+	case extensionsv1beta1.SchemeGroupVersion:
+		return extensionsv1beta1.SchemeGroupVersion.WithKind("Scale")
+	case appsv1beta1.SchemeGroupVersion:
+		return appsv1beta1.SchemeGroupVersion.WithKind("Scale")
+	case appsv1beta2.SchemeGroupVersion:
+		return appsv1beta2.SchemeGroupVersion.WithKind("Scale")
+	default:
+		return autoscalingv1.SchemeGroupVersion.WithKind("Scale")
+	}
+}
+
+// New creates a new Scale object
+func (r *ScaleREST) New() runtime.Object {
+	return &autoscaling.Scale{}
+}
+
+func (r *ScaleREST) Get(ctx genericapirequest.Context, name string, options *metav1.GetOptions) (runtime.Object, error) {
+	rs, err := r.registry.GetReplicaSet(ctx, name, options)
+	if err != nil {
+		return nil, errors.NewNotFound(extensions.Resource("replicasets/scale"), name)
+	}
+	scale, err := scaleFromReplicaSet(rs)
+	if err != nil {
+		return nil, errors.NewBadRequest(fmt.Sprintf("%v", err))
+	}
+	return scale, err
+}
+
+func (r *ScaleREST) Update(ctx genericapirequest.Context, name string, objInfo rest.UpdatedObjectInfo, createValidation rest.ValidateObjectFunc, updateValidation rest.ValidateObjectUpdateFunc) (runtime.Object, bool, error) {
+	rs, err := r.registry.GetReplicaSet(ctx, name, &metav1.GetOptions{})
+	if err != nil {
+		return nil, false, errors.NewNotFound(extensions.Resource("replicasets/scale"), name)
+	}
+
+	oldScale, err := scaleFromReplicaSet(rs)
+	if err != nil {
+		return nil, false, err
+	}
+
+	// TODO: should this pass admission?
+	obj, err := objInfo.UpdatedObject(ctx, oldScale)
+	if err != nil {
+		return nil, false, err
+	}
+	if obj == nil {
+		return nil, false, errors.NewBadRequest(fmt.Sprintf("nil update passed to Scale"))
+	}
+	scale, ok := obj.(*autoscaling.Scale)
+	if !ok {
+		return nil, false, errors.NewBadRequest(fmt.Sprintf("wrong object passed to Scale update: %v", obj))
+	}
+
+	if errs := autoscalingvalidation.ValidateScale(scale); len(errs) > 0 {
+		return nil, false, errors.NewInvalid(extensions.Kind("Scale"), scale.Name, errs)
+	}
+
+	rs.Spec.Replicas = scale.Spec.Replicas
+	rs.ResourceVersion = scale.ResourceVersion
+	rs, err = r.registry.UpdateReplicaSet(ctx, rs, createValidation, updateValidation)
+	if err != nil {
+		return nil, false, err
+	}
+	newScale, err := scaleFromReplicaSet(rs)
+	if err != nil {
+		return nil, false, errors.NewBadRequest(fmt.Sprintf("%v", err))
+	}
+	return newScale, false, err
+}
+
+// scaleFromReplicaSet returns a scale subresource for a replica set.
+func scaleFromReplicaSet(rs *extensions.ReplicaSet) (*autoscaling.Scale, error) {
+	selector, err := metav1.LabelSelectorAsSelector(rs.Spec.Selector)
+	if err != nil {
+		return nil, err
+	}
+	return &autoscaling.Scale{
+		// TODO: Create a variant of ObjectMeta type that only contains the fields below.
+		ObjectMeta: metav1.ObjectMeta{
+			Name:              rs.Name,
+			Namespace:         rs.Namespace,
+			UID:               rs.UID,
+			ResourceVersion:   rs.ResourceVersion,
+			CreationTimestamp: rs.CreationTimestamp,
+		},
+		Spec: autoscaling.ScaleSpec{
+			Replicas: rs.Spec.Replicas,
+		},
+		Status: autoscaling.ScaleStatus{
+			Replicas: rs.Status.Replicas,
+			Selector: selector.String(),
+		},
+	}, nil
+}

vendor/k8s.io/kubernetes/pkg/registry/extensions/replicaset/storage/storage_test.go

@@ -0,0 +1,393 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package storage
+
+import (
+	"testing"
+
+	apiequality "k8s.io/apimachinery/pkg/api/equality"
+	"k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/fields"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/util/diff"
+	genericapirequest "k8s.io/apiserver/pkg/endpoints/request"
+	"k8s.io/apiserver/pkg/registry/generic"
+	genericregistrytest "k8s.io/apiserver/pkg/registry/generic/testing"
+	"k8s.io/apiserver/pkg/registry/rest"
+	etcdtesting "k8s.io/apiserver/pkg/storage/etcd/testing"
+	"k8s.io/kubernetes/pkg/apis/autoscaling"
+	api "k8s.io/kubernetes/pkg/apis/core"
+	"k8s.io/kubernetes/pkg/apis/extensions"
+	"k8s.io/kubernetes/pkg/registry/registrytest"
+)
+
+const defaultReplicas = 100
+
+func newStorage(t *testing.T) (*ReplicaSetStorage, *etcdtesting.EtcdTestServer) {
+	etcdStorage, server := registrytest.NewEtcdStorage(t, "extensions")
+	restOptions := generic.RESTOptions{StorageConfig: etcdStorage, Decorator: generic.UndecoratedStorage, DeleteCollectionWorkers: 1, ResourcePrefix: "replicasets"}
+	replicaSetStorage := NewStorage(restOptions)
+	return &replicaSetStorage, server
+}
+
+// createReplicaSet is a helper function that returns a ReplicaSet with the updated resource version.
+func createReplicaSet(storage *REST, rs extensions.ReplicaSet, t *testing.T) (extensions.ReplicaSet, error) {
+	ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), rs.Namespace)
+	obj, err := storage.Create(ctx, &rs, rest.ValidateAllObjectFunc, false)
+	if err != nil {
+		t.Errorf("Failed to create ReplicaSet, %v", err)
+	}
+	newRS := obj.(*extensions.ReplicaSet)
+	return *newRS, nil
+}
+
+func validNewReplicaSet() *extensions.ReplicaSet {
+	return &extensions.ReplicaSet{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "foo",
+			Namespace: metav1.NamespaceDefault,
+		},
+		Spec: extensions.ReplicaSetSpec{
+			Selector: &metav1.LabelSelector{MatchLabels: map[string]string{"a": "b"}},
+			Template: api.PodTemplateSpec{
+				ObjectMeta: metav1.ObjectMeta{
+					Labels: map[string]string{"a": "b"},
+				},
+				Spec: api.PodSpec{
+					Containers: []api.Container{
+						{
+							Name:                     "test",
+							Image:                    "test_image",
+							ImagePullPolicy:          api.PullIfNotPresent,
+							TerminationMessagePolicy: api.TerminationMessageReadFile,
+						},
+					},
+					RestartPolicy: api.RestartPolicyAlways,
+					DNSPolicy:     api.DNSClusterFirst,
+				},
+			},
+			Replicas: 7,
+		},
+		Status: extensions.ReplicaSetStatus{
+			Replicas: 5,
+		},
+	}
+}
+
+var validReplicaSet = *validNewReplicaSet()
+
+func TestCreate(t *testing.T) {
+	storage, server := newStorage(t)
+	defer server.Terminate(t)
+	defer storage.ReplicaSet.Store.DestroyFunc()
+	test := genericregistrytest.New(t, storage.ReplicaSet.Store)
+	rs := validNewReplicaSet()
+	rs.ObjectMeta = metav1.ObjectMeta{}
+	test.TestCreate(
+		// valid
+		rs,
+		// invalid (invalid selector)
+		&extensions.ReplicaSet{
+			Spec: extensions.ReplicaSetSpec{
+				Replicas: 2,
+				Selector: &metav1.LabelSelector{MatchLabels: map[string]string{}},
+				Template: validReplicaSet.Spec.Template,
+			},
+		},
+	)
+}
+
+func TestUpdate(t *testing.T) {
+	storage, server := newStorage(t)
+	defer server.Terminate(t)
+	defer storage.ReplicaSet.Store.DestroyFunc()
+	test := genericregistrytest.New(t, storage.ReplicaSet.Store)
+	test.TestUpdate(
+		// valid
+		validNewReplicaSet(),
+		// valid updateFunc
+		func(obj runtime.Object) runtime.Object {
+			object := obj.(*extensions.ReplicaSet)
+			object.Spec.Replicas = object.Spec.Replicas + 1
+			return object
+		},
+		// invalid updateFunc
+		func(obj runtime.Object) runtime.Object {
+			object := obj.(*extensions.ReplicaSet)
+			object.Name = ""
+			return object
+		},
+		func(obj runtime.Object) runtime.Object {
+			object := obj.(*extensions.ReplicaSet)
+			object.Spec.Selector = &metav1.LabelSelector{MatchLabels: map[string]string{}}
+			return object
+		},
+	)
+}
+
+func TestDelete(t *testing.T) {
+	storage, server := newStorage(t)
+	defer server.Terminate(t)
+	defer storage.ReplicaSet.Store.DestroyFunc()
+	test := genericregistrytest.New(t, storage.ReplicaSet.Store)
+	test.TestDelete(validNewReplicaSet())
+}
+
+func TestGenerationNumber(t *testing.T) {
+	storage, server := newStorage(t)
+	defer server.Terminate(t)
+	defer storage.ReplicaSet.Store.DestroyFunc()
+	modifiedSno := *validNewReplicaSet()
+	modifiedSno.Generation = 100
+	modifiedSno.Status.ObservedGeneration = 10
+	ctx := genericapirequest.NewDefaultContext()
+	rs, err := createReplicaSet(storage.ReplicaSet, modifiedSno, t)
+	etcdRS, err := storage.ReplicaSet.Get(ctx, rs.Name, &metav1.GetOptions{})
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	storedRS, _ := etcdRS.(*extensions.ReplicaSet)
+
+	// Generation initialization
+	if storedRS.Generation != 1 && storedRS.Status.ObservedGeneration != 0 {
+		t.Fatalf("Unexpected generation number %v, status generation %v", storedRS.Generation, storedRS.Status.ObservedGeneration)
+	}
+
+	// Updates to spec should increment the generation number
+	storedRS.Spec.Replicas += 1
+	storage.ReplicaSet.Update(ctx, storedRS.Name, rest.DefaultUpdatedObjectInfo(storedRS), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc)
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	etcdRS, err = storage.ReplicaSet.Get(ctx, rs.Name, &metav1.GetOptions{})
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	storedRS, _ = etcdRS.(*extensions.ReplicaSet)
+	if storedRS.Generation != 2 || storedRS.Status.ObservedGeneration != 0 {
+		t.Fatalf("Unexpected generation, spec: %v, status: %v", storedRS.Generation, storedRS.Status.ObservedGeneration)
+	}
+
+	// Updates to status should not increment either spec or status generation numbers
+	storedRS.Status.Replicas += 1
+	storage.ReplicaSet.Update(ctx, storedRS.Name, rest.DefaultUpdatedObjectInfo(storedRS), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc)
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	etcdRS, err = storage.ReplicaSet.Get(ctx, rs.Name, &metav1.GetOptions{})
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	storedRS, _ = etcdRS.(*extensions.ReplicaSet)
+	if storedRS.Generation != 2 || storedRS.Status.ObservedGeneration != 0 {
+		t.Fatalf("Unexpected generation number, spec: %v, status: %v", storedRS.Generation, storedRS.Status.ObservedGeneration)
+	}
+}
+
+func TestGet(t *testing.T) {
+	storage, server := newStorage(t)
+	defer server.Terminate(t)
+	defer storage.ReplicaSet.Store.DestroyFunc()
+	test := genericregistrytest.New(t, storage.ReplicaSet.Store)
+	test.TestGet(validNewReplicaSet())
+}
+
+func TestList(t *testing.T) {
+	storage, server := newStorage(t)
+	defer server.Terminate(t)
+	defer storage.ReplicaSet.Store.DestroyFunc()
+	test := genericregistrytest.New(t, storage.ReplicaSet.Store)
+	test.TestList(validNewReplicaSet())
+}
+
+func TestWatch(t *testing.T) {
+	storage, server := newStorage(t)
+	defer server.Terminate(t)
+	defer storage.ReplicaSet.Store.DestroyFunc()
+	test := genericregistrytest.New(t, storage.ReplicaSet.Store)
+	test.TestWatch(
+		validNewReplicaSet(),
+		// matching labels
+		[]labels.Set{
+			{"a": "b"},
+		},
+		// not matching labels
+		[]labels.Set{
+			{"a": "c"},
+			{"foo": "bar"},
+		},
+		// matching fields
+		[]fields.Set{
+			{"status.replicas": "5"},
+			{"metadata.name": "foo"},
+			{"status.replicas": "5", "metadata.name": "foo"},
+		},
+		// not matchin fields
+		[]fields.Set{
+			{"status.replicas": "10"},
+			{"metadata.name": "bar"},
+			{"name": "foo"},
+			{"status.replicas": "10", "metadata.name": "foo"},
+			{"status.replicas": "0", "metadata.name": "bar"},
+		},
+	)
+}
+
+func TestScaleGet(t *testing.T) {
+	storage, server := newStorage(t)
+	defer server.Terminate(t)
+	defer storage.ReplicaSet.Store.DestroyFunc()
+
+	name := "foo"
+
+	var rs extensions.ReplicaSet
+	ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), metav1.NamespaceDefault)
+	key := "/replicasets/" + metav1.NamespaceDefault + "/" + name
+	if err := storage.ReplicaSet.Storage.Create(ctx, key, &validReplicaSet, &rs, 0); err != nil {
+		t.Fatalf("error setting new replica set (key: %s) %v: %v", key, validReplicaSet, err)
+	}
+
+	selector, err := metav1.LabelSelectorAsSelector(validReplicaSet.Spec.Selector)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	want := &autoscaling.Scale{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:              name,
+			Namespace:         metav1.NamespaceDefault,
+			UID:               rs.UID,
+			ResourceVersion:   rs.ResourceVersion,
+			CreationTimestamp: rs.CreationTimestamp,
+		},
+		Spec: autoscaling.ScaleSpec{
+			Replicas: validReplicaSet.Spec.Replicas,
+		},
+		Status: autoscaling.ScaleStatus{
+			Replicas: validReplicaSet.Status.Replicas,
+			Selector: selector.String(),
+		},
+	}
+	obj, err := storage.Scale.Get(ctx, name, &metav1.GetOptions{})
+	got := obj.(*autoscaling.Scale)
+	if err != nil {
+		t.Fatalf("error fetching scale for %s: %v", name, err)
+	}
+	if !apiequality.Semantic.DeepEqual(got, want) {
+		t.Errorf("unexpected scale: %s", diff.ObjectDiff(got, want))
+	}
+}
+
+func TestScaleUpdate(t *testing.T) {
+	storage, server := newStorage(t)
+	defer server.Terminate(t)
+	defer storage.ReplicaSet.Store.DestroyFunc()
+
+	name := "foo"
+
+	var rs extensions.ReplicaSet
+	ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), metav1.NamespaceDefault)
+	key := "/replicasets/" + metav1.NamespaceDefault + "/" + name
+	if err := storage.ReplicaSet.Storage.Create(ctx, key, &validReplicaSet, &rs, 0); err != nil {
+		t.Fatalf("error setting new replica set (key: %s) %v: %v", key, validReplicaSet, err)
+	}
+	replicas := 12
+	update := autoscaling.Scale{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      name,
+			Namespace: metav1.NamespaceDefault,
+		},
+		Spec: autoscaling.ScaleSpec{
+			Replicas: int32(replicas),
+		},
+	}
+
+	if _, _, err := storage.Scale.Update(ctx, update.Name, rest.DefaultUpdatedObjectInfo(&update), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc); err != nil {
+		t.Fatalf("error updating scale %v: %v", update, err)
+	}
+
+	obj, err := storage.Scale.Get(ctx, name, &metav1.GetOptions{})
+	if err != nil {
+		t.Fatalf("error fetching scale for %s: %v", name, err)
+	}
+	scale := obj.(*autoscaling.Scale)
+	if scale.Spec.Replicas != int32(replicas) {
+		t.Errorf("wrong replicas count expected: %d got: %d", replicas, scale.Spec.Replicas)
+	}
+
+	update.ResourceVersion = rs.ResourceVersion
+	update.Spec.Replicas = 15
+
+	if _, _, err = storage.Scale.Update(ctx, update.Name, rest.DefaultUpdatedObjectInfo(&update), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc); err != nil && !errors.IsConflict(err) {
+		t.Fatalf("unexpected error, expecting an update conflict but got %v", err)
+	}
+}
+
+func TestStatusUpdate(t *testing.T) {
+	storage, server := newStorage(t)
+	defer server.Terminate(t)
+	defer storage.ReplicaSet.Store.DestroyFunc()
+
+	ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), metav1.NamespaceDefault)
+	key := "/replicasets/" + metav1.NamespaceDefault + "/foo"
+	if err := storage.ReplicaSet.Storage.Create(ctx, key, &validReplicaSet, nil, 0); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	update := extensions.ReplicaSet{
+		ObjectMeta: validReplicaSet.ObjectMeta,
+		Spec: extensions.ReplicaSetSpec{
+			Replicas: defaultReplicas,
+		},
+		Status: extensions.ReplicaSetStatus{
+			Replicas: defaultReplicas,
+		},
+	}
+
+	if _, _, err := storage.Status.Update(ctx, update.Name, rest.DefaultUpdatedObjectInfo(&update), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	obj, err := storage.ReplicaSet.Get(ctx, "foo", &metav1.GetOptions{})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	rs := obj.(*extensions.ReplicaSet)
+	if rs.Spec.Replicas != 7 {
+		t.Errorf("we expected .spec.replicas to not be updated but it was updated to %v", rs.Spec.Replicas)
+	}
+	if rs.Status.Replicas != defaultReplicas {
+		t.Errorf("we expected .status.replicas to be updated to %d but it was %v", defaultReplicas, rs.Status.Replicas)
+	}
+}
+
+func TestShortNames(t *testing.T) {
+	storage, server := newStorage(t)
+	defer server.Terminate(t)
+	defer storage.ReplicaSet.DestroyFunc()
+	expected := []string{"rs"}
+	registrytest.AssertShortNames(t, storage.ReplicaSet, expected)
+}
+
+func TestCategories(t *testing.T) {
+	storage, server := newStorage(t)
+	defer server.Terminate(t)
+	defer storage.ReplicaSet.Store.DestroyFunc()
+	expected := []string{"all"}
+	registrytest.AssertCategories(t, storage.ReplicaSet, expected)
+}

vendor/k8s.io/kubernetes/pkg/registry/extensions/replicaset/strategy.go

@@ -0,0 +1,196 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// If you make changes to this file, you should also make the corresponding change in ReplicationController.
+
+package replicaset
+
+import (
+	"fmt"
+	"strconv"
+
+	appsv1beta2 "k8s.io/api/apps/v1beta2"
+	extensionsv1beta1 "k8s.io/api/extensions/v1beta1"
+	apiequality "k8s.io/apimachinery/pkg/api/equality"
+	apivalidation "k8s.io/apimachinery/pkg/api/validation"
+	"k8s.io/apimachinery/pkg/fields"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/util/validation/field"
+	genericapirequest "k8s.io/apiserver/pkg/endpoints/request"
+	"k8s.io/apiserver/pkg/registry/generic"
+	"k8s.io/apiserver/pkg/registry/rest"
+	apistorage "k8s.io/apiserver/pkg/storage"
+	"k8s.io/apiserver/pkg/storage/names"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
+	"k8s.io/kubernetes/pkg/api/pod"
+	"k8s.io/kubernetes/pkg/apis/extensions"
+	"k8s.io/kubernetes/pkg/apis/extensions/validation"
+)
+
+// rsStrategy implements verification logic for ReplicaSets.
+type rsStrategy struct {
+	runtime.ObjectTyper
+	names.NameGenerator
+}
+
+// Strategy is the default logic that applies when creating and updating ReplicaSet objects.
+var Strategy = rsStrategy{legacyscheme.Scheme, names.SimpleNameGenerator}
+
+// DefaultGarbageCollectionPolicy returns OrphanDependents by default. For apps/v1, returns DeleteDependents.
+func (rsStrategy) DefaultGarbageCollectionPolicy(ctx genericapirequest.Context) rest.GarbageCollectionPolicy {
+	if requestInfo, found := genericapirequest.RequestInfoFrom(ctx); found {
+		groupVersion := schema.GroupVersion{Group: requestInfo.APIGroup, Version: requestInfo.APIVersion}
+		switch groupVersion {
+		case extensionsv1beta1.SchemeGroupVersion, appsv1beta2.SchemeGroupVersion:
+			// for back compatibility
+			return rest.OrphanDependents
+		default:
+			return rest.DeleteDependents
+		}
+	}
+	return rest.OrphanDependents
+}
+
+// NamespaceScoped returns true because all ReplicaSets need to be within a namespace.
+func (rsStrategy) NamespaceScoped() bool {
+	return true
+}
+
+// PrepareForCreate clears the status of a ReplicaSet before creation.
+func (rsStrategy) PrepareForCreate(ctx genericapirequest.Context, obj runtime.Object) {
+	rs := obj.(*extensions.ReplicaSet)
+	rs.Status = extensions.ReplicaSetStatus{}
+
+	rs.Generation = 1
+
+	pod.DropDisabledAlphaFields(&rs.Spec.Template.Spec)
+}
+
+// PrepareForUpdate clears fields that are not allowed to be set by end users on update.
+func (rsStrategy) PrepareForUpdate(ctx genericapirequest.Context, obj, old runtime.Object) {
+	newRS := obj.(*extensions.ReplicaSet)
+	oldRS := old.(*extensions.ReplicaSet)
+	// update is not allowed to set status
+	newRS.Status = oldRS.Status
+
+	pod.DropDisabledAlphaFields(&newRS.Spec.Template.Spec)
+	pod.DropDisabledAlphaFields(&oldRS.Spec.Template.Spec)
+
+	// Any changes to the spec increment the generation number, any changes to the
+	// status should reflect the generation number of the corresponding object. We push
+	// the burden of managing the status onto the clients because we can't (in general)
+	// know here what version of spec the writer of the status has seen. It may seem like
+	// we can at first -- since obj contains spec -- but in the future we will probably make
+	// status its own object, and even if we don't, writes may be the result of a
+	// read-update-write loop, so the contents of spec may not actually be the spec that
+	// the ReplicaSet has *seen*.
+	if !apiequality.Semantic.DeepEqual(oldRS.Spec, newRS.Spec) {
+		newRS.Generation = oldRS.Generation + 1
+	}
+}
+
+// Validate validates a new ReplicaSet.
+func (rsStrategy) Validate(ctx genericapirequest.Context, obj runtime.Object) field.ErrorList {
+	rs := obj.(*extensions.ReplicaSet)
+	return validation.ValidateReplicaSet(rs)
+}
+
+// Canonicalize normalizes the object after validation.
+func (rsStrategy) Canonicalize(obj runtime.Object) {
+}
+
+// AllowCreateOnUpdate is false for ReplicaSets; this means a POST is
+// needed to create one.
+func (rsStrategy) AllowCreateOnUpdate() bool {
+	return false
+}
+
+// ValidateUpdate is the default update validation for an end user.
+func (rsStrategy) ValidateUpdate(ctx genericapirequest.Context, obj, old runtime.Object) field.ErrorList {
+	newReplicaSet := obj.(*extensions.ReplicaSet)
+	oldReplicaSet := old.(*extensions.ReplicaSet)
+	allErrs := validation.ValidateReplicaSet(obj.(*extensions.ReplicaSet))
+	allErrs = append(allErrs, validation.ValidateReplicaSetUpdate(newReplicaSet, oldReplicaSet)...)
+
+	// Update is not allowed to set Spec.Selector for all groups/versions except extensions/v1beta1.
+	// If RequestInfo is nil, it is better to revert to old behavior (i.e. allow update to set Spec.Selector)
+	// to prevent unintentionally breaking users who may rely on the old behavior.
+	// TODO(#50791): after extensions/v1beta1 is removed, move selector immutability check inside ValidateReplicaSetUpdate().
+	if requestInfo, found := genericapirequest.RequestInfoFrom(ctx); found {
+		groupVersion := schema.GroupVersion{Group: requestInfo.APIGroup, Version: requestInfo.APIVersion}
+		switch groupVersion {
+		case extensionsv1beta1.SchemeGroupVersion:
+			// no-op for compatibility
+		default:
+			// disallow mutation of selector
+			allErrs = append(allErrs, apivalidation.ValidateImmutableField(newReplicaSet.Spec.Selector, oldReplicaSet.Spec.Selector, field.NewPath("spec").Child("selector"))...)
+		}
+	}
+
+	return allErrs
+}
+
+func (rsStrategy) AllowUnconditionalUpdate() bool {
+	return true
+}
+
+// ReplicaSetToSelectableFields returns a field set that represents the object.
+func ReplicaSetToSelectableFields(rs *extensions.ReplicaSet) fields.Set {
+	objectMetaFieldsSet := generic.ObjectMetaFieldsSet(&rs.ObjectMeta, true)
+	rsSpecificFieldsSet := fields.Set{
+		"status.replicas": strconv.Itoa(int(rs.Status.Replicas)),
+	}
+	return generic.MergeFieldsSets(objectMetaFieldsSet, rsSpecificFieldsSet)
+}
+
+// GetAttrs returns labels and fields of a given object for filtering purposes.
+func GetAttrs(obj runtime.Object) (labels.Set, fields.Set, bool, error) {
+	rs, ok := obj.(*extensions.ReplicaSet)
+	if !ok {
+		return nil, nil, false, fmt.Errorf("given object is not a ReplicaSet.")
+	}
+	return labels.Set(rs.ObjectMeta.Labels), ReplicaSetToSelectableFields(rs), rs.Initializers != nil, nil
+}
+
+// MatchReplicaSet is the filter used by the generic etcd backend to route
+// watch events from etcd to clients of the apiserver only interested in specific
+// labels/fields.
+func MatchReplicaSet(label labels.Selector, field fields.Selector) apistorage.SelectionPredicate {
+	return apistorage.SelectionPredicate{
+		Label:    label,
+		Field:    field,
+		GetAttrs: GetAttrs,
+	}
+}
+
+type rsStatusStrategy struct {
+	rsStrategy
+}
+
+var StatusStrategy = rsStatusStrategy{Strategy}
+
+func (rsStatusStrategy) PrepareForUpdate(ctx genericapirequest.Context, obj, old runtime.Object) {
+	newRS := obj.(*extensions.ReplicaSet)
+	oldRS := old.(*extensions.ReplicaSet)
+	// update is not allowed to set spec
+	newRS.Spec = oldRS.Spec
+}
+
+func (rsStatusStrategy) ValidateUpdate(ctx genericapirequest.Context, obj, old runtime.Object) field.ErrorList {
+	return validation.ValidateReplicaSetStatusUpdate(obj.(*extensions.ReplicaSet), old.(*extensions.ReplicaSet))
+}

vendor/k8s.io/kubernetes/pkg/registry/extensions/replicaset/strategy_test.go

@@ -0,0 +1,284 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package replicaset
+
+import (
+	"reflect"
+	"testing"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/util/validation/field"
+	genericapirequest "k8s.io/apiserver/pkg/endpoints/request"
+	"k8s.io/apiserver/pkg/registry/rest"
+	api "k8s.io/kubernetes/pkg/apis/core"
+	"k8s.io/kubernetes/pkg/apis/extensions"
+)
+
+const (
+	fakeImageName  = "fake-name"
+	fakeImage      = "fakeimage"
+	replicasetName = "test-replicaset"
+	namespace      = "test-namespace"
+)
+
+func TestReplicaSetStrategy(t *testing.T) {
+	ctx := genericapirequest.NewDefaultContext()
+	if !Strategy.NamespaceScoped() {
+		t.Errorf("ReplicaSet must be namespace scoped")
+	}
+	if Strategy.AllowCreateOnUpdate() {
+		t.Errorf("ReplicaSet should not allow create on update")
+	}
+
+	validSelector := map[string]string{"a": "b"}
+	validPodTemplate := api.PodTemplate{
+		Template: api.PodTemplateSpec{
+			ObjectMeta: metav1.ObjectMeta{
+				Labels: validSelector,
+			},
+			Spec: api.PodSpec{
+				RestartPolicy: api.RestartPolicyAlways,
+				DNSPolicy:     api.DNSClusterFirst,
+				Containers:    []api.Container{{Name: "abc", Image: "image", ImagePullPolicy: "IfNotPresent", TerminationMessagePolicy: api.TerminationMessageReadFile}},
+			},
+		},
+	}
+	rs := &extensions.ReplicaSet{
+		ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
+		Spec: extensions.ReplicaSetSpec{
+			Selector: &metav1.LabelSelector{MatchLabels: validSelector},
+			Template: validPodTemplate.Template,
+		},
+		Status: extensions.ReplicaSetStatus{
+			Replicas:           1,
+			ObservedGeneration: int64(10),
+		},
+	}
+
+	Strategy.PrepareForCreate(ctx, rs)
+	if rs.Status.Replicas != 0 {
+		t.Error("ReplicaSet should not allow setting status.replicas on create")
+	}
+	if rs.Status.ObservedGeneration != int64(0) {
+		t.Error("ReplicaSet should not allow setting status.observedGeneration on create")
+	}
+	errs := Strategy.Validate(ctx, rs)
+	if len(errs) != 0 {
+		t.Errorf("Unexpected error validating %v", errs)
+	}
+
+	invalidRc := &extensions.ReplicaSet{
+		ObjectMeta: metav1.ObjectMeta{Name: "bar", ResourceVersion: "4"},
+	}
+	Strategy.PrepareForUpdate(ctx, invalidRc, rs)
+	errs = Strategy.ValidateUpdate(ctx, invalidRc, rs)
+	if len(errs) == 0 {
+		t.Errorf("Expected a validation error")
+	}
+	if invalidRc.ResourceVersion != "4" {
+		t.Errorf("Incoming resource version on update should not be mutated")
+	}
+}
+
+func TestReplicaSetStatusStrategy(t *testing.T) {
+	ctx := genericapirequest.NewDefaultContext()
+	if !StatusStrategy.NamespaceScoped() {
+		t.Errorf("ReplicaSet must be namespace scoped")
+	}
+	if StatusStrategy.AllowCreateOnUpdate() {
+		t.Errorf("ReplicaSet should not allow create on update")
+	}
+	validSelector := map[string]string{"a": "b"}
+	validPodTemplate := api.PodTemplate{
+		Template: api.PodTemplateSpec{
+			ObjectMeta: metav1.ObjectMeta{
+				Labels: validSelector,
+			},
+			Spec: api.PodSpec{
+				RestartPolicy: api.RestartPolicyAlways,
+				DNSPolicy:     api.DNSClusterFirst,
+				Containers:    []api.Container{{Name: "abc", Image: "image", ImagePullPolicy: "IfNotPresent"}},
+			},
+		},
+	}
+	oldRS := &extensions.ReplicaSet{
+		ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault, ResourceVersion: "10"},
+		Spec: extensions.ReplicaSetSpec{
+			Replicas: 3,
+			Selector: &metav1.LabelSelector{MatchLabels: validSelector},
+			Template: validPodTemplate.Template,
+		},
+		Status: extensions.ReplicaSetStatus{
+			Replicas:           1,
+			ObservedGeneration: int64(10),
+		},
+	}
+	newRS := &extensions.ReplicaSet{
+		ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault, ResourceVersion: "9"},
+		Spec: extensions.ReplicaSetSpec{
+			Replicas: 1,
+			Selector: &metav1.LabelSelector{MatchLabels: validSelector},
+			Template: validPodTemplate.Template,
+		},
+		Status: extensions.ReplicaSetStatus{
+			Replicas:           3,
+			ObservedGeneration: int64(11),
+		},
+	}
+	StatusStrategy.PrepareForUpdate(ctx, newRS, oldRS)
+	if newRS.Status.Replicas != 3 {
+		t.Errorf("ReplicaSet status updates should allow change of replicas: %v", newRS.Status.Replicas)
+	}
+	if newRS.Spec.Replicas != 3 {
+		t.Errorf("PrepareForUpdate should have preferred spec")
+	}
+	errs := StatusStrategy.ValidateUpdate(ctx, newRS, oldRS)
+	if len(errs) != 0 {
+		t.Errorf("Unexpected error %v", errs)
+	}
+}
+
+func TestSelectorImmutability(t *testing.T) {
+	tests := []struct {
+		requestInfo       genericapirequest.RequestInfo
+		oldSelectorLabels map[string]string
+		newSelectorLabels map[string]string
+		expectedErrorList field.ErrorList
+	}{
+		{
+			genericapirequest.RequestInfo{
+				APIGroup:   "apps",
+				APIVersion: "v1beta2",
+				Resource:   "replicasets",
+			},
+			map[string]string{"a": "b"},
+			map[string]string{"c": "d"},
+			field.ErrorList{
+				&field.Error{
+					Type:  field.ErrorTypeInvalid,
+					Field: field.NewPath("spec").Child("selector").String(),
+					BadValue: &metav1.LabelSelector{
+						MatchLabels:      map[string]string{"c": "d"},
+						MatchExpressions: []metav1.LabelSelectorRequirement{},
+					},
+					Detail: "field is immutable",
+				},
+			},
+		},
+		{
+			genericapirequest.RequestInfo{
+				APIGroup:   "extensions",
+				APIVersion: "v1beta1",
+				Resource:   "replicasets",
+			},
+			map[string]string{"a": "b"},
+			map[string]string{"c": "d"},
+			field.ErrorList{},
+		},
+	}
+
+	for _, test := range tests {
+		oldReplicaSet := newReplicaSetWithSelectorLabels(test.oldSelectorLabels)
+		newReplicaSet := newReplicaSetWithSelectorLabels(test.newSelectorLabels)
+		context := genericapirequest.NewContext()
+		context = genericapirequest.WithRequestInfo(context, &test.requestInfo)
+		errorList := rsStrategy{}.ValidateUpdate(context, newReplicaSet, oldReplicaSet)
+		if !reflect.DeepEqual(test.expectedErrorList, errorList) {
+			t.Errorf("Unexpected error list, expected: %v, actual: %v", test.expectedErrorList, errorList)
+		}
+	}
+}
+
+func newReplicaSetWithSelectorLabels(selectorLabels map[string]string) *extensions.ReplicaSet {
+	return &extensions.ReplicaSet{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:            replicasetName,
+			Namespace:       namespace,
+			ResourceVersion: "1",
+		},
+		Spec: extensions.ReplicaSetSpec{
+			Selector: &metav1.LabelSelector{
+				MatchLabels:      selectorLabels,
+				MatchExpressions: []metav1.LabelSelectorRequirement{},
+			},
+			Template: api.PodTemplateSpec{
+				ObjectMeta: metav1.ObjectMeta{
+					Labels: selectorLabels,
+				},
+				Spec: api.PodSpec{
+					RestartPolicy: api.RestartPolicyAlways,
+					DNSPolicy:     api.DNSClusterFirst,
+					Containers:    []api.Container{{Name: fakeImageName, Image: fakeImage, ImagePullPolicy: "IfNotPresent", TerminationMessagePolicy: api.TerminationMessageReadFile}},
+				},
+			},
+		},
+	}
+}
+
+func TestReplicasetDefaultGarbageCollectionPolicy(t *testing.T) {
+	// Make sure we correctly implement the interface.
+	// Otherwise a typo could silently change the default.
+	var gcds rest.GarbageCollectionDeleteStrategy = Strategy
+	tests := []struct {
+		requestInfo      genericapirequest.RequestInfo
+		expectedGCPolicy rest.GarbageCollectionPolicy
+		isNilRequestInfo bool
+	}{
+		{
+			genericapirequest.RequestInfo{
+				APIGroup:   "extensions",
+				APIVersion: "v1beta1",
+				Resource:   "replicasets",
+			},
+			rest.OrphanDependents,
+			false,
+		},
+		{
+			genericapirequest.RequestInfo{
+				APIGroup:   "apps",
+				APIVersion: "v1beta2",
+				Resource:   "replicasets",
+			},
+			rest.OrphanDependents,
+			false,
+		},
+		{
+			genericapirequest.RequestInfo{
+				APIGroup:   "apps",
+				APIVersion: "v1",
+				Resource:   "replicasets",
+			},
+			rest.DeleteDependents,
+			false,
+		},
+		{
+			expectedGCPolicy: rest.OrphanDependents,
+			isNilRequestInfo: true,
+		},
+	}
+
+	for _, test := range tests {
+		context := genericapirequest.NewContext()
+		if !test.isNilRequestInfo {
+			context = genericapirequest.WithRequestInfo(context, &test.requestInfo)
+		}
+		if got, want := gcds.DefaultGarbageCollectionPolicy(context), test.expectedGCPolicy; got != want {
+			t.Errorf("%s/%s: DefaultGarbageCollectionPolicy() = %#v, want %#v", test.requestInfo.APIGroup,
+				test.requestInfo.APIVersion, got, want)
+		}
+	}
+}