Qiming
abcb57e1fd
* Restore gate jobs Most gate jobs have been disabled recently so we are risking introduce many defects when migrating to Hugo. This PR fixes the gate job to get it running again. * add comment for fix * comment out, delete later * comment out completely * include package
684 lines
25 KiB
Go
684 lines
25 KiB
Go
/*
|
|
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 examples_test
|
|
|
|
import (
|
|
"bufio"
|
|
"bytes"
|
|
"fmt"
|
|
"io"
|
|
"io/ioutil"
|
|
"os"
|
|
"path/filepath"
|
|
"regexp"
|
|
"strings"
|
|
"testing"
|
|
|
|
"k8s.io/apimachinery/pkg/runtime"
|
|
"k8s.io/apimachinery/pkg/types"
|
|
"k8s.io/apimachinery/pkg/util/validation/field"
|
|
"k8s.io/apimachinery/pkg/util/yaml"
|
|
utilfeature "k8s.io/apiserver/pkg/util/feature"
|
|
"k8s.io/kubernetes/pkg/api/testapi"
|
|
"k8s.io/kubernetes/pkg/apis/admissionregistration"
|
|
ar_validation "k8s.io/kubernetes/pkg/apis/admissionregistration/validation"
|
|
"k8s.io/kubernetes/pkg/apis/apps"
|
|
apps_validation "k8s.io/kubernetes/pkg/apis/apps/validation"
|
|
"k8s.io/kubernetes/pkg/apis/autoscaling"
|
|
autoscaling_validation "k8s.io/kubernetes/pkg/apis/autoscaling/validation"
|
|
"k8s.io/kubernetes/pkg/apis/batch"
|
|
batch_validation "k8s.io/kubernetes/pkg/apis/batch/validation"
|
|
api "k8s.io/kubernetes/pkg/apis/core"
|
|
"k8s.io/kubernetes/pkg/apis/core/validation"
|
|
"k8s.io/kubernetes/pkg/apis/extensions"
|
|
ext_validation "k8s.io/kubernetes/pkg/apis/extensions/validation"
|
|
"k8s.io/kubernetes/pkg/apis/policy"
|
|
policy_validation "k8s.io/kubernetes/pkg/apis/policy/validation"
|
|
"k8s.io/kubernetes/pkg/apis/rbac"
|
|
rbac_validation "k8s.io/kubernetes/pkg/apis/rbac/validation"
|
|
"k8s.io/kubernetes/pkg/apis/settings"
|
|
settings_validation "k8s.io/kubernetes/pkg/apis/settings/validation"
|
|
"k8s.io/kubernetes/pkg/apis/storage"
|
|
storage_validation "k8s.io/kubernetes/pkg/apis/storage/validation"
|
|
"k8s.io/kubernetes/pkg/capabilities"
|
|
"k8s.io/kubernetes/pkg/registry/batch/job"
|
|
schedulerapilatest "k8s.io/kubernetes/pkg/scheduler/api/latest"
|
|
)
|
|
|
|
func validateObject(obj runtime.Object) (errors field.ErrorList) {
|
|
// Enable CustomPodDNS for testing
|
|
utilfeature.DefaultFeatureGate.Set("CustomPodDNS=true")
|
|
switch t := obj.(type) {
|
|
case *admissionregistration.InitializerConfiguration:
|
|
// cluster scope resource
|
|
errors = ar_validation.ValidateInitializerConfiguration(t)
|
|
case *api.ConfigMap:
|
|
if t.Namespace == "" {
|
|
t.Namespace = api.NamespaceDefault
|
|
}
|
|
errors = validation.ValidateConfigMap(t)
|
|
case *api.Endpoints:
|
|
if t.Namespace == "" {
|
|
t.Namespace = api.NamespaceDefault
|
|
}
|
|
errors = validation.ValidateEndpoints(t)
|
|
case *api.LimitRange:
|
|
if t.Namespace == "" {
|
|
t.Namespace = api.NamespaceDefault
|
|
}
|
|
errors = validation.ValidateLimitRange(t)
|
|
case *api.Namespace:
|
|
errors = validation.ValidateNamespace(t)
|
|
case *api.PersistentVolume:
|
|
errors = validation.ValidatePersistentVolume(t)
|
|
case *api.PersistentVolumeClaim:
|
|
if t.Namespace == "" {
|
|
t.Namespace = api.NamespaceDefault
|
|
}
|
|
errors = validation.ValidatePersistentVolumeClaim(t)
|
|
case *api.Pod:
|
|
if t.Namespace == "" {
|
|
t.Namespace = api.NamespaceDefault
|
|
}
|
|
errors = validation.ValidatePod(t)
|
|
case *api.PodList:
|
|
for i := range t.Items {
|
|
errors = append(errors, validateObject(&t.Items[i])...)
|
|
}
|
|
case *api.PodTemplate:
|
|
if t.Namespace == "" {
|
|
t.Namespace = api.NamespaceDefault
|
|
}
|
|
errors = validation.ValidatePodTemplate(t)
|
|
case *api.ReplicationController:
|
|
if t.Namespace == "" {
|
|
t.Namespace = api.NamespaceDefault
|
|
}
|
|
errors = validation.ValidateReplicationController(t)
|
|
case *api.ReplicationControllerList:
|
|
for i := range t.Items {
|
|
errors = append(errors, validateObject(&t.Items[i])...)
|
|
}
|
|
case *api.ResourceQuota:
|
|
if t.Namespace == "" {
|
|
t.Namespace = api.NamespaceDefault
|
|
}
|
|
errors = validation.ValidateResourceQuota(t)
|
|
case *api.Secret:
|
|
if t.Namespace == "" {
|
|
t.Namespace = api.NamespaceDefault
|
|
}
|
|
errors = validation.ValidateSecret(t)
|
|
case *api.Service:
|
|
if t.Namespace == "" {
|
|
t.Namespace = api.NamespaceDefault
|
|
}
|
|
errors = validation.ValidateService(t)
|
|
case *api.ServiceAccount:
|
|
if t.Namespace == "" {
|
|
t.Namespace = api.NamespaceDefault
|
|
}
|
|
errors = validation.ValidateServiceAccount(t)
|
|
case *api.ServiceList:
|
|
for i := range t.Items {
|
|
errors = append(errors, validateObject(&t.Items[i])...)
|
|
}
|
|
case *apps.StatefulSet:
|
|
if t.Namespace == "" {
|
|
t.Namespace = api.NamespaceDefault
|
|
}
|
|
errors = apps_validation.ValidateStatefulSet(t)
|
|
case *autoscaling.HorizontalPodAutoscaler:
|
|
if t.Namespace == "" {
|
|
t.Namespace = api.NamespaceDefault
|
|
}
|
|
errors = autoscaling_validation.ValidateHorizontalPodAutoscaler(t)
|
|
case *batch.Job:
|
|
if t.Namespace == "" {
|
|
t.Namespace = api.NamespaceDefault
|
|
}
|
|
// Job needs generateSelector called before validation, and job.Validate does this.
|
|
// See: https://github.com/kubernetes/kubernetes/issues/20951#issuecomment-187787040
|
|
t.ObjectMeta.UID = types.UID("fakeuid")
|
|
if strings.Index(t.ObjectMeta.Name, "$") > -1 {
|
|
t.ObjectMeta.Name = "skip-for-good"
|
|
}
|
|
errors = job.Strategy.Validate(nil, t)
|
|
case *extensions.DaemonSet:
|
|
if t.Namespace == "" {
|
|
t.Namespace = api.NamespaceDefault
|
|
}
|
|
errors = ext_validation.ValidateDaemonSet(t)
|
|
case *extensions.Deployment:
|
|
if t.Namespace == "" {
|
|
t.Namespace = api.NamespaceDefault
|
|
}
|
|
errors = ext_validation.ValidateDeployment(t)
|
|
case *extensions.Ingress:
|
|
if t.Namespace == "" {
|
|
t.Namespace = api.NamespaceDefault
|
|
}
|
|
errors = ext_validation.ValidateIngress(t)
|
|
case *extensions.PodSecurityPolicy:
|
|
errors = ext_validation.ValidatePodSecurityPolicy(t)
|
|
case *extensions.ReplicaSet:
|
|
if t.Namespace == "" {
|
|
t.Namespace = api.NamespaceDefault
|
|
}
|
|
errors = ext_validation.ValidateReplicaSet(t)
|
|
case *batch.CronJob:
|
|
if t.Namespace == "" {
|
|
t.Namespace = api.NamespaceDefault
|
|
}
|
|
errors = batch_validation.ValidateCronJob(t)
|
|
case *policy.PodDisruptionBudget:
|
|
if t.Namespace == "" {
|
|
t.Namespace = api.NamespaceDefault
|
|
}
|
|
errors = policy_validation.ValidatePodDisruptionBudget(t)
|
|
case *rbac.ClusterRoleBinding:
|
|
// clusterolebinding does not accept namespace
|
|
errors = rbac_validation.ValidateClusterRoleBinding(t)
|
|
case *settings.PodPreset:
|
|
if t.Namespace == "" {
|
|
t.Namespace = api.NamespaceDefault
|
|
}
|
|
errors = settings_validation.ValidatePodPreset(t)
|
|
case *storage.StorageClass:
|
|
// storageclass does not accept namespace
|
|
errors = storage_validation.ValidateStorageClass(t)
|
|
default:
|
|
errors = field.ErrorList{}
|
|
errors = append(errors, field.InternalError(field.NewPath(""), fmt.Errorf("no validation defined for %#v", obj)))
|
|
}
|
|
return errors
|
|
}
|
|
|
|
// Walks inDir for any json/yaml files. Converts yaml to json, and calls fn for
|
|
// each file found with the contents in data.
|
|
func walkConfigFiles(inDir string, fn func(name, path string, data [][]byte)) error {
|
|
return filepath.Walk(inDir, func(path string, info os.FileInfo, err error) error {
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if info.IsDir() && path != inDir {
|
|
return filepath.SkipDir
|
|
}
|
|
|
|
file := filepath.Base(path)
|
|
if ext := filepath.Ext(file); ext == ".json" || ext == ".yaml" {
|
|
//glog.Infof("Testing %s", path)
|
|
data, err := ioutil.ReadFile(path)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
// workaround for Jekyllr limit
|
|
if bytes.HasPrefix(data, []byte("---\n")) {
|
|
return fmt.Errorf("YAML file cannot start with \"---\", please remove the first line")
|
|
}
|
|
name := strings.TrimSuffix(file, ext)
|
|
|
|
var docs [][]byte
|
|
if ext == ".yaml" {
|
|
// YAML can contain multiple documents.
|
|
splitter := yaml.NewYAMLReader(bufio.NewReader(bytes.NewBuffer(data)))
|
|
for {
|
|
doc, err := splitter.Read()
|
|
if err == io.EOF {
|
|
break
|
|
}
|
|
if err != nil {
|
|
return fmt.Errorf("%s: %v", path, err)
|
|
}
|
|
out, err := yaml.ToJSON(doc)
|
|
if err != nil {
|
|
return fmt.Errorf("%s: %v", path, err)
|
|
}
|
|
// deal with "empty" document (e.g. pure comments)
|
|
if string(out) != "null" {
|
|
docs = append(docs, out)
|
|
}
|
|
}
|
|
} else {
|
|
docs = append(docs, data)
|
|
}
|
|
|
|
fn(name, path, docs)
|
|
}
|
|
return nil
|
|
})
|
|
}
|
|
|
|
func TestExampleObjectSchemas(t *testing.T) {
|
|
// Please help maintain the alphabeta order in the map
|
|
cases := map[string]map[string][]runtime.Object{
|
|
"docs/admin/high-availability": {
|
|
"etcd": {&api.Pod{}},
|
|
"kube-apiserver": {&api.Pod{}},
|
|
"kube-controller-manager": {&api.Pod{}},
|
|
"kube-scheduler": {&api.Pod{}},
|
|
"podmaster": {&api.Pod{}},
|
|
},
|
|
"docs/admin/limitrange": {
|
|
"invalid-pod": {&api.Pod{}},
|
|
"limits": {&api.LimitRange{}},
|
|
"namespace": {&api.Namespace{}},
|
|
"valid-pod": {&api.Pod{}},
|
|
},
|
|
"docs/admin/multiple-schedulers": {
|
|
"my-scheduler": {&extensions.Deployment{}},
|
|
"pod1": {&api.Pod{}},
|
|
"pod2": {&api.Pod{}},
|
|
"pod3": {&api.Pod{}},
|
|
},
|
|
"docs/admin/resourcequota": {
|
|
"best-effort": {&api.ResourceQuota{}},
|
|
"compute-resources": {&api.ResourceQuota{}},
|
|
"limits": {&api.LimitRange{}},
|
|
"namespace": {&api.Namespace{}},
|
|
"not-best-effort": {&api.ResourceQuota{}},
|
|
"object-counts": {&api.ResourceQuota{}},
|
|
},
|
|
"docs/concepts/cluster-administration": {
|
|
"counter-pod": {&api.Pod{}},
|
|
"fluentd-sidecar-config": {&api.ConfigMap{}},
|
|
"nginx-app": {&api.Service{}, &extensions.Deployment{}},
|
|
"nginx-deployment": {&extensions.Deployment{}},
|
|
"two-files-counter-pod": {&api.Pod{}},
|
|
"two-files-counter-pod-agent-sidecar": {&api.Pod{}},
|
|
"two-files-counter-pod-streaming-sidecar": {&api.Pod{}},
|
|
},
|
|
"docs/concepts/cluster-administration/nginx": {
|
|
"nginx-deployment": {&extensions.Deployment{}},
|
|
"nginx-svc": {&api.Service{}},
|
|
},
|
|
"docs/concepts/configuration": {
|
|
"commands": {&api.Pod{}},
|
|
"pod": {&api.Pod{}},
|
|
"pod-with-node-affinity": {&api.Pod{}},
|
|
"pod-with-pod-affinity": {&api.Pod{}},
|
|
},
|
|
"docs/concepts/overview/working-with-objects": {
|
|
"nginx-deployment": {&extensions.Deployment{}},
|
|
},
|
|
"docs/concepts/policy": {
|
|
"privileged-psp": {&extensions.PodSecurityPolicy{}},
|
|
"restricted-psp": {&extensions.PodSecurityPolicy{}},
|
|
"example-psp": {&extensions.PodSecurityPolicy{}},
|
|
},
|
|
"docs/concepts/services-networking": {
|
|
"curlpod": {&extensions.Deployment{}},
|
|
"custom-dns": {&api.Pod{}},
|
|
"hostaliases-pod": {&api.Pod{}},
|
|
"ingress": {&extensions.Ingress{}},
|
|
"nginx-secure-app": {&api.Service{}, &extensions.Deployment{}},
|
|
"nginx-svc": {&api.Service{}},
|
|
"run-my-nginx": {&extensions.Deployment{}},
|
|
},
|
|
"docs/concepts/workloads/controllers": {
|
|
"cronjob": {&batch.CronJob{}},
|
|
"daemonset": {&extensions.DaemonSet{}},
|
|
"frontend": {&extensions.ReplicaSet{}},
|
|
"hpa-rs": {&autoscaling.HorizontalPodAutoscaler{}},
|
|
"job": {&batch.Job{}},
|
|
"my-repset": {&extensions.ReplicaSet{}},
|
|
"nginx-deployment": {&extensions.Deployment{}},
|
|
"replication": {&api.ReplicationController{}},
|
|
},
|
|
"docs/tasks/access-application-cluster": {
|
|
"frontend": {&api.Service{}, &extensions.Deployment{}},
|
|
"hello-service": {&api.Service{}},
|
|
"hello": {&extensions.Deployment{}},
|
|
"redis-master": {&api.Pod{}},
|
|
"two-container-pod": {&api.Pod{}},
|
|
},
|
|
"docs/tasks/administer-cluster": {
|
|
"busybox": {&api.Pod{}},
|
|
"cloud-controller-manager-daemonset-example": {&api.ServiceAccount{}, &rbac.ClusterRoleBinding{}, &extensions.DaemonSet{}},
|
|
"cpu-constraints": {&api.LimitRange{}},
|
|
"cpu-constraints-pod": {&api.Pod{}},
|
|
"cpu-constraints-pod-2": {&api.Pod{}},
|
|
"cpu-constraints-pod-3": {&api.Pod{}},
|
|
"cpu-constraints-pod-4": {&api.Pod{}},
|
|
"cpu-defaults": {&api.LimitRange{}},
|
|
"cpu-defaults-pod": {&api.Pod{}},
|
|
"cpu-defaults-pod-2": {&api.Pod{}},
|
|
"cpu-defaults-pod-3": {&api.Pod{}},
|
|
"dns-horizontal-autoscaler": {&extensions.Deployment{}},
|
|
"memory-constraints": {&api.LimitRange{}},
|
|
"memory-constraints-pod": {&api.Pod{}},
|
|
"memory-constraints-pod-2": {&api.Pod{}},
|
|
"memory-constraints-pod-3": {&api.Pod{}},
|
|
"memory-constraints-pod-4": {&api.Pod{}},
|
|
"memory-defaults": {&api.LimitRange{}},
|
|
"memory-defaults-pod": {&api.Pod{}},
|
|
"memory-defaults-pod-2": {&api.Pod{}},
|
|
"memory-defaults-pod-3": {&api.Pod{}},
|
|
"my-scheduler": {&extensions.Deployment{}},
|
|
"namespace-dev": {&api.Namespace{}},
|
|
"namespace-prod": {&api.Namespace{}},
|
|
"persistent-volume-label-initializer-config": {&admissionregistration.InitializerConfiguration{}},
|
|
"pod1": {&api.Pod{}},
|
|
"pod2": {&api.Pod{}},
|
|
"pod3": {&api.Pod{}},
|
|
"quota-mem-cpu": {&api.ResourceQuota{}},
|
|
"quota-mem-cpu-pod": {&api.Pod{}},
|
|
"quota-mem-cpu-pod-2": {&api.Pod{}},
|
|
"quota-objects": {&api.ResourceQuota{}},
|
|
"quota-objects-pvc": {&api.PersistentVolumeClaim{}},
|
|
"quota-objects-pvc-2": {&api.PersistentVolumeClaim{}},
|
|
"quota-pod": {&api.ResourceQuota{}},
|
|
"quota-pod-deployment": {&extensions.Deployment{}},
|
|
"quota-pvc-2": {&api.PersistentVolumeClaim{}},
|
|
},
|
|
"docs/tasks/configure-pod-container": {
|
|
"cpu-request-limit": {&api.Pod{}},
|
|
"cpu-request-limit-2": {&api.Pod{}},
|
|
"exec-liveness": {&api.Pod{}},
|
|
"extended-resource-pod": {&api.Pod{}},
|
|
"extended-resource-pod-2": {&api.Pod{}},
|
|
"http-liveness": {&api.Pod{}},
|
|
"init-containers": {&api.Pod{}},
|
|
"lifecycle-events": {&api.Pod{}},
|
|
"mem-limit-range": {&api.LimitRange{}},
|
|
"memory-request-limit": {&api.Pod{}},
|
|
"memory-request-limit-2": {&api.Pod{}},
|
|
"memory-request-limit-3": {&api.Pod{}},
|
|
"oir-pod": {&api.Pod{}},
|
|
"oir-pod-2": {&api.Pod{}},
|
|
"pod": {&api.Pod{}},
|
|
"pod-redis": {&api.Pod{}},
|
|
"private-reg-pod": {&api.Pod{}},
|
|
"projected-volume": {&api.Pod{}},
|
|
"qos-pod": {&api.Pod{}},
|
|
"qos-pod-2": {&api.Pod{}},
|
|
"qos-pod-3": {&api.Pod{}},
|
|
"qos-pod-4": {&api.Pod{}},
|
|
"rq-compute-resources": {&api.ResourceQuota{}},
|
|
"security-context": {&api.Pod{}},
|
|
"security-context-2": {&api.Pod{}},
|
|
"security-context-3": {&api.Pod{}},
|
|
"security-context-4": {&api.Pod{}},
|
|
"share-process-namespace": {&api.Pod{}},
|
|
"task-pv-claim": {&api.PersistentVolumeClaim{}},
|
|
"task-pv-pod": {&api.Pod{}},
|
|
"task-pv-volume": {&api.PersistentVolume{}},
|
|
"tcp-liveness-readiness": {&api.Pod{}},
|
|
},
|
|
"docs/tasks/debug-application-cluster": {
|
|
"counter-pod": {&api.Pod{}},
|
|
"event-exporter-deploy": {&api.ServiceAccount{}, &rbac.ClusterRoleBinding{}, &extensions.Deployment{}},
|
|
"fluentd-gcp-configmap": {&api.ConfigMap{}},
|
|
"fluentd-gcp-ds": {&extensions.DaemonSet{}},
|
|
"nginx-dep": {&extensions.Deployment{}},
|
|
"node-problem-detector": {&extensions.DaemonSet{}},
|
|
"node-problem-detector-configmap": {&extensions.DaemonSet{}},
|
|
"shell-demo": {&api.Pod{}},
|
|
"termination": {&api.Pod{}},
|
|
},
|
|
// TODO: decide whether federation examples should be added
|
|
"docs/tasks/inject-data-application": {
|
|
"commands": {&api.Pod{}},
|
|
"dapi-envars-container": {&api.Pod{}},
|
|
"dapi-envars-pod": {&api.Pod{}},
|
|
"dapi-volume": {&api.Pod{}},
|
|
"dapi-volume-resources": {&api.Pod{}},
|
|
"envars": {&api.Pod{}},
|
|
"podpreset-allow-db": {&settings.PodPreset{}},
|
|
"podpreset-allow-db-merged": {&api.Pod{}},
|
|
"podpreset-configmap": {&api.ConfigMap{}},
|
|
"podpreset-conflict-pod": {&api.Pod{}},
|
|
"podpreset-conflict-preset": {&settings.PodPreset{}},
|
|
"podpreset-merged": {&api.Pod{}},
|
|
"podpreset-multi-merged": {&api.Pod{}},
|
|
"podpreset-pod": {&api.Pod{}},
|
|
"podpreset-preset": {&settings.PodPreset{}},
|
|
"podpreset-proxy": {&settings.PodPreset{}},
|
|
"podpreset-replicaset-merged": {&api.Pod{}},
|
|
"podpreset-replicaset": {&extensions.ReplicaSet{}},
|
|
"secret": {&api.Secret{}},
|
|
"secret-envars-pod": {&api.Pod{}},
|
|
"secret-pod": {&api.Pod{}},
|
|
},
|
|
"docs/tasks/job": {
|
|
"cronjob": {&batch.CronJob{}},
|
|
"job": {&batch.Job{}},
|
|
},
|
|
"docs/tasks/job/coarse-parallel-processing-work-queue": {
|
|
"job": {&batch.Job{}},
|
|
},
|
|
"docs/tasks/job/fine-parallel-processing-work-queue": {
|
|
"job": {&batch.Job{}},
|
|
"redis-pod": {&api.Pod{}},
|
|
"redis-service": {&api.Service{}},
|
|
},
|
|
"docs/tasks/run-application": {
|
|
"deployment": {&extensions.Deployment{}},
|
|
"deployment-patch-demo": {&extensions.Deployment{}},
|
|
"deployment-scale": {&extensions.Deployment{}},
|
|
"deployment-update": {&extensions.Deployment{}},
|
|
"hpa-php-apache": {&autoscaling.HorizontalPodAutoscaler{}},
|
|
"mysql-configmap": {&api.ConfigMap{}},
|
|
"mysql-deployment": {&api.Service{}, &api.PersistentVolumeClaim{}, &extensions.Deployment{}},
|
|
"mysql-services": {&api.Service{}, &api.Service{}},
|
|
"mysql-statefulset": {&apps.StatefulSet{}},
|
|
},
|
|
"docs/tutorials/clusters": {
|
|
"hello-apparmor-pod": {&api.Pod{}},
|
|
"my-scheduler": {&extensions.Deployment{}},
|
|
},
|
|
"docs/tutorials/configuration/configmap/redis": {
|
|
"redis-pod": {&api.Pod{}},
|
|
},
|
|
"docs/concepts/overview/object-management-kubectl": {
|
|
"simple_deployment": {&extensions.Deployment{}},
|
|
"update_deployment": {&extensions.Deployment{}},
|
|
},
|
|
"docs/tutorials/stateful-application": {
|
|
"web": {&api.Service{}, &apps.StatefulSet{}},
|
|
"webp": {&api.Service{}, &apps.StatefulSet{}},
|
|
"zookeeper": {&api.Service{}, &api.Service{}, &policy.PodDisruptionBudget{}, &apps.StatefulSet{}},
|
|
},
|
|
"docs/tutorials/stateful-application/cassandra": {
|
|
"cassandra-service": {&api.Service{}},
|
|
"cassandra-statefulset": {&apps.StatefulSet{}, &storage.StorageClass{}},
|
|
},
|
|
"docs/tutorials/stateful-application/mysql-wordpress-persistent-volume": {
|
|
"local-volumes": {&api.PersistentVolume{}, &api.PersistentVolume{}},
|
|
"mysql-deployment": {&api.Service{}, &api.PersistentVolumeClaim{}, &extensions.Deployment{}},
|
|
"wordpress-deployment": {&api.Service{}, &api.PersistentVolumeClaim{}, &extensions.Deployment{}},
|
|
},
|
|
"docs/tutorials/stateless-application": {
|
|
"deployment": {&extensions.Deployment{}},
|
|
"deployment-scale": {&extensions.Deployment{}},
|
|
"deployment-update": {&extensions.Deployment{}},
|
|
},
|
|
"docs/tutorials/stateless-application/guestbook": {
|
|
"frontend-deployment": {&extensions.Deployment{}},
|
|
"frontend-service": {&api.Service{}},
|
|
"redis-master-deployment": {&extensions.Deployment{}},
|
|
"redis-master-service": {&api.Service{}},
|
|
"redis-slave-deployment": {&extensions.Deployment{}},
|
|
"redis-slave-service": {&api.Service{}},
|
|
},
|
|
"docs/user-guide/walkthrough": {
|
|
"deployment": {&extensions.Deployment{}},
|
|
"deployment-update": {&extensions.Deployment{}},
|
|
"pod-nginx": {&api.Pod{}},
|
|
"pod-nginx-with-label": {&api.Pod{}},
|
|
"pod-redis": {&api.Pod{}},
|
|
"pod-with-http-healthcheck": {&api.Pod{}},
|
|
"pod-with-tcp-socket-healthcheck": {&api.Pod{}},
|
|
"service": {&api.Service{}},
|
|
},
|
|
}
|
|
|
|
// Note a key in the following map has to be complete relative path
|
|
filesIgnore := map[string]map[string]bool{
|
|
"../content/en/docs/tasks/debug-application-cluster": {
|
|
"audit-policy": true,
|
|
},
|
|
}
|
|
capabilities.SetForTests(capabilities.Capabilities{
|
|
AllowPrivileged: true,
|
|
})
|
|
// PodShareProcessNamespace needed for example share-process-namespace.yaml
|
|
utilfeature.DefaultFeatureGate.Set("PodShareProcessNamespace=true")
|
|
|
|
rootpath := "../content/en/"
|
|
for dir, expected := range cases {
|
|
tested := 0
|
|
numExpected := 0
|
|
path := rootpath + dir
|
|
err := walkConfigFiles(path, func(name, path string, docs [][]byte) {
|
|
expectedTypes, found := expected[name]
|
|
if !found {
|
|
p := filepath.Dir(path)
|
|
if files, ok := filesIgnore[p]; ok {
|
|
if files[name] {
|
|
return
|
|
}
|
|
}
|
|
t.Errorf("%s: %s does not have a test case defined", path, name)
|
|
return
|
|
}
|
|
numExpected += len(expectedTypes)
|
|
if len(expectedTypes) != len(docs) {
|
|
t.Errorf("%s: number of expected types (%v) doesn't match number of docs in YAML (%v)", path, len(expectedTypes), len(docs))
|
|
return
|
|
}
|
|
for i, data := range docs {
|
|
expectedType := expectedTypes[i]
|
|
tested++
|
|
if expectedType == nil {
|
|
t.Logf("skipping : %s/%s\n", path, name)
|
|
return
|
|
}
|
|
if strings.Contains(name, "scheduler-policy-config") {
|
|
if err := runtime.DecodeInto(schedulerapilatest.Codec, data, expectedType); err != nil {
|
|
t.Errorf("%s did not decode correctly: %v\n%s", path, err, string(data))
|
|
return
|
|
}
|
|
// TODO: Add validate method for
|
|
// &schedulerapi.Policy, and remove this
|
|
// special case
|
|
} else {
|
|
codec, err := testapi.GetCodecForObject(expectedType)
|
|
if err != nil {
|
|
t.Errorf("Could not get codec for %s: %s", expectedType, err)
|
|
}
|
|
if err := runtime.DecodeInto(codec, data, expectedType); err != nil {
|
|
t.Errorf("%s did not decode correctly: %v\n%s", path, err, string(data))
|
|
return
|
|
}
|
|
if errors := validateObject(expectedType); len(errors) > 0 {
|
|
t.Errorf("%s did not validate correctly: %v", path, errors)
|
|
}
|
|
}
|
|
}
|
|
})
|
|
if err != nil {
|
|
t.Errorf("Expected no error, Got %v on Path %v", err, path)
|
|
}
|
|
if tested != numExpected {
|
|
t.Errorf("Directory %v: Expected %d examples, Got %d", path, len(expected), tested)
|
|
}
|
|
}
|
|
}
|
|
|
|
// This regex is tricky, but it works. For future me, here is the decode:
|
|
//
|
|
// Flags: (?ms) = multiline match, allow . to match \n
|
|
// 1) Look for a line that starts with ``` (a markdown code block)
|
|
// 2) (?: ... ) = non-capturing group
|
|
// 3) (P<name>) = capture group as "name"
|
|
// 4) Look for #1 followed by either:
|
|
// 4a) "yaml" followed by any word-characters followed by a newline (e.g. ```yamlfoo\n)
|
|
// 4b) "any word-characters followed by a newline (e.g. ```json\n)
|
|
// 5) Look for either:
|
|
// 5a) #4a followed by one or more characters (non-greedy)
|
|
// 5b) #4b followed by { followed by one or more characters (non-greedy) followed by }
|
|
// 6) Look for #5 followed by a newline followed by ``` (end of the code block)
|
|
//
|
|
// This could probably be simplified, but is already too delicate. Before any
|
|
// real changes, we should have a test case that just tests this regex.
|
|
var sampleRegexp = regexp.MustCompile("(?ms)^```(?:(?P<type>yaml)\\w*\\n(?P<content>.+?)|\\w*\\n(?P<content>\\{.+?\\}))\\n^```")
|
|
var subsetRegexp = regexp.MustCompile("(?ms)\\.{3}")
|
|
|
|
func TestReadme(t *testing.T) {
|
|
paths := []struct {
|
|
file string
|
|
expectedType []runtime.Object
|
|
}{
|
|
{"../content/en/docs/concepts/storage/volumes.md", []runtime.Object{&api.Pod{}}},
|
|
}
|
|
|
|
for _, path := range paths {
|
|
data, err := ioutil.ReadFile(path.file)
|
|
if err != nil {
|
|
t.Errorf("Unable to read file %s: %v", path, err)
|
|
continue
|
|
}
|
|
|
|
matches := sampleRegexp.FindAllStringSubmatch(string(data), -1)
|
|
if matches == nil {
|
|
continue
|
|
}
|
|
ix := 0
|
|
for _, match := range matches {
|
|
var content, subtype string
|
|
for i, name := range sampleRegexp.SubexpNames() {
|
|
if name == "type" {
|
|
subtype = match[i]
|
|
}
|
|
if name == "content" && match[i] != "" {
|
|
content = match[i]
|
|
}
|
|
}
|
|
if subtype == "yaml" && subsetRegexp.FindString(content) != "" {
|
|
t.Logf("skipping (%s): \n%s", subtype, content)
|
|
continue
|
|
}
|
|
|
|
var expectedType runtime.Object
|
|
if len(path.expectedType) == 1 {
|
|
expectedType = path.expectedType[0]
|
|
} else {
|
|
expectedType = path.expectedType[ix]
|
|
ix++
|
|
}
|
|
json, err := yaml.ToJSON([]byte(content))
|
|
if err != nil {
|
|
t.Errorf("%s could not be converted to JSON: %v\n%s", path, err, string(content))
|
|
}
|
|
if err := runtime.DecodeInto(testapi.Default.Codec(), json, expectedType); err != nil {
|
|
t.Errorf("%s did not decode correctly: %v\n%s", path, err, string(content))
|
|
continue
|
|
}
|
|
if errors := validateObject(expectedType); len(errors) > 0 {
|
|
t.Errorf("%s did not validate correctly: %v", path, errors)
|
|
}
|
|
_, err = runtime.Encode(testapi.Default.Codec(), expectedType)
|
|
if err != nil {
|
|
t.Errorf("Could not encode object: %v", err)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
}
|