public void Setup() { _dependencyManager = new DependencyManager(); _dependencyManager.ConfigureStartupDependencies(); _customLogger = _dependencyManager.Container.GetInstance<ICustomLogger>(); }
public void ResolveSafeExecutionHelper_FromStartupDependencies_DefinedinBootstrapperRegistries() { using ( var safeExecutionHelper = new DependencyManager().ConfigureStartupDependencies(ContainerType.Nested) .GetInstance<SafeExecutionHelper>()) { Assert.Throws<CustomException<ResolveSafeExecutionHelperTestExceptionArgs>>( () => safeExecutionHelper.ExecuteSafely<Exception>(ExceptionPolicy.RethrowException, () => { Console.WriteLine("Hello"); throw new Exception(); }, (ex, log) => { log.Error("There was an error, it has been logged : \n" + ex.Message); throw new CustomException<ResolveSafeExecutionHelperTestExceptionArgs>( new ResolveSafeExecutionHelperTestExceptionArgs()); })); safeExecutionHelper.ExecuteSafely<NullReferenceException>(ExceptionPolicy.SwallowException, () => { Console.WriteLine(""); throw new NullReferenceException(); }, (ex, log) => log.Error(ex.Message)); } }
public void ResolveController_UsingDependencyManager_GetType() { var container = new DependencyManager().ConfigureStartupDependencies(); var messageBusController = container.GetInstance<MessageBusController>(); messageBusController.SendMessage("HelloWorldCommand", new TaskRunnerPropertyModel {Id = "1", Name = "Text", Value = "Hello"}, new TaskRunnerPropertyModel {Id = "2", Name = "Count", Value = "1123"}); }
public void IoCContainerTests_Nested_Vs_Standard() { using (var container = new DependencyManager().ConfigureStartupDependencies(ContainerType.Nested)) { var customLogger = container.GetInstance<ICustomLogger>(); customLogger.Info("Atomically created logger as Container is a nested Container!"); } }
public void CustomContainer_Add_NoInitialize() { var dependencyManager = new DependencyManager(); dependencyManager.ConfigureStartupDependencies(); var customLogger = dependencyManager.Container.GetInstance<ICustomLogger>(); customLogger.Info("Test"); Assert.True(customLogger != null); }
public void SetUp() { var dependencyManager = new DependencyManager(); dependencyManager.ConfigureStartupDependencies(); var logger = dependencyManager.Container.GetInstance<ICustomLogger>(); ReflectorApiMock = new ReflectorApiMock("username", "password", logger); }
public void Setup() { using ( var customLogger = new DependencyManager().ConfigureStartupDependencies(ContainerType.Nested) .GetInstance<ICustomLogger>()) { _safeExecutionHelper = new SafeExecutionHelper(customLogger); } }
protected override void OnStart(string[] args) { _dependencyManager = new DependencyManager(); _dependencyManager.AddRegistries<Registry>(new QuartzRegistry(_dependencyManager.Container)); new OnewayRhinoServiceBusConfiguration() .UseStructureMap(_dependencyManager.Container) .Configure(); _customLogger.Info("Started scheduler service.."); }
public void SetUp() { var container = new DependencyManager().ConfigureStartupDependencies(); MessageType = typeof (HelloWorldCommand); Manager = new ServiceBusModelBuilder(new TaskRunnerReflector(), @"C:\Users\smarkey\Documents\GitHub\LayeredArchitecture\Miscellaneous\SharedDlls\TaskRunner.Common.dll"); Controller = new MessageBusController(Manager, container.GetInstance<ICustomLogger>(), new MessageBusManager(new Client<IOnewayBus>(container))); }
public IController CreateController(RequestContext requestContext, string controllerName) { if (controllerName.ToUpper().StartsWith("MessageBus".ToUpper())) { var container = new DependencyManager().ConfigureStartupDependencies(); var controller = new MessageBusController(new ServiceBusModelBuilder(new TaskRunnerReflector(), @"C:\Users\smarkey\Documents\GitHub\LayeredArchitecture\Miscellaneous\SharedDlls\TaskRunner.Common.dll "), container.GetInstance<ICustomLogger>(), new MessageBusManager(new Client<IOnewayBus>(container))); return controller; } return new DefaultControllerFactory().CreateController(requestContext, controllerName); }
public void ShouldAddResolution1Test() { DependencyManager dependencyManager; Mockery mockery; IDependencyResolution mockDependencyResolution; string selectorKey; mockery = new Mockery(); mockDependencyResolution = mockery.NewMock<IDependencyResolution>(); dependencyManager = new DependencyManager(); selectorKey = "x"; dependencyManager.AddResolution<object>(selectorKey, mockDependencyResolution); mockery.VerifyAllExpectationsHaveBeenMet(); }
private RunList<StepDescriptor> BuildRunlist(CodeModelBuilder modelBuilder, string[] finalResources) { var mutators = AppDomain.CurrentDomain.GetAssemblies() .SelectMany(x => x.GetTypes()) .Where(x => typeof(IMutator).IsAssignableFrom(x) && x.IsClass && !x.IsAbstract) .Select(x => new MutatorStepDescriptor(modelBuilder, x)); var finalResourcesStep = new RequiredResources(finalResources); var dependencyNetwork = new DependencyManager<StepDescriptor>(x => x.Provides, x => x.Needs, x => x.OptionalNeeds); dependencyNetwork.AddRange(mutators); dependencyNetwork.Add(finalResourcesStep); dependencyNetwork.RequireElements(finalResourcesStep); return dependencyNetwork.CalculateRunList(); }
public void ShouldAddResolutionTest() { DependencyManager dependencyManager; Mockery mockery; IDependencyResolution mockDependencyResolution; Type targetType; string selectorKey; mockery = new Mockery(); mockDependencyResolution = mockery.NewMock<IDependencyResolution>(); dependencyManager = new DependencyManager(); targetType = typeof(object); selectorKey = "x"; dependencyManager.AddResolution(targetType, selectorKey, mockDependencyResolution); mockery.VerifyAllExpectationsHaveBeenMet(); }
public void ShouldFailOnDisposedRemoveResolution1Test() { DependencyManager dependencyManager; Mockery mockery; IDependencyResolution mockDependencyResolution; string selectorKey; mockery = new Mockery(); mockDependencyResolution = mockery.NewMock<IDependencyResolution>(); dependencyManager = new DependencyManager(); selectorKey = "x"; dependencyManager.Dispose(); dependencyManager.RemoveResolution<object>(selectorKey); }
public void CleanStorageCache() { Storage.Dispose(); Storage = DependencyManager.Resolve <DataContext>(); }
public FluentTarget() : this(DependencyManager.GetService <IDependencyResolver>(), DependencyManager.GetService <IMetaModelRepository>()) { }
public void WriteDependencies(Action <string> callback) { DependencyManager.WriteDependencies(Value, callback); }
public virtual IObjectBinder GetBinder(IMember parameterInfo) { return((IObjectBinder)DependencyManager.GetService(Type)); }
public static WeixinServiceRegister AddMpService(this WeixinServiceRegister serviceRegister) { DependencyManager.Register <IAccessTokenStoreService, DefaultAccessTokenStoreService>(); return(serviceRegister); }
public T GetDependency <T>() { return(DependencyManager.GetInstance <T>()); }
private void resetVariables() { playlists = DependencyManager.Resolve <IYouTubePlaylists>(); playlistVideos = DependencyManager.Resolve <IYouTubeVideos>(); }
protected override void TearDown() { RequestScope.Dispose(); DependencyManager.UnsetResolver(); }
// ReSharper disable once MemberHidesStaticFromOuterClass internal static void ShutDown() { Reset(int.MaxValue); DependencyManager.ShutDown(); }
/// <summary> /// Registering types with using Autofac /// </summary> /// <param name="builder"></param> public override void ConfigureContainer(ContainerBuilder builder) { base.ConfigureContainer(builder); DependencyManager.ConfigureContainer(builder); }
/// <summary> /// Add services to IoC. /// </summary> /// <param name="services"></param> public override void ConfigureServices(IServiceCollection services) { base.ConfigureServices(services); DependencyManager.ConfigureServices(Configuration, services); }
static HostManager() { Log = DependencyManager.IsAvailable ? DependencyManager.GetService <ILogger>() : new TraceSourceLogger(); }
public void ShouldCheckIfHasResolution1Test() { DependencyManager dependencyManager; Mockery mockery; IDependencyResolution mockDependencyResolution; IDisposable mockDisposable; string selectorKey; bool result; mockery = new Mockery(); mockDependencyResolution = mockery.NewMock<IDependencyResolution>(); mockDisposable = mockery.NewMock<IDisposable>(); dependencyManager = new DependencyManager(); result = dependencyManager.HasTypeResolution<IDisposable>(null); Assert.IsFalse(result); result = dependencyManager.HasTypeResolution<IDisposable>(""); Assert.IsFalse(result); result = dependencyManager.HasTypeResolution<IDisposable>("x"); Assert.IsFalse(result); selectorKey = "x"; dependencyManager.AddResolution<IDisposable>(selectorKey, mockDependencyResolution); result = dependencyManager.HasTypeResolution<IDisposable>(null); Assert.IsTrue(result); result = dependencyManager.HasTypeResolution<IDisposable>(""); Assert.IsFalse(result); result = dependencyManager.HasTypeResolution<IDisposable>("x"); Assert.IsTrue(result); dependencyManager.ClearAllResolutions(); result = dependencyManager.HasTypeResolution<IDisposable>(null); Assert.IsFalse(result); result = dependencyManager.HasTypeResolution<IDisposable>(""); Assert.IsFalse(result); result = dependencyManager.HasTypeResolution<IDisposable>("x"); Assert.IsFalse(result); selectorKey = ""; dependencyManager.AddResolution<IDisposable>(selectorKey, mockDependencyResolution); result = dependencyManager.HasTypeResolution<IDisposable>(null); Assert.IsTrue(result); result = dependencyManager.HasTypeResolution<IDisposable>(""); Assert.IsTrue(result); result = dependencyManager.HasTypeResolution<IDisposable>("x"); Assert.IsFalse(result); mockery.VerifyAllExpectationsHaveBeenMet(); }
private void Awake() { DependencyManager.AddDependency <LeaderBoard>(this); }
public static void Start() { var container = new DependencyManager().ConfigureStartupDependencies(); DependencyResolver.SetResolver(new StructureMapDependencyResolver(container)); GlobalConfiguration.Configuration.DependencyResolver = new StructureMapDependencyResolver(container); }
public void ShouldFailOnNotAssignableResolveDependencyTest() { DependencyManager dependencyManager; Mockery mockery; IDependencyResolution mockDependencyResolution; Type targetType; string selectorKey; object value; mockery = new Mockery(); mockDependencyResolution = mockery.NewMock<IDependencyResolution>(); Expect.Once.On(mockDependencyResolution).Method("Resolve").WithNoArguments().Will(Return.Value(1)); dependencyManager = new DependencyManager(); targetType = typeof(IDisposable); selectorKey = "yyy"; dependencyManager.AddResolution(targetType, selectorKey, mockDependencyResolution); value = dependencyManager.ResolveDependency<IDisposable>(selectorKey); }
protected override void TearDown() { base.TearDown(); DependencyManager.UnsetResolver(); }
public void ShouldFailOnNullDependencyResolutionAddResolutionTest() { DependencyManager dependencyManager; Mockery mockery; IDependencyResolution mockDependencyResolution; Type targetType; string selectorKey; mockery = new Mockery(); mockDependencyResolution = null; dependencyManager = new DependencyManager(); targetType = typeof(object); selectorKey = "x"; dependencyManager.AddResolution(targetType, selectorKey, mockDependencyResolution); }
public static WeixinServiceRegister AddAccessTokenStore <T>(this WeixinServiceRegister serviceRegister) where T : class, IAccessTokenStoreService { DependencyManager.Register <IAccessTokenStoreService, T>(); return(serviceRegister); }
protected void Application_Start() { AreaRegistration.RegisterAllAreas(); RouteConfig.RegisterRoutes(RouteTable.Routes); DependencyManager.Initialize(); }
public IAssemblyLoader Create(NuGetFramework runtimeFramework, IAssemblyLoadContextAccessor loadContextAccessor, DependencyManager dependencies) { return(new PackageAssemblyLoader( runtimeFramework, loadContextAccessor, dependencies.GetLibraries(LibraryTypes.Package), _packagePathResolver)); }
public AppInfoService() { _appInfoRepository = DependencyManager.Resolve <IAppInfoRepository>(); }
public void ShouldFailOnNullKeyResolveDependency1Test() { DependencyManager dependencyManager; Mockery mockery; IDependencyResolution mockDependencyResolution; string selectorKey; object value; mockery = new Mockery(); mockDependencyResolution = mockery.NewMock<IDependencyResolution>(); dependencyManager = new DependencyManager(); selectorKey = null; value = dependencyManager.ResolveDependency<object>(selectorKey); }
public BaseApi() { this.Logger = DependencyManager.Resolve <ILogger>(); this.HttpService = DependencyManager.Resolve <IHttpService>(); this.ServerHostConfig = DependencyManager.Resolve <WeixinServerHostConfig>(); }
public static Uri CreateUri(this object target, string uriName, object additionalProperties) => target.CreateUri(DependencyManager.GetService <ICommunicationContext>().ApplicationBaseUri, uriName, additionalProperties);
public void ShouldFailOnNullTypeCheckIfHasResolutionTest() { DependencyManager dependencyManager; Mockery mockery; IDependencyResolution mockDependencyResolution; Type targetType; mockery = new Mockery(); mockDependencyResolution = mockery.NewMock<IDependencyResolution>(); dependencyManager = new DependencyManager(); targetType = null; dependencyManager.HasTypeResolution(targetType, null); }
public void ShouldFailOnDisposedClearTypeResolutionsTest() { DependencyManager dependencyManager; Mockery mockery; IDependencyResolution mockDependencyResolution; Type targetType; bool result; mockery = new Mockery(); mockDependencyResolution = mockery.NewMock<IDependencyResolution>(); dependencyManager = new DependencyManager(); targetType = typeof(object); dependencyManager.Dispose(); result = dependencyManager.ClearTypeResolutions(targetType); }
public void ShouldFailOnNullTypeResolveDependencyTest() { DependencyManager dependencyManager; Mockery mockery; IDependencyResolution mockDependencyResolution; Type targetType; string selectorKey; object value; mockery = new Mockery(); mockDependencyResolution = mockery.NewMock<IDependencyResolution>(); dependencyManager = new DependencyManager(); targetType = null; selectorKey = "x"; value = dependencyManager.ResolveDependency(targetType, selectorKey); }
/// <summary>Only for tests</summary> internal static void _setCurrentExecutionState(CompletionState state) { Serializer.Reset(state.LastActivityId); DependencyManager.Reset(); TerminationHistory.Reset(state.LastActivityId, state.Gaps); }
protected virtual void HandleIncomingRequestProcessed(object sender, IncomingRequestProcessedEventArgs e) { using (DependencyManager.ScopedResolver(Resolver)) ((IDisposable)e.Context.PipelineData[Keys.Request.ResolverRequestScope]).Dispose(); }
public void ShouldFailOnNullDependencyResolutionAddResolution1Test() { DependencyManager dependencyManager; Mockery mockery; IDependencyResolution mockDependencyResolution; string selectorKey; mockery = new Mockery(); mockDependencyResolution = null; dependencyManager = new DependencyManager(); selectorKey = "x"; dependencyManager.AddResolution<object>(selectorKey, mockDependencyResolution); }
/// <summary> /// MUST BE SYNCHRON /// GAPS MUST BE ORDERED /// </summary> internal static void Start(int lastDatabaseId, int lastExecutedId, int[] gaps, System.IO.TextWriter consoleOut) { if (consoleOut != null) { consoleOut.WriteLine("Executing unprocessed activities. {0}-{1} {2}", lastExecutedId, lastDatabaseId, CompletionState.GapsToString(gaps, 5, 3)); } SnLog.WriteInformation("Executing unprocessed activities.", EventId.RepositoryRuntime, properties: new Dictionary <string, object> { { "LastDatabaseId", lastDatabaseId }, { "LastExecutedId", lastExecutedId }, { "CountOfGaps", gaps.Length }, { "Gaps", String.Join(", ", gaps) } }); DependencyManager.Start(); var count = 0; if (gaps.Any()) { var loadedActivities = new IndexingActivityLoader(gaps, true); foreach (LuceneIndexingActivity loadedActivity in loadedActivities) { // wait and start processing loaded activities in the meantime WaitIfOverloaded(true); SnTrace.IndexQueue.Write("IAQ: Startup: A{0} enqueued from db.", loadedActivity.Id); IndexingActivityHistory.Arrive(loadedActivity); _arrivalQueue.Enqueue(loadedActivity); _lastQueued = loadedActivity.Id; count++; } } if (lastExecutedId < lastDatabaseId) { var loadedActivities = new IndexingActivityLoader(lastExecutedId + 1, lastDatabaseId, true); foreach (LuceneIndexingActivity loadedActivity in loadedActivities) { // wait and start processing loaded activities in the meantime WaitIfOverloaded(true); SnTrace.IndexQueue.Write("IAQ: Startup: A{0} enqueued from db.", loadedActivity.Id); IndexingActivityHistory.Arrive(loadedActivity); _arrivalQueue.Enqueue(loadedActivity); _lastQueued = loadedActivity.Id; count++; } } if (_lastQueued < lastExecutedId) { _lastQueued = lastExecutedId; } // ensure that the arrival activity queue is not empty at this pont. DependencyManager.ActivityEnqueued(); if (lastDatabaseId != 0 || lastExecutedId != 0 || gaps.Any()) { while (IsWorking()) { Thread.Sleep(200); } } // At this point we know for sure that the original gap is not there anymore. // In case there is a false gap (e.g. because there are missing activity ids // in the db) we have to remove these ids manually from the in-memory gap. if (gaps.Any()) { TerminationHistory.RemoveGaps(gaps); // Commit is necessary because otherwise the gap is removed only in memory, but // the index is not updated in the file system. LuceneManager.Commit(); } SnLog.WriteInformation($"Executing unprocessed activities ({count}) finished.", EventId.RepositoryLifecycle); }
public void ShouldFailOnNullKeyAddResolution1Test() { DependencyManager dependencyManager; Mockery mockery; IDependencyResolution mockDependencyResolution; string selectorKey; mockery = new Mockery(); mockDependencyResolution = mockery.NewMock<IDependencyResolution>(); Expect.Once.On(mockDependencyResolution).Method("Resolve").WithNoArguments().Will(Return.Value(null)); dependencyManager = new DependencyManager(); selectorKey = null; dependencyManager.AddResolution<object>(selectorKey, mockDependencyResolution); }
public static void EnqueueActivity(LuceneIndexingActivity activity) { SnTrace.IndexQueue.Write("IAQ: A{0} arrived{1}. {2}, {3}", activity.Id, activity.FromReceiver ? " from another computer" : "", activity.GetType().Name, activity.Path); IndexingActivityHistory.Arrive(activity); lock (_arrivalQueueLock) { if (activity.Id <= _lastQueued) { var sameActivity = _arrivalQueue.FirstOrDefault(a => a.Id == activity.Id); if (sameActivity != null) { sameActivity.Attach(activity); SnTrace.IndexQueue.Write("IAQ: A{0} attached to another one in the queue", activity.Id); return; } DependencyManager.AttachOrFinish(activity); return; } if (activity.Id > _lastQueued + 1) { var from = _lastQueued + 1; var to = activity.Id - 1; var expectedCount = to - from + 1; var loadedActivities = Retrier.Retry <IEnumerable <IIndexingActivity> >( 3, 100, () => LoadActivities(from, to), (r, i, e) => { if (i < 3) { SnTrace.IndexQueue.Write("IAQ: Loading attempt {0}", 4 - i); } if (e != null) { return(false); } return(r.Count() == expectedCount); }); foreach (LuceneIndexingActivity loadedActivity in loadedActivities) { IndexingActivityHistory.Arrive(loadedActivity); _arrivalQueue.Enqueue(loadedActivity); _lastQueued = loadedActivity.Id; SnTrace.IndexQueue.Write("IAQ: A{0} enqueued from db.", loadedActivity.Id); DependencyManager.ActivityEnqueued(); } } _arrivalQueue.Enqueue(activity); _lastQueued = activity.Id; SnTrace.IndexQueue.Write("IAQ: A{0} enqueued.", activity.Id); DependencyManager.ActivityEnqueued(); } }
public void ShouldFailOnNullKeyRemoveResolutionTest() { DependencyManager dependencyManager; Mockery mockery; IDependencyResolution mockDependencyResolution; Type targetType; string selectorKey; mockery = new Mockery(); mockDependencyResolution = mockery.NewMock<IDependencyResolution>(); dependencyManager = new DependencyManager(); targetType = typeof(object); selectorKey = null; dependencyManager.RemoveResolution(targetType, selectorKey); }
/// <summary> /// Method to process a FunctionLoadRequest. /// FunctionLoadRequest should be processed sequentially. There is no point to process FunctionLoadRequest /// concurrently as a FunctionApp doesn't include a lot functions in general. Having this step sequential /// will make the Runspace-level initialization easier and more predictable. /// </summary> internal StreamingMessage ProcessFunctionLoadRequest(StreamingMessage request) { var stopwatch = new Stopwatch(); stopwatch.Start(); FunctionLoadRequest functionLoadRequest = request.FunctionLoadRequest; StreamingMessage response = NewStreamingMessageTemplate( request.RequestId, StreamingMessage.ContentOneofCase.FunctionLoadResponse, out StatusResult status); response.FunctionLoadResponse.FunctionId = functionLoadRequest.FunctionId; // The worker may occasionally receive multiple function load requests with // the same FunctionId. In order to make function load request idempotent, // the worker should ignore the duplicates. if (FunctionLoader.IsLoaded(functionLoadRequest.FunctionId)) { // If FunctionLoader considers this function loaded, this means // the previous request was successful, so respond accordingly. return(response); } // When a functionLoadRequest comes in, we check to see if a dependency download has failed in a previous call // or if PowerShell could not be initialized. If this is the case, mark this as a failed request // and submit the exception to the Host (runtime). if (_initTerminatingError != null) { status.Status = StatusResult.Types.Status.Failure; status.Exception = _initTerminatingError.ToRpcException(); return(response); } // Ideally, the initialization should happen when processing 'WorkerInitRequest', however, the 'WorkerInitRequest' // message doesn't provide information about the FunctionApp. That information is not available until the first // 'FunctionLoadRequest' comes in. Therefore, we run initialization here. // Also, we receive a FunctionLoadRequest when a proxy is configured. Proxies don't have the Metadata.Directory set // which would cause initialization issues with the PSModulePath. Since they don't have that set, we skip over them. if (!_isFunctionAppInitialized && !functionLoadRequest.Metadata.IsProxy) { try { _isFunctionAppInitialized = true; var rpcLogger = new RpcLogger(_msgStream); rpcLogger.SetContext(request.RequestId, null); _dependencyManager = new DependencyManager(request.FunctionLoadRequest.Metadata.Directory, logger: rpcLogger); var managedDependenciesPath = _dependencyManager.Initialize(request, rpcLogger); SetupAppRootPathAndModulePath(functionLoadRequest, managedDependenciesPath); _powershellPool.Initialize(_firstPwshInstance); // Start the download asynchronously if needed. _dependencyManager.StartDependencyInstallationIfNeeded(request, _firstPwshInstance, rpcLogger); rpcLogger.Log(isUserOnlyLog: false, LogLevel.Trace, string.Format(PowerShellWorkerStrings.FirstFunctionLoadCompleted, stopwatch.ElapsedMilliseconds)); } catch (Exception e) { // Failure that happens during this step is terminating and we will need to return a failure response to // all subsequent 'FunctionLoadRequest'. Cache the exception so we can reuse it in future calls. _initTerminatingError = e; status.Status = StatusResult.Types.Status.Failure; status.Exception = e.ToRpcException(); return(response); } } try { // Load the metadata of the function. FunctionLoader.LoadFunction(functionLoadRequest); } catch (Exception e) { status.Status = StatusResult.Types.Status.Failure; status.Exception = e.ToRpcException(); } return(response); }
public void ShouldFailOnNullTypeAddResolutionTest() { DependencyManager dependencyManager; Mockery mockery; IDependencyResolution mockDependencyResolution; Type targetType; string selectorKey; mockery = new Mockery(); mockDependencyResolution = mockery.NewMock<IDependencyResolution>(); Expect.Once.On(mockDependencyResolution).Method("Resolve").WithNoArguments().Will(Return.Value(null)); dependencyManager = new DependencyManager(); targetType = null; selectorKey = "x"; dependencyManager.AddResolution(targetType, selectorKey, mockDependencyResolution); }
public void AddBinding <TInterface, TImplementation>() where TImplementation : TInterface { //_kernel.Bind<TInterface>().To<TImplementation>(); DependencyManager.Register <TInterface>(typeof(TImplementation)); }
public void ShouldFailOnNullTypeClearTypeResolutionsTest() { DependencyManager dependencyManager; Mockery mockery; IDependencyResolution mockDependencyResolution; Type targetType; mockery = new Mockery(); mockDependencyResolution = mockery.NewMock<IDependencyResolution>(); dependencyManager = new DependencyManager(); targetType = null; dependencyManager.ClearTypeResolutions(targetType); }
public T GetInstance <T>() { return(DependencyManager.Get <T>()); //return _kernel.Get<T>(); }
public void ShouldNotFailOnDoubleDisposedAddResolution1Test() { DependencyManager dependencyManager; Mockery mockery; IDependencyResolution mockDependencyResolution; mockery = new Mockery(); mockDependencyResolution = mockery.NewMock<IDependencyResolution>(); dependencyManager = new DependencyManager(); Assert.IsFalse(dependencyManager.Disposed); dependencyManager.Dispose(); Assert.IsTrue(dependencyManager.Disposed); dependencyManager.Dispose(); Assert.IsTrue(dependencyManager.Disposed); mockery.VerifyAllExpectationsHaveBeenMet(); }
public T GetSingletonInstance <T>() { return(DependencyManager.Get <T>(DependencyType.Singleton)); }
public void ShouldResolveDependencyTest() { DependencyManager dependencyManager; Mockery mockery; IDependencyResolution mockDependencyResolution; Type targetType; string selectorKey; object value; mockery = new Mockery(); mockDependencyResolution = mockery.NewMock<IDependencyResolution>(); Expect.Once.On(mockDependencyResolution).Method("Resolve").WithNoArguments().Will(Return.Value(1)); dependencyManager = new DependencyManager(); targetType = typeof(object); selectorKey = "x"; dependencyManager.AddResolution(targetType, selectorKey, mockDependencyResolution); value = dependencyManager.ResolveDependency(targetType, selectorKey); Assert.IsNotNull(value); Assert.AreEqual(1, value); mockery.VerifyAllExpectationsHaveBeenMet(); }
public AccessTokenService() { _accessTokenRepository = DependencyManager.Resolve <IAccessTokenRepository>(); _appInfoRepository = DependencyManager.Resolve <IAppInfoRepository>(); }
public void Setup() { _dependencyManager = new DependencyManager(); _dependencyManager.ConfigureStartupDependencies(); }
/// <summary> /// Registering types with using Autofac /// </summary> /// <param name="builder"></param> public override void ConfigureContainer(ContainerBuilder builder) { base.ConfigureContainer(builder); DependencyManager.ConfigureContainer(builder); DependencyHelper.RegisterCommonTypes(builder, typeof(Program)); }