/// <summary>
/// Saves the specified connection - method provided for testing.
/// </summary>
/// <param name="jsonObj"></param>
/// <param name="defaultEnvironment">The environment where the connection will be saved - must ALWAYS be .</param>
/// <exception cref="System.ArgumentNullException">connectionID</exception>
public void Save(dynamic jsonObj, IEnvironmentModel defaultEnvironment)
{
if(jsonObj == null)
{
throw new ArgumentNullException();
}
Connection newConnection = JsonConvert.DeserializeObject<Connection>(jsonObj.ToString());
var resourceId = newConnection.ResourceID;
ServerProxy connection;
if(newConnection.AuthenticationType == AuthenticationType.Windows || newConnection.AuthenticationType == AuthenticationType.Anonymous)
{
connection = new ServerProxy(new Uri(newConnection.WebAddress));
}
else
{
//
// NOTE: Public needs to drop through to User for the rest of the framework to pick up properly behind the scenes ;)
//
connection = new ServerProxy(newConnection.WebAddress, newConnection.UserName, newConnection.Password);
}
var environmentModel = CurrentEnvironmentRepository.Get(resourceId);
if(environmentModel == null)
{
var newEnvironment = new EnvironmentModel(resourceId, connection) { Name = newConnection.ResourceName, Category = newConnection.ResourcePath };
CurrentEnvironmentRepository.Save(newEnvironment);
}
else
{
environmentModel.Connection = connection;
environmentModel.Name = newConnection.ResourceName;
environmentModel.Category = newConnection.ResourcePath;
}
}
public void GivenIHaveAServer(string serverName)
{
if(serverName != "localhost")
{
var environmentModel = new EnvironmentModel(Guid.NewGuid(), new ServerProxy(new Uri(string.Format("http://{0}:3142", serverName))));
EnvironmentRepository.Instance.Save(environmentModel);
environmentModel.Connect();
}
}
public void EnvironmentModel_Constructor_ConnectionAndWizardEngine_InitializesConnectionAndResourceRepository()
{
var connection = CreateConnection();
//, wizard.Object
var env = new EnvironmentModel(Guid.NewGuid(), connection.Object);
Assert.IsNotNull(env.Connection);
Assert.IsNotNull(env.ResourceRepository);
Assert.AreSame(connection.Object, env.Connection);
}
public void EnvironmentModel_Constructor_ConnectionAndResourceRepository_InitializesConnectionAndResourceRepository()
{
var connection = CreateConnection();
var repo = new Mock<IResourceRepository>();
var env = new EnvironmentModel(Guid.NewGuid(), connection.Object, repo.Object, new Mock<IStudioResourceRepository>().Object);
Assert.IsNotNull(env.Connection);
Assert.IsNotNull(env.ResourceRepository);
Assert.AreSame(connection.Object, env.Connection);
Assert.AreSame(repo.Object, env.ResourceRepository);
}
public void EnvironmentModel_AuthorizationService_Constructor_PropertyInitialized()
{
//------------Setup for test--------------------------
var connection = CreateConnection();
//------------Execute Test---------------------------
var env = new EnvironmentModel(Guid.NewGuid(), connection.Object, new Mock<IResourceRepository>().Object, new Mock<IStudioResourceRepository>().Object);
connection.Raise(environmentConnection => environmentConnection.NetworkStateChanged += null, new NetworkStateEventArgs(NetworkState.Offline, NetworkState.Online));
//------------Assert Results-------------------------
Assert.IsNotNull(env.AuthorizationService);
}
public void DeployViewConnectedToVisiblityConverter_Convert_IsConnectedIsTrue_VisibilityIsCollapsed()
{
//Arrange
var converter = new DeployViewConnectedToVisiblityConverter();
Mock<IEnvironmentConnection> mockEnvironmentConnection = new Mock<IEnvironmentConnection>();
mockEnvironmentConnection.Setup(m => m.ServerEvents).Returns(new Mock<IEventPublisher>().Object);
mockEnvironmentConnection.Setup(m => m.IsConnected).Returns(true);
IEnvironmentModel environmentModel = new EnvironmentModel(Guid.NewGuid(), mockEnvironmentConnection.Object, new Mock<IStudioResourceRepository>().Object);
//Act
var actual = (Visibility)converter.Convert(environmentModel, typeof(bool), null, null);
//Assert
Assert.AreEqual(Visibility.Visible, actual);
}
static void TestAuxilliaryConnections(string appServerUri)
{
var repo = new Mock<IResourceRepository>();
var sRepo = new Mock<IStudioResourceRepository>();
var connection = CreateConnection(appServerUri);
var environment = new EnvironmentModel(Guid.NewGuid(), connection, repo.Object,sRepo.Object) { Name = "conn" };
var auxRepo = new Mock<IResourceRepository>();
var auxConnection = CreateConnection(appServerUri);
var auxEnvironment = new EnvironmentModel(Guid.NewGuid(), auxConnection, auxRepo.Object,sRepo.Object) { Name = "auxconn" };
environment.Connect();
Assert.IsTrue(environment.IsConnected);
auxEnvironment.Connect(environment);
Assert.IsTrue(auxEnvironment.IsConnected);
auxEnvironment.Disconnect();
environment.Disconnect();
}
public void EnvironmentRepositoryWriteSessionWithExistingFileExpectedOverwritesFile()
{
var path = EnvironmentRepository.GetEnvironmentsFilePath();
var bakPath = RetryUtility.RetryMethod(() => BackupFile(path), 15, 1000, null);
var c1 = CreateMockConnection();
var e1 = new EnvironmentModel(Guid.NewGuid(), c1.Object, new Mock<IResourceRepository>().Object, new Mock<IStudioResourceRepository>().Object);
var repo = new TestEnvironmentRespository(e1) { IsReadWriteEnabled = true };
// Create file
repo.WriteSession(new List<Guid> { Guid.NewGuid() });
var xml = XElement.Load(path);
var actual = xml.Descendants("Environment").Count();
Assert.AreEqual(1, actual);
// Overwrite file
repo.WriteSession(new List<Guid> { Guid.NewGuid(), Guid.NewGuid() });
xml = XElement.Load(path);
actual = xml.Descendants("Environment").Count();
Assert.AreEqual(2, actual);
// ReSharper disable ImplicitlyCapturedClosure
RetryUtility.RetryAction(() => DeleteFile(path), 15, 1000);
// ReSharper restore ImplicitlyCapturedClosure
RetryUtility.RetryAction(() => RestoreFile(path, bakPath), 15, 1000);
}
public void EnvironmentRepository_Fetch_NotFound_ReturnsEnvironment()
{
//------------Setup for test--------------------------
var c1 = CreateMockConnection();
var e1 = new EnvironmentModel(Guid.NewGuid(), c1.Object);
var source = new Mock<IEnvironmentModel>();
var repo = new TestEnvironmentRespository(source.Object);
repo.Save(e1);
//------------Execute Test---------------------------
var environmentModel = repo.Fetch(new Mock<IEnvironmentModel>().Object);
//------------Assert Results-------------------------
Assert.IsNotNull(environmentModel);
}
public void EnvironmentRepositorySaveWithSingleExistingItemExpectedReplacesItem()
{
// DO NOT use mock as test requires IEquatable of IEnvironmentModel
var c1 = CreateMockConnection();
//var wizard = new Mock<IWizardEngine>();
var e1 = new EnvironmentModel(Guid.NewGuid(), c1.Object);
var source = new Mock<IEnvironmentModel>();
var repo = new TestEnvironmentRespository(source.Object, e1);
var startCount = repo.All().Count;
repo.Save(e1);
Assert.AreEqual(startCount, repo.All().Count);
}
public void EnvironmentRepositorySaveWithSingleExpectedDoesNotConnect()
{
// DO NOT use mock as test requires IEquatable of IEnvironmentModel
var c1 = CreateMockConnection();
c1.Setup(c => c.Connect(It.IsAny<Guid>())).Verifiable();
//var wizard = new Mock<IWizardEngine>();
var e1 = new EnvironmentModel(Guid.NewGuid(), c1.Object);
var source = new Mock<IEnvironmentModel>();
var repo = new TestEnvironmentRespository(source.Object);
repo.Save(e1);
c1.Verify(c => c.Connect(It.IsAny<Guid>()), Times.Never());
}
static void TestConnectionEvents(NetworkState toState)
{
var environmentConnection = new Mock<IEnvironmentConnection>();
environmentConnection.Setup(connection => connection.IsConnected).Returns(true);
environmentConnection.Setup(connection => connection.ServerEvents).Returns(EventPublishers.Studio);
var repo = new Mock<IResourceRepository>();
var envModel = new EnvironmentModel(Guid.NewGuid(), environmentConnection.Object, repo.Object, new Mock<IStudioResourceRepository>().Object);
envModel.IsConnectedChanged += (sender, args) => Assert.AreEqual(toState == NetworkState.Online, args.IsConnected);
environmentConnection.Raise(c => c.NetworkStateChanged += null, new NetworkStateEventArgs(NetworkState.Connecting, toState));
}
public void EnvironmentTreeViewModel_PermissionsChanged_MemoIDEqualsEnvironmentServerId_UserPermissionChangesNonLocalHost()
{
//------------Setup for test--------------------------
var resourceID = Guid.NewGuid();
//var connectionServerId = Guid.NewGuid();
var memoServerID = Guid.NewGuid();
var pubMemo = new PermissionsModifiedMemo { ServerID = memoServerID };
pubMemo.ModifiedPermissions.Add(new WindowsGroupPermission { ResourceID = resourceID, Permissions = Permissions.Execute });
pubMemo.ModifiedPermissions.Add(new WindowsGroupPermission { ResourceID = resourceID, Permissions = Permissions.DeployTo });
var eventPublisher = new EventPublisher();
var connection = new Mock<IEnvironmentConnection>();
connection.Setup(e => e.ServerEvents).Returns(eventPublisher);
connection.SetupGet(c => c.ServerID).Returns(memoServerID);
var srepo = new Mock<IStudioResourceRepository>();
var repo = new Mock<IResourceRepository>();
#pragma warning disable 168
var environment = new EnvironmentModel(Guid.NewGuid(), connection.Object, repo.Object, srepo.Object) { Name = "localhost" };
connection.Raise(environmentConnection => environmentConnection.NetworkStateChanged += null, new NetworkStateEventArgs(NetworkState.Offline, NetworkState.Online));
#pragma warning restore 168
connection.Setup(a => a.DisplayName).Returns("bob");
//------------Execute Test---------------------------
eventPublisher.Publish(pubMemo);
srepo.Verify(a => a.UpdateRootAndFoldersPermissions(It.IsAny<Permissions>(), It.IsAny<Guid>(), true), Times.Never());
}
public void EnvironmentModel_LoadResources_ShouldLoadFalse_NotInvokeLoadOnResourceRepository()
{
var resourceRepo = new Mock<IResourceRepository>();
resourceRepo.Setup(r => r.Load()).Verifiable();
var connection = CreateConnection();
connection.Setup(c => c.DisplayName).Returns("Test");
connection.Setup(c => c.IsConnected).Returns(true);
var env = new EnvironmentModel(Guid.NewGuid(), connection.Object, resourceRepo.Object, new Mock<IStudioResourceRepository>().Object) { CanStudioExecute = false };
env.LoadResources();
resourceRepo.Verify(r => r.Load(), Times.Never());
}
// ReSharper disable InconsistentNaming - Unit Tests
public void Save_WithValidConnection_Expected_InvokesSaveEnvironment()
// ReSharper restore InconsistentNaming - Unit Tests
{
var mockConnection = new Mock<IEnvironmentConnection>();
mockConnection.Setup(connection => connection.ServerEvents).Returns(new Mock<IEventPublisher>().Object);
var mockResourceRepo = new Mock<IResourceRepository>();
var env = new EnvironmentModel(Guid.NewGuid(), mockConnection.Object, mockResourceRepo.Object, new Mock<IStudioResourceRepository>().Object);
var currentRepository = new Mock<IEnvironmentRepository>();
currentRepository.Setup(c => c.ActiveEnvironment).Returns(env);
currentRepository.Setup(e => e.Save(It.IsAny<IEnvironmentModel>())).Verifiable();
currentRepository.Setup(e => e.Fetch(It.IsAny<IEnvironmentModel>())).Returns(new Mock<IEnvironmentModel>().Object);
var handler = new ConnectCallbackHandler(currentRepository.Object);
handler.Save(ConnectionJson, null);
// ReSharper disable PossibleUnintendedReferenceComparison - expected to be the same instance
currentRepository.Verify(r => r.Save(It.IsAny<IEnvironmentModel>()));
// ReSharper restore PossibleUnintendedReferenceComparison
}
public void EnvironmentRepository_Save_RaisesItemAddedEvent()
{
//------------Setup for test--------------------------
var c1 = CreateMockConnection();
var e1 = new EnvironmentModel(Guid.NewGuid(), c1.Object);
var source = new Mock<IEnvironmentModel>();
bool _eventFired = false;
var repo = new TestEnvironmentRespository(source.Object);
repo.ItemAdded += (sender, args) =>
{
_eventFired = true;
};
e1.Name = "New Name";
//------------Execute Test---------------------------
repo.Save(e1);
//------------Assert Results-------------------------
Assert.IsTrue(_eventFired);
}
public void EnvironmentRepository_UnitTest_LookupEnvironmentsWithDefaultEnvironmentExpectDoesNotThrowException()
{
var env = new Mock<IEnvironmentModel>();
var con = new Mock<IEnvironmentConnection>();
var repo = new Mock<IResourceRepository>();
var id = Guid.NewGuid();
Connection theCon = new Connection
{
Address = "http://127.0.0.1:1234",
ResourceName = "TheConnection",
ResourceID = id,
WebServerPort = 1234
};
List<Connection> cons = new List<Connection> { theCon };
repo.Setup(r => r.FindSourcesByType<Connection>(It.IsAny<IEnvironmentModel>(), enSourceType.Dev2Server)).Returns(cons);
con.Setup(c => c.IsConnected).Returns(true);
con.Setup(c => c.ExecuteCommand(It.IsAny<StringBuilder>(), It.IsAny<Guid>())).Returns(new StringBuilder());
env.Setup(e => e.IsConnected).Returns(true);
env.Setup(e => e.Connection).Returns(con.Object);
env.Setup(e => e.ResourceRepository).Returns(repo.Object);
var studiorepo = new Mock<IStudioResourceRepository>();
//------------Setup for test--------------------------
var defaultEnvironment = new EnvironmentModel(Guid.NewGuid(), CreateMockConnection("localhost").Object, repo.Object, studiorepo.Object);
//------------Execute Test---------------------------
EnvironmentRepository.Instance.LookupEnvironments(defaultEnvironment);
//------------Assert Results-------------------------
Assert.IsTrue(true);
}
public void EnvironmentRepository_Save_NotExistingEnvironment_DoesNotRaisesItemEditedEvent()
{
//------------Setup for test--------------------------
var c1 = CreateMockConnection();
var e1 = new EnvironmentModel(Guid.NewGuid(), c1.Object);
var source = new Mock<IEnvironmentModel>();
IEnvironmentModel _editedEnvironment = null;
var repo = new TestEnvironmentRespository(source.Object);
repo.ItemEdited += (sender, args) =>
{
_editedEnvironment = args.Environment;
};
e1.Name = "New Name";
//------------Execute Test---------------------------
repo.Save(e1);
//------------Assert Results-------------------------
Assert.IsNull(_editedEnvironment);
}
public void EnvironmentModel_DisplayName_WithConnection_ContainsConnectionAddress()
{
//------------Setup for test--------------------------
var connection = CreateConnection();
var repo = new Mock<IResourceRepository>();
var env = new EnvironmentModel(Guid.NewGuid(), connection.Object, repo.Object, new Mock<IStudioResourceRepository>().Object);
const string expectedDisplayName = "localhost (http://localhost:3142/)";
//------------Execute Test---------------------------
string displayName = env.DisplayName;
//------------Assert Results-------------------------
Assert.AreEqual(expectedDisplayName, displayName);
}
public void EnvironmentModel_Load_DoesNotLoads_SetsLoaded()
{
var resourceRepo = new Mock<IResourceRepository>();
resourceRepo.Setup(r => r.Load()).Verifiable();
var connection = CreateConnection();
connection.Setup(c => c.DisplayName).Returns("Test");
connection.Setup(c => c.IsConnected).Returns(true);
var env = new EnvironmentModel(Guid.NewGuid(), connection.Object, resourceRepo.Object, new Mock<IStudioResourceRepository>().Object) { CanStudioExecute = false };
env.LoadResources();
Assert.IsFalse(env.HasLoadedResources);
}
public void EnvironmentModel_LoadResources_ShouldLoadTrue_InvokesLoadOnResourceRepository()
{
var resourceRepo = new Mock<IResourceRepository>();
resourceRepo.Setup(r => r.Load()).Verifiable();
var connection = CreateConnection();
connection.Setup(c => c.DisplayName).Returns("Test");
connection.Setup(c => c.IsConnected).Returns(true);
var env = new EnvironmentModel(Guid.NewGuid(), connection.Object, resourceRepo.Object, new Mock<IStudioResourceRepository>().Object);
Assert.IsTrue(env.CanStudioExecute);
env.LoadResources();
resourceRepo.Verify(r => r.UpdateWorkspace(It.IsAny<List<IWorkspaceItem>>()), Times.Once());
}
public void WhenConnectedAsUserPartOf(string userGroup)
{
if(SchedulerSteps.AccountExists("SpecsUser"))
{
if(!IsUserInGroup("SpecsUser", userGroup))
{
try
{
SecurityIdentifier id = SchedulerSteps.GetUserSecurityIdentifier("SpecsUser");
PrincipalContext context = new PrincipalContext(ContextType.Machine);
UserPrincipal userPrincipal = UserPrincipal.FindByIdentity(context, IdentityType.Sid, id.Value);
SchedulerSteps.AddUserToGroup(userGroup, context, userPrincipal);
}
catch(Exception)
{
Assert.Fail("User not found");
}
}
}
else
{
SchedulerSteps.CreateLocalWindowsAccount("SpecsUser", "T35t3r!@#", userGroup);
}
var reconnectModel = new EnvironmentModel(Guid.NewGuid(), new ServerProxy(AppSettings.LocalHost, "SpecsUser", "T35t3r!@#")) { Name = "Other Connection" };
try
{
reconnectModel.Connect();
}
catch(UnauthorizedAccessException)
{
Assert.Fail("Connection unauthorized when connecting to local Warewolf server as user who is part of '" + userGroup + "' user group.");
}
ScenarioContext.Current.Add("currentEnvironment", reconnectModel);
}
// ReSharper disable InconsistentNaming - Unit Tests
public void Save_WithValidConnection_Expected_InvokesSaveEnvironmentWithCategory()
// ReSharper restore InconsistentNaming - Unit Tests
{
// BUG: 8786 - TWR - 2013.02.20
var mockConnection = new Mock<IEnvironmentConnection>();
mockConnection.Setup(connection => connection.ServerEvents).Returns(new Mock<IEventPublisher>().Object);
var mockResourceRepo = new Mock<IResourceRepository>();
var enviro = new EnvironmentModel(Guid.NewGuid(), mockConnection.Object, mockResourceRepo.Object, new Mock<IStudioResourceRepository>().Object);
var currentRepository = new Mock<IEnvironmentRepository>();
currentRepository.Setup(e => e.Save(It.IsAny<IEnvironmentModel>())).Verifiable();
currentRepository.Setup(c => c.ActiveEnvironment).Returns(enviro);
var env = new Mock<IEnvironmentModel>();
env.SetupProperty(e => e.Category); // start tracking sets/gets to this property
currentRepository.Setup(e => e.Fetch(It.IsAny<IEnvironmentModel>())).Returns(env.Object);
var handler = new ConnectCallbackHandler(new Mock<IEventAggregator>().Object, currentRepository.Object);
handler.Save(ConnectionJson, null);
// ReSharper disable PossibleUnintendedReferenceComparison - expected to be the same instance
currentRepository.Verify(r => r.Save(It.IsAny<IEnvironmentModel>()));
// ReSharper restore PossibleUnintendedReferenceComparison
}
public void EnvironmentRepositoryRemoveWithSingleItemExpectedDoesNotInvokesWriteSession()
{
var source = new Mock<IEnvironmentModel>();
var c1 = CreateMockConnection();
var c2 = CreateMockConnection();
var c3 = CreateMockConnection();
var e1 = new EnvironmentModel(Guid.NewGuid(), c1.Object, new Mock<IResourceRepository>().Object, new Mock<IStudioResourceRepository>().Object);
var e2 = new EnvironmentModel(Guid.NewGuid(), c2.Object, new Mock<IResourceRepository>().Object, new Mock<IStudioResourceRepository>().Object);
var e3 = new EnvironmentModel(Guid.NewGuid(), c3.Object, new Mock<IResourceRepository>().Object, new Mock<IStudioResourceRepository>().Object);
var repo = new TestEnvironmentRespository(source.Object, e1, e2, e3);
repo.Remove(e1);
Assert.AreEqual(0, repo.WriteSessionHitCount);
}
public void WorkflowExecuted_Where_ExecutionStatusCallBackRegisteredAndDataListMergeRequested_Expected_DataMergedInAndOutOfWorkflow()
{
//
// Create a reset event which is used to wait for callbacks form the server
//
ManualResetEventSlim resetEvent = new ManualResetEventSlim(false);
//
// Setup MEF context
//
ImportService.CurrentContext = CompositionInitializer.DefaultInitialize();
//
// Setup test data
//
ErrorResultTO errors = new ErrorResultTO();
Guid callBackID = Guid.NewGuid();
string serviceName = "wizardtest";
IBinaryDataList dataList = Dev2BinaryDataListFactory.CreateDataList();
string error;
dataList.TryCreateScalarTemplate("", "testvalue", "", true, out error);
dataList.TryCreateScalarValue("321", "testvalue", out error);
DataListMergeOpsTO dataListMergeOpsTO = new DataListMergeOpsTO(dataList.UID);
ServiceLocator serviceLocator = new ServiceLocator();
ImportService.SatisfyImports(serviceLocator);
//
// Connect to the server
//
IEnvironmentConnection conn = new EnvironmentConnection();
conn.Address = new Uri(ServerSettings.DsfAddress);
conn.Connect();
IEventAggregator eventAggregator = ImportService.GetExportValue<IEventAggregator>();
IFrameworkSecurityContext securityContext = ImportService.GetExportValue<IFrameworkSecurityContext>();
IEnvironmentConnection environmentConnection = ImportService.GetExportValue<IEnvironmentConnection>();
IEnvironmentModel environment = new EnvironmentModel(eventAggregator, securityContext, environmentConnection);
environment.EnvironmentConnection = conn;
//
// Write the datalist to the server over the datalist channel
//
conn.DataListChannel.WriteDataList(dataList.UID, dataList, errors);
//
// Add an execution callback, the action of this call back will set the reset event allowing the test to continue
//
conn.ExecutionChannel.AddExecutionStatusCallback(callBackID, new Action<ExecutionStatusCallbackMessage>(m =>
{
if (m.MessageType == ExecutionStatusCallbackMessageType.CompletedCallback)
{
resetEvent.Set();
}
}));
//
// Get endpoint to query and make request to server
//
Uri enpoint = serviceLocator.GetEndpoint(WizardEndpointGenerationStrategyProvider.ServiceWithDataListMergeAndExecutionCallBackKey, new Tuple<string, IEnvironmentModel, DataListMergeOpsTO, Guid>(serviceName, environment, dataListMergeOpsTO, callBackID));
WebRequest wr = WebRequest.Create(enpoint);
WebResponse wrsp = wr.GetResponse();
Stream s = wrsp.GetResponseStream();
StreamReader sr = new StreamReader(s);
string payload = sr.ReadToEnd();
//
// Wait for completed callback
//
resetEvent.Wait(10000);
//
// Get datalist from the server
//
IBinaryDataList resultDataList = conn.DataListChannel.ReadDatalist(dataList.UID, errors);
//
// Clean up
//
conn.Disconnect();
IBinaryDataListEntry testValueEntry;
resultDataList.TryGetEntry("testvalue", out testValueEntry, out error);
IBinaryDataListEntry inValueEntry;
resultDataList.TryGetEntry("invalue", out inValueEntry, out error);
string expected = "123|321";
string actual = testValueEntry.FetchScalar().TheValue + "|" + inValueEntry.FetchScalar().TheValue;
Assert.AreEqual(expected, actual);
}
public void EnvironmentRepositoryRemoveWithSingleNonExistingItemExpectedDoesNotRemoveItem()
{
var source = new Mock<IEnvironmentModel>();
var c1 = CreateMockConnection();
var c2 = CreateMockConnection();
var c3 = CreateMockConnection();
var e1 = new EnvironmentModel(Guid.NewGuid(), c1.Object, new Mock<IResourceRepository>().Object, new Mock<IStudioResourceRepository>().Object);
var e2 = new EnvironmentModel(Guid.NewGuid(), c2.Object, new Mock<IResourceRepository>().Object, new Mock<IStudioResourceRepository>().Object);
var e3 = new EnvironmentModel(Guid.NewGuid(), c3.Object, new Mock<IResourceRepository>().Object, new Mock<IStudioResourceRepository>().Object);
var repo = new TestEnvironmentRespository(source.Object, e1, e2);
var startCount = repo.All().Count;
repo.Remove(e3);
Assert.AreEqual(startCount, repo.All().Count);
Assert.AreEqual(1, repo.RemoveInternalHitCount);
Assert.AreEqual(0, repo.WriteSessionHitCount);
}
public void EnvironmentRepositoryRemoveWithManyItemsExpectedDisconnectsAndRemovesItems()
{
// DO NOT use mock as test requires IEquatable of IEnvironmentModel
var source = new Mock<IEnvironmentModel>();
var c1 = CreateMockConnection();
var c2 = CreateMockConnection();
var c3 = CreateMockConnection();
c1.Setup(c => c.Disconnect()).Verifiable();
c2.Setup(c => c.Disconnect()).Verifiable();
c3.Setup(c => c.Disconnect()).Verifiable();
var e1 = new EnvironmentModel(Guid.NewGuid(), c1.Object, new Mock<IResourceRepository>().Object, new Mock<IStudioResourceRepository>().Object);
var e2 = new EnvironmentModel(Guid.NewGuid(), c2.Object, new Mock<IResourceRepository>().Object, new Mock<IStudioResourceRepository>().Object);
var e3 = new EnvironmentModel(Guid.NewGuid(), c3.Object, new Mock<IResourceRepository>().Object, new Mock<IStudioResourceRepository>().Object);
var repo = new TestEnvironmentRespository(source.Object, e1, e2, e3);
repo.Remove(new List<IEnvironmentModel> { e1, e3 });
var actual = repo.All().ToList();
c1.Verify(c => c.Disconnect(), Times.Once());
c2.Verify(c => c.Disconnect(), Times.Never());
c3.Verify(c => c.Disconnect(), Times.Once());
Assert.AreEqual(2, actual.Count);
Assert.AreEqual(2, repo.RemoveInternalHitCount);
Assert.AreSame(source.Object, actual[0]);
Assert.AreSame(e2, actual[1]);
}
public void EnvironmentModel_Load_CallsLoadedEvent()
{
var resourceRepo = new Mock<IResourceRepository>();
resourceRepo.Setup(r => r.Load()).Verifiable();
var connection = CreateConnection();
connection.Setup(c => c.DisplayName).Returns("Test");
connection.Setup(c => c.IsConnected).Returns(true);
var env = new EnvironmentModel(Guid.NewGuid(), connection.Object, resourceRepo.Object, new Mock<IStudioResourceRepository>().Object);
env.ResourcesLoaded += (sender, args) => Assert.AreEqual(args.Model, env);
env.CanStudioExecute = false;
env.LoadResources();
Assert.IsFalse(env.HasLoadedResources);
}
public void SettingsViewModel_ServerChangedCommand_ServerEnvironmentIsNotConnected_CurrentEnvironmentSetButNotConnected()
{
//------------Setup for test--------------------------
var popupController = new Mock<IPopupController>();
popupController.Setup(p => p.ShowNotConnected()).Verifiable();
var viewModel = new SettingsViewModel(new Mock<IEventAggregator>().Object, popupController.Object, AsyncWorkerTests.CreateSynchronousAsyncWorker().Object, new Mock<IWin32Window>().Object, new Mock<IConnectControlViewModel>().Object);
var mockConnection = new Mock<IEnvironmentConnection>();
mockConnection.Setup(c => c.IsConnected).Returns(false);
mockConnection.Setup(connection => connection.ServerEvents).Returns(new Mock<IEventPublisher>().Object);
var mockResourceRepo = new Mock<IResourceRepository>();
var server = new EnvironmentModel(Guid.NewGuid(), mockConnection.Object, mockResourceRepo.Object, new Mock<IStudioResourceRepository>().Object);
Assert.IsNull(viewModel.CurrentEnvironment);
Assert.IsTrue(server.CanStudioExecute);
//------------Execute Test---------------------------
viewModel.ServerChangedCommand.Execute(server);
//------------Assert Results-------------------------
Assert.IsNotNull(viewModel.CurrentEnvironment);
Assert.IsFalse(viewModel.CurrentEnvironment.IsConnected);
}
public void EnvironmentRepositoryRemoveWithSingleItemExpectedDisconnectsAndRemovesItem()
{
var source = new Mock<IEnvironmentModel>();
var c1 = CreateMockConnection();
var c2 = CreateMockConnection();
var c3 = CreateMockConnection();
c1.Setup(c => c.Disconnect()).Verifiable();
c2.Setup(c => c.Disconnect()).Verifiable();
c3.Setup(c => c.Disconnect()).Verifiable();
var e1 = new EnvironmentModel(Guid.NewGuid(), c1.Object, new Mock<IResourceRepository>().Object, new Mock<IStudioResourceRepository>().Object);
var e2 = new EnvironmentModel(Guid.NewGuid(), c2.Object, new Mock<IResourceRepository>().Object, new Mock<IStudioResourceRepository>().Object);
var e3 = new EnvironmentModel(Guid.NewGuid(), c3.Object, new Mock<IResourceRepository>().Object, new Mock<IStudioResourceRepository>().Object);
var repo = new TestEnvironmentRespository(source.Object, e1, e2, e3);
repo.Remove(e2);
var actual = repo.All().ToList();
c1.Verify(c => c.Disconnect(), Times.Never());
c2.Verify(c => c.Disconnect(), Times.Once());
c3.Verify(c => c.Disconnect(), Times.Never());
Assert.AreEqual(3, actual.Count);
Assert.AreEqual(1, repo.RemoveInternalHitCount);
Assert.AreSame(source.Object, actual[0]);
Assert.AreSame(e1, actual[1]);
Assert.AreSame(e3, actual[2]);
}
