diff --git a/src/.editorconfig b/src/.editorconfig
index 9a433412..417bb343 100644
--- a/src/.editorconfig
+++ b/src/.editorconfig
@@ -47,7 +47,7 @@ dotnet_diagnostic.CA2227.severity = warning
 dotnet_diagnostic.IDE0004.severity = warning
 
 # IDE0005: Using directive is unnecessary
-dotnet_diagnostic.IDE0005.severity = warning
+dotnet_diagnostic.IDE0005.severity = error
 
 # IDE0008: Use explicit type
 csharp_style_var_elsewhere = true:suggestion
@@ -91,7 +91,7 @@ dotnet_diagnostic.SA1117.severity = none
 dotnet_diagnostic.SA1122.severity = error
 
 # SA1200: Using directive should appear within a namespace declaration
-dotnet_diagnostic.SA1200.severity = error
+dotnet_diagnostic.SA1200.severity = none
 
 # SA1201: Elements should appear in the correct order
 dotnet_diagnostic.SA1201.severity = none
diff --git a/src/GitReleaseManager.Cli/Logging/LogConfiguration.cs b/src/GitReleaseManager.Cli/Logging/LogConfiguration.cs
index ff1796a1..b03f0e57 100644
--- a/src/GitReleaseManager.Cli/Logging/LogConfiguration.cs
+++ b/src/GitReleaseManager.Cli/Logging/LogConfiguration.cs
@@ -1,14 +1,14 @@
+using System.Diagnostics;
+using System.Text;
+using Destructurama;
+using GitReleaseManager.Core.Options;
+using Octokit;
+using Serilog;
+using Serilog.Events;
+using Serilog.Sinks.SystemConsole.Themes;
+
 namespace GitReleaseManager.Cli.Logging
 {
-    using System.Diagnostics;
-    using System.Text;
-    using Destructurama;
-    using GitReleaseManager.Core.Options;
-    using Octokit;
-    using Serilog;
-    using Serilog.Events;
-    using Serilog.Sinks.SystemConsole.Themes;
-
     public static class LogConfiguration
     {
         private const string CONSOLE_FULL_TEMPLATE = "[{Level:u3}] " + CONSOLE_INFO_TEMPLATE;
diff --git a/src/GitReleaseManager.Cli/Program.cs b/src/GitReleaseManager.Cli/Program.cs
index 031813e8..9e1cf4a4 100644
--- a/src/GitReleaseManager.Cli/Program.cs
+++ b/src/GitReleaseManager.Cli/Program.cs
@@ -1,23 +1,23 @@
+using System;
+using System.Net;
+using System.Reflection;
+using System.Threading.Tasks;
+using CommandLine;
+using GitReleaseManager.Cli.Logging;
+using GitReleaseManager.Core;
+using GitReleaseManager.Core.Commands;
+using GitReleaseManager.Core.Configuration;
+using GitReleaseManager.Core.Helpers;
+using GitReleaseManager.Core.Options;
+using GitReleaseManager.Core.Provider;
+using GitReleaseManager.Core.ReleaseNotes;
+using GitReleaseManager.Core.Templates;
+using Microsoft.Extensions.DependencyInjection;
+using Octokit;
+using Serilog;
+
 namespace GitReleaseManager.Cli
 {
-    using System;
-    using System.Net;
-    using System.Reflection;
-    using System.Threading.Tasks;
-    using CommandLine;
-    using GitReleaseManager.Cli.Logging;
-    using GitReleaseManager.Core;
-    using GitReleaseManager.Core.Commands;
-    using GitReleaseManager.Core.Configuration;
-    using GitReleaseManager.Core.Helpers;
-    using GitReleaseManager.Core.Options;
-    using GitReleaseManager.Core.Provider;
-    using GitReleaseManager.Core.ReleaseNotes;
-    using GitReleaseManager.Core.Templates;
-    using Microsoft.Extensions.DependencyInjection;
-    using Octokit;
-    using Serilog;
-
     public static class Program
     {
         private static IServiceProvider _serviceProvider;
diff --git a/src/GitReleaseManager.Core.Tests/.editorconfig b/src/GitReleaseManager.Core.Tests/.editorconfig
new file mode 100644
index 00000000..8572e65f
--- /dev/null
+++ b/src/GitReleaseManager.Core.Tests/.editorconfig
@@ -0,0 +1,4 @@
+root = false
+
+[*.cs]
+dotnet_naming_rule.async_method_should_have_async_suffix.severity = none
\ No newline at end of file
diff --git a/src/GitReleaseManager.Core.Tests/Commands/AddAssetsCommandTests.cs b/src/GitReleaseManager.Core.Tests/Commands/AddAssetsCommandTests.cs
index ae785760..43035efe 100644
--- a/src/GitReleaseManager.Core.Tests/Commands/AddAssetsCommandTests.cs
+++ b/src/GitReleaseManager.Core.Tests/Commands/AddAssetsCommandTests.cs
@@ -1,14 +1,14 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using GitReleaseManager.Core.Commands;
+using GitReleaseManager.Core.Options;
+using NSubstitute;
+using NUnit.Framework;
+using Serilog;
+using Shouldly;
+
 namespace GitReleaseManager.Core.Tests.Commands
 {
-    using System.Collections.Generic;
-    using System.Threading.Tasks;
-    using GitReleaseManager.Core.Commands;
-    using GitReleaseManager.Core.Options;
-    using NSubstitute;
-    using NUnit.Framework;
-    using Serilog;
-    using Shouldly;
-
     [TestFixture]
     public class AddAssetsCommandTests
     {
diff --git a/src/GitReleaseManager.Core.Tests/Commands/CloseCommandTests.cs b/src/GitReleaseManager.Core.Tests/Commands/CloseCommandTests.cs
index b0ec5f7b..f9a57c89 100644
--- a/src/GitReleaseManager.Core.Tests/Commands/CloseCommandTests.cs
+++ b/src/GitReleaseManager.Core.Tests/Commands/CloseCommandTests.cs
@@ -1,13 +1,13 @@
+using System.Threading.Tasks;
+using GitReleaseManager.Core.Commands;
+using GitReleaseManager.Core.Options;
+using NSubstitute;
+using NUnit.Framework;
+using Serilog;
+using Shouldly;
+
 namespace GitReleaseManager.Core.Tests.Commands
 {
-    using System.Threading.Tasks;
-    using GitReleaseManager.Core.Commands;
-    using GitReleaseManager.Core.Options;
-    using NSubstitute;
-    using NUnit.Framework;
-    using Serilog;
-    using Shouldly;
-
     [TestFixture]
     public class CloseCommandTests
     {
diff --git a/src/GitReleaseManager.Core.Tests/Commands/CreateCommandTests.cs b/src/GitReleaseManager.Core.Tests/Commands/CreateCommandTests.cs
index 7d191312..de14eef5 100644
--- a/src/GitReleaseManager.Core.Tests/Commands/CreateCommandTests.cs
+++ b/src/GitReleaseManager.Core.Tests/Commands/CreateCommandTests.cs
@@ -1,15 +1,15 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using GitReleaseManager.Core.Commands;
+using GitReleaseManager.Core.Model;
+using GitReleaseManager.Core.Options;
+using NSubstitute;
+using NUnit.Framework;
+using Serilog;
+using Shouldly;
+
 namespace GitReleaseManager.Core.Tests.Commands
 {
-    using System.Collections.Generic;
-    using System.Threading.Tasks;
-    using GitReleaseManager.Core.Commands;
-    using GitReleaseManager.Core.Model;
-    using GitReleaseManager.Core.Options;
-    using NSubstitute;
-    using NUnit.Framework;
-    using Serilog;
-    using Shouldly;
-
     [TestFixture]
     public class CreateCommandTests
     {
diff --git a/src/GitReleaseManager.Core.Tests/Commands/DiscardCommandTests.cs b/src/GitReleaseManager.Core.Tests/Commands/DiscardCommandTests.cs
index ec248edf..51de6f0c 100644
--- a/src/GitReleaseManager.Core.Tests/Commands/DiscardCommandTests.cs
+++ b/src/GitReleaseManager.Core.Tests/Commands/DiscardCommandTests.cs
@@ -1,13 +1,13 @@
+using System.Threading.Tasks;
+using GitReleaseManager.Core.Commands;
+using GitReleaseManager.Core.Options;
+using NSubstitute;
+using NUnit.Framework;
+using Serilog;
+using Shouldly;
+
 namespace GitReleaseManager.Core.Tests.Commands
 {
-    using System.Threading.Tasks;
-    using GitReleaseManager.Core.Commands;
-    using GitReleaseManager.Core.Options;
-    using NSubstitute;
-    using NUnit.Framework;
-    using Serilog;
-    using Shouldly;
-
     [TestFixture]
     public class DiscardCommandTests
     {
diff --git a/src/GitReleaseManager.Core.Tests/Commands/ExportCommandTests.cs b/src/GitReleaseManager.Core.Tests/Commands/ExportCommandTests.cs
index 829190c7..9dc9f278 100644
--- a/src/GitReleaseManager.Core.Tests/Commands/ExportCommandTests.cs
+++ b/src/GitReleaseManager.Core.Tests/Commands/ExportCommandTests.cs
@@ -1,14 +1,14 @@
+using System.IO;
+using System.Threading.Tasks;
+using GitReleaseManager.Core.Commands;
+using GitReleaseManager.Core.Options;
+using NSubstitute;
+using NUnit.Framework;
+using Serilog;
+using Shouldly;
+
 namespace GitReleaseManager.Core.Tests.Commands
 {
-    using System.IO;
-    using System.Threading.Tasks;
-    using GitReleaseManager.Core.Commands;
-    using GitReleaseManager.Core.Options;
-    using NSubstitute;
-    using NUnit.Framework;
-    using Serilog;
-    using Shouldly;
-
     [TestFixture]
     public class ExportCommandTests
     {
diff --git a/src/GitReleaseManager.Core.Tests/Commands/InitCommandTests.cs b/src/GitReleaseManager.Core.Tests/Commands/InitCommandTests.cs
index 0dc975b0..9a587620 100644
--- a/src/GitReleaseManager.Core.Tests/Commands/InitCommandTests.cs
+++ b/src/GitReleaseManager.Core.Tests/Commands/InitCommandTests.cs
@@ -1,15 +1,15 @@
+using System.IO;
+using System.Threading.Tasks;
+using GitReleaseManager.Core.Commands;
+using GitReleaseManager.Core.Helpers;
+using GitReleaseManager.Core.Options;
+using NSubstitute;
+using NUnit.Framework;
+using Serilog;
+using Shouldly;
+
 namespace GitReleaseManager.Core.Tests.Commands
 {
-    using System.IO;
-    using System.Threading.Tasks;
-    using GitReleaseManager.Core.Commands;
-    using GitReleaseManager.Core.Helpers;
-    using GitReleaseManager.Core.Options;
-    using NSubstitute;
-    using NUnit.Framework;
-    using Serilog;
-    using Shouldly;
-
     [TestFixture]
     public class InitCommandTests
     {
diff --git a/src/GitReleaseManager.Core.Tests/Commands/LabelCommandTests.cs b/src/GitReleaseManager.Core.Tests/Commands/LabelCommandTests.cs
index 34a7ccee..1762d911 100644
--- a/src/GitReleaseManager.Core.Tests/Commands/LabelCommandTests.cs
+++ b/src/GitReleaseManager.Core.Tests/Commands/LabelCommandTests.cs
@@ -1,13 +1,13 @@
+using System.Threading.Tasks;
+using GitReleaseManager.Core.Commands;
+using GitReleaseManager.Core.Options;
+using NSubstitute;
+using NUnit.Framework;
+using Serilog;
+using Shouldly;
+
 namespace GitReleaseManager.Core.Tests.Commands
 {
-    using System.Threading.Tasks;
-    using GitReleaseManager.Core.Commands;
-    using GitReleaseManager.Core.Options;
-    using NSubstitute;
-    using NUnit.Framework;
-    using Serilog;
-    using Shouldly;
-
     [TestFixture]
     public class LabelCommandTests
     {
diff --git a/src/GitReleaseManager.Core.Tests/Commands/OpenCommandTests.cs b/src/GitReleaseManager.Core.Tests/Commands/OpenCommandTests.cs
index 2f646fea..21c36538 100644
--- a/src/GitReleaseManager.Core.Tests/Commands/OpenCommandTests.cs
+++ b/src/GitReleaseManager.Core.Tests/Commands/OpenCommandTests.cs
@@ -1,13 +1,13 @@
+using System.Threading.Tasks;
+using GitReleaseManager.Core.Commands;
+using GitReleaseManager.Core.Options;
+using NSubstitute;
+using NUnit.Framework;
+using Serilog;
+using Shouldly;
+
 namespace GitReleaseManager.Core.Tests.Commands
 {
-    using System.Threading.Tasks;
-    using GitReleaseManager.Core.Commands;
-    using GitReleaseManager.Core.Options;
-    using NSubstitute;
-    using NUnit.Framework;
-    using Serilog;
-    using Shouldly;
-
     [TestFixture]
     public class OpenCommandTests
     {
diff --git a/src/GitReleaseManager.Core.Tests/Commands/PublishCommandTests.cs b/src/GitReleaseManager.Core.Tests/Commands/PublishCommandTests.cs
index d4a4549f..87ebbc98 100644
--- a/src/GitReleaseManager.Core.Tests/Commands/PublishCommandTests.cs
+++ b/src/GitReleaseManager.Core.Tests/Commands/PublishCommandTests.cs
@@ -1,13 +1,13 @@
+using System.Threading.Tasks;
+using GitReleaseManager.Core.Commands;
+using GitReleaseManager.Core.Options;
+using NSubstitute;
+using NUnit.Framework;
+using Serilog;
+using Shouldly;
+
 namespace GitReleaseManager.Core.Tests.Commands
 {
-    using System.Threading.Tasks;
-    using GitReleaseManager.Core.Commands;
-    using GitReleaseManager.Core.Options;
-    using NSubstitute;
-    using NUnit.Framework;
-    using Serilog;
-    using Shouldly;
-
     [TestFixture]
     public class PublishCommandTests
     {
diff --git a/src/GitReleaseManager.Core.Tests/Commands/ShowConfigCommandTests.cs b/src/GitReleaseManager.Core.Tests/Commands/ShowConfigCommandTests.cs
index b2bcab26..7456af05 100644
--- a/src/GitReleaseManager.Core.Tests/Commands/ShowConfigCommandTests.cs
+++ b/src/GitReleaseManager.Core.Tests/Commands/ShowConfigCommandTests.cs
@@ -1,14 +1,14 @@
+using System.Threading.Tasks;
+using GitReleaseManager.Core.Commands;
+using GitReleaseManager.Core.Helpers;
+using GitReleaseManager.Core.Options;
+using NSubstitute;
+using NUnit.Framework;
+using Serilog;
+using Shouldly;
+
 namespace GitReleaseManager.Core.Tests.Commands
 {
-    using System.Threading.Tasks;
-    using GitReleaseManager.Core.Commands;
-    using GitReleaseManager.Core.Helpers;
-    using GitReleaseManager.Core.Options;
-    using NSubstitute;
-    using NUnit.Framework;
-    using Serilog;
-    using Shouldly;
-
     [TestFixture]
     public class ShowConfigCommandTests
     {
diff --git a/src/GitReleaseManager.Core.Tests/EnsureTests.cs b/src/GitReleaseManager.Core.Tests/EnsureTests.cs
index 4a5bc9f8..91281ff4 100644
--- a/src/GitReleaseManager.Core.Tests/EnsureTests.cs
+++ b/src/GitReleaseManager.Core.Tests/EnsureTests.cs
@@ -1,10 +1,10 @@
+using System;
+using System.IO;
+using NUnit.Framework;
+using Shouldly;
+
 namespace GitReleaseManager.Core.Tests
 {
-    using System;
-    using System.IO;
-    using NUnit.Framework;
-    using Shouldly;
-
     [TestFixture]
     public class EnsureTests
     {
diff --git a/src/GitReleaseManager.Core.Tests/Provider/GitHubProviderTests.cs b/src/GitReleaseManager.Core.Tests/Provider/GitHubProviderTests.cs
index 938bd4b9..ad6668b8 100644
--- a/src/GitReleaseManager.Core.Tests/Provider/GitHubProviderTests.cs
+++ b/src/GitReleaseManager.Core.Tests/Provider/GitHubProviderTests.cs
@@ -1,53 +1,53 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Net;
+using System.Threading.Tasks;
+using AutoMapper;
+using GitReleaseManager.Core.Provider;
+using NSubstitute;
+using NSubstitute.ExceptionExtensions;
+using NUnit.Framework;
+using Octokit;
+using Shouldly;
+using ApiException = GitReleaseManager.Core.Exceptions.ApiException;
+using Issue = GitReleaseManager.Core.Model.Issue;
+using IssueComment = GitReleaseManager.Core.Model.IssueComment;
+using ItemState = GitReleaseManager.Core.Model.ItemState;
+using ItemStateFilter = GitReleaseManager.Core.Model.ItemStateFilter;
+using Label = GitReleaseManager.Core.Model.Label;
+using Milestone = GitReleaseManager.Core.Model.Milestone;
+using NotFoundException = GitReleaseManager.Core.Exceptions.NotFoundException;
+using RateLimit = GitReleaseManager.Core.Model.RateLimit;
+using Release = GitReleaseManager.Core.Model.Release;
+using ReleaseAssetUpload = GitReleaseManager.Core.Model.ReleaseAssetUpload;
+
 namespace GitReleaseManager.Core.Tests.Provider
 {
-    using System;
-    using System.Collections;
-    using System.Collections.Generic;
-    using System.Net;
-    using System.Threading.Tasks;
-    using AutoMapper;
-    using GitReleaseManager.Core.Provider;
-    using NSubstitute;
-    using NSubstitute.ExceptionExtensions;
-    using NUnit.Framework;
-    using Octokit;
-    using Shouldly;
-    using ApiException = GitReleaseManager.Core.Exceptions.ApiException;
-    using Issue = GitReleaseManager.Core.Model.Issue;
-    using IssueComment = GitReleaseManager.Core.Model.IssueComment;
-    using ItemState = GitReleaseManager.Core.Model.ItemState;
-    using ItemStateFilter = GitReleaseManager.Core.Model.ItemStateFilter;
-    using Label = GitReleaseManager.Core.Model.Label;
-    using Milestone = GitReleaseManager.Core.Model.Milestone;
-    using NotFoundException = GitReleaseManager.Core.Exceptions.NotFoundException;
-    using RateLimit = GitReleaseManager.Core.Model.RateLimit;
-    using Release = GitReleaseManager.Core.Model.Release;
-    using ReleaseAssetUpload = GitReleaseManager.Core.Model.ReleaseAssetUpload;
-
     [TestFixture]
     public class GitHubProviderTests
     {
-        private const string _owner = "owner";
-        private const string _repository = "repository";
-        private const string _base = "0.1.0";
-        private const string _head = "0.5.0";
-        private const int _milestoneNumber = 1;
-        private const string _milestoneNumberString = "1";
-        private const string _milestoneTitle = "0.1.0";
-        private const int _issueNumber = 1;
-        private const string _issueComment = "Issue Comment";
-        private const string _labelName = "Label";
-        private const string _tagName = "0.1.0";
-        private const int _releaseId = 1;
-        private const int _assetId = 1;
-        private const string _notFoundMessage = "NotFound";
+        private const string OWNER = "owner";
+        private const string REPOSITORY = "repository";
+        private const string BASE = "0.1.0";
+        private const string HEAD = "0.5.0";
+        private const int MILESTONE_NUMBER = 1;
+        private const string MILESTONE_NUMBER_STRING = "1";
+        private const string MILESTONE_TITLE = "0.1.0";
+        private const int ISSUE_NUMBER = 1;
+        private const string ISSUE_COMMENT = "Issue Comment";
+        private const string LABEL_NAME = "Label";
+        private const string TAG_NAME = "0.1.0";
+        private const int RELEASE_ID = 1;
+        private const int ASSET_ID = 1;
+        private const string NOT_FOUND_MESSAGE = "NotFound";
 
         private readonly Release _release = new Release();
         private readonly ReleaseAssetUpload _releaseAssetUpload = new ReleaseAssetUpload();
-        private readonly Octokit.NewLabel _newLabel = new Octokit.NewLabel(_labelName, "ffffff");
-        private readonly Octokit.NewRelease _newRelease = new Octokit.NewRelease(_tagName);
+        private readonly Octokit.NewLabel _newLabel = new Octokit.NewLabel(LABEL_NAME, "ffffff");
+        private readonly Octokit.NewRelease _newRelease = new Octokit.NewRelease(TAG_NAME);
         private readonly Exception _exception = new Exception("API Error");
-        private readonly Octokit.NotFoundException _notFoundException = new Octokit.NotFoundException(_notFoundMessage, HttpStatusCode.NotFound);
+        private readonly Octokit.NotFoundException _notFoundException = new Octokit.NotFoundException(NOT_FOUND_MESSAGE, HttpStatusCode.NotFound);
 
         private IMapper _mapper;
         private IGitHubClient _gitHubClient;
@@ -65,21 +65,21 @@ public void Setup()
         [Test]
         public async Task Should_Delete_Asset()
         {
-            _gitHubClient.Repository.Release.DeleteAsset(_owner, _repository, _assetId)
+            _gitHubClient.Repository.Release.DeleteAsset(OWNER, REPOSITORY, ASSET_ID)
                 .Returns(Task.FromResult);
 
-            await _gitHubProvider.DeleteAssetAsync(_owner, _repository, _assetId).ConfigureAwait(false);
+            await _gitHubProvider.DeleteAssetAsync(OWNER, REPOSITORY, ASSET_ID).ConfigureAwait(false);
 
-            await _gitHubClient.Repository.Release.Received(1).DeleteAsset(_owner, _repository, _assetId).ConfigureAwait(false);
+            await _gitHubClient.Repository.Release.Received(1).DeleteAsset(OWNER, REPOSITORY, ASSET_ID).ConfigureAwait(false);
         }
 
         [Test]
         public async Task Should_Throw_An_Exception_On_Deleting_Asset_For_Non_Existing_Id()
         {
-            _gitHubClient.Repository.Release.DeleteAsset(_owner, _repository, _assetId)
+            _gitHubClient.Repository.Release.DeleteAsset(OWNER, REPOSITORY, ASSET_ID)
                 .Returns(Task.FromException(_notFoundException));
 
-            var ex = await Should.ThrowAsync<NotFoundException>(() => _gitHubProvider.DeleteAssetAsync(_owner, _repository, _assetId)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<NotFoundException>(() => _gitHubProvider.DeleteAssetAsync(OWNER, REPOSITORY, ASSET_ID)).ConfigureAwait(false);
             ex.Message.ShouldBe(_notFoundException.Message);
             ex.InnerException.ShouldBe(_notFoundException);
         }
@@ -87,10 +87,10 @@ public async Task Should_Throw_An_Exception_On_Deleting_Asset_For_Non_Existing_I
         [Test]
         public async Task Should_Throw_An_Exception_On_Deleting_Asset()
         {
-            _gitHubClient.Repository.Release.DeleteAsset(_owner, _repository, _assetId)
+            _gitHubClient.Repository.Release.DeleteAsset(OWNER, REPOSITORY, ASSET_ID)
                 .Returns(Task.FromException(_exception));
 
-            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.DeleteAssetAsync(_owner, _repository, _assetId)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.DeleteAssetAsync(OWNER, REPOSITORY, ASSET_ID)).ConfigureAwait(false);
             ex.Message.ShouldBe(_exception.Message);
             ex.InnerException.ShouldBe(_exception);
         }
@@ -157,34 +157,34 @@ public async Task Should_Get_Commits_Count()
         {
             var commitsCount = 12;
 
-            _gitHubClient.Repository.Commit.Compare(_owner, _repository, _base, _head)
+            _gitHubClient.Repository.Commit.Compare(OWNER, REPOSITORY, BASE, HEAD)
                 .Returns(Task.FromResult(new CompareResult(null, null, null, null, null, null, null, null, commitsCount, 0, 0, null, null)));
 
-            var result = await _gitHubProvider.GetCommitsCount(_owner, _repository, _base, _head).ConfigureAwait(false);
+            var result = await _gitHubProvider.GetCommitsCount(OWNER, REPOSITORY, BASE, HEAD).ConfigureAwait(false);
             result.ShouldBe(commitsCount);
 
-            await _gitHubClient.Repository.Commit.Received(1).Compare(_owner, _repository, _base, _head).ConfigureAwait(false);
+            await _gitHubClient.Repository.Commit.Received(1).Compare(OWNER, REPOSITORY, BASE, HEAD).ConfigureAwait(false);
         }
 
         [Test]
         public async Task Should_Get_Commits_Count_Zero_If_No_Commits_Found()
         {
-            _gitHubClient.Repository.Commit.Compare(_owner, _repository, _base, _head)
+            _gitHubClient.Repository.Commit.Compare(OWNER, REPOSITORY, BASE, HEAD)
                 .Returns(Task.FromException<CompareResult>(_notFoundException));
 
-            var result = await _gitHubProvider.GetCommitsCount(_owner, _repository, _base, _head).ConfigureAwait(false);
+            var result = await _gitHubProvider.GetCommitsCount(OWNER, REPOSITORY, BASE, HEAD).ConfigureAwait(false);
             result.ShouldBe(0);
 
-            await _gitHubClient.Repository.Commit.Received(1).Compare(_owner, _repository, _base, _head).ConfigureAwait(false);
+            await _gitHubClient.Repository.Commit.Received(1).Compare(OWNER, REPOSITORY, BASE, HEAD).ConfigureAwait(false);
         }
 
         [Test]
         public async Task Should_Throw_An_Exception_On_Getting_Commits_Count()
         {
-            _gitHubClient.Repository.Commit.Compare(_owner, _repository, _base, _head)
+            _gitHubClient.Repository.Commit.Compare(OWNER, REPOSITORY, BASE, HEAD)
                 .Returns(Task.FromException<CompareResult>(_exception));
 
-            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.GetCommitsCount(_owner, _repository, _base, _head)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.GetCommitsCount(OWNER, REPOSITORY, BASE, HEAD)).ConfigureAwait(false);
             ex.Message.ShouldContain(_exception.Message);
             ex.InnerException.ShouldBeSameAs(_exception);
         }
@@ -193,7 +193,7 @@ public async Task Should_Throw_An_Exception_On_Getting_Commits_Count()
         [TestCase("0.5.0", "0.1.0", "https://github.com/owner/repository/compare/0.1.0...0.5.0")]
         public void Should_Get_Commits_Url(string head, string @base, string expectedResult)
         {
-            var result = _gitHubProvider.GetCommitsUrl(_owner, _repository, head, @base);
+            var result = _gitHubProvider.GetCommitsUrl(OWNER, REPOSITORY, head, @base);
             result.ShouldBe(expectedResult);
         }
 
@@ -226,21 +226,21 @@ public static IEnumerable GetCommitsUrl_TestCases()
         [Test]
         public async Task Should_Create_Issue_Comment()
         {
-            _gitHubClient.Issue.Comment.Create(_owner, _repository, _issueNumber, _issueComment)
+            _gitHubClient.Issue.Comment.Create(OWNER, REPOSITORY, ISSUE_NUMBER, ISSUE_COMMENT)
                 .Returns(Task.FromResult(new Octokit.IssueComment()));
 
-            await _gitHubProvider.CreateIssueCommentAsync(_owner, _repository, _issueNumber, _issueComment).ConfigureAwait(false);
+            await _gitHubProvider.CreateIssueCommentAsync(OWNER, REPOSITORY, ISSUE_NUMBER, ISSUE_COMMENT).ConfigureAwait(false);
 
-            await _gitHubClient.Issue.Comment.Received(1).Create(_owner, _repository, _issueNumber, _issueComment).ConfigureAwait(false);
+            await _gitHubClient.Issue.Comment.Received(1).Create(OWNER, REPOSITORY, ISSUE_NUMBER, ISSUE_COMMENT).ConfigureAwait(false);
         }
 
         [Test]
         public async Task Should_Throw_An_Exception_On_Creating_Issue_Comment_For_Non_Existing_Issue_Number()
         {
-            _gitHubClient.Issue.Comment.Create(_owner, _repository, _issueNumber, _issueComment)
+            _gitHubClient.Issue.Comment.Create(OWNER, REPOSITORY, ISSUE_NUMBER, ISSUE_COMMENT)
                 .Returns(Task.FromException<Octokit.IssueComment>(_notFoundException));
 
-            var ex = await Should.ThrowAsync<NotFoundException>(() => _gitHubProvider.CreateIssueCommentAsync(_owner, _repository, _issueNumber, _issueComment)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<NotFoundException>(() => _gitHubProvider.CreateIssueCommentAsync(OWNER, REPOSITORY, ISSUE_NUMBER, ISSUE_COMMENT)).ConfigureAwait(false);
             ex.Message.ShouldBe(_notFoundException.Message);
             ex.InnerException.ShouldBe(_notFoundException);
         }
@@ -248,10 +248,10 @@ public async Task Should_Throw_An_Exception_On_Creating_Issue_Comment_For_Non_Ex
         [Test]
         public async Task Should_Throw_An_Exception_On_Creating_Issue_Comment()
         {
-            _gitHubClient.Issue.Comment.Create(_owner, _repository, _issueNumber, _issueComment)
+            _gitHubClient.Issue.Comment.Create(OWNER, REPOSITORY, ISSUE_NUMBER, ISSUE_COMMENT)
                 .Returns(Task.FromException<Octokit.IssueComment>(_exception));
 
-            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.CreateIssueCommentAsync(_owner, _repository, _issueNumber, _issueComment)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.CreateIssueCommentAsync(OWNER, REPOSITORY, ISSUE_NUMBER, ISSUE_COMMENT)).ConfigureAwait(false);
             ex.Message.ShouldBe(_exception.Message);
             ex.InnerException.ShouldBe(_exception);
         }
@@ -263,19 +263,19 @@ public async Task Should_Get_Issues_For_Milestone(ItemStateFilter itemStateFilte
         {
             var issues = new List<Issue>();
 
-            _gitHubClient.Issue.GetAllForRepository(_owner, _repository, Arg.Any<RepositoryIssueRequest>(), Arg.Any<ApiOptions>())
+            _gitHubClient.Issue.GetAllForRepository(OWNER, REPOSITORY, Arg.Any<RepositoryIssueRequest>(), Arg.Any<ApiOptions>())
                 .Returns(Task.FromResult((IReadOnlyList<Octokit.Issue>)new List<Octokit.Issue>()));
 
             _mapper.Map<IEnumerable<Issue>>(Arg.Any<object>())
                 .Returns(issues);
 
-            var result = await _gitHubProvider.GetIssuesAsync(_owner, _repository, _milestoneNumber, itemStateFilter).ConfigureAwait(false);
+            var result = await _gitHubProvider.GetIssuesAsync(OWNER, REPOSITORY, MILESTONE_NUMBER, itemStateFilter).ConfigureAwait(false);
             result.ShouldBeSameAs(issues);
 
             await _gitHubClient.Issue.Received(1).GetAllForRepository(
-                _owner,
-                _repository,
-                Arg.Is<RepositoryIssueRequest>(o => o.Milestone == _milestoneNumberString && o.State == (Octokit.ItemStateFilter)itemStateFilter),
+                OWNER,
+                REPOSITORY,
+                Arg.Is<RepositoryIssueRequest>(o => o.Milestone == MILESTONE_NUMBER_STRING && o.State == (Octokit.ItemStateFilter)itemStateFilter),
                 Arg.Any<ApiOptions>()).ConfigureAwait(false);
 
             _mapper.ReceivedWithAnyArgs(1).Map<IEnumerable<Issue>>(default);
@@ -284,10 +284,10 @@ await _gitHubClient.Issue.Received(1).GetAllForRepository(
         [Test]
         public async Task Should_Throw_An_Exception_On_Getting_Issues_For_Non_Existent_Milestone()
         {
-            _gitHubClient.Issue.GetAllForRepository(_owner, _repository, Arg.Any<RepositoryIssueRequest>(), Arg.Any<ApiOptions>())
+            _gitHubClient.Issue.GetAllForRepository(OWNER, REPOSITORY, Arg.Any<RepositoryIssueRequest>(), Arg.Any<ApiOptions>())
                 .Returns(Task.FromException<IReadOnlyList<Octokit.Issue>>(_exception));
 
-            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.GetIssuesAsync(_owner, _repository, 1)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.GetIssuesAsync(OWNER, REPOSITORY, 1)).ConfigureAwait(false);
             ex.Message.ShouldBe(_exception.Message);
             ex.InnerException.ShouldBe(_exception);
         }
@@ -297,26 +297,26 @@ public async Task Should_Get_Issue_Comments()
         {
             var comments = new List<IssueComment>();
 
-            _gitHubClient.Issue.Comment.GetAllForIssue(_owner, _repository, _issueNumber, Arg.Any<ApiOptions>())
+            _gitHubClient.Issue.Comment.GetAllForIssue(OWNER, REPOSITORY, ISSUE_NUMBER, Arg.Any<ApiOptions>())
                 .Returns(Task.FromResult((IReadOnlyList<Octokit.IssueComment>)new List<Octokit.IssueComment>()));
 
             _mapper.Map<IEnumerable<IssueComment>>(Arg.Any<object>())
                 .Returns(comments);
 
-            var result = await _gitHubProvider.GetIssueCommentsAsync(_owner, _repository, _issueNumber).ConfigureAwait(false);
+            var result = await _gitHubProvider.GetIssueCommentsAsync(OWNER, REPOSITORY, ISSUE_NUMBER).ConfigureAwait(false);
             result.ShouldBeSameAs(comments);
 
-            await _gitHubClient.Issue.Comment.Received(1).GetAllForIssue(_owner, _repository, _issueNumber, Arg.Any<ApiOptions>()).ConfigureAwait(false);
+            await _gitHubClient.Issue.Comment.Received(1).GetAllForIssue(OWNER, REPOSITORY, ISSUE_NUMBER, Arg.Any<ApiOptions>()).ConfigureAwait(false);
             _mapper.Received(1).Map<IEnumerable<IssueComment>>(Arg.Any<object>());
         }
 
         [Test]
         public async Task Should_Throw_An_Exception_On_Getting_Issue_Comments_For_Non_Existing_Issue_Number()
         {
-            _gitHubClient.Issue.Comment.GetAllForIssue(_owner, _repository, _issueNumber, Arg.Any<ApiOptions>())
+            _gitHubClient.Issue.Comment.GetAllForIssue(OWNER, REPOSITORY, ISSUE_NUMBER, Arg.Any<ApiOptions>())
                 .Returns(Task.FromException<IReadOnlyList<Octokit.IssueComment>>(_notFoundException));
 
-            var ex = await Should.ThrowAsync<NotFoundException>(() => _gitHubProvider.GetIssueCommentsAsync(_owner, _repository, _issueNumber)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<NotFoundException>(() => _gitHubProvider.GetIssueCommentsAsync(OWNER, REPOSITORY, ISSUE_NUMBER)).ConfigureAwait(false);
             ex.Message.ShouldBe(_notFoundException.Message);
             ex.InnerException.ShouldBe(_notFoundException);
         }
@@ -324,10 +324,10 @@ public async Task Should_Throw_An_Exception_On_Getting_Issue_Comments_For_Non_Ex
         [Test]
         public async Task Should_Throw_An_Exception_On_Getting_Issue_Comments()
         {
-            _gitHubClient.Issue.Comment.GetAllForIssue(_owner, _repository, _issueNumber, Arg.Any<ApiOptions>())
+            _gitHubClient.Issue.Comment.GetAllForIssue(OWNER, REPOSITORY, ISSUE_NUMBER, Arg.Any<ApiOptions>())
                 .Returns(Task.FromException<IReadOnlyList<Octokit.IssueComment>>(_exception));
 
-            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.GetIssueCommentsAsync(_owner, _repository, _issueNumber)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.GetIssueCommentsAsync(OWNER, REPOSITORY, ISSUE_NUMBER)).ConfigureAwait(false);
             ex.Message.ShouldBe(_exception.Message);
             ex.InnerException.ShouldBe(_exception);
         }
@@ -339,12 +339,12 @@ public async Task Should_Create_Label()
             _mapper.Map<Octokit.NewLabel>(Arg.Any<Label>())
                 .Returns(_newLabel);
 
-            _gitHubClient.Issue.Labels.Create(_owner, _repository, _newLabel)
+            _gitHubClient.Issue.Labels.Create(OWNER, REPOSITORY, _newLabel)
                 .Returns(Task.FromResult(new Octokit.Label()));
 
-            await _gitHubProvider.CreateLabelAsync(_owner, _repository, new Label()).ConfigureAwait(false);
+            await _gitHubProvider.CreateLabelAsync(OWNER, REPOSITORY, new Label()).ConfigureAwait(false);
 
-            await _gitHubClient.Issue.Labels.Received(1).Create(_owner, _repository, _newLabel).ConfigureAwait(false);
+            await _gitHubClient.Issue.Labels.Received(1).Create(OWNER, REPOSITORY, _newLabel).ConfigureAwait(false);
             _mapper.Received(1).Map<Octokit.NewLabel>(Arg.Any<Label>());
         }
 
@@ -356,10 +356,10 @@ public async Task Should_Throw_An_Exception_On_Creating_Label()
             _mapper.Map<Octokit.NewLabel>(label)
                 .Returns(_newLabel);
 
-            _gitHubClient.Issue.Labels.Create(_owner, _repository, _newLabel)
+            _gitHubClient.Issue.Labels.Create(OWNER, REPOSITORY, _newLabel)
                 .Returns(Task.FromException<Octokit.Label>(_exception));
 
-            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.CreateLabelAsync(_owner, _repository, label)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.CreateLabelAsync(OWNER, REPOSITORY, label)).ConfigureAwait(false);
             ex.Message.ShouldBe(_exception.Message);
             ex.InnerException.ShouldBe(_exception);
         }
@@ -367,21 +367,21 @@ public async Task Should_Throw_An_Exception_On_Creating_Label()
         [Test]
         public async Task Should_Delete_Label()
         {
-            _gitHubClient.Issue.Labels.Delete(_owner, _repository, _labelName)
+            _gitHubClient.Issue.Labels.Delete(OWNER, REPOSITORY, LABEL_NAME)
                 .Returns(Task.FromResult);
 
-            await _gitHubProvider.DeleteLabelAsync(_owner, _repository, _labelName).ConfigureAwait(false);
+            await _gitHubProvider.DeleteLabelAsync(OWNER, REPOSITORY, LABEL_NAME).ConfigureAwait(false);
 
-            await _gitHubClient.Issue.Labels.Received(1).Delete(_owner, _repository, _labelName).ConfigureAwait(false);
+            await _gitHubClient.Issue.Labels.Received(1).Delete(OWNER, REPOSITORY, LABEL_NAME).ConfigureAwait(false);
         }
 
         [Test]
         public async Task Should_Throw_An_Exception_On_Deleting_Label_For_Non_Existing_Label()
         {
-            _gitHubClient.Issue.Labels.Delete(_owner, _repository, _labelName)
+            _gitHubClient.Issue.Labels.Delete(OWNER, REPOSITORY, LABEL_NAME)
                 .Returns(Task.FromException<IReadOnlyList<Octokit.Label>>(_notFoundException));
 
-            var ex = await Should.ThrowAsync<NotFoundException>(() => _gitHubProvider.DeleteLabelAsync(_owner, _repository, _labelName)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<NotFoundException>(() => _gitHubProvider.DeleteLabelAsync(OWNER, REPOSITORY, LABEL_NAME)).ConfigureAwait(false);
             ex.Message.ShouldBe(_notFoundException.Message);
             ex.InnerException.ShouldBe(_notFoundException);
         }
@@ -389,10 +389,10 @@ public async Task Should_Throw_An_Exception_On_Deleting_Label_For_Non_Existing_L
         [Test]
         public async Task Should_Throw_An_Exception_On_Deleting_Label()
         {
-            _gitHubClient.Issue.Labels.Delete(_owner, _repository, _labelName)
+            _gitHubClient.Issue.Labels.Delete(OWNER, REPOSITORY, LABEL_NAME)
                 .Returns(Task.FromException<IReadOnlyList<Octokit.Label>>(_exception));
 
-            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.DeleteLabelAsync(_owner, _repository, _labelName)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.DeleteLabelAsync(OWNER, REPOSITORY, LABEL_NAME)).ConfigureAwait(false);
             ex.Message.ShouldBe(_exception.Message);
             ex.InnerException.ShouldBe(_exception);
         }
@@ -402,26 +402,26 @@ public async Task Should_Get_Labels()
         {
             var labels = new List<Label>();
 
-            _gitHubClient.Issue.Labels.GetAllForRepository(_owner, _repository, Arg.Any<ApiOptions>())
+            _gitHubClient.Issue.Labels.GetAllForRepository(OWNER, REPOSITORY, Arg.Any<ApiOptions>())
                 .Returns(Task.FromResult((IReadOnlyList<Octokit.Label>)new List<Octokit.Label>()));
 
             _mapper.Map<IEnumerable<Label>>(Arg.Any<object>())
                 .Returns(labels);
 
-            var result = await _gitHubProvider.GetLabelsAsync(_owner, _repository).ConfigureAwait(false);
+            var result = await _gitHubProvider.GetLabelsAsync(OWNER, REPOSITORY).ConfigureAwait(false);
             result.ShouldBeSameAs(labels);
 
-            await _gitHubClient.Issue.Labels.Received(1).GetAllForRepository(_owner, _repository, Arg.Any<ApiOptions>()).ConfigureAwait(false);
+            await _gitHubClient.Issue.Labels.Received(1).GetAllForRepository(OWNER, REPOSITORY, Arg.Any<ApiOptions>()).ConfigureAwait(false);
             _mapper.ReceivedWithAnyArgs(1).Map<IEnumerable<Label>>(default);
         }
 
         [Test]
         public async Task Should_Throw_An_Exception_On_Getting_Labels()
         {
-            _gitHubClient.Issue.Labels.GetAllForRepository(_owner, _repository, Arg.Any<ApiOptions>())
+            _gitHubClient.Issue.Labels.GetAllForRepository(OWNER, REPOSITORY, Arg.Any<ApiOptions>())
                 .Returns(Task.FromException<IReadOnlyList<Octokit.Label>>(_exception));
 
-            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.GetLabelsAsync(_owner, _repository)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.GetLabelsAsync(OWNER, REPOSITORY)).ConfigureAwait(false);
             ex.Message.ShouldBe(_exception.Message);
             ex.InnerException.ShouldBe(_exception);
         }
@@ -432,21 +432,21 @@ public async Task Should_Throw_An_Exception_On_Getting_Labels()
         [TestCase(ItemStateFilter.All)]
         public async Task Should_Get_Milestone(ItemStateFilter itemStateFilter)
         {
-            var milestone = new Milestone { Title = _milestoneTitle };
+            var milestone = new Milestone { Title = MILESTONE_TITLE };
             var milestones = new List<Milestone> { milestone };
 
-            _gitHubClient.Issue.Milestone.GetAllForRepository(_owner, _repository, Arg.Any<MilestoneRequest>(), Arg.Any<ApiOptions>())
+            _gitHubClient.Issue.Milestone.GetAllForRepository(OWNER, REPOSITORY, Arg.Any<MilestoneRequest>(), Arg.Any<ApiOptions>())
                 .Returns(Task.FromResult((IReadOnlyList<Octokit.Milestone>)new List<Octokit.Milestone>()));
 
             _mapper.Map<IEnumerable<Milestone>>(Arg.Any<object>())
                 .Returns(milestones);
 
-            var result = await _gitHubProvider.GetMilestoneAsync(_owner, _repository, _milestoneTitle, itemStateFilter).ConfigureAwait(false);
+            var result = await _gitHubProvider.GetMilestoneAsync(OWNER, REPOSITORY, MILESTONE_TITLE, itemStateFilter).ConfigureAwait(false);
             result.ShouldBeSameAs(milestone);
 
             await _gitHubClient.Issue.Milestone.Received(1).GetAllForRepository(
-                _owner,
-                _repository,
+                OWNER,
+                REPOSITORY,
                 Arg.Is<MilestoneRequest>(o => o.State == (Octokit.ItemStateFilter)itemStateFilter),
                 Arg.Any<ApiOptions>()).ConfigureAwait(false);
 
@@ -456,14 +456,14 @@ await _gitHubClient.Issue.Milestone.Received(1).GetAllForRepository(
         [Test]
         public async Task Should_Throw_An_Exception_On_Getting_Milestone_For_Non_Existing_Title()
         {
-            _gitHubClient.Issue.Milestone.GetAllForRepository(_owner, _repository, Arg.Any<MilestoneRequest>())
+            _gitHubClient.Issue.Milestone.GetAllForRepository(OWNER, REPOSITORY, Arg.Any<MilestoneRequest>())
                 .Returns(Task.FromResult((IReadOnlyList<Octokit.Milestone>)new List<Octokit.Milestone>()));
 
             _mapper.Map<IEnumerable<Milestone>>(Arg.Any<object>())
                 .Returns(new List<Milestone>());
 
-            var ex = await Should.ThrowAsync<NotFoundException>(() => _gitHubProvider.GetMilestoneAsync(_owner, _repository, _milestoneTitle)).ConfigureAwait(false);
-            ex.Message.ShouldBe(_notFoundMessage);
+            var ex = await Should.ThrowAsync<NotFoundException>(() => _gitHubProvider.GetMilestoneAsync(OWNER, REPOSITORY, MILESTONE_TITLE)).ConfigureAwait(false);
+            ex.Message.ShouldBe(NOT_FOUND_MESSAGE);
             ex.InnerException.ShouldBeNull();
         }
 
@@ -474,18 +474,18 @@ public async Task Should_Get_Milestones(ItemStateFilter itemStateFilter)
         {
             var milestones = new List<Milestone>();
 
-            _gitHubClient.Issue.Milestone.GetAllForRepository(_owner, _repository, Arg.Any<MilestoneRequest>(), Arg.Any<ApiOptions>())
+            _gitHubClient.Issue.Milestone.GetAllForRepository(OWNER, REPOSITORY, Arg.Any<MilestoneRequest>(), Arg.Any<ApiOptions>())
                 .Returns(Task.FromResult((IReadOnlyList<Octokit.Milestone>)new List<Octokit.Milestone>()));
 
             _mapper.Map<IEnumerable<Milestone>>(Arg.Any<object>())
                 .Returns(milestones);
 
-            var result = await _gitHubProvider.GetMilestonesAsync(_owner, _repository, itemStateFilter).ConfigureAwait(false);
+            var result = await _gitHubProvider.GetMilestonesAsync(OWNER, REPOSITORY, itemStateFilter).ConfigureAwait(false);
             result.ShouldBeSameAs(milestones);
 
             await _gitHubClient.Issue.Milestone.Received(1).GetAllForRepository(
-                _owner,
-                _repository,
+                OWNER,
+                REPOSITORY,
                 Arg.Is<MilestoneRequest>(o => o.State == (Octokit.ItemStateFilter)itemStateFilter),
                 Arg.Any<ApiOptions>()).ConfigureAwait(false);
 
@@ -495,10 +495,10 @@ await _gitHubClient.Issue.Milestone.Received(1).GetAllForRepository(
         [Test]
         public async Task Should_Throw_An_Exception_On_Getting_Milestones()
         {
-            _gitHubClient.Issue.Milestone.GetAllForRepository(_owner, _repository, Arg.Any<MilestoneRequest>(), Arg.Any<ApiOptions>())
+            _gitHubClient.Issue.Milestone.GetAllForRepository(OWNER, REPOSITORY, Arg.Any<MilestoneRequest>(), Arg.Any<ApiOptions>())
                 .Returns(Task.FromException<IReadOnlyList<Octokit.Milestone>>(_exception));
 
-            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.GetMilestonesAsync(_owner, _repository)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.GetMilestonesAsync(OWNER, REPOSITORY)).ConfigureAwait(false);
             ex.Message.ShouldBe(_exception.Message);
             ex.InnerException.ShouldBe(_exception);
         }
@@ -507,21 +507,21 @@ public async Task Should_Throw_An_Exception_On_Getting_Milestones()
         [TestCase(ItemState.Open)]
         public async Task Should_Set_Milestone_State(ItemState itemState)
         {
-            _gitHubClient.Issue.Milestone.Update(_owner, _repository, _milestoneNumber, Arg.Any<MilestoneUpdate>())
+            _gitHubClient.Issue.Milestone.Update(OWNER, REPOSITORY, MILESTONE_NUMBER, Arg.Any<MilestoneUpdate>())
                 .Returns(Task.FromResult(new Octokit.Milestone()));
 
-            await _gitHubProvider.SetMilestoneStateAsync(_owner, _repository, _milestoneNumber, itemState).ConfigureAwait(false);
+            await _gitHubProvider.SetMilestoneStateAsync(OWNER, REPOSITORY, MILESTONE_NUMBER, itemState).ConfigureAwait(false);
 
-            await _gitHubClient.Issue.Milestone.Received(1).Update(_owner, _repository, _milestoneNumber, Arg.Is<MilestoneUpdate>(o => o.State == (Octokit.ItemState)itemState)).ConfigureAwait(false);
+            await _gitHubClient.Issue.Milestone.Received(1).Update(OWNER, REPOSITORY, MILESTONE_NUMBER, Arg.Is<MilestoneUpdate>(o => o.State == (Octokit.ItemState)itemState)).ConfigureAwait(false);
         }
 
         [Test]
         public async Task Should_Throw_An_Exception_On_Setting_Milestone_State_For_Non_Existent_Number()
         {
-            _gitHubClient.Issue.Milestone.Update(_owner, _repository, _milestoneNumber, Arg.Any<MilestoneUpdate>())
+            _gitHubClient.Issue.Milestone.Update(OWNER, REPOSITORY, MILESTONE_NUMBER, Arg.Any<MilestoneUpdate>())
                 .Returns(Task.FromException<Octokit.Milestone>(_notFoundException));
 
-            var ex = await Should.ThrowAsync<NotFoundException>(() => _gitHubProvider.SetMilestoneStateAsync(_owner, _repository, _milestoneNumber, ItemState.Closed)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<NotFoundException>(() => _gitHubProvider.SetMilestoneStateAsync(OWNER, REPOSITORY, MILESTONE_NUMBER, ItemState.Closed)).ConfigureAwait(false);
             ex.Message.ShouldBe(_notFoundException.Message);
             ex.InnerException.ShouldBeSameAs(_notFoundException);
         }
@@ -529,10 +529,10 @@ public async Task Should_Throw_An_Exception_On_Setting_Milestone_State_For_Non_E
         [Test]
         public async Task Should_Throw_An_Exception_On_Setting_Milestone_State()
         {
-            _gitHubClient.Issue.Milestone.Update(_owner, _repository, _milestoneNumber, Arg.Any<MilestoneUpdate>())
+            _gitHubClient.Issue.Milestone.Update(OWNER, REPOSITORY, MILESTONE_NUMBER, Arg.Any<MilestoneUpdate>())
                 .Returns(Task.FromException<Octokit.Milestone>(_exception));
 
-            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.SetMilestoneStateAsync(_owner, _repository, _milestoneNumber, ItemState.Closed)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.SetMilestoneStateAsync(OWNER, REPOSITORY, MILESTONE_NUMBER, ItemState.Closed)).ConfigureAwait(false);
             ex.Message.ShouldBe(_exception.Message);
             ex.InnerException.ShouldBeSameAs(_exception);
         }
@@ -547,16 +547,16 @@ public async Task Should_Create_Release()
             _mapper.Map<Octokit.NewRelease>(createRelease)
                 .Returns(_newRelease);
 
-            _gitHubClient.Repository.Release.Create(_owner, _repository, _newRelease)
+            _gitHubClient.Repository.Release.Create(OWNER, REPOSITORY, _newRelease)
                 .Returns(Task.FromResult(new Octokit.Release()));
 
             _mapper.Map<Release>(Arg.Any<Octokit.Release>())
                 .Returns(resultRelease);
 
-            var result = await _gitHubProvider.CreateReleaseAsync(_owner, _repository, createRelease).ConfigureAwait(false);
+            var result = await _gitHubProvider.CreateReleaseAsync(OWNER, REPOSITORY, createRelease).ConfigureAwait(false);
             result.ShouldBeSameAs(resultRelease);
 
-            await _gitHubClient.Repository.Release.Received(1).Create(_owner, _repository, _newRelease).ConfigureAwait(false);
+            await _gitHubClient.Repository.Release.Received(1).Create(OWNER, REPOSITORY, _newRelease).ConfigureAwait(false);
             _mapper.Received(1).Map<Octokit.NewRelease>(Arg.Any<Release>());
             _mapper.Received(1).Map<Release>(Arg.Any<Octokit.Release>());
         }
@@ -569,10 +569,10 @@ public async Task Should_Throw_An_Exception_On_Creating_Release()
             _mapper.Map<Octokit.NewRelease>(label)
                 .Returns(_newRelease);
 
-            _gitHubClient.Repository.Release.Create(_owner, _repository, _newRelease)
+            _gitHubClient.Repository.Release.Create(OWNER, REPOSITORY, _newRelease)
                 .Returns(Task.FromException<Octokit.Release>(_exception));
 
-            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.CreateReleaseAsync(_owner, _repository, label)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.CreateReleaseAsync(OWNER, REPOSITORY, label)).ConfigureAwait(false);
             ex.Message.ShouldBe(_exception.Message);
             ex.InnerException.ShouldBe(_exception);
         }
@@ -582,12 +582,12 @@ public async Task Should_Delete_Release()
         {
             var id = 1;
 
-            _gitHubClient.Repository.Release.Delete(_owner, _repository, id)
+            _gitHubClient.Repository.Release.Delete(OWNER, REPOSITORY, id)
                 .Returns(Task.CompletedTask);
 
-            await _gitHubProvider.DeleteReleaseAsync(_owner, _repository, id).ConfigureAwait(false);
+            await _gitHubProvider.DeleteReleaseAsync(OWNER, REPOSITORY, id).ConfigureAwait(false);
 
-            await _gitHubClient.Repository.Release.Received(1).Delete(_owner, _repository, id).ConfigureAwait(false);
+            await _gitHubClient.Repository.Release.Received(1).Delete(OWNER, REPOSITORY, id).ConfigureAwait(false);
         }
 
         [Test]
@@ -595,10 +595,10 @@ public async Task Should_Throw_An_Exception_On_Deleting_Release_For_Non_Existent
         {
             var id = 1;
 
-            _gitHubClient.Repository.Release.Delete(_owner, _repository, id)
+            _gitHubClient.Repository.Release.Delete(OWNER, REPOSITORY, id)
                 .Returns(Task.FromException(_notFoundException));
 
-            var ex = await Should.ThrowAsync<NotFoundException>(() => _gitHubProvider.DeleteReleaseAsync(_owner, _repository, id)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<NotFoundException>(() => _gitHubProvider.DeleteReleaseAsync(OWNER, REPOSITORY, id)).ConfigureAwait(false);
             ex.Message.ShouldBe(_notFoundException.Message);
             ex.InnerException.ShouldBeSameAs(_notFoundException);
         }
@@ -608,10 +608,10 @@ public async Task Should_Throw_An_Exception_On_Deleting_Release()
         {
             var id = 1;
 
-            _gitHubClient.Repository.Release.Delete(_owner, _repository, id)
+            _gitHubClient.Repository.Release.Delete(OWNER, REPOSITORY, id)
                 .Returns(Task.FromException(_exception));
 
-            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.DeleteReleaseAsync(_owner, _repository, id)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.DeleteReleaseAsync(OWNER, REPOSITORY, id)).ConfigureAwait(false);
             ex.Message.ShouldBe(_exception.Message);
             ex.InnerException.ShouldBeSameAs(_exception);
         }
@@ -621,26 +621,26 @@ public async Task Should_Get_Release()
         {
             var release = new Release();
 
-            _gitHubClient.Repository.Release.Get(_owner, _repository, _tagName)
+            _gitHubClient.Repository.Release.Get(OWNER, REPOSITORY, TAG_NAME)
                 .Returns(Task.FromResult(new Octokit.Release()));
 
             _mapper.Map<Release>(Arg.Any<object>())
                 .Returns(release);
 
-            var result = await _gitHubProvider.GetReleaseAsync(_owner, _repository, _tagName).ConfigureAwait(false);
+            var result = await _gitHubProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
             result.ShouldBeSameAs(release);
 
-            await _gitHubClient.Repository.Release.Received(1).Get(_owner, _repository, _tagName).ConfigureAwait(false);
+            await _gitHubClient.Repository.Release.Received(1).Get(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
             _mapper.Received(1).Map<Release>(Arg.Any<object>());
         }
 
         [Test]
         public async Task Should_Throw_An_Exception_On_Getting_Release_For_Non_Existent_Tag()
         {
-            _gitHubClient.Repository.Release.Get(_owner, _repository, _tagName)
+            _gitHubClient.Repository.Release.Get(OWNER, REPOSITORY, TAG_NAME)
                 .Returns(Task.FromException<Octokit.Release>(_notFoundException));
 
-            var ex = await Should.ThrowAsync<NotFoundException>(() => _gitHubProvider.GetReleaseAsync(_owner, _repository, _tagName)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<NotFoundException>(() => _gitHubProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)).ConfigureAwait(false);
             ex.Message.ShouldBe(_notFoundException.Message);
             ex.InnerException.ShouldBe(_notFoundException);
         }
@@ -648,10 +648,10 @@ public async Task Should_Throw_An_Exception_On_Getting_Release_For_Non_Existent_
         [Test]
         public async Task Should_Throw_An_Exception_On_Getting_Release()
         {
-            _gitHubClient.Repository.Release.Get(_owner, _repository, _tagName)
+            _gitHubClient.Repository.Release.Get(OWNER, REPOSITORY, TAG_NAME)
                 .Returns(Task.FromException<Octokit.Release>(_exception));
 
-            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.GetReleaseAsync(_owner, _repository, _tagName)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)).ConfigureAwait(false);
             ex.Message.ShouldBe(_exception.Message);
             ex.InnerException.ShouldBe(_exception);
         }
@@ -661,26 +661,26 @@ public async Task Should_Get_Releases()
         {
             var releases = new List<Release>();
 
-            _gitHubClient.Repository.Release.GetAll(_owner, _repository, Arg.Any<ApiOptions>())
+            _gitHubClient.Repository.Release.GetAll(OWNER, REPOSITORY, Arg.Any<ApiOptions>())
                 .Returns(Task.FromResult((IReadOnlyList<Octokit.Release>)new List<Octokit.Release>()));
 
             _mapper.Map<IEnumerable<Release>>(Arg.Any<object>())
                 .Returns(releases);
 
-            var result = await _gitHubProvider.GetReleasesAsync(_owner, _repository).ConfigureAwait(false);
+            var result = await _gitHubProvider.GetReleasesAsync(OWNER, REPOSITORY).ConfigureAwait(false);
             result.ShouldBeSameAs(releases);
 
-            await _gitHubClient.Repository.Release.Received(1).GetAll(_owner, _repository, Arg.Any<ApiOptions>()).ConfigureAwait(false);
+            await _gitHubClient.Repository.Release.Received(1).GetAll(OWNER, REPOSITORY, Arg.Any<ApiOptions>()).ConfigureAwait(false);
             _mapper.Received(1).Map<IEnumerable<Release>>(Arg.Any<object>());
         }
 
         [Test]
         public async Task Should_Throw_An_Exception_On_Getting_Releases()
         {
-            _gitHubClient.Repository.Release.GetAll(_owner, _repository, Arg.Any<ApiOptions>())
+            _gitHubClient.Repository.Release.GetAll(OWNER, REPOSITORY, Arg.Any<ApiOptions>())
                 .Returns(Task.FromException<IReadOnlyList<Octokit.Release>>(_exception));
 
-            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.GetReleasesAsync(_owner, _repository)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.GetReleasesAsync(OWNER, REPOSITORY)).ConfigureAwait(false);
             ex.Message.ShouldBe(_exception.Message);
             ex.InnerException.ShouldBe(_exception);
         }
@@ -688,23 +688,23 @@ public async Task Should_Throw_An_Exception_On_Getting_Releases()
         [Test]
         public async Task Should_Publish_Release()
         {
-            _gitHubClient.Repository.Release.Edit(_owner, _repository, _releaseId, Arg.Any<ReleaseUpdate>())
+            _gitHubClient.Repository.Release.Edit(OWNER, REPOSITORY, RELEASE_ID, Arg.Any<ReleaseUpdate>())
                 .Returns(Task.FromResult(new Octokit.Release()));
 
-            await _gitHubProvider.PublishReleaseAsync(_owner, _repository, _tagName, _releaseId).ConfigureAwait(false);
+            await _gitHubProvider.PublishReleaseAsync(OWNER, REPOSITORY, TAG_NAME, RELEASE_ID).ConfigureAwait(false);
 
-            await _gitHubClient.Repository.Release.Received(1).Edit(_owner, _repository, _releaseId, Arg.Is<ReleaseUpdate>(o =>
+            await _gitHubClient.Repository.Release.Received(1).Edit(OWNER, REPOSITORY, RELEASE_ID, Arg.Is<ReleaseUpdate>(o =>
                 o.Draft == false &&
-                o.TagName == _tagName)).ConfigureAwait(false);
+                o.TagName == TAG_NAME)).ConfigureAwait(false);
         }
 
         [Test]
         public async Task Should_Throw_An_Exception_On_Publishing_Release_For_Non_Existent_Id()
         {
-            _gitHubClient.Repository.Release.Edit(_owner, _repository, _releaseId, Arg.Any<ReleaseUpdate>())
+            _gitHubClient.Repository.Release.Edit(OWNER, REPOSITORY, RELEASE_ID, Arg.Any<ReleaseUpdate>())
                 .Returns(Task.FromException<Octokit.Release>(_notFoundException));
 
-            var ex = await Should.ThrowAsync<NotFoundException>(() => _gitHubProvider.PublishReleaseAsync(_owner, _repository, _tagName, _releaseId)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<NotFoundException>(() => _gitHubProvider.PublishReleaseAsync(OWNER, REPOSITORY, TAG_NAME, RELEASE_ID)).ConfigureAwait(false);
             ex.Message.ShouldBe(_notFoundException.Message);
             ex.InnerException.ShouldBe(_notFoundException);
         }
@@ -712,10 +712,10 @@ public async Task Should_Throw_An_Exception_On_Publishing_Release_For_Non_Existe
         [Test]
         public async Task Should_Throw_An_Exception_On_Publishing_Release()
         {
-            _gitHubClient.Repository.Release.Edit(_owner, _repository, _releaseId, Arg.Any<ReleaseUpdate>())
+            _gitHubClient.Repository.Release.Edit(OWNER, REPOSITORY, RELEASE_ID, Arg.Any<ReleaseUpdate>())
                 .Returns(Task.FromException<Octokit.Release>(_exception));
 
-            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.PublishReleaseAsync(_owner, _repository, _tagName, _releaseId)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.PublishReleaseAsync(OWNER, REPOSITORY, TAG_NAME, RELEASE_ID)).ConfigureAwait(false);
             ex.Message.ShouldBe(_exception.Message);
             ex.InnerException.ShouldBe(_exception);
         }
@@ -725,7 +725,7 @@ public async Task Should_Update_Release()
         {
             var release = new Release
             {
-                Id = _releaseId,
+                Id = RELEASE_ID,
                 Body = "Body",
                 Draft = true,
                 Name = "Name",
@@ -734,12 +734,12 @@ public async Task Should_Update_Release()
                 TargetCommitish = "TargetCommitish",
             };
 
-            _gitHubClient.Repository.Release.Edit(_owner, _repository, release.Id, Arg.Any<ReleaseUpdate>())
+            _gitHubClient.Repository.Release.Edit(OWNER, REPOSITORY, release.Id, Arg.Any<ReleaseUpdate>())
                 .Returns(Task.FromResult(new Octokit.Release()));
 
-            await _gitHubProvider.UpdateReleaseAsync(_owner, _repository, release).ConfigureAwait(false);
+            await _gitHubProvider.UpdateReleaseAsync(OWNER, REPOSITORY, release).ConfigureAwait(false);
 
-            await _gitHubClient.Repository.Release.Received(1).Edit(_owner, _repository, release.Id, Arg.Is<ReleaseUpdate>(o =>
+            await _gitHubClient.Repository.Release.Received(1).Edit(OWNER, REPOSITORY, release.Id, Arg.Is<ReleaseUpdate>(o =>
                 o.Body == release.Body &&
                 o.Draft == release.Draft &&
                 o.Name == release.Name &&
@@ -751,12 +751,12 @@ await _gitHubClient.Repository.Release.Received(1).Edit(_owner, _repository, rel
         [Test]
         public async Task Should_Throw_An_Exception_On_Updating_Release_For_Non_Existent_Id()
         {
-            var release = new Release { Id = _releaseId };
+            var release = new Release { Id = RELEASE_ID };
 
-            _gitHubClient.Repository.Release.Edit(_owner, _repository, release.Id, Arg.Any<ReleaseUpdate>())
+            _gitHubClient.Repository.Release.Edit(OWNER, REPOSITORY, release.Id, Arg.Any<ReleaseUpdate>())
                 .Returns(Task.FromException<Octokit.Release>(_notFoundException));
 
-            var ex = await Should.ThrowAsync<NotFoundException>(() => _gitHubProvider.UpdateReleaseAsync(_owner, _repository, release)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<NotFoundException>(() => _gitHubProvider.UpdateReleaseAsync(OWNER, REPOSITORY, release)).ConfigureAwait(false);
             ex.Message.ShouldBe(_notFoundException.Message);
             ex.InnerException.ShouldBe(_notFoundException);
         }
@@ -764,12 +764,12 @@ public async Task Should_Throw_An_Exception_On_Updating_Release_For_Non_Existent
         [Test]
         public async Task Should_Throw_An_Exception_On_Updating_Release()
         {
-            var release = new Release { Id = _releaseId };
+            var release = new Release { Id = RELEASE_ID };
 
-            _gitHubClient.Repository.Release.Edit(_owner, _repository, release.Id, Arg.Any<ReleaseUpdate>())
+            _gitHubClient.Repository.Release.Edit(OWNER, REPOSITORY, release.Id, Arg.Any<ReleaseUpdate>())
                 .Returns(Task.FromException<Octokit.Release>(_exception));
 
-            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.UpdateReleaseAsync(_owner, _repository, release)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.UpdateReleaseAsync(OWNER, REPOSITORY, release)).ConfigureAwait(false);
             ex.Message.ShouldBe(_exception.Message);
             ex.InnerException.ShouldBe(_exception);
         }
diff --git a/src/GitReleaseManager.Core.Tests/Templates/TemplateLoaderTests.cs b/src/GitReleaseManager.Core.Tests/Templates/TemplateLoaderTests.cs
index 77433ccf..fd1dbf04 100644
--- a/src/GitReleaseManager.Core.Tests/Templates/TemplateLoaderTests.cs
+++ b/src/GitReleaseManager.Core.Tests/Templates/TemplateLoaderTests.cs
@@ -1,16 +1,16 @@
+using System;
+using System.Collections;
+using System.IO;
+using GitReleaseManager.Core.Configuration;
+using GitReleaseManager.Core.Helpers;
+using GitReleaseManager.Core.Templates;
+using NSubstitute;
+using NUnit.Framework;
+using Scriban;
+using Shouldly;
+
 namespace GitReleaseManager.Core.Tests.Templates
 {
-    using System;
-    using System.Collections;
-    using System.IO;
-    using GitReleaseManager.Core.Configuration;
-    using GitReleaseManager.Core.Helpers;
-    using GitReleaseManager.Core.Templates;
-    using NSubstitute;
-    using NUnit.Framework;
-    using Scriban;
-    using Shouldly;
-
     [TestFixture]
     public class TemplateLoaderTests
     {
diff --git a/src/GitReleaseManager.Core.Tests/VcsServiceTests.cs b/src/GitReleaseManager.Core.Tests/VcsServiceTests.cs
index 50af2d6c..887ae73c 100644
--- a/src/GitReleaseManager.Core.Tests/VcsServiceTests.cs
+++ b/src/GitReleaseManager.Core.Tests/VcsServiceTests.cs
@@ -1,39 +1,39 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using GitReleaseManager.Core.Configuration;
+using GitReleaseManager.Core.Model;
+using GitReleaseManager.Core.Provider;
+using GitReleaseManager.Core.ReleaseNotes;
+using GitReleaseManager.Core.Templates;
+using NSubstitute;
+using NUnit.Framework;
+using Serilog;
+using Shouldly;
+using ItemState = GitReleaseManager.Core.Model.ItemState;
+using ItemStateFilter = GitReleaseManager.Core.Model.ItemStateFilter;
+using Label = GitReleaseManager.Core.Model.Label;
+using Milestone = GitReleaseManager.Core.Model.Milestone;
+using NotFoundException = GitReleaseManager.Core.Exceptions.NotFoundException;
+using Release = GitReleaseManager.Core.Model.Release;
+
 namespace GitReleaseManager.Core.Tests
 {
-    using System;
-    using System.Collections;
-    using System.Collections.Generic;
-    using System.IO;
-    using System.Linq;
-    using System.Threading.Tasks;
-    using GitReleaseManager.Core.Configuration;
-    using GitReleaseManager.Core.Model;
-    using GitReleaseManager.Core.Provider;
-    using GitReleaseManager.Core.ReleaseNotes;
-    using GitReleaseManager.Core.Templates;
-    using NSubstitute;
-    using NUnit.Framework;
-    using Serilog;
-    using Shouldly;
-    using ItemState = GitReleaseManager.Core.Model.ItemState;
-    using ItemStateFilter = GitReleaseManager.Core.Model.ItemStateFilter;
-    using Label = GitReleaseManager.Core.Model.Label;
-    using Milestone = GitReleaseManager.Core.Model.Milestone;
-    using NotFoundException = GitReleaseManager.Core.Exceptions.NotFoundException;
-    using Release = GitReleaseManager.Core.Model.Release;
-
     public class VcsServiceTests
     {
-        private const string _owner = "owner";
-        private const string _repository = "repository";
-        private const int _milestoneNumber = 1;
-        private const string _milestoneTitle = "0.1.0";
-        private const string _tagName = "0.1.0";
-        private const string _releaseNotes = "Release Notes";
-        private const string _assetContent = "Asset Content";
+        private const string OWNER = "owner";
+        private const string REPOSITORY = "repository";
+        private const int MILESTONE_NUMBER = 1;
+        private const string MILESTONE_TITLE = "0.1.0";
+        private const string TAG_NAME = "0.1.0";
+        private const string RELEASE_NOTES = "Release Notes";
+        private const string ASSET_CONTENT = "Asset Content";
 
-        private const string _unableToFoundMilestoneMessage = "Unable to find a {State} milestone with title '{Title}' on '{Owner}/{Repository}'";
-        private const string _unableToFoundReleaseMessage = "Unable to find a release with tag '{TagName}' on '{Owner}/{Repository}'";
+        private const string UNABLE_TO_FOUND_MILESTONE_MESSAGE = "Unable to find a {State} milestone with title '{Title}' on '{Owner}/{Repository}'";
+        private const string UNABLE_TO_FOUND_RELEASE_MESSAGE = "Unable to find a release with tag '{TagName}' on '{Owner}/{Repository}'";
 
         private static readonly string _tempPath = Path.GetTempPath();
         private static readonly string _releaseNotesTemplate = Path.Combine(_tempPath, "ReleaseNotesTemplate.txt");
@@ -61,7 +61,7 @@ public void OneTimeSetUp()
 
             var fileContent = new Dictionary<string, string>
             {
-                { _releaseNotesFilePath, _releaseNotes },
+                { _releaseNotesFilePath, RELEASE_NOTES },
                 { _releaseNotesTemplateFilePath, _releaseNotesTemplate },
                 { _releaseNotesEmptyTemplateFilePath, string.Empty },
             };
@@ -72,7 +72,7 @@ public void OneTimeSetUp()
                 var filePath = Path.Combine(_tempPath, fileName);
                 _assets.Add(filePath);
 
-                fileContent.Add(filePath, _assetContent);
+                fileContent.Add(filePath, ASSET_CONTENT);
             }
 
             _files.Add(_releaseNotesFilePath);
@@ -119,17 +119,17 @@ public async Task Should_Add_Assets()
 
             var assetsCount = _assets.Count;
 
-            _vcsProvider.GetReleaseAsync(_owner, _repository, _tagName)
+            _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)
                 .Returns(release);
 
-            await _vcsService.AddAssetsAsync(_owner, _repository, _tagName, _assets).ConfigureAwait(false);
+            await _vcsService.AddAssetsAsync(OWNER, REPOSITORY, TAG_NAME, _assets).ConfigureAwait(false);
 
-            await _vcsProvider.Received(1).GetReleaseAsync(_owner, _repository, _tagName).ConfigureAwait(false);
-            await _vcsProvider.DidNotReceive().DeleteAssetAsync(_owner, _repository, Arg.Any<int>()).ConfigureAwait(false);
+            await _vcsProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
+            await _vcsProvider.DidNotReceive().DeleteAssetAsync(OWNER, REPOSITORY, Arg.Any<int>()).ConfigureAwait(false);
             await _vcsProvider.Received(assetsCount).UploadAssetAsync(release, Arg.Any<ReleaseAssetUpload>()).ConfigureAwait(false);
 
             _logger.DidNotReceive().Warning(Arg.Any<string>(), Arg.Any<string>());
-            _logger.Received(assetsCount).Verbose(Arg.Any<string>(), Arg.Any<string>(), _tagName, _owner, _repository);
+            _logger.Received(assetsCount).Verbose(Arg.Any<string>(), Arg.Any<string>(), TAG_NAME, OWNER, REPOSITORY);
             _logger.Received(assetsCount).Debug(Arg.Any<string>(), Arg.Any<ReleaseAssetUpload>());
         }
 
@@ -142,17 +142,17 @@ public async Task Should_Add_Assets_With_Deleting_Existing_Assets()
             var releaseAssetsCount = release.Assets.Count;
             var assetsCount = _assets.Count;
 
-            _vcsProvider.GetReleaseAsync(_owner, _repository, _tagName)
+            _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)
                 .Returns(release);
 
-            await _vcsService.AddAssetsAsync(_owner, _repository, _tagName, _assets).ConfigureAwait(false);
+            await _vcsService.AddAssetsAsync(OWNER, REPOSITORY, TAG_NAME, _assets).ConfigureAwait(false);
 
-            await _vcsProvider.Received(1).GetReleaseAsync(_owner, _repository, _tagName).ConfigureAwait(false);
-            await _vcsProvider.Received(releaseAssetsCount).DeleteAssetAsync(_owner, _repository, releaseAsset.Id).ConfigureAwait(false);
+            await _vcsProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
+            await _vcsProvider.Received(releaseAssetsCount).DeleteAssetAsync(OWNER, REPOSITORY, releaseAsset.Id).ConfigureAwait(false);
             await _vcsProvider.Received(assetsCount).UploadAssetAsync(release, Arg.Any<ReleaseAssetUpload>()).ConfigureAwait(false);
 
             _logger.Received(releaseAssetsCount).Warning(Arg.Any<string>(), Arg.Any<string>());
-            _logger.Received(assetsCount).Verbose(Arg.Any<string>(), Arg.Any<string>(), _tagName, _owner, _repository);
+            _logger.Received(assetsCount).Verbose(Arg.Any<string>(), Arg.Any<string>(), TAG_NAME, OWNER, REPOSITORY);
             _logger.Received(assetsCount).Debug(Arg.Any<string>(), Arg.Any<ReleaseAssetUpload>());
         }
 
@@ -164,24 +164,24 @@ public async Task Should_Throw_Exception_On_Adding_Assets_When_Asset_File_Not_Ex
 
             _assets[0] = assetFilePath;
 
-            _vcsProvider.GetReleaseAsync(_owner, _repository, _tagName)
+            _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)
                 .Returns(release);
 
-            var ex = await Should.ThrowAsync<FileNotFoundException>(() => _vcsService.AddAssetsAsync(_owner, _repository, _tagName, _assets)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<FileNotFoundException>(() => _vcsService.AddAssetsAsync(OWNER, REPOSITORY, TAG_NAME, _assets)).ConfigureAwait(false);
             ex.Message.ShouldContain(assetFilePath);
 
-            await _vcsProvider.Received(1).GetReleaseAsync(_owner, _repository, _tagName).ConfigureAwait(false);
-            await _vcsProvider.DidNotReceive().DeleteAssetAsync(_owner, _repository, Arg.Any<int>()).ConfigureAwait(false);
+            await _vcsProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
+            await _vcsProvider.DidNotReceive().DeleteAssetAsync(OWNER, REPOSITORY, Arg.Any<int>()).ConfigureAwait(false);
             await _vcsProvider.DidNotReceive().UploadAssetAsync(release, Arg.Any<ReleaseAssetUpload>()).ConfigureAwait(false);
         }
 
         [TestCaseSource(nameof(Assets_TestCases))]
         public async Task Should_Do_Nothing_On_Missing_Assets(IList<string> assets)
         {
-            await _vcsService.AddAssetsAsync(_owner, _repository, _tagName, assets).ConfigureAwait(false);
+            await _vcsService.AddAssetsAsync(OWNER, REPOSITORY, TAG_NAME, assets).ConfigureAwait(false);
 
-            await _vcsProvider.DidNotReceive().GetReleaseAsync(_owner, _repository, _tagName).ConfigureAwait(false);
-            await _vcsProvider.DidNotReceive().DeleteAssetAsync(_owner, _repository, Arg.Any<int>()).ConfigureAwait(false);
+            await _vcsProvider.DidNotReceive().GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
+            await _vcsProvider.DidNotReceive().DeleteAssetAsync(OWNER, REPOSITORY, Arg.Any<int>()).ConfigureAwait(false);
             await _vcsProvider.DidNotReceive().UploadAssetAsync(Arg.Any<Release>(), Arg.Any<ReleaseAssetUpload>()).ConfigureAwait(false);
         }
 
@@ -201,22 +201,22 @@ public async Task Should_Create_Labels()
                 new Label { Name = "Improvement" },
             };
 
-            _vcsProvider.GetLabelsAsync(_owner, _repository)
+            _vcsProvider.GetLabelsAsync(OWNER, REPOSITORY)
                 .Returns(Task.FromResult((IEnumerable<Label>)labels));
 
-            _vcsProvider.DeleteLabelAsync(_owner, _repository, Arg.Any<string>())
+            _vcsProvider.DeleteLabelAsync(OWNER, REPOSITORY, Arg.Any<string>())
                 .Returns(Task.CompletedTask);
 
-            _vcsProvider.CreateLabelAsync(_owner, _repository, Arg.Any<Label>())
+            _vcsProvider.CreateLabelAsync(OWNER, REPOSITORY, Arg.Any<Label>())
                 .Returns(Task.CompletedTask);
 
-            await _vcsService.CreateLabelsAsync(_owner, _repository).ConfigureAwait(false);
+            await _vcsService.CreateLabelsAsync(OWNER, REPOSITORY).ConfigureAwait(false);
 
-            await _vcsProvider.Received(1).GetLabelsAsync(_owner, _repository).ConfigureAwait(false);
-            await _vcsProvider.Received(labels.Count).DeleteLabelAsync(_owner, _repository, Arg.Any<string>()).ConfigureAwait(false);
-            await _vcsProvider.Received(_configuration.Labels.Count).CreateLabelAsync(_owner, _repository, Arg.Any<Label>()).ConfigureAwait(false);
+            await _vcsProvider.Received(1).GetLabelsAsync(OWNER, REPOSITORY).ConfigureAwait(false);
+            await _vcsProvider.Received(labels.Count).DeleteLabelAsync(OWNER, REPOSITORY, Arg.Any<string>()).ConfigureAwait(false);
+            await _vcsProvider.Received(_configuration.Labels.Count).CreateLabelAsync(OWNER, REPOSITORY, Arg.Any<Label>()).ConfigureAwait(false);
 
-            _logger.Received(1).Verbose(Arg.Any<string>(), _owner, _repository);
+            _logger.Received(1).Verbose(Arg.Any<string>(), OWNER, REPOSITORY);
             _logger.Received(2).Verbose(Arg.Any<string>());
             _logger.Received(2).Debug(Arg.Any<string>(), Arg.Any<IEnumerable<Label>>());
         }
@@ -226,7 +226,7 @@ public async Task Should_Log_An_Warning_When_Labels_Not_Configured()
         {
             _configuration.Labels.Clear();
 
-            await _vcsService.CreateLabelsAsync(_owner, _repository).ConfigureAwait(false);
+            await _vcsService.CreateLabelsAsync(OWNER, REPOSITORY).ConfigureAwait(false);
 
             _logger.Received(1).Warning(Arg.Any<string>());
         }
@@ -234,62 +234,62 @@ public async Task Should_Log_An_Warning_When_Labels_Not_Configured()
         [Test]
         public async Task Should_Close_Milestone()
         {
-            var milestone = new Milestone { Number = _milestoneNumber };
+            var milestone = new Milestone { Number = MILESTONE_NUMBER };
 
-            _vcsProvider.GetMilestoneAsync(_owner, _repository, _milestoneTitle, ItemStateFilter.Open)
+            _vcsProvider.GetMilestoneAsync(OWNER, REPOSITORY, MILESTONE_TITLE, ItemStateFilter.Open)
                 .Returns(Task.FromResult(milestone));
 
-            _vcsProvider.SetMilestoneStateAsync(_owner, _repository, milestone.Number, ItemState.Closed)
+            _vcsProvider.SetMilestoneStateAsync(OWNER, REPOSITORY, milestone.Number, ItemState.Closed)
                 .Returns(Task.CompletedTask);
 
-            await _vcsService.CloseMilestoneAsync(_owner, _repository, _milestoneTitle).ConfigureAwait(false);
+            await _vcsService.CloseMilestoneAsync(OWNER, REPOSITORY, MILESTONE_TITLE).ConfigureAwait(false);
 
-            await _vcsProvider.Received(1).GetMilestoneAsync(_owner, _repository, _milestoneTitle, ItemStateFilter.Open).ConfigureAwait(false);
-            await _vcsProvider.Received(1).SetMilestoneStateAsync(_owner, _repository, milestone.Number, ItemState.Closed).ConfigureAwait(false);
+            await _vcsProvider.Received(1).GetMilestoneAsync(OWNER, REPOSITORY, MILESTONE_TITLE, ItemStateFilter.Open).ConfigureAwait(false);
+            await _vcsProvider.Received(1).SetMilestoneStateAsync(OWNER, REPOSITORY, milestone.Number, ItemState.Closed).ConfigureAwait(false);
         }
 
         [Test]
         public async Task Should_Log_An_Warning_On_Closing_When_Milestone_Cannot_Be_Found()
         {
-            _vcsProvider.GetMilestoneAsync(_owner, _repository, _milestoneTitle, ItemStateFilter.Open)
+            _vcsProvider.GetMilestoneAsync(OWNER, REPOSITORY, MILESTONE_TITLE, ItemStateFilter.Open)
                 .Returns(Task.FromException<Milestone>(_notFoundException));
 
-            await _vcsService.CloseMilestoneAsync(_owner, _repository, _milestoneTitle).ConfigureAwait(false);
+            await _vcsService.CloseMilestoneAsync(OWNER, REPOSITORY, MILESTONE_TITLE).ConfigureAwait(false);
 
-            await _vcsProvider.Received(1).GetMilestoneAsync(_owner, _repository, _milestoneTitle, ItemStateFilter.Open).ConfigureAwait(false);
-            await _vcsProvider.DidNotReceive().SetMilestoneStateAsync(_owner, _repository, _milestoneNumber, ItemState.Closed).ConfigureAwait(false);
-            _logger.Received(1).Warning(_unableToFoundMilestoneMessage, "open", _milestoneTitle, _owner, _repository);
+            await _vcsProvider.Received(1).GetMilestoneAsync(OWNER, REPOSITORY, MILESTONE_TITLE, ItemStateFilter.Open).ConfigureAwait(false);
+            await _vcsProvider.DidNotReceive().SetMilestoneStateAsync(OWNER, REPOSITORY, MILESTONE_NUMBER, ItemState.Closed).ConfigureAwait(false);
+            _logger.Received(1).Warning(UNABLE_TO_FOUND_MILESTONE_MESSAGE, "open", MILESTONE_TITLE, OWNER, REPOSITORY);
         }
 
         [Test]
         public async Task Should_Open_Milestone()
         {
-            var milestone = new Milestone { Number = _milestoneNumber };
+            var milestone = new Milestone { Number = MILESTONE_NUMBER };
 
-            _vcsProvider.GetMilestoneAsync(_owner, _repository, _milestoneTitle, ItemStateFilter.Closed)
+            _vcsProvider.GetMilestoneAsync(OWNER, REPOSITORY, MILESTONE_TITLE, ItemStateFilter.Closed)
                 .Returns(Task.FromResult(milestone));
 
-            _vcsProvider.SetMilestoneStateAsync(_owner, _repository, milestone.Number, ItemState.Open)
+            _vcsProvider.SetMilestoneStateAsync(OWNER, REPOSITORY, milestone.Number, ItemState.Open)
                 .Returns(Task.CompletedTask);
 
-            await _vcsService.OpenMilestoneAsync(_owner, _repository, _milestoneTitle).ConfigureAwait(false);
+            await _vcsService.OpenMilestoneAsync(OWNER, REPOSITORY, MILESTONE_TITLE).ConfigureAwait(false);
 
-            await _vcsProvider.Received(1).GetMilestoneAsync(_owner, _repository, _milestoneTitle, ItemStateFilter.Closed).ConfigureAwait(false);
-            await _vcsProvider.Received(1).SetMilestoneStateAsync(_owner, _repository, milestone.Number, ItemState.Open).ConfigureAwait(false);
-            _logger.Received(2).Verbose(Arg.Any<string>(), _milestoneTitle, _owner, _repository);
+            await _vcsProvider.Received(1).GetMilestoneAsync(OWNER, REPOSITORY, MILESTONE_TITLE, ItemStateFilter.Closed).ConfigureAwait(false);
+            await _vcsProvider.Received(1).SetMilestoneStateAsync(OWNER, REPOSITORY, milestone.Number, ItemState.Open).ConfigureAwait(false);
+            _logger.Received(2).Verbose(Arg.Any<string>(), MILESTONE_TITLE, OWNER, REPOSITORY);
         }
 
         [Test]
         public async Task Should_Log_An_Warning_On_Opening_When_Milestone_Cannot_Be_Found()
         {
-            _vcsProvider.GetMilestoneAsync(_owner, _repository, _milestoneTitle, ItemStateFilter.Closed)
+            _vcsProvider.GetMilestoneAsync(OWNER, REPOSITORY, MILESTONE_TITLE, ItemStateFilter.Closed)
                 .Returns(Task.FromException<Milestone>(_notFoundException));
 
-            await _vcsService.OpenMilestoneAsync(_owner, _repository, _milestoneTitle).ConfigureAwait(false);
+            await _vcsService.OpenMilestoneAsync(OWNER, REPOSITORY, MILESTONE_TITLE).ConfigureAwait(false);
 
-            await _vcsProvider.Received(1).GetMilestoneAsync(_owner, _repository, _milestoneTitle, ItemStateFilter.Closed).ConfigureAwait(false);
-            await _vcsProvider.DidNotReceive().SetMilestoneStateAsync(_owner, _repository, _milestoneNumber, ItemState.Open).ConfigureAwait(false);
-            _logger.Received(1).Warning(_unableToFoundMilestoneMessage, "closed", _milestoneTitle, _owner, _repository);
+            await _vcsProvider.Received(1).GetMilestoneAsync(OWNER, REPOSITORY, MILESTONE_TITLE, ItemStateFilter.Closed).ConfigureAwait(false);
+            await _vcsProvider.DidNotReceive().SetMilestoneStateAsync(OWNER, REPOSITORY, MILESTONE_NUMBER, ItemState.Open).ConfigureAwait(false);
+            _logger.Received(1).Warning(UNABLE_TO_FOUND_MILESTONE_MESSAGE, "closed", MILESTONE_TITLE, OWNER, REPOSITORY);
         }
 
         [Test]
@@ -297,26 +297,26 @@ public async Task Should_Create_Release_From_Milestone()
         {
             var release = new Release();
 
-            _releaseNotesBuilder.BuildReleaseNotes(_owner, _repository, _milestoneTitle, ReleaseTemplates.DEFAULT_NAME)
-                .Returns(Task.FromResult(_releaseNotes));
+            _releaseNotesBuilder.BuildReleaseNotes(OWNER, REPOSITORY, MILESTONE_TITLE, ReleaseTemplates.DEFAULT_NAME)
+                .Returns(Task.FromResult(RELEASE_NOTES));
 
-            _vcsProvider.GetReleaseAsync(_owner, _repository, _milestoneTitle)
+            _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE)
                 .Returns(Task.FromException<Release>(_notFoundException));
 
-            _vcsProvider.CreateReleaseAsync(_owner, _repository, Arg.Any<Release>())
+            _vcsProvider.CreateReleaseAsync(OWNER, REPOSITORY, Arg.Any<Release>())
                 .Returns(Task.FromResult(release));
 
-            var result = await _vcsService.CreateReleaseFromMilestoneAsync(_owner, _repository, _milestoneTitle, _milestoneTitle, null, null, false, null).ConfigureAwait(false);
+            var result = await _vcsService.CreateReleaseFromMilestoneAsync(OWNER, REPOSITORY, MILESTONE_TITLE, MILESTONE_TITLE, null, null, false, null).ConfigureAwait(false);
             result.ShouldBeSameAs(release);
 
-            await _releaseNotesBuilder.Received(1).BuildReleaseNotes(_owner, _repository, _milestoneTitle, ReleaseTemplates.DEFAULT_NAME).ConfigureAwait(false);
-            await _vcsProvider.Received(1).GetReleaseAsync(_owner, _repository, _milestoneTitle).ConfigureAwait(false);
-            await _vcsProvider.Received(1).CreateReleaseAsync(_owner, _repository, Arg.Is<Release>(o =>
-                o.Body == _releaseNotes &&
-                o.Name == _milestoneTitle &&
-                o.TagName == _milestoneTitle)).ConfigureAwait(false);
+            await _releaseNotesBuilder.Received(1).BuildReleaseNotes(OWNER, REPOSITORY, MILESTONE_TITLE, ReleaseTemplates.DEFAULT_NAME).ConfigureAwait(false);
+            await _vcsProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE).ConfigureAwait(false);
+            await _vcsProvider.Received(1).CreateReleaseAsync(OWNER, REPOSITORY, Arg.Is<Release>(o =>
+                o.Body == RELEASE_NOTES &&
+                o.Name == MILESTONE_TITLE &&
+                o.TagName == MILESTONE_TITLE)).ConfigureAwait(false);
 
-            _logger.Received(1).Verbose(Arg.Any<string>(), _milestoneTitle, _owner, _repository);
+            _logger.Received(1).Verbose(Arg.Any<string>(), MILESTONE_TITLE, OWNER, REPOSITORY);
             _logger.Received(1).Debug(Arg.Any<string>(), Arg.Any<Release>());
         }
 
@@ -325,26 +325,26 @@ public async Task Should_Create_Release_From_Milestone_Using_Template_File()
         {
             var release = new Release();
 
-            _releaseNotesBuilder.BuildReleaseNotes(_owner, _repository, _milestoneTitle, _releaseNotesTemplate)
-                .Returns(Task.FromResult(_releaseNotes));
+            _releaseNotesBuilder.BuildReleaseNotes(OWNER, REPOSITORY, MILESTONE_TITLE, _releaseNotesTemplate)
+                .Returns(Task.FromResult(RELEASE_NOTES));
 
-            _vcsProvider.GetReleaseAsync(_owner, _repository, _milestoneTitle)
+            _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE)
                 .Returns(Task.FromException<Release>(_notFoundException));
 
-            _vcsProvider.CreateReleaseAsync(_owner, _repository, Arg.Any<Release>())
+            _vcsProvider.CreateReleaseAsync(OWNER, REPOSITORY, Arg.Any<Release>())
                 .Returns(Task.FromResult(release));
 
-            var result = await _vcsService.CreateReleaseFromMilestoneAsync(_owner, _repository, _milestoneTitle, _milestoneTitle, null, null, false, _releaseNotesTemplateFilePath).ConfigureAwait(false);
+            var result = await _vcsService.CreateReleaseFromMilestoneAsync(OWNER, REPOSITORY, MILESTONE_TITLE, MILESTONE_TITLE, null, null, false, _releaseNotesTemplateFilePath).ConfigureAwait(false);
             result.ShouldBeSameAs(release);
 
-            await _releaseNotesBuilder.Received(1).BuildReleaseNotes(_owner, _repository, _milestoneTitle, _releaseNotesTemplate).ConfigureAwait(false);
-            await _vcsProvider.Received(1).GetReleaseAsync(_owner, _repository, _milestoneTitle).ConfigureAwait(false);
-            await _vcsProvider.Received(1).CreateReleaseAsync(_owner, _repository, Arg.Is<Release>(o =>
-                o.Body == _releaseNotes &&
-                o.Name == _milestoneTitle &&
-                o.TagName == _milestoneTitle)).ConfigureAwait(false);
+            await _releaseNotesBuilder.Received(1).BuildReleaseNotes(OWNER, REPOSITORY, MILESTONE_TITLE, _releaseNotesTemplate).ConfigureAwait(false);
+            await _vcsProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE).ConfigureAwait(false);
+            await _vcsProvider.Received(1).CreateReleaseAsync(OWNER, REPOSITORY, Arg.Is<Release>(o =>
+                o.Body == RELEASE_NOTES &&
+                o.Name == MILESTONE_TITLE &&
+                o.TagName == MILESTONE_TITLE)).ConfigureAwait(false);
 
-            _logger.Received(1).Verbose(Arg.Any<string>(), _milestoneTitle, _owner, _repository);
+            _logger.Received(1).Verbose(Arg.Any<string>(), MILESTONE_TITLE, OWNER, REPOSITORY);
             _logger.Received(1).Debug(Arg.Any<string>(), Arg.Any<Release>());
         }
 
@@ -352,29 +352,29 @@ await _vcsProvider.Received(1).CreateReleaseAsync(_owner, _repository, Arg.Is<Re
         [Ignore("This may be handled by the TemplateLoader instead")]
         public async Task Should_Throw_Exception_On_Creating_Release_With_Empty_Template()
         {
-            _vcsProvider.GetReleaseAsync(_owner, _repository, _tagName)
+            _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)
                 .Returns(Task.FromException<Release>(_notFoundException));
 
-            await Should.ThrowAsync<ArgumentException>(() => _vcsService.CreateReleaseFromMilestoneAsync(_owner, _repository, _milestoneTitle, _milestoneTitle, null, null, false, _releaseNotesEmptyTemplateFilePath)).ConfigureAwait(false);
+            await Should.ThrowAsync<ArgumentException>(() => _vcsService.CreateReleaseFromMilestoneAsync(OWNER, REPOSITORY, MILESTONE_TITLE, MILESTONE_TITLE, null, null, false, _releaseNotesEmptyTemplateFilePath)).ConfigureAwait(false);
 
-            await _releaseNotesBuilder.DidNotReceive().BuildReleaseNotes(_owner, _repository, _milestoneTitle, Arg.Any<string>()).ConfigureAwait(false);
+            await _releaseNotesBuilder.DidNotReceive().BuildReleaseNotes(OWNER, REPOSITORY, MILESTONE_TITLE, Arg.Any<string>()).ConfigureAwait(false);
         }
 
         [Test]
         [Ignore("This may be handled by the TemplateLoader instead")]
         public async Task Should_Throw_Exception_On_Creating_Release_With_Invalid_Template_File_Path()
         {
-            _vcsProvider.GetReleaseAsync(_owner, _repository, _tagName)
+            _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)
                 .Returns(Task.FromException<Release>(_notFoundException));
 
             var fileName = "InvalidReleaseNotesTemplate.txt";
             var invalidReleaseNotesTemplateFilePath = Path.Combine(_tempPath, fileName);
 
-            var ex = await Should.ThrowAsync<FileNotFoundException>(() => _vcsService.CreateReleaseFromMilestoneAsync(_owner, _repository, _milestoneTitle, _milestoneTitle, null, null, false, invalidReleaseNotesTemplateFilePath)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<FileNotFoundException>(() => _vcsService.CreateReleaseFromMilestoneAsync(OWNER, REPOSITORY, MILESTONE_TITLE, MILESTONE_TITLE, null, null, false, invalidReleaseNotesTemplateFilePath)).ConfigureAwait(false);
             ex.Message.ShouldContain(invalidReleaseNotesTemplateFilePath);
             ex.FileName.ShouldBe(fileName);
 
-            await _releaseNotesBuilder.DidNotReceive().BuildReleaseNotes(_owner, _repository, _milestoneTitle, Arg.Any<string>()).ConfigureAwait(false);
+            await _releaseNotesBuilder.DidNotReceive().BuildReleaseNotes(OWNER, REPOSITORY, MILESTONE_TITLE, Arg.Any<string>()).ConfigureAwait(false);
         }
 
         [TestCase(true, false)]
@@ -386,24 +386,24 @@ public async Task Should_Update_Published_Release_On_Creating_Release_From_Miles
 
             _configuration.Create.AllowUpdateToPublishedRelease = updatePublishedRelease;
 
-            _releaseNotesBuilder.BuildReleaseNotes(_owner, _repository, _milestoneTitle, ReleaseTemplates.DEFAULT_NAME)
-                .Returns(Task.FromResult(_releaseNotes));
+            _releaseNotesBuilder.BuildReleaseNotes(OWNER, REPOSITORY, MILESTONE_TITLE, ReleaseTemplates.DEFAULT_NAME)
+                .Returns(Task.FromResult(RELEASE_NOTES));
 
-            _vcsProvider.GetReleaseAsync(_owner, _repository, _milestoneTitle)
+            _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE)
                 .Returns(Task.FromResult(release));
 
-            _vcsProvider.UpdateReleaseAsync(_owner, _repository, release)
+            _vcsProvider.UpdateReleaseAsync(OWNER, REPOSITORY, release)
                 .Returns(Task.FromResult(new Release()));
 
-            var result = await _vcsService.CreateReleaseFromMilestoneAsync(_owner, _repository, _milestoneTitle, _milestoneTitle, null, null, false, null).ConfigureAwait(false);
+            var result = await _vcsService.CreateReleaseFromMilestoneAsync(OWNER, REPOSITORY, MILESTONE_TITLE, MILESTONE_TITLE, null, null, false, null).ConfigureAwait(false);
             result.ShouldBeSameAs(release);
 
-            await _releaseNotesBuilder.Received(1).BuildReleaseNotes(_owner, _repository, _milestoneTitle, ReleaseTemplates.DEFAULT_NAME).ConfigureAwait(false);
-            await _vcsProvider.Received(1).GetReleaseAsync(_owner, _repository, _milestoneTitle).ConfigureAwait(false);
-            await _vcsProvider.Received(1).UpdateReleaseAsync(_owner, _repository, release).ConfigureAwait(false);
+            await _releaseNotesBuilder.Received(1).BuildReleaseNotes(OWNER, REPOSITORY, MILESTONE_TITLE, ReleaseTemplates.DEFAULT_NAME).ConfigureAwait(false);
+            await _vcsProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE).ConfigureAwait(false);
+            await _vcsProvider.Received(1).UpdateReleaseAsync(OWNER, REPOSITORY, release).ConfigureAwait(false);
 
-            _logger.Received(1).Warning(Arg.Any<string>(), _milestoneTitle);
-            _logger.Received(1).Verbose(Arg.Any<string>(), _milestoneTitle, _owner, _repository);
+            _logger.Received(1).Warning(Arg.Any<string>(), MILESTONE_TITLE);
+            _logger.Received(1).Verbose(Arg.Any<string>(), MILESTONE_TITLE, OWNER, REPOSITORY);
             _logger.Received(1).Debug(Arg.Any<string>(), release);
         }
 
@@ -414,17 +414,17 @@ public async Task Should_Throw_Exception_While_Updating_Published_Release_On_Cre
 
             _configuration.Create.AllowUpdateToPublishedRelease = false;
 
-            _releaseNotesBuilder.BuildReleaseNotes(_owner, _repository, _milestoneTitle, ReleaseTemplates.DEFAULT_NAME)
-                .Returns(Task.FromResult(_releaseNotes));
+            _releaseNotesBuilder.BuildReleaseNotes(OWNER, REPOSITORY, MILESTONE_TITLE, ReleaseTemplates.DEFAULT_NAME)
+                .Returns(Task.FromResult(RELEASE_NOTES));
 
-            _vcsProvider.GetReleaseAsync(_owner, _repository, _milestoneTitle)
+            _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE)
                 .Returns(Task.FromResult(release));
 
-            var ex = await Should.ThrowAsync<InvalidOperationException>(() => _vcsService.CreateReleaseFromMilestoneAsync(_owner, _repository, _milestoneTitle, _milestoneTitle, null, null, false, null)).ConfigureAwait(false);
-            ex.Message.ShouldBe($"Release with tag '{_milestoneTitle}' not in draft state, so not updating");
+            var ex = await Should.ThrowAsync<InvalidOperationException>(() => _vcsService.CreateReleaseFromMilestoneAsync(OWNER, REPOSITORY, MILESTONE_TITLE, MILESTONE_TITLE, null, null, false, null)).ConfigureAwait(false);
+            ex.Message.ShouldBe($"Release with tag '{MILESTONE_TITLE}' not in draft state, so not updating");
 
-            await _releaseNotesBuilder.Received(1).BuildReleaseNotes(_owner, _repository, _milestoneTitle, ReleaseTemplates.DEFAULT_NAME).ConfigureAwait(false);
-            await _vcsProvider.Received(1).GetReleaseAsync(_owner, _repository, _milestoneTitle).ConfigureAwait(false);
+            await _releaseNotesBuilder.Received(1).BuildReleaseNotes(OWNER, REPOSITORY, MILESTONE_TITLE, ReleaseTemplates.DEFAULT_NAME).ConfigureAwait(false);
+            await _vcsProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE).ConfigureAwait(false);
         }
 
         [Test]
@@ -432,22 +432,22 @@ public async Task Should_Create_Release_From_InputFile()
         {
             var release = new Release();
 
-            _vcsProvider.GetReleaseAsync(_owner, _repository, _milestoneTitle)
+            _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE)
                 .Returns(Task.FromException<Release>(_notFoundException));
 
-            _vcsProvider.CreateReleaseAsync(_owner, _repository, Arg.Any<Release>())
+            _vcsProvider.CreateReleaseAsync(OWNER, REPOSITORY, Arg.Any<Release>())
                 .Returns(Task.FromResult(release));
 
-            var result = await _vcsService.CreateReleaseFromInputFileAsync(_owner, _repository, _milestoneTitle, _releaseNotesFilePath, null, null, false).ConfigureAwait(false);
+            var result = await _vcsService.CreateReleaseFromInputFileAsync(OWNER, REPOSITORY, MILESTONE_TITLE, _releaseNotesFilePath, null, null, false).ConfigureAwait(false);
             result.ShouldBeSameAs(release);
 
-            await _vcsProvider.Received(1).GetReleaseAsync(_owner, _repository, _milestoneTitle).ConfigureAwait(false);
-            await _vcsProvider.Received(1).CreateReleaseAsync(_owner, _repository, Arg.Is<Release>(o =>
-                o.Body == _releaseNotes &&
-                o.Name == _milestoneTitle &&
-                o.TagName == _milestoneTitle)).ConfigureAwait(false);
+            await _vcsProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE).ConfigureAwait(false);
+            await _vcsProvider.Received(1).CreateReleaseAsync(OWNER, REPOSITORY, Arg.Is<Release>(o =>
+                o.Body == RELEASE_NOTES &&
+                o.Name == MILESTONE_TITLE &&
+                o.TagName == MILESTONE_TITLE)).ConfigureAwait(false);
 
-            _logger.Received(1).Verbose(Arg.Any<string>(), _milestoneTitle, _owner, _repository);
+            _logger.Received(1).Verbose(Arg.Any<string>(), MILESTONE_TITLE, OWNER, REPOSITORY);
             _logger.Received(1).Debug(Arg.Any<string>(), Arg.Any<Release>());
         }
 
@@ -460,20 +460,20 @@ public async Task Should_Update_Published_Release_On_Creating_Release_From_Input
 
             _configuration.Create.AllowUpdateToPublishedRelease = updatePublishedRelease;
 
-            _vcsProvider.GetReleaseAsync(_owner, _repository, _milestoneTitle)
+            _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE)
                 .Returns(Task.FromResult(release));
 
-            _vcsProvider.UpdateReleaseAsync(_owner, _repository, release)
+            _vcsProvider.UpdateReleaseAsync(OWNER, REPOSITORY, release)
                 .Returns(Task.FromResult(new Release()));
 
-            var result = await _vcsService.CreateReleaseFromInputFileAsync(_owner, _repository, _milestoneTitle, _releaseNotesFilePath, null, null, false).ConfigureAwait(false);
+            var result = await _vcsService.CreateReleaseFromInputFileAsync(OWNER, REPOSITORY, MILESTONE_TITLE, _releaseNotesFilePath, null, null, false).ConfigureAwait(false);
             result.ShouldBeSameAs(release);
 
-            await _vcsProvider.Received(1).GetReleaseAsync(_owner, _repository, _milestoneTitle).ConfigureAwait(false);
-            await _vcsProvider.Received(1).UpdateReleaseAsync(_owner, _repository, release).ConfigureAwait(false);
+            await _vcsProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE).ConfigureAwait(false);
+            await _vcsProvider.Received(1).UpdateReleaseAsync(OWNER, REPOSITORY, release).ConfigureAwait(false);
 
-            _logger.Received(1).Warning(Arg.Any<string>(), _milestoneTitle);
-            _logger.Received(1).Verbose(Arg.Any<string>(), _milestoneTitle, _owner, _repository);
+            _logger.Received(1).Warning(Arg.Any<string>(), MILESTONE_TITLE);
+            _logger.Received(1).Verbose(Arg.Any<string>(), MILESTONE_TITLE, OWNER, REPOSITORY);
             _logger.Received(1).Debug(Arg.Any<string>(), release);
         }
 
@@ -484,13 +484,13 @@ public async Task Should_Throw_Exception_While_Updating_Published_Release_On_Cre
 
             _configuration.Create.AllowUpdateToPublishedRelease = false;
 
-            _vcsProvider.GetReleaseAsync(_owner, _repository, _milestoneTitle)
+            _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE)
                 .Returns(Task.FromResult(release));
 
-            var ex = await Should.ThrowAsync<InvalidOperationException>(() => _vcsService.CreateReleaseFromInputFileAsync(_owner, _repository, _milestoneTitle, _releaseNotesFilePath, null, null, false)).ConfigureAwait(false);
-            ex.Message.ShouldBe($"Release with tag '{_milestoneTitle}' not in draft state, so not updating");
+            var ex = await Should.ThrowAsync<InvalidOperationException>(() => _vcsService.CreateReleaseFromInputFileAsync(OWNER, REPOSITORY, MILESTONE_TITLE, _releaseNotesFilePath, null, null, false)).ConfigureAwait(false);
+            ex.Message.ShouldBe($"Release with tag '{MILESTONE_TITLE}' not in draft state, so not updating");
 
-            await _vcsProvider.Received(1).GetReleaseAsync(_owner, _repository, _milestoneTitle).ConfigureAwait(false);
+            await _vcsProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE).ConfigureAwait(false);
         }
 
         [Test]
@@ -499,7 +499,7 @@ public async Task Should_Throw_Exception_Creating_Release_From_InputFile()
             var fileName = "NonExistingReleaseNotes.txt";
             var filePath = Path.Combine(Path.GetTempPath(), fileName);
 
-            var ex = await Should.ThrowAsync<FileNotFoundException>(() => _vcsService.CreateReleaseFromInputFileAsync(_owner, _repository, _milestoneTitle, filePath, null, null, false)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<FileNotFoundException>(() => _vcsService.CreateReleaseFromInputFileAsync(OWNER, REPOSITORY, MILESTONE_TITLE, filePath, null, null, false)).ConfigureAwait(false);
             ex.Message.ShouldBe("Unable to locate input file.");
             ex.FileName.ShouldBe(fileName);
         }
@@ -513,16 +513,16 @@ public async Task Should_Delete_Draft_Release()
                 Draft = true,
             };
 
-            _vcsProvider.GetReleaseAsync(_owner, _repository, _tagName)
+            _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)
                 .Returns(Task.FromResult(release));
 
-            _vcsProvider.DeleteReleaseAsync(_owner, _repository, release.Id)
+            _vcsProvider.DeleteReleaseAsync(OWNER, REPOSITORY, release.Id)
                 .Returns(Task.CompletedTask);
 
-            await _vcsService.DiscardReleaseAsync(_owner, _repository, _tagName).ConfigureAwait(false);
+            await _vcsService.DiscardReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
 
-            await _vcsProvider.Received(1).GetReleaseAsync(_owner, _repository, _tagName).ConfigureAwait(false);
-            await _vcsProvider.Received(1).DeleteReleaseAsync(_owner, _repository, release.Id).ConfigureAwait(false);
+            await _vcsProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
+            await _vcsProvider.Received(1).DeleteReleaseAsync(OWNER, REPOSITORY, release.Id).ConfigureAwait(false);
         }
 
         [Test]
@@ -530,27 +530,27 @@ public async Task Should_Not_Delete_Published_Release()
         {
             var release = new Release { Id = 1 };
 
-            _vcsProvider.GetReleaseAsync(_owner, _repository, _tagName)
+            _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)
                 .Returns(Task.FromResult(release));
 
-            await _vcsService.DiscardReleaseAsync(_owner, _repository, _tagName).ConfigureAwait(false);
+            await _vcsService.DiscardReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
 
-            await _vcsProvider.Received(1).GetReleaseAsync(_owner, _repository, _tagName).ConfigureAwait(false);
-            await _vcsProvider.DidNotReceive().DeleteReleaseAsync(_owner, _repository, release.Id).ConfigureAwait(false);
-            _logger.Received(1).Warning(Arg.Any<string>(), _tagName);
+            await _vcsProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
+            await _vcsProvider.DidNotReceive().DeleteReleaseAsync(OWNER, REPOSITORY, release.Id).ConfigureAwait(false);
+            _logger.Received(1).Warning(Arg.Any<string>(), TAG_NAME);
         }
 
         [Test]
         public async Task Should_Log_An_Warning_On_Deleting_Release_For_Non_Existing_Tag()
         {
-            _vcsProvider.GetReleaseAsync(_owner, _repository, _tagName)
+            _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)
                 .Returns(Task.FromException<Release>(_notFoundException));
 
-            await _vcsService.DiscardReleaseAsync(_owner, _repository, _tagName).ConfigureAwait(false);
+            await _vcsService.DiscardReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
 
-            await _vcsProvider.Received().GetReleaseAsync(_owner, _repository, _tagName).ConfigureAwait(false);
-            await _vcsProvider.DidNotReceiveWithAnyArgs().DeleteReleaseAsync(_owner, _repository, default).ConfigureAwait(false);
-            _logger.Received(1).Warning(_unableToFoundReleaseMessage, _tagName, _owner, _repository);
+            await _vcsProvider.Received().GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
+            await _vcsProvider.DidNotReceiveWithAnyArgs().DeleteReleaseAsync(OWNER, REPOSITORY, default).ConfigureAwait(false);
+            _logger.Received(1).Warning(UNABLE_TO_FOUND_RELEASE_MESSAGE, TAG_NAME, OWNER, REPOSITORY);
         }
 
         [Test]
@@ -558,31 +558,31 @@ public async Task Should_Publish_Release()
         {
             var release = new Release { Id = 1 };
 
-            _vcsProvider.GetReleaseAsync(_owner, _repository, _tagName)
+            _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)
                 .Returns(Task.FromResult(release));
 
-            _vcsProvider.PublishReleaseAsync(_owner, _repository, _tagName, release.Id)
+            _vcsProvider.PublishReleaseAsync(OWNER, REPOSITORY, TAG_NAME, release.Id)
                 .Returns(Task.CompletedTask);
 
-            await _vcsService.PublishReleaseAsync(_owner, _repository, _tagName).ConfigureAwait(false);
+            await _vcsService.PublishReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
 
-            await _vcsProvider.Received(1).GetReleaseAsync(_owner, _repository, _tagName).ConfigureAwait(false);
-            await _vcsProvider.Received(1).PublishReleaseAsync(_owner, _repository, _tagName, release.Id).ConfigureAwait(false);
-            _logger.Received(1).Verbose(Arg.Any<string>(), _tagName, _owner, _repository);
+            await _vcsProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
+            await _vcsProvider.Received(1).PublishReleaseAsync(OWNER, REPOSITORY, TAG_NAME, release.Id).ConfigureAwait(false);
+            _logger.Received(1).Verbose(Arg.Any<string>(), TAG_NAME, OWNER, REPOSITORY);
             _logger.Received(1).Debug(Arg.Any<string>(), Arg.Any<Release>());
         }
 
         [Test]
         public async Task Should_Log_An_Warning_On_Publishing_Release_For_Non_Existing_Tag()
         {
-            _vcsProvider.GetReleaseAsync(_owner, _repository, _tagName)
+            _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)
                 .Returns(Task.FromException<Release>(_notFoundException));
 
-            await _vcsService.PublishReleaseAsync(_owner, _repository, _tagName).ConfigureAwait(false);
+            await _vcsService.PublishReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
 
-            await _vcsProvider.Received().GetReleaseAsync(_owner, _repository, _tagName).ConfigureAwait(false);
-            await _vcsProvider.DidNotReceiveWithAnyArgs().PublishReleaseAsync(_owner, _repository, _tagName, default).ConfigureAwait(false);
-            _logger.Received(1).Warning(Arg.Any<string>(), _tagName, _owner, _repository);
+            await _vcsProvider.Received().GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
+            await _vcsProvider.DidNotReceiveWithAnyArgs().PublishReleaseAsync(OWNER, REPOSITORY, TAG_NAME, default).ConfigureAwait(false);
+            _logger.Received(1).Warning(Arg.Any<string>(), TAG_NAME, OWNER, REPOSITORY);
         }
 
         [Test]
