Adding KeychainTests

Author: StanleyGoldman

src/GitHub.Api/Authentication/Keychain.cs

@@ -32,19 +32,29 @@ class Keychain : IKeychain
 
         private readonly ILogging logger = Logging.GetLogger<Keychain>();
 
+        private readonly IEnvironment environment;
+        private readonly IFileSystem fileSystem;
         private readonly ICredentialManager credentialManager;
-        private readonly NPath cachePath;
+        private readonly string cachePath;
 
         // loaded at the start of application from cached/serialized data
         private Dictionary<UriString, Connection> connectionCache = new Dictionary<UriString, Connection>();
 
         // cached credentials loaded from git to pass to GitHub/ApiClient
-        private Dictionary<UriString, KeychainAdapter> keychainAdapters =
-            new Dictionary<UriString, KeychainAdapter>();
+        private readonly Dictionary<UriString, KeychainAdapter> keychainAdapters
+            = new Dictionary<UriString, KeychainAdapter>();
 
-        public Keychain(IEnvironment environment, ICredentialManager credentialManager)
+        public Keychain(IEnvironment environment, IFileSystem fileSystem, ICredentialManager credentialManager)
         {
-            cachePath = environment.UserCachePath.Combine(ConnectionFile);
+            Guard.ArgumentNotNull(environment, nameof(environment));
+            Guard.ArgumentNotNull(fileSystem, nameof(fileSystem));
+            Guard.ArgumentNotNull(credentialManager, nameof(credentialManager));
+
+            Guard.NotNull(environment, environment.UserCachePath, nameof(environment.UserCachePath));
+
+            cachePath = environment.UserCachePath.Combine(ConnectionFile).ToString();
+            this.environment = environment;
+            this.fileSystem = fileSystem;
             this.credentialManager = credentialManager;
         }
 
@@ -101,17 +111,18 @@ private void ReadCacheFromDisk()
             logger.Trace("ReadCacheFromDisk Path:{0}", cachePath.ToString());
 
             ConnectionCacheItem[] connections = null;
-            if (cachePath.FileExists())
+            
+            if (fileSystem.FileExists(cachePath))
             {
-                var json = cachePath.ReadAllText();
+                var json = fileSystem.ReadAllText(cachePath);
                 try
                 {
                     connections = SimpleJson.DeserializeObject<ConnectionCacheItem[]>(json);
                 }
                 catch (Exception ex)
                 {
                     logger.Error(ex, "Error deserializing connection cache: {0}", cachePath);
-                    cachePath.Delete();
+                    fileSystem.FileDelete(cachePath);
                 }
             }
 
@@ -140,7 +151,7 @@ private void WriteCacheToDisk()
                         }).ToArray();
 
             var json = SimpleJson.SerializeObject(connectionCacheItems);
-            cachePath.WriteAllText(json);
+            fileSystem.WriteAllText(cachePath, json);
         }
 
         /// <summary>

src/GitHub.Api/Platform/Platform.cs

@@ -27,7 +27,7 @@ public IPlatform Initialize(IProcessManager processManager, ITaskManager taskMan
             if (CredentialManager == null)
             {
                 CredentialManager = new GitCredentialManager(Environment, processManager, taskManager);
-                Keychain = new Keychain(Environment, CredentialManager);
+                Keychain = new Keychain(Environment, Environment.FileSystem, CredentialManager);
                 Keychain.Initialize();
             }
 

src/tests/UnitTests/Authentication/KeychainTests.cs

@@ -0,0 +1,86 @@
+using System.Collections.Generic;
+using GitHub.Unity;
+using NCrunch.Framework;
+using NSubstitute;
+using NUnit.Framework;
+using TestUtils;
+
+namespace UnitTests
+{
+    [TestFixture, Isolated]
+    public class KeychainTests
+    {
+        private static readonly SubstituteFactory SubstituteFactory = new SubstituteFactory();
+
+        [Test]
+        public void Should_Initialize_When_Cache_Does_Not_Exist()
+        {
+            const string connectionsCachePath = "c:\\UserCachePath\\";
+
+            var environment = SubstituteFactory.CreateEnvironment();
+            environment.UserCachePath.Returns(info => connectionsCachePath.ToNPath());
+
+            var fileSystem = SubstituteFactory.CreateFileSystem();
+            var credentialManager = NSubstitute.Substitute.For<ICredentialManager>();
+
+            var keychain = new Keychain(environment, fileSystem, credentialManager);
+            keychain.Initialize();
+
+            fileSystem.Received(1).FileExists(@"c:\UserCachePath\connections.json");
+            fileSystem.DidNotReceive().ReadAllText(Args.String);
+            fileSystem.DidNotReceive().ReadAllLines(Args.String);
+        }
+
+        [Test]
+        public void Should_Initialize_When_Cache_Invalid()
+        {
+            const string connectionsCachePath = "c:\\UserCachePath\\";
+            const string connectionsCacheFile = @"c:\UserCachePath\connections.json";
+
+            var environment = SubstituteFactory.CreateEnvironment();
+            environment.UserCachePath.Returns(info => connectionsCachePath.ToNPath());
+
+            var fileSystem = SubstituteFactory.CreateFileSystem(new CreateFileSystemOptions()
+            {
+                FilesThatExist = new List<string> { connectionsCacheFile },
+                FileContents = new Dictionary<string, IList<string>> {
+                    {connectionsCacheFile, new List<string> { @"invalid json" }}
+                }
+            });
+
+            var credentialManager = Substitute.For<ICredentialManager>();
+
+            var keychain = new Keychain(environment, fileSystem, credentialManager);
+            keychain.Initialize();
+
+            fileSystem.Received(1).FileExists(connectionsCacheFile);
+            fileSystem.Received(1).ReadAllText(connectionsCacheFile);
+        }
+
+        [Test]
+        public void Should_Initialize_When_Cache_Exists()
+        {
+            const string connectionsCachePath = "c:\\UserCachePath\\";
+            const string connectionsCacheFile = @"c:\UserCachePath\connections.json";
+
+            var environment = SubstituteFactory.CreateEnvironment();
+            environment.UserCachePath.Returns(info => connectionsCachePath.ToNPath());
+
+            var fileSystem = SubstituteFactory.CreateFileSystem(new CreateFileSystemOptions()
+            {
+                FilesThatExist = new List<string> { connectionsCacheFile },
+                FileContents = new Dictionary<string, IList<string>> {
+                    {connectionsCacheFile, new List<string> { @"[{""Host"":""https://github.com/"",""Username"":""StanleyGoldman""}]" }}
+                }
+            });
+
+            var credentialManager = Substitute.For<ICredentialManager>();
+
+            var keychain = new Keychain(environment, fileSystem, credentialManager);
+            keychain.Initialize();
+
+            fileSystem.Received(1).FileExists(connectionsCacheFile);
+            fileSystem.Received(1).ReadAllText(connectionsCacheFile);
+        }
+    }
+}

src/tests/UnitTests/UnitTests.csproj

@@ -80,6 +80,7 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Authentication\KeychainTests.cs" />
     <Compile Include="Git\GitConfigTests.cs" />
     <Compile Include="IO\BranchListOutputProcessorTests.cs" />
     <Compile Include="Extensions\EnvironmentExtensionTests.cs" />