public void TestStream()
        {
            Stream stream1 = "test".AsStream();
            IFileSystem fs = new MockFileSystem();
            fs.AddFile(@"c:\test.config",stream1);
            //Stream stream2 = fs.OpenFile();

        }
 public void TestFixtureSetUp()
 {
     _mockFileSystem = new MockFileSystem();
     _packageManager = new PackageManager(
         AggregateRepositoryHelper.CreateAggregateRepositoryFromSources(Utilities.GetFactory(),
                                                                        Utilities.GetSourceProvider(),
                                                                        new List<string>() { "Dev" }),
         new DefaultPackagePathResolver(_mockFileSystem), _mockFileSystem);
 }
 public void Setup()
 {
     _mfs = new MockFileSystem();
     _mfs.CreateDirectory(@"c:\files");
     _mfs.CreateDirectory(@"c:\files\TestSolution");
     _mfs.CreateDirectory(@"c:\files\TestSolution\packages");
     _mfs.AddFile(@"c:\files\TestSolution\packages\repositories.config", baseRepositoriesConfig);
     _mfs.AddFile(@"c:\files\TestSolution\repositories.config", baseRepositoriesConfig);
     _mfs.CreateDirectory(@"c:\random\empty");
 }
        public void NugettedProjectHasPackagesConfigAddedToRepositoriesConfig()
        {
            const string projectRoot = "c:\\projectRoot";
            var fileSystem = new MockFileSystem(projectRoot);
            var singleDependency = ProjectReferenceTestData.ConstructMockDependency();
            var projectWithSingleDependency = ProjectReferenceTestData.ConstructMockProject(new[] { singleDependency.Object });
            var packageRepositoryWithOnePackage = ProjectReferenceTestData.CreateMockRepository();
            var repositoriesConfig = new Mock<ISharedPackageRepository>();

            var nugetifier = ReferenceNugetifierTester.BuildNugetifier(vsProject: projectWithSingleDependency, packageRepository: packageRepositoryWithOnePackage, projectFileSystem: fileSystem);
            var nugettedDependencies = ReferenceNugetifierTester.AddReferenceMetadata(nugetifier, repositoriesConfig, new DirectoryInfo(projectRoot));

            Assert.That(nugettedDependencies, Is.Not.Empty);
            repositoriesConfig.Verify(r => r.RegisterRepository(It.Is<string>(path => path.StartsWith(projectRoot))));
        }
        public void ReferenceToPackageIdNotOnFeedStays()
        {
            var fileSystem = new MockFileSystem(@"d:\");
            fileSystem.AddFile(@"d:\test\packages.config",
                "<packages>" +
                    "<package id=\"Missing\" version=\"1.0.0.0\" />" +
                "</packages>");

            var repository = new MockPackageRepository("http://test.com");

            var command = new FixReferences(fileSystem, repository, new Console()) { Directory = @"d:\test" };
            command.Execute();

            var packageReferences = new PackageReferenceFile(fileSystem, @"d:\test\packages.config").GetPackageReferences().ToList();
            Assert.AreEqual("1.0.0.0", packageReferences.First(p => p.Id == "Missing").Version.Version.ToString());
        }
        public void CanCleanPackageFolders()
        {
            var mfs = new MockFileSystem();

            mfs.CreateDirectory("c:\\packages\\Component");
            mfs.AddFile("c:\\packages\\Component\\test.txt", "blah");
            mfs.AddFile("c:\\packages\\Component\\test.dll","blah");
            mfs.AddFile("c:\\packages\\repositories.config","blah");

            var re = new Mock<IRepositoryEnumerator>();
            re.Setup(r => r.GetPackageReferenceFiles(It.IsAny<FileInfo>())).Returns(new List<PackageReferenceFile>());
            var repositoryManager = new RepositoryManager(@"c:\packages\repositories.config", re.Object, mfs);
            
            Assert.AreEqual(1, mfs.GetDirectories(repositoryManager.RepositoryConfig.Directory.FullName).Count());
            
            //_repositoryManager.CleanPackageFolders();

            Assert.AreEqual(0, mfs.GetDirectories(repositoryManager.RepositoryConfig.Directory.FullName).Count());
        }
        public void ConstructParser()
        {
            var mfs = new MockFileSystem();
            var correctConfig = @"<?xml version='1.0' encoding='utf-8'?>
                                    <repositories>
                                        <repository path='..\Project1\packages.config' />
                                        <repository path='..\Project2\packages.config' />
                                        <repository path='..\Project3\packages.config' />
                                    </repositories>";

            mfs.AddFile(@"c:\packages\repositories.config", correctConfig);
            mfs.AddFile(@"c:\project1\packages.config", correctConfig);
            mfs.AddFile(@"c:\project2\packages.config", correctConfig);
            mfs.AddFile(@"c:\project3\packages.config", correctConfig);
            mfs.AddFile(@"c:\packages\repositories.config", correctConfig);

            var repositoryManager = new RepositoryManager(@"c:\packages\repositories.config", new RepositoryEnumerator(mfs), mfs);
            Assert.IsNotNull(repositoryManager);
            Assert.AreEqual(3, repositoryManager.PackageReferenceFiles.Count());
        }
        public void CanDetectMissingVersionAndUpdateToValid()
        {
            var fileSystem = new MockFileSystem(@"d:\");
            fileSystem.AddFile(@"d:\test\packages.config",
                "<packages>" +
                    "<package id=\"Test\" version=\"1.0.0.0\" />" +
                    "<package id=\"Other\" version=\"1.0.0.0\" />" +
                "</packages>");

            var repository = new MockPackageRepository("http://test.com");
            repository.AddPackage(PackageUtility.CreatePackage("Test", "2.0.0.0"));
            repository.AddPackage(PackageUtility.CreatePackage("Other", "1.0.0.0"));

            var command = new FixReferences(fileSystem, repository, new Console()) {Directory = @"d:\test"};
            command.Execute();

            var packageReferences = new PackageReferenceFile(fileSystem, @"d:\test\packages.config").GetPackageReferences().ToList();
            Assert.AreEqual("2.0.0.0", packageReferences.First(p => p.Id == "Test").Version.Version.ToString());
            Assert.AreEqual("1.0.0.0", packageReferences.First(p => p.Id == "Other").Version.Version.ToString());
        }
        public void CanEnumerateOverSet()
        {
            IFileSystem fs = new MockFileSystem();
            var test1 = @"c:\test1\packages.config";
            var test2 = @"c:\test1\packages.config";

            var p1 = @"<packages>
                      <package id='Test' version='1.0.0.0' />
                      <package id='Test' version='1.1.0.0' />
                      <package id='Test' version='1.2.0.07' />
                    </packages>";

            var p2 = @"<packages>
                      <package id='Test' version='1.0.0.0' />
                      <package id='Test' version='1.1.0.0' />
                      <package id='Test' version='1.2.0.07' />
                    </packages>";

            fs.AddFile(test1, p1.AsStream());
            fs.AddFile(test2, p2.AsStream());

            var list = new List<PackageReferenceFile>();

            list.Add(new PackageReferenceFile(fs, test1));
            list.Add(new PackageReferenceFile(fs, test2));


            PackageEnumerator enumerator = new PackageEnumerator();
            var idOnly = enumerator.GetPackageReferences(list, (a, b) => { }, PackageReferenceEqualityComparer.Id);
            Assert.AreEqual(1, idOnly.Count());

            var idAndVersion = enumerator.GetPackageReferences(list, (a, b) => { }, PackageReferenceEqualityComparer.IdAndVersion);
            Assert.AreEqual(3, idAndVersion.Count());


        }
        public void WillChoosePackageWithSmallestNumberOfAssembliesFromMultipleMatches()
        {
            var packages = new List<IPackage> 
            {
                PackageUtility.CreatePackage(AssemblyCommon, "1.0", assemblyReferences: new List<string>() { AssemblyCommonDll }),
                PackageUtility.CreatePackage("Assembly.Other", "1.0", assemblyReferences: new List<string>() { AssemblyCommonDll, "Assembly.Other.dll" }) 
            };

            var assemblies = new List<string>() { AssemblyCommonDll };
            var filesystem = new MockFileSystem();

            var assemblyResolver = new RepositoryAssemblyResolver(assemblies, packages.AsQueryable(), filesystem, new Mock<IConsole>().Object);
            var resolved = assemblyResolver.GetAssemblyToPackageMapping(false);
            resolved.OutputPackageConfigFile();
            Assert.AreEqual(1, filesystem.Paths.Count);
            var file = new PackageReferenceFile(filesystem, string.Concat(filesystem.Root, ".\\packages.config"));
            Assert.AreEqual(1, file.GetPackageReferences().Count());
            Assert.AreEqual(true, file.EntryExists(AssemblyCommon,SemanticVersion.Parse("1.0")));
        }
        public void CanOutputPackageConfigWithSingleEntry()
        {
            var fileList = new List<string>() { AssemblyCommonDll };
            var packages = new List<IPackage> { PackageUtility.CreatePackage(AssemblyCommon, "1.0", assemblyReferences: fileList) };

            var assemblies = new List<string>() { AssemblyCommonDll };
            var filesystem = new MockFileSystem();
            //filesystem.Root = @"c:\test";

            var assemblyResolver = new RepositoryAssemblyResolver(assemblies, packages.AsQueryable(), filesystem, new Mock<IConsole>().Object);
            var resolved = assemblyResolver.GetAssemblyToPackageMapping(false);
            resolved.OutputPackageConfigFile();
            Assert.AreEqual(1,filesystem.Paths.Count);
            var file = new PackageReferenceFile(filesystem, string.Concat(filesystem.Root, ".\\packages.config"));
            Assert.AreEqual(1, file.GetPackageReferences().Count());
        }
 public void ConstructorException(string repositoryConfigPath)
 {
     var mfs = new MockFileSystem();
     mfs.AddFile(repositoryConfigPath);
     new RepositoryGroupManager(repositoryConfigPath, mfs);
 }
        public void TargetFrameworkAppearsInPackagesConfig(string targetFrameworkString)
        {
            FrameworkName targetFramework = targetFrameworkString != null ? VersionUtility.ParseFrameworkName(targetFrameworkString) : null;
            var singleDependency = ProjectReferenceTestData.ConstructMockDependency();
            var projectWithSingleDependency = ProjectReferenceTestData.ConstructMockProject(new[] { singleDependency.Object });
            var packageRepositoryWithCorrespondingPackage = ProjectReferenceTestData.CreateMockRepository();
            var projectFileSystem = new MockFileSystem();
            var nugetifier = ReferenceNugetifierTester.BuildNugetifier(vsProject: projectWithSingleDependency, packageRepository: packageRepositoryWithCorrespondingPackage, projectFileSystem: projectFileSystem);

            ReferenceNugetifierTester.AddReferenceMetadata(nugetifier, targetFrameWork: targetFramework);

            var packageConfigs = projectFileSystem.Paths.Select(pathAndData => new PackageReferenceFile(projectFileSystem, pathAndData.Key));
            var packageReferences = packageConfigs.SelectMany(config => config.GetPackageReferences()).ToList();
            Assert.That(packageReferences, Is.Not.Empty);
            Assert.That(packageReferences, Has.All.Matches<PackageReference>(x => Equals(targetFramework, x.TargetFramework)));
        }