From 37a1463f0af704cf9655f770f3d86253ae502886 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Adolfo=20Garc=C3=ADa=20Veytia=20=28Puerco=29?= Date: Mon, 17 May 2021 18:54:40 -0500 Subject: [PATCH 1/2] SPDX pkg unit and integration tests --- pkg/spdx/spdx_test.go | 151 +++++++++++++++++++++++++++++++++++++ pkg/spdx/spdx_unit_test.go | 128 +++++++++++++++++++++++++++++++ 2 files changed, 279 insertions(+) create mode 100644 pkg/spdx/spdx_test.go create mode 100644 pkg/spdx/spdx_unit_test.go diff --git a/pkg/spdx/spdx_test.go b/pkg/spdx/spdx_test.go new file mode 100644 index 00000000000..dca6713512f --- /dev/null +++ b/pkg/spdx/spdx_test.go @@ -0,0 +1,151 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package spdx_test + +import ( + "testing" + + "github.com/pkg/errors" + "github.com/stretchr/testify/require" + "k8s.io/release/pkg/spdx" + "k8s.io/release/pkg/spdx/spdxfakes" +) + +var ( + err = errors.New("synthetic error") + manifest = &spdx.ArchiveManifest{ + ConfigFilename: "9283479287498237498.json", + RepoTags: []string{"image-test:latest"}, + LayerFiles: []string{"ksjdhfkjsdhfkjsdhf/layer.tar"}, + } +) + +func TestPackageFromImageTarball(t *testing.T) { + for _, tc := range []struct { + prepare func(*spdxfakes.FakeSpdxImplementation) + shouldError bool + }{ + { // success + prepare: func(mock *spdxfakes.FakeSpdxImplementation) { + mock.ExtractTarballTmpReturns("/mock/path", nil) + mock.ReadArchiveManifestReturns(manifest, nil) + mock.PackageFromLayerTarBallReturns(&spdx.Package{Name: "test"}, nil) + }, + shouldError: false, + }, + { + prepare: func(mock *spdxfakes.FakeSpdxImplementation) { + mock.ReadArchiveManifestReturns(manifest, nil) + mock.ExtractTarballTmpReturns("", err) + }, + shouldError: true, + }, + { + prepare: func(mock *spdxfakes.FakeSpdxImplementation) { + mock.ReadArchiveManifestReturns(nil, err) + }, + shouldError: true, + }, + { + prepare: func(mock *spdxfakes.FakeSpdxImplementation) { + mock.ReadArchiveManifestReturns(manifest, nil) + mock.PackageFromLayerTarBallReturns(nil, err) + }, + shouldError: true, + }, + } { + sut := spdx.NewSPDX() + sut.Options().AnalyzeLayers = false + mock := &spdxfakes.FakeSpdxImplementation{} + tc.prepare(mock) + sut.SetImplementation(mock) + + dir, err := sut.PackageFromImageTarball("mock.tar", &spdx.TarballOptions{}) + if tc.shouldError { + require.NotNil(t, err) + } else { + require.Nil(t, err) + require.NotNil(t, dir) + } + } +} + +func TestExtractTarballTmp(t *testing.T) { + for _, tc := range []struct { + prepare func(*spdxfakes.FakeSpdxImplementation) + shouldError bool + }{ + { // success + prepare: func(mock *spdxfakes.FakeSpdxImplementation) { + mock.ExtractTarballTmpReturns("/mock/path", nil) + }, + shouldError: false, + }, + { // error + prepare: func(mock *spdxfakes.FakeSpdxImplementation) { + mock.ExtractTarballTmpReturns("/mock/path", err) + }, + shouldError: true, + }, + } { + sut := spdx.NewSPDX() + mock := &spdxfakes.FakeSpdxImplementation{} + tc.prepare(mock) + sut.SetImplementation(mock) + + path, err := sut.ExtractTarballTmp("/mock/path") + if tc.shouldError { + require.NotNil(t, err) + } else { + require.NotEmpty(t, path) + require.Nil(t, err) + } + } +} + +func TestPullImagesToArchive(t *testing.T) { + for _, tc := range []struct { + prepare func(*spdxfakes.FakeSpdxImplementation) + shouldError bool + }{ + { // success + prepare: func(mock *spdxfakes.FakeSpdxImplementation) { + mock.PullImagesToArchiveReturns(nil) + }, + shouldError: false, + }, + { // success + prepare: func(mock *spdxfakes.FakeSpdxImplementation) { + mock.PullImagesToArchiveReturns(err) + }, + shouldError: true, + }, + } { + sut := spdx.NewSPDX() + sut.Options().AnalyzeLayers = false + mock := &spdxfakes.FakeSpdxImplementation{} + tc.prepare(mock) + sut.SetImplementation(mock) + + err := sut.PullImagesToArchive("mock-image:latest", "/tmp") + if tc.shouldError { + require.NotNil(t, err) + } else { + require.Nil(t, err) + } + } +} diff --git a/pkg/spdx/spdx_unit_test.go b/pkg/spdx/spdx_unit_test.go new file mode 100644 index 00000000000..b5bbad32a1f --- /dev/null +++ b/pkg/spdx/spdx_unit_test.go @@ -0,0 +1,128 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package spdx + +import ( + "bytes" + "compress/gzip" + "encoding/base64" + "io/ioutil" + "os" + "path/filepath" + "testing" + + "github.com/stretchr/testify/require" + "sigs.k8s.io/release-utils/util" +) + +func TestUnitExtractTarballTmp(t *testing.T) { + tar := writeTestTarball(t) + require.NotNil(t, tar) + defer os.Remove(tar.Name()) + + sut := NewSPDX() + _, err := sut.ExtractTarballTmp("lsdjkflskdjfl") + require.NotNil(t, err) + dir, err := sut.ExtractTarballTmp(tar.Name()) + require.Nil(t, err, "extracting file") + defer os.RemoveAll(dir) + require.True(t, util.Exists(filepath.Join(dir, "/text.txt")), "checking directory") + require.True(t, util.Exists(filepath.Join(dir, "/subdir/text.txt")), "checking subdirectory") + require.True(t, util.Exists(dir), "checking directory") + + // Check files +} + +func TestReadArchiveManifest(t *testing.T) { + f, err := os.CreateTemp(os.TempDir(), "sample-manifest-*.json") + require.Nil(t, err) + defer os.Remove(f.Name()) + require.Nil(t, os.WriteFile( + f.Name(), []byte(sampleManifest), os.FileMode(0o644), + ), "writing test manifest file") + + sut := spdxDefaultImplementation{} + _, err = sut.ReadArchiveManifest("laksdjlakjsdlkjsd") + require.NotNil(t, err) + manifest, err := sut.ReadArchiveManifest(f.Name()) + require.Nil(t, err) + require.Equal( + t, "386bcf5c63de46c7066c42d4ae1c38af0689836e88fed37d1dca2d484b343cf5.json", + manifest.ConfigFilename, + ) + require.Equal(t, 1, len(manifest.RepoTags)) + require.Equal(t, "k8s.gcr.io/kube-apiserver-amd64:v1.22.0-alpha.1", manifest.RepoTags[0]) + require.Equal(t, 3, len(manifest.LayerFiles)) + for i, fname := range []string{ + "23e140cb8e03a12cba4ac571d9a7143cf5e2e9b72de3b33ce3243b4f7ad6a188/layer.tar", + "48dd73ececdf0f52a174ad33a469145824713bd2b73c6257ce1ba8502003ad4e/layer.tar", + "d397673d78556210baa112013c960cb95a3fd452e5c4a2ead2b26e5a458cd87f/layer.tar", + } { + require.Equal(t, fname, manifest.LayerFiles[i]) + } +} + +func TestPackageFromLayerTarBall(t *testing.T) { + tar := writeTestTarball(t) + require.NotNil(t, tar) + defer os.Remove(tar.Name()) + + sut := spdxDefaultImplementation{} + _, err := sut.PackageFromLayerTarBall("lsdkjflksdjflk", &TarballOptions{}) + require.NotNil(t, err) + pkg, err := sut.PackageFromLayerTarBall(tar.Name(), &TarballOptions{}) + require.Nil(t, err) + require.NotNil(t, pkg) + + require.NotNil(t, pkg.Checksum) + _, ok := pkg.Checksum["SHA256"] + require.True(t, ok, "checking if sha256 checksum is set") + _, ok = pkg.Checksum["SHA512"] + require.True(t, ok, "checking if sha512 checksum is set") + require.Equal(t, "5e75826e1baf84d5c5b26cc8fc3744f560ef0288c767f1cbc160124733fdc50e", pkg.Checksum["SHA256"]) + require.Equal(t, "f3b48a64a3d9db36fff10a9752dea6271725ddf125baf7026cdf09a2c352d9ff4effadb75da31e4310bc1b2513be441c86488b69d689353128f703563846c97e", pkg.Checksum["SHA512"]) +} + +func writeTestTarball(t *testing.T) *os.File { + // Create a testdire + tar, err := os.CreateTemp(os.TempDir(), "test-tar-*.tar.gz") + require.Nil(t, err) + + tardata, err := base64.StdEncoding.DecodeString(testTar) + require.Nil(t, err) + + reader := bytes.NewReader(tardata) + zipreader, err := gzip.NewReader(reader) + require.Nil(t, err) + + bindata, err := ioutil.ReadAll(zipreader) + require.Nil(t, err) + + require.Nil(t, os.WriteFile( + tar.Name(), bindata, os.FileMode(0o644)), "writing test tar file", + ) + return tar +} + +var testTar string = `H4sICPIFo2AAA2hlbGxvLnRhcgDt1EsKwjAUBdCMXUXcQPuS5rMFwaEraDGgUFpIE3D5puAPRYuD +VNR7Jm+QQh7c3hQly44Sa/U4hdV0O8+YUKTJkLRCMhKk0zHX+VdjLA6h9pyz6Ju66198N3H+pYpy +iM1273P+Bm/lX4mUvyQlkP8cLvkHdwhFOIQMd4wBG6Oe5y/1Xf6VNhXjlGGXB3+e/yY2O9e2PV/H +xvnOBTcsF59eCmZT5Cz+yXT/5bX/pMb3P030fw4rlB8AAAAAAAAAAAAAAAAA4CccAXRRwL4AKAAA +` + +var sampleManifest = `[{"Config":"386bcf5c63de46c7066c42d4ae1c38af0689836e88fed37d1dca2d484b343cf5.json","RepoTags":["k8s.gcr.io/kube-apiserver-amd64:v1.22.0-alpha.1"],"Layers":["23e140cb8e03a12cba4ac571d9a7143cf5e2e9b72de3b33ce3243b4f7ad6a188/layer.tar","48dd73ececdf0f52a174ad33a469145824713bd2b73c6257ce1ba8502003ad4e/layer.tar","d397673d78556210baa112013c960cb95a3fd452e5c4a2ead2b26e5a458cd87f/layer.tar"]}] +` From 67f53c4bf5cc6e2746bdd704b652c771950e7946 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Adolfo=20Garc=C3=ADa=20Veytia=20=28Puerco=29?= Date: Tue, 18 May 2021 09:12:14 -0500 Subject: [PATCH 2/2] Regenerate SPDX package fakes MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Adolfo García Veytia (Puerco) --- .../spdxfakes/fake_spdx_implementation.go | 366 ++++++++++++++++++ 1 file changed, 366 insertions(+) create mode 100644 pkg/spdx/spdxfakes/fake_spdx_implementation.go diff --git a/pkg/spdx/spdxfakes/fake_spdx_implementation.go b/pkg/spdx/spdxfakes/fake_spdx_implementation.go new file mode 100644 index 00000000000..7956d5f3b18 --- /dev/null +++ b/pkg/spdx/spdxfakes/fake_spdx_implementation.go @@ -0,0 +1,366 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by counterfeiter. DO NOT EDIT. +package spdxfakes + +import ( + "sync" + + "k8s.io/release/pkg/spdx" +) + +type FakeSpdxImplementation struct { + ExtractTarballTmpStub func(string) (string, error) + extractTarballTmpMutex sync.RWMutex + extractTarballTmpArgsForCall []struct { + arg1 string + } + extractTarballTmpReturns struct { + result1 string + result2 error + } + extractTarballTmpReturnsOnCall map[int]struct { + result1 string + result2 error + } + PackageFromLayerTarBallStub func(string, *spdx.TarballOptions) (*spdx.Package, error) + packageFromLayerTarBallMutex sync.RWMutex + packageFromLayerTarBallArgsForCall []struct { + arg1 string + arg2 *spdx.TarballOptions + } + packageFromLayerTarBallReturns struct { + result1 *spdx.Package + result2 error + } + packageFromLayerTarBallReturnsOnCall map[int]struct { + result1 *spdx.Package + result2 error + } + PullImagesToArchiveStub func(string, string) error + pullImagesToArchiveMutex sync.RWMutex + pullImagesToArchiveArgsForCall []struct { + arg1 string + arg2 string + } + pullImagesToArchiveReturns struct { + result1 error + } + pullImagesToArchiveReturnsOnCall map[int]struct { + result1 error + } + ReadArchiveManifestStub func(string) (*spdx.ArchiveManifest, error) + readArchiveManifestMutex sync.RWMutex + readArchiveManifestArgsForCall []struct { + arg1 string + } + readArchiveManifestReturns struct { + result1 *spdx.ArchiveManifest + result2 error + } + readArchiveManifestReturnsOnCall map[int]struct { + result1 *spdx.ArchiveManifest + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeSpdxImplementation) ExtractTarballTmp(arg1 string) (string, error) { + fake.extractTarballTmpMutex.Lock() + ret, specificReturn := fake.extractTarballTmpReturnsOnCall[len(fake.extractTarballTmpArgsForCall)] + fake.extractTarballTmpArgsForCall = append(fake.extractTarballTmpArgsForCall, struct { + arg1 string + }{arg1}) + stub := fake.ExtractTarballTmpStub + fakeReturns := fake.extractTarballTmpReturns + fake.recordInvocation("ExtractTarballTmp", []interface{}{arg1}) + fake.extractTarballTmpMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeSpdxImplementation) ExtractTarballTmpCallCount() int { + fake.extractTarballTmpMutex.RLock() + defer fake.extractTarballTmpMutex.RUnlock() + return len(fake.extractTarballTmpArgsForCall) +} + +func (fake *FakeSpdxImplementation) ExtractTarballTmpCalls(stub func(string) (string, error)) { + fake.extractTarballTmpMutex.Lock() + defer fake.extractTarballTmpMutex.Unlock() + fake.ExtractTarballTmpStub = stub +} + +func (fake *FakeSpdxImplementation) ExtractTarballTmpArgsForCall(i int) string { + fake.extractTarballTmpMutex.RLock() + defer fake.extractTarballTmpMutex.RUnlock() + argsForCall := fake.extractTarballTmpArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeSpdxImplementation) ExtractTarballTmpReturns(result1 string, result2 error) { + fake.extractTarballTmpMutex.Lock() + defer fake.extractTarballTmpMutex.Unlock() + fake.ExtractTarballTmpStub = nil + fake.extractTarballTmpReturns = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *FakeSpdxImplementation) ExtractTarballTmpReturnsOnCall(i int, result1 string, result2 error) { + fake.extractTarballTmpMutex.Lock() + defer fake.extractTarballTmpMutex.Unlock() + fake.ExtractTarballTmpStub = nil + if fake.extractTarballTmpReturnsOnCall == nil { + fake.extractTarballTmpReturnsOnCall = make(map[int]struct { + result1 string + result2 error + }) + } + fake.extractTarballTmpReturnsOnCall[i] = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *FakeSpdxImplementation) PackageFromLayerTarBall(arg1 string, arg2 *spdx.TarballOptions) (*spdx.Package, error) { + fake.packageFromLayerTarBallMutex.Lock() + ret, specificReturn := fake.packageFromLayerTarBallReturnsOnCall[len(fake.packageFromLayerTarBallArgsForCall)] + fake.packageFromLayerTarBallArgsForCall = append(fake.packageFromLayerTarBallArgsForCall, struct { + arg1 string + arg2 *spdx.TarballOptions + }{arg1, arg2}) + stub := fake.PackageFromLayerTarBallStub + fakeReturns := fake.packageFromLayerTarBallReturns + fake.recordInvocation("PackageFromLayerTarBall", []interface{}{arg1, arg2}) + fake.packageFromLayerTarBallMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeSpdxImplementation) PackageFromLayerTarBallCallCount() int { + fake.packageFromLayerTarBallMutex.RLock() + defer fake.packageFromLayerTarBallMutex.RUnlock() + return len(fake.packageFromLayerTarBallArgsForCall) +} + +func (fake *FakeSpdxImplementation) PackageFromLayerTarBallCalls(stub func(string, *spdx.TarballOptions) (*spdx.Package, error)) { + fake.packageFromLayerTarBallMutex.Lock() + defer fake.packageFromLayerTarBallMutex.Unlock() + fake.PackageFromLayerTarBallStub = stub +} + +func (fake *FakeSpdxImplementation) PackageFromLayerTarBallArgsForCall(i int) (string, *spdx.TarballOptions) { + fake.packageFromLayerTarBallMutex.RLock() + defer fake.packageFromLayerTarBallMutex.RUnlock() + argsForCall := fake.packageFromLayerTarBallArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeSpdxImplementation) PackageFromLayerTarBallReturns(result1 *spdx.Package, result2 error) { + fake.packageFromLayerTarBallMutex.Lock() + defer fake.packageFromLayerTarBallMutex.Unlock() + fake.PackageFromLayerTarBallStub = nil + fake.packageFromLayerTarBallReturns = struct { + result1 *spdx.Package + result2 error + }{result1, result2} +} + +func (fake *FakeSpdxImplementation) PackageFromLayerTarBallReturnsOnCall(i int, result1 *spdx.Package, result2 error) { + fake.packageFromLayerTarBallMutex.Lock() + defer fake.packageFromLayerTarBallMutex.Unlock() + fake.PackageFromLayerTarBallStub = nil + if fake.packageFromLayerTarBallReturnsOnCall == nil { + fake.packageFromLayerTarBallReturnsOnCall = make(map[int]struct { + result1 *spdx.Package + result2 error + }) + } + fake.packageFromLayerTarBallReturnsOnCall[i] = struct { + result1 *spdx.Package + result2 error + }{result1, result2} +} + +func (fake *FakeSpdxImplementation) PullImagesToArchive(arg1 string, arg2 string) error { + fake.pullImagesToArchiveMutex.Lock() + ret, specificReturn := fake.pullImagesToArchiveReturnsOnCall[len(fake.pullImagesToArchiveArgsForCall)] + fake.pullImagesToArchiveArgsForCall = append(fake.pullImagesToArchiveArgsForCall, struct { + arg1 string + arg2 string + }{arg1, arg2}) + stub := fake.PullImagesToArchiveStub + fakeReturns := fake.pullImagesToArchiveReturns + fake.recordInvocation("PullImagesToArchive", []interface{}{arg1, arg2}) + fake.pullImagesToArchiveMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeSpdxImplementation) PullImagesToArchiveCallCount() int { + fake.pullImagesToArchiveMutex.RLock() + defer fake.pullImagesToArchiveMutex.RUnlock() + return len(fake.pullImagesToArchiveArgsForCall) +} + +func (fake *FakeSpdxImplementation) PullImagesToArchiveCalls(stub func(string, string) error) { + fake.pullImagesToArchiveMutex.Lock() + defer fake.pullImagesToArchiveMutex.Unlock() + fake.PullImagesToArchiveStub = stub +} + +func (fake *FakeSpdxImplementation) PullImagesToArchiveArgsForCall(i int) (string, string) { + fake.pullImagesToArchiveMutex.RLock() + defer fake.pullImagesToArchiveMutex.RUnlock() + argsForCall := fake.pullImagesToArchiveArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeSpdxImplementation) PullImagesToArchiveReturns(result1 error) { + fake.pullImagesToArchiveMutex.Lock() + defer fake.pullImagesToArchiveMutex.Unlock() + fake.PullImagesToArchiveStub = nil + fake.pullImagesToArchiveReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeSpdxImplementation) PullImagesToArchiveReturnsOnCall(i int, result1 error) { + fake.pullImagesToArchiveMutex.Lock() + defer fake.pullImagesToArchiveMutex.Unlock() + fake.PullImagesToArchiveStub = nil + if fake.pullImagesToArchiveReturnsOnCall == nil { + fake.pullImagesToArchiveReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.pullImagesToArchiveReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeSpdxImplementation) ReadArchiveManifest(arg1 string) (*spdx.ArchiveManifest, error) { + fake.readArchiveManifestMutex.Lock() + ret, specificReturn := fake.readArchiveManifestReturnsOnCall[len(fake.readArchiveManifestArgsForCall)] + fake.readArchiveManifestArgsForCall = append(fake.readArchiveManifestArgsForCall, struct { + arg1 string + }{arg1}) + stub := fake.ReadArchiveManifestStub + fakeReturns := fake.readArchiveManifestReturns + fake.recordInvocation("ReadArchiveManifest", []interface{}{arg1}) + fake.readArchiveManifestMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeSpdxImplementation) ReadArchiveManifestCallCount() int { + fake.readArchiveManifestMutex.RLock() + defer fake.readArchiveManifestMutex.RUnlock() + return len(fake.readArchiveManifestArgsForCall) +} + +func (fake *FakeSpdxImplementation) ReadArchiveManifestCalls(stub func(string) (*spdx.ArchiveManifest, error)) { + fake.readArchiveManifestMutex.Lock() + defer fake.readArchiveManifestMutex.Unlock() + fake.ReadArchiveManifestStub = stub +} + +func (fake *FakeSpdxImplementation) ReadArchiveManifestArgsForCall(i int) string { + fake.readArchiveManifestMutex.RLock() + defer fake.readArchiveManifestMutex.RUnlock() + argsForCall := fake.readArchiveManifestArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeSpdxImplementation) ReadArchiveManifestReturns(result1 *spdx.ArchiveManifest, result2 error) { + fake.readArchiveManifestMutex.Lock() + defer fake.readArchiveManifestMutex.Unlock() + fake.ReadArchiveManifestStub = nil + fake.readArchiveManifestReturns = struct { + result1 *spdx.ArchiveManifest + result2 error + }{result1, result2} +} + +func (fake *FakeSpdxImplementation) ReadArchiveManifestReturnsOnCall(i int, result1 *spdx.ArchiveManifest, result2 error) { + fake.readArchiveManifestMutex.Lock() + defer fake.readArchiveManifestMutex.Unlock() + fake.ReadArchiveManifestStub = nil + if fake.readArchiveManifestReturnsOnCall == nil { + fake.readArchiveManifestReturnsOnCall = make(map[int]struct { + result1 *spdx.ArchiveManifest + result2 error + }) + } + fake.readArchiveManifestReturnsOnCall[i] = struct { + result1 *spdx.ArchiveManifest + result2 error + }{result1, result2} +} + +func (fake *FakeSpdxImplementation) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.extractTarballTmpMutex.RLock() + defer fake.extractTarballTmpMutex.RUnlock() + fake.packageFromLayerTarBallMutex.RLock() + defer fake.packageFromLayerTarBallMutex.RUnlock() + fake.pullImagesToArchiveMutex.RLock() + defer fake.pullImagesToArchiveMutex.RUnlock() + fake.readArchiveManifestMutex.RLock() + defer fake.readArchiveManifestMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeSpdxImplementation) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +}