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()); }