func TestDeployerCustomLabelsAndAnnotations(t *testing.T) {
controller := &DeploymentController{
decodeConfig: func(deployment *kapi.ReplicationController) (*deployapi.DeploymentConfig, error) {
return deployutil.DecodeDeploymentConfig(deployment, api.Codec)
},
podClient: &podClientImpl{
createPodFunc: func(namespace string, pod *kapi.Pod) (*kapi.Pod, error) {
return pod, nil
},
},
makeContainer: func(strategy *deployapi.DeploymentStrategy) (*kapi.Container, error) {
return okContainer(), nil
},
}
testCases := []struct {
name string
strategy deployapi.DeploymentStrategy
labels map[string]string
annotations map[string]string
verifyLabels bool
}{
{name: "labels and annotations", strategy: deploytest.OkStrategy(), labels: map[string]string{"label1": "value1"}, annotations: map[string]string{"annotation1": "value1"}, verifyLabels: true},
{name: "custom strategy, no annotations", strategy: deploytest.OkCustomStrategy(), labels: map[string]string{"label2": "value2", "label3": "value3"}, verifyLabels: true},
{name: "custom strategy, no labels", strategy: deploytest.OkCustomStrategy(), annotations: map[string]string{"annotation3": "value3"}, verifyLabels: true},
{name: "no overrride", strategy: deploytest.OkStrategy(), labels: map[string]string{deployapi.DeployerPodForDeploymentLabel: "ignored"}, verifyLabels: false},
}
for _, test := range testCases {
t.Logf("evaluating test case %s", test.name)
config := deploytest.OkDeploymentConfig(1)
config.Spec.Strategy = test.strategy
config.Spec.Strategy.Labels = test.labels
config.Spec.Strategy.Annotations = test.annotations
deployment, _ := deployutil.MakeDeployment(config, kapi.Codec)
podTemplate, err := controller.makeDeployerPod(deployment)
if err != nil {
t.Fatal(err)
}
nameLabel, ok := podTemplate.Labels[deployapi.DeployerPodForDeploymentLabel]
if ok && nameLabel != deployment.Name {
t.Errorf("label %s expected %s, got %s", deployapi.DeployerPodForDeploymentLabel, deployment.Name, nameLabel)
} else if !ok {
t.Errorf("label %s not present", deployapi.DeployerPodForDeploymentLabel)
}
if test.verifyLabels {
expectMapContains(t, podTemplate.Labels, test.labels, "labels")
}
expectMapContains(t, podTemplate.Annotations, test.annotations, "annotations")
}
}
func TestDeployerCustomLabelsAndAnnotations(t *testing.T) {
testCases := []struct {
name string
strategy deployapi.DeploymentStrategy
labels map[string]string
annotations map[string]string
verifyLabels bool
}{
{name: "labels and annotations", strategy: deploytest.OkStrategy(), labels: map[string]string{"label1": "value1"}, annotations: map[string]string{"annotation1": "value1"}, verifyLabels: true},
{name: "custom strategy, no annotations", strategy: deploytest.OkCustomStrategy(), labels: map[string]string{"label2": "value2", "label3": "value3"}, verifyLabels: true},
{name: "custom strategy, no labels", strategy: deploytest.OkCustomStrategy(), annotations: map[string]string{"annotation3": "value3"}, verifyLabels: true},
{name: "no overrride", strategy: deploytest.OkStrategy(), labels: map[string]string{deployapi.DeployerPodForDeploymentLabel: "ignored"}, verifyLabels: false},
}
for _, test := range testCases {
t.Logf("evaluating test case %s", test.name)
config := deploytest.OkDeploymentConfig(1)
config.Spec.Strategy = test.strategy
config.Spec.Strategy.Labels = test.labels
config.Spec.Strategy.Annotations = test.annotations
deployment, _ := deployutil.MakeDeployment(config, codec)
fake := &ktestclient.Fake{}
fake.AddReactor("create", "pods", func(action ktestclient.Action) (handled bool, ret runtime.Object, err error) {
return true, deployerPod(deployment, "", true), nil
})
controller := okDeploymentController(fake, nil, nil, true)
podTemplate, err := controller.makeDeployerPod(deployment)
if err != nil {
t.Fatal(err)
}
nameLabel, ok := podTemplate.Labels[deployapi.DeployerPodForDeploymentLabel]
if ok && nameLabel != deployment.Name {
t.Errorf("label %s expected %s, got %s", deployapi.DeployerPodForDeploymentLabel, deployment.Name, nameLabel)
} else if !ok {
t.Errorf("label %s not present", deployapi.DeployerPodForDeploymentLabel)
}
if test.verifyLabels {
expectMapContains(t, podTemplate.Labels, test.labels, "labels")
}
expectMapContains(t, podTemplate.Annotations, test.annotations, "annotations")
}
}
func TestDeploymentConfigDescriber(t *testing.T) {
config := deployapitest.OkDeploymentConfig(1)
deployment, _ := deployutil.MakeDeployment(config, kapi.Codec)
podList := &kapi.PodList{}
eventList := &kapi.EventList{}
deploymentList := &kapi.ReplicationControllerList{}
d := &DeploymentConfigDescriber{
client: &genericDeploymentDescriberClient{
getDeploymentConfigFunc: func(namespace, name string) (*deployapi.DeploymentConfig, error) {
return config, nil
},
getDeploymentFunc: func(namespace, name string) (*kapi.ReplicationController, error) {
return deployment, nil
},
listDeploymentsFunc: func(namespace string, selector labels.Selector) (*kapi.ReplicationControllerList, error) {
return deploymentList, nil
},
listPodsFunc: func(namespace string, selector labels.Selector) (*kapi.PodList, error) {
return podList, nil
},
listEventsFunc: func(deploymentConfig *deployapi.DeploymentConfig) (*kapi.EventList, error) {
return eventList, nil
},
},
}
describe := func() {
if output, err := d.Describe("test", "deployment"); err != nil {
t.Fatalf("unexpected error: %v", err)
} else {
t.Logf("describer output:\n%s\n", output)
}
}
podList.Items = []kapi.Pod{*mkPod(kapi.PodRunning, 0)}
describe()
config.Triggers = append(config.Triggers, deployapitest.OkConfigChangeTrigger())
describe()
config.Template.Strategy = deployapitest.OkCustomStrategy()
describe()
config.Triggers[0].ImageChangeParams.RepositoryName = ""
config.Triggers[0].ImageChangeParams.From = kapi.ObjectReference{Name: "imageRepo"}
describe()
config.Template.Strategy = deployapitest.OkStrategy()
config.Template.Strategy.RecreateParams = &deployapi.RecreateDeploymentStrategyParams{
Pre: &deployapi.LifecycleHook{
FailurePolicy: deployapi.LifecycleHookFailurePolicyAbort,
ExecNewPod: &deployapi.ExecNewPodHook{
ContainerName: "container",
Command: []string{"/command1", "args"},
Env: []kapi.EnvVar{
{
Name: "KEY1",
Value: "value1",
},
},
},
},
Post: &deployapi.LifecycleHook{
FailurePolicy: deployapi.LifecycleHookFailurePolicyIgnore,
ExecNewPod: &deployapi.ExecNewPodHook{
ContainerName: "container",
Command: []string{"/command2", "args"},
Env: []kapi.EnvVar{
{
Name: "KEY2",
Value: "value2",
},
},
},
},
}
describe()
}
// TestHandle_createPodOk ensures that a the deployer pod created in response
// to a new deployment is valid.
func TestHandle_createPodOk(t *testing.T) {
var (
updatedDeployment *kapi.ReplicationController
createdPod *kapi.Pod
expectedContainer = okContainer()
)
fake := &ktestclient.Fake{}
fake.AddReactor("create", "pods", func(action ktestclient.Action) (handled bool, ret runtime.Object, err error) {
pod := action.(ktestclient.CreateAction).GetObject().(*kapi.Pod)
createdPod = pod
return true, pod, nil
})
fake.AddReactor("update", "replicationcontrollers", func(action ktestclient.Action) (handled bool, ret runtime.Object, err error) {
rc := action.(ktestclient.UpdateAction).GetObject().(*kapi.ReplicationController)
updatedDeployment = rc
return true, rc, nil
})
// Verify new -> pending
config := deploytest.OkDeploymentConfig(1)
config.Spec.Strategy = deploytest.OkCustomStrategy()
deployment, _ := deployutil.MakeDeployment(config, codec)
deployment.Annotations[deployapi.DeploymentStatusAnnotation] = string(deployapi.DeploymentStatusNew)
deployment.Spec.Template.Spec.NodeSelector = map[string]string{"labelKey1": "labelValue1", "labelKey2": "labelValue2"}
controller := okDeploymentController(fake, nil, nil, true)
if err := controller.Handle(deployment); err != nil {
t.Fatalf("unexpected error: %v", err)
}
if updatedDeployment == nil {
t.Fatalf("expected an updated deployment")
}
if e, a := deployapi.DeploymentStatusPending, deployutil.DeploymentStatusFor(updatedDeployment); e != a {
t.Fatalf("expected updated deployment status %s, got %s", e, a)
}
if createdPod == nil {
t.Fatalf("expected a pod to be created")
}
if e := deployutil.DeployerPodNameFor(updatedDeployment); len(e) == 0 {
t.Fatalf("missing deployment pod annotation")
}
if e, a := createdPod.Name, deployutil.DeployerPodNameFor(updatedDeployment); e != a {
t.Fatalf("expected deployment pod annotation %s, got %s", e, a)
}
if e := deployutil.DeploymentNameFor(createdPod); len(e) == 0 {
t.Fatalf("missing deployment annotation")
}
if e, a := updatedDeployment.Name, deployutil.DeploymentNameFor(createdPod); e != a {
t.Fatalf("expected pod deployment annotation %s, got %s", e, a)
}
if e, a := deployment.Spec.Template.Spec.NodeSelector, createdPod.Spec.NodeSelector; !reflect.DeepEqual(e, a) {
t.Fatalf("expected pod NodeSelector %v, got %v", e, a)
}
if createdPod.Spec.ActiveDeadlineSeconds == nil {
t.Fatalf("expected ActiveDeadlineSeconds to be set on the deployer pod")
}
if *createdPod.Spec.ActiveDeadlineSeconds != deployapi.MaxDeploymentDurationSeconds {
t.Fatalf("expected ActiveDeadlineSeconds on the deployer pod to be set to %d; found: %d", deployapi.MaxDeploymentDurationSeconds, *createdPod.Spec.ActiveDeadlineSeconds)
}
actualContainer := createdPod.Spec.Containers[0]
if e, a := expectedContainer.Image, actualContainer.Image; e != a {
t.Fatalf("expected container image %s, got %s", expectedContainer.Image, actualContainer.Image)
}
if e, a := expectedContainer.Command[0], actualContainer.Command[0]; e != a {
t.Fatalf("expected container command %s, got %s", expectedContainer.Command[0], actualContainer.Command[0])
}
if e, a := expectedContainer.Env[0].Name, actualContainer.Env[0].Name; e != a {
t.Fatalf("expected container env name %s, got %s", expectedContainer.Env[0].Name, actualContainer.Env[0].Name)
}
if e, a := expectedContainer.Env[0].Value, actualContainer.Env[0].Value; e != a {
t.Fatalf("expected container env value %s, got %s", expectedContainer.Env[0].Value, actualContainer.Env[0].Value)
}
if e, a := expectedContainer.Resources, actualContainer.Resources; !kapi.Semantic.DeepEqual(e, a) {
t.Fatalf("expected container resources %v, got %v", expectedContainer.Resources, actualContainer.Resources)
}
}
func TestDeploymentConfigDescriber(t *testing.T) {
config := deployapitest.OkDeploymentConfig(1)
deployment, _ := deployutil.MakeDeployment(config, kapi.Codecs.LegacyCodec(deployapi.SchemeGroupVersion))
podList := &kapi.PodList{}
fake := &testclient.Fake{}
fake.PrependReactor("get", "deploymentconfigs", func(action ktestclient.Action) (handled bool, ret runtime.Object, err error) {
return true, config, nil
})
kFake := &ktestclient.Fake{}
kFake.PrependReactor("list", "horizontalpodautoscalers", func(action ktestclient.Action) (handled bool, ret runtime.Object, err error) {
return true, &extensions.HorizontalPodAutoscalerList{
Items: []extensions.HorizontalPodAutoscaler{
*deployapitest.OkHPAForDeploymentConfig(config, 1, 3),
}}, nil
})
kFake.PrependReactor("get", "replicationcontrollers", func(action ktestclient.Action) (handled bool, ret runtime.Object, err error) {
return true, deployment, nil
})
kFake.PrependReactor("list", "replicationcontrollers", func(action ktestclient.Action) (handled bool, ret runtime.Object, err error) {
return true, &kapi.ReplicationControllerList{}, nil
})
kFake.PrependReactor("list", "pods", func(action ktestclient.Action) (handled bool, ret runtime.Object, err error) {
return true, podList, nil
})
kFake.PrependReactor("list", "events", func(action ktestclient.Action) (handled bool, ret runtime.Object, err error) {
return true, &kapi.EventList{}, nil
})
d := &DeploymentConfigDescriber{
osClient: fake,
kubeClient: kFake,
}
describe := func() string {
output, err := d.Describe("test", "deployment", kubectl.DescriberSettings{})
if err != nil {
t.Fatalf("unexpected error: %v", err)
return ""
}
t.Logf("describer output:\n%s\n", output)
return output
}
podList.Items = []kapi.Pod{*mkPod(kapi.PodRunning, 0)}
out := describe()
substr := "Autoscaling:\tbetween 1 and 3 replicas"
if !strings.Contains(out, substr) {
t.Fatalf("expected %q in output:\n%s", substr, out)
}
config.Spec.Triggers = append(config.Spec.Triggers, deployapitest.OkConfigChangeTrigger())
describe()
config.Spec.Strategy = deployapitest.OkCustomStrategy()
describe()
config.Spec.Triggers[0].ImageChangeParams.From = kapi.ObjectReference{Name: "imagestream"}
describe()
config.Spec.Strategy = deployapitest.OkStrategy()
config.Spec.Strategy.RecreateParams = &deployapi.RecreateDeploymentStrategyParams{
Pre: &deployapi.LifecycleHook{
FailurePolicy: deployapi.LifecycleHookFailurePolicyAbort,
ExecNewPod: &deployapi.ExecNewPodHook{
ContainerName: "container",
Command: []string{"/command1", "args"},
Env: []kapi.EnvVar{
{
Name: "KEY1",
Value: "value1",
},
},
},
},
Post: &deployapi.LifecycleHook{
FailurePolicy: deployapi.LifecycleHookFailurePolicyIgnore,
ExecNewPod: &deployapi.ExecNewPodHook{
ContainerName: "container",
Command: []string{"/command2", "args"},
Env: []kapi.EnvVar{
{
Name: "KEY2",
Value: "value2",
},
},
},
},
}
describe()
}
