From 5b110aefadc7ee2bf16cc0fcc4a825284adca8b3 Mon Sep 17 00:00:00 2001
From: Gabriela Trutan <gabriela.trutan@sonarsource.com>
Date: Wed, 11 Dec 2024 09:44:24 +0100
Subject: [PATCH] SLVS-1377 Implement unbind in Binding Dialog (#5880)

---
 .../UnintrusiveBindingControllerTests.cs      | 107 +++++++++++-------
 .../ManageBindingViewModelTests.cs            |  77 ++++++++++++-
 .../Binding/IUnintrusiveBindingController.cs  |  16 ++-
 .../UI/ManageBinding/ManageBindingDialog.xaml |   4 +-
 .../ManageBinding/ManageBindingDialog.xaml.cs |   4 +-
 .../ManageBinding/ManageBindingViewModel.cs   |  75 ++++++++----
 src/ConnectedMode/UI/Resources/Styles.xaml    |   2 +-
 .../UI/Resources/UiResources.Designer.cs      |  27 +++++
 .../UI/Resources/UiResources.resx             |   9 ++
 9 files changed, 249 insertions(+), 72 deletions(-)

diff --git a/src/ConnectedMode.UnitTests/Binding/UnintrusiveBindingControllerTests.cs b/src/ConnectedMode.UnitTests/Binding/UnintrusiveBindingControllerTests.cs
index 66e60b69e..2192a3228 100644
--- a/src/ConnectedMode.UnitTests/Binding/UnintrusiveBindingControllerTests.cs
+++ b/src/ConnectedMode.UnitTests/Binding/UnintrusiveBindingControllerTests.cs
@@ -21,7 +21,6 @@
 using System.Security;
 using SonarLint.VisualStudio.ConnectedMode.Binding;
 using SonarLint.VisualStudio.ConnectedMode.Persistence;
-using SonarLint.VisualStudio.Core;
 using SonarLint.VisualStudio.Core.Binding;
 using SonarLint.VisualStudio.TestInfrastructure;
 using SonarQube.Client;
@@ -35,58 +34,66 @@ namespace SonarLint.VisualStudio.ConnectedMode.UnitTests.Binding;
 public class UnintrusiveBindingControllerTests
 {
     private static readonly CancellationToken ACancellationToken = CancellationToken.None;
-    private static readonly BasicAuthCredentials ValidToken = new ("TOKEN", new SecureString());
-    private static readonly BoundServerProject AnyBoundProject = new ("any", "any", new ServerConnection.SonarCloud("any", credentials: ValidToken));
+    private static readonly BasicAuthCredentials ValidToken = new("TOKEN", new SecureString());
+    private static readonly BoundServerProject AnyBoundProject = new("any", "any", new ServerConnection.SonarCloud("any", credentials: ValidToken));
+    private IActiveSolutionChangedHandler activeSolutionChangedHandler;
+    private IBindingProcess bindingProcess;
+    private IBindingProcessFactory bindingProcessFactory;
+    private ISonarQubeService sonarQubeService;
+    private UnintrusiveBindingController testSubject;
+    private ISolutionBindingRepository solutionBindingRepository;
+
+    [TestInitialize]
+    public void TestInitialize()
+    {
+        CreateBindingProcessFactory();
+        sonarQubeService = Substitute.For<ISonarQubeService>();
+        activeSolutionChangedHandler = Substitute.For<IActiveSolutionChangedHandler>();
+        solutionBindingRepository = Substitute.For<ISolutionBindingRepository>();
+        testSubject = new UnintrusiveBindingController(bindingProcessFactory, sonarQubeService, activeSolutionChangedHandler, solutionBindingRepository);
+    }
 
     [TestMethod]
-    public void MefCtor_CheckTypeIsNonShared()
-        => MefTestHelpers.CheckIsNonSharedMefComponent<UnintrusiveBindingController>();
+    public void MefCtor_CheckTypeIsNonShared() => MefTestHelpers.CheckIsNonSharedMefComponent<UnintrusiveBindingController>();
 
     [TestMethod]
-    public void MefCtor_IUnintrusiveBindingController_CheckIsExported()
-    {
+    public void MefCtor_IUnintrusiveBindingController_CheckIsExported() =>
         MefTestHelpers.CheckTypeCanBeImported<UnintrusiveBindingController, IUnintrusiveBindingController>(
             MefTestHelpers.CreateExport<IBindingProcessFactory>(),
             MefTestHelpers.CreateExport<ISonarQubeService>(),
-            MefTestHelpers.CreateExport<IActiveSolutionChangedHandler>());
-    }
-    
+            MefTestHelpers.CreateExport<IActiveSolutionChangedHandler>(),
+            MefTestHelpers.CreateExport<ISolutionBindingRepository>());
+
     [TestMethod]
-    public void MefCtor_IBindingController_CheckIsExported()
-    {
+    public void MefCtor_IBindingController_CheckIsExported() =>
         MefTestHelpers.CheckTypeCanBeImported<UnintrusiveBindingController, IBindingController>(
             MefTestHelpers.CreateExport<IBindingProcessFactory>(),
             MefTestHelpers.CreateExport<ISonarQubeService>(),
-            MefTestHelpers.CreateExport<IActiveSolutionChangedHandler>());
-    }
+            MefTestHelpers.CreateExport<IActiveSolutionChangedHandler>(),
+            MefTestHelpers.CreateExport<ISolutionBindingRepository>());
 
     [TestMethod]
     public async Task BindAsync_EstablishesConnection()
     {
-        var sonarQubeService = Substitute.For<ISonarQubeService>();
         var projectToBind = new BoundServerProject(
-            "local-key", 
+            "local-key",
             "server-key",
             new ServerConnection.SonarCloud("organization", credentials: ValidToken));
-        var testSubject = CreateTestSubject(sonarQubeService: sonarQubeService);
-        
+
         await testSubject.BindAsync(projectToBind, ACancellationToken);
 
         await sonarQubeService
             .Received()
             .ConnectAsync(
-                Arg.Is<ConnectionInformation>(x => x.ServerUri.Equals("https://sonarcloud.io/") 
+                Arg.Is<ConnectionInformation>(x => x.ServerUri.Equals("https://sonarcloud.io/")
                                                    && x.UserName.Equals(ValidToken.UserName)
                                                    && string.IsNullOrEmpty(x.Password.ToUnsecureString())),
                 ACancellationToken);
     }
-    
+
     [TestMethod]
     public async Task BindAsync_NotifiesBindingChanged()
     {
-        var activeSolutionChangedHandler = Substitute.For<IActiveSolutionChangedHandler>();
-        var testSubject = CreateTestSubject(activeSolutionChangedHandler: activeSolutionChangedHandler);
-        
         await testSubject.BindAsync(AnyBoundProject, ACancellationToken);
 
         activeSolutionChangedHandler
@@ -98,10 +105,7 @@ public async Task BindAsync_NotifiesBindingChanged()
     public async Task BindAsync_CallsBindingProcessInOrder()
     {
         var cancellationToken = CancellationToken.None;
-        var bindingProcess = Substitute.For<IBindingProcess>();
-        var bindingProcessFactory = CreateBindingProcessFactory(bindingProcess);
-        var testSubject = CreateTestSubject(bindingProcessFactory);
-            
+
         await testSubject.BindAsync(AnyBoundProject, null, cancellationToken);
 
         Received.InOrder(() =>
@@ -111,25 +115,50 @@ public async Task BindAsync_CallsBindingProcessInOrder()
             bindingProcess.SaveServerExclusionsAsync(cancellationToken);
         });
     }
-    
-    private UnintrusiveBindingController CreateTestSubject(IBindingProcessFactory bindingProcessFactory = null,
-        ISonarQubeService sonarQubeService = null,
-        IActiveSolutionChangedHandler activeSolutionChangedHandler = null)
+
+    [TestMethod]
+    public void Unbind_BindingDeletionSucceeded_HandlesBindingChangesAndDisconnects()
+    {
+        solutionBindingRepository.DeleteBinding(AnyBoundProject.LocalBindingKey).Returns(true);
+
+        testSubject.Unbind(AnyBoundProject.LocalBindingKey);
+
+        Received.InOrder(() =>
+        {
+            solutionBindingRepository.DeleteBinding(AnyBoundProject.LocalBindingKey);
+            sonarQubeService.Disconnect();
+            activeSolutionChangedHandler.HandleBindingChange(true);
+        });
+    }
+
+    [TestMethod]
+    public void Unbind_BindingDeletionFailed_DoesNotCallHandleBindingChange()
     {
-        var testSubject = new UnintrusiveBindingController(bindingProcessFactory ?? CreateBindingProcessFactory(),
-            sonarQubeService ?? Substitute.For<ISonarQubeService>(),
-            activeSolutionChangedHandler ?? Substitute.For<IActiveSolutionChangedHandler>());
+        solutionBindingRepository.DeleteBinding(AnyBoundProject.LocalBindingKey).Returns(false);
+
+        testSubject.Unbind(AnyBoundProject.LocalBindingKey);
 
-        return testSubject;
+        solutionBindingRepository.Received(1).DeleteBinding(AnyBoundProject.LocalBindingKey);
+        activeSolutionChangedHandler.DidNotReceive().HandleBindingChange(true);
     }
 
-    private static IBindingProcessFactory CreateBindingProcessFactory(IBindingProcess bindingProcess = null)
+    [TestMethod]
+    [DataRow(true)]
+    [DataRow(false)]
+    public void Unbind_ReturnsResultOfDeletedBinding(bool expectedResult)
+    {
+        solutionBindingRepository.DeleteBinding(AnyBoundProject.LocalBindingKey).Returns(expectedResult);
+
+        var result = testSubject.Unbind(AnyBoundProject.LocalBindingKey);
+
+        result.Should().Be(expectedResult);
+    }
+
+    private void CreateBindingProcessFactory()
     {
         bindingProcess ??= Substitute.For<IBindingProcess>();
 
-        var bindingProcessFactory = Substitute.For<IBindingProcessFactory>();
+        bindingProcessFactory = Substitute.For<IBindingProcessFactory>();
         bindingProcessFactory.Create(Arg.Any<BindCommandArgs>()).Returns(bindingProcess);
-
-        return bindingProcessFactory;
     }
 }
