Merge pull request #546 from github/grokys/remove-duplicate-guard

Remove duplicate guard class.

Author: shana

src/GitHub.App/Api/ApiClient.cs

@@ -18,6 +18,7 @@
 using Octokit.Internal;
 using System.Collections.Generic;
 using GitHub.Models;
+using GitHub.Extensions;
 
 namespace GitHub.Api
 {

src/GitHub.App/Caches/LoginCache.cs

@@ -4,6 +4,7 @@
 using System.Reactive;
 using System.Reactive.Linq;
 using Akavache;
+using GitHub.Extensions;
 using GitHub.Primitives;
 using NLog;
 

src/GitHub.App/Factories/SqlitePersistentBlobCacheFactory.cs

@@ -6,6 +6,7 @@
 using System.ComponentModel.Composition;
 using System.Reactive.Linq;
 using System.Threading.Tasks;
+using GitHub.Extensions;
 
 namespace GitHub.Factories
 {

src/GitHub.App/Models/RepositoryHost.cs

@@ -17,6 +17,7 @@
 using System.Linq;
 using System.Reactive.Threading.Tasks;
 using System.Collections.Generic;
+using GitHub.Extensions;
 
 namespace GitHub.Models
 {

src/GitHub.App/Services/GitClient.cs

@@ -3,8 +3,9 @@
 using System.Linq;
 using System.Reactive;
 using System.Reactive.Linq;
-using LibGit2Sharp;
+using GitHub.Extensions;
 using GitHub.Primitives;
+using LibGit2Sharp;
 
 namespace GitHub.Services
 {

src/GitHub.App/Services/RepositoryCreationService.cs

@@ -3,6 +3,7 @@
 using System.Reactive;
 using System.Reactive.Linq;
 using GitHub.Api;
+using GitHub.Extensions;
 using GitHub.Extensions.Reactive;
 using GitHub.Models;
 using Octokit;

src/GitHub.Exports.Reactive/GitHub.Exports.Reactive.csproj

@@ -125,7 +125,6 @@
       <Link>Key.snk</Link>
     </None>
     <Compile Include="Helpers\ExceptionHelper.cs" />
-    <Compile Include="Helpers\Guard.cs" />
     <Compile Include="Models\GitIgnoreItem.cs" />
     <Compile Include="Models\LicenseItem.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />

src/GitHub.Exports.Reactive/Helpers/Guard.cs

@@ -37,13 +37,13 @@ public static void ArgumentNonNegative(int value, string name)
         }
 
         /// <summary>
-        ///   Checks a string argument to ensure it isn't null or empty.
+        /// Checks a string argument to ensure it isn't null or empty.
         /// </summary>
         /// <param name = "value">The argument value to check.</param>
         /// <param name = "name">The name of the argument.</param>
         public static void ArgumentNotEmptyString(string value, string name)
         {
-            if (value.Length > 0) return;
+            if (value?.Length > 0) return;
             string message = String.Format(CultureInfo.InvariantCulture, "The value for '{0}' must not be empty", name);
 #if DEBUG
             if (!InUnitTestRunner())

src/GitHub.Extensions/Guard.cs

@@ -10,6 +10,7 @@
 using ReactiveUI;
 using NullGuard;
 using GitHub.Services;
+using GitHub.Extensions;
 
 namespace GitHub.Validation
 {

src/GitHub.UI.Reactive/Validation/ReactiveValidatableObject.cs

@@ -0,0 +1,121 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using GitHub.Extensions;
+using Xunit;
+
+namespace UnitTests.GitHub.Extensions
+{
+    public class GuardTests
+    {
+        public class TheArgumentNotNullMethod : TestBaseClass
+        {
+            [Fact]
+            public void ShouldNotThrow()
+            {
+                Guard.ArgumentNotNull(new object(), "name");
+            }
+
+            [Fact]
+            public void ShouldThrow()
+            {
+                Assert.Throws<ArgumentNullException>(() => Guard.ArgumentNotNull(null, "name"));
+            }
+        }
+
+        public class TheArgumentNonNegativeMethod : TestBaseClass
+        {
+            [Fact]
+            public void ShouldNotThrowFor0()
+            {
+                Guard.ArgumentNonNegative(0, "name");
+            }
+
+            [Fact]
+            public void ShouldNotThrowFor1()
+            {
+                Guard.ArgumentNonNegative(1, "name");
+            }
+
+            [Fact]
+            public void ShouldThrowForMinus1()
+            {
+                Assert.Throws<ArgumentException>(() => Guard.ArgumentNonNegative(-1, "name"));
+            }
+        }
+
+        public class TheArgumentNotEmptyStringMethod : TestBaseClass
+        {
+            [Fact]
+            public void ShouldNotThrowForString()
+            {
+                Guard.ArgumentNotEmptyString("string", "name");
+            }
+
+            [Fact]
+            public void ShouldThrowForEmptyString()
+            {
+                Assert.Throws<ArgumentException>(() => Guard.ArgumentNotEmptyString("", "name"));
+            }
+
+            [Fact]
+            public void ShouldThrowForNull()
+            {
+                Assert.Throws<ArgumentException>(() => Guard.ArgumentNotEmptyString(null, "name"));
+            }
+        }
+
+        public class TheArgumentInRangeMethod : TestBaseClass
+        {
+            [Fact]
+            public void ShouldNotThrowForGreaterThanMinimum()
+            {
+                Guard.ArgumentInRange(12, 10, "name");
+            }
+
+            [Fact]
+            public void ShouldNotThrowForEqualToMinimumNoMaximum()
+            {
+                Guard.ArgumentInRange(10, 10, "name");
+            }
+
+            [Fact]
+            public void ShouldNotThrowForEqualToMinimumWithMaximum()
+            {
+                Guard.ArgumentInRange(10, 10, 20, "name");
+            }
+
+            [Fact]
+            public void ShouldNotThrowForEqualToMaximum()
+            {
+                Guard.ArgumentInRange(20, 10, 20, "name");
+            }
+
+            [Fact]
+            public void ShouldNotThrowForBetweenMinimumAndMaximum()
+            {
+                Guard.ArgumentInRange(12, 10, 20, "name");
+            }
+
+            [Fact]
+            public void ShouldThrowForLessThanMinimumNoMaximum()
+            {
+                Assert.Throws<ArgumentOutOfRangeException>(() => Guard.ArgumentInRange(2, 10, "name"));
+            }
+
+            [Fact]
+            public void ShouldThrowForLessThanMinimumWithMaximum()
+            {
+                Assert.Throws<ArgumentOutOfRangeException>(() => Guard.ArgumentInRange(2, 10, 20, "name"));
+            }
+
+            [Fact]
+            public void ShouldThrowForGreaterThanMaximum()
+            {
+                Assert.Throws<ArgumentOutOfRangeException>(() => Guard.ArgumentInRange(22, 10, 20, "name"));
+            }
+        }
+    }
+}

src/UnitTests/GitHub.Extensions/GuardTests.cs

@@ -181,6 +181,7 @@
     <Compile Include="GitHub.Exports\GitServiceTests.cs" />
     <None Include="GitHub.Exports\VSServicesTests.cs" />
     <Compile Include="GitHub.Exports\SimpleRepositoryModelTests.cs" />
+    <Compile Include="GitHub.Extensions\GuardTests.cs" />
     <Compile Include="GitHub.Extensions\UriExtensionTests.cs" />
     <Compile Include="GitHub.Primitives\UriStringTests.cs" />
     <Compile Include="GitHub.UI\Converters.cs" />