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()));
}