diff --git a/src/ConnectedMode.UnitTests/UI/ManageBinding/ManageBindingViewModelTests.cs b/src/ConnectedMode.UnitTests/UI/ManageBinding/ManageBindingViewModelTests.cs
index 9c9d52f88..51fd618ad 100644
--- a/src/ConnectedMode.UnitTests/UI/ManageBinding/ManageBindingViewModelTests.cs
+++ b/src/ConnectedMode.UnitTests/UI/ManageBinding/ManageBindingViewModelTests.cs
@@ -32,6 +32,7 @@
 using SonarLint.VisualStudio.ConnectedMode.UI.Resources;
 using SonarLint.VisualStudio.Core;
 using SonarLint.VisualStudio.Core.Binding;
+using SonarLint.VisualStudio.TestInfrastructure;
 
 namespace SonarLint.VisualStudio.ConnectedMode.UnitTests.UI.ManageBinding;
 
@@ -199,22 +200,84 @@ public void SelectedConnection_Set_RaisesEvents()
     }
 
     [TestMethod]
-    public void Unbind_SetsBoundProjectToNull()
+    public async Task UnbindWithProgressAsync_BindsProjectAndReportsProgress()
+    {
+        await testSubject.UnbindWithProgressAsync();
+
+        await progressReporterViewModel.Received(1)
+            .ExecuteTaskWithProgressAsync(
+                Arg.Is<TaskToPerformParams<AdapterResponse>>(x =>
+                    x.TaskToPerform == testSubject.UnbindAsync &&
+                    x.ProgressStatus == UiResources.UnbindingInProgressText &&
+                    x.WarningText == UiResources.UnbindingFailedText &&
+                    x.AfterProgressUpdated == testSubject.OnProgressUpdated &&
+                    x.AfterSuccess == testSubject.AfterUnbind));
+    }
+
+    [TestMethod]
+    public async Task UnbindAsync_UnbindsOnUIThread()
+    {
+        await testSubject.UnbindAsync();
+
+        await threadHandling.Received(1).RunOnUIThreadAsync(Arg.Any<Action>());
+    }
+
+    [TestMethod]
+    public async Task UnbindAsync_UnbindsCurrentSolution()
+    {
+        await InitializeBoundProject();
+        connectedModeServices.ThreadHandling.Returns(new NoOpThreadHandler());
+
+        await testSubject.UnbindAsync();
+
+        connectedModeBindingServices.BindingController.Received(1).Unbind(testSubject.SolutionInfo.Name);
+    }
+
+    [TestMethod]
+    [DataRow(true)]
+    [DataRow(false)]
+    public async Task UnbindAsync_ReturnsResponseOfUnbinding(bool expectedResponse)
+    {
+        await InitializeBoundProject();
+        connectedModeServices.ThreadHandling.Returns(new NoOpThreadHandler());
+        connectedModeBindingServices.BindingController.Unbind(Arg.Any<string>()).Returns(expectedResponse);
+
+        var adapterResponse = await testSubject.UnbindAsync();
+
+        adapterResponse.Success.Should().Be(expectedResponse);
+    }
+
+    [TestMethod]
+    public async Task UnbindAsync_UnbindingThrows_ReturnsFalse()
+    {
+        var exceptionMsg = "Failed to load connections";
+        var mockedThreadHandling = Substitute.For<IThreadHandling>();
+        connectedModeServices.ThreadHandling.Returns(mockedThreadHandling);
+        mockedThreadHandling.When(x => x.RunOnUIThreadAsync(Arg.Any<Action>())).Do(_ => throw new Exception(exceptionMsg));
+
+        var adapterResponse = await testSubject.UnbindAsync();
+
+        adapterResponse.Success.Should().BeFalse();
+        logger.Received(1).WriteLine(exceptionMsg);
+    }
+
+    [TestMethod]
+    public void AfterUnbind_SetsBoundProjectToNull()
     {
         testSubject.BoundProject = serverProject;
 
-        testSubject.Unbind();
+        testSubject.AfterUnbind(new AdapterResponse(true));
 
         testSubject.BoundProject.Should().BeNull();
     }
 
     [TestMethod]
