public void ReplaceTokens_Invalid(string[] tokens, string[] replacements)
{
Assert.Throws <ArgumentException>(() =>
{
var result = DWPSUtils.ReplaceTokens("this is a test", tokens, replacements);
});
}
public RepoPaths GetRepoPaths(string currentPath, bool noCache)
{
if (string.IsNullOrWhiteSpace(currentPath))
{
throw new ArgumentException("Current path cannot be empty");
}
var fixedCurPath = DWPSUtils.ForceTrailingSlash(currentPath);
var refCurPath = "REF" + fixedCurPath;
RepoPaths result = null;
if (!noCache)
{
result = RepoCache.Get <RepoPaths>(refCurPath);
}
if (result == null)
{
result = BuildRepoPaths(currentPath);
RepoCache.Add(refCurPath, result, new TimeSpan(0, 10, 0), true);
}
result.IgnoreCache = noCache;
return(result);
}
public void GetResourceNames_Tests()
{
var names = DWPSUtils.GetEmbeddedResourceNames(_assembly);
_assembly.Received(1).GetManifestResourceNames();
CollectionAssert.AreEqual(_resourceNames, names);
}
protected List <string> ResolveLinkedFiles(Dictionary <string, string> tokens)
{
var result = new List <string>();
if (this.CacheLinkFiles != null && this.CacheLinkFiles.Length > 0)
{
foreach (var linkFile in this.CacheLinkFiles)
{
var cacheLinkFile = linkFile.Replace("/", "\\");
foreach (var token in tokens)
{
if (cacheLinkFile.IndexOf(token.Key, StringComparison.InvariantCulture) >= 0)
{
cacheLinkFile = cacheLinkFile.Replace(token.Key, token.Value);
}
var linkFilePath = DWPSUtils.IsFullPath(cacheLinkFile)
? cacheLinkFile
: _diskManager.Path.Combine(this.RepositoryDirectories.RepositoryFolder, cacheLinkFile);
result.Add(linkFilePath);
}
}
}
return(result);
}
/// <summary>
/// replaces characters that git allows (i.e. double quotes) with Windows equivalents where possible.
/// </summary>
/// <param name="path">the path to check</param>
/// <returns>a valid Windows-safe version of the file path</returns>
public string FixInvalidFileNameCharsInPath(string path)
{
var findChars = new string[] { "\"" }; // just double quotes for now but I suspect the list will grow over time
var replaceChars = new string[] { "" };
return(DWPSUtils.ReplaceTokens(path, findChars, replaceChars, false));
}
public void GetFullPath_Existing_matches(string testValue, string expectedValue)
{
string basePath = "J:\\junk\\path";
var result = DWPSUtils.GetFullPath(basePath, testValue);
Assert.AreEqual(expectedValue, result);
}
public void ForceTrailingSlash_Invalid(string compare)
{
Assert.Throws <ArgumentNullException>(() =>
{
var result = DWPSUtils.ForceTrailingSlash(compare);
});
}
public void Bad_Command_Tests(string command)
{
Assert.Throws <ArgumentException>(() =>
{
DWPSUtils.ExecuteCommandSync(_diskManager, _processManager, command, "somePath");
});
}
public string GetPathToRepository(string currentPath)
{
if (string.IsNullOrWhiteSpace(currentPath))
{
return(null);
}
var curDir = _diskManager.NewDirectoryInfo(currentPath);
if (curDir == null)
{
return(null);
}
while (curDir != null)
{
var path = _diskManager.Path.Combine(curDir.FullName, ".git");
if (_diskManager.Directory.Exists(path))
{
return(DWPSUtils.ForceTrailingSlash(curDir.FullName));
}
curDir = curDir.Parent;
}
return(null);
}
internal RepoPaths BuildRepoPaths(string currentPath)
{
var fixedCurPath = DWPSUtils.ForceTrailingSlash(currentPath);
var result = new RepoPaths {
CurrentPath = fixedCurPath
};
var repoPath = GetPathToRepository(currentPath);
if (!String.IsNullOrWhiteSpace(repoPath))
{
result.RootFolder = DWPSUtils.ForceTrailingSlash(repoPath);
result.RepositoryFolder = DWPSUtils.ForceTrailingSlash(_diskManager.Path.Combine(result.RootFolder, ".git"));
result.RelativePathToRoot = DWPSUtils.BuildRelativePath(currentPath, result.RootFolder);
result.RelativePathToRepository = DWPSUtils.BuildRelativePath(currentPath, result.RepositoryFolder);
}
var refPath = result.RootFolder ?? result.CurrentPath;
var cache = RepoCache.Get <ICommandCache>(refPath);
if (cache == null)
{
cache = new CommandCache();
RepoCache.Add(refPath, cache);
}
result.Cache = cache;
return(result);
}
protected void Init(IStaticAbstraction diskManager, string defaultColorFile, string customColorFile)
{
_diskManager = diskManager ?? new StAbWrapper();
var defColorFile = string.IsNullOrWhiteSpace(defaultColorFile) ? _defaultColorFileName : defaultColorFile;
var custColorFile = string.IsNullOrWhiteSpace(customColorFile) ? _defaultCustomColorFileName : customColorFile;
var path = _diskManager.NewFileInfo(_diskManager.Assembly.GetCallingAssembly().Location).DirectoryName;
var testPath = DWPSUtils.IsFullPath(defColorFile) ? defColorFile : _diskManager.Path.Combine(path, defColorFile);
if (_diskManager.File.Exists(testPath))
{
_defaultColorFilePath = testPath;
}
else
{
testPath = _diskManager.Path.Combine(path, "psscripts", defColorFile);
if (_diskManager.File.Exists(testPath))
{
_defaultColorFilePath = testPath;
}
}
_customColorFilePath = DWPSUtils.IsFullPath(custColorFile) ? custColorFile : _diskManager.Path.Combine(path, custColorFile);
RefreshColors();
}
public static void TagRepoDir(string name, string path)
{
if (string.IsNullOrWhiteSpace(name) || string.IsNullOrWhiteSpace(path))
{
return;
}
if (_gitDirs.ContainsKey(name) &&
string.Compare(_gitDirs[name], path, StringComparison.InvariantCultureIgnoreCase) == 0)
{
return;
}
if (!_diskManager.Directory.Exists(_infoDir))
{
_diskManager.Directory.CreateDirectory(_infoDir);
}
var fileName = _diskManager.Path.Combine(_infoDir, DWPSUtils.MakeFileSystemSafe(name + ".repo"));
if (_diskManager.File.Exists(fileName))
{
var touchInfo = _diskManager.NewFileInfo(fileName);
touchInfo.LastAccessTimeUtc = DateTime.UtcNow;
return;
}
_diskManager.File.WriteAllText(fileName, path);
_gitDirs.Add(name, path);
}
public void Valid_Happy_Path_Tests()
{
var expectedCommand = "SomeAppName";
DWPSUtils.ExecuteCommandSync(_diskManager, _processManager, expectedCommand, null);
_processManager.Received(1).Execute(Arg.Any <string>(), "/c " + expectedCommand, Arg.Any <int>());
}
public void GetEmbeddedResource_valid_fullnames_Tests()
{
for (var i = 0; i < _resourceNames.Length; i++)
{
var res = DWPSUtils.GetEmbeddedResource(_assembly, _resourceNames[i]);
Assert.AreEqual(_resourceData[i], res);
}
}
public void GetEmbeddedResource_valid_partialnames_Tests(int lengthOfPartial)
{
for (var i = 0; i < _resourceNames.Length; i++)
{
var last5 = _resourceNames[i].Substring(_resourceNames[i].Length - lengthOfPartial);
var res = DWPSUtils.GetEmbeddedResource(_assembly, last5);
Assert.AreEqual(_resourceData[i], res);
}
}
public void Bad_Path_Tests()
{
var badPath = "f:\\bad\\path";
_diskManager.Directory.Exists(badPath).Returns(false);
Assert.Throws <DirectoryNotFoundException>(() =>
{
DWPSUtils.ExecuteCommandSync(_diskManager, _processManager, "filler", badPath);
});
}
public void Bad_Parameter_Tests()
{
Assert.Throws <ArgumentNullException>(() =>
{
DWPSUtils.ExecuteCommandSync(_diskManager, null, "filler", "somePath");
});
Assert.Throws <ArgumentNullException>(() =>
{
DWPSUtils.ExecuteCommandSync(null, _processManager, "filler", "somePath");
});
}
public void ReplaceTokens_SingleCharacterKeepDuplicates()
{
var sourceText = "||1|2|||3|";
var tokens = new string[] { "|" };
var replaceWith = new string[] { "_" };
var expected = "__1_2___3_";
var result = DWPSUtils.ReplaceTokens(sourceText, tokens, replaceWith, false);
Assert.AreEqual(result, expected);
}
public void ReplaceTokens_RemovingCharacters()
{
var sourceText = "The red fox swam through red water to paint the deck red";
var tokens = new string[] { " ", "i", "o" };
var replaceWith = new string[] { "_", "", "" };
var expected = "The_red_fx_swam_thrugh_red_water_t_pant_the_deck_red";
var result = DWPSUtils.ReplaceTokens(sourceText, tokens, replaceWith, true);
Assert.AreEqual(result, expected);
}
public void ReplaceTokens_ReplaceContainsToken()
{
var sourceText = "The red fox swam through red water to paint the deck red";
var tokens = new string[] { " ", "i", "o" };
var replaceWith = new string[] { "\\ /", "dig", "OO" };
var expected = "The\\ /red\\ /fOOx\\ /swam\\ /thrOOugh\\ /red\\ /water\\ /tOO\\ /padignt\\ /the\\ /deck\\ /red";
var result = DWPSUtils.ReplaceTokens(sourceText, tokens, replaceWith, true);
Assert.AreEqual(result, expected);
}
public void ReplaceTokens_SingleCharacter()
{
var sourceText = "PURpleThe pUrple fox swam through purplePURPLE water to paint the deck puRple";
var tokens = new string[] { "purple" };
var replaceWith = new string[] { "red" };
var expected = "redThe red fox swam through red water to paint the deck red";
var result = DWPSUtils.ReplaceTokens(sourceText, tokens, replaceWith, true);
Assert.AreEqual(result, expected);
}
protected virtual string BuildCacheName()
{
var cacheName = this.CacheName;
if (this.CommandExecFolder != null)
{
cacheName += $"_{DWPSUtils.MakeFileSystemSafe(this.CommandExecFolder)}";
}
return(cacheName);
}
public void ReplaceTokens_Basic()
{
var source = " This is a Test! ";
var tokens = new string[] { " " };
var reptokens = new string[] { "_" };
var result = DWPSUtils.ReplaceTokens(source, tokens, reptokens);
Assert.IsTrue(result == source.Replace(" ", "_"));
result = DWPSUtils.ReplaceTokens(source, tokens, reptokens, true);
Assert.AreEqual("_This_is_a_Test!_", result);
}
public void GetDirectoryPath_existingFolder(string folder, string expected)
{
_diskManager.File.Exists(Arg.Any <string>()).Returns(false);
_diskManager.Directory.Exists(folder).Returns(true);
var info = Substitute.For <IDirectoryInfo>();
info.FullName.Returns(folder);
_diskManager.NewDirectoryInfo(folder).Returns(info);
var result = DWPSUtils.GetDirectoryPath(folder);
Assert.AreEqual(result, expected);
}
public void GetDirectoryPath_existingFile(string folder, string fileName, string expected)
{
var filePath = folder.Trim('\\') + "\\" + fileName;
_diskManager.File.Exists(filePath).Returns(true);
var info = Substitute.For <IFileInfo>();
info.DirectoryName.Returns(folder);
_diskManager.NewFileInfo(filePath).Returns(info);
var result = DWPSUtils.GetDirectoryPath(filePath);
Assert.AreEqual(result, expected);
}
public virtual TResult GetCommandResults(bool skipCache = false)
{
if (RepositoryDirectories == null)
{
return(null);
}
if (string.IsNullOrWhiteSpace(RepositoryDirectories.RootFolder))
{
return(null);
}
if (string.IsNullOrWhiteSpace(this.Command))
{
return(null);
}
var cacheName = BuildCacheName();
var useCache = this.UseCache;
if (skipCache || RepositoryDirectories.IgnoreCache || string.IsNullOrWhiteSpace(this.CacheName))
{
useCache = false;
}
TResult resultOut = default(TResult);
if (useCache)
{
resultOut = RepositoryDirectories.Cache.Get <TResult>(cacheName);
}
this.CommandOutput = null;
if (resultOut == default(TResult) || !useCache)
{
var execFolder = this.CommandExecFolder ?? RepositoryDirectories.RootFolder;
var writer = new ConsoleWriter();
var barColor = _colorGroups.GetColor("commandExecBar");
writer.WriteHeader(this.Command, barColor.Foreground, barColor.Background, ConsoleTextPosition.Center);
var result = DWPSUtils.ExecuteCommandSync(_diskManager, _processManager, this.Command, execFolder);
writer.ResetConsole();
resultOut = this.Parser.Parse(result.Output);
AddItemToCache(RepositoryDirectories, cacheName, resultOut);
this.CommandOutput = result.Output;
}
return(resultOut);
}
public void Valid_Change_app_dir_Tests()
{
var currentFolder = "C:\\current\\folder\\here";
var appFolder = "C:\\app\\folder\\there";
_diskManager.Directory.Exists(appFolder).Returns(true);
_diskManager.Directory.GetCurrentDirectory().Returns(currentFolder);
DWPSUtils.ExecuteCommandSync(_diskManager, _processManager, "filler", appFolder);
_diskManager.Directory.Received(1).Exists(appFolder);
_diskManager.Directory.Received(1).GetCurrentDirectory();
_diskManager.Directory.Received(1).SetCurrentDirectory(appFolder);
_diskManager.Directory.Received(1).SetCurrentDirectory(currentFolder);
}
public void GetAssemblyFolder_Path(string path, string expected)
{
var asm = Substitute.For <IAssemblyInstance>();
asm.Location.Returns($"{path.Trim('\\')}\\Library.dll");
var info = Substitute.For <IFileInfo>();
info.DirectoryName.Returns(path);
_diskManager.NewFileInfo(Arg.Any <string>()).Returns(info);
var result = DWPSUtils.GetAssemblyFolder(asm);
Assert.AreEqual(result, expected);
}
public void GetFullPath_whitespace_path_matches_basePath(string basePath, string fileName, string expectedValue)
{
var combined = string.IsNullOrWhiteSpace(fileName) ? basePath : new StAbWrapper().Path.Combine(basePath, fileName);
_diskManager.Path.Combine(basePath, fileName).Returns(combined);
var info = new MockFileInfo {
FullName = combined
};
_diskManager.NewFileInfo(combined).Returns(info);
var result = DWPSUtils.GetFullPath(basePath, fileName);
Assert.AreEqual(expectedValue, result);
_diskManager.Path.Received(0).Combine(Arg.Any <string>(), Arg.Any <string>());
_diskManager.Received(0).NewFileInfo(Arg.Any <string>());
}
public void GetDirectoryPath_itemNotFound(string value)
{
_diskManager.File.Exists(Arg.Any <string>()).Returns(false);
_diskManager.Directory.Exists(Arg.Any <string>()).Returns(false);
var ex = Assert.Throws <ApplicationException>(() => { DWPSUtils.GetDirectoryPath(value); });
Assert.IsNotNull(ex?.Message);
if (value == "")
{
Assert.IsTrue(ex.Message.IndexOf("''") > 0);
}
else
{
Assert.IsTrue(ex.Message.IndexOf(value) > 0);
}
}
