dave/flutter-rimworld-modman
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 2 Wiki Activity

Rework everything again

Browse Source
This commit is contained in:
PhatPhuckDave
2025-03-18 16:51:36 +01:00
parent 43a7efa1aa
commit 1e4b4db220
4 changed files with 144 additions and 198 deletions
Download Patch File Download Diff File Expand all files Collapse all files

97
test/mod_list_test.dart
View File

@@ -1,4 +1,3 @@
import 'package:rimworld_modman/logger.dart';
import 'package:rimworld_modman/mod.dart';
import 'package:rimworld_modman/mod_list.dart';
import 'package:test/test.dart';
@@ -246,7 +245,7 @@ void main() {
final result = list.loadRequired();
// We say the mods are incompatible but load them anyway, who are we to decide what isn't loaded?
final expected = ['harmony', 'prepatcher', 'incompatible'];
final expected = ['incompatible', 'harmony', 'prepatcher'];
expect(result.errors, isNotEmpty);
expect(result.errors.any((e) => e.contains('incompatible')), isTrue);
expect(result.errors.any((e) => e.contains('harmony')), isTrue);
@@ -303,7 +302,7 @@ void main() {
// We try to not disable mods...... But cyclic dependencies are just hell
// Can not handle it
final expected = [];
final expected = ['modB', 'modA', 'modC'];
expect(result.errors, isNotEmpty);
expect(result.errors.any((e) => e.contains('modA')), isTrue);
expect(result.errors.any((e) => e.contains('modB')), isTrue);
@@ -446,26 +445,9 @@ void main() {
final result = list.loadRequired();
final expected = ['modD', 'modC', 'modB', 'modA'];
expect(result.errors, isEmpty);
// All mods in the chain should be enabled
expect(result.loadOrder.contains('modA'), isTrue);
expect(result.loadOrder.contains('modB'), isTrue);
expect(result.loadOrder.contains('modC'), isTrue);
expect(result.loadOrder.contains('modD'), isTrue);
// The order should be D -> C -> B -> A
expect(
result.loadOrder.indexOf('modD'),
lessThan(result.loadOrder.indexOf('modC')),
);
expect(
result.loadOrder.indexOf('modC'),
lessThan(result.loadOrder.indexOf('modB')),
);
expect(
result.loadOrder.indexOf('modB'),
lessThan(result.loadOrder.indexOf('modA')),
);
expect(result.loadOrder, equals(expected));
});
});
@@ -504,11 +486,12 @@ void main() {
};
list.enableAll();
// Should return errors with both missing dependencies mentioned
final result = list.generateLoadOrder();
final expected = ['modA', 'modB'];
expect(result.errors, isNotEmpty);
expect(result.errors.any((e) => e.contains('missing1')), isTrue);
expect(result.errors.any((e) => e.contains('missing2')), isTrue);
expect(result.loadOrder, equals(expected));
});
});
@@ -527,8 +510,9 @@ void main() {
// Should not throw exception for soft constraints
// But might generate a warning that we could check for
final order = list.generateLoadOrder();
final expected = ['modA'];
expect(order.errors, isEmpty);
expect(order.loadOrder.contains('modA'), isTrue);
expect(order.loadOrder, equals(expected));
});
test('Should handle missing loadAfter relationships', () {
@@ -544,8 +528,9 @@ void main() {
// Should not throw exception for soft constraints
final order = list.generateLoadOrder();
final expected = ['modA'];
expect(order.errors, isEmpty);
expect(order.loadOrder.contains('modA'), isTrue);
expect(order.loadOrder, equals(expected));
});
});
@@ -563,10 +548,12 @@ void main() {
list.enableAll();
final result = list.generateLoadOrder();
final expected = ['modA', 'modB'];
expect(result.errors, isNotEmpty);
expect(result.errors.any((e) => e.contains('Incompatible')), isTrue);
expect(result.errors.any((e) => e.contains('incompatible')), isTrue);
expect(result.errors.any((e) => e.contains('modA')), isTrue);
expect(result.errors.any((e) => e.contains('modB')), isTrue);
expect(result.loadOrder, equals(expected));
});
test('Should handle a combination of errors simultaneously', () {
@@ -583,9 +570,11 @@ void main() {
list.enableAll();
final result = list.generateLoadOrder();
final expected = ['modA', 'modB'];
expect(result.errors, isNotEmpty);
expect(result.errors.any((e) => e.contains('missingDep')), isTrue);
expect(result.errors.any((e) => e.contains('Incompatible')), isTrue);
expect(result.errors.any((e) => e.contains('incompatible')), isTrue);
expect(result.loadOrder, equals(expected));
});
});
@@ -664,11 +653,10 @@ void main() {
list.enableAll();
final result = list.generateLoadOrder();
final expected = ['modA', 'modB'];
expect(result.errors, isEmpty);
expect(result.loadOrder.length, equals(2));
expect(result.loadOrder.contains('modA'), isTrue);
expect(result.loadOrder.contains('modB'), isTrue);
expect(result.loadOrder, equals(expected));
});
test('Should return errors for missing dependencies', () {
@@ -683,10 +671,11 @@ void main() {
list.enableAll();
final result = list.generateLoadOrder();
final expected = ['modA'];
expect(result.errors, isNotEmpty);
expect(result.errors.any((e) => e.contains('nonExistentMod')), isTrue);
// The load order might be empty or contain valid mods only
expect(result.loadOrder, equals(expected));
});
test('Should return both valid load order and errors', () {
@@ -702,12 +691,11 @@ void main() {
list.enableAll();
final result = list.generateLoadOrder();
final expected = ['modA', 'modB'];
expect(result.errors, isNotEmpty);
expect(result.errors.any((e) => e.contains('nonExistentMod')), isTrue);
// modA should still be in the load order even though modB has errors
expect(result.loadOrder.contains('modA'), isTrue);
// modB might be excluded from load order due to its error
expect(result.loadOrder, equals(expected));
});
});
@@ -731,7 +719,7 @@ void main() {
list.enableAll();
final result = list.generateLoadOrder();
final expected = ['modA', 'modB'];
// Verify all missing dependencies are reported
expect(result.errors, isNotEmpty);
expect(result.errors.any((e) => e.contains('missingDep1')), isTrue);
@@ -739,12 +727,11 @@ void main() {
expect(result.errors.any((e) => e.contains('missingDep3')), isTrue);
// Verify errors include the mod that requires the missing dependency
expect(result.errors.any((e) => e.contains('Mod A')), isTrue);
expect(result.errors.any((e) => e.contains('Mod B')), isTrue);
expect(result.errors.any((e) => e.contains('modA')), isTrue);
expect(result.errors.any((e) => e.contains('modB')), isTrue);
// But mods should still be loaded anyway (the "It's fucked but anyway" philosophy)
expect(result.loadOrder.contains('modA'), isTrue);
expect(result.loadOrder.contains('modB'), isTrue);
expect(result.loadOrder, equals(expected));
},
);
});
@@ -762,9 +749,10 @@ void main() {
list.enableAll();
final result = list.generateLoadOrder();
final expected = ['modA'];
// Should still generate a valid load order despite missing soft constraints
expect(result.loadOrder.contains('modA'), isTrue);
expect(result.loadOrder, equals(expected));
// System should track or report the missing loadBefore targets
// This may be implementation-specific - modify if needed based on how your system handles this
@@ -788,9 +776,10 @@ void main() {
list.enableAll();
final result = list.generateLoadOrder();
final expected = ['existingMod', 'modA'];
// Should still generate a valid load order despite missing soft constraints
expect(result.loadOrder.contains('modA'), isTrue);
// Should still generatdeequals(mopected)
expect(result.loadOrder.contains('existingMod'), isTrue);
// The existing loadAfter relationship should be honored
@@ -820,7 +809,7 @@ void main() {
};
list.enableAll();
final result = list.generateLoadOrder();
final expected = ['modA']; final result = list.generateLoadOrder();
// Should report the missing dependency
expect(result.errors, isNotEmpty);
@@ -833,7 +822,7 @@ void main() {
isFalse,
);
// Mod should still be loaded despite missing dependencies
// Mod should still be , equals(expected)pendencies
expect(result.loadOrder.contains('modA'), isTrue);
},
);
@@ -863,6 +852,7 @@ void main() {
list.enableAll();
final result = list.generateLoadOrder();
final expected = ['modB', 'modC', 'modA'];
// Should report all missing dependencies
expect(result.errors, isNotEmpty);
@@ -870,24 +860,11 @@ void main() {
expect(result.errors.any((e) => e.contains('missingDep2')), isTrue);
// Should indicate which mods are affected by these missing dependencies
expect(result.errors.any((e) => e.contains('Mod B')), isTrue);
expect(result.errors.any((e) => e.contains('Mod C')), isTrue);
expect(result.errors.any((e) => e.contains('modB')), isTrue);
expect(result.errors.any((e) => e.contains('modC')), isTrue);
// But all mods should still be loaded in the best possible order
expect(result.loadOrder.contains('modA'), isTrue);
expect(result.loadOrder.contains('modB'), isTrue);
expect(result.loadOrder.contains('modC'), isTrue);
// And existing constraints should be respected
// modA depends on modB and modC, so it should load after them
expect(
result.loadOrder.indexOf('modB'),
lessThan(result.loadOrder.indexOf('modA')),
);
expect(
result.loadOrder.indexOf('modC'),
lessThan(result.loadOrder.indexOf('modA')),
);
expect(result.loadOrder, equals(expected));
},
);