Merge pull request 'Fix checkForNewerStuffTest' (#5) from fix/checkForNewerStuffTest into dev

Reviewed-on: #5

.editorconfig

@@ -10,7 +10,7 @@ indent_style = space
 tab_width = 4
 
 # Naming Conventions
-dotnet_naming_style.pascal_case_style.capitalization = pascal_case
+dotnet_naming_style.camel_case.capitalization = camel_case
 
 # New line preferences
 csharp_new_line_before_open_brace = none

justfile

@@ -17,15 +17,15 @@ run:
     @dotnet run
 
 build:
-    @dotnet build src/Pacserver/pacserver.csproj
+    @dotnet build src/{{uppercase_project_name}}/{{project_name}}.csproj
-    @dotnet build src/Pacserver.Tests/Pacserver.Tests.csproj
+    @dotnet build src/{{uppercase_project_name}}.Tests/{{uppercase_project_name}}.Tests.csproj
 
 publish: format
-    @dotnet publish --configuration Release src/Pacserver/pacserver.csproj
+    @dotnet publish --configuration Release src/{{uppercase_project_name}}/{{project_name}}.csproj
 
 format:
-    @dotnet format src/Pacserver
+    @dotnet format src/{{uppercase_project_name}}
-    @dotnet format src/Pacserver.Tests
+    @dotnet format src/{{uppercase_project_name}}.Tests
 
 test: build
-    @dotnet test src/Pacserver.Tests
+    @dotnet test src/{{uppercase_project_name}}.Tests

src/Pacserver.Tests/Pacserver.Tests.csproj

@@ -9,6 +9,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="FluentAssertions" Version="6.11.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.3.2" />
     <PackageReference Include="xunit" Version="2.4.2" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5">

src/Pacserver.Tests/TransferFilesTest.cs

@@ -4,10 +4,15 @@ namespace Pacserver.Tests;
 
 public class TranserFilesTest {
     [Fact]
-    public void TransferPacmanCacheTest() {
+    public void transferPacmanCache_doesNotFail() {
-        string result = PacserverUtils.determinePacmanCacheDirectory();
+        // Arrange
-        PacserverUtils.TransferPacmanCache();
+        PacserverUtils utils = new PacserverUtils();
 
+        // Act
+        utils.readPacmanConfig();
+        utils.transferPacmanCache();
+
+        // Assert
         //Assert.NotEmpty(Directory.GetFiles("/home/rene/test/"));
     }
 }

src/Pacserver.Tests/Usings.cs

@@ -1 +1,2 @@
 global using Xunit;
+global using FluentAssertions;

src/Pacserver.Tests/checkForNewerStuffTest.cs

@@ -0,0 +1,60 @@
+using Pacserver.Utils;
+
+namespace Pacserver.Tests;
+
+public class checkForNewerStuffTest {
+    [Fact]
+    public void checkForNewerPackages_throwsExceptionIfNoFilesExist() {
+        // Arrange
+        PacserverUtils utils = new PacserverUtils();
+        File.Delete("/tmp/packages_before.txt");
+        File.Delete("/tmp/packages_after.txt");
+
+        // Act
+        Action act = () => utils.diff("/tmp/packages_before.txt", "/tmp/packages_after.txt");
+
+        // Assert
+        act.Should().Throw<FileNotFoundException>().WithMessage("Necessary files could not be found");
+    }
+
+    [Fact]
+    public void getEveryPackageNameAndVersionViaFolderName_createsFiles() {
+        // Arrange
+        PacserverUtils utils = new PacserverUtils();
+        utils.readPacmanConfig();
+
+        // Act
+        utils.getEveryPackageNameAndVersion("before", "/tmp/packages_before.txt");
+        utils.getEveryPackageNameAndVersion("after", "/tmp/packages_after.txt");
+
+        // Assert
+        File.Exists("/tmp/packages_before.txt").Should().BeTrue();
+        File.Exists("/tmp/packages_before.txt").Should().BeTrue();
+    }
+
+    [Fact]
+    public void packageNamesAndVersion_notEmpty() {
+        // Arrange
+        PacserverUtils utils = new PacserverUtils();
+        utils.readPacmanConfig();
+        utils.getEveryPackageNameAndVersion("before", "/tmp/packages_before.txt");
+
+        // Act
+        List<String> packageList = utils.packageNamesAndVersion;
+
+        // Assert
+        packageList.Should().NotBeNullOrEmpty();
+    }
+
+    [Fact]
+    public void getEveryPackageNameAndVersionViaFolderName_throwsExceptionIfModeIsNotValid() {
+        // Arrange
+        PacserverUtils utils = new PacserverUtils();
+
+        // Act
+        Action act = () => utils.getEveryPackageNameAndVersion("test", "/tmp/test.txt");
+
+        // Assert
+        act.Should().Throw<ArgumentException>().WithMessage("No valid mode was given. Valid modes are before and after");
+    }
+}

src/Pacserver.Tests/checkIfDatabasesWereModifiedTest.cs

@@ -0,0 +1,31 @@
+using Pacserver.Utils;
+
+namespace Pacserver.Tests;
+
+public class checkIfDatabasesWereModifiedTest {
+    [Fact]
+    public void checkIfDatabasesWereModified_throwsExceptionIfNoValidModeIsGiven() {
+        // Arrange
+        PacserverUtils utils = new PacserverUtils();
+        utils.readPacmanConfig();
+
+        // Act
+        Action act = () => utils.checkIfDatabasesWereModified("test", "/tmp/test.txt");
+
+        // Assert
+        act.Should().Throw<ArgumentException>().WithMessage("No valid mode was given. Valid modes are before and after");
+    }
+
+    [Fact]
+    public void checkIfDatabasesWereModified_throwsNoExceptionIfValidModeIsGiven() {
+        // Arrange
+        PacserverUtils utils = new PacserverUtils();
+        utils.readPacmanConfig();
+
+        // Act
+        Action act = () => utils.checkIfDatabasesWereModified("before", "/tmp/test.txt");
+
+        // Assert
+        act.Should().NotThrow();
+    }
+}

src/Pacserver.Tests/pacmanCache_Test.cs

@@ -1,13 +0,0 @@
-using Pacserver.Utils;
-
-namespace Pacserver.Tests;
-
-public class pacmanCache_Test {
-    [Fact]
-    public void doesPacmanCacheExist() {
-        string result = PacserverUtils.determinePacmanCacheDirectory();
-
-        Assert.Equivalent(result, "/var/cache/pacman/pkg/");
-    }
-}
-

src/Pacserver.Tests/pacmanDatabase_Test.cs

@@ -1,12 +0,0 @@
-using Pacserver.Utils;
-
-namespace Pacserver.Tests;
-
-public class pacmanDatabase_Test {
-    [Fact]
-    public void doesPacmanDatabaseExist() {
-        string result = PacserverUtils.determinePacmanDatabaseDirectory();
-
-        Assert.Equivalent(result, "/var/lib/pacman/");
-    }
-}

src/Pacserver.Tests/readPacmanConfigTest.cs

@@ -0,0 +1,18 @@
+using Pacserver.Utils;
+
+namespace Pacserver.Tests;
+
+public class readPacmanConfigTest {
+    [Fact]
+    public void readPacmanConfig_returnsNoException() {
+        // Arrange
+        PacserverUtils utils = new PacserverUtils();
+
+        // Act
+        var exception = Record.Exception(() => utils.readPacmanConfig());
+
+        // Assert
+        Assert.Null(exception);
+    }
+}
+

src/Pacserver/Pacserver.cs

@@ -3,69 +3,140 @@ using System.Text.RegularExpressions;
 
 namespace Pacserver.Utils;
 public class PacserverUtils {
-    public static string pacmanCacheDirectory { get; set; } = string.Empty;
+    public string pacmanCacheDirectory = string.Empty;
-    public static string determinePacmanCacheDirectory() {
+    public string pacmanDatabaseDirectory = string.Empty;
-        string defaultPacmanCacheDirectory = "/var/cache/pacman/pkg/";
+    public static List<String> pathsToDetermine = new List<String>() { "CacheDir", "DBPath" };
+    public void readPacmanConfig() {
+        using (StreamReader file = new StreamReader("/etc/pacman.conf")) {
+            Regex regex = new Regex(@"\/(?:[\w.-]+\/)*[\w.-]+(?:\.\w+)*\/?$"); // https://regex101.com/r/GwWeui/2
+            string? line;
 
-        Regex regex = new Regex(@"\/(?:[\w.-]+\/)*[\w.-]+(?:\.\w+)*\/?$"); // https://regex101.com/r/GwWeui/2
+            while ((line = file.ReadLine()) is not null) {
-        string? line;
+                foreach (string path in pathsToDetermine) {
-        StreamReader file = new StreamReader("/etc/pacman.conf");
+                    if (line.Contains(path)) {
-        while ((line = file.ReadLine()) is not null) {
+                        Match match = regex.Match(line);
-            if (line.Contains("CacheDir")) {
+                        if (match.Success) {
-                Match match = regex.Match(line);
+                            switch (path) {
-                if (match.Success) {
+                                case "CacheDir":
-                    pacmanCacheDirectory = match.ToString();
+                                    pacmanCacheDirectory = match.ToString();
-                } else {
+                                    break;
-                    throw new Exception("Could not determine where pacman cache is! Would normally be found here " + defaultPacmanCacheDirectory);
+                                case "DBPath":
+                                    pacmanDatabaseDirectory = match.ToString();
+                                    break;
+                                default:
+                                    throw new Exception("Could not deal with " + match.ToString());
+                            }
+                        } else {
+                            string pathsToDetermineString = string.Join(",", pathsToDetermine);
+                            throw new Exception("Could not determine the necessary file paths: " + pathsToDetermineString);
+                        }
+                    }
                 }
             }
         }
-        file.Close();
-
-        return pacmanCacheDirectory;
     }
 
-    public static string pacmanDatabaseDirectory { get; set; } = string.Empty;
+    public List<String> packageNamesAndVersion = new List<String>();
-    public static string determinePacmanDatabaseDirectory() {
+    public void getEveryPackageNameAndVersion(string mode, string filePath) {
-        string defaultPacmanDatabaseDirectory = "/var/lib/pacman/";
+        Regex regex = new Regex(@".+\.pkg\.tar\.zst$");
 
-        Regex regex = new Regex(@"\/(?:[\w.-]+\/)*[\w.-]+(?:\.\w+)*\/?$"); // https://regex101.com/r/GwWeui/2
+        if (Directory.Exists(pacmanCacheDirectory)) {
-        string? line;
+            if (Directory.GetFiles(pacmanCacheDirectory) is not null) {
-        StreamReader file = new StreamReader("/etc/pacman.conf");
+                packageNamesAndVersion = Directory.GetFiles(pacmanCacheDirectory).Where(file => regex.IsMatch(file)).ToList();
-        while ((line = file.ReadLine()) is not null) {
+            } else {
-            if (line.Contains("DBPath")) {
+                Console.WriteLine("No packages found in pacman cache");
-                Match match = regex.Match(line);
+            }
-                if (match.Success) {
+        } else {
-                    pacmanDatabaseDirectory = match.ToString();
+            Console.WriteLine("No pacman cache directory found");
-                } else {
+        }
-                    throw new Exception("Could not determine where pacman database is! Would normally be found here " + defaultPacmanDatabaseDirectory);
+
+        switch (mode) {
+            case "before":
+                writePackageNamesAndVersionToFile(filePath);
+                break;
+            case "after":
+                writePackageNamesAndVersionToFile(filePath);
+                break;
+            default:
+                throw new ArgumentException("No valid mode was given. Valid modes are before and after");
+        }
+    }
+
+    public void writePackageNamesAndVersionToFile(string filePath) {
+        if (File.Exists(filePath)) {
+            File.Delete(filePath);
+        }
+        
+        using (File.Open(filePath, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite)) {
+            using (StreamWriter sw = new StreamWriter(filePath)) {
+                foreach (string package in packageNamesAndVersion) {
+                    sw.WriteLine(package);
                 }
             }
         }
-        file.Close();
-
-        return pacmanDatabaseDirectory;
     }
 
-    public static void checkForNewerPackagesAndDatabases() {
+    public List<String> diffOfPackagesOrDatabases = new List<String>();
-
+    public void diff(string before, string after) {
+        if (File.Exists(before) && File.Exists(after)) {
+            diffOfPackagesOrDatabases = File.ReadAllLines(after).Except(File.ReadLines(before)).ToList();
+        } else {
+            throw new FileNotFoundException("Necessary files could not be found");
+        }
     }
 
-    private static List<String> NewerPackagesAndDatabases = new List<String>();
+    public List<String> databases = new List<String>();
-    public static async void TransferPacmanCache() {
+    public void checkIfDatabasesWereModified(string mode, string filePath) {
+        string[] databases = Directory.GetFiles(pacmanDatabaseDirectory + "sync/");
+
+        foreach (string database in databases) {
+            switch (mode) {
+                case "before":
+                    writeDatabaseAccessTimeToFile(filePath, database);
+                    break;
+                case "after":
+                    writeDatabaseAccessTimeToFile(filePath, database);
+                    break;
+                default:
+                    throw new ArgumentException("No valid mode was given. Valid modes are before and after");
+            }
+        }
+    }
+
+    public void writeDatabaseAccessTimeToFile(string filePath, string database) {
+        if (File.Exists(filePath)) {
+            File.Delete(filePath);
+        }
+
+        using (File.Open(filePath, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite)) {
+            using (StreamWriter sw = new StreamWriter(filePath)) {
+                sw.WriteLine(database + " " + File.GetLastAccessTime(database));
+            }
+        }
+    }
+
+    public List<String> databasesToTransfer = new List<String>();
+    public void filterDiffOutputForDatabases() {
+        foreach (string database in diffOfPackagesOrDatabases) {
+            databasesToTransfer.Add(Regex.Match(database, @"\/(?:[\w.-]+\/)*[\w.-]+(?:\.\w+)*\/*db").Value); // https://regex101.com/r/Wm5M0P/1
+        }
+    }
+
+    private static List<String> newerPackagesAndDatabases = new List<String>();
+    public async void transferPacmanCache() {
         HttpClient client = new HttpClient();
         HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, "http://192.168.0.69:12000/upload?path=/");
         MultipartFormDataContent content = new MultipartFormDataContent();
 
-        foreach (String PkgOrDb in NewerPackagesAndDatabases) {
+        foreach (string pkgOrDb in newerPackagesAndDatabases) {
-            content.Add(new ByteArrayContent(File.ReadAllBytes(pacmanCacheDirectory + PkgOrDb)), "path", Path.GetFileName(pacmanCacheDirectory + PkgOrDb));
+            content.Add(new ByteArrayContent(File.ReadAllBytes(pacmanCacheDirectory + pkgOrDb)), "path", Path.GetFileName(pacmanCacheDirectory + pkgOrDb));
         }
         request.Content = content;
 
         await client.SendAsync(request);
     }
 
-    public static void transferPacmanDatabases() {
+    public void transferPacmanDatabases() {
 
     }
 }

src/Pacserver/Program.cs

@@ -6,19 +6,60 @@ public class Program {
             Console.ForegroundColor = ConsoleColor.Red;
             Console.WriteLine("Please specify an option.");
             Console.ResetColor();
-            Console.WriteLine("Possible options are: determinePacmanCacheDirectory");
+            Console.WriteLine("Possible options are: determinePacmanCacheDirectory, packagesBefore, packagesAfter, diffPackages, databasesBefore, databasesAfter, diffDatabases, filter");
             return;
         }
 
+        PacserverUtils utils = new PacserverUtils();
+
         switch (args[0]) {
             case "determinePacmanCacheDirectory":
-                Console.WriteLine(PacserverUtils.determinePacmanCacheDirectory());
+                utils.readPacmanConfig();
+                Console.WriteLine(utils.pacmanCacheDirectory);
+                break;
+            case "packagesBefore":
+                utils.readPacmanConfig();
+                utils.getEveryPackageNameAndVersion("before", "/tmp/packages_before.txt");
+                break;
+            case "packagesAfter":
+                utils.readPacmanConfig();
+                utils.getEveryPackageNameAndVersion("after", "/tmp/packages_after.txt");
+                break;
+            case "diffPackages":
+                utils.diff("/tmp/packages_before.txt", "/tmp/packages_after.txt");
+                string packages = string.Join("\n", utils.diffOfPackagesOrDatabases);
+                Console.WriteLine(packages);
+                break;
+            case "databasesBefore":
+                utils.readPacmanConfig();
+                utils.checkIfDatabasesWereModified("before", "/tmp/databases_before.txt");
+                break;
+            case "databasesAfter":
+                utils.readPacmanConfig();
+                utils.checkIfDatabasesWereModified("after", "/tmp/databases_after.txt");
+                break;
+            case "diffDatabases":
+                utils.diff("/tmp/databases_before.txt", "/tmp/databases_after.txt");
+                string databases = string.Join("\n", utils.diffOfPackagesOrDatabases);
+                Console.WriteLine(databases);
+                break;
+            case "filter":
+                utils.diff("/tmp/databases_before.txt", "/tmp/databases_after.txt");
+                utils.filterDiffOutputForDatabases();
+                string filteredDatabases = string.Join("\n", utils.databasesToTransfer);
+                Console.WriteLine(filteredDatabases);
+                break;
+            case "getEveryPackageInCache":
+                utils.readPacmanConfig();
+                utils.getEveryPackageNameAndVersion("before", "/tmp/packages_before.txt");
+                string allPackages = string.Join("\n", utils.packageNamesAndVersion);
+                Console.WriteLine(allPackages);
                 break;
             default:
                 Console.ForegroundColor = ConsoleColor.Red;
                 Console.WriteLine(args[0] + " is not a recognized option.");
                 Console.ResetColor();
-                Console.WriteLine("Possible options are: determinePacmanCacheDirectory");
+                Console.WriteLine("Possible options are: determinePacmanCacheDirectory, packagesBefore, packagesAfter, diffPackages, databasesBefore, databasesAfter, diffDatabases, filter");
                 break;
         }
     }