Dev2.Core.Tests.MainViewModelTest.MainViewModel_AddWorkSurfaceContext_AddResourceFromWorkspace_ExpectIsSavedValueSameAsWhenPassedIn C# (CSharp) Method

        public void MainViewModel_AddWorkSurfaceContext_AddResourceFromWorkspace_ExpectIsSavedValueSameAsWhenPassedIn()
        {
            var resourceId = Guid.NewGuid();
            var serverId = Guid.NewGuid();
            var environmentId = Guid.NewGuid();
            var workspaceId = Guid.NewGuid();

            var resourceModel = new Mock<IContextualResourceModel>();
            resourceModel.Setup(r => r.ResourceType).Returns(ResourceType.WorkflowService);
            resourceModel.SetupGet(r => r.ID).Returns(resourceId);
            resourceModel.SetupGet(r => r.ServerID).Returns(serverId);
            resourceModel.SetupGet(r => r.ResourceName).Returns("My_Resource_Name");

            var environmentModel = new Mock<IEnvironmentModel>();
            environmentModel.SetupGet(e => e.ID).Returns(environmentId);

            var environmentConnection = new Mock<IEnvironmentConnection>();
            environmentConnection.SetupGet(env => env.WorkspaceID).Returns(workspaceId);

            environmentModel.SetupGet(e => e.Connection).Returns(environmentConnection.Object);

            var resourceRepository = new Mock<IResourceRepository>();
            resourceRepository.Setup(repository => repository.ReloadResource(It.IsAny<Guid>(), It.IsAny<ResourceType>(), It.IsAny<IEqualityComparer<IResourceModel>>(), It.IsAny<bool>())).Returns(() =>
            {
                Thread.Sleep(100);
                return new List<IResourceModel>();
            });
            environmentModel.SetupGet(e => e.ResourceRepository).Returns(resourceRepository.Object);
            resourceModel.SetupGet(r => r.Environment).Returns(environmentModel.Object);

            var environmentRepository = new Mock<IEnvironmentRepository>();
            environmentModel.Setup(c => c.CanStudioExecute).Returns(false);
            environmentRepository.Setup(c => c.Source).Returns(environmentModel.Object);
            environmentRepository.Setup(c => c.ReadSession()).Returns(new[] { Guid.NewGuid() });
            environmentRepository.Setup(c => c.All()).Returns(new[] { environmentModel.Object });
            //            new Thread(() =>
            //            {
            //                var vm = new MainViewModel(new Mock<IEventAggregator>().Object,
            //                                     new TestAsyncWorker(),
            //                                     environmentRepository.Object,
            //                                     new Mock<IVersionChecker>().Object,
            //                                     false,
            //                                     new Mock<IBrowserPopupController>().Object,
            //                                     new Mock<IPopupController>().Object,
            //                                     new Mock<IWindowManager>().Object,
            //                                     new Mock<IWebController>().Object,
            //                                     new Mock<IFeedbackInvoker>().Object);
            //
            //                var workspaceItemRepository = new Mock<IWorkspaceItemRepository>();
            //                workspaceItemRepository.SetupGet(p => p.WorkspaceItems).Returns(new List<IWorkspaceItem>());
            //
            //                vm.GetWorkspaceItemRepository = () => workspaceItemRepository.Object;
            //
            //                var tasks = new List<Task>
            //                {
            //                    Task.Factory.StartNew(() => vm.AddWorkSurfaceContextFromWorkspace(resourceModel.Object))
            //                };
            //
            //                Task.WaitAll(tasks.ToArray());
            //
            //                Assert.IsFalse(resourceModel.Object.IsWorkflowSaved);
            //            });
        }