diff --git a/integration/dockerfiles/Dockerfile_relative_copy b/integration/dockerfiles/Dockerfile_relative_copy
new file mode 100644
index 000000000..2ee928020
--- /dev/null
+++ b/integration/dockerfiles/Dockerfile_relative_copy
@@ -0,0 +1,3 @@
+FROM alpine@sha256:5ce5f501c457015c4b91f91a15ac69157d9b06f1a75cf9107bf2b62e0843983a
+COPY foo foo
+COPY foo /foodir/
diff --git a/integration/images.go b/integration/images.go
index 50fea929a..c52d6d40d 100644
--- a/integration/images.go
+++ b/integration/images.go
@@ -356,28 +356,45 @@ func (d *DockerFileBuilder) buildCachedImages(config *integrationTestConfig, cac
 }
 
 // buildRelativePathsImage builds the images for testing passing relatives paths to Kaniko
-func (d *DockerFileBuilder) buildRelativePathsImage(imageRepo, dockerfile, serviceAccount string) error {
+func (d *DockerFileBuilder) buildRelativePathsImage(imageRepo, dockerfile, serviceAccount, buildContextPath string) error {
 	_, ex, _, _ := runtime.Caller(0)
 	cwd := filepath.Dir(ex)
 
-	buildContextPath := "./relative-subdirectory"
-	kanikoImage := GetKanikoImage(imageRepo, dockerfile)
+	dockerImage := GetDockerImage(imageRepo, "test_relative_"+dockerfile)
+	kanikoImage := GetKanikoImage(imageRepo, "test_relative_"+dockerfile)
+
+	dockerCmd := exec.Command("docker",
+		append([]string{"build",
+			"-t", dockerImage,
+			"-f", dockerfile,
+			"./context"},
+		)...,
+	)
+
+	timer := timing.Start(dockerfile + "_docker")
+	out, err := RunCommandWithoutTest(dockerCmd)
+	timing.DefaultRun.Stop(timer)
+	if err != nil {
+		return fmt.Errorf("Failed to build image %s with docker command \"%s\": %s %s", dockerImage, dockerCmd.Args, err, string(out))
+	}
 
 	dockerRunFlags := []string{"run", "--net=host", "-v", cwd + ":/workspace"}
 	dockerRunFlags = addServiceAccountFlags(dockerRunFlags, serviceAccount)
 	dockerRunFlags = append(dockerRunFlags, ExecutorImage,
 		"-f", dockerfile,
 		"-d", kanikoImage,
-		"--digest-file", "./digest",
 		"-c", buildContextPath)
 
 	kanikoCmd := exec.Command("docker", dockerRunFlags...)
 
-	timer := timing.Start(dockerfile + "_kaniko_relative_paths")
-	_, err := RunCommandWithoutTest(kanikoCmd)
+	timer = timing.Start(dockerfile + "_kaniko_relative_paths")
+	out, err = RunCommandWithoutTest(kanikoCmd)
 	timing.DefaultRun.Stop(timer)
+
 	if err != nil {
-		return fmt.Errorf("Failed to build relative path image %s with kaniko command \"%s\": %s", kanikoImage, kanikoCmd.Args, err)
+		return fmt.Errorf(
+			"Failed to build relative path image %s with kaniko command \"%s\": %s\n%s",
+			kanikoImage, kanikoCmd.Args, err, string(out))
 	}
 
 	return nil
diff --git a/integration/integration_test.go b/integration/integration_test.go
index b202aa978..f70522b35 100644
--- a/integration/integration_test.go
+++ b/integration/integration_test.go
@@ -383,14 +383,27 @@ func TestCache(t *testing.T) {
 
 func TestRelativePaths(t *testing.T) {
 
-	dockerfile := "Dockerfile_test_copy"
+	dockerfile := "Dockerfile_relative_copy"
 
 	t.Run("test_relative_"+dockerfile, func(t *testing.T) {
 		t.Parallel()
-		imageBuilder.buildRelativePathsImage(config.imageRepo, dockerfile, config.serviceAccount)
 
-		dockerImage := GetDockerImage(config.imageRepo, dockerfile)
-		kanikoImage := GetKanikoImage(config.imageRepo, dockerfile)
+		dockerfile = filepath.Join("./dockerfiles", dockerfile)
+
+		contextPath := "./context"
+
+		err := imageBuilder.buildRelativePathsImage(
+			config.imageRepo,
+			dockerfile,
+			config.serviceAccount,
+			contextPath,
+		)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		dockerImage := GetDockerImage(config.imageRepo, "test_relative_"+dockerfile)
+		kanikoImage := GetKanikoImage(config.imageRepo, "test_relative_"+dockerfile)
 
 		diff := containerDiff(t, daemonPrefix+dockerImage, kanikoImage, "--no-cache")