mirror of
https://github.com/moby/moby.git
synced 2022-11-09 12:21:53 -05:00
292 lines
9.5 KiB
Go
292 lines
9.5 KiB
Go
package utils
|
|
|
|
import (
|
|
"bytes"
|
|
"io"
|
|
"io/ioutil"
|
|
"os"
|
|
"testing"
|
|
)
|
|
|
|
func TestBufReader(t *testing.T) {
|
|
reader, writer := io.Pipe()
|
|
bufreader := NewBufReader(reader)
|
|
|
|
// Write everything down to a Pipe
|
|
// Usually, a pipe should block but because of the buffered reader,
|
|
// the writes will go through
|
|
done := make(chan bool)
|
|
go func() {
|
|
writer.Write([]byte("hello world"))
|
|
writer.Close()
|
|
done <- true
|
|
}()
|
|
|
|
// Drain the reader *after* everything has been written, just to verify
|
|
// it is indeed buffering
|
|
<-done
|
|
output, err := ioutil.ReadAll(bufreader)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !bytes.Equal(output, []byte("hello world")) {
|
|
t.Error(string(output))
|
|
}
|
|
}
|
|
|
|
func assertKernelVersion(t *testing.T, a, b *KernelVersionInfo, result int) {
|
|
if r := CompareKernelVersion(a, b); r != result {
|
|
t.Fatalf("Unexpected kernel version comparison result. Found %d, expected %d", r, result)
|
|
}
|
|
}
|
|
|
|
func TestCompareKernelVersion(t *testing.T) {
|
|
assertKernelVersion(t,
|
|
&KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0},
|
|
&KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0},
|
|
0)
|
|
assertKernelVersion(t,
|
|
&KernelVersionInfo{Kernel: 2, Major: 6, Minor: 0},
|
|
&KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0},
|
|
-1)
|
|
assertKernelVersion(t,
|
|
&KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0},
|
|
&KernelVersionInfo{Kernel: 2, Major: 6, Minor: 0},
|
|
1)
|
|
assertKernelVersion(t,
|
|
&KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0},
|
|
&KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0},
|
|
0)
|
|
assertKernelVersion(t,
|
|
&KernelVersionInfo{Kernel: 3, Major: 8, Minor: 5},
|
|
&KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0},
|
|
1)
|
|
assertKernelVersion(t,
|
|
&KernelVersionInfo{Kernel: 3, Major: 0, Minor: 20},
|
|
&KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0},
|
|
-1)
|
|
}
|
|
|
|
func TestParseHost(t *testing.T) {
|
|
var (
|
|
defaultHttpHost = "127.0.0.1"
|
|
defaultUnix = "/var/run/docker.sock"
|
|
)
|
|
if addr, err := ParseHost(defaultHttpHost, defaultUnix, "0.0.0.0"); err == nil {
|
|
t.Errorf("tcp 0.0.0.0 address expected error return, but err == nil, got %s", addr)
|
|
}
|
|
if addr, err := ParseHost(defaultHttpHost, defaultUnix, "tcp://"); err == nil {
|
|
t.Errorf("default tcp:// address expected error return, but err == nil, got %s", addr)
|
|
}
|
|
if addr, err := ParseHost(defaultHttpHost, defaultUnix, "0.0.0.1:5555"); err != nil || addr != "tcp://0.0.0.1:5555" {
|
|
t.Errorf("0.0.0.1:5555 -> expected tcp://0.0.0.1:5555, got %s", addr)
|
|
}
|
|
if addr, err := ParseHost(defaultHttpHost, defaultUnix, ":6666"); err != nil || addr != "tcp://127.0.0.1:6666" {
|
|
t.Errorf(":6666 -> expected tcp://127.0.0.1:6666, got %s", addr)
|
|
}
|
|
if addr, err := ParseHost(defaultHttpHost, defaultUnix, "tcp://:7777"); err != nil || addr != "tcp://127.0.0.1:7777" {
|
|
t.Errorf("tcp://:7777 -> expected tcp://127.0.0.1:7777, got %s", addr)
|
|
}
|
|
if addr, err := ParseHost(defaultHttpHost, defaultUnix, ""); err != nil || addr != "unix:///var/run/docker.sock" {
|
|
t.Errorf("empty argument -> expected unix:///var/run/docker.sock, got %s", addr)
|
|
}
|
|
if addr, err := ParseHost(defaultHttpHost, defaultUnix, "unix:///var/run/docker.sock"); err != nil || addr != "unix:///var/run/docker.sock" {
|
|
t.Errorf("unix:///var/run/docker.sock -> expected unix:///var/run/docker.sock, got %s", addr)
|
|
}
|
|
if addr, err := ParseHost(defaultHttpHost, defaultUnix, "unix://"); err != nil || addr != "unix:///var/run/docker.sock" {
|
|
t.Errorf("unix:///var/run/docker.sock -> expected unix:///var/run/docker.sock, got %s", addr)
|
|
}
|
|
if addr, err := ParseHost(defaultHttpHost, defaultUnix, "udp://127.0.0.1"); err == nil {
|
|
t.Errorf("udp protocol address expected error return, but err == nil. Got %s", addr)
|
|
}
|
|
if addr, err := ParseHost(defaultHttpHost, defaultUnix, "udp://127.0.0.1:2375"); err == nil {
|
|
t.Errorf("udp protocol address expected error return, but err == nil. Got %s", addr)
|
|
}
|
|
}
|
|
|
|
func TestParseRepositoryTag(t *testing.T) {
|
|
if repo, tag := ParseRepositoryTag("root"); repo != "root" || tag != "" {
|
|
t.Errorf("Expected repo: '%s' and tag: '%s', got '%s' and '%s'", "root", "", repo, tag)
|
|
}
|
|
if repo, tag := ParseRepositoryTag("root:tag"); repo != "root" || tag != "tag" {
|
|
t.Errorf("Expected repo: '%s' and tag: '%s', got '%s' and '%s'", "root", "tag", repo, tag)
|
|
}
|
|
if repo, tag := ParseRepositoryTag("user/repo"); repo != "user/repo" || tag != "" {
|
|
t.Errorf("Expected repo: '%s' and tag: '%s', got '%s' and '%s'", "user/repo", "", repo, tag)
|
|
}
|
|
if repo, tag := ParseRepositoryTag("user/repo:tag"); repo != "user/repo" || tag != "tag" {
|
|
t.Errorf("Expected repo: '%s' and tag: '%s', got '%s' and '%s'", "user/repo", "tag", repo, tag)
|
|
}
|
|
if repo, tag := ParseRepositoryTag("url:5000/repo"); repo != "url:5000/repo" || tag != "" {
|
|
t.Errorf("Expected repo: '%s' and tag: '%s', got '%s' and '%s'", "url:5000/repo", "", repo, tag)
|
|
}
|
|
if repo, tag := ParseRepositoryTag("url:5000/repo:tag"); repo != "url:5000/repo" || tag != "tag" {
|
|
t.Errorf("Expected repo: '%s' and tag: '%s', got '%s' and '%s'", "url:5000/repo", "tag", repo, tag)
|
|
}
|
|
}
|
|
|
|
func TestCheckLocalDns(t *testing.T) {
|
|
for resolv, result := range map[string]bool{`# Dynamic
|
|
nameserver 10.0.2.3
|
|
search dotcloud.net`: false,
|
|
`# Dynamic
|
|
#nameserver 127.0.0.1
|
|
nameserver 10.0.2.3
|
|
search dotcloud.net`: false,
|
|
`# Dynamic
|
|
nameserver 10.0.2.3 #not used 127.0.1.1
|
|
search dotcloud.net`: false,
|
|
`# Dynamic
|
|
#nameserver 10.0.2.3
|
|
#search dotcloud.net`: true,
|
|
`# Dynamic
|
|
nameserver 127.0.0.1
|
|
search dotcloud.net`: true,
|
|
`# Dynamic
|
|
nameserver 127.0.1.1
|
|
search dotcloud.net`: true,
|
|
`# Dynamic
|
|
`: true,
|
|
``: true,
|
|
} {
|
|
if CheckLocalDns([]byte(resolv)) != result {
|
|
t.Fatalf("Wrong local dns detection: {%s} should be %v", resolv, result)
|
|
}
|
|
}
|
|
}
|
|
|
|
func assertParseRelease(t *testing.T, release string, b *KernelVersionInfo, result int) {
|
|
var (
|
|
a *KernelVersionInfo
|
|
)
|
|
a, _ = ParseRelease(release)
|
|
|
|
if r := CompareKernelVersion(a, b); r != result {
|
|
t.Fatalf("Unexpected kernel version comparison result. Found %d, expected %d", r, result)
|
|
}
|
|
if a.Flavor != b.Flavor {
|
|
t.Fatalf("Unexpected parsed kernel flavor. Found %s, expected %s", a.Flavor, b.Flavor)
|
|
}
|
|
}
|
|
|
|
func TestParseRelease(t *testing.T) {
|
|
assertParseRelease(t, "3.8.0", &KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0}, 0)
|
|
assertParseRelease(t, "3.4.54.longterm-1", &KernelVersionInfo{Kernel: 3, Major: 4, Minor: 54, Flavor: ".longterm-1"}, 0)
|
|
assertParseRelease(t, "3.4.54.longterm-1", &KernelVersionInfo{Kernel: 3, Major: 4, Minor: 54, Flavor: ".longterm-1"}, 0)
|
|
assertParseRelease(t, "3.8.0-19-generic", &KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0, Flavor: "-19-generic"}, 0)
|
|
assertParseRelease(t, "3.12.8tag", &KernelVersionInfo{Kernel: 3, Major: 12, Minor: 8, Flavor: "tag"}, 0)
|
|
assertParseRelease(t, "3.12-1-amd64", &KernelVersionInfo{Kernel: 3, Major: 12, Minor: 0, Flavor: "-1-amd64"}, 0)
|
|
}
|
|
|
|
func TestParsePortMapping(t *testing.T) {
|
|
data, err := PartParser("ip:public:private", "192.168.1.1:80:8080")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if len(data) != 3 {
|
|
t.FailNow()
|
|
}
|
|
if data["ip"] != "192.168.1.1" {
|
|
t.Fail()
|
|
}
|
|
if data["public"] != "80" {
|
|
t.Fail()
|
|
}
|
|
if data["private"] != "8080" {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestReplaceAndAppendEnvVars(t *testing.T) {
|
|
var (
|
|
d = []string{"HOME=/"}
|
|
o = []string{"HOME=/root", "TERM=xterm"}
|
|
)
|
|
|
|
env := ReplaceOrAppendEnvValues(d, o)
|
|
if len(env) != 2 {
|
|
t.Fatalf("expected len of 2 got %d", len(env))
|
|
}
|
|
if env[0] != "HOME=/root" {
|
|
t.Fatalf("expected HOME=/root got '%s'", env[0])
|
|
}
|
|
if env[1] != "TERM=xterm" {
|
|
t.Fatalf("expected TERM=xterm got '%s'", env[1])
|
|
}
|
|
}
|
|
|
|
// Reading a symlink to a directory must return the directory
|
|
func TestReadSymlinkedDirectoryExistingDirectory(t *testing.T) {
|
|
var err error
|
|
if err = os.Mkdir("/tmp/testReadSymlinkToExistingDirectory", 0777); err != nil {
|
|
t.Errorf("failed to create directory: %s", err)
|
|
}
|
|
|
|
if err = os.Symlink("/tmp/testReadSymlinkToExistingDirectory", "/tmp/dirLinkTest"); err != nil {
|
|
t.Errorf("failed to create symlink: %s", err)
|
|
}
|
|
|
|
var path string
|
|
if path, err = ReadSymlinkedDirectory("/tmp/dirLinkTest"); err != nil {
|
|
t.Fatalf("failed to read symlink to directory: %s", err)
|
|
}
|
|
|
|
if path != "/tmp/testReadSymlinkToExistingDirectory" {
|
|
t.Fatalf("symlink returned unexpected directory: %s", path)
|
|
}
|
|
|
|
if err = os.Remove("/tmp/testReadSymlinkToExistingDirectory"); err != nil {
|
|
t.Errorf("failed to remove temporary directory: %s", err)
|
|
}
|
|
|
|
if err = os.Remove("/tmp/dirLinkTest"); err != nil {
|
|
t.Errorf("failed to remove symlink: %s", err)
|
|
}
|
|
}
|
|
|
|
// Reading a non-existing symlink must fail
|
|
func TestReadSymlinkedDirectoryNonExistingSymlink(t *testing.T) {
|
|
var path string
|
|
var err error
|
|
if path, err = ReadSymlinkedDirectory("/tmp/test/foo/Non/ExistingPath"); err == nil {
|
|
t.Fatalf("error expected for non-existing symlink")
|
|
}
|
|
|
|
if path != "" {
|
|
t.Fatalf("expected empty path, but '%s' was returned", path)
|
|
}
|
|
}
|
|
|
|
// Reading a symlink to a file must fail
|
|
func TestReadSymlinkedDirectoryToFile(t *testing.T) {
|
|
var err error
|
|
var file *os.File
|
|
|
|
if file, err = os.Create("/tmp/testReadSymlinkToFile"); err != nil {
|
|
t.Fatalf("failed to create file: %s", err)
|
|
}
|
|
|
|
file.Close()
|
|
|
|
if err = os.Symlink("/tmp/testReadSymlinkToFile", "/tmp/fileLinkTest"); err != nil {
|
|
t.Errorf("failed to create symlink: %s", err)
|
|
}
|
|
|
|
var path string
|
|
if path, err = ReadSymlinkedDirectory("/tmp/fileLinkTest"); err == nil {
|
|
t.Fatalf("ReadSymlinkedDirectory on a symlink to a file should've failed")
|
|
}
|
|
|
|
if path != "" {
|
|
t.Fatalf("path should've been empty: %s", path)
|
|
}
|
|
|
|
if err = os.Remove("/tmp/testReadSymlinkToFile"); err != nil {
|
|
t.Errorf("failed to remove file: %s", err)
|
|
}
|
|
|
|
if err = os.Remove("/tmp/fileLinkTest"); err != nil {
|
|
t.Errorf("failed to remove symlink: %s", err)
|
|
}
|
|
}
|