public void SaveTest()
{
var key = new Mock <IRegistryKey>();
var subkey = new Mock <IRegistryKey>();
key.Setup(k => k.CreateSubKey(It.IsAny <string>())).Returns(subkey.Object);
var package = new Mock <IReAttachPackage>();
package.Setup(p => p.OpenUserRegistryRoot()).Returns(key.Object);
var repository = new ReAttachRegistryRepository(package.Object);
var targets = new ReAttachTargetList(ReAttachConstants.ReAttachHistorySize);
for (var i = 1; i <= 3; i++)
{
targets.AddFirst(new ReAttachTarget(i, "path" + i, "user" + i));
}
Assert.IsTrue(repository.SaveTargets(targets));
key.Verify(k => k.CreateSubKey(It.IsAny <string>()), Times.Once());
for (var i = 1; i <= 3; i++)
{
subkey.Verify(k => k.SetValue(
ReAttachConstants.ReAttachRegistryHistoryKeyPrefix + i,
It.IsAny <string>()), Times.Once());
}
subkey.Verify(k => k.Close(), Times.Once());
}
public void SaveErrorTest()
{
var key = new Mock <IRegistryKey>(MockBehavior.Strict);
var subkey = new Mock <IRegistryKey>(MockBehavior.Strict);
key.Setup(k => k.CreateSubKey(It.IsAny <string>())).Returns(subkey.Object);
subkey.Setup(k => k.SetValue(It.IsAny <string>(), It.IsAny <string>())).Throws
(new SecurityException("Simulating no access when setting value. :)"));
subkey.Setup(k => k.DeleteValue(It.IsAny <string>(), It.IsAny <bool>())).Throws
(new SecurityException("Simulating no access when deleting value. :)"));
var package = new Mock <IReAttachPackage>();
package.Setup(p => p.OpenUserRegistryRoot()).Returns(key.Object);
package.Setup(p => p.Reporter).Returns(new ReAttachTraceReporter());
var repository = new ReAttachRegistryRepository(package.Object);
var targets = new ReAttachTargetList(ReAttachConstants.ReAttachHistorySize);
Assert.IsFalse(repository.SaveTargets(targets));
for (var i = 1; i <= 3; i++)
{
targets.AddFirst(new ReAttachTarget(i, "path" + i, "user" + i));
}
Assert.IsFalse(repository.SaveTargets(targets));
}
// TODO: Locking on save/loads might be relevant. Ref-switching will do for now.
public bool Load()
{
var items = _repository.LoadTargets();
if (items == null)
return false;
Items = items;
return true;
}
// TODO: Locking on save/loads might be relevant. Ref-switching will do for now.
public bool Load()
{
var items = _repository.LoadTargets();
if (items == null)
{
return(false);
}
Items = items;
return(true);
}
public void MaxItemsTest()
{
var list = new ReAttachTargetList(5);
for (var i = 1; i <= 10; i++)
{
list.AddFirst(new ReAttachTarget(i, "path" + i, "user" + i));
}
Assert.AreEqual(5, list.Count);
Assert.AreEqual(10, list[0].ProcessId);
Assert.AreEqual(6, list[4].ProcessId);
}
public void AddExistingElementLastTest()
{
var list = new ReAttachTargetList(5);
for (var i = 1; i <= 4; i++)
list.AddLast(new ReAttachTarget(i, "path" + i, "user" + i));
Assert.AreEqual(3, list[2].ProcessId);
Assert.AreEqual(4, list.Count);
list.AddLast(new ReAttachTarget(3, "path3", "user3"));
Assert.AreNotEqual(3, list[2].ProcessId);
Assert.AreEqual(3, list[3].ProcessId);
Assert.AreEqual(4, list.Count);
}
public void AddLastTest()
{
var list = new ReAttachTargetList(5);
for (var i = 1; i <= 3; i++)
list.AddLast(new ReAttachTarget(i, "path" + i, "user" + i));
Assert.AreEqual(3, list[2].ProcessId);
Assert.AreEqual(2, list[1].ProcessId);
for (var i = 4; i <= 5; i++)
list.AddLast(new ReAttachTarget(i, "path" + i, "user" + i));
Assert.AreEqual(5, list[4].ProcessId);
Assert.AreEqual(4, list[3].ProcessId);
}
public void ContainsTest()
{
var list = new ReAttachTargetList(5);
var indices = new[] {1, 2, 3, 4, 5};
for (var i = 1; i <= 5; i++)
list.AddLast(new ReAttachTarget(indices[i-1], "path" + i, "user" + i));
foreach (var index in indices)
{
Assert.AreEqual(index, list[index-1].ProcessId);
}
Assert.IsNull(list[123]);
}
public void ContainsTest()
{
var list = new ReAttachTargetList(5);
var indices = new[] { 1, 2, 3, 4, 5 };
for (var i = 1; i <= 5; i++)
{
list.AddLast(new ReAttachTarget(indices[i - 1], "path" + i, "user" + i));
}
foreach (var index in indices)
{
Assert.AreEqual(index, list[index - 1].ProcessId);
}
Assert.IsNull(list[123]);
}
public void AddExistingElementLastTest()
{
var list = new ReAttachTargetList(5);
for (var i = 1; i <= 4; i++)
{
list.AddLast(new ReAttachTarget(i, "path" + i, "user" + i));
}
Assert.AreEqual(3, list[2].ProcessId);
Assert.AreEqual(4, list.Count);
list.AddLast(new ReAttachTarget(3, "path3", "user3"));
Assert.AreNotEqual(3, list[2].ProcessId);
Assert.AreEqual(3, list[3].ProcessId);
Assert.AreEqual(4, list.Count);
}
public void EmptySaveTest()
{
var key = new Mock<IRegistryKey>();
var subkey = new Mock<IRegistryKey>();
key.Setup(k => k.CreateSubKey(It.IsAny<string>())).Returns(subkey.Object);
var package = new Mock<IReAttachPackage>();
package.Setup(p => p.OpenUserRegistryRoot()).Returns(key.Object);
var repository = new ReAttachRegistryRepository(package.Object);
var targets = new ReAttachTargetList(ReAttachConstants.ReAttachHistorySize);
Assert.IsTrue(repository.SaveTargets(targets));
key.Verify(k => k.CreateSubKey(It.IsAny<string>()), Times.Once());
subkey.Verify(k => k.SetValue(It.IsAny<string>(), It.IsAny<string>()), Times.Never());
subkey.Verify(k => k.Close(), Times.Once());
}
public void AddLastTest()
{
var list = new ReAttachTargetList(5);
for (var i = 1; i <= 3; i++)
{
list.AddLast(new ReAttachTarget(i, "path" + i, "user" + i));
}
Assert.AreEqual(3, list[2].ProcessId);
Assert.AreEqual(2, list[1].ProcessId);
for (var i = 4; i <= 5; i++)
{
list.AddLast(new ReAttachTarget(i, "path" + i, "user" + i));
}
Assert.AreEqual(5, list[4].ProcessId);
Assert.AreEqual(4, list[3].ProcessId);
}
public ReAttachTargetList LoadTargets()
{
try
{
var root = _package.OpenUserRegistryRoot();
if (root == null)
{
_package.Reporter.ReportError("Unable to open user root registry key.");
return null;
}
var subkey = root.OpenSubKey(ReAttachConstants.ReAttachRegistryKeyName);
if (subkey == null)
{
_package.Reporter.ReportWarning(
"Unable to open ReAttach registry subkey. This might be the first time ReAttach is started.");
root.Close();
return null;
}
var targets = new ReAttachTargetList(ReAttachConstants.ReAttachHistorySize);
for (var i = 1; i < ReAttachConstants.ReAttachHistorySize; i++)
{
var value = subkey.GetValue(ReAttachConstants.ReAttachRegistryHistoryKeyPrefix + i) as string;
if (value == null)
continue;
var tokens = value.Split(new[] {ReAttachConstants.ReAttachRegistrySplitChar});
if (tokens.Length != 4)
continue;
int pid;
int.TryParse(tokens[2], out pid);
targets.AddLast(new ReAttachTarget(pid, tokens[0], tokens[1], tokens[3]));
}
subkey.Close();
root.Close();
return targets;
}
catch (Exception e)
{
_package.Reporter.ReportWarning(
"Unable to load history. This might be first time ReAttach is started. Exception: {0}", e.Message);
}
return null;
}
public ReAttachTargetList LoadTargets()
{
try
{
var root = _package.OpenUserRegistryRoot();
if (root == null)
{
_package.Reporter.ReportError("Unable to open user root registry key.");
return null;
}
var subkey = root.OpenSubKey(ReAttachConstants.ReAttachRegistryKeyName);
if (subkey == null)
{
_package.Reporter.ReportWarning(
"Unable to open ReAttach registry subkey. This might be the first time ReAttach is started.");
root.Close();
return null;
}
var targets = new ReAttachTargetList(ReAttachConstants.ReAttachHistorySize);
for (var i = 1; i < ReAttachConstants.ReAttachHistorySize; i++)
{
var json = subkey.GetValue(ReAttachConstants.ReAttachRegistryHistoryKeyPrefix + i) as string;
if (json == null)
continue;
try
{
var target = JsonConvert.DeserializeObject<ReAttachTarget>(json);
targets.AddLast(target);
} catch (Exception e) { /* Ignore broken elements */}
}
subkey.Close();
root.Close();
return targets;
}
catch (Exception e)
{
_package.Reporter.ReportWarning(
"Unable to load history. This might be first time ReAttach is started. Exception: {0}", e.Message);
}
return null;
}
public void EmptySaveTest()
{
var key = new Mock <IRegistryKey>();
var subkey = new Mock <IRegistryKey>();
key.Setup(k => k.CreateSubKey(It.IsAny <string>())).Returns(subkey.Object);
var package = new Mock <IReAttachPackage>();
package.Setup(p => p.OpenUserRegistryRoot()).Returns(key.Object);
var repository = new ReAttachRegistryRepository(package.Object);
var targets = new ReAttachTargetList(ReAttachConstants.ReAttachHistorySize);
Assert.IsTrue(repository.SaveTargets(targets));
key.Verify(k => k.CreateSubKey(It.IsAny <string>()), Times.Once());
subkey.Verify(k => k.SetValue(It.IsAny <string>(), It.IsAny <string>()), Times.Never());
subkey.Verify(k => k.Close(), Times.Once());
}
public ReAttachMocks(MockBehavior behavior = MockBehavior.Strict)
{
CreateMockDebugger(behavior);
CreateMockDTE(behavior);
CreateMockMenuCommandService(behavior);
MockReAttachReporter = new ReAttachTraceReporter(); // Use real reporting for simplicity.
MockReAttachUi = new Mock <IReAttachUi>(behavior);
MockReAttachHistory = new Mock <IReAttachHistory>(behavior);
MockReAttachHistoryItems = new ReAttachTargetList(ReAttachConstants.ReAttachHistorySize);
MockReAttachHistory.Setup(h => h.Items).Returns(MockReAttachHistoryItems);
MockReAttachDebugger = new Mock <IReAttachDebugger>(behavior);
// Wire up all services and modules.
MockReAttachPackage = new Mock <IReAttachPackage>(behavior);
MockReAttachPackage.Setup(p => p.GetService(typeof(IMenuCommandService))).Returns(MockMenuService.Object);
MockReAttachPackage.Setup(p => p.GetService(typeof(SVsShellDebugger))).Returns(MockDebugger.Object);
MockReAttachPackage.Setup(p => p.GetService(typeof(SDTE))).Returns(MockDTE.Object);
MockReAttachPackage.Setup(p => p.Reporter).Returns(MockReAttachReporter);
MockReAttachPackage.Setup(p => p.Ui).Returns(MockReAttachUi.Object);
MockReAttachPackage.Setup(p => p.History).Returns(MockReAttachHistory.Object);
MockReAttachPackage.Setup(p => p.Debugger).Returns(MockReAttachDebugger.Object);
}
public ReAttachMocks(MockBehavior behavior = MockBehavior.Strict)
{
CreateMockDebugger(behavior);
CreateMockDTE(behavior);
CreateMockMenuCommandService(behavior);
MockReAttachReporter = new ReAttachTraceReporter(); // Use real reporting for simplicity.
MockReAttachUi = new Mock<IReAttachUi>(behavior);
MockReAttachHistory = new Mock<IReAttachHistory>(behavior);
MockReAttachHistoryItems = new ReAttachTargetList(ReAttachConstants.ReAttachHistorySize);
MockReAttachHistory.Setup(h => h.Items).Returns(MockReAttachHistoryItems);
MockReAttachDebugger = new Mock<IReAttachDebugger>(behavior);
// Wire up all services and modules.
MockReAttachPackage = new Mock<IReAttachPackage>(behavior);
MockReAttachPackage.Setup(p => p.GetService(typeof(IMenuCommandService))).Returns(MockMenuService.Object);
MockReAttachPackage.Setup(p => p.GetService(typeof(SVsShellDebugger))).Returns(MockDebugger.Object);
MockReAttachPackage.Setup(p => p.GetService(typeof(SDTE))).Returns(MockDTE.Object);
MockReAttachPackage.Setup(p => p.Reporter).Returns(MockReAttachReporter);
MockReAttachPackage.Setup(p => p.Ui).Returns(MockReAttachUi.Object);
MockReAttachPackage.Setup(p => p.History).Returns(MockReAttachHistory.Object);
MockReAttachPackage.Setup(p => p.Debugger).Returns(MockReAttachDebugger.Object);
}
public bool SaveTargets(ReAttachTargetList targets)
{
try
{
var root = _package.OpenUserRegistryRoot();
if (root == null)
{
_package.Reporter.ReportError("Unable to open user root registry key.");
return false;
}
var subkey = root.CreateSubKey(ReAttachConstants.ReAttachRegistryKeyName);
if (subkey == null)
{
_package.Reporter.ReportError("Unable to open/create ReAttach subkey.");
root.Close();
return false;
}
var index = 1;
foreach (var target in targets)
{
var json = JsonConvert.SerializeObject(target);
subkey.SetValue(ReAttachConstants.ReAttachRegistryHistoryKeyPrefix + index, json);
index++;
}
subkey.Close();
root.Close();
return true;
}
catch (Exception e)
{
_package.Reporter.ReportError(
"Unable to save ReAttachTargetList using ReAttachRegistryRepository. Message: {0}", e.Message);
return false;
}
}
public bool SaveTargets(ReAttachTargetList targets)
{
try
{
var root = _package.OpenUserRegistryRoot();
if (root == null)
{
_package.Reporter.ReportError("Unable to open user root registry key.");
return false;
}
var subkey = root.CreateSubKey(ReAttachConstants.ReAttachRegistryKeyName);
if (subkey == null)
{
_package.Reporter.ReportError("Unable to open/create ReAttach subkey.");
root.Close();
return false;
}
var index = 1;
foreach (var target in targets)
{
var data = string.Format("{0}{1}{2}{3}{4}{5}{6}",
target.ProcessPath, ReAttachConstants.ReAttachRegistrySplitChar,
target.ProcessUser, ReAttachConstants.ReAttachRegistrySplitChar,
target.ProcessId, ReAttachConstants.ReAttachRegistrySplitChar,
target.ServerName);
subkey.SetValue(ReAttachConstants.ReAttachRegistryHistoryKeyPrefix + index, data);
index++;
}
// Clear old keys.
for (var i = targets.Count + 1; i <= ReAttachConstants.ReAttachHistorySize; i++)
subkey.DeleteValue(ReAttachConstants.ReAttachRegistryHistoryKeyPrefix + i, false);
subkey.Close();
root.Close();
return true;
}
catch (Exception e)
{
_package.Reporter.ReportError(
"Unable to save ReAttachTargetList using ReAttachRegistryRepository. Message: {0}", e.Message);
}
return false;
}
public void SaveTest()
{
var key = new Mock<IRegistryKey>();
var subkey = new Mock<IRegistryKey>();
key.Setup(k => k.CreateSubKey(It.IsAny<string>())).Returns(subkey.Object);
var package = new Mock<IReAttachPackage>();
package.Setup(p => p.OpenUserRegistryRoot()).Returns(key.Object);
var repository = new ReAttachRegistryRepository(package.Object);
var targets = new ReAttachTargetList(ReAttachConstants.ReAttachHistorySize);
for (var i = 1; i <= 3; i++)
targets.AddFirst(new ReAttachTarget(i, "path" + i, "user" + i));
Assert.IsTrue(repository.SaveTargets(targets));
key.Verify(k => k.CreateSubKey(It.IsAny<string>()), Times.Once());
for (var i = 1; i <= 3; i++)
{
var expected = string.Format("{0}{1}{2}{3}{4}{5}{6}",
targets[i - 1].ProcessPath, ReAttachConstants.ReAttachRegistrySplitChar,
targets[i - 1].ProcessUser, ReAttachConstants.ReAttachRegistrySplitChar,
targets[i - 1].ProcessId, ReAttachConstants.ReAttachRegistrySplitChar,
targets[i - 1].ServerName);
subkey.Verify(k => k.SetValue(ReAttachConstants.ReAttachRegistryHistoryKeyPrefix + i,
expected), Times.Once());
}
subkey.Verify(k => k.Close(), Times.Once());
}
public ReAttachHistory(IReAttachRepository repository)
{
_repository = repository;
Items = new ReAttachTargetList(ReAttachConstants.ReAttachHistorySize);
Options = new ReAttachOptions();
}
public void SaveErrorTest()
{
var key = new Mock<IRegistryKey>(MockBehavior.Strict);
var subkey = new Mock<IRegistryKey>(MockBehavior.Strict);
key.Setup(k => k.CreateSubKey(It.IsAny<string>())).Returns(subkey.Object);
subkey.Setup(k => k.SetValue(It.IsAny<string>(), It.IsAny<string>())).Throws
(new SecurityException("Simulating no access when setting value. :)"));
subkey.Setup(k => k.DeleteValue(It.IsAny<string>(), It.IsAny<bool>())).Throws
(new SecurityException("Simulating no access when deleting value. :)"));
var package = new Mock<IReAttachPackage>();
package.Setup(p => p.OpenUserRegistryRoot()).Returns(key.Object);
package.Setup(p => p.Reporter).Returns(new ReAttachTraceReporter());
var repository = new ReAttachRegistryRepository(package.Object);
var targets = new ReAttachTargetList(ReAttachConstants.ReAttachHistorySize);
Assert.IsFalse(repository.SaveTargets(targets));
for (var i = 1; i <= 3; i++)
targets.AddFirst(new ReAttachTarget(i, "path" + i, "user" + i));
Assert.IsFalse(repository.SaveTargets(targets));
}
public void MaxItemsTest()
{
var list = new ReAttachTargetList(5);
for (var i = 1; i <= 10; i++)
list.AddFirst(new ReAttachTarget(i, "path" + i, "user" + i));
Assert.AreEqual(5, list.Count);
Assert.AreEqual(10, list[0].ProcessId);
Assert.AreEqual(6, list[4].ProcessId);
}
public void SaveTest()
{
var key = new Mock<IRegistryKey>();
var subkey = new Mock<IRegistryKey>();
key.Setup(k => k.CreateSubKey(It.IsAny<string>())).Returns(subkey.Object);
var package = new Mock<IReAttachPackage>();
package.Setup(p => p.OpenUserRegistryRoot()).Returns(key.Object);
var repository = new ReAttachRegistryRepository(package.Object);
var targets = new ReAttachTargetList(ReAttachConstants.ReAttachHistorySize);
for (var i = 1; i <= 3; i++)
targets.AddFirst(new ReAttachTarget(i, "path" + i, "user" + i));
Assert.IsTrue(repository.SaveTargets(targets));
key.Verify(k => k.CreateSubKey(It.IsAny<string>()), Times.Once());
for (var i = 1; i <= 3; i++)
{
subkey.Verify(k => k.SetValue(
ReAttachConstants.ReAttachRegistryHistoryKeyPrefix + i,
It.IsAny<string>()), Times.Once());
}
subkey.Verify(k => k.Close(), Times.Once());
}
public ReAttachHistory(IReAttachRepository repository)
{
_repository = repository;
Items = new ReAttachTargetList(ReAttachConstants.ReAttachHistorySize);
Options = new ReAttachOptions();
}
