func TestRolling_deployInitial(t *testing.T) {
initialStrategyInvoked := false
strategy := &RollingDeploymentStrategy{
decoder: kapi.Codecs.UniversalDecoder(),
rcClient: ktestclient.NewSimpleFake(),
eventClient: ktestclient.NewSimpleFake(),
initialStrategy: &testStrategy{
deployFn: func(from *kapi.ReplicationController, to *kapi.ReplicationController, desiredReplicas int, updateAcceptor strat.UpdateAcceptor) error {
initialStrategyInvoked = true
return nil
},
},
rollingUpdate: func(config *kubectl.RollingUpdaterConfig) error {
t.Fatalf("unexpected call to rollingUpdate")
return nil
},
getUpdateAcceptor: getUpdateAcceptor,
apiRetryPeriod: 1 * time.Millisecond,
apiRetryTimeout: 10 * time.Millisecond,
}
config := deploytest.OkDeploymentConfig(1)
config.Spec.Strategy = deploytest.OkRollingStrategy()
deployment, _ := deployutil.MakeDeployment(config, kapi.Codecs.LegacyCodec(registered.GroupOrDie(kapi.GroupName).GroupVersions[0]))
strategy.out, strategy.errOut = &bytes.Buffer{}, &bytes.Buffer{}
err := strategy.Deploy(nil, deployment, 2)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if !initialStrategyInvoked {
t.Fatalf("expected initial strategy to be invoked")
}
}
func TestRolling_deployInitial(t *testing.T) {
initialStrategyInvoked := false
strategy := &RollingDeploymentStrategy{
codec: api.Codec,
client: ktestclient.NewSimpleFake(),
initialStrategy: &testStrategy{
deployFn: func(from *kapi.ReplicationController, to *kapi.ReplicationController, desiredReplicas int, updateAcceptor strat.UpdateAcceptor) error {
initialStrategyInvoked = true
return nil
},
},
rollingUpdate: func(config *kubectl.RollingUpdaterConfig) error {
t.Fatalf("unexpected call to rollingUpdate")
return nil
},
getUpdateAcceptor: getUpdateAcceptor,
apiRetryPeriod: 1 * time.Millisecond,
apiRetryTimeout: 10 * time.Millisecond,
}
config := deploytest.OkDeploymentConfig(1)
config.Template.Strategy = deploytest.OkRollingStrategy()
deployment, _ := deployutil.MakeDeployment(config, kapi.Codec)
err := strategy.Deploy(nil, deployment, 2)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if !initialStrategyInvoked {
t.Fatalf("expected initial strategy to be invoked")
}
}
func TestRolling_deployInitial(t *testing.T) {
initialStrategyInvoked := false
strategy := &RollingDeploymentStrategy{
codec: api.Codec,
client: &rollingUpdaterClient{
GetReplicationControllerFn: func(namespace, name string) (*kapi.ReplicationController, error) {
t.Fatalf("unexpected call to GetReplicationController")
return nil, nil
},
},
initialStrategy: &testStrategy{
deployFn: func(from *kapi.ReplicationController, to *kapi.ReplicationController, desiredReplicas int, updateAcceptor kubectl.UpdateAcceptor) error {
initialStrategyInvoked = true
return nil
},
},
rollingUpdate: func(config *kubectl.RollingUpdaterConfig) error {
t.Fatalf("unexpected call to rollingUpdate")
return nil
},
getUpdateAcceptor: getUpdateAcceptor,
}
config := deploytest.OkDeploymentConfig(1)
config.Template.Strategy = deploytest.OkRollingStrategy()
deployment, _ := deployutil.MakeDeployment(config, kapi.Codec)
err := strategy.Deploy(nil, deployment, 2)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if !initialStrategyInvoked {
t.Fatalf("expected initial strategy to be invoked")
}
}
func TestRolling_deployRolling(t *testing.T) {
latestConfig := deploytest.OkDeploymentConfig(1)
latestConfig.Template.Strategy = deploytest.OkRollingStrategy()
latest, _ := deployutil.MakeDeployment(latestConfig, kapi.Codec)
config := deploytest.OkDeploymentConfig(2)
config.Template.Strategy = deploytest.OkRollingStrategy()
deployment, _ := deployutil.MakeDeployment(config, kapi.Codec)
deployments := map[string]*kapi.ReplicationController{
latest.Name: latest,
deployment.Name: deployment,
}
deploymentUpdated := false
fake := &ktestclient.Fake{}
fake.AddReactor("get", "replicationcontrollers", func(action ktestclient.Action) (handled bool, ret runtime.Object, err error) {
name := action.(ktestclient.GetAction).GetName()
return true, deployments[name], nil
})
fake.AddReactor("update", "replicationcontrollers", func(action ktestclient.Action) (handled bool, ret runtime.Object, err error) {
updated := action.(ktestclient.UpdateAction).GetObject().(*kapi.ReplicationController)
deploymentUpdated = true
return true, updated, nil
})
var rollingConfig *kubectl.RollingUpdaterConfig
strategy := &RollingDeploymentStrategy{
codec: api.Codec,
client: fake,
initialStrategy: &testStrategy{
deployFn: func(from *kapi.ReplicationController, to *kapi.ReplicationController, desiredReplicas int, updateAcceptor strat.UpdateAcceptor) error {
t.Fatalf("unexpected call to initial strategy")
return nil
},
},
rollingUpdate: func(config *kubectl.RollingUpdaterConfig) error {
rollingConfig = config
return nil
},
getUpdateAcceptor: getUpdateAcceptor,
apiRetryPeriod: 1 * time.Millisecond,
apiRetryTimeout: 10 * time.Millisecond,
}
err := strategy.Deploy(latest, deployment, 2)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if rollingConfig == nil {
t.Fatalf("expected rolling update to be invoked")
}
if e, a := latest, rollingConfig.OldRc; e != a {
t.Errorf("expected rollingConfig.OldRc %v, got %v", e, a)
}
if e, a := deployment, rollingConfig.NewRc; e != a {
t.Errorf("expected rollingConfig.NewRc %v, got %v", e, a)
}
if e, a := 1*time.Second, rollingConfig.Interval; e != a {
t.Errorf("expected Interval %d, got %d", e, a)
}
if e, a := 1*time.Second, rollingConfig.UpdatePeriod; e != a {
t.Errorf("expected UpdatePeriod %d, got %d", e, a)
}
if e, a := 20*time.Second, rollingConfig.Timeout; e != a {
t.Errorf("expected Timeout %d, got %d", e, a)
}
// verify hack
if e, a := 1, rollingConfig.NewRc.Spec.Replicas; e != a {
t.Errorf("expected rollingConfig.NewRc.Spec.Replicas %d, got %d", e, a)
}
// verify hack
if !deploymentUpdated {
t.Errorf("expected deployment to be updated for source annotation")
}
sid := fmt.Sprintf("%s:%s", latest.Name, latest.ObjectMeta.UID)
if e, a := sid, rollingConfig.NewRc.Annotations[sourceIdAnnotation]; e != a {
t.Errorf("expected sourceIdAnnotation %s, got %s", e, a)
}
}
func TestRolling_deployRollingHooks(t *testing.T) {
config := deploytest.OkDeploymentConfig(1)
config.Template.Strategy = deploytest.OkRollingStrategy()
latest, _ := deployutil.MakeDeployment(config, kapi.Codec)
var hookError error
deployments := map[string]*kapi.ReplicationController{latest.Name: latest}
fake := &ktestclient.Fake{}
fake.AddReactor("get", "replicationcontrollers", func(action ktestclient.Action) (handled bool, ret runtime.Object, err error) {
name := action.(ktestclient.GetAction).GetName()
return true, deployments[name], nil
})
fake.AddReactor("update", "replicationcontrollers", func(action ktestclient.Action) (handled bool, ret runtime.Object, err error) {
updated := action.(ktestclient.UpdateAction).GetObject().(*kapi.ReplicationController)
return true, updated, nil
})
strategy := &RollingDeploymentStrategy{
codec: api.Codec,
client: fake,
initialStrategy: &testStrategy{
deployFn: func(from *kapi.ReplicationController, to *kapi.ReplicationController, desiredReplicas int, updateAcceptor strat.UpdateAcceptor) error {
t.Fatalf("unexpected call to initial strategy")
return nil
},
},
rollingUpdate: func(config *kubectl.RollingUpdaterConfig) error {
return nil
},
hookExecutor: &hookExecutorImpl{
executeFunc: func(hook *deployapi.LifecycleHook, deployment *kapi.ReplicationController, label string) error {
return hookError
},
},
getUpdateAcceptor: getUpdateAcceptor,
apiRetryPeriod: 1 * time.Millisecond,
apiRetryTimeout: 10 * time.Millisecond,
}
cases := []struct {
params *deployapi.RollingDeploymentStrategyParams
hookShouldFail bool
deploymentShouldFail bool
}{
{rollingParams(deployapi.LifecycleHookFailurePolicyAbort, ""), true, true},
{rollingParams(deployapi.LifecycleHookFailurePolicyAbort, ""), false, false},
{rollingParams("", deployapi.LifecycleHookFailurePolicyAbort), true, false},
{rollingParams("", deployapi.LifecycleHookFailurePolicyAbort), false, false},
}
for _, tc := range cases {
config := deploytest.OkDeploymentConfig(2)
config.Template.Strategy.RollingParams = tc.params
deployment, _ := deployutil.MakeDeployment(config, kapi.Codec)
deployments[deployment.Name] = deployment
hookError = nil
if tc.hookShouldFail {
hookError = fmt.Errorf("hook failure")
}
err := strategy.Deploy(latest, deployment, 2)
if err != nil && tc.deploymentShouldFail {
t.Logf("got expected error: %v", err)
}
if err == nil && tc.deploymentShouldFail {
t.Errorf("expected an error for case: %v", tc)
}
if err != nil && !tc.deploymentShouldFail {
t.Errorf("unexpected error for case: %v: %v", tc, err)
}
}
}
func TestRolling_deployRollingHooks(t *testing.T) {
config := deploytest.OkDeploymentConfig(1)
config.Spec.Strategy = deploytest.OkRollingStrategy()
latest, _ := deployutil.MakeDeployment(config, kapi.Codecs.LegacyCodec(registered.GroupOrDie(kapi.GroupName).GroupVersions[0]))
var hookError error
deployments := map[string]*kapi.ReplicationController{latest.Name: latest}
client := &fake.Clientset{}
client.AddReactor("get", "replicationcontrollers", func(action core.Action) (handled bool, ret runtime.Object, err error) {
name := action.(core.GetAction).GetName()
return true, deployments[name], nil
})
client.AddReactor("update", "replicationcontrollers", func(action core.Action) (handled bool, ret runtime.Object, err error) {
updated := action.(core.UpdateAction).GetObject().(*kapi.ReplicationController)
return true, updated, nil
})
strategy := &RollingDeploymentStrategy{
decoder: kapi.Codecs.UniversalDecoder(),
rcClient: client.Core(),
eventClient: fake.NewSimpleClientset().Core(),
initialStrategy: &testStrategy{
deployFn: func(from *kapi.ReplicationController, to *kapi.ReplicationController, desiredReplicas int, updateAcceptor strat.UpdateAcceptor) error {
t.Fatalf("unexpected call to initial strategy")
return nil
},
},
rollingUpdate: func(config *kubectl.RollingUpdaterConfig) error {
return nil
},
hookExecutor: &hookExecutorImpl{
executeFunc: func(hook *deployapi.LifecycleHook, deployment *kapi.ReplicationController, suffix, label string) error {
return hookError
},
},
getUpdateAcceptor: getUpdateAcceptor,
apiRetryPeriod: 1 * time.Millisecond,
apiRetryTimeout: 10 * time.Millisecond,
}
cases := []struct {
params *deployapi.RollingDeploymentStrategyParams
hookShouldFail bool
deploymentShouldFail bool
}{
{rollingParams(deployapi.LifecycleHookFailurePolicyAbort, ""), true, true},
{rollingParams(deployapi.LifecycleHookFailurePolicyAbort, ""), false, false},
{rollingParams("", deployapi.LifecycleHookFailurePolicyAbort), true, true},
{rollingParams("", deployapi.LifecycleHookFailurePolicyAbort), false, false},
}
for _, tc := range cases {
config := deploytest.OkDeploymentConfig(2)
config.Spec.Strategy.RollingParams = tc.params
deployment, _ := deployutil.MakeDeployment(config, kapi.Codecs.LegacyCodec(registered.GroupOrDie(kapi.GroupName).GroupVersions[0]))
deployments[deployment.Name] = deployment
hookError = nil
if tc.hookShouldFail {
hookError = fmt.Errorf("hook failure")
}
strategy.out, strategy.errOut = &bytes.Buffer{}, &bytes.Buffer{}
err := strategy.Deploy(latest, deployment, 2)
if err != nil && tc.deploymentShouldFail {
t.Logf("got expected error: %v", err)
}
if err == nil && tc.deploymentShouldFail {
t.Errorf("expected an error for case: %#v", tc)
}
if err != nil && !tc.deploymentShouldFail {
t.Errorf("unexpected error for case: %#v: %v", tc, err)
}
}
}
func TestRolling_deployRolling(t *testing.T) {
latestConfig := deploytest.OkDeploymentConfig(1)
latestConfig.Template.Strategy = deploytest.OkRollingStrategy()
latest, _ := deployutil.MakeDeployment(latestConfig, kapi.Codec)
config := deploytest.OkDeploymentConfig(2)
config.Template.Strategy = deploytest.OkRollingStrategy()
deployment, _ := deployutil.MakeDeployment(config, kapi.Codec)
deployments := map[string]*kapi.ReplicationController{
latest.Name: latest,
deployment.Name: deployment,
}
var rollingConfig *kubectl.RollingUpdaterConfig
deploymentUpdated := false
strategy := &RollingDeploymentStrategy{
codec: api.Codec,
client: &rollingUpdaterClient{
GetReplicationControllerFn: func(namespace, name string) (*kapi.ReplicationController, error) {
return deployments[name], nil
},
UpdateReplicationControllerFn: func(namespace string, rc *kapi.ReplicationController) (*kapi.ReplicationController, error) {
if rc.Name != deployment.Name {
t.Fatalf("unexpected call to UpdateReplicationController for %s", rc.Name)
}
deploymentUpdated = true
return rc, nil
},
},
initialStrategy: &testStrategy{
deployFn: func(from *kapi.ReplicationController, to *kapi.ReplicationController, desiredReplicas int, updateAcceptor kubectl.UpdateAcceptor) error {
t.Fatalf("unexpected call to initial strategy")
return nil
},
},
rollingUpdate: func(config *kubectl.RollingUpdaterConfig) error {
rollingConfig = config
return nil
},
getUpdateAcceptor: getUpdateAcceptor,
}
err := strategy.Deploy(latest, deployment, 2)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if rollingConfig == nil {
t.Fatalf("expected rolling update to be invoked")
}
if e, a := latest, rollingConfig.OldRc; e != a {
t.Errorf("expected rollingConfig.OldRc %v, got %v", e, a)
}
if e, a := deployment, rollingConfig.NewRc; e != a {
t.Errorf("expected rollingConfig.NewRc %v, got %v", e, a)
}
if e, a := 1*time.Second, rollingConfig.Interval; e != a {
t.Errorf("expected Interval %d, got %d", e, a)
}
if e, a := 1*time.Second, rollingConfig.UpdatePeriod; e != a {
t.Errorf("expected UpdatePeriod %d, got %d", e, a)
}
if e, a := 20*time.Second, rollingConfig.Timeout; e != a {
t.Errorf("expected Timeout %d, got %d", e, a)
}
// verify hack
if e, a := 1, rollingConfig.NewRc.Spec.Replicas; e != a {
t.Errorf("expected rollingConfig.NewRc.Spec.Replicas %d, got %d", e, a)
}
// verify hack
if !deploymentUpdated {
t.Errorf("expected deployment to be updated for source annotation")
}
sid := fmt.Sprintf("%s:%s", latest.Name, latest.ObjectMeta.UID)
if e, a := sid, rollingConfig.NewRc.Annotations[sourceIdAnnotation]; e != a {
t.Errorf("expected sourceIdAnnotation %s, got %s", e, a)
}
}
func TestRolling_deployRollingHooks(t *testing.T) {
config := deploytest.OkDeploymentConfig(1)
config.Template.Strategy = deploytest.OkRollingStrategy()
latest, _ := deployutil.MakeDeployment(config, kapi.Codec)
var hookError error
deployments := map[string]*kapi.ReplicationController{latest.Name: latest}
strategy := &RollingDeploymentStrategy{
codec: api.Codec,
client: &rollingUpdaterClient{
GetReplicationControllerFn: func(namespace, name string) (*kapi.ReplicationController, error) {
return deployments[name], nil
},
UpdateReplicationControllerFn: func(namespace string, rc *kapi.ReplicationController) (*kapi.ReplicationController, error) {
return rc, nil
},
},
initialStrategy: &testStrategy{
deployFn: func(from *kapi.ReplicationController, to *kapi.ReplicationController, desiredReplicas int, updateAcceptor kubectl.UpdateAcceptor) error {
t.Fatalf("unexpected call to initial strategy")
return nil
},
},
rollingUpdate: func(config *kubectl.RollingUpdaterConfig) error {
return nil
},
hookExecutor: &hookExecutorImpl{
executeFunc: func(hook *deployapi.LifecycleHook, deployment *kapi.ReplicationController, label string) error {
return hookError
},
},
getUpdateAcceptor: getUpdateAcceptor,
}
cases := []struct {
params *deployapi.RollingDeploymentStrategyParams
hookShouldFail bool
deploymentShouldFail bool
}{
{rollingParams(deployapi.LifecycleHookFailurePolicyAbort, ""), true, true},
{rollingParams(deployapi.LifecycleHookFailurePolicyAbort, ""), false, false},
{rollingParams("", deployapi.LifecycleHookFailurePolicyAbort), true, false},
{rollingParams("", deployapi.LifecycleHookFailurePolicyAbort), false, false},
}
for _, tc := range cases {
config := deploytest.OkDeploymentConfig(2)
config.Template.Strategy.RollingParams = tc.params
deployment, _ := deployutil.MakeDeployment(config, kapi.Codec)
deployments[deployment.Name] = deployment
hookError = nil
if tc.hookShouldFail {
hookError = fmt.Errorf("hook failure")
}
err := strategy.Deploy(latest, deployment, 2)
if err != nil && tc.deploymentShouldFail {
t.Logf("got expected error: %v", err)
}
if err == nil && tc.deploymentShouldFail {
t.Errorf("expected an error for case: %v", tc)
}
if err != nil && !tc.deploymentShouldFail {
t.Errorf("unexpected error for case: %v: %v", tc, err)
}
}
}