public void AutomaticallyProvideATestLogAccessor() { using var provider = new DefaultServiceProvider(); var instance = provider.GetService(typeof(ITestLogAccessor)); Assert.IsInstanceOfType(instance, typeof(TestLogAccessor)); }
public void AutomaticallyProvideAScopeFactory() { using var provider = new DefaultServiceProvider(); var instance = provider.GetService(typeof(IServiceScopeFactory)); Assert.IsInstanceOfType(instance, typeof(DefaultServiceProviderScopeFactory)); }
public void AutomaticallyProvideItselfAsAServiceProvider() { using var provider = new DefaultServiceProvider(); var instance = provider.GetService(typeof(IServiceProvider)); Assert.AreSame(provider, instance); }
public void DefaultServiceProvider_Should_Create_AutoRegisteringGraphTypes() { var provider = new DefaultServiceProvider(); provider.GetService(typeof(AutoRegisteringObjectGraphType <Dummy>)).ShouldNotBeNull(); provider.GetService(typeof(AutoRegisteringInputObjectGraphType <Dummy>)).ShouldNotBeNull(); }
public void InstantiateClassesWithPublicConstructorsWithParameters() { using var provider = new DefaultServiceProvider(); var instance = provider.GetService(typeof(PublicConstructorWithParameters)); Assert.IsInstanceOfType(instance, typeof(PublicConstructorWithParameters)); }
public async Task LimitMaximumTestCasesRunInParallel() { var testCasesInProgress = 0; async Task <Microsoft.VisualStudio.TestPlatform.ObjectModel.TestResult> CreateTask(TestCase testCase) { Interlocked.Increment(ref testCasesInProgress); await Task.Yield(); Interlocked.Decrement(ref testCasesInProgress); return(new Microsoft.VisualStudio.TestPlatform.ObjectModel.TestResult(testCase)); } var serviceProvider = new DefaultServiceProvider(); var context = new TestRunContext( serviceProvider, new NullTestLogAccessor()) { MaximumSimultaneousTestCases = 1 }; var mockStepsExecutor = new Mock <IStepsExecutor>(); var testCaseExecutor = new TestCaseExecutor(context, binder => { if (testCasesInProgress > 1) { Assert.Fail(); } return(mockStepsExecutor.Object); }); var testCase1 = new TestCase() { LocalExtensionData = new DiscoveredTestData(Assembly.GetExecutingAssembly(), new MockFeature(), null, new MockScenario()) }; mockStepsExecutor .Setup(m => m.Execute(testCase1, It.IsAny <DiscoveredTestData>(), context, It.IsAny <IMessageLogger>())) .Returns(CreateTask(testCase1)); var testCase2 = new TestCase() { LocalExtensionData = new DiscoveredTestData(Assembly.GetExecutingAssembly(), new MockFeature(), null, new MockScenario()) }; mockStepsExecutor .Setup(m => m.Execute(testCase2, It.IsAny <DiscoveredTestData>(), context, It.IsAny <IMessageLogger>())) .Returns(CreateTask(testCase2)); await testCaseExecutor .RunTestCases( new[] { testCase1, testCase2 }, Mock.Of <IFrameworkHandle>(), CancellationToken.None) .ConfigureAwait(false); }
public static IServiceProvider CreateServiceProvider(Action<IServiceRegister> registerServices) { Preconditions.CheckNotNull(registerServices, "registerServices"); var serviceProvider = new DefaultServiceProvider(); registerServices(serviceProvider); // we only want single instances of these shared services, so instantiate them here var logger = new ConsoleLogger(); var serializer = new JsonSerializer(); var conventions = new Conventions(); // default service registration serviceProvider .Register<IEasyNetQLogger>(x => logger) .Register<ISerializer>(x => serializer) .Register<IConventions>(x => conventions) .Register<SerializeType>(x => TypeNameSerializer.Serialize) .Register<Func<string>>(x => CorrelationIdGenerator.GetCorrelationId) .Register<IClusterHostSelectionStrategy<ConnectionFactoryInfo>>(x => new DefaultClusterHostSelectionStrategy<ConnectionFactoryInfo>()) .Register<IConsumerDispatcherFactory>(x => new ConsumerDispatcherFactory(x.Resolve<IEasyNetQLogger>())) .Register<IConsumerErrorStrategy>(x => new DefaultConsumerErrorStrategy( x.Resolve<IConnectionFactory>(), x.Resolve<ISerializer>(), x.Resolve<IEasyNetQLogger>(), x.Resolve<IConventions>())) .Register<IHandlerRunner>(x => new HandlerRunner( x.Resolve<IEasyNetQLogger>(), x.Resolve<IConsumerErrorStrategy>())) .Register<IInternalConsumerFactory>(x => new InternalConsumerFactory( x.Resolve<IHandlerRunner>(), x.Resolve<IEasyNetQLogger>(), x.Resolve<IConventions>(), x.Resolve<IConnectionConfiguration>(), x.Resolve<IConsumerDispatcherFactory>())) .Register<IConsumerFactory>(x => new ConsumerFactory(x.Resolve<IInternalConsumerFactory>())) .Register<IConnectionFactory>(x => new ConnectionFactoryWrapper( x.Resolve<IConnectionConfiguration>(), x.Resolve<IClusterHostSelectionStrategy<ConnectionFactoryInfo>>())) .Register<IMessageValidationStrategy>(x => new DefaultMessageValidationStrategy( x.Resolve<IEasyNetQLogger>(), x.Resolve<SerializeType>())) .Register<IAdvancedBus>(x => new RabbitAdvancedBus( x.Resolve<IConnectionFactory>(), x.Resolve<SerializeType>(), x.Resolve<ISerializer>(), x.Resolve<IConsumerFactory>(), x.Resolve<IEasyNetQLogger>(), x.Resolve<Func<string>>(), x.Resolve<IMessageValidationStrategy>())) .Register<IBus>(x => new RabbitBus( x.Resolve<SerializeType>(), x.Resolve<IEasyNetQLogger>(), x.Resolve<IConventions>(), x.Resolve<IAdvancedBus>() )); return serviceProvider; }
public void SetUp() { serviceProvider = new DefaultServiceProvider(); serviceProvider.Register<IRoot, Root>(); serviceProvider.Register<IChild, Child>(); serviceProvider.Register<IGrandChild, GrandChild>(); }
public void NotInstantiateClassesWithNonPublicParameterlessConstructors() { using (var provider = new DefaultServiceProvider()) { Assert.ThrowsException <MissingMethodException>( () => provider.GetService(typeof(ProtectedParameterlessConstructor))); } }
public void GetDefaultLogger_DefaultLoggerInstanceReturned() { DefaultServiceProvider provider = new DefaultServiceProvider(); var results = provider.GetLogger(); Assert.IsNotNull(results, "Should have default"); Assert.IsInstanceOfType(results, typeof(DefaultConsoleLogger)); }
public void SetUp() { serviceProvider = new DefaultServiceProvider(); serviceProvider.Register <IRoot, Root>(); serviceProvider.Register <IChild, Child>(); serviceProvider.Register <IGrandChild, GrandChild>(); }
public DefaultServiceProviderTestsX() { serviceProvider = new DefaultServiceProvider(); serviceProvider.Register <IRoot, Root>(); serviceProvider.Register <IChild, Child>(); serviceProvider.Register <IGrandChild, GrandChild>(); }
public void GetDefaultCache_DefaultCacheInstanceReturned() { DefaultServiceProvider provider = new DefaultServiceProvider(); var results = provider.GetConfigCache(); Assert.IsNotNull(results, "Should have default"); Assert.IsInstanceOfType(results, typeof(DefaultConfigMemCache)); }
public void GetDefaultDataStore_ConnectionStringNotInConfig_InAnotherCastleInvalidConfigurationThrown() { var config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None); config.ConnectionStrings.ConnectionStrings.Clear(); config.Save(); ConfigurationManager.RefreshSection("connectionStrings"); DefaultServiceProvider provider = new DefaultServiceProvider(); var results = provider.GetStorage(); }
public static TService Service <TService>() where TService : class { if (typeof(TService) == typeof(ISessionManager)) { return(Instance._sessionManager as TService); } if (typeof(TService) == typeof(IDataManager)) { return(Instance._dataManager as TService); } return(DefaultServiceProvider.GetDefaultProvider <TService>(typeof(StoreKeeperServer))); }
public void ReturnInstancesFromParentScopeIfInstantiatedThere() { using var outerProvider = new DefaultServiceProvider(); var outerInstance = outerProvider.GetService(typeof(PublicParameterlessConstructor)); var scopeFactory = (IServiceScopeFactory)outerProvider.GetService(typeof(IServiceScopeFactory)); using var scope = scopeFactory.CreateScope(); var innerInstance = scope.ServiceProvider.GetService(typeof(PublicParameterlessConstructor)); Assert.AreSame(outerInstance, innerInstance); }
public void SetUp() { myFirst = MockRepository.GenerateStub <IMyFirst>(); someDelegate = () => { }; var defaultServiceProvider = new DefaultServiceProvider(); defaultServiceProvider.Register(x => myFirst); defaultServiceProvider.Register(x => someDelegate); defaultServiceProvider.Register <IMySecond>(x => new MySecond(x.Resolve <IMyFirst>())); serviceProvider = defaultServiceProvider; }
public DefaultServiceProviderTests() { myFirst = Substitute.For <IMyFirst>(); someDelegate = () => { }; var defaultServiceProvider = new DefaultServiceProvider(); defaultServiceProvider.Register(x => myFirst); defaultServiceProvider.Register(x => someDelegate); defaultServiceProvider.Register <IMySecond>(x => new MySecond(x.Resolve <IMyFirst>())); serviceProvider = defaultServiceProvider; }
private async Task RunTestCases(IEnumerable <TestCase> mappedTests, IFrameworkHandle frameworkHandle) { using var defaultServiceProvider = new DefaultServiceProvider(); var testRunContext = defaultServiceProvider.GetService <TestRunContext>(); var testCaseExecutor = new TestCaseExecutor( testRunContext, stepsBinder => new StepsExecutor(stepsBinder)); await testCaseExecutor .RunTestCases(mappedTests, frameworkHandle, cancellationTokenSource.Token) .ConfigureAwait(false); }
public void SetUp() { myFirst = MockRepository.GenerateStub<IMyFirst>(); someDelegate = () => { }; var defaultServiceProvider = new DefaultServiceProvider(); defaultServiceProvider.Register(x => myFirst); defaultServiceProvider.Register(x => someDelegate); defaultServiceProvider.Register<IMySecond>(x => new MySecond(x.Resolve<IMyFirst>())); serviceProvider = defaultServiceProvider; }
public SchemaTypes_Test_Cannot_Initialize_More_Than_Once() { var serviceProvider = new DefaultServiceProvider(); var schema = new Schema(serviceProvider) { Query = new ObjectGraphType() }; schema.Query.AddField(new FieldType { Name = "field1", Type = typeof(IntGraphType) }); Initialize(schema, serviceProvider, null); Should.Throw <InvalidOperationException>(() => Initialize(schema, serviceProvider, null)); }
public static T Service <T>() where T : class { if (typeof(T) == typeof(IResourceProvider)) { return(Instance as T); } if (typeof(T) == typeof(ILocalizationProvider)) { return(Instance._localizationProvider as T); } T service = Instance.GetService <T>(); return(service ?? DefaultServiceProvider.GetDefaultProvider <T>(typeof(ResourceLibrary))); }
public void GetDefaultDataStore_DefaultDataStoreInstanceReturned() { DefaultServiceProvider provider = new DefaultServiceProvider(); var config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None); config.ConnectionStrings.ConnectionStrings.Clear(); //Ensure that connection is present config.ConnectionStrings.ConnectionStrings.Add(new ConnectionStringSettings(DefaultServiceProvider.ConnectionStringKey, "Server=LocalHost;Database=MyTests;Trusted_Connection=True;MultipleActiveResultSets=true;", "System.Data.SqlClient")); config.Save(); ConfigurationManager.RefreshSection("connectionStrings"); var results = provider.GetStorage(); Assert.IsNotNull(results, "Should have default"); Assert.IsInstanceOfType(results, typeof(ConfigurationStorage)); }
private void RegisterServiceProvider <TService>(Assembly[] assemblies) { var types = GetTypes <TService>(assemblies); // Register service provider var serviceProvider = new DefaultServiceProvider <TService>(_container, types); _serviceProviders.Add(serviceProvider); _container.Register(Component.For(typeof(IServiceProvider <TService>)). Instance(serviceProvider)); // Register types themselves foreach (var type in types) { _container.Register(Component.For(type.Item2)); } }
private void RunMappedTests(IEnumerable <TestCase> mappedTests, IFrameworkHandle frameworkHandle) { frameworkHandle.SendMessage(TestMessageLevel.Informational, "Running tests"); using (var defaultServiceProvider = new DefaultServiceProvider()) { var testRunContext = (TestRunContext)defaultServiceProvider.GetService( typeof(TestRunContext)); var runHooks = new RunHooks( testRunContext, mappedTests .Select( test => test .DiscoveredData() .Assembly) .Distinct()); runHooks.ExecuteBeforeRun().Wait(); var stepBinder = new StepBinder(); var tasks = new List <Task>(); foreach (var testCase in mappedTests) { if (isCancelling) { frameworkHandle.SendMessage(TestMessageLevel.Informational, "Test run cancelled"); break; } if (testCase.DiscoveredData().IsIgnored) { testCase.MarkAsSkipped(frameworkHandle); continue; } tasks.Add( RunMappedTest(testCase, testCase.DiscoveredData(), testRunContext, stepBinder, frameworkHandle)); } Task.WhenAll(tasks).Wait(); runHooks.ExecuteAfterRun().Wait(); } }
public static IServiceProvider CreateServiceProvider(Action<IServiceRegister> registerServices) { Preconditions.CheckNotNull(registerServices, "registerServices"); var serviceProvider = new DefaultServiceProvider(); // gives the user a chance to register alternative service implementations. registerServices(serviceProvider); // Note: IConnectionConfiguration gets registered when RabbitHutch.CreateBus(..) is run. // default service registration serviceProvider .Register<IEasyNetQLogger, ConsoleLogger>() .Register<ISerializer, JsonSerializer>() .Register<IConventions, Conventions>() .Register<IEventBus, EventBus>() .Register<ITypeNameSerializer, TypeNameSerializer>() .Register<Func<string>>(x => CorrelationIdGenerator.GetCorrelationId) .Register<IClusterHostSelectionStrategy<ConnectionFactoryInfo>, DefaultClusterHostSelectionStrategy<ConnectionFactoryInfo>>() .Register<IConsumerDispatcherFactory, ConsumerDispatcherFactory>() .Register<IPublishExchangeDeclareStrategy, PublishExchangeDeclareStrategy>() .Register<IPublisherConfirms, PublisherConfirms>() .Register<IConsumerErrorStrategy, DefaultConsumerErrorStrategy>() .Register<IHandlerRunner, HandlerRunner>() .Register<IInternalConsumerFactory, InternalConsumerFactory>() .Register<IConsumerFactory, ConsumerFactory>() .Register<IConnectionFactory, ConnectionFactoryWrapper>() .Register<IPersistentChannelFactory, PersistentChannelFactory>() .Register<IClientCommandDispatcherFactory, ClientCommandDispatcherFactory>() .Register<IHandlerCollectionFactory, HandlerCollectionFactory>() .Register<IAdvancedBus, RabbitAdvancedBus>() .Register<IRpc, Rpc>() .Register<ISendReceive, SendReceive>() .Register<IBus, RabbitBus>(); return serviceProvider; }
private void listView_DetailTextures_DoubleClick(object sender, EventArgs e) { if (TerrainEditor.CurrentDetailTexture == null) return; if (TerrainEditor.CurrentTerrain == null || TerrainEditor.CurrentTerrain.IsReference || !TerrainEditor.CurrentTerrain.Modifiable) return; // open the UI editor from outside the property grid PropertyDescriptor pd = TypeDescriptor.GetProperties(TerrainEditor.CurrentTerrain)["DetailTextures"]; TypedCollectionEditor editor = (TypedCollectionEditor)pd.GetEditor(typeof(UITypeEditor)); DefaultServiceProvider serviceProvider = new DefaultServiceProvider(TerrainEditor.CurrentTerrain, pd); ArrayList oldArray = TerrainEditor.CurrentTerrain.DetailTextures; ArrayList newArray = ArrayListHelper.ShallowClone(oldArray); DetailTextureResource.AllowUpdate = false; // temporarily disable ArrayList newArrayRes = (ArrayList)editor.EditValue(serviceProvider, serviceProvider, newArray); DetailTextureResource.AllowUpdate = true; DialogResult res = editor.UsedCollectionForm.DialogResult; if (res != DialogResult.OK) // abort? return; if (newArrayRes.Count < 1 || !((DetailTextureResource)newArrayRes[0])._bIsBaseTexture) { EditorManager.ShowMessageBox(this, "Cannot remove or change order of base texture", "Changing detail textures failed", MessageBoxButtons.OK, MessageBoxIcon.Error); return; } EditorManager.Actions.Add(new NewDetailTextureCollectionAction(TerrainEditor.CurrentTerrain, oldArray, newArrayRes)); }
public InProcessStrategyConfig() { ServiceProvider = new DefaultServiceProvider(); }
public UnitTestBase() { connection = new SqliteConnection("Data Source=:memory:;"); connection.Open(); serviceProvider = new DefaultServiceProvider(); }
public static TService Service <TService>() where TService : class { TService service = Instance.GetService <TService>(); return(service ?? DefaultServiceProvider.GetDefaultProvider <TService>(Instance.GetType())); }