-    public void Unbind_SetsConnectionInfoToNull()
+    public void AfterUnbind_SetsConnectionInfoToNull()
     {
         testSubject.SelectedConnectionInfo = sonarQubeConnectionInfo;
         testSubject.SelectedProject = serverProject;
 
-        testSubject.Unbind();
+        testSubject.AfterUnbind(new AdapterResponse(true));
 
         testSubject.SelectedConnectionInfo.Should().BeNull();
         testSubject.SelectedProject.Should().BeNull();
@@ -1025,4 +1088,10 @@ private void MockGetServerProjectByKey(bool success, ServerProject responseData)
             .Returns(Task.FromResult(new AdapterResponseWithData<ServerProject>(success, responseData)));
         connectedModeServices.SlCoreConnectionAdapter.Returns(slCoreConnectionAdapter);
     }
+
+    private async Task InitializeBoundProject()
+    {
+        SetupBoundProject(new ServerConnection.SonarCloud("my org"), serverProject);
+        await testSubject.DisplayBindStatusAsync();
+    }
 }
diff --git a/src/ConnectedMode/Binding/IUnintrusiveBindingController.cs b/src/ConnectedMode/Binding/IUnintrusiveBindingController.cs
index ef1b2b575..96d243289 100644
--- a/src/ConnectedMode/Binding/IUnintrusiveBindingController.cs
+++ b/src/ConnectedMode/Binding/IUnintrusiveBindingController.cs
@@ -28,6 +28,7 @@ namespace SonarLint.VisualStudio.ConnectedMode.Binding
     public interface IBindingController
     {
         Task BindAsync(BoundServerProject project, CancellationToken cancellationToken);
+        bool Unbind(string localBindingKey);
     }
     
     internal interface IUnintrusiveBindingController