@@ -591,18 +591,18 @@ public async Task Should_Get_Release_Notes()
             var releases = Enumerable.Empty<Release>();
             var releaseNotes = "Release Notes";
 
-            _vcsProvider.GetReleasesAsync(_owner, _repository)
+            _vcsProvider.GetReleasesAsync(OWNER, REPOSITORY)
                 .Returns(Task.FromResult(releases));
 
             _releaseNotesExporter.ExportReleaseNotes(Arg.Any<IEnumerable<Release>>())
                 .Returns(releaseNotes);
 
-            var result = await _vcsService.ExportReleasesAsync(_owner, _repository, null).ConfigureAwait(false);
+            var result = await _vcsService.ExportReleasesAsync(OWNER, REPOSITORY, null).ConfigureAwait(false);
             result.ShouldBeSameAs(releaseNotes);
 
             await _vcsProvider.DidNotReceive().GetReleaseAsync(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>()).ConfigureAwait(false);
-            await _vcsProvider.Received(1).GetReleasesAsync(_owner, _repository).ConfigureAwait(false);
-            _logger.Received(1).Verbose(Arg.Any<string>(), _owner, _repository);
+            await _vcsProvider.Received(1).GetReleasesAsync(OWNER, REPOSITORY).ConfigureAwait(false);
+            _logger.Received(1).Verbose(Arg.Any<string>(), OWNER, REPOSITORY);
             _releaseNotesExporter.Received(1).ExportReleaseNotes(Arg.Any<IEnumerable<Release>>());
         }
 
