utils_test.go 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544
  1. package utils
  2. import (
  3. "bytes"
  4. "errors"
  5. "io"
  6. "io/ioutil"
  7. "os"
  8. "strings"
  9. "testing"
  10. )
  11. func TestBufReader(t *testing.T) {
  12. reader, writer := io.Pipe()
  13. bufreader := NewBufReader(reader)
  14. // Write everything down to a Pipe
  15. // Usually, a pipe should block but because of the buffered reader,
  16. // the writes will go through
  17. done := make(chan bool)
  18. go func() {
  19. writer.Write([]byte("hello world"))
  20. writer.Close()
  21. done <- true
  22. }()
  23. // Drain the reader *after* everything has been written, just to verify
  24. // it is indeed buffering
  25. <-done
  26. output, err := ioutil.ReadAll(bufreader)
  27. if err != nil {
  28. t.Fatal(err)
  29. }
  30. if !bytes.Equal(output, []byte("hello world")) {
  31. t.Error(string(output))
  32. }
  33. }
  34. type dummyWriter struct {
  35. buffer bytes.Buffer
  36. failOnWrite bool
  37. }
  38. func (dw *dummyWriter) Write(p []byte) (n int, err error) {
  39. if dw.failOnWrite {
  40. return 0, errors.New("Fake fail")
  41. }
  42. return dw.buffer.Write(p)
  43. }
  44. func (dw *dummyWriter) String() string {
  45. return dw.buffer.String()
  46. }
  47. func (dw *dummyWriter) Close() error {
  48. return nil
  49. }
  50. func TestWriteBroadcaster(t *testing.T) {
  51. writer := NewWriteBroadcaster()
  52. // Test 1: Both bufferA and bufferB should contain "foo"
  53. bufferA := &dummyWriter{}
  54. writer.AddWriter(bufferA, "")
  55. bufferB := &dummyWriter{}
  56. writer.AddWriter(bufferB, "")
  57. writer.Write([]byte("foo"))
  58. if bufferA.String() != "foo" {
  59. t.Errorf("Buffer contains %v", bufferA.String())
  60. }
  61. if bufferB.String() != "foo" {
  62. t.Errorf("Buffer contains %v", bufferB.String())
  63. }
  64. // Test2: bufferA and bufferB should contain "foobar",
  65. // while bufferC should only contain "bar"
  66. bufferC := &dummyWriter{}
  67. writer.AddWriter(bufferC, "")
  68. writer.Write([]byte("bar"))
  69. if bufferA.String() != "foobar" {
  70. t.Errorf("Buffer contains %v", bufferA.String())
  71. }
  72. if bufferB.String() != "foobar" {
  73. t.Errorf("Buffer contains %v", bufferB.String())
  74. }
  75. if bufferC.String() != "bar" {
  76. t.Errorf("Buffer contains %v", bufferC.String())
  77. }
  78. // Test3: Test eviction on failure
  79. bufferA.failOnWrite = true
  80. writer.Write([]byte("fail"))
  81. if bufferA.String() != "foobar" {
  82. t.Errorf("Buffer contains %v", bufferA.String())
  83. }
  84. if bufferC.String() != "barfail" {
  85. t.Errorf("Buffer contains %v", bufferC.String())
  86. }
  87. // Even though we reset the flag, no more writes should go in there
  88. bufferA.failOnWrite = false
  89. writer.Write([]byte("test"))
  90. if bufferA.String() != "foobar" {
  91. t.Errorf("Buffer contains %v", bufferA.String())
  92. }
  93. if bufferC.String() != "barfailtest" {
  94. t.Errorf("Buffer contains %v", bufferC.String())
  95. }
  96. writer.CloseWriters()
  97. }
  98. type devNullCloser int
  99. func (d devNullCloser) Close() error {
  100. return nil
  101. }
  102. func (d devNullCloser) Write(buf []byte) (int, error) {
  103. return len(buf), nil
  104. }
  105. // This test checks for races. It is only useful when run with the race detector.
  106. func TestRaceWriteBroadcaster(t *testing.T) {
  107. writer := NewWriteBroadcaster()
  108. c := make(chan bool)
  109. go func() {
  110. writer.AddWriter(devNullCloser(0), "")
  111. c <- true
  112. }()
  113. writer.Write([]byte("hello"))
  114. <-c
  115. }
  116. // Test the behavior of TruncIndex, an index for querying IDs from a non-conflicting prefix.
  117. func TestTruncIndex(t *testing.T) {
  118. ids := []string{}
  119. index := NewTruncIndex(ids)
  120. // Get on an empty index
  121. if _, err := index.Get("foobar"); err == nil {
  122. t.Fatal("Get on an empty index should return an error")
  123. }
  124. // Spaces should be illegal in an id
  125. if err := index.Add("I have a space"); err == nil {
  126. t.Fatalf("Adding an id with ' ' should return an error")
  127. }
  128. id := "99b36c2c326ccc11e726eee6ee78a0baf166ef96"
  129. // Add an id
  130. if err := index.Add(id); err != nil {
  131. t.Fatal(err)
  132. }
  133. // Get a non-existing id
  134. assertIndexGet(t, index, "abracadabra", "", true)
  135. // Get the exact id
  136. assertIndexGet(t, index, id, id, false)
  137. // The first letter should match
  138. assertIndexGet(t, index, id[:1], id, false)
  139. // The first half should match
  140. assertIndexGet(t, index, id[:len(id)/2], id, false)
  141. // The second half should NOT match
  142. assertIndexGet(t, index, id[len(id)/2:], "", true)
  143. id2 := id[:6] + "blabla"
  144. // Add an id
  145. if err := index.Add(id2); err != nil {
  146. t.Fatal(err)
  147. }
  148. // Both exact IDs should work
  149. assertIndexGet(t, index, id, id, false)
  150. assertIndexGet(t, index, id2, id2, false)
  151. // 6 characters or less should conflict
  152. assertIndexGet(t, index, id[:6], "", true)
  153. assertIndexGet(t, index, id[:4], "", true)
  154. assertIndexGet(t, index, id[:1], "", true)
  155. // 7 characters should NOT conflict
  156. assertIndexGet(t, index, id[:7], id, false)
  157. assertIndexGet(t, index, id2[:7], id2, false)
  158. // Deleting a non-existing id should return an error
  159. if err := index.Delete("non-existing"); err == nil {
  160. t.Fatalf("Deleting a non-existing id should return an error")
  161. }
  162. // Deleting id2 should remove conflicts
  163. if err := index.Delete(id2); err != nil {
  164. t.Fatal(err)
  165. }
  166. // id2 should no longer work
  167. assertIndexGet(t, index, id2, "", true)
  168. assertIndexGet(t, index, id2[:7], "", true)
  169. assertIndexGet(t, index, id2[:11], "", true)
  170. // conflicts between id and id2 should be gone
  171. assertIndexGet(t, index, id[:6], id, false)
  172. assertIndexGet(t, index, id[:4], id, false)
  173. assertIndexGet(t, index, id[:1], id, false)
  174. // non-conflicting substrings should still not conflict
  175. assertIndexGet(t, index, id[:7], id, false)
  176. assertIndexGet(t, index, id[:15], id, false)
  177. assertIndexGet(t, index, id, id, false)
  178. }
  179. func assertIndexGet(t *testing.T, index *TruncIndex, input, expectedResult string, expectError bool) {
  180. if result, err := index.Get(input); err != nil && !expectError {
  181. t.Fatalf("Unexpected error getting '%s': %s", input, err)
  182. } else if err == nil && expectError {
  183. t.Fatalf("Getting '%s' should return an error", input)
  184. } else if result != expectedResult {
  185. t.Fatalf("Getting '%s' returned '%s' instead of '%s'", input, result, expectedResult)
  186. }
  187. }
  188. func BenchmarkTruncIndexAdd(b *testing.B) {
  189. ids := []string{"banana", "bananaa", "bananab"}
  190. b.ResetTimer()
  191. for i := 0; i < b.N; i++ {
  192. index := NewTruncIndex([]string{})
  193. for _, id := range ids {
  194. index.Add(id)
  195. }
  196. }
  197. }
  198. func BenchmarkTruncIndexNew(b *testing.B) {
  199. ids := []string{"banana", "bananaa", "bananab"}
  200. b.ResetTimer()
  201. for i := 0; i < b.N; i++ {
  202. NewTruncIndex(ids)
  203. }
  204. }
  205. func assertKernelVersion(t *testing.T, a, b *KernelVersionInfo, result int) {
  206. if r := CompareKernelVersion(a, b); r != result {
  207. t.Fatalf("Unexpected kernel version comparison result. Found %d, expected %d", r, result)
  208. }
  209. }
  210. func TestCompareKernelVersion(t *testing.T) {
  211. assertKernelVersion(t,
  212. &KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0},
  213. &KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0},
  214. 0)
  215. assertKernelVersion(t,
  216. &KernelVersionInfo{Kernel: 2, Major: 6, Minor: 0},
  217. &KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0},
  218. -1)
  219. assertKernelVersion(t,
  220. &KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0},
  221. &KernelVersionInfo{Kernel: 2, Major: 6, Minor: 0},
  222. 1)
  223. assertKernelVersion(t,
  224. &KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0},
  225. &KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0},
  226. 0)
  227. assertKernelVersion(t,
  228. &KernelVersionInfo{Kernel: 3, Major: 8, Minor: 5},
  229. &KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0},
  230. 1)
  231. assertKernelVersion(t,
  232. &KernelVersionInfo{Kernel: 3, Major: 0, Minor: 20},
  233. &KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0},
  234. -1)
  235. }
  236. func TestHumanSize(t *testing.T) {
  237. size := strings.Trim(HumanSize(1000), " \t")
  238. expect := "1 kB"
  239. if size != expect {
  240. t.Errorf("1000 -> expected '%s', got '%s'", expect, size)
  241. }
  242. size = strings.Trim(HumanSize(1024), " \t")
  243. expect = "1.024 kB"
  244. if size != expect {
  245. t.Errorf("1024 -> expected '%s', got '%s'", expect, size)
  246. }
  247. }
  248. func TestRAMInBytes(t *testing.T) {
  249. assertRAMInBytes(t, "32", false, 32)
  250. assertRAMInBytes(t, "32b", false, 32)
  251. assertRAMInBytes(t, "32B", false, 32)
  252. assertRAMInBytes(t, "32k", false, 32*1024)
  253. assertRAMInBytes(t, "32K", false, 32*1024)
  254. assertRAMInBytes(t, "32kb", false, 32*1024)
  255. assertRAMInBytes(t, "32Kb", false, 32*1024)
  256. assertRAMInBytes(t, "32Mb", false, 32*1024*1024)
  257. assertRAMInBytes(t, "32Gb", false, 32*1024*1024*1024)
  258. assertRAMInBytes(t, "", true, -1)
  259. assertRAMInBytes(t, "hello", true, -1)
  260. assertRAMInBytes(t, "-32", true, -1)
  261. assertRAMInBytes(t, " 32 ", true, -1)
  262. assertRAMInBytes(t, "32 mb", true, -1)
  263. assertRAMInBytes(t, "32m b", true, -1)
  264. assertRAMInBytes(t, "32bm", true, -1)
  265. }
  266. func assertRAMInBytes(t *testing.T, size string, expectError bool, expectedBytes int64) {
  267. actualBytes, err := RAMInBytes(size)
  268. if (err != nil) && !expectError {
  269. t.Errorf("Unexpected error parsing '%s': %s", size, err)
  270. }
  271. if (err == nil) && expectError {
  272. t.Errorf("Expected to get an error parsing '%s', but got none (bytes=%d)", size, actualBytes)
  273. }
  274. if actualBytes != expectedBytes {
  275. t.Errorf("Expected '%s' to parse as %d bytes, got %d", size, expectedBytes, actualBytes)
  276. }
  277. }
  278. func TestParseHost(t *testing.T) {
  279. var (
  280. defaultHttpHost = "127.0.0.1"
  281. defaultUnix = "/var/run/docker.sock"
  282. )
  283. if addr, err := ParseHost(defaultHttpHost, defaultUnix, "0.0.0.0"); err == nil {
  284. t.Errorf("tcp 0.0.0.0 address expected error return, but err == nil, got %s", addr)
  285. }
  286. if addr, err := ParseHost(defaultHttpHost, defaultUnix, "tcp://"); err == nil {
  287. t.Errorf("default tcp:// address expected error return, but err == nil, got %s", addr)
  288. }
  289. if addr, err := ParseHost(defaultHttpHost, defaultUnix, "0.0.0.1:5555"); err != nil || addr != "tcp://0.0.0.1:5555" {
  290. t.Errorf("0.0.0.1:5555 -> expected tcp://0.0.0.1:5555, got %s", addr)
  291. }
  292. if addr, err := ParseHost(defaultHttpHost, defaultUnix, ":6666"); err != nil || addr != "tcp://127.0.0.1:6666" {
  293. t.Errorf(":6666 -> expected tcp://127.0.0.1:6666, got %s", addr)
  294. }
  295. if addr, err := ParseHost(defaultHttpHost, defaultUnix, "tcp://:7777"); err != nil || addr != "tcp://127.0.0.1:7777" {
  296. t.Errorf("tcp://:7777 -> expected tcp://127.0.0.1:7777, got %s", addr)
  297. }
  298. if addr, err := ParseHost(defaultHttpHost, defaultUnix, ""); err != nil || addr != "unix:///var/run/docker.sock" {
  299. t.Errorf("empty argument -> expected unix:///var/run/docker.sock, got %s", addr)
  300. }
  301. if addr, err := ParseHost(defaultHttpHost, defaultUnix, "unix:///var/run/docker.sock"); err != nil || addr != "unix:///var/run/docker.sock" {
  302. t.Errorf("unix:///var/run/docker.sock -> expected unix:///var/run/docker.sock, got %s", addr)
  303. }
  304. if addr, err := ParseHost(defaultHttpHost, defaultUnix, "unix://"); err != nil || addr != "unix:///var/run/docker.sock" {
  305. t.Errorf("unix:///var/run/docker.sock -> expected unix:///var/run/docker.sock, got %s", addr)
  306. }
  307. if addr, err := ParseHost(defaultHttpHost, defaultUnix, "udp://127.0.0.1"); err == nil {
  308. t.Errorf("udp protocol address expected error return, but err == nil. Got %s", addr)
  309. }
  310. if addr, err := ParseHost(defaultHttpHost, defaultUnix, "udp://127.0.0.1:4243"); err == nil {
  311. t.Errorf("udp protocol address expected error return, but err == nil. Got %s", addr)
  312. }
  313. }
  314. func TestParseRepositoryTag(t *testing.T) {
  315. if repo, tag := ParseRepositoryTag("root"); repo != "root" || tag != "" {
  316. t.Errorf("Expected repo: '%s' and tag: '%s', got '%s' and '%s'", "root", "", repo, tag)
  317. }
  318. if repo, tag := ParseRepositoryTag("root:tag"); repo != "root" || tag != "tag" {
  319. t.Errorf("Expected repo: '%s' and tag: '%s', got '%s' and '%s'", "root", "tag", repo, tag)
  320. }
  321. if repo, tag := ParseRepositoryTag("user/repo"); repo != "user/repo" || tag != "" {
  322. t.Errorf("Expected repo: '%s' and tag: '%s', got '%s' and '%s'", "user/repo", "", repo, tag)
  323. }
  324. if repo, tag := ParseRepositoryTag("user/repo:tag"); repo != "user/repo" || tag != "tag" {
  325. t.Errorf("Expected repo: '%s' and tag: '%s', got '%s' and '%s'", "user/repo", "tag", repo, tag)
  326. }
  327. if repo, tag := ParseRepositoryTag("url:5000/repo"); repo != "url:5000/repo" || tag != "" {
  328. t.Errorf("Expected repo: '%s' and tag: '%s', got '%s' and '%s'", "url:5000/repo", "", repo, tag)
  329. }
  330. if repo, tag := ParseRepositoryTag("url:5000/repo:tag"); repo != "url:5000/repo" || tag != "tag" {
  331. t.Errorf("Expected repo: '%s' and tag: '%s', got '%s' and '%s'", "url:5000/repo", "tag", repo, tag)
  332. }
  333. }
  334. func TestCheckLocalDns(t *testing.T) {
  335. for resolv, result := range map[string]bool{`# Dynamic
  336. nameserver 10.0.2.3
  337. search dotcloud.net`: false,
  338. `# Dynamic
  339. #nameserver 127.0.0.1
  340. nameserver 10.0.2.3
  341. search dotcloud.net`: false,
  342. `# Dynamic
  343. nameserver 10.0.2.3 #not used 127.0.1.1
  344. search dotcloud.net`: false,
  345. `# Dynamic
  346. #nameserver 10.0.2.3
  347. #search dotcloud.net`: true,
  348. `# Dynamic
  349. nameserver 127.0.0.1
  350. search dotcloud.net`: true,
  351. `# Dynamic
  352. nameserver 127.0.1.1
  353. search dotcloud.net`: true,
  354. `# Dynamic
  355. `: true,
  356. ``: true,
  357. } {
  358. if CheckLocalDns([]byte(resolv)) != result {
  359. t.Fatalf("Wrong local dns detection: {%s} should be %v", resolv, result)
  360. }
  361. }
  362. }
  363. func assertParseRelease(t *testing.T, release string, b *KernelVersionInfo, result int) {
  364. var (
  365. a *KernelVersionInfo
  366. )
  367. a, _ = ParseRelease(release)
  368. if r := CompareKernelVersion(a, b); r != result {
  369. t.Fatalf("Unexpected kernel version comparison result. Found %d, expected %d", r, result)
  370. }
  371. if a.Flavor != b.Flavor {
  372. t.Fatalf("Unexpected parsed kernel flavor. Found %s, expected %s", a.Flavor, b.Flavor)
  373. }
  374. }
  375. func TestParseRelease(t *testing.T) {
  376. assertParseRelease(t, "3.8.0", &KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0}, 0)
  377. assertParseRelease(t, "3.4.54.longterm-1", &KernelVersionInfo{Kernel: 3, Major: 4, Minor: 54, Flavor: ".longterm-1"}, 0)
  378. assertParseRelease(t, "3.4.54.longterm-1", &KernelVersionInfo{Kernel: 3, Major: 4, Minor: 54, Flavor: ".longterm-1"}, 0)
  379. assertParseRelease(t, "3.8.0-19-generic", &KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0, Flavor: "-19-generic"}, 0)
  380. assertParseRelease(t, "3.12.8tag", &KernelVersionInfo{Kernel: 3, Major: 12, Minor: 8, Flavor: "tag"}, 0)
  381. assertParseRelease(t, "3.12-1-amd64", &KernelVersionInfo{Kernel: 3, Major: 12, Minor: 0, Flavor: "-1-amd64"}, 0)
  382. }
  383. func TestParsePortMapping(t *testing.T) {
  384. data, err := PartParser("ip:public:private", "192.168.1.1:80:8080")
  385. if err != nil {
  386. t.Fatal(err)
  387. }
  388. if len(data) != 3 {
  389. t.FailNow()
  390. }
  391. if data["ip"] != "192.168.1.1" {
  392. t.Fail()
  393. }
  394. if data["public"] != "80" {
  395. t.Fail()
  396. }
  397. if data["private"] != "8080" {
  398. t.Fail()
  399. }
  400. }
  401. func TestReplaceAndAppendEnvVars(t *testing.T) {
  402. var (
  403. d = []string{"HOME=/"}
  404. o = []string{"HOME=/root", "TERM=xterm"}
  405. )
  406. env := ReplaceOrAppendEnvValues(d, o)
  407. if len(env) != 2 {
  408. t.Fatalf("expected len of 2 got %d", len(env))
  409. }
  410. if env[0] != "HOME=/root" {
  411. t.Fatalf("expected HOME=/root got '%s'", env[0])
  412. }
  413. if env[1] != "TERM=xterm" {
  414. t.Fatalf("expected TERM=xterm got '%s'", env[1])
  415. }
  416. }
  417. // Reading a symlink to a directory must return the directory
  418. func TestReadSymlinkedDirectoryExistingDirectory(t *testing.T) {
  419. var err error
  420. if err = os.Mkdir("/tmp/testReadSymlinkToExistingDirectory", 0777); err != nil {
  421. t.Errorf("failed to create directory: %s", err)
  422. }
  423. if err = os.Symlink("/tmp/testReadSymlinkToExistingDirectory", "/tmp/dirLinkTest"); err != nil {
  424. t.Errorf("failed to create symlink: %s", err)
  425. }
  426. var path string
  427. if path, err = ReadSymlinkedDirectory("/tmp/dirLinkTest"); err != nil {
  428. t.Fatalf("failed to read symlink to directory: %s", err)
  429. }
  430. if path != "/tmp/testReadSymlinkToExistingDirectory" {
  431. t.Fatalf("symlink returned unexpected directory: %s", path)
  432. }
  433. if err = os.Remove("/tmp/testReadSymlinkToExistingDirectory"); err != nil {
  434. t.Errorf("failed to remove temporary directory: %s", err)
  435. }
  436. if err = os.Remove("/tmp/dirLinkTest"); err != nil {
  437. t.Errorf("failed to remove symlink: %s", err)
  438. }
  439. }
  440. // Reading a non-existing symlink must fail
  441. func TestReadSymlinkedDirectoryNonExistingSymlink(t *testing.T) {
  442. var path string
  443. var err error
  444. if path, err = ReadSymlinkedDirectory("/tmp/test/foo/Non/ExistingPath"); err == nil {
  445. t.Fatalf("error expected for non-existing symlink")
  446. }
  447. if path != "" {
  448. t.Fatalf("expected empty path, but '%s' was returned", path)
  449. }
  450. }
  451. // Reading a symlink to a file must fail
  452. func TestReadSymlinkedDirectoryToFile(t *testing.T) {
  453. var err error
  454. var file *os.File
  455. if file, err = os.Create("/tmp/testReadSymlinkToFile"); err != nil {
  456. t.Fatalf("failed to create file: %s", err)
  457. }
  458. file.Close()
  459. if err = os.Symlink("/tmp/testReadSymlinkToFile", "/tmp/fileLinkTest"); err != nil {
  460. t.Errorf("failed to create symlink: %s", err)
  461. }
  462. var path string
  463. if path, err = ReadSymlinkedDirectory("/tmp/fileLinkTest"); err == nil {
  464. t.Fatalf("ReadSymlinkedDirectory on a symlink to a file should've failed")
  465. }
  466. if path != "" {
  467. t.Fatalf("path should've been empty: %s", path)
  468. }
  469. if err = os.Remove("/tmp/testReadSymlinkToFile"); err != nil {
  470. t.Errorf("failed to remove file: %s", err)
  471. }
  472. if err = os.Remove("/tmp/fileLinkTest"); err != nil {
  473. t.Errorf("failed to remove symlink: %s", err)
  474. }
  475. }