public void one_module_has_lower_version_than_required_results_in_exception()
{
/* Graph:
* A -> B (wrong version) -> C
*/
var upper = new Version("1.2.0.0");
var lower = new Version("1.0.0.0");
var c = SetUpModuleInfoWithVersion("C", upper);
var b = SetUpModuleInfoWithVersion("B", lower,
new KeyValuePair <string, Version>("C", lower));
var a = SetUpModuleInfoWithVersion("A", upper,
new KeyValuePair <string, Version>("B", upper));
Modules = new[]
{
a,
b,
c
};
// no expected modules but exception
Assert.Throws <ArgumentException>(() => DependencyChecker.SortModules(Modules),
"The modules should not be possible to sort. Missing version.");
}
public void sorting_properly_modules_with_equal_high_versions()
{
/* More complex graph:
* P
* / \
* A Z
* \ /
* Q
*/
var version = new Version("2.2.1.4");
var z = SetUpModuleInfoWithVersion("Z", version);
var p = SetUpModuleInfoWithVersion("P", version,
new KeyValuePair <string, Version>("Z", version));
var q = SetUpModuleInfoWithVersion("Q", version,
new KeyValuePair <string, Version>("Z", version));
ModuleInfo a = SetUpModuleInfoWithVersion("A", version,
new KeyValuePair <string, Version>("P", version),
new KeyValuePair <string, Version>("Q", version));
Modules = new[]
{
a, q, p, z
};
ExpectedModules = new[]
{
z, p, q, a
};
Assert.AreEqual(ExpectedModules, DependencyChecker.SortModules(Modules),
"The list was sorted wrongly.");
}
public TypeDescriptor(Type type)
{
if (type == null)
throw new ArgumentNullException("type");
QualifiedName = type.AssemblyQualifiedName;
Version = new Version(type.Assembly.GetName().Version);
}
public TypeDescriptor(Type type)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
QualifiedName = type.AssemblyQualifiedName;
Version = new Version(type.Assembly.GetName().Version);
}
public TypeDescriptor(string qualifiedName, Version version)
{
if (string.IsNullOrEmpty(qualifiedName))
throw new ArgumentNullException("qualifiedName");
if (version == null)
throw new ArgumentNullException("version");
QualifiedName = qualifiedName;
Version = version;
}
private static ModuleDependency SetUpModuleDependency(string name, Version version)
{
return(new ModuleDependency
{
ModuleName = name,
HasLoadingOrderPriority = false,
// default values
MinimalVersion = version,
ProcessorArchitecture = ProcessorArchitecture.None
});
}
public TypeDescriptor(string qualifiedName, Version version)
{
if (string.IsNullOrEmpty(qualifiedName))
{
throw new ArgumentNullException("qualifiedName");
}
if (version == null)
{
throw new ArgumentNullException("version");
}
QualifiedName = qualifiedName;
Version = version;
}
private static Mock<IModuleManifestFactory> SetUpManifestFactory(string name,
List<ModuleDependency>
dependencies,
Version version)
{
var moduleManifestFacotry = new Mock<IModuleManifestFactory>(MockBehavior.Loose);
moduleManifestFacotry.Setup(x => x.GetManifest(It.IsAny<ModuleInfo>()))
.Returns(new ModuleManifest
{
Issuer = @"ISSUER_NAME",
ModuleName = name,
ModuleDependencies = dependencies,
ModuleVersion = version
}
);
return moduleManifestFacotry;
}
public void set_up()
{
_moduleName = "test_module.dll";
var moduleVersion = new Nomad.Utils.Version("0.1.1.0");
_moduleManifest = new ModuleManifest {
ModuleName = _moduleName, ModuleVersion = moduleVersion
};
// sick creating of dependency checker
IEnumerable <ModuleInfo> outter = new List <ModuleInfo>();
DependencyChecker.Setup(
x =>
x.CheckModules(It.IsAny <IEnumerable <ModuleInfo> >(),
It.IsAny <IEnumerable <ModuleInfo> >(),
out outter))
.Returns(true);
}
private static Mock <IModuleManifestFactory> SetUpManifestFactory(string name,
List <ModuleDependency>
dependencies,
Version version)
{
var moduleManifestFacotry = new Mock <IModuleManifestFactory>(MockBehavior.Loose);
moduleManifestFacotry.Setup(x => x.GetManifest(It.IsAny <ModuleInfo>()))
.Returns(new ModuleManifest
{
Issuer = @"ISSUER_NAME",
ModuleName = name,
ModuleDependencies = dependencies,
ModuleVersion = version
}
);
return(moduleManifestFacotry);
}
public void sorting_proper_with_various_versions()
{
/*
* Quite the DAG graph
* Q
* /
* P -- R
* / \
* A Z
* \ /
* B
*
*/
var high = new Version("2.2.37.2");
var neutral = new Version("1.5.0.0");
var low = new Version("1.0.0.50");
var z = SetUpModuleInfoWithVersion("Z", neutral);
var b = SetUpModuleInfoWithVersion("B", neutral,
new KeyValuePair <string, Version>("Z", neutral));
var r = SetUpModuleInfoWithVersion("R", neutral,
new KeyValuePair <string, Version>("Z", low));
var q = SetUpModuleInfoWithVersion("Q", high);
var p = SetUpModuleInfoWithVersion("P", neutral,
new KeyValuePair <string, Version>("Q", high),
new KeyValuePair <string, Version>("R", low));
var a = SetUpModuleInfoWithVersion("A", high,
new KeyValuePair <string, Version>("P", neutral),
new KeyValuePair <string, Version>("B", low));
Modules = new[]
{
a, p, q, z, b, r,
};
ExpectedModules = new[]
{
q, z, r, p, b, a
};
Assert.AreEqual(ExpectedModules, DependencyChecker.SortModules(Modules), "This complex case should be possible to sort");
}
protected static ModuleInfo SetUpModuleInfoWithVersion(string moduleName, Version version,
params
KeyValuePair<string, Version>[]
dependenciesNamesAndVersions)
{
// make sure that assemblies are not the same beacause of the path.
string modulePath = @"SAMPLE_MODULE_PATH_WITH_VERSION" + Random.Next(0, 100);
var moduleManifestFacotry = new Mock<IModuleManifestFactory>(MockBehavior.Loose);
moduleManifestFacotry.Setup(x => x.GetManifest(It.IsAny<ModuleInfo>()))
.Returns(new ModuleManifest
{
Issuer = @"ISSUER_NAME",
ModuleName = moduleName,
ModuleDependencies = SetUpDependenciesWithVersion(dependenciesNamesAndVersions),
ModuleVersion = version
}
);
return new ModuleInfo(modulePath, moduleManifestFacotry.Object);
}
protected static ModuleInfo SetUpModuleInfoWithVersion(string moduleName, Version version,
params
KeyValuePair <string, Version>[]
dependenciesNamesAndVersions)
{
// make sure that assemblies are not the same beacause of the path.
string modulePath = @"SAMPLE_MODULE_PATH_WITH_VERSION" + Random.Next(0, 100);
var moduleManifestFacotry = new Mock <IModuleManifestFactory>(MockBehavior.Loose);
moduleManifestFacotry.Setup(x => x.GetManifest(It.IsAny <ModuleInfo>()))
.Returns(new ModuleManifest
{
Issuer = @"ISSUER_NAME",
ModuleName = moduleName,
ModuleDependencies = SetUpDependenciesWithVersion(dependenciesNamesAndVersions),
ModuleVersion = version
}
);
return(new ModuleInfo(modulePath, moduleManifestFacotry.Object));
}
internal static void UnPackData(TypeDescriptor typeDescriptor, byte[] byteStream, out object sendObject, out Type type)
{
type = Type.GetType(typeDescriptor.QualifiedName);
if (type != null)
{
var nomadVersion = new Version(type.Assembly.GetName().Version);
if (!nomadVersion.Equals(typeDescriptor.Version))
{
throw new InvalidCastException("The version of the assembly does not match");
}
}
// try deserializing object
sendObject = Deserialize(byteStream);
// check if o is assignable
if (type != null && !type.IsInstanceOfType(sendObject))
{
throw new InvalidCastException("The sent object cannot be casted to sent type");
}
}
internal static void UnPackData(TypeDescriptor typeDescriptor, byte[] byteStream, out object sendObject, out Type type)
{
type = Type.GetType(typeDescriptor.QualifiedName);
if (type != null)
{
var nomadVersion = new Version(type.Assembly.GetName().Version);
if (!nomadVersion.Equals(typeDescriptor.Version))
{
throw new InvalidCastException("The version of the assembly does not match");
}
}
// try deserializing object
sendObject = Deserialize(byteStream);
// check if o is assignable
if (type != null && !type.IsInstanceOfType(sendObject))
{
throw new InvalidCastException("The sent object cannot be casted to sent type");
}
}
private static ModuleDependency SetUpModuleDependency(string name, Version version)
{
return new ModuleDependency
{
ModuleName = name,
HasLoadingOrderPriority = false,
// default values
MinimalVersion = version,
ProcessorArchitecture = ProcessorArchitecture.None
};
}
public void set_up()
{
_moduleName = "test_module.dll";
var moduleVersion = new Nomad.Utils.Version("0.1.1.0");
_moduleManifest = new ModuleManifest { ModuleName = _moduleName, ModuleVersion = moduleVersion };
// sick creating of dependency checker
IEnumerable<ModuleInfo> outter = new List<ModuleInfo>();
DependencyChecker.Setup(
x =>
x.CheckModules(It.IsAny<IEnumerable<ModuleInfo>>(),
It.IsAny<IEnumerable<ModuleInfo>>(),
out outter))
.Returns(true);
}
private void GoDFS(string myNode, ModuleWrapper myNodeInfo)
{
// get list of nodes to go
List <string> nodesToGo;
if (!_nextNodeList.TryGetValue(myNode, out nodesToGo))
{
if (_sortingMode == SortingMode.Exceptions)
{
throw new ArgumentException(
string.Format(
"No such dependency in dictionary. The {0} could not be found.",
myNode), "myNode");
}
else if (_sortingMode == SortingMode.Silent)
{
_canBeSorted = false;
return; // nodes to go wil be empty -> no place to go
}
}
// stop condition (already visted)
if (myNodeInfo.Color == NodeColor.Black)
{
return;
}
// stop c
if (myNodeInfo.Color == NodeColor.Gray)
{
if (_sortingMode == SortingMode.Exceptions)
{
throw new ArgumentException(
string.Format("DependencyGraph has cycles. Duplicated node is {0}.", myNode),
"myNode");
}
else if (_sortingMode == SortingMode.Silent)
{
_canBeSorted = false;
return;
}
}
// mark node as gray (meaning we are traversing this node)
myNodeInfo.Color = NodeColor.Gray;
foreach (string nodeName in nodesToGo)
{
// check if the node exists
ModuleWrapper nodeToGo;
if (!_myNodesDict.TryGetValue(nodeName, out nodeToGo))
{
if (_sortingMode == SortingMode.Exceptions)
{
throw new ArgumentException(
string.Format(
"No such dependency in dictionary. The {0} could not be found.",
myNode),
"myNode");
}
else if (_sortingMode == SortingMode.Silent)
{
_canBeSorted = false;
// add the starting node to the list of non valid nodes (it has some empty reference)
if (!_nonValidModules.Contains(myNodeInfo.Module))
{
_nonValidModules.Add(myNodeInfo.Module);
}
// go to another node
continue;
}
}
// get version
string name = nodeName;
IEnumerable <Version> myNodeDependencyVersions =
myNodeInfo.Module.Manifest.ModuleDependencies.Where(
x => x.ModuleName.Equals(name)).Select(x => x.MinimalVersion);
Version myNodeDependencyVersion =
myNodeDependencyVersions.SingleOrDefault();
Version dependencyVersion = nodeToGo.Module.Manifest.ModuleVersion;
// compare values of the versions, using system feature
if (myNodeDependencyVersion.GetSystemVersion() >
dependencyVersion.GetSystemVersion())
{
if (_sortingMode == SortingMode.Exceptions)
{
throw new ArgumentException(
string.Format(
"Dependency version ({0}) is higher than module's version {1}",
myNodeDependencyVersion, dependencyVersion));
}
else if (_sortingMode == SortingMode.Silent)
{
_canBeSorted = false;
// wrong version means that our node has wrong reference
if (!_nonValidModules.Contains(myNodeInfo.Module))
{
_nonValidModules.Add(myNodeInfo.Module);
}
// let go this way
}
}
// if everything ok, go DFS
GoDFS(nodeName, nodeToGo);
}
_stack.Push(myNodeInfo.Module);
myNodeInfo.Color = NodeColor.Black;
}