@@ -43,13 +44,15 @@ internal class UnintrusiveBindingController : IUnintrusiveBindingController, IBi
         private readonly IBindingProcessFactory bindingProcessFactory;
         private readonly ISonarQubeService sonarQubeService;
         private readonly IActiveSolutionChangedHandler activeSolutionChangedHandler;
+        private readonly ISolutionBindingRepository solutionBindingRepository;
 
         [ImportingConstructor]
-        public UnintrusiveBindingController(IBindingProcessFactory bindingProcessFactory, ISonarQubeService sonarQubeService, IActiveSolutionChangedHandler activeSolutionChangedHandler)
+        public UnintrusiveBindingController(IBindingProcessFactory bindingProcessFactory, ISonarQubeService sonarQubeService, IActiveSolutionChangedHandler activeSolutionChangedHandler, ISolutionBindingRepository solutionBindingRepository)
         {
             this.bindingProcessFactory = bindingProcessFactory;
             this.sonarQubeService = sonarQubeService;
             this.activeSolutionChangedHandler = activeSolutionChangedHandler;
+            this.solutionBindingRepository = solutionBindingRepository;
         }
 
         public async Task BindAsync(BoundServerProject project, CancellationToken cancellationToken)
@@ -67,6 +70,17 @@ public async Task BindAsync(BoundServerProject project, IProgress<FixedStepsProg
             await bindingProcess.SaveServerExclusionsAsync(token);
         }
 
