Set up end to end Send/Receive testing with LexBox

src/LfMerge.Core.Tests/E2E/E2ETestBase.cs

@@ -6,21 +6,84 @@
 using LfMerge.Core.FieldWorks;
 using LfMerge.Core.MongoConnector;
 using NUnit.Framework;
+using NUnit.Framework.Interfaces;
 using SIL.LCModel;
+using SIL.TestUtilities;
 
 namespace LfMerge.Core.Tests.E2E
 {
 	[TestFixture]
 	[Category("LongRunning")]
 	[Category("IntegrationTests")]
-	public class E2ETestBase : SRTestBase
+	public class E2ETestBase
 	{
+		public LfMerge.Core.Logging.ILogger Logger => MainClass.Logger;
+		public TemporaryFolder TempFolderForClass { get; set; }
+		public TemporaryFolder TempFolderForTest { get; set; }
+		public TemporaryFolder TestDataFolder { get; set; }
+		public TemporaryFolder LcmDataFolder { get; set; }
+		public string Sena3ZipPath { get; set; }
+		private Guid? ProjectIdToDelete { get; set; }
+		public SRTestEnvironment TestEnv { get; set; }
+
 		public MongoConnectionDouble _mongoConnection;
 		public MongoProjectRecordFactory _recordFactory;
 
+		public E2ETestBase()
+		{
+		}
+
+		private static string TestName => TestContext.CurrentContext.Test.Name;
+		private static string TestNameForPath => string.Concat(TestName.Split(Path.GetInvalidPathChars())); // Easiest way to strip out all invalid chars
+
+		[OneTimeSetUp]
+		public async Task FixtureSetup()
+		{
+			// Ensure we don't delete top-level /tmp/LfMergeSRTests folder and data subfolder if they already exist
+			var tempPath = Path.Combine(Path.GetTempPath(), "LfMergeSRTests");
+			var rootTempFolder = Directory.Exists(tempPath) ? TemporaryFolder.TrackExisting(tempPath) : new TemporaryFolder(tempPath);
+			var testDataPath = Path.Combine(tempPath, "data");
+			TestDataFolder = Directory.Exists(testDataPath) ? TemporaryFolder.TrackExisting(testDataPath) : new TemporaryFolder(testDataPath);
+			var lcmDataPath = Path.Combine(tempPath, "lcm-common");
+			LcmDataFolder = Directory.Exists(lcmDataPath) ? TemporaryFolder.TrackExisting(lcmDataPath) : new TemporaryFolder(lcmDataPath);
+			Environment.SetEnvironmentVariable("FW_CommonAppData", LcmDataFolder.Path);
+
+			// But the folder for this specific test suite should be deleted if it already exists
+			var derivedClassName = this.GetType().Name;
+			TempFolderForClass = new TemporaryFolder(rootTempFolder, derivedClassName);
+
+			// Ensure sena-3.zip is available to all tests as a starting point
+			Sena3ZipPath = Path.Combine(TestDataFolder.Path, "sena-3.zip");
+			if (!File.Exists(Sena3ZipPath)) {
+				var testEnv = new SRTestEnvironment(TempFolderForTest);
+				if (!await testEnv.IsLexBoxAvailable()) {
+					Assert.Ignore("Can't run E2E tests without a copy of LexBox to test against. Please either launch LexBox on localhost port 80, or set the appropriate environment variables to point to a running copy of LexBox.");
+				}
+				await testEnv.Login();
+				await testEnv.DownloadProjectBackup("sena-3", Sena3ZipPath);
+			}
+		}
+
+		[OneTimeTearDown]
+		public void FixtureTeardown()
+		{
+			Environment.SetEnvironmentVariable("FW_CommonAppData", null);
+			var result = TestContext.CurrentContext.Result;
+			var nonSuccess = result.FailCount + result.InconclusiveCount + result.WarningCount;
+			// Only delete class temp folder if we passed or skipped all tests
+			if (nonSuccess == 0) TempFolderForClass.Dispose();
+		}
+
 		[SetUp]
-		public void Setup()
+		public async Task TestSetup()
 		{
+			TempFolderForTest = new TemporaryFolder(TempFolderForClass, TestNameForPath);
+			TestEnv = new SRTestEnvironment(TempFolderForTest);
+			if (!await TestEnv.IsLexBoxAvailable()) {
+				Assert.Ignore("Can't run E2E tests without a copy of LexBox to test against. Please either launch LexBox on localhost port 80, or set the appropriate environment variables to point to a running copy of LexBox.");
+			}
+			await TestEnv.Login();
+
 			MagicStrings.SetMinimalModelVersion(LcmCache.ModelVersion);
 			_mongoConnection = MainClass.Container.Resolve<IMongoConnection>() as MongoConnectionDouble;
 			if (_mongoConnection == null)
@@ -30,35 +93,124 @@ public void Setup()
 				throw new AssertionException("E2E tests need a mock MongoProjectRecordFactory in order to work.");
 		}
 
+		[TearDown]
+		public async Task TestTeardown()
+		{
+			// Only delete temp folder if test passed, otherwise we'll want to leave it in place for post-test investigation
+			if (TestContext.CurrentContext.Result.Outcome == ResultState.Success) {
+				TempFolderForTest.Dispose();
+				if (ProjectIdToDelete is not null) {
+					var projId = ProjectIdToDelete.Value;
+					ProjectIdToDelete = null;
+					// Also leave LexBox project in place for post-test investigation, even though this might tend to clutter things up a little
+					await TestEnv.DeleteLexBoxProject(projId);
+				}
+			}
+		}
+
+		public string TestFolderForProject(string projectCode) => Path.Join(TempFolderForTest.Path, "webwork", projectCode);
+		public string FwDataPathForProject(string projectCode) => Path.Join(TestFolderForProject(projectCode), $"{projectCode}.fwdata");
+
+		public string CloneRepoFromLexbox(string code, string? newCode = null, TimeSpan? waitTime = null)
+		{
+			var projUrl = SRTestEnvironment.LexboxUrlForProjectWithAuth(code);
+			newCode ??= code;
+			var dest = TestFolderForProject(newCode);
+			if (waitTime is null) {
+				MercurialTestHelper.CloneRepo(projUrl.AbsoluteUri, dest);
+			} else {
+				var start = DateTime.UtcNow;
+				var success = false;
+				while (!success) {
+					try {
+						MercurialTestHelper.CloneRepo(projUrl.AbsoluteUri, dest);
+					} catch {
+						if (DateTime.UtcNow > start + waitTime) {
+							throw; // Give up
+						}
+						System.Threading.Thread.Sleep(250);
+						continue;
+					}
+					// If we got this far, no exception so we succeeded
+					success = true;
+				}
+			}
+			return dest;
+		}
+
+		public FwProject CloneFromLexbox(string code, string? newCode = null, TimeSpan? waitTime = null)
+		{
+			var dest = CloneRepoFromLexbox(code, newCode, waitTime);
+			var dirInfo = new DirectoryInfo(dest);
+			if (!dirInfo.Exists) throw new InvalidOperationException($"Failed to clone {code} from lexbox, cannot create FwProject");
+			var dirname = dirInfo.Name;
+			var fwdataPath = Path.Join(dest, $"{dirname}.fwdata");
+			MercurialTestHelper.ChangeBranch(dest, "tip");
+			LfMergeBridge.LfMergeBridge.ReassembleFwdataFile(TestEnv.NullProgress, false, fwdataPath);
+			var settings = new LfMergeSettingsDouble(TempFolderForTest.Path);
+			return new FwProject(settings, dirname);
+		}
+
+		public async Task<string> CreateEmptyFlexProjectInLexbox()
+		{
+			var randomGuid = Guid.NewGuid();
+			var testCode = $"sr-{randomGuid}";
+			var testPath = TestFolderForProject(testCode);
+			MercurialTestHelper.InitializeHgRepo(testPath);
+			MercurialTestHelper.CreateFlexRepo(testPath);
+			// Now create project in LexBox
+			var result = await TestEnv.CreateLexBoxProject(testCode, randomGuid);
+			Assert.That(result.Result, Is.EqualTo(LexboxGraphQLTypes.CreateProjectResult.Created));
+			Assert.That(result.Id, Is.EqualTo(randomGuid));
+			var pushUrl = SRTestEnvironment.LexboxUrlForProjectWithAuth(testCode).AbsoluteUri;
+			MercurialTestHelper.HgPush(testPath, pushUrl);
+			ProjectIdToDelete = result.Id;
+			return testCode;
+		}
+
+		public async Task<string> CreateNewProjectFromTemplate(string origZipPath)
+		{
+			var randomGuid = Guid.NewGuid();
+			var testCode = $"sr-{randomGuid}";
+			var testPath = TestFolderForProject(testCode);
+			// Now create project in LexBox
+			var result = await TestEnv.CreateLexBoxProject(testCode, randomGuid);
+			Assert.That(result.Result, Is.EqualTo(LexboxGraphQLTypes.CreateProjectResult.Created));
+			Assert.That(result.Id, Is.EqualTo(randomGuid));
+			await TestEnv.ResetAndUploadZip(testCode, origZipPath);
+			ProjectIdToDelete = result.Id;
+			return testCode;
+		}
+
+		public Task<string> CreateNewProjectFromSena3() => CreateNewProjectFromTemplate(Sena3ZipPath);
+
+		public void CommitAndPush(FwProject project, string code, string? localCode = null, string? commitMsg = null)
+		{
+			TestEnv.CommitAndPush(project, code, TempFolderForTest.Path, localCode, commitMsg);
+		}
+
 		public async Task<LanguageForgeProject> CreateLfProjectFromSena3()
 		{
 			var projCode = await CreateNewProjectFromSena3();
 			var projPath = CloneRepoFromLexbox(projCode, waitTime:TimeSpan.FromSeconds(5));
 			MercurialTestHelper.ChangeBranch(projPath, "tip");
 			var fwdataPath = Path.Combine(projPath, $"{projCode}.fwdata");
-			LfMergeBridge.LfMergeBridge.ReassembleFwdataFile(SRTestEnvironment.NullProgress, false, fwdataPath);
+			LfMergeBridge.LfMergeBridge.ReassembleFwdataFile(TestEnv.NullProgress, false, fwdataPath);
 
 			// Do an initial clone from LexBox to the mock LF
 			var lfProject = LanguageForgeProject.Create(projCode, TestEnv.Settings);
 			lfProject.IsInitialClone = true;
-			var transferLcmToMongo = new TransferLcmToMongoAction(TestEnv.Settings, SRTestEnvironment.NullLogger, _mongoConnection, _recordFactory);
+			var transferLcmToMongo = new TransferLcmToMongoAction(TestEnv.Settings, TestEnv.NullLogger, _mongoConnection, _recordFactory);
 			transferLcmToMongo.Run(lfProject);
 
 			return lfProject;
 		}
 
 		public void SendReceiveToLexbox(LanguageForgeProject lfProject)
 		{
-			// ChorusHelperDouble.GetSyncUri assumes presence of a LanguageDepotMock, but here we want a real LexBox instance so we override it via environment variable
-			var saveEnv = Environment.GetEnvironmentVariable(MagicStrings.SettingsEnvVar_LanguageDepotRepoUri);
-			try {
-				var lexboxRepoUrl = SRTestEnvironment.LexboxUrlForProjectWithAuth(lfProject.ProjectCode).AbsoluteUri;
-				Environment.SetEnvironmentVariable(MagicStrings.SettingsEnvVar_LanguageDepotRepoUri, lexboxRepoUrl);
-				var syncAction = new SynchronizeAction(TestEnv.Settings, TestEnv.Logger);
-				syncAction.Run(lfProject);
-			} finally {
-				Environment.SetEnvironmentVariable(MagicStrings.SettingsEnvVar_LanguageDepotRepoUri, saveEnv);
-			}
+			TestEnv.Settings.LanguageDepotRepoUri = SRTestEnvironment.LexboxUrlForProjectWithAuth(lfProject.ProjectCode).AbsoluteUri;
+			var syncAction = new SynchronizeAction(TestEnv.Settings, TestEnv.Logger);
+			syncAction.Run(lfProject);
 		}
 
 		public (string, DateTime, DateTime) UpdateFwGloss(FwProject project, Guid entryId, Func<string, string> textConverter)

src/LfMerge.Core.Tests/E2E/TryOutE2ETests.cs

@@ -36,7 +36,7 @@ public async Task E2E_LFDataChangedLDDataChanged_LFWins()
 			var fwProject = CloneFromLexbox(lfProject.ProjectCode, fwProjectCode);
 
 			// Modify FW data first, then push to Lexbox
-			Guid entryId = Guid.Parse("0006f482-a078-4cef-9c5a-8bd35b53cf72");
+			Guid entryId = LcmTestHelper.GetFirstEntry(fwProject).Guid;
 			var (unchangedGloss, origFwDateModified, fwDateModified) = UpdateFwGloss(fwProject, entryId, text => text + " - changed in FW");
 			CommitAndPush(fwProject, lfProject.ProjectCode, fwProjectCode, "Modified gloss in FW");
 

src/LfMerge.Core.Tests/LcmTestHelper.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using LfMerge.Core.FieldWorks;
 using SIL.LCModel;
 using SIL.LCModel.Infrastructure;
@@ -25,6 +26,12 @@ public static ILexEntry GetEntry(FwProject project, Guid guid)
 			return repo.GetObject(guid);
 		}
 
+		public static ILexEntry GetFirstEntry(FwProject project)
+		{
+			var repo = project?.ServiceLocator?.GetInstance<ILexEntryRepository>();
+			return repo.AllInstances().First();
+		}
+
 		public static string? GetVernacularText(IMultiUnicode field)
 		{
 			return field.BestVernacularAlternative?.Text;