public void WhenResourcesAreLoadedFor(string serverName)
{
var environmentModel = EnvironmentRepository.Instance.FindSingle(model => model.Name == serverName);
ServerExplorerClientProxy repository = new ServerExplorerClientProxy(environmentModel.Connection);
var explorerItemModel = repository.Load(Guid.Empty);
ScenarioContext.Current.Add(serverName, explorerItemModel);
}
public void WhenIRenameTheFolderFolderToRenameTo(string p0)
{
var environmentModel = EnvironmentRepository.Instance.FindSingle(model => model.Name == "localhost");
ServerExplorerClientProxy repository = new ServerExplorerClientProxy(environmentModel.Connection);
var result = repository.RenameItem(new ServerExplorerItem("FolderToRename", Guid.NewGuid(), ResourceType.Folder, null, Permissions.Administrator, "FolderToRename"), p0, Guid.Empty);
Assert.AreEqual(result.Status, ExecStatus.Success);
var explorerItemModel = repository.Load(Guid.Empty);
ScenarioContext.Current.Add("localhost", explorerItemModel);
ScenarioContext.Current.Add("newName", explorerItemModel);
}
public void ClientExplorerRepository_ClientExplorerRepository_Ctor_ExpectConnectionIsSet()
{
//------------Setup for test--------------------------
//------------Execute Test---------------------------
var env = new Mock<IEnvironmentConnection>();
var comFactory = new Mock<ICommunicationControllerFactory>();
var rep = new ServerExplorerClientProxy(env.Object, comFactory.Object);
//------------Assert Results-------------------------
Assert.AreEqual(rep.Connection, env.Object);
Assert.AreEqual(rep.CommunicationControllerFactory, comFactory.Object);
}
public void ClientExplorerRepository_ClientExplorerRepository_ExpectLoadCalled_ExpectExecCalled()
{
//------------Setup for test--------------------------
var env = new Mock<IEnvironmentConnection>();
var comFactory = new Mock<ICommunicationControllerFactory>();
var rep = new ServerExplorerClientProxy(env.Object, comFactory.Object);
var com = new Mock<ICommunicationController>();
var item = new Mock<IExplorerItem>();
// ReSharper disable MaximumChainedReferences
comFactory.Setup(a => a.CreateController("FetchExplorerItemsService")).Returns(com.Object).Verifiable();
com.Setup(a => a.ExecuteCommand<IExplorerItem>(env.Object, Guid.Empty)).Returns(item.Object).Verifiable();
//------------Execute Test---------------------------
rep.Load(Guid.Empty);
//------------Assert Results-------------------------
comFactory.Verify(a => a.CreateController("FetchExplorerItemsService"));
com.Verify(a => a.ExecuteCommand<IExplorerItem>(env.Object, Guid.Empty));
}
public void ClientExplorerRepository_CreateFolder_ExpectCreateServiceCalled()
{
//------------Setup for test--------------------------
var env = new Mock<IEnvironmentConnection>();
var comFactory = new Mock<ICommunicationControllerFactory>();
var rep = new ServerExplorerClientProxy(env.Object, comFactory.Object);
var com = new Mock<ICommunicationController>();
var item = new ServerExplorerItem("", Guid.Empty, ResourceType.DbService, null, Permissions.Contribute, "f");
comFactory.Setup(a => a.CreateController("AddFolderService")).Returns(com.Object).Verifiable();
com.Setup(a => a.ExecuteCommand<IExplorerItem>(env.Object, Guid.Empty)).Returns(item).Verifiable();
//------------Execute Test---------------------------
rep.AddItem(item, Guid.Empty);
//------------Assert Results-------------------------
comFactory.Verify(a => a.CreateController("AddFolderService"));
com.Verify(a => a.ExecuteCommand<IExplorerRepositoryResult>(env.Object, Guid.Empty));
com.Verify(a => a.AddPayloadArgument("itemToAdd", It.IsAny<string>()));
com.Verify(a => a.ExecuteCommand<IExplorerRepositoryResult>(env.Object, Guid.Empty));
}
public void WhenIRenameTheResourceTo(string itemToRename, string p1)
{
var environmentModel = EnvironmentRepository.Instance.FindSingle(model => model.Name == "localhost");
ServerExplorerClientProxy repository = new ServerExplorerClientProxy(environmentModel.Connection);
var item = repository.Load(Guid.Empty)
.Children.First(a => a.DisplayName == "ExplorerSpecsRenameItem")
.Children.FirstOrDefault(a => a.DisplayName == itemToRename);
if(item != null)
{
item.DisplayName = p1;
var result = repository.RenameItem(item, p1, Guid.Empty);
Assert.AreEqual(result.Status, ExecStatus.Success);
}
var explorerItemModel = repository.Load(Guid.Empty);
ScenarioContext.Current.Add("localhost", explorerItemModel);
ScenarioContext.Current.Add("newName", explorerItemModel);
ScenarioContext.Current.Add("folderName", "ExplorerSpecsRenameItem");
}
public void WhenIDeleteTheFolderWithoutRecursiveDeleteFlag(string folderToDelete)
{
var environmentModel = EnvironmentRepository.Instance.FindSingle(model => model.Name == "localhost");
ServerExplorerClientProxy repository = new ServerExplorerClientProxy(environmentModel.Connection);
var result = repository.DeleteItem(new ServerExplorerItem(folderToDelete, Guid.NewGuid(), ResourceType.Folder, null, Permissions.Administrator, ""), Guid.Empty);
Assert.AreEqual(result.Status, ExecStatus.Success);
var explorerItemModel = repository.Load(Guid.Empty);
Assert.IsFalse(0 == explorerItemModel.Children.Count(a => a.DisplayName == folderToDelete));
ScenarioContext.Current.Add("localhost", explorerItemModel);
ScenarioContext.Current.Add("newName", explorerItemModel);
}
public void WhenICreateTheFolder(string folderName)
{
var environmentModel = EnvironmentRepository.Instance.FindSingle(model => model.Name == "localhost");
var repository = new ServerExplorerClientProxy(environmentModel.Connection);
Assert.AreEqual(0, repository.Load(Guid.Empty).Children.Count(a => a.DisplayName == folderName));
var result = repository.AddItem(new ServerExplorerItem(folderName, Guid.NewGuid(), ResourceType.Folder, null, Permissions.Administrator, ""), Guid.Empty);
Assert.AreEqual(result.Status, ExecStatus.Success);
var explorerItemModel = repository.Load(Guid.Empty);
ScenarioContext.Current.Add("explorerItemModel", explorerItemModel);
ScenarioContext.Current.Add("folderName", folderName);
}
public void WhenIDeleteTheResource(string p0)
{
var environmentModel = EnvironmentRepository.Instance.FindSingle(model => model.Name == "localhost");
ServerExplorerClientProxy repository = new ServerExplorerClientProxy(environmentModel.Connection);
var item = repository.Load(Guid.Empty).Children.First(a => a.DisplayName == "ExplorerSpecsDeleteItem")
.Children.First();
var result = repository.DeleteItem(item, Guid.Empty);
Assert.AreEqual(result.Status, ExecStatus.Success);
var explorerItemModel = repository.Load(Guid.Empty);
ScenarioContext.Current.Add("localhost", explorerItemModel);
ScenarioContext.Current.Add("newName", explorerItemModel);
ScenarioContext.Current.Add("folderName", "ExplorerSpecsDeleteItem");
}
public void ThenTheExplorerTreeForWillHave(string p0, Table table)
{
var allItems = new List<ExplorerItemModel>();
foreach(var tableRow in table.Rows)
{
var parentName = tableRow["Parent"];
var childName = tableRow["Child"];
var type = tableRow["Type"];
ResourceType resourceType;
Enum.TryParse(type, out resourceType);
var eim = new ExplorerItemModel
{
DisplayName = childName,
Children = new ObservableCollection<IExplorerItemModel>(),
ResourceType = resourceType
};
var explorerItemModel = allItems.FirstOrDefault(model => model.DisplayName == parentName);
if(explorerItemModel != null)
{
explorerItemModel.Children.Add(eim);
}
allItems.Add(eim);
}
var folderName = ScenarioContext.Current.Get<string>("folderName");
var itemModel = ScenarioContext.Current.Get<IExplorerItem>("localhost");
var folder = itemModel.Children.FirstOrDefault(a => a.DisplayName == folderName);
Assert.IsNotNull(folder);
Assert.AreEqual(itemModel.DisplayName, Environment.MachineName);
Assert.AreEqual(folder.DisplayName, allItems[0].Children[0].DisplayName);
Assert.AreEqual(folder.Children.Count, allItems[0].Children[0].Children.Count);
// assert that the test directory exists
foreach(var explorerItemModel in folder.Children)
{
Assert.IsTrue(allItems[0].Children[0].Children.Count(a => a.ResourceType == explorerItemModel.ResourceType && a.DisplayName == explorerItemModel.DisplayName) == 1);
}
var environmentModel = EnvironmentRepository.Instance.FindSingle(model => model.Name == "localhost");
ServerExplorerClientProxy repository = new ServerExplorerClientProxy(environmentModel.Connection);
repository.RenameItem(new ServerExplorerItem("FolderToRename", Guid.NewGuid(), ResourceType.Folder, null, Permissions.Administrator, "FolderToRename"), p0, Guid.Empty);
}
public void ClientExplorerRepository_GetServerVersion_ExpectCorrectServiceCalled_defaultIfEmpty()
{
//------------Setup for test--------------------------
var env = new Mock<IEnvironmentConnection>();
var comFactory = new Mock<ICommunicationControllerFactory>();
var rep = new ServerExplorerClientProxy(env.Object, comFactory.Object);
var com = new Mock<ICommunicationController>();
comFactory.Setup(a => a.CreateController("GetServerVersion")).Returns(com.Object).Verifiable();
com.Setup(a => a.ExecuteCommand<string>(env.Object, Guid.Empty)).Returns("").Verifiable();
//------------Execute Test---------------------------
Assert.AreEqual("less than 0.4.19.1", rep.GetServerVersion());
//------------Assert Results-------------------------
comFactory.Verify(a => a.CreateController("GetServerVersion"));
com.Verify(a => a.ExecuteCommand<string>(env.Object, Guid.Empty));
com.Verify(a => a.ExecuteCommand<string>(env.Object, Guid.Empty));
}
public void WhenIRenameTheFolderTo(string folderToRename, string newName)
{
var environmentModel = EnvironmentRepository.Instance.FindSingle(model => model.Name == "localhost");
ServerExplorerClientProxy repository = new ServerExplorerClientProxy(environmentModel.Connection);
var result = repository.RenameItem(new ServerExplorerItem(folderToRename, Guid.NewGuid(), Common.Interfaces.Data.ResourceType.Folder, null, Permissions.Administrator, ""), newName, Guid.Empty);
Assert.AreEqual(ExecStatus.Success, result.Status, "Rename failed: " + result.Message);
var explorerItemModel = repository.Load(Guid.Empty);
ScenarioContext.Current.Add("localhost", explorerItemModel);
ScenarioContext.Current.Add("newName", explorerItemModel);
ScenarioContext.Current.Add("folderName", newName);
}
