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