Functionality to send commands for and parse git and git lfs version

Author: StanleyGoldman

src/GitHub.Api/Git/GitClient.cs

@@ -77,6 +77,10 @@ ITask<string> Unlock(string file, bool force,
             IOutputProcessor<string> processor = null);
 
         ITask<List<GitLogEntry>> Log(BaseOutputListProcessor<GitLogEntry> processor = null);
+
+        ITask<SoftwareVersion> Version(IOutputProcessor<SoftwareVersion> processor = null);
+
+        ITask<SoftwareVersion> LfsVersion(IOutputProcessor<SoftwareVersion> processor = null);
     }
 
     class GitClient : IGitClient
@@ -183,6 +187,22 @@ public ITask<List<GitLogEntry>> Log(BaseOutputListProcessor<GitLogEntry> process
                 .Configure(processManager);
         }
 
+        public ITask<SoftwareVersion> Version(IOutputProcessor<SoftwareVersion> processor = null)
+        {
+            Logger.Trace("Version");
+
+            return new GitVersionTask(cancellationToken, processor)
+                .Configure(processManager);
+        }
+
+        public ITask<SoftwareVersion> LfsVersion(IOutputProcessor<SoftwareVersion> processor = null)
+        {
+            Logger.Trace("LfsVersion");
+
+            return new GitLfsVersionTask(cancellationToken, processor)
+                .Configure(processManager);
+        }
+
         public ITask<string> GetConfig(string key, GitConfigSource configSource, IOutputProcessor<string> processor = null)
         {
             Logger.Trace("GetConfig");

src/GitHub.Api/Git/Tasks/GitLfsVersionTask.cs

@@ -0,0 +1,18 @@
+using System.Threading;
+
+namespace GitHub.Unity
+{
+    class GitLfsVersionTask : ProcessTask<SoftwareVersion>
+    {
+        private const string TaskName = "git lfs version";
+
+        public GitLfsVersionTask(CancellationToken token, IOutputProcessor<SoftwareVersion> processor = null)
+            : base(token, processor ?? new LfsVersionOutputProcessor())
+        {
+            Name = TaskName;
+        }
+
+        public override string ProcessArguments { get { return "lfs version"; } }
+        public override TaskAffinity Affinity { get { return TaskAffinity.Concurrent; } }
+    }
+}

src/GitHub.Api/Git/Tasks/GitVersionTask.cs

@@ -0,0 +1,18 @@
+using System.Threading;
+
+namespace GitHub.Unity
+{
+    class GitVersionTask : ProcessTask<SoftwareVersion>
+    {
+        private const string TaskName = "git --version";
+
+        public GitVersionTask(CancellationToken token, IOutputProcessor<SoftwareVersion> processor = null)
+            : base(token, processor ?? new VersionOutputProcessor())
+        {
+            Name = TaskName;
+        }
+
+        public override string ProcessArguments { get { return "--version"; } }
+        public override TaskAffinity Affinity { get { return TaskAffinity.Concurrent; } }
+    }
+}

src/GitHub.Api/GitHub.Api.csproj

@@ -100,6 +100,8 @@
     <Compile Include="Application\LoginResult.cs" />
     <Compile Include="Application\AppConfiguration.cs" />
     <Compile Include="Extensions\ListExtensions.cs" />
+    <Compile Include="Git\Tasks\GitLfsVersionTask.cs" />
+    <Compile Include="Git\Tasks\GitVersionTask.cs" />
     <Compile Include="Helpers\AssemblyResources.cs" />
     <Compile Include="Authentication\IKeychain.cs" />
     <Compile Include="Authentication\Keychain.cs" />
@@ -109,6 +111,9 @@
     <Compile Include="Helpers\Constants.cs" />
     <Compile Include="Cache\IBranchCache.cs" />
     <Compile Include="Helpers\Validation.cs" />
+    <Compile Include="OutputProcessors\LfsVersionOutputProcessor.cs" />
+    <Compile Include="OutputProcessors\SoftwareVersion.cs" />
+    <Compile Include="OutputProcessors\VersionOutputProcessor.cs" />
     <Compile Include="Platform\DefaultEnvironment.cs" />
     <Compile Include="Extensions\EnvironmentExtensions.cs" />
     <Compile Include="Extensions\FileEventExtensions.cs" />

src/GitHub.Api/OutputProcessors/LfsVersionOutputProcessor.cs

@@ -0,0 +1,22 @@
+using System;
+
+namespace GitHub.Unity
+{
+    class LfsVersionOutputProcessor : BaseOutputProcessor<SoftwareVersion>
+    {
+        public override void LineReceived(string line)
+        {
+            if (String.IsNullOrEmpty(line))
+                return;
+
+            var gitVersion = "git-lfs/";
+            if (line.StartsWith(gitVersion))
+            {
+                line = line.Substring(gitVersion.Length, line.IndexOf(" ", StringComparison.InvariantCultureIgnoreCase) - gitVersion.Length);
+                var strings = line.Split(new[] { "." }, StringSplitOptions.None);
+
+                RaiseOnEntry(new SoftwareVersion(strings[0], strings[1], strings[2]));
+            }
+        }
+    }
+}

src/GitHub.Api/OutputProcessors/SoftwareVersion.cs

@@ -0,0 +1,22 @@
+namespace GitHub.Unity
+{
+    public struct SoftwareVersion
+    {
+        public int Major;
+        public int Minor;
+        public int Build;
+
+        public SoftwareVersion(int major, int minor, int build)
+        {
+            Major = major;
+            Minor = minor;
+            Build = build;
+        }
+
+        public SoftwareVersion(string major, string minor, string build):
+            this(int.Parse(major), int.Parse(minor), int.Parse(build))
+        {
+            
+        }
+    }
+}

src/GitHub.Api/OutputProcessors/VersionOutputProcessor.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+
+namespace GitHub.Unity
+{
+    class VersionOutputProcessor : BaseOutputProcessor<SoftwareVersion>
+    {
+        public override void LineReceived(string line)
+        {
+            if (String.IsNullOrEmpty(line))
+                return;
+
+            var gitVersion = "git version ";
+            if (line.StartsWith(gitVersion))
+            {
+                line = line.Substring(gitVersion.Length);
+                var strings = line.Split(new[] { "." }, StringSplitOptions.None);
+
+                RaiseOnEntry(new SoftwareVersion(strings[0], strings[1], strings[2]));
+            }
+        }
+    }
+}

src/tests/IntegrationTests/GitClientTests.cs

@@ -0,0 +1,49 @@
+using System.Threading.Tasks;
+using FluentAssertions;
+using GitHub.Unity;
+using NUnit.Framework;
+
+namespace IntegrationTests
+{
+    [TestFixture/*, Category("TimeSensitive")*/]
+    class GitClientTests : BaseGitEnvironmentTest
+    {
+        [Test]
+        public async Task ShouldGetGitVersion()
+        {
+            await Initialize(TestRepoMasterCleanSynchronized);
+
+            var version = GitClient.Version();
+            version.Start().Wait();
+
+            var versionResult = version.Result;
+            if (Environment.IsWindows)
+            {
+                versionResult.Should().Be($"2.11.1");
+            }
+            else
+            {
+                versionResult.Should().NotBe(string.Empty);
+            }
+        }
+
+        [Test]
+        public async Task ShouldGetGitLfsVersion()
+        {
+            await Initialize(TestRepoMasterCleanSynchronized);
+
+            var version = GitClient.LfsVersion();
+            version.Start().Wait();
+
+            var versionResult = version.Result;
+            if (Environment.IsWindows)
+            {
+                versionResult.Should().Be("2.2.0");
+            }
+            else
+            {
+                versionResult.Should().NotBe(string.Empty);
+            }
+        }
+    }
+}

src/tests/IntegrationTests/IntegrationTests.csproj

@@ -78,6 +78,7 @@
     <Compile Include="BaseGitEnvironmentTest.cs" />
     <Compile Include="BaseGitRepoTest.cs" />
     <Compile Include="BaseIntegrationTest.cs" />
+    <Compile Include="GitClientTests.cs" />
     <Compile Include="Git\GitSetupTests.cs" />
     <Compile Include="Git\IntegrationTestEnvironment.cs" />
     <Compile Include="ProcessManagerExtensions.cs" />

src/tests/UnitTests/IO/LfsVersionOutputProcessorTests.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using FluentAssertions;
+using GitHub.Unity;
+using NUnit.Framework;
+
+namespace UnitTests
+{
+    [TestFixture]
+    class LfsVersionOutputProcessorTests : BaseOutputProcessorTests
+    {
+        public static IEnumerable<TestCaseData> ShouldParseVersionOutputs_TestCases()
+        {
+            TestCaseData testCase;
+
+            testCase = new TestCaseData(
+                $"git-lfs/2.2.0 (GitHub; windows amd64; go 1.8.3; git a99f4b21){Environment.NewLine}", 
+                new SoftwareVersion(2, 2, 0));
+
+            testCase.SetName("Windows GitLFS 2.2.0");
+            yield return testCase;
+        }
+
+        [TestCaseSource(nameof(ShouldParseVersionOutputs_TestCases))]
+        public void ShouldParseVersionOutputs(string line, SoftwareVersion expected)
+        {
+            SoftwareVersion? version = null;
+
+            var outputProcessor = new LfsVersionOutputProcessor();
+            outputProcessor.OnEntry += output => { version = output; };
+            outputProcessor.LineReceived(line);
+
+            version.HasValue.Should().BeTrue();
+            version.Value.Should().Be(expected);
+        }
+    }
+}