utils_test.go 9.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359
  1. package docker
  2. import (
  3. "bytes"
  4. "fmt"
  5. "io"
  6. "io/ioutil"
  7. "net/http"
  8. "net/http/httptest"
  9. "os"
  10. "path"
  11. "strings"
  12. "testing"
  13. "time"
  14. "github.com/docker/docker/vendor/src/code.google.com/p/go/src/pkg/archive/tar"
  15. "github.com/docker/docker/builtins"
  16. "github.com/docker/docker/daemon"
  17. "github.com/docker/docker/engine"
  18. "github.com/docker/docker/pkg/log"
  19. flag "github.com/docker/docker/pkg/mflag"
  20. "github.com/docker/docker/pkg/sysinfo"
  21. "github.com/docker/docker/runconfig"
  22. "github.com/docker/docker/utils"
  23. )
  24. // This file contains utility functions for docker's unit test suite.
  25. // It has to be named XXX_test.go, apparently, in other to access private functions
  26. // from other XXX_test.go functions.
  27. // Create a temporary daemon suitable for unit testing.
  28. // Call t.Fatal() at the first error.
  29. func mkDaemon(f log.Fataler) *daemon.Daemon {
  30. eng := newTestEngine(f, false, "")
  31. return mkDaemonFromEngine(eng, f)
  32. // FIXME:
  33. // [...]
  34. // Mtu: docker.GetDefaultNetworkMtu(),
  35. // [...]
  36. }
  37. func createNamedTestContainer(eng *engine.Engine, config *runconfig.Config, f log.Fataler, name string) (shortId string) {
  38. job := eng.Job("create", name)
  39. if err := job.ImportEnv(config); err != nil {
  40. f.Fatal(err)
  41. }
  42. var outputBuffer = bytes.NewBuffer(nil)
  43. job.Stdout.Add(outputBuffer)
  44. if err := job.Run(); err != nil {
  45. f.Fatal(err)
  46. }
  47. return engine.Tail(outputBuffer, 1)
  48. }
  49. func createTestContainer(eng *engine.Engine, config *runconfig.Config, f log.Fataler) (shortId string) {
  50. return createNamedTestContainer(eng, config, f, "")
  51. }
  52. func startContainer(eng *engine.Engine, id string, t log.Fataler) {
  53. job := eng.Job("start", id)
  54. if err := job.Run(); err != nil {
  55. t.Fatal(err)
  56. }
  57. }
  58. func containerRun(eng *engine.Engine, id string, t log.Fataler) {
  59. startContainer(eng, id, t)
  60. containerWait(eng, id, t)
  61. }
  62. func containerFileExists(eng *engine.Engine, id, dir string, t log.Fataler) bool {
  63. c := getContainer(eng, id, t)
  64. if err := c.Mount(); err != nil {
  65. t.Fatal(err)
  66. }
  67. defer c.Unmount()
  68. if _, err := os.Stat(path.Join(c.RootfsPath(), dir)); err != nil {
  69. if os.IsNotExist(err) {
  70. return false
  71. }
  72. t.Fatal(err)
  73. }
  74. return true
  75. }
  76. func containerAttach(eng *engine.Engine, id string, t log.Fataler) (io.WriteCloser, io.ReadCloser) {
  77. c := getContainer(eng, id, t)
  78. i, err := c.StdinPipe()
  79. if err != nil {
  80. t.Fatal(err)
  81. }
  82. o, err := c.StdoutPipe()
  83. if err != nil {
  84. t.Fatal(err)
  85. }
  86. return i, o
  87. }
  88. func containerWait(eng *engine.Engine, id string, t log.Fataler) int {
  89. ex, _ := getContainer(eng, id, t).WaitStop(-1 * time.Second)
  90. return ex
  91. }
  92. func containerWaitTimeout(eng *engine.Engine, id string, t log.Fataler) error {
  93. _, err := getContainer(eng, id, t).WaitStop(500 * time.Millisecond)
  94. return err
  95. }
  96. func containerKill(eng *engine.Engine, id string, t log.Fataler) {
  97. if err := eng.Job("kill", id).Run(); err != nil {
  98. t.Fatal(err)
  99. }
  100. }
  101. func containerRunning(eng *engine.Engine, id string, t log.Fataler) bool {
  102. return getContainer(eng, id, t).IsRunning()
  103. }
  104. func containerAssertExists(eng *engine.Engine, id string, t log.Fataler) {
  105. getContainer(eng, id, t)
  106. }
  107. func containerAssertNotExists(eng *engine.Engine, id string, t log.Fataler) {
  108. daemon := mkDaemonFromEngine(eng, t)
  109. if c := daemon.Get(id); c != nil {
  110. t.Fatal(fmt.Errorf("Container %s should not exist", id))
  111. }
  112. }
  113. // assertHttpNotError expect the given response to not have an error.
  114. // Otherwise the it causes the test to fail.
  115. func assertHttpNotError(r *httptest.ResponseRecorder, t log.Fataler) {
  116. // Non-error http status are [200, 400)
  117. if r.Code < http.StatusOK || r.Code >= http.StatusBadRequest {
  118. t.Fatal(fmt.Errorf("Unexpected http error: %v", r.Code))
  119. }
  120. }
  121. // assertHttpError expect the given response to have an error.
  122. // Otherwise the it causes the test to fail.
  123. func assertHttpError(r *httptest.ResponseRecorder, t log.Fataler) {
  124. // Non-error http status are [200, 400)
  125. if !(r.Code < http.StatusOK || r.Code >= http.StatusBadRequest) {
  126. t.Fatal(fmt.Errorf("Unexpected http success code: %v", r.Code))
  127. }
  128. }
  129. func getContainer(eng *engine.Engine, id string, t log.Fataler) *daemon.Container {
  130. daemon := mkDaemonFromEngine(eng, t)
  131. c := daemon.Get(id)
  132. if c == nil {
  133. t.Fatal(fmt.Errorf("No such container: %s", id))
  134. }
  135. return c
  136. }
  137. func mkDaemonFromEngine(eng *engine.Engine, t log.Fataler) *daemon.Daemon {
  138. iDaemon := eng.Hack_GetGlobalVar("httpapi.daemon")
  139. if iDaemon == nil {
  140. panic("Legacy daemon field not set in engine")
  141. }
  142. daemon, ok := iDaemon.(*daemon.Daemon)
  143. if !ok {
  144. panic("Legacy daemon field in engine does not cast to *daemon.Daemon")
  145. }
  146. return daemon
  147. }
  148. func newTestEngine(t log.Fataler, autorestart bool, root string) *engine.Engine {
  149. if root == "" {
  150. if dir, err := newTestDirectory(unitTestStoreBase); err != nil {
  151. t.Fatal(err)
  152. } else {
  153. root = dir
  154. }
  155. }
  156. os.MkdirAll(root, 0700)
  157. eng := engine.New()
  158. // Load default plugins
  159. builtins.Register(eng)
  160. // (This is manually copied and modified from main() until we have a more generic plugin system)
  161. cfg := &daemon.Config{
  162. Root: root,
  163. AutoRestart: autorestart,
  164. ExecDriver: "native",
  165. // Either InterContainerCommunication or EnableIptables must be set,
  166. // otherwise NewDaemon will fail because of conflicting settings.
  167. InterContainerCommunication: true,
  168. }
  169. d, err := daemon.NewDaemon(cfg, eng)
  170. if err != nil {
  171. t.Fatal(err)
  172. }
  173. if err := d.Install(eng); err != nil {
  174. t.Fatal(err)
  175. }
  176. return eng
  177. }
  178. func NewTestEngine(t log.Fataler) *engine.Engine {
  179. return newTestEngine(t, false, "")
  180. }
  181. func newTestDirectory(templateDir string) (dir string, err error) {
  182. return utils.TestDirectory(templateDir)
  183. }
  184. func getCallerName(depth int) string {
  185. return utils.GetCallerName(depth)
  186. }
  187. // Write `content` to the file at path `dst`, creating it if necessary,
  188. // as well as any missing directories.
  189. // The file is truncated if it already exists.
  190. // Call t.Fatal() at the first error.
  191. func writeFile(dst, content string, t *testing.T) {
  192. // Create subdirectories if necessary
  193. if err := os.MkdirAll(path.Dir(dst), 0700); err != nil && !os.IsExist(err) {
  194. t.Fatal(err)
  195. }
  196. f, err := os.OpenFile(dst, os.O_CREATE|os.O_RDWR|os.O_TRUNC, 0700)
  197. if err != nil {
  198. t.Fatal(err)
  199. }
  200. // Write content (truncate if it exists)
  201. if _, err := io.Copy(f, strings.NewReader(content)); err != nil {
  202. t.Fatal(err)
  203. }
  204. }
  205. // Return the contents of file at path `src`.
  206. // Call t.Fatal() at the first error (including if the file doesn't exist)
  207. func readFile(src string, t *testing.T) (content string) {
  208. f, err := os.Open(src)
  209. if err != nil {
  210. t.Fatal(err)
  211. }
  212. data, err := ioutil.ReadAll(f)
  213. if err != nil {
  214. t.Fatal(err)
  215. }
  216. return string(data)
  217. }
  218. // Create a test container from the given daemon `r` and run arguments `args`.
  219. // If the image name is "_", (eg. []string{"-i", "-t", "_", "bash"}, it is
  220. // dynamically replaced by the current test image.
  221. // The caller is responsible for destroying the container.
  222. // Call t.Fatal() at the first error.
  223. func mkContainer(r *daemon.Daemon, args []string, t *testing.T) (*daemon.Container, *runconfig.HostConfig, error) {
  224. config, hc, _, err := parseRun(args, nil)
  225. defer func() {
  226. if err != nil && t != nil {
  227. t.Fatal(err)
  228. }
  229. }()
  230. if err != nil {
  231. return nil, nil, err
  232. }
  233. if config.Image == "_" {
  234. config.Image = GetTestImage(r).ID
  235. }
  236. c, _, err := r.Create(config, "")
  237. if err != nil {
  238. return nil, nil, err
  239. }
  240. // NOTE: hostConfig is ignored.
  241. // If `args` specify privileged mode, custom lxc conf, external mount binds,
  242. // port redirects etc. they will be ignored.
  243. // This is because the correct way to set these things is to pass environment
  244. // to the `start` job.
  245. // FIXME: this helper function should be deprecated in favor of calling
  246. // `create` and `start` jobs directly.
  247. return c, hc, nil
  248. }
  249. // Create a test container, start it, wait for it to complete, destroy it,
  250. // and return its standard output as a string.
  251. // The image name (eg. the XXX in []string{"-i", "-t", "XXX", "bash"}, is dynamically replaced by the current test image.
  252. // If t is not nil, call t.Fatal() at the first error. Otherwise return errors normally.
  253. func runContainer(eng *engine.Engine, r *daemon.Daemon, args []string, t *testing.T) (output string, err error) {
  254. defer func() {
  255. if err != nil && t != nil {
  256. t.Fatal(err)
  257. }
  258. }()
  259. container, hc, err := mkContainer(r, args, t)
  260. if err != nil {
  261. return "", err
  262. }
  263. defer r.Destroy(container)
  264. stdout, err := container.StdoutPipe()
  265. if err != nil {
  266. return "", err
  267. }
  268. defer stdout.Close()
  269. job := eng.Job("start", container.ID)
  270. if err := job.ImportEnv(hc); err != nil {
  271. return "", err
  272. }
  273. if err := job.Run(); err != nil {
  274. return "", err
  275. }
  276. container.WaitStop(-1 * time.Second)
  277. data, err := ioutil.ReadAll(stdout)
  278. if err != nil {
  279. return "", err
  280. }
  281. output = string(data)
  282. return
  283. }
  284. // FIXME: this is duplicated from graph_test.go in the docker package.
  285. func fakeTar() (io.ReadCloser, error) {
  286. content := []byte("Hello world!\n")
  287. buf := new(bytes.Buffer)
  288. tw := tar.NewWriter(buf)
  289. for _, name := range []string{"/etc/postgres/postgres.conf", "/etc/passwd", "/var/log/postgres/postgres.conf"} {
  290. hdr := new(tar.Header)
  291. hdr.Size = int64(len(content))
  292. hdr.Name = name
  293. if err := tw.WriteHeader(hdr); err != nil {
  294. return nil, err
  295. }
  296. tw.Write([]byte(content))
  297. }
  298. tw.Close()
  299. return ioutil.NopCloser(buf), nil
  300. }
  301. func getAllImages(eng *engine.Engine, t *testing.T) *engine.Table {
  302. return getImages(eng, t, true, "")
  303. }
  304. func getImages(eng *engine.Engine, t *testing.T, all bool, filter string) *engine.Table {
  305. job := eng.Job("images")
  306. job.SetenvBool("all", all)
  307. job.Setenv("filter", filter)
  308. images, err := job.Stdout.AddListTable()
  309. if err != nil {
  310. t.Fatal(err)
  311. }
  312. if err := job.Run(); err != nil {
  313. t.Fatal(err)
  314. }
  315. return images
  316. }
  317. func parseRun(args []string, sysInfo *sysinfo.SysInfo) (*runconfig.Config, *runconfig.HostConfig, *flag.FlagSet, error) {
  318. cmd := flag.NewFlagSet("run", flag.ContinueOnError)
  319. cmd.SetOutput(ioutil.Discard)
  320. cmd.Usage = nil
  321. return runconfig.Parse(cmd, args, sysInfo)
  322. }