Exemplo n.º 1
0
 private void UnsetRecommendedVersion(Package package, PublishedPackage publishedPackage)
 {
     package.IsLatestVersion          = false;
     publishedPackage.IsLatestVersion = false;
     _packageRepository.Update(package);
     _publishedPackageRepository.Update(publishedPackage);
 }
Exemplo n.º 2
0
        private static PackagingEntry CreatePackageEntry(PublishedPackage package, PackagingSource source, Uri downloadUri)
        {
            var baseUri = new Uri(string.Format("{0}://{1}:{2}/",
                                                downloadUri.Scheme,
                                                downloadUri.Host,
                                                downloadUri.Port));

            PublishedScreenshot screenshot = package.Screenshots != null?package.Screenshots.FirstOrDefault() : null;

            string iconUrl         = GetAbsoluteUri(package.IconUrl, baseUri);
            string firstScreenshot = screenshot != null?GetAbsoluteUri(screenshot.ScreenshotUri, baseUri) : string.Empty;

            return(new PackagingEntry {
                Title = string.IsNullOrWhiteSpace(package.Title) ? package.Id : package.Title,
                PackageId = package.Id,
                PackageStreamUri = downloadUri.ToString(),
                ProjectUrl = package.ProjectUrl,
                GalleryDetailsUrl = package.GalleryDetailsUrl,
                Source = source,
                Version = package.Version ?? string.Empty,
                Description = package.Description,
                Authors = package.Authors,
                LastUpdated = package.LastUpdated,
                IconUrl = iconUrl,
                FirstScreenshot = firstScreenshot,
                Rating = package.Rating,
                RatingsCount = package.RatingsCount,
                DownloadCount = package.DownloadCount
            });
        }
Exemplo n.º 3
0
 private void Unpublish(Package package, PublishedPackage publishedPackage)
 {
     package.Published          = Constants.UnpublishedDate;
     publishedPackage.Published = Constants.UnpublishedDate;
     _packageRepository.Update(package);
     _publishedPackageRepository.Update(publishedPackage);
 }
Exemplo n.º 4
0
 private static void VerifyPackageIsInPublishedState(Package package, PublishedPackage publishedPackage)
 {
     if (package.Published == Constants.UnpublishedDate || publishedPackage == null || publishedPackage.Published == Constants.UnpublishedDate)
     {
         throw new InvalidOperationException("Cannot Unpublish a Package that is not currently Published.");
     }
 }
Exemplo n.º 5
0
        public void ShouldThrowWhenNoPackageIsGiven()
        {
            PublishedPackage nullPackage = null;

            TestDelegate methodThatShouldThrow = () => _creator.CreateUri(nullPackage);

            Assert.Throws <ArgumentNullException>(methodThatShouldThrow);
        }
 private static PackagingEntry CreatePackagingEntry(PublishedPackage package)
 {
     return(new PackagingEntry {
         PackageId = package.Id,
         Title = package.Title,
         Version = package.Version,
     });
 }
Exemplo n.º 7
0
 public void SetUp()
 {
     _mockedConfigSettings = new Mock <IConfigSettings>();
     _creator     = new Infrastructure.Impl.PackageReportAbuseUriCreator(_mockedConfigSettings.Object);
     _testPackage = new PublishedPackage {
         Id = "TestId", Version = "TestVersion"
     };
 }
Exemplo n.º 8
0
 public string CreateUri(PublishedPackage package)
 {
     if (package == null)
     {
         throw new ArgumentNullException("package");
     }
     return(_configSettings.ReportAbuseUriTemplate.Replace(PackageUriTemplateToken.PackageId, package.Id)
            .Replace(PackageUriTemplateToken.PackageVersion, package.Version));
 }
Exemplo n.º 9
0
        public void IconUrlShouldBeNullWhenEmptyOrWhitespaceStringGiven(string iconUrl)
        {
            Package packageToMapFrom = new Package {
                IconUrl = iconUrl
            };

            PublishedPackage publishedPackage = Mapper.Map <Package, PublishedPackage>(packageToMapFrom);

            Assert.IsNull(publishedPackage.IconUrl, "IconUrl should have been null.");
        }
