From 4022e97b08e515d3d49005e763a4cc2eb812552d Mon Sep 17 00:00:00 2001 From: Ying Li Date: Tue, 15 Mar 2016 13:52:48 -0700 Subject: [PATCH] Use 'require' instead of 'assert' in client and TUF client tests Signed-off-by: Ying Li --- client/client_root_validation_test.go | 29 +- client/client_test.go | 1268 ++++++++++++------------- client/helpers_test.go | 376 ++++---- tuf/client/client_test.go | 336 +++---- tuf/data/roles_test.go | 122 +-- tuf/data/types_test.go | 84 +- tuf/db/files.db | Bin 28672 -> 0 bytes tuf/signed/ed25519_test.go | 12 +- tuf/signed/sign_test.go | 26 +- tuf/signed/verify_test.go | 52 +- tuf/validation/errors_test.go | 30 +- 11 files changed, 1167 insertions(+), 1168 deletions(-) delete mode 100644 tuf/db/files.db diff --git a/client/client_root_validation_test.go b/client/client_root_validation_test.go index e4b1bb0608..5f665f1394 100644 --- a/client/client_root_validation_test.go +++ b/client/client_root_validation_test.go @@ -7,7 +7,7 @@ import ( "github.com/Sirupsen/logrus" "github.com/docker/notary/certs" "github.com/docker/notary/tuf/data" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) // TestValidateRoot through the process of initializing a repository and makes @@ -32,12 +32,12 @@ func validateRootSuccessfully(t *testing.T, rootType string) { // tests need to manually boostrap timestamp as client doesn't generate it err := repo.tufRepo.InitTimestamp() - assert.NoError(t, err, "error creating repository: %s", err) + require.NoError(t, err, "error creating repository: %s", err) // Initialize is supposed to have created new certificate for this repository // Lets check for it and store it for later use allCerts := repo.CertStore.GetCertificates() - assert.Len(t, allCerts, 1) + require.Len(t, allCerts, 1) fakeServerData(t, repo, mux, keys) @@ -45,13 +45,13 @@ func validateRootSuccessfully(t *testing.T, rootType string) { // Test TOFUS logic. We remove all certs and expect a new one to be added after ListTargets // err = repo.CertStore.RemoveAll() - assert.NoError(t, err) - assert.Len(t, repo.CertStore.GetCertificates(), 0) + require.NoError(t, err) + require.Len(t, repo.CertStore.GetCertificates(), 0) // This list targets is expected to succeed and the certificate store to have the new certificate _, err = repo.ListTargets(data.CanonicalTargetsRole) - assert.NoError(t, err) - assert.Len(t, repo.CertStore.GetCertificates(), 1) + require.NoError(t, err) + require.Len(t, repo.CertStore.GetCertificates(), 1) // // Test certificate mismatch logic. We remove all certs, add a different cert to the @@ -60,20 +60,19 @@ func validateRootSuccessfully(t *testing.T, rootType string) { // First, remove all certs err = repo.CertStore.RemoveAll() - assert.NoError(t, err) - assert.Len(t, repo.CertStore.GetCertificates(), 0) + require.NoError(t, err) + require.Len(t, repo.CertStore.GetCertificates(), 0) // Add a previously generated certificate with CN=docker.com/notary err = repo.CertStore.AddCertFromFile( "../fixtures/self-signed_docker.com-notary.crt") - assert.NoError(t, err) + require.NoError(t, err) // This list targets is expected to fail, since there already exists a certificate // in the store for the dnsName docker.com/notary, so TOFUS doesn't apply _, err = repo.ListTargets(data.CanonicalTargetsRole) - if assert.Error(t, err, "An error was expected") { - assert.Equal(t, err, &certs.ErrValidationFail{ - Reason: "failed to validate data with current trusted certificates", - }) - } + require.Error(t, err, "An error was expected") + require.Equal(t, err, &certs.ErrValidationFail{ + Reason: "failed to validate data with current trusted certificates", + }) } diff --git a/client/client_test.go b/client/client_test.go index 39de2cd6f6..6083dc21fd 100644 --- a/client/client_test.go +++ b/client/client_test.go @@ -21,7 +21,7 @@ import ( "github.com/Sirupsen/logrus" ctxu "github.com/docker/distribution/context" "github.com/docker/go/canonical/json" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "golang.org/x/net/context" "github.com/docker/notary" @@ -77,16 +77,16 @@ func (p *passRoleRecorder) compareRolesRecorded(t *testing.T, expected []string, } sort.Stable(actual) - assert.Equal(t, useExpected, actual, args...) + require.Equal(t, useExpected, actual, args...) } // requires the following keys be created: order does not matter -func (p *passRoleRecorder) assertCreated(t *testing.T, expected []string, args ...interface{}) { +func (p *passRoleRecorder) requireCreated(t *testing.T, expected []string, args ...interface{}) { p.compareRolesRecorded(t, expected, true, args...) } // requires that passwords be asked for the following keys: order does not matter -func (p *passRoleRecorder) assertAsked(t *testing.T, expected []string, args ...interface{}) { +func (p *passRoleRecorder) requireAsked(t *testing.T, expected []string, args ...interface{}) { p.compareRolesRecorded(t, expected, false, args...) } @@ -103,12 +103,12 @@ func simpleTestServer(t *testing.T, roles ...string) ( for _, role := range roles { key, err := trustmanager.GenerateECDSAKey(rand.Reader) - assert.NoError(t, err) + require.NoError(t, err) keys[role] = key pubKey := data.PublicKeyFromPrivate(key) jsonBytes, err := json.MarshalCanonical(&pubKey) - assert.NoError(t, err) + require.NoError(t, err) keyJSON := string(jsonBytes) // TUF will request /v2/docker.com/notary/_trust/tuf/.key @@ -159,7 +159,7 @@ func initializeRepo(t *testing.T, rootType, gun, url string, // Temporary directory where test files will be created tempBaseDir, err := ioutil.TempDir("", "notary-test-") - assert.NoError(t, err, "failed to create a temporary directory: %s", err) + require.NoError(t, err, "failed to create a temporary directory: %s", err) serverManagedRoles := []string{} if serverManagesSnapshot { @@ -172,17 +172,17 @@ func initializeRepo(t *testing.T, rootType, gun, url string, if err != nil { os.RemoveAll(tempBaseDir) } - assert.NoError(t, err, "error creating repository: %s", err) + require.NoError(t, err, "error creating repository: %s", err) // generates the target role, maybe the snapshot role if serverManagesSnapshot { - rec.assertCreated(t, []string{data.CanonicalTargetsRole}) + rec.requireCreated(t, []string{data.CanonicalTargetsRole}) } else { - rec.assertCreated(t, []string{data.CanonicalTargetsRole, data.CanonicalSnapshotRole}) + rec.requireCreated(t, []string{data.CanonicalTargetsRole, data.CanonicalSnapshotRole}) } // root key is cached by the cryptoservice, so when signing we don't actually ask // for the passphrase - rec.assertAsked(t, nil) + rec.requireAsked(t, nil) return repo, rootPubKeyID } @@ -193,14 +193,14 @@ func createRepoAndKey(t *testing.T, rootType, tempBaseDir, gun, url string) ( rec := newRoleRecorder() repo, err := NewNotaryRepository( tempBaseDir, gun, url, http.DefaultTransport, rec.retriever) - assert.NoError(t, err, "error creating repo: %s", err) + require.NoError(t, err, "error creating repo: %s", err) rootPubKey, err := repo.CryptoService.Create("root", rootType) - assert.NoError(t, err, "error generating root key: %s", err) + require.NoError(t, err, "error generating root key: %s", err) - rec.assertCreated(t, []string{data.CanonicalRootRole}, + rec.requireCreated(t, []string{data.CanonicalRootRole}, "root passphrase should have been required to generate a root key") - rec.assertAsked(t, nil) + rec.requireAsked(t, nil) rec.clear() return repo, rec, rootPubKey.ID() @@ -216,7 +216,7 @@ func newRepoToTestRepo(t *testing.T, existingRepo *NotaryRepository, newDir bool repoDir := existingRepo.baseDir if newDir { tempBaseDir, err := ioutil.TempDir("", "notary-test-") - assert.NoError(t, err, "failed to create a temporary directory") + require.NoError(t, err, "failed to create a temporary directory") repoDir = tempBaseDir } @@ -224,7 +224,7 @@ func newRepoToTestRepo(t *testing.T, existingRepo *NotaryRepository, newDir bool repo, err := NewNotaryRepository( repoDir, existingRepo.gun, existingRepo.baseURL, http.DefaultTransport, rec.retriever) - assert.NoError(t, err, "error creating repository: %s", err) + require.NoError(t, err, "error creating repository: %s", err) if err != nil && newDir { defer os.RemoveAll(repoDir) } @@ -237,19 +237,19 @@ func newRepoToTestRepo(t *testing.T, existingRepo *NotaryRepository, newDir bool func TestInitRepositoryManagedRolesIncludingRoot(t *testing.T) { // Temporary directory where test files will be created tempBaseDir, err := ioutil.TempDir("/tmp", "notary-test-") - assert.NoError(t, err, "failed to create a temporary directory") + require.NoError(t, err, "failed to create a temporary directory") defer os.RemoveAll(tempBaseDir) repo, rec, rootPubKeyID := createRepoAndKey( t, data.ECDSAKey, tempBaseDir, "docker.com/notary", "http://localhost") err = repo.Initialize(rootPubKeyID, data.CanonicalRootRole) - assert.Error(t, err) - assert.IsType(t, ErrInvalidRemoteRole{}, err) + require.Error(t, err) + require.IsType(t, ErrInvalidRemoteRole{}, err) // Just testing the error message here in this one case - assert.Equal(t, err.Error(), + require.Equal(t, err.Error(), "notary does not support the server managing the root key") // no key creation happened - rec.assertCreated(t, nil) + rec.requireCreated(t, nil) } // Initializing a new repo while specifying that the server should manage some @@ -257,16 +257,16 @@ func TestInitRepositoryManagedRolesIncludingRoot(t *testing.T) { func TestInitRepositoryManagedRolesInvalidRole(t *testing.T) { // Temporary directory where test files will be created tempBaseDir, err := ioutil.TempDir("/tmp", "notary-test-") - assert.NoError(t, err, "failed to create a temporary directory") + require.NoError(t, err, "failed to create a temporary directory") defer os.RemoveAll(tempBaseDir) repo, rec, rootPubKeyID := createRepoAndKey( t, data.ECDSAKey, tempBaseDir, "docker.com/notary", "http://localhost") err = repo.Initialize(rootPubKeyID, "randomrole") - assert.Error(t, err) - assert.IsType(t, ErrInvalidRemoteRole{}, err) + require.Error(t, err) + require.IsType(t, ErrInvalidRemoteRole{}, err) // no key creation happened - rec.assertCreated(t, nil) + rec.requireCreated(t, nil) } // Initializing a new repo while specifying that the server should manage the @@ -274,16 +274,16 @@ func TestInitRepositoryManagedRolesInvalidRole(t *testing.T) { func TestInitRepositoryManagedRolesIncludingTargets(t *testing.T) { // Temporary directory where test files will be created tempBaseDir, err := ioutil.TempDir("/tmp", "notary-test-") - assert.NoError(t, err, "failed to create a temporary directory") + require.NoError(t, err, "failed to create a temporary directory") defer os.RemoveAll(tempBaseDir) repo, rec, rootPubKeyID := createRepoAndKey( t, data.ECDSAKey, tempBaseDir, "docker.com/notary", "http://localhost") err = repo.Initialize(rootPubKeyID, data.CanonicalTargetsRole) - assert.Error(t, err) - assert.IsType(t, ErrInvalidRemoteRole{}, err) + require.Error(t, err) + require.IsType(t, ErrInvalidRemoteRole{}, err) // no key creation happened - rec.assertCreated(t, nil) + rec.requireCreated(t, nil) } // Initializing a new repo while specifying that the server should manage the @@ -291,7 +291,7 @@ func TestInitRepositoryManagedRolesIncludingTargets(t *testing.T) { func TestInitRepositoryManagedRolesIncludingTimestamp(t *testing.T) { // Temporary directory where test files will be created tempBaseDir, err := ioutil.TempDir("/tmp", "notary-test-") - assert.NoError(t, err, "failed to create a temporary directory") + require.NoError(t, err, "failed to create a temporary directory") defer os.RemoveAll(tempBaseDir) ts, _, _ := simpleTestServer(t) @@ -300,9 +300,9 @@ func TestInitRepositoryManagedRolesIncludingTimestamp(t *testing.T) { repo, rec, rootPubKeyID := createRepoAndKey( t, data.ECDSAKey, tempBaseDir, "docker.com/notary", ts.URL) err = repo.Initialize(rootPubKeyID, data.CanonicalTimestampRole) - assert.NoError(t, err) + require.NoError(t, err) // generates the target role, the snapshot role - rec.assertCreated(t, []string{data.CanonicalTargetsRole, data.CanonicalSnapshotRole}) + rec.requireCreated(t, []string{data.CanonicalTargetsRole, data.CanonicalSnapshotRole}) } // Initializing a new repo fails if unable to get the timestamp key, even if @@ -310,7 +310,7 @@ func TestInitRepositoryManagedRolesIncludingTimestamp(t *testing.T) { func TestInitRepositoryNeedsRemoteTimestampKey(t *testing.T) { // Temporary directory where test files will be created tempBaseDir, err := ioutil.TempDir("/tmp", "notary-test-") - assert.NoError(t, err, "failed to create a temporary directory") + require.NoError(t, err, "failed to create a temporary directory") defer os.RemoveAll(tempBaseDir) ts, _, _ := simpleTestServer(t, data.CanonicalSnapshotRole) @@ -319,12 +319,12 @@ func TestInitRepositoryNeedsRemoteTimestampKey(t *testing.T) { repo, rec, rootPubKeyID := createRepoAndKey( t, data.ECDSAKey, tempBaseDir, "docker.com/notary", ts.URL) err = repo.Initialize(rootPubKeyID, data.CanonicalTimestampRole) - assert.Error(t, err) - assert.IsType(t, store.ErrMetaNotFound{}, err) + require.Error(t, err) + require.IsType(t, store.ErrMetaNotFound{}, err) // locally managed keys are created first, to avoid unnecssary network calls, // so they would have been generated - rec.assertCreated(t, []string{data.CanonicalTargetsRole, data.CanonicalSnapshotRole}) + rec.requireCreated(t, []string{data.CanonicalTargetsRole, data.CanonicalSnapshotRole}) } // Initializing a new repo with remote server signing fails if unable to get @@ -332,7 +332,7 @@ func TestInitRepositoryNeedsRemoteTimestampKey(t *testing.T) { func TestInitRepositoryNeedsRemoteSnapshotKey(t *testing.T) { // Temporary directory where test files will be created tempBaseDir, err := ioutil.TempDir("/tmp", "notary-test-") - assert.NoError(t, err, "failed to create a temporary directory") + require.NoError(t, err, "failed to create a temporary directory") defer os.RemoveAll(tempBaseDir) ts, _, _ := simpleTestServer(t, data.CanonicalTimestampRole) @@ -341,12 +341,12 @@ func TestInitRepositoryNeedsRemoteSnapshotKey(t *testing.T) { repo, rec, rootPubKeyID := createRepoAndKey( t, data.ECDSAKey, tempBaseDir, "docker.com/notary", ts.URL) err = repo.Initialize(rootPubKeyID, data.CanonicalSnapshotRole) - assert.Error(t, err) - assert.IsType(t, store.ErrMetaNotFound{}, err) + require.Error(t, err) + require.IsType(t, store.ErrMetaNotFound{}, err) // locally managed keys are created first, to avoid unnecssary network calls, // so they would have been generated - rec.assertCreated(t, []string{data.CanonicalTargetsRole}) + rec.requireCreated(t, []string{data.CanonicalTargetsRole}) } // passing timestamp + snapshot, or just snapshot, is tested in the next two @@ -381,53 +381,53 @@ func TestInitRepoServerManagesTimestampAndSnapshotKeys(t *testing.T) { // This creates a new KeyFileStore in the repo's base directory and makes sure // the repo has the right number of keys -func assertRepoHasExpectedKeys(t *testing.T, repo *NotaryRepository, +func requireRepoHasExpectedKeys(t *testing.T, repo *NotaryRepository, rootKeyID string, expectedSnapshotKey bool) { // The repo should have a keyFileStore and have created keys using it, // so create a new KeyFileStore, and check that the keys do exist and are // valid ks, err := trustmanager.NewKeyFileStore(repo.baseDir, passphraseRetriever) - assert.NoError(t, err) + require.NoError(t, err) roles := make(map[string]bool) for keyID, role := range ks.ListKeys() { if role == data.CanonicalRootRole { - assert.Equal(t, rootKeyID, keyID, "Unexpected root key ID") + require.Equal(t, rootKeyID, keyID, "Unexpected root key ID") } // just to ensure the content of the key files created are valid _, r, err := ks.GetKey(keyID) - assert.NoError(t, err) - assert.Equal(t, role, r) + require.NoError(t, err) + require.Equal(t, role, r) roles[role] = true } // there is a root key and a targets key alwaysThere := []string{data.CanonicalRootRole, data.CanonicalTargetsRole} for _, role := range alwaysThere { _, ok := roles[role] - assert.True(t, ok, "missing %s key", role) + require.True(t, ok, "missing %s key", role) } // there may be a snapshots key, depending on whether the server is managing // the snapshots key _, ok := roles[data.CanonicalSnapshotRole] if expectedSnapshotKey { - assert.True(t, ok, "missing snapshot key") + require.True(t, ok, "missing snapshot key") } else { - assert.False(t, ok, + require.False(t, ok, "there should be no snapshot key because the server manages it") } // The server manages the timestamp key - there should not be a timestamp // key _, ok = roles[data.CanonicalTimestampRole] - assert.False(t, ok, + require.False(t, ok, "there should be no timestamp key because the server manages it") } // This creates a new certificate store in the repo's base directory and // makes sure the repo has the right certificates -func assertRepoHasExpectedCerts(t *testing.T, repo *NotaryRepository) { +func requireRepoHasExpectedCerts(t *testing.T, repo *NotaryRepository) { // The repo should have a certificate store and have created certs using // it, so create a new store, and check that the certs do exist and // are valid @@ -436,20 +436,20 @@ func assertRepoHasExpectedCerts(t *testing.T, repo *NotaryRepository) { trustPath, trustmanager.FilterCertsExpiredSha1, ) - assert.NoError(t, err) + require.NoError(t, err) certificates := certStore.GetCertificates() - assert.Len(t, certificates, 1, "unexpected number of trusted certificates") + require.Len(t, certificates, 1, "unexpected number of trusted certificates") certID, err := trustmanager.FingerprintCert(certificates[0]) - assert.NoError(t, err, "unable to fingerprint the trusted certificate") - assert.NotEqual(t, certID, "") + require.NoError(t, err, "unable to fingerprint the trusted certificate") + require.NotEqual(t, certID, "") } // Sanity check the TUF metadata files. Verify that it exists for a particular // role, the JSON is well-formed, and the signatures exist. // For the root.json file, also check that the root, snapshot, and // targets key IDs are present. -func assertRepoHasExpectedMetadata(t *testing.T, repo *NotaryRepository, +func requireRepoHasExpectedMetadata(t *testing.T, repo *NotaryRepository, role string, expected bool) { filename := filepath.Join(tufDir, filepath.FromSlash(repo.gun), @@ -458,28 +458,28 @@ func assertRepoHasExpectedMetadata(t *testing.T, repo *NotaryRepository, _, err := os.Stat(fullPath) if expected { - assert.NoError(t, err, "missing TUF metadata file: %s", filename) + require.NoError(t, err, "missing TUF metadata file: %s", filename) } else { - assert.Error(t, err, + require.Error(t, err, "%s metadata should not exist, but does: %s", role, filename) return } jsonBytes, err := ioutil.ReadFile(fullPath) - assert.NoError(t, err, "error reading TUF metadata file %s: %s", filename, err) + require.NoError(t, err, "error reading TUF metadata file %s: %s", filename, err) var decoded data.Signed err = json.Unmarshal(jsonBytes, &decoded) - assert.NoError(t, err, "error parsing TUF metadata file %s: %s", filename, err) + require.NoError(t, err, "error parsing TUF metadata file %s: %s", filename, err) - assert.Len(t, decoded.Signatures, 1, + require.Len(t, decoded.Signatures, 1, "incorrect number of signatures in TUF metadata file %s", filename) - assert.NotEmpty(t, decoded.Signatures[0].KeyID, + require.NotEmpty(t, decoded.Signatures[0].KeyID, "empty key ID field in TUF metadata file %s", filename) - assert.NotEmpty(t, decoded.Signatures[0].Method, + require.NotEmpty(t, decoded.Signatures[0].Method, "empty method field in TUF metadata file %s", filename) - assert.NotEmpty(t, decoded.Signatures[0].Signature, + require.NotEmpty(t, decoded.Signatures[0].Signature, "empty signature in TUF metadata file %s", filename) // Special case for root.json: also check that the signed @@ -487,20 +487,20 @@ func assertRepoHasExpectedMetadata(t *testing.T, repo *NotaryRepository, if role == data.CanonicalRootRole { var decodedRoot data.Root err := json.Unmarshal(decoded.Signed, &decodedRoot) - assert.NoError(t, err, "error parsing root.json signed section: %s", err) + require.NoError(t, err, "error parsing root.json signed section: %s", err) - assert.Equal(t, "Root", decodedRoot.Type, "_type mismatch in root.json") + require.Equal(t, "Root", decodedRoot.Type, "_type mismatch in root.json") // Expect 1 key for each valid role in the Keys map - one for // each of root, targets, snapshot, timestamp - assert.Len(t, decodedRoot.Keys, len(data.BaseRoles), + require.Len(t, decodedRoot.Keys, len(data.BaseRoles), "wrong number of keys in root.json") - assert.Len(t, decodedRoot.Roles, len(data.BaseRoles), + require.Len(t, decodedRoot.Roles, len(data.BaseRoles), "wrong number of roles in root.json") for _, role := range data.BaseRoles { _, ok := decodedRoot.Roles[role] - assert.True(t, ok, "Missing role %s in root.json", role) + require.True(t, ok, "Missing role %s in root.json", role) } } } @@ -514,11 +514,11 @@ func testInitRepoMetadata(t *testing.T, rootType string, serverManagesSnapshot b repo, rootKeyID := initializeRepo(t, rootType, gun, ts.URL, serverManagesSnapshot) defer os.RemoveAll(repo.baseDir) - assertRepoHasExpectedKeys(t, repo, rootKeyID, !serverManagesSnapshot) - assertRepoHasExpectedCerts(t, repo) - assertRepoHasExpectedMetadata(t, repo, data.CanonicalRootRole, true) - assertRepoHasExpectedMetadata(t, repo, data.CanonicalTargetsRole, true) - assertRepoHasExpectedMetadata(t, repo, data.CanonicalSnapshotRole, + requireRepoHasExpectedKeys(t, repo, rootKeyID, !serverManagesSnapshot) + requireRepoHasExpectedCerts(t, repo) + requireRepoHasExpectedMetadata(t, repo, data.CanonicalRootRole, true) + requireRepoHasExpectedMetadata(t, repo, data.CanonicalTargetsRole, true) + requireRepoHasExpectedMetadata(t, repo, data.CanonicalSnapshotRole, !serverManagesSnapshot) } @@ -528,7 +528,7 @@ func testInitRepoSigningKeys(t *testing.T, rootType string, serverManagesSnapsho // Temporary directory where test files will be created tempBaseDir, err := ioutil.TempDir("", "notary-test-") - assert.NoError(t, err, "failed to create a temporary directory: %s", err) + require.NoError(t, err, "failed to create a temporary directory: %s", err) repo, _, rootPubKeyID := createRepoAndKey( t, data.ECDSAKey, tempBaseDir, "docker.com/notary", ts.URL) @@ -543,16 +543,16 @@ func testInitRepoSigningKeys(t *testing.T, rootType string, serverManagesSnapsho err = repo.Initialize(rootPubKeyID) } - assert.NoError(t, err, "error initializing repository") + require.NoError(t, err, "error initializing repository") // generates the target role, maybe the snapshot role if serverManagesSnapshot { - rec.assertCreated(t, []string{data.CanonicalTargetsRole}) + rec.requireCreated(t, []string{data.CanonicalTargetsRole}) } else { - rec.assertCreated(t, []string{data.CanonicalTargetsRole, data.CanonicalSnapshotRole}) + rec.requireCreated(t, []string{data.CanonicalTargetsRole, data.CanonicalSnapshotRole}) } // root is asked for signing the root role - rec.assertAsked(t, []string{data.CanonicalRootRole}) + rec.requireAsked(t, []string{data.CanonicalRootRole}) } // TestInitRepoAttemptsExceeded tests error handling when passphrase.Retriever @@ -568,7 +568,7 @@ func testInitRepoAttemptsExceeded(t *testing.T, rootType string) { gun := "docker.com/notary" // Temporary directory where test files will be created tempBaseDir, err := ioutil.TempDir("", "notary-test-") - assert.NoError(t, err, "failed to create a temporary directory: %s", err) + require.NoError(t, err, "failed to create a temporary directory: %s", err) defer os.RemoveAll(tempBaseDir) ts, _, _ := simpleTestServer(t) @@ -576,17 +576,17 @@ func testInitRepoAttemptsExceeded(t *testing.T, rootType string) { retriever := passphrase.ConstantRetriever("password") repo, err := NewNotaryRepository(tempBaseDir, gun, ts.URL, http.DefaultTransport, retriever) - assert.NoError(t, err, "error creating repo: %s", err) + require.NoError(t, err, "error creating repo: %s", err) rootPubKey, err := repo.CryptoService.Create("root", rootType) - assert.NoError(t, err, "error generating root key: %s", err) + require.NoError(t, err, "error generating root key: %s", err) retriever = passphrase.ConstantRetriever("incorrect password") // repo.CryptoService’s FileKeyStore caches the unlocked private key, so to test // private key unlocking we need a new repo instance. repo, err = NewNotaryRepository(tempBaseDir, gun, ts.URL, http.DefaultTransport, retriever) - assert.NoError(t, err, "error creating repo: %s", err) + require.NoError(t, err, "error creating repo: %s", err) err = repo.Initialize(rootPubKey.ID()) - assert.EqualError(t, err, trustmanager.ErrAttemptsExceeded{}.Error()) + require.EqualError(t, err, trustmanager.ErrAttemptsExceeded{}.Error()) } // TestInitRepoPasswordInvalid tests error handling when passphrase.Retriever @@ -606,7 +606,7 @@ func testInitRepoPasswordInvalid(t *testing.T, rootType string) { gun := "docker.com/notary" // Temporary directory where test files will be created tempBaseDir, err := ioutil.TempDir("", "notary-test-") - assert.NoError(t, err, "failed to create a temporary directory: %s", err) + require.NoError(t, err, "failed to create a temporary directory: %s", err) defer os.RemoveAll(tempBaseDir) ts, _, _ := simpleTestServer(t) @@ -614,31 +614,31 @@ func testInitRepoPasswordInvalid(t *testing.T, rootType string) { retriever := passphrase.ConstantRetriever("password") repo, err := NewNotaryRepository(tempBaseDir, gun, ts.URL, http.DefaultTransport, retriever) - assert.NoError(t, err, "error creating repo: %s", err) + require.NoError(t, err, "error creating repo: %s", err) rootPubKey, err := repo.CryptoService.Create("root", rootType) - assert.NoError(t, err, "error generating root key: %s", err) + require.NoError(t, err, "error generating root key: %s", err) // repo.CryptoService’s FileKeyStore caches the unlocked private key, so to test // private key unlocking we need a new repo instance. repo, err = NewNotaryRepository(tempBaseDir, gun, ts.URL, http.DefaultTransport, giveUpPassphraseRetriever) - assert.NoError(t, err, "error creating repo: %s", err) + require.NoError(t, err, "error creating repo: %s", err) err = repo.Initialize(rootPubKey.ID()) - assert.EqualError(t, err, trustmanager.ErrPasswordInvalid{}.Error()) + require.EqualError(t, err, trustmanager.ErrPasswordInvalid{}.Error()) } func addTarget(t *testing.T, repo *NotaryRepository, targetName, targetFile string, roles ...string) *Target { target, err := NewTarget(targetName, targetFile) - assert.NoError(t, err, "error creating target") + require.NoError(t, err, "error creating target") err = repo.AddTarget(target, roles...) - assert.NoError(t, err, "error adding target") + require.NoError(t, err, "error adding target") return target } // calls GetChangelist and gets the actual changes out func getChanges(t *testing.T, repo *NotaryRepository) []changelist.Change { changeList, err := repo.GetChangelist() - assert.NoError(t, err) + require.NoError(t, err) return changeList.List() } @@ -667,8 +667,8 @@ func testAddTargetToTargetRoleByDefault(t *testing.T, clearCache bool) { if clearCache { // no key creation or signing happened, because add doesn't ever require signing - rec.assertCreated(t, nil) - rec.assertAsked(t, nil) + rec.requireCreated(t, nil) + rec.requireAsked(t, nil) } } @@ -677,7 +677,7 @@ func testAddTargetToTargetRoleByDefault(t *testing.T, clearCache bool) { func testAddOrDeleteTarget(t *testing.T, repo *NotaryRepository, action string, rolesToChange []string, expectedScopes []string) { - assert.Len(t, getChanges(t, repo), 0, "should start with zero changes") + require.Len(t, getChanges(t, repo), 0, "should start with zero changes") if action == changelist.ActionCreate { // Add fixtures/intermediate-ca.crt as a target. There's no particular @@ -686,28 +686,28 @@ func testAddOrDeleteTarget(t *testing.T, repo *NotaryRepository, action string, addTarget(t, repo, "latest", "../fixtures/intermediate-ca.crt", rolesToChange...) } else { err := repo.RemoveTarget("latest", rolesToChange...) - assert.NoError(t, err, "error removing target") + require.NoError(t, err, "error removing target") } changes := getChanges(t, repo) - assert.Len(t, changes, len(expectedScopes), "wrong number of changes files found") + require.Len(t, changes, len(expectedScopes), "wrong number of changes files found") foundScopes := make(map[string]bool) for _, c := range changes { // there is only one - assert.EqualValues(t, action, c.Action()) + require.EqualValues(t, action, c.Action()) foundScopes[c.Scope()] = true - assert.Equal(t, "target", c.Type()) - assert.Equal(t, "latest", c.Path()) + require.Equal(t, "target", c.Type()) + require.Equal(t, "latest", c.Path()) if action == changelist.ActionCreate { - assert.NotEmpty(t, c.Content()) + require.NotEmpty(t, c.Content()) } else { - assert.Empty(t, c.Content()) + require.Empty(t, c.Content()) } } - assert.Len(t, foundScopes, len(expectedScopes)) + require.Len(t, foundScopes, len(expectedScopes)) for _, expectedScope := range expectedScopes { _, ok := foundScopes[expectedScope] - assert.True(t, ok, "Target was not added/removed from %s", expectedScope) + require.True(t, ok, "Target was not added/removed from %s", expectedScope) } // add/delete a second time @@ -715,35 +715,35 @@ func testAddOrDeleteTarget(t *testing.T, repo *NotaryRepository, action string, addTarget(t, repo, "current", "../fixtures/intermediate-ca.crt", rolesToChange...) } else { err := repo.RemoveTarget("current", rolesToChange...) - assert.NoError(t, err, "error removing target") + require.NoError(t, err, "error removing target") } changes = getChanges(t, repo) - assert.Len(t, changes, 2*len(expectedScopes), + require.Len(t, changes, 2*len(expectedScopes), "wrong number of changelist files found") newFileFound := false foundScopes = make(map[string]bool) for _, c := range changes { if c.Path() != "latest" { - assert.EqualValues(t, action, c.Action()) + require.EqualValues(t, action, c.Action()) foundScopes[c.Scope()] = true - assert.Equal(t, "target", c.Type()) - assert.Equal(t, "current", c.Path()) + require.Equal(t, "target", c.Type()) + require.Equal(t, "current", c.Path()) if action == changelist.ActionCreate { - assert.NotEmpty(t, c.Content()) + require.NotEmpty(t, c.Content()) } else { - assert.Empty(t, c.Content()) + require.Empty(t, c.Content()) } newFileFound = true } } - assert.True(t, newFileFound, "second changelist file not found") - assert.Len(t, foundScopes, len(expectedScopes)) + require.True(t, newFileFound, "second changelist file not found") + require.Len(t, foundScopes, len(expectedScopes)) for _, expectedScope := range expectedScopes { _, ok := foundScopes[expectedScope] - assert.True(t, ok, "Target was not added/removed from %s", expectedScope) + require.True(t, ok, "Target was not added/removed from %s", expectedScope) } } @@ -777,8 +777,8 @@ func testAddTargetToSpecifiedValidRoles(t *testing.T, clearCache bool) { if clearCache { // no key creation or signing happened, because add doesn't ever require signing - rec.assertCreated(t, nil) - rec.assertAsked(t, nil) + rec.requireCreated(t, nil) + rec.requireAsked(t, nil) } } @@ -813,24 +813,24 @@ func testAddTargetToSpecifiedInvalidRoles(t *testing.T, clearCache bool) { for _, invalidRole := range invalidRoles { target, err := NewTarget("latest", "../fixtures/intermediate-ca.crt") - assert.NoError(t, err, "error creating target") + require.NoError(t, err, "error creating target") err = repo.AddTarget(target, data.CanonicalTargetsRole, invalidRole) - assert.Error(t, err, "Expected an ErrInvalidRole error") - assert.IsType(t, data.ErrInvalidRole{}, err) + require.Error(t, err, "Expected an ErrInvalidRole error") + require.IsType(t, data.ErrInvalidRole{}, err) changes := getChanges(t, repo) - assert.Len(t, changes, 0) + require.Len(t, changes, 0) } if clearCache { // no key creation or signing happened, because add doesn't ever require signing - rec.assertCreated(t, nil) - rec.assertAsked(t, nil) + rec.requireCreated(t, nil) + rec.requireAsked(t, nil) } } -// General way to assert that errors writing a changefile are propagated up +// General way to require that errors writing a changefile are propagated up func testErrorWritingChangefiles(t *testing.T, writeChangeFile func(*NotaryRepository) error) { ts, _, _ := simpleTestServer(t) defer ts.Close() @@ -842,26 +842,26 @@ func testErrorWritingChangefiles(t *testing.T, writeChangeFile func(*NotaryRepos // directory unwritable changelistPath := filepath.Join(repo.tufRepoPath, "changelist") err := os.MkdirAll(changelistPath, 0744) - assert.NoError(t, err, "could not create changelist dir") + require.NoError(t, err, "could not create changelist dir") err = os.Chmod(changelistPath, 0600) - assert.NoError(t, err, "could not change permission of changelist dir") + require.NoError(t, err, "could not change permission of changelist dir") err = writeChangeFile(repo) - assert.Error(t, err, "Expected an error writing the change") - assert.IsType(t, &os.PathError{}, err) + require.Error(t, err, "Expected an error writing the change") + require.IsType(t, &os.PathError{}, err) // then break prevent the changlist directory from being able to be created err = os.Chmod(changelistPath, 0744) - assert.NoError(t, err, "could not change permission of temp dir") + require.NoError(t, err, "could not change permission of temp dir") err = os.RemoveAll(changelistPath) - assert.NoError(t, err, "could not remove changelist dir") + require.NoError(t, err, "could not remove changelist dir") // creating a changelist file so the directory can't be created err = ioutil.WriteFile(changelistPath, []byte("hi"), 0644) - assert.NoError(t, err, "could not write temporary file") + require.NoError(t, err, "could not write temporary file") err = writeChangeFile(repo) - assert.Error(t, err, "Expected an error writing the change") - assert.IsType(t, &os.PathError{}, err) + require.Error(t, err, "Expected an error writing the change") + require.IsType(t, &os.PathError{}, err) } // TestAddTargetErrorWritingChanges expects errors writing a change to file @@ -869,7 +869,7 @@ func testErrorWritingChangefiles(t *testing.T, writeChangeFile func(*NotaryRepos func TestAddTargetErrorWritingChanges(t *testing.T) { testErrorWritingChangefiles(t, func(repo *NotaryRepository) error { target, err := NewTarget("latest", "../fixtures/intermediate-ca.crt") - assert.NoError(t, err, "error creating target") + require.NoError(t, err, "error creating target") return repo.AddTarget(target, data.CanonicalTargetsRole) }) } @@ -899,8 +899,8 @@ func testRemoveTargetToTargetRoleByDefault(t *testing.T, clearCache bool) { if clearCache { // no key creation or signing happened, because remove doesn't ever require signing - rec.assertCreated(t, nil) - rec.assertAsked(t, nil) + rec.requireCreated(t, nil) + rec.requireAsked(t, nil) } } @@ -934,8 +934,8 @@ func testRemoveTargetFromSpecifiedValidRoles(t *testing.T, clearCache bool) { if clearCache { // no key creation or signing happened, because remove doesn't ever require signing - rec.assertCreated(t, nil) - rec.assertAsked(t, nil) + rec.requireCreated(t, nil) + rec.requireAsked(t, nil) } } @@ -969,17 +969,17 @@ func testRemoveTargetToSpecifiedInvalidRoles(t *testing.T, clearCache bool) { for _, invalidRole := range invalidRoles { err := repo.RemoveTarget("latest", data.CanonicalTargetsRole, invalidRole) - assert.Error(t, err, "Expected an ErrInvalidRole error") - assert.IsType(t, data.ErrInvalidRole{}, err) + require.Error(t, err, "Expected an ErrInvalidRole error") + require.IsType(t, data.ErrInvalidRole{}, err) changes := getChanges(t, repo) - assert.Len(t, changes, 0) + require.Len(t, changes, 0) } if clearCache { // no key creation or signing happened, because remove doesn't ever require signing - rec.assertCreated(t, nil) - rec.assertAsked(t, nil) + rec.requireCreated(t, nil) + rec.requireAsked(t, nil) } } @@ -1014,7 +1014,7 @@ func testListEmptyTargets(t *testing.T, rootType string) { defer os.RemoveAll(repo.baseDir) _, err := repo.ListTargets(data.CanonicalTargetsRole) - assert.Error(t, err) // no trust data + require.Error(t, err) // no trust data } // reads data from the repository in order to fake data being served via @@ -1023,11 +1023,11 @@ func fakeServerData(t *testing.T, repo *NotaryRepository, mux *http.ServeMux, keys map[string]data.PrivateKey) { timestampKey, ok := keys[data.CanonicalTimestampRole] - assert.True(t, ok) + require.True(t, ok) savedTUFRepo := repo.tufRepo // in case this is overwritten fileStore, err := trustmanager.NewKeyFileStore(repo.baseDir, passphraseRetriever) - assert.NoError(t, err) + require.NoError(t, err) fileStore.AddKey( filepath.Join(filepath.FromSlash(repo.gun), timestampKey.ID()), "nonroot", timestampKey) @@ -1038,14 +1038,14 @@ func fakeServerData(t *testing.T, repo *NotaryRepository, mux *http.ServeMux, signedTargets, err := savedTUFRepo.SignTargets( "targets", data.DefaultExpires("targets")) - assert.NoError(t, err) + require.NoError(t, err) signedLevel1, err := savedTUFRepo.SignTargets( "targets/level1", data.DefaultExpires(data.CanonicalTargetsRole), ) if _, ok := savedTUFRepo.Targets["targets/level1"]; ok { - assert.NoError(t, err) + require.NoError(t, err) } signedLevel2, err := savedTUFRepo.SignTargets( @@ -1053,7 +1053,7 @@ func fakeServerData(t *testing.T, repo *NotaryRepository, mux *http.ServeMux, data.DefaultExpires(data.CanonicalTargetsRole), ) if _, ok := savedTUFRepo.Targets["targets/level2"]; ok { - assert.NoError(t, err) + require.NoError(t, err) } nested, err := savedTUFRepo.SignTargets( @@ -1062,16 +1062,16 @@ func fakeServerData(t *testing.T, repo *NotaryRepository, mux *http.ServeMux, ) if _, ok := savedTUFRepo.Targets["targets/level1/level2"]; ok { - assert.NoError(t, err) + require.NoError(t, err) } signedSnapshot, err := savedTUFRepo.SignSnapshot( data.DefaultExpires("snapshot")) - assert.NoError(t, err) + require.NoError(t, err) signedTimestamp, err := savedTUFRepo.SignTimestamp( data.DefaultExpires("timestamp")) - assert.NoError(t, err) + require.NoError(t, err) timestampJSON, _ := json.Marshal(signedTimestamp) snapshotJSON, _ := json.Marshal(signedSnapshot) @@ -1100,12 +1100,12 @@ func fakeServerData(t *testing.T, repo *NotaryRepository, mux *http.ServeMux, mux.HandleFunc("/v2/docker.com/notary/_trust/tuf/root.json", func(w http.ResponseWriter, r *http.Request) { - assert.NoError(t, err) + require.NoError(t, err) fmt.Fprint(w, string(rootFileBytes)) }) mux.HandleFunc("/v2/docker.com/notary/_trust/tuf/root."+rootChecksum+".json", func(w http.ResponseWriter, r *http.Request) { - assert.NoError(t, err) + require.NoError(t, err) fmt.Fprint(w, string(rootFileBytes)) }) @@ -1152,7 +1152,7 @@ func fakeServerData(t *testing.T, repo *NotaryRepository, mux *http.ServeMux, mux.HandleFunc("/v2/docker.com/notary/_trust/tuf/targets/level1/level2."+nestedChecksum+".json", func(w http.ResponseWriter, r *http.Request) { level2JSON, err := json.Marshal(nested) - assert.NoError(t, err) + require.NoError(t, err) fmt.Fprint(w, string(level2JSON)) }) } @@ -1173,7 +1173,7 @@ func testListTarget(t *testing.T, rootType string) { // tests need to manually bootstrap timestamp as client doesn't generate it err := repo.tufRepo.InitTimestamp() - assert.NoError(t, err, "error creating repository: %s", err) + require.NoError(t, err, "error creating repository: %s", err) latestTarget := addTarget(t, repo, "latest", "../fixtures/intermediate-ca.crt") currentTarget := addTarget(t, repo, "current", "../fixtures/intermediate-ca.crt") @@ -1183,41 +1183,41 @@ func testListTarget(t *testing.T, rootType string) { // load the changelist for this repo cl, err := changelist.NewFileChangelist( filepath.Join(repo.baseDir, "tuf", filepath.FromSlash(repo.gun), "changelist")) - assert.NoError(t, err, "could not open changelist") + require.NoError(t, err, "could not open changelist") // apply the changelist to the repo err = applyChangelist(repo.tufRepo, cl) - assert.NoError(t, err, "could not apply changelist") + require.NoError(t, err, "could not apply changelist") fakeServerData(t, repo, mux, keys) targets, err := repo.ListTargets(data.CanonicalTargetsRole) - assert.NoError(t, err) + require.NoError(t, err) // Should be two targets - assert.Len(t, targets, 2, "unexpected number of targets returned by ListTargets") + require.Len(t, targets, 2, "unexpected number of targets returned by ListTargets") sort.Stable(targetSorter(targets)) // the targets should both be found in the targets role for _, foundTarget := range targets { - assert.Equal(t, data.CanonicalTargetsRole, foundTarget.Role) + require.Equal(t, data.CanonicalTargetsRole, foundTarget.Role) } // current should be first - assert.True(t, reflect.DeepEqual(*currentTarget, targets[0].Target), "current target does not match") - assert.True(t, reflect.DeepEqual(*latestTarget, targets[1].Target), "latest target does not match") + require.True(t, reflect.DeepEqual(*currentTarget, targets[0].Target), "current target does not match") + require.True(t, reflect.DeepEqual(*latestTarget, targets[1].Target), "latest target does not match") // Also test GetTargetByName newLatestTarget, err := repo.GetTargetByName("latest") - assert.NoError(t, err) - assert.Equal(t, data.CanonicalTargetsRole, newLatestTarget.Role) - assert.True(t, reflect.DeepEqual(*latestTarget, newLatestTarget.Target), "latest target does not match") + require.NoError(t, err) + require.Equal(t, data.CanonicalTargetsRole, newLatestTarget.Role) + require.True(t, reflect.DeepEqual(*latestTarget, newLatestTarget.Target), "latest target does not match") newCurrentTarget, err := repo.GetTargetByName("current") - assert.NoError(t, err) - assert.Equal(t, data.CanonicalTargetsRole, newCurrentTarget.Role) - assert.True(t, reflect.DeepEqual(*currentTarget, newCurrentTarget.Target), "current target does not match") + require.NoError(t, err) + require.Equal(t, data.CanonicalTargetsRole, newCurrentTarget.Role) + require.True(t, reflect.DeepEqual(*currentTarget, newCurrentTarget.Target), "current target does not match") } func testListTargetWithDelegates(t *testing.T, rootType string) { @@ -1229,28 +1229,28 @@ func testListTargetWithDelegates(t *testing.T, rootType string) { // tests need to manually bootstrap timestamp as client doesn't generate it err := repo.tufRepo.InitTimestamp() - assert.NoError(t, err, "error creating repository: %s", err) + require.NoError(t, err, "error creating repository: %s", err) latestTarget := addTarget(t, repo, "latest", "../fixtures/intermediate-ca.crt") currentTarget := addTarget(t, repo, "current", "../fixtures/intermediate-ca.crt") // setup delegated targets/level1 role k, err := repo.CryptoService.Create("targets/level1", rootType) - assert.NoError(t, err) + require.NoError(t, err) err = repo.tufRepo.UpdateDelegationKeys("targets/level1", []data.PublicKey{k}, []string{}, 1) - assert.NoError(t, err) + require.NoError(t, err) err = repo.tufRepo.UpdateDelegationPaths("targets/level1", []string{""}, []string{}, false) - assert.NoError(t, err) + require.NoError(t, err) delegatedTarget := addTarget(t, repo, "current", "../fixtures/root-ca.crt", "targets/level1") otherTarget := addTarget(t, repo, "other", "../fixtures/root-ca.crt", "targets/level1") // setup delegated targets/level2 role k, err = repo.CryptoService.Create("targets/level2", rootType) - assert.NoError(t, err) + require.NoError(t, err) err = repo.tufRepo.UpdateDelegationKeys("targets/level2", []data.PublicKey{k}, []string{}, 1) - assert.NoError(t, err) + require.NoError(t, err) err = repo.tufRepo.UpdateDelegationPaths("targets/level2", []string{""}, []string{}, false) - assert.NoError(t, err) + require.NoError(t, err) // this target should not show up as the one in targets/level1 takes higher priority _ = addTarget(t, repo, "current", "../fixtures/notary-server.crt", "targets/level2") // this target should show up as the name doesn't exist elsewhere @@ -1261,120 +1261,120 @@ func testListTargetWithDelegates(t *testing.T, rootType string) { // load the changelist for this repo cl, err := changelist.NewFileChangelist( filepath.Join(repo.baseDir, "tuf", filepath.FromSlash(repo.gun), "changelist")) - assert.NoError(t, err, "could not open changelist") + require.NoError(t, err, "could not open changelist") // apply the changelist to the repo, then clear it err = applyChangelist(repo.tufRepo, cl) - assert.NoError(t, err, "could not apply changelist") - assert.NoError(t, cl.Clear("")) + require.NoError(t, err, "could not apply changelist") + require.NoError(t, cl.Clear("")) _, ok := repo.tufRepo.Targets["targets/level1"].Signed.Targets["current"] - assert.True(t, ok) + require.True(t, ok) _, ok = repo.tufRepo.Targets["targets/level1"].Signed.Targets["other"] - assert.True(t, ok) + require.True(t, ok) _, ok = repo.tufRepo.Targets["targets/level2"].Signed.Targets["level2"] - assert.True(t, ok) + require.True(t, ok) // setup delegated targets/level1/level2 role separately, which can only modify paths prefixed with "level2" // This is done separately due to target shadowing k, err = repo.CryptoService.Create("targets/level1/level2", rootType) - assert.NoError(t, err) + require.NoError(t, err) err = repo.tufRepo.UpdateDelegationKeys("targets/level1/level2", []data.PublicKey{k}, []string{}, 1) - assert.NoError(t, err) + require.NoError(t, err) err = repo.tufRepo.UpdateDelegationPaths("targets/level1/level2", []string{"level2"}, []string{}, false) - assert.NoError(t, err) + require.NoError(t, err) nestedTarget := addTarget(t, repo, "level2", "../fixtures/notary-signer.crt", "targets/level1/level2") // load the changelist for this repo cl, err = changelist.NewFileChangelist( filepath.Join(repo.baseDir, "tuf", filepath.FromSlash(repo.gun), "changelist")) - assert.NoError(t, err, "could not open changelist") + require.NoError(t, err, "could not open changelist") // apply the changelist to the repo err = applyChangelist(repo.tufRepo, cl) - assert.NoError(t, err, "could not apply changelist") + require.NoError(t, err, "could not apply changelist") // check the changelist was applied _, ok = repo.tufRepo.Targets["targets/level1/level2"].Signed.Targets["level2"] - assert.True(t, ok) + require.True(t, ok) fakeServerData(t, repo, mux, keys) // test default listing targets, err := repo.ListTargets() - assert.NoError(t, err) + require.NoError(t, err) // Should be four targets - assert.Len(t, targets, 4, "unexpected number of targets returned by ListTargets") + require.Len(t, targets, 4, "unexpected number of targets returned by ListTargets") sort.Stable(targetSorter(targets)) // current should be first. - assert.True(t, reflect.DeepEqual(*currentTarget, targets[0].Target), "current target does not match") - assert.Equal(t, data.CanonicalTargetsRole, targets[0].Role) + require.True(t, reflect.DeepEqual(*currentTarget, targets[0].Target), "current target does not match") + require.Equal(t, data.CanonicalTargetsRole, targets[0].Role) - assert.True(t, reflect.DeepEqual(*latestTarget, targets[1].Target), "latest target does not match") - assert.Equal(t, data.CanonicalTargetsRole, targets[1].Role) + require.True(t, reflect.DeepEqual(*latestTarget, targets[1].Target), "latest target does not match") + require.Equal(t, data.CanonicalTargetsRole, targets[1].Role) // This target shadows the "level2" target in level1/level2 - assert.True(t, reflect.DeepEqual(*level2Target, targets[2].Target), "level2 target does not match") - assert.Equal(t, "targets/level2", targets[2].Role) + require.True(t, reflect.DeepEqual(*level2Target, targets[2].Target), "level2 target does not match") + require.Equal(t, "targets/level2", targets[2].Role) - assert.True(t, reflect.DeepEqual(*otherTarget, targets[3].Target), "other target does not match") - assert.Equal(t, "targets/level1", targets[3].Role) + require.True(t, reflect.DeepEqual(*otherTarget, targets[3].Target), "other target does not match") + require.Equal(t, "targets/level1", targets[3].Role) // test listing with priority specified targets, err = repo.ListTargets("targets/level1", data.CanonicalTargetsRole) - assert.NoError(t, err) + require.NoError(t, err) // Should be four targets - assert.Len(t, targets, 4, "unexpected number of targets returned by ListTargets") + require.Len(t, targets, 4, "unexpected number of targets returned by ListTargets") sort.Stable(targetSorter(targets)) // current (in delegated role) should be first - assert.True(t, reflect.DeepEqual(*delegatedTarget, targets[0].Target), "current target does not match") - assert.Equal(t, "targets/level1", targets[0].Role) + require.True(t, reflect.DeepEqual(*delegatedTarget, targets[0].Target), "current target does not match") + require.Equal(t, "targets/level1", targets[0].Role) - assert.True(t, reflect.DeepEqual(*latestTarget, targets[1].Target), "latest target does not match") - assert.Equal(t, data.CanonicalTargetsRole, targets[1].Role) + require.True(t, reflect.DeepEqual(*latestTarget, targets[1].Target), "latest target does not match") + require.Equal(t, data.CanonicalTargetsRole, targets[1].Role) // Now the level1/level2 target shadows the level2 target - assert.True(t, reflect.DeepEqual(*nestedTarget, targets[2].Target), "level1/level2 target does not match") - assert.Equal(t, "targets/level1/level2", targets[2].Role) + require.True(t, reflect.DeepEqual(*nestedTarget, targets[2].Target), "level1/level2 target does not match") + require.Equal(t, "targets/level1/level2", targets[2].Role) - assert.True(t, reflect.DeepEqual(*otherTarget, targets[3].Target), "other target does not match") - assert.Equal(t, "targets/level1", targets[3].Role) + require.True(t, reflect.DeepEqual(*otherTarget, targets[3].Target), "other target does not match") + require.Equal(t, "targets/level1", targets[3].Role) // Also test GetTargetByName newLatestTarget, err := repo.GetTargetByName("latest") - assert.NoError(t, err) - assert.True(t, reflect.DeepEqual(*latestTarget, newLatestTarget.Target), "latest target does not match") - assert.Equal(t, data.CanonicalTargetsRole, newLatestTarget.Role) + require.NoError(t, err) + require.True(t, reflect.DeepEqual(*latestTarget, newLatestTarget.Target), "latest target does not match") + require.Equal(t, data.CanonicalTargetsRole, newLatestTarget.Role) newCurrentTarget, err := repo.GetTargetByName("current", "targets/level1", "targets") - assert.NoError(t, err) - assert.True(t, reflect.DeepEqual(*delegatedTarget, newCurrentTarget.Target), "current target does not match") - assert.Equal(t, "targets/level1", newCurrentTarget.Role) + require.NoError(t, err) + require.True(t, reflect.DeepEqual(*delegatedTarget, newCurrentTarget.Target), "current target does not match") + require.Equal(t, "targets/level1", newCurrentTarget.Role) newOtherTarget, err := repo.GetTargetByName("other") - assert.NoError(t, err) - assert.True(t, reflect.DeepEqual(*otherTarget, newOtherTarget.Target), "other target does not match") - assert.Equal(t, "targets/level1", newOtherTarget.Role) + require.NoError(t, err) + require.True(t, reflect.DeepEqual(*otherTarget, newOtherTarget.Target), "other target does not match") + require.Equal(t, "targets/level1", newOtherTarget.Role) newLevel2Target, err := repo.GetTargetByName("level2") - assert.NoError(t, err) - assert.True(t, reflect.DeepEqual(*level2Target, newLevel2Target.Target), "level2 target does not match") - assert.Equal(t, "targets/level2", newLevel2Target.Role) + require.NoError(t, err) + require.True(t, reflect.DeepEqual(*level2Target, newLevel2Target.Target), "level2 target does not match") + require.Equal(t, "targets/level2", newLevel2Target.Role) // Shadow by prioritizing level1, but exclude level1/level2, so we should still get targets/level2's level2 target newLevel2Target, err = repo.GetTargetByName("level2", "targets/level1", "targets/level2", "targets/level1/level2") - assert.NoError(t, err) - assert.True(t, reflect.DeepEqual(*level2Target, newLevel2Target.Target), "level2 target does not match") - assert.Equal(t, "targets/level2", newLevel2Target.Role) + require.NoError(t, err) + require.True(t, reflect.DeepEqual(*level2Target, newLevel2Target.Target), "level2 target does not match") + require.Equal(t, "targets/level2", newLevel2Target.Role) // Prioritize level1 to get level1/level2's level2 target newLevel2Target, err = repo.GetTargetByName("level2", "targets/level1") - assert.NoError(t, err) - assert.True(t, reflect.DeepEqual(*nestedTarget, newLevel2Target.Target), "level2 target does not match") - assert.Equal(t, "targets/level1/level2", newLevel2Target.Role) + require.NoError(t, err) + require.True(t, reflect.DeepEqual(*nestedTarget, newLevel2Target.Target), "level2 target does not match") + require.Equal(t, "targets/level1/level2", newLevel2Target.Role) } func TestListTargetRestrictsDelegationPaths(t *testing.T) { @@ -1386,23 +1386,23 @@ func TestListTargetRestrictsDelegationPaths(t *testing.T) { // tests need to manually bootstrap timestamp as client doesn't generate it err := repo.tufRepo.InitTimestamp() - assert.NoError(t, err, "error creating repository: %s", err) + require.NoError(t, err, "error creating repository: %s", err) // setup delegated targets/level1 role k, err := repo.CryptoService.Create("targets/level1", data.ECDSAKey) - assert.NoError(t, err) + require.NoError(t, err) err = repo.tufRepo.UpdateDelegationKeys("targets/level1", []data.PublicKey{k}, []string{}, 1) - assert.NoError(t, err) + require.NoError(t, err) err = repo.tufRepo.UpdateDelegationPaths("targets/level1", []string{""}, []string{}, false) - assert.NoError(t, err) + require.NoError(t, err) addTarget(t, repo, "level1-target", "../fixtures/root-ca.crt", "targets/level1") addTarget(t, repo, "incorrectly-named-target", "../fixtures/root-ca.crt", "targets/level1") // setup delegated targets/level2 role err = repo.tufRepo.UpdateDelegationKeys("targets/level1/level2", []data.PublicKey{k}, []string{}, 1) - assert.NoError(t, err) + require.NoError(t, err) err = repo.tufRepo.UpdateDelegationPaths("targets/level1/level2", []string{""}, []string{}, false) - assert.NoError(t, err) + require.NoError(t, err) addTarget(t, repo, "level2-target", "../fixtures/notary-server.crt", "targets/level1/level2") addTarget(t, repo, "level1-level2-target", "../fixtures/notary-server.crt", "targets/level1/level2") @@ -1411,42 +1411,42 @@ func TestListTargetRestrictsDelegationPaths(t *testing.T) { // load the changelist for this repo cl, err := changelist.NewFileChangelist( filepath.Join(repo.baseDir, "tuf", filepath.FromSlash(repo.gun), "changelist")) - assert.NoError(t, err, "could not open changelist") + require.NoError(t, err, "could not open changelist") // apply the changelist to the repo err = applyChangelist(repo.tufRepo, cl) - assert.NoError(t, err, "could not apply changelist") + require.NoError(t, err, "could not apply changelist") - assert.NoError(t, cl.Clear("")) + require.NoError(t, cl.Clear("")) // Now restrict the paths err = repo.tufRepo.UpdateDelegationPaths("targets/level1", []string{"level1"}, []string{}, false) - assert.NoError(t, err) + require.NoError(t, err) err = repo.tufRepo.UpdateDelegationPaths("targets/level1/level2", []string{"level1-level2", "level2"}, []string{}, false) - assert.NoError(t, err) + require.NoError(t, err) err = repo.tufRepo.UpdateDelegationPaths("targets/level1", []string{}, []string{""}, false) - assert.NoError(t, err) + require.NoError(t, err) err = repo.tufRepo.UpdateDelegationPaths("targets/level1/level2", []string{}, []string{""}, false) - assert.NoError(t, err) + require.NoError(t, err) // load the changelist for this repo cl, err = changelist.NewFileChangelist( filepath.Join(repo.baseDir, "tuf", filepath.FromSlash(repo.gun), "changelist")) - assert.NoError(t, err, "could not open changelist") + require.NoError(t, err, "could not open changelist") // apply the changelist to the repo err = applyChangelist(repo.tufRepo, cl) - assert.NoError(t, err, "could not apply changelist") + require.NoError(t, err, "could not apply changelist") fakeServerData(t, repo, mux, keys) // test default listing targets, err := repo.ListTargets("targets/level1") - assert.NoError(t, err) + require.NoError(t, err) // Should be four targets - assert.Len(t, targets, 2, "unexpected number of targets returned by ListTargets") + require.Len(t, targets, 2, "unexpected number of targets returned by ListTargets") sort.Stable(targetSorter(targets)) @@ -1455,31 +1455,31 @@ func TestListTargetRestrictsDelegationPaths(t *testing.T) { for _, tgts := range targets { switch tgts.Name { case "level1-target": - assert.Equal(t, "targets/level1", tgts.Role) + require.Equal(t, "targets/level1", tgts.Role) foundLevel1 = true case "level1-level2-target": - assert.Equal(t, "targets/level1/level2", tgts.Role) + require.Equal(t, "targets/level1/level2", tgts.Role) foundLevel2 = true } } - assert.True(t, foundLevel1) - assert.True(t, foundLevel2) + require.True(t, foundLevel1) + require.True(t, foundLevel2) // test GetTargetByName tgt, err := repo.GetTargetByName("level1-target", "targets/level1") - assert.NoError(t, err) - assert.NotNil(t, tgt) - assert.Equal(t, tgt.Role, "targets/level1") + require.NoError(t, err) + require.NotNil(t, tgt) + require.Equal(t, tgt.Role, "targets/level1") tgt, err = repo.GetTargetByName("level1-level2-target", "targets/level1") - assert.NoError(t, err) - assert.NotNil(t, tgt) - assert.Equal(t, tgt.Role, "targets/level1/level2") + require.NoError(t, err) + require.NotNil(t, tgt) + require.Equal(t, tgt.Role, "targets/level1/level2") tgt, err = repo.GetTargetByName("level2-target", "targets/level1/level2") - assert.Error(t, err) - assert.Nil(t, tgt) + require.Error(t, err) + require.Nil(t, tgt) } // TestValidateRootKey verifies that the public data in root.json for the root @@ -1502,15 +1502,15 @@ func testValidateRootKey(t *testing.T, rootType string) { "metadata", "root.json") jsonBytes, err := ioutil.ReadFile(rootJSONFile) - assert.NoError(t, err, "error reading TUF metadata file %s: %s", rootJSONFile, err) + require.NoError(t, err, "error reading TUF metadata file %s: %s", rootJSONFile, err) var decoded data.Signed err = json.Unmarshal(jsonBytes, &decoded) - assert.NoError(t, err, "error parsing TUF metadata file %s: %s", rootJSONFile, err) + require.NoError(t, err, "error parsing TUF metadata file %s: %s", rootJSONFile, err) var decodedRoot data.Root err = json.Unmarshal(decoded.Signed, &decodedRoot) - assert.NoError(t, err, "error parsing root.json signed section: %s", err) + require.NoError(t, err, "error parsing root.json signed section: %s", err) keyids := []string{} for role, roleData := range decodedRoot.Roles { @@ -1518,13 +1518,13 @@ func testValidateRootKey(t *testing.T, rootType string) { keyids = append(keyids, roleData.KeyIDs...) } } - assert.NotEmpty(t, keyids) + require.NotEmpty(t, keyids) for _, keyid := range keyids { key, ok := decodedRoot.Keys[keyid] - assert.True(t, ok, "key id not found in keys") + require.True(t, ok, "key id not found in keys") _, err := trustmanager.LoadCertFromPEM(key.Public()) - assert.NoError(t, err, "key is not a valid cert") + require.NoError(t, err, "key is not a valid cert") } } @@ -1544,7 +1544,7 @@ func testGetChangelist(t *testing.T, rootType string) { repo, _ := initializeRepo(t, rootType, "docker.com/notary", ts.URL, false) defer os.RemoveAll(repo.baseDir) - assert.Len(t, getChanges(t, repo), 0, "No changes should be in changelist yet") + require.Len(t, getChanges(t, repo), 0, "No changes should be in changelist yet") // Create 2 targets addTarget(t, repo, "latest", "../fixtures/intermediate-ca.crt") @@ -1552,7 +1552,7 @@ func testGetChangelist(t *testing.T, rootType string) { // Test loading changelist chgs := getChanges(t, repo) - assert.Len(t, chgs, 2, "Wrong number of changes returned from changelist") + require.Len(t, chgs, 2, "Wrong number of changes returned from changelist") changes := make(map[string]changelist.Change) for _, ch := range chgs { @@ -1560,18 +1560,18 @@ func testGetChangelist(t *testing.T, rootType string) { } currentChange := changes["current"] - assert.NotNil(t, currentChange, "Expected changelist to contain a change for path 'current'") - assert.EqualValues(t, changelist.ActionCreate, currentChange.Action()) - assert.Equal(t, "targets", currentChange.Scope()) - assert.Equal(t, "target", currentChange.Type()) - assert.Equal(t, "current", currentChange.Path()) + require.NotNil(t, currentChange, "Expected changelist to contain a change for path 'current'") + require.EqualValues(t, changelist.ActionCreate, currentChange.Action()) + require.Equal(t, "targets", currentChange.Scope()) + require.Equal(t, "target", currentChange.Type()) + require.Equal(t, "current", currentChange.Path()) latestChange := changes["latest"] - assert.NotNil(t, latestChange, "Expected changelist to contain a change for path 'latest'") - assert.EqualValues(t, changelist.ActionCreate, latestChange.Action()) - assert.Equal(t, "targets", latestChange.Scope()) - assert.Equal(t, "target", latestChange.Type()) - assert.Equal(t, "latest", latestChange.Path()) + require.NotNil(t, latestChange, "Expected changelist to contain a change for path 'latest'") + require.EqualValues(t, changelist.ActionCreate, latestChange.Action()) + require.Equal(t, "targets", latestChange.Scope()) + require.Equal(t, "target", latestChange.Type()) + require.Equal(t, "latest", latestChange.Path()) } // Create a repo, instantiate a notary server, and publish the bare repo to the @@ -1604,15 +1604,15 @@ func testPublishNoData(t *testing.T, rootType string, clearCache, serverManagesS repo1, rec = newRepoToTestRepo(t, repo1, false) } - assert.NoError(t, repo1.Publish()) + require.NoError(t, repo1.Publish()) if clearCache { // signing is only done by the target/snapshot keys - rec.assertCreated(t, nil) + rec.requireCreated(t, nil) if serverManagesSnapshot { - rec.assertAsked(t, []string{data.CanonicalTargetsRole}) + rec.requireAsked(t, []string{data.CanonicalTargetsRole}) } else { - rec.assertAsked(t, []string{data.CanonicalTargetsRole, data.CanonicalSnapshotRole}) + rec.requireAsked(t, []string{data.CanonicalTargetsRole, data.CanonicalSnapshotRole}) } } @@ -1621,13 +1621,13 @@ func testPublishNoData(t *testing.T, rootType string, clearCache, serverManagesS defer os.RemoveAll(repo2.baseDir) targets, err := repo2.ListTargets() - assert.NoError(t, err) - assert.Empty(t, targets) + require.NoError(t, err) + require.Empty(t, targets) for _, role := range data.BaseRoles { // we don't cache timstamp metadata if role != data.CanonicalTimestampRole { - assertRepoHasExpectedMetadata(t, repo2, role, true) + requireRepoHasExpectedMetadata(t, repo2, role, true) } } } @@ -1641,32 +1641,32 @@ func TestPublishUninitializedRepo(t *testing.T) { // uninitialized repo should fail to publish tempBaseDir, err := ioutil.TempDir("", "notary-tests") - assert.NoError(t, err) + require.NoError(t, err) defer os.RemoveAll(tempBaseDir) repo, err := NewNotaryRepository(tempBaseDir, gun, ts.URL, http.DefaultTransport, passphraseRetriever) - assert.NoError(t, err, "error creating repository: %s", err) + require.NoError(t, err, "error creating repository: %s", err) err = repo.Publish() - assert.Error(t, err) + require.Error(t, err) // no metadata created - assertRepoHasExpectedMetadata(t, repo, data.CanonicalRootRole, false) - assertRepoHasExpectedMetadata(t, repo, data.CanonicalSnapshotRole, false) - assertRepoHasExpectedMetadata(t, repo, data.CanonicalTargetsRole, false) + requireRepoHasExpectedMetadata(t, repo, data.CanonicalRootRole, false) + requireRepoHasExpectedMetadata(t, repo, data.CanonicalSnapshotRole, false) + requireRepoHasExpectedMetadata(t, repo, data.CanonicalTargetsRole, false) // now, initialize and republish in the same directory rootPubKey, err := repo.CryptoService.Create("root", data.ECDSAKey) - assert.NoError(t, err, "error generating root key: %s", err) + require.NoError(t, err, "error generating root key: %s", err) - assert.NoError(t, repo.Initialize(rootPubKey.ID())) + require.NoError(t, repo.Initialize(rootPubKey.ID())) // now metadata is created - assertRepoHasExpectedMetadata(t, repo, data.CanonicalRootRole, true) - assertRepoHasExpectedMetadata(t, repo, data.CanonicalSnapshotRole, true) - assertRepoHasExpectedMetadata(t, repo, data.CanonicalTargetsRole, true) + requireRepoHasExpectedMetadata(t, repo, data.CanonicalRootRole, true) + requireRepoHasExpectedMetadata(t, repo, data.CanonicalSnapshotRole, true) + requireRepoHasExpectedMetadata(t, repo, data.CanonicalTargetsRole, true) - assert.NoError(t, repo.Publish()) + require.NoError(t, repo.Publish()) } // Create a repo, instantiate a notary server, and publish the repo with @@ -1708,22 +1708,22 @@ func testPublishWithData(t *testing.T, rootType string, clearCache, serverManage repo, rec = newRepoToTestRepo(t, repo, false) } - assertPublishToRolesSucceeds(t, repo, nil, []string{data.CanonicalTargetsRole}) + requirePublishToRolesSucceeds(t, repo, nil, []string{data.CanonicalTargetsRole}) if clearCache { // signing is only done by the target/snapshot keys - rec.assertCreated(t, nil) + rec.requireCreated(t, nil) if serverManagesSnapshot { - rec.assertAsked(t, []string{data.CanonicalTargetsRole}) + rec.requireAsked(t, []string{data.CanonicalTargetsRole}) } else { - rec.assertAsked(t, []string{data.CanonicalTargetsRole, data.CanonicalSnapshotRole}) + rec.requireAsked(t, []string{data.CanonicalTargetsRole, data.CanonicalSnapshotRole}) } } } -// asserts that adding to the given roles results in the targets actually being +// requires that adding to the given roles results in the targets actually being // added only to the expected roles and no others -func assertPublishToRolesSucceeds(t *testing.T, repo1 *NotaryRepository, +func requirePublishToRolesSucceeds(t *testing.T, repo1 *NotaryRepository, publishToRoles []string, expectedPublishedRoles []string) { // were there unpublished changes before? @@ -1739,13 +1739,13 @@ func assertPublishToRolesSucceeds(t *testing.T, repo1 *NotaryRepository, // if no roles are provided, the default role is target numRoles := int(math.Max(1, float64(len(publishToRoles)))) - assert.Len(t, getChanges(t, repo1), changesOffset+4*numRoles, + require.Len(t, getChanges(t, repo1), changesOffset+4*numRoles, "wrong number of changelist files found") // Now test Publish err := repo1.Publish() - assert.NoError(t, err) - assert.Len(t, getChanges(t, repo1), 0, "wrong number of changelist files found") + require.NoError(t, err) + require.Len(t, getChanges(t, repo1), 0, "wrong number of changelist files found") // use another repo to check metadata repo2, _ := newRepoToTestRepo(t, repo1, true) @@ -1755,28 +1755,28 @@ func assertPublishToRolesSucceeds(t *testing.T, repo1 *NotaryRepository, for _, role := range expectedPublishedRoles { for _, repo := range []*NotaryRepository{repo1, repo2} { targets, err := repo.ListTargets(role) - assert.NoError(t, err) + require.NoError(t, err) - assert.Len(t, targets, 2, + require.Len(t, targets, 2, "unexpected number of targets returned by ListTargets(%s)", role) sort.Stable(targetSorter(targets)) - assert.True(t, reflect.DeepEqual(*currentTarget, targets[0].Target), "current target does not match") - assert.Equal(t, role, targets[0].Role) - assert.True(t, reflect.DeepEqual(*latestTarget, targets[1].Target), "latest target does not match") - assert.Equal(t, role, targets[1].Role) + require.True(t, reflect.DeepEqual(*currentTarget, targets[0].Target), "current target does not match") + require.Equal(t, role, targets[0].Role) + require.True(t, reflect.DeepEqual(*latestTarget, targets[1].Target), "latest target does not match") + require.Equal(t, role, targets[1].Role) // Also test GetTargetByName newLatestTarget, err := repo.GetTargetByName("latest", role) - assert.NoError(t, err) - assert.True(t, reflect.DeepEqual(*latestTarget, newLatestTarget.Target), "latest target does not match") - assert.Equal(t, role, newLatestTarget.Role) + require.NoError(t, err) + require.True(t, reflect.DeepEqual(*latestTarget, newLatestTarget.Target), "latest target does not match") + require.Equal(t, role, newLatestTarget.Role) newCurrentTarget, err := repo.GetTargetByName("current", role) - assert.NoError(t, err) - assert.True(t, reflect.DeepEqual(*currentTarget, newCurrentTarget.Target), "current target does not match") - assert.Equal(t, role, newCurrentTarget.Role) + require.NoError(t, err) + require.True(t, reflect.DeepEqual(*currentTarget, newCurrentTarget.Target), "current target does not match") + require.Equal(t, role, newCurrentTarget.Role) } } } @@ -1799,30 +1799,30 @@ func testPublishAfterPullServerHasSnapshotKey(t *testing.T, rootType string) { repo, _ := initializeRepo(t, rootType, "docker.com/notary", ts.URL, true) defer os.RemoveAll(repo.baseDir) // no timestamp metadata because that comes from the server - assertRepoHasExpectedMetadata(t, repo, data.CanonicalTimestampRole, false) + requireRepoHasExpectedMetadata(t, repo, data.CanonicalTimestampRole, false) // no snapshot metadata because that comes from the server - assertRepoHasExpectedMetadata(t, repo, data.CanonicalSnapshotRole, false) + requireRepoHasExpectedMetadata(t, repo, data.CanonicalSnapshotRole, false) // Publish something published := addTarget(t, repo, "v1", "../fixtures/intermediate-ca.crt") - assert.NoError(t, repo.Publish()) + require.NoError(t, repo.Publish()) // still no timestamp or snapshot metadata info - assertRepoHasExpectedMetadata(t, repo, data.CanonicalTimestampRole, false) - assertRepoHasExpectedMetadata(t, repo, data.CanonicalSnapshotRole, false) + requireRepoHasExpectedMetadata(t, repo, data.CanonicalTimestampRole, false) + requireRepoHasExpectedMetadata(t, repo, data.CanonicalSnapshotRole, false) // list, so that the snapshot metadata is pulled from server targets, err := repo.ListTargets(data.CanonicalTargetsRole) - assert.NoError(t, err) - assert.Equal(t, []*TargetWithRole{{Target: *published, Role: data.CanonicalTargetsRole}}, targets) + require.NoError(t, err) + require.Equal(t, []*TargetWithRole{{Target: *published, Role: data.CanonicalTargetsRole}}, targets) // listing downloaded the timestamp and snapshot metadata info - assertRepoHasExpectedMetadata(t, repo, data.CanonicalTimestampRole, true) - assertRepoHasExpectedMetadata(t, repo, data.CanonicalSnapshotRole, true) + requireRepoHasExpectedMetadata(t, repo, data.CanonicalTimestampRole, true) + requireRepoHasExpectedMetadata(t, repo, data.CanonicalSnapshotRole, true) // Publish again should succeed addTarget(t, repo, "v2", "../fixtures/intermediate-ca.crt") err = repo.Publish() - assert.NoError(t, err) + require.NoError(t, err) } // If neither the client nor the server has the snapshot key, signing will fail @@ -1844,7 +1844,7 @@ func testPublishNoOneHasSnapshotKey(t *testing.T, rootType string) { defer os.RemoveAll(repo.baseDir) snapshotRole, ok := repo.tufRepo.Root.Signed.Roles[data.CanonicalSnapshotRole] - assert.True(t, ok) + require.True(t, ok) for _, keyID := range snapshotRole.KeyIDs { repo.CryptoService.RemoveKey(keyID) } @@ -1852,8 +1852,8 @@ func testPublishNoOneHasSnapshotKey(t *testing.T, rootType string) { // Publish something addTarget(t, repo, "v1", "../fixtures/intermediate-ca.crt") err := repo.Publish() - assert.Error(t, err) - assert.IsType(t, validation.ErrBadHierarchy{}, err) + require.Error(t, err) + require.IsType(t, validation.ErrBadHierarchy{}, err) } // If the snapshot metadata is corrupt or the snapshot metadata is unreadable, @@ -1934,7 +1934,7 @@ func testPublishBadMetadata(t *testing.T, roleName string, repo *NotaryRepositor publishFirst, succeeds bool) { if publishFirst { - assert.NoError(t, repo.Publish()) + require.NoError(t, repo.Publish()) } addTarget(t, repo, "v1", "../fixtures/intermediate-ca.crt") @@ -1943,10 +1943,10 @@ func testPublishBadMetadata(t *testing.T, roleName string, repo *NotaryRepositor repo.fileStore.SetMeta(roleName, []byte("this isn't JSON")) err := repo.Publish() if succeeds { - assert.NoError(t, err) + require.NoError(t, err) } else { - assert.Error(t, err) - assert.IsType(t, ®Json.SyntaxError{}, err) + require.Error(t, err) + require.IsType(t, ®Json.SyntaxError{}, err) } // make an unreadable file by creating a directory instead of a file @@ -1954,15 +1954,15 @@ func testPublishBadMetadata(t *testing.T, roleName string, repo *NotaryRepositor filepath.Join(repo.baseDir, tufDir, filepath.FromSlash(repo.gun), "metadata", roleName), "json") os.RemoveAll(path) - assert.NoError(t, os.Mkdir(path, 0755)) + require.NoError(t, os.Mkdir(path, 0755)) defer os.RemoveAll(path) err = repo.Publish() if succeeds { - assert.NoError(t, err) + require.NoError(t, err) } else { - assert.Error(t, err) - assert.IsType(t, &os.PathError{}, err) + require.Error(t, err) + require.IsType(t, &os.PathError{}, err) } } @@ -1971,7 +1971,7 @@ func TestNotInitializedOnPublish(t *testing.T) { // Temporary directory where test files will be created tempBaseDir, err := ioutil.TempDir("/tmp", "notary-test-") defer os.RemoveAll(tempBaseDir) - assert.NoError(t, err, "failed to create a temporary directory: %s", err) + require.NoError(t, err, "failed to create a temporary directory: %s", err) gun := "docker.com/notary" ts := fullTestServer(t) @@ -1982,8 +1982,8 @@ func TestNotInitializedOnPublish(t *testing.T) { addTarget(t, repo, "v1", "../fixtures/intermediate-ca.crt") err = repo.Publish() - assert.Error(t, err) - assert.IsType(t, ErrRepoNotInitialized{}, err) + require.Error(t, err) + require.IsType(t, ErrRepoNotInitialized{}, err) } type cannotCreateKeys struct { @@ -2000,7 +2000,7 @@ func TestPublishSnapshotLocalKeysCreatedFirst(t *testing.T) { // Temporary directory where test files will be created tempBaseDir, err := ioutil.TempDir("/tmp", "notary-test-") defer os.RemoveAll(tempBaseDir) - assert.NoError(t, err, "failed to create a temporary directory: %s", err) + require.NoError(t, err, "failed to create a temporary directory: %s", err) gun := "docker.com/notary" requestMade := false @@ -2010,34 +2010,34 @@ func TestPublishSnapshotLocalKeysCreatedFirst(t *testing.T) { repo, err := NewNotaryRepository( tempBaseDir, gun, ts.URL, http.DefaultTransport, passphraseRetriever) - assert.NoError(t, err, "error creating repo: %s", err) + require.NoError(t, err, "error creating repo: %s", err) cs := cryptoservice.NewCryptoService(gun, trustmanager.NewKeyMemoryStore(passphraseRetriever)) rootPubKey, err := cs.Create(data.CanonicalRootRole, data.ECDSAKey) - assert.NoError(t, err, "error generating root key: %s", err) + require.NoError(t, err, "error generating root key: %s", err) repo.CryptoService = cannotCreateKeys{CryptoService: cs} err = repo.Initialize(rootPubKey.ID(), data.CanonicalSnapshotRole) - assert.Error(t, err) - assert.Contains(t, err.Error(), "Oh no I cannot create keys") - assert.False(t, requestMade) + require.Error(t, err) + require.Contains(t, err.Error(), "Oh no I cannot create keys") + require.False(t, requestMade) } func createKey(t *testing.T, repo *NotaryRepository, role string, x509 bool) data.PublicKey { key, err := repo.CryptoService.Create(role, data.ECDSAKey) - assert.NoError(t, err, "error creating key") + require.NoError(t, err, "error creating key") if x509 { start := time.Now().AddDate(0, 0, -1) privKey, _, err := repo.CryptoService.GetPrivateKey(key.ID()) - assert.NoError(t, err) + require.NoError(t, err) cert, err := cryptoservice.GenerateCertificate( privKey, role, start, start.AddDate(1, 0, 0), ) - assert.NoError(t, err) + require.NoError(t, err) return data.NewECDSAx509PublicKey(trustmanager.CertToPEM(cert)) } return key @@ -2070,37 +2070,37 @@ func testPublishDelegations(t *testing.T, clearCache, x509Keys bool) { // This should publish fine, even though targets/a/b is dependent upon // targets/a, because these should execute in order for _, delgName := range []string{"targets/a", "targets/a/b", "targets/c"} { - assert.NoError(t, + require.NoError(t, repo1.AddDelegation(delgName, []data.PublicKey{delgKey}, []string{""}), "error creating delegation") } - assert.Len(t, getChanges(t, repo1), 6, "wrong number of changelist files found") + require.Len(t, getChanges(t, repo1), 6, "wrong number of changelist files found") var rec *passRoleRecorder if clearCache { repo1, rec = newRepoToTestRepo(t, repo1, false) } - assert.NoError(t, repo1.Publish()) - assert.Len(t, getChanges(t, repo1), 0, "wrong number of changelist files found") + require.NoError(t, repo1.Publish()) + require.Len(t, getChanges(t, repo1), 0, "wrong number of changelist files found") if clearCache { // when publishing, only the parents of the delegations created need to be signed // (and snapshot) - rec.assertAsked(t, []string{data.CanonicalTargetsRole, "targets/a", data.CanonicalSnapshotRole}) + rec.requireAsked(t, []string{data.CanonicalTargetsRole, "targets/a", data.CanonicalSnapshotRole}) rec.clear() } // this should not publish, because targets/z doesn't exist - assert.NoError(t, + require.NoError(t, repo1.AddDelegation("targets/z/y", []data.PublicKey{delgKey}, []string{""}), "error creating delegation") - assert.Len(t, getChanges(t, repo1), 2, "wrong number of changelist files found") - assert.Error(t, repo1.Publish()) - assert.Len(t, getChanges(t, repo1), 2, "wrong number of changelist files found") + require.Len(t, getChanges(t, repo1), 2, "wrong number of changelist files found") + require.Error(t, repo1.Publish()) + require.Len(t, getChanges(t, repo1), 2, "wrong number of changelist files found") if clearCache { - rec.assertAsked(t, nil) + rec.requireAsked(t, nil) } // use another repo to check metadata @@ -2109,33 +2109,33 @@ func testPublishDelegations(t *testing.T, clearCache, x509Keys bool) { // pull _, err := repo2.ListTargets() - assert.NoError(t, err, "unable to pull repo") + require.NoError(t, err, "unable to pull repo") for _, repo := range []*NotaryRepository{repo1, repo2} { // targets should have delegations targets/a and targets/c targets := repo.tufRepo.Targets[data.CanonicalTargetsRole] - assert.Len(t, targets.Signed.Delegations.Roles, 2) - assert.Len(t, targets.Signed.Delegations.Keys, 1) + require.Len(t, targets.Signed.Delegations.Roles, 2) + require.Len(t, targets.Signed.Delegations.Keys, 1) _, ok := targets.Signed.Delegations.Keys[delgKey.ID()] - assert.True(t, ok) + require.True(t, ok) foundRoleNames := make(map[string]bool) for _, r := range targets.Signed.Delegations.Roles { foundRoleNames[r.Name] = true } - assert.True(t, foundRoleNames["targets/a"]) - assert.True(t, foundRoleNames["targets/c"]) + require.True(t, foundRoleNames["targets/a"]) + require.True(t, foundRoleNames["targets/c"]) // targets/a should have delegation targets/a/b only a := repo.tufRepo.Targets["targets/a"] - assert.Len(t, a.Signed.Delegations.Roles, 1) - assert.Len(t, a.Signed.Delegations.Keys, 1) + require.Len(t, a.Signed.Delegations.Roles, 1) + require.Len(t, a.Signed.Delegations.Keys, 1) _, ok = a.Signed.Delegations.Keys[delgKey.ID()] - assert.True(t, ok) + require.True(t, ok) - assert.Equal(t, "targets/a/b", a.Signed.Delegations.Roles[0].Name) + require.Equal(t, "targets/a/b", a.Signed.Delegations.Roles[0].Name) } } @@ -2161,12 +2161,12 @@ func testPublishTargetsDelgationScopeFallback(t *testing.T, clearCache bool) { repo, rec = newRepoToTestRepo(t, repo, false) } - assertPublishToRolesSucceeds(t, repo, []string{"targets/a/b", "targets/b/c"}, + requirePublishToRolesSucceeds(t, repo, []string{"targets/a/b", "targets/b/c"}, []string{data.CanonicalTargetsRole}) if clearCache { - rec.assertAsked(t, []string{data.CanonicalTargetsRole, data.CanonicalSnapshotRole}) - rec.assertCreated(t, nil) + rec.requireAsked(t, []string{data.CanonicalTargetsRole, data.CanonicalSnapshotRole}) + rec.requireCreated(t, nil) } } @@ -2187,7 +2187,7 @@ func testPublishTargetsDelgationScopeNoFallbackIfNoKeys(t *testing.T, clearCache // generate a key that isn't in the cryptoservice, so we can't sign this // one aPrivKey, err := trustmanager.GenerateECDSAKey(rand.Reader) - assert.NoError(t, err, "error generating key that is not in our cryptoservice") + require.NoError(t, err, "error generating key that is not in our cryptoservice") aPubKey := data.PublicKeyFromPrivate(aPrivKey) var rec *passRoleRecorder @@ -2196,30 +2196,30 @@ func testPublishTargetsDelgationScopeNoFallbackIfNoKeys(t *testing.T, clearCache } // ensure that the role exists - assert.NoError(t, repo.AddDelegation("targets/a", []data.PublicKey{aPubKey}, []string{""})) - assert.NoError(t, repo.Publish()) + require.NoError(t, repo.AddDelegation("targets/a", []data.PublicKey{aPubKey}, []string{""})) + require.NoError(t, repo.Publish()) if clearCache { - rec.assertAsked(t, []string{data.CanonicalTargetsRole, data.CanonicalSnapshotRole}) + rec.requireAsked(t, []string{data.CanonicalTargetsRole, data.CanonicalSnapshotRole}) rec.clear() } // add a target to targets/a/b - no role b, so it falls back on a, which // exists but there is no signing key for addTarget(t, repo, "latest", "../fixtures/intermediate-ca.crt", "targets/a/b") - assert.Len(t, getChanges(t, repo), 1, "wrong number of changelist files found") + require.Len(t, getChanges(t, repo), 1, "wrong number of changelist files found") // Now Publish should fail - assert.Error(t, repo.Publish()) - assert.Len(t, getChanges(t, repo), 1, "wrong number of changelist files found") + require.Error(t, repo.Publish()) + require.Len(t, getChanges(t, repo), 1, "wrong number of changelist files found") if clearCache { - rec.assertAsked(t, nil) + rec.requireAsked(t, nil) rec.clear() } targets, err := repo.ListTargets("targets", "targets/a", "targets/a/b") - assert.NoError(t, err) - assert.Empty(t, targets) + require.NoError(t, err) + require.Empty(t, targets) } // If a changelist specifies a particular role to push targets to, and such @@ -2236,7 +2236,7 @@ func TestPublishTargetsDelgationSuccessLocallyHasRoles(t *testing.T) { for _, delgName := range []string{"targets/a", "targets/a/b"} { delgKey := createKey(t, repo, delgName, false) - assert.NoError(t, + require.NoError(t, repo.AddDelegation(delgName, []data.PublicKey{delgKey}, []string{""}), "error creating delegation") } @@ -2246,11 +2246,11 @@ func TestPublishTargetsDelgationSuccessLocallyHasRoles(t *testing.T) { var rec *passRoleRecorder repo, rec = newRepoToTestRepo(t, repo, false) - assertPublishToRolesSucceeds(t, repo, []string{"targets/a/b"}, + requirePublishToRolesSucceeds(t, repo, []string{"targets/a/b"}, []string{"targets/a/b"}) // first time publishing, so everything gets signed - rec.assertAsked(t, []string{data.CanonicalTargetsRole, "targets/a", "targets/a/b", + rec.requireAsked(t, []string{data.CanonicalTargetsRole, "targets/a", "targets/a/b", data.CanonicalSnapshotRole}) } @@ -2266,7 +2266,7 @@ func TestPublishTargetsDelgationNoTargetsKeyNeeded(t *testing.T) { for _, delgName := range []string{"targets/a", "targets/a/b"} { delgKey := createKey(t, repo, delgName, false) - assert.NoError(t, + require.NoError(t, repo.AddDelegation(delgName, []data.PublicKey{delgKey}, []string{""}), "error creating delegation") } @@ -2276,21 +2276,21 @@ func TestPublishTargetsDelgationNoTargetsKeyNeeded(t *testing.T) { var rec *passRoleRecorder repo, rec = newRepoToTestRepo(t, repo, false) - assert.NoError(t, repo.Publish()) + require.NoError(t, repo.Publish()) // first time publishing, so all delegation parents get signed - rec.assertAsked(t, []string{data.CanonicalTargetsRole, "targets/a", data.CanonicalSnapshotRole}) + rec.requireAsked(t, []string{data.CanonicalTargetsRole, "targets/a", data.CanonicalSnapshotRole}) rec.clear() // remove targets key - it is not even needed targetsKeys := repo.CryptoService.ListKeys(data.CanonicalTargetsRole) - assert.Len(t, targetsKeys, 1) - assert.NoError(t, repo.CryptoService.RemoveKey(targetsKeys[0])) + require.Len(t, targetsKeys, 1) + require.NoError(t, repo.CryptoService.RemoveKey(targetsKeys[0])) - assertPublishToRolesSucceeds(t, repo, []string{"targets/a/b"}, + requirePublishToRolesSucceeds(t, repo, []string{"targets/a/b"}, []string{"targets/a/b"}) // only the target delegation gets signed - snapshot key has already been cached - rec.assertAsked(t, []string{"targets/a/b"}) + rec.requireAsked(t, []string{"targets/a/b"}) } // If a changelist specifies a particular role to push targets to, and is such @@ -2318,11 +2318,11 @@ func TestPublishTargetsDelgationSuccessNeedsToDownloadRoles(t *testing.T) { // create a key on the owner repo aKey, err := ownerRepo.CryptoService.Create("targets/a", data.ECDSAKey) - assert.NoError(t, err, "error creating delegation key") + require.NoError(t, err, "error creating delegation key") // create a key on the delegated repo bKey, err := delgRepo.CryptoService.Create("targets/a/b", data.ECDSAKey) - assert.NoError(t, err, "error creating delegation key") + require.NoError(t, err, "error creating delegation key") // clear metadata and unencrypted private key cache var ownerRec, delgRec *passRoleRecorder @@ -2330,22 +2330,22 @@ func TestPublishTargetsDelgationSuccessNeedsToDownloadRoles(t *testing.T) { delgRepo, delgRec = newRepoToTestRepo(t, delgRepo, false) // owner creates delegations, adds the delegated key to them, and publishes them - assert.NoError(t, + require.NoError(t, ownerRepo.AddDelegation("targets/a", []data.PublicKey{aKey}, []string{""}), "error creating delegation") - assert.NoError(t, + require.NoError(t, ownerRepo.AddDelegation("targets/a/b", []data.PublicKey{bKey}, []string{""}), "error creating delegation") - assert.NoError(t, ownerRepo.Publish()) + require.NoError(t, ownerRepo.Publish()) // delegation parents all get signed - ownerRec.assertAsked(t, []string{data.CanonicalTargetsRole, "targets/a"}) + ownerRec.requireAsked(t, []string{data.CanonicalTargetsRole, "targets/a"}) // delegated repo now publishes to delegated roles, but it will need // to download those roles first, since it doesn't know about them - assertPublishToRolesSucceeds(t, delgRepo, []string{"targets/a/b"}, + requirePublishToRolesSucceeds(t, delgRepo, []string{"targets/a/b"}, []string{"targets/a/b"}) - delgRec.assertAsked(t, []string{"targets/a/b"}) + delgRec.requireAsked(t, []string{"targets/a/b"}) } // Ensure that two clients can publish delegations with two different keys and @@ -2365,18 +2365,18 @@ func TestPublishTargetsDelgationFromTwoRepos(t *testing.T) { // create keys for each repo key1, err := repo1.CryptoService.Create("targets/a", data.ECDSAKey) - assert.NoError(t, err, "error creating delegation key") + require.NoError(t, err, "error creating delegation key") // create a key on the delegated repo key2, err := repo2.CryptoService.Create("targets/a", data.ECDSAKey) - assert.NoError(t, err, "error creating delegation key") + require.NoError(t, err, "error creating delegation key") // delegation includes both keys - assert.NoError(t, + require.NoError(t, repo1.AddDelegation("targets/a", []data.PublicKey{key1, key2}, []string{""}), "error creating delegation") - assert.NoError(t, repo1.Publish()) + require.NoError(t, repo1.Publish()) // clear metadata and unencrypted private key cache var rec1, rec2 *passRoleRecorder @@ -2385,27 +2385,27 @@ func TestPublishTargetsDelgationFromTwoRepos(t *testing.T) { // both repos add targets and publish addTarget(t, repo1, "first", "../fixtures/root-ca.crt", "targets/a") - assert.NoError(t, repo1.Publish()) - rec1.assertAsked(t, []string{"targets/a"}) + require.NoError(t, repo1.Publish()) + rec1.requireAsked(t, []string{"targets/a"}) rec1.clear() addTarget(t, repo2, "second", "../fixtures/root-ca.crt", "targets/a") - assert.NoError(t, repo2.Publish()) - rec2.assertAsked(t, []string{"targets/a"}) + require.NoError(t, repo2.Publish()) + rec2.requireAsked(t, []string{"targets/a"}) rec2.clear() // first repo can publish again addTarget(t, repo1, "third", "../fixtures/root-ca.crt", "targets/a") - assert.NoError(t, repo1.Publish()) + require.NoError(t, repo1.Publish()) // key has been cached now - rec1.assertAsked(t, nil) + rec1.requireAsked(t, nil) rec1.clear() // both repos should be able to see all targets for _, repo := range []*NotaryRepository{repo1, repo2} { targets, err := repo.ListTargets() - assert.NoError(t, err) - assert.Len(t, targets, 3) + require.NoError(t, err) + require.Len(t, targets, 3) found := make(map[string]bool) for _, t := range targets { @@ -2414,7 +2414,7 @@ func TestPublishTargetsDelgationFromTwoRepos(t *testing.T) { for _, targetName := range []string{"first", "second", "third"} { _, ok := found[targetName] - assert.True(t, ok) + require.True(t, ok) } } } @@ -2439,31 +2439,31 @@ func TestPublishRemoveDelgationKeyFromDelegationRole(t *testing.T) { // create a key on the delegated repo aKey, err := delgRepo.CryptoService.Create("targets/a", data.ECDSAKey) - assert.NoError(t, err, "error creating delegation key") + require.NoError(t, err, "error creating delegation key") // owner creates delegation, adds the delegated key to it, and publishes it - assert.NoError(t, + require.NoError(t, ownerRepo.AddDelegation("targets/a", []data.PublicKey{aKey}, []string{""}), "error creating delegation") - assert.NoError(t, ownerRepo.Publish()) + require.NoError(t, ownerRepo.Publish()) // delegated repo can now publish to delegated role addTarget(t, delgRepo, "v1", "../fixtures/root-ca.crt", "targets/a") - assert.NoError(t, delgRepo.Publish()) + require.NoError(t, delgRepo.Publish()) // owner revokes delegation // note there is no removekeyfromdelegation yet, so here's a hack to do so newKey, err := ownerRepo.CryptoService.Create("targets/a", data.ECDSAKey) - assert.NoError(t, err) + require.NoError(t, err) tdJSON, err := json.Marshal(&changelist.TufDelegation{ NewThreshold: 1, AddKeys: data.KeyList([]data.PublicKey{newKey}), RemoveKeys: []string{aKey.ID()}, }) - assert.NoError(t, err) + require.NoError(t, err) cl, err := changelist.NewFileChangelist(filepath.Join(ownerRepo.tufRepoPath, "changelist")) - assert.NoError(t, cl.Add(changelist.NewTufChange( + require.NoError(t, cl.Add(changelist.NewTufChange( changelist.ActionUpdate, "targets/a", changelist.TypeTargetsDelegation, @@ -2471,11 +2471,11 @@ func TestPublishRemoveDelgationKeyFromDelegationRole(t *testing.T) { tdJSON, ))) cl.Close() - assert.NoError(t, ownerRepo.Publish()) + require.NoError(t, ownerRepo.Publish()) // delegated repo can now no longer publish to delegated role addTarget(t, delgRepo, "v2", "../fixtures/root-ca.crt", "targets/a") - assert.Error(t, delgRepo.Publish()) + require.Error(t, delgRepo.Publish()) } // A client who could publish before can no longer publish once the owner @@ -2497,27 +2497,27 @@ func TestPublishRemoveDelgation(t *testing.T) { // create a key on the delegated repo aKey, err := delgRepo.CryptoService.Create("targets/a", data.ECDSAKey) - assert.NoError(t, err, "error creating delegation key") + require.NoError(t, err, "error creating delegation key") // owner creates delegation, adds the delegated key to it, and publishes it - assert.NoError(t, + require.NoError(t, ownerRepo.AddDelegation("targets/a", []data.PublicKey{aKey}, []string{""}), "error creating delegation") - assert.NoError(t, ownerRepo.Publish()) + require.NoError(t, ownerRepo.Publish()) // delegated repo can now publish to delegated role addTarget(t, delgRepo, "v1", "../fixtures/root-ca.crt", "targets/a") - assert.NoError(t, delgRepo.Publish()) + require.NoError(t, delgRepo.Publish()) // owner removes delegation aKeyCanonicalID, err := utils.CanonicalKeyID(aKey) - assert.NoError(t, err) - assert.NoError(t, ownerRepo.RemoveDelegationKeys("targets/a", []string{aKeyCanonicalID})) - assert.NoError(t, ownerRepo.Publish()) + require.NoError(t, err) + require.NoError(t, ownerRepo.RemoveDelegationKeys("targets/a", []string{aKeyCanonicalID})) + require.NoError(t, ownerRepo.Publish()) // delegated repo can now no longer publish to delegated role addTarget(t, delgRepo, "v2", "../fixtures/root-ca.crt", "targets/a") - assert.Error(t, delgRepo.Publish()) + require.Error(t, delgRepo.Publish()) } // If the delegation data is corrupt or unreadable, it doesn't matter because @@ -2532,9 +2532,9 @@ func TestPublishSucceedsDespiteDelegationCorrupt(t *testing.T) { defer os.RemoveAll(repo.baseDir) delgKey, err := repo.CryptoService.Create("targets/a", data.ECDSAKey) - assert.NoError(t, err, "error creating delegation key") + require.NoError(t, err, "error creating delegation key") - assert.NoError(t, + require.NoError(t, repo.AddDelegation("targets/a", []data.PublicKey{delgKey}, []string{""}), "error creating delegation") @@ -2564,7 +2564,7 @@ func TestRotateKeyInvalidRole(t *testing.T) { continue } err := repo.RotateKey(role, serverManagesKey) - assert.Error(t, err, + require.Error(t, err, "Rotating a %s key with server-managing the key as %v should fail", role, serverManagesKey) } @@ -2572,8 +2572,8 @@ func TestRotateKeyInvalidRole(t *testing.T) { } // Rotates the keys. After the rotation, downloading the latest metadata -// and assert that the keys have changed -func assertRotationSuccessful(t *testing.T, repo1 *NotaryRepository, +// and require that the keys have changed +func requireRotationSuccessful(t *testing.T, repo1 *NotaryRepository, keysToRotate map[string]bool, alreadyPublished bool) { // Create 2 new repos: 1 will download repo data before the publish, // and one only downloads after the publish. This reflects a client @@ -2590,7 +2590,7 @@ func assertRotationSuccessful(t *testing.T, repo1 *NotaryRepository, // force a pull on repo3 _, err := repo3.GetTargetByName("latest") - assert.NoError(t, err) + require.NoError(t, err) repos = append(repos, repo3) } @@ -2603,29 +2603,29 @@ func assertRotationSuccessful(t *testing.T, repo1 *NotaryRepository, // Do rotation for role, serverManaged := range keysToRotate { - assert.NoError(t, repo1.RotateKey(role, serverManaged)) + require.NoError(t, repo1.RotateKey(role, serverManaged)) } // Publish err := repo1.Publish() - assert.NoError(t, err) + require.NoError(t, err) // Download data from remote and check that keys have changed for _, repo := range repos { _, err := repo.GetTargetByName("latest") // force a pull - assert.NoError(t, err) + require.NoError(t, err) for role, isRemoteKey := range keysToRotate { keyIDs := repo.tufRepo.Root.Signed.Roles[role].KeyIDs - assert.Len(t, keyIDs, 1) + require.Len(t, keyIDs, 1) // the new key is not the same as any of the old keys, and the // old keys have been removed not just from the TUF file, but // from the cryptoservice for _, oldKeyID := range oldKeyIDs[role] { - assert.NotEqual(t, oldKeyID, keyIDs[0]) + require.NotEqual(t, oldKeyID, keyIDs[0]) _, _, err := repo.CryptoService.GetPrivateKey(oldKeyID) - assert.Error(t, err) + require.Error(t, err) } // On the old repo, the new key is present in the cryptoservice, or @@ -2633,11 +2633,11 @@ func assertRotationSuccessful(t *testing.T, repo1 *NotaryRepository, // cryptoservice key, _, err := repo.CryptoService.GetPrivateKey(keyIDs[0]) if repo != repo1 || isRemoteKey { - assert.Error(t, err) - assert.Nil(t, key) + require.Error(t, err) + require.Nil(t, key) } else { - assert.NoError(t, err) - assert.NotNil(t, key) + require.NoError(t, err) + require.NotNil(t, key) } } @@ -2645,7 +2645,7 @@ func assertRotationSuccessful(t *testing.T, repo1 *NotaryRepository, // after publishing changes, on repo2, there should never have been // any changelists) changes := getChanges(t, repo) - assert.Len(t, changes, 0, "wrong number of changelist files found") + require.Len(t, changes, 0, "wrong number of changelist files found") } } @@ -2663,7 +2663,7 @@ func TestRotateBeforePublishFromRemoteKeyToLocalKey(t *testing.T) { // Adding a target will allow us to confirm the repository is still valid // after rotating the keys. addTarget(t, repo, "latest", "../fixtures/intermediate-ca.crt") - assertRotationSuccessful(t, repo, map[string]bool{ + requireRotationSuccessful(t, repo, map[string]bool{ data.CanonicalTargetsRole: false, data.CanonicalSnapshotRole: false}, false) } @@ -2671,7 +2671,7 @@ func TestRotateBeforePublishFromRemoteKeyToLocalKey(t *testing.T) { // Initialize a repo, locally signed snapshots // Publish some content (so that the server has a root.json), and download root.json // Rotate keys -// Download the latest metadata and assert that the keys have changed. +// Download the latest metadata and require that the keys have changed. func TestRotateKeyAfterPublishNoServerManagementChange(t *testing.T) { // rotate a single target key testRotateKeySuccess(t, false, map[string]bool{data.CanonicalTargetsRole: false}) @@ -2714,11 +2714,11 @@ func testRotateKeySuccess(t *testing.T, serverManagesSnapshotInit bool, addTarget(t, repo, "latest", "../fixtures/intermediate-ca.crt") // Publish - assert.NoError(t, repo.Publish()) + require.NoError(t, repo.Publish()) // Get root.json and capture targets + snapshot key IDs repo.GetTargetByName("latest") // force a pull - assertRotationSuccessful(t, repo, keysToRotate, true) + requireRotationSuccessful(t, repo, keysToRotate, true) var keysToExpectCreated []string for role, serverManaged := range keysToRotate { @@ -2731,7 +2731,7 @@ func testRotateKeySuccess(t *testing.T, serverManagesSnapshotInit bool, // If there is no local cache, notary operations return the remote error code func TestRemoteServerUnavailableNoLocalCache(t *testing.T) { tempBaseDir, err := ioutil.TempDir("/tmp", "notary-test-") - assert.NoError(t, err, "failed to create a temporary directory: %s", err) + require.NoError(t, err, "failed to create a temporary directory: %s", err) defer os.RemoveAll(tempBaseDir) ts := errorTestServer(t, 500) @@ -2739,19 +2739,19 @@ func TestRemoteServerUnavailableNoLocalCache(t *testing.T) { repo, err := NewNotaryRepository(tempBaseDir, "docker.com/notary", ts.URL, http.DefaultTransport, passphraseRetriever) - assert.NoError(t, err, "error creating repo: %s", err) + require.NoError(t, err, "error creating repo: %s", err) _, err = repo.ListTargets(data.CanonicalTargetsRole) - assert.Error(t, err) - assert.IsType(t, store.ErrServerUnavailable{}, err) + require.Error(t, err) + require.IsType(t, store.ErrServerUnavailable{}, err) _, err = repo.GetTargetByName("targetName") - assert.Error(t, err) - assert.IsType(t, store.ErrServerUnavailable{}, err) + require.Error(t, err) + require.IsType(t, store.ErrServerUnavailable{}, err) err = repo.Publish() - assert.Error(t, err) - assert.IsType(t, store.ErrServerUnavailable{}, err) + require.Error(t, err) + require.IsType(t, store.ErrServerUnavailable{}, err) } // AddDelegation creates a valid changefile (rejects invalid delegation names, @@ -2766,30 +2766,30 @@ func TestAddDelegationChangefileValid(t *testing.T) { defer os.RemoveAll(repo.baseDir) targetKeyIds := repo.CryptoService.ListKeys(data.CanonicalTargetsRole) - assert.NotEmpty(t, targetKeyIds) + require.NotEmpty(t, targetKeyIds) targetPubKey := repo.CryptoService.GetKey(targetKeyIds[0]) - assert.NotNil(t, targetPubKey) + require.NotNil(t, targetPubKey) err := repo.AddDelegation("root", []data.PublicKey{targetPubKey}, []string{""}) - assert.Error(t, err) - assert.IsType(t, data.ErrInvalidRole{}, err) - assert.Empty(t, getChanges(t, repo)) + require.Error(t, err) + require.IsType(t, data.ErrInvalidRole{}, err) + require.Empty(t, getChanges(t, repo)) // to show that adding does not care about the hierarchy err = repo.AddDelegation("targets/a/b/c", []data.PublicKey{targetPubKey}, []string{""}) - assert.NoError(t, err) + require.NoError(t, err) // ensure that the changefiles is correct changes := getChanges(t, repo) - assert.Len(t, changes, 2) - assert.Equal(t, changelist.ActionCreate, changes[0].Action()) - assert.Equal(t, "targets/a/b/c", changes[0].Scope()) - assert.Equal(t, changelist.TypeTargetsDelegation, changes[0].Type()) - assert.Equal(t, changelist.ActionCreate, changes[1].Action()) - assert.Equal(t, "targets/a/b/c", changes[1].Scope()) - assert.Equal(t, changelist.TypeTargetsDelegation, changes[1].Type()) - assert.Equal(t, "", changes[1].Path()) - assert.NotEmpty(t, changes[0].Content()) + require.Len(t, changes, 2) + require.Equal(t, changelist.ActionCreate, changes[0].Action()) + require.Equal(t, "targets/a/b/c", changes[0].Scope()) + require.Equal(t, changelist.TypeTargetsDelegation, changes[0].Type()) + require.Equal(t, changelist.ActionCreate, changes[1].Action()) + require.Equal(t, "targets/a/b/c", changes[1].Scope()) + require.Equal(t, changelist.TypeTargetsDelegation, changes[1].Type()) + require.Equal(t, "", changes[1].Path()) + require.NotEmpty(t, changes[0].Content()) } // The changefile produced by AddDelegation, when applied, actually adds @@ -2804,31 +2804,31 @@ func TestAddDelegationChangefileApplicable(t *testing.T) { defer os.RemoveAll(repo.baseDir) targetKeyIds := repo.CryptoService.ListKeys(data.CanonicalTargetsRole) - assert.NotEmpty(t, targetKeyIds) + require.NotEmpty(t, targetKeyIds) targetPubKey := repo.CryptoService.GetKey(targetKeyIds[0]) - assert.NotNil(t, targetPubKey) + require.NotNil(t, targetPubKey) // this hierarchy has to be right to be applied err := repo.AddDelegation("targets/a", []data.PublicKey{targetPubKey}, []string{""}) - assert.NoError(t, err) + require.NoError(t, err) changes := getChanges(t, repo) - assert.Len(t, changes, 2) + require.Len(t, changes, 2) // ensure that it can be applied correctly err = applyTargetsChange(repo.tufRepo, changes[0]) - assert.NoError(t, err) + require.NoError(t, err) targetRole := repo.tufRepo.Targets[data.CanonicalTargetsRole] - assert.Len(t, targetRole.Signed.Delegations.Roles, 1) - assert.Len(t, targetRole.Signed.Delegations.Keys, 1) + require.Len(t, targetRole.Signed.Delegations.Roles, 1) + require.Len(t, targetRole.Signed.Delegations.Keys, 1) _, ok := targetRole.Signed.Delegations.Keys[targetPubKey.ID()] - assert.True(t, ok) + require.True(t, ok) newDelegationRole := targetRole.Signed.Delegations.Roles[0] - assert.Len(t, newDelegationRole.KeyIDs, 1) - assert.Equal(t, targetPubKey.ID(), newDelegationRole.KeyIDs[0]) - assert.Equal(t, "targets/a", newDelegationRole.Name) + require.Len(t, newDelegationRole.KeyIDs, 1) + require.Equal(t, targetPubKey.ID(), newDelegationRole.KeyIDs[0]) + require.Equal(t, "targets/a", newDelegationRole.Name) } // TestAddDelegationErrorWritingChanges expects errors writing a change to file @@ -2836,9 +2836,9 @@ func TestAddDelegationChangefileApplicable(t *testing.T) { func TestAddDelegationErrorWritingChanges(t *testing.T) { testErrorWritingChangefiles(t, func(repo *NotaryRepository) error { targetKeyIds := repo.CryptoService.ListKeys(data.CanonicalTargetsRole) - assert.NotEmpty(t, targetKeyIds) + require.NotEmpty(t, targetKeyIds) targetPubKey := repo.CryptoService.GetKey(targetKeyIds[0]) - assert.NotNil(t, targetPubKey) + require.NotNil(t, targetPubKey) return repo.AddDelegation("targets/a", []data.PublicKey{targetPubKey}, []string{""}) }) @@ -2855,24 +2855,24 @@ func TestRemoveDelegationChangefileValid(t *testing.T) { repo, rootKeyID := initializeRepo(t, data.ECDSAKey, gun, ts.URL, false) defer os.RemoveAll(repo.baseDir) rootPubKey := repo.CryptoService.GetKey(rootKeyID) - assert.NotNil(t, rootPubKey) + require.NotNil(t, rootPubKey) err := repo.RemoveDelegationKeys("root", []string{rootKeyID}) - assert.Error(t, err) - assert.IsType(t, data.ErrInvalidRole{}, err) - assert.Empty(t, getChanges(t, repo)) + require.Error(t, err) + require.IsType(t, data.ErrInvalidRole{}, err) + require.Empty(t, getChanges(t, repo)) // to demonstrate that so long as the delegation name is valid, the // existence of the delegation doesn't matter - assert.NoError(t, repo.RemoveDelegationKeys("targets/a/b/c", []string{rootKeyID})) + require.NoError(t, repo.RemoveDelegationKeys("targets/a/b/c", []string{rootKeyID})) // ensure that the changefile is correct changes := getChanges(t, repo) - assert.Len(t, changes, 1) - assert.Equal(t, changelist.ActionUpdate, changes[0].Action()) - assert.Equal(t, "targets/a/b/c", changes[0].Scope()) - assert.Equal(t, changelist.TypeTargetsDelegation, changes[0].Type()) - assert.Equal(t, "", changes[0].Path()) + require.Len(t, changes, 1) + require.Equal(t, changelist.ActionUpdate, changes[0].Action()) + require.Equal(t, "targets/a/b/c", changes[0].Scope()) + require.Equal(t, changelist.TypeTargetsDelegation, changes[0].Type()) + require.Equal(t, "", changes[0].Path()) } // The changefile produced by RemoveDelegationKeys, when applied, actually removes @@ -2886,30 +2886,30 @@ func TestRemoveDelegationChangefileApplicable(t *testing.T) { repo, rootKeyID := initializeRepo(t, data.ECDSAKey, gun, ts.URL, false) defer os.RemoveAll(repo.baseDir) rootPubKey := repo.CryptoService.GetKey(rootKeyID) - assert.NotNil(t, rootPubKey) + require.NotNil(t, rootPubKey) // add a delegation first so it can be removed - assert.NoError(t, repo.AddDelegation("targets/a", []data.PublicKey{rootPubKey}, []string{""})) + require.NoError(t, repo.AddDelegation("targets/a", []data.PublicKey{rootPubKey}, []string{""})) changes := getChanges(t, repo) - assert.Len(t, changes, 2) - assert.NoError(t, applyTargetsChange(repo.tufRepo, changes[0])) - assert.NoError(t, applyTargetsChange(repo.tufRepo, changes[1])) + require.Len(t, changes, 2) + require.NoError(t, applyTargetsChange(repo.tufRepo, changes[0])) + require.NoError(t, applyTargetsChange(repo.tufRepo, changes[1])) targetRole := repo.tufRepo.Targets[data.CanonicalTargetsRole] - assert.Len(t, targetRole.Signed.Delegations.Roles, 1) - assert.Len(t, targetRole.Signed.Delegations.Keys, 1) + require.Len(t, targetRole.Signed.Delegations.Roles, 1) + require.Len(t, targetRole.Signed.Delegations.Keys, 1) // now remove it rootKeyCanonicalID, err := utils.CanonicalKeyID(rootPubKey) - assert.NoError(t, err) - assert.NoError(t, repo.RemoveDelegationKeys("targets/a", []string{rootKeyCanonicalID})) + require.NoError(t, err) + require.NoError(t, repo.RemoveDelegationKeys("targets/a", []string{rootKeyCanonicalID})) changes = getChanges(t, repo) - assert.Len(t, changes, 3) - assert.NoError(t, applyTargetsChange(repo.tufRepo, changes[2])) + require.Len(t, changes, 3) + require.NoError(t, applyTargetsChange(repo.tufRepo, changes[2])) targetRole = repo.tufRepo.Targets[data.CanonicalTargetsRole] - assert.Empty(t, targetRole.Signed.Delegations.Roles) - assert.Empty(t, targetRole.Signed.Delegations.Keys) + require.Empty(t, targetRole.Signed.Delegations.Roles) + require.Empty(t, targetRole.Signed.Delegations.Keys) } // The changefile with the ClearAllPaths key set, when applied, actually removes @@ -2922,24 +2922,24 @@ func TestClearAllPathsDelegationChangefileApplicable(t *testing.T) { repo, rootKeyID := initializeRepo(t, data.ECDSAKey, gun, ts.URL, false) defer os.RemoveAll(repo.baseDir) rootPubKey := repo.CryptoService.GetKey(rootKeyID) - assert.NotNil(t, rootPubKey) + require.NotNil(t, rootPubKey) // add a delegation first so it can be removed - assert.NoError(t, repo.AddDelegation("targets/a", []data.PublicKey{rootPubKey}, []string{"abc,123,xyz,path"})) + require.NoError(t, repo.AddDelegation("targets/a", []data.PublicKey{rootPubKey}, []string{"abc,123,xyz,path"})) changes := getChanges(t, repo) - assert.Len(t, changes, 2) - assert.NoError(t, applyTargetsChange(repo.tufRepo, changes[0])) - assert.NoError(t, applyTargetsChange(repo.tufRepo, changes[1])) + require.Len(t, changes, 2) + require.NoError(t, applyTargetsChange(repo.tufRepo, changes[0])) + require.NoError(t, applyTargetsChange(repo.tufRepo, changes[1])) // now clear paths it - assert.NoError(t, repo.ClearDelegationPaths("targets/a")) + require.NoError(t, repo.ClearDelegationPaths("targets/a")) changes = getChanges(t, repo) - assert.Len(t, changes, 3) - assert.NoError(t, applyTargetsChange(repo.tufRepo, changes[2])) + require.Len(t, changes, 3) + require.NoError(t, applyTargetsChange(repo.tufRepo, changes[2])) delgRoles := repo.tufRepo.Targets[data.CanonicalTargetsRole].Signed.Delegations.Roles - assert.Len(t, delgRoles, 1) - assert.Len(t, delgRoles[0].Paths, 0) + require.Len(t, delgRoles, 1) + require.Len(t, delgRoles[0].Paths, 0) } // TestFullAddDelegationChangefileApplicable generates a single changelist with AddKeys and AddPaths set, @@ -2952,10 +2952,10 @@ func TestFullAddDelegationChangefileApplicable(t *testing.T) { repo, rootKeyID := initializeRepo(t, data.ECDSAKey, gun, ts.URL, false) defer os.RemoveAll(repo.baseDir) rootPubKey := repo.CryptoService.GetKey(rootKeyID) - assert.NotNil(t, rootPubKey) + require.NotNil(t, rootPubKey) key2, err := repo.CryptoService.Create("user", data.ECDSAKey) - assert.NoError(t, err) + require.NoError(t, err) delegationName := "targets/a" @@ -2970,14 +2970,14 @@ func TestFullAddDelegationChangefileApplicable(t *testing.T) { addChange(cl, change, delegationName) changes := getChanges(t, repo) - assert.Len(t, changes, 1) - assert.NoError(t, applyTargetsChange(repo.tufRepo, changes[0])) + require.Len(t, changes, 1) + require.NoError(t, applyTargetsChange(repo.tufRepo, changes[0])) delgRoles := repo.tufRepo.Targets[data.CanonicalTargetsRole].Signed.Delegations.Roles - assert.Len(t, delgRoles, 1) - assert.Len(t, delgRoles[0].Paths, 3) - assert.Len(t, delgRoles[0].KeyIDs, 2) - assert.Equal(t, delgRoles[0].Name, delegationName) + require.Len(t, delgRoles, 1) + require.Len(t, delgRoles[0].Paths, 3) + require.Len(t, delgRoles[0].KeyIDs, 2) + require.Equal(t, delgRoles[0].Name, delegationName) } // TestFullRemoveDelegationChangefileApplicable generates a single changelist with RemoveKeys and RemovePaths set, @@ -2990,24 +2990,24 @@ func TestFullRemoveDelegationChangefileApplicable(t *testing.T) { repo, rootKeyID := initializeRepo(t, data.ECDSAKey, gun, ts.URL, false) defer os.RemoveAll(repo.baseDir) rootPubKey := repo.CryptoService.GetKey(rootKeyID) - assert.NotNil(t, rootPubKey) + require.NotNil(t, rootPubKey) key2, err := repo.CryptoService.Create("user", data.ECDSAKey) - assert.NoError(t, err) + require.NoError(t, err) key2CanonicalID, err := utils.CanonicalKeyID(key2) - assert.NoError(t, err) + require.NoError(t, err) delegationName := "targets/a" - assert.NoError(t, repo.AddDelegation(delegationName, []data.PublicKey{rootPubKey, key2}, []string{"abc", "123"})) + require.NoError(t, repo.AddDelegation(delegationName, []data.PublicKey{rootPubKey, key2}, []string{"abc", "123"})) changes := getChanges(t, repo) - assert.Len(t, changes, 2) - assert.NoError(t, applyTargetsChange(repo.tufRepo, changes[0])) - assert.NoError(t, applyTargetsChange(repo.tufRepo, changes[1])) + require.Len(t, changes, 2) + require.NoError(t, applyTargetsChange(repo.tufRepo, changes[0])) + require.NoError(t, applyTargetsChange(repo.tufRepo, changes[1])) targetRole := repo.tufRepo.Targets[data.CanonicalTargetsRole] - assert.Len(t, targetRole.Signed.Delegations.Roles, 1) - assert.Len(t, targetRole.Signed.Delegations.Keys, 2) + require.Len(t, targetRole.Signed.Delegations.Roles, 1) + require.Len(t, targetRole.Signed.Delegations.Keys, 2) // manually create the changelist object to load multiple keys tdJSON, err := json.Marshal(&changelist.TufDelegation{ @@ -3019,13 +3019,13 @@ func TestFullRemoveDelegationChangefileApplicable(t *testing.T) { addChange(cl, change, delegationName) changes = getChanges(t, repo) - assert.Len(t, changes, 3) - assert.NoError(t, applyTargetsChange(repo.tufRepo, changes[2])) + require.Len(t, changes, 3) + require.NoError(t, applyTargetsChange(repo.tufRepo, changes[2])) delgRoles := repo.tufRepo.Targets[data.CanonicalTargetsRole].Signed.Delegations.Roles - assert.Len(t, delgRoles, 1) - assert.Len(t, delgRoles[0].Paths, 0) - assert.Len(t, delgRoles[0].KeyIDs, 1) + require.Len(t, delgRoles, 1) + require.Len(t, delgRoles[0].Paths, 0) + require.Len(t, delgRoles[0].KeyIDs, 1) } // TestRemoveDelegationErrorWritingChanges expects errors writing a change to @@ -3041,7 +3041,7 @@ func TestRemoveDelegationErrorWritingChanges(t *testing.T) { // a TUF server func TestBootstrapClientBadURL(t *testing.T) { tempBaseDir, err := ioutil.TempDir("", "notary-test-") - assert.NoError(t, err, "failed to create a temporary directory: %s", err) + require.NoError(t, err, "failed to create a temporary directory: %s", err) repo, err := NewNotaryRepository( tempBaseDir, "testGun", @@ -3049,20 +3049,20 @@ func TestBootstrapClientBadURL(t *testing.T) { http.DefaultTransport, passphraseRetriever, ) - assert.NoError(t, err, "error creating repo: %s", err) + require.NoError(t, err, "error creating repo: %s", err) c, err := repo.bootstrapClient(false) - assert.Nil(t, c) - assert.Error(t, err) + require.Nil(t, c) + require.Error(t, err) c, err2 := repo.bootstrapClient(true) - assert.Nil(t, c) - assert.Error(t, err2) + require.Nil(t, c) + require.Error(t, err2) // same error should be returned because we don't have local data // and are requesting remote root regardless of checkInitialized // value - assert.EqualError(t, err, err2.Error()) + require.EqualError(t, err, err2.Error()) } // TestBootstrapClientInvalidURL checks that bootstrapClient correctly @@ -3070,7 +3070,7 @@ func TestBootstrapClientBadURL(t *testing.T) { // a TUF server func TestBootstrapClientInvalidURL(t *testing.T) { tempBaseDir, err := ioutil.TempDir("", "notary-test-") - assert.NoError(t, err, "failed to create a temporary directory: %s", err) + require.NoError(t, err, "failed to create a temporary directory: %s", err) repo, err := NewNotaryRepository( tempBaseDir, "testGun", @@ -3078,20 +3078,20 @@ func TestBootstrapClientInvalidURL(t *testing.T) { http.DefaultTransport, passphraseRetriever, ) - assert.NoError(t, err, "error creating repo: %s", err) + require.NoError(t, err, "error creating repo: %s", err) c, err := repo.bootstrapClient(false) - assert.Nil(t, c) - assert.Error(t, err) + require.Nil(t, c) + require.Error(t, err) c, err2 := repo.bootstrapClient(true) - assert.Nil(t, c) - assert.Error(t, err2) + require.Nil(t, c) + require.Error(t, err2) // same error should be returned because we don't have local data // and are requesting remote root regardless of checkInitialized // value - assert.EqualError(t, err, err2.Error()) + require.EqualError(t, err, err2.Error()) } func TestPublishTargetsDelgationCanUseUserKeyWithArbitraryRole(t *testing.T) { @@ -3118,18 +3118,18 @@ func testPublishTargetsDelgationCanUseUserKeyWithArbitraryRole(t *testing.T, x50 // create a key on the owner repo aKey := createKey(t, ownerRepo, "user", x509) aKeyID, err := utils.CanonicalKeyID(aKey) - assert.NoError(t, err) + require.NoError(t, err) // move this to the tuf_keys directory without any GUN, and ensure that we // can sign with it - assert.NoError(t, os.Rename( + require.NoError(t, os.Rename( filepath.Join(ownerRepo.baseDir, "private/tuf_keys", gun, aKeyID+".key"), filepath.Join(ownerRepo.baseDir, "private/tuf_keys", aKeyID+".key"))) // create a key on the delegated repo bKey := createKey(t, delgRepo, "notARealRoleName", x509) bKeyID, err := utils.CanonicalKeyID(bKey) - assert.NoError(t, err) - assert.NoError(t, os.Rename( + require.NoError(t, err) + require.NoError(t, os.Rename( filepath.Join(delgRepo.baseDir, "private/tuf_keys", gun, bKeyID+".key"), filepath.Join(delgRepo.baseDir, "private/tuf_keys", bKeyID+".key"))) @@ -3139,23 +3139,23 @@ func testPublishTargetsDelgationCanUseUserKeyWithArbitraryRole(t *testing.T, x50 delgRepo, delgRec = newRepoToTestRepo(t, delgRepo, false) // owner creates delegations, adds the delegated key to them, and publishes them - assert.NoError(t, + require.NoError(t, ownerRepo.AddDelegation("targets/a", []data.PublicKey{aKey}, []string{""}), "error creating delegation") - assert.NoError(t, + require.NoError(t, ownerRepo.AddDelegation("targets/a/b", []data.PublicKey{bKey}, []string{""}), "error creating delegation") - assert.NoError(t, ownerRepo.Publish()) + require.NoError(t, ownerRepo.Publish()) // delegation parents all get signed - ownerRec.assertAsked(t, []string{data.CanonicalTargetsRole, "targets/a"}) + ownerRec.requireAsked(t, []string{data.CanonicalTargetsRole, "targets/a"}) // delegated repo now publishes to delegated roles, but it will need // to download those roles first, since it doesn't know about them - assertPublishToRolesSucceeds(t, delgRepo, []string{"targets/a/b"}, + requirePublishToRolesSucceeds(t, delgRepo, []string{"targets/a/b"}, []string{"targets/a/b"}) - delgRec.assertAsked(t, []string{"targets/a/b"}) + delgRec.requireAsked(t, []string{"targets/a/b"}) } // TestDeleteRepo tests that local repo data, certificate, and keys are deleted from the client library call @@ -3169,30 +3169,30 @@ func TestDeleteRepo(t *testing.T) { defer os.RemoveAll(repo.baseDir) // Assert initialization was successful before we delete - assertRepoHasExpectedKeys(t, repo, rootKeyID, true) - assertRepoHasExpectedCerts(t, repo) - assertRepoHasExpectedMetadata(t, repo, data.CanonicalRootRole, true) - assertRepoHasExpectedMetadata(t, repo, data.CanonicalTargetsRole, true) - assertRepoHasExpectedMetadata(t, repo, data.CanonicalSnapshotRole, true) + requireRepoHasExpectedKeys(t, repo, rootKeyID, true) + requireRepoHasExpectedCerts(t, repo) + requireRepoHasExpectedMetadata(t, repo, data.CanonicalRootRole, true) + requireRepoHasExpectedMetadata(t, repo, data.CanonicalTargetsRole, true) + requireRepoHasExpectedMetadata(t, repo, data.CanonicalSnapshotRole, true) // Delete all client trust data for repo err := repo.DeleteTrustData() - assert.NoError(t, err) + require.NoError(t, err) // Assert no metadata for this repo exists locally - assertRepoHasExpectedMetadata(t, repo, data.CanonicalRootRole, false) - assertRepoHasExpectedMetadata(t, repo, data.CanonicalTargetsRole, false) - assertRepoHasExpectedMetadata(t, repo, data.CanonicalSnapshotRole, false) - assertRepoHasExpectedMetadata(t, repo, data.CanonicalTimestampRole, false) + requireRepoHasExpectedMetadata(t, repo, data.CanonicalRootRole, false) + requireRepoHasExpectedMetadata(t, repo, data.CanonicalTargetsRole, false) + requireRepoHasExpectedMetadata(t, repo, data.CanonicalSnapshotRole, false) + requireRepoHasExpectedMetadata(t, repo, data.CanonicalTimestampRole, false) // Assert no certs for this repo exist locally _, err = repo.CertStore.GetCertificatesByCN(gun) - assert.Error(t, err) - assert.IsType(t, &trustmanager.ErrNoCertificatesFound{}, err) - assert.NotNil(t, err) + require.Error(t, err) + require.IsType(t, &trustmanager.ErrNoCertificatesFound{}, err) + require.NotNil(t, err) // Assert keys for this repo exist locally - assertRepoHasExpectedKeys(t, repo, rootKeyID, true) + requireRepoHasExpectedKeys(t, repo, rootKeyID, true) } type brokenRemoveFilestore struct { @@ -3214,18 +3214,18 @@ func TestDeleteRepoBadFilestore(t *testing.T) { defer os.RemoveAll(repo.baseDir) // Assert initialization was successful before we delete - assertRepoHasExpectedKeys(t, repo, rootKeyID, true) - assertRepoHasExpectedCerts(t, repo) - assertRepoHasExpectedMetadata(t, repo, data.CanonicalRootRole, true) - assertRepoHasExpectedMetadata(t, repo, data.CanonicalTargetsRole, true) - assertRepoHasExpectedMetadata(t, repo, data.CanonicalSnapshotRole, true) + requireRepoHasExpectedKeys(t, repo, rootKeyID, true) + requireRepoHasExpectedCerts(t, repo) + requireRepoHasExpectedMetadata(t, repo, data.CanonicalRootRole, true) + requireRepoHasExpectedMetadata(t, repo, data.CanonicalTargetsRole, true) + requireRepoHasExpectedMetadata(t, repo, data.CanonicalSnapshotRole, true) // Make the filestore faulty on remove repo.fileStore = &brokenRemoveFilestore{repo.fileStore} - // Delete all client trust data for repo, assert an error on the filestore removal + // Delete all client trust data for repo, require an error on the filestore removal err := repo.DeleteTrustData() - assert.Error(t, err) + require.Error(t, err) } // TestDeleteRepoNoCerts tests that local repo data is deleted successfully without an error even when we do not have certificates @@ -3239,37 +3239,37 @@ func TestDeleteRepoNoCerts(t *testing.T) { defer os.RemoveAll(repo.baseDir) // Assert initialization was successful before we delete - assertRepoHasExpectedKeys(t, repo, rootKeyID, true) - assertRepoHasExpectedCerts(t, repo) - assertRepoHasExpectedMetadata(t, repo, data.CanonicalRootRole, true) - assertRepoHasExpectedMetadata(t, repo, data.CanonicalTargetsRole, true) - assertRepoHasExpectedMetadata(t, repo, data.CanonicalSnapshotRole, true) + requireRepoHasExpectedKeys(t, repo, rootKeyID, true) + requireRepoHasExpectedCerts(t, repo) + requireRepoHasExpectedMetadata(t, repo, data.CanonicalRootRole, true) + requireRepoHasExpectedMetadata(t, repo, data.CanonicalTargetsRole, true) + requireRepoHasExpectedMetadata(t, repo, data.CanonicalSnapshotRole, true) - // Delete the certificate store contents and assert it has been fully deleted + // Delete the certificate store contents and require it has been fully deleted repo.CertStore.RemoveAll() _, err := repo.CertStore.GetCertificatesByCN(gun) - assert.Error(t, err) - assert.IsType(t, &trustmanager.ErrNoCertificatesFound{}, err) - assert.NotNil(t, err) + require.Error(t, err) + require.IsType(t, &trustmanager.ErrNoCertificatesFound{}, err) + require.NotNil(t, err) // Delete all client trust data for repo err = repo.DeleteTrustData() - assert.NoError(t, err) + require.NoError(t, err) // Assert no metadata for this repo exists locally - assertRepoHasExpectedMetadata(t, repo, data.CanonicalRootRole, false) - assertRepoHasExpectedMetadata(t, repo, data.CanonicalTargetsRole, false) - assertRepoHasExpectedMetadata(t, repo, data.CanonicalSnapshotRole, false) - assertRepoHasExpectedMetadata(t, repo, data.CanonicalTimestampRole, false) + requireRepoHasExpectedMetadata(t, repo, data.CanonicalRootRole, false) + requireRepoHasExpectedMetadata(t, repo, data.CanonicalTargetsRole, false) + requireRepoHasExpectedMetadata(t, repo, data.CanonicalSnapshotRole, false) + requireRepoHasExpectedMetadata(t, repo, data.CanonicalTimestampRole, false) // Assert no certs for this repo exist locally _, err = repo.CertStore.GetCertificatesByCN(gun) - assert.Error(t, err) - assert.IsType(t, &trustmanager.ErrNoCertificatesFound{}, err) - assert.NotNil(t, err) + require.Error(t, err) + require.IsType(t, &trustmanager.ErrNoCertificatesFound{}, err) + require.NotNil(t, err) // Assert keys for this repo exist locally - assertRepoHasExpectedKeys(t, repo, rootKeyID, true) + requireRepoHasExpectedKeys(t, repo, rootKeyID, true) } // Test that we get a correct list of roles with keys and signatures @@ -3280,93 +3280,93 @@ func TestListRoles(t *testing.T) { repo, _ := initializeRepo(t, data.ECDSAKey, "docker.com/notary", ts.URL, false) defer os.RemoveAll(repo.baseDir) - assert.NoError(t, repo.Publish()) + require.NoError(t, repo.Publish()) rolesWithSigs, err := repo.ListRoles() - assert.NoError(t, err) + require.NoError(t, err) // Should only have base roles at this point - assert.Len(t, rolesWithSigs, len(data.BaseRoles)) + require.Len(t, rolesWithSigs, len(data.BaseRoles)) // Each base role should only have one key, one signature, and its key should match the signature's key for _, role := range rolesWithSigs { - assert.Len(t, role.Signatures, 1) - assert.Len(t, role.KeyIDs, 1) - assert.Equal(t, role.Signatures[0].KeyID, role.KeyIDs[0]) + require.Len(t, role.Signatures, 1) + require.Len(t, role.KeyIDs, 1) + require.Equal(t, role.Signatures[0].KeyID, role.KeyIDs[0]) } // Create a delegation on the top level aKey := createKey(t, repo, "user", true) - assert.NoError(t, + require.NoError(t, repo.AddDelegation("targets/a", []data.PublicKey{aKey}, []string{""}), "error creating delegation") - assert.NoError(t, repo.Publish()) + require.NoError(t, repo.Publish()) rolesWithSigs, err = repo.ListRoles() - assert.NoError(t, err) + require.NoError(t, err) - assert.Len(t, rolesWithSigs, len(data.BaseRoles)+1) + require.Len(t, rolesWithSigs, len(data.BaseRoles)+1) // The delegation hasn't published any targets or metadata so it won't have a signature yet for _, role := range rolesWithSigs { if role.Name == "targets/a" { - assert.Nil(t, role.Signatures) + require.Nil(t, role.Signatures) } else { - assert.Len(t, role.Signatures, 1) - assert.Equal(t, role.Signatures[0].KeyID, role.KeyIDs[0]) + require.Len(t, role.Signatures, 1) + require.Equal(t, role.Signatures[0].KeyID, role.KeyIDs[0]) } - assert.Len(t, role.KeyIDs, 1) + require.Len(t, role.KeyIDs, 1) } addTarget(t, repo, "current", "../fixtures/intermediate-ca.crt", "targets/a") - assert.NoError(t, repo.Publish()) + require.NoError(t, repo.Publish()) rolesWithSigs, err = repo.ListRoles() - assert.NoError(t, err) + require.NoError(t, err) - assert.Len(t, rolesWithSigs, len(data.BaseRoles)+1) + require.Len(t, rolesWithSigs, len(data.BaseRoles)+1) // The delegation should have a signature now for _, role := range rolesWithSigs { - assert.Len(t, role.Signatures, 1) - assert.Equal(t, role.Signatures[0].KeyID, role.KeyIDs[0]) - assert.Len(t, role.KeyIDs, 1) + require.Len(t, role.Signatures, 1) + require.Equal(t, role.Signatures[0].KeyID, role.KeyIDs[0]) + require.Len(t, role.KeyIDs, 1) } // Create another delegation, one level further bKey := createKey(t, repo, "user", true) - assert.NoError(t, + require.NoError(t, repo.AddDelegation("targets/a/b", []data.PublicKey{bKey}, []string{""}), "error creating delegation") - assert.NoError(t, repo.Publish()) + require.NoError(t, repo.Publish()) rolesWithSigs, err = repo.ListRoles() - assert.NoError(t, err) + require.NoError(t, err) - assert.Len(t, rolesWithSigs, len(data.BaseRoles)+2) + require.Len(t, rolesWithSigs, len(data.BaseRoles)+2) // The nested delegation hasn't published any targets or metadata so it won't have a signature yet for _, role := range rolesWithSigs { if role.Name == "targets/a/b" { - assert.Nil(t, role.Signatures) + require.Nil(t, role.Signatures) } else { - assert.Len(t, role.Signatures, 1) - assert.Equal(t, role.Signatures[0].KeyID, role.KeyIDs[0]) + require.Len(t, role.Signatures, 1) + require.Equal(t, role.Signatures[0].KeyID, role.KeyIDs[0]) } - assert.Len(t, role.KeyIDs, 1) + require.Len(t, role.KeyIDs, 1) } // Now make another repo and check that we don't pick up its roles repo2, _ := initializeRepo(t, data.ECDSAKey, "docker.com/notary2", ts.URL, false) defer os.RemoveAll(repo2.baseDir) - assert.NoError(t, repo2.Publish()) + require.NoError(t, repo2.Publish()) // repo2 only has the base roles rolesWithSigs2, err := repo2.ListRoles() - assert.NoError(t, err) - assert.Len(t, rolesWithSigs2, len(data.BaseRoles)) + require.NoError(t, err) + require.Len(t, rolesWithSigs2, len(data.BaseRoles)) // original repo stays in same state (base roles + 2 delegations) rolesWithSigs, err = repo.ListRoles() - assert.NoError(t, err) - assert.Len(t, rolesWithSigs, len(data.BaseRoles)+2) + require.NoError(t, err) + require.Len(t, rolesWithSigs, len(data.BaseRoles)+2) } diff --git a/client/helpers_test.go b/client/helpers_test.go index e48d4c8524..3df3b46315 100644 --- a/client/helpers_test.go +++ b/client/helpers_test.go @@ -8,14 +8,14 @@ import ( "github.com/docker/notary/client/changelist" "github.com/docker/notary/tuf/data" "github.com/docker/notary/tuf/testutils" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestApplyTargetsChange(t *testing.T) { repo, _, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) _, err = repo.InitTargets(data.CanonicalTargetsRole) - assert.NoError(t, err) + require.NoError(t, err) hash := sha256.Sum256([]byte{}) f := &data.FileMeta{ Length: 1, @@ -24,7 +24,7 @@ func TestApplyTargetsChange(t *testing.T) { }, } fjson, err := json.Marshal(f) - assert.NoError(t, err) + require.NoError(t, err) addChange := &changelist.TufChange{ Actn: changelist.ActionCreate, @@ -34,8 +34,8 @@ func TestApplyTargetsChange(t *testing.T) { Data: fjson, } err = applyTargetsChange(repo, addChange) - assert.NoError(t, err) - assert.NotNil(t, repo.Targets["targets"].Signed.Targets["latest"]) + require.NoError(t, err) + require.NotNil(t, repo.Targets["targets"].Signed.Targets["latest"]) removeChange := &changelist.TufChange{ Actn: changelist.ActionDelete, @@ -45,17 +45,17 @@ func TestApplyTargetsChange(t *testing.T) { Data: nil, } err = applyTargetsChange(repo, removeChange) - assert.NoError(t, err) + require.NoError(t, err) _, ok := repo.Targets["targets"].Signed.Targets["latest"] - assert.False(t, ok) + require.False(t, ok) } // Adding the same target twice doesn't actually add it. func TestApplyAddTargetTwice(t *testing.T) { repo, _, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) _, err = repo.InitTargets(data.CanonicalTargetsRole) - assert.NoError(t, err) + require.NoError(t, err) hash := sha256.Sum256([]byte{}) f := &data.FileMeta{ Length: 1, @@ -64,17 +64,17 @@ func TestApplyAddTargetTwice(t *testing.T) { }, } fjson, err := json.Marshal(f) - assert.NoError(t, err) + require.NoError(t, err) cl := changelist.NewMemChangelist() - assert.NoError(t, cl.Add(&changelist.TufChange{ + require.NoError(t, cl.Add(&changelist.TufChange{ Actn: changelist.ActionCreate, Role: changelist.ScopeTargets, ChangeType: "target", ChangePath: "latest", Data: fjson, })) - assert.NoError(t, cl.Add(&changelist.TufChange{ + require.NoError(t, cl.Add(&changelist.TufChange{ Actn: changelist.ActionCreate, Role: changelist.ScopeTargets, ChangeType: "target", @@ -82,26 +82,26 @@ func TestApplyAddTargetTwice(t *testing.T) { Data: fjson, })) - assert.NoError(t, applyChangelist(repo, cl)) - assert.Len(t, repo.Targets["targets"].Signed.Targets, 1) - assert.NotEmpty(t, repo.Targets["targets"].Signed.Targets["latest"]) + require.NoError(t, applyChangelist(repo, cl)) + require.Len(t, repo.Targets["targets"].Signed.Targets, 1) + require.NotEmpty(t, repo.Targets["targets"].Signed.Targets["latest"]) - assert.NoError(t, applyTargetsChange(repo, &changelist.TufChange{ + require.NoError(t, applyTargetsChange(repo, &changelist.TufChange{ Actn: changelist.ActionCreate, Role: changelist.ScopeTargets, ChangeType: "target", ChangePath: "latest", Data: fjson, })) - assert.Len(t, repo.Targets["targets"].Signed.Targets, 1) - assert.NotEmpty(t, repo.Targets["targets"].Signed.Targets["latest"]) + require.Len(t, repo.Targets["targets"].Signed.Targets, 1) + require.NotEmpty(t, repo.Targets["targets"].Signed.Targets["latest"]) } func TestApplyChangelist(t *testing.T) { repo, _, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) _, err = repo.InitTargets(data.CanonicalTargetsRole) - assert.NoError(t, err) + require.NoError(t, err) hash := sha256.Sum256([]byte{}) f := &data.FileMeta{ Length: 1, @@ -110,7 +110,7 @@ func TestApplyChangelist(t *testing.T) { }, } fjson, err := json.Marshal(f) - assert.NoError(t, err) + require.NoError(t, err) cl := changelist.NewMemChangelist() addChange := &changelist.TufChange{ @@ -122,8 +122,8 @@ func TestApplyChangelist(t *testing.T) { } cl.Add(addChange) err = applyChangelist(repo, cl) - assert.NoError(t, err) - assert.NotNil(t, repo.Targets["targets"].Signed.Targets["latest"]) + require.NoError(t, err) + require.NotNil(t, repo.Targets["targets"].Signed.Targets["latest"]) cl.Clear("") @@ -136,16 +136,16 @@ func TestApplyChangelist(t *testing.T) { } cl.Add(removeChange) err = applyChangelist(repo, cl) - assert.NoError(t, err) + require.NoError(t, err) _, ok := repo.Targets["targets"].Signed.Targets["latest"] - assert.False(t, ok) + require.False(t, ok) } func TestApplyChangelistMulti(t *testing.T) { repo, _, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) _, err = repo.InitTargets(data.CanonicalTargetsRole) - assert.NoError(t, err) + require.NoError(t, err) hash := sha256.Sum256([]byte{}) f := &data.FileMeta{ Length: 1, @@ -154,7 +154,7 @@ func TestApplyChangelistMulti(t *testing.T) { }, } fjson, err := json.Marshal(f) - assert.NoError(t, err) + require.NoError(t, err) cl := changelist.NewMemChangelist() addChange := &changelist.TufChange{ @@ -177,17 +177,17 @@ func TestApplyChangelistMulti(t *testing.T) { cl.Add(removeChange) err = applyChangelist(repo, cl) - assert.NoError(t, err) + require.NoError(t, err) _, ok := repo.Targets["targets"].Signed.Targets["latest"] - assert.False(t, ok) + require.False(t, ok) } func TestApplyTargetsDelegationCreateDelete(t *testing.T) { repo, cs, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) newKey, err := cs.Create("targets/level1", data.ED25519Key) - assert.NoError(t, err) + require.NoError(t, err) // create delegation kl := data.KeyList{newKey} @@ -198,7 +198,7 @@ func TestApplyTargetsDelegationCreateDelete(t *testing.T) { } tdJSON, err := json.Marshal(td) - assert.NoError(t, err) + require.NoError(t, err) ch := changelist.NewTufChange( changelist.ActionCreate, @@ -209,20 +209,20 @@ func TestApplyTargetsDelegationCreateDelete(t *testing.T) { ) err = applyTargetsChange(repo, ch) - assert.NoError(t, err) + require.NoError(t, err) tgts := repo.Targets[data.CanonicalTargetsRole] - assert.Len(t, tgts.Signed.Delegations.Roles, 1) - assert.Len(t, tgts.Signed.Delegations.Keys, 1) + require.Len(t, tgts.Signed.Delegations.Roles, 1) + require.Len(t, tgts.Signed.Delegations.Keys, 1) _, ok := tgts.Signed.Delegations.Keys[newKey.ID()] - assert.True(t, ok) + require.True(t, ok) role := tgts.Signed.Delegations.Roles[0] - assert.Len(t, role.KeyIDs, 1) - assert.Equal(t, newKey.ID(), role.KeyIDs[0]) - assert.Equal(t, "targets/level1", role.Name) - assert.Equal(t, "level1", role.Paths[0]) + require.Len(t, role.KeyIDs, 1) + require.Equal(t, newKey.ID(), role.KeyIDs[0]) + require.Equal(t, "targets/level1", role.Name) + require.Equal(t, "level1", role.Paths[0]) // delete delegation td = &changelist.TufDelegation{ @@ -230,7 +230,7 @@ func TestApplyTargetsDelegationCreateDelete(t *testing.T) { } tdJSON, err = json.Marshal(td) - assert.NoError(t, err) + require.NoError(t, err) ch = changelist.NewTufChange( changelist.ActionDelete, "targets/level1", @@ -240,18 +240,18 @@ func TestApplyTargetsDelegationCreateDelete(t *testing.T) { ) err = applyTargetsChange(repo, ch) - assert.NoError(t, err) + require.NoError(t, err) - assert.Len(t, tgts.Signed.Delegations.Roles, 0) - assert.Len(t, tgts.Signed.Delegations.Keys, 0) + require.Len(t, tgts.Signed.Delegations.Roles, 0) + require.Len(t, tgts.Signed.Delegations.Keys, 0) } func TestApplyTargetsDelegationCreate2SharedKey(t *testing.T) { repo, cs, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) newKey, err := cs.Create("targets/level1", data.ED25519Key) - assert.NoError(t, err) + require.NoError(t, err) // create first delegation kl := data.KeyList{newKey} @@ -262,7 +262,7 @@ func TestApplyTargetsDelegationCreate2SharedKey(t *testing.T) { } tdJSON, err := json.Marshal(td) - assert.NoError(t, err) + require.NoError(t, err) ch := changelist.NewTufChange( changelist.ActionCreate, @@ -273,7 +273,7 @@ func TestApplyTargetsDelegationCreate2SharedKey(t *testing.T) { ) err = applyTargetsChange(repo, ch) - assert.NoError(t, err) + require.NoError(t, err) // create second delegation kl = data.KeyList{newKey} @@ -284,7 +284,7 @@ func TestApplyTargetsDelegationCreate2SharedKey(t *testing.T) { } tdJSON, err = json.Marshal(td) - assert.NoError(t, err) + require.NoError(t, err) ch = changelist.NewTufChange( changelist.ActionCreate, @@ -295,30 +295,30 @@ func TestApplyTargetsDelegationCreate2SharedKey(t *testing.T) { ) err = applyTargetsChange(repo, ch) - assert.NoError(t, err) + require.NoError(t, err) tgts := repo.Targets[data.CanonicalTargetsRole] - assert.Len(t, tgts.Signed.Delegations.Roles, 2) - assert.Len(t, tgts.Signed.Delegations.Keys, 1) + require.Len(t, tgts.Signed.Delegations.Roles, 2) + require.Len(t, tgts.Signed.Delegations.Keys, 1) role1 := tgts.Signed.Delegations.Roles[0] - assert.Len(t, role1.KeyIDs, 1) - assert.Equal(t, newKey.ID(), role1.KeyIDs[0]) - assert.Equal(t, "targets/level1", role1.Name) - assert.Equal(t, "level1", role1.Paths[0]) + require.Len(t, role1.KeyIDs, 1) + require.Equal(t, newKey.ID(), role1.KeyIDs[0]) + require.Equal(t, "targets/level1", role1.Name) + require.Equal(t, "level1", role1.Paths[0]) role2 := tgts.Signed.Delegations.Roles[1] - assert.Len(t, role2.KeyIDs, 1) - assert.Equal(t, newKey.ID(), role2.KeyIDs[0]) - assert.Equal(t, "targets/level2", role2.Name) - assert.Equal(t, "level2", role2.Paths[0]) + require.Len(t, role2.KeyIDs, 1) + require.Equal(t, newKey.ID(), role2.KeyIDs[0]) + require.Equal(t, "targets/level2", role2.Name) + require.Equal(t, "level2", role2.Paths[0]) // delete one delegation, ensure shared key remains td = &changelist.TufDelegation{ RemoveKeys: []string{newKey.ID()}, } tdJSON, err = json.Marshal(td) - assert.NoError(t, err) + require.NoError(t, err) ch = changelist.NewTufChange( changelist.ActionDelete, "targets/level1", @@ -328,10 +328,10 @@ func TestApplyTargetsDelegationCreate2SharedKey(t *testing.T) { ) err = applyTargetsChange(repo, ch) - assert.NoError(t, err) + require.NoError(t, err) - assert.Len(t, tgts.Signed.Delegations.Roles, 1) - assert.Len(t, tgts.Signed.Delegations.Keys, 1) + require.Len(t, tgts.Signed.Delegations.Roles, 1) + require.Len(t, tgts.Signed.Delegations.Keys, 1) // delete other delegation, ensure key cleaned up ch = changelist.NewTufChange( @@ -343,18 +343,18 @@ func TestApplyTargetsDelegationCreate2SharedKey(t *testing.T) { ) err = applyTargetsChange(repo, ch) - assert.NoError(t, err) + require.NoError(t, err) - assert.Len(t, tgts.Signed.Delegations.Roles, 0) - assert.Len(t, tgts.Signed.Delegations.Keys, 0) + require.Len(t, tgts.Signed.Delegations.Roles, 0) + require.Len(t, tgts.Signed.Delegations.Keys, 0) } func TestApplyTargetsDelegationCreateEdit(t *testing.T) { repo, cs, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) newKey, err := cs.Create("targets/level1", data.ED25519Key) - assert.NoError(t, err) + require.NoError(t, err) // create delegation kl := data.KeyList{newKey} @@ -365,7 +365,7 @@ func TestApplyTargetsDelegationCreateEdit(t *testing.T) { } tdJSON, err := json.Marshal(td) - assert.NoError(t, err) + require.NoError(t, err) ch := changelist.NewTufChange( changelist.ActionCreate, @@ -376,11 +376,11 @@ func TestApplyTargetsDelegationCreateEdit(t *testing.T) { ) err = applyTargetsChange(repo, ch) - assert.NoError(t, err) + require.NoError(t, err) // edit delegation newKey2, err := cs.Create("targets/level1", data.ED25519Key) - assert.NoError(t, err) + require.NoError(t, err) kl = data.KeyList{newKey2} td = &changelist.TufDelegation{ @@ -390,7 +390,7 @@ func TestApplyTargetsDelegationCreateEdit(t *testing.T) { } tdJSON, err = json.Marshal(td) - assert.NoError(t, err) + require.NoError(t, err) ch = changelist.NewTufChange( changelist.ActionUpdate, @@ -401,28 +401,28 @@ func TestApplyTargetsDelegationCreateEdit(t *testing.T) { ) err = applyTargetsChange(repo, ch) - assert.NoError(t, err) + require.NoError(t, err) tgts := repo.Targets[data.CanonicalTargetsRole] - assert.Len(t, tgts.Signed.Delegations.Roles, 1) - assert.Len(t, tgts.Signed.Delegations.Keys, 1) + require.Len(t, tgts.Signed.Delegations.Roles, 1) + require.Len(t, tgts.Signed.Delegations.Keys, 1) _, ok := tgts.Signed.Delegations.Keys[newKey2.ID()] - assert.True(t, ok) + require.True(t, ok) role := tgts.Signed.Delegations.Roles[0] - assert.Len(t, role.KeyIDs, 1) - assert.Equal(t, newKey2.ID(), role.KeyIDs[0]) - assert.Equal(t, "targets/level1", role.Name) - assert.Equal(t, "level1", role.Paths[0]) + require.Len(t, role.KeyIDs, 1) + require.Equal(t, newKey2.ID(), role.KeyIDs[0]) + require.Equal(t, "targets/level1", role.Name) + require.Equal(t, "level1", role.Paths[0]) } func TestApplyTargetsDelegationEditNonExisting(t *testing.T) { repo, cs, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) newKey, err := cs.Create("targets/level1", data.ED25519Key) - assert.NoError(t, err) + require.NoError(t, err) // create delegation kl := data.KeyList{newKey} @@ -433,7 +433,7 @@ func TestApplyTargetsDelegationEditNonExisting(t *testing.T) { } tdJSON, err := json.Marshal(td) - assert.NoError(t, err) + require.NoError(t, err) ch := changelist.NewTufChange( changelist.ActionUpdate, @@ -444,16 +444,16 @@ func TestApplyTargetsDelegationEditNonExisting(t *testing.T) { ) err = applyTargetsChange(repo, ch) - assert.Error(t, err) - assert.IsType(t, data.ErrInvalidRole{}, err) + require.Error(t, err) + require.IsType(t, data.ErrInvalidRole{}, err) } func TestApplyTargetsDelegationCreateAlreadyExisting(t *testing.T) { repo, cs, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) newKey, err := cs.Create("targets/level1", data.ED25519Key) - assert.NoError(t, err) + require.NoError(t, err) // create delegation kl := data.KeyList{newKey} @@ -464,7 +464,7 @@ func TestApplyTargetsDelegationCreateAlreadyExisting(t *testing.T) { } tdJSON, err := json.Marshal(td) - assert.NoError(t, err) + require.NoError(t, err) ch := changelist.NewTufChange( changelist.ActionCreate, @@ -475,12 +475,12 @@ func TestApplyTargetsDelegationCreateAlreadyExisting(t *testing.T) { ) err = applyTargetsChange(repo, ch) - assert.NoError(t, err) + require.NoError(t, err) // we have sufficient checks elsewhere we don't need to confirm that - // creating fresh works here via more asserts. + // creating fresh works here via more requires. extraKey, err := cs.Create("targets/level1", data.ED25519Key) - assert.NoError(t, err) + require.NoError(t, err) // create delegation kl = data.KeyList{extraKey} @@ -491,7 +491,7 @@ func TestApplyTargetsDelegationCreateAlreadyExisting(t *testing.T) { } tdJSON, err = json.Marshal(td) - assert.NoError(t, err) + require.NoError(t, err) ch = changelist.NewTufChange( changelist.ActionCreate, @@ -503,19 +503,19 @@ func TestApplyTargetsDelegationCreateAlreadyExisting(t *testing.T) { // when attempting to create the same role again, check that we added a key err = applyTargetsChange(repo, ch) - assert.NoError(t, err) + require.NoError(t, err) delegation, err := repo.GetDelegationRole("targets/level1") - assert.NoError(t, err) - assert.Contains(t, delegation.Paths, "level1") - assert.Equal(t, len(delegation.ListKeyIDs()), 2) + require.NoError(t, err) + require.Contains(t, delegation.Paths, "level1") + require.Equal(t, len(delegation.ListKeyIDs()), 2) } func TestApplyTargetsDelegationAlreadyExistingMergePaths(t *testing.T) { repo, cs, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) newKey, err := cs.Create("targets/level1", data.ED25519Key) - assert.NoError(t, err) + require.NoError(t, err) // create delegation kl := data.KeyList{newKey} @@ -526,7 +526,7 @@ func TestApplyTargetsDelegationAlreadyExistingMergePaths(t *testing.T) { } tdJSON, err := json.Marshal(td) - assert.NoError(t, err) + require.NoError(t, err) ch := changelist.NewTufChange( changelist.ActionCreate, @@ -537,15 +537,15 @@ func TestApplyTargetsDelegationAlreadyExistingMergePaths(t *testing.T) { ) err = applyTargetsChange(repo, ch) - assert.NoError(t, err) + require.NoError(t, err) // we have sufficient checks elsewhere we don't need to confirm that - // creating fresh works here via more asserts. + // creating fresh works here via more requires. // Use different path for this changelist td.AddPaths = []string{"level2"} tdJSON, err = json.Marshal(td) - assert.NoError(t, err) + require.NoError(t, err) ch = changelist.NewTufChange( changelist.ActionCreate, @@ -558,20 +558,20 @@ func TestApplyTargetsDelegationAlreadyExistingMergePaths(t *testing.T) { // when attempting to create the same role again, check that we // merged with previous details err = applyTargetsChange(repo, ch) - assert.NoError(t, err) + require.NoError(t, err) delegation, err := repo.GetDelegationRole("targets/level1") - assert.NoError(t, err) + require.NoError(t, err) // Assert we have both paths - assert.Contains(t, delegation.Paths, "level2") - assert.Contains(t, delegation.Paths, "level1") + require.Contains(t, delegation.Paths, "level2") + require.Contains(t, delegation.Paths, "level1") } func TestApplyTargetsDelegationInvalidRole(t *testing.T) { repo, cs, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) newKey, err := cs.Create("targets/level1", data.ED25519Key) - assert.NoError(t, err) + require.NoError(t, err) // create delegation kl := data.KeyList{newKey} @@ -582,7 +582,7 @@ func TestApplyTargetsDelegationInvalidRole(t *testing.T) { } tdJSON, err := json.Marshal(td) - assert.NoError(t, err) + require.NoError(t, err) ch := changelist.NewTufChange( changelist.ActionCreate, @@ -593,15 +593,15 @@ func TestApplyTargetsDelegationInvalidRole(t *testing.T) { ) err = applyTargetsChange(repo, ch) - assert.Error(t, err) + require.Error(t, err) } func TestApplyTargetsDelegationInvalidJSONContent(t *testing.T) { repo, cs, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) newKey, err := cs.Create("targets/level1", data.ED25519Key) - assert.NoError(t, err) + require.NoError(t, err) // create delegation kl := data.KeyList{newKey} @@ -612,7 +612,7 @@ func TestApplyTargetsDelegationInvalidJSONContent(t *testing.T) { } tdJSON, err := json.Marshal(td) - assert.NoError(t, err) + require.NoError(t, err) ch := changelist.NewTufChange( changelist.ActionCreate, @@ -623,12 +623,12 @@ func TestApplyTargetsDelegationInvalidJSONContent(t *testing.T) { ) err = applyTargetsChange(repo, ch) - assert.Error(t, err) + require.Error(t, err) } func TestApplyTargetsDelegationInvalidAction(t *testing.T) { repo, _, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) ch := changelist.NewTufChange( "bad action", @@ -639,12 +639,12 @@ func TestApplyTargetsDelegationInvalidAction(t *testing.T) { ) err = applyTargetsChange(repo, ch) - assert.Error(t, err) + require.Error(t, err) } func TestApplyTargetsChangeInvalidType(t *testing.T) { repo, _, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) ch := changelist.NewTufChange( changelist.ActionCreate, @@ -655,15 +655,15 @@ func TestApplyTargetsChangeInvalidType(t *testing.T) { ) err = applyTargetsChange(repo, ch) - assert.Error(t, err) + require.Error(t, err) } func TestApplyTargetsDelegationCreate2Deep(t *testing.T) { repo, cs, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) newKey, err := cs.Create("targets/level1", data.ED25519Key) - assert.NoError(t, err) + require.NoError(t, err) // create delegation kl := data.KeyList{newKey} @@ -674,7 +674,7 @@ func TestApplyTargetsDelegationCreate2Deep(t *testing.T) { } tdJSON, err := json.Marshal(td) - assert.NoError(t, err) + require.NoError(t, err) ch := changelist.NewTufChange( changelist.ActionCreate, @@ -685,20 +685,20 @@ func TestApplyTargetsDelegationCreate2Deep(t *testing.T) { ) err = applyTargetsChange(repo, ch) - assert.NoError(t, err) + require.NoError(t, err) tgts := repo.Targets[data.CanonicalTargetsRole] - assert.Len(t, tgts.Signed.Delegations.Roles, 1) - assert.Len(t, tgts.Signed.Delegations.Keys, 1) + require.Len(t, tgts.Signed.Delegations.Roles, 1) + require.Len(t, tgts.Signed.Delegations.Keys, 1) _, ok := tgts.Signed.Delegations.Keys[newKey.ID()] - assert.True(t, ok) + require.True(t, ok) role := tgts.Signed.Delegations.Roles[0] - assert.Len(t, role.KeyIDs, 1) - assert.Equal(t, newKey.ID(), role.KeyIDs[0]) - assert.Equal(t, "targets/level1", role.Name) - assert.Equal(t, "level1", role.Paths[0]) + require.Len(t, role.KeyIDs, 1) + require.Equal(t, newKey.ID(), role.KeyIDs[0]) + require.Equal(t, "targets/level1", role.Name) + require.Equal(t, "level1", role.Paths[0]) // init delegations targets file. This would be done as part of a publish // operation @@ -711,7 +711,7 @@ func TestApplyTargetsDelegationCreate2Deep(t *testing.T) { } tdJSON, err = json.Marshal(td) - assert.NoError(t, err) + require.NoError(t, err) ch = changelist.NewTufChange( changelist.ActionCreate, @@ -722,34 +722,34 @@ func TestApplyTargetsDelegationCreate2Deep(t *testing.T) { ) err = applyTargetsChange(repo, ch) - assert.NoError(t, err) + require.NoError(t, err) tgts = repo.Targets["targets/level1"] - assert.Len(t, tgts.Signed.Delegations.Roles, 1) - assert.Len(t, tgts.Signed.Delegations.Keys, 1) + require.Len(t, tgts.Signed.Delegations.Roles, 1) + require.Len(t, tgts.Signed.Delegations.Keys, 1) _, ok = tgts.Signed.Delegations.Keys[newKey.ID()] - assert.True(t, ok) + require.True(t, ok) role = tgts.Signed.Delegations.Roles[0] - assert.Len(t, role.KeyIDs, 1) - assert.Equal(t, newKey.ID(), role.KeyIDs[0]) - assert.Equal(t, "targets/level1/level2", role.Name) - assert.Equal(t, "level1/level2", role.Paths[0]) + require.Len(t, role.KeyIDs, 1) + require.Equal(t, newKey.ID(), role.KeyIDs[0]) + require.Equal(t, "targets/level1/level2", role.Name) + require.Equal(t, "level1/level2", role.Paths[0]) } // Applying a delegation whose parent doesn't exist fails. func TestApplyTargetsDelegationParentDoesntExist(t *testing.T) { repo, cs, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) // make sure a key exists for the previous level, so it's not a missing // key error, but we don't care about this key _, err = cs.Create("targets/level1", data.ED25519Key) - assert.NoError(t, err) + require.NoError(t, err) newKey, err := cs.Create("targets/level1/level2", data.ED25519Key) - assert.NoError(t, err) + require.NoError(t, err) // create delegation kl := data.KeyList{newKey} @@ -759,7 +759,7 @@ func TestApplyTargetsDelegationParentDoesntExist(t *testing.T) { } tdJSON, err := json.Marshal(td) - assert.NoError(t, err) + require.NoError(t, err) ch := changelist.NewTufChange( changelist.ActionCreate, @@ -770,20 +770,20 @@ func TestApplyTargetsDelegationParentDoesntExist(t *testing.T) { ) err = applyTargetsChange(repo, ch) - assert.Error(t, err) - assert.IsType(t, data.ErrInvalidRole{}, err) + require.Error(t, err) + require.IsType(t, data.ErrInvalidRole{}, err) } // If there is no delegation target, ApplyTargets creates it func TestApplyChangelistCreatesDelegation(t *testing.T) { repo, cs, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) newKey, err := cs.Create("targets/level1", data.ED25519Key) - assert.NoError(t, err) + require.NoError(t, err) err = repo.UpdateDelegationKeys("targets/level1", []data.PublicKey{newKey}, []string{}, 1) - assert.NoError(t, err) + require.NoError(t, err) err = repo.UpdateDelegationPaths("targets/level1", []string{""}, []string{}, false) delete(repo.Targets, "targets/level1") @@ -795,10 +795,10 @@ func TestApplyChangelistCreatesDelegation(t *testing.T) { }, } fjson, err := json.Marshal(f) - assert.NoError(t, err) + require.NoError(t, err) cl := changelist.NewMemChangelist() - assert.NoError(t, cl.Add(&changelist.TufChange{ + require.NoError(t, cl.Add(&changelist.TufChange{ Actn: changelist.ActionCreate, Role: "targets/level1", ChangeType: "target", @@ -806,30 +806,30 @@ func TestApplyChangelistCreatesDelegation(t *testing.T) { Data: fjson, })) - assert.NoError(t, applyChangelist(repo, cl)) + require.NoError(t, applyChangelist(repo, cl)) _, ok := repo.Targets["targets/level1"] - assert.True(t, ok, "Failed to create the delegation target") + require.True(t, ok, "Failed to create the delegation target") _, ok = repo.Targets["targets/level1"].Signed.Targets["latest"] - assert.True(t, ok, "Failed to write change to delegation target") + require.True(t, ok, "Failed to write change to delegation target") } // Each change applies only to the role specified func TestApplyChangelistTargetsToMultipleRoles(t *testing.T) { repo, cs, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) newKey, err := cs.Create("targets/level1", data.ED25519Key) - assert.NoError(t, err) + require.NoError(t, err) err = repo.UpdateDelegationKeys("targets/level1", []data.PublicKey{newKey}, []string{}, 1) - assert.NoError(t, err) + require.NoError(t, err) err = repo.UpdateDelegationPaths("targets/level1", []string{""}, []string{}, false) - assert.NoError(t, err) + require.NoError(t, err) err = repo.UpdateDelegationKeys("targets/level2", []data.PublicKey{newKey}, []string{}, 1) - assert.NoError(t, err) + require.NoError(t, err) err = repo.UpdateDelegationPaths("targets/level2", []string{""}, []string{}, false) - assert.NoError(t, err) + require.NoError(t, err) hash := sha256.Sum256([]byte{}) f := &data.FileMeta{ @@ -839,17 +839,17 @@ func TestApplyChangelistTargetsToMultipleRoles(t *testing.T) { }, } fjson, err := json.Marshal(f) - assert.NoError(t, err) + require.NoError(t, err) cl := changelist.NewMemChangelist() - assert.NoError(t, cl.Add(&changelist.TufChange{ + require.NoError(t, cl.Add(&changelist.TufChange{ Actn: changelist.ActionCreate, Role: "targets/level1", ChangeType: "target", ChangePath: "latest", Data: fjson, })) - assert.NoError(t, cl.Add(&changelist.TufChange{ + require.NoError(t, cl.Add(&changelist.TufChange{ Actn: changelist.ActionDelete, Role: "targets/level2", ChangeType: "target", @@ -857,17 +857,17 @@ func TestApplyChangelistTargetsToMultipleRoles(t *testing.T) { Data: nil, })) - assert.NoError(t, applyChangelist(repo, cl)) + require.NoError(t, applyChangelist(repo, cl)) _, ok := repo.Targets["targets/level1"].Signed.Targets["latest"] - assert.True(t, ok) + require.True(t, ok) _, ok = repo.Targets["targets/level2"] - assert.False(t, ok, "no change to targets/level2, so metadata not created") + require.False(t, ok, "no change to targets/level2, so metadata not created") } // ApplyTargets falls back to role that exists when adding or deleting a change func TestApplyChangelistTargetsFallbackRoles(t *testing.T) { repo, _, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) hash := sha256.Sum256([]byte{}) f := &data.FileMeta{ @@ -877,10 +877,10 @@ func TestApplyChangelistTargetsFallbackRoles(t *testing.T) { }, } fjson, err := json.Marshal(f) - assert.NoError(t, err) + require.NoError(t, err) cl := changelist.NewMemChangelist() - assert.NoError(t, cl.Add(&changelist.TufChange{ + require.NoError(t, cl.Add(&changelist.TufChange{ Actn: changelist.ActionCreate, Role: "targets/level1/level2/level3/level4", ChangeType: "target", @@ -888,13 +888,13 @@ func TestApplyChangelistTargetsFallbackRoles(t *testing.T) { Data: fjson, })) - assert.NoError(t, applyChangelist(repo, cl)) + require.NoError(t, applyChangelist(repo, cl)) _, ok := repo.Targets[data.CanonicalTargetsRole].Signed.Targets["latest"] - assert.True(t, ok) + require.True(t, ok) - // now delete and assert it applies to + // now delete and require it applies to cl = changelist.NewMemChangelist() - assert.NoError(t, cl.Add(&changelist.TufChange{ + require.NoError(t, cl.Add(&changelist.TufChange{ Actn: changelist.ActionDelete, Role: "targets/level1/level2/level3/level4", ChangeType: "target", @@ -902,14 +902,14 @@ func TestApplyChangelistTargetsFallbackRoles(t *testing.T) { Data: nil, })) - assert.NoError(t, applyChangelist(repo, cl)) - assert.Empty(t, repo.Targets[data.CanonicalTargetsRole].Signed.Targets) + require.NoError(t, applyChangelist(repo, cl)) + require.Empty(t, repo.Targets[data.CanonicalTargetsRole].Signed.Targets) } // changeTargetMeta fallback fails with ErrInvalidRole if role is invalid func TestChangeTargetMetaFallbackFailsInvalidRole(t *testing.T) { repo, _, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) hash := sha256.Sum256([]byte{}) f := &data.FileMeta{ @@ -919,7 +919,7 @@ func TestChangeTargetMetaFallbackFailsInvalidRole(t *testing.T) { }, } fjson, err := json.Marshal(f) - assert.NoError(t, err) + require.NoError(t, err) err = changeTargetMeta(repo, &changelist.TufChange{ Actn: changelist.ActionCreate, @@ -928,23 +928,23 @@ func TestChangeTargetMetaFallbackFailsInvalidRole(t *testing.T) { ChangePath: "latest", Data: fjson, }) - assert.Error(t, err) - assert.IsType(t, data.ErrInvalidRole{}, err) + require.Error(t, err) + require.IsType(t, data.ErrInvalidRole{}, err) } // If applying a change fails due to a prefix error, it does not fall back // on the parent. func TestChangeTargetMetaDoesntFallbackIfPrefixError(t *testing.T) { repo, cs, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) newKey, err := cs.Create("targets/level1", data.ED25519Key) - assert.NoError(t, err) + require.NoError(t, err) err = repo.UpdateDelegationKeys("targets/level1", []data.PublicKey{newKey}, []string{}, 1) - assert.NoError(t, err) + require.NoError(t, err) err = repo.UpdateDelegationPaths("targets/level1", []string{"pathprefix"}, []string{}, false) - assert.NoError(t, err) + require.NoError(t, err) hash := sha256.Sum256([]byte{}) f := &data.FileMeta{ @@ -954,7 +954,7 @@ func TestChangeTargetMetaDoesntFallbackIfPrefixError(t *testing.T) { }, } fjson, err := json.Marshal(f) - assert.NoError(t, err) + require.NoError(t, err) err = changeTargetMeta(repo, &changelist.TufChange{ Actn: changelist.ActionCreate, @@ -963,9 +963,9 @@ func TestChangeTargetMetaDoesntFallbackIfPrefixError(t *testing.T) { ChangePath: "notPathPrefix", Data: fjson, }) - assert.Error(t, err) + require.Error(t, err) // no target in targets or targets/latest - assert.Empty(t, repo.Targets[data.CanonicalTargetsRole].Signed.Targets) - assert.Empty(t, repo.Targets["targets/level1"].Signed.Targets) + require.Empty(t, repo.Targets[data.CanonicalTargetsRole].Signed.Targets) + require.Empty(t, repo.Targets["targets/level1"].Signed.Targets) } diff --git a/tuf/client/client_test.go b/tuf/client/client_test.go index 84c9b9f1a2..716f3261be 100644 --- a/tuf/client/client_test.go +++ b/tuf/client/client_test.go @@ -12,7 +12,7 @@ import ( "github.com/Sirupsen/logrus" tuf "github.com/docker/notary/tuf" "github.com/docker/notary/tuf/testutils" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "github.com/docker/notary/tuf/data" "github.com/docker/notary/tuf/signed" @@ -27,9 +27,9 @@ func TestRotation(t *testing.T) { // Generate initial root key and role and add to key DB rootKey, err := signer.Create("root", data.ED25519Key) - assert.NoError(t, err, "Error creating root key") + require.NoError(t, err, "Error creating root key") rootRole, err := data.NewRole("root", 1, []string{rootKey.ID()}, nil) - assert.NoError(t, err, "Error creating root role") + require.NoError(t, err, "Error creating root role") originalRoot, err := data.NewRoot( map[string]data.PublicKey{rootKey.ID(): rootKey}, @@ -41,9 +41,9 @@ func TestRotation(t *testing.T) { // Generate new key and role. replacementKey, err := signer.Create("root", data.ED25519Key) - assert.NoError(t, err, "Error creating replacement root key") + require.NoError(t, err, "Error creating replacement root key") replacementRole, err := data.NewRole("root", 1, []string{replacementKey.ID()}, nil) - assert.NoError(t, err, "Error creating replacement root role") + require.NoError(t, err, "Error creating replacement root role") // Generate a new root with the replacement key and role testRoot, err := data.NewRoot( @@ -56,12 +56,12 @@ func TestRotation(t *testing.T) { }, false, ) - assert.NoError(t, err, "Failed to create new root") + require.NoError(t, err, "Failed to create new root") // Sign testRoot with both old and new keys signedRoot, err := testRoot.ToSigned() err = signed.Sign(signer, signedRoot, rootKey, replacementKey) - assert.NoError(t, err, "Failed to sign root") + require.NoError(t, err, "Failed to sign root") var origKeySig bool var replKeySig bool for _, sig := range signedRoot.Signatures { @@ -71,13 +71,13 @@ func TestRotation(t *testing.T) { replKeySig = true } } - assert.True(t, origKeySig, "Original root key signature not present") - assert.True(t, replKeySig, "Replacement root key signature not present") + require.True(t, origKeySig, "Original root key signature not present") + require.True(t, replKeySig, "Replacement root key signature not present") client := NewClient(repo, remote, cache) err = client.verifyRoot("root", signedRoot, 0) - assert.NoError(t, err, "Failed to verify key rotated root") + require.NoError(t, err, "Failed to verify key rotated root") } func TestRotationNewSigMissing(t *testing.T) { @@ -89,9 +89,9 @@ func TestRotationNewSigMissing(t *testing.T) { // Generate initial root key and role and add to key DB rootKey, err := signer.Create("root", data.ED25519Key) - assert.NoError(t, err, "Error creating root key") + require.NoError(t, err, "Error creating root key") rootRole, err := data.NewRole("root", 1, []string{rootKey.ID()}, nil) - assert.NoError(t, err, "Error creating root role") + require.NoError(t, err, "Error creating root role") originalRoot, err := data.NewRoot( map[string]data.PublicKey{rootKey.ID(): rootKey}, @@ -103,11 +103,11 @@ func TestRotationNewSigMissing(t *testing.T) { // Generate new key and role. replacementKey, err := signer.Create("root", data.ED25519Key) - assert.NoError(t, err, "Error creating replacement root key") + require.NoError(t, err, "Error creating replacement root key") replacementRole, err := data.NewRole("root", 1, []string{replacementKey.ID()}, nil) - assert.NoError(t, err, "Error creating replacement root role") + require.NoError(t, err, "Error creating replacement root role") - assert.NotEqual(t, rootKey.ID(), replacementKey.ID(), "Key IDs are the same") + require.NotEqual(t, rootKey.ID(), replacementKey.ID(), "Key IDs are the same") // Generate a new root with the replacement key and role testRoot, err := data.NewRoot( @@ -115,15 +115,15 @@ func TestRotationNewSigMissing(t *testing.T) { map[string]*data.RootRole{"root": &replacementRole.RootRole}, false, ) - assert.NoError(t, err, "Failed to create new root") + require.NoError(t, err, "Failed to create new root") _, ok := testRoot.Signed.Keys[rootKey.ID()] - assert.False(t, ok, "Old root key appeared in test root") + require.False(t, ok, "Old root key appeared in test root") // Sign testRoot with both old and new keys signedRoot, err := testRoot.ToSigned() err = signed.Sign(signer, signedRoot, rootKey) - assert.NoError(t, err, "Failed to sign root") + require.NoError(t, err, "Failed to sign root") var origKeySig bool var replKeySig bool for _, sig := range signedRoot.Signatures { @@ -133,13 +133,13 @@ func TestRotationNewSigMissing(t *testing.T) { replKeySig = true } } - assert.True(t, origKeySig, "Original root key signature not present") - assert.False(t, replKeySig, "Replacement root key signature was present and shouldn't be") + require.True(t, origKeySig, "Original root key signature not present") + require.False(t, replKeySig, "Replacement root key signature was present and shouldn't be") client := NewClient(repo, remote, cache) err = client.verifyRoot("root", signedRoot, 0) - assert.Error(t, err, "Should have errored on verify as replacement signature was missing.") + require.Error(t, err, "Should have errored on verify as replacement signature was missing.") } @@ -152,9 +152,9 @@ func TestRotationOldSigMissing(t *testing.T) { // Generate initial root key and role and add to key DB rootKey, err := signer.Create("root", data.ED25519Key) - assert.NoError(t, err, "Error creating root key") + require.NoError(t, err, "Error creating root key") rootRole, err := data.NewRole("root", 1, []string{rootKey.ID()}, nil) - assert.NoError(t, err, "Error creating root role") + require.NoError(t, err, "Error creating root role") originalRoot, err := data.NewRoot( map[string]data.PublicKey{rootKey.ID(): rootKey}, @@ -166,11 +166,11 @@ func TestRotationOldSigMissing(t *testing.T) { // Generate new key and role. replacementKey, err := signer.Create("root", data.ED25519Key) - assert.NoError(t, err, "Error creating replacement root key") + require.NoError(t, err, "Error creating replacement root key") replacementRole, err := data.NewRole("root", 1, []string{replacementKey.ID()}, nil) - assert.NoError(t, err, "Error creating replacement root role") + require.NoError(t, err, "Error creating replacement root role") - assert.NotEqual(t, rootKey.ID(), replacementKey.ID(), "Key IDs are the same") + require.NotEqual(t, rootKey.ID(), replacementKey.ID(), "Key IDs are the same") // Generate a new root with the replacement key and role testRoot, err := data.NewRoot( @@ -178,15 +178,15 @@ func TestRotationOldSigMissing(t *testing.T) { map[string]*data.RootRole{"root": &replacementRole.RootRole}, false, ) - assert.NoError(t, err, "Failed to create new root") + require.NoError(t, err, "Failed to create new root") _, ok := testRoot.Signed.Keys[rootKey.ID()] - assert.False(t, ok, "Old root key appeared in test root") + require.False(t, ok, "Old root key appeared in test root") // Sign testRoot with both old and new keys signedRoot, err := testRoot.ToSigned() err = signed.Sign(signer, signedRoot, replacementKey) - assert.NoError(t, err, "Failed to sign root") + require.NoError(t, err, "Failed to sign root") var origKeySig bool var replKeySig bool for _, sig := range signedRoot.Signatures { @@ -196,13 +196,13 @@ func TestRotationOldSigMissing(t *testing.T) { replKeySig = true } } - assert.False(t, origKeySig, "Original root key signature was present and shouldn't be") - assert.True(t, replKeySig, "Replacement root key signature was not present") + require.False(t, origKeySig, "Original root key signature was present and shouldn't be") + require.True(t, replKeySig, "Replacement root key signature was not present") client := NewClient(repo, remote, cache) err = client.verifyRoot("root", signedRoot, 0) - assert.Error(t, err, "Should have errored on verify as replacement signature was missing.") + require.Error(t, err, "Should have errored on verify as replacement signature was missing.") } @@ -215,9 +215,9 @@ func TestCheckRootExpired(t *testing.T) { root.Signed.Expires = time.Now().AddDate(-1, 0, 0) signedRoot, err := root.ToSigned() - assert.NoError(t, err) + require.NoError(t, err) rootJSON, err := json.Marshal(signedRoot) - assert.NoError(t, err) + require.NoError(t, err) rootHash := sha256.Sum256(rootJSON) @@ -239,8 +239,8 @@ func TestCheckRootExpired(t *testing.T) { storage.SetMeta("root", rootJSON) err = client.checkRoot() - assert.Error(t, err) - assert.IsType(t, tuf.ErrLocalRootExpired{}, err) + require.Error(t, err) + require.IsType(t, tuf.ErrLocalRootExpired{}, err) } func TestChecksumMismatch(t *testing.T) { @@ -251,15 +251,15 @@ func TestChecksumMismatch(t *testing.T) { sampleTargets := data.NewTargets() orig, err := json.Marshal(sampleTargets) - assert.NoError(t, err) + require.NoError(t, err) origHashes, err := GetSupportedHashes(orig) - assert.NoError(t, err) + require.NoError(t, err) remoteStorage.SetMeta("targets", orig) _, _, err = client.downloadSigned("targets", int64(len(orig)), origHashes) - assert.IsType(t, ErrChecksumMismatch{}, err) + require.IsType(t, ErrChecksumMismatch{}, err) } func TestChecksumMatch(t *testing.T) { @@ -270,15 +270,15 @@ func TestChecksumMatch(t *testing.T) { sampleTargets := data.NewTargets() orig, err := json.Marshal(sampleTargets) - assert.NoError(t, err) + require.NoError(t, err) origHashes, err := GetSupportedHashes(orig) - assert.NoError(t, err) + require.NoError(t, err) remoteStorage.SetMeta("targets", orig) _, _, err = client.downloadSigned("targets", int64(len(orig)), origHashes) - assert.NoError(t, err) + require.NoError(t, err) } func TestSizeMismatchLong(t *testing.T) { @@ -289,18 +289,18 @@ func TestSizeMismatchLong(t *testing.T) { sampleTargets := data.NewTargets() orig, err := json.Marshal(sampleTargets) - assert.NoError(t, err) + require.NoError(t, err) l := int64(len(orig)) origHashes, err := GetSupportedHashes(orig) - assert.NoError(t, err) + require.NoError(t, err) remoteStorage.SetMeta("targets", orig) _, _, err = client.downloadSigned("targets", l, origHashes) // size just limits the data received, the error is caught // either during checksum verification or during json deserialization - assert.IsType(t, ErrChecksumMismatch{}, err) + require.IsType(t, ErrChecksumMismatch{}, err) } func TestSizeMismatchShort(t *testing.T) { @@ -311,39 +311,39 @@ func TestSizeMismatchShort(t *testing.T) { sampleTargets := data.NewTargets() orig, err := json.Marshal(sampleTargets) - assert.NoError(t, err) + require.NoError(t, err) l := int64(len(orig)) origHashes, err := GetSupportedHashes(orig) - assert.NoError(t, err) + require.NoError(t, err) remoteStorage.SetMeta("targets", orig) _, _, err = client.downloadSigned("targets", l, origHashes) // size just limits the data received, the error is caught // either during checksum verification or during json deserialization - assert.IsType(t, ErrChecksumMismatch{}, err) + require.IsType(t, ErrChecksumMismatch{}, err) } func TestDownloadTargetsHappy(t *testing.T) { repo, _, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) localStorage := store.NewMemoryStore(nil) remoteStorage := store.NewMemoryStore(nil) client := NewClient(repo, remoteStorage, localStorage) signedOrig, err := repo.SignTargets("targets", data.DefaultExpires("targets")) - assert.NoError(t, err) + require.NoError(t, err) orig, err := json.Marshal(signedOrig) - assert.NoError(t, err) + require.NoError(t, err) err = remoteStorage.SetMeta("targets", orig) - assert.NoError(t, err) + require.NoError(t, err) // call repo.SignSnapshot to update the targets role in the snapshot repo.SignSnapshot(data.DefaultExpires("snapshot")) err = client.downloadTargets("targets") - assert.NoError(t, err) + require.NoError(t, err) } // TestDownloadTargetsLarge: Check that we can download very large targets metadata files, @@ -355,7 +355,7 @@ func TestDownloadTargetsLarge(t *testing.T) { } repo, _, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) localStorage := store.NewMemoryStore(nil) remoteStorage := store.NewMemoryStore(nil) client := NewClient(repo, remoteStorage, localStorage) @@ -371,15 +371,15 @@ func TestDownloadTargetsLarge(t *testing.T) { // 75,000 targets results in > 5MB (~6.5MB on recent runs) for i := 0; i < 75000; i++ { _, err = repo.AddTargets(data.CanonicalTargetsRole, data.Files{strconv.Itoa(i): f}) - assert.NoError(t, err) + require.NoError(t, err) } signedOrig, err := repo.SignTargets("targets", data.DefaultExpires("targets")) - assert.NoError(t, err) + require.NoError(t, err) orig, err := json.Marshal(signedOrig) - assert.NoError(t, err) + require.NoError(t, err) err = remoteStorage.SetMeta("targets", orig) - assert.NoError(t, err) + require.NoError(t, err) // call repo.SignSnapshot to update the targets role in the snapshot repo.SignSnapshot(data.DefaultExpires("snapshot")) @@ -388,12 +388,12 @@ func TestDownloadTargetsLarge(t *testing.T) { client.cache.RemoveAll() err = client.downloadTargets("targets") - assert.NoError(t, err) + require.NoError(t, err) } func TestDownloadTargetsDeepHappy(t *testing.T) { repo, cs, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) localStorage := store.NewMemoryStore(nil) remoteStorage := store.NewMemoryStore(nil) client := NewClient(repo, remoteStorage, localStorage) @@ -416,13 +416,13 @@ func TestDownloadTargetsDeepHappy(t *testing.T) { for _, r := range delegations { // create role k, err := cs.Create(r, data.ED25519Key) - assert.NoError(t, err) + require.NoError(t, err) // add role to repo err = repo.UpdateDelegationKeys(r, []data.PublicKey{k}, []string{}, 1) - assert.NoError(t, err) + require.NoError(t, err) err = repo.UpdateDelegationPaths(r, []string{""}, []string{}, false) - assert.NoError(t, err) + require.NoError(t, err) repo.InitTargets(r) } @@ -430,20 +430,20 @@ func TestDownloadTargetsDeepHappy(t *testing.T) { for _, r := range delegations { // serialize and store role signedOrig, err := repo.SignTargets(r, data.DefaultExpires("targets")) - assert.NoError(t, err) + require.NoError(t, err) orig, err := json.Marshal(signedOrig) - assert.NoError(t, err) + require.NoError(t, err) err = remoteStorage.SetMeta(r, orig) - assert.NoError(t, err) + require.NoError(t, err) } // serialize and store targets after adding all delegations signedOrig, err := repo.SignTargets("targets", data.DefaultExpires("targets")) - assert.NoError(t, err) + require.NoError(t, err) orig, err := json.Marshal(signedOrig) - assert.NoError(t, err) + require.NoError(t, err) err = remoteStorage.SetMeta("targets", orig) - assert.NoError(t, err) + require.NoError(t, err) // call repo.SignSnapshot to update the targets role in the snapshot repo.SignSnapshot(data.DefaultExpires("snapshot")) @@ -452,36 +452,36 @@ func TestDownloadTargetsDeepHappy(t *testing.T) { for _, r := range delegations { delete(repo.Targets, r) _, ok := repo.Targets[r] - assert.False(t, ok) + require.False(t, ok) } err = client.downloadTargets("targets") - assert.NoError(t, err) + require.NoError(t, err) _, ok := repo.Targets["targets"] - assert.True(t, ok) + require.True(t, ok) for _, r := range delegations { _, ok = repo.Targets[r] - assert.True(t, ok) + require.True(t, ok) } } func TestDownloadTargetChecksumMismatch(t *testing.T) { repo, _, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) localStorage := store.NewMemoryStore(nil) remoteStorage := testutils.NewCorruptingMemoryStore(nil) client := NewClient(repo, remoteStorage, localStorage) // create and "upload" sample targets signedOrig, err := repo.SignTargets("targets", data.DefaultExpires("targets")) - assert.NoError(t, err) + require.NoError(t, err) orig, err := json.Marshal(signedOrig) - assert.NoError(t, err) + require.NoError(t, err) origSha256 := sha256.Sum256(orig) err = remoteStorage.SetMeta("targets", orig) - assert.NoError(t, err) + require.NoError(t, err) // create local snapshot with targets file snap := data.SignedSnapshot{ @@ -500,192 +500,192 @@ func TestDownloadTargetChecksumMismatch(t *testing.T) { repo.Snapshot = &snap err = client.downloadTargets("targets") - assert.IsType(t, ErrChecksumMismatch{}, err) + require.IsType(t, ErrChecksumMismatch{}, err) } // TestDownloadTargetsNoChecksum: it's never valid to download any targets // role (incl. delegations) when a checksum is not available. func TestDownloadTargetsNoChecksum(t *testing.T) { repo, _, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) localStorage := store.NewMemoryStore(nil) remoteStorage := store.NewMemoryStore(nil) client := NewClient(repo, remoteStorage, localStorage) // create and "upload" sample targets signedOrig, err := repo.SignTargets("targets", data.DefaultExpires("targets")) - assert.NoError(t, err) + require.NoError(t, err) orig, err := json.Marshal(signedOrig) - assert.NoError(t, err) + require.NoError(t, err) err = remoteStorage.SetMeta("targets", orig) - assert.NoError(t, err) + require.NoError(t, err) delete(repo.Snapshot.Signed.Meta["targets"].Hashes, "sha256") delete(repo.Snapshot.Signed.Meta["targets"].Hashes, "sha512") err = client.downloadTargets("targets") - assert.IsType(t, data.ErrMissingMeta{}, err) + require.IsType(t, data.ErrMissingMeta{}, err) } // TestDownloadTargetsNoSnapshot: it's never valid to download any targets // role (incl. delegations) when a checksum is not available. func TestDownloadTargetsNoSnapshot(t *testing.T) { repo, _, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) localStorage := store.NewMemoryStore(nil) remoteStorage := store.NewMemoryStore(nil) client := NewClient(repo, remoteStorage, localStorage) // create and "upload" sample targets signedOrig, err := repo.SignTargets("targets", data.DefaultExpires("targets")) - assert.NoError(t, err) + require.NoError(t, err) orig, err := json.Marshal(signedOrig) - assert.NoError(t, err) + require.NoError(t, err) err = remoteStorage.SetMeta("targets", orig) - assert.NoError(t, err) + require.NoError(t, err) repo.Snapshot = nil err = client.downloadTargets("targets") - assert.IsType(t, tuf.ErrNotLoaded{}, err) + require.IsType(t, tuf.ErrNotLoaded{}, err) } func TestBootstrapDownloadRootHappy(t *testing.T) { repo, _, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) localStorage := store.NewMemoryStore(nil) remoteStorage := store.NewMemoryStore(nil) client := NewClient(repo, remoteStorage, localStorage) // create and "upload" sample root signedOrig, err := repo.SignRoot(data.DefaultExpires("root")) - assert.NoError(t, err) + require.NoError(t, err) orig, err := json.Marshal(signedOrig) - assert.NoError(t, err) + require.NoError(t, err) err = remoteStorage.SetMeta("root", orig) - assert.NoError(t, err) + require.NoError(t, err) // unset snapshot as if we're bootstrapping from nothing repo.Snapshot = nil err = client.downloadRoot() - assert.NoError(t, err) + require.NoError(t, err) } func TestUpdateDownloadRootHappy(t *testing.T) { repo, _, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) localStorage := store.NewMemoryStore(nil) remoteStorage := store.NewMemoryStore(nil) client := NewClient(repo, remoteStorage, localStorage) // create and "upload" sample root, snapshot, and timestamp signedOrig, err := repo.SignRoot(data.DefaultExpires("root")) - assert.NoError(t, err) + require.NoError(t, err) orig, err := json.Marshal(signedOrig) - assert.NoError(t, err) + require.NoError(t, err) err = remoteStorage.SetMeta("root", orig) - assert.NoError(t, err) + require.NoError(t, err) // sign snapshot to make root meta in snapshot get updated signedOrig, err = repo.SignSnapshot(data.DefaultExpires("snapshot")) err = client.downloadRoot() - assert.NoError(t, err) + require.NoError(t, err) } func TestUpdateDownloadRootBadChecksum(t *testing.T) { remoteStore := testutils.NewCorruptingMemoryStore(nil) repo, _, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) localStorage := store.NewMemoryStore(nil) client := NewClient(repo, remoteStore, localStorage) // sign and "upload" sample root signedOrig, err := repo.SignRoot(data.DefaultExpires("root")) - assert.NoError(t, err) + require.NoError(t, err) orig, err := json.Marshal(signedOrig) - assert.NoError(t, err) + require.NoError(t, err) err = remoteStore.SetMeta("root", orig) - assert.NoError(t, err) + require.NoError(t, err) // sign snapshot to make sure we have current checksum for root _, err = repo.SignSnapshot(data.DefaultExpires("snapshot")) - assert.NoError(t, err) + require.NoError(t, err) err = client.downloadRoot() - assert.IsType(t, ErrChecksumMismatch{}, err) + require.IsType(t, ErrChecksumMismatch{}, err) } func TestUpdateDownloadRootChecksumNotFound(t *testing.T) { remoteStore := store.NewMemoryStore(nil) repo, _, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) localStorage := store.NewMemoryStore(nil) client := NewClient(repo, remoteStore, localStorage) // sign snapshot to make sure we have current checksum for root _, err = repo.SignSnapshot(data.DefaultExpires("snapshot")) - assert.NoError(t, err) + require.NoError(t, err) // sign and "upload" sample root signedOrig, err := repo.SignRoot(data.DefaultExpires("root")) - assert.NoError(t, err) + require.NoError(t, err) orig, err := json.Marshal(signedOrig) - assert.NoError(t, err) + require.NoError(t, err) err = remoteStore.SetMeta("root", orig) - assert.NoError(t, err) + require.NoError(t, err) // don't sign snapshot again to ensure checksum is out of date (bad) err = client.downloadRoot() - assert.IsType(t, store.ErrMetaNotFound{}, err) + require.IsType(t, store.ErrMetaNotFound{}, err) } func TestDownloadTimestampHappy(t *testing.T) { repo, _, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) localStorage := store.NewMemoryStore(nil) remoteStorage := store.NewMemoryStore(nil) client := NewClient(repo, remoteStorage, localStorage) // create and "upload" sample timestamp signedOrig, err := repo.SignTimestamp(data.DefaultExpires("timestamp")) - assert.NoError(t, err) + require.NoError(t, err) orig, err := json.Marshal(signedOrig) - assert.NoError(t, err) + require.NoError(t, err) err = remoteStorage.SetMeta("timestamp", orig) - assert.NoError(t, err) + require.NoError(t, err) err = client.downloadTimestamp() - assert.NoError(t, err) + require.NoError(t, err) } func TestDownloadSnapshotHappy(t *testing.T) { repo, _, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) localStorage := store.NewMemoryStore(nil) remoteStorage := store.NewMemoryStore(nil) client := NewClient(repo, remoteStorage, localStorage) // create and "upload" sample snapshot and timestamp signedOrig, err := repo.SignSnapshot(data.DefaultExpires("snapshot")) - assert.NoError(t, err) + require.NoError(t, err) orig, err := json.Marshal(signedOrig) - assert.NoError(t, err) + require.NoError(t, err) err = remoteStorage.SetMeta("snapshot", orig) - assert.NoError(t, err) + require.NoError(t, err) signedOrig, err = repo.SignTimestamp(data.DefaultExpires("timestamp")) - assert.NoError(t, err) + require.NoError(t, err) orig, err = json.Marshal(signedOrig) - assert.NoError(t, err) + require.NoError(t, err) err = remoteStorage.SetMeta("timestamp", orig) - assert.NoError(t, err) + require.NoError(t, err) err = client.downloadSnapshot() - assert.NoError(t, err) + require.NoError(t, err) } // TestDownloadSnapshotLarge: Check that we can download very large snapshot metadata files, @@ -696,7 +696,7 @@ func TestDownloadSnapshotLarge(t *testing.T) { t.Skip("skipping test in short mode") } repo, _, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) localStorage := store.NewMemoryStore(nil) remoteStorage := store.NewMemoryStore(nil) client := NewClient(repo, remoteStorage, localStorage) @@ -711,187 +711,187 @@ func TestDownloadSnapshotLarge(t *testing.T) { // create and "upload" sample snapshot and timestamp signedOrig, err := repo.SignSnapshot(data.DefaultExpires("snapshot")) - assert.NoError(t, err) + require.NoError(t, err) orig, err := json.Marshal(signedOrig) - assert.NoError(t, err) + require.NoError(t, err) err = remoteStorage.SetMeta("snapshot", orig) - assert.NoError(t, err) + require.NoError(t, err) signedOrig, err = repo.SignTimestamp(data.DefaultExpires("timestamp")) - assert.NoError(t, err) + require.NoError(t, err) orig, err = json.Marshal(signedOrig) - assert.NoError(t, err) + require.NoError(t, err) err = remoteStorage.SetMeta("timestamp", orig) - assert.NoError(t, err) + require.NoError(t, err) // Clear the cache to force an online download client.cache.RemoveAll() err = client.downloadSnapshot() - assert.NoError(t, err) + require.NoError(t, err) } func TestDownloadSnapshotNoTimestamp(t *testing.T) { repo, _, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) localStorage := store.NewMemoryStore(nil) remoteStorage := store.NewMemoryStore(nil) client := NewClient(repo, remoteStorage, localStorage) // create and "upload" sample snapshot and timestamp signedOrig, err := repo.SignSnapshot(data.DefaultExpires("snapshot")) - assert.NoError(t, err) + require.NoError(t, err) orig, err := json.Marshal(signedOrig) - assert.NoError(t, err) + require.NoError(t, err) err = remoteStorage.SetMeta("snapshot", orig) - assert.NoError(t, err) + require.NoError(t, err) repo.Timestamp = nil err = client.downloadSnapshot() - assert.IsType(t, tuf.ErrNotLoaded{}, err) + require.IsType(t, tuf.ErrNotLoaded{}, err) } // TestDownloadSnapshotNoChecksum: It should never be valid to download a // snapshot if we don't have a checksum func TestDownloadSnapshotNoChecksum(t *testing.T) { repo, _, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) localStorage := store.NewMemoryStore(nil) remoteStorage := store.NewMemoryStore(nil) client := NewClient(repo, remoteStorage, localStorage) // create and "upload" sample snapshot and timestamp signedOrig, err := repo.SignSnapshot(data.DefaultExpires("snapshot")) - assert.NoError(t, err) + require.NoError(t, err) orig, err := json.Marshal(signedOrig) - assert.NoError(t, err) + require.NoError(t, err) err = remoteStorage.SetMeta("snapshot", orig) - assert.NoError(t, err) + require.NoError(t, err) delete(repo.Timestamp.Signed.Meta["snapshot"].Hashes, "sha256") delete(repo.Timestamp.Signed.Meta["snapshot"].Hashes, "sha512") err = client.downloadSnapshot() - assert.IsType(t, data.ErrMissingMeta{}, err) + require.IsType(t, data.ErrMissingMeta{}, err) } func TestDownloadSnapshotChecksumNotFound(t *testing.T) { repo, _, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) localStorage := store.NewMemoryStore(nil) remoteStorage := store.NewMemoryStore(nil) client := NewClient(repo, remoteStorage, localStorage) // sign timestamp to ensure it has a checksum for snapshot _, err = repo.SignTimestamp(data.DefaultExpires("timestamp")) - assert.NoError(t, err) + require.NoError(t, err) // create and "upload" sample snapshot and timestamp signedOrig, err := repo.SignSnapshot(data.DefaultExpires("snapshot")) - assert.NoError(t, err) + require.NoError(t, err) orig, err := json.Marshal(signedOrig) - assert.NoError(t, err) + require.NoError(t, err) err = remoteStorage.SetMeta("snapshot", orig) - assert.NoError(t, err) + require.NoError(t, err) // by not signing timestamp again we ensure it has the wrong checksum err = client.downloadSnapshot() - assert.IsType(t, store.ErrMetaNotFound{}, err) + require.IsType(t, store.ErrMetaNotFound{}, err) } // If there is no local cache and also no remote timestamp, downloading the timestamp // fails with a store.ErrMetaNotFound func TestDownloadTimestampNoTimestamps(t *testing.T) { repo, _, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) localStorage := store.NewMemoryStore(nil) remoteStorage := store.NewMemoryStore(nil) client := NewClient(repo, remoteStorage, localStorage) err = client.downloadTimestamp() - assert.Error(t, err) + require.Error(t, err) notFoundErr, ok := err.(store.ErrMetaNotFound) - assert.True(t, ok) - assert.Equal(t, data.CanonicalTimestampRole, notFoundErr.Resource) + require.True(t, ok) + require.Equal(t, data.CanonicalTimestampRole, notFoundErr.Resource) } // If there is no local cache and the remote timestamp is empty, downloading the timestamp // fails with a store.ErrMetaNotFound func TestDownloadTimestampNoLocalTimestampRemoteTimestampEmpty(t *testing.T) { repo, _, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) localStorage := store.NewMemoryStore(nil) remoteStorage := store.NewMemoryStore(map[string][]byte{data.CanonicalTimestampRole: {}}) client := NewClient(repo, remoteStorage, localStorage) err = client.downloadTimestamp() - assert.Error(t, err) - assert.IsType(t, &json.SyntaxError{}, err) + require.Error(t, err) + require.IsType(t, &json.SyntaxError{}, err) } // If there is no local cache and the remote timestamp is invalid, downloading the timestamp // fails with a store.ErrMetaNotFound func TestDownloadTimestampNoLocalTimestampRemoteTimestampInvalid(t *testing.T) { repo, _, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) localStorage := store.NewMemoryStore(nil) // add a timestamp to the remote cache tsSigned, err := repo.SignTimestamp(data.DefaultExpires("timestamp")) - assert.NoError(t, err) + require.NoError(t, err) tsSigned.Signatures[0].Signature = []byte("12345") // invalidate the signature ts, err := json.Marshal(tsSigned) - assert.NoError(t, err) + require.NoError(t, err) remoteStorage := store.NewMemoryStore(map[string][]byte{data.CanonicalTimestampRole: ts}) client := NewClient(repo, remoteStorage, localStorage) err = client.downloadTimestamp() - assert.Error(t, err) - assert.IsType(t, signed.ErrRoleThreshold{}, err) + require.Error(t, err) + require.IsType(t, signed.ErrRoleThreshold{}, err) } // If there is is a local cache and no remote timestamp, we fall back on the cached timestamp func TestDownloadTimestampLocalTimestampNoRemoteTimestamp(t *testing.T) { repo, _, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) // add a timestamp to the local cache tsSigned, err := repo.SignTimestamp(data.DefaultExpires("timestamp")) - assert.NoError(t, err) + require.NoError(t, err) ts, err := json.Marshal(tsSigned) - assert.NoError(t, err) + require.NoError(t, err) localStorage := store.NewMemoryStore(map[string][]byte{data.CanonicalTimestampRole: ts}) remoteStorage := store.NewMemoryStore(nil) client := NewClient(repo, remoteStorage, localStorage) err = client.downloadTimestamp() - assert.NoError(t, err) + require.NoError(t, err) } // If there is is a local cache and the remote timestamp is invalid, we fall back on the cached timestamp func TestDownloadTimestampLocalTimestampInvalidRemoteTimestamp(t *testing.T) { repo, _, err := testutils.EmptyRepo("docker.com/notary") - assert.NoError(t, err) + require.NoError(t, err) // add a timestamp to the local cache tsSigned, err := repo.SignTimestamp(data.DefaultExpires("timestamp")) - assert.NoError(t, err) + require.NoError(t, err) ts, err := json.Marshal(tsSigned) - assert.NoError(t, err) + require.NoError(t, err) localStorage := store.NewMemoryStore(map[string][]byte{data.CanonicalTimestampRole: ts}) // add a timestamp to the remote cache tsSigned.Signatures[0].Signature = []byte("12345") // invalidate the signature ts, err = json.Marshal(tsSigned) - assert.NoError(t, err) + require.NoError(t, err) remoteStorage := store.NewMemoryStore(map[string][]byte{data.CanonicalTimestampRole: ts}) client := NewClient(repo, remoteStorage, localStorage) err = client.downloadTimestamp() - assert.NoError(t, err) + require.NoError(t, err) } // GetSupportedHashes is a helper function that returns diff --git a/tuf/data/roles_test.go b/tuf/data/roles_test.go index 819908cac9..0441114123 100644 --- a/tuf/data/roles_test.go +++ b/tuf/data/roles_test.go @@ -5,7 +5,7 @@ import ( "strings" "testing" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestMergeStrSlicesExclusive(t *testing.T) { @@ -13,9 +13,9 @@ func TestMergeStrSlicesExclusive(t *testing.T) { new := []string{"b"} res := mergeStrSlices(orig, new) - assert.Len(t, res, 2) - assert.Equal(t, "a", res[0]) - assert.Equal(t, "b", res[1]) + require.Len(t, res, 2) + require.Equal(t, "a", res[0]) + require.Equal(t, "b", res[1]) } func TestMergeStrSlicesOverlap(t *testing.T) { @@ -23,9 +23,9 @@ func TestMergeStrSlicesOverlap(t *testing.T) { new := []string{"a", "b"} res := mergeStrSlices(orig, new) - assert.Len(t, res, 2) - assert.Equal(t, "a", res[0]) - assert.Equal(t, "b", res[1]) + require.Len(t, res, 2) + require.Equal(t, "a", res[0]) + require.Equal(t, "b", res[1]) } func TestMergeStrSlicesEqual(t *testing.T) { @@ -33,8 +33,8 @@ func TestMergeStrSlicesEqual(t *testing.T) { new := []string{"a"} res := mergeStrSlices(orig, new) - assert.Len(t, res, 1) - assert.Equal(t, "a", res[0]) + require.Len(t, res, 1) + require.Equal(t, "a", res[0]) } func TestSubtractStrSlicesExclusive(t *testing.T) { @@ -42,8 +42,8 @@ func TestSubtractStrSlicesExclusive(t *testing.T) { new := []string{"b"} res := subtractStrSlices(orig, new) - assert.Len(t, res, 1) - assert.Equal(t, "a", res[0]) + require.Len(t, res, 1) + require.Equal(t, "a", res[0]) } func TestSubtractStrSlicesOverlap(t *testing.T) { @@ -51,8 +51,8 @@ func TestSubtractStrSlicesOverlap(t *testing.T) { new := []string{"a"} res := subtractStrSlices(orig, new) - assert.Len(t, res, 1) - assert.Equal(t, "b", res[0]) + require.Len(t, res, 1) + require.Equal(t, "b", res[0]) } func TestSubtractStrSlicesEqual(t *testing.T) { @@ -60,107 +60,107 @@ func TestSubtractStrSlicesEqual(t *testing.T) { new := []string{"a"} res := subtractStrSlices(orig, new) - assert.Len(t, res, 0) + require.Len(t, res, 0) } func TestAddRemoveKeys(t *testing.T) { role, err := NewRole("targets", 1, []string{"abc"}, []string{""}) - assert.NoError(t, err) + require.NoError(t, err) role.AddKeys([]string{"abc"}) - assert.Equal(t, []string{"abc"}, role.KeyIDs) + require.Equal(t, []string{"abc"}, role.KeyIDs) role.AddKeys([]string{"def"}) - assert.Equal(t, []string{"abc", "def"}, role.KeyIDs) + require.Equal(t, []string{"abc", "def"}, role.KeyIDs) role.RemoveKeys([]string{"abc"}) - assert.Equal(t, []string{"def"}, role.KeyIDs) + require.Equal(t, []string{"def"}, role.KeyIDs) } func TestAddRemovePaths(t *testing.T) { role, err := NewRole("targets", 1, []string{"abc"}, []string{"123"}) - assert.NoError(t, err) + require.NoError(t, err) err = role.AddPaths([]string{"123"}) - assert.NoError(t, err) - assert.Equal(t, []string{"123"}, role.Paths) + require.NoError(t, err) + require.Equal(t, []string{"123"}, role.Paths) err = role.AddPaths([]string{"456"}) - assert.NoError(t, err) - assert.Equal(t, []string{"123", "456"}, role.Paths) + require.NoError(t, err) + require.Equal(t, []string{"123", "456"}, role.Paths) role.RemovePaths([]string{"123"}) - assert.Equal(t, []string{"456"}, role.Paths) + require.Equal(t, []string{"456"}, role.Paths) } func TestAddPathNil(t *testing.T) { role, err := NewRole("targets", 1, []string{"abc"}, nil) - assert.NoError(t, err) + require.NoError(t, err) err = role.AddPaths(nil) - assert.NoError(t, err) + require.NoError(t, err) } func TestErrNoSuchRole(t *testing.T) { var err error = ErrNoSuchRole{Role: "test"} - assert.True(t, strings.HasSuffix(err.Error(), "test")) + require.True(t, strings.HasSuffix(err.Error(), "test")) } func TestErrInvalidRole(t *testing.T) { var err error = ErrInvalidRole{Role: "test"} - assert.False(t, strings.Contains(err.Error(), "Reason")) + require.False(t, strings.Contains(err.Error(), "Reason")) } func TestIsDelegation(t *testing.T) { - assert.True(t, IsDelegation(path.Join(CanonicalTargetsRole, "level1"))) - assert.True(t, IsDelegation( + require.True(t, IsDelegation(path.Join(CanonicalTargetsRole, "level1"))) + require.True(t, IsDelegation( path.Join(CanonicalTargetsRole, "level1", "level2", "level3"))) - assert.True(t, IsDelegation(path.Join(CanonicalTargetsRole, "under_score"))) - assert.True(t, IsDelegation(path.Join(CanonicalTargetsRole, "hyphen-hyphen"))) - assert.False(t, IsDelegation( + require.True(t, IsDelegation(path.Join(CanonicalTargetsRole, "under_score"))) + require.True(t, IsDelegation(path.Join(CanonicalTargetsRole, "hyphen-hyphen"))) + require.False(t, IsDelegation( path.Join(CanonicalTargetsRole, strings.Repeat("x", 255-len(CanonicalTargetsRole))))) - assert.False(t, IsDelegation("")) - assert.False(t, IsDelegation(CanonicalRootRole)) - assert.False(t, IsDelegation(path.Join(CanonicalRootRole, "level1"))) + require.False(t, IsDelegation("")) + require.False(t, IsDelegation(CanonicalRootRole)) + require.False(t, IsDelegation(path.Join(CanonicalRootRole, "level1"))) - assert.False(t, IsDelegation(CanonicalTargetsRole)) - assert.False(t, IsDelegation(CanonicalTargetsRole+"/")) - assert.False(t, IsDelegation(path.Join(CanonicalTargetsRole, "level1")+"/")) - assert.False(t, IsDelegation(path.Join(CanonicalTargetsRole, "UpperCase"))) + require.False(t, IsDelegation(CanonicalTargetsRole)) + require.False(t, IsDelegation(CanonicalTargetsRole+"/")) + require.False(t, IsDelegation(path.Join(CanonicalTargetsRole, "level1")+"/")) + require.False(t, IsDelegation(path.Join(CanonicalTargetsRole, "UpperCase"))) - assert.False(t, IsDelegation( + require.False(t, IsDelegation( path.Join(CanonicalTargetsRole, "directory")+"/../../traversal")) - assert.False(t, IsDelegation(CanonicalTargetsRole+"///test/middle/slashes")) + require.False(t, IsDelegation(CanonicalTargetsRole+"///test/middle/slashes")) - assert.False(t, IsDelegation(CanonicalTargetsRole+"/./././")) + require.False(t, IsDelegation(CanonicalTargetsRole+"/./././")) - assert.False(t, IsDelegation( + require.False(t, IsDelegation( path.Join(" ", CanonicalTargetsRole, "level1"))) - assert.False(t, IsDelegation( + require.False(t, IsDelegation( path.Join(" "+CanonicalTargetsRole, "level1"))) - assert.False(t, IsDelegation( + require.False(t, IsDelegation( path.Join(CanonicalTargetsRole, "level1"+" "))) - assert.False(t, IsDelegation( + require.False(t, IsDelegation( path.Join(CanonicalTargetsRole, "white space"+"level2"))) - assert.False(t, IsDelegation( + require.False(t, IsDelegation( path.Join(CanonicalTargetsRole, strings.Repeat("x", 256-len(CanonicalTargetsRole))))) } func TestValidRoleFunction(t *testing.T) { - assert.True(t, ValidRole(CanonicalRootRole)) - assert.True(t, ValidRole(CanonicalTimestampRole)) - assert.True(t, ValidRole(CanonicalSnapshotRole)) - assert.True(t, ValidRole(CanonicalTargetsRole)) - assert.True(t, ValidRole(path.Join(CanonicalTargetsRole, "level1"))) - assert.True(t, ValidRole( + require.True(t, ValidRole(CanonicalRootRole)) + require.True(t, ValidRole(CanonicalTimestampRole)) + require.True(t, ValidRole(CanonicalSnapshotRole)) + require.True(t, ValidRole(CanonicalTargetsRole)) + require.True(t, ValidRole(path.Join(CanonicalTargetsRole, "level1"))) + require.True(t, ValidRole( path.Join(CanonicalTargetsRole, "level1", "level2", "level3"))) - assert.False(t, ValidRole("")) - assert.False(t, ValidRole(CanonicalRootRole+"/")) - assert.False(t, ValidRole(CanonicalTimestampRole+"/")) - assert.False(t, ValidRole(CanonicalSnapshotRole+"/")) - assert.False(t, ValidRole(CanonicalTargetsRole+"/")) + require.False(t, ValidRole("")) + require.False(t, ValidRole(CanonicalRootRole+"/")) + require.False(t, ValidRole(CanonicalTimestampRole+"/")) + require.False(t, ValidRole(CanonicalSnapshotRole+"/")) + require.False(t, ValidRole(CanonicalTargetsRole+"/")) - assert.False(t, ValidRole(path.Join(CanonicalRootRole, "level1"))) + require.False(t, ValidRole(path.Join(CanonicalRootRole, "level1"))) - assert.False(t, ValidRole(path.Join("role"))) + require.False(t, ValidRole(path.Join("role"))) } diff --git a/tuf/data/types_test.go b/tuf/data/types_test.go index 696c163a89..c81a9c5a99 100644 --- a/tuf/data/types_test.go +++ b/tuf/data/types_test.go @@ -6,31 +6,31 @@ import ( "testing" "github.com/docker/go/canonical/json" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestGenerateFileMetaDefault(t *testing.T) { // default is sha512 r := bytes.NewReader([]byte("foo")) meta, err := NewFileMeta(r, "sha512") - assert.NoError(t, err, "Unexpected error.") - assert.Equal(t, meta.Length, int64(3), "Meta did not have expected Length field value") + require.NoError(t, err, "Unexpected error.") + require.Equal(t, meta.Length, int64(3), "Meta did not have expected Length field value") hashes := meta.Hashes - assert.Len(t, hashes, 1, "Only expected one hash to be present") + require.Len(t, hashes, 1, "Only expected one hash to be present") hash, ok := hashes["sha512"] if !ok { t.Fatal("missing sha512 hash") } - assert.Equal(t, "f7fbba6e0636f890e56fbbf3283e524c6fa3204ae298382d624741d0dc6638326e282c41be5e4254d8820772c5518a2c5a8c0c7f7eda19594a7eb539453e1ed7", hex.EncodeToString(hash), "Hashes not equal") + require.Equal(t, "f7fbba6e0636f890e56fbbf3283e524c6fa3204ae298382d624741d0dc6638326e282c41be5e4254d8820772c5518a2c5a8c0c7f7eda19594a7eb539453e1ed7", hex.EncodeToString(hash), "Hashes not equal") } func TestGenerateFileMetaExplicit(t *testing.T) { r := bytes.NewReader([]byte("foo")) meta, err := NewFileMeta(r, "sha256", "sha512") - assert.NoError(t, err) - assert.Equal(t, meta.Length, int64(3)) + require.NoError(t, err) + require.Equal(t, meta.Length, int64(3)) hashes := meta.Hashes - assert.Len(t, hashes, 2) + require.Len(t, hashes, 2) for name, val := range map[string]string{ "sha256": "2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae", "sha512": "f7fbba6e0636f890e56fbbf3283e524c6fa3204ae298382d624741d0dc6638326e282c41be5e4254d8820772c5518a2c5a8c0c7f7eda19594a7eb539453e1ed7", @@ -39,7 +39,7 @@ func TestGenerateFileMetaExplicit(t *testing.T) { if !ok { t.Fatalf("missing %s hash", name) } - assert.Equal(t, hex.EncodeToString(hash), val) + require.Equal(t, hex.EncodeToString(hash), val) } } @@ -48,10 +48,10 @@ func TestSignatureUnmarshalJSON(t *testing.T) { var sig Signature err := json.Unmarshal([]byte(signatureJSON), &sig) - assert.NoError(t, err) + require.NoError(t, err) // Check that the method string is lowercased - assert.Equal(t, sig.Method.String(), "rsa") + require.Equal(t, sig.Method.String(), "rsa") } func TestCheckHashes(t *testing.T) { @@ -63,65 +63,65 @@ func TestCheckHashes(t *testing.T) { unSupported := make(Hashes) unSupported["Arthas"] = []byte("is past away.") err = CheckHashes(raw, unSupported) - assert.Error(t, err) - assert.Contains(t, err.Error(), "at least one supported hash needed") + require.Error(t, err) + require.Contains(t, err.Error(), "at least one supported hash needed") // Expected to fail since there is no checksum at all. hashes := make(Hashes) err = CheckHashes(raw, hashes) - assert.Error(t, err) - assert.Contains(t, err.Error(), "at least one supported hash needed") + require.Error(t, err) + require.Contains(t, err.Error(), "at least one supported hash needed") // The most standard one. hashes["sha256"], err = hex.DecodeString("d13e2b60d74c2e6f4f449b5e536814edf9a4827f5a9f4f957fc92e77609b9c92") - assert.NoError(t, err) + require.NoError(t, err) hashes["sha512"], err = hex.DecodeString("f2330f50d0f3ee56cf0d7f66aad8205e0cb9972c323208ffaa914ef7b3c240ae4774b5bbd1db2ce226ee967cfa9058173a853944f9b44e2e08abca385e2b7ed4") - assert.NoError(t, err) + require.NoError(t, err) err = CheckHashes(raw, hashes) - assert.NoError(t, err) + require.NoError(t, err) // Expected as success since there are already supported hash here, // just ignore the unsupported one. hashes["Saar"] = []byte("survives again in CTM.") err = CheckHashes(raw, hashes) - assert.NoError(t, err) + require.NoError(t, err) only256 := make(Hashes) only256["sha256"], err = hex.DecodeString("d13e2b60d74c2e6f4f449b5e536814edf9a4827f5a9f4f957fc92e77609b9c92") - assert.NoError(t, err) + require.NoError(t, err) err = CheckHashes(raw, only256) - assert.NoError(t, err) + require.NoError(t, err) only512 := make(Hashes) only512["sha512"], err = hex.DecodeString("f2330f50d0f3ee56cf0d7f66aad8205e0cb9972c323208ffaa914ef7b3c240ae4774b5bbd1db2ce226ee967cfa9058173a853944f9b44e2e08abca385e2b7ed4") - assert.NoError(t, err) + require.NoError(t, err) err = CheckHashes(raw, only512) - assert.NoError(t, err) + require.NoError(t, err) // Expected to fail due to the failure of sha256 malicious256 := make(Hashes) malicious256["sha256"] = []byte("malicious data") err = CheckHashes(raw, malicious256) - assert.Error(t, err) - assert.Contains(t, err.Error(), "checksum mismatched") + require.Error(t, err) + require.Contains(t, err.Error(), "checksum mismatched") // Expected to fail due to the failure of sha512 malicious512 := make(Hashes) malicious512["sha512"] = []byte("malicious data") err = CheckHashes(raw, malicious512) - assert.Error(t, err) - assert.Contains(t, err.Error(), "checksum mismatched") + require.Error(t, err) + require.Contains(t, err.Error(), "checksum mismatched") // Expected to fail because of the failure of sha512 // even though the sha256 is OK. doubleFace := make(Hashes) doubleFace["sha256"], err = hex.DecodeString("d13e2b60d74c2e6f4f449b5e536814edf9a4827f5a9f4f957fc92e77609b9c92") - assert.NoError(t, err) + require.NoError(t, err) doubleFace["sha512"], err = hex.DecodeString("d13e2b60d74c2e6f4f449b5e536814edf9a4827f5a9f4f957fc92e77609b9c92") - assert.NoError(t, err) + require.NoError(t, err) err = CheckHashes(raw, doubleFace) - assert.Error(t, err) - assert.Contains(t, err.Error(), "checksum mismatched") + require.Error(t, err) + require.Contains(t, err.Error(), "checksum mismatched") } func TestCheckValidHashStructures(t *testing.T) { @@ -130,34 +130,34 @@ func TestCheckValidHashStructures(t *testing.T) { // Expected to fail since there is no checksum at all. err = CheckValidHashStructures(hashes) - assert.Error(t, err) - assert.Contains(t, err.Error(), "at least one supported hash needed") + require.Error(t, err) + require.Contains(t, err.Error(), "at least one supported hash needed") // Expected to fail even though the checksum of sha384 is valid, // because we haven't provided a supported hash algorithm yet (ex: sha256). hashes["sha384"], err = hex.DecodeString("64becc3c23843942b1040ffd4743d1368d988ddf046d17d448a6e199c02c3044b425a680112b399d4dbe9b35b7ccc989") err = CheckValidHashStructures(hashes) - assert.Error(t, err) - assert.Contains(t, err.Error(), "at least one supported hash needed") + require.Error(t, err) + require.Contains(t, err.Error(), "at least one supported hash needed") hashes["sha256"], err = hex.DecodeString("766af0ef090a4f2307e49160fa242db6fb95f071ad81a198eeb7d770e61cd6d8") - assert.NoError(t, err) + require.NoError(t, err) err = CheckValidHashStructures(hashes) - assert.NoError(t, err) + require.NoError(t, err) hashes["sha512"], err = hex.DecodeString("795d9e95db099464b6730844f28effddb010b0d5abae5d5892a6ee04deacb09c9e622f89e816458b5a1a81761278d7d3a6a7c269d9707eff8858b16c51de0315") - assert.NoError(t, err) + require.NoError(t, err) err = CheckValidHashStructures(hashes) - assert.NoError(t, err) + require.NoError(t, err) // Also should be succeed since only check the length of the checksum. hashes["sha256"], err = hex.DecodeString("01234567890a4f2307e49160fa242db6fb95f071ad81a198eeb7d770e61cd6d8") err = CheckValidHashStructures(hashes) - assert.NoError(t, err) + require.NoError(t, err) // Should failed since the first '0' is missing. hashes["sha256"], err = hex.DecodeString("1234567890a4f2307e49160fa242db6fb95f071ad81a198eeb7d770e61cd6d8") err = CheckValidHashStructures(hashes) - assert.Error(t, err) - assert.Contains(t, err.Error(), "invalid") + require.Error(t, err) + require.Contains(t, err.Error(), "invalid") } diff --git a/tuf/db/files.db b/tuf/db/files.db deleted file mode 100644 index e30c3ee59ff96e86b4bc7d61c2f06f90d24f0bd1..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 28672 zcmeI4OKW7u6@a^?R?Cvr(*w35CPtYaZDusco_ar=EaI3Ugc$PjUex2%sF~Iy-B-fn zVK9<6*#)u-H8OYZ4R=eH$=3vljy?(RRYR%&B`DYprI?qq=zx~4T8Hd=$ zn}2Tg`k%JCJ=5wh^nZP=bM0x*^nQQF1(Zz$hyW2F0z`la5CI}U1c(3;xMBqMS7v6H z78lzGx0?`0@DLtN>aY9m5AVP8{{6xG?|kdM`-7S@xHCV@gW*;)2)oVp`fw|aVH38R zwfU{E36q_WV6Yd)X(Np92(4EKTieZGYj-qSn;&nF&Md>G2Mv6HRgbFgjE9?H{HRJD z+!^N8`PJLq?$Xy6+pXbNh7Tq`9^pD~y=rlIzFxIk=QW+(|Nivs(yd$VgNKK`DZ>$L zgvka>j*mJgdUl+D=fC%3Co~&p^)ZYd92If)V(+U0$3?=uSazbTM;zA%Rnpo3+gx3h zo$k`NZ=KcmWBu3p@$t<5H`=pH%ggP9?;dg3geKG)^?&Mf3~KHr2~36`!l8d0TQcoV zn(fVJ_RUbj?&!HooY(Qy)q7LjrFWOl>vPrjS&!?{;d;JTN7nULtN)MwAFtRTBXx)X z5g-CYfCvx)B0vO)01+SpM1Tko0VFV(nvu(M3wb*|gz;O$?RyPOn(u6e2XHTj@mmc( zADaGLjb3}EhZo%|+uOCqd?i`e|DW_fA*e)v2oM1xKm>>Y5g-CYfCvx)B0vO)z?CF0 z=*Z>vc@F?iDPQQ|1Ayo2|D*l?zx038|5g7NSF)F+6cHc-M1Tko0U|&IhyW2F0z`la z5P>U3;BE(Z+;1$Nvm~Ev1fdP%Ox&%z^XJrE>fl!Wjm5*w{JY&V>wdPAkL~KEsb^Ol zXMHAWsqXq?Q^y6G3nrO5+W&vr{~LavUNM}c4iO*%M1Tko0U|&IhyW2F0z`la5P>fT zf!lT6e%==Sv*!Wz#d_a6z25Pf9T)RwH+Q1i>vg%`eqp(fmrlJ_Gmm!u>+=FGj`sh5 z(!YM~XV<>c`}x8z7ryrDPv`&r<-ki?5& zH;-5Fg+a}u9awpL1v0*{i2Iebnzt85D{ntu+1ZVwVZy?ktkGbd3*7l4l1s)b$7J-S z$Se$FCi~)yv8=?xWeS05sf`NKILQsRiZ8p_3r&?2yl};G#Q|aoF$)#5)8Gq8A4Lc@ z@EpC7Uf7tkvC4-Sg2qzia?a_}$~<{;aN`w(^Tw%gnlOF<&E)0Tcq4?7(R!Ca$HGG9 zf$`!?vRpF&rgDrcohY|cJt$paC&cs_{yjzZ0@|YsKAXx_$9lP!J-)9g7?}1 z6z+{T))ZDG1I=u3*<>a|X2>~Y;SBTggc(3d+_vz=2jjhWfS45;!~i!;uwqjb!aKaF z0G*@L&IdrFg{YJYP^`SPGH8bRS)_qJiZm|llPNJ1g5q3&LmgvDCdg!pDLR95=sgL% zC<^-$qR0p;Mz3V?5T%Mjoq!=YAU_5wv1F1E%%KyzkfK3v^fq#jJ}nZr+8{C&l@nT_ z2=0<9jKxbUgD~d02m^hxy2b^4kmGn_R+a=TS}<9Gf)spA5-dwh$fN<#+$9Hw4k3ar z!C>dI1?;kb6D%|$Fm~ch3 zbBsH~F*f=sy-LBF^)f7eB=rTwdYD{EfjFebc(@Zuqi$pZ6QSP zJ}ERcpiKakmnz^lR(0lZyvfB=)wu}fm5lMm#+bAym5jyH>@oTo52&TZiNxkqN)Z|( z42EuhR0Vf~>kKIXXDuyK*6&oiwAuKC_N5T z!J?7^XUmkdW3gn6QaO9U3`3^_YgOUEg45a7s2DTWM)$04_+bZyBkGHDO_~|)!8l!{ z!s*2rU>autSwgB40@_m+p0##3rw3y=8Xi4Va3^ps$|(EMG|EP-7iEZ{CxH+pD5+&Y z;aq1Y4bDv-x4N^oDyxvJ#woxQmzCElXltUyX)WPoP(@F5_oh%fI{bya8#|>SdmPhB z;%$*gnkx~D#ak5Vf&qi~I4(l8IN(iiCNP%^Fj=a%bL&v_Ui*KLtMP70NsKcp1&E9R z-dSM6a6HG5W%iJDLi^%yVg-Y;M31o6dvr7ObgfYC(fg}Kxewuo~y|#HJPnRwC|Mp LCR5YXt-1dIv6Gb~ diff --git a/tuf/signed/ed25519_test.go b/tuf/signed/ed25519_test.go index 18e0ccff2b..f6afecaf6b 100644 --- a/tuf/signed/ed25519_test.go +++ b/tuf/signed/ed25519_test.go @@ -4,21 +4,21 @@ import ( "testing" "github.com/docker/notary/tuf/data" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) // ListKeys only returns the keys for that role func TestListKeys(t *testing.T) { c := NewEd25519() tskey, err := c.Create(data.CanonicalTimestampRole, data.ED25519Key) - assert.NoError(t, err) + require.NoError(t, err) _, err = c.Create(data.CanonicalRootRole, data.ED25519Key) - assert.NoError(t, err) + require.NoError(t, err) tsKeys := c.ListKeys(data.CanonicalTimestampRole) - assert.Len(t, tsKeys, 1) - assert.Equal(t, tskey.ID(), tsKeys[0]) + require.Len(t, tsKeys, 1) + require.Equal(t, tskey.ID(), tsKeys[0]) - assert.Len(t, c.ListKeys(data.CanonicalTargetsRole), 0) + require.Len(t, c.ListKeys(data.CanonicalTargetsRole), 0) } diff --git a/tuf/signed/sign_test.go b/tuf/signed/sign_test.go index 50c241b7b7..7d65f1c6eb 100644 --- a/tuf/signed/sign_test.go +++ b/tuf/signed/sign_test.go @@ -9,7 +9,7 @@ import ( "github.com/docker/notary/cryptoservice" "github.com/docker/notary/trustmanager" "github.com/docker/notary/tuf/data" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) const ( @@ -157,11 +157,11 @@ func (mts *StrictMockCryptoService) ImportRootKey(r io.Reader) error { func TestBasicSign(t *testing.T) { cs := NewEd25519() key, err := cs.Create("root", data.ED25519Key) - assert.NoError(t, err) + require.NoError(t, err) testData := data.Signed{} err = Sign(cs, &testData, key) - assert.NoError(t, err) + require.NoError(t, err) if len(testData.Signatures) != 1 { t.Fatalf("Incorrect number of signatures: %d", len(testData.Signatures)) @@ -177,7 +177,7 @@ func TestBasicSign(t *testing.T) { func TestReSign(t *testing.T) { cs := NewEd25519() key, err := cs.Create("root", data.ED25519Key) - assert.NoError(t, err) + require.NoError(t, err) testData := data.Signed{} Sign(cs, &testData, key) @@ -199,7 +199,7 @@ func TestMultiSign(t *testing.T) { testData := data.Signed{} key1, err := cs.Create("root", data.ED25519Key) - assert.NoError(t, err) + require.NoError(t, err) Sign(cs, &testData, key1) // reinitializing cs means it won't know about key1. We want @@ -208,7 +208,7 @@ func TestMultiSign(t *testing.T) { // for key2 is added cs = NewEd25519() key2, err := cs.Create("root", data.ED25519Key) - assert.NoError(t, err) + require.NoError(t, err) Sign( cs, &testData, @@ -228,7 +228,7 @@ func TestMultiSign(t *testing.T) { t.Fatalf("Got a signature we didn't expect: %s", sig.KeyID) } } - assert.Equal(t, 2, count) + require.Equal(t, 2, count) } @@ -251,22 +251,22 @@ func TestSignReturnsNoSigs(t *testing.T) { func TestSignWithX509(t *testing.T) { // generate a key becase we need a cert privKey, err := trustmanager.GenerateRSAKey(rand.Reader, 1024) - assert.NoError(t, err) + require.NoError(t, err) // make a RSA x509 key cert, err := cryptoservice.GenerateTestingCertificate(privKey.CryptoSigner(), "test") - assert.NoError(t, err) + require.NoError(t, err) tufRSAx509Key := trustmanager.CertToKey(cert) - assert.NoError(t, err) + require.NoError(t, err) // test signing against a service that only recognizes a RSAKey (not // RSAx509 key) mockCryptoService := &StrictMockCryptoService{MockCryptoService{privKey}} testData := data.Signed{} err = Sign(mockCryptoService, &testData, tufRSAx509Key) - assert.NoError(t, err) + require.NoError(t, err) - assert.Len(t, testData.Signatures, 1) - assert.Equal(t, tufRSAx509Key.ID(), testData.Signatures[0].KeyID) + require.Len(t, testData.Signatures, 1) + require.Equal(t, tufRSAx509Key.ID(), testData.Signatures[0].KeyID) } diff --git a/tuf/signed/verify_test.go b/tuf/signed/verify_test.go index 94029b4496..b2e86af869 100644 --- a/tuf/signed/verify_test.go +++ b/tuf/signed/verify_test.go @@ -6,7 +6,7 @@ import ( "time" "github.com/docker/go/canonical/json" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "github.com/docker/notary/tuf/data" ) @@ -14,90 +14,90 @@ import ( func TestRoleNoKeys(t *testing.T) { cs := NewEd25519() k, err := cs.Create("root", data.ED25519Key) - assert.NoError(t, err) - assert.NoError(t, err) + require.NoError(t, err) + require.NoError(t, err) roleWithKeys := data.BaseRole{Name: "root", Keys: data.Keys{}, Threshold: 1} meta := &data.SignedCommon{Type: "Root", Version: 1, Expires: data.DefaultExpires("root")} b, err := json.MarshalCanonical(meta) - assert.NoError(t, err) + require.NoError(t, err) s := &data.Signed{Signed: b} Sign(cs, s, k) err = Verify(s, roleWithKeys, 1) - assert.IsType(t, ErrRoleThreshold{}, err) + require.IsType(t, ErrRoleThreshold{}, err) } func TestNotEnoughSigs(t *testing.T) { cs := NewEd25519() k, err := cs.Create("root", data.ED25519Key) - assert.NoError(t, err) - assert.NoError(t, err) + require.NoError(t, err) + require.NoError(t, err) roleWithKeys := data.BaseRole{Name: "root", Keys: data.Keys{k.ID(): k}, Threshold: 2} meta := &data.SignedCommon{Type: "Root", Version: 1, Expires: data.DefaultExpires("root")} b, err := json.MarshalCanonical(meta) - assert.NoError(t, err) + require.NoError(t, err) s := &data.Signed{Signed: b} Sign(cs, s, k) err = Verify(s, roleWithKeys, 1) - assert.IsType(t, ErrRoleThreshold{}, err) + require.IsType(t, ErrRoleThreshold{}, err) } func TestMoreThanEnoughSigs(t *testing.T) { cs := NewEd25519() k1, err := cs.Create("root", data.ED25519Key) - assert.NoError(t, err) + require.NoError(t, err) k2, err := cs.Create("root", data.ED25519Key) - assert.NoError(t, err) + require.NoError(t, err) roleWithKeys := data.BaseRole{Name: "root", Keys: data.Keys{k1.ID(): k1, k2.ID(): k2}, Threshold: 1} meta := &data.SignedCommon{Type: "Root", Version: 1, Expires: data.DefaultExpires("root")} b, err := json.MarshalCanonical(meta) - assert.NoError(t, err) + require.NoError(t, err) s := &data.Signed{Signed: b} Sign(cs, s, k1, k2) - assert.Equal(t, 2, len(s.Signatures)) + require.Equal(t, 2, len(s.Signatures)) err = Verify(s, roleWithKeys, 1) - assert.NoError(t, err) + require.NoError(t, err) } func TestDuplicateSigs(t *testing.T) { cs := NewEd25519() k, err := cs.Create("root", data.ED25519Key) - assert.NoError(t, err) + require.NoError(t, err) roleWithKeys := data.BaseRole{Name: "root", Keys: data.Keys{k.ID(): k}, Threshold: 2} meta := &data.SignedCommon{Type: "Root", Version: 1, Expires: data.DefaultExpires("root")} b, err := json.MarshalCanonical(meta) - assert.NoError(t, err) + require.NoError(t, err) s := &data.Signed{Signed: b} Sign(cs, s, k) s.Signatures = append(s.Signatures, s.Signatures[0]) err = Verify(s, roleWithKeys, 1) - assert.IsType(t, ErrRoleThreshold{}, err) + require.IsType(t, ErrRoleThreshold{}, err) } func TestUnknownKeyBelowThreshold(t *testing.T) { cs := NewEd25519() k, err := cs.Create("root", data.ED25519Key) - assert.NoError(t, err) + require.NoError(t, err) unknown, err := cs.Create("root", data.ED25519Key) - assert.NoError(t, err) + require.NoError(t, err) roleWithKeys := data.BaseRole{Name: "root", Keys: data.Keys{k.ID(): k}, Threshold: 2} meta := &data.SignedCommon{Type: "Root", Version: 1, Expires: data.DefaultExpires("root")} b, err := json.MarshalCanonical(meta) - assert.NoError(t, err) + require.NoError(t, err) s := &data.Signed{Signed: b} Sign(cs, s, k, unknown) s.Signatures = append(s.Signatures) err = Verify(s, roleWithKeys, 1) - assert.IsType(t, ErrRoleThreshold{}, err) + require.IsType(t, ErrRoleThreshold{}, err) } func Test(t *testing.T) { @@ -167,7 +167,7 @@ func Test(t *testing.T) { meta := &data.SignedCommon{Type: run.typ, Version: run.ver, Expires: *run.exp} b, err := json.MarshalCanonical(meta) - assert.NoError(t, err) + require.NoError(t, err) s := &data.Signed{Signed: b} Sign(cryptoService, s, k) run.s = s @@ -178,17 +178,17 @@ func Test(t *testing.T) { err := Verify(run.s, run.roleData, minVer) if e, ok := run.err.(ErrExpired); ok { - assertErrExpired(t, err, e) + requireErrExpired(t, err, e) } else { - assert.Equal(t, run.err, err) + require.Equal(t, run.err, err) } } } -func assertErrExpired(t *testing.T, err error, expected ErrExpired) { +func requireErrExpired(t *testing.T, err error, expected ErrExpired) { actual, ok := err.(ErrExpired) if !ok { t.Fatalf("expected err to have type ErrExpired, got %T", err) } - assert.Equal(t, actual.Expired, expected.Expired) + require.Equal(t, actual.Expired, expected.Expired) } diff --git a/tuf/validation/errors_test.go b/tuf/validation/errors_test.go index 092b67c440..fc2712761c 100644 --- a/tuf/validation/errors_test.go +++ b/tuf/validation/errors_test.go @@ -5,22 +5,22 @@ import ( "fmt" "testing" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) // NewSerializableError errors if some random error is not returned func TestNewSerializableErrorNonValidationError(t *testing.T) { _, err := NewSerializableError(fmt.Errorf("not validation error")) - assert.Error(t, err) + require.Error(t, err) } // NewSerializableError succeeds if a validation error is passed to it func TestNewSerializableErrorValidationError(t *testing.T) { vError := ErrValidation{"validation error"} s, err := NewSerializableError(vError) - assert.NoError(t, err) - assert.Equal(t, "ErrValidation", s.Name) - assert.Equal(t, vError, s.Error) + require.NoError(t, err) + require.Equal(t, "ErrValidation", s.Name) + require.Equal(t, vError, s.Error) } // We can unmarshal a marshalled SerializableError for all validation errors @@ -35,15 +35,15 @@ func TestUnmarshalSerialiableErrorSuccessfully(t *testing.T) { for _, validError := range validationErrors { origS, err := NewSerializableError(validError) - assert.NoError(t, err) + require.NoError(t, err) jsonBytes, err := json.Marshal(origS) - assert.NoError(t, err) + require.NoError(t, err) var newS SerializableError err = json.Unmarshal(jsonBytes, &newS) - assert.NoError(t, err) + require.NoError(t, err) - assert.Equal(t, validError, newS.Error) + require.Equal(t, validError, newS.Error) } } @@ -51,11 +51,11 @@ func TestUnmarshalSerialiableErrorSuccessfully(t *testing.T) { func TestUnmarshalUnknownErrorName(t *testing.T) { origS := SerializableError{Name: "boop", Error: ErrBadRoot{"bad"}} b, err := json.Marshal(origS) - assert.NoError(t, err) + require.NoError(t, err) var newS SerializableError err = json.Unmarshal(b, &newS) - assert.Error(t, err) + require.Error(t, err) } // If the error is unmarshallable, unmarshalling will error even if the name @@ -63,22 +63,22 @@ func TestUnmarshalUnknownErrorName(t *testing.T) { func TestUnmarshalInvalidError(t *testing.T) { var newS SerializableError err := json.Unmarshal([]byte(`{"Name": "ErrBadRoot", "Error": "meh"}`), &newS) - assert.Error(t, err) + require.Error(t, err) } // If there is no name, unmarshalling will error even if the error is valid func TestUnmarshalNoName(t *testing.T) { origS := SerializableError{Error: ErrBadRoot{"bad"}} b, err := json.Marshal(origS) - assert.NoError(t, err) + require.NoError(t, err) var newS SerializableError err = json.Unmarshal(b, &newS) - assert.Error(t, err) + require.Error(t, err) } func TestUnmarshalInvalidJSON(t *testing.T) { var newS SerializableError err := json.Unmarshal([]byte("{"), &newS) - assert.Error(t, err) + require.Error(t, err) }