/// <summary>
/// Gets all available types that are considered to be controllers.
/// </summary>
/// <returns>
/// The types that are controllers.
/// </returns>
public IEnumerable <Type> GetControllerTypes()
{
return(_assemblyProvider.GetAssemblies()
.SelectMany(a => a.GetTypes())
.Where(IsControllerType)
.Where(IsIncluded));
}
/// <summary>
/// Initial common kernel setup for mocks
/// </summary>
protected virtual (StandardKernel k, IAssemblyProvider providerMock, IFileSystem fileSystemMock) Setup()
{
var k = new StandardKernel();
k.Load(new ConfigVerificationModule(new ConsoleLogLoggersModules(), new ServiceArguments(), "InfraTests", infraVersion: null));
var cfg =
new HostEnvironment(
new TestHostEnvironmentSource(
"InfraTests"));
k.Bind <IEnvironment>().ToConstant(cfg);
k.Bind <CurrentApplicationInfo>().ToConstant(cfg.ApplicationInfo);
IAssemblyProvider providerMock = Substitute.For <IAssemblyProvider>();
providerMock.GetAssemblies().Returns(info => new[] { GetType().Assembly });
IFileSystem fileSystemMock = Substitute.For <IFileSystem>();
fileSystemMock.ReadAllTextFromFile(Arg.Any <string>()).Returns(a => LoadPaths);
fileSystemMock.Exists(Arg.Any <string>()).Returns(a => true);
k.Rebind <IAssemblyProvider>().ToConstant(providerMock);
k.Rebind <IFileSystem>().ToConstant(fileSystemMock);
return(k, providerMock, fileSystemMock);
}
private void MatchUrl(string url)
{
try {
LogInfo($"MatchUrl: {url}");
_log.Info($"MatchUrl: {url}");
var assemblies = _assemblyProvider.GetAssemblies();
if (assemblies != null)
{
LogInfo($"Compiled successfully.");
var urlMatcher = new UrlMatcher(assemblies.Item1, assemblies.Item2);
var matchUrlResult = urlMatcher.Match(url);
LogInfo($"Matched successfully: {matchUrlResult.ServiceId}-{matchUrlResult.PageId}");
_browserConnection.SendUrlMatchResult(matchUrlResult);
if (!string.IsNullOrWhiteSpace(matchUrlResult.PageId))
{
OpenDocumentWithType(matchUrlResult.PageId);
}
}
}
catch (Exception e) {
LogInfo($"Error!!!");
LogInfo(e.Message);
LogInfo(e.StackTrace);
if (e.InnerException != null)
{
LogInfo(e.InnerException.Message);
LogInfo(e.InnerException.StackTrace);
}
}
}
protected virtual AutoPersistenceModel GetAutoPersistenceModel(IAssemblyProvider assemblyProvider)
{
IEnumerable <Assembly> allLoadedAssemblies = assemblyProvider.GetAssemblies();
AutoPersistenceModel autoPersistenceModel = GetAutoPersistenceModel(allLoadedAssemblies);
return(autoPersistenceModel);
}
private List <Type> GetPublicExportedTypes()
{
return(_typeCache ?? (_typeCache = _assemblyProvider
.GetAssemblies()
.SelectMany(x => x.GetExportedTypes())
.Where(x => x.IsPublic).ToList()));
}
/// <summary>
/// Gets all available types that are considered to be controllers.
/// </summary>
/// <returns>
/// The types that are controllers.
/// </returns>
public IEnumerable <Type> GetControllerTypes()
{
return(_assemblyProvider.GetAssemblies()
.SelectMany(GetAssemblyTypes)
.Where(t => !t.IsAbstract)
.Where(IsControllerType)
.Where(IsIncluded));
}
public TypeResolver(IAssemblyProvider assemblyProvider)
{
if (assemblyProvider == null)
{
throw new ArgumentNullException(nameof(assemblyProvider));
}
LoadedTypes = assemblyProvider.GetAssemblies()
.SelectMany(a => a.GetTypes())
.ToList();
}
private static void DiscoverAssemblies(IAssemblyProvider assemblyProvider, string extensionsPath, bool includingSubpaths)
{
// TODO: remove this workaround in the next major release
// (it is done this way now only to avoid changing the IAssemblyProvider public interface in the minor release).
if (assemblyProvider is DefaultAssemblyProvider)
{
ExtensionManager.SetAssemblies((assemblyProvider as DefaultAssemblyProvider).GetAssemblies(extensionsPath, includingSubpaths));
}
else
{
ExtensionManager.SetAssemblies(assemblyProvider.GetAssemblies(extensionsPath));
}
}
private void DiscoverAssemblies()
{
var modulesPath = _configuration?["Modules:Path"];
var assembliesPath = string.IsNullOrEmpty(modulesPath)
? null
: _hostingEnvironment.ContentRootPath + modulesPath;
var assemblies = new List <Assembly>();
foreach (var extDirectory in Directory.GetDirectories(assembliesPath))
{
var extAssemblies = _assemblyProvider.GetAssemblies(extDirectory);
assemblies.AddRange(extAssemblies);
}
ExtensionManager.SetAssemblies(assemblies);
}
public bool IsTestMethod(StackFrame details)
{
foreach (var assembly in _assemblyProvider.GetAssemblies())
{
var type = assembly.GetType(details.TypeName);
var method = type?.GetTypeInfo().GetDeclaredMethod(details.MethodName);
if (method == null)
{
continue;
}
var attributes = method.GetCustomAttributes();
return(attributes.Any(x => AttributeNames.Any(p => p == x.GetType().Name)));
}
return(false);
}
/// <summary>
/// Initial common kernel setup for mocks
/// </summary>
public (StandardKernel k, IAssemblyProvider providerMock, IFileSystem fileSystemMock) Setup()
{
var k = new StandardKernel();
k.Load(new ConfigVerificationModule(new ConsoleLogLoggersModules(), new ServiceArguments(), "InfraTests", infraVersion: null));
IAssemblyProvider providerMock = Substitute.For <IAssemblyProvider>();
providerMock.GetAssemblies().Returns(info => new[] { GetType().Assembly });
IFileSystem fileSystemMock = Substitute.For <IFileSystem>();
fileSystemMock.ReadAllTextFromFile(Arg.Any <string>()).Returns(a => _loadPaths);
fileSystemMock.Exists(Arg.Any <string>()).Returns(a => true);
k.Rebind <IAssemblyProvider>().ToConstant(providerMock);
k.Rebind <IFileSystem>().ToConstant(fileSystemMock);
return(k, providerMock, fileSystemMock);
}
public Stream GetAsStream(string resourceName = null, bool exactMatch = false)
{
var frame = _stackTraceProvider.GetStack().FirstOrDefault(_methodDetailsFilter.IsTestMethod);
if (frame == null)
{
return(Stream.Null);
}
resourceName = resourceName ?? frame.MethodName;
foreach (var assembly in _resourceAssemblyProvider.GetAssemblies())
{
var resources = assembly.GetManifestResourceNames();
return(exactMatch ?
GetExactMatchResource(assembly, resourceName, resources) :
GetSimilarResource(frame, assembly, resourceName, resources));
}
return(Stream.Null);
}
private void SearchAssembliesAndRebindIConfig(IKernel kernel)
{
IAssemblyProvider aProvider = kernel.Get <IAssemblyProvider>();
foreach (Assembly assembly in aProvider.GetAssemblies())
{
foreach (Type configType in assembly.GetTypes().Where(ConfigObjectCreator.IsConfigObject))
{
IConfigObjectCreatorWrapper cocWrapper = kernel.Get <IConfigObjectCreatorWrapper>(new ConstructorArgument("type", configType));
dynamic getLataestLambda = cocWrapper.GetLambdaOfGetLatest(configType);
kernel.Rebind(typeof(Func <>).MakeGenericType(configType)).ToMethod(t => getLataestLambda());
Type sourceBlockType = typeof(ISourceBlock <>).MakeGenericType(configType);
kernel.Rebind(sourceBlockType).ToMethod(m => cocWrapper.GetChangeNotifications());
dynamic changeNotificationsLambda = cocWrapper.GetLambdaOfChangeNotifications(sourceBlockType);
kernel.Rebind(typeof(Func <>).MakeGenericType(sourceBlockType)).ToMethod(i => changeNotificationsLambda());
kernel.Rebind(configType).ToMethod(i => cocWrapper.GetLatest());
}
}
}
public IEnumerable <AutoRunModuleInfo> Discover()
{
var assemblies = _assemblyProvider.GetAssemblies();
return(Reflect.Reflect
.AssembliesMarkedByAttribute <AutoRunDiscoverableAttribute>(assemblies.ToArray())
.TypesMarkedByAttribute <AutoRunAttribute>()
.Select(type => new AutoRunModuleInfo
{
ModuleType = type.ReflectedType,
ModuleFactory = () =>
{
var factoryType = type.Attribute.FactoryType;
var factory = factoryType?.GetConstructor(Type.EmptyTypes)?.Invoke(new object[] { });
if (factory is IModuleFactory moduleFactory)
{
return moduleFactory.New();
}
try
{
if (Activator.CreateInstance(type.ReflectedType) is ISImplModule sImplModule)
{
return sImplModule;
}
}
catch (Exception)
{
// ignored
}
throw new Exception(
$"The AutoRunModule: '{type.ReflectedType.FullName}' is required to either contain a parameterless constructor or implement IModuleFactory ");
}
}));
private IDictionary <Type, IList <Type> > FindAnnotatedTypes(TypeDefined typeDefined)
{
IEnumerable <Type> types = appDomain.GetAssemblies()
.SelectMany(assembly => assembly.GetTypes());
IDictionary <Type, IList <Type> > typesPerAttribute = new Dictionary <Type, IList <Type> >
{
{ typeof(RegisterTypeAttribute), new List <Type>() },
{ typeof(RegisterProviderAttribute), new List <Type>() }
};
foreach (Type classType in types)
{
// todo avoid nested loop
#pragma warning disable AV1532
foreach (KeyValuePair <Type, IList <Type> > kv in typesPerAttribute)
#pragma warning restore AV1532
{
Type attributeType = kv.Key;
IList <Type> typesWithAttribute = kv.Value;
if (classType.IsDefined(attributeType, typeDefined == TypeDefined.Inherit))
{
if (classType.IsStatic() || classType.IsAbstract)
{
throw new InvalidOperationException(
$"Class type must not be static or abstract to be used with RegisterTypeAttribute: {classType.FullName}");
}
typesWithAttribute.Add(classType);
}
}
}
return(typesPerAttribute);
}
public static IEnumerable <Assembly> GetAssemblies(IAssemblyProvider assemblyProvider)
{
return(assemblyProvider.GetAssemblies());
}
private static IEnumerable <AssemblyDiffPair> CreateAssemblyPairs(IAssemblyProvider firstProvider, IAssemblyProvider secondProvider) =>
firstProvider.GetAssemblies(_targets).Join(secondProvider.GetAssemblies(_targets),
f => f.Name.ToUpperInvariant(),
f => f.Name.ToUpperInvariant(),
(f1, f2) => new AssemblyDiffPair(f1, f2));
private static void DiscoverAssemblies(IAssemblyProvider assemblyProvider, string extensionsPath)
{
ExtensionManager.SetAssemblies(assemblyProvider.GetAssemblies(extensionsPath));
}
private static void DiscoverAssemblies(IAssemblyProvider assemblyProvider, string extensionsPath, bool includingSubpaths)
{
ExtensionManager.SetAssemblies(assemblyProvider.GetAssemblies(extensionsPath, includingSubpaths));
}
/// <summary>
/// Find classes of type
/// </summary>
/// <param name="assignTypeFrom">Assign type from</param>
/// <param name="onlyConcreteClasses">A value indicating whether to find only concrete classes</param>
/// <returns>Result</returns>
/// <returns></returns>
public IEnumerable <Type> FindClassesOfType(Type assignTypeFrom, bool onlyConcreteClasses = true)
{
return(FindClassesOfType(assignTypeFrom, _assemblyProvider.GetAssemblies(), onlyConcreteClasses));
}
/// <summary>
/// Initializes a new instance of the <see cref="FilteringAssemblyProvider"/> class.
/// </summary>
/// <param name="provider">The provider.</param>
public FilteringAssemblyProvider(IAssemblyProvider provider)
{
this.assemblies = provider == null ? new Assembly[] { } : provider.GetAssemblies();
}
protected virtual AutoPersistenceModel GetAutoPersistenceModel(IAssemblyProvider assemblyProvider)
{
IEnumerable<Assembly> allLoadedAssemblies = assemblyProvider.GetAssemblies();
AutoPersistenceModel autoPersistenceModel = GetAutoPersistenceModel(allLoadedAssemblies);
return autoPersistenceModel;
}