DecompressCommand can return 3 types of wrapped errors

creativeprojects · creativeprojects · commit 897e2c7d497c · 2021-01-21T18:33:21.000Z
diff --git a/arm.go b/arm.go
@@ -1,6 +1,7 @@
 package selfupdate
 
 import (
+	// unsafe is used to get a private variable from the runtime package
 	_ "unsafe"
 )
 
diff --git a/decompress.go b/decompress.go
@@ -32,9 +32,15 @@ var (
 )
 
 // DecompressCommand decompresses the given source. Archive and compression format is
-// automatically detected from 'url' parameter, which represents the URL of asset.
+// automatically detected from 'url' parameter, which represents the URL of asset,
+// or simply a filename (with an extension).
 // This returns a reader for the decompressed command given by 'cmd'. '.zip',
 // '.tar.gz', '.tar.xz', '.tgz', '.gz', '.bz2' and '.xz' are supported.
+//
+// These wrapped errors can be returned:
+//  - ErrCannotDecompressFile
+//  - ErrExecutableNotFoundInArchive
+//  - ErrCannotReadStream
 func DecompressCommand(src io.Reader, url, cmd, os, arch string) (io.Reader, error) {
 	for _, fileType := range fileTypes {
 		if strings.HasSuffix(url, fileType.ext) {
@@ -52,13 +58,13 @@ func unzip(src io.Reader, cmd, os, arch string) (io.Reader, error) {
 	// So we need to read the HTTP response into a buffer at first.
 	buf, err := ioutil.ReadAll(src)
 	if err != nil {
-		return nil, fmt.Errorf("failed to create buffer for zip file: %s", err)
+		return nil, fmt.Errorf("%w for zip file: %v", ErrCannotReadStream, err)
 	}
 
 	r := bytes.NewReader(buf)
 	z, err := zip.NewReader(r, r.Size())
 	if err != nil {
-		return nil, fmt.Errorf("failed to decompress zip file: %s", err)
+		return nil, fmt.Errorf("%w zip file: %s", ErrCannotDecompressFile, err)
 	}
 
 	for _, file := range z.File {
@@ -69,15 +75,15 @@ func unzip(src io.Reader, cmd, os, arch string) (io.Reader, error) {
 		}
 	}
 
-	return nil, fmt.Errorf("file %q is not found", cmd)
+	return nil, fmt.Errorf("%w in zip file: %q", ErrExecutableNotFoundInArchive, cmd)
 }
 
 func untar(src io.Reader, cmd, os, arch string) (io.Reader, error) {
 	log.Print("Decompressing tar.gz file")
 
 	gz, err := gzip.NewReader(src)
 	if err != nil {
-		return nil, fmt.Errorf("failed to decompress .tar.gz file: %s", err)
+		return nil, fmt.Errorf("%w tar.gz file: %s", ErrCannotDecompressFile, err)
 	}
 
 	return unarchiveTar(gz, cmd, os, arch)
@@ -88,12 +94,12 @@ func gunzip(src io.Reader, cmd, os, arch string) (io.Reader, error) {
 
 	r, err := gzip.NewReader(src)
 	if err != nil {
-		return nil, fmt.Errorf("failed to decompress gzip file: %s", err)
+		return nil, fmt.Errorf("%w gzip file: %s", ErrCannotDecompressFile, err)
 	}
 
 	name := r.Header.Name
 	if !matchExecutableName(cmd, os, arch, name) {
-		return nil, fmt.Errorf("file name '%s' does not match to command '%s' found", name, cmd)
+		return nil, fmt.Errorf("%w: expected %q but found %q", ErrExecutableNotFoundInArchive, cmd, name)
 	}
 
 	log.Printf("Executable file %q was found in gzip file", name)
@@ -105,7 +111,7 @@ func untarxz(src io.Reader, cmd, os, arch string) (io.Reader, error) {
 
 	xzip, err := xz.NewReader(src)
 	if err != nil {
-		return nil, fmt.Errorf("failed to decompress .tar.xz file: %s", err)
+		return nil, fmt.Errorf("%w .tar.xz file: %s", ErrCannotDecompressFile, err)
 	}
 
 	return unarchiveTar(xzip, cmd, os, arch)
@@ -116,7 +122,7 @@ func unxz(src io.Reader, cmd, os, arch string) (io.Reader, error) {
 
 	xzip, err := xz.NewReader(src)
 	if err != nil {
-		return nil, fmt.Errorf("failed to decompress xzip file: %s", err)
+		return nil, fmt.Errorf("%w xzip file: %s", ErrCannotDecompressFile, err)
 	}
 
 	log.Printf("Decompressed file from xzip is assumed to be an executable: %s", cmd)
@@ -160,13 +166,13 @@ func unarchiveTar(src io.Reader, cmd, os, arch string) (io.Reader, error) {
 			break
 		}
 		if err != nil {
-			return nil, fmt.Errorf("failed to unarchive tar file: %s", err)
+			return nil, fmt.Errorf("%w tar file: %s", ErrCannotDecompressFile, err)
 		}
 		_, name := filepath.Split(h.Name)
 		if matchExecutableName(cmd, os, arch, name) {
 			log.Printf("Executable file %q was found in tar archive", h.Name)
 			return t, nil
 		}
 	}
-	return nil, fmt.Errorf("file %q is not found in tar", cmd)
+	return nil, fmt.Errorf("%w in tar: %q", ErrExecutableNotFoundInArchive, cmd)
 }
diff --git a/decompress_test.go b/decompress_test.go
@@ -2,6 +2,7 @@ package selfupdate
 
 import (
 	"bytes"
+	"errors"
 	"io/ioutil"
 	"os"
 	"path/filepath"
@@ -71,12 +72,12 @@ func TestDecompressInvalidArchive(t *testing.T) {
 		name string
 		msg  string
 	}{
-		{"testdata/invalid.zip", "not a valid zip file"},
+		{"testdata/invalid.zip", "failed to decompress zip file"},
 		{"testdata/invalid.gz", "failed to decompress gzip file"},
-		{"testdata/invalid-tar.tar.gz", "failed to unarchive tar file"},
-		{"testdata/invalid-gzip.tar.gz", "failed to decompress .tar.gz file"},
+		{"testdata/invalid-tar.tar.gz", "failed to decompress tar file"},
+		{"testdata/invalid-gzip.tar.gz", "failed to decompress tar.gz file"},
 		{"testdata/invalid.xz", "failed to decompress xzip file"},
-		{"testdata/invalid-tar.tar.xz", "failed to unarchive tar file"},
+		{"testdata/invalid-tar.tar.xz", "failed to decompress tar file"},
 		{"testdata/invalid-xz.tar.xz", "failed to decompress .tar.xz file"},
 	} {
 		f, err := os.Open(a.name)
@@ -85,9 +86,8 @@ func TestDecompressInvalidArchive(t *testing.T) {
 		ext := getArchiveFileExt(a.name)
 		url := "https://github.com/foo/bar/releases/download/v1.2.3/bar" + ext
 		_, err = DecompressCommand(f, url, "bar", runtime.GOOS, runtime.GOOS)
-		if err == nil {
-			t.Fatal("Error should be raised")
-		}
+		require.Error(t, err)
+		assert.True(t, errors.Is(err, ErrCannotDecompressFile))
 		if !strings.Contains(err.Error(), a.msg) {
 			t.Fatal("Unexpected error:", err)
 		}
@@ -99,11 +99,11 @@ func TestTargetNotFound(t *testing.T) {
 		name string
 		msg  string
 	}{
-		{"testdata/empty.zip", "is not found"},
-		{"testdata/bar-not-found.zip", "is not found"},
-		{"testdata/bar-not-found.gzip", "does not match to command"},
-		{"testdata/empty.tar.gz", "is not found"},
-		{"testdata/bar-not-found.tar.gz", "is not found"},
+		{"testdata/empty.zip", "not found"},
+		{"testdata/bar-not-found.zip", "not found"},
+		{"testdata/bar-not-found.gzip", "not found"},
+		{"testdata/empty.tar.gz", "not found"},
+		{"testdata/bar-not-found.tar.gz", "not found"},
 	} {
 		t.Run(tc.name, func(t *testing.T) {
 			f, err := os.Open(tc.name)
@@ -112,9 +112,8 @@ func TestTargetNotFound(t *testing.T) {
 			ext := getArchiveFileExt(tc.name)
 			url := "https://github.com/foo/bar/releases/download/v1.2.3/bar" + ext
 			_, err = DecompressCommand(f, url, "bar", runtime.GOOS, runtime.GOOS)
-			if err == nil {
-				t.Fatal("Error should be raised for")
-			}
+			require.Error(t, err)
+			assert.True(t, errors.Is(err, ErrExecutableNotFoundInArchive))
 			if !strings.Contains(err.Error(), tc.msg) {
 				t.Fatal("Unexpected error:", err)
 			}
diff --git a/errors.go b/errors.go
@@ -4,13 +4,16 @@ import "errors"
 
 // Possible errors returned
 var (
-	ErrInvalidSlug              = errors.New("invalid slug format, expected 'owner/name'")
-	ErrIncorrectParameterOwner  = errors.New("incorrect parameter \"owner\"")
-	ErrIncorrectParameterRepo   = errors.New("incorrect parameter \"repo\"")
-	ErrAssetNotFound            = errors.New("asset not found")
-	ErrIncorrectChecksumFile    = errors.New("incorrect checksum file format")
-	ErrChecksumValidationFailed = errors.New("sha256 validation failed")
-	ErrHashNotFound             = errors.New("hash not found in checksum file")
-	ErrECDSAValidationFailed    = errors.New("ECDSA signature verification failed")
-	ErrInvalidECDSASignature    = errors.New("invalid ECDSA signature")
+	ErrInvalidSlug                 = errors.New("invalid slug format, expected 'owner/name'")
+	ErrIncorrectParameterOwner     = errors.New("incorrect parameter \"owner\"")
+	ErrIncorrectParameterRepo      = errors.New("incorrect parameter \"repo\"")
+	ErrAssetNotFound               = errors.New("asset not found")
+	ErrIncorrectChecksumFile       = errors.New("incorrect checksum file format")
+	ErrChecksumValidationFailed    = errors.New("sha256 validation failed")
+	ErrHashNotFound                = errors.New("hash not found in checksum file")
+	ErrECDSAValidationFailed       = errors.New("ECDSA signature verification failed")
+	ErrInvalidECDSASignature       = errors.New("invalid ECDSA signature")
+	ErrCannotDecompressFile        = errors.New("failed to decompress")
+	ErrExecutableNotFoundInArchive = errors.New("executable not found")
+	ErrCannotReadStream            = errors.New("error reading from stream")
 )
diff --git a/update_test.go b/update_test.go
@@ -229,7 +229,7 @@ func TestBrokenBinaryUpdate(t *testing.T) {
 	if err == nil {
 		t.Fatal("Error should occur for broken package")
 	}
-	if !strings.Contains(err.Error(), "failed to decompress .tar.gz file") {
+	if !strings.Contains(err.Error(), "failed to decompress tar.gz file") {
 		t.Fatal("Unexpected error:", err)
 	}
 }

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`	`1`	`package selfupdate`
`2`	`2`
`3`	`3`	`import (`
	`4`	`+ // unsafe is used to get a private variable from the runtime package`
`4`	`5`	`_ "unsafe"`
`5`	`6`	`)`
`6`	`7`
Original file line number	Diff line number	Diff line change
`@@ -32,9 +32,15 @@ var (`
`32`	`32`	`)`
`33`	`33`
`34`	`34`	`// DecompressCommand decompresses the given source. Archive and compression format is`
`35`		`-// automatically detected from 'url' parameter, which represents the URL of asset.`
	`35`	`+// automatically detected from 'url' parameter, which represents the URL of asset,`
	`36`	`+// or simply a filename (with an extension).`
`36`	`37`	`// This returns a reader for the decompressed command given by 'cmd'. '.zip',`
`37`	`38`	`// '.tar.gz', '.tar.xz', '.tgz', '.gz', '.bz2' and '.xz' are supported.`
	`39`	`+//`
	`40`	`+// These wrapped errors can be returned:`
	`41`	`+// - ErrCannotDecompressFile`
	`42`	`+// - ErrExecutableNotFoundInArchive`
	`43`	`+// - ErrCannotReadStream`
`38`	`44`	`func DecompressCommand(src io.Reader, url, cmd, os, arch string) (io.Reader, error) {`
`39`	`45`	`for _, fileType := range fileTypes {`
`40`	`46`	`if strings.HasSuffix(url, fileType.ext) {`
`@@ -52,13 +58,13 @@ func unzip(src io.Reader, cmd, os, arch string) (io.Reader, error) {`
`52`	`58`	`// So we need to read the HTTP response into a buffer at first.`
`53`	`59`	`buf, err := ioutil.ReadAll(src)`
`54`	`60`	`if err != nil {`
`55`		`- return nil, fmt.Errorf("failed to create buffer for zip file: %s", err)`
	`61`	`+ return nil, fmt.Errorf("%w for zip file: %v", ErrCannotReadStream, err)`
`56`	`62`	`}`
`57`	`63`
`58`	`64`	`r := bytes.NewReader(buf)`
`59`	`65`	`z, err := zip.NewReader(r, r.Size())`
`60`	`66`	`if err != nil {`
`61`		`- return nil, fmt.Errorf("failed to decompress zip file: %s", err)`
	`67`	`+ return nil, fmt.Errorf("%w zip file: %s", ErrCannotDecompressFile, err)`
`62`	`68`	`}`
`63`	`69`
`64`	`70`	`for _, file := range z.File {`
`@@ -69,15 +75,15 @@ func unzip(src io.Reader, cmd, os, arch string) (io.Reader, error) {`
`69`	`75`	`}`
`70`	`76`	`}`
`71`	`77`
`72`		`- return nil, fmt.Errorf("file %q is not found", cmd)`
	`78`	`+ return nil, fmt.Errorf("%w in zip file: %q", ErrExecutableNotFoundInArchive, cmd)`
`73`	`79`	`}`
`74`	`80`
`75`	`81`	`func untar(src io.Reader, cmd, os, arch string) (io.Reader, error) {`
`76`	`82`	`log.Print("Decompressing tar.gz file")`
`77`	`83`
`78`	`84`	`gz, err := gzip.NewReader(src)`
`79`	`85`	`if err != nil {`
`80`		`- return nil, fmt.Errorf("failed to decompress .tar.gz file: %s", err)`
	`86`	`+ return nil, fmt.Errorf("%w tar.gz file: %s", ErrCannotDecompressFile, err)`
`81`	`87`	`}`
`82`	`88`
`83`	`89`	`return unarchiveTar(gz, cmd, os, arch)`
`@@ -88,12 +94,12 @@ func gunzip(src io.Reader, cmd, os, arch string) (io.Reader, error) {`
`88`	`94`
`89`	`95`	`r, err := gzip.NewReader(src)`
`90`	`96`	`if err != nil {`
`91`		`- return nil, fmt.Errorf("failed to decompress gzip file: %s", err)`
	`97`	`+ return nil, fmt.Errorf("%w gzip file: %s", ErrCannotDecompressFile, err)`
`92`	`98`	`}`
`93`	`99`
`94`	`100`	`name := r.Header.Name`
`95`	`101`	`if !matchExecutableName(cmd, os, arch, name) {`
`96`		`- return nil, fmt.Errorf("file name '%s' does not match to command '%s' found", name, cmd)`
	`102`	`+ return nil, fmt.Errorf("%w: expected %q but found %q", ErrExecutableNotFoundInArchive, cmd, name)`
`97`	`103`	`}`
`98`	`104`
`99`	`105`	`log.Printf("Executable file %q was found in gzip file", name)`
`@@ -105,7 +111,7 @@ func untarxz(src io.Reader, cmd, os, arch string) (io.Reader, error) {`
`105`	`111`
`106`	`112`	`xzip, err := xz.NewReader(src)`
`107`	`113`	`if err != nil {`
`108`		`- return nil, fmt.Errorf("failed to decompress .tar.xz file: %s", err)`
	`114`	`+ return nil, fmt.Errorf("%w .tar.xz file: %s", ErrCannotDecompressFile, err)`
`109`	`115`	`}`
`110`	`116`
`111`	`117`	`return unarchiveTar(xzip, cmd, os, arch)`
`@@ -116,7 +122,7 @@ func unxz(src io.Reader, cmd, os, arch string) (io.Reader, error) {`
`116`	`122`
`117`	`123`	`xzip, err := xz.NewReader(src)`
`118`	`124`	`if err != nil {`
`119`		`- return nil, fmt.Errorf("failed to decompress xzip file: %s", err)`
	`125`	`+ return nil, fmt.Errorf("%w xzip file: %s", ErrCannotDecompressFile, err)`
`120`	`126`	`}`
`121`	`127`
`122`	`128`	`log.Printf("Decompressed file from xzip is assumed to be an executable: %s", cmd)`
`@@ -160,13 +166,13 @@ func unarchiveTar(src io.Reader, cmd, os, arch string) (io.Reader, error) {`
`160`	`166`	`break`
`161`	`167`	`}`
`162`	`168`	`if err != nil {`
`163`		`- return nil, fmt.Errorf("failed to unarchive tar file: %s", err)`
	`169`	`+ return nil, fmt.Errorf("%w tar file: %s", ErrCannotDecompressFile, err)`
`164`	`170`	`}`
`165`	`171`	`_, name := filepath.Split(h.Name)`
`166`	`172`	`if matchExecutableName(cmd, os, arch, name) {`
`167`	`173`	`log.Printf("Executable file %q was found in tar archive", h.Name)`
`168`	`174`	`return t, nil`
`169`	`175`	`}`
`170`	`176`	`}`
`171`		`- return nil, fmt.Errorf("file %q is not found in tar", cmd)`
	`177`	`+ return nil, fmt.Errorf("%w in tar: %q", ErrExecutableNotFoundInArchive, cmd)`
`172`	`178`	`}`
Original file line number	Diff line number	Diff line change
`@@ -229,7 +229,7 @@ func TestBrokenBinaryUpdate(t *testing.T) {`
`229`	`229`	`if err == nil {`
`230`	`230`	`t.Fatal("Error should occur for broken package")`
`231`	`231`	`}`
`232`		`- if !strings.Contains(err.Error(), "failed to decompress .tar.gz file") {`
	`232`	`+ if !strings.Contains(err.Error(), "failed to decompress tar.gz file") {`
`233`	`233`	`t.Fatal("Unexpected error:", err)`
`234`	`234`	`}`
`235`	`235`	`}`