+        public bool Unbind(string localBindingKey)
+        {
+            var bindingDeleted = solutionBindingRepository.DeleteBinding(localBindingKey);
+            if (bindingDeleted)
+            {
+                sonarQubeService.Disconnect();
+                activeSolutionChangedHandler.HandleBindingChange(true);
+            }
+            return bindingDeleted;
+        }
+
         private IBindingProcess CreateBindingProcess(BoundServerProject project)
         {
             var bindingProcess = bindingProcessFactory.Create(new BindCommandArgs(project));
diff --git a/src/ConnectedMode/UI/ManageBinding/ManageBindingDialog.xaml b/src/ConnectedMode/UI/ManageBinding/ManageBindingDialog.xaml
index 6a0773237..dfa3b39cb 100644
--- a/src/ConnectedMode/UI/ManageBinding/ManageBindingDialog.xaml
+++ b/src/ConnectedMode/UI/ManageBinding/ManageBindingDialog.xaml
@@ -90,7 +90,7 @@
                         </Grid.ColumnDefinitions>
 
                         <Button Grid.Column="0" Content="{x:Static res:UiResources.UnbindButton}" IsEnabled="{Binding Path=IsUnbindButtonEnabled}" 
-                           Visibility="Collapsed" VerticalAlignment="Center"
+                           VerticalAlignment="Center"
                            Click="Unbind_OnClick"/>
                         <Button Grid.Column="1" Visibility="Collapsed" Content="{x:Static res:UiResources.ShareConfigurationButton}" ToolTip="{x:Static res:UiResources.ExportBindingConfigurationTooltip}"
                            IsEnabled="{Binding Path=IsExportButtonEnabled}" VerticalAlignment="Center"
@@ -170,7 +170,7 @@
 
             <Button Grid.Column="0" Content="{x:Static res:UiResources.BindButton}" IsDefault="True" IsEnabled="{Binding Path=IsBindButtonEnabled}"
                     Click="Binding_OnClick"/>
-            <Button Grid.Column="1" Content="{x:Static res:UiResources.CancelButton}" IsCancel="True"/> 
+            <Button Grid.Column="1" Content="{x:Static res:UiResources.CloseButton}" IsCancel="True"/> 
         </Grid>
 
         <Grid Grid.Row="4" HorizontalAlignment="Right" Visibility="{Binding  Path=IsCurrentProjectBound, Converter={StaticResource TrueToVisibleConverter}}">
diff --git a/src/ConnectedMode/UI/ManageBinding/ManageBindingDialog.xaml.cs b/src/ConnectedMode/UI/ManageBinding/ManageBindingDialog.xaml.cs
index 1173e3c44..484a1ca28 100644
--- a/src/ConnectedMode/UI/ManageBinding/ManageBindingDialog.xaml.cs
+++ b/src/ConnectedMode/UI/ManageBinding/ManageBindingDialog.xaml.cs
@@ -79,9 +79,9 @@ private async void ManageBindingDialog_OnInitialized(object sender, EventArgs e)
         }
     }
 
-    private void Unbind_OnClick(object sender, RoutedEventArgs e)
+    private async void Unbind_OnClick(object sender, RoutedEventArgs e)
     {
-        ViewModel.Unbind();
+        await ViewModel.UnbindWithProgressAsync();
     }
 
     private async void UseSharedBinding_OnClick(object sender, RoutedEventArgs e)
