public void GivenTwoManifestWithDifferentAttributes_ExceptionExpected()
        {
            Manifest differentAttributes = SharedMethods.GetCopyOfManifest(baseManifest);

            differentAttributes.AzureDevOpsAccount = "newAccount";
            Action act = () => pushMetadata.ParseBuildManifestsMetadata(new List <Manifest> {
                baseManifest, differentAttributes
            }, CancellationToken.None);

            act.Should().Throw <Exception>().WithMessage("Attributes should be the same in all manifests.");
        }
        public void GivenUnversionedBlob()
        {
            Manifest manifestWithUnversionedBlob = SharedMethods.GetCopyOfManifest(baseManifest);

            manifestWithUnversionedBlob.Blobs = new List <Blob> {
                unversionedBlob
            };
            Action act = () => pushMetadata.ParseBuildManifestsMetadata(new List <Manifest> {
                manifestWithUnversionedBlob
            }, CancellationToken.None);

            act.Should().Throw <InvalidOperationException>();
        }
        public void GivenManifestWithoutBlobs()
        {
            Manifest manifestWithoutBlobs = SharedMethods.GetCopyOfManifest(baseManifest);

            manifestWithoutBlobs.Packages = new List <Package> {
                package1
            };
            var(actualBuildData, actualSigningInformation, actualManifestBuildData) = pushMetadata.ParseBuildManifestsMetadata(new List <Manifest> {
                manifestWithoutBlobs
            }, CancellationToken.None);
            actualBuildData.Should().BeEquivalentTo(noBlobManifestBuildData);
            actualManifestBuildData.Should().BeEquivalentTo(baseManifestBuildData);
        }
        public void GivenManifestWithUnversionedPackage()
        {
            Manifest manifestWithUnversionedPackage = SharedMethods.GetCopyOfManifest(baseManifest);

            manifestWithUnversionedPackage.Packages = new List <Package> {
                unversionedPackage
            };
            var expectedPackages = new List <PackageArtifactModel>()
            {
                unversionedPackageArtifactModel
            };

            var(actualPackages, actualBlobs) = pushMetadata.GetPackagesAndBlobsInfo(manifestWithUnversionedPackage);
            actualPackages.Should().BeEquivalentTo(expectedPackages);
        }
        public void GivenUnversionedBlob()
        {
            Manifest manifestWithUnversionedBlob = SharedMethods.GetCopyOfManifest(baseManifest);

            manifestWithUnversionedBlob.Blobs = new List <Blob> {
                unversionedBlob
            };

            var expectedBlobs = new List <BlobArtifactModel>()
            {
                unversionedBlobArtifactModel
            };

            var(actualPackages, actualBlobs) = pushMetadata.GetPackagesAndBlobsInfo(manifestWithUnversionedBlob);
            actualBlobs.Should().BeEquivalentTo(expectedBlobs);
            actualPackages.Should().BeEmpty();
        }
        public void GivenManifestWithoutBlobs()
        {
            Manifest manifestWithoutBlobs = SharedMethods.GetCopyOfManifest(baseManifest);

            manifestWithoutBlobs.Packages = new List <Package> {
                package1
            };

            var expectedPackages = new List <PackageArtifactModel>()
            {
                packageArtifactModel1
            };

            var(actualPackages, actualBlobs) = pushMetadata.GetPackagesAndBlobsInfo(manifestWithoutBlobs);
            actualPackages.Should().BeEquivalentTo(expectedPackages);
            actualBlobs.Should().BeEmpty();
        }
        public void GivenManifestWithoutPackages()
        {
            Manifest manifestWithoutPackages = SharedMethods.GetCopyOfManifest(baseManifest);

            manifestWithoutPackages.Blobs = new List <Blob> {
                manifestAsBlob
            };

            var expectedBlobs = new List <BlobArtifactModel>()
            {
                manifestAsBlobArtifactModel
            };

            var(packages, blobs) = pushMetadata.GetPackagesAndBlobsInfo(manifestWithoutPackages);
            packages.Should().BeEmpty();
            blobs.Should().BeEquivalentTo(expectedBlobs);
        }