func TestRunningK8sDataDaemonsets(t *testing.T) {
c := getK8sClientForDaemonSets(t)
deisK8sResources := NewResourceInterfaceNamespaced(c, namespace)
runningK8sData := NewRunningK8sData(deisK8sResources)
daemonsets, err := runningK8sData.DaemonSets()
assert.NoErr(t, err)
assert.True(t, len(daemonsets) == 2, "daemonsets response slice was not the expected length")
assert.True(t, daemonsets[0].Data != daemonsets[1].Data, "daemonsets should not be identical")
}
func TestRunningK8sDataNodes(t *testing.T) {
c := getK8sClientForNodes(t)
deisK8sResources := NewResourceInterfaceNamespaced(c, namespace)
runningK8sData := NewRunningK8sData(deisK8sResources)
nodes, err := runningK8sData.Nodes()
assert.NoErr(t, err)
assert.True(t, len(nodes) == 3, "nodes response slice was not the expected length")
assert.True(t, nodes[0].Data != nodes[1].Data, "nodes should not be identical")
}
func TestRunningK8sDataPods(t *testing.T) {
c := getK8sClientForPods(t)
deisK8sResources := NewResourceInterfaceNamespaced(c, namespace)
runningK8sData := NewRunningK8sData(deisK8sResources)
pods, err := runningK8sData.Pods()
assert.NoErr(t, err)
assert.True(t, len(pods) == 2, "pods response slice was not the expected length")
assert.True(t, pods[0].Data != pods[1].Data, "pods should not be identical")
}
func TestRunningK8sDataReplicationControllers(t *testing.T) {
c := getK8sClientForReplicationControllers(t)
deisK8sResources := NewResourceInterfaceNamespaced(c, namespace)
runningK8sData := NewRunningK8sData(deisK8sResources)
rcs, err := runningK8sData.ReplicationControllers()
assert.NoErr(t, err)
assert.True(t, len(rcs) == 2, "rc response slice was not the expected length")
assert.True(t, rcs[0].Data != rcs[1].Data, "rcs should not be identical")
}
func TestRunningK8sDataServices(t *testing.T) {
c := getK8sClientForServices(t)
//_, _ = c.Setup(t).Services(namespace).List(api.ListOptions{})
deisK8sResources := NewResourceInterfaceNamespaced(c, namespace)
runningK8sData := NewRunningK8sData(deisK8sResources)
services, err := runningK8sData.Services()
assert.NoErr(t, err)
assert.True(t, len(services) == 2, "services response slice was not the expected length")
assert.True(t, services[0].Data != services[1].Data, "services should not be identical")
}
func TestDoPeriodic(t *testing.T) {
interval := time.Duration(3000) * time.Millisecond
p := &testPeriodic{t: t, err: nil, freq: interval}
closeCh1 := DoPeriodic([]Periodic{p})
time.Sleep(interval / 2) // wait a little while for the goroutine to call the job once
assert.True(t, p.i == 1, "the periodic wasn't called once")
time.Sleep(interval)
assert.True(t, p.i == 2, "the periodic wasn't called twice")
time.Sleep(interval)
assert.True(t, p.i == 3, "the periodic wasn't called thrice")
close(closeCh1)
}
func TestWaitForObjectMissing(t *testing.T) {
statter := &FakeObjectStatter{
Fn: func(context.Context, string) (storagedriver.FileInfo, error) {
return storagedriver.FileInfoInternal{FileInfoFields: storagedriver.FileInfoFields{}}, storagedriver.PathNotFoundError{Path: objPath}
},
}
err := WaitForObject(statter, objPath, 1*time.Millisecond, 2*time.Millisecond)
assert.True(t, err != nil, "no error received when there should have been")
// it should make 1 call immediately, then calls at 1ms and 2ms
assert.True(
t,
len(statter.Calls) >= 1,
"the statter was not called, but should have been called at least once",
)
}
func TestParse(t *testing.T) {
//TODO: use gogenerate to generate valid html templates
//http://godoc.org/github.com/arschles/gogenerate
tmpl := `
<html>
<head>
<title>hello {{.name}}</title>
</head>
<body>
{{.greeting}}
</body>
</html>
`
fileName := "mytmpl.tmpl"
tmplBytes := []byte(tmpl)
expectedErr := errors.New("template not found")
assetFunc := createValidAssetFunc(fileName, tmplBytes, expectedErr)
tmpl1, err1 := New("test", assetFunc).Parse(fileName)
assert.NoErr(t, err1)
assert.False(t, tmpl1 == nil, "tmpl1 was nil when it should not have been")
tmpl2, err2 := New("test1", assetFunc).Parse(fileName + fileName)
assert.Err(t, err2, expectedErr)
assert.True(t, tmpl2 == nil, "tmpl2 was not nil when it should have been")
//TODO: check actual template output
name := "Aaron"
tmplData := map[string]string{
"name": name,
}
buf1 := bytes.NewBuffer([]byte{})
executeErr1 := tmpl1.Execute(buf1, tmplData)
stdTmpl, stdTmplParseErr := template.New("referenceTest").Parse(tmpl)
assert.NoErr(t, stdTmplParseErr)
buf2 := bytes.NewBuffer([]byte{})
executeErr2 := stdTmpl.Execute(buf2, tmplData)
assert.NoErr(t, executeErr1)
assert.NoErr(t, executeErr2)
bytes1 := buf1.Bytes()
bytes2 := buf2.Bytes()
assert.True(t,
string(bytes1) == string(bytes2),
"actual template output %s is not equal expected %s", string(bytes1), string(bytes2))
}
func TestCollectEnv(t *testing.T) {
envMap := collectEnv()
pwd, ok := envMap["PWD"]
assert.True(t, ok, "'PWD' not found in the env")
wd, err := os.Getwd()
assert.NoErr(t, err)
assert.Equal(t, pwd, wd, "working dir")
}
func TestGitPktLine(t *testing.T) {
b := new(bytes.Buffer)
str := "hello world"
err := gitPktLine(b, str)
assert.NoErr(t, err)
outStr := string(b.Bytes())
assert.True(t, len(outStr) > 4, "output string <= 4 chars")
assert.Equal(t, outStr[:4], fmt.Sprintf("%04x", len(str)+4), "hex prefix")
assert.Equal(t, outStr[4:], str, "remainder of string")
}
func TestGetProcFileFromServerFailure(t *testing.T) {
expectedErr := errors.New("test error")
getter := &storage.FakeObjectGetter{
Fn: func(context.Context, string) ([]byte, error) {
return []byte("web: example-go"), expectedErr
},
}
_, err := getProcFile(getter, "", objKey, buildTypeProcfile)
assert.Err(t, err, fmt.Errorf("error in reading %s (%s)", objKey, expectedErr))
assert.True(t, err != nil, "no error received when there should have been")
}
func TestSuccessfulRoundTrip(t *testing.T) {
mut := new(sync.Mutex)
lockID := NewLockID()
router := mux.NewRouter()
registerLockHandler(router, mut, lockID)
registerUnlockHandler(router, mut, lockID)
w := httptest.NewRecorder()
r, err := http.NewRequest("POST", "/lock", bytes.NewReader(nil))
assert.NoErr(t, err)
router.ServeHTTP(w, r)
assert.Equal(t, w.Code, http.StatusOK, "response code")
idStr := string(w.Body.Bytes())
assert.True(t, len(idStr) > 0, "returned lock ID was empty")
assert.True(t, lockID.Equals(idStr), fmt.Sprintf("internal lock ID (%s) was not equal returned lock ID (%s)", lockID.id, idStr))
w = httptest.NewRecorder()
r, err = http.NewRequest("DELETE", "/lock/"+idStr, bytes.NewReader(nil))
assert.NoErr(t, err)
router.ServeHTTP(w, r)
assert.Equal(t, w.Code, http.StatusOK, "response code")
}
func TestObjectExistsSuccess(t *testing.T) {
objInfo := storagedriver.FileInfoInternal{storagedriver.FileInfoFields{Path: objPath, Size: 1234}}
statter := &FakeObjectStatter{
Fn: func(context.Context, string) (storagedriver.FileInfo, error) {
return objInfo, nil
},
}
exists, err := ObjectExists(statter, objPath)
assert.NoErr(t, err)
assert.True(t, exists, "object not found when it should be present")
assert.Equal(t, len(statter.Calls), 1, "number of StatObject calls")
assert.Equal(t, statter.Calls[0].Path, objPath, "object key")
}
// TestConcurrentPushSameRepo tests many concurrent pushes, each to the same repo
func TestConcurrentPushSameRepo(t *testing.T) {
const testingServerAddr = "127.0.0.1:2245"
key, err := sshTestingHostKey()
assert.NoErr(t, err)
cfg, err := serverConfigure()
assert.NoErr(t, err)
cfg.AddHostKey(key)
c := NewCircuit()
pushLock := NewInMemoryRepositoryLock(500 * time.Millisecond)
runServer(cfg, c, pushLock, testingServerAddr, 2*time.Second, t)
// Give server time to initialize.
time.Sleep(200 * time.Millisecond)
assert.Equal(t, c.State(), ClosedState, "circuit state")
// Connect to the server and issue env var set. This should return true.
client, err := ssh.Dial("tcp", testingServerAddr, clientConfig())
assert.NoErr(t, err)
const numPushers = 4
outCh := make(chan *sshSessionOutput, numPushers)
for i := 0; i < numPushers; i++ {
go func() {
sess, newSessErr := client.NewSession()
assert.NoErr(t, newSessErr)
defer sess.Close()
out, outErr := sess.Output("git-upload-pack /demo.git")
outCh <- &sshSessionOutput{outStr: string(out), err: outErr}
}()
}
// ensure at least 1 output was successful
foundOK := false
to := 1 * time.Second
for i := 0; i < numPushers; i++ {
select {
case sessOut := <-outCh:
if sessOut.outStr == "OK" {
foundOK = true
}
case <-time.After(to):
t.Fatalf("didn't receive an output within %s", to)
}
}
assert.True(t, foundOK, "no SSH requests were successful")
}
func TestMultipleSameRepoLocks(t *testing.T) {
var wg sync.WaitGroup
const repo = "repo1"
const numTries = 100
lck := NewInMemoryRepositoryLock()
assert.NoErr(t, lck.Lock(repo, 0*time.Second))
for i := 0; i < numTries; i++ {
wg.Add(1)
go func() {
defer wg.Done()
assert.True(t, lck.Lock(repo, 0*time.Second) != nil, "lock of already locked repo should return error")
}()
}
assert.NoErr(t, waitWithTimeout(&wg, 1*time.Second))
assert.NoErr(t, lck.Unlock(repo, 0*time.Second))
for i := 0; i < numTries; i++ {
wg.Add(1)
go func() {
defer wg.Done()
assert.True(t, lck.Unlock(repo, 0*time.Second) != nil, "unlock of already unlocked repo should return error")
}()
}
assert.NoErr(t, waitWithTimeout(&wg, 1*time.Second))
}
func TestGetFiles(t *testing.T) {
dir, err := tests.DataDir()
assert.NoErr(t, err)
files, err := getFiles(dir)
assert.NoErr(t, err)
expected := tests.ExpectedDataSlice()
set := map[string]struct{}{}
for _, file := range files {
set[file] = struct{}{}
}
for _, ex := range expected {
_, ok := set[ex]
assert.True(t, ok, "file %s was not found", ex)
}
}
func TestGetProcFileFromRepoFailure(t *testing.T) {
tmpDir, err := ioutil.TempDir("", "tmpdir")
if err != nil {
t.Fatalf("error creating temp directory (%s)", err)
}
data := []byte("web= example-go")
if err := ioutil.WriteFile(tmpDir+"/Procfile", data, 0644); err != nil {
t.Fatalf("error creating %s/Procfile (%s)", tmpDir, err)
}
defer func() {
if err := os.RemoveAll(tmpDir); err != nil {
t.Fatalf("failed to remove Procfile from %s (%s)", tmpDir, err)
}
}()
getter := &storage.FakeObjectGetter{}
_, err = getProcFile(getter, tmpDir, objKey, buildTypeProcfile)
assert.True(t, err != nil, "no error received when there should have been")
}
func TestBooleans(t *testing.T) {
assert.True(t, true, "boolean true")
assert.False(t, false, "boolean false")
}
func TestGetBuilderKeyError(t *testing.T) {
_, err := GetBuilderKey()
assert.True(t, err != nil, "no error received when there should have been")
}
func TestNewWithInvalidBuilderKeyPath(t *testing.T) {
host := "127.0.0.1"
port := "80"
_, err := New(host, port)
assert.True(t, err != nil, "no error received when there should have been")
}
func TestDirHasGitSuffix(t *testing.T) {
assert.True(t, dirHasGitSuffix("a.git"), "'a.git' reported no git suffix")
assert.False(t, dirHasGitSuffix("abc"), "'a' reported git suffix")
}