diff --git a/src/ConnectedMode/UI/ManageBinding/ManageBindingViewModel.cs b/src/ConnectedMode/UI/ManageBinding/ManageBindingViewModel.cs
index 0580cacaf..67eb8ca1b 100644
--- a/src/ConnectedMode/UI/ManageBinding/ManageBindingViewModel.cs
+++ b/src/ConnectedMode/UI/ManageBinding/ManageBindingViewModel.cs
@@ -21,6 +21,7 @@
 using System.Collections.ObjectModel;
 using System.Windows;
 using SonarLint.VisualStudio.ConnectedMode.Shared;
+using SonarLint.VisualStudio.ConnectedMode.UI.ManageConnections;
 using SonarLint.VisualStudio.ConnectedMode.UI.ProjectSelection;
 using SonarLint.VisualStudio.ConnectedMode.UI.Resources;
 using SonarLint.VisualStudio.Core.Binding;
@@ -48,6 +49,7 @@ private set
             RaisePropertyChanged();
         }
     }
+
     public IProgressReporterViewModel ProgressReporter { get; }
 
     public ServerProject BoundProject
@@ -65,12 +67,12 @@ public ServerProject BoundProject
         }
     }
 
-    public ConnectionInfo SelectedConnectionInfo    
+    public ConnectionInfo SelectedConnectionInfo
     {
         get => selectedConnectionInfo;
         set
         {
-            if(value == selectedConnectionInfo)
+            if (value == selectedConnectionInfo)
             {
                 return;
             }
@@ -84,7 +86,7 @@ public ConnectionInfo SelectedConnectionInfo
 
     public ObservableCollection<ConnectionInfo> Connections { get; } = [];
 
-    public ServerProject SelectedProject   
+    public ServerProject SelectedProject
     {
         get => selectedProject;
         set
@@ -119,24 +121,24 @@ internal SharedBindingConfigModel SharedBindingConfigModel
     public bool IsExportButtonEnabled => !ProgressReporter.IsOperationInProgress && IsCurrentProjectBound;
     public string ConnectionSelectionCaptionText => Connections.Any() ? UiResources.SelectConnectionToBindDescription : UiResources.NoConnectionExistsLabel;
 
-     public ManageBindingViewModel(
-         IConnectedModeServices connectedModeServices, 
-         IConnectedModeBindingServices connectedModeBindingServices,
-         IProgressReporterViewModel progressReporterViewModel)
+    public ManageBindingViewModel(
+        IConnectedModeServices connectedModeServices,
+        IConnectedModeBindingServices connectedModeBindingServices,
+        IProgressReporterViewModel progressReporterViewModel)
     {
         this.connectedModeServices = connectedModeServices;
         this.connectedModeBindingServices = connectedModeBindingServices;
         ProgressReporter = progressReporterViewModel;
     }
-    
+
     public async Task InitializeDataAsync()
     {
         var loadData = new TaskToPerformParams<AdapterResponse>(LoadDataAsync, UiResources.LoadingConnectionsText,
-                UiResources.LoadingConnectionsFailedText) { AfterProgressUpdated = OnProgressUpdated };
+            UiResources.LoadingConnectionsFailedText) { AfterProgressUpdated = OnProgressUpdated };
         await ProgressReporter.ExecuteTaskWithProgressAsync(loadData);
 
         var displayBindStatus = new TaskToPerformParams<AdapterResponse>(DisplayBindStatusAsync, UiResources.FetchingBindingStatusText,
-                UiResources.FetchingBindingStatusFailedText) { AfterProgressUpdated = OnProgressUpdated};
+            UiResources.FetchingBindingStatusFailedText) { AfterProgressUpdated = OnProgressUpdated };
         await ProgressReporter.ExecuteTaskWithProgressAsync(displayBindStatus);
 
         if (!IsCurrentProjectBound)
@@ -149,7 +151,7 @@ public async Task InitializeDataAsync()
 
     public async Task BindWithProgressAsync()
     {
-        var bind = new TaskToPerformParams<AdapterResponse>(BindAsync, UiResources.BindingInProgressText, UiResources.BindingFailedText){AfterProgressUpdated = OnProgressUpdated};
+        var bind = new TaskToPerformParams<AdapterResponse>(BindAsync, UiResources.BindingInProgressText, UiResources.BindingFailedText) { AfterProgressUpdated = OnProgressUpdated };
         await ProgressReporter.ExecuteTaskWithProgressAsync(bind);
     }
 
@@ -159,11 +161,14 @@ public async Task UseSharedBindingWithProgressAsync()
         await ProgressReporter.ExecuteTaskWithProgressAsync(bind);
     }
 
-    public void Unbind()
+    public async Task UnbindWithProgressAsync()
     {
-        BoundProject = null;
-        SelectedConnectionInfo = null;
-        SelectedProject = null;
+        var bind = new TaskToPerformParams<AdapterResponse>(UnbindAsync, UiResources.UnbindingInProgressText, UiResources.UnbindingFailedText)
+        {
+            AfterSuccess = AfterUnbind,
+            AfterProgressUpdated = OnProgressUpdated
+        };
+        await ProgressReporter.ExecuteTaskWithProgressAsync(bind);
     }
 
     public async Task ExportBindingConfigurationAsync()
@@ -184,7 +189,7 @@ public void Dispose()
     {
         cancellationTokenSource?.Dispose();
     }
-    
+
     internal Task<AdapterResponse> CheckForSharedBindingAsync()
     {
         SharedBindingConfigModel = connectedModeBindingServices.SharedBindingConfigProvider.GetSharedBinding();
@@ -246,7 +251,7 @@ internal bool LoadConnections()
         RaisePropertyChanged(nameof(ConnectionSelectionCaptionText));
         return succeeded;
     }
-    
+
     internal /* for testing */ async Task<AdapterResponse> DisplayBindStatusAsync()
     {
         var solutionName = await connectedModeBindingServices.SolutionInfoProvider.GetSolutionNameAsync();
@@ -258,16 +263,16 @@ internal bool LoadConnections()
         {
             return new AdapterResponse(true);
         }
-        
+
         var boundServerProject = connectedModeServices.ConfigurationProvider.GetConfiguration()?.Project;
         var serverConnection = boundServerProject?.ServerConnection;
         if (serverConnection == null)
         {
             return new AdapterResponse(false);
         }
-        
+
         var response = await connectedModeServices.SlCoreConnectionAdapter.GetServerProjectByKeyAsync(serverConnection, boundServerProject.ServerProjectKey);
-        
+
         SelectedConnectionInfo = ConnectionInfo.From(serverConnection);
         SelectedProject = response.ResponseData;
         BoundProject = SelectedProject;
@@ -283,6 +288,29 @@ internal bool LoadConnections()
         return await BindAsync(serverConnection, SelectedProject?.Key);
     }
 
+    internal async Task<AdapterResponse> UnbindAsync()
+    {
+        var succeeded = false;
+        try
+        {
+            await connectedModeServices.ThreadHandling.RunOnUIThreadAsync(() => succeeded = connectedModeBindingServices.BindingController.Unbind(SolutionInfo.Name));
+        }
+        catch (Exception ex)
+        {
+            connectedModeServices.Logger.WriteLine(ex.Message);
+            succeeded = false;
+        }
+
+        return new AdapterResponse(succeeded);
+    }
+
+    internal void AfterUnbind(AdapterResponse obj)
+    {
+        BoundProject = null;
+        SelectedConnectionInfo = null;
+        SelectedProject = null;
+    }
+
     private async Task<AdapterResponse> BindAsync(ServerConnection serverConnection, string serverProjectKey)
     {
         try
@@ -307,7 +335,8 @@ private bool ConnectionExists(ConnectionInfo connectionInfo, out ServerConnectio
         }
 
         connectedModeServices.Logger.WriteLine(ConnectedMode.Resources.UseSharedBinding_ConnectionNotFound, connectionInfo.Id);
-        connectedModeServices.MessageBox.Show(UiResources.NotFoundConnectionForSharedBindingMessageBoxText, UiResources.NotFoundConnectionForSharedBindingMessageBoxCaption, MessageBoxButton.OK, MessageBoxImage.Warning);
+        connectedModeServices.MessageBox.Show(UiResources.NotFoundConnectionForSharedBindingMessageBoxText, UiResources.NotFoundConnectionForSharedBindingMessageBoxCaption, MessageBoxButton.OK,
+            MessageBoxImage.Warning);
         return false;
     }
 
@@ -318,9 +347,9 @@ private bool CredentialsExists(ConnectionInfo connectionInfo, ServerConnection s
             return true;
         }
         connectedModeServices.Logger.WriteLine(ConnectedMode.Resources.UseSharedBinding_CredentiasNotFound, connectionInfo.Id);
-        connectedModeServices.MessageBox.Show(UiResources.NotFoundCredentialsForSharedBindingMessageBoxText, UiResources.NotFoundCredentialsForSharedBindingMessageBoxCaption, MessageBoxButton.OK, MessageBoxImage.Warning);
+        connectedModeServices.MessageBox.Show(UiResources.NotFoundCredentialsForSharedBindingMessageBoxText, UiResources.NotFoundCredentialsForSharedBindingMessageBoxCaption, MessageBoxButton.OK,
+            MessageBoxImage.Warning);
         return false;
-
     }
 
     private ConnectionInfo CreateConnectionInfoFromSharedBinding()
