public void Test_All_Variables_Are_Loaded()
{
_LibraryPluginManager.Activate(_SimpleDummyReference);
// get the first available plugin
ILibraryPluginData testLibraryPluginData = (from p in _LibraryPluginManager.AvailablePlugins
select p.Value).FirstOrDefault();
// get the expected result
// load a list of types from the plugin assebly that implement the IStaticExtension interface
// count all properties that have a StaticVariableAttribute
Type staticExtensionInterfaceType = typeof(IStaticExtension);
var expectedStaticExtensionTypes = from t in Assembly.GetAssembly(typeof(FirstDummyStaticExtension)).GetTypes()
where t.IsClass &&
staticExtensionInterfaceType.IsAssignableFrom(t)
select t;
int expectedNumberOfVariables = 0;
foreach (var extensionType in expectedStaticExtensionTypes)
{
var variableProperties = from m in extensionType.GetMembers()
where m.MemberType == MemberTypes.Property &&
m.GetCustomAttribute <StaticVariableAttribute>() != null
select m;
expectedNumberOfVariables += variableProperties.Count();
}
Assert.AreEqual(expectedNumberOfVariables, testLibraryPluginData.StaticExtensionContainer.Variables.Count);
}
public void SetupTest()
{
string solutionDirectoryPath = Path.GetDirectoryName(Path.GetDirectoryName(Path.GetDirectoryName(System.IO.Directory.GetCurrentDirectory())));
_PluginDirectoryPath = Path.Combine(solutionDirectoryPath, @"_TestData\InterfaceBooster\LibraryPluginData");
_PluginXmlFilePath = Path.Combine(_PluginDirectoryPath, "plugin.xml");
_LibraryPluginData = LibraryPluginDataController.Load(_PluginXmlFilePath);
}
public static ILibraryPluginData Load(string pluginXmlFilePath)
{
LibraryPluginDataController controller = new LibraryPluginDataController(pluginXmlFilePath);
ILibraryPluginData data = controller.LoadData();
return(data);
}
public void Activate(LibraryPluginReference reference)
{
if (string.IsNullOrEmpty(PluginMainDirectoryPath))
{
throw new LibraryPluginManagerException(this, String.Format(
"A valid PluginMainDirectoryPath must be set before using the LibraryPluginManager. Path given: {0}",
PluginMainDirectoryPath));
}
ILibraryPluginData pluginData = (from d in _AvailablePlugins
where d.Key.IdPlugin == reference.IdPlugin
select d.Value).FirstOrDefault();
// If the plugin data was found the plugin has already been initialized. So nothing must be done.
// Otherwise the plugin must be searched on the filesystem and the assembly must be loaded.
if (pluginData == null)
{
// check whether the SyneryIdentifier is unique
var numberOfExistingPluginsWithTheSameIdentfier = (from i in _AvailablePlugins
where i.Key.SyneryIdentifier == reference.SyneryIdentifier
select i).Count();
if (numberOfExistingPluginsWithTheSameIdentfier != 0)
{
throw new LibraryPluginManagerException(this, String.Format(
"Plugin activation for SyneryIdentifier='{0}' failed. A plugin with the given identifier already exists. The identifier must be unique.",
reference.SyneryIdentifier));
}
// start loading plugin data
// load plugin.xml
pluginData = LoadLibraryPluginXmlData(reference);
if (pluginData != null)
{
// try to load the assembly by using the data from the plugin.xml
Assembly assembly = LoadAssembly(reference, pluginData);
// get the data of the StaticExtensions by reflection
pluginData.StaticExtensionContainer = LoadStaticExtensionContainer(reference, assembly);
// append the new plugin data to the dictionary
_AvailablePlugins.Add(reference, pluginData);
}
else
{
throw new LibraryPluginManagerException(this, String.Format(
"Plugin activation for SyneryIdentifier='{0}' failed. The requested Plugin with Name='{1}' and Id='{2}' was not found.",
reference.SyneryIdentifier, reference.PluginName, reference.IdPlugin));
}
}
}
public void Test_Variable_HasSetter_Is_Recognized()
{
_LibraryPluginManager.Activate(_SimpleDummyReference);
// get the first available plugin
ILibraryPluginData testLibraryPluginData = (from p in _LibraryPluginManager.AvailablePlugins
select p.Value).FirstOrDefault();
// get the expected result
// load a list of types from the plugin assebly that implement the IStaticExtension interface
// loop threw all properties that have a StaticVariableAttribute and check for a public setter
Type staticExtensionInterfaceType = typeof(IStaticExtension);
var expectedStaticExtensionTypes = from t in Assembly.GetAssembly(typeof(FirstDummyStaticExtension)).GetTypes()
where t.IsClass &&
staticExtensionInterfaceType.IsAssignableFrom(t)
select t;
List <PropertyInfo> expectedListOfPropertiesWithSetter = new List <PropertyInfo>();
List <PropertyInfo> expectedListOfReadOnlyProperties = new List <PropertyInfo>();
foreach (var extensionType in expectedStaticExtensionTypes)
{
var propertiesWithSetter = from m in extensionType.GetProperties()
where m.MemberType == MemberTypes.Property &&
m.SetMethod != null &&
m.SetMethod.IsPublic == true &&
m.GetCustomAttribute <StaticVariableAttribute>() != null
select m;
var readOnlyProperties = from m in extensionType.GetProperties()
where m.MemberType == MemberTypes.Property &&
(m.SetMethod == null || m.SetMethod.IsPublic == false) &&
m.GetCustomAttribute <StaticVariableAttribute>() != null
select m;
expectedListOfPropertiesWithSetter.AddRange(propertiesWithSetter);
expectedListOfReadOnlyProperties.AddRange(readOnlyProperties);
}
IEnumerable <IStaticExtensionVariableData> listOfVariableDataWithSetter = from v in testLibraryPluginData.StaticExtensionContainer.Variables
where v.HasSetter == true
select v;
IEnumerable <IStaticExtensionVariableData> listOfVariableDataWithoutSetter = from v in testLibraryPluginData.StaticExtensionContainer.Variables
where v.HasSetter == false
select v;
Assert.AreEqual(expectedListOfPropertiesWithSetter.Count, listOfVariableDataWithSetter.Count());
Assert.AreEqual(expectedListOfReadOnlyProperties.Count, listOfVariableDataWithoutSetter.Count());
}
private Assembly LoadAssembly(LibraryPluginReference reference, ILibraryPluginData pluginData)
{
Version availableInterfaceVersion = GetInterfaceAssemblyVersion();
// check for the correct interface version
// if the versions don't match the ProviderPlugin bases on another interface .dll-file than provided by the current runtime
ILibraryPluginAssemblyData assemblyData = (from a in pluginData.Assemblies
where a.RequiredInterfaceVersion == availableInterfaceVersion
select a).FirstOrDefault();
if (assemblyData != null)
{
Assembly assembly;
string assemblyFilePath = Path.Combine(pluginData.PluginDirectoryPath, assemblyData.Path);
if (!File.Exists(assemblyFilePath))
{
throw new LibraryPluginManagerException(this, String.Format(
"The given assembly of LibraryPlugin with name='{0}' and id='{1}' cannot be found. Assembly file path='{2}'.",
pluginData.Name, pluginData.Id, assemblyFilePath));
}
try
{
// now we are ready to load the foreign assembly
assembly = Assembly.LoadFrom(assemblyFilePath);
return(assembly);
}
catch (Exception ex)
{
// catch unexpected exceptions while loading the assembly to enrich the thrown exception with some additional information
throw new LibraryPluginManagerException(this, String.Format(
"An unexpected error occured while loading the LibraryPlugin with name='{0}' and id='{1}'. Assembly file path='{2}'.",
pluginData.Name, pluginData.Id, assemblyFilePath),
ex);
}
}
else
{
throw new LibraryPluginManagerException(this, String.Format(
"No assembly found for the LibraryPlugin with name='{0}' and id='{1}' that supports the required interface version '{2}'",
reference.PluginName, reference.IdPlugin, availableInterfaceVersion.ToString()));
}
}
private IStaticExtensionFunctionData FindFunctionDeclaration(ILibraryPluginData libraryPluginData, string functionIdentifier, Type[] listOfParameterTypes)
{
int numberOfParameterTypes = listOfParameterTypes.Count();
// try to find function(s) with the same name with at least the same number of parameters as given
var listOfFunctionData = (from f in libraryPluginData.StaticExtensionContainer.Functions
where f.FullSyneryIdentifier == functionIdentifier &&
f.Parameters.Count >= numberOfParameterTypes
select f);
// try to find the matching function signature
// also consider that a parameter isn't set because it is optional
foreach (var functionData in listOfFunctionData)
{
bool isMatching = true;
for (int i = 0; i < functionData.Parameters.Count; i++)
{
if (numberOfParameterTypes > i && listOfParameterTypes[i] != null)
{
// compare the types of the expected parameter and the given value
if (listOfParameterTypes[i] != functionData.Parameters[i].Type)
{
isMatching = false;
}
}
else
{
// no value given for the parameter: check whether parameter is optional
if (functionData.Parameters[i].IsOptional == false)
{
isMatching = false;
}
}
}
// the current function declaration seems to match -> return it
if (isMatching == true)
{
return(functionData);
}
}
return(null);
}
public void Test_All_StaticExtensions_Are_Loaded()
{
_LibraryPluginManager.Activate(_SimpleDummyReference);
// get the first available plugin
ILibraryPluginData testLibraryPluginData = (from p in _LibraryPluginManager.AvailablePlugins
select p.Value).FirstOrDefault();
// get the expected result
// load a list of types from the plugin assebly that implement the IStaticExtension interface
Type staticExtensionInterfaceType = typeof(IStaticExtension);
var expectedStaticExtensionTypes = from t in Assembly.GetAssembly(typeof(FirstDummyStaticExtension)).GetTypes()
where t.IsClass &&
staticExtensionInterfaceType.IsAssignableFrom(t)
select t;
Assert.AreEqual(expectedStaticExtensionTypes.Count(), testLibraryPluginData.StaticExtensionContainer.Extensions.Count);
}
