utils_test.go 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627
  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. index := NewTruncIndex()
  119. // Get on an empty index
  120. if _, err := index.Get("foobar"); err == nil {
  121. t.Fatal("Get on an empty index should return an error")
  122. }
  123. // Spaces should be illegal in an id
  124. if err := index.Add("I have a space"); err == nil {
  125. t.Fatalf("Adding an id with ' ' should return an error")
  126. }
  127. id := "99b36c2c326ccc11e726eee6ee78a0baf166ef96"
  128. // Add an id
  129. if err := index.Add(id); err != nil {
  130. t.Fatal(err)
  131. }
  132. // Get a non-existing id
  133. assertIndexGet(t, index, "abracadabra", "", true)
  134. // Get the exact id
  135. assertIndexGet(t, index, id, id, false)
  136. // The first letter should match
  137. assertIndexGet(t, index, id[:1], id, false)
  138. // The first half should match
  139. assertIndexGet(t, index, id[:len(id)/2], id, false)
  140. // The second half should NOT match
  141. assertIndexGet(t, index, id[len(id)/2:], "", true)
  142. id2 := id[:6] + "blabla"
  143. // Add an id
  144. if err := index.Add(id2); err != nil {
  145. t.Fatal(err)
  146. }
  147. // Both exact IDs should work
  148. assertIndexGet(t, index, id, id, false)
  149. assertIndexGet(t, index, id2, id2, false)
  150. // 6 characters or less should conflict
  151. assertIndexGet(t, index, id[:6], "", true)
  152. assertIndexGet(t, index, id[:4], "", true)
  153. assertIndexGet(t, index, id[:1], "", true)
  154. // 7 characters should NOT conflict
  155. assertIndexGet(t, index, id[:7], id, false)
  156. assertIndexGet(t, index, id2[:7], id2, false)
  157. // Deleting a non-existing id should return an error
  158. if err := index.Delete("non-existing"); err == nil {
  159. t.Fatalf("Deleting a non-existing id should return an error")
  160. }
  161. // Deleting id2 should remove conflicts
  162. if err := index.Delete(id2); err != nil {
  163. t.Fatal(err)
  164. }
  165. // id2 should no longer work
  166. assertIndexGet(t, index, id2, "", true)
  167. assertIndexGet(t, index, id2[:7], "", true)
  168. assertIndexGet(t, index, id2[:11], "", true)
  169. // conflicts between id and id2 should be gone
  170. assertIndexGet(t, index, id[:6], id, false)
  171. assertIndexGet(t, index, id[:4], id, false)
  172. assertIndexGet(t, index, id[:1], id, false)
  173. // non-conflicting substrings should still not conflict
  174. assertIndexGet(t, index, id[:7], id, false)
  175. assertIndexGet(t, index, id[:15], id, false)
  176. assertIndexGet(t, index, id, id, false)
  177. }
  178. func assertIndexGet(t *testing.T, index *TruncIndex, input, expectedResult string, expectError bool) {
  179. if result, err := index.Get(input); err != nil && !expectError {
  180. t.Fatalf("Unexpected error getting '%s': %s", input, err)
  181. } else if err == nil && expectError {
  182. t.Fatalf("Getting '%s' should return an error", input)
  183. } else if result != expectedResult {
  184. t.Fatalf("Getting '%s' returned '%s' instead of '%s'", input, result, expectedResult)
  185. }
  186. }
  187. func assertKernelVersion(t *testing.T, a, b *KernelVersionInfo, result int) {
  188. if r := CompareKernelVersion(a, b); r != result {
  189. t.Fatalf("Unexpected kernel version comparison result. Found %d, expected %d", r, result)
  190. }
  191. }
  192. func TestCompareKernelVersion(t *testing.T) {
  193. assertKernelVersion(t,
  194. &KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0},
  195. &KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0},
  196. 0)
  197. assertKernelVersion(t,
  198. &KernelVersionInfo{Kernel: 2, Major: 6, Minor: 0},
  199. &KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0},
  200. -1)
  201. assertKernelVersion(t,
  202. &KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0},
  203. &KernelVersionInfo{Kernel: 2, Major: 6, Minor: 0},
  204. 1)
  205. assertKernelVersion(t,
  206. &KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0},
  207. &KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0},
  208. 0)
  209. assertKernelVersion(t,
  210. &KernelVersionInfo{Kernel: 3, Major: 8, Minor: 5},
  211. &KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0},
  212. 1)
  213. assertKernelVersion(t,
  214. &KernelVersionInfo{Kernel: 3, Major: 0, Minor: 20},
  215. &KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0},
  216. -1)
  217. }
  218. func TestHumanSize(t *testing.T) {
  219. size := strings.Trim(HumanSize(1000), " \t")
  220. expect := "1 kB"
  221. if size != expect {
  222. t.Errorf("1000 -> expected '%s', got '%s'", expect, size)
  223. }
  224. size = strings.Trim(HumanSize(1024), " \t")
  225. expect = "1.024 kB"
  226. if size != expect {
  227. t.Errorf("1024 -> expected '%s', got '%s'", expect, size)
  228. }
  229. }
  230. func TestRAMInBytes(t *testing.T) {
  231. assertRAMInBytes(t, "32", false, 32)
  232. assertRAMInBytes(t, "32b", false, 32)
  233. assertRAMInBytes(t, "32B", false, 32)
  234. assertRAMInBytes(t, "32k", false, 32*1024)
  235. assertRAMInBytes(t, "32K", false, 32*1024)
  236. assertRAMInBytes(t, "32kb", false, 32*1024)
  237. assertRAMInBytes(t, "32Kb", false, 32*1024)
  238. assertRAMInBytes(t, "32Mb", false, 32*1024*1024)
  239. assertRAMInBytes(t, "32Gb", false, 32*1024*1024*1024)
  240. assertRAMInBytes(t, "", true, -1)
  241. assertRAMInBytes(t, "hello", true, -1)
  242. assertRAMInBytes(t, "-32", true, -1)
  243. assertRAMInBytes(t, " 32 ", true, -1)
  244. assertRAMInBytes(t, "32 mb", true, -1)
  245. assertRAMInBytes(t, "32m b", true, -1)
  246. assertRAMInBytes(t, "32bm", true, -1)
  247. }
  248. func assertRAMInBytes(t *testing.T, size string, expectError bool, expectedBytes int64) {
  249. actualBytes, err := RAMInBytes(size)
  250. if (err != nil) && !expectError {
  251. t.Errorf("Unexpected error parsing '%s': %s", size, err)
  252. }
  253. if (err == nil) && expectError {
  254. t.Errorf("Expected to get an error parsing '%s', but got none (bytes=%d)", size, actualBytes)
  255. }
  256. if actualBytes != expectedBytes {
  257. t.Errorf("Expected '%s' to parse as %d bytes, got %d", size, expectedBytes, actualBytes)
  258. }
  259. }
  260. func TestParseHost(t *testing.T) {
  261. var (
  262. defaultHttpHost = "127.0.0.1"
  263. defaultUnix = "/var/run/docker.sock"
  264. )
  265. if addr, err := ParseHost(defaultHttpHost, defaultUnix, "0.0.0.0"); err == nil {
  266. t.Errorf("tcp 0.0.0.0 address expected error return, but err == nil, got %s", addr)
  267. }
  268. if addr, err := ParseHost(defaultHttpHost, defaultUnix, "tcp://"); err == nil {
  269. t.Errorf("default tcp:// address expected error return, but err == nil, got %s", addr)
  270. }
  271. if addr, err := ParseHost(defaultHttpHost, defaultUnix, "0.0.0.1:5555"); err != nil || addr != "tcp://0.0.0.1:5555" {
  272. t.Errorf("0.0.0.1:5555 -> expected tcp://0.0.0.1:5555, got %s", addr)
  273. }
  274. if addr, err := ParseHost(defaultHttpHost, defaultUnix, ":6666"); err != nil || addr != "tcp://127.0.0.1:6666" {
  275. t.Errorf(":6666 -> expected tcp://127.0.0.1:6666, got %s", addr)
  276. }
  277. if addr, err := ParseHost(defaultHttpHost, defaultUnix, "tcp://:7777"); err != nil || addr != "tcp://127.0.0.1:7777" {
  278. t.Errorf("tcp://:7777 -> expected tcp://127.0.0.1:7777, got %s", addr)
  279. }
  280. if addr, err := ParseHost(defaultHttpHost, defaultUnix, ""); err != nil || addr != "unix:///var/run/docker.sock" {
  281. t.Errorf("empty argument -> expected unix:///var/run/docker.sock, got %s", addr)
  282. }
  283. if addr, err := ParseHost(defaultHttpHost, defaultUnix, "unix:///var/run/docker.sock"); err != nil || addr != "unix:///var/run/docker.sock" {
  284. t.Errorf("unix:///var/run/docker.sock -> expected unix:///var/run/docker.sock, got %s", addr)
  285. }
  286. if addr, err := ParseHost(defaultHttpHost, defaultUnix, "unix://"); err != nil || addr != "unix:///var/run/docker.sock" {
  287. t.Errorf("unix:///var/run/docker.sock -> expected unix:///var/run/docker.sock, got %s", addr)
  288. }
  289. if addr, err := ParseHost(defaultHttpHost, defaultUnix, "udp://127.0.0.1"); err == nil {
  290. t.Errorf("udp protocol address expected error return, but err == nil. Got %s", addr)
  291. }
  292. if addr, err := ParseHost(defaultHttpHost, defaultUnix, "udp://127.0.0.1:4243"); err == nil {
  293. t.Errorf("udp protocol address expected error return, but err == nil. Got %s", addr)
  294. }
  295. }
  296. func TestParseRepositoryTag(t *testing.T) {
  297. if repo, tag := ParseRepositoryTag("root"); repo != "root" || tag != "" {
  298. t.Errorf("Expected repo: '%s' and tag: '%s', got '%s' and '%s'", "root", "", repo, tag)
  299. }
  300. if repo, tag := ParseRepositoryTag("root:tag"); repo != "root" || tag != "tag" {
  301. t.Errorf("Expected repo: '%s' and tag: '%s', got '%s' and '%s'", "root", "tag", repo, tag)
  302. }
  303. if repo, tag := ParseRepositoryTag("user/repo"); repo != "user/repo" || tag != "" {
  304. t.Errorf("Expected repo: '%s' and tag: '%s', got '%s' and '%s'", "user/repo", "", repo, tag)
  305. }
  306. if repo, tag := ParseRepositoryTag("user/repo:tag"); repo != "user/repo" || tag != "tag" {
  307. t.Errorf("Expected repo: '%s' and tag: '%s', got '%s' and '%s'", "user/repo", "tag", repo, tag)
  308. }
  309. if repo, tag := ParseRepositoryTag("url:5000/repo"); repo != "url:5000/repo" || tag != "" {
  310. t.Errorf("Expected repo: '%s' and tag: '%s', got '%s' and '%s'", "url:5000/repo", "", repo, tag)
  311. }
  312. if repo, tag := ParseRepositoryTag("url:5000/repo:tag"); repo != "url:5000/repo" || tag != "tag" {
  313. t.Errorf("Expected repo: '%s' and tag: '%s', got '%s' and '%s'", "url:5000/repo", "tag", repo, tag)
  314. }
  315. }
  316. func TestGetResolvConf(t *testing.T) {
  317. resolvConfUtils, err := GetResolvConf()
  318. if err != nil {
  319. t.Fatal(err)
  320. }
  321. resolvConfSystem, err := ioutil.ReadFile("/etc/resolv.conf")
  322. if err != nil {
  323. t.Fatal(err)
  324. }
  325. if string(resolvConfUtils) != string(resolvConfSystem) {
  326. t.Fatalf("/etc/resolv.conf and GetResolvConf have different content.")
  327. }
  328. }
  329. func TestCheckLocalDns(t *testing.T) {
  330. for resolv, result := range map[string]bool{`# Dynamic
  331. nameserver 10.0.2.3
  332. search dotcloud.net`: false,
  333. `# Dynamic
  334. #nameserver 127.0.0.1
  335. nameserver 10.0.2.3
  336. search dotcloud.net`: false,
  337. `# Dynamic
  338. nameserver 10.0.2.3 #not used 127.0.1.1
  339. search dotcloud.net`: false,
  340. `# Dynamic
  341. #nameserver 10.0.2.3
  342. #search dotcloud.net`: true,
  343. `# Dynamic
  344. nameserver 127.0.0.1
  345. search dotcloud.net`: true,
  346. `# Dynamic
  347. nameserver 127.0.1.1
  348. search dotcloud.net`: true,
  349. `# Dynamic
  350. `: true,
  351. ``: true,
  352. } {
  353. if CheckLocalDns([]byte(resolv)) != result {
  354. t.Fatalf("Wrong local dns detection: {%s} should be %v", resolv, result)
  355. }
  356. }
  357. }
  358. func assertParseRelease(t *testing.T, release string, b *KernelVersionInfo, result int) {
  359. var (
  360. a *KernelVersionInfo
  361. )
  362. a, _ = ParseRelease(release)
  363. if r := CompareKernelVersion(a, b); r != result {
  364. t.Fatalf("Unexpected kernel version comparison result. Found %d, expected %d", r, result)
  365. }
  366. if a.Flavor != b.Flavor {
  367. t.Fatalf("Unexpected parsed kernel flavor. Found %s, expected %s", a.Flavor, b.Flavor)
  368. }
  369. }
  370. func TestParseRelease(t *testing.T) {
  371. assertParseRelease(t, "3.8.0", &KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0}, 0)
  372. assertParseRelease(t, "3.4.54.longterm-1", &KernelVersionInfo{Kernel: 3, Major: 4, Minor: 54, Flavor: ".longterm-1"}, 0)
  373. assertParseRelease(t, "3.4.54.longterm-1", &KernelVersionInfo{Kernel: 3, Major: 4, Minor: 54, Flavor: ".longterm-1"}, 0)
  374. assertParseRelease(t, "3.8.0-19-generic", &KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0, Flavor: "-19-generic"}, 0)
  375. assertParseRelease(t, "3.12.8tag", &KernelVersionInfo{Kernel: 3, Major: 12, Minor: 8, Flavor: "tag"}, 0)
  376. assertParseRelease(t, "3.12-1-amd64", &KernelVersionInfo{Kernel: 3, Major: 12, Minor: 0, Flavor: "-1-amd64"}, 0)
  377. }
  378. func TestParsePortMapping(t *testing.T) {
  379. data, err := PartParser("ip:public:private", "192.168.1.1:80:8080")
  380. if err != nil {
  381. t.Fatal(err)
  382. }
  383. if len(data) != 3 {
  384. t.FailNow()
  385. }
  386. if data["ip"] != "192.168.1.1" {
  387. t.Fail()
  388. }
  389. if data["public"] != "80" {
  390. t.Fail()
  391. }
  392. if data["private"] != "8080" {
  393. t.Fail()
  394. }
  395. }
  396. func TestGetNameservers(t *testing.T) {
  397. for resolv, result := range map[string][]string{`
  398. nameserver 1.2.3.4
  399. nameserver 40.3.200.10
  400. search example.com`: {"1.2.3.4", "40.3.200.10"},
  401. `search example.com`: {},
  402. `nameserver 1.2.3.4
  403. search example.com
  404. nameserver 4.30.20.100`: {"1.2.3.4", "4.30.20.100"},
  405. ``: {},
  406. ` nameserver 1.2.3.4 `: {"1.2.3.4"},
  407. `search example.com
  408. nameserver 1.2.3.4
  409. #nameserver 4.3.2.1`: {"1.2.3.4"},
  410. `search example.com
  411. nameserver 1.2.3.4 # not 4.3.2.1`: {"1.2.3.4"},
  412. } {
  413. test := GetNameservers([]byte(resolv))
  414. if !StrSlicesEqual(test, result) {
  415. t.Fatalf("Wrong nameserver string {%s} should be %v. Input: %s", test, result, resolv)
  416. }
  417. }
  418. }
  419. func TestGetNameserversAsCIDR(t *testing.T) {
  420. for resolv, result := range map[string][]string{`
  421. nameserver 1.2.3.4
  422. nameserver 40.3.200.10
  423. search example.com`: {"1.2.3.4/32", "40.3.200.10/32"},
  424. `search example.com`: {},
  425. `nameserver 1.2.3.4
  426. search example.com
  427. nameserver 4.30.20.100`: {"1.2.3.4/32", "4.30.20.100/32"},
  428. ``: {},
  429. ` nameserver 1.2.3.4 `: {"1.2.3.4/32"},
  430. `search example.com
  431. nameserver 1.2.3.4
  432. #nameserver 4.3.2.1`: {"1.2.3.4/32"},
  433. `search example.com
  434. nameserver 1.2.3.4 # not 4.3.2.1`: {"1.2.3.4/32"},
  435. } {
  436. test := GetNameserversAsCIDR([]byte(resolv))
  437. if !StrSlicesEqual(test, result) {
  438. t.Fatalf("Wrong nameserver string {%s} should be %v. Input: %s", test, result, resolv)
  439. }
  440. }
  441. }
  442. func TestGetSearchDomains(t *testing.T) {
  443. for resolv, result := range map[string][]string{
  444. `search example.com`: {"example.com"},
  445. `search example.com # ignored`: {"example.com"},
  446. ` search example.com `: {"example.com"},
  447. ` search example.com # ignored`: {"example.com"},
  448. `search foo.example.com example.com`: {"foo.example.com", "example.com"},
  449. ` search foo.example.com example.com `: {"foo.example.com", "example.com"},
  450. ` search foo.example.com example.com # ignored`: {"foo.example.com", "example.com"},
  451. ``: {},
  452. `# ignored`: {},
  453. `nameserver 1.2.3.4
  454. search foo.example.com example.com`: {"foo.example.com", "example.com"},
  455. `nameserver 1.2.3.4
  456. search dup1.example.com dup2.example.com
  457. search foo.example.com example.com`: {"foo.example.com", "example.com"},
  458. `nameserver 1.2.3.4
  459. search foo.example.com example.com
  460. nameserver 4.30.20.100`: {"foo.example.com", "example.com"},
  461. } {
  462. test := GetSearchDomains([]byte(resolv))
  463. if !StrSlicesEqual(test, result) {
  464. t.Fatalf("Wrong search domain string {%s} should be %v. Input: %s", test, result, resolv)
  465. }
  466. }
  467. }
  468. func StrSlicesEqual(a, b []string) bool {
  469. if len(a) != len(b) {
  470. return false
  471. }
  472. for i, v := range a {
  473. if v != b[i] {
  474. return false
  475. }
  476. }
  477. return true
  478. }
  479. func TestReplaceAndAppendEnvVars(t *testing.T) {
  480. var (
  481. d = []string{"HOME=/"}
  482. o = []string{"HOME=/root", "TERM=xterm"}
  483. )
  484. env := ReplaceOrAppendEnvValues(d, o)
  485. if len(env) != 2 {
  486. t.Fatalf("expected len of 2 got %d", len(env))
  487. }
  488. if env[0] != "HOME=/root" {
  489. t.Fatalf("expected HOME=/root got '%s'", env[0])
  490. }
  491. if env[1] != "TERM=xterm" {
  492. t.Fatalf("expected TERM=xterm got '%s'", env[1])
  493. }
  494. }
  495. // Reading a symlink to a directory must return the directory
  496. func TestReadSymlinkedDirectoryExistingDirectory(t *testing.T) {
  497. var err error
  498. if err = os.Mkdir("/tmp/testReadSymlinkToExistingDirectory", 0777); err != nil {
  499. t.Errorf("failed to create directory: %s", err)
  500. }
  501. if err = os.Symlink("/tmp/testReadSymlinkToExistingDirectory", "/tmp/dirLinkTest"); err != nil {
  502. t.Errorf("failed to create symlink: %s", err)
  503. }
  504. var path string
  505. if path, err = ReadSymlinkedDirectory("/tmp/dirLinkTest"); err != nil {
  506. t.Fatalf("failed to read symlink to directory: %s", err)
  507. }
  508. if path != "/tmp/testReadSymlinkToExistingDirectory" {
  509. t.Fatalf("symlink returned unexpected directory: %s", path)
  510. }
  511. if err = os.Remove("/tmp/testReadSymlinkToExistingDirectory"); err != nil {
  512. t.Errorf("failed to remove temporary directory: %s", err)
  513. }
  514. if err = os.Remove("/tmp/dirLinkTest"); err != nil {
  515. t.Errorf("failed to remove symlink: %s", err)
  516. }
  517. }
  518. // Reading a non-existing symlink must fail
  519. func TestReadSymlinkedDirectoryNonExistingSymlink(t *testing.T) {
  520. var path string
  521. var err error
  522. if path, err = ReadSymlinkedDirectory("/tmp/test/foo/Non/ExistingPath"); err == nil {
  523. t.Fatalf("error expected for non-existing symlink")
  524. }
  525. if path != "" {
  526. t.Fatalf("expected empty path, but '%s' was returned", path)
  527. }
  528. }
  529. // Reading a symlink to a file must fail
  530. func TestReadSymlinkedDirectoryToFile(t *testing.T) {
  531. var err error
  532. var file *os.File
  533. if file, err = os.Create("/tmp/testReadSymlinkToFile"); err != nil {
  534. t.Fatalf("failed to create file: %s", err)
  535. }
  536. file.Close()
  537. if err = os.Symlink("/tmp/testReadSymlinkToFile", "/tmp/fileLinkTest"); err != nil {
  538. t.Errorf("failed to create symlink: %s", err)
  539. }
  540. var path string
  541. if path, err = ReadSymlinkedDirectory("/tmp/fileLinkTest"); err == nil {
  542. t.Fatalf("ReadSymlinkedDirectory on a symlink to a file should've failed")
  543. }
  544. if path != "" {
  545. t.Fatalf("path should've been empty: %s", path)
  546. }
  547. if err = os.Remove("/tmp/testReadSymlinkToFile"); err != nil {
  548. t.Errorf("failed to remove file: %s", err)
  549. }
  550. if err = os.Remove("/tmp/fileLinkTest"); err != nil {
  551. t.Errorf("failed to remove symlink: %s", err)
  552. }
  553. }