This is an automated email from the ASF dual-hosted git repository.
nferraro pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel-k.git
The following commit(s) were added to refs/heads/master by this push:
new 6eb9f94 Make test timeouts configurable
6eb9f94 is described below
commit 6eb9f94c6dcc7b1193374dca1e1531fb526adbc5
Author: Jan <[email protected]>
AuthorDate: Thu Feb 27 18:24:28 2020 +0100
Make test timeouts configurable
---
e2e/addons_test.go | 12 ++++++------
e2e/build_test.go | 3 +--
e2e/cron_test.go | 13 ++++++-------
e2e/dev_mode_test.go | 9 ++++-----
e2e/docker_hub_test.go | 7 +++----
e2e/github_packages_test.go | 7 +++----
e2e/global_test.go | 5 ++---
e2e/init_test.go | 5 ++---
e2e/knative_platform_test.go | 19 +++++++++----------
e2e/knative_test.go | 42 +++++++++++++++++++++---------------------
e2e/platformless_run_test.go | 5 ++---
e2e/run_test.go | 35 +++++++++++++++++------------------
e2e/test_support.go | 34 ++++++++++++++++++++++++++++++++--
e2e/upgrade_test.go | 6 +++---
14 files changed, 111 insertions(+), 91 deletions(-)
diff --git a/e2e/addons_test.go b/e2e/addons_test.go
index fca3039..01a6269 100644
--- a/e2e/addons_test.go
+++ b/e2e/addons_test.go
@@ -36,8 +36,8 @@ func TestAddons(t *testing.T) {
t.Run("master works", func(t *testing.T) {
RegisterTestingT(t)
Expect(kamel("run", "-n", ns,
"files/Master.java").Execute()).Should(BeNil())
- Eventually(integrationPodPhase(ns, "master"),
5*time.Minute).Should(Equal(v1.PodRunning))
- Eventually(integrationLogs(ns, "master"),
1*time.Minute).Should(ContainSubstring("Magicstring!"))
+ Eventually(integrationPodPhase(ns, "master"),
testTimeoutMedium).Should(Equal(v1.PodRunning))
+ Eventually(integrationLogs(ns, "master"),
testTimeoutShort).Should(ContainSubstring("Magicstring!"))
Eventually(configMap(ns, "master-lock"),
30*time.Second).ShouldNot(BeNil())
Expect(kamel("delete", "--all", "-n",
ns).Execute()).Should(BeNil())
})
@@ -50,8 +50,8 @@ func TestAddons(t *testing.T) {
"-t", "master.label-key=leader-group",
"-t", "master.label-value=same",
"-t",
"owner.target-labels=leader-group").Execute()).Should(BeNil())
- Eventually(integrationPodPhase(ns, "first"),
5*time.Minute).Should(Equal(v1.PodRunning))
- Eventually(integrationLogs(ns, "first"),
1*time.Minute).Should(ContainSubstring("Magicstring!"))
+ Eventually(integrationPodPhase(ns, "first"),
testTimeoutMedium).Should(Equal(v1.PodRunning))
+ Eventually(integrationLogs(ns, "first"),
testTimeoutShort).Should(ContainSubstring("Magicstring!"))
Eventually(configMap(ns, "first-lock"),
30*time.Second).ShouldNot(BeNil())
// Start a second integration with the same lock (it
should not start the route)
Expect(kamel("run", "-n", ns, "files/Master.java",
@@ -61,8 +61,8 @@ func TestAddons(t *testing.T) {
"-t", "master.label-value=same",
"-t", "master.configmap=first-lock",
"-t",
"owner.target-labels=leader-group").Execute()).Should(BeNil())
- Eventually(integrationPodPhase(ns, "second"),
5*time.Minute).Should(Equal(v1.PodRunning))
- Eventually(integrationLogs(ns, "second"),
1*time.Minute).Should(ContainSubstring("started in"))
+ Eventually(integrationPodPhase(ns, "second"),
testTimeoutMedium).Should(Equal(v1.PodRunning))
+ Eventually(integrationLogs(ns, "second"),
testTimeoutShort).Should(ContainSubstring("started in"))
Eventually(integrationLogs(ns, "second"),
30*time.Second).ShouldNot(ContainSubstring("Magicstring!"))
Expect(kamel("delete", "--all", "-n",
ns).Execute()).Should(BeNil())
})
diff --git a/e2e/build_test.go b/e2e/build_test.go
index 0c10ba7..b6cca41 100644
--- a/e2e/build_test.go
+++ b/e2e/build_test.go
@@ -23,7 +23,6 @@ package e2e
import (
"testing"
- "time"
"github.com/apache/camel-k/pkg/apis/camel/v1"
. "github.com/onsi/gomega"
@@ -67,6 +66,6 @@ func doNamedKitFullBuild(t *testing.T, name string) {
Eventually(build(ns, name)).ShouldNot(BeNil())
Eventually(func() v1.BuildPhase {
return build(ns, name)().Status.Phase
- }, 5*time.Minute).Should(Equal(v1.BuildPhaseSucceeded))
+ }, testTimeoutMedium).Should(Equal(v1.BuildPhaseSucceeded))
})
}
diff --git a/e2e/cron_test.go b/e2e/cron_test.go
index 0c7730c..a64936a 100644
--- a/e2e/cron_test.go
+++ b/e2e/cron_test.go
@@ -23,7 +23,6 @@ package e2e
import (
"testing"
- "time"
. "github.com/onsi/gomega"
v1 "k8s.io/api/core/v1"
@@ -37,8 +36,8 @@ func TestRunCronExample(t *testing.T) {
RegisterTestingT(t)
Expect(kamel("run", "-n", ns,
"files/cron.groovy").Execute()).Should(BeNil())
- Eventually(integrationCronJob(ns, "cron"),
5*time.Minute).ShouldNot(BeNil())
- Eventually(integrationLogs(ns, "cron"),
5*time.Minute).Should(ContainSubstring("Magicstring!"))
+ Eventually(integrationCronJob(ns, "cron"),
testTimeoutMedium).ShouldNot(BeNil())
+ Eventually(integrationLogs(ns, "cron"),
testTimeoutMedium).Should(ContainSubstring("Magicstring!"))
Expect(kamel("delete", "--all", "-n",
ns).Execute()).Should(BeNil())
})
@@ -46,8 +45,8 @@ func TestRunCronExample(t *testing.T) {
RegisterTestingT(t)
Expect(kamel("run", "-n", ns,
"files/cron-timer.groovy").Execute()).Should(BeNil())
- Eventually(integrationCronJob(ns, "cron-timer"),
5*time.Minute).ShouldNot(BeNil())
- Eventually(integrationLogs(ns, "cron-timer"),
5*time.Minute).Should(ContainSubstring("Magicstring!"))
+ Eventually(integrationCronJob(ns, "cron-timer"),
testTimeoutMedium).ShouldNot(BeNil())
+ Eventually(integrationLogs(ns, "cron-timer"),
testTimeoutMedium).Should(ContainSubstring("Magicstring!"))
Expect(kamel("delete", "--all", "-n",
ns).Execute()).Should(BeNil())
})
@@ -55,8 +54,8 @@ func TestRunCronExample(t *testing.T) {
RegisterTestingT(t)
Expect(kamel("run", "-n", ns,
"files/cron-fallback.groovy").Execute()).Should(BeNil())
- Eventually(integrationPodPhase(ns, "cron-fallback"),
5*time.Minute).Should(Equal(v1.PodRunning))
- Eventually(integrationLogs(ns, "cron-fallback"),
1*time.Minute).Should(ContainSubstring("Magicstring!"))
+ Eventually(integrationPodPhase(ns, "cron-fallback"),
testTimeoutMedium).Should(Equal(v1.PodRunning))
+ Eventually(integrationLogs(ns, "cron-fallback"),
testTimeoutShort).Should(ContainSubstring("Magicstring!"))
Expect(kamel("delete", "--all", "-n",
ns).Execute()).Should(BeNil())
})
})
diff --git a/e2e/dev_mode_test.go b/e2e/dev_mode_test.go
index 2b42ea7..91055c9 100644
--- a/e2e/dev_mode_test.go
+++ b/e2e/dev_mode_test.go
@@ -25,7 +25,6 @@ import (
"context"
"io"
"testing"
- "time"
"github.com/apache/camel-k/e2e/util"
. "github.com/onsi/gomega"
@@ -52,12 +51,12 @@ func TestRunDevMode(t *testing.T) {
go kamelRun.Execute()
- Eventually(logScanner.IsFound(`integration "yaml" in
phase Running`), 5*time.Minute).Should(BeTrue())
- Eventually(logScanner.IsFound("Magicstring!"),
3*time.Minute).Should(BeTrue())
+ Eventually(logScanner.IsFound(`integration "yaml" in
phase Running`), testTimeoutMedium).Should(BeTrue())
+ Eventually(logScanner.IsFound("Magicstring!"),
testTimeoutMedium).Should(BeTrue())
Expect(logScanner.IsFound("Magicjordan!")()).To(BeFalse())
util.ReplaceInFile(t, file, "string!", "jordan!")
- Eventually(logScanner.IsFound("Magicjordan!"),
5*time.Minute).Should(BeTrue())
+ Eventually(logScanner.IsFound("Magicjordan!"),
testTimeoutMedium).Should(BeTrue())
})
t.Run("run yaml remote dev mode", func(t *testing.T) {
@@ -76,7 +75,7 @@ func TestRunDevMode(t *testing.T) {
go kamelRun.Execute()
- Eventually(logScanner.IsFound("Magicstring!"),
5*time.Minute).Should(BeTrue())
+ Eventually(logScanner.IsFound("Magicstring!"),
testTimeoutMedium).Should(BeTrue())
})
})
}
diff --git a/e2e/docker_hub_test.go b/e2e/docker_hub_test.go
index 0b2e1cb..270d892 100644
--- a/e2e/docker_hub_test.go
+++ b/e2e/docker_hub_test.go
@@ -24,7 +24,6 @@ package e2e
import (
"os"
"testing"
- "time"
. "github.com/onsi/gomega"
v1 "k8s.io/api/core/v1"
@@ -47,9 +46,9 @@ func TestRunWithDockerHubRegistry(t *testing.T) {
Execute()).Should(BeNil())
Expect(kamel("run", "-n", ns,
"files/groovy.groovy").Execute()).Should(BeNil())
- Eventually(integrationPodPhase(ns, "groovy"),
5*time.Minute).Should(Equal(v1.PodRunning))
- Eventually(integrationLogs(ns, "groovy"),
1*time.Minute).Should(ContainSubstring("Magicstring!"))
- Eventually(integrationPodImage(ns, "groovy"),
1*time.Minute).Should(HavePrefix("docker.io"))
+ Eventually(integrationPodPhase(ns, "groovy"),
testTimeoutMedium).Should(Equal(v1.PodRunning))
+ Eventually(integrationLogs(ns, "groovy"),
testTimeoutShort).Should(ContainSubstring("Magicstring!"))
+ Eventually(integrationPodImage(ns, "groovy"),
testTimeoutShort).Should(HavePrefix("docker.io"))
Expect(kamel("delete", "--all", "-n",
ns).Execute()).Should(BeNil())
})
diff --git a/e2e/github_packages_test.go b/e2e/github_packages_test.go
index c82e66a..df9abf8 100644
--- a/e2e/github_packages_test.go
+++ b/e2e/github_packages_test.go
@@ -24,7 +24,6 @@ package e2e
import (
"os"
"testing"
- "time"
. "github.com/onsi/gomega"
v1 "k8s.io/api/core/v1"
@@ -48,9 +47,9 @@ func TestRunWithGithubPackagesRegistry(t *testing.T) {
Execute()).Should(BeNil())
Expect(kamel("run", "-n", ns,
"files/groovy.groovy").Execute()).Should(BeNil())
- Eventually(integrationPodPhase(ns, "groovy"),
5*time.Minute).Should(Equal(v1.PodRunning))
- Eventually(integrationLogs(ns, "groovy"),
1*time.Minute).Should(ContainSubstring("Magicstring!"))
- Eventually(integrationPodImage(ns, "groovy"),
1*time.Minute).Should(HavePrefix("docker.pkg.github.com"))
+ Eventually(integrationPodPhase(ns, "groovy"),
testTimeoutMedium).Should(Equal(v1.PodRunning))
+ Eventually(integrationLogs(ns, "groovy"),
testTimeoutShort).Should(ContainSubstring("Magicstring!"))
+ Eventually(integrationPodImage(ns, "groovy"),
testTimeoutShort).Should(HavePrefix("docker.pkg.github.com"))
Expect(kamel("delete", "--all", "-n",
ns).Execute()).Should(BeNil())
})
diff --git a/e2e/global_test.go b/e2e/global_test.go
index dc4062b..4bcbf16 100644
--- a/e2e/global_test.go
+++ b/e2e/global_test.go
@@ -24,7 +24,6 @@ package e2e
import (
"os"
"testing"
- "time"
"github.com/apache/camel-k/pkg/util/openshift"
. "github.com/onsi/gomega"
@@ -51,8 +50,8 @@ func TestRunGlobalInstall(t *testing.T) {
Expect(kamel("install", "-n", ns2,
"--skip-operator-setup", "--olm", "false").Execute()).Should(BeNil())
Expect(kamel("run", "-n", ns2,
"files/Java.java").Execute()).Should(BeNil())
- Eventually(integrationPodPhase(ns2, "java"),
5*time.Minute).Should(Equal(v1.PodRunning))
- Eventually(integrationLogs(ns2, "java"),
1*time.Minute).Should(ContainSubstring("Magicstring!"))
+ Eventually(integrationPodPhase(ns2, "java"),
testTimeoutMedium).Should(Equal(v1.PodRunning))
+ Eventually(integrationLogs(ns2, "java"),
testTimeoutShort).Should(ContainSubstring("Magicstring!"))
Expect(kamel("delete", "--all", "-n",
ns2).Execute()).Should(BeNil())
})
diff --git a/e2e/init_test.go b/e2e/init_test.go
index 82cbe53..fbe5a00 100644
--- a/e2e/init_test.go
+++ b/e2e/init_test.go
@@ -25,7 +25,6 @@ import (
"fmt"
"path"
"testing"
- "time"
"github.com/apache/camel-k/e2e/util"
camelv1 "github.com/apache/camel-k/pkg/apis/camel/v1"
@@ -46,8 +45,8 @@ func TestRunInitGeneratedExamples(t *testing.T) {
file := path.Join(dir, fileName)
Expect(kamel("init",
file).Execute()).Should(BeNil())
Expect(kamel("run", "-n", ns,
file).Execute()).Should(BeNil())
- Eventually(integrationPodPhase(ns, itName),
5*time.Minute).Should(Equal(v1.PodRunning))
- Eventually(integrationLogs(ns, itName),
1*time.Minute).Should(ContainSubstring(languageInitExpectedString(lang)))
+ Eventually(integrationPodPhase(ns, itName),
testTimeoutMedium).Should(Equal(v1.PodRunning))
+ Eventually(integrationLogs(ns, itName),
testTimeoutShort).Should(ContainSubstring(languageInitExpectedString(lang)))
Expect(kamel("delete", "--all", "-n",
ns).Execute()).Should(BeNil())
})
}
diff --git a/e2e/knative_platform_test.go b/e2e/knative_platform_test.go
index 8b90522..37d9d37 100644
--- a/e2e/knative_platform_test.go
+++ b/e2e/knative_platform_test.go
@@ -24,7 +24,6 @@ package e2e
import (
"strings"
"testing"
- "time"
"github.com/apache/camel-k/pkg/apis/camel/v1"
"github.com/apache/camel-k/pkg/util/knative"
@@ -40,16 +39,16 @@ func TestKnativePlatformTest(t *testing.T) {
}
Expect(kamel("install", "-n", ns).Execute()).Should(BeNil())
- Eventually(platformPhase(ns),
5*time.Minute).Should(Equal(v1.IntegrationPlatformPhaseReady))
- Eventually(platformProfile(ns),
1*time.Minute).Should(Equal(v1.TraitProfile("")))
+ Eventually(platformPhase(ns),
testTimeoutMedium).Should(Equal(v1.IntegrationPlatformPhaseReady))
+ Eventually(platformProfile(ns),
testTimeoutShort).Should(Equal(v1.TraitProfile("")))
cluster := platform(ns)().Status.Cluster
t.Run("run yaml on cluster profile", func(t *testing.T) {
RegisterTestingT(t)
Expect(kamel("run", "-n", ns, "files/yaml.yaml",
"--profile", string(cluster)).Execute()).Should(BeNil())
- Eventually(integrationPodPhase(ns, "yaml"),
5*time.Minute).Should(Equal(corev1.PodRunning))
- Eventually(integrationLogs(ns, "yaml"),
1*time.Minute).Should(ContainSubstring("Magicstring!"))
- Eventually(integrationProfile(ns, "yaml"),
1*time.Minute).Should(Equal(v1.TraitProfile(string(cluster))))
+ Eventually(integrationPodPhase(ns, "yaml"),
testTimeoutMedium).Should(Equal(corev1.PodRunning))
+ Eventually(integrationLogs(ns, "yaml"),
testTimeoutShort).Should(ContainSubstring("Magicstring!"))
+ Eventually(integrationProfile(ns, "yaml"),
testTimeoutShort).Should(Equal(v1.TraitProfile(string(cluster))))
// Change something in the integration to produce a
redeploy
Expect(updateIntegration(ns, "yaml", func(it
*v1.Integration) {
it.Spec.Profile = v1.TraitProfile("")
@@ -59,9 +58,9 @@ func TestKnativePlatformTest(t *testing.T) {
Eventually(integrationSpecProfile(ns,
"yaml")).Should(Equal(v1.TraitProfile("")))
// When integration is running again ...
Eventually(integrationPhase(ns,
"yaml")).Should(Equal(v1.IntegrationPhaseRunning))
- Eventually(integrationLogs(ns, "yaml"),
1*time.Minute).Should(ContainSubstring("Magicstring!!!"))
+ Eventually(integrationLogs(ns, "yaml"),
testTimeoutShort).Should(ContainSubstring("Magicstring!!!"))
// It should keep the old profile saved in status
- Eventually(integrationProfile(ns, "yaml"),
5*time.Minute).Should(Equal(v1.TraitProfile(string(cluster))))
+ Eventually(integrationProfile(ns, "yaml"),
testTimeoutMedium).Should(Equal(v1.TraitProfile(string(cluster))))
Expect(kamel("delete", "--all", "-n",
ns).Execute()).Should(BeNil())
})
@@ -69,8 +68,8 @@ func TestKnativePlatformTest(t *testing.T) {
t.Run("run yaml on automatic profile", func(t *testing.T) {
RegisterTestingT(t)
Expect(kamel("run", "-n", ns,
"files/yaml.yaml").Execute()).Should(BeNil())
- Eventually(integrationPodPhase(ns, "yaml"),
5*time.Minute).Should(Equal(corev1.PodRunning))
- Eventually(integrationProfile(ns, "yaml"),
1*time.Minute).Should(Equal(v1.TraitProfileKnative))
+ Eventually(integrationPodPhase(ns, "yaml"),
testTimeoutMedium).Should(Equal(corev1.PodRunning))
+ Eventually(integrationProfile(ns, "yaml"),
testTimeoutShort).Should(Equal(v1.TraitProfileKnative))
Expect(kamel("delete", "--all", "-n",
ns).Execute()).Should(BeNil())
})
diff --git a/e2e/knative_test.go b/e2e/knative_test.go
index 564ca4a..9bdb1b9 100644
--- a/e2e/knative_test.go
+++ b/e2e/knative_test.go
@@ -34,14 +34,14 @@ func TestRunServiceCombo(t *testing.T) {
Expect(kamel("install", "-n", ns, "--trait-profile",
"knative").Execute()).Should(BeNil())
Expect(kamel("run", "-n", ns,
"files/knative2.groovy").Execute()).Should(BeNil())
- Eventually(integrationPodPhase(ns, "knative2"),
10*time.Minute).Should(Equal(v1.PodRunning))
+ Eventually(integrationPodPhase(ns, "knative2"),
testTimeoutLong).Should(Equal(v1.PodRunning))
Expect(kamel("run", "-n", ns,
"files/knative3.groovy").Execute()).Should(BeNil())
- Eventually(integrationPodPhase(ns, "knative3"),
10*time.Minute).Should(Equal(v1.PodRunning))
+ Eventually(integrationPodPhase(ns, "knative3"),
testTimeoutLong).Should(Equal(v1.PodRunning))
Expect(kamel("run", "-n", ns,
"files/knative1.groovy").Execute()).Should(BeNil())
- Eventually(integrationPodPhase(ns, "knative1"),
10*time.Minute).Should(Equal(v1.PodRunning))
+ Eventually(integrationPodPhase(ns, "knative1"),
testTimeoutLong).Should(Equal(v1.PodRunning))
// Correct logs
- Eventually(integrationLogs(ns, "knative1"),
5*time.Minute).Should(ContainSubstring("Received from 2: Hello from knative2"))
- Eventually(integrationLogs(ns, "knative1"),
5*time.Minute).Should(ContainSubstring("Received from 3: Hello from knative3"))
+ Eventually(integrationLogs(ns, "knative1"),
testTimeoutMedium).Should(ContainSubstring("Received from 2: Hello from
knative2"))
+ Eventually(integrationLogs(ns, "knative1"),
testTimeoutMedium).Should(ContainSubstring("Received from 3: Hello from
knative3"))
// Incorrect logs
Consistently(integrationLogs(ns, "knative1"),
10*time.Second).ShouldNot(ContainSubstring("Received from 2: Hello from
knative3"))
Consistently(integrationLogs(ns, "knative1"),
10*time.Second).ShouldNot(ContainSubstring("Received from 3: Hello from
knative2"))
@@ -57,9 +57,9 @@ func TestRunChannelCombo(t *testing.T) {
Expect(kamel("install", "-n", ns, "--trait-profile",
"knative").Execute()).Should(BeNil())
Expect(kamel("run", "-n", ns,
"files/knativech2.groovy").Execute()).Should(BeNil())
Expect(kamel("run", "-n", ns,
"files/knativech1.groovy").Execute()).Should(BeNil())
- Eventually(integrationPodPhase(ns, "knativech2"),
10*time.Minute).Should(Equal(v1.PodRunning))
- Eventually(integrationPodPhase(ns, "knativech1"),
10*time.Minute).Should(Equal(v1.PodRunning))
- Eventually(integrationLogs(ns, "knativech2"),
5*time.Minute).Should(ContainSubstring("Received: Hello from knativech1"))
+ Eventually(integrationPodPhase(ns, "knativech2"),
testTimeoutLong).Should(Equal(v1.PodRunning))
+ Eventually(integrationPodPhase(ns, "knativech1"),
testTimeoutLong).Should(Equal(v1.PodRunning))
+ Eventually(integrationLogs(ns, "knativech2"),
testTimeoutMedium).Should(ContainSubstring("Received: Hello from knativech1"))
Expect(kamel("delete", "--all", "-n",
ns).Execute()).Should(BeNil())
})
}
@@ -71,9 +71,9 @@ func TestRunChannelComboGetToPost(t *testing.T) {
Expect(kamel("install", "-n", ns, "--trait-profile",
"knative").Execute()).Should(BeNil())
Expect(kamel("run", "-n", ns,
"files/knativegetpost2.groovy").Execute()).Should(BeNil())
Expect(kamel("run", "-n", ns,
"files/knativegetpost1.groovy").Execute()).Should(BeNil())
- Eventually(integrationPodPhase(ns, "knativegetpost2"),
10*time.Minute).Should(Equal(v1.PodRunning))
- Eventually(integrationPodPhase(ns, "knativegetpost1"),
10*time.Minute).Should(Equal(v1.PodRunning))
- Eventually(integrationLogs(ns, "knativegetpost2"),
5*time.Minute).Should(ContainSubstring(`Received ""`))
+ Eventually(integrationPodPhase(ns, "knativegetpost2"),
testTimeoutLong).Should(Equal(v1.PodRunning))
+ Eventually(integrationPodPhase(ns, "knativegetpost1"),
testTimeoutLong).Should(Equal(v1.PodRunning))
+ Eventually(integrationLogs(ns, "knativegetpost2"),
testTimeoutMedium).Should(ContainSubstring(`Received ""`))
Expect(kamel("delete", "--all", "-n",
ns).Execute()).Should(BeNil())
})
}
@@ -88,12 +88,12 @@ func TestRunMultiChannelChain(t *testing.T) {
Expect(kamel("run", "-n", ns,
"files/knativemultihop3.groovy").Execute()).Should(BeNil())
Expect(kamel("run", "-n", ns,
"files/knativemultihop2.groovy").Execute()).Should(BeNil())
Expect(kamel("run", "-n", ns,
"files/knativemultihop1.groovy").Execute()).Should(BeNil())
- Eventually(integrationPodPhase(ns, "knativemultihop3"),
10*time.Minute).Should(Equal(v1.PodRunning))
- Eventually(integrationPodPhase(ns, "knativemultihop2"),
10*time.Minute).Should(Equal(v1.PodRunning))
- Eventually(integrationPodPhase(ns, "knativemultihop1"),
10*time.Minute).Should(Equal(v1.PodRunning))
- Eventually(integrationLogs(ns, "knativemultihop3"),
5*time.Minute).Should(ContainSubstring(`From messages: message`))
- Eventually(integrationLogs(ns, "knativemultihop3"),
5*time.Minute).Should(ContainSubstring(`From words: word`))
- Eventually(integrationLogs(ns, "knativemultihop3"),
5*time.Minute).Should(ContainSubstring(`From words: transformed message`))
+ Eventually(integrationPodPhase(ns, "knativemultihop3"),
testTimeoutLong).Should(Equal(v1.PodRunning))
+ Eventually(integrationPodPhase(ns, "knativemultihop2"),
testTimeoutLong).Should(Equal(v1.PodRunning))
+ Eventually(integrationPodPhase(ns, "knativemultihop1"),
testTimeoutLong).Should(Equal(v1.PodRunning))
+ Eventually(integrationLogs(ns, "knativemultihop3"),
testTimeoutMedium).Should(ContainSubstring(`From messages: message`))
+ Eventually(integrationLogs(ns, "knativemultihop3"),
testTimeoutMedium).Should(ContainSubstring(`From words: word`))
+ Eventually(integrationLogs(ns, "knativemultihop3"),
testTimeoutMedium).Should(ContainSubstring(`From words: transformed message`))
Eventually(integrationLogs(ns, "knativemultihop3"),
10*time.Second).ShouldNot(ContainSubstring(`From messages: word`))
Eventually(integrationLogs(ns, "knativemultihop3"),
10*time.Second).ShouldNot(ContainSubstring(`From words: message`))
Eventually(integrationLogs(ns, "knativemultihop3"),
10*time.Second).ShouldNot(ContainSubstring(`From messages: transformed
message`))
@@ -107,10 +107,10 @@ func TestRunBroker(t *testing.T) {
Expect(kamel("install", "-n", ns, "--trait-profile",
"knative").Execute()).Should(BeNil())
Expect(kamel("run", "-n", ns,
"files/knativeevt1.groovy").Execute()).Should(BeNil())
Expect(kamel("run", "-n", ns,
"files/knativeevt2.groovy").Execute()).Should(BeNil())
- Eventually(integrationPodPhase(ns, "knativeevt1"),
10*time.Minute).Should(Equal(v1.PodRunning))
- Eventually(integrationPodPhase(ns, "knativeevt2"),
10*time.Minute).Should(Equal(v1.PodRunning))
- Eventually(integrationLogs(ns, "knativeevt2"),
5*time.Minute).Should(ContainSubstring("Received 1: Hello 1"))
- Eventually(integrationLogs(ns, "knativeevt2"),
5*time.Minute).Should(ContainSubstring("Received 2: Hello 2"))
+ Eventually(integrationPodPhase(ns, "knativeevt1"),
testTimeoutLong).Should(Equal(v1.PodRunning))
+ Eventually(integrationPodPhase(ns, "knativeevt2"),
testTimeoutLong).Should(Equal(v1.PodRunning))
+ Eventually(integrationLogs(ns, "knativeevt2"),
testTimeoutMedium).Should(ContainSubstring("Received 1: Hello 1"))
+ Eventually(integrationLogs(ns, "knativeevt2"),
testTimeoutMedium).Should(ContainSubstring("Received 2: Hello 2"))
Eventually(integrationLogs(ns,
"knativeevt2")).ShouldNot(ContainSubstring("Received 1: Hello 2"))
Expect(kamel("delete", "--all", "-n",
ns).Execute()).Should(BeNil())
})
diff --git a/e2e/platformless_run_test.go b/e2e/platformless_run_test.go
index 28213b9..15e9ccd 100644
--- a/e2e/platformless_run_test.go
+++ b/e2e/platformless_run_test.go
@@ -24,7 +24,6 @@ package e2e
import (
"os"
"testing"
- "time"
"github.com/apache/camel-k/pkg/apis/camel/v1"
"github.com/apache/camel-k/pkg/util/openshift"
@@ -49,8 +48,8 @@ func TestPlatformlessRun(t *testing.T) {
Eventually(deletePlatform(ns)).Should(BeTrue())
Expect(kamel("run", "-n", ns,
"files/yaml.yaml").Execute()).Should(BeNil())
- Eventually(integrationPodPhase(ns, "yaml"),
5*time.Minute).Should(Equal(corev1.PodRunning))
- Eventually(integrationLogs(ns, "yaml"),
1*time.Minute).Should(ContainSubstring("Magicstring!"))
+ Eventually(integrationPodPhase(ns, "yaml"),
testTimeoutMedium).Should(Equal(corev1.PodRunning))
+ Eventually(integrationLogs(ns, "yaml"),
testTimeoutShort).Should(ContainSubstring("Magicstring!"))
// Platform should be recreated
Eventually(platform(ns)).ShouldNot(BeNil())
diff --git a/e2e/run_test.go b/e2e/run_test.go
index 46bb010..ae3911d 100644
--- a/e2e/run_test.go
+++ b/e2e/run_test.go
@@ -23,7 +23,6 @@ package e2e
import (
"testing"
- "time"
. "github.com/onsi/gomega"
v1 "k8s.io/api/core/v1"
@@ -36,65 +35,65 @@ func TestRunSimpleExamples(t *testing.T) {
t.Run("run java", func(t *testing.T) {
RegisterTestingT(t)
Expect(kamel("run", "-n", ns,
"files/Java.java").Execute()).Should(BeNil())
- Eventually(integrationPodPhase(ns, "java"),
5*time.Minute).Should(Equal(v1.PodRunning))
- Eventually(integrationLogs(ns, "java"),
1*time.Minute).Should(ContainSubstring("Magicstring!"))
+ Eventually(integrationPodPhase(ns, "java"),
testTimeoutMedium).Should(Equal(v1.PodRunning))
+ Eventually(integrationLogs(ns, "java"),
testTimeoutShort).Should(ContainSubstring("Magicstring!"))
Expect(kamel("delete", "--all", "-n",
ns).Execute()).Should(BeNil())
})
t.Run("run java with properties", func(t *testing.T) {
RegisterTestingT(t)
Expect(kamel("run", "-n", ns, "files/Prop.java",
"--property-file", "files/prop.properties").Execute()).Should(BeNil())
- Eventually(integrationPodPhase(ns, "prop"),
5*time.Minute).Should(Equal(v1.PodRunning))
- Eventually(integrationLogs(ns, "prop"),
1*time.Minute).Should(ContainSubstring("Magicstring!"))
+ Eventually(integrationPodPhase(ns, "prop"),
testTimeoutMedium).Should(Equal(v1.PodRunning))
+ Eventually(integrationLogs(ns, "prop"),
testTimeoutShort).Should(ContainSubstring("Magicstring!"))
Expect(kamel("delete", "--all", "-n",
ns).Execute()).Should(BeNil())
})
t.Run("run xml", func(t *testing.T) {
RegisterTestingT(t)
Expect(kamel("run", "-n", ns,
"files/xml.xml").Execute()).Should(BeNil())
- Eventually(integrationPodPhase(ns, "xml"),
5*time.Minute).Should(Equal(v1.PodRunning))
- Eventually(integrationLogs(ns, "xml"),
1*time.Minute).Should(ContainSubstring("Magicstring!"))
+ Eventually(integrationPodPhase(ns, "xml"),
testTimeoutMedium).Should(Equal(v1.PodRunning))
+ Eventually(integrationLogs(ns, "xml"),
testTimeoutShort).Should(ContainSubstring("Magicstring!"))
Expect(kamel("delete", "--all", "-n",
ns).Execute()).Should(BeNil())
})
t.Run("run groovy", func(t *testing.T) {
RegisterTestingT(t)
Expect(kamel("run", "-n", ns,
"files/groovy.groovy").Execute()).Should(BeNil())
- Eventually(integrationPodPhase(ns, "groovy"),
5*time.Minute).Should(Equal(v1.PodRunning))
- Eventually(integrationLogs(ns, "groovy"),
1*time.Minute).Should(ContainSubstring("Magicstring!"))
+ Eventually(integrationPodPhase(ns, "groovy"),
testTimeoutMedium).Should(Equal(v1.PodRunning))
+ Eventually(integrationLogs(ns, "groovy"),
testTimeoutShort).Should(ContainSubstring("Magicstring!"))
Expect(kamel("delete", "--all", "-n",
ns).Execute()).Should(BeNil())
})
t.Run("run js", func(t *testing.T) {
RegisterTestingT(t)
Expect(kamel("run", "-n", ns,
"files/js.js").Execute()).Should(BeNil())
- Eventually(integrationPodPhase(ns, "js"),
5*time.Minute).Should(Equal(v1.PodRunning))
- Eventually(integrationLogs(ns, "js"),
1*time.Minute).Should(ContainSubstring("Magicstring!"))
+ Eventually(integrationPodPhase(ns, "js"),
testTimeoutMedium).Should(Equal(v1.PodRunning))
+ Eventually(integrationLogs(ns, "js"),
testTimeoutShort).Should(ContainSubstring("Magicstring!"))
Expect(kamel("delete", "--all", "-n",
ns).Execute()).Should(BeNil())
})
t.Run("run kotlin", func(t *testing.T) {
RegisterTestingT(t)
Expect(kamel("run", "-n", ns,
"files/kotlin.kts").Execute()).Should(BeNil())
- Eventually(integrationPodPhase(ns, "kotlin"),
5*time.Minute).Should(Equal(v1.PodRunning))
- Eventually(integrationLogs(ns, "kotlin"),
1*time.Minute).Should(ContainSubstring("Magicstring!"))
+ Eventually(integrationPodPhase(ns, "kotlin"),
testTimeoutMedium).Should(Equal(v1.PodRunning))
+ Eventually(integrationLogs(ns, "kotlin"),
testTimeoutShort).Should(ContainSubstring("Magicstring!"))
Expect(kamel("delete", "--all", "-n",
ns).Execute()).Should(BeNil())
})
t.Run("run yaml", func(t *testing.T) {
RegisterTestingT(t)
Expect(kamel("run", "-n", ns,
"files/yaml.yaml").Execute()).Should(BeNil())
- Eventually(integrationPodPhase(ns, "yaml"),
5*time.Minute).Should(Equal(v1.PodRunning))
- Eventually(integrationLogs(ns, "yaml"),
1*time.Minute).Should(ContainSubstring("Magicstring!"))
+ Eventually(integrationPodPhase(ns, "yaml"),
testTimeoutMedium).Should(Equal(v1.PodRunning))
+ Eventually(integrationLogs(ns, "yaml"),
testTimeoutShort).Should(ContainSubstring("Magicstring!"))
Expect(kamel("delete", "--all", "-n",
ns).Execute()).Should(BeNil())
})
t.Run("run yaml Quarkus", func(t *testing.T) {
RegisterTestingT(t)
Expect(kamel("run", "-n", ns, "--name", "yaml-quarkus",
"files/yaml.yaml", "-t", "quarkus.enabled=true").Execute()).Should(BeNil())
- Eventually(integrationPodPhase(ns, "yaml-quarkus"),
5*time.Minute).Should(Equal(v1.PodRunning))
- Eventually(integrationLogs(ns, "yaml-quarkus"),
1*time.Minute).Should(ContainSubstring("running on Quarkus"))
- Eventually(integrationLogs(ns, "yaml-quarkus"),
1*time.Minute).Should(ContainSubstring("Magicstring!"))
+ Eventually(integrationPodPhase(ns, "yaml-quarkus"),
testTimeoutMedium).Should(Equal(v1.PodRunning))
+ Eventually(integrationLogs(ns, "yaml-quarkus"),
testTimeoutShort).Should(ContainSubstring("running on Quarkus"))
+ Eventually(integrationLogs(ns, "yaml-quarkus"),
testTimeoutShort).Should(ContainSubstring("Magicstring!"))
Expect(kamel("delete", "--all", "-n",
ns).Execute()).Should(BeNil())
})
diff --git a/e2e/test_support.go b/e2e/test_support.go
index f47891c..bb6ea57 100644
--- a/e2e/test_support.go
+++ b/e2e/test_support.go
@@ -61,6 +61,10 @@ import (
_ "github.com/apache/camel-k/addons"
)
+var testTimeoutShort = 1*time.Minute
+var testTimeoutMedium = 5*time.Minute
+var testTimeoutLong = 10*time.Minute
+
var testContext context.Context
var testClient client.Client
@@ -84,8 +88,6 @@ func init() {
}
// Defaults for testing
- gomega.SetDefaultEventuallyTimeout(60 * time.Second)
-
imageName := os.Getenv("CAMEL_K_TEST_IMAGE_NAME")
if imageName != "" {
testImageName = imageName
@@ -95,6 +97,34 @@ func init() {
testImageVersion = imageVersion
}
+ // Timeouts
+ var duration time.Duration
+ if value, ok := os.LookupEnv("CAMEL_K_TEST_TIMEOUT_SHORT"); ok {
+ if duration, err = time.ParseDuration(value); err == nil {
+ testTimeoutShort = duration
+ } else {
+ fmt.Printf("Can't parse CAMEL_K_TEST_TIMEOUT_SHORT.
Using default value: %s", testTimeoutShort)
+ }
+ }
+
+ if value, ok := os.LookupEnv("CAMEL_K_TEST_TIMEOUT_MEDIUM"); ok {
+ if duration, err = time.ParseDuration(value); err == nil {
+ testTimeoutMedium = duration
+ } else {
+ fmt.Printf("Can't parse CAMEL_K_TEST_TIMEOUT_MEDIUM.
Using default value: %s", testTimeoutMedium)
+ }
+ }
+
+ if value, ok := os.LookupEnv("CAMEL_K_TEST_TIMEOUT_LONG"); ok {
+ if duration, err = time.ParseDuration(value); err == nil {
+ testTimeoutLong = duration
+ } else {
+ fmt.Printf("Can't parse CAMEL_K_TEST_TIMEOUT_LONG.
Using default value: %s", testTimeoutLong)
+ }
+ }
+
+ gomega.SetDefaultEventuallyTimeout(testTimeoutShort)
+
}
func newTestClient() (client.Client, error) {
diff --git a/e2e/upgrade_test.go b/e2e/upgrade_test.go
index ede2b5d..58e3115 100644
--- a/e2e/upgrade_test.go
+++ b/e2e/upgrade_test.go
@@ -59,7 +59,7 @@ func TestIntegrationUpgrade(t *testing.T) {
// Run an integration
Expect(kamel("run", "-n", ns,
"files/js.js").Execute()).Should(BeNil())
- Eventually(integrationPodPhase(ns, "js"),
5*time.Minute).Should(Equal(v1.PodRunning))
+ Eventually(integrationPodPhase(ns, "js"),
testTimeoutMedium).Should(Equal(v1.PodRunning))
initialImage := integrationPodImage(ns, "js")()
// Scale the operator down to zero
@@ -88,7 +88,7 @@ func TestIntegrationUpgrade(t *testing.T) {
Eventually(integrationVersion(ns,
"js")).Should(Equal(defaults.Version))
Eventually(kitsWithVersion(ns,
"an.older.one")).Should(Equal(1)) // old one is not recycled
Eventually(kitsWithVersion(ns,
defaults.Version)).Should(Equal(1))
- Eventually(integrationPodImage(ns, "js"),
5*time.Minute).ShouldNot(Equal(initialImage)) // rolling deployment triggered
- Eventually(integrationPodPhase(ns, "js"),
5*time.Minute).Should(Equal(v1.PodRunning))
+ Eventually(integrationPodImage(ns, "js"),
testTimeoutMedium).ShouldNot(Equal(initialImage)) // rolling deployment
triggered
+ Eventually(integrationPodPhase(ns, "js"),
testTimeoutMedium).Should(Equal(v1.PodRunning))
})
}
