public TestableCuratedFeedService()
: base()
{
StubCuratedFeed = new CuratedFeed {
Key = 0, Name = "aName"
};
StubPackageRegistration = new PackageRegistration {
Key = 1066, Id = "aPackageId"
};
StubCuratedPackage = new CuratedPackage
{
Key = 0,
CuratedFeedKey = StubCuratedFeed.Key,
CuratedFeed = StubCuratedFeed,
PackageRegistration = StubPackageRegistration,
PackageRegistrationKey = StubPackageRegistration.Key
};
StubCuratedFeed.Packages.Add(StubCuratedPackage);
StubCuratedFeedRepository = new Mock <IEntityRepository <CuratedFeed> >();
StubCuratedFeedRepository
.Setup(repo => repo.GetAll())
.Returns(new CuratedFeed[] { StubCuratedFeed }.AsQueryable());
StubCuratedPackageRepository = new Mock <IEntityRepository <CuratedPackage> >();
StubCuratedPackageRepository
.Setup(repo => repo.GetAll())
.Returns(new CuratedPackage[] { StubCuratedPackage }.AsQueryable());
}
public async Task WillNotIncludeThePackageWhenItDependsOnAPackageThatIsNotIncluded()
{
var stubFeed = new CuratedFeed();
var stubNuGetPackage = CreateStubNuGetPackageReader();
var stubGalleryPackage = CreateStubGalleryPackage();
stubGalleryPackage.Dependencies.Add(
new PackageDependency {
Id = "NotACuratedPackage"
});
var curator = TestableWebMatrixPackageCurator.Create(stubCuratedFeedService =>
{
stubCuratedFeedService.Setup(stub => stub.GetFeedByName(It.IsAny <string>(), It.IsAny <bool>())).Returns(stubFeed);
});
await curator.CurateAsync(stubGalleryPackage, stubNuGetPackage.Object, commitChanges : true);
curator.StubCuratedFeedService.Verify(
stub => stub.CreatedCuratedPackageAsync(
It.IsAny <CuratedFeed>(),
It.IsAny <PackageRegistration>(),
It.IsAny <bool>(),
It.IsAny <bool>(),
It.IsAny <string>(),
It.IsAny <bool>()),
Times.Never());
}
protected override ODataV2CuratedFeedController CreateController(
IEntityRepository <Package> packagesRepository,
IGalleryConfigurationService configurationService,
ISearchService searchService)
{
var curatedFeed = new CuratedFeed {
Name = _curatedFeedName
};
var curatedFeedServiceMock = new Mock <ICuratedFeedService>(MockBehavior.Strict);
curatedFeedServiceMock.Setup(m => m.GetPackages(_curatedFeedName)).Returns(AllPackages);
curatedFeedServiceMock.Setup(m => m.GetFeedByName(_curatedFeedName, false)).Returns(curatedFeed);
var entitiesContextMock = new Mock <IEntitiesContext>(MockBehavior.Strict);
var curatedFeedDbSet = GetQueryableMockDbSet(curatedFeed);
entitiesContextMock.SetupGet(m => m.CuratedFeeds).Returns(curatedFeedDbSet);
return(new ODataV2CuratedFeedController(
entitiesContextMock.Object,
configurationService,
searchService,
curatedFeedServiceMock.Object));
}
public void WillNotIncludeThePackageWhenItDependsOnAPackageThatIsExcludedInTheFeed()
{
var stubFeed = new CuratedFeed();
var dependencyPackage = new CuratedPackage
{
AutomaticallyCurated = false,
Included = false,
PackageRegistration = new PackageRegistration {
Id = "ManuallyExcludedPackage"
}
};
stubFeed.Packages.Add(dependencyPackage);
var stubNuGetPackage = CreateStubNuGetPackage().Object;
var stubGalleryPackage = CreateStubGalleryPackage();
stubGalleryPackage.Dependencies.Add(
new PackageDependency {
Id = "ManuallyExcludedPackage"
});
bool result = WebMatrixPackageCurator.ShouldCuratePackage(
stubFeed,
stubGalleryPackage,
stubNuGetPackage);
Assert.False(result);
}
public static async Task <SearchAdaptorResult> SearchCore(
ISearchService searchService,
HttpRequestBase request,
IQueryable <Package> packages,
string searchTerm,
string targetFramework,
bool includePrerelease,
CuratedFeed curatedFeed)
{
SearchFilter searchFilter;
// We can only use Lucene if:
// a) We are looking for the latest version of a package OR the Index contains all versions of each package
// b) The sort order is something Lucene can handle
if (TryReadSearchFilter(searchService.ContainsAllVersions, request.RawUrl, false, out searchFilter))
{
searchFilter.SearchTerm = searchTerm;
searchFilter.IncludePrerelease = includePrerelease;
searchFilter.CuratedFeed = curatedFeed;
searchFilter.SupportedFramework = targetFramework;
var results = await GetResultsFromSearchService(searchService, searchFilter);
return(new SearchAdaptorResult(true, results));
}
if (!includePrerelease)
{
packages = packages.Where(p => !p.IsPrerelease);
}
return(new SearchAdaptorResult(false, packages.Search(searchTerm)));
}
public TestableCuratedFeedService()
{
StubCuratedFeed = new CuratedFeed { Key = 0, Name = "aName" };
StubPackageRegistration = new PackageRegistration { Key = 1066, Id = "aPackageId" };
StubCuratedPackage = new CuratedPackage
{
Key = 0,
CuratedFeedKey = StubCuratedFeed.Key,
CuratedFeed = StubCuratedFeed,
PackageRegistration = StubPackageRegistration,
PackageRegistrationKey = StubPackageRegistration.Key
};
StubCuratedFeed.Packages.Add(StubCuratedPackage);
StubCuratedFeedRepository = new Mock<IEntityRepository<CuratedFeed>>();
StubCuratedFeedRepository
.Setup(repo => repo.GetAll())
.Returns(new CuratedFeed[] { StubCuratedFeed }.AsQueryable());
StubCuratedPackageRepository = new Mock<IEntityRepository<CuratedPackage>>();
StubCuratedPackageRepository
.Setup(repo => repo.GetAll())
.Returns(new CuratedPackage[] { StubCuratedPackage }.AsQueryable());
}
public void CompareSearchResultsForAdditions(string targetFramework, CuratedFeed feed)
{
// Get the list of packages that are added to the new search results
List <IPackage> additions = GetChangesInSearchResults(targetFramework, feed).Item2;
// Assert packages from the additions list are compatible with the project's targetframework
AssertPackageListOutcome(targetFramework, additions, true);
}
public void CompareSearchResultsForReductions(string targetFramework, CuratedFeed feed)
{
// Get the list of packages that are missing from the new search results
List<IPackage> reductions = GetChangesInSearchResults(targetFramework, feed).Item1;
// Assert packages from the redutions list are not compatible with the project's targetframework
AssertPackageListOutcome(targetFramework, reductions, false);
}
public void CompareSearchResultsForVersionUpdates(string targetFramework, CuratedFeed feed)
{
// Get the list of packages that have different versions in the new result results
List <IPackage> versionUpdates = GetChangesInSearchResults(targetFramework, feed).Item3;
// Assert packages from the versionUpdates list are compatible with the project's targetframework
AssertPackageListOutcome(targetFramework, versionUpdates, true);
}
public void CompareSearchResultsForReductions(string targetFramework, CuratedFeed feed)
{
// Get the list of packages that are missing from the new search results
List <IPackage> reductions = GetChangesInSearchResults(targetFramework, feed).Item1;
// Assert packages from the redutions list are not compatible with the project's targetframework
AssertPackageListOutcome(targetFramework, reductions, false);
}
public TheGetMethod()
{
_curatedFeed = new CuratedFeed {
Name = _curatedFeedName
};
_curatedFeedPackage = new Package
{
PackageRegistration = new PackageRegistration
{
Id = "NuGet.Core",
},
};
_mainFeedPackage = new Package
{
PackageRegistration = new PackageRegistration
{
Id = "NuGet.Versioning",
},
};
_featureConfiguration = new FeatureConfiguration();
_appConfig = new Mock <IAppConfiguration>();
_config = new Mock <IGalleryConfigurationService>();
_searchService = new Mock <ISearchService>();
_curatedFeedService = new Mock <ICuratedFeedService>();
_packages = new Mock <IEntityRepository <Package> >();
_telemetryService = new Mock <ITelemetryService>();
_config
.Setup(x => x.Current)
.Returns(() => _appConfig.Object);
_config
.Setup(x => x.Features)
.Returns(() => _featureConfiguration);
_config
.Setup(x => x.GetSiteRoot(It.IsAny <bool>()))
.Returns(() => _siteRoot);
_curatedFeedService
.Setup(x => x.GetFeedByName(_curatedFeedName))
.Returns(() => _curatedFeed);
_curatedFeedService
.Setup(x => x.GetPackages(_curatedFeedName))
.Returns(() => new[] { _curatedFeedPackage }.AsQueryable());
_packages
.Setup(x => x.GetAll())
.Returns(() => new[] { _mainFeedPackage }.AsQueryable());
_target = new ODataV2CuratedFeedController(
_config.Object,
_searchService.Object,
_curatedFeedService.Object,
_packages.Object,
_telemetryService.Object);
_request = new HttpRequestMessage(HttpMethod.Get, $"{_siteRoot}/api/v2/curated-feed/{_curatedFeedName}/Packages");
_options = new ODataQueryOptions <V2FeedPackage>(CreateODataQueryContext <V2FeedPackage>(), _request);
AddRequestToController(_request, _target);
}
public string GetPackageSourceURL(FeedSource source, CuratedFeed type)
{
string rootURL = string.Empty;
string curatedURL = string.Empty;
switch (source)
{
case FeedSource.Prod:
{
rootURL = "https://www.nuget.org/api/v2/";
break;
}
case FeedSource.Int:
{
rootURL = "https://int.nugettest.org/api/v2/";
break;
}
default:
break;
}
switch (type)
{
case CuratedFeed.None:
{
curatedURL = "";
break;
}
case CuratedFeed.Win8Express:
{
curatedURL = "curated-feeds/windows8-packages/";
break;
}
case CuratedFeed.WebMatrix:
{
curatedURL = "curated-feeds/webmatrix/";
break;
}
case CuratedFeed.DotNet:
{
curatedURL = "curated-feeds/microsoftdotnet/";
break;
}
default:
break;
}
return(rootURL + curatedURL);
}
public TestableCuratedFeedService()
{
StubCuratedFeed = new CuratedFeed { Key = 0, Name = "aName" };
StubCuratedFeed2 = new CuratedFeed {Key = 1, Name = "AnotherFeed"};
StubPackageRegistration_ForFeed1 = new PackageRegistration { Key = 1066, Id = "aPackageId" };
StubPackageRegistration_ForFeed2 = new PackageRegistration { Key = 1067, Id = "aPackageId2" };
StubPackageRegistration_ForFeed1_NotIncluded = new PackageRegistration { Key = 1068, Id = "aPackageId2" };
StubPackage = new Package { PackageRegistration = StubPackageRegistration_ForFeed1, PackageRegistrationKey = StubPackageRegistration_ForFeed1.Key, Version = "1.0.0" };
StubPackage_IncompatibleVersion = new Package { PackageRegistration = StubPackageRegistration_ForFeed1, PackageRegistrationKey = StubPackageRegistration_ForFeed1.Key, Version = "2.0.0" };
StubPackage_ForFeed1_NotIncluded = new Package { PackageRegistration = StubPackageRegistration_ForFeed1_NotIncluded, PackageRegistrationKey = StubPackageRegistration_ForFeed1_NotIncluded.Key };
StubCuratedPackageRegistration_ForFeed1 = new CuratedPackage
{
Key = 1,
CuratedFeedKey = StubCuratedFeed.Key,
CuratedFeed = StubCuratedFeed,
PackageRegistration = StubPackageRegistration_ForFeed1,
PackageRegistrationKey = StubPackageRegistration_ForFeed1.Key,
Included = true
};
StubCuratedFeed.Packages.Add(StubCuratedPackageRegistration_ForFeed1);
StubCuratedPackageRegistration_ForFeed2 = new CuratedPackage
{
Key = 2,
CuratedFeedKey = StubCuratedFeed2.Key,
CuratedFeed = StubCuratedFeed2,
PackageRegistration = StubPackageRegistration_ForFeed2,
PackageRegistrationKey = StubPackageRegistration_ForFeed2.Key,
Included = true
};
StubCuratedFeed2.Packages.Add(StubCuratedPackageRegistration_ForFeed2);
StubCuratedPackageRegistration_ForFeed1_NotIncluded = new CuratedPackage
{
Key = 3,
CuratedFeedKey = StubCuratedFeed.Key,
CuratedFeed = StubCuratedFeed,
PackageRegistration = StubPackageRegistration_ForFeed1_NotIncluded,
PackageRegistrationKey = StubPackageRegistration_ForFeed1_NotIncluded.Key,
Included = false
};
StubCuratedFeed.Packages.Add(StubCuratedPackageRegistration_ForFeed1_NotIncluded);
StubCuratedFeedRepository = new Mock<IEntityRepository<CuratedFeed>>();
StubCuratedFeedRepository
.Setup(repo => repo.GetAll())
.Returns(new CuratedFeed[] { StubCuratedFeed, StubCuratedFeed2 }.AsQueryable());
StubCuratedPackageRepository = new Mock<IEntityRepository<CuratedPackage>>();
StubCuratedPackageRepository
.Setup(repo => repo.GetAll())
.Returns(new CuratedPackage[] { StubCuratedPackageRegistration_ForFeed1, StubCuratedPackageRegistration_ForFeed2, StubCuratedPackageRegistration_ForFeed1_NotIncluded }.AsQueryable());
}
public TestableWebMatrixPackageCurator()
{
StubCuratedFeed = new CuratedFeed {
Key = 0
};
StubCuratedFeedService = new Mock <ICuratedFeedService>();
StubCuratedFeedService
.Setup(stub => stub.GetFeedByName(It.IsAny <string>(), It.IsAny <bool>()))
.Returns(StubCuratedFeed);
}
public TestableWindows8PackageCurator()
{
StubCreatedCuratedPackageCmd = new Mock <ICreateCuratedPackageCommand>();
StubCuratedFeed = new CuratedFeed {
Key = 0
};
StubCuratedFeedByNameQry = new Mock <ICuratedFeedByNameQuery>();
StubCuratedFeedByNameQry
.Setup(stub => stub.Execute(It.IsAny <string>(), It.IsAny <bool>()))
.Returns(StubCuratedFeed);
}
public void WillNotIncludeThePackageWhenMinClientVersionIsTooHigh()
{
var stubFeed = new CuratedFeed();
var stubGalleryPackage = CreateStubGalleryPackage();
var stubNuGetPackage = CreateStubNuGetPackage(minClientVersion: "3.0.0");
bool result = WebMatrixPackageCurator.ShouldCuratePackage(
stubFeed,
stubGalleryPackage,
new PackageArchiveReader(stubNuGetPackage));
Assert.False(result);
}
public void WillIncludeThePackageWhenItIsTaggedWithAspNetWebPages()
{
var stubFeed = new CuratedFeed();
var stubGalleryPackage = CreateStubGalleryPackage();
var stubNuGetPackage = CreateStubNuGetPackage();
bool result = WebMatrixPackageCurator.ShouldCuratePackage(
stubFeed,
stubGalleryPackage,
stubNuGetPackage.Object);
Assert.True(result);
}
public void WillIncludeThePackageWhenItIsTaggedWithAspNetWebPages()
{
var stubFeed = new CuratedFeed();
var stubGalleryPackage = CreateStubGalleryPackage();
var stubNuGetPackage = CreateStubNuGetPackage();
stubGalleryPackage.Tags = "aspnetwebpages";
bool result = WebMatrixPackageCurator.ShouldCuratePackage(
stubFeed,
stubGalleryPackage,
stubNuGetPackage.Object);
Assert.True(result);
}
public void WillNotIncludeThePackageWhenItIsNotTheLatestStable()
{
var stubFeed = new CuratedFeed();
var stubGalleryPackage = CreateStubGalleryPackage();
stubGalleryPackage.IsLatestStable = false;
var stubNuGetPackage = CreateStubNuGetPackage();
bool result = WebMatrixPackageCurator.ShouldCuratePackage(
stubFeed,
stubGalleryPackage,
stubNuGetPackage.Object);
Assert.False(result);
}
public TestableModifyCuratedPackageCommand()
: base(null)
{
StubCuratedFeed = new CuratedFeed {
Key = 0, Name = "aName",
};
StubCuratedFeedByKeyQry = new Mock <ICuratedFeedByKeyQuery>();
StubEntitiesContext = new Mock <IEntitiesContext>();
StubCuratedFeedByKeyQry
.Setup(stub => stub.Execute(It.IsAny <int>(), It.IsAny <bool>()))
.Returns(StubCuratedFeed);
Entities = StubEntitiesContext.Object;
}
public void WillNotIncludeThePackageWhenMinClientVersionIsTooHigh()
{
var stubFeed = new CuratedFeed();
var stubGalleryPackage = CreateStubGalleryPackage();
var stubNuGetPackage = CreateStubNuGetPackage();
stubNuGetPackage.Setup(n => n.Metadata.MinClientVersion).Returns(new Version(3, 0));
bool result = WebMatrixPackageCurator.ShouldCuratePackage(
stubFeed,
stubGalleryPackage,
stubNuGetPackage.Object);
Assert.False(result);
}
public void WillNotIncludeThePackageWhenItIsNotTheLatestStable()
{
var stubFeed = new CuratedFeed();
var stubGalleryPackage = CreateStubGalleryPackage();
stubGalleryPackage.IsLatestStable = false;
var stubNuGetPackage = CreateStubNuGetPackage();
bool result = WebMatrixPackageCurator.ShouldCuratePackage(
stubFeed,
stubGalleryPackage,
stubNuGetPackage.Object);
Assert.False(result);
}
public List <IPackage> ReturnSearchResults(FeedSource source, CuratedFeed subFeed, string searchTerm, List <string> targetFrameworks, bool allowPrerelease, int count)
{
try
{
string packageSource = GetPackageSourceURL(source, subFeed);
IPackageRepository repo = PackageRepositoryFactory.Default.CreateRepository(packageSource);
IQueryable <IPackage> packages = repo.Search(searchTerm, targetFrameworks, allowPrerelease);
var query = packages.OrderBy(p => p.DownloadCount).Take(count);
return(query.ToList().Take(count).ToList());
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return(null);
}
}
public static TestableWebMatrixPackageCurator Create(Action<Mock<ICuratedFeedService>> setupCuratedFeedServiceStub)
{
var stubCuratedFeed = new CuratedFeed { Key = 0 };
var stubCuratedFeedService = new Mock<ICuratedFeedService>();
stubCuratedFeedService
.Setup(stub => stub.GetFeedByName(It.IsAny<string>(), It.IsAny<bool>()))
.Returns(stubCuratedFeed);
if (setupCuratedFeedServiceStub != null)
{
setupCuratedFeedServiceStub(stubCuratedFeedService);
}
return new TestableWebMatrixPackageCurator(stubCuratedFeed, stubCuratedFeedService);
}
public void WillIncludeThePackageWhenThereIsNotPowerShellOrT4File()
{
var stubFeed = new CuratedFeed();
var stubGalleryPackage = CreateStubGalleryPackage();
var stubNuGetPackage = CreateStubNuGetPackage(populatePackage: p =>
{
p.CreateEntry("foo.txt", CompressionLevel.Fastest);
p.CreateEntry("foo.cs", CompressionLevel.Fastest);
});
bool result = WebMatrixPackageCurator.ShouldCuratePackage(
stubFeed,
stubGalleryPackage,
new PackageArchiveReader(stubNuGetPackage));
Assert.True(result);
}
public void WillNotIncludeThePackageWhenItDependsOnAPackageThatIsNotIncluded()
{
var stubFeed = new CuratedFeed();
var stubNuGetPackage = CreateStubNuGetPackage().Object;
var stubGalleryPackage = CreateStubGalleryPackage();
stubGalleryPackage.Dependencies.Add(
new PackageDependency {
Id = "NotACuratedPackage"
});
bool result = WebMatrixPackageCurator.ShouldCuratePackage(
stubFeed,
stubGalleryPackage,
stubNuGetPackage);
Assert.False(result);
}
public void WillNotIncludeThePackageWhenNotTaggedAndThereIsT4Template()
{
var stubFeed = new CuratedFeed();
var stubGalleryPackage = CreateStubGalleryPackage();
var stubNuGetPackage = CreateStubNuGetPackage(populatePackage: p =>
{
p.CreateEntry("foo.txt", CompressionLevel.Fastest);
p.CreateEntry("foo.t4", CompressionLevel.Fastest);
p.CreateEntry("foo.cs", CompressionLevel.Fastest);
});
bool result = WebMatrixPackageCurator.ShouldCuratePackage(
stubFeed,
stubGalleryPackage,
new PackageArchiveReader(stubNuGetPackage));
Assert.False(result);
}
public static TestableWindows8PackageCurator Create(Action <Mock <ICuratedFeedService> > setupCuratedFeedServiceStub)
{
var stubCuratedFeed = new CuratedFeed {
Key = 0
};
var stubCuratedFeedService = new Mock <ICuratedFeedService>();
stubCuratedFeedService
.Setup(stub => stub.GetFeedByName(It.IsAny <string>(), It.IsAny <bool>()))
.Returns(stubCuratedFeed);
if (setupCuratedFeedServiceStub != null)
{
setupCuratedFeedServiceStub(stubCuratedFeedService);
}
return(new TestableWindows8PackageCurator(stubCuratedFeed, stubCuratedFeedService));
}
public void WillNotIncludeThePackageWhenPackageDoesNotSupportNet40()
{
var stubFeed = new CuratedFeed();
var stubGalleryPackage = CreateStubGalleryPackage();
var stubNuGetPackage = CreateStubNuGetPackageReader();
stubGalleryPackage.Tags = "aspnetwebpages";
stubGalleryPackage.SupportedFrameworks.Add(new PackageFramework()
{
TargetFramework = "net45"
});
bool result = WebMatrixPackageCurator.ShouldCuratePackage(
stubFeed,
stubGalleryPackage,
stubNuGetPackage.Object);
Assert.False(result);
}
protected override ODataV2CuratedFeedController CreateController(
IEntityRepository <Package> packagesRepository,
IGalleryConfigurationService configurationService,
ISearchService searchService)
{
var curatedFeed = new CuratedFeed {
Name = _curatedFeedName
};
var curatedFeedServiceMock = new Mock <ICuratedFeedService>(MockBehavior.Strict);
curatedFeedServiceMock.Setup(m => m.GetPackages(_curatedFeedName)).Returns(AllPackages);
curatedFeedServiceMock.Setup(m => m.GetFeedByName(_curatedFeedName)).Returns(curatedFeed);
return(new ODataV2CuratedFeedController(
configurationService,
searchService,
curatedFeedServiceMock.Object,
packagesRepository));
}
public void WillIncludeThePackageWhenThereIsNotPowerShellOrT4File()
{
var stubFeed = new CuratedFeed();
var stubGalleryPackage = CreateStubGalleryPackage();
var stubNuGetPackage = CreateStubNuGetPackage();
stubNuGetPackage.Setup(stub => stub.GetFiles()).Returns(
new[]
{
"foo.txt",
"foo.cs",
});
bool result = WebMatrixPackageCurator.ShouldCuratePackage(
stubFeed,
stubGalleryPackage,
stubNuGetPackage.Object);
Assert.True(result);
}
public void WillNotIncludeThePackageWhenNotTaggedAndThereIsT4Template()
{
var stubFeed = new CuratedFeed();
var stubGalleryPackage = CreateStubGalleryPackage();
var stubNuGetPackage = CreateStubNuGetPackage();
stubNuGetPackage.Setup(stub => stub.GetFiles()).Returns(
new[]
{
"foo.txt",
"foo.t4",
"foo.cs",
});
bool result = WebMatrixPackageCurator.ShouldCuratePackage(
stubFeed,
stubGalleryPackage,
stubNuGetPackage.Object);
Assert.False(result);
}
public static async Task <SearchAdaptorResult> FindByIdAndVersionCore(
ISearchService searchService,
HttpRequestBase request,
IQueryable <Package> packages,
string id,
string version,
CuratedFeed curatedFeed,
string semVerLevel)
{
SearchFilter searchFilter;
// We can only use Lucene if:
// a) The Index contains all versions of each package
// b) The sort order is something Lucene can handle
if (TryReadSearchFilter(searchService.ContainsAllVersions, UrlExtensions.MakeSecure(request.RawUrl), searchService.ContainsAllVersions, out searchFilter) && !string.IsNullOrWhiteSpace(id))
{
var normalizedRegistrationId = id.Normalize(NormalizationForm.FormC);
var searchTerm = string.Format(CultureInfo.CurrentCulture, "Id:\"{0}\"", normalizedRegistrationId);
if (!string.IsNullOrEmpty(version))
{
searchTerm = string.Format(CultureInfo.CurrentCulture, "Id:\"{0}\" AND Version:\"{1}\"", normalizedRegistrationId, version);
searchFilter.Take = 1; // only one result is needed in this case
}
searchFilter.SearchTerm = searchTerm;
searchFilter.SemVerLevel = semVerLevel;
searchFilter.IncludePrerelease = true;
searchFilter.CuratedFeed = curatedFeed;
searchFilter.SupportedFramework = null;
searchFilter.IncludeAllVersions = true;
var results = await GetRawResultsFromSearchService(searchService, searchFilter);
return(new SearchAdaptorResult(true, results));
}
return(new SearchAdaptorResult(false, packages));
}
public TestableRequiredDependencyPackageCurator()
{
StubCuratedFeed = new CuratedFeed
{
Key = 0,
Name = RequiredDependencyPackageId + "_v3.0"
};
FakeEntitiesContext = new FakeEntitiesContext();
FakeEntitiesContext.CuratedFeeds.Add(StubCuratedFeed);
StubCuratedFeedService = new Mock <ICuratedFeedService>();
StubCuratedFeedService
.Setup(stub => stub.GetFeedByName(It.IsAny <string>(), It.IsAny <bool>()))
.Returns(StubCuratedFeed);
var packageRegistration = new PackageRegistration
{
Key = 23,
Id = PackageDependencyPackageId,
};
var package = new Package
{
Key = 14,
PackageRegistrationKey = packageRegistration.Key,
PackageRegistration = packageRegistration,
Version = "3.0.0"
};
packageRegistration.Packages.Add(package);
StubPackageRegistrationRepository = new Mock <IEntityRepository <PackageRegistration> >();
StubPackageRegistrationRepository
.Setup(stub => stub.GetAll())
.Returns(new[] { packageRegistration }.AsQueryable());
}
public TestableWebMatrixPackageCurator(CuratedFeed stubCuratedFeed, Mock<ICuratedFeedService> stubCuratedFeedService)
: base(stubCuratedFeedService.Object)
{
StubCuratedFeed = stubCuratedFeed;
StubCuratedFeedService = stubCuratedFeedService;
}
public void WillNotIncludeThePackageWhenPackageDoesNotSupportNet40()
{
var stubFeed = new CuratedFeed();
var stubGalleryPackage = CreateStubGalleryPackage();
var stubNuGetPackage = CreateStubNuGetPackage();
stubGalleryPackage.Tags = "aspnetwebpages";
stubGalleryPackage.SupportedFrameworks.Add(new PackageFramework()
{
TargetFramework = "net45"
});
bool result = WebMatrixPackageCurator.ShouldCuratePackage(
stubFeed,
stubGalleryPackage,
stubNuGetPackage.Object);
Assert.False(result);
}
public void WillNotIncludeThePackageWhenMinClientVersionIsTooHigh()
{
var stubFeed = new CuratedFeed();
var stubGalleryPackage = CreateStubGalleryPackage();
var stubNuGetPackage = CreateStubNuGetPackage();
stubNuGetPackage.Setup(n => n.Metadata.MinClientVersion).Returns(new Version(3, 0));
bool result = WebMatrixPackageCurator.ShouldCuratePackage(
stubFeed,
stubGalleryPackage,
stubNuGetPackage.Object);
Assert.False(result);
}
public void WillIncludeThePackageWhenThereIsNotPowerShellOrT4File()
{
var stubFeed = new CuratedFeed();
var stubGalleryPackage = CreateStubGalleryPackage();
var stubNuGetPackage = CreateStubNuGetPackage();
stubNuGetPackage.Setup(stub => stub.GetFiles()).Returns(
new[]
{
"foo.txt",
"foo.cs",
});
bool result = WebMatrixPackageCurator.ShouldCuratePackage(
stubFeed,
stubGalleryPackage,
stubNuGetPackage.Object);
Assert.True(result);
}
public void WillNotIncludeThePackageWhenItDependsOnAPackageThatIsExcludedInTheFeed()
{
var stubFeed = new CuratedFeed();
var dependencyPackage = new CuratedPackage
{
AutomaticallyCurated = false,
Included = false,
PackageRegistration = new PackageRegistration { Id = "ManuallyExcludedPackage" }
};
stubFeed.Packages.Add(dependencyPackage);
var stubNuGetPackage = CreateStubNuGetPackage().Object;
var stubGalleryPackage = CreateStubGalleryPackage();
stubGalleryPackage.Dependencies.Add(
new PackageDependency { Id = "ManuallyExcludedPackage" });
bool result = WebMatrixPackageCurator.ShouldCuratePackage(
stubFeed,
stubGalleryPackage,
stubNuGetPackage);
Assert.False(result);
}
public void WillNotIncludeThePackageWhenItDependsOnAPackageThatIsNotIncluded()
{
var stubFeed = new CuratedFeed();
var stubNuGetPackage = CreateStubNuGetPackage().Object;
var stubGalleryPackage = CreateStubGalleryPackage();
stubGalleryPackage.Dependencies.Add(
new PackageDependency { Id = "NotACuratedPackage" });
bool result = WebMatrixPackageCurator.ShouldCuratePackage(
stubFeed,
stubGalleryPackage,
stubNuGetPackage);
Assert.False(result);
}
public void WillIncludeThePackageWhenThereIsNotPowerShellOrT4File()
{
var stubFeed = new CuratedFeed();
var stubGalleryPackage = CreateStubGalleryPackage();
var stubNuGetPackage = CreateStubNuGetPackage(populatePackage: p =>
{
p.CreateEntry("foo.txt", CompressionLevel.Fastest);
p.CreateEntry("foo.cs", CompressionLevel.Fastest);
});
bool result = WebMatrixPackageCurator.ShouldCuratePackage(
stubFeed,
stubGalleryPackage,
new PackageArchiveReader(stubNuGetPackage));
Assert.True(result);
}
public void WillNotIncludeThePackageWhenNotTaggedAndThereIsT4Template()
{
var stubFeed = new CuratedFeed();
var stubGalleryPackage = CreateStubGalleryPackage();
var stubNuGetPackage = CreateStubNuGetPackage();
stubNuGetPackage.Setup(stub => stub.GetFiles()).Returns(
new[]
{
"foo.txt",
"foo.t4",
"foo.cs",
});
bool result = WebMatrixPackageCurator.ShouldCuratePackage(
stubFeed,
stubGalleryPackage,
stubNuGetPackage.Object);
Assert.False(result);
}
public List<IPackage> ReturnSearchResults(FeedSource source, CuratedFeed subFeed, string searchTerm, List<string> targetFrameworks, bool allowPrerelease, int count)
{
try
{
string packageSource = GetPackageSourceURL(source, subFeed);
IPackageRepository repo = PackageRepositoryFactory.Default.CreateRepository(packageSource);
IQueryable<IPackage> packages = repo.Search(searchTerm, targetFrameworks, allowPrerelease);
var query = packages.OrderBy(p => p.DownloadCount).Take(count);
return query.ToList().Take(count).ToList();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return null;
}
}
public string GetPackageSourceURL(FeedSource source, CuratedFeed type)
{
string rootURL = string.Empty;
string curatedURL = string.Empty;
switch (source)
{
case FeedSource.Prod:
{
rootURL = "https://www.nuget.org/api/v2/";
break;
}
case FeedSource.Int:
{
rootURL = "https://int.nugettest.org/api/v2/";
break;
}
default:
break;
}
switch (type)
{
case CuratedFeed.None:
{
curatedURL = "";
break;
}
case CuratedFeed.Win8Express:
{
curatedURL = "curated-feeds/windows8-packages/";
break;
}
case CuratedFeed.WebMatrix:
{
curatedURL = "curated-feeds/webmatrix/";
break;
}
case CuratedFeed.DotNet:
{
curatedURL = "curated-feeds/microsoftdotnet/";
break;
}
default:
break;
}
return rootURL + curatedURL;
}
public static async Task<SearchAdaptorResult> FindByIdAndVersionCore(
ISearchService searchService,
HttpRequestBase request,
IQueryable<Package> packages,
string id,
string version,
CuratedFeed curatedFeed)
{
SearchFilter searchFilter;
// We can only use Lucene if:
// a) The Index contains all versions of each package
// b) The sort order is something Lucene can handle
if (TryReadSearchFilter(searchService.ContainsAllVersions, request.RawUrl, searchService.ContainsAllVersions, out searchFilter))
{
var searchTerm = string.Format(CultureInfo.CurrentCulture, "Id:\"{0}\"", id);
if (!string.IsNullOrEmpty(version))
{
searchTerm = string.Format(CultureInfo.CurrentCulture, "Id:\"{0}\" AND Version:\"{1}\"", id, version);
searchFilter.Take = 1; // only one result is needed in this case
}
searchFilter.SearchTerm = searchTerm;
searchFilter.IncludePrerelease = true;
searchFilter.CuratedFeed = curatedFeed;
searchFilter.SupportedFramework = null;
searchFilter.IncludeAllVersions = true;
var results = await GetRawResultsFromSearchService(searchService, searchFilter);
return new SearchAdaptorResult(true, results);
}
return new SearchAdaptorResult(false, packages);
}
private Tuple <List <IPackage>, List <IPackage>, List <IPackage> > GetChangesInSearchResults(string targetFramework, CuratedFeed feed)
{
List <string> frameworks = new List <string>();
frameworks.Add(targetFramework);
// Get prod search results
List <IPackage> prodResults = ReturnSearchResults(FeedSource.Prod, feed, "", frameworks, false, Count);
// Get Int search results
List <IPackage> intResults = ReturnSearchResults(FeedSource.Int, feed, "", frameworks, false, Count);
List <IPackage> reductions = new List <IPackage>();
List <IPackage> additions = new List <IPackage>();
List <IPackage> versionUpdates = new List <IPackage>();
for (int i = 0; i < prodResults.Count(); i++)
{
IPackage package = intResults.Where(p => p.Id == prodResults[i].Id).FirstOrDefault();
if (package == null)
{
reductions.Add(prodResults[i]);
}
}
for (int i = 0; i < intResults.Count(); i++)
{
IPackage package = prodResults.Where(p => p.Id == intResults[i].Id).FirstOrDefault();
if (package == null)
{
additions.Add(intResults[i]);
}
}
for (int i = 0; i < prodResults.Count(); i++)
{
IPackage packageA = prodResults[i];
IPackage packageB = intResults.Where(p => p.Id == packageA.Id).FirstOrDefault();
if (packageB != null && packageA.Version != packageB.Version)
{
versionUpdates.Add(packageB);
}
}
var resultTuple = new Tuple <List <IPackage>, List <IPackage>, List <IPackage> >(reductions, additions, versionUpdates);
return(resultTuple);
}
public static async Task<SearchAdaptorResult> SearchCore(
ISearchService searchService,
HttpRequestBase request,
IQueryable<Package> packages,
string searchTerm,
string targetFramework,
bool includePrerelease,
CuratedFeed curatedFeed)
{
SearchFilter searchFilter;
// We can only use Lucene if:
// a) We are looking for the latest version of a package OR the Index contains all versions of each package
// b) The sort order is something Lucene can handle
if (TryReadSearchFilter(searchService.ContainsAllVersions, request.RawUrl, false, out searchFilter))
{
searchFilter.SearchTerm = searchTerm;
searchFilter.IncludePrerelease = includePrerelease;
searchFilter.CuratedFeed = curatedFeed;
searchFilter.SupportedFramework = targetFramework;
var results = await GetResultsFromSearchService(searchService, searchFilter);
return new SearchAdaptorResult(true, results);
}
if (!includePrerelease)
{
packages = packages.Where(p => !p.IsPrerelease);
}
return new SearchAdaptorResult(false, packages.Search(searchTerm));
}
public void WillNotIncludeThePackageWhenNotTaggedAndThereIsT4Template()
{
var stubFeed = new CuratedFeed();
var stubGalleryPackage = CreateStubGalleryPackage();
var stubNuGetPackage = CreateStubNuGetPackage(populatePackage: p =>
{
p.CreateEntry("foo.txt", CompressionLevel.Fastest);
p.CreateEntry("foo.t4", CompressionLevel.Fastest);
p.CreateEntry("foo.cs", CompressionLevel.Fastest);
});
bool result = WebMatrixPackageCurator.ShouldCuratePackage(
stubFeed,
stubGalleryPackage,
new PackageArchiveReader(stubNuGetPackage));
Assert.False(result);
}
private Tuple<List<IPackage>, List<IPackage>, List<IPackage>> GetChangesInSearchResults(string targetFramework, CuratedFeed feed)
{
List<string> frameworks = new List<string>();
frameworks.Add(targetFramework);
// Get prod search results
List<IPackage> prodResults = ReturnSearchResults(FeedSource.Prod, feed, "", frameworks, false, Count);
// Get Int search results
List<IPackage> intResults = ReturnSearchResults(FeedSource.Int, feed, "", frameworks, false, Count);
List<IPackage> reductions = new List<IPackage>();
List<IPackage> additions = new List<IPackage>();
List<IPackage> versionUpdates = new List<IPackage>();
for (int i = 0; i < prodResults.Count(); i++)
{
IPackage package = intResults.Where(p => p.Id == prodResults[i].Id).FirstOrDefault();
if (package == null)
{
reductions.Add(prodResults[i]);
}
}
for (int i = 0; i < intResults.Count(); i++)
{
IPackage package = prodResults.Where(p => p.Id == intResults[i].Id).FirstOrDefault();
if (package == null)
{
additions.Add(intResults[i]);
}
}
for (int i = 0; i < prodResults.Count(); i++)
{
IPackage packageA = prodResults[i];
IPackage packageB = intResults.Where(p => p.Id == packageA.Id).FirstOrDefault();
if (packageB != null && packageA.Version != packageB.Version)
{
versionUpdates.Add(packageB);
}
}
var resultTuple = new Tuple<List<IPackage>, List<IPackage>, List<IPackage>>(reductions, additions, versionUpdates);
return resultTuple;
}
public void CompareSearchResultsForVersionUpdates(string targetFramework, CuratedFeed feed)
{
// Get the list of packages that have different versions in the new result results
List<IPackage> versionUpdates = GetChangesInSearchResults(targetFramework, feed).Item3;
// Assert packages from the versionUpdates list are compatible with the project's targetframework
AssertPackageListOutcome(targetFramework, versionUpdates, true);
}
public void WillNotIncludeThePackageWhenMinClientVersionIsTooHigh()
{
var stubFeed = new CuratedFeed();
var stubGalleryPackage = CreateStubGalleryPackage();
var stubNuGetPackage = CreateStubNuGetPackage(minClientVersion: "3.0.0");
bool result = WebMatrixPackageCurator.ShouldCuratePackage(
stubFeed,
stubGalleryPackage,
new PackageArchiveReader(stubNuGetPackage));
Assert.False(result);
}
public TestableWindows8PackageCurator(CuratedFeed stubCuratedFeed, Mock <ICuratedFeedService> stubCuratedFeedService)
: base(stubCuratedFeedService.Object)
{
StubCuratedFeed = stubCuratedFeed;
StubCuratedFeedService = stubCuratedFeedService;
}
public void CompareSearchResultsForAdditions(string targetFramework, CuratedFeed feed)
{
// Get the list of packages that are added to the new search results
List<IPackage> additions = GetChangesInSearchResults(targetFramework, feed).Item2;
// Assert packages from the additions list are compatible with the project's targetframework
AssertPackageListOutcome(targetFramework, additions, true);
}