Exemplo n.º 10
0
        public void CategoriesShouldBeDirectlyMapped()
        {
            Package packageToMapFrom = new Package {
                Categories = "Foo, Bar"
            };

            PublishedPackage publishedPackage = Mapper.Map <Package, PublishedPackage>(packageToMapFrom);

            Assert.AreEqual(packageToMapFrom.Categories, publishedPackage.Categories, "Categories were not mapped from Package to PublishedPackage correctly.");
        }
Exemplo n.º 11
0
        public void TitleShouldBeNullWhenEmptyOrWhitespaceStringGiven(string title)
        {
            Package packageToMapFrom = new Package {
                Title = title
            };

            PublishedPackage publishedPackage = Mapper.Map <Package, PublishedPackage>(packageToMapFrom);

            Assert.IsNull(publishedPackage.Title, "Title should have been null.");
        }
Exemplo n.º 12
0
        public void AuthorsShouldBeNullWhenEmptyOrWhitespaceStringGiven(string authors)
        {
            Package packageToMapFrom = new Package {
                Authors = authors
            };

            PublishedPackage publishedPackage = Mapper.Map <Package, PublishedPackage>(packageToMapFrom);

            Assert.IsNull(publishedPackage.Authors, "Authors should have been null.");
        }
Exemplo n.º 13
0
        public void RatingsCountShouldBeMappedToVersionRatingsCount()
        {
            Package packageToMapFrom = new Package {
                RatingsCount = 66
            };

            PublishedPackage publishedPackage = Mapper.Map <Package, PublishedPackage>(packageToMapFrom);

            Assert.AreEqual(packageToMapFrom.RatingsCount, publishedPackage.VersionRatingsCount, "VersionRatingCount should come from RatingsCount.");
        }
Exemplo n.º 14
0
        public void TagsShouldBeNullWhenEmptyOrWhitespaceStringGiven(string tags)
        {
            Package packageToMapFrom = new Package {
                Tags = tags
            };

            PublishedPackage publishedPackage = Mapper.Map <Package, PublishedPackage>(packageToMapFrom);

            Assert.IsNull(publishedPackage.Tags, "Tags should have been null.");
        }
Exemplo n.º 15
0
        public void ShouldThrowWhenPublishedPackageWithGivenIdAndVersionDoesNotExist()
        {
            IQueryable <PublishedPackage> publishedPackages = new PublishedPackage[0].AsQueryable();

            _mockedPublishedPackageRepository.SetupGet(ppr => ppr.Collection).Returns(publishedPackages);

            TestDelegate methodThatShouldThrow = () => _packageController.Download("Id", "Version");

            Assert.Throws <PackageFileDoesNotExistException>(methodThatShouldThrow, "Exception should have been thrown.");
        }
Exemplo n.º 16
0
        public void ExternalPackageUrlShouldBeNullWhenEmptyOrWhitespaceStringGiven(string externalPackageUrl)
        {
            Package packageToMapFrom = new Package {
                ExternalPackageUrl = externalPackageUrl
            };

            PublishedPackage publishedPackage = Mapper.Map <Package, PublishedPackage>(packageToMapFrom);

            Assert.IsNull(publishedPackage.ExternalPackageUrl, "ExternalPackageUrl should have been null.");
        }
Exemplo n.º 17
0
        public void PackageHashShouldBeNullWhenEmptyOrWhitespaceStringGiven(string packageHash)
        {
            Package packageToMapFrom = new Package {
                PackageHash = packageHash
            };

            PublishedPackage publishedPackage = Mapper.Map <Package, PublishedPackage>(packageToMapFrom);

            Assert.IsNull(publishedPackage.PackageHash, "PackageHash should have been null.");
        }
Exemplo n.º 18
0
        public void CopyrightShouldBeNullWhenEmptyOrWhitespaceStringGiven(string copyright)
        {
            Package packageToMapFrom = new Package {
                Copyright = copyright
            };

            PublishedPackage publishedPackage = Mapper.Map <Package, PublishedPackage>(packageToMapFrom);

            Assert.IsNull(publishedPackage.Copyright, "Copyright should have been null.");
        }
