public void ScopeDataDictionaryIsReferenced()
{
Logger logger = new Logger();
string value = $"ScopeData-{Guid.NewGuid()}";
IDictionary <string, object> scopeData = null;
var options = new LoggerOptions
{
Factory = new KissLog.LoggerFactory(logger),
OnBeginScope = (BeginScopeArgs args) =>
{
args.ScopeData.Add("Key", value);
},
OnEndScope = (EndScopeArgs args) =>
{
scopeData = args.ScopeData;
}
};
ILogger adapter = new LoggerAdapter(options);
using (adapter.BeginScope(null))
{
}
Assert.IsNotNull(scopeData);
Assert.AreEqual(value, scopeData["Key"]);
}
public IDictionary <string, object> GetCustomParaFromToken(string token, string src, string pemFile, List <string> keys)
{
IDictionary <string, object> strs;
IDictionary <string, object> strs1 = new Dictionary <string, object>();
try
{
string str = File.ReadAllText(pemFile);
Dictionary <string, object> strs2 = JWT.Decode <Dictionary <string, object> >(token, Crypto.DecodeX509PublicKey(str));
object item = strs2["datas"];
Console.WriteLine(string.Format(item.ToString(), new object[0]));
if (object.Equals(this.GetMd5(src), item))
{
foreach (string key in keys)
{
strs1.Add(key, strs2[key]);
}
}
strs = strs1;
}
catch (Exception exception)
{
LoggerAdapter.Error(string.Format("ValidateToken fail:{0}", exception.Message));
strs = strs1;
}
return(strs);
}
/// <summary>
/// Restores missing packages for the entire solution
/// </summary>
/// <returns></returns>
public virtual async Task <PackageRestoreResult> RestoreMissingPackagesInSolutionAsync(
string solutionDirectory,
INuGetProjectContext nuGetProjectContext,
ILogger logger,
CancellationToken token)
{
var packageReferencesDictionary = await GetPackagesReferencesDictionaryAsync(token);
// When this method is called, the step to compute if a package is missing is implicit. Assume it is true
var packages = packageReferencesDictionary.Select(p =>
{
Debug.Assert(p.Value != null);
return(new PackageRestoreData(p.Key, p.Value, isMissing: true));
});
using (var cacheContext = new SourceCacheContext())
{
var adapterLogger = new LoggerAdapter(nuGetProjectContext);
var downloadContext = new PackageDownloadContext(cacheContext)
{
ParentId = nuGetProjectContext.OperationId,
ClientPolicyContext = ClientPolicyContext.GetClientPolicy(Settings, adapterLogger)
};
return(await RestoreMissingPackagesAsync(
solutionDirectory,
packages,
nuGetProjectContext,
downloadContext,
logger,
token));
}
}
protected NuGetPowerShellBaseCommand()
{
var componentModel = NuGetUIThreadHelper.JoinableTaskFactory.Run(ServiceLocator.GetComponentModelAsync);
_sourceRepositoryProvider = componentModel.GetService <ISourceRepositoryProvider>();
ConfigSettings = componentModel.GetService <ISettings>();
VsSolutionManager = componentModel.GetService <IVsSolutionManager>();
SourceControlManagerProvider = componentModel.GetService <ISourceControlManagerProvider>();
_commonOperations = componentModel.GetService <ICommonOperations>();
PackageRestoreManager = componentModel.GetService <IPackageRestoreManager>();
_deleteOnRestartManager = componentModel.GetService <IDeleteOnRestartManager>();
_nuGetProgressReporter = componentModel.GetService <IRestoreProgressReporter>();
DTE = ServiceLocator.GetInstance <DTE>();
var logger = new LoggerAdapter(this);
PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
ClientPolicyContext.GetClientPolicy(ConfigSettings, logger),
logger);
if (_commonOperations != null)
{
ExecutionContext = new IDEExecutionContext(_commonOperations);
}
ActivityCorrelationId.StartNew();
}
public async Task CreateAsync_WhenInputIsValid_Then_CreatesContractSuccessfullyTest()
{
// Arrange
string baseUrl = $"https://localhost:5001";
SetMapperHelper();
var request = Generate_CreateContractRequest();
ILoggerAdapter <ContractService> logger = new LoggerAdapter <ContractService>(new Logger <ContractService>(new LoggerFactory()));
ILoggerAdapter <ContractRepository> loggerRepo = new LoggerAdapter <ContractRepository>(new Logger <ContractRepository>(new LoggerFactory()));
MockAuditService();
var inMemPdsDbContext = HelperExtensions.GetInMemoryPdsDbContext();
var repo = new Repository <DataModels.Contract>(inMemPdsDbContext);
var work = new SingleUnitOfWorkForRepositories(inMemPdsDbContext);
var contractRepo = new ContractRepository(repo, work, loggerRepo);
var uriService = new UriService(baseUrl);
var asposeDocumentManagementContractService = GetDocumentService();
var contractValidationService = GetContractValidationService();
var mediator = BuildMediator();
var contractDocumentService = BuildContractDocumentService();
var service = new ContractService(contractRepo, _mapper, uriService, logger, _mockAuditService.Object, _semaphoreOnEntity, asposeDocumentManagementContractService, contractValidationService, mediator, contractDocumentService);
// Act
var before = await contractRepo.GetByContractNumberAsync(request.ContractNumber);
await service.CreateAsync(request);
var after = await contractRepo.GetByContractNumberAsync(request.ContractNumber);
// Assert
before.Should().BeEmpty();
after.Should().HaveCount(1).And.Subject.First().ContractVersion.Should().Be(request.ContractVersion);
}
static void setUpNLog(bool EnableConsoleLog, bool EnableServiceLog)
{
var config = new LoggingConfiguration();
if (EnableConsoleLog)
{
var consoleTarget = new ColoredConsoleTarget();
config.AddTarget("console", consoleTarget);
consoleTarget.Layout = @"${date:format=HH\:mm\:ss} ${logger} ${message}";
var rule = new LoggingRule("*", LoggerAdapter.ToNLogLevel(verbosity), consoleTarget);
config.LoggingRules.Add(rule);
}
if (EnableServiceLog)
{
var eventTarget = new EventLogTarget();
config.AddTarget("eventlog", eventTarget);
eventTarget.Layout = @"${date:format=HH\:mm\:ss} ${logger} ${message}";
var rule = new LoggingRule("*", LoggerAdapter.ToNLogLevel(verbosity), eventTarget);
config.LoggingRules.Add(rule);
}
N.LogManager.Configuration = config;
}
public void EndScopeInvokesOptionsOnEndScope()
{
Logger logger = new Logger();
var options = new LoggerOptions
{
Factory = new KissLog.LoggerFactory(logger),
OnBeginScope = (BeginScopeArgs args) =>
{
string message = args.State?.ToString();
args.Logger.Trace(message);
},
OnEndScope = (EndScopeArgs args) =>
{
args.Logger.Trace("Scope ended");
}
};
ILogger adapter = new LoggerAdapter(options);
using (adapter.BeginScope("Scope"))
{
adapter.LogInformation("Info message");
}
Assert.AreEqual(3, logger.DataContainer.LogMessages.Count());
Assert.IsTrue(logger.DataContainer.LogMessages.ElementAt(0).Message == "Scope");
Assert.IsTrue(logger.DataContainer.LogMessages.ElementAt(1).Message == "Info message");
Assert.IsTrue(logger.DataContainer.LogMessages.ElementAt(2).Message == "Scope ended");
}
private async Task <IEnumerable <Packaging.PackageReference> > GetInstalledPackageReferencesAsync(
Project project)
{
if (project == null)
{
throw new ArgumentNullException("project");
}
var packages = new List <Packaging.PackageReference>();
if (_solutionManager != null &&
!string.IsNullOrEmpty(_solutionManager.SolutionDirectory))
{
InitializePackageManagerAndPackageFolderPath();
var projectContext = new VSAPIProjectContext();
var logger = new LoggerAdapter(projectContext);
projectContext.PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
ClientPolicyContext.GetClientPolicy(_settings, logger),
logger);
var nuGetProject = await _solutionManager.GetOrCreateProjectAsync(
project,
projectContext);
var installedPackages = await nuGetProject.GetInstalledPackagesAsync(CancellationToken.None);
packages.AddRange(installedPackages);
}
return(packages);
}
public VsPackageInstaller(
ISourceRepositoryProvider sourceRepositoryProvider,
Configuration.ISettings settings,
IVsSolutionManager solutionManager,
IVsPackageInstallerServices packageServices,
IDeleteOnRestartManager deleteOnRestartManager)
{
_sourceRepositoryProvider = sourceRepositoryProvider;
_settings = settings;
_solutionManager = solutionManager;
_packageServices = packageServices;
_deleteOnRestartManager = deleteOnRestartManager;
_isCPSJTFLoaded = false;
_projectContext = new Lazy <INuGetProjectContext>(() => {
var projectContext = new VSAPIProjectContext();
var signedPackageVerifier = new PackageSignatureVerifier(SignatureVerificationProviderFactory.GetSignatureVerificationProviders());
var logger = new LoggerAdapter(projectContext);
projectContext.PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
logger,
signedPackageVerifier,
SignedPackageVerifierSettings.GetClientPolicy(_settings, logger));
return(projectContext);
});
PumpingJTF = new PumpingJTF(NuGetUIThreadHelper.JoinableTaskFactory);
}
/// <summary>
/// Returns the UI for the project or given set of projects.
/// </summary>
public async ValueTask <INuGetUI> CreateAsync(
IServiceBroker serviceBroker,
params IProjectContextInfo[] projects)
{
if (serviceBroker is null)
{
throw new ArgumentNullException(nameof(serviceBroker));
}
var adapterLogger = new LoggerAdapter(ProjectContext);
ProjectContext.PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
ClientPolicyContext.GetClientPolicy(Settings.Value, adapterLogger),
adapterLogger);
return(await NuGetUI.CreateAsync(
serviceBroker,
CommonOperations,
ProjectContext,
SourceRepositoryProvider.Value,
Settings.Value,
SolutionManager,
PackageRestoreManager.Value,
OptionsPageActivator.Value,
SolutionUserOptions,
DeleteOnRestartManager.Value,
SolutionUserOptions,
LockService.Value,
OutputConsoleLogger,
RestoreProgressReporter.Value,
CancellationToken.None,
projects));
}
private Task InstallPackageAsync(string source, Project project, string packageId, NuGetVersion version, bool includePrerelease, bool ignoreDependencies)
{
IEnumerable <string> sources = null;
if (!string.IsNullOrEmpty(source) &&
!StringComparer.OrdinalIgnoreCase.Equals("All", source)) // "All" was supported in V2
{
sources = new[] { source };
}
var versionRange = VersionRange.All;
if (version != null)
{
versionRange = new VersionRange(version, true, version, true);
}
var toInstall = new List <PackageIdentity>
{
new PackageIdentity(packageId, version)
};
var projectContext = new VSAPIProjectContext();
var logger = new LoggerAdapter(projectContext);
var signedPackageVerifier = new PackageSignatureVerifier(SignatureVerificationProviderFactory.GetSignatureVerificationProviders());
projectContext.PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
logger,
signedPackageVerifier,
SignedPackageVerifierSettings.GetClientPolicy(_settings, logger));
return(InstallInternalAsync(project, toInstall, GetSources(sources), projectContext, includePrerelease, ignoreDependencies, CancellationToken.None));
}
public VsPathContextProvider(
IAsyncServiceProvider asyncServiceProvider,
Lazy <ISettings> settings,
Lazy <IVsSolutionManager> solutionManager,
Lazy <NuGet.Common.ILogger> logger)
{
_asyncServiceprovider = asyncServiceProvider ?? throw new ArgumentNullException(nameof(asyncServiceProvider));
_settings = settings ?? throw new ArgumentNullException(nameof(settings));
_solutionManager = solutionManager ?? throw new ArgumentNullException(nameof(solutionManager));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_getLockFileOrNullAsync = BuildIntegratedProjectUtility.GetLockFileOrNull;
_projectContext = new Lazy <INuGetProjectContext>(() => {
var projectContext = new VSAPIProjectContext();
var adapterLogger = new LoggerAdapter(projectContext);
projectContext.PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
ClientPolicyContext.GetClientPolicy(_settings.Value, adapterLogger),
adapterLogger);
return(projectContext);
});
}
protected NuGetPowerShellBaseCommand()
{
_sourceRepositoryProvider = ServiceLocator.GetInstance <ISourceRepositoryProvider>();
ConfigSettings = ServiceLocator.GetInstance <Configuration.ISettings>();
VsSolutionManager = ServiceLocator.GetInstance <IVsSolutionManager>();
DTE = ServiceLocator.GetInstance <DTE>();
SourceControlManagerProvider = ServiceLocator.GetInstance <ISourceControlManagerProvider>();
_commonOperations = ServiceLocator.GetInstance <ICommonOperations>();
PackageRestoreManager = ServiceLocator.GetInstance <IPackageRestoreManager>();
_deleteOnRestartManager = ServiceLocator.GetInstance <IDeleteOnRestartManager>();
var logger = new LoggerAdapter(this);
PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
ClientPolicyContext.GetClientPolicy(ConfigSettings, logger),
logger);
if (_commonOperations != null)
{
ExecutionContext = new IDEExecutionContext(_commonOperations);
}
ActivityCorrelationId.StartNew();
}
public static void ApplicationOnLogMessageReceived(string condition, string stackTrace, LogType type)
{
if (UnityToLog4Net)
{
if (_logger == null)
{
_logger = new LoggerAdapter("Unity");
}
if (type == LogType.Log && _logger.IsDebugEnabled)
{
_logger.DebugFormat("{0} {1} {2}", type, condition, stackTrace);
}
else if (type == LogType.Warning && _logger.IsWarnEnabled)
{
if (!condition.Contains("The referenced script on this Behaviour"))
{
_logger.WarnFormat("{0} {1} {2}", type, condition, stackTrace);
}
}
else if (_logger.IsErrorEnabled)
{
_logger.ErrorFormat("{0} {1} {2}", type, condition, stackTrace);
}
}
}
public SearchServiceTests()
{
var mockLogger = new Mock <LoggerFactory>();
var loggerAdapter = new LoggerAdapter <SearchService>(mockLogger.Object);
_searchService = new SearchService(loggerAdapter);
}
public ExplorerDatabaseService()
{
Logger = new LoggerAdapter(Name);
RepositoryManager = new Database.Managers.RepositoryManager(Logger);
SqlTransactionManager = new SqlTransactionManager(trigger, RepositoryManager, Logger);
ReadDatabaseManager = new Database.Managers.ReadDatabaseManager(RepositoryManager);
}
/// <summary>
/// Returns the UI for the project or given set of projects.
/// </summary>
public async ValueTask <INuGetUI> CreateAsync(params IProjectContextInfo[] projects)
{
var adapterLogger = new LoggerAdapter(ProjectContext);
ProjectContext.PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
ClientPolicyContext.GetClientPolicy(Settings.Value, adapterLogger),
adapterLogger);
// only pick up at most three integrated package managers
const int MaxPackageManager = 3;
var packageManagerProviders = PackageManagerProviderUtility.Sort(
PackageManagerProviders, MaxPackageManager);
return(await NuGetUI.CreateAsync(
CommonOperations,
ProjectContext,
SourceRepositoryProvider.Value,
Settings.Value,
SolutionManager,
PackageRestoreManager.Value,
OptionsPageActivator.Value,
SolutionUserOptions,
DeleteOnRestartManager.Value,
packageManagerProviders,
SolutionUserOptions,
LockService.Value,
OutputConsoleLogger,
CancellationToken.None,
projects));
}
public QbittorrentTests(ITestOutputHelper output)
{
_output = output;
_logger = new LoggerBuilder <QbittorrentService>().Build();
_qbittorrentSettings = new qbittorrentSettingBuilder().Build();
_qbittorrentService = new QbittorrentService(_logger, _qbittorrentSettings);
}
public static void InitLog4net()
{
lock (_lock)
{
if (!_isInitLog)
{
_isInitLog = true;
#if UNITY_2017
var configFile = Application.dataPath + "\\Config\\log4net.xml";
log4net.GlobalContext.Properties["LogDir"] = Application.dataPath;
#else
#if UNITY_EDITOR
var configFile = Application.dataPath + "/Config/log4net_56_editor.xml";
#else
var configFile = Application.dataPath + "/Config/log4net_56.xml";
#endif
var logDir = (Application.dataPath + "/../log/");
logDir = logDir.Replace("/", Path.DirectorySeparatorChar + "");
logDir = Path.GetFullPath(logDir);
log4net.GlobalContext.Properties["LogDir"] = logDir;
#endif
LoggerAdapter.Init(configFile);
}
}
}
public void InstallPackagesFromRegistryRepository(string keyName, bool isPreUnzipped, bool skipAssemblyReferences, bool ignoreDependencies, Project project, IDictionary <string, string> packageVersions)
{
if (string.IsNullOrEmpty(keyName))
{
throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, nameof(keyName));
}
if (project == null)
{
throw new ArgumentNullException(nameof(project));
}
if (packageVersions == null ||
!packageVersions.Any())
{
throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, nameof(packageVersions));
}
RunJTFWithCorrectContext(project, async() =>
{
// HACK !!! : This is a hack for PCL projects which send isPreUnzipped = true, but their package source
// (located at C:\Program Files (x86)\Microsoft SDKs\NuGetPackages) follows the V3
// folder version format.
if (isPreUnzipped)
{
var isProjectJsonProject = await EnvDTEProjectUtility.HasBuildIntegratedConfig(project);
isPreUnzipped = isProjectJsonProject ? false : isPreUnzipped;
}
// create a repository provider with only the registry repository
var repoProvider = new PreinstalledRepositoryProvider(ErrorHandler, _sourceRepositoryProvider);
repoProvider.AddFromRegistry(keyName, isPreUnzipped);
var toInstall = GetIdentitiesFromDict(packageVersions);
// Skip assembly references and disable binding redirections should be done together
var disableBindingRedirects = skipAssemblyReferences;
var projectContext = new VSAPIProjectContext(skipAssemblyReferences, disableBindingRedirects);
var signedPackageVerifier = new PackageSignatureVerifier(SignatureVerificationProviderFactory.GetSignatureVerificationProviders());
var logger = new LoggerAdapter(projectContext);
projectContext.PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
logger,
signedPackageVerifier,
SignedPackageVerifierSettings.GetClientPolicy(_settings, logger));
await InstallInternalAsync(
project,
toInstall,
repoProvider,
projectContext,
includePrerelease: false,
ignoreDependencies: ignoreDependencies,
token: CancellationToken.None);
});
}
/// <summary>
/// Adds refresh files to the specified project for all assemblies references belonging to the packages
/// specified by packageNames.
/// </summary>
/// <param name="project">The project.</param>
/// <param name="repositoryPath">The file system pointing to 'packages' folder under the solution.</param>
/// <param name="packageNames">The package names.</param>
private void AddRefreshFilesForReferences(EnvDTE.Project project, string repositoryPath, IEnumerable <PackageIdentity> packageNames)
{
if (project == null)
{
throw new ArgumentNullException("project");
}
if (repositoryPath == null)
{
throw new ArgumentNullException("repositoryPath");
}
if (!packageNames.Any())
{
return;
}
VSAPIProjectContext context = new VSAPIProjectContext(skipAssemblyReferences: true, bindingRedirectsDisabled: true);
var logger = new LoggerAdapter(context);
context.PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
ClientPolicyContext.GetClientPolicy(_settings, logger),
logger);
WebSiteProjectSystem projectSystem = new WebSiteProjectSystem(_vsProjectAdapterProvider.CreateAdapterForFullyLoadedProject(project), context);
foreach (var packageName in packageNames)
{
string packagePath = string.Format(CultureInfo.InvariantCulture, "{0}.{1}", packageName.Id, packageName.Version);
DirectoryInfo packageFolder = new DirectoryInfo(Path.Combine(repositoryPath, packagePath));
PackageFolderReader reader = new PackageFolderReader(packageFolder);
var frameworkGroups = reader.GetReferenceItems();
var groups = reader.GetReferenceItems();
var fwComparer = new NuGetFrameworkFullComparer();
FrameworkReducer reducer = new FrameworkReducer();
NuGetFramework targetGroupFramework = reducer.GetNearest(projectSystem.TargetFramework, groups.Select(e => e.TargetFramework));
if (targetGroupFramework != null)
{
var refGroup = groups.Where(e => fwComparer.Equals(targetGroupFramework, e.TargetFramework)).FirstOrDefault();
foreach (string refItem in refGroup.Items)
{
string sourcePath = Path.Combine(packageFolder.FullName, refItem.Replace('/', Path.DirectorySeparatorChar));
// create one refresh file for each assembly reference, as per required by Website projects
// projectSystem.CreateRefreshFile(assemblyPath);
RefreshFileUtility.CreateRefreshFile(projectSystem, sourcePath);
}
}
}
}
public void ShouldCreateLogger(Mock <ILoggerFactory> loggerFactory)
{
// Act
_ = new LoggerAdapter <LoggerAdapterTests>(loggerFactory.Object);
// Assert
loggerFactory.Verify(x => x.CreateLogger(typeof(LoggerAdapterTests).FullName), Times.Once);
}
#pragma warning disable 1591
protected override void OnGameStarting()
#pragma warning restore 1591
{
var logger = new LoggerAdapter(Logs.Game);
IEnumerable <SingularityModules> moduleResources = ContentProvider.GetAvailableContent <SingularityModules>().Select(x => x.Res);
_gameScope = new GameScope(logger, new SceneScopeFactory(), new SceneEventsProvider(), moduleResources);
}
public ConsumerThread(string name, Func <Job, Result> action) : base(name)
{
_action = action;
_profile = SingletonManager.Get <DurationHelp>().GetCustomProfileInfo(name);
_profile2 = SingletonManager.Get <DurationHelp>().GetCustomProfileInfo(name + "_all");
_logger =
new LoggerAdapter(Name);
}
public void LogInformation_WhenLogFailed_ReturnFalse()
{
// arrange
LoggerAdapter la = new LoggerAdapter(LoggingConstants.DefaultLogUriFail);
// act & assert
la.LogInformation(LoggingConstants.AppName, "Unit Testing of negative test case of Log Information").Should().BeFalse();
}
public void LogPerformance_WhenLogged_ReturnTrue()
{
// arrange
LoggerAdapter la = new LoggerAdapter(LoggingConstants.DefaultLogUri);
// act & assert
la.LogPerformance(LoggingConstants.AppName, "Unit Test of LogPerformance", DateTime.Now, DateTime.Now).Should().BeTrue();
}
public IActionResult Index()
{
LoggerAdapter.Debug("Logs Debug");
LoggerAdapter.Information("Logs Information");
LoggerAdapter.Warning("Logs Warning");
LoggerAdapter.Error("Logs Error");
LoggerAdapter.Fatal("Logs Fatal");
return(View());
}
public void LogInformation_WhenLogged_ReturnTrue()
{
// arrange
System.IO.Directory.CreateDirectory(LoggingConstants.DefaultLogUri);
LoggerAdapter la = new LoggerAdapter(LoggingConstants.DefaultLogUri);
// act & assert
la.LogInformation(LoggingConstants.AppName, "Unit Test of Log Information").Should().BeTrue();
}
public DownloadServiceTests(ITestOutputHelper output)
{
_output = output;
_logger = new LoggerBuilder <DownloadService>().Build();
_movieService = new MovieServiceBuilder().Build();
_movieMagnetService = new MovieMagServiceBuilder().Build();
_qbittorrentService = new QbittorrentServiceBuilder().Build();
_downloadService = new DownloadService(_logger, _movieService, _movieMagnetService, _qbittorrentService, null);
}
public void LogInformation_ThrowsDirectoryNotFoundException()
{
// arrange
LoggerAdapter la = new LoggerAdapter(LoggingConstants.DefaultLogUriFail);
// act & assert
var ex = Assert.Throws <ArgumentException>(() => la.LogInformation(LoggingConstants.AppName, "Unit Testing of DirectoryNotFoundException"));
Assert.Equal("Directory Not Found Exception", ex.Message);
}
