Feature/create cli (#3)

* Add list command

* #1 : Add list command

* #1 : Add project reader

* #2 : Add version update commands

* #2 : Add version tests

* #2 : Add set command

* #2 : Add set tests

* Update and rename dotnet-core.yml to build.yml

* Update build.yml

Author: oliver254

.github/workflows/dotnet-core.yml .github/workflows/build.yml

@@ -1,4 +1,4 @@
-name: .NET Core
+name: Build
 
 on:
   push:
@@ -16,7 +16,7 @@ jobs:
     - name: Setup .NET Core
       uses: actions/setup-dotnet@v1
       with:
-        dotnet-version: 3.1.301
+        dotnet-version: 5.0.x
     - name: Install dependencies
       run: dotnet restore
     - name: Build

README.md

@@ -1,2 +1,40 @@
 # UpdateVersion
-Update-Version is a developper tool to update the Visual Studio project versions.
+
+Update-Version is a developper tool to update the .Net project versions.
+
+## Installing UpdateVersion
+
+Install UpdateVersion via the following command:
+
+```text
+$ dotnet tool install -g Monbsoft.UpdateVersion
+```
+
+## How To Use
+
+Run `UpdateVersion --help` for information about usage.
+
+```text
+UpdateVersion:
+  Developper tool to update the Visual Studio project versions.
+
+Usage:
+  UpdateVersion [options] [command]
+
+Options:
+  -?, -h, --help    Show help and usage information
+  --version         Show version information
+
+Commands:
+  list    Lists all project versions
+```
+
+## Usage
+
+### Major version update
+
+Update major versions via the following command:
+
+```text
+$ UpdateVersion major
+```

UpdateVersion.sln

@@ -3,7 +3,11 @@ Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio Version 16
 VisualStudioVersion = 16.0.30717.126
 MinimumVisualStudioVersion = 10.0.40219.1
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Monbsoft.UpdateVersion", "src\Monbsoft.UpdateVersion\Monbsoft.UpdateVersion.csproj", "{DA8669FD-210C-4BB4-A2FA-97B244BBFBEB}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Monbsoft.UpdateVersion", "src\Monbsoft.UpdateVersion\Monbsoft.UpdateVersion.csproj", "{DA8669FD-210C-4BB4-A2FA-97B244BBFBEB}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Monbsoft.UpdateVersion.Tests", "test\Monbsoft.UpdateVersion.Tests\Monbsoft.UpdateVersion.Tests.csproj", "{A5FC3208-92F2-4B43-A863-A5C4D30EBFE0}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "test", "test", "{8E10E03A-B534-4A14-965C-D82BD93D05B3}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -15,10 +19,17 @@ Global
 		{DA8669FD-210C-4BB4-A2FA-97B244BBFBEB}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{DA8669FD-210C-4BB4-A2FA-97B244BBFBEB}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{DA8669FD-210C-4BB4-A2FA-97B244BBFBEB}.Release|Any CPU.Build.0 = Release|Any CPU
+		{A5FC3208-92F2-4B43-A863-A5C4D30EBFE0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{A5FC3208-92F2-4B43-A863-A5C4D30EBFE0}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{A5FC3208-92F2-4B43-A863-A5C4D30EBFE0}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{A5FC3208-92F2-4B43-A863-A5C4D30EBFE0}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
+	GlobalSection(NestedProjects) = preSolution
+		{A5FC3208-92F2-4B43-A863-A5C4D30EBFE0} = {8E10E03A-B534-4A14-965C-D82BD93D05B3}
+	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {0B857B9C-B6E3-4386-834E-656B9476EB16}
 	EndGlobalSection

src/Monbsoft.UpdateVersion/Commands/BuildCommand.cs

@@ -0,0 +1,36 @@
+using Monbsoft.UpdateVersion.Core;
+using System;
+using System.Collections.Generic;
+using System.CommandLine;
+using System.CommandLine.Invocation;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Monbsoft.UpdateVersion.Commands
+{
+    public class BuildCommand : VersionCommandBase
+    {
+        public static Command Create()
+        {
+            var command = new Command("build", "Increment build version number");
+
+            command.Handler = CommandHandler.Create<VersionCommandArguments>(args =>
+            {
+                var context = new CommandContext(args.Console, args.Verbosity)
+                {
+                    Directory = Directory.GetCurrentDirectory()
+                };
+                var command = new PatchCommand();
+                command.Execute(context);
+            });
+
+            return command;
+        }
+
+        public void Execute(CommandContext context)
+        {
+        }
+    }
+}

src/Monbsoft.UpdateVersion/Commands/ListCommand.cs

@@ -0,0 +1,48 @@
+using Monbsoft.UpdateVersion.Core;
+using Monbsoft.UpdateVersion.Models;
+using System.CommandLine;
+using System.CommandLine.Invocation;
+using System.IO;
+
+namespace Monbsoft.UpdateVersion.Commands
+{
+    public class ListCommand
+    {
+        public static Command Create()
+        {
+            var command = new Command("list", "Lists all project versions");
+
+            command.Handler = CommandHandler.Create<ListCommandArguments>(args =>
+            {
+                var context = new CommandContext(args.Console, args.Verbosity)
+                {
+                    Directory = Directory.GetCurrentDirectory()
+                };
+                var command = new ListCommand();
+                command.Execute(context);
+            });
+
+            return command;
+        }
+
+        public void Execute(CommandContext context)
+        {
+            var reader = new ProjectStore();
+            var finder = new ProjectFinder(context.Directory);
+            var projectFiles = finder.FindProjects();
+
+            foreach (var projectFile in projectFiles)
+            {
+                var project = reader.Read(projectFile);
+                context.WriteInfo($"\t{project.Name} -> {project.Version}");
+            }
+        }
+
+        private class ListCommandArguments
+        {
+            public IConsole Console { get; set; } = default;
+            public FileInfo Path { get; set; } = default;
+            public Verbosity Verbosity { get; set; } = Verbosity.Info;
+        }
+    }
+}

src/Monbsoft.UpdateVersion/Commands/MajorCommand.cs

@@ -0,0 +1,36 @@
+using Monbsoft.UpdateVersion.Core;
+using System.CommandLine;
+using System.CommandLine.Invocation;
+using System.IO;
+
+namespace Monbsoft.UpdateVersion.Commands
+{
+    public class MajorCommand : VersionCommandBase
+    {
+        public static Command Create()
+        {
+            var command = new Command("major", "Increments major version number");
+
+            command.Handler = CommandHandler.Create<VersionCommandArguments>(args =>
+            {
+                var context = new CommandContext(args.Console, args.Verbosity)
+                {
+                    Directory = Directory.GetCurrentDirectory()
+                };
+                var command = new MajorCommand();
+                command.Execute(context);
+            });
+
+            return command;
+        }
+
+        public void Execute(CommandContext context)
+        {
+            int count = Update(context, (oldVersion) =>
+            {
+                return oldVersion.Change(major: oldVersion.Major + 1, 0, 0);
+            });
+            context.WriteInfo($"{count} major versions are updated.");
+        }
+    }
+}

src/Monbsoft.UpdateVersion/Commands/MinorCommand.cs

@@ -0,0 +1,36 @@
+using Monbsoft.UpdateVersion.Core;
+using System.CommandLine;
+using System.CommandLine.Invocation;
+using System.IO;
+
+namespace Monbsoft.UpdateVersion.Commands
+{
+    public class MinorCommand : VersionCommandBase
+    {
+        public static Command Create()
+        {
+            var command = new Command("minor", "Increments minor version number");
+
+            command.Handler = CommandHandler.Create<VersionCommandArguments>(args =>
+            {
+                var context = new CommandContext(args.Console, args.Verbosity)
+                {
+                    Directory = Directory.GetCurrentDirectory()
+                };
+                var command = new MinorCommand();
+                command.Execute(context);
+            });
+
+            return command;
+        }
+
+        public void Execute(CommandContext context)
+        {
+            int count = Update(context, (oldVersion) =>
+            {
+                return oldVersion.Change(minor: oldVersion.Minor + 1, patch: 0);
+            });
+            context.WriteInfo($"{count} minor versions are updated.");
+        }
+    }
+}

src/Monbsoft.UpdateVersion/Commands/PatchCommand.cs

@@ -0,0 +1,36 @@
+using Monbsoft.UpdateVersion.Core;
+using System.CommandLine;
+using System.CommandLine.Invocation;
+using System.IO;
+
+namespace Monbsoft.UpdateVersion.Commands
+{
+    public class PatchCommand : VersionCommandBase
+    {
+        public static Command Create()
+        {
+            var command = new Command("patch", "Increments patch version number");
+
+            command.Handler = CommandHandler.Create<VersionCommandArguments>(args =>
+            {
+                var context = new CommandContext(args.Console, args.Verbosity)
+                {
+                    Directory = Directory.GetCurrentDirectory()
+                };
+                var command = new PatchCommand();
+                command.Execute(context);
+            });
+
+            return command;
+        }
+
+        public void Execute(CommandContext context)
+        {
+            int count = Update(context, (oldVersion) =>
+            {
+                return oldVersion.Change(patch: oldVersion.Patch + 1);
+            });
+            context.WriteInfo($"{count} patch versions are updated.");
+        }
+    }
+}

src/Monbsoft.UpdateVersion/Commands/SetCommand.cs

@@ -0,0 +1,51 @@
+using Monbsoft.UpdateVersion.Core;
+using Monbsoft.UpdateVersion.Models;
+using Semver;
+using System;
+using System.CommandLine;
+using System.CommandLine.Invocation;
+using System.IO;
+
+namespace Monbsoft.UpdateVersion.Commands
+{
+    public class SetCommand : VersionCommandBase
+    {
+        public static Command Create()
+        {
+            var command = new Command("set", "Sets the version of the projects.");
+
+            var versionArg = new Argument("vesion");
+            versionArg.Description = "Version of the projects";
+            command.AddArgument(versionArg);
+
+            command.Handler = CommandHandler.Create<SetCommandArguments>(args =>
+            {
+                var context = new CommandContext(args.Console, args.Verbosity)
+                {
+                    Directory = Directory.GetCurrentDirectory()
+                };
+                var command = new SetCommand();
+                command.Execute(context, args.Version);
+            });
+
+            return command;
+        }
+
+        public void Execute(CommandContext context, string version)
+        {
+            var newVersion = SemVersion.Parse(version);
+            int count = Update(context, (oldVersion) =>
+            {
+                return newVersion;
+            });
+            context.WriteInfo($"{count} versions are updated.");
+        }
+
+        public class SetCommandArguments
+        {
+            public IConsole Console { get; set; } = default;
+            public Verbosity Verbosity { get; set; } = Verbosity.Info;
+            public string Version { get; set; }
+        }
+    }
+}

src/Monbsoft.UpdateVersion/Commands/VersionCommandBase.cs

@@ -0,0 +1,44 @@
+using Monbsoft.UpdateVersion.Core;
+using Monbsoft.UpdateVersion.Models;
+using Semver;
+using System;
+using System.CommandLine;
+
+namespace Monbsoft.UpdateVersion.Commands
+{
+    public class VersionCommandArguments
+    {
+        public IConsole Console { get; set; } = default;
+        public Verbosity Verbosity { get; set; } = Verbosity.Info;
+    }
+
+    public abstract class VersionCommandBase
+    {
+        private ProjectStore _store;
+
+        public VersionCommandBase()
+        {
+            _store = new ProjectStore();
+        }
+
+        protected int Update(CommandContext context, Func<SemVersion, SemVersion> changeVersion)
+        {
+            var finder = new ProjectFinder(context.Directory);
+            var projectFiles = finder.FindProjects();
+            foreach (var projectFile in projectFiles)
+            {
+                var project = _store.Read(projectFile);
+                UpdateProject(project, changeVersion);
+                _store.Save(project);
+            }
+            return projectFiles.Count;
+        }
+
+        protected void UpdateProject(Project project, Func<SemVersion, SemVersion> changeVersion)
+        {
+            var oldVersion = SemVersion.Parse(project.Version);
+            var newVersion = changeVersion(oldVersion);
+            project.Version = newVersion.ToString();
+        }
+    }
+}

src/Monbsoft.UpdateVersion/Core/CommandContext.cs

@@ -0,0 +1,42 @@
+using Monbsoft.UpdateVersion.Models;
+using System;
+using System.CommandLine;
+using System.CommandLine.IO;
+
+namespace Monbsoft.UpdateVersion.Core
+{
+    public class CommandContext
+    {
+        public CommandContext(IConsole console, Verbosity verbosity)
+        {
+            if (console == null)
+            {
+                throw new ArgumentNullException(nameof(console));
+            }
+            Console = console;
+            Verbosity = verbosity;
+        }
+
+        public IConsole Console { get; set; }
+        public string Directory { get; set; }
+        public Verbosity Verbosity { get; set; }
+
+        public void WriteLine(Verbosity verbosity, string message)
+        {
+            if (Verbosity >= verbosity)
+            {
+                Console.Out.WriteLine(message);
+            }
+        }
+
+        public void WriteDebug(string message)
+        {
+            WriteLine(Verbosity.Debug, message);
+        }
+
+        public void WriteInfo(string message)
+        {
+            WriteLine(Verbosity.Info, message);
+        }
+    }
+}

src/Monbsoft.UpdateVersion/Core/ProjectFinder.cs

@@ -0,0 +1,80 @@
+using Microsoft.Extensions.FileProviders;
+using Microsoft.Extensions.FileProviders.Physical;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+namespace Monbsoft.UpdateVersion.Core
+{
+    public class ProjectFinder
+    {
+        private static readonly string ProjectFormat = "*.csproj";
+        private static readonly string SolutionFormat = "*.sln";
+        private readonly DirectoryInfo _currentFolder;
+
+        public ProjectFinder(string folderPath)
+        {
+            _currentFolder = new DirectoryInfo(folderPath);
+            if(!_currentFolder.Exists)
+            {
+                throw new DirectoryNotFoundException(_currentFolder.Name);
+            }
+        }
+
+        public List<IFileInfo> FindProjects()
+        {
+            List<IFileInfo> projectFiles = new List<IFileInfo>();
+            // try project files in current folder
+            if (TryProjectFiles(true, out projectFiles))
+            {
+                return projectFiles;
+            }
+            // try
+            if (ExistsSolutionFile())
+            {
+                TryProjectFiles(false, out projectFiles);
+            }
+            else
+            {
+                throw new FileNotFoundException("No project or solution file is found.");
+            }
+
+            return projectFiles;
+        }
+        private bool ExistsSolutionFile()
+        {
+            var files = _currentFolder.GetFiles(SolutionFormat);
+
+            if (files.Length > 1)
+            {
+                throw new FileNotFoundException("More solution files are found.");
+            }
+            if (files.Length == 0)
+            {
+                return false;
+            }
+
+            return true;
+        }
+
+        private bool TryProjectFiles(bool inCurrentFolder, out List<IFileInfo> projectFiles)
+        {
+            var files = _currentFolder.GetFiles();
+            SearchOption searchOption = SearchOption.AllDirectories;
+
+            if(inCurrentFolder)
+            {
+                searchOption = SearchOption.TopDirectoryOnly;
+            }
+
+            if (!files.Any())
+            {
+                projectFiles = default;
+                return false;
+            }
+            projectFiles = _currentFolder.EnumerateFiles(ProjectFormat, searchOption)
+                .Select(file => new PhysicalFileInfo(file)).ToList<IFileInfo>();
+            return projectFiles.Any();
+        }
+    }
+}

src/Monbsoft.UpdateVersion/Core/ProjectStore.cs

@@ -0,0 +1,95 @@
+using Microsoft.Extensions.FileProviders;
+using Monbsoft.UpdateVersion.Models;
+using Semver;
+using System;
+using System.Linq;
+using System.Xml;
+using System.Xml.Linq;
+using System.Xml.XPath;
+
+namespace Monbsoft.UpdateVersion.Core
+{
+    public class ProjectStore
+    {
+        public Project Read(IFileInfo projectFile)
+        {
+            if (projectFile == null)
+            {
+                throw new ArgumentNullException(nameof(projectFile));
+            }
+            var project = new Project(projectFile);
+
+            var projectDocument = ReadProject(projectFile);
+            var versionElement = ReadVersionElement(projectDocument);
+
+            if (versionElement != null)
+            {
+                project.Version = versionElement.Value;
+            }
+
+            if (!SemVersion.TryParse(project.Version, out var version))
+            {
+                version = new SemVersion(0, 1, 0);
+                project.Version = version.ToString();
+            }
+            return project;
+        }
+
+        public void Save(Project project)
+        {
+            var projectDocument = ReadProject(project.File);
+            var versionElement = ReadVersionElement(projectDocument);
+
+            SemVersion parsedVersion = SemVersion.Parse(project.Version);
+
+            if (versionElement != null)
+            {
+                versionElement.Value = parsedVersion.ToString();
+            }
+            else
+            {
+                // Find the first non-conditional PropertyGroup
+                var propertyGroup = projectDocument.Root.DescendantNodes()
+                    .FirstOrDefault(node => node is XElement el
+                        && el.Name == "PropertyGroup"
+                        && el.Attributes().All(attr =>
+                            attr.Name != "Condition")) as XElement;
+                // No valid property group, create a new one
+                if (propertyGroup == null)
+                {
+                    propertyGroup = new XElement("PropertyGroup");
+                    projectDocument.Root.AddFirst(propertyGroup);
+                }
+                propertyGroup.Add(new XElement("Version", parsedVersion.ToString()));
+            }
+
+            var settings = new XmlWriterSettings
+            {
+                OmitXmlDeclaration = true,
+            };
+
+            using var xw = XmlWriter.Create(project.FullName, settings);
+            projectDocument.Save(xw);
+        }
+
+        /// <summary>
+        /// Reads the xml version element if it exists.
+        /// </summary>
+        /// <param name="projectDocument"></param>
+        /// <returns></returns>
+        private XElement ReadVersionElement(XDocument projectDocument)
+        {
+            return projectDocument.XPathSelectElements("//Version").FirstOrDefault();
+        }
+
+        /// <summary>
+        /// Reads the project file as XML
+        /// </summary>
+        /// <param name="fileInfo"></param>
+        /// <returns></returns>
+        private XDocument ReadProject(IFileInfo fileInfo)
+        {
+            return XDocument.Load(fileInfo.PhysicalPath, LoadOptions.PreserveWhitespace);
+        }
+    }
+}

src/Monbsoft.UpdateVersion/Models/Project.cs

@@ -0,0 +1,33 @@
+using Microsoft.Extensions.FileProviders;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Xml.Linq;
+using System.Xml.XPath;
+
+namespace Monbsoft.UpdateVersion.Models
+{
+    public class Project
+    {
+        public Project(IFileInfo file)
+        {
+            File = file ?? throw new ArgumentNullException(nameof(file));
+        }
+       
+        public IFileInfo File { get; }
+
+        public string FullName => File.PhysicalPath;
+
+        public string Name => File.Name;
+
+        public string Version { get; set; }
+
+        public override string ToString()
+        {
+            return Name;
+        }
+
+    }
+}

src/Monbsoft.UpdateVersion/Models/Verbosity.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Monbsoft.UpdateVersion.Models
+{
+    public enum Verbosity
+    {
+        Quiet,
+        Info,
+        Debug,
+        Warn
+    }
+}

src/Monbsoft.UpdateVersion/Monbsoft.UpdateVersion.csproj

@@ -1,11 +1,20 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>net5.0</TargetFramework>
+    <RootNamespace>Monbsoft.UpdateVersion</RootNamespace>
+    <AssemblyName>update-version</AssemblyName>
+    <Version>0.1.0</Version>    
+    <PackageId>Monbsoft.UpdateVersion</PackageId>
+    <IsPackable>true</IsPackable>
+    <PackAsTool>true</PackAsTool>  
+    <ToolCommandName>updateVersion</ToolCommandName>      
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.FileProviders.Physical" Version="5.0.0" />
+    <PackageReference Include="semver" Version="2.0.6" />
     <PackageReference Include="System.CommandLine" Version="2.0.0-beta1.20371.2" />
   </ItemGroup>
 

src/Monbsoft.UpdateVersion/Program.cs

@@ -1,12 +1,48 @@
-using System;
+using Monbsoft.UpdateVersion.Commands;
+using System;
+using System.CommandLine;
+using System.CommandLine.Builder;
+using System.CommandLine.Help;
+using System.CommandLine.Invocation;
+using System.CommandLine.IO;
+using System.CommandLine.Parsing;
+using System.Threading.Tasks;
 
 namespace Monbsoft.UpdateVersion
 {
     class Program
-    {
-        static void Main(string[] args)
+    {       
+        public static Task<int> Main(string[] args)
         {
-            Console.WriteLine("Hello World!");
+            var command = new RootCommand()
+            {
+                Description = "Developper tool to update the Visual Studio project versions."
+            };
+            command.AddCommand(ListCommand.Create());
+            command.AddCommand(MajorCommand.Create());
+            command.AddCommand(MinorCommand.Create());
+            command.AddCommand(PatchCommand.Create());
+            //command.AddCommand(BuildCommand.Create());
+            command.AddCommand(SetCommand.Create());
+            
+
+            var builder = new CommandLineBuilder(command)
+                .UseHelp()
+                .UseDefaults()
+                .UseVersionOption()
+                .CancelOnProcessTermination()
+                .UseExceptionHandler();
+
+            var parser = builder.Build();
+            return parser.InvokeAsync(args);
+        }
+
+        private static void HandleException(Exception ex, InvocationContext context)
+        {
+            context.Console.Error.WriteLine();
+            context.Console.Error.WriteLine(ex.Message);
+
+            context.ResultCode = 1;
         }
     }
 }

test/Monbsoft.UpdateVersion.Tests/BuildTests.cs

@@ -0,0 +1,65 @@
+using Monbsoft.UpdateVersion.Commands;
+using Monbsoft.UpdateVersion.Core;
+using Monbsoft.UpdateVersion.Models;
+using Monbsoft.UpdateVersion.Tests.Utilities;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace Monbsoft.UpdateVersion.Tests
+{
+    public class BuildTests
+    {
+        private TestConsole _console;
+
+        public BuildTests()
+        {
+            _console = new TestConsole();
+        }
+
+        //[Fact]
+        //public void ChangeBuildVersionTest()
+        //{
+        //    using (var fs = new DisposableFileSystem())
+        //    {
+        //        fs.CreateFile("MySolution.sln");
+        //        fs.CreateFolder("src/Services");
+        //        fs.CreateFile("src/Services/project1.csproj", ProjectHelper.BuildVersion("3.63.4"));
+        //        var store = new ProjectStore();
+        //        var command = new BuildCommand();
+        //        var context = new CommandContext(_console, Verbosity.Info);
+        //        context.Directory = fs.RootPath;
+
+        //        command.Execute(context);
+        //        var project = store.Read(PathHelper.GetFile(fs, "src/Services/project1.csproj"));
+
+        //        Assert.Equal("3.63.4+1", project.Version);
+
+        //    }
+        //}
+
+        //[Fact]
+        //public void ChangeExistingBuildVersionTest()
+        //{
+        //    using (var fs = new DisposableFileSystem())
+        //    {
+        //        fs.CreateFile("MySolution.sln");
+        //        fs.CreateFolder("src/Services");
+        //        fs.CreateFile("src/Services/project1.csproj", ProjectHelper.BuildVersion("5.0.8"));
+        //        var store = new ProjectStore();
+        //        var command = new BuildCommand();
+        //        var context = new CommandContext(_console, Verbosity.Info);
+        //        context.Directory = fs.RootPath;
+
+        //        command.Execute(context);
+        //        var project = store.Read(PathHelper.GetFile(fs, "src/Services/project1.csproj"));
+
+        //        Assert.Equal("5.0.8+15", project.Version);
+
+        //    }
+        //}
+    }
+}

test/Monbsoft.UpdateVersion.Tests/FileFinderTests.cs

@@ -0,0 +1,62 @@
+using Monbsoft.UpdateVersion.Core;
+using Monbsoft.UpdateVersion.Tests.Utilities;
+using System.IO;
+using System.Linq;
+using Xunit;
+
+namespace Monbsoft.UpdateVersion.Tests
+{
+    public class FileFinderTests
+    {
+        [Fact]
+        public void FindWithSolutionFile()
+        {
+            using(var fs = new DisposableFileSystem())
+            {
+                fs.CreateFile("MySolution.sln")
+                    .CreateFolder("src/project")
+                    .CreateFile("src/project/proj1.csproj");
+                var finder = new ProjectFinder(fs.RootPath);
+
+
+                var projectFiles = finder.FindProjects();
+                var project = projectFiles.First();
+
+
+                Assert.Single(projectFiles);
+                Assert.Equal("proj1.csproj", project.Name);
+            }
+        }
+
+        [Fact]
+        public void FindWithProjectFiles()
+        {
+            using(var fs = new DisposableFileSystem())
+            {
+                fs.CreateFile("project1.csproj")
+                    .CreateFile("project2.csproj");
+                var finder = new ProjectFinder(fs.RootPath);
+
+                var projects = finder.FindProjects();
+
+                Assert.Equal("project1.csproj", projects[0].Name);
+                Assert.Equal("project2.csproj", projects[1].Name);
+
+            }
+        }
+
+        [Fact]
+        public void FindWithNoProjectOrSolution()
+        {
+            using(var fs = new DisposableFileSystem())
+            {
+                fs.CreateFolder("src/project1")
+                    .CreateFile("src/project1/project1.csproj");
+                var finder = new ProjectFinder(fs.RootPath);
+
+                Assert.Throws<FileNotFoundException>(() => finder.FindProjects());
+
+            }
+        }
+    }
+}

test/Monbsoft.UpdateVersion.Tests/MajorTests.cs

@@ -0,0 +1,39 @@
+using Monbsoft.UpdateVersion.Commands;
+using Monbsoft.UpdateVersion.Core;
+using Monbsoft.UpdateVersion.Models;
+using Monbsoft.UpdateVersion.Tests.Utilities;
+using Xunit;
+
+namespace Monbsoft.UpdateVersion.Tests
+{
+    public class MajorTests
+    {
+        private TestConsole _console;
+
+        public MajorTests()
+        {
+            _console = new TestConsole();
+        }
+
+        [Fact]
+        public void ChangeMajorVersionTest()
+        {
+            using(var fs = new DisposableFileSystem())
+            {
+                fs.CreateFile("MySolution.sln");
+                fs.CreateFolder("src/Services");
+                fs.CreateFile("src/Services/project1.csproj", ProjectHelper.BuildVersion("1.5.1"));
+                var store = new ProjectStore();
+                var command = new MajorCommand();
+                var context = new CommandContext(_console, Verbosity.Info);
+                context.Directory = fs.RootPath;
+
+                command.Execute(context);
+                var project  = store.Read(PathHelper.GetFile(fs, "src/Services/project1.csproj"));
+
+                Assert.Equal("2.0.0", project.Version);
+
+            }
+        }
+    }
+}

test/Monbsoft.UpdateVersion.Tests/MinorTests.cs

@@ -0,0 +1,39 @@
+using Monbsoft.UpdateVersion.Commands;
+using Monbsoft.UpdateVersion.Core;
+using Monbsoft.UpdateVersion.Models;
+using Monbsoft.UpdateVersion.Tests.Utilities;
+using Xunit;
+
+namespace Monbsoft.UpdateVersion.Tests
+{
+    public class PatchTests
+    {
+        private TestConsole _console;
+
+        public PatchTests()
+        {
+            _console = new TestConsole();
+        }
+
+        [Fact]
+        public void ChangePatchVersionTest()
+        {
+            using (var fs = new DisposableFileSystem())
+            {
+                fs.CreateFile("MySolution.sln");
+                fs.CreateFolder("src/Services");
+                fs.CreateFile("src/Services/project1.csproj", ProjectHelper.BuildVersion("1.5.1"));
+                var store = new ProjectStore();
+                var command = new PatchCommand();
+                var context = new CommandContext(_console, Verbosity.Info);
+                context.Directory = fs.RootPath;
+
+                command.Execute(context);
+                var project = store.Read(PathHelper.GetFile(fs, "src/Services/project1.csproj"));
+
+                Assert.Equal("1.5.2", project.Version);
+
+            }
+        }
+    }
+}

test/Monbsoft.UpdateVersion.Tests/Monbsoft.UpdateVersion.Tests.csproj

@@ -0,0 +1,26 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net5.0</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.7.1" />
+    <PackageReference Include="xunit" Version="2.4.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+    <PackageReference Include="coverlet.collector" Version="1.3.0">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\Monbsoft.UpdateVersion\Monbsoft.UpdateVersion.csproj" />
+  </ItemGroup>
+
+</Project>

test/Monbsoft.UpdateVersion.Tests/PatchTests.cs

@@ -0,0 +1,39 @@
+using Monbsoft.UpdateVersion.Commands;
+using Monbsoft.UpdateVersion.Core;
+using Monbsoft.UpdateVersion.Models;
+using Monbsoft.UpdateVersion.Tests.Utilities;
+using Xunit;
+
+namespace Monbsoft.UpdateVersion.Tests
+{
+    public class MinorTests
+    {
+        private TestConsole _console;
+
+        public MinorTests()
+        {
+            _console = new TestConsole();
+        }
+
+        [Fact]
+        public void ChangeMinorVersionTest()
+        {
+            using (var fs = new DisposableFileSystem())
+            {
+                fs.CreateFile("MySolution.sln");
+                fs.CreateFolder("src/Services");
+                fs.CreateFile("src/Services/project1.csproj", ProjectHelper.BuildVersion("1.5.1"));
+                var store = new ProjectStore();
+                var command = new MinorCommand();
+                var context = new CommandContext(_console, Verbosity.Info);
+                context.Directory = fs.RootPath;
+
+                command.Execute(context);
+                var project = store.Read(PathHelper.GetFile(fs, "src/Services/project1.csproj"));
+
+                Assert.Equal("1.6.0", project.Version);
+
+            }
+        }
+    }
+}

test/Monbsoft.UpdateVersion.Tests/ProjectStoreTests.cs

@@ -0,0 +1,99 @@
+using Microsoft.Extensions.FileProviders;
+using Microsoft.Extensions.FileProviders.Physical;
+using Monbsoft.UpdateVersion.Core;
+using Monbsoft.UpdateVersion.Tests.Utilities;
+using System;
+using System.IO;
+using Xunit;
+
+namespace Monbsoft.UpdateVersion.Tests
+{
+    public class ProjectStoreTests
+    {
+
+        [Fact]
+        public void ReadNoVersionTest()
+        {
+            string projectFile = "project2.csproj";
+            using (var fs = new DisposableFileSystem())
+            {
+                fs.CreateFile(projectFile, ProjectHelper.BuildVersion(string.Empty));
+                var store = new ProjectStore();
+
+                var project = store.Read(CreateFileInfo(fs, projectFile));
+
+                Assert.Equal("0.1.0", project.Version);
+            }
+        }
+
+        [Fact]
+        public void ReadProjectTest()
+        {
+            string projectFile = "project1.csproj";
+            using (var fs = new DisposableFileSystem())
+            {
+                fs.CreateFile(projectFile, ProjectHelper.BuildVersion("0.5"));
+                var store = new ProjectStore();
+
+                var project = store.Read(CreateFileInfo(fs, projectFile));
+
+                Assert.Equal("0.5", project.Version);
+            }
+        }
+
+        [Fact]
+        public void ReadProjectWithPatchTest()
+        {
+            string projectFile = "MyProject.csproj";
+            using (var fs = new DisposableFileSystem())
+            {
+                fs.CreateFile(projectFile, ProjectHelper.BuildVersion("1.3.5"));
+                var store = new ProjectStore();
+
+                var project = store.Read(CreateFileInfo(fs, projectFile));
+
+                Assert.Equal("1.3.5", project.Version);
+            }
+        }
+
+        [Fact]
+        public void UpdateProjectTest()
+        {
+            string projectFile = "MyProject.csproj";
+
+            using (var fs = new DisposableFileSystem())
+            {
+                fs.CreateFile(projectFile, ProjectHelper.BuildVersion("1.4.0"));
+                var store = new ProjectStore();
+                var project = store.Read(CreateFileInfo(fs, projectFile));
+                project.Version = "2.0";
+
+                store.Save(project);
+                var newProject = store.Read(CreateFileInfo(fs, projectFile));
+
+                Assert.Equal("2.0", project.Version);
+            }
+        }
+
+        [Fact]
+        public void UpdateProjectWithBadVersionTest()
+        {
+            string projectFile = "MyProject.csproj";
+
+            using (var fs = new DisposableFileSystem())
+            {
+                fs.CreateFile(projectFile, ProjectHelper.BuildVersion("1.4.0"));
+                var store = new ProjectStore();
+                var project = store.Read(CreateFileInfo(fs, projectFile));
+                project.Version = "${BuildVersion}";
+
+                Assert.Throws<ArgumentException>("version", () => store.Save(project));
+            }
+        }
+
+        private static IFileInfo CreateFileInfo(DisposableFileSystem fs, string filename)
+        {
+            return new PhysicalFileInfo(new FileInfo(Path.Combine(fs.RootPath, filename)));
+        }
+    }
+}

test/Monbsoft.UpdateVersion.Tests/SetTests.cs

@@ -0,0 +1,64 @@
+using Monbsoft.UpdateVersion.Commands;
+using Monbsoft.UpdateVersion.Core;
+using Monbsoft.UpdateVersion.Models;
+using Monbsoft.UpdateVersion.Tests.Utilities;
+using Xunit;
+
+namespace Monbsoft.UpdateVersion.Tests
+{
+    public class SetTests
+    {
+        private TestConsole _console;
+
+        public SetTests()
+        {
+            _console = new TestConsole();
+        }
+
+        [Fact]
+        public void ChangeVersionTest()
+        {
+            using (var fs = new DisposableFileSystem())
+            {
+                fs.CreateFile("MySolution.sln");
+                fs.CreateFolder("src/Services");
+                fs.CreateFile("src/Services/project1.csproj", ProjectHelper.BuildVersion("1.5.1"));
+                var store = new ProjectStore();
+                var command = new SetCommand();
+                var context = new CommandContext(_console, Verbosity.Info);
+                context.Directory = fs.RootPath;
+
+                command.Execute(context, "3.0.1");
+                var project = store.Read(PathHelper.GetFile(fs, "src/Services/project1.csproj"));
+
+                Assert.Equal("3.0.1", project.Version);
+
+            }
+        }
+
+        [Fact]
+        public void ChangeVersionsTest()
+        {
+            using (var fs = new DisposableFileSystem())
+            {
+                fs.CreateFile("MySolution.sln")
+                    .CreateFolder("src/Services/project1")
+                    .CreateFile("src/Services/project1/project1.csproj", ProjectHelper.BuildVersion("1.5.1"))
+                    .CreateFolder("src/Services/project2")
+                    .CreateFile("src/Services/project2/project2.csproj", ProjectHelper.BuildVersion("2.1.0"));
+                var store = new ProjectStore();
+                var command = new SetCommand();
+                var context = new CommandContext(_console, Verbosity.Info);
+                context.Directory = fs.RootPath;
+
+                command.Execute(context, "4.0.12");
+                var project1 = store.Read(PathHelper.GetFile(fs, "src/Services/project1/project1.csproj"));
+                var project2 = store.Read(PathHelper.GetFile(fs, "src/Services/project2/project2.csproj"));
+
+                Assert.Equal("4.0.12", project1.Version);
+                Assert.Equal("4.0.12", project2.Version);
+
+            }
+        }
+    }
+}

test/Monbsoft.UpdateVersion.Tests/Utilities/DisposableFileSystem.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+
+namespace Monbsoft.UpdateVersion.Tests.Utilities
+{
+    public class DisposableFileSystem : IDisposable
+    {
+        private bool _disposed;
+
+        public DisposableFileSystem()
+        {
+            _disposed = false;
+            RootPath = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
+            Directory.CreateDirectory(RootPath);
+            DirectoryInfo = new DirectoryInfo(RootPath);
+        }
+
+        public DirectoryInfo DirectoryInfo { get; set; }
+        public string RootPath { get; }
+
+        public DisposableFileSystem CreateFile(string path)
+        {
+            File.WriteAllText(Path.Combine(RootPath, path), GetDefaultContent());
+            return this;
+        }
+        public DisposableFileSystem CreateFile(string path, string content)
+        {
+            File.WriteAllText(Path.Combine(RootPath, path), content);
+            return this;
+        }
+        public DisposableFileSystem CreateFolder(string path)
+        {
+            Directory.CreateDirectory(Path.Combine(RootPath, path));
+            return this;
+        }
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_disposed)
+            {
+                return;
+            }
+            if (disposing)
+            {
+                try
+                {
+                    Directory.Delete(RootPath, true);
+                }
+                catch
+                {
+
+                }
+            }
+            _disposed = true;
+        }
+
+        private string GetDefaultContent()
+        {
+            return @"<Project Sdk=""Microsoft.NET.Sdk"">
+</Project>";
+        }
+
+    }
+}

test/Monbsoft.UpdateVersion.Tests/Utilities/PathHelper.cs

@@ -0,0 +1,20 @@
+using Microsoft.Extensions.FileProviders;
+using Microsoft.Extensions.FileProviders.Physical;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Monbsoft.UpdateVersion.Tests.Utilities
+{
+    public static class PathHelper
+    {
+        public static IFileInfo GetFile(DisposableFileSystem fs, string filename)
+        {
+            var fileInfo = new FileInfo(Path.Combine(fs.RootPath, filename));
+            return new PhysicalFileInfo(fileInfo);
+        }
+    }
+}

test/Monbsoft.UpdateVersion.Tests/Utilities/ProjectHelper.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Monbsoft.UpdateVersion.Tests.Utilities
+{
+    public static class ProjectHelper
+    {
+        private const string ProjectTemplate = @"<Project Sdk=""Microsoft.NET.Sdk"">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFrameworks>net5.0</TargetFrameworks>
+    {0}
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include=""**\*.cs"" Exclude=""Excluded.cs;$(DefaultItemExcludes)"" />
+  </ItemGroup>
+</Project>";
+
+        public static string BuildVersion(string version)
+        {
+            return string.Format(ProjectTemplate, $"<Version>{version}</Version>");
+        }
+    }
+}

test/Monbsoft.UpdateVersion.Tests/Utilities/TestConsole.cs

@@ -0,0 +1,45 @@
+using System.CommandLine;
+using System.CommandLine.IO;
+using System.IO;
+using System.Text;
+
+namespace Monbsoft.UpdateVersion.Tests.Utilities
+{
+    public class TestConsole : IConsole
+    {
+        public TestConsole()
+        {
+            Out = new StandardStreamWriter();
+            Error = new StandardStreamWriter();
+        }
+
+        public IStandardStreamWriter Error { get; protected set; }
+
+        public IStandardStreamWriter Out { get; protected set; }
+
+        public bool IsOutputRedirected { get; protected set; }
+
+        public bool IsErrorRedirected { get; protected set; }
+
+        public bool IsInputRedirected { get; protected set; }
+
+        internal class StandardStreamWriter : TextWriter, IStandardStreamWriter
+        {
+            private readonly StringBuilder _stringBuilder = new StringBuilder();
+
+            public override void Write(char value)
+            {
+                _stringBuilder.Append(value);
+            }
+
+            public override void Write(string? value)
+            {
+                _stringBuilder.Append(value);
+            }
+
+            public override Encoding Encoding { get; } = Encoding.Unicode;
+
+            public override string ToString() => _stringBuilder.ToString();
+        }
+    }
+}