Function TestToServiceUpdateRollback

cli/command/service/opts_test.go:277–337

(t *testing.T)

}

func TestToServiceUpdateRollback(t *testing.T) {
	expected := swarm.ServiceSpec{
		UpdateConfig: &swarm.UpdateConfig{
			Parallelism:     23,
			Delay:           34 * time.Second,
			Monitor:         54321 * time.Nanosecond,
			FailureAction:   swarm.UpdateFailureActionPause,
			MaxFailureRatio: 0.6,
			Order:           swarm.UpdateOrderStopFirst,
		},
		RollbackConfig: &swarm.UpdateConfig{
			Parallelism:     12,
			Delay:           23 * time.Second,
			Monitor:         12345 * time.Nanosecond,
			FailureAction:   swarm.UpdateFailureActionContinue,
			MaxFailureRatio: 0.5,
			Order:           swarm.UpdateOrderStartFirst,
		},
	}

	// Note: in test-situation, the flags are only used to detect if an option
	// was set; the actual value itself is read from the serviceOptions below.
	flags := newCreateCommand(nil).Flags()
	flags.Set("update-parallelism", "23")
	flags.Set("update-delay", "34s")
	flags.Set("update-monitor", "54321ns")
	flags.Set("update-failure-action", string(swarm.UpdateFailureActionPause))
	flags.Set("update-max-failure-ratio", "0.6")
	flags.Set("update-order", string(swarm.UpdateOrderStopFirst))

	flags.Set("rollback-parallelism", "12")
	flags.Set("rollback-delay", "23s")
	flags.Set("rollback-monitor", "12345ns")
	flags.Set("rollback-failure-action", string(swarm.UpdateFailureActionContinue))
	flags.Set("rollback-max-failure-ratio", "0.5")
	flags.Set("rollback-order", string(swarm.UpdateOrderStartFirst))

	o := newServiceOptions()
	o.mode = "replicated"
	o.update = updateOptions{
		parallelism:     23,
		delay:           34 * time.Second,
		monitor:         54321 * time.Nanosecond,
		onFailure:       string(swarm.UpdateFailureActionPause),
		maxFailureRatio: 0.6,
		order:           string(swarm.UpdateOrderStopFirst),
	}
	o.rollback = updateOptions{
		parallelism:     12,
		delay:           23 * time.Second,
		monitor:         12345 * time.Nanosecond,
		onFailure:       string(swarm.UpdateFailureActionContinue),
		maxFailureRatio: 0.5,
		order:           string(swarm.UpdateOrderStartFirst),
	}

	service, err := o.ToService(context.Background(), &fakeClient{}, flags)
	assert.NilError(t, err)