public void SolutionBindingInformationProvider_GetBoundProjects_SolutionNotBound()
        {
            // Setup
            var testSubject = new SolutionBindingInformationProvider(this.serviceProvider);
            this.bindingSerializer.CurrentBinding = null;
            IEnumerable<Project> projects;

            // Act
            projects = testSubject.GetBoundProjects();

            // Verify
            AssertEmptyResult(projects);
        }
        public void SolutionBindingInformationProvider_GetBoundProjects_SolutionNotBound()
        {
            // Arrange
            var testSubject = new SolutionBindingInformationProvider(this.serviceProvider);

            this.bindingSerializer.CurrentBinding = null;
            IEnumerable <Project> projects;

            // Act
            projects = testSubject.GetBoundProjects();

            // Assert
            AssertEmptyResult(projects);
        }
        public void SolutionBindingInformationProvider_GetBoundProjects_SolutionBound_EmptyFilteredProjects()
        {
            // Arrange
            var testSubject = new SolutionBindingInformationProvider(this.serviceProvider);

            this.SetValidSolutionBinding();
            this.projectSystemHelper.FilteredProjects = new Project[0];
            IEnumerable <Project> projects;

            // Act
            projects = testSubject.GetBoundProjects();

            // Assert
            AssertEmptyResult(projects);
        }
        public void SolutionBindingInformationProvider_GetBoundProjects_SolutionNotBound_StandaloneMode()
        {
            // Arrange
            var testSubject = new SolutionBindingInformationProvider(this.serviceProvider);

            this.configProvider.ModeToReturn = SonarLintMode.Standalone;
            IEnumerable <Project> projects;

            // Act
            projects = testSubject.GetBoundProjects();

            // Assert
            AssertEmptyResult(projects);
            this.serviceProvider.AssertServiceNotUsed(typeof(IProjectSystemHelper));
        }
        public void SolutionBindingInformationProvider_GetUnboundProjects_HasNoBoundProjects()
        {
            // Arrange
            var testSubject = new SolutionBindingInformationProvider(this.serviceProvider);

            this.SetValidSolutionBinding();
            this.SetValidFilteredProjects();
            IEnumerable <Project> projects;

            // Act
            projects = testSubject.GetUnboundProjects();

            // Assert
            CollectionAssert.AreEquivalent(this.projectSystemHelper.FilteredProjects.ToArray(), projects.ToArray(), "Unexpected unbound projects");
        }
        public void SolutionBindingInformationProvider_GetUnboundProjects_SolutionNotBound_NewConnectedMode()
        {
            // Arrange
            var testSubject = new SolutionBindingInformationProvider(this.serviceProvider);

            this.configProvider.ModeToReturn    = SonarLintMode.Connected;
            this.configProvider.ProjectToReturn = new Persistence.BoundSonarQubeProject();
            IEnumerable <Project> projects;

            // Act
            projects = testSubject.GetUnboundProjects();

            // Assert
            AssertEmptyResult(projects);
            this.serviceProvider.AssertServiceNotUsed(typeof(IProjectSystemHelper));
        }
        public void SolutionBindingInformationProvider_GetBoundProjects_ValidSolution_SolutionRuleSetIsMissing()
        {
            // Arrange
            var testSubject = new SolutionBindingInformationProvider(this.serviceProvider);

            this.SetValidSolutionBinding();
            this.SetValidFilteredProjects();

            IEnumerable <Project> projects;

            // Act
            projects = testSubject.GetBoundProjects();

            // Assert
            AssertEmptyResult(projects);
        }
        public void SolutionBindingInformationProvider_GetUnboundProjects_HasBoundProjects()
        {
            // Arrange
            var testSubject = new SolutionBindingInformationProvider(this.serviceProvider);

            this.SetValidSolutionBinding();
            this.SetValidFilteredProjects();
            ProjectMock           boundProject   = SetValidSolutionAndProjectRuleSets();
            ProjectMock           unboundProject = this.projectSystemHelper.FilteredProjects.OfType <ProjectMock>().Except(new[] { boundProject }).SingleOrDefault();
            IEnumerable <Project> projects;

            // Act
            projects = testSubject.GetUnboundProjects();

            // Assert
            projects.SingleOrDefault().Should().Be(unboundProject, "Unexpected unbound project");
        }
        public void SolutionBindingInformationProvider_GetBoundProjects_ValidSolution_ProjectRuleSetIncludesSolutionRuleSet()
        {
            // Arrange
            var testSubject = new SolutionBindingInformationProvider(this.serviceProvider);

            this.SetValidSolutionBinding();
            this.SetValidFilteredProjects();
            ProjectMock           boundProject = SetValidSolutionAndProjectRuleSets();
            IEnumerable <Project> projects;

            // Act
            projects = testSubject.GetBoundProjects();

            // Assert
            projects.SingleOrDefault().Should().Be(boundProject, "Unexpected bound project");
            this.ruleSetSerializer.AssertAllRegisteredRuleSetsLoadedExactlyOnce();
        }
        public void GetUnboundProjects_Connected_ValidSolution_ProjectRuleSetIsMissing()
        {
            // Arrange
            var testSubject = new SolutionBindingInformationProvider(this.serviceProvider);
            var expected    = this.SetValidFilteredProjects();

            this.SetValidSolutionBinding(SonarLintMode.Connected);
            this.SetValidSolutionRuleSet(new RuleSet("SolutionRuleSet"), SonarLintMode.Connected);

            IEnumerable <Project> projects;

            // Act
            projects = testSubject.GetUnboundProjects();

            // Assert
            AssertExpectedProjects(expected, projects);
        }
        public void SolutionBindingInformationProvider_IsSolutionBound()
        {
            // Arrange
            var testSubject = new SolutionBindingInformationProvider(this.serviceProvider);

            // Case 1: Not bound
            this.bindingSerializer.CurrentBinding = null;

            // Act + Assert
            testSubject.IsSolutionBound().Should().BeFalse();

            // Case 2: Bound
            this.bindingSerializer.CurrentBinding = new Persistence.BoundSonarQubeProject();

            // Act + Assert
            testSubject.IsSolutionBound().Should().BeTrue();
        }
        public void SolutionBindingInformationProvider_IsSolutionBound()
        {
            // Setup
            var testSubject = new SolutionBindingInformationProvider(this.serviceProvider);

            // Case 1: Not bound
            this.bindingSerializer.CurrentBinding = null;

            // Act + Verify
            Assert.IsFalse(testSubject.IsSolutionBound());

            // Case 2: Bound
            this.bindingSerializer.CurrentBinding = new Persistence.BoundSonarQubeProject();

            // Act + Verify
            Assert.IsTrue(testSubject.IsSolutionBound());
        }
        public void SolutionBindingInformationProvider_IsSolutionBound()
        {
            // Setup
            var testSubject = new SolutionBindingInformationProvider(this.serviceProvider);

            // Case 1: Not bound
            this.bindingSerializer.CurrentBinding = null;

            // Act + Verify
            Assert.IsFalse(testSubject.IsSolutionBound());

            // Case 2: Bound
            this.bindingSerializer.CurrentBinding = new Persistence.BoundSonarQubeProject();

            // Act + Verify
            Assert.IsTrue(testSubject.IsSolutionBound());
        }