Exemplo n.º 19
0
        public void SummaryShouldBeNullWhenEmptyOrWhitespaceStringGiven(string summary)
        {
            Package packageToMapFrom = new Package {
                Summary = summary
            };

            PublishedPackage publishedPackage = Mapper.Map <Package, PublishedPackage>(packageToMapFrom);

            Assert.IsNull(publishedPackage.Summary, "Summary should have been null.");
        }
Exemplo n.º 20
0
        public void DescriptionShouldBeNullWhenEmptyOrWhitespaceStringGiven(string description)
        {
            Package packageToMapFrom = new Package {
                Description = description
            };

            PublishedPackage publishedPackage = Mapper.Map <Package, PublishedPackage>(packageToMapFrom);

            Assert.IsNull(publishedPackage.Description, "Description should have been null.");
        }
Exemplo n.º 21
0
        public void CategoriesShouldBeNullWhenEmptyOrWhitespaceStringGiven(string categories)
        {
            Package packageToMapFrom = new Package {
                Categories = categories
            };

            PublishedPackage publishedPackage = Mapper.Map <Package, PublishedPackage>(packageToMapFrom);

            Assert.IsNull(publishedPackage.Categories, "Categories should have been null.");
        }
Exemplo n.º 22
0
        public void RatingAverageShouldBeMappedToVersionRating()
        {
            Package packageToMapFrom = new Package {
                RatingAverage = 4.5
            };

            PublishedPackage publishedPackage = Mapper.Map <Package, PublishedPackage>(packageToMapFrom);

            Assert.AreEqual(packageToMapFrom.RatingAverage, publishedPackage.VersionRating, "VersionRating should come from RatingAverage.");
        }
Exemplo n.º 23
0
        public void DownloadCountOnPublishedPackageShouldBeMappedTo0WhenAggregateForPackageIdDoesNotExist()
        {
            const int expectedDownloadCount = 0;

            MockedPackageDataAggregateRepository.SetupGet(pdar => pdar.Collection).Returns(new PackageDataAggregate[0].AsQueryable());

            PublishedPackage publishedPackage = Mapper.Map <Package, PublishedPackage>(new Package());

            Assert.AreEqual(expectedDownloadCount, publishedPackage.DownloadCount, "DownloadCount should have been mapped to 0.");
        }
Exemplo n.º 24
0
        public void ShouldSaveMappedPublishedPackage()
        {
            var publishedPackageToCreate = new PublishedPackage();

            _mockedMapper.Setup(m => m.Map <Package, PublishedPackage>(_existingPackage)).Returns(publishedPackageToCreate);

            _packagePublisher.PublishPackage("newKey", EXISTING_PACKAGE_ID, EXISTING_PACKAGE_VERSION, LOG_ACTION);

            _mockedPublishedPackageRepository.Verify(ppr => ppr.Create(publishedPackageToCreate), Times.Once(),
                                                     "Mapped PublishedPackage should have been created.");
        }
Exemplo n.º 25
0
        public void PackageRatingsCountShouldNotBeDirectlyMappedToRatingsCountInPublishedPackage()
        {
            Package packageToMapFrom = new Package {
                RatingsCount = 37
            };

            PublishedPackage publishedPackage = Mapper.Map <Package, PublishedPackage>(packageToMapFrom);

            Assert.AreNotEqual(packageToMapFrom.RatingsCount, publishedPackage.RatingsCount,
                               "RatingsCount on PublishedPackage should not come from Package.RatingsCount.");
        }
Exemplo n.º 26
0
        public void ShouldCreateAPackageLogEntryForCreateWhenPackageHasNotBeenPublished()
        {
            var publishedPackageToCreate = new PublishedPackage();

            _mockedMapper.Setup(m => m.Map <Package, PublishedPackage>(_existingPackage)).Returns(publishedPackageToCreate);

            _packagePublisher.PublishPackage("newKey", EXISTING_PACKAGE_ID, EXISTING_PACKAGE_VERSION, LOG_ACTION);

            _mockedPackageLogEntryCreator.Verify(c => c.Create(EXISTING_PACKAGE_ID, EXISTING_PACKAGE_VERSION, PackageLogAction.Create), Times.Once(),
                                                 "PackageLogEntryCreator's Create() should have been called exactly once for a Create action with the expected package ID and version.");
        }
