public void CheckRequiredMods_WhenRequirementsRedundant_GetExpectedRequiredMod()
{
const string requiredMod = "SMLHelper";
const string requiredVersionString = "8.6.7";
var versionDependentMod = new QMod
{
// Mod that redundantly includes the same mod both ID and minimum version.
// Unnecessary, but should not cause errors.
Dependencies = new[] { requiredMod },
VersionDependencies = new Dictionary <string, string>
{
{ requiredMod, requiredVersionString }
}
};
var validator = new ManifestValidator();
validator.CheckRequiredMods(versionDependentMod);
// Only a single entry is added to RequiredMods.
Assert.AreEqual(1, versionDependentMod.RequiredMods.Count());
RequiredQMod expected = new RequiredQMod(requiredMod, requiredVersionString);
RequiredQMod actual = versionDependentMod.RequiredMods.First();
Assert.AreEqual(requiredMod, actual.Id);
Assert.AreEqual(expected.RequiresMinimumVersion, actual.RequiresMinimumVersion);
Assert.AreEqual(expected.MinimumVersion, actual.MinimumVersion);
}
public void CheckRequiredMods_WhenRequiresVersion_GetExpectedRequiredMod()
{
const string requiredMod = "SMLHelper";
const string requiredVersionString = "8.6.7";
var versionDependentMod = new QMod
{
// Mod that requires a minimum version of another mod.
VersionDependencies = new Dictionary <string, string>
{
{ requiredMod, requiredVersionString }
}
};
var validator = new ManifestValidator();
validator.CheckRequiredMods(versionDependentMod);
Assert.AreEqual(1, versionDependentMod.RequiredMods.Count());
RequiredQMod expected = new RequiredQMod(requiredMod, requiredVersionString);
RequiredQMod actual = versionDependentMod.RequiredMods.First();
Assert.AreEqual(requiredMod, actual.Id);
Assert.AreEqual(expected.RequiresMinimumVersion, actual.RequiresMinimumVersion);
Assert.AreEqual(expected.MinimumVersion, actual.MinimumVersion);
}
public void CheckRequiredMods_WhenRequiredVersionInvalid_GetExpectedRequiredMod()
{
const string requiredMod = "SMLHelper";
const string invalidVersionString = "1.X.0.Y";
var versionDependentMod = new QMod
{
// Mod with a bad version string in its version dependencies.
VersionDependencies = new Dictionary <string, string>
{
{ requiredMod, invalidVersionString }
}
};
var validator = new ManifestValidator();
validator.CheckRequiredMods(versionDependentMod);
// The entry is added to RequiredMods but without a minimum version.
Assert.AreEqual(1, versionDependentMod.RequiredMods.Count());
RequiredQMod expected = new RequiredQMod(requiredMod);
RequiredQMod actual = versionDependentMod.RequiredMods.First();
Assert.AreEqual(requiredMod, actual.Id);
Assert.AreEqual(expected.RequiresMinimumVersion, actual.RequiresMinimumVersion);
Assert.AreEqual(expected.MinimumVersion, actual.MinimumVersion);
}
public void WhenVersionStringIsMissing_EqualsVersionZero()
{
var required = new RequiredQMod("SomeMod");
var expectedVersion = new Version(0, 0, 0, 0);
Assert.AreEqual(expectedVersion, required.MinimumVersion);
}
public void WhenVersionStringIsTrimmed_EqualsExplicitVersion(string trimmedVersionString)
{
var explicitVersion = new RequiredQMod("SMLHelper", "2.8.0.0");
var trimmedVersion = new RequiredQMod("SMLHelper", trimmedVersionString);
Assert.AreEqual(explicitVersion.MinimumVersion, trimmedVersion.MinimumVersion);
}
public void CreateModStatusList_WhenMissingVersionDependencies_StatusUpdates(string missingOrOutdatedMod, ModStatus expectedStatus)
{
// Arange
var factory = new QModFactory(new DummyPluginCollection(), new DummyValidator())
{
};
var noModsRequired = new RequiredQMod[0];
var earlyErrors = new List <QMod>
{
new QMod {
Id = "5", Status = ModStatus.MissingPatchMethod, RequiredMods = noModsRequired
},
};
var modToInspect = new QMod
{
Id = "8",
Status = ModStatus.Success,
RequiredMods = new List <RequiredQMod>
{
new RequiredQMod(missingOrOutdatedMod, "1.0.2")
}
};
var modsToLoad = new List <QMod>
{
new QMod {
Id = "6", Status = ModStatus.Success, RequiredMods = noModsRequired
},
new QMod
{
Id = "7", Status = ModStatus.Success,
ParsedVersion = new Version(1, 0, 1),
LoadedAssembly = Assembly.GetExecutingAssembly(),
RequiredMods = noModsRequired
},
modToInspect
};
// Act
List <QMod> combinedList = factory.CreateModStatusList(earlyErrors, modsToLoad);
// Assert
Assert.AreEqual(expectedStatus, modToInspect.Status);
}
public void CheckRequiredMods_WhenRequiresIdOnly_GetExpectedRequiredMod()
{
const string requiredMod = "SMLHelper";
var simpleDependentMod = new QMod
{
// Mod that requires one other mod, only by ID.
Dependencies = new[] { requiredMod }
};
var validator = new ManifestValidator();
validator.CheckRequiredMods(simpleDependentMod);
Assert.AreEqual(1, simpleDependentMod.RequiredMods.Count());
RequiredQMod expected = new RequiredQMod(requiredMod);
RequiredQMod actual = simpleDependentMod.RequiredMods.First();
Assert.AreEqual(requiredMod, actual.Id);
Assert.AreEqual(expected.RequiresMinimumVersion, actual.RequiresMinimumVersion);
Assert.AreEqual(expected.MinimumVersion, actual.MinimumVersion);
}
public void CheckRequiredMods_WhenRequirementsMixed_GetExpectedRequiredMods()
{
const string requiredModA = "SMLHelper";
const string requiredModB = "MoreCyclopsUpgrades";
const string requiredVersionBString = "8.6.7";
var versionDependentMod = new QMod
{
// Mod that requires one mod by id only and another at a minimum verison.
Dependencies = new[] { requiredModA },
VersionDependencies = new Dictionary <string, string>
{
{ requiredModB, requiredVersionBString }
}
};
var validator = new ManifestValidator();
validator.CheckRequiredMods(versionDependentMod);
Assert.AreEqual(2, versionDependentMod.RequiredMods.Count());
RequiredQMod expectedA = new RequiredQMod(requiredModA);
RequiredQMod actualA = versionDependentMod.RequiredMods.ElementAt(0);
Assert.AreEqual(requiredModA, actualA.Id);
Assert.AreEqual(expectedA.RequiresMinimumVersion, actualA.RequiresMinimumVersion);
Assert.AreEqual(expectedA.MinimumVersion, actualA.MinimumVersion);
RequiredQMod expectedB = new RequiredQMod(requiredModB, requiredVersionBString);
RequiredQMod actualB = versionDependentMod.RequiredMods.ElementAt(1);
Assert.AreEqual(requiredModB, actualB.Id);
Assert.AreEqual(expectedB.RequiresMinimumVersion, actualB.RequiresMinimumVersion);
Assert.AreEqual(expectedB.MinimumVersion, actualB.MinimumVersion);
}
public void CheckRequiredMods(QMod mod)
{
var requiredMods = new Dictionary <string, RequiredQMod>(mod.VersionDependencies.Count + mod.Dependencies.Length);
foreach (string id in mod.Dependencies)
{
mod.RequiredDependencies.Add(id);
requiredMods.Add(id, new RequiredQMod(id));
}
foreach (string id in mod.LoadBefore)
{
mod.LoadBeforePreferences.Add(id);
}
foreach (string id in mod.LoadAfter)
{
mod.LoadAfterPreferences.Add(id);
}
if (mod.VersionDependencies.Count > 0)
{
foreach (KeyValuePair <string, string> item in mod.VersionDependencies)
{
string id = item.Key;
string versionString = item.Value;
Version version = VersionParserService.GetVersion(versionString);
requiredMods[id] = new RequiredQMod(id, version);
mod.RequiredDependencies.Add(id);
}
}
mod.RequiredMods = requiredMods.Values;
if (Logger.DebugLogsEnabled)
{
string GetModList(IEnumerable <string> modIds)
{
string modList = string.Empty;
foreach (var id in modIds)
{
modList += $"{id} ";
}
return(modList);
}
if (requiredMods.Count > 0)
{
Logger.Debug($"{mod.Id} has required mods: {GetModList(mod.RequiredMods.Select(mod => mod.Id))}");
}
if (mod.LoadBeforePreferences.Count > 0)
{
Logger.Debug($"{mod.Id} should load before: {GetModList(mod.LoadBeforePreferences)}");
}
if (mod.LoadAfterPreferences.Count > 0)
{
Logger.Debug($"{mod.Id} should load after: {GetModList(mod.LoadAfterPreferences)}");
}
}
}