Beispiel #14
0
        internal static /* for testing purposes */ IBindingWorkflow CreateBindingWorkflow(IHost host, BindCommandArgs bindingArgs)
        {
            //Choose the type of binding
            var configProvider = host.GetService <IConfigurationProvider>();

            configProvider.AssertLocalServiceIsNotNull();

            var currentConfiguration = configProvider.GetConfiguration();

            SonarLintMode          modeToBind;
            INuGetBindingOperation nugetBindingOp;

            // If we are currently in standalone then the project is being bound for the first time.
            // Otherwise, we are updating an existing binding
            var isFirstBinding = currentConfiguration.Mode == SonarLintMode.Standalone;

            if (currentConfiguration.Mode == SonarLintMode.LegacyConnected)
            {
                host.Logger.WriteLine(Strings.Bind_UpdatingLegacyBinding);
                modeToBind     = SonarLintMode.LegacyConnected;
                nugetBindingOp = new NuGetBindingOperation(host, host.Logger);
            }
            else
            {
                host.Logger.WriteLine(
                    isFirstBinding ?
                    Strings.Bind_FirstTimeBinding :
                    Strings.Bind_UpdatingNewStyleBinding);

                modeToBind     = SonarLintMode.Connected;
                nugetBindingOp = new NoOpNuGetBindingOperation(host.Logger);
            }

            var solutionBindingOp = new SolutionBindingOperation(
                host,
                bindingArgs.Connection,
                bindingArgs.ProjectKey,
                bindingArgs.ProjectName,
                modeToBind,
                host.Logger);

            var bindingInformationProvider = new SolutionBindingInformationProvider(host);

            return(new BindingWorkflow(host, bindingArgs, solutionBindingOp, nugetBindingOp, bindingInformationProvider, isFirstBinding));
        }
        public void GetUnboundProjects_Connected_ValidSolution_SolutionRuleSetIsMissing()
        {
            // If the solution ruleset is missing then all projects will be returned as unbound

            // Arrange
            var testSubject = new SolutionBindingInformationProvider(this.serviceProvider);
            var expected    = this.SetValidFilteredProjects();

            this.SetValidSolutionBinding(SonarLintMode.Connected);

            IEnumerable <Project> projects;

            // Act
            projects = testSubject.GetUnboundProjects();

            // Assert
            AssertExpectedProjects(expected, projects);
        }
        public void GetUnboundProjects_Connected_ValidSolution_ProjectRuleSetIncludesSolutionRuleSet()
        {
            // Arrange
            var testSubject = new SolutionBindingInformationProvider(this.serviceProvider);
            var allProjects = this.SetValidFilteredProjects();

            this.SetValidSolutionBinding(SonarLintMode.Connected);
            ProjectMock boundProject = SetValidSolutionAndProjectRuleSets(SonarLintMode.Connected);

            IEnumerable <Project> projects;

            // Act
            projects = testSubject.GetUnboundProjects();

            // Assert
            AssertExpectedProjects(allProjects.Except(new Project[] { boundProject }), projects);
            this.ruleSetSerializer.AssertAllRegisteredRuleSetsLoadedExactlyOnce();
        }
