Speed up API tests (#624)

* Adjust API tests internal API

* Refactor API tests to take less time

 - sqlite: tests 15s, overall time: 1m
 - mysql: tests 15s, overall time: 59s

* Use retry func to survive in faulty places

* Use retry func while trying to ping SQL datastore

 - implements retry func specifically for SQL datastore ping
 - fmt fixes
 - using sqlx.Db.PingContext instead of sqlx.Db.Ping
 - propogate context to SQL datastore

* Simplify TestCanCauseTimeout retry loop

* Call retry with sane timeout

* Fix TestOversizedLog, use retry func

* Increase number of attempts

 2 test cases are really faulty in CI, so they need a lot more time to finish.

* Increase TestCanCauseTimeout timeout

* Use retry at TestMultiLog to speed it up

* Use retry at TestCanWriteLogs to speed it up

* Use retry at TestGetCallsSuccess to speed it up

* Use retry at TestCanGetAsyncState to speed it up

* Use retry at TestListCallsSuccess to speed it up

* Remove sleep calls

* Remove dup test case

* Cleaup Calls API test

* Build API tests binary once

 This patch lets CI to build API tests binary once and reuse that whenever it needs it

* Swap API tests checks

* Build API test binary by default

 dirty fix for CircleCI

* Use retry func to determine if datastore is alive in tests

* go install should also reduce build time

* Fix rebase issues

test/fn-api-tests/exec_test.go

@@ -14,15 +14,6 @@ import (
 	"github.com/fnproject/fn_go/client/operations"
 )
 
-type ErrMsg struct {
-	Message string `json:"message"`
-}
-
-type TimeoutBody struct {
-	Error  ErrMsg `json:"error"`
-	CallID string `json:"request_id"`
-}
-
 func CallAsync(t *testing.T, u url.URL, content io.Reader) string {
 	output := &bytes.Buffer{}
 	_, err := CallFN(u.String(), content, output, "POST", []string{})
@@ -49,119 +40,125 @@ func CallAsync(t *testing.T, u url.URL, content io.Reader) string {
 	return callID.CallID
 }
 
-func TestRouteExecutions(t *testing.T) {
+func TestCanCallfunction(t *testing.T) {
+	t.Parallel()
+	s := SetupDefaultSuite()
+	CreateApp(t, s.Context, s.Client, s.AppName, map[string]string{})
+	CreateRoute(t, s.Context, s.Client, s.AppName, s.RoutePath, s.Image, "sync",
+		s.Format, s.Timeout, s.IdleTimeout, s.RouteConfig, s.RouteHeaders)
+
+	u := url.URL{
+		Scheme: "http",
+		Host:   Host(),
+	}
+	u.Path = path.Join(u.Path, "r", s.AppName, s.RoutePath)
+
+	content := &bytes.Buffer{}
+	output := &bytes.Buffer{}
+	_, err := CallFN(u.String(), content, output, "POST", []string{})
+	if err != nil {
+		t.Errorf("Got unexpected error: %v", err)
+	}
+	expectedOutput := "Hello World!\n"
+	if !strings.Contains(expectedOutput, output.String()) {
+		t.Errorf("Assertion error.\n\tExpected: %v\n\tActual: %v", expectedOutput, output.String())
+	}
+	DeleteApp(t, s.Context, s.Client, s.AppName)
+}
+
+func TestCallOutputMatch(t *testing.T) {
+	t.Parallel()
+	s := SetupDefaultSuite()
+	CreateApp(t, s.Context, s.Client, s.AppName, map[string]string{})
+	CreateRoute(t, s.Context, s.Client, s.AppName, s.RoutePath, s.Image, "sync",
+		s.Format, s.Timeout, s.IdleTimeout, s.RouteConfig, s.RouteHeaders)
+
+	u := url.URL{
+		Scheme: "http",
+		Host:   Host(),
+	}
+	u.Path = path.Join(u.Path, "r", s.AppName, s.RoutePath)
+
+	content := &bytes.Buffer{}
+	json.NewEncoder(content).Encode(struct {
+		Name string
+	}{Name: "John"})
+	output := &bytes.Buffer{}
+	_, err := CallFN(u.String(), content, output, "POST", []string{})
+	if err != nil {
+		t.Errorf("Got unexpected error: %v", err)
+	}
+	expectedOutput := "Hello John!\n"
+	if !strings.Contains(expectedOutput, output.String()) {
+		t.Errorf("Assertion error.\n\tExpected: %v\n\tActual: %v", expectedOutput, output.String())
+	}
+	DeleteApp(t, s.Context, s.Client, s.AppName)
+}
+
+func TestCanCallAsync(t *testing.T) {
 	newRouteType := "async"
+	t.Parallel()
+	s := SetupDefaultSuite()
+	CreateApp(t, s.Context, s.Client, s.AppName, map[string]string{})
+	CreateRoute(t, s.Context, s.Client, s.AppName, s.RoutePath, s.Image, "sync",
+		s.Format, s.Timeout, s.IdleTimeout, s.RouteConfig, s.RouteHeaders)
 
-	t.Run("run-sync-fnproject/hello-no-input", func(t *testing.T) {
-		t.Parallel()
-		s := SetupDefaultSuite()
-		CreateApp(t, s.Context, s.Client, s.AppName, map[string]string{})
-		CreateRoute(t, s.Context, s.Client, s.AppName, s.RoutePath, s.Image, "sync",
-			s.Format, s.RouteConfig, s.RouteHeaders)
+	u := url.URL{
+		Scheme: "http",
+		Host:   Host(),
+	}
+	u.Path = path.Join(u.Path, "r", s.AppName, s.RoutePath)
 
-		u := url.URL{
-			Scheme: "http",
-			Host:   Host(),
-		}
-		u.Path = path.Join(u.Path, "r", s.AppName, s.RoutePath)
+	_, err := UpdateRoute(
+		t, s.Context, s.Client,
+		s.AppName, s.RoutePath,
+		s.Image, newRouteType, s.Format,
+		s.Memory, s.RouteConfig, s.RouteHeaders, "")
 
-		content := &bytes.Buffer{}
-		output := &bytes.Buffer{}
-		_, err := CallFN(u.String(), content, output, "POST", []string{})
-		if err != nil {
-			t.Errorf("Got unexpected error: %v", err)
-		}
-		expectedOutput := "Hello World!\n"
-		if !strings.Contains(expectedOutput, output.String()) {
-			t.Errorf("Assertion error.\n\tExpected: %v\n\tActual: %v", expectedOutput, output.String())
-		}
-		DeleteApp(t, s.Context, s.Client, s.AppName)
+	CheckRouteResponseError(t, err)
+
+	CallAsync(t, u, &bytes.Buffer{})
+	DeleteApp(t, s.Context, s.Client, s.AppName)
+}
+
+func TestCanGetAsyncState(t *testing.T) {
+	newRouteType := "async"
+	t.Parallel()
+	s := SetupDefaultSuite()
+	CreateApp(t, s.Context, s.Client, s.AppName, map[string]string{})
+	CreateRoute(t, s.Context, s.Client, s.AppName, s.RoutePath, s.Image, "sync",
+		s.Format, s.Timeout, s.IdleTimeout, s.RouteConfig, s.RouteHeaders)
+
+	u := url.URL{
+		Scheme: "http",
+		Host:   Host(),
+	}
+	u.Path = path.Join(u.Path, "r", s.AppName, s.RoutePath)
+
+	_, err := UpdateRoute(
+		t, s.Context, s.Client,
+		s.AppName, s.RoutePath,
+		s.Image, newRouteType, s.Format,
+		s.Memory, s.RouteConfig, s.RouteHeaders, "")
+
+	CheckRouteResponseError(t, err)
+
+	callID := CallAsync(t, u, &bytes.Buffer{})
+	cfg := &call.GetAppsAppCallsCallParams{
+		Call:    callID,
+		App:     s.AppName,
+		Context: s.Context,
+	}
+	cfg.WithTimeout(time.Second * 60)
+
+	retryErr := APICallWithRetry(t, 10, time.Second*2, func() (err error) {
+		_, err = s.Client.Call.GetAppsAppCallsCall(cfg)
+		return err
 	})
 
-	t.Run("run-sync-fnproject/hello-with-input", func(t *testing.T) {
-		t.Parallel()
-		s := SetupDefaultSuite()
-		CreateApp(t, s.Context, s.Client, s.AppName, map[string]string{})
-		CreateRoute(t, s.Context, s.Client, s.AppName, s.RoutePath, s.Image, "sync",
-			s.Format, s.RouteConfig, s.RouteHeaders)
-
-		u := url.URL{
-			Scheme: "http",
-			Host:   Host(),
-		}
-		u.Path = path.Join(u.Path, "r", s.AppName, s.RoutePath)
-
-		content := &bytes.Buffer{}
-		json.NewEncoder(content).Encode(struct {
-			Name string
-		}{Name: "John"})
-		output := &bytes.Buffer{}
-		_, err := CallFN(u.String(), content, output, "POST", []string{})
-		if err != nil {
-			t.Errorf("Got unexpected error: %v", err)
-		}
-		expectedOutput := "Hello John!\n"
-		if !strings.Contains(expectedOutput, output.String()) {
-			t.Errorf("Assertion error.\n\tExpected: %v\n\tActual: %v", expectedOutput, output.String())
-		}
-		DeleteApp(t, s.Context, s.Client, s.AppName)
-
-	})
-
-	t.Run("run-async-fnproject/hello", func(t *testing.T) {
-		t.Parallel()
-		s := SetupDefaultSuite()
-		CreateApp(t, s.Context, s.Client, s.AppName, map[string]string{})
-		CreateRoute(t, s.Context, s.Client, s.AppName, s.RoutePath, s.Image, "sync",
-			s.Format, s.RouteConfig, s.RouteHeaders)
-
-		u := url.URL{
-			Scheme: "http",
-			Host:   Host(),
-		}
-		u.Path = path.Join(u.Path, "r", s.AppName, s.RoutePath)
-
-		_, err := UpdateRoute(
-			t, s.Context, s.Client,
-			s.AppName, s.RoutePath,
-			s.Image, newRouteType, s.Format,
-			s.Memory, s.RouteConfig, s.RouteHeaders, "")
-
-		CheckRouteResponseError(t, err)
-
-		CallAsync(t, u, &bytes.Buffer{})
-		DeleteApp(t, s.Context, s.Client, s.AppName)
-	})
-
-	t.Run("run-async-fnproject/hello-with-status-check", func(t *testing.T) {
-		t.Parallel()
-		s := SetupDefaultSuite()
-		CreateApp(t, s.Context, s.Client, s.AppName, map[string]string{})
-		CreateRoute(t, s.Context, s.Client, s.AppName, s.RoutePath, s.Image, "sync",
-			s.Format, s.RouteConfig, s.RouteHeaders)
-
-		u := url.URL{
-			Scheme: "http",
-			Host:   Host(),
-		}
-		u.Path = path.Join(u.Path, "r", s.AppName, s.RoutePath)
-
-		_, err := UpdateRoute(
-			t, s.Context, s.Client,
-			s.AppName, s.RoutePath,
-			s.Image, newRouteType, s.Format,
-			s.Memory, s.RouteConfig, s.RouteHeaders, "")
-
-		CheckRouteResponseError(t, err)
-
-		callID := CallAsync(t, u, &bytes.Buffer{})
-		time.Sleep(time.Second * 10)
-		cfg := &call.GetAppsAppCallsCallParams{
-			Call:    callID,
-			App:     s.AppName,
-			Context: s.Context,
-		}
-		cfg.WithTimeout(time.Second * 60)
+	if retryErr != nil {
+		t.Error(retryErr.Error())
+	} else {
 		callResponse, err := s.Client.Call.GetAppsAppCallsCall(cfg)
 		if err != nil {
 			switch err.(type) {
@@ -184,46 +181,54 @@ func TestRouteExecutions(t *testing.T) {
 		if callObject.Status != "success" {
 			t.Errorf("Call object status mismatch.\n\tExpected: %v\n\tActual:%v", "success", callObject.Status)
 		}
+	}
 
-		DeleteApp(t, s.Context, s.Client, s.AppName)
+	DeleteApp(t, s.Context, s.Client, s.AppName)
+}
 
+func TestCanCauseTimeout(t *testing.T) {
+	t.Parallel()
+	s := SetupDefaultSuite()
+	routePath := "/" + RandStringBytes(10)
+	image := "funcy/timeout:0.0.1"
+	routeType := "sync"
+
+	CreateApp(t, s.Context, s.Client, s.AppName, map[string]string{})
+	CreateRoute(t, s.Context, s.Client, s.AppName, routePath, image, routeType,
+		s.Format, int32(10), s.IdleTimeout, s.RouteConfig, s.RouteHeaders)
+
+	u := url.URL{
+		Scheme: "http",
+		Host:   Host(),
+	}
+	u.Path = path.Join(u.Path, "r", s.AppName, routePath)
+
+	content := &bytes.Buffer{}
+	json.NewEncoder(content).Encode(struct {
+		Seconds int64 `json:"seconds"`
+	}{Seconds: 11})
+	output := &bytes.Buffer{}
+
+	headers, _ := CallFN(u.String(), content, output, "POST", []string{})
+
+	if !strings.Contains(output.String(), "Timed out") {
+		t.Errorf("Must fail because of timeout, but got error message: %v", output.String())
+	}
+	cfg := &call.GetAppsAppCallsCallParams{
+		Call:    headers.Get("FN_CALL_ID"),
+		App:     s.AppName,
+		Context: s.Context,
+	}
+	cfg.WithTimeout(time.Second * 60)
+
+	retryErr := APICallWithRetry(t, 10, time.Second*2, func() (err error) {
+		_, err = s.Client.Call.GetAppsAppCallsCall(cfg)
+		return err
 	})
 
-	t.Run("exec-timeout-test", func(t *testing.T) {
-		t.Parallel()
-		s := SetupDefaultSuite()
-		routePath := "/" + RandStringBytes(10)
-		image := "funcy/timeout:0.0.1"
-		routeType := "sync"
-
-		CreateApp(t, s.Context, s.Client, s.AppName, map[string]string{})
-		CreateRoute(t, s.Context, s.Client, s.AppName, routePath, image, routeType,
-			s.Format, s.RouteConfig, s.RouteHeaders)
-
-		u := url.URL{
-			Scheme: "http",
-			Host:   Host(),
-		}
-		u.Path = path.Join(u.Path, "r", s.AppName, routePath)
-
-		content := &bytes.Buffer{}
-		json.NewEncoder(content).Encode(struct {
-			Seconds int64 `json:"seconds"`
-		}{Seconds: 31})
-		output := &bytes.Buffer{}
-
-		headers, _ := CallFN(u.String(), content, output, "POST", []string{})
-
-		if !strings.Contains(output.String(), "Timed out") {
-			t.Errorf("Must fail because of timeout, but got error message: %v", output.String())
-		}
-
-		cfg := &call.GetAppsAppCallsCallParams{
-			Call:    headers.Get("FN_CALL_ID"),
-			App:     s.AppName,
-			Context: s.Context,
-		}
-		cfg.WithTimeout(time.Second * 60)
+	if retryErr != nil {
+		t.Error(retryErr.Error())
+	} else {
 		callObj, err := s.Client.Call.GetAppsAppCallsCall(cfg)
 		if err != nil {
 			t.Errorf("Unexpected error: %s", err)
@@ -232,36 +237,43 @@ func TestRouteExecutions(t *testing.T) {
 			t.Errorf("Call status mismatch.\n\tExpected: %v\n\tActual: %v",
 				"output", "callObj.Payload.Call.Status")
 		}
+	}
+	DeleteApp(t, s.Context, s.Client, s.AppName)
+}
 
-		DeleteApp(t, s.Context, s.Client, s.AppName)
+func TestMultiLog(t *testing.T) {
+	t.Parallel()
+	s := SetupDefaultSuite()
+	routePath := "/multi-log"
+	image := "funcy/multi-log:0.0.1"
+	routeType := "async"
+
+	CreateApp(t, s.Context, s.Client, s.AppName, map[string]string{})
+	CreateRoute(t, s.Context, s.Client, s.AppName, routePath, image, routeType,
+		s.Format, s.Timeout, s.IdleTimeout, s.RouteConfig, s.RouteHeaders)
+
+	u := url.URL{
+		Scheme: "http",
+		Host:   Host(),
+	}
+	u.Path = path.Join(u.Path, "r", s.AppName, routePath)
+
+	callID := CallAsync(t, u, &bytes.Buffer{})
+
+	cfg := &operations.GetAppsAppCallsCallLogParams{
+		Call:    callID,
+		App:     s.AppName,
+		Context: s.Context,
+	}
+
+	retryErr := APICallWithRetry(t, 10, time.Second*2, func() (err error) {
+		_, err = s.Client.Operations.GetAppsAppCallsCallLog(cfg)
+		return err
 	})
 
-	t.Run("exec-multi-log-test", func(t *testing.T) {
-		t.Parallel()
-		s := SetupDefaultSuite()
-		routePath := "/multi-log"
-		image := "funcy/multi-log:0.0.1"
-		routeType := "async"
-
-		CreateApp(t, s.Context, s.Client, s.AppName, map[string]string{})
-		CreateRoute(t, s.Context, s.Client, s.AppName, routePath, image, routeType,
-			s.Format, s.RouteConfig, s.RouteHeaders)
-
-		u := url.URL{
-			Scheme: "http",
-			Host:   Host(),
-		}
-		u.Path = path.Join(u.Path, "r", s.AppName, routePath)
-
-		callID := CallAsync(t, u, &bytes.Buffer{})
-		time.Sleep(15 * time.Second)
-
-		cfg := &operations.GetAppsAppCallsCallLogParams{
-			Call:    callID,
-			App:     s.AppName,
-			Context: s.Context,
-		}
-
+	if retryErr != nil {
+		t.Error(retryErr.Error())
+	} else {
 		logObj, err := s.Client.Operations.GetAppsAppCallsCallLog(cfg)
 		if err != nil {
 			t.Errorf("Unexpected error: %s", err)
@@ -277,115 +289,120 @@ func TestRouteExecutions(t *testing.T) {
 			t.Errorf("Log entry must contain `Second line` "+
 				"string, but got: %v", logObj.Payload.Log.Log)
 		}
+	}
 
-		DeleteApp(t, s.Context, s.Client, s.AppName)
+	DeleteApp(t, s.Context, s.Client, s.AppName)
+}
+
+func TestCallResponseHeadersMatch(t *testing.T) {
+	t.Parallel()
+	s := SetupDefaultSuite()
+	CreateApp(t, s.Context, s.Client, s.AppName, map[string]string{})
+	routePath := "/os.environ"
+	image := "denismakogon/os.environ"
+	routeType := "sync"
+	CreateRoute(t, s.Context, s.Client, s.AppName, routePath, image, routeType,
+		s.Format, s.Timeout, s.IdleTimeout, s.RouteConfig, s.RouteHeaders)
+
+	u := url.URL{
+		Scheme: "http",
+		Host:   Host(),
+	}
+	u.Path = path.Join(u.Path, "r", s.AppName, routePath)
+	content := &bytes.Buffer{}
+	output := &bytes.Buffer{}
+	CallFN(u.String(), content, output, "POST",
+		[]string{
+			"ACCEPT: application/xml",
+			"ACCEPT: application/json; q=0.2",
+		})
+	res := output.String()
+	if !strings.Contains("application/xml, application/json; q=0.2", res) {
+		t.Errorf("HEADER_ACCEPT='application/xml, application/json; q=0.2' "+
+			"should be in output, have:%s\n", res)
+	}
+	DeleteRoute(t, s.Context, s.Client, s.AppName, routePath)
+	DeleteApp(t, s.Context, s.Client, s.AppName)
+}
+
+func TestCanWriteLogs(t *testing.T) {
+	t.Parallel()
+	s := SetupDefaultSuite()
+	routePath := "/log"
+	image := "funcy/log:0.0.1"
+	routeType := "async"
+
+	CreateApp(t, s.Context, s.Client, s.AppName, map[string]string{})
+	CreateRoute(t, s.Context, s.Client, s.AppName, routePath, image, routeType,
+		s.Format, s.Timeout, s.IdleTimeout, s.RouteConfig, s.RouteHeaders)
+
+	u := url.URL{
+		Scheme: "http",
+		Host:   Host(),
+	}
+	u.Path = path.Join(u.Path, "r", s.AppName, routePath)
+	content := &bytes.Buffer{}
+	json.NewEncoder(content).Encode(struct {
+		Size int
+	}{Size: 20})
+
+	callID := CallAsync(t, u, content)
+
+	cfg := &operations.GetAppsAppCallsCallLogParams{
+		Call:    callID,
+		App:     s.AppName,
+		Context: s.Context,
+	}
+
+	retryErr := APICallWithRetry(t, 10, time.Second*2, func() (err error) {
+		_, err = s.Client.Operations.GetAppsAppCallsCallLog(cfg)
+		return err
 	})
 
-	t.Run("verify-headers-separator", func(t *testing.T) {
-		t.Parallel()
-		s := SetupDefaultSuite()
-		CreateApp(t, s.Context, s.Client, s.AppName, map[string]string{})
-		routePath := "/os.environ"
-		image := "denismakogon/os.environ"
-		routeType := "sync"
-		CreateRoute(t, s.Context, s.Client, s.AppName, routePath, image, routeType,
-			s.Format, s.RouteConfig, s.RouteHeaders)
+	if retryErr != nil {
+		t.Error(retryErr.Error())
+	}
 
-		u := url.URL{
-			Scheme: "http",
-			Host:   Host(),
-		}
-		u.Path = path.Join(u.Path, "r", s.AppName, routePath)
-		content := &bytes.Buffer{}
-		output := &bytes.Buffer{}
-		CallFN(u.String(), content, output, "POST",
-			[]string{
-				"ACCEPT: application/xml",
-				"ACCEPT: application/json; q=0.2",
-			})
-		res := output.String()
-		if !strings.Contains("application/xml, application/json; q=0.2", res) {
-			t.Errorf("HEADER_ACCEPT='application/xml, application/json; q=0.2' "+
-				"should be in output, have:%s\n", res)
-		}
-		DeleteRoute(t, s.Context, s.Client, s.AppName, routePath)
-		DeleteApp(t, s.Context, s.Client, s.AppName)
+	DeleteApp(t, s.Context, s.Client, s.AppName)
+}
+
+func TestOversizedLog(t *testing.T) {
+	t.Parallel()
+	s := SetupDefaultSuite()
+	routePath := "/log"
+	image := "funcy/log:0.0.1"
+	routeType := "async"
+
+	CreateApp(t, s.Context, s.Client, s.AppName, map[string]string{})
+	CreateRoute(t, s.Context, s.Client, s.AppName, routePath, image, routeType,
+		s.Format, s.Timeout, s.IdleTimeout, s.RouteConfig, s.RouteHeaders)
+
+	size := 1 * 1024 * 1024 * 1024
+	u := url.URL{
+		Scheme: "http",
+		Host:   Host(),
+	}
+	u.Path = path.Join(u.Path, "r", s.AppName, routePath)
+	content := &bytes.Buffer{}
+	json.NewEncoder(content).Encode(struct {
+		Size int
+	}{Size: size}) //exceeding log by 1 symbol
+
+	callID := CallAsync(t, u, content)
+
+	cfg := &operations.GetAppsAppCallsCallLogParams{
+		Call:    callID,
+		App:     s.AppName,
+		Context: s.Context,
+	}
+
+	retryErr := APICallWithRetry(t, 10, time.Second*2, func() (err error) {
+		_, err = s.Client.Operations.GetAppsAppCallsCallLog(cfg)
+		return err
 	})
-
-	t.Run("exec-log-test", func(t *testing.T) {
-		//XXX: Fix this test.
-		t.Skip("Flaky test needs to be rewritten. https://github.com/fnproject/fn/issues/253")
-		t.Parallel()
-		s := SetupDefaultSuite()
-		routePath := "/log"
-		image := "funcy/log:0.0.1"
-		routeType := "async"
-
-		CreateApp(t, s.Context, s.Client, s.AppName, map[string]string{})
-		CreateRoute(t, s.Context, s.Client, s.AppName, routePath, image, routeType,
-			s.Format, s.RouteConfig, s.RouteHeaders)
-
-		u := url.URL{
-			Scheme: "http",
-			Host:   Host(),
-		}
-		u.Path = path.Join(u.Path, "r", s.AppName, routePath)
-		content := &bytes.Buffer{}
-		json.NewEncoder(content).Encode(struct {
-			Size int
-		}{Size: 20})
-
-		callID := CallAsync(t, u, content)
-		time.Sleep(10 * time.Second)
-
-		cfg := &operations.GetAppsAppCallsCallLogParams{
-			Call:    callID,
-			App:     s.AppName,
-			Context: s.Context,
-		}
-
-		_, err := s.Client.Operations.GetAppsAppCallsCallLog(cfg)
-
-		if err != nil {
-			t.Errorf("Unexpected error: %s", err)
-		}
-
-		DeleteApp(t, s.Context, s.Client, s.AppName)
-	})
-
-	t.Run("exec-oversized-log-test", func(t *testing.T) {
-		t.Parallel()
-		t.Skip("Skipped until fix for https://gitlab-odx.oracle.com/odx/functions/issues/86.")
-
-		s := SetupDefaultSuite()
-		routePath := "/log"
-		image := "funcy/log:0.0.1"
-		routeType := "async"
-
-		CreateApp(t, s.Context, s.Client, s.AppName, map[string]string{})
-		CreateRoute(t, s.Context, s.Client, s.AppName, routePath, image, routeType,
-			s.Format, s.RouteConfig, s.RouteHeaders)
-
-		size := 1 * 1024 * 1024 * 1024
-		u := url.URL{
-			Scheme: "http",
-			Host:   Host(),
-		}
-		u.Path = path.Join(u.Path, "r", s.AppName, routePath)
-		content := &bytes.Buffer{}
-		json.NewEncoder(content).Encode(struct {
-			Size int
-		}{Size: size}) //exceeding log by 1 symbol
-
-		callID := CallAsync(t, u, content)
-		time.Sleep(5 * time.Second)
-
-		cfg := &operations.GetAppsAppCallsCallLogParams{
-			Call:    callID,
-			App:     s.AppName,
-			Context: s.Context,
-		}
-
+	if retryErr != nil {
+		t.Error(retryErr.Error())
+	} else {
 		logObj, err := s.Client.Operations.GetAppsAppCallsCallLog(cfg)
 		if err != nil {
 			t.Errorf("Unexpected error: %s", err)
@@ -394,7 +411,7 @@ func TestRouteExecutions(t *testing.T) {
 			t.Errorf("Log entry suppose to be truncated up to expected size %v, got %v",
 				size/1024, len(logObj.Payload.Log.Log))
 		}
-		DeleteApp(t, s.Context, s.Client, s.AppName)
-	})
 
+	}
+	DeleteApp(t, s.Context, s.Client, s.AppName)
 }