@@ -611,35 +611,35 @@ public async Task Should_Get_Release_Notes_For_Tag()
         {
             var release = new Release();
 
-            _vcsProvider.GetReleaseAsync(_owner, _repository, _tagName)
+            _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)
                 .Returns(Task.FromResult(release));
 
             _releaseNotesExporter.ExportReleaseNotes(Arg.Any<IEnumerable<Release>>())
-                .Returns(_releaseNotes);
+                .Returns(RELEASE_NOTES);
 
-            var result = await _vcsService.ExportReleasesAsync(_owner, _repository, _tagName).ConfigureAwait(false);
-            result.ShouldBeSameAs(_releaseNotes);
+            var result = await _vcsService.ExportReleasesAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
+            result.ShouldBeSameAs(RELEASE_NOTES);
 
-            await _vcsProvider.Received(1).GetReleaseAsync(_owner, _repository, _tagName).ConfigureAwait(false);
+            await _vcsProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
             await _vcsProvider.DidNotReceive().GetReleasesAsync(Arg.Any<string>(), Arg.Any<string>()).ConfigureAwait(false);
-            _logger.Received(1).Verbose(Arg.Any<string>(), _owner, _repository, _tagName);
+            _logger.Received(1).Verbose(Arg.Any<string>(), OWNER, REPOSITORY, TAG_NAME);
             _releaseNotesExporter.Received(1).ExportReleaseNotes(Arg.Any<IEnumerable<Release>>());
         }
 
         [Test]
         public async Task Should_Get_Default_Release_Notes_For_Non_Existent_Tag()
         {
-            _vcsProvider.GetReleaseAsync(_owner, _repository, _tagName)
+            _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)
                 .Returns(Task.FromException<Release>(_notFoundException));
 
             _releaseNotesExporter.ExportReleaseNotes(Arg.Any<IEnumerable<Release>>())