Exemplo n.º 27
0
        public void PackageDownloadCountShouldNotBeDirectlyMappedToDownloadCountInPublishedPackage()
        {
            Package packageToMapFrom = new Package {
                DownloadCount = 45
            };

            PublishedPackage publishedPackage = Mapper.Map <Package, PublishedPackage>(packageToMapFrom);

            Assert.AreNotEqual(packageToMapFrom.DownloadCount, publishedPackage.DownloadCount,
                               "DownloadCount on PublishedPackage should not come from Package.DownloadCount.");
        }
Exemplo n.º 28
0
        protected override PublishedScreenshot GetObjectToCreate()
        {
            PublishedPackage existingPackage = PackageTestHelpers.GetExistingPublishedPackage();

            return(new PublishedScreenshot
            {
                Caption = _caption,
                PublishedPackageId = existingPackage.Id,
                PublishedPackageVersion = existingPackage.Version
            });
        }
Exemplo n.º 29
0
        public string CreateUri(PublishedPackage package)
        {
            if (package == null)
            {
                throw new ArgumentNullException("package");
            }
            string packageTypeSlug = GallerySlugifyPackageType(package.PackageType);

            return(_configSettings.GalleryDetailsUriTemplate.Replace(PackageUriTemplateToken.PackageTypeSlug, packageTypeSlug)
                   .Replace(PackageUriTemplateToken.PackageId, package.Id)
                   .Replace(PackageUriTemplateToken.PackageVersion, package.Version));
        }
Exemplo n.º 30
0
        public void ShouldNotCallLatestVersionUpdaterWhenPackageToPublishIsNotLatestVersion()
        {
            var publishedPackageToCreate = new PublishedPackage {
                IsLatestVersion = false
            };

            _mockedMapper.Setup(m => m.Map <Package, PublishedPackage>(_existingPackage)).Returns(publishedPackageToCreate);

            _packagePublisher.PublishPackage("newKey", EXISTING_PACKAGE_ID, EXISTING_PACKAGE_VERSION, LOG_ACTION);

            _mockedLatestVersionUpdater.Verify(lvu => lvu.SetLatestVersionFlagsOfOtherVersionablesWithSameId(It.IsAny <PublishedPackage>()), Times.Never(),
                                               "LatestVersionUpdater should not have been called.");
        }
Exemplo n.º 31
0
 public void AddToPackages(PublishedPackage publishedPackage)
 {
     base.AddObject("Packages", publishedPackage);
 }
Exemplo n.º 32
0
 public static PublishedPackage CreatePublishedPackage(string ID, string version, long packageSize, decimal price, bool requireLicenseAcceptance, bool isLatestVersion, double versionRating, int versionRatingsCount, int versionDownloadCount, global::System.DateTime created, global::System.DateTime lastUpdated, global::System.DateTime published, double rating, int ratingsCount, int downloadCount)
 {
     PublishedPackage publishedPackage = new PublishedPackage();
     publishedPackage.Id = ID;
     publishedPackage.Version = version;
     publishedPackage.PackageSize = packageSize;
     publishedPackage.Price = price;
     publishedPackage.RequireLicenseAcceptance = requireLicenseAcceptance;
     publishedPackage.IsLatestVersion = isLatestVersion;
     publishedPackage.VersionRating = versionRating;
     publishedPackage.VersionRatingsCount = versionRatingsCount;
     publishedPackage.VersionDownloadCount = versionDownloadCount;
     publishedPackage.Created = created;
     publishedPackage.LastUpdated = lastUpdated;
     publishedPackage.Published = published;
     publishedPackage.Rating = rating;
     publishedPackage.RatingsCount = ratingsCount;
     publishedPackage.DownloadCount = downloadCount;
     return publishedPackage;
 }