public void Product()
{
IServiceProvider testService = new TestServiceProvider();
HomeController controller = new HomeController(testService);
controller.Product();
}
/// <summary>
/// Initializes a new instance of the TestHarnessSettings class.
/// </summary>
public TestHarnessSettings()
{
Components = new Dictionary<string, object>();
LogProviders = new List<LogProvider>();
Parameters = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
TestAssemblies = new List<Assembly>();
TestService = new TestServiceProvider();
}
public void GetUrlEncoder_ServiceProviderDoesNotHaveEncoder_UsesDefault()
{
// Arrange
var serviceProvider = new TestServiceProvider();
// Act
var retVal = serviceProvider.GetUrlEncoder();
// Assert
Assert.Same(UrlEncoder.Default, retVal);
}
public void FullConfigureStartupShouldInjectServicesCorrectly()
{
MyApplication.StartsFrom <FullConfigureStartup>();
Assert.NotNull(TestServiceProvider.GetService <IHostEnvironment>());
Assert.NotNull(TestServiceProvider.GetService <ILoggerFactory>());
Assert.NotNull(TestServiceProvider.GetService <IHostApplicationLifetime>());
MyApplication
.IsRunningOn(server => server
.WithStartup <DefaultStartup>());
}
public void AddMvcUniverseTestingShouldAddRoutingTestingServicesAndDisableEndPointRouting()
{
MyApplication.StartsFrom <TestStartup>()
.WithServices(services =>
{
services.AddMvcUniverseTesting();
});
var mvcOptions = TestServiceProvider.GetService <IOptions <MvcOptions> >();
Assert.True(mvcOptions.Value.EnableEndpointRouting);
}
private void ReportCodeCoverage(TestServiceProvider testService)
{
if (CodeCoverage.HitBlockCount > 0 && testService != null && testService.HasService(TestServiceFeature.CodeCoverageReporting))
{
CodeCoverageProvider ccp = testService.GetService <CodeCoverageProvider>(TestServiceFeature.CodeCoverageReporting);
if (ccp != null)
{
string data = CodeCoverage.GetCoverageData();
ccp.SaveCoverageData(data, /* no callback Action */ null);
}
}
}
public async Task CanStoreAndDelete()
{
RegisterServices();
BuildServiceProvider();
ISimpleRepository <TestEntity> testRepository = TestServiceProvider.GetRequiredService <ISimpleRepository <TestEntity> >();
await testRepository.Insert(TestEntity);
await testRepository.Delete(TestEntity.ID);
await Assert.ThrowsExceptionAsync <KeyNotFoundException>(() => testRepository.Fetch(TestEntity.ID));
}
public void MyTestMethod()
{
using (var _services = TestServiceProvider.InSQLContext(svc => svc.AddScoped <ICurrentAppUser>(a => new TestCurrentUser(-1, "test"))))
{
var _dbContext = _services.GetService <ICanaryDbContext>();
var _result = _dbContext.LSUsers.Any();
Assert.IsTrue(_result, "No data");
}
}
public void GetUrlEncoder_ServiceProviderHasEncoder_ReturnsRegisteredInstance()
{
// Arrange
var expectedEncoder = new UrlEncoder();
var serviceProvider = new TestServiceProvider() { Service = expectedEncoder };
// Act
var retVal = serviceProvider.GetUrlEncoder();
// Assert
Assert.Same(expectedEncoder, retVal);
}
public async Task RunAsync(Func <Task> next)
{
var provider = new TestServiceProvider();
var testContext = new TestContext(provider);
provider.AddTransient <ITestMiddleware, SetNameTestMiddleware> ();
provider.AddTransient <ITestMiddleware, SetDisplayNameTestMiddleware> ();
provider.AddTransient <ContextMiddlewareFactory, ContextMiddlewareFactory> ();
var factory = provider.GetService <ContextMiddlewareFactory> ();
Console.WriteLine("Without generic type implementation:");
await factory.UseMiddlewareAsync(testContext, next);
}
public void IsUsingWithStartUpClassShouldThrowStartupExceptionWithServiceProviderWhenTestServicesAreMissing()
{
Test.AssertException <InvalidOperationException>(
() =>
{
MyApplication.StartsFrom <CustomStartupWithDefaultBuildProvider>();
TestServiceProvider.GetService <IInjectedService>();
},
"Testing services could not be resolved. If your ConfigureServices method returns an IServiceProvider, you should either change it to return 'void' or manually register the required testing services by calling one of the provided IServiceCollection extension methods in the 'MyTested.AspNetCore.Mvc' namespace. An easy way to do the second option is to add a TestStartup class at the root of your test project and invoke the extension methods there.");
MyApplication.StartsFrom <DefaultStartup>();
}
public void DefaultConfigurationShouldSetMockedMemoryCache()
{
MyMvc
.IsUsingDefaultConfiguration()
.WithServices(services => services.AddMemoryCache());
var memoryCache = TestServiceProvider.GetService <IMemoryCache>();
Assert.NotNull(memoryCache);
Assert.IsAssignableFrom <MockedMemoryCache>(memoryCache);
MyMvc.IsUsingDefaultConfiguration();
}
public void DefaultConfigurationShouldSetMockMemoryCache()
{
MyApplication
.StartsFrom <DefaultStartup>()
.WithServices(services => services.AddMemoryCache());
var memoryCache = TestServiceProvider.GetService <IMemoryCache>();
Assert.NotNull(memoryCache);
Assert.IsAssignableFrom <MemoryCacheMock>(memoryCache);
MyApplication.StartsFrom <DefaultStartup>();
}
/// <summary>
/// Adds the <see cref="MockJsRuntimeInvokeHandler"/> to the <see cref="TestServiceProvider"/>.
/// </summary>
/// <returns>The added <see cref="MockJsRuntimeInvokeHandler"/>.</returns>
public static MockJsRuntimeInvokeHandler AddMockJsRuntime(this TestServiceProvider serviceProvider, JsRuntimeMockMode mode = JsRuntimeMockMode.Loose)
{
if (serviceProvider is null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
var result = new MockJsRuntimeInvokeHandler(mode);
serviceProvider.AddSingleton(result.ToJsRuntime());
return(result);
}
public static void AddAuthenticationServices(this TestServiceProvider services, Task <AuthenticationState> initialAuthState = null, AuthorizationResult nextAuth = null)
{
if (nextAuth == null)
{
nextAuth = AuthorizationResult.Success();
}
services.AddSingleton <IAuthorizationService>(new TestAuthorizationService()
{
NextResult = nextAuth
});
services.AddSingleton <IAuthorizationPolicyProvider>(new TestAuthorizationPolicyProvider());
services.AddSingleton <AuthenticationStateProvider>(new TestAuthenticationStateProvider(initialAuthState));
}
public void IsUsingShouldAddServices()
{
MyApplication
.StartsFrom <DefaultStartup>()
.WithServices(TestObjectFactory.GetCustomServicesRegistrationAction());
var injectedService = TestServiceProvider.GetService <IInjectedService>();
var anotherInjectedService = TestServiceProvider.GetService <IAnotherInjectedService>();
Assert.NotNull(injectedService);
Assert.NotNull(anotherInjectedService);
MyApplication.StartsFrom <DefaultStartup>();
}
private static ChainContext CreateChainContext(string name = "TestName", TestLogSink?logSink = null)
{
var serviceProvider = new TestServiceProvider(
configureServices: services =>
{
services.AddLogging(builder =>
{
builder.AddProvider(new TestLoggerProvider(logSink ?? new TestLogSink()));
});
}
);
return(new ChainContext(name, serviceProvider, CancellationToken.None));
}
public async Task Enqueue_AsyncInstanceMethod_ShouldSucceed()
{
var testServiceProvider = new TestServiceProvider();
var testStore = new MemoryJobStore();
var jobManager = new JobManager(testStore);
var jobRunner = new JobRunner(testServiceProvider);
await jobManager.EnqueueAsync <TestJobs>((t) => t.InstanceJobAsync1(1));
JobDescriptor?job = await testStore.NextAsync(CancellationToken.None);
Assert.Equal("InstanceJobAsync1", job !.Call.Method);
await jobRunner.InvokeAsync(job.Call, CancellationToken.None);
}
public void StartupFiltersShouldBeRegisteredAndConsidered()
{
MyApplication
.StartsFrom <DefaultStartup>()
.WithServices(services => services
.AddSingleton <IStartupFilter>(new CustomStartupFilter()));
var sameStartupFilter = TestServiceProvider.GetService <IStartupFilter>() as CustomStartupFilter;
Assert.NotNull(sameStartupFilter);
Assert.True(sameStartupFilter.Registered);
MyApplication.StartsFrom <DefaultStartup>();
}
public void TestServiceProviderShouldReturnServiceToBeSet()
{
var applicationController = Substitute.For <IApplicationController>();
TestServiceProvider testServiceProvider = (TestServiceProvider)ServiceProvider.Create(applicationController, ServiceType.Test);
IMainWindowViewModel mainWindowViewModelMock = Substitute.For <IMainWindowViewModel>();
testServiceProvider.SetMainWindowViewModel(mainWindowViewModelMock);
Assert.AreEqual(mainWindowViewModelMock, testServiceProvider.GetMainWindowViewModel());
IConfigWindowViewModel configWindowViewModelMock = Substitute.For <IConfigWindowViewModel>();
testServiceProvider.SetConfigWindowViewModel(configWindowViewModelMock);
Assert.AreEqual(configWindowViewModelMock, testServiceProvider.GetConfigWindowViewModel());
}
public async Task CanStoreAndRetrieve()
{
RegisterServices();
BuildServiceProvider();
ISimpleRepository <TestEntity> testRepository = TestServiceProvider.GetRequiredService <ISimpleRepository <TestEntity> >();
await testRepository.Insert(TestEntity);
TestEntity fetched = await testRepository.Fetch(TestEntity.ID);
Assert.AreNotEqual(0, fetched.ID);
Assert.AreEqual(TestEntity.ID, fetched.ID);
Assert.AreNotSame(TestEntity, fetched);
}
public void IsUsingShouldAddServices()
{
MyMvc
.IsUsingDefaultConfiguration()
.WithServices(TestObjectFactory.GetCustomServicesRegistrationAction());
var injectedService = TestServiceProvider.GetService <IInjectedService>();
var anotherInjectedService = TestServiceProvider.GetService <IAnotherInjectedService>();
Assert.NotNull(injectedService);
Assert.NotNull(anotherInjectedService);
MyMvc.IsUsingDefaultConfiguration();
}
public void ServiceInitialization()
{
try
{
TestServiceProvider serviceProvider = TestServiceProvider.Instance;
Assert.NotNull(serviceProvider);
}
catch (System.ArgumentException)
{
}
Assert.True(LanguageService.Instance.Context != null);
Assert.True(LanguageService.Instance.ConnectionServiceInstance != null);
Assert.True(LanguageService.Instance.CurrentWorkspaceSettings != null);
Assert.True(LanguageService.Instance.CurrentWorkspace != null);
}
/// <summary>
/// Merge any settings provided by a test service with the parameters
/// that were passed inside the TestHarnessSettings.
/// </summary>
/// <param name="testService">The test service.</param>
/// <param name="inputSettings">The run settings.</param>
private static void MergeSettingsAndParameters(TestServiceProvider testService, UnitTestSettings inputSettings)
{
if (testService != null && testService.HasService(TestServiceFeature.RunSettings))
{
SettingsProvider settings = testService.GetService <SettingsProvider>(TestServiceFeature.RunSettings);
foreach (string key in settings.Settings.Keys)
{
if (inputSettings.Parameters.ContainsKey(key))
{
Debug.WriteLine("MergeSettingsAndParameters: Overwriting " + key + " key during merge.");
}
inputSettings.Parameters[key] = settings.Settings[key];
}
}
}
public void DefaultConfigAndAdditionalServicesShouldWorkCorrectly()
{
MyMvc
.IsUsingDefaultConfiguration()
.WithServices(services =>
{
services.AddMvc();
});
var service = TestServiceProvider.GetRequiredService <MvcMarkerService>();
Assert.NotNull(service);
MyMvc.IsUsingDefaultConfiguration();
}
public void DefaultConfigAndAdditionalServicesShouldWorkCorrectly()
{
MyApplication
.StartsFrom <DefaultStartup>()
.WithServices(services =>
{
services.AddMvc();
});
var service = TestServiceProvider.GetRequiredService <MvcMarkerService>();
Assert.NotNull(service);
MyApplication.StartsFrom <DefaultStartup>();
}
/// <inheritdoc />
public IAndControllerBuilder <TController> WithServiceSetupFor <TService>(Action <TService> scopedServiceSetup)
{
CommonValidator.CheckForNullReference(scopedServiceSetup, nameof(scopedServiceSetup));
var serviceLifetime = TestServiceProvider.GetServiceLifetime <TService>();
if (serviceLifetime != ServiceLifetime.Scoped)
{
throw new InvalidOperationException("This overload of the 'WithServiceSetupFor' method can be used only for services with scoped lifetime.");
}
scopedServiceSetup(this.HttpContext.RequestServices.GetService <TService>());
return(this);
}
public void GetUrlEncoder_ServiceProviderHasEncoder_ReturnsRegisteredInstance()
{
// Arrange
var expectedEncoder = new UrlEncoder();
var serviceProvider = new TestServiceProvider()
{
Service = expectedEncoder
};
// Act
var retVal = serviceProvider.GetUrlEncoder();
// Assert
Assert.Same(expectedEncoder, retVal);
}
public static void AddBootstrapProviders(TestServiceProvider services)
{
services.AddSingleton <IIdGenerator>(new IdGenerator());
services.AddSingleton <IEditContextValidator>(sp => new EditContextValidator(new ValidationMessageLocalizerAttributeFinder(), sp));
services.AddSingleton <IClassProvider>(new BootstrapClassProvider());
services.AddSingleton <IStyleProvider>(new BootstrapStyleProvider());
services.AddSingleton <IBehaviourProvider>(new BootstrapBehaviourProvider());
services.AddSingleton <IThemeGenerator>(new BootstrapThemeGenerator(new Mock <IThemeCache>().Object));
services.AddSingleton <IIconProvider>(new Mock <IIconProvider>().Object);
services.AddSingleton <IValidationHandlerFactory, ValidationHandlerFactory>();
services.AddSingleton <ValidatorValidationHandler>();
services.AddSingleton <PatternValidationHandler>();
services.AddSingleton <DataAnnotationValidationHandler>();
services.AddSingleton <IDateTimeFormatConverter, DateTimeFormatConverter>();
services.AddSingleton <IVersionProvider, VersionProvider>();
services.AddScoped <ITextLocalizerService, TextLocalizerService>();
services.AddScoped(typeof(ITextLocalizer <>), typeof(TextLocalizer <>));
Action <BlazoriseOptions> configureOptions = (options) =>
{
};
services.AddSingleton(configureOptions);
services.AddSingleton <BlazoriseOptions>();
services.AddScoped <IJSUtilitiesModule, JSUtilitiesModule>();
services.AddScoped <IJSButtonModule, JSButtonModule>();
services.AddScoped <IJSClosableModule, JSClosableModule>();
services.AddScoped <IJSBreakpointModule, JSBreakpointModule>();
services.AddScoped <IJSTextEditModule, JSTextEditModule>();
services.AddScoped <IJSMemoEditModule, JSMemoEditModule>();
services.AddScoped <IJSNumericPickerModule, JSNumericPickerModule>();
services.AddScoped <IJSDatePickerModule, JSDatePickerModule>();
services.AddScoped <IJSTimePickerModule, JSTimePickerModule>();
services.AddScoped <IJSColorPickerModule, JSColorPickerModule>();
services.AddScoped <IJSFileEditModule, JSFileEditModule>();
services.AddScoped <IJSTableModule, JSTableModule>();
services.AddScoped <IJSInputMaskModule, JSInputMaskModule>();
services.AddScoped <IJSDropdownModule, JSDropdownModule>();
services.AddScoped <IJSModalModule, Bootstrap.Modules.BootstrapJSModalModule>();
services.AddScoped <IJSTooltipModule, Bootstrap.Modules.BootstrapJSTooltipModule>();
services.AddMemoryCache();
services.AddScoped <Blazorise.Shared.Data.EmployeeData>();
services.AddScoped <Blazorise.Shared.Data.CountryData>();
}
public void ExplicitMockedTempDataProviderShouldOverrideIt()
{
MyMvc
.StartsFrom <DataStartup>()
.WithServices(services =>
{
services.ReplaceTempDataProvider();
});
var tempDataProvider = TestServiceProvider.GetService <ITempDataProvider>();
Assert.NotNull(tempDataProvider);
Assert.IsAssignableFrom <MockedTempDataProvider>(tempDataProvider);
MyMvc.IsUsingDefaultConfiguration();
}
public void ExplicitMockMemoryCacheShouldOverrideIt()
{
MyApplication
.StartsFrom <DataStartup>()
.WithServices(services =>
{
services.ReplaceMemoryCache();
});
var memoryCache = TestServiceProvider.GetService <IMemoryCache>();
Assert.NotNull(memoryCache);
Assert.IsAssignableFrom <MemoryCacheMock>(memoryCache);
MyApplication.StartsFrom <DefaultStartup>();
}
public void IsUsingWithAdditionalServicesShouldUseThem()
{
MyMvc
.StartsFrom <CustomStartup>()
.WithServices(services =>
{
services.AddTransient <IInjectedService, InjectedService>();
});
var injectedServices = TestServiceProvider.GetService <IInjectedService>();
Assert.NotNull(injectedServices);
Assert.IsAssignableFrom(typeof(InjectedService), injectedServices);
MyMvc.IsUsingDefaultConfiguration();
}
public void ExplicitMockedMemoryCacheShouldOverrideIt()
{
MyMvc
.StartsFrom <DataStartup>()
.WithServices(services =>
{
services.ReplaceMemoryCache();
});
var memoryCache = TestServiceProvider.GetService <IMemoryCache>();
Assert.NotNull(memoryCache);
Assert.IsAssignableFrom <MockedMemoryCache>(memoryCache);
MyMvc.IsUsingDefaultConfiguration();
}
public void ExplicitMockedSessionShouldOverrideIt()
{
MyMvc
.StartsFrom <SessionDataStartup>()
.WithServices(services =>
{
services.ReplaceSession();
});
var session = TestServiceProvider.GetService <ISessionStore>();
Assert.NotNull(session);
Assert.IsAssignableFrom <MockedSessionStore>(session);
MyMvc.IsUsingDefaultConfiguration();
}
/// <summary>
/// Settings for the unit test system.
/// </summary>
public UnitTestSettings()
{
SampleTags = new List<string>();
Components = new Dictionary<string, object>();
LogProviders = new List<LogProvider>();
Parameters = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
TestAssemblies = new List<Assembly>();
TestService = new TestServiceProvider();
SortTestMethods = DefaultSortTestMethods;
SortTestClasses = DefaultSortTestClasses;
TestClassesToRun = new Collection<string>();
ShowTagExpressionEditor = true;
// Service defaults
TestServiceHostname = "localhost";
TestServicePath = "/externalInterface/";
TestServicePort = 8000;
}
/// <summary>
/// Initializes a new environment provider.
/// </summary>
/// <param name="testService">The web test service.</param>
public WebEnvironmentProvider(TestServiceProvider testService)
: base(testService)
{
}
private void ReportCodeCoverage(TestServiceProvider testService)
{
if (CodeCoverage.HitBlockCount > 0 && testService != null && testService.HasService(TestServiceFeature.CodeCoverageReporting))
{
CodeCoverageProvider ccp = testService.GetService<CodeCoverageProvider>(TestServiceFeature.CodeCoverageReporting);
if (ccp != null)
{
string data = CodeCoverage.GetCoverageData();
ccp.SaveCoverageData(data, /* no callback Action */ null);
}
}
}
/// <summary>
/// Initializes a new base provider class.
/// </summary>
/// <param name="provider">The owning test service provider.</param>
/// <param name="displayName">The display name of the service.</param>
protected ProviderBase(TestServiceProvider provider, string displayName)
{
DisplayName = displayName;
TestService = provider ?? this as TestServiceProvider;
}
/// <summary>
/// Initializes a new reporting provider instance.
/// </summary>
/// <param name="testService">The test service.</param>
public WebTestReportingProvider(TestServiceProvider testService)
: base(testService)
{
}
/// <summary>
/// Initializes a new code coverage provider.
/// </summary>
/// <param name="testService">The test service.</param>
public CodeCoverageProvider(TestServiceProvider testService)
: base(testService, "CodeCoverage")
{
}
/// <summary>
/// Initializes a new environment provider.
/// </summary>
/// <param name="testService">The test service.</param>
public EnvironmentProvider(TestServiceProvider testService)
: base(testService, "Environment")
{
}
public void FixtureSetup()
{
IServiceProvider serviceProvider = new TestServiceProvider();
serviceProvider.Add(new TwitterUtilities());
_resolver = new ServiceResolver(serviceProvider);
}
/// <summary>
/// Initializes a new settings provider instance.
/// </summary>
/// <param name="testService">The test service.</param>
public WebSettingsProvider(TestServiceProvider testService)
: base(testService)
{
}
public TestBaseReportService(TestServiceProvider serviceProvider)
: base(serviceProvider)
{
}
/// <summary>
/// Initializes a new SettingsProvider object.
/// </summary>
/// <param name="testService">The test service.</param>
public SettingsProvider(TestServiceProvider testService)
: this(testService, "Settings")
{
}
/// <summary>
/// Merge any settings provided by a test service with the parameters
/// that were passed inside the TestHarnessSettings.
/// </summary>
/// <param name="testService">The test service.</param>
/// <param name="inputSettings">The run settings.</param>
private static void MergeSettingsAndParameters(TestServiceProvider testService, UnitTestSettings inputSettings)
{
if (testService != null && testService.HasService(TestServiceFeature.RunSettings))
{
SettingsProvider settings = testService.GetService<SettingsProvider>(TestServiceFeature.RunSettings);
foreach (string key in settings.Settings.Keys)
{
if (inputSettings.Parameters.ContainsKey(key))
{
Debug.WriteLine("MergeSettingsAndParameters: Overwriting " + key + " key during merge.");
}
inputSettings.Parameters[key] = settings.Settings[key];
}
}
}
/// <summary>
/// Initializes a new isolated storage settings provider.
/// </summary>
/// <param name="testService">The test service instance.</param>
public IsolatedStorageSettingsProvider(TestServiceProvider testService)
: base(testService, "Isolated Storage Settings")
{
SourceName = "Local application storage";
}
/// <summary>
/// Initializes a new SettingsProvider object.
/// </summary>
/// <param name="testService">The test service.</param>
/// <param name="serviceName">The service name.</param>
public SettingsProvider(TestServiceProvider testService, string serviceName)
: base(testService, serviceName)
{
Settings = new Dictionary<string, string>();
IsReadOnly = true;
}
public IsolatedStorageReportingProvider(TestServiceProvider testService)
: base(testService)
{
}
/// <summary>
/// Initializes a new reporting provider instance.
/// </summary>
/// <param name="testService">The test service.</param>
protected TestReportingProvider(TestServiceProvider testService)
: base(testService, "TestReporting")
{
}
/// <summary>
/// Initializes a new code coverage provider.
/// </summary>
/// <param name="testService">The test service.</param>
public WebCodeCoverageProvider(TestServiceProvider testService)
: base(testService)
{
}
