func TestUserDocker(t *testing.T) {
assert := require.New(t)
config := &CloudConfig{
Rancher: RancherConfig{
UserDocker: DockerConfig{
TLS: true,
},
},
}
bytes, err := yaml.Marshal(config)
assert.Nil(err)
config = NewConfig()
err = yaml.Unmarshal(bytes, config)
assert.Nil(err)
data := make(map[interface{}]map[interface{}]interface{})
util.Convert(config, data)
fmt.Println(data)
val, ok := data["rancher"]["user_docker"]
assert.True(ok)
m, ok := val.(map[interface{}]interface{})
assert.True(ok)
v, ok := m["tls"]
assert.True(ok)
assert.True(v.(bool))
}
// Tests the flow of AddMetricToMap where the metric name is not present in the map
func TestAddMetricToMapNewKey(t *testing.T) {
var (
cluster = newRealModel(time.Minute)
metrics = make(map[string]*daystore.DayStore)
new_metric_name = "name_not_in_map"
stamp = time.Now().Round(cluster.resolution)
zeroTime = time.Time{}
value = uint64(1234567890)
assert = assert.New(t)
require = require.New(t)
)
// First Call: Add a new metric to the map
assert.NoError(cluster.addMetricToMap(new_metric_name, stamp, value, metrics))
// Second Call: Add a second metric to the map on a later time. Flushes previous metric.
assert.NoError(cluster.addMetricToMap(new_metric_name, stamp.Add(time.Minute), value, metrics))
new_ts := *metrics[new_metric_name]
results := new_ts.Hour.Get(zeroTime, zeroTime)
require.Len(results, 2)
assert.Equal(results[0].Timestamp, stamp.Add(time.Minute))
assert.Equal(roundToEpsilon(results[0].Value, defaultEpsilon), roundToEpsilon(value, defaultEpsilon))
assert.Equal(results[1].Timestamp, stamp)
assert.Equal(roundToEpsilon(results[1].Value, defaultEpsilon), roundToEpsilon(value, defaultEpsilon))
// Second Call: addMetricToMap for a new key, cause TimeStore failure
assert.NoError(cluster.addMetricToMap("other_metric", stamp, value, metrics))
assert.Error(cluster.addMetricToMap("other_metric", stamp.Add(-time.Minute), value, metrics))
}
func Test_Column_MapsSlice(t *testing.T) {
r := require.New(t)
c1 := columns.ColumnsForStruct(&foo{}, "foo")
c2 := columns.ColumnsForStruct(&foos{}, "foo")
r.Equal(c1.String(), c2.String())
}
func TestGet(t *testing.T) {
assert := require.New(t)
data := map[interface{}]interface{}{
"key": "value",
"rancher": map[interface{}]interface{}{
"key2": map[interface{}]interface{}{
"subkey": "subvalue",
"subnum": 42,
},
},
}
tests := map[string]interface{}{
"key": "value",
"rancher.key2.subkey": "subvalue",
"rancher.key2.subnum": 42,
"rancher.key2.subkey2": "",
"foo": "",
}
for k, v := range tests {
assert.Equal(v, getOrSetVal(k, data, nil))
}
}
func Test_Request_URL_Params(t *testing.T) {
r := require.New(t)
w := willy.New(App())
req := w.Request("/foo?a=%s&b=%s", "A", "B")
r.Equal("/foo?a=A&b=B", req.URL)
}
// TestCli runs tests on the zest Cli and SetCli methods.
func TestCli(t *testing.T) {
a := assert.New(t)
r := require.New(t)
zest := New()
r.NotPanics(func() { _ = zest.Cli() })
cli := zest.Cli()
cli.Name = "foobar"
zest.SetCli(cli)
r.NotPanics(func() { _ = zest.Cli() })
cli = zest.Cli()
a.Equal("foobar", cli.Name)
zest = Classic() // should also work with the Classic zest
r.NotPanics(func() { _ = zest.Cli() })
cli = zest.Cli()
cli.Name = "foobar"
zest.SetCli(cli)
r.NotPanics(func() { _ = zest.Cli() })
cli = zest.Cli()
a.Equal("foobar", cli.Name)
}
// TestRegister runs tests on the syringe Register method.
func TestRegister(t *testing.T) {
a := assert.New(t)
r := require.New(t)
syringe := New()
deps := []interface{}{
newDep1,
newDep2,
}
syringe.Register(deps)
r.NotPanics(func() { _ = syringe.deps[0]; _ = syringe.deps[1] })
a.IsType(newDep1, syringe.deps[0])
a.IsType(newDep2, syringe.deps[1])
syringe.Register(newDep3, newDep4)
r.NotPanics(func() { _ = syringe.deps[2]; _ = syringe.deps[3] })
a.IsType(newDep3, syringe.deps[2])
a.IsType(newDep4, syringe.deps[3])
syringe.Register(newDep4)
r.NotPanics(func() { _ = syringe.deps[4] })
a.IsType(newDep4, syringe.deps[4])
syringe.Register(newDep4())
r.NotPanics(func() { _ = syringe.deps[5] })
a.IsType(&dep4{}, syringe.deps[5])
}
//
//
// Unit TestCases
//
//
func TestIsPrefixHeader(t *testing.T) {
assert := require.New(t)
tests := map[string]bool{
"$": false,
"#header 1": true,
"# header 1": true,
"#######header 7": true,
}
p := new(parser)
for key, value := range tests {
assert.Equal(p.isPrefixHeader([]byte(key)), value)
}
testsExtSpaceHeader := map[string]bool{
"$": false,
"# ": true,
"#header 1": false,
"####### header 7": false,
"# header 1": true,
"### header 3": true,
"# he": true,
}
p1 := new(parser)
p1.flags |= EXTENSION_SPACE_HEADERS
for key, value := range testsExtSpaceHeader {
assert.Equal(p1.isPrefixHeader([]byte(key)), value)
}
}
func TestParseCmdline(t *testing.T) {
assert := require.New(t)
expected := map[interface{}]interface{}{
"rancher": map[interface{}]interface{}{
"rescue": true,
"key1": "value1",
"key2": "value2",
"keyArray": []interface{}{int64(1), int64(2)},
"obj1": map[interface{}]interface{}{
"key3": "3value",
"obj2": map[interface{}]interface{}{
"key4": true,
},
},
"key5": int64(5),
"key6": "a,b",
"key7": "a\nb",
},
}
actual := parseCmdline("a b rancher.rescue rancher.keyArray=[1,2] rancher.key1=value1 c rancher.key2=value2 rancher.obj1.key3=3value rancher.obj1.obj2.key4 rancher.key5=5 rancher.key6=a,b rancher.key7=a\nb")
assert.Equal(expected, actual)
}
func TestRepo(t *testing.T) {
scenarios.Load(tdb.StellarCoreURL(), "base-core.sql")
assert := assert.New(t)
require := require.New(t)
repo := &Repo{DB: tdb.StellarCore()}
var count int
err := repo.GetRaw(&count, "SELECT COUNT(*) FROM txhistory")
assert.NoError(err)
assert.Equal(4, count)
var ids []string
err = repo.SelectRaw(&ids, "SELECT txid FROM txhistory")
assert.NoError(err)
assert.Len(ids, 4)
ret, err := repo.ExecRaw("DELETE FROM txhistory")
assert.NoError(err)
deleted, err := ret.RowsAffected()
assert.NoError(err)
assert.Equal(int64(4), deleted)
// Test args
var hash string
err = repo.GetRaw(&hash, "SELECT prevhash FROM ledgerheaders WHERE ledgerseq = ?", 1)
assert.NoError(err)
assert.Equal("0000000000000000000000000000000000000000000000000000000000000000", hash)
// Test NoRows
err = repo.GetRaw(&hash, "SELECT prevhash FROM ledgerheaders WHERE ledgerseq = ?", 100)
assert.True(repo.NoRows(err))
// Test transactions
require.NoError(repo.Begin(), "begin failed")
err = repo.GetRaw(&count, "SELECT COUNT(*) FROM ledgerheaders")
assert.NoError(err)
assert.Equal(3, count)
_, err = repo.ExecRaw("DELETE FROM ledgerheaders")
assert.NoError(err)
err = repo.GetRaw(&count, "SELECT COUNT(*) FROM ledgerheaders")
assert.NoError(err)
assert.Equal(0, count, "Ledgers did not appear deleted inside transaction")
assert.NoError(repo.Rollback(), "rollback failed")
// Ensure commit works
require.NoError(repo.Begin(), "begin failed")
repo.ExecRaw("DELETE FROM ledgerheaders")
assert.NoError(repo.Commit(), "commit failed")
err = repo.GetRaw(&count, "SELECT COUNT(*) FROM ledgerheaders")
assert.NoError(err)
assert.Equal(0, count)
// ensure that selecting into a populated slice clears the slice first
scenarios.Load(tdb.StellarCoreURL(), "base-core.sql")
require.Len(ids, 4, "ids slice was not preloaded with data")
err = repo.SelectRaw(&ids, "SELECT txid FROM txhistory limit 2")
assert.NoError(err)
assert.Len(ids, 2)
}
func Test_WillieSessions(t *testing.T) {
r := require.New(t)
w := willie.New(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer context.Clear(req)
sess, _ := Store.Get(req, "my-session")
t := sess.Values["foo"]
fmt.Printf("t: %s\n", t)
if t != nil {
res.WriteHeader(200)
fmt.Fprint(res, t)
} else {
sess.Values["foo"] = "bar"
sess.Save(req, res)
res.WriteHeader(201)
fmt.Fprint(res, "setting session")
}
}))
res := w.Get("/", nil)
r.Equal(201, res.Code)
r.Equal("setting session", res.Body.String())
res = w.Get("/", nil)
r.Equal(200, res.Code)
r.Equal("bar", res.Body.String())
}
func TestTests_Detail_OK(t *testing.T) {
assert := assert.New(t)
require := require.New(t)
c := &fakeAPIClient{
fixture: "tests_detail_ok.json",
}
tt := newTests(c)
test, err := tt.Detail(1234)
require.Nil(err)
assert.Equal("/Tests/Details", c.sentRequestPath)
assert.Equal("GET", c.sentRequestMethod)
assert.Equal(url.Values{"TestID": {"1234"}}, c.sentRequestValues)
assert.Equal(test.TestID, 6735)
assert.Equal(test.TestType, "HTTP")
assert.Equal(test.Paused, false)
assert.Equal(test.WebsiteName, "NL")
assert.Equal(test.ContactID, 536)
assert.Equal(test.Status, "Up")
assert.Equal(test.Uptime, 0.0)
assert.Equal(test.CheckRate, 60)
assert.Equal(test.Timeout, 40)
assert.Equal(test.LogoImage, "")
assert.Equal(test.WebsiteHost, "Various")
assert.Equal(test.FindString, "")
assert.Equal(test.DoNotFind, false)
}
func Test_Client_Save_MultiHost(t *testing.T) {
r := require.New(t)
ms := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
s := SimpleSaveable{Message: "Primary"}
json.NewEncoder(w).Encode(s)
w.WriteHeader(200)
}))
defer ms.Close()
ss := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
s := SimpleSaveable{Message: "Slave"}
json.NewEncoder(w).Encode(s)
w.WriteHeader(404)
}))
defer ms.Close()
c, err := client.New([]*client.Host{
{URL: ms.URL, Primary: true},
{URL: ss.URL},
})
r.NoError(err)
s := &SimpleSaveable{}
res, err := c.Save(s)
r.NoError(err)
r.Equal(200, res.StatusCode)
r.Equal("Primary", s.Message)
}
func Test_New_RespectsPrimary(t *testing.T) {
r := require.New(t)
c, err := client.New([]*client.Host{{}, {Primary: true}})
r.NoError(err)
r.False(c.Hosts[0].Primary)
r.True(c.Hosts[1].Primary)
}
func TestSoftRequirementsValidationSuccess(t *testing.T) {
req := require.New(t)
tempDir, err := ioutil.TempDir("", "")
req.NoError(err)
req.NoError(ioutil.WriteFile(path.Join(tempDir, "cpu.cfs_period_us"), []byte("0"), os.ModePerm))
req.NoError(ioutil.WriteFile(path.Join(tempDir, "cpu.cfs_quota_us"), []byte("0"), os.ModePerm))
mountInt := &fakeMountInterface{
[]mount.MountPoint{
{
Device: "cgroup",
Type: "cgroup",
Opts: []string{"rw", "relatime", "cpuset"},
},
{
Device: "cgroup",
Type: "cgroup",
Opts: []string{"rw", "relatime", "cpu"},
Path: tempDir,
},
{
Device: "cgroup",
Type: "cgroup",
Opts: []string{"rw", "relatime", "cpuacct", "memory"},
},
},
}
f, err := validateSystemRequirements(mountInt)
assert.NoError(t, err)
assert.True(t, f.cpuHardcapping, "cpu hardcapping is expected to be enabled")
}
func Test_Client_Register(t *testing.T) {
r := require.New(t)
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
p := client.Product{Token: "token", Secret: "secret"}
json.NewEncoder(w).Encode(p)
w.WriteHeader(200)
}))
defer ts.Close()
h := &client.Host{URL: ts.URL, Primary: true}
c, err := client.New([]*client.Host{h})
r.NoError(err)
p := &client.Product{}
res, err := c.Register(p)
r.NoError(err)
r.Equal(200, res.StatusCode)
r.Equal("token", p.Token)
r.Equal("secret", p.Secret)
r.Equal("token", h.Token)
r.Equal("secret", h.SecretKey)
}
func Test_Pagination(t *testing.T) {
transaction(func(tx *pop.Connection) {
a := require.New(t)
for _, name := range []string{"Mark", "Joe", "Jane"} {
user := User{Name: nulls.NewString(name)}
err := tx.Create(&user)
a.NoError(err)
}
u := Users{}
q := tx.Paginate(1, 2)
err := q.All(&u)
a.NoError(err)
a.Equal(len(u), 2)
p := q.Paginator
a.Equal(p.CurrentEntriesSize, 2)
a.Equal(p.TotalEntriesSize, 3)
a.Equal(p.TotalPages, 2)
u = Users{}
err = tx.Where("name = 'Mark'").All(&u)
a.NoError(err)
a.Equal(reflect.ValueOf(&u).Elem().Len(), 1)
})
}
func TestMapsUnion(t *testing.T) {
assert := require.New(t)
m0 := map[interface{}]interface{}{
"a": 1,
"b": map[interface{}]interface{}{"c": 3},
"d": "4",
"f": []interface{}{1, 2, 3},
}
m1 := MapCopy(m0)
m1["e"] = "added"
m1["d"] = "replaced"
m1["f"] = []interface{}{2, 3, 4}
delete(m0, "a")
b1 := m1["b"].(map[interface{}]interface{})
delete(b1, "c")
expected := map[interface{}]interface{}{
"a": 1,
"b": map[interface{}]interface{}{"c": 3},
"d": "replaced",
"e": "added",
"f": []interface{}{2, 3, 4},
}
assert.Equal(expected, MapsUnion(m0, m1))
}
func TestMapsDifference(t *testing.T) {
assert := require.New(t)
m0 := map[interface{}]interface{}{
"a": 1,
"b": map[interface{}]interface{}{"c": 3},
"d": "4",
"e": []interface{}{1, 2, 3},
}
m1 := MapCopy(m0)
assert.Equal(map[interface{}]interface{}{}, MapsDifference(m0, m0))
assert.Equal(map[interface{}]interface{}{}, MapsDifference(m0, m1))
delete(m1, "a")
b1 := m1["b"].(map[interface{}]interface{})
delete(b1, "c")
m1["e"] = []interface{}{2, 3, 4}
expectedM1M0 := map[interface{}]interface{}{"b": map[interface{}]interface{}{}, "e": []interface{}{2, 3, 4}}
assert.Equal(expectedM1M0, MapsDifference(m1, m0))
expectedM0M1 := map[interface{}]interface{}{"a": 1, "b": map[interface{}]interface{}{"c": 3}, "e": []interface{}{1, 2, 3}}
assert.Equal(expectedM0M1, MapsDifference(m0, m1))
}
func testDelete(t *testing.T) {
assert := require.New(t)
c := NewContainer(config.DOCKER_HOST, &config.ContainerConfig{
Cmd: "--rm busybox echo hi",
}).Parse()
assert.False(c.Exists())
assert.NoError(c.Err, "")
c.Start()
assert.NoError(c.Err, "")
c.Reset()
assert.NoError(c.Err, "")
assert.True(c.Exists())
assert.NoError(c.Err, "")
c.Delete()
assert.NoError(c.Err, "")
c.Reset()
assert.False(c.Exists())
assert.NoError(c.Err, "")
}
func testDockerClientNames(t *testing.T) {
assert := require.New(t)
client, err := dockerClient.NewClient(config.DOCKER_HOST)
assert.NoError(err, "")
c, err := client.CreateContainer(dockerClient.CreateContainerOptions{
Name: "foo",
Config: &dockerClient.Config{
Image: "ubuntu",
},
})
assert.NoError(err, "")
assert.Equal("foo", c.Name)
c2, err := client.InspectContainer(c.ID)
assert.NoError(err, "")
assert.Equal("/foo", c2.Name)
c2, err = inspect(client, c.ID)
assert.NoError(err, "")
assert.Equal("foo", c2.Name)
client.RemoveContainer(dockerClient.RemoveContainerOptions{
ID: c2.ID,
Force: true,
})
}
func testRollback(t *testing.T) {
assert := require.New(t)
c := NewContainer(config.DOCKER_HOST, &config.ContainerConfig{
Cmd: "--name rollback busybox echo hi",
}).Parse().Start().Lookup()
assert.NoError(c.Err, "")
assert.Equal("rollback", c.Container.Name)
c2 := NewContainer(config.DOCKER_HOST, &config.ContainerConfig{
Cmd: "--name rollback busybox echo bye",
}).Parse().Start().Lookup()
assert.Equal("rollback", c2.Container.Name)
assert.NoError(c2.Err, "")
assert.NotEqual(c.Container.ID, c2.Container.ID)
c3 := NewContainer(config.DOCKER_HOST, &config.ContainerConfig{
Cmd: "--name rollback busybox echo hi",
}).Parse().Start().Lookup()
assert.NoError(c3.Err, "")
assert.Equal(c.Container.ID, c3.Container.ID)
assert.Equal("rollback", c3.Container.Name)
c2.Reset().Lookup()
assert.NoError(c2.Err, "")
assert.True(strings.HasPrefix(c2.Container.Name, "rollback-"))
c.Delete()
c2.Delete()
}
func testLookup(t *testing.T) {
assert := require.New(t)
cfg := &config.ContainerConfig{
Cmd: "--rm busybox echo hi",
}
c := NewContainer(config.DOCKER_HOST, cfg).Parse().Start()
cfg2 := &config.ContainerConfig{
Cmd: "--rm busybox echo hi2",
}
c2 := NewContainer(config.DOCKER_HOST, cfg2).Parse().Start()
assert.NoError(c.Err, "")
assert.NoError(c2.Err, "")
c1Lookup := NewContainer(config.DOCKER_HOST, cfg).Lookup()
c2Lookup := NewContainer(config.DOCKER_HOST, cfg2).Lookup()
assert.NoError(c1Lookup.Err, "")
assert.NoError(c2Lookup.Err, "")
assert.Equal(c.Container.ID, c1Lookup.Container.ID, "")
assert.Equal(c2.Container.ID, c2Lookup.Container.ID, "")
c.Delete()
c2.Delete()
}
func testMigrateVolumes(t *testing.T) {
assert := require.New(t)
c := NewContainer(config.DOCKER_HOST, &config.ContainerConfig{
Cmd: "--name foo -v /test busybox echo hi",
}).Parse().Start().Lookup()
assert.NoError(c.Err, "")
test_path, ok := c.Container.Volumes["/test"]
assert.True(ok, "")
c2 := NewContainer(config.DOCKER_HOST, &config.ContainerConfig{
MigrateVolumes: true,
Cmd: "--name foo -v /test2 busybox echo hi",
}).Parse().Start().Lookup()
assert.NoError(c2.Err, "")
assert.True(c2.Container != nil)
_, ok = c2.Container.Volumes["/test2"]
assert.True(ok, "")
assert.Equal(test_path, c2.Container.Volumes["/test"])
c.Delete()
c2.Delete()
}
func TestParse(t *testing.T) {
assert := require.New(t)
cfg := &config.ContainerConfig{
Cmd: "--name c1 " +
"-d " +
"--rm " +
"--privileged " +
"test/image " +
"arg1 " +
"arg2 ",
}
c := NewContainer("", cfg).Parse()
assert.NoError(c.Err, "")
assert.Equal(cfg.Id, "c1", "Id doesn't match")
assert.Equal(c.Name, "c1", "Name doesn't match")
assert.True(c.remove, "Remove doesn't match")
assert.True(c.detach, "Detach doesn't match")
assert.Equal(c.Config.Cmd.Len(), 2, "Args doesn't match")
assert.Equal(c.Config.Cmd.Slice()[0], "arg1", "Arg1 doesn't match")
assert.Equal(c.Config.Cmd.Slice()[1], "arg2", "Arg2 doesn't match")
assert.True(c.HostConfig.Privileged, "Privileged doesn't match")
}
func TestConvertMergesLeftIntoRight(t *testing.T) {
assert := require.New(t)
cc0 := testCloudConfig{Key1: "k1v0", Key2: "k2v0"}
cc1 := map[interface{}]interface{}{"key1": "k1value1", "hostname": "somehost"}
Convert(cc1, &cc0)
expected := testCloudConfig{Hostname: "somehost", Key1: "k1value1", Key2: "k2v0"}
assert.Equal(expected, cc0)
}
func TestPassByValue(t *testing.T) {
assert := require.New(t)
cc0ptr := &testCloudConfig{}
cc0ptr.Hostname = "test0"
cc1 := *cc0ptr
cc1.Hostname = "test1"
assert.NotEqual(cc0ptr.Hostname, cc1.Hostname)
}
func TestListCmd(t *testing.T) {
require := require.New(t)
cmd := listCmd()
require.NotNil(cmd)
require.Equal("list", cmd.Name())
require.NotNil(cmd.RunE)
}
func Test_Columns_WriteableString_Symbolized(t *testing.T) {
r := require.New(t)
for _, f := range []interface{}{foo{}, &foo{}} {
c := columns.ColumnsForStruct(f, "foo")
u := c.Writeable().SymbolizedString()
r.Equal(u, ":LastName, :write")
}
}
func Test_Columns_UpdateString(t *testing.T) {
r := require.New(t)
for _, f := range []interface{}{foo{}, &foo{}} {
c := columns.ColumnsForStruct(f, "foo")
u := c.Writeable().UpdateString()
r.Equal(u, "LastName = :LastName, write = :write")
}
}