FilesExpand file tree

 master

/

docker_cli_pause_test.go

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

112 lines (94 loc) · 3.42 KB

 master

/

docker_cli_pause_test.go

Copy path

Top

File metadata and controls

• Code
• Blame

112 lines (94 loc) · 3.42 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

package main

import (

"fmt"

"os/exec"

"strings"

"testing"

)

func TestPause(t *testing.T) {

defer deleteAllContainers()

defer unpauseAllContainers()

name := "testeventpause"

out, _, _ := dockerCmd(t, "images", "-q")

image := strings.Split(out, "\n")[0]

dockerCmd(t, "run", "-d", "--name", name, image, "sleep", "2")

dockerCmd(t, "pause", name)

pausedContainers, err := getSliceOfPausedContainers()

if err != nil {

t.Fatalf("error thrown while checking if containers were paused: %v", err)

}

if len(pausedContainers) != 1 {

t.Fatalf("there should be one paused container and not", len(pausedContainers))

}

dockerCmd(t, "unpause", name)

eventsCmd := exec.Command(dockerBinary, "events", "--since=0", fmt.Sprintf("--until=%d", daemonTime(t).Unix()))

out, _, _ = runCommandWithOutput(eventsCmd)

events := strings.Split(out, "\n")

if len(events) <= 1 {

t.Fatalf("Missing expected event")

}

pauseEvent := strings.Fields(events[len(events)-3])

unpauseEvent := strings.Fields(events[len(events)-2])

if pauseEvent[len(pauseEvent)-1] != "pause" {

t.Fatalf("event should be pause, not %#v", pauseEvent)

}

if unpauseEvent[len(unpauseEvent)-1] != "unpause" {

t.Fatalf("event should be unpause, not %#v", unpauseEvent)

}

waitCmd := exec.Command(dockerBinary, "wait", name)

if waitOut, _, err := runCommandWithOutput(waitCmd); err != nil {

t.Fatalf("error thrown while waiting for container: %s, %v", waitOut, err)

}

logDone("pause - pause/unpause is logged")

}

func TestPauseMultipleContainers(t *testing.T) {

defer deleteAllContainers()

defer unpauseAllContainers()

containers := []string{

"testpausewithmorecontainers1",

"testpausewithmorecontainers2",

}

out, _, _ := dockerCmd(t, "images", "-q")

image := strings.Split(out, "\n")[0]

for _, name := range containers {

dockerCmd(t, "run", "-d", "--name", name, image, "sleep", "2")

}

dockerCmd(t, append([]string{"pause"}, containers...)...)

pausedContainers, err := getSliceOfPausedContainers()

if err != nil {

t.Fatalf("error thrown while checking if containers were paused: %v", err)

}

if len(pausedContainers) != len(containers) {

t.Fatalf("there should be %d paused container and not %d", len(containers), len(pausedContainers))

}

dockerCmd(t, append([]string{"unpause"}, containers...)...)

eventsCmd := exec.Command(dockerBinary, "events", "--since=0", fmt.Sprintf("--until=%d", daemonTime(t).Unix()))

out, _, _ = runCommandWithOutput(eventsCmd)

events := strings.Split(out, "\n")

if len(events) <= len(containers)*3-2 {

t.Fatalf("Missing expected event")

}

pauseEvents := make([][]string, len(containers))

unpauseEvents := make([][]string, len(containers))

for i := range containers {

pauseEvents[i] = strings.Fields(events[len(events)-len(containers)*2-1+i])

unpauseEvents[i] = strings.Fields(events[len(events)-len(containers)-1+i])

}

for _, pauseEvent := range pauseEvents {

if pauseEvent[len(pauseEvent)-1] != "pause" {

t.Fatalf("event should be pause, not %#v", pauseEvent)

}

}

for _, unpauseEvent := range unpauseEvents {

if unpauseEvent[len(unpauseEvent)-1] != "unpause" {

t.Fatalf("event should be unpause, not %#v", unpauseEvent)

}

}

for _, name := range containers {

waitCmd := exec.Command(dockerBinary, "wait", name)

if waitOut, _, err := runCommandWithOutput(waitCmd); err != nil {

t.Fatalf("error thrown while waiting for container: %s, %v", waitOut, err)

}

}

logDone("pause - multi pause/unpause is logged")

}