- lock file now contains the relative path to the description in case of local path

CHANGELOG.md

@@ -24,6 +24,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Fixed missing imports for method parameters that are query parameters.
 - Replaces the use of "new" by "override" and "virtual" in CSharp models.
 - Fixed query parameters type mapping for arrays. [#3354](https://github.com/microsoft/kiota/issues/3354)
+- The lock file now contains the relative path to the description in case of local path. [#3151](https://github.com/microsoft/kiota/issues/3151)
 - Fixed bug where base64url and decimal types would not be generated properly in Java.
 - Fixed bug where symbol name cleanup would not work on forward single quotes characters [#3426](https://github.com/microsoft/kiota/issues/3426).
 - Fixed a bug where a "models" API path segment in the description would derail generation. [#3400](https://github.com/microsoft/kiota/issues/3400)

src/Kiota.Builder/Lock/LockManagementService.cs

@@ -31,13 +31,18 @@ public IEnumerable<string> GetDirectoriesContainingLockFile(string searchDirecto
     }
     private static async Task<KiotaLock?> GetLockFromDirectoryInternalAsync(string directoryPath, CancellationToken cancellationToken)
     {
-        var lockFile = Path.Combine(directoryPath, LockFileName);
-        if (File.Exists(lockFile))
+        var lockFilePath = Path.Combine(directoryPath, LockFileName);
+        if (File.Exists(lockFilePath))
         {
 #pragma warning disable CA2007
-            await using var fileStream = File.OpenRead(lockFile);
+            await using var fileStream = File.OpenRead(lockFilePath);
 #pragma warning restore CA2007
-            return await GetLockFromStreamInternalAsync(fileStream, cancellationToken).ConfigureAwait(false);
+            var result = await GetLockFromStreamInternalAsync(fileStream, cancellationToken).ConfigureAwait(false);
+            if (result is not null && IsDescriptionLocal(result.DescriptionLocation) && !Path.IsPathRooted(result.DescriptionLocation))
+            {
+                result.DescriptionLocation = Path.GetFullPath(Path.Combine(directoryPath, result.DescriptionLocation));
+            }
+            return result;
         }
         return null;
     }
@@ -70,8 +75,17 @@ private static async Task WriteLockFileInternalAsync(string directoryPath, Kiota
 #pragma warning disable CA2007
         await using var fileStream = File.Open(lockFilePath, FileMode.Create);
 #pragma warning restore CA2007
+        lockInfo.DescriptionLocation = GetRelativeDescriptionPath(lockInfo.DescriptionLocation, lockFilePath);
         await JsonSerializer.SerializeAsync(fileStream, lockInfo, context.KiotaLock, cancellationToken).ConfigureAwait(false);
     }
+    private static bool IsDescriptionLocal(string descriptionPath) => !descriptionPath.StartsWith("http", StringComparison.OrdinalIgnoreCase);
+    private static string GetRelativeDescriptionPath(string descriptionPath, string lockFilePath)
+    {
+        if (IsDescriptionLocal(descriptionPath) &&
+            Path.GetDirectoryName(lockFilePath) is string lockFileDirectoryPath)
+            return Path.GetRelativePath(lockFileDirectoryPath, descriptionPath);
+        return descriptionPath;
+    }
     /// <inheritdoc/>
     public Task BackupLockFileAsync(string directoryPath, CancellationToken cancellationToken = default)
     {

tests/Kiota.Builder.Tests/Lock/LockManagementServiceTests.cs

@@ -9,7 +9,7 @@ namespace Kiota.Builder.Tests.Lock;
 public class LockManagementServiceTests
 {
     [Fact]
-    public async Task DefensivePrograming()
+    public async Task DefensiveProgramming()
     {
         var lockManagementService = new LockManagementService();
         Assert.Throws<ArgumentNullException>(() => lockManagementService.GetDirectoriesContainingLockFile(null));
@@ -22,13 +22,34 @@ public async Task DefensivePrograming()
     public async Task Identity()
     {
         var lockManagementService = new LockManagementService();
+        var descriptionPath = Path.Combine(Path.GetTempPath(), "description.yml");
         var lockFile = new KiotaLock
         {
-            DescriptionLocation = "description",
+            ClientClassName = "foo",
+            ClientNamespaceName = "bar",
+            DescriptionLocation = descriptionPath,
         };
         var path = Path.GetTempPath();
         await lockManagementService.WriteLockFileAsync(path, lockFile);
+        lockFile.DescriptionLocation = Path.GetFullPath(descriptionPath); // expected since we write the relative path but read to the full path
         var result = await lockManagementService.GetLockFromDirectoryAsync(path);
         Assert.Equal(lockFile, result, new KiotaLockComparer());
     }
+    [Fact]
+    public async Task UsesRelativePaths()
+    {
+        var tmpPath = Path.Combine(Path.GetTempPath(), "tests", "kiota");
+        var lockManagementService = new LockManagementService();
+        var descriptionPath = Path.Combine(tmpPath, "information", "description.yml");
+        var descriptionDirectory = Path.GetDirectoryName(descriptionPath);
+        Directory.CreateDirectory(descriptionDirectory);
+        var lockFile = new KiotaLock
+        {
+            DescriptionLocation = descriptionPath,
+        };
+        var outputDirectory = Path.Combine(tmpPath, "output");
+        Directory.CreateDirectory(outputDirectory);
+        await lockManagementService.WriteLockFileAsync(outputDirectory, lockFile);
+        Assert.Equal($"..{Path.DirectorySeparatorChar}information{Path.DirectorySeparatorChar}description.yml", lockFile.DescriptionLocation, StringComparer.OrdinalIgnoreCase);
+    }
 }