public void ConfigurationCacheIsClearedIfFileRemoved()
{
// Arrange
var solutionManager = new Mock<ISolutionManager>();
solutionManager.Setup(m => m.SolutionDirectory).Returns(@"bar\baz");
var fileSystem = new MockFileSystem();
fileSystem.AddFile(@"bar\nuget.config", @"
<settings>
<repositoryPath>lib</repositoryPath>
</settings>");
var fileSystemProvider = new Mock<IFileSystemProvider>();
fileSystemProvider.Setup(m => m.GetFileSystem(@"bar\baz")).Returns(fileSystem);
var repositorySettings = new RepositorySettings(solutionManager.Object, fileSystemProvider.Object);
// Act
string p1 = repositorySettings.RepositoryPath;
fileSystem.DeleteFile(@"bar\nuget.config");
string p2 = repositorySettings.RepositoryPath;
// Assert
Assert.AreEqual(@"bar\lib", p1);
Assert.AreEqual(@"bar\baz\packages", p2);
}
public void RepositoryPathThrowsIfSolutionDirectoryIsNull()
{
// Arrange
var solutionManager = new Mock<ISolutionManager>();
var repositorySettings = new RepositorySettings(solutionManager.Object, new Mock<IFileSystemProvider>().Object, new Mock<IVsSourceControlTracker>().Object);
// Act
ExceptionAssert.Throws<InvalidOperationException>(() => { string s = repositorySettings.RepositoryPath; }, "Unable to locate the solution directory. Please ensure that the solution has been saved.");
}
public void RepositoryPathDefaultsToPackagesFolderInSolutionDirectoryIfNoConfigExists()
{
// Arrange
var solutionManager = new Mock<ISolutionManager>();
solutionManager.Setup(m => m.SolutionDirectory).Returns(@"bar\baz");
var fileSystemProvider = new Mock<IFileSystemProvider>();
fileSystemProvider.Setup(m => m.GetFileSystem(@"bar\baz\.nuget")).Returns(new MockFileSystem());
var repositorySettings = new RepositorySettings(solutionManager.Object, fileSystemProvider.Object, new Mock<IVsSourceControlTracker>().Object);
// Act
string path = repositorySettings.RepositoryPath;
// Assert
Assert.Equal(@"bar\baz\packages", path);
}
public void RepositoryPathComesFromConfigFileIfSpecified()
{
// Arrange
var solutionManager = new Mock<ISolutionManager>();
solutionManager.Setup(m => m.SolutionDirectory).Returns(@"bar\baz");
var fileSystem = new MockFileSystem();
fileSystem.AddFile(@"bar\nuget.config", @"
<settings>
<repositoryPath>lib</repositoryPath>
</settings>");
solutionManager.Setup(m => m.SolutionDirectory).Returns(@"bar\baz");
var fileSystemProvider = new Mock<IFileSystemProvider>();
fileSystemProvider.Setup(m => m.GetFileSystem(@"bar\baz\.nuget")).Returns(fileSystem);
var repositorySettings = new RepositorySettings(solutionManager.Object, fileSystemProvider.Object, new Mock<IVsSourceControlTracker>().Object);
// Act
string path = repositorySettings.RepositoryPath;
// Assert
Assert.Equal(@"bar\lib", path);
}
public void RepositoryPathDefaultsToPackagesDirectoryIfConfigFileHasEmptyOrNullRepositoryPath()
{
// Arrange
var solutionManager = new Mock<ISolutionManager>();
solutionManager.Setup(m => m.SolutionDirectory).Returns(@"bar\baz");
var fileSystem = new MockFileSystem();
fileSystem.AddFile(@"bar\nuget.config", @"
<settings>
<repositoryPath></repositoryPath>
</settings>");
solutionManager.Setup(m => m.SolutionDirectory).Returns(@"bar\baz");
var fileSystemProvider = new Mock<IFileSystemProvider>();
fileSystemProvider.Setup(m => m.GetFileSystem(@"bar\baz\.nuget")).Returns(fileSystem);
var repositorySettings = new RepositorySettings(solutionManager.Object, fileSystemProvider.Object, new Mock<IVsSourceControlTracker>().Object);
// Act
string path = repositorySettings.RepositoryPath;
// Assert
Assert.Equal(@"bar\baz\packages", path);
}
public static IReferenceDataRepository GetReferenceDataRepository()
{
// See if the IReferenceDataRepository instance was already created
if (ReferenceDataRepositoryFactory.referenceDataRepository == null)
{
// It was not created, so build it now
RepositorySettings settings =
(RepositorySettings)ConfigurationManager.GetSection(
RepositoryMappingConstants.RepositoryMappingsConfigurationSectionName);
// Get the type to be created
Type repositoryType =
Type.GetType(
settings.RepositoryMappings["IReferenceDataRepository"].RepositoryFullTypeName);
// Create the repository, and cast it to the
// IReferenceDataRepository interface
ReferenceDataRepositoryFactory.referenceDataRepository =
Activator.CreateInstance(repositoryType) as IReferenceDataRepository;
}
return(ReferenceDataRepositoryFactory.referenceDataRepository);
}
public async Task <XLSForm> LoadAsync(string f, string keyWordSurvey)
{
XLSForm xlsform = new XLSForm();
FileInfo file = new FileInfo(f);
using (ExcelPackage package = new ExcelPackage(file))
{
RepositorySurvey rSurvey = new RepositorySurvey(package, keyWordSurvey);
RepositoryChoice rChoices = new RepositoryChoice(package);
RepositorySettings rSettings = new RepositorySettings(package);
await rSurvey.LoadContentAsync();
await rChoices.LoadContentAsync();
await rSettings.LoadContentAsync();
xlsform.Surveys = rSurvey.Records;
xlsform.Choices = rChoices.Records;
xlsform.Settings = rSettings.Records[0];
}
return(xlsform);
}
public static T GetProvider <T>() where T : class
{
// See if the provider instance was already created
if (ProviderFactory.provider == null)
{
// It was not created, so build it now
RepositorySettings settings =
(RepositorySettings)ConfigurationManager.GetSection(
RepositoryMappingConstants.RepositoryMappingsConfigurationSectionName);
// Get the type to be created
string interfaceTypeName = typeof(T).Name;
Type repositoryType =
Type.GetType(
settings.RepositoryMappings[interfaceTypeName].RepositoryFullTypeName);
// Create the provider
ProviderFactory.provider =
Activator.CreateInstance(repositoryType);
}
return(ProviderFactory.provider as T);
}
protected override void ProcessRecord()
{
string nameArrayAsString = (Name == null || !Name.Any() || string.Equals(Name[0], "*") || Name[0] == null)
? "all" : string.Join(", ", Name);
WriteVerbose(String.Format("reading repository: {0}. Calling Read() API now", nameArrayAsString));
List <PSRepositoryInfo> items = RepositorySettings.Read(Name, out string[] errorList);
// handle non-terminating errors
foreach (string error in errorList)
{
WriteError(new ErrorRecord(
new PSInvalidOperationException(error),
"ErrorGettingSpecifiedRepo",
ErrorCategory.InvalidOperation,
this));
}
foreach (PSRepositoryInfo repo in items)
{
WriteObject(repo);
}
}
public async Task Run(RepositorySettings repository, UsernamePasswordCredentials gitCreds)
{
try
{
var repo = await BuildGitRepositorySpec(repository, gitCreds.Username);
if (repo == null)
{
return;
}
var tempFolder = _folderFactory.UniqueTemporaryFolder();
var git = new LibGit2SharpDriver(_logger, tempFolder, gitCreds);
await _repositoryUpdater.Run(git, repo);
tempFolder.TryDelete();
}
catch (Exception ex)
{
_logger.Error($"Failed on repo {repository.RepositoryName}", ex);
}
}
public IEnumerable <CompletionResult> CompleteArgument(
string commandName,
string parameterName,
string wordToComplete,
CommandAst commandAst,
IDictionary fakeBoundParameters)
{
List <PSRepositoryInfo> listOfRepositories = RepositorySettings.Read(null, out string[] _);
wordToComplete = Utils.TrimQuotes(wordToComplete);
var wordToCompletePattern = WildcardPattern.Get(
pattern: string.IsNullOrWhiteSpace(wordToComplete) ? "*" : wordToComplete + "*",
options: WildcardOptions.IgnoreCase);
foreach (PSRepositoryInfo repo in listOfRepositories)
{
string repoName = repo.Name;
if (wordToCompletePattern.IsMatch(repoName))
{
yield return(new CompletionResult(Utils.QuoteName(repoName)));
}
}
}
public async Task SaveMessage(ChatHistoryEntity chatHistoryEntity)
{
RepositorySettings repositorySettings = new RepositorySettings();
// Retrieve the storage account from the connection string.
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(
repositorySettings.ConnectionString);
// Create the table client.
CloudTableClient tableClient = storageAccount.CreateCloudTableClient();
// Create the CloudTable object that represents the "people" table.
CloudTable table = tableClient.GetTableReference(repositorySettings.ChatHistoryTableName);
// Create the table if it doesn't exist.
await table.CreateIfNotExistsAsync();
// Create the TableOperation object that inserts the chat history entity.
TableOperation insertOperation = TableOperation.Insert(chatHistoryEntity);
// Execute the insert operation.
await table.ExecuteAsync(insertOperation);
}
public Files(string name, RepositorySettings settings)
{
var fileName = string.Concat(name, settings.Extension);
var settingsDirectory = new DirectoryInfo(settings.Directory);
this.File = settingsDirectory.CreateFileInfoInDirectory(fileName);
var tempfileName = string.Concat(name, settings.TempExtension);
this.Temp = settingsDirectory.CreateFileInfoInDirectory(tempfileName);
this.SoftDelete = this.File.GetSoftDeleteFileFor();
this.WithNewName = this.File.WithNewName(NewName, settings);
this.SoftDeleteNewName = this.SoftDelete.WithNewName(NewName, settings);
var backupSettings = settings.BackupSettings;
if (backupSettings != null)
{
this.Backup = BackupFile.CreateFor(this.File, backupSettings);
this.BackupSoftDelete = this.Backup.GetSoftDeleteFileFor();
this.BackupNewName = BackupFile.CreateFor(this.WithNewName, backupSettings);
}
}
/// <summary>
/// Reads the affected file path from a warning logged in a MsBuild log.
/// </summary>
/// <param name="warning">Warning element from MsBuild log.</param>
/// <param name="repositorySettings">Repository settings to use.</param>
/// <param name="fileName">Returns the full path to the affected file.</param>
/// <returns>True if the file path could be parsed.</returns>
private bool TryGetFile(
XElement warning,
RepositorySettings repositorySettings,
out string fileName)
{
fileName = string.Empty;
var fileAttr = warning.Attribute("file");
if (fileAttr == null)
{
return(true);
}
fileName = fileAttr.Value;
if (string.IsNullOrWhiteSpace(fileName))
{
return(true);
}
// If not absolute path, combine with file path from compile task.
if (!fileName.IsFullPath())
{
var parentFileAttr = warning.Parent?.Attribute("file");
if (parentFileAttr != null)
{
var compileTaskDirectory = System.IO.Path.GetDirectoryName(parentFileAttr.Value);
fileName = System.IO.Path.Combine(compileTaskDirectory, fileName);
}
}
// Validate file path and make relative to repository root.
bool result;
(result, fileName) = this.ValidateFilePath(fileName, repositorySettings);
return(result);
}
private static async Task <bool> PerformCrud(ContextPersistence <Guid, MondayMorningBlues> repo, string batchId, ConsoleMenu m)
{
var createEntity = CreateEntity();
var repoSettings = new RepositorySettings {
BatchId = batchId
};
var createResult = await repo.Persistence.Create(createEntity, repoSettings);
if (!createResult.IsSuccess)
{
PersistenceLog(m, $"StressCrudTest Create {createResult.ResponseCode}", createResult.IsSuccess);
return(false);
}
var readResult = await repo.Persistence.Read(createEntity.Id, repoSettings);
if (!readResult.IsSuccess)
{
PersistenceLog(m, $"StressCrudTest Read {readResult.ResponseCode}", readResult.IsSuccess);
return(false);
}
var updateResult = await repo.Persistence.Update(readResult.Entity, repoSettings);
if (!updateResult.IsSuccess)
{
PersistenceLog(m, $"StressCrudTest Update {updateResult.ResponseCode}", updateResult.IsSuccess);
return(false);
}
var deleteResult = await repo.Persistence.Delete(createEntity.Id, repoSettings);
if (!deleteResult.IsSuccess)
{
PersistenceLog(m, $"StressCrudTest Delete {deleteResult.ResponseCode}", deleteResult.IsSuccess);
return(false);
}
return(true);
}
/// <inheritdoc />
public override IEnumerable <IIssue> ReadIssues(
MarkdownlintIssuesProvider issueProvider,
IssueCommentFormat format,
RepositorySettings repositorySettings,
MarkdownlintIssuesSettings markdownlintIssuesSettings)
{
issueProvider.NotNull(nameof(issueProvider));
repositorySettings.NotNull(nameof(repositorySettings));
markdownlintIssuesSettings.NotNull(nameof(markdownlintIssuesSettings));
Dictionary <string, IEnumerable <Issue> > logFileEntries;
using (var ms = new MemoryStream(markdownlintIssuesSettings.LogFileContent.RemovePreamble()))
{
var jsonSerializer = new DataContractJsonSerializer(
typeof(Dictionary <string, IEnumerable <Issue> >),
settings: new DataContractJsonSerializerSettings {
UseSimpleDictionaryFormat = true
});
logFileEntries = jsonSerializer.ReadObject(ms) as Dictionary <string, IEnumerable <Issue> >;
}
return
(from file in logFileEntries
from entry in file.Value
let
rule = entry.ruleName
select
IssueBuilder
.NewIssue(entry.ruleDescription, issueProvider)
.InFile(file.Key, entry.lineNumber)
.WithPriority(IssuePriority.Warning)
.OfRule(rule, MarkdownlintRuleUrlResolver.Instance.ResolveRuleUrl(rule))
.Create());
}
public async Task <bool> ContainsDotNetProjects(RepositorySettings repository)
{
const string dotNetCodeFiles = "\"packages.config\" OR \".csproj\" OR \".fsproj\" OR \".vbproj\"";
var repos = new List <SearchRepo>
{
new SearchRepo(repository.RepositoryOwner, repository.RepositoryName)
};
var searchCodeRequest = new SearchCodeRequest(dotNetCodeFiles, repos)
{
PerPage = 1
};
try
{
var result = await _collaborationFactory.CollaborationPlatform.Search(searchCodeRequest);
if (result.TotalCount <= 0)
{
_logger.Detailed(
$"Repository {repository.RepositoryOwner}/{repository.RepositoryName} contains no .NET code on the default branch, skipping.");
return(false);
}
return(true);
}
#pragma warning disable CA1031
catch (Exception ex)
#pragma warning restore CA1031
{
_logger.Error("Repository search failed.", ex);
}
return(true);
}
public void RepositoryPathComesFromConfigFileIfSpecified()
{
// Arrange
var solutionManager = new Mock <ISolutionManager>();
solutionManager.Setup(m => m.SolutionDirectory).Returns(@"bar\baz");
var fileSystem = new MockFileSystem();
fileSystem.AddFile(@"bar\nuget.config", @"
<settings>
<repositoryPath>lib</repositoryPath>
</settings>");
solutionManager.Setup(m => m.SolutionDirectory).Returns(@"bar\baz");
var fileSystemProvider = new Mock <IFileSystemProvider>();
fileSystemProvider.Setup(m => m.GetFileSystem(@"bar\baz")).Returns(fileSystem);
var repositorySettings = new RepositorySettings(solutionManager.Object, fileSystemProvider.Object, new Mock <IVsSourceControlTracker>().Object);
// Act
string path = repositorySettings.RepositoryPath;
// Assert
Assert.Equal(@"bar\lib", path);
}
public void ConfigurationCacheIsClearedIfSourceControlBindingChanges()
{
// Arrange
var solutionManager = new Mock <MockSolutionManager>();
solutionManager.Setup(m => m.SolutionDirectory).Returns(@"bar\baz");
var fileSystem = new MockFileSystem();
fileSystem.AddFile(@"bar\nuget.config", @"
<settings>
<repositoryPath>lib</repositoryPath>
</settings>");
var fileSystemProvider = new Mock <IFileSystemProvider>();
fileSystemProvider.Setup(m => m.GetFileSystem(@"bar\baz")).Returns(fileSystem);
var sourceControlTracker = new Mock <IVsSourceControlTracker>();
var repositorySettings = new RepositorySettings(solutionManager.Object, fileSystemProvider.Object, sourceControlTracker.Object);
// Act
string p1 = repositorySettings.RepositoryPath;
sourceControlTracker.Raise(p => p.SolutionBoundToSourceControl += (o, e) => { }, EventArgs.Empty);
fileSystem.AddFile(@"bar\baz\nuget.config", @"
<settings>
<repositoryPath>foo</repositoryPath>
</settings>");
string p2 = repositorySettings.RepositoryPath;
// Assert
Assert.Equal(@"bar\lib", p1);
Assert.Equal(@"bar\baz\foo", p2);
}
/// <summary>
/// 反射工厂
/// </summary>
/// <typeparam name="T">对象</typeparam>
/// <returns>结果</returns>
public static T GetFactory <T>()
where T : class
{
T respository = default(T);
string interfaceShortName = typeof(T).Name;
if (!MRespository.ContainsKey(interfaceShortName))
{
RepositorySettings settings = (RepositorySettings)ConfigurationManager.GetSection(RepositoryMappingConstants.RepositoryMappingsConfigurationSectionName);
string repositoryFullTypeName = settings.RepositoryMappings[interfaceShortName].RepositoryFullTypeName;
Type type = Type.GetType(repositoryFullTypeName);
if (type != null)
{
respository = Activator.CreateInstance(type) as T;
MRespository.Add(interfaceShortName, respository);
}
}
else
{
respository = (T)MRespository[interfaceShortName];
}
return(respository);
}
public void should_load_with_defaults()
{
// We just need the defaults so we can resolve it from loader and
// repoResolver, and compare them.
var defaults = loader.Lookup <RepositorySettings>(nameof(DefaultRepositorySettings));
defaults.Should().NotBeNull();
var withDefaults = resolver.Lookup("learn_to_fly");
var withDefaultsFromLoader = loader.LookupWith <RepositorySettings>("learn_to_fly", defaults);
withDefaultsFromLoader.Should().NotBeNull();
withDefaults.Should().NotBeNull().And.BeEquivalentTo(withDefaultsFromLoader, opt => opt
// Name and selection will vary, these aren't properties we
// want to compare
.Excluding(t => t.Name)
.Excluding(t => t.Selection)
// Reviewers is the only thing that was overlayed in the
// learn_to_fly repo settings
.Excluding(t => t.Reviewers)
, "Resolving via repository and laoder should be the same."
);
// Make sure then when we resolve without defaults, the properties
// should line up with a new instance of repo settings.
var newSettings = new RepositorySettings();
var withoutDefaults = loader.Lookup <RepositorySettings>().Single(r => r.Selection.Repos.Contains("learn_to_fly"));
withoutDefaults.Should().NotBeNull();
withoutDefaults.Reviewers.Should().Be(5).And.NotBe(newSettings.Reviewers);
withoutDefaults.MergeCommit.Should().Be(newSettings.MergeCommit);
withoutDefaults.SquashCommit.Should().Be(newSettings.SquashCommit);
withoutDefaults.RebaseCommit.Should().Be(newSettings.RebaseCommit);
}
public void GetValueFromMachineWideSettings()
{
// Arrange
var solutionManager = new Mock <MockSolutionManager>();
solutionManager.Setup(m => m.SolutionDirectory).Returns(@"bar\baz");
var fileSystem = new MockFileSystem();
var fileSystemProvider = new Mock <IFileSystemProvider>();
fileSystemProvider.Setup(m => m.GetFileSystem(@"bar\baz\.nuget")).Returns(fileSystem);
var sourceControlTracker = new Mock <IVsSourceControlTracker>();
fileSystem.AddFile(@"a.config", @"
<configuration>
<config>
<add key=""repositorypath"" value=""c:\path"" />
</config>
</configuration>");
var settings = new Settings[] {
new Settings(fileSystem, "a.config")
};
var machineWideSettings = new Mock <IMachineWideSettings>();
machineWideSettings.SetupGet(m => m.Settings).Returns(settings);
var repositorySettings = new RepositorySettings(solutionManager.Object, fileSystemProvider.Object, sourceControlTracker.Object, machineWideSettings.Object);
// Act
var repositoryPath = repositorySettings.RepositoryPath;
// Assert
Assert.Equal(@"c:\path", repositoryPath);
}
protected override void BeginProcessing()
{
if (Proxy != null || ProxyCredential != null)
{
ThrowTerminatingError(new ErrorRecord(
new PSNotImplementedException("Proxy and ProxyCredential are not yet implemented. Please rerun cmdlet with other parameters."),
"ParametersNotImplementedYet",
ErrorCategory.NotImplemented,
this));
}
try
{
RepositorySettings.CheckRepositoryStore();
}
catch (PSInvalidOperationException e)
{
ThrowTerminatingError(new ErrorRecord(
new PSInvalidOperationException(e.Message),
"RepositoryStoreException",
ErrorCategory.ReadError,
this));
}
}
public void RepositoryPathDefaultsToPackagesDirectoryIfConfigFileHasEmptyOrNullRepositoryPath()
{
// Arrange
var solutionManager = new Mock <ISolutionManager>();
solutionManager.Setup(m => m.SolutionDirectory).Returns(@"bar\baz");
var fileSystem = new MockFileSystem();
fileSystem.AddFile(@"bar\nuget.config", @"
<settings>
<repositoryPath></repositoryPath>
</settings>");
solutionManager.Setup(m => m.SolutionDirectory).Returns(@"bar\baz");
var fileSystemProvider = new Mock <IFileSystemProvider>();
fileSystemProvider.Setup(m => m.GetFileSystem(@"bar\baz")).Returns(fileSystem);
var repositorySettings = new RepositorySettings(solutionManager.Object, fileSystemProvider.Object, new Mock <IVsSourceControlTracker>().Object);
// Act
string path = repositorySettings.RepositoryPath;
// Assert
Assert.Equal(@"bar\baz\packages", path);
}
public new (bool Valid, string FilePath) ValidateFilePath(string filePath, RepositorySettings repositorySettings)
{
return(base.ValidateFilePath(filePath, repositorySettings));
}
protected override void BeginProcessing()
{
RepositorySettings.CheckRepositoryStore();
}
// This method calls iterates through repositories (by priority order) to search for the pkgs to install
private List <PSResourceInfo> ProcessRepositories(
string[] repository,
bool trustRepository,
PSCredential credential,
bool skipDependencyCheck)
{
var listOfRepositories = RepositorySettings.Read(repository, out string[] _);
var yesToAll = false;
var noToAll = false;
var findHelper = new FindHelper(_cancellationToken, _cmdletPassedIn);
List <PSResourceInfo> allPkgsInstalled = new List <PSResourceInfo>();
foreach (var repo in listOfRepositories)
{
// If no more packages to install, then return
if (!_pkgNamesToInstall.Any())
{
return(allPkgsInstalled);
}
string repoName = repo.Name;
_cmdletPassedIn.WriteVerbose(string.Format("Attempting to search for packages in '{0}'", repoName));
// Source is only trusted if it's set at the repository level to be trusted, -TrustRepository flag is true, -Force flag is true
// OR the user issues trust interactively via console.
var sourceTrusted = true;
if (repo.Trusted == false && !trustRepository && !_force)
{
_cmdletPassedIn.WriteVerbose("Checking if untrusted repository should be used");
if (!(yesToAll || noToAll))
{
// Prompt for installation of package from untrusted repository
var message = string.Format(CultureInfo.InvariantCulture, MsgInstallUntrustedPackage, repoName);
sourceTrusted = _cmdletPassedIn.ShouldContinue(message, MsgRepositoryNotTrusted, true, ref yesToAll, ref noToAll);
}
}
if (!sourceTrusted && !yesToAll)
{
continue;
}
_cmdletPassedIn.WriteVerbose("Untrusted repository accepted as trusted source.");
// If it can't find the pkg in one repository, it'll look for it in the next repo in the list
var isLocalRepo = repo.Url.AbsoluteUri.StartsWith(Uri.UriSchemeFile + Uri.SchemeDelimiter, StringComparison.OrdinalIgnoreCase);
// Finds parent packages and dependencies
IEnumerable <PSResourceInfo> pkgsFromRepoToInstall = findHelper.FindByResourceName(
name: _pkgNamesToInstall.ToArray(),
type: ResourceType.None,
version: _versionRange != null ? _versionRange.OriginalString : null,
prerelease: _prerelease,
tag: null,
repository: new string[] { repoName },
credential: credential,
includeDependencies: !skipDependencyCheck);
if (!pkgsFromRepoToInstall.Any())
{
_cmdletPassedIn.WriteVerbose(string.Format("None of the specified resources were found in the '{0}' repository.", repoName));
// Check in the next repository
continue;
}
// Select the first package from each name group, which is guaranteed to be the latest version.
// We should only have one version returned for each package name
// e.g.:
// PackageA (version 1.0)
// PackageB (version 2.0)
// PackageC (version 1.0)
pkgsFromRepoToInstall = pkgsFromRepoToInstall.GroupBy(
m => new { m.Name }).Select(
group => group.First()).ToList();
// Check to see if the pkgs (including dependencies) are already installed (ie the pkg is installed and the version satisfies the version range provided via param)
if (!_reinstall)
{
pkgsFromRepoToInstall = FilterByInstalledPkgs(pkgsFromRepoToInstall);
}
if (!pkgsFromRepoToInstall.Any())
{
continue;
}
List <PSResourceInfo> pkgsInstalled = InstallPackage(
pkgsFromRepoToInstall,
repo.Url.AbsoluteUri,
credential,
isLocalRepo);
foreach (PSResourceInfo pkg in pkgsInstalled)
{
_pkgNamesToInstall.RemoveAll(x => x.Equals(pkg.Name, StringComparison.InvariantCultureIgnoreCase));
}
allPkgsInstalled.AddRange(pkgsInstalled);
}
// At this only package names left were those which could not be found in registered repositories
foreach (string pkgName in _pkgNamesToInstall)
{
var message = String.Format("Package '{0}' with requested version range {1} could not be installed as it was not found in any registered repositories",
pkgName,
_versionRange.ToString());
var ex = new ArgumentException(message);
var ResourceNotFoundError = new ErrorRecord(ex, "ResourceNotFoundError", ErrorCategory.ObjectNotFound, null);
_cmdletPassedIn.WriteError(ResourceNotFoundError);
}
return(allPkgsInstalled);
}
public void Initialise(RepositorySettings settings, ILogger logger)
{
Settings = settings;
Logger = logger ?? new BasicLogger();
}
public void Initialise(RepositorySettings settings) => throw new NotImplementedException();
public void OnlyConfigPathIsCachedNotRepositoryPath()
{
// Arrange
var solutionManager = new Mock<ISolutionManager>();
solutionManager.Setup(m => m.SolutionDirectory).Returns(@"bar\baz");
var fileSystem = new MockFileSystem();
fileSystem.AddFile(@"bar\nuget.config", @"
<settings>
<repositoryPath>lib</repositoryPath>
</settings>");
var fileSystemProvider = new Mock<IFileSystemProvider>();
fileSystemProvider.Setup(m => m.GetFileSystem(@"bar\baz\.nuget")).Returns(fileSystem);
var repositorySettings = new RepositorySettings(solutionManager.Object, fileSystemProvider.Object, new Mock<IVsSourceControlTracker>().Object);
// Act
string p1 = repositorySettings.RepositoryPath;
fileSystem.AddFile(@"bar\nuget.config", @"
<settings>
<repositoryPath>..\..\lib</repositoryPath>
</settings>");
string p2 = repositorySettings.RepositoryPath;
// Assert
Assert.Equal(@"bar\lib", p1);
Assert.Equal(@"bar\..\..\lib", p2);
}
public RepositoryFile(string filePath, RepositorySettings repo, VBProject project)
{
FilePath = filePath;
Repository = repo;
Project = project;
}
/// <summary>
/// Gets or creates an instance of the requested interface. Once a
/// repository is created and initialized, it is cached, and all
/// future requests for the repository will come from the cache.
/// </summary>
/// <typeparam name="TRepository">The interface of the repository
/// to create.</typeparam>
/// <typeparam name="TEntity">The type of the Entity that the
/// repository is for.</typeparam>
/// <param name="unitOfWork">The unit of work that the repository
/// will be participating in.</param>
/// <returns>An instance of the interface requested.</returns>
public static TRepository GetRepository <TRepository, TEntity>(IUnitOfWork unitOfWork)
where TRepository : class, IRepository <TEntity>
where TEntity : IAggregateRoot
{
// Initialize the provider's default value
TRepository repository = default(TRepository);
string interfaceShortName = typeof(TRepository).Name;
// See if the provider was already created and is in the cache
if (!RepositoryFactory.repositories.ContainsKey(interfaceShortName))
{
// Not there, so create it
// Get the repositoryMappingsConfiguration config section
RepositorySettings settings = (RepositorySettings)ConfigurationManager.GetSection(RepositoryMappingConstants.RepositoryMappingsConfigurationSectionName);
// Get the type to be created
Type repositoryType = null;
// See if a valid interfaceShortName was passed in
if (settings.RepositoryMappings.ContainsKey(interfaceShortName))
{
repositoryType = Type.GetType(settings.RepositoryMappings[interfaceShortName].RepositoryFullTypeName);
}
else
{
// It was not, but that's ok. Now check to see if any of the
// interface short names contain the name of the Entity. If they
// do, then use the matching one to get the right Repository
// Mapping Element
string entityTypeName = typeof(TEntity).Name;
foreach (RepositoryMappingElement element in settings.RepositoryMappings)
{
if (element.InterfaceShortTypeName.Contains(entityTypeName))
{
repositoryType = Type.GetType(settings.RepositoryMappings[element.InterfaceShortTypeName].RepositoryFullTypeName);
break;
}
}
}
// Throw an exception if the right Repository
// Mapping Element could not be found and the resulting
// Repository Type could not be created
if (repositoryType == null)
{
throw new ArgumentNullException("Cannot create the Repository. There was one or more invalid repositoryMapping configuration settings.");
}
// See if an IUnitOfWork needs to be injected to the repository's constructor
object[] constructorArgs = null;
// Check if an IUnitOfWork was passed in and if the repository
// type to be created derives from RepositoryBase<T>
if (unitOfWork != null &&
repositoryType.IsSubclassOf(typeof(RepositoryBase <TEntity>)))
{
constructorArgs = new object[] { unitOfWork };
}
// Create the repository, and cast it to the interface specified
repository = Activator.CreateInstance(repositoryType, constructorArgs) as TRepository;
// Add the new provider instance to the cache
RepositoryFactory.repositories.Add(interfaceShortName, repository);
}
else
{
// The provider was in the cache, so retrieve it
repository = (TRepository)RepositoryFactory.repositories[interfaceShortName];
if (unitOfWork != null &&
repository.GetType().IsSubclassOf(typeof(RepositoryBase <TEntity>)))
{
repository.SetUnitOfWork(unitOfWork);
}
}
return(repository);
}
/// <inheritdoc />
public override async Task <IReadOnlyCollection <RevInfoTestMerge> > RemoveMergedTestMerges(
IRepository repository,
RepositorySettings repositorySettings,
RevisionInformation revisionInformation,
CancellationToken cancellationToken)
{
if (repository == null)
{
throw new ArgumentNullException(nameof(repository));
}
if (repositorySettings == null)
{
throw new ArgumentNullException(nameof(repositorySettings));
}
if (revisionInformation == null)
{
throw new ArgumentNullException(nameof(revisionInformation));
}
if (revisionInformation.ActiveTestMerges?.Any() != true)
{
Logger.LogTrace("No test merges to remove.");
return(Array.Empty <RevInfoTestMerge>());
}
var client = repositorySettings.AccessToken != null
? new GitLabClient(GitLabRemoteFeatures.GitLabUrl, repositorySettings.AccessToken)
: new GitLabClient(GitLabRemoteFeatures.GitLabUrl);
var tasks = revisionInformation
.ActiveTestMerges
.Select(x => client
.MergeRequests
.GetAsync(
$"{repository.RemoteRepositoryOwner}/{repository.RemoteRepositoryName}",
x.TestMerge.Number)
.WithToken(cancellationToken));
try
{
await Task.WhenAll(tasks).ConfigureAwait(false);
}
catch (Exception ex) when(!(ex is OperationCanceledException))
{
Logger.LogWarning(ex, "Merge requests update check failed!");
}
var newList = revisionInformation.ActiveTestMerges.ToList();
MergeRequest lastMerged = null;
async Task CheckRemoveMR(Task <MergeRequest> task)
{
var mergeRequest = await task.ConfigureAwait(false);
if (mergeRequest.State != MergeRequestState.Merged)
{
return;
}
// We don't just assume, actually check the repo contains the merge commit.
if (await repository.ShaIsParent(mergeRequest.MergeCommitSha, cancellationToken).ConfigureAwait(false))
{
if (lastMerged == null || lastMerged.ClosedAt < mergeRequest.ClosedAt)
{
lastMerged = mergeRequest;
}
newList.Remove(
newList.First(
potential => potential.TestMerge.Number == mergeRequest.Id));
}
}
foreach (var prTask in tasks)
{
await CheckRemoveMR(prTask).ConfigureAwait(false);
}
return(newList);
}
public void ConfigurationCacheIsClearedIfSolutionCloses()
{
// Arrange
var solutionManager = new Mock<MockSolutionManager>();
solutionManager.Setup(m => m.SolutionDirectory).Returns(@"bar\baz");
var fileSystem = new MockFileSystem();
fileSystem.AddFile(@"bar\nuget.config", @"
<settings>
<repositoryPath>lib</repositoryPath>
</settings>");
var fileSystemProvider = new Mock<IFileSystemProvider>();
fileSystemProvider.Setup(m => m.GetFileSystem(@"bar\baz\.nuget", It.IsAny<bool>())).Returns(fileSystem);
var repositorySettings = new RepositorySettings(solutionManager.Object, fileSystemProvider.Object, new Mock<IVsSourceControlTracker>().Object);
// Act
string p1 = repositorySettings.RepositoryPath;
solutionManager.Object.CloseSolution();
fileSystem.AddFile(@"bar\baz\nuget.config", @"
<settings>
<repositoryPath>foo</repositoryPath>
</settings>");
string p2 = repositorySettings.RepositoryPath;
// Assert
Assert.Equal(@"bar\lib", p1);
Assert.Equal(@"bar\baz\foo", p2);
}
public void RepositoryPathMalformedConfigThrows()
{
// Arrange
var solutionManager = new Mock<ISolutionManager>();
solutionManager.Setup(m => m.SolutionDirectory).Returns(@"bar\baz");
var fileSystem = new MockFileSystem();
fileSystem.AddFile(@"bar\nuget.config", @"
<settings>
<repositoryPath
</settings>");
var fileSystemProvider = new Mock<IFileSystemProvider>();
fileSystemProvider.Setup(m => m.GetFileSystem(@"bar\baz\.nuget")).Returns(fileSystem);
var repositorySettings = new RepositorySettings(solutionManager.Object, fileSystemProvider.Object, new Mock<IVsSourceControlTracker>().Object);
// Act & Assert
ExceptionAssert.Throws<InvalidOperationException>(() => { string s = repositorySettings.RepositoryPath; }, @"Error reading 'bar\nuget.config'.");
}
public void ConfigFoundInDirectoryHierarchyIsCached()
{
// Arrange
var solutionManager = new Mock<ISolutionManager>();
solutionManager.Setup(m => m.SolutionDirectory).Returns(@"bar\baz");
var fileSystem = new MockFileSystem();
fileSystem.AddFile(@"bar\nuget.config", @"
<settings>
<repositoryPath>lib</repositoryPath>
</settings>");
var fileSystemProvider = new Mock<IFileSystemProvider>();
fileSystemProvider.Setup(m => m.GetFileSystem(@"bar\baz")).Returns(fileSystem);
var repositorySettings = new RepositorySettings(solutionManager.Object, fileSystemProvider.Object);
// Act
string p1 = repositorySettings.RepositoryPath;
fileSystem.AddFile(@"bar\baz\nuget.config", @"
<settings>
<repositoryPath>foo</repositoryPath>
</settings>");
string p2 = repositorySettings.RepositoryPath;
// Assert
Assert.Equal(@"bar\lib", p1);
Assert.Equal(@"bar\lib", p2);
}
public void GetValueFromMachineWideSettings()
{
// Arrange
var solutionManager = new Mock<MockSolutionManager>();
solutionManager.Setup(m => m.SolutionDirectory).Returns(@"bar\baz");
var fileSystem = new MockFileSystem();
var fileSystemProvider = new Mock<IFileSystemProvider>();
fileSystemProvider.Setup(m => m.GetFileSystem(@"bar\baz\.nuget")).Returns(fileSystem);
var sourceControlTracker = new Mock<IVsSourceControlTracker>();
fileSystem.AddFile(@"a.config", @"
<configuration>
<config>
<add key=""repositorypath"" value=""c:\path"" />
</config>
</configuration>");
var settings = new Settings[] {
new Settings(fileSystem, "a.config")
};
var machineWideSettings = new Mock<IMachineWideSettings>();
machineWideSettings.SetupGet(m => m.Settings).Returns(settings);
var repositorySettings = new RepositorySettings(solutionManager.Object, fileSystemProvider.Object, sourceControlTracker.Object, machineWideSettings.Object);
// Act
var repositoryPath = repositorySettings.RepositoryPath;
// Assert
Assert.Equal(@"c:\path", repositoryPath);
}
public void ConfigurationCacheIsClearedIfSourceControlBindingChanges()
{
// Arrange
var solutionManager = new Mock<MockSolutionManager>();
solutionManager.Setup(m => m.SolutionDirectory).Returns(@"bar\baz");
var fileSystem = new MockFileSystem();
fileSystem.AddFile(@"bar\nuget.config", @"
<settings>
<repositoryPath>lib</repositoryPath>
</settings>");
var fileSystemProvider = new Mock<IFileSystemProvider>();
fileSystemProvider.Setup(m => m.GetFileSystem(@"bar\baz\.nuget")).Returns(fileSystem);
var sourceControlTracker = new Mock<IVsSourceControlTracker>();
var repositorySettings = new RepositorySettings(solutionManager.Object, fileSystemProvider.Object, sourceControlTracker.Object);
// Act
string p1 = repositorySettings.RepositoryPath;
sourceControlTracker.Raise(p => p.SolutionBoundToSourceControl += (o, e) => { }, EventArgs.Empty);
fileSystem.AddFile(@"bar\baz\nuget.config", @"
<settings>
<repositoryPath>foo</repositoryPath>
</settings>");
string p2 = repositorySettings.RepositoryPath;
// Assert
Assert.Equal(@"bar\lib", p1);
Assert.Equal(@"bar\baz\foo", p2);
}
public new bool CheckIfFileIsInRepository(string filePath, RepositorySettings repositorySettings)
{
return(base.CheckIfFileIsInRepository(filePath, repositorySettings));
}
protected override async Task <EventHandlerResult> execute(CreateEventPayload webhookPayload, RepositorySettings repoSettings)
{
if (!webhookPayload.RefType.StringValue.Equals("branch", StringComparison.OrdinalIgnoreCase))
{
return(EventHandlerResult.NoActionNeeded($"create event for ref {webhookPayload.RefType} is not of interrest"));
}
if (repoSettings.BranchProtection == null || !repoSettings.BranchProtection.Enabled)
{
return(EventHandlerResult.Disabled());
}
await GitHubClient.Repository.Branch.UpdateBranchProtection(
webhookPayload.Repository.Id, webhookPayload.Ref, getBranchProtectionSettingsUpdate(webhookPayload.Ref, webhookPayload.Repository.DefaultBranch));
return(EventHandlerResult.ActionPerformed("branch protection rule applied"));
}
public new string MakeFilePathRelativeToRepositoryRoot(string filePath, RepositorySettings repositorySettings)
{
return(base.MakeFilePathRelativeToRepositoryRoot(filePath, repositorySettings));
}
public void RepositoryPathAtSolutionRootFolderIsConsideredBeforeParentFolder()
{
// Arrange
var solutionManager = new Mock<ISolutionManager>();
solutionManager.Setup(m => m.SolutionDirectory).Returns(@"bar\baz");
var fileSystem = new MockFileSystem();
fileSystem.AddFile(@"bar\nuget.config", @"
<configuration>
<repositoryPath>lib</repositoryPath>
</configuration>");
fileSystem.AddFile(@"bar\baz\nuget.config", @"
<configuration>
<repositoryPath>x:\demo</repositoryPath>
</configuration>");
var fileSystemProvider = new Mock<IFileSystemProvider>();
fileSystemProvider.Setup(m => m.GetFileSystem(@"bar\baz\.nuget")).Returns(fileSystem);
var repositorySettings = new RepositorySettings(solutionManager.Object, fileSystemProvider.Object, new Mock<IVsSourceControlTracker>().Object);
// Act
string p = repositorySettings.RepositoryPath;
// Assert
Assert.Equal(@"x:\demo", p);
}
