public void Constructor_ValidParams()
 {
     var configuration = new Config
     {
         ReferencesConfig = new List<ReferenceConfig>()
     };
     _configProvider.Load<Config>(null).ReturnsForAnyArgs(configuration);
     new ProjectManager("dummy", _configProvider, _logger);
 }
Exemple #2
0
        public ProjectManager(string configFile, IConfigProvider configProvider, ILogger logger, IFileSystem fileSystem)
        {
            if (configFile == null) throw new ArgumentNullException("configFile");
            if (configProvider == null) throw new ArgumentNullException("configProvider");
            if (logger == null) throw new ArgumentNullException("logger");
            if (fileSystem == null) throw new ArgumentNullException("fileSystem");
            if (string.IsNullOrEmpty(configFile)) throw new ArgumentException("configFile must be defined");

            _logger = logger;
            _fileSystem = fileSystem;
            _config = configProvider.Load<Config>(configFile);
            _changedProjects = new List<string>();
            _changedSolutions = new List<string>();

            _processedReferences = new Dictionary<ReferenceConfig, bool>(_config.ReferencesConfig.Count);
            foreach (var referenceConfig in ReferencesConfig)
            {
                _processedReferences.Add(referenceConfig, false);
            }
        }
        public void Constructor_LoadsMultipleReferenceConfigs()
        {
            //Arrange
            var configuration = new Config
            {
                Include = new List<string>(),
                ReferencesConfig = new List<ReferenceConfig>
                {
                    new ReferenceConfig {ProjectReference = "test1", AssemblyReference = "test1"},
                    new ReferenceConfig {ProjectReference = "test2", AssemblyReference = "test2"}
                }
            };

            _configProvider.Load<Config>(null).ReturnsForAnyArgs(configuration);

            //Act
            var manager = new ProjectManager("dummy", _configProvider, _logger);

            //Assert
            Assert.That(manager.NotFoundReferences.Count == 2);
        }
        public void FixProject_ProjectIsNull_ReturnsFalse()
        {
            //Arrange
            var configuration = new Config
            {
                Include = new List<string>(),
                ReferencesConfig = new List<ReferenceConfig>()
            };
            _configProvider.Load<Config>(null).ReturnsForAnyArgs(configuration);

            var manager = new ProjectManager("dummy", _configProvider, _logger);

            //Act
            var fixProject = manager.FixProject(null);

            //Assert
            Assert.IsFalse(fixProject);
        }
        public void ListProjects_TwoPatshBothWithOneProject_ProjectCountTwo()
        {
            //Arrange
            var configuration = new Config
            {
                Include = new List<string> {"dummyPath", "dummyPath2"},
                ReferencesConfig = new List<ReferenceConfig>()
            };
            _configProvider.Load<Config>(null).ReturnsForAnyArgs(configuration);
            var fileSystem = Substitute.For<IFileSystem>();

            fileSystem.GetProjects(null).ReturnsForAnyArgs(
                new List<Project>
                {
                    new Project()
                });

            fileSystem.GetDirectories(null).ReturnsForAnyArgs(Enumerable.Empty<string>());

            var manager = new ProjectManager("dummy", _configProvider, _logger, fileSystem);

            //Act
            var prjs = manager.ListProjects();

            //Assert
            Assert.AreEqual(2, prjs.Count);
        }
        public void ListProjects_TwoPathsBothWithMultipleProjects_ProjectCountEqualsNumberOfProjectsInBothPaths()
        {
            //Arrange
            var random = new Random();
            var numberOfProjectsPath1 = random.Next(2, 10);
            var numberOfProjectsPath2 = random.Next(2, 10);
            var totalNumberOfProjects = numberOfProjectsPath1 + numberOfProjectsPath2;
            var projectsPath1 = Enumerable.Repeat(new Project(), numberOfProjectsPath1);
            var projectsPath2 = Enumerable.Repeat(new Project(), numberOfProjectsPath2);

            var configuration = new Config
            {
                Include = new List<string> {"dummyPath", "dummyPath2"},
                ReferencesConfig = new List<ReferenceConfig>()
            };
            _configProvider.Load<Config>(null).ReturnsForAnyArgs(configuration);
            var fileSystem = Substitute.For<IFileSystem>();

            fileSystem.GetProjects("dummyPath").Returns(new List<Project>(projectsPath1));
            fileSystem.GetProjects("dummyPath2").Returns(new List<Project>(projectsPath2));
            fileSystem.GetDirectories(null).ReturnsForAnyArgs(Enumerable.Empty<string>());

            var manager = new ProjectManager("dummy", _configProvider, _logger, fileSystem);

            //Act
            var prjs = manager.ListProjects();

            //Assert
            Assert.AreEqual(totalNumberOfProjects, prjs.Count);
        }
        public void ListProjects_NoPaths_ProjectCountZero()
        {
            //Arrange
            var configuration = new Config
            {
                Include = new List<string>(),
                ReferencesConfig = new List<ReferenceConfig>()
            };

            _configProvider.Load<Config>(null).ReturnsForAnyArgs(configuration);
            var fileSystem = Substitute.For<IFileSystem>();
            var manager = new ProjectManager("dummy", _configProvider, _logger, fileSystem);

            //Act
            var projectCount = manager.ListProjects();

            //Assert
            Assert.AreEqual(0, projectCount.Count);
        }