diff --git a/src/ConnectedMode/UI/Resources/Styles.xaml b/src/ConnectedMode/UI/Resources/Styles.xaml
index 577b064bc..2fa325f83 100644
--- a/src/ConnectedMode/UI/Resources/Styles.xaml
+++ b/src/ConnectedMode/UI/Resources/Styles.xaml
@@ -30,7 +30,7 @@
         <Setter Property="Padding" Value="5,2"/>
         <Setter Property="Foreground" Value="{DynamicResource {x:Static platformUi:CommonControlsColors.ButtonTextBrushKey}}" />
         <Setter Property="Background" Value="{DynamicResource {x:Static platformUi:CommonControlsColors.ButtonBrushKey}}" />
-        <Setter Property="BorderBrush" Value="{DynamicResource {x:Static platformUi:CommonControlsColors.ButtonBorderBrushKey}}" />
+        <Setter Property="BorderBrush" Value="{DynamicResource {x:Static platformUi:CommonControlsColors.ButtonBorderFocusedBrushKey}}" />
         <Setter Property="Template">
             <Setter.Value>
                 <ControlTemplate TargetType="Button">
diff --git a/src/ConnectedMode/UI/Resources/UiResources.Designer.cs b/src/ConnectedMode/UI/Resources/UiResources.Designer.cs
index 3b460ded9..113f61bcd 100644
--- a/src/ConnectedMode/UI/Resources/UiResources.Designer.cs
+++ b/src/ConnectedMode/UI/Resources/UiResources.Designer.cs
@@ -213,6 +213,15 @@ public static string ChooseConnectionTypeLabel {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Close.
+        /// </summary>
+        public static string CloseButton {
+            get {
+                return ResourceManager.GetString("CloseButton", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Discover which connection is best for your team .
         /// </summary>
@@ -944,6 +953,24 @@ public static string UnbindButton {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Unbinding the project failed.  Please check the SonarQube for Visual Studio logs for more details..
+        /// </summary>
+        public static string UnbindingFailedText {
+            get {
+                return ResourceManager.GetString("UnbindingFailedText", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Unbinding in progress....
+        /// </summary>
+        public static string UnbindingInProgressText {
+            get {
+                return ResourceManager.GetString("UnbindingInProgressText", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Failed to update the connection, please make sure that the credentials are correct..
         /// </summary>
diff --git a/src/ConnectedMode/UI/Resources/UiResources.resx b/src/ConnectedMode/UI/Resources/UiResources.resx
index 51ab389fe..51702a0e7 100644
--- a/src/ConnectedMode/UI/Resources/UiResources.resx
+++ b/src/ConnectedMode/UI/Resources/UiResources.resx
@@ -434,4 +434,13 @@ Please manually add the credentials for the connection and then try again.</valu
   <data name="RebindingFailedText" xml:space="preserve">
     <value>Failed to refresh binding, please make sure that the credentials are correct.</value>
   </data>
+  <data name="UnbindingInProgressText" xml:space="preserve">
+    <value>Unbinding in progress...</value>
+  </data>
+  <data name="UnbindingFailedText" xml:space="preserve">
+    <value>Unbinding the project failed.  Please check the SonarQube for Visual Studio logs for more details.</value>
+  </data>
+  <data name="CloseButton" xml:space="preserve">
+    <value>Close</value>
+  </data>
 </root>
\ No newline at end of file