Beispiel #17
0
        public void SolutionBindingInformationProvider_GetProjectKey()
        {
            // Arrange
            var testSubject = new SolutionBindingInformationProvider(this.serviceProvider);

            // Case 1: Not bound
            this.bindingSerializer.CurrentBinding = null;

            // Act + Assert
            testSubject.GetProjectKey().Should().BeNull();

            // Case 2: Bound
            this.bindingSerializer.CurrentBinding = new Persistence.BoundSonarQubeProject {
                ProjectKey = "PROJECT_KEY"
            };

            // Act + Assert
            testSubject.GetProjectKey().Should().Be("PROJECT_KEY");
        }
        public void SolutionBindingInformationProvider_GetBoundProjects_ValidSolution_ProjectRuleSetIncludesSolutionRuleSet_RuleSetAggregation()
        {
            // Arrange
            var testSubject = new SolutionBindingInformationProvider(this.serviceProvider);

            this.SetValidSolutionBinding();
            this.SetValidFilteredProjects();
            // Duplicate the configurations, which will create duplicate rule sets
            this.projectSystemHelper.FilteredProjects.OfType <ProjectMock>().ToList().ForEach(p => this.SetValidProjectConfiguration(p, "AnotherConfiguration"));
            ProjectMock           boundProject = SetValidSolutionAndProjectRuleSets();
            IEnumerable <Project> projects;

            // Act
            projects = testSubject.GetBoundProjects();

            // Assert
            projects.SingleOrDefault().Should().Be(boundProject, "Unexpected bound project");
            this.ruleSetSerializer.AssertAllRegisteredRuleSetsLoadedExactlyOnce();
        }
        public void GetUnboundProjects_Connected_ValidSolution_ProjectRuleSetIncludesSolutionRuleSet_RuleSetAggregation()
        {
            // Arrange
            var testSubject = new SolutionBindingInformationProvider(this.serviceProvider);
            var allProjects = this.SetValidFilteredProjects();

            // Duplicate the configurations, which will create duplicate rule sets
            allProjects.OfType <ProjectMock>().ToList().ForEach(p => this.SetValidProjectConfiguration(p, "AnotherConfiguration"));

            this.SetValidSolutionBinding(SonarLintMode.Connected);
            ProjectMock boundProject = SetValidSolutionAndProjectRuleSets(SonarLintMode.Connected);

            IEnumerable <Project> projects;

            // Act
            projects = testSubject.GetUnboundProjects();

            // Assert
            AssertExpectedProjects(allProjects.Except(new Project[] { boundProject }), projects);
            this.ruleSetSerializer.AssertAllRegisteredRuleSetsLoadedExactlyOnce();
        }
        public void SolutionBindingInformationProvider_GetBoundProjects_ValidSolution_ProjectRuleSetNotIncludingSolutionRuleSet()
        {
            // Arrange
            var testSubject = new SolutionBindingInformationProvider(this.serviceProvider);

            this.SetValidSolutionBinding();
            this.SetValidFilteredProjects();
            this.SetValidSolutionRuleSet(new RuleSet("SolutionRuleSet"));
            this.SetValidProjectRuleSets((project, filePath) => new RuleSet("ProjectRuleSet")
            {
                FilePath = filePath
            });

            IEnumerable <Project> projects;

            // Act
            projects = testSubject.GetBoundProjects();

            // Assert
            AssertEmptyResult(projects);
        }
        public void GetUnboundProjects_Legacy_ValidSolution_ProjectRuleSetNotIncludingSolutionRuleSet()
        {
            // Arrange
            var testSubject = new SolutionBindingInformationProvider(this.serviceProvider);
            var expected    = this.SetValidFilteredProjects();

            this.SetValidProjectRuleSets((project, filePath) => new RuleSet("ProjectRuleSet")
            {
                FilePath = filePath
            });

            this.SetValidSolutionBinding(SonarLintMode.LegacyConnected);
            this.SetValidSolutionRuleSet(new RuleSet("SolutionRuleSet"), SonarLintMode.LegacyConnected);

            IEnumerable <Project> projects;

            // Act
            projects = testSubject.GetUnboundProjects();

            // Assert
            AssertExpectedProjects(expected, projects);
        }
        public void SolutionBindingInformationProvider_GetBoundProjects_SolutionBound_EmptyFilteredProjects()
        {
            // Setup
            var testSubject = new SolutionBindingInformationProvider(this.serviceProvider);
            this.SetValidSolutionBinding();
            this.projectSystemHelper.FilteredProjects = new Project[0];
            IEnumerable<Project> projects;

            // Act
            projects = testSubject.GetBoundProjects();

            // Verify
            AssertEmptyResult(projects);
        }
        public void SolutionBindingInformationProvider_GetUnboundProjects_HasNoBoundProjects()
        {
            // Setup
            var testSubject = new SolutionBindingInformationProvider(this.serviceProvider);
            this.SetValidSolutionBinding();
            this.SetValidFilteredProjects();
            IEnumerable<Project> projects;

            // Act
            projects = testSubject.GetUnboundProjects();

            // Verify
            CollectionAssert.AreEquivalent(this.projectSystemHelper.FilteredProjects.ToArray(), projects.ToArray(), "Unexpected unbound projects");
        }
        public void SolutionBindingInformationProvider_GetUnboundProjects_HasBoundProjects()
        {
            // Setup
            var testSubject = new SolutionBindingInformationProvider(this.serviceProvider);
            this.SetValidSolutionBinding();
            this.SetValidFilteredProjects();
            ProjectMock boundProject = SetValidSolutionAndProjectRuleSets();
            ProjectMock unboundProject = this.projectSystemHelper.FilteredProjects.OfType<ProjectMock>().Except(new[] { boundProject }).SingleOrDefault();
            IEnumerable<Project> projects;

            // Act
            projects = testSubject.GetUnboundProjects();

            // Verify
            Assert.AreSame(unboundProject, projects.SingleOrDefault(), "Unexpected unbound project");
        }
        public void SolutionBindingInformationProvider_GetBoundProjects_ValidSolution_ProjectRuleSetIncludesSolutionRuleSet_RuleSetAggregation()
        {
            // Setup
            var testSubject = new SolutionBindingInformationProvider(this.serviceProvider);
            this.SetValidSolutionBinding();
            this.SetValidFilteredProjects();
            // Duplicate the configurations, which will create duplicate rule sets
            this.projectSystemHelper.FilteredProjects.OfType<ProjectMock>().ToList().ForEach(p => this.SetValidProjectConfiguration(p, "AnotherConfiguration"));
            ProjectMock boundProject = SetValidSolutionAndProjectRuleSets();
            IEnumerable<Project> projects;

            // Act
            projects = testSubject.GetBoundProjects();

            // Verify
            Assert.AreSame(boundProject, projects.SingleOrDefault(), "Unexpected bound project");
            this.ruleSetSerializer.AssertAllRegisteredRuleSetsLoadedExactlyOnce();
        }
        public void SolutionBindingInformationProvider_GetBoundProjects_ValidSolution_ProjectRuleSetIncludesSolutionRuleSet()
        {
            // Setup
            var testSubject = new SolutionBindingInformationProvider(this.serviceProvider);
            this.SetValidSolutionBinding();
            this.SetValidFilteredProjects();
            ProjectMock boundProject = SetValidSolutionAndProjectRuleSets();
            IEnumerable<Project> projects;

            // Act
            projects = testSubject.GetBoundProjects();

            // Verify
            Assert.AreSame(boundProject, projects.SingleOrDefault(), "Unexpected bound project");
            this.ruleSetSerializer.AssertAllRegisteredRuleSetsLoadedExactlyOnce();
        }
        public void SolutionBindingInformationProvider_GetBoundProjects_ValidSolution_ProjectRuleSetNotIncludingSolutionRuleSet()
        {
            // Setup
            var testSubject = new SolutionBindingInformationProvider(this.serviceProvider);
            this.SetValidSolutionBinding();
            this.SetValidFilteredProjects();
            this.SetValidSolutionRuleSet(new RuleSet("SolutionRuleSet"));
            this.SetValidProjectRuleSets((project, filePath) => new RuleSet("ProjectRuleSet") { FilePath = filePath });

            IEnumerable<Project> projects;

            // Act
            projects = testSubject.GetBoundProjects();

            // Verify
            AssertEmptyResult(projects);
        }
        public void SolutionBindingInformationProvider_GetBoundProjects_ValidSolution_SolutionRuleSetIsMissing()
        {
            // Setup
            var testSubject = new SolutionBindingInformationProvider(this.serviceProvider);
            this.SetValidSolutionBinding();
            this.SetValidFilteredProjects();

            IEnumerable<Project> projects;

            // Act
            projects = testSubject.GetBoundProjects();

            // Verify
            AssertEmptyResult(projects);
        }