-                .Returns(_releaseNotes);
+                .Returns(RELEASE_NOTES);
 
-            var result = await _vcsService.ExportReleasesAsync(_owner, _repository, _tagName).ConfigureAwait(false);
-            result.ShouldBeSameAs(_releaseNotes);
+            var result = await _vcsService.ExportReleasesAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
+            result.ShouldBeSameAs(RELEASE_NOTES);
 
-            await _vcsProvider.Received(1).GetReleaseAsync(_owner, _repository, _tagName).ConfigureAwait(false);
-            _logger.Received(1).Warning(_unableToFoundReleaseMessage, _tagName, _owner, _repository);
+            await _vcsProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
+            _logger.Received(1).Warning(UNABLE_TO_FOUND_RELEASE_MESSAGE, TAG_NAME, OWNER, REPOSITORY);
             _releaseNotesExporter.Received(1).ExportReleaseNotes(Arg.Any<IEnumerable<Release>>());
         }
     }
diff --git a/src/GitReleaseManager.Core/Attributes/SampleAttribute.cs b/src/GitReleaseManager.Core/Attributes/SampleAttribute.cs
index 386918ef..50a43533 100644
--- a/src/GitReleaseManager.Core/Attributes/SampleAttribute.cs
+++ b/src/GitReleaseManager.Core/Attributes/SampleAttribute.cs
@@ -1,7 +1,7 @@
+using System;
+
 namespace GitReleaseManager.Core.Attributes
 {
-    using System;
-
     [AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
     public sealed class SampleAttribute : Attribute
     {
diff --git a/src/GitReleaseManager.Core/AutoMapperConfiguration.cs b/src/GitReleaseManager.Core/AutoMapperConfiguration.cs
index 7265a2c8..fe6a7183 100644
--- a/src/GitReleaseManager.Core/AutoMapperConfiguration.cs
+++ b/src/GitReleaseManager.Core/AutoMapperConfiguration.cs
@@ -1,8 +1,8 @@
+using AutoMapper;
+using Serilog;
+
 namespace GitReleaseManager.Core
 {
-    using AutoMapper;
-    using Serilog;
-
     public static class AutoMapperConfiguration
     {
         private static readonly ILogger _logger = Log.ForContext(typeof(AutoMapperConfiguration));
diff --git a/src/GitReleaseManager.Core/Commands/AddAssetsCommand.cs b/src/GitReleaseManager.Core/Commands/AddAssetsCommand.cs
index 7d00d957..22c3dded 100644
--- a/src/GitReleaseManager.Core/Commands/AddAssetsCommand.cs
+++ b/src/GitReleaseManager.Core/Commands/AddAssetsCommand.cs
@@ -1,9 +1,9 @@
+using System.Threading.Tasks;
+using GitReleaseManager.Core.Options;
+using Serilog;
+
 namespace GitReleaseManager.Core.Commands
 {
-    using System.Threading.Tasks;
-    using GitReleaseManager.Core.Options;
-    using Serilog;
-
     public class AddAssetsCommand : ICommand<AddAssetSubOptions>
     {
         private readonly IVcsService _vcsService;
diff --git a/src/GitReleaseManager.Core/Commands/CloseCommand.cs b/src/GitReleaseManager.Core/Commands/CloseCommand.cs
index 1fb195aa..413f3b3a 100644
--- a/src/GitReleaseManager.Core/Commands/CloseCommand.cs
+++ b/src/GitReleaseManager.Core/Commands/CloseCommand.cs
@@ -1,9 +1,9 @@
+using System.Threading.Tasks;
+using GitReleaseManager.Core.Options;
+using Serilog;
+
 namespace GitReleaseManager.Core.Commands
 {
-    using System.Threading.Tasks;
-    using GitReleaseManager.Core.Options;
-    using Serilog;
-
     public class CloseCommand : ICommand<CloseSubOptions>
     {
         private readonly IVcsService _vcsService;
diff --git a/src/GitReleaseManager.Core/Commands/CreateCommand.cs b/src/GitReleaseManager.Core/Commands/CreateCommand.cs
index ab95f0c9..d4901a20 100644
--- a/src/GitReleaseManager.Core/Commands/CreateCommand.cs
+++ b/src/GitReleaseManager.Core/Commands/CreateCommand.cs
@@ -1,10 +1,10 @@
+using System.Threading.Tasks;
+using GitReleaseManager.Core.Model;
+using GitReleaseManager.Core.Options;
+using Serilog;
+
 namespace GitReleaseManager.Core.Commands
 {
-    using System.Threading.Tasks;
-    using GitReleaseManager.Core.Model;
-    using GitReleaseManager.Core.Options;
-    using Serilog;
-
     public class CreateCommand : ICommand<CreateSubOptions>
     {
         private readonly IVcsService _vcsService;
diff --git a/src/GitReleaseManager.Core/Commands/DiscardCommand.cs b/src/GitReleaseManager.Core/Commands/DiscardCommand.cs
index f190aeda..0ca8066a 100644
--- a/src/GitReleaseManager.Core/Commands/DiscardCommand.cs
+++ b/src/GitReleaseManager.Core/Commands/DiscardCommand.cs
@@ -1,9 +1,9 @@
+using System.Threading.Tasks;
+using GitReleaseManager.Core.Options;
+using Serilog;
+
 namespace GitReleaseManager.Core.Commands
 {
-    using System.Threading.Tasks;
-    using GitReleaseManager.Core.Options;
-    using Serilog;
-
     public class DiscardCommand : ICommand<DiscardSubOptions>
     {
         private readonly IVcsService _vcsService;
diff --git a/src/GitReleaseManager.Core/Commands/ExportCommand.cs b/src/GitReleaseManager.Core/Commands/ExportCommand.cs
index 15a7bf38..756ad527 100644
--- a/src/GitReleaseManager.Core/Commands/ExportCommand.cs
+++ b/src/GitReleaseManager.Core/Commands/ExportCommand.cs
@@ -1,10 +1,10 @@
+using System.IO;
+using System.Threading.Tasks;
+using GitReleaseManager.Core.Options;
+using Serilog;
+
 namespace GitReleaseManager.Core.Commands
 {
-    using System.IO;
-    using System.Threading.Tasks;
-    using GitReleaseManager.Core.Options;
-    using Serilog;
-
     public class ExportCommand : ICommand<ExportSubOptions>
     {
         private readonly IVcsService _vcsService;
diff --git a/src/GitReleaseManager.Core/Commands/ICommand.cs b/src/GitReleaseManager.Core/Commands/ICommand.cs
index cb19da18..b62b1d14 100644
--- a/src/GitReleaseManager.Core/Commands/ICommand.cs
+++ b/src/GitReleaseManager.Core/Commands/ICommand.cs
@@ -1,8 +1,8 @@
+using System.Threading.Tasks;
+using GitReleaseManager.Core.Options;
+
 namespace GitReleaseManager.Core.Commands
 {
-    using System.Threading.Tasks;
-    using GitReleaseManager.Core.Options;
-
     public interface ICommand<TOptions>
         where TOptions : BaseSubOptions
     {
diff --git a/src/GitReleaseManager.Core/Commands/InitCommand.cs b/src/GitReleaseManager.Core/Commands/InitCommand.cs
index 60206975..eaf233d5 100644
--- a/src/GitReleaseManager.Core/Commands/InitCommand.cs
+++ b/src/GitReleaseManager.Core/Commands/InitCommand.cs
@@ -1,14 +1,14 @@
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using GitReleaseManager.Core.Configuration;
+using GitReleaseManager.Core.Helpers;
+using GitReleaseManager.Core.Options;
+using GitReleaseManager.Core.Templates;
+using Serilog;
+
 namespace GitReleaseManager.Core.Commands
 {
-    using System;
-    using System.IO;
-    using System.Threading.Tasks;
-    using GitReleaseManager.Core.Configuration;
-    using GitReleaseManager.Core.Helpers;
-    using GitReleaseManager.Core.Options;
-    using GitReleaseManager.Core.Templates;
-    using Serilog;
-
     public class InitCommand : ICommand<InitSubOptions>
     {
         private readonly IFileSystem _fileSystem;
diff --git a/src/GitReleaseManager.Core/Commands/LabelCommand.cs b/src/GitReleaseManager.Core/Commands/LabelCommand.cs
index 790e0d39..70e41a51 100644
--- a/src/GitReleaseManager.Core/Commands/LabelCommand.cs
+++ b/src/GitReleaseManager.Core/Commands/LabelCommand.cs
@@ -1,9 +1,9 @@
+using System.Threading.Tasks;
+using GitReleaseManager.Core.Options;
+using Serilog;
+
 namespace GitReleaseManager.Core.Commands
 {
-    using System.Threading.Tasks;
-    using GitReleaseManager.Core.Options;
-    using Serilog;
-
     public class LabelCommand : ICommand<LabelSubOptions>
     {
         private readonly IVcsService _vcsService;
diff --git a/src/GitReleaseManager.Core/Commands/OpenCommand.cs b/src/GitReleaseManager.Core/Commands/OpenCommand.cs
index 12e31922..fe9a9a88 100644
--- a/src/GitReleaseManager.Core/Commands/OpenCommand.cs
+++ b/src/GitReleaseManager.Core/Commands/OpenCommand.cs
@@ -1,9 +1,9 @@
+using System.Threading.Tasks;
+using GitReleaseManager.Core.Options;
+using Serilog;
+
 namespace GitReleaseManager.Core.Commands
 {
-    using System.Threading.Tasks;
-    using GitReleaseManager.Core.Options;
-    using Serilog;
-
     public class OpenCommand : ICommand<OpenSubOptions>
     {
         private readonly IVcsService _vcsService;
diff --git a/src/GitReleaseManager.Core/Commands/PublishCommand.cs b/src/GitReleaseManager.Core/Commands/PublishCommand.cs
index 583678bb..142ef720 100644
--- a/src/GitReleaseManager.Core/Commands/PublishCommand.cs
+++ b/src/GitReleaseManager.Core/Commands/PublishCommand.cs
@@ -1,9 +1,9 @@
+using System.Threading.Tasks;
+using GitReleaseManager.Core.Options;
+using Serilog;
+
 namespace GitReleaseManager.Core.Commands
 {
-    using System.Threading.Tasks;
-    using GitReleaseManager.Core.Options;
-    using Serilog;
-
     public class PublishCommand : ICommand<PublishSubOptions>
     {
         private readonly IVcsService _vcsService;
diff --git a/src/GitReleaseManager.Core/Commands/ShowConfigCommand.cs b/src/GitReleaseManager.Core/Commands/ShowConfigCommand.cs
index 0d2c71c4..8d3fc874 100644
--- a/src/GitReleaseManager.Core/Commands/ShowConfigCommand.cs
+++ b/src/GitReleaseManager.Core/Commands/ShowConfigCommand.cs
@@ -1,12 +1,12 @@
+using System;
+using System.Threading.Tasks;
+using GitReleaseManager.Core.Configuration;
+using GitReleaseManager.Core.Helpers;
+using GitReleaseManager.Core.Options;
+using Serilog;
+
 namespace GitReleaseManager.Core.Commands
 {
-    using System;
-    using System.Threading.Tasks;
-    using GitReleaseManager.Core.Configuration;
-    using GitReleaseManager.Core.Helpers;
-    using GitReleaseManager.Core.Options;
-    using Serilog;
-
     public class ShowConfigCommand : ICommand<ShowConfigSubOptions>
     {
         private readonly IFileSystem _fileSystem;
diff --git a/src/GitReleaseManager.Core/Configuration/CloseConfig.cs b/src/GitReleaseManager.Core/Configuration/CloseConfig.cs
index 20f748fd..48495888 100644
--- a/src/GitReleaseManager.Core/Configuration/CloseConfig.cs
+++ b/src/GitReleaseManager.Core/Configuration/CloseConfig.cs
@@ -1,9 +1,9 @@
+using System.ComponentModel;
+using GitReleaseManager.Core.Attributes;
+using YamlDotNet.Serialization;
+
 namespace GitReleaseManager.Core.Configuration
 {
-    using System.ComponentModel;
-    using GitReleaseManager.Core.Attributes;
-    using YamlDotNet.Serialization;
-
     /// <summary>
     /// Class for holding configuration values used during milestone closing. This class cannot be inherited.
     /// </summary>
diff --git a/src/GitReleaseManager.Core/Configuration/CommentSerialization/CommentGatheringTypeInspector.cs b/src/GitReleaseManager.Core/Configuration/CommentSerialization/CommentGatheringTypeInspector.cs
index 651015d5..ffdd6282 100644
--- a/src/GitReleaseManager.Core/Configuration/CommentSerialization/CommentGatheringTypeInspector.cs
+++ b/src/GitReleaseManager.Core/Configuration/CommentSerialization/CommentGatheringTypeInspector.cs
@@ -2,16 +2,16 @@
 // https://dotnetfiddle.net/8M6iIE which was mentioned
 // on the YamlDotNet repository here: https://github.com/aaubry/YamlDotNet/issues/444#issuecomment-546709672
 
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using YamlDotNet.Core;
+using YamlDotNet.Serialization;
+using YamlDotNet.Serialization.TypeInspectors;
+
 namespace GitReleaseManager.Core.Configuration.CommentSerialization
 {
-    using System;
-    using System.Collections.Generic;
-    using System.ComponentModel;
-    using System.Linq;
-    using YamlDotNet.Core;
-    using YamlDotNet.Serialization;
-    using YamlDotNet.Serialization.TypeInspectors;
-
     public sealed class CommentGatheringTypeInspector : TypeInspectorSkeleton
     {
         private readonly ITypeInspector _innerTypeDescriptor;
diff --git a/src/GitReleaseManager.Core/Configuration/CommentSerialization/CommentsObjectDescriptor.cs b/src/GitReleaseManager.Core/Configuration/CommentSerialization/CommentsObjectDescriptor.cs
index 8e527248..7701b02e 100644
--- a/src/GitReleaseManager.Core/Configuration/CommentSerialization/CommentsObjectDescriptor.cs
+++ b/src/GitReleaseManager.Core/Configuration/CommentSerialization/CommentsObjectDescriptor.cs
@@ -2,12 +2,12 @@
 // https://dotnetfiddle.net/8M6iIE which was mentioned
 // on the YamlDotNet repository here: https://github.com/aaubry/YamlDotNet/issues/444#issuecomment-546709672
 
+using System;
+using YamlDotNet.Core;
+using YamlDotNet.Serialization;
+
 namespace GitReleaseManager.Core.Configuration.CommentSerialization
 {
-    using System;
-    using YamlDotNet.Core;
-    using YamlDotNet.Serialization;
-
     public sealed class CommentsObjectDescriptor : IObjectDescriptor
     {
         private readonly IObjectDescriptor _innerDescriptor;
diff --git a/src/GitReleaseManager.Core/Configuration/CommentSerialization/CommentsObjectGraphVisitor.cs b/src/GitReleaseManager.Core/Configuration/CommentSerialization/CommentsObjectGraphVisitor.cs
index 82bf963b..c83f0133 100644
--- a/src/GitReleaseManager.Core/Configuration/CommentSerialization/CommentsObjectGraphVisitor.cs
+++ b/src/GitReleaseManager.Core/Configuration/CommentSerialization/CommentsObjectGraphVisitor.cs
@@ -2,13 +2,13 @@
 // https://dotnetfiddle.net/8M6iIE which was mentioned
 // on the YamlDotNet repository here: https://github.com/aaubry/YamlDotNet/issues/444#issuecomment-546709672
 
+using YamlDotNet.Core;
+using YamlDotNet.Core.Events;
+using YamlDotNet.Serialization;
+using YamlDotNet.Serialization.ObjectGraphVisitors;
+
 namespace GitReleaseManager.Core.Configuration.CommentSerialization
 {
-    using YamlDotNet.Core;
-    using YamlDotNet.Core.Events;
-    using YamlDotNet.Serialization;
-    using YamlDotNet.Serialization.ObjectGraphVisitors;
-
     public sealed class CommentsObjectGraphVisitor : ChainedObjectGraphVisitor
     {
         public CommentsObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor)
diff --git a/src/GitReleaseManager.Core/Configuration/Config.cs b/src/GitReleaseManager.Core/Configuration/Config.cs
index 3276eea7..9df3e365 100644
--- a/src/GitReleaseManager.Core/Configuration/Config.cs
+++ b/src/GitReleaseManager.Core/Configuration/Config.cs
@@ -1,14 +1,12 @@
+using System.Collections.Generic;
+using System.ComponentModel;
+using YamlDotNet.Serialization;
+
 namespace GitReleaseManager.Core.Configuration
 {
-    using System;
-    using System.Collections.Generic;
-    using System.ComponentModel;
-    using System.IO;
-    using YamlDotNet.Serialization;
-
     public class Config
     {
-        internal const string IssueCommentFormat = @":tada: This issue has been resolved in version {milestone} :tada:
+        internal const string ISSUE_COMMENT_FORMAT = @":tada: This issue has been resolved in version {milestone} :tada:
 
 The release is available on:
 
@@ -43,7 +41,7 @@ public Config()
             Close = new CloseConfig
             {
                 IssueComments = false,
-                IssueCommentFormat = IssueCommentFormat,
+                IssueCommentFormat = ISSUE_COMMENT_FORMAT,
             };
 
             DefaultBranch = "master";
diff --git a/src/GitReleaseManager.Core/Configuration/ConfigSerializer.cs b/src/GitReleaseManager.Core/Configuration/ConfigSerializer.cs
index 1b1c0495..102b1833 100644
--- a/src/GitReleaseManager.Core/Configuration/ConfigSerializer.cs
+++ b/src/GitReleaseManager.Core/Configuration/ConfigSerializer.cs
@@ -1,14 +1,14 @@
+using System;
+using System.IO;
+using System.Reflection;
+using GitReleaseManager.Core.Attributes;
+using GitReleaseManager.Core.Configuration.CommentSerialization;
+using Serilog;
+using YamlDotNet.Serialization;
+using YamlDotNet.Serialization.NamingConventions;
+
 namespace GitReleaseManager.Core.Configuration
 {
-    using System;
-    using System.IO;
-    using System.Reflection;
-    using GitReleaseManager.Core.Attributes;
-    using GitReleaseManager.Core.Configuration.CommentSerialization;
-    using Serilog;
-    using YamlDotNet.Serialization;
-    using YamlDotNet.Serialization.NamingConventions;
-
     public static class ConfigSerializer
     {
         private static readonly ILogger _logger = Log.ForContext(typeof(ConfigSerializer));
diff --git a/src/GitReleaseManager.Core/Configuration/ConfigurationProvider.cs b/src/GitReleaseManager.Core/Configuration/ConfigurationProvider.cs
index 29eb80b3..4fc09b09 100644
--- a/src/GitReleaseManager.Core/Configuration/ConfigurationProvider.cs
+++ b/src/GitReleaseManager.Core/Configuration/ConfigurationProvider.cs
@@ -1,12 +1,12 @@
+using System;
+using System.Globalization;
+using System.IO;
+using System.Text;
+using GitReleaseManager.Core.Helpers;
+using Serilog;
+
 namespace GitReleaseManager.Core.Configuration
 {
-    using System;
-    using System.Globalization;
-    using System.IO;
-    using System.Text;
-    using GitReleaseManager.Core.Helpers;
-    using Serilog;
-
     public static class ConfigurationProvider
     {
         private static readonly ILogger _logger = Log.ForContext(typeof(ConfigurationProvider));
@@ -125,7 +125,7 @@ private static void EnsureDefaultConfig(Config configuration)
             if (configuration.Close.IssueCommentFormat == null)
             {
                 _logger.Debug("Setting default Close.IssueCommentFormat configuration value");
-                configuration.Close.IssueCommentFormat = Config.IssueCommentFormat;
+                configuration.Close.IssueCommentFormat = Config.ISSUE_COMMENT_FORMAT;
             }
         }
     }
diff --git a/src/GitReleaseManager.Core/Configuration/CreateConfig.cs b/src/GitReleaseManager.Core/Configuration/CreateConfig.cs
index 0d635f14..512e4a28 100644
--- a/src/GitReleaseManager.Core/Configuration/CreateConfig.cs
+++ b/src/GitReleaseManager.Core/Configuration/CreateConfig.cs
@@ -1,9 +1,9 @@
+using System.ComponentModel;
+using GitReleaseManager.Core.Attributes;
+using YamlDotNet.Serialization;
+
 namespace GitReleaseManager.Core.Configuration
 {
-    using System.ComponentModel;
-    using GitReleaseManager.Core.Attributes;
-    using YamlDotNet.Serialization;
-
     public class CreateConfig
     {
         [Description("Enable generation of footer content in the release notes. Extract the recommended templates by running 'init --templates' and edit the footer.sbn file to provide the wanted footer content.")]
diff --git a/src/GitReleaseManager.Core/Configuration/ExportConfig.cs b/src/GitReleaseManager.Core/Configuration/ExportConfig.cs
index 2dc59cdf..a91f972d 100644
--- a/src/GitReleaseManager.Core/Configuration/ExportConfig.cs
+++ b/src/GitReleaseManager.Core/Configuration/ExportConfig.cs
@@ -1,8 +1,8 @@
+using GitReleaseManager.Core.Attributes;
+using YamlDotNet.Serialization;
+
 namespace GitReleaseManager.Core.Configuration
 {
-    using GitReleaseManager.Core.Attributes;
-    using YamlDotNet.Serialization;
-
     public class ExportConfig
     {
         [YamlMember(Alias = "include-created-date-in-title")]
diff --git a/src/GitReleaseManager.Core/Configuration/LabelConfig.cs b/src/GitReleaseManager.Core/Configuration/LabelConfig.cs
index 0e389878..adddd445 100644
--- a/src/GitReleaseManager.Core/Configuration/LabelConfig.cs
+++ b/src/GitReleaseManager.Core/Configuration/LabelConfig.cs
@@ -1,7 +1,7 @@
+using YamlDotNet.Serialization;
+
 namespace GitReleaseManager.Core.Configuration
 {
-    using YamlDotNet.Serialization;
-
     public class LabelConfig
     {
         [YamlMember(Alias = "name")]
diff --git a/src/GitReleaseManager.Core/Ensure.cs b/src/GitReleaseManager.Core/Ensure.cs
index 978417b6..ce24a922 100644
--- a/src/GitReleaseManager.Core/Ensure.cs
+++ b/src/GitReleaseManager.Core/Ensure.cs
@@ -1,8 +1,8 @@
+using System;
+using System.IO;
+
 namespace GitReleaseManager.Core
 {
-    using System;
-    using System.IO;
-
     /// <summary>
     /// Provides static methods that help a constructor or method to verify correct arguments and
     /// state.
diff --git a/src/GitReleaseManager.Core/Exceptions/ApiException.cs b/src/GitReleaseManager.Core/Exceptions/ApiException.cs
index 7a827e0a..6bf81139 100644
--- a/src/GitReleaseManager.Core/Exceptions/ApiException.cs
+++ b/src/GitReleaseManager.Core/Exceptions/ApiException.cs
@@ -1,8 +1,8 @@
+using System;
+using System.Runtime.Serialization;
+
 namespace GitReleaseManager.Core.Exceptions
 {
-    using System;
-    using System.Runtime.Serialization;
-
     [Serializable]
     public class ApiException : Exception
     {
diff --git a/src/GitReleaseManager.Core/Exceptions/ForbiddenException.cs b/src/GitReleaseManager.Core/Exceptions/ForbiddenException.cs
index acc51f39..f2c55512 100644
--- a/src/GitReleaseManager.Core/Exceptions/ForbiddenException.cs
+++ b/src/GitReleaseManager.Core/Exceptions/ForbiddenException.cs
@@ -1,8 +1,8 @@
+using System;
+using System.Runtime.Serialization;
+
 namespace GitReleaseManager.Core.Exceptions
 {
-    using System;
-    using System.Runtime.Serialization;
-
     [Serializable]
     public class ForbiddenException : Exception
     {
diff --git a/src/GitReleaseManager.Core/Exceptions/NotFoundException.cs b/src/GitReleaseManager.Core/Exceptions/NotFoundException.cs
index eeffb135..cafd93eb 100644
--- a/src/GitReleaseManager.Core/Exceptions/NotFoundException.cs
+++ b/src/GitReleaseManager.Core/Exceptions/NotFoundException.cs
@@ -1,8 +1,8 @@
+using System;
+using System.Runtime.Serialization;
+
 namespace GitReleaseManager.Core.Exceptions
 {
-    using System;
-    using System.Runtime.Serialization;
-
     [Serializable]
     public class NotFoundException : Exception
     {
diff --git a/src/GitReleaseManager.Core/Extensions/MilestoneExtensions.cs b/src/GitReleaseManager.Core/Extensions/MilestoneExtensions.cs
index 4bdebfa4..41578201 100644
--- a/src/GitReleaseManager.Core/Extensions/MilestoneExtensions.cs
+++ b/src/GitReleaseManager.Core/Extensions/MilestoneExtensions.cs
@@ -1,9 +1,9 @@
+using System;
+using Octokit;
+using Serilog;
+
 namespace GitReleaseManager.Core.Extensions
 {
-    using System;
-    using Octokit;
-    using Serilog;
-
     public static class MilestoneExtensions
     {
         public static readonly ILogger _logger = Log.ForContext(typeof(MilestoneExtensions));
diff --git a/src/GitReleaseManager.Core/Extensions/OctokitExtensions.cs b/src/GitReleaseManager.Core/Extensions/OctokitExtensions.cs
index 3474f9b7..c54c8089 100644
--- a/src/GitReleaseManager.Core/Extensions/OctokitExtensions.cs
+++ b/src/GitReleaseManager.Core/Extensions/OctokitExtensions.cs
@@ -1,13 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Threading.Tasks;
+using Octokit;
+using Serilog;
+
 namespace GitReleaseManager.Core.Extensions
 {
-    using System;
-    using System.Collections.Generic;
-    using System.Globalization;
-    using System.Linq;
-    using System.Threading.Tasks;
-    using Octokit;
-    using Serilog;
-
     public static class OctokitExtensions
     {
         private static readonly ILogger _logger = Log.ForContext(typeof(OctokitExtensions));
@@ -34,7 +34,7 @@ public static Task<IEnumerable<Issue>> AllIssuesForMilestone(this IGitHubClient
                 throw new ArgumentNullException(nameof(milestone));
             }
 
-            return AllIssuesForMilestoneInternal(gitHubClient, milestone);
+            return AllIssuesForMilestoneInternalAsync(gitHubClient, milestone);
         }
 
         public static Uri HtmlUrl(this Milestone milestone)
@@ -51,7 +51,7 @@ public static Uri HtmlUrl(this Milestone milestone)
             return new Uri(string.Format(CultureInfo.InvariantCulture, "https://github.com/{0}/{1}/issues?milestone={2}&state=closed", user, repository, milestone.Number));
         }
 
-        private static async Task<IEnumerable<Issue>> AllIssuesForMilestoneInternal(IGitHubClient gitHubClient, Milestone milestone)
+        private static async Task<IEnumerable<Issue>> AllIssuesForMilestoneInternalAsync(IGitHubClient gitHubClient, Milestone milestone)
         {
             var closedIssueRequest = new RepositoryIssueRequest
             {
diff --git a/src/GitReleaseManager.Core/Extensions/StringExtensions.cs b/src/GitReleaseManager.Core/Extensions/StringExtensions.cs
index 0efd7d16..2d106c09 100644
--- a/src/GitReleaseManager.Core/Extensions/StringExtensions.cs
+++ b/src/GitReleaseManager.Core/Extensions/StringExtensions.cs
@@ -1,12 +1,11 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
 [assembly: System.Runtime.CompilerServices.InternalsVisibleTo("GitReleaseManager.Tests")]
 
 namespace GitReleaseManager.Core.Extensions
 {
-    using System;
-    using System.Collections.Generic;
-    using System.Linq;
-    using System.Text;
-
     internal static class StringExtensions
     {
         public static string ReplaceMilestoneTitle(this string source, string milestoneKey, string milestoneTitle)
diff --git a/src/GitReleaseManager.Core/Helpers/FileSystem.cs b/src/GitReleaseManager.Core/Helpers/FileSystem.cs
index 7c8e55b4..c6f53827 100644
--- a/src/GitReleaseManager.Core/Helpers/FileSystem.cs
+++ b/src/GitReleaseManager.Core/Helpers/FileSystem.cs
@@ -1,10 +1,10 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using GitReleaseManager.Core.Options;
+
 namespace GitReleaseManager.Core.Helpers
 {
-    using System;
-    using System.Collections.Generic;
-    using System.IO;
-    using GitReleaseManager.Core.Options;
-
     public class FileSystem : IFileSystem
     {
         private readonly BaseSubOptions options;
diff --git a/src/GitReleaseManager.Core/Helpers/IFileSystem.cs b/src/GitReleaseManager.Core/Helpers/IFileSystem.cs
index 0d84e79a..eb85b7fc 100644
--- a/src/GitReleaseManager.Core/Helpers/IFileSystem.cs
+++ b/src/GitReleaseManager.Core/Helpers/IFileSystem.cs
@@ -1,8 +1,8 @@
+using System.Collections.Generic;
+using System.IO;
+
 namespace GitReleaseManager.Core.Helpers
 {
-    using System.Collections.Generic;
-    using System.IO;
-
     public interface IFileSystem
     {
         void Copy(string source, string destination, bool overwrite);
diff --git a/src/GitReleaseManager.Core/IVcsService.cs b/src/GitReleaseManager.Core/IVcsService.cs
index 5f3613cd..031c22ed 100644
--- a/src/GitReleaseManager.Core/IVcsService.cs
+++ b/src/GitReleaseManager.Core/IVcsService.cs
@@ -1,9 +1,9 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using GitReleaseManager.Core.Model;
+
 namespace GitReleaseManager.Core
 {
-    using System.Collections.Generic;
-    using System.Threading.Tasks;
-    using GitReleaseManager.Core.Model;
-
     public interface IVcsService
     {
         Task<Release> CreateReleaseFromMilestoneAsync(string owner, string repository, string milestone, string releaseName, string targetCommitish, IList<string> assets, bool prerelease, string templateFilePath);
diff --git a/src/GitReleaseManager.Core/MappingProfiles/GitHubProfile.cs b/src/GitReleaseManager.Core/MappingProfiles/GitHubProfile.cs
index c4a0c878..ee57207b 100644
--- a/src/GitReleaseManager.Core/MappingProfiles/GitHubProfile.cs
+++ b/src/GitReleaseManager.Core/MappingProfiles/GitHubProfile.cs
@@ -1,8 +1,8 @@
+using AutoMapper;
+using GitReleaseManager.Core.Extensions;
+
 namespace GitReleaseManager.Core.MappingProfiles
 {
-    using AutoMapper;
-    using GitReleaseManager.Core.Extensions;
-
     public class GitHubProfile : Profile
     {
         public GitHubProfile()
diff --git a/src/GitReleaseManager.Core/Model/Issue.cs b/src/GitReleaseManager.Core/Model/Issue.cs
index b390d30d..5af76d1b 100644
--- a/src/GitReleaseManager.Core/Model/Issue.cs
+++ b/src/GitReleaseManager.Core/Model/Issue.cs
@@ -1,7 +1,7 @@
+using System.Collections.Generic;
+
 namespace GitReleaseManager.Core.Model
 {
-    using System.Collections.Generic;
-
     public sealed class Issue
     {
         public string Title { get; set; }
diff --git a/src/GitReleaseManager.Core/Model/Milestone.cs b/src/GitReleaseManager.Core/Model/Milestone.cs
index 26d48821..c719186b 100644
--- a/src/GitReleaseManager.Core/Model/Milestone.cs
+++ b/src/GitReleaseManager.Core/Model/Milestone.cs
@@ -1,7 +1,7 @@
+using System;
+
 namespace GitReleaseManager.Core.Model
 {
-    using System;
-
     public sealed class Milestone
     {
         public string Title { get; set; }
diff --git a/src/GitReleaseManager.Core/Model/RateLimit.cs b/src/GitReleaseManager.Core/Model/RateLimit.cs
index 1f8be9a6..67ddfe76 100644
--- a/src/GitReleaseManager.Core/Model/RateLimit.cs
+++ b/src/GitReleaseManager.Core/Model/RateLimit.cs
@@ -1,7 +1,7 @@
+using System;
+
 namespace GitReleaseManager.Core.Model
 {
-    using System;
-
     public class RateLimit
     {
         /// <summary>
diff --git a/src/GitReleaseManager.Core/Model/Release.cs b/src/GitReleaseManager.Core/Model/Release.cs
index 584f364f..590ec7b9 100644
--- a/src/GitReleaseManager.Core/Model/Release.cs
+++ b/src/GitReleaseManager.Core/Model/Release.cs
@@ -1,8 +1,8 @@
+using System;
+using System.Collections.Generic;
+
 namespace GitReleaseManager.Core.Model
 {
-    using System;
-    using System.Collections.Generic;
-
     public sealed class Release
     {
         public int Id { get; set; }
diff --git a/src/GitReleaseManager.Core/Model/ReleaseAssetUpload.cs b/src/GitReleaseManager.Core/Model/ReleaseAssetUpload.cs
index 23a0d6da..53ccec63 100644
--- a/src/GitReleaseManager.Core/Model/ReleaseAssetUpload.cs
+++ b/src/GitReleaseManager.Core/Model/ReleaseAssetUpload.cs
@@ -1,7 +1,7 @@
+using System.IO;
+
 namespace GitReleaseManager.Core.Model
 {
-    using System.IO;
-
     public class ReleaseAssetUpload
     {
         /// <summary>
diff --git a/src/GitReleaseManager.Core/Options/AddAssetSubOptions.cs b/src/GitReleaseManager.Core/Options/AddAssetSubOptions.cs
index d34c40ab..ed7745d6 100644
--- a/src/GitReleaseManager.Core/Options/AddAssetSubOptions.cs
+++ b/src/GitReleaseManager.Core/Options/AddAssetSubOptions.cs
@@ -1,8 +1,8 @@
+using System.Collections.Generic;
+using CommandLine;
+
 namespace GitReleaseManager.Core.Options
 {
-    using System.Collections.Generic;
-    using CommandLine;
-
     [Verb("addasset", HelpText = "Adds an asset to an existing release.")]
     public class AddAssetSubOptions : BaseVcsOptions
     {
diff --git a/src/GitReleaseManager.Core/Options/BaseSubOptions.cs b/src/GitReleaseManager.Core/Options/BaseSubOptions.cs
index f7fe44e7..c8a15ad1 100644
--- a/src/GitReleaseManager.Core/Options/BaseSubOptions.cs
+++ b/src/GitReleaseManager.Core/Options/BaseSubOptions.cs
@@ -1,7 +1,7 @@
+using CommandLine;
+
 namespace GitReleaseManager.Core.Options
 {
-    using CommandLine;
-
     public abstract class BaseSubOptions
     {
         [Option("debug", HelpText = "Enable debugging console output")]
diff --git a/src/GitReleaseManager.Core/Options/BaseVcsSubOptions.cs b/src/GitReleaseManager.Core/Options/BaseVcsSubOptions.cs
index 998bd196..35b994bd 100644
--- a/src/GitReleaseManager.Core/Options/BaseVcsSubOptions.cs
+++ b/src/GitReleaseManager.Core/Options/BaseVcsSubOptions.cs
@@ -1,8 +1,8 @@
+using CommandLine;
+using Destructurama.Attributed;
+
 namespace GitReleaseManager.Core.Options
 {
-    using CommandLine;
-    using Destructurama.Attributed;
-
     public abstract class BaseVcsOptions : BaseSubOptions
     {
         [LogMasked(Text = "[REDACTED]")]
diff --git a/src/GitReleaseManager.Core/Options/CloseSubOptions.cs b/src/GitReleaseManager.Core/Options/CloseSubOptions.cs
index e9b0f2d7..651c1dab 100644
--- a/src/GitReleaseManager.Core/Options/CloseSubOptions.cs
+++ b/src/GitReleaseManager.Core/Options/CloseSubOptions.cs
@@ -1,7 +1,7 @@
+using CommandLine;
+
 namespace GitReleaseManager.Core.Options
 {
-    using CommandLine;
-
     [Verb("close", HelpText = "Closes the milestone.")]
     public class CloseSubOptions : BaseVcsOptions
     {
diff --git a/src/GitReleaseManager.Core/Options/CreateSubOptions.cs b/src/GitReleaseManager.Core/Options/CreateSubOptions.cs
index 41b1d642..c3a66690 100644
--- a/src/GitReleaseManager.Core/Options/CreateSubOptions.cs
+++ b/src/GitReleaseManager.Core/Options/CreateSubOptions.cs
@@ -1,8 +1,8 @@
+using System.Collections.Generic;
+using CommandLine;
+
 namespace GitReleaseManager.Core.Options
 {
-    using System.Collections.Generic;
-    using CommandLine;
-
     [Verb("create", HelpText = "Creates a draft release notes from a milestone.")]
     public class CreateSubOptions : BaseVcsOptions
     {
diff --git a/src/GitReleaseManager.Core/Options/DiscardSubOptions.cs b/src/GitReleaseManager.Core/Options/DiscardSubOptions.cs
index 47a0d7eb..aeb74315 100644
--- a/src/GitReleaseManager.Core/Options/DiscardSubOptions.cs
+++ b/src/GitReleaseManager.Core/Options/DiscardSubOptions.cs
@@ -1,7 +1,7 @@
+using CommandLine;
+
 namespace GitReleaseManager.Core.Options
 {
-    using CommandLine;
-
     [Verb("discard", HelpText = "Discards a draft release.")]
     public class DiscardSubOptions : BaseVcsOptions
     {
diff --git a/src/GitReleaseManager.Core/Options/ExportSubOptions.cs b/src/GitReleaseManager.Core/Options/ExportSubOptions.cs
index a11ca451..692f25dc 100644
--- a/src/GitReleaseManager.Core/Options/ExportSubOptions.cs
+++ b/src/GitReleaseManager.Core/Options/ExportSubOptions.cs
@@ -1,7 +1,7 @@
+using CommandLine;
+
 namespace GitReleaseManager.Core.Options
 {
-    using CommandLine;
-
     [Verb("export", HelpText = "Exports all the Release Notes in markdown format.")]
     public class ExportSubOptions : BaseVcsOptions
     {
diff --git a/src/GitReleaseManager.Core/Options/InitSubOptions.cs b/src/GitReleaseManager.Core/Options/InitSubOptions.cs
index 024d7227..6dae60bb 100644
--- a/src/GitReleaseManager.Core/Options/InitSubOptions.cs
+++ b/src/GitReleaseManager.Core/Options/InitSubOptions.cs
@@ -1,7 +1,7 @@
+using CommandLine;
+
 namespace GitReleaseManager.Core.Options
 {
-    using CommandLine;
-
     [Verb("init", HelpText = "Creates a sample Yaml Configuration file in root directory")]
     public class InitSubOptions : BaseSubOptions
     {
diff --git a/src/GitReleaseManager.Core/Options/LabelSubOptions.cs b/src/GitReleaseManager.Core/Options/LabelSubOptions.cs
index 136b2307..6f0e6d04 100644
--- a/src/GitReleaseManager.Core/Options/LabelSubOptions.cs
+++ b/src/GitReleaseManager.Core/Options/LabelSubOptions.cs
@@ -1,7 +1,7 @@
+using CommandLine;
+
 namespace GitReleaseManager.Core.Options
 {
-    using CommandLine;
-
     [Verb("label", HelpText = "Deletes existing labels and replaces with set of default labels.")]
     public class LabelSubOptions : BaseVcsOptions
     {
diff --git a/src/GitReleaseManager.Core/Options/OpenSubOptions.cs b/src/GitReleaseManager.Core/Options/OpenSubOptions.cs
index 22bd94ea..0f9413c5 100644
--- a/src/GitReleaseManager.Core/Options/OpenSubOptions.cs
+++ b/src/GitReleaseManager.Core/Options/OpenSubOptions.cs
@@ -1,7 +1,7 @@
+using CommandLine;
+
 namespace GitReleaseManager.Core.Options
 {
-    using CommandLine;
-
     [Verb("open", HelpText = "Opens the milestone.")]
     public class OpenSubOptions : BaseVcsOptions
     {
diff --git a/src/GitReleaseManager.Core/Options/PublishSubOptions.cs b/src/GitReleaseManager.Core/Options/PublishSubOptions.cs
index 2398f642..5ebffe2d 100644
--- a/src/GitReleaseManager.Core/Options/PublishSubOptions.cs
+++ b/src/GitReleaseManager.Core/Options/PublishSubOptions.cs
@@ -1,7 +1,7 @@
+using CommandLine;
+
 namespace GitReleaseManager.Core.Options
 {
-    using CommandLine;
-
     [Verb("publish", HelpText = "Publishes the Release.")]
     public class PublishSubOptions : BaseVcsOptions
     {
diff --git a/src/GitReleaseManager.Core/Options/ShowConfigSubOptions.cs b/src/GitReleaseManager.Core/Options/ShowConfigSubOptions.cs
index c8c48392..e26862dd 100644
--- a/src/GitReleaseManager.Core/Options/ShowConfigSubOptions.cs
+++ b/src/GitReleaseManager.Core/Options/ShowConfigSubOptions.cs
@@ -1,7 +1,7 @@
+using CommandLine;
+
 namespace GitReleaseManager.Core.Options
 {
-    using CommandLine;
-
     [Verb("showconfig", HelpText = "Shows the current configuration")]
     public class ShowConfigSubOptions : BaseSubOptions
     {
diff --git a/src/GitReleaseManager.Core/Provider/GitHubProvider.cs b/src/GitReleaseManager.Core/Provider/GitHubProvider.cs
index b84ea4d6..6a933ee8 100644
--- a/src/GitReleaseManager.Core/Provider/GitHubProvider.cs
+++ b/src/GitReleaseManager.Core/Provider/GitHubProvider.cs
@@ -1,29 +1,29 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Threading.Tasks;
+using AutoMapper;
+using Octokit;
+using ApiException = GitReleaseManager.Core.Exceptions.ApiException;
+using ForbiddenException = GitReleaseManager.Core.Exceptions.ForbiddenException;
+using Issue = GitReleaseManager.Core.Model.Issue;
+using IssueComment = GitReleaseManager.Core.Model.IssueComment;
+using ItemState = GitReleaseManager.Core.Model.ItemState;
+using ItemStateFilter = GitReleaseManager.Core.Model.ItemStateFilter;
+using Label = GitReleaseManager.Core.Model.Label;
+using Milestone = GitReleaseManager.Core.Model.Milestone;
+using NotFoundException = GitReleaseManager.Core.Exceptions.NotFoundException;
+using RateLimit = GitReleaseManager.Core.Model.RateLimit;
+using Release = GitReleaseManager.Core.Model.Release;
+using ReleaseAssetUpload = GitReleaseManager.Core.Model.ReleaseAssetUpload;
+
 namespace GitReleaseManager.Core.Provider
 {
-    using System;
-    using System.Collections.Generic;
-    using System.Globalization;
-    using System.Linq;
-    using System.Threading.Tasks;
-    using AutoMapper;
-    using Octokit;
-    using ApiException = GitReleaseManager.Core.Exceptions.ApiException;
-    using ForbiddenException = GitReleaseManager.Core.Exceptions.ForbiddenException;
-    using Issue = GitReleaseManager.Core.Model.Issue;
-    using IssueComment = GitReleaseManager.Core.Model.IssueComment;
-    using ItemState = GitReleaseManager.Core.Model.ItemState;
-    using ItemStateFilter = GitReleaseManager.Core.Model.ItemStateFilter;
-    using Label = GitReleaseManager.Core.Model.Label;
-    using Milestone = GitReleaseManager.Core.Model.Milestone;
-    using NotFoundException = GitReleaseManager.Core.Exceptions.NotFoundException;
-    using RateLimit = GitReleaseManager.Core.Model.RateLimit;
-    using Release = GitReleaseManager.Core.Model.Release;
-    using ReleaseAssetUpload = GitReleaseManager.Core.Model.ReleaseAssetUpload;
-
     public class GitHubProvider : IVcsProvider
     {
-        private const int _pageSize = 100;
-        private const string _notFoundMessgae = "NotFound";
+        private const int PAGE_SIZE = 100;
+        private const string NOT_FOUND_MESSGAE = "NotFound";
 
         private readonly IGitHubClient _gitHubClient;
         private readonly IMapper _mapper;
@@ -36,7 +36,7 @@ public GitHubProvider(IGitHubClient gitHubClient, IMapper mapper)
 
         public Task DeleteAssetAsync(string owner, string repository, int id)
         {
-            return Execute(async () =>
+            return ExecuteAsync(async () =>
             {
                 await _gitHubClient.Repository.Release.DeleteAsset(owner, repository, id).ConfigureAwait(false);
             });
@@ -44,7 +44,7 @@ public Task DeleteAssetAsync(string owner, string repository, int id)
 
         public Task UploadAssetAsync(Release release, ReleaseAssetUpload releaseAssetUpload)
         {
-            return Execute(async () =>
+            return ExecuteAsync(async () =>
             {
                 var octokitRelease = _mapper.Map<Octokit.Release>(release);
                 var octokitReleaseAssetUpload = _mapper.Map<Octokit.ReleaseAssetUpload>(releaseAssetUpload);
@@ -55,7 +55,7 @@ public Task UploadAssetAsync(Release release, ReleaseAssetUpload releaseAssetUpl
 
         public Task<int> GetCommitsCount(string owner, string repository, string @base, string head)
         {
-            return Execute(async () =>
+            return ExecuteAsync(async () =>
             {
                 try
                 {
@@ -86,7 +86,7 @@ public string GetCommitsUrl(string owner, string repository, string head, string
 
         public Task CreateIssueCommentAsync(string owner, string repository, int issueNumber, string comment)
         {
-            return Execute(async () =>
+            return ExecuteAsync(async () =>
             {
                 await _gitHubClient.Issue.Comment.Create(owner, repository, issueNumber, comment).ConfigureAwait(false);
             });
@@ -94,7 +94,7 @@ public Task CreateIssueCommentAsync(string owner, string repository, int issueNu
 
         public Task<IEnumerable<Issue>> GetIssuesAsync(string owner, string repository, int milestoneNumber, ItemStateFilter itemStateFilter = ItemStateFilter.All)
         {
-            return Execute(async () =>
+            return ExecuteAsync(async () =>
             {
                 var openIssueRequest = new RepositoryIssueRequest
                 {
@@ -114,7 +114,7 @@ public Task<IEnumerable<Issue>> GetIssuesAsync(string owner, string repository,
                     issues.AddRange(results);
                     startPage++;
                 }
-                while (results.Count == _pageSize);
+                while (results.Count == PAGE_SIZE);
 
                 return _mapper.Map<IEnumerable<Issue>>(issues);
             });
@@ -122,7 +122,7 @@ public Task<IEnumerable<Issue>> GetIssuesAsync(string owner, string repository,
 
         public Task<IEnumerable<IssueComment>> GetIssueCommentsAsync(string owner, string repository, int issueNumber)
         {
-            return Execute(async () =>
+            return ExecuteAsync(async () =>
             {
                 var startPage = 1;
                 var comments = new List<Octokit.IssueComment>();
@@ -136,7 +136,7 @@ public Task<IEnumerable<IssueComment>> GetIssueCommentsAsync(string owner, strin
                     comments.AddRange(results);
                     startPage++;
                 }
-                while (results.Count == _pageSize);
+                while (results.Count == PAGE_SIZE);
 
                 return _mapper.Map<IEnumerable<IssueComment>>(comments);
             });
@@ -144,7 +144,7 @@ public Task<IEnumerable<IssueComment>> GetIssueCommentsAsync(string owner, strin
 
         public Task CreateLabelAsync(string owner, string repository, Label label)
         {
-            return Execute(async () =>
+            return ExecuteAsync(async () =>
             {
                 var newLabel = _mapper.Map<NewLabel>(label);
 
@@ -154,7 +154,7 @@ public Task CreateLabelAsync(string owner, string repository, Label label)
 
         public Task DeleteLabelAsync(string owner, string repository, string labelName)
         {
-            return Execute(async () =>
+            return ExecuteAsync(async () =>
             {
                 await _gitHubClient.Issue.Labels.Delete(owner, repository, labelName).ConfigureAwait(false);
             });
@@ -162,7 +162,7 @@ public Task DeleteLabelAsync(string owner, string repository, string labelName)
 
         public Task<IEnumerable<Label>> GetLabelsAsync(string owner, string repository)
         {
-            return Execute(async () =>
+            return ExecuteAsync(async () =>
             {
                 var startPage = 1;
                 var labels = new List<Octokit.Label>();
@@ -176,7 +176,7 @@ public Task<IEnumerable<Label>> GetLabelsAsync(string owner, string repository)
                     labels.AddRange(results);
                     startPage++;
                 }
-                while (results.Count == _pageSize);
+                while (results.Count == PAGE_SIZE);
 
                 return _mapper.Map<IEnumerable<Label>>(labels);
             });
@@ -184,14 +184,14 @@ public Task<IEnumerable<Label>> GetLabelsAsync(string owner, string repository)
 
         public Task<Milestone> GetMilestoneAsync(string owner, string repository, string milestoneTitle, ItemStateFilter itemStateFilter = ItemStateFilter.All)
         {
-            return Execute(async () =>
+            return ExecuteAsync(async () =>
             {
                 var milestones = await GetMilestonesAsync(owner, repository, itemStateFilter).ConfigureAwait(false);
                 var milestone = milestones.FirstOrDefault(m => m.Title == milestoneTitle);
 
                 if (milestone is null)
                 {
-                    throw new NotFoundException(_notFoundMessgae);
+                    throw new NotFoundException(NOT_FOUND_MESSGAE);
                 }
 
                 return milestone;
@@ -200,7 +200,7 @@ public Task<Milestone> GetMilestoneAsync(string owner, string repository, string
 
         public Task<IEnumerable<Milestone>> GetMilestonesAsync(string owner, string repository, ItemStateFilter itemStateFilter = ItemStateFilter.All)
         {
-            return Execute(async () =>
+            return ExecuteAsync(async () =>
             {
                 var request = new MilestoneRequest { State = (Octokit.ItemStateFilter)itemStateFilter };
 
@@ -216,7 +216,7 @@ public Task<IEnumerable<Milestone>> GetMilestonesAsync(string owner, string repo
                     milestones.AddRange(results);
                     startPage++;
                 }
-                while (results.Count == _pageSize);
+                while (results.Count == PAGE_SIZE);
 
                 return _mapper.Map<IEnumerable<Milestone>>(milestones);
             });
@@ -224,7 +224,7 @@ public Task<IEnumerable<Milestone>> GetMilestonesAsync(string owner, string repo
 
         public Task SetMilestoneStateAsync(string owner, string repository, int milestoneNumber, ItemState itemState)
         {
-            return Execute(async () =>
+            return ExecuteAsync(async () =>
             {
                 var update = new MilestoneUpdate { State = (Octokit.ItemState)itemState };
                 await _gitHubClient.Issue.Milestone.Update(owner, repository, milestoneNumber, update).ConfigureAwait(false);
@@ -233,7 +233,7 @@ public Task SetMilestoneStateAsync(string owner, string repository, int mileston
 
         public Task<Release> CreateReleaseAsync(string owner, string repository, Release release)
         {
-            return Execute(async () =>
+            return ExecuteAsync(async () =>
             {
                 var newRelease = _mapper.Map<NewRelease>(release);
                 var octokitRelease = await _gitHubClient.Repository.Release.Create(owner, repository, newRelease).ConfigureAwait(false);
@@ -244,7 +244,7 @@ public Task<Release> CreateReleaseAsync(string owner, string repository, Release
 
         public Task DeleteReleaseAsync(string owner, string repository, int id)
         {
-            return Execute(async () =>
+            return ExecuteAsync(async () =>
             {
                 await _gitHubClient.Repository.Release.Delete(owner, repository, id).ConfigureAwait(false);
             });
@@ -252,7 +252,7 @@ public Task DeleteReleaseAsync(string owner, string repository, int id)
 
         public Task<Release> GetReleaseAsync(string owner, string repository, string tagName)
         {
-            return Execute(async () =>
+            return ExecuteAsync(async () =>
             {
                 var release = await _gitHubClient.Repository.Release.Get(owner, repository, tagName).ConfigureAwait(false);
 
@@ -262,7 +262,7 @@ public Task<Release> GetReleaseAsync(string owner, string repository, string tag
 
         public Task<IEnumerable<Release>> GetReleasesAsync(string owner, string repository)
         {
-            return Execute(async () =>
+            return ExecuteAsync(async () =>
             {
                 var startPage = 1;
                 var releases = new List<Octokit.Release>();
@@ -276,7 +276,7 @@ public Task<IEnumerable<Release>> GetReleasesAsync(string owner, string reposito
                     releases.AddRange(results);
                     startPage++;
                 }
-                while (results.Count == _pageSize);
+                while (results.Count == PAGE_SIZE);
 
                 releases = releases.OrderByDescending(r => r.CreatedAt).ToList();
 
@@ -286,7 +286,7 @@ public Task<IEnumerable<Release>> GetReleasesAsync(string owner, string reposito
 
         public Task PublishReleaseAsync(string owner, string repository, string tagName, int releaseId)
         {
-            return Execute(async () =>
+            return ExecuteAsync(async () =>
             {
                 var update = new ReleaseUpdate
                 {
@@ -300,7 +300,7 @@ public Task PublishReleaseAsync(string owner, string repository, string tagName,
 
         public Task UpdateReleaseAsync(string owner, string repository, Release release)
         {
-            return Execute(async () =>
+            return ExecuteAsync(async () =>
             {
                 var update = new ReleaseUpdate
                 {
@@ -330,7 +330,7 @@ public RateLimit GetRateLimit()
             }
         }
 
-        private async Task Execute(Func<Task> action)
+        private async Task ExecuteAsync(Func<Task> action)
         {
             try
             {
@@ -350,7 +350,7 @@ private async Task Execute(Func<Task> action)
             }
         }
 
-        private async Task<T> Execute<T>(Func<Task<T>> action)
+        private async Task<T> ExecuteAsync<T>(Func<Task<T>> action)
         {
             try
             {
diff --git a/src/GitReleaseManager.Core/Provider/IVcsProvider.cs b/src/GitReleaseManager.Core/Provider/IVcsProvider.cs
index 4710363f..f8b4de76 100644
--- a/src/GitReleaseManager.Core/Provider/IVcsProvider.cs
+++ b/src/GitReleaseManager.Core/Provider/IVcsProvider.cs
@@ -1,9 +1,9 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using GitReleaseManager.Core.Model;
+
 namespace GitReleaseManager.Core.Provider
 {
-    using System.Collections.Generic;
-    using System.Threading.Tasks;
-    using GitReleaseManager.Core.Model;
-
     public interface IVcsProvider
     {
         Task DeleteAssetAsync(string owner, string repository, int id);
diff --git a/src/GitReleaseManager.Core/ReleaseNotes/IReleaseNotesBuilder.cs b/src/GitReleaseManager.Core/ReleaseNotes/IReleaseNotesBuilder.cs
index 5f19ab46..1b769ab8 100644
--- a/src/GitReleaseManager.Core/ReleaseNotes/IReleaseNotesBuilder.cs
+++ b/src/GitReleaseManager.Core/ReleaseNotes/IReleaseNotesBuilder.cs
@@ -1,7 +1,7 @@
+using System.Threading.Tasks;
+
 namespace GitReleaseManager.Core.ReleaseNotes
 {
-    using System.Threading.Tasks;
-
     public interface IReleaseNotesBuilder
     {
         Task<string> BuildReleaseNotes(string user, string repository, string milestoneTitle, string template);
diff --git a/src/GitReleaseManager.Core/ReleaseNotes/IReleaseNotesExporter.cs b/src/GitReleaseManager.Core/ReleaseNotes/IReleaseNotesExporter.cs
index daa61ff3..0a09785c 100644
--- a/src/GitReleaseManager.Core/ReleaseNotes/IReleaseNotesExporter.cs
+++ b/src/GitReleaseManager.Core/ReleaseNotes/IReleaseNotesExporter.cs
@@ -1,8 +1,8 @@
+using System.Collections.Generic;
+using GitReleaseManager.Core.Model;
+
 namespace GitReleaseManager.Core.ReleaseNotes
 {
-    using System.Collections.Generic;
-    using GitReleaseManager.Core.Model;
-
     public interface IReleaseNotesExporter
     {
         string ExportReleaseNotes(IEnumerable<Release> releases);
diff --git a/src/GitReleaseManager.Core/ReleaseNotes/ReleaseNotesBuilder.cs b/src/GitReleaseManager.Core/ReleaseNotes/ReleaseNotesBuilder.cs
index e5c804be..38d2f058 100644
--- a/src/GitReleaseManager.Core/ReleaseNotes/ReleaseNotesBuilder.cs
+++ b/src/GitReleaseManager.Core/ReleaseNotes/ReleaseNotesBuilder.cs
@@ -1,20 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Threading.Tasks;
+using GitReleaseManager.Core.Configuration;
+using GitReleaseManager.Core.Helpers;
+using GitReleaseManager.Core.Model;
+using GitReleaseManager.Core.Provider;
+using GitReleaseManager.Core.Templates;
+using Serilog;
+
 namespace GitReleaseManager.Core.ReleaseNotes
 {
-    using System;
-    using System.Collections.Generic;
-    using System.Globalization;
-    using System.Linq;
-    using System.Threading.Tasks;
-    using GitReleaseManager.Core.Configuration;
-    using GitReleaseManager.Core.Extensions;
-    using GitReleaseManager.Core.Helpers;
-    using GitReleaseManager.Core.Model;
-    using GitReleaseManager.Core.Provider;
-    using GitReleaseManager.Core.Templates;
-    using Scriban;
-    using Scriban.Runtime;
-    using Serilog;
-
     public class ReleaseNotesBuilder : IReleaseNotesBuilder
     {
         private readonly IVcsProvider _vcsProvider;
diff --git a/src/GitReleaseManager.Core/ReleaseNotes/ReleaseNotesExporter.cs b/src/GitReleaseManager.Core/ReleaseNotes/ReleaseNotesExporter.cs
index a639afd2..0ef631e3 100644
--- a/src/GitReleaseManager.Core/ReleaseNotes/ReleaseNotesExporter.cs
+++ b/src/GitReleaseManager.Core/ReleaseNotes/ReleaseNotesExporter.cs
@@ -1,15 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+using GitReleaseManager.Core.Configuration;
+using GitReleaseManager.Core.Model;
+using Serilog;
+
 namespace GitReleaseManager.Core.ReleaseNotes
 {
-    using System;
-    using System.Collections.Generic;
-    using System.Globalization;
-    using System.Linq;
-    using System.Text;
-    using System.Text.RegularExpressions;
-    using GitReleaseManager.Core.Configuration;
-    using GitReleaseManager.Core.Model;
-    using Serilog;
-
     public class ReleaseNotesExporter : IReleaseNotesExporter
     {
         private readonly ILogger _logger;
diff --git a/src/GitReleaseManager.Core/Templates/TemplateFactory.cs b/src/GitReleaseManager.Core/Templates/TemplateFactory.cs
index 0f8b2894..e93ce1d3 100644
--- a/src/GitReleaseManager.Core/Templates/TemplateFactory.cs
+++ b/src/GitReleaseManager.Core/Templates/TemplateFactory.cs
@@ -1,12 +1,12 @@
+using System.Threading.Tasks;
+using GitReleaseManager.Core.Configuration;
+using GitReleaseManager.Core.Extensions;
+using GitReleaseManager.Core.Helpers;
+using Scriban;
+using Scriban.Runtime;
+
 namespace GitReleaseManager.Core.Templates
 {
-    using System.Threading.Tasks;
-    using GitReleaseManager.Core.Configuration;
-    using GitReleaseManager.Core.Extensions;
-    using GitReleaseManager.Core.Helpers;
-    using Scriban;
-    using Scriban.Runtime;
-
     public class TemplateFactory
     {
         private readonly IFileSystem fileSystem;
diff --git a/src/GitReleaseManager.Core/Templates/TemplateLoader.cs b/src/GitReleaseManager.Core/Templates/TemplateLoader.cs
index d18d7b74..c4b9b383 100644
--- a/src/GitReleaseManager.Core/Templates/TemplateLoader.cs
+++ b/src/GitReleaseManager.Core/Templates/TemplateLoader.cs
@@ -1,17 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using GitReleaseManager.Core.Configuration;
+using GitReleaseManager.Core.Helpers;
+using Scriban;
+using Scriban.Parsing;
+using Scriban.Runtime;
+
 namespace GitReleaseManager.Core.Templates
 {
-    using System;
-    using System.Collections.Generic;
-    using System.Diagnostics;
-    using System.IO;
-    using System.Linq;
-    using System.Threading.Tasks;
-    using GitReleaseManager.Core.Configuration;
-    using GitReleaseManager.Core.Helpers;
-    using Scriban;
-    using Scriban.Parsing;
-    using Scriban.Runtime;
-
     public class TemplateLoader : ITemplateLoader
     {
         private static readonly string[] _templateExtensions = new[] { ".sbn", ".scriban" };
diff --git a/src/GitReleaseManager.Core/VcsService.cs b/src/GitReleaseManager.Core/VcsService.cs
index 006699b3..1c0296ae 100644
--- a/src/GitReleaseManager.Core/VcsService.cs
+++ b/src/GitReleaseManager.Core/VcsService.cs
@@ -1,26 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using GitReleaseManager.Core.Configuration;
+using GitReleaseManager.Core.Exceptions;
+using GitReleaseManager.Core.Extensions;
+using GitReleaseManager.Core.Model;
+using GitReleaseManager.Core.Provider;
+using GitReleaseManager.Core.ReleaseNotes;
+using GitReleaseManager.Core.Templates;
+using Serilog;
+
 namespace GitReleaseManager.Core
 {
-    using System;
-    using System.Collections.Generic;
-    using System.IO;
-    using System.Linq;
-    using System.Security.Cryptography;
-    using System.Text;
-    using System.Threading;
-    using System.Threading.Tasks;
-    using GitReleaseManager.Core.Configuration;
-    using GitReleaseManager.Core.Exceptions;
-    using GitReleaseManager.Core.Extensions;
-    using GitReleaseManager.Core.Model;
-    using GitReleaseManager.Core.Provider;
-    using GitReleaseManager.Core.ReleaseNotes;
-    using GitReleaseManager.Core.Templates;
-    using Serilog;
-
     public class VcsService : IVcsService
     {
-        private const string _unableToFoundMilestoneMessage = "Unable to find a {State} milestone with title '{Title}' on '{Owner}/{Repository}'";
-        private const string _unableToFoundReleaseMessage = "Unable to find a release with tag '{TagName}' on '{Owner}/{Repository}'";
+        private const string UNABLE_TO_FOUND_MILESTONE_MESSAGE = "Unable to find a {State} milestone with title '{Title}' on '{Owner}/{Repository}'";
+        private const string UNABLE_TO_FOUND_RELEASE_MESSAGE = "Unable to find a release with tag '{TagName}' on '{Owner}/{Repository}'";
 
         private readonly IVcsProvider _vcsProvider;
         private readonly ILogger _logger;
@@ -47,7 +47,7 @@ public async Task<Release> CreateReleaseFromMilestoneAsync(string owner, string
             }
 
             var releaseNotes = await _releaseNotesBuilder.BuildReleaseNotes(owner, repository, milestone, templatePath).ConfigureAwait(false);
-            var release = await CreateRelease(owner, repository, releaseName, milestone, releaseNotes, prerelease, targetCommitish, assets).ConfigureAwait(false);
+            var release = await CreateReleaseAsync(owner, repository, releaseName, milestone, releaseNotes, prerelease, targetCommitish, assets).ConfigureAwait(false);
 
             return release;
         }
@@ -59,12 +59,12 @@ public async Task<Release> CreateReleaseFromInputFileAsync(string owner, string
             _logger.Verbose("Reading release notes from: '{FilePath}'", inputFilePath);
 
             var releaseNotes = File.ReadAllText(inputFilePath);
-            var release = await CreateRelease(owner, repository, name, name, releaseNotes, prerelease, targetCommitish, assets).ConfigureAwait(false);
+            var release = await CreateReleaseAsync(owner, repository, name, name, releaseNotes, prerelease, targetCommitish, assets).ConfigureAwait(false);
 
             return release;
         }
 
-        private async Task<Release> CreateRelease(string owner, string repository, string name, string tagName, string body, bool prerelease, string targetCommitish, IList<string> assets)
+        private async Task<Release> CreateReleaseAsync(string owner, string repository, string name, string tagName, string body, bool prerelease, string targetCommitish, IList<string> assets)
         {
             Release release;
 
@@ -117,7 +117,7 @@ public async Task DiscardReleaseAsync(string owner, string repository, string ta
             }
             catch (NotFoundException)
             {
-                _logger.Warning(_unableToFoundReleaseMessage, tagName, owner, repository);
+                _logger.Warning(UNABLE_TO_FOUND_RELEASE_MESSAGE, tagName, owner, repository);
             }
         }
 
@@ -199,7 +199,7 @@ public async Task AddAssetsAsync(string owner, string repository, string tagName
                 }
                 catch (NotFoundException)
                 {
-                    _logger.Warning(_unableToFoundReleaseMessage, tagName, owner, repository);
+                    _logger.Warning(UNABLE_TO_FOUND_RELEASE_MESSAGE, tagName, owner, repository);
                 }
             }
         }
@@ -223,7 +223,7 @@ public async Task<string> ExportReleasesAsync(string owner, string repository, s
                 }
                 catch (NotFoundException)
                 {
-                    _logger.Warning(_unableToFoundReleaseMessage, tagName, owner, repository);
+                    _logger.Warning(UNABLE_TO_FOUND_RELEASE_MESSAGE, tagName, owner, repository);
                 }
             }
 
@@ -247,7 +247,7 @@ public async Task CloseMilestoneAsync(string owner, string repository, string mi
             }
             catch (NotFoundException)
             {
-                _logger.Warning(_unableToFoundMilestoneMessage, "open", milestoneTitle, owner, repository);
+                _logger.Warning(UNABLE_TO_FOUND_MILESTONE_MESSAGE, "open", milestoneTitle, owner, repository);
             }
         }
 
@@ -263,7 +263,7 @@ public async Task OpenMilestoneAsync(string owner, string repository, string mil
             }
             catch (NotFoundException)
             {
-                _logger.Warning(_unableToFoundMilestoneMessage, "closed", milestoneTitle, owner, repository);
+                _logger.Warning(UNABLE_TO_FOUND_MILESTONE_MESSAGE, "closed", milestoneTitle, owner, repository);
             }
         }
 
@@ -280,7 +280,7 @@ public async Task PublishReleaseAsync(string owner, string repository, string ta
             }
             catch (NotFoundException)
             {
-                _logger.Warning(_unableToFoundReleaseMessage, tagName, owner, repository);
+                _logger.Warning(UNABLE_TO_FOUND_RELEASE_MESSAGE, tagName, owner, repository);
             }
         }
 
@@ -375,7 +375,7 @@ private async Task AddIssueCommentsAsync(string owner, string repository, Milest
 
                 try
                 {
-                    if (!await CommentsIncludeString(owner, repository, issue.Number, detectionComment).ConfigureAwait(false))
+                    if (!await CommentsIncludeStringAsync(owner, repository, issue.Number, detectionComment).ConfigureAwait(false))
                     {
                         _logger.Information("Adding release comment for issue #{IssueNumber}", issue.Number);
                         await _vcsProvider.CreateIssueCommentAsync(owner, repository, issue.Number, issueComment).ConfigureAwait(false);
@@ -393,7 +393,7 @@ private async Task AddIssueCommentsAsync(string owner, string repository, Milest
             }
         }
 
-        private async Task<bool> CommentsIncludeString(string owner, string repository, int issueNumber, string comment)
+        private async Task<bool> CommentsIncludeStringAsync(string owner, string repository, int issueNumber, string comment)
         {
             _logger.Verbose("Finding issue comment created by GitReleaseManager for issue #{IssueNumber}", issueNumber);
             var issueComments = await _vcsProvider.GetIssueCommentsAsync(owner, repository, issueNumber).ConfigureAwait(false);
diff --git a/src/GitReleaseManager.IntegrationTests/.editorconfig b/src/GitReleaseManager.IntegrationTests/.editorconfig
new file mode 100644
index 00000000..8572e65f
--- /dev/null
+++ b/src/GitReleaseManager.IntegrationTests/.editorconfig
@@ -0,0 +1,4 @@
+root = false
+
+[*.cs]
+dotnet_naming_rule.async_method_should_have_async_suffix.severity = none
\ No newline at end of file
diff --git a/src/GitReleaseManager.IntegrationTests/ClientBuilder.cs b/src/GitReleaseManager.IntegrationTests/ClientBuilder.cs
index 6c17c338..6909e15b 100644
--- a/src/GitReleaseManager.IntegrationTests/ClientBuilder.cs
+++ b/src/GitReleaseManager.IntegrationTests/ClientBuilder.cs
@@ -1,8 +1,8 @@
+using Octokit;
+using Octokit.Internal;
+
 namespace GitReleaseManager.IntegrationTests
 {
-    using Octokit;
-    using Octokit.Internal;
-
     public static class ClientBuilder
     {
         private static HttpClientAdapter _httpClient;
diff --git a/src/GitReleaseManager.IntegrationTests/ClipBoardHelper.cs b/src/GitReleaseManager.IntegrationTests/ClipBoardHelper.cs
index c7b9863f..94bb5e18 100644
--- a/src/GitReleaseManager.IntegrationTests/ClipBoardHelper.cs
+++ b/src/GitReleaseManager.IntegrationTests/ClipBoardHelper.cs
@@ -1,8 +1,8 @@
+using System.Threading;
+using TextCopy;
+
 namespace GitReleaseManager.IntegrationTests
 {
-    using System.Threading;
-    using TextCopy;
-
     public static class ClipBoardHelper
     {
         public static void SetClipboard(string result)
diff --git a/src/GitReleaseManager.IntegrationTests/GitHubProviderIntegrationTests.cs b/src/GitReleaseManager.IntegrationTests/GitHubProviderIntegrationTests.cs
index 8f673542..354bbaf0 100644
--- a/src/GitReleaseManager.IntegrationTests/GitHubProviderIntegrationTests.cs
+++ b/src/GitReleaseManager.IntegrationTests/GitHubProviderIntegrationTests.cs
@@ -1,24 +1,24 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using AutoMapper;
+using GitReleaseManager.Core;
+using GitReleaseManager.Core.Provider;
+using NUnit.Framework;
+using Octokit;
+using Serilog;
+using Shouldly;
+using Issue = GitReleaseManager.Core.Model.Issue;
+using Milestone = GitReleaseManager.Core.Model.Milestone;
+
 namespace GitReleaseManager.IntegrationTests
 {
-    using System;
-    using System.Linq;
-    using System.Threading.Tasks;
-    using AutoMapper;
-    using GitReleaseManager.Core;
-    using GitReleaseManager.Core.Provider;
-    using NUnit.Framework;
-    using Octokit;
-    using Serilog;
-    using Shouldly;
-    using Issue = GitReleaseManager.Core.Model.Issue;
-    using Milestone = GitReleaseManager.Core.Model.Milestone;
-
     [TestFixture]
     [Explicit]
     public class GitHubProviderIntegrationTests
     {
-        private const string _owner = "GitTools";
-        private const string _repository = "GitReleaseManager";
+        private const string OWNER = "GitTools";
+        private const string REPOSITORY = "GitReleaseManager";
 
         private GitHubProvider _gitHubProvider;
         private IGitHubClient _gitHubClient;
@@ -51,7 +51,7 @@ public void OneTimeSetUp()
         [Order(1)]
         public async Task Should_Get_Labels()
         {
-            var result = await _gitHubProvider.GetLabelsAsync(_owner, _repository).ConfigureAwait(false);
+            var result = await _gitHubProvider.GetLabelsAsync(OWNER, REPOSITORY).ConfigureAwait(false);
             result.Count().ShouldBeGreaterThan(0);
         }
 
@@ -59,7 +59,7 @@ public async Task Should_Get_Labels()
         [Order(2)]
         public async Task Should_Get_Milestones()
         {
-            var result = await _gitHubProvider.GetMilestonesAsync(_owner, _repository).ConfigureAwait(false);
+            var result = await _gitHubProvider.GetMilestonesAsync(OWNER, REPOSITORY).ConfigureAwait(false);
             result.Count().ShouldBeGreaterThan(0);
 
             _milestone = result.OrderByDescending(m => m.Number).First();
@@ -69,7 +69,7 @@ public async Task Should_Get_Milestones()
         [Order(3)]
         public async Task Should_Get_Issues()
         {
-            var result = await _gitHubProvider.GetIssuesAsync(_owner, _repository, _milestone.Number).ConfigureAwait(false);
+            var result = await _gitHubProvider.GetIssuesAsync(OWNER, REPOSITORY, _milestone.Number).ConfigureAwait(false);
             result.Count().ShouldBeGreaterThan(0);
 
             _issue = result.First();
@@ -79,7 +79,7 @@ public async Task Should_Get_Issues()
         [Order(4)]
         public async Task Should_Get_Issue_Comments()
         {
-            var result = await _gitHubProvider.GetIssueCommentsAsync(_owner, _repository, _issue.Number).ConfigureAwait(false);
+            var result = await _gitHubProvider.GetIssueCommentsAsync(OWNER, REPOSITORY, _issue.Number).ConfigureAwait(false);
             result.Count().ShouldBeGreaterThan(0);
         }
 
@@ -87,7 +87,7 @@ public async Task Should_Get_Issue_Comments()
         [Order(5)]
         public async Task Should_Get_Releases()
         {
-            var result = await _gitHubProvider.GetReleasesAsync(_owner, _repository).ConfigureAwait(false);
+            var result = await _gitHubProvider.GetReleasesAsync(OWNER, REPOSITORY).ConfigureAwait(false);
             result.Count().ShouldBeGreaterThan(0);
 
             var orderedReleases = result.OrderByDescending(r => r.Id).ToList();
@@ -100,7 +100,7 @@ public async Task Should_Get_Releases()
         [Order(6)]
         public async Task Should_Get_Commits_Count()
         {
-            var result = await _gitHubProvider.GetCommitsCount(_owner, _repository, _releaseBaseTag, _releaseHeadTag).ConfigureAwait(false);
+            var result = await _gitHubProvider.GetCommitsCount(OWNER, REPOSITORY, _releaseBaseTag, _releaseHeadTag).ConfigureAwait(false);
             result.ShouldBeGreaterThan(0);
         }
     }
diff --git a/src/GitReleaseManager.IntegrationTests/Helper.cs b/src/GitReleaseManager.IntegrationTests/Helper.cs
index 80b304d0..1e116717 100644
--- a/src/GitReleaseManager.IntegrationTests/Helper.cs
+++ b/src/GitReleaseManager.IntegrationTests/Helper.cs
@@ -1,9 +1,9 @@
+using System;
+using System.Net;
+using Octokit;
+
 namespace GitReleaseManager.IntegrationTests
 {
-    using System;
-    using System.Net;
-    using Octokit;
-
     public static class Helper
     {
         // From https://github.com/octokit/octokit.net/blob/master/Octokit.Tests.Integration/Helper.cs
diff --git a/src/GitReleaseManager.IntegrationTests/ReleaseNotesBuilderIntegrationTests.cs b/src/GitReleaseManager.IntegrationTests/ReleaseNotesBuilderIntegrationTests.cs
index 188f5e37..28424ea2 100644
--- a/src/GitReleaseManager.IntegrationTests/ReleaseNotesBuilderIntegrationTests.cs
+++ b/src/GitReleaseManager.IntegrationTests/ReleaseNotesBuilderIntegrationTests.cs
@@ -1,20 +1,20 @@
+using System;
+using System.Diagnostics;
+using System.Threading.Tasks;
+using AutoMapper;
+using GitReleaseManager.Core;
+using GitReleaseManager.Core.Configuration;
+using GitReleaseManager.Core.Helpers;
+using GitReleaseManager.Core.Options;
+using GitReleaseManager.Core.Provider;
+using GitReleaseManager.Core.ReleaseNotes;
+using GitReleaseManager.Core.Templates;
+using NUnit.Framework;
+using Octokit;
+using Serilog;
+
 namespace GitReleaseManager.IntegrationTests
 {
-    using System;
-    using System.Diagnostics;
-    using System.Threading.Tasks;
-    using AutoMapper;
-    using GitReleaseManager.Core;
-    using GitReleaseManager.Core.Configuration;
-    using GitReleaseManager.Core.Helpers;
-    using GitReleaseManager.Core.Options;
-    using GitReleaseManager.Core.Provider;
-    using GitReleaseManager.Core.ReleaseNotes;
-    using GitReleaseManager.Core.Templates;
-    using NUnit.Framework;
-    using Octokit;
-    using Serilog;
-
     [TestFixture]
     [Explicit]
     public class ReleaseNotesBuilderIntegrationTests
diff --git a/src/GitReleaseManager.Tests/.editorconfig b/src/GitReleaseManager.Tests/.editorconfig
new file mode 100644
index 00000000..8572e65f
--- /dev/null
+++ b/src/GitReleaseManager.Tests/.editorconfig
@@ -0,0 +1,4 @@
+root = false
+
+[*.cs]
+dotnet_naming_rule.async_method_should_have_async_suffix.severity = none
\ No newline at end of file
diff --git a/src/GitReleaseManager.Tests/ConfigurationTests.cs b/src/GitReleaseManager.Tests/ConfigurationTests.cs
index 147ebf48..e4112a5c 100644
--- a/src/GitReleaseManager.Tests/ConfigurationTests.cs
+++ b/src/GitReleaseManager.Tests/ConfigurationTests.cs
@@ -1,11 +1,11 @@
+using System;
+using System.IO;
+using System.Text;
+using GitReleaseManager.Core.Configuration;
+using NUnit.Framework;
+
 namespace GitReleaseManager.Tests
 {
-    using System;
-    using System.IO;
-    using System.Text;
-    using GitReleaseManager.Core.Configuration;
-    using NUnit.Framework;
-
     [TestFixture]
     public class ConfigurationTests
     {
diff --git a/src/GitReleaseManager.Tests/Extensions/StringExtensionsTests.cs b/src/GitReleaseManager.Tests/Extensions/StringExtensionsTests.cs
index 5cba5553..09908f97 100644
--- a/src/GitReleaseManager.Tests/Extensions/StringExtensionsTests.cs
+++ b/src/GitReleaseManager.Tests/Extensions/StringExtensionsTests.cs
@@ -1,9 +1,9 @@
+using System.Collections.Generic;
+using GitReleaseManager.Core.Extensions;
+using NUnit.Framework;
+
 namespace GitReleaseManager.Tests.Extensions
 {
-    using System.Collections.Generic;
-    using GitReleaseManager.Core.Extensions;
-    using NUnit.Framework;
-
     [TestFixture]
     public class StringExtensionsTests
     {
diff --git a/src/GitReleaseManager.Tests/Helper.cs b/src/GitReleaseManager.Tests/Helper.cs
index 4dd16750..5e04843f 100644
--- a/src/GitReleaseManager.Tests/Helper.cs
+++ b/src/GitReleaseManager.Tests/Helper.cs
@@ -1,9 +1,9 @@
+using System;
+using System.Net;
+using Octokit;
+
 namespace GitReleaseManager.Tests
 {
-    using System;
-    using System.Net;
-    using Octokit;
-
     public static class Helper
     {
         // From https://github.com/octokit/octokit.net/blob/master/Octokit.Tests.Integration/Helper.cs
diff --git a/src/GitReleaseManager.Tests/ReleaseNotesBuilderTests.cs b/src/GitReleaseManager.Tests/ReleaseNotesBuilderTests.cs
index cc6833ae..ff51d84c 100644
--- a/src/GitReleaseManager.Tests/ReleaseNotesBuilderTests.cs
+++ b/src/GitReleaseManager.Tests/ReleaseNotesBuilderTests.cs
@@ -1,20 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using ApprovalTests;
+using GitReleaseManager.Core.Configuration;
+using GitReleaseManager.Core.Helpers;
+using GitReleaseManager.Core.Model;
+using GitReleaseManager.Core.Provider;
+using GitReleaseManager.Core.ReleaseNotes;
+using GitReleaseManager.Core.Templates;
+using NSubstitute;
+using NUnit.Framework;
+using Serilog;
+
 namespace GitReleaseManager.Tests
 {
-    using System;
-    using System.Collections.Generic;
-    using System.Linq;
-    using System.Threading.Tasks;
-    using ApprovalTests;
-    using GitReleaseManager.Core.Configuration;
-    using GitReleaseManager.Core.Helpers;
-    using GitReleaseManager.Core.Model;
-    using GitReleaseManager.Core.Provider;
-    using GitReleaseManager.Core.ReleaseNotes;
-    using GitReleaseManager.Core.Templates;
-    using NSubstitute;
-    using NUnit.Framework;
-    using Serilog;
-
     [TestFixture]
     public class ReleaseNotesBuilderTests
     {
diff --git a/src/GitReleaseManager.Tests/ReleaseNotesExporterTests.cs b/src/GitReleaseManager.Tests/ReleaseNotesExporterTests.cs
index 54f4dd54..8761d7ef 100644
--- a/src/GitReleaseManager.Tests/ReleaseNotesExporterTests.cs
+++ b/src/GitReleaseManager.Tests/ReleaseNotesExporterTests.cs
@@ -1,16 +1,16 @@
+using System;
+using System.Text;
+using ApprovalTests;
+using GitReleaseManager.Core.Configuration;
+using GitReleaseManager.Core.Helpers;
+using GitReleaseManager.Core.Model;
+using GitReleaseManager.Core.ReleaseNotes;
+using NSubstitute;
+using NUnit.Framework;
+using Serilog;
+
 namespace GitReleaseManager.Tests
 {
-    using System;
-    using System.Text;
-    using ApprovalTests;
-    using GitReleaseManager.Core.Configuration;
-    using GitReleaseManager.Core.Helpers;
-    using GitReleaseManager.Core.Model;
-    using GitReleaseManager.Core.ReleaseNotes;
-    using NSubstitute;
-    using NUnit.Framework;
-    using Serilog;
-
     [TestFixture]
     public class ReleaseNotesExporterTests
     {
diff --git a/src/GitReleaseManager.Tests/VcsServiceMock.cs b/src/GitReleaseManager.Tests/VcsServiceMock.cs
index 8b556c53..4a5b53ae 100644
--- a/src/GitReleaseManager.Tests/VcsServiceMock.cs
+++ b/src/GitReleaseManager.Tests/VcsServiceMock.cs
@@ -1,10 +1,10 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using GitReleaseManager.Core.Model;
+using IVcsService = GitReleaseManager.Core.IVcsService;
+
 namespace GitReleaseManager.Tests
 {
-    using System.Collections.Generic;
-    using System.Threading.Tasks;
-    using GitReleaseManager.Core.Model;
-    using IVcsService = GitReleaseManager.Core.IVcsService;
-
     public class VcsServiceMock : IVcsService
     {
         public VcsServiceMock()