ref #60 Added method mergeSign, unittests.

src/CopyrighFixer/CopyrighFixer/signer.cpp

@@ -8,6 +8,7 @@
 #include "signer.h"
 #include "CopyrighFixer/ifilemanager.h"
 #include <QDir>
+#include <quasarapp.h>
 
 namespace CopyrighFixer {
 Signer::Signer() {
@@ -19,46 +20,92 @@ bool Signer::checkSign(const Config &objConf) {
     Config currConfig = objConf;
 
     QDir currentFolder(currConfig.getSrcDir());
-    currentFolder.setFilter(QDir::Dirs | QDir::Files);
+    currentFolder.setFilter(QDir::Dirs | QDir::Files | QDir::NoDotAndDotDot);
 
     QFileInfoList folderItems(currentFolder.entryInfoList());
 
     for (auto i_file: folderItems) {
 
-        if (i_file.fileName() == "." || i_file.fileName() == "..") {
-            continue;
-        }
+        if (i_file.isDir()) {
 
-        if (!i_file.isDir()) {
+            currConfig.setSourceDir(i_file.filePath());
+            checkSign(currConfig);
+
+        } else {
 
             IFileManager *currFM = searchFileByExt(i_file.suffix());
-            Signature objSing = currConfig.getSignVal();
+            Signature signFromFile;
+            Signature signForWrite;
 
             if (currFM == nullptr) {
                 return false;
             }
 
-            bool valRead = currFM->read(i_file.filePath(), objSing);
-            if (!valRead) {
+            if (!currFM->read(i_file.filePath(), signFromFile)) {
                 return false;
             }
 
-            currConfig.setSingValue(objSing);
+            signForWrite = mergeSign(currConfig.getSignVal(), signFromFile);
 
-            bool valWrite = currFM->write(i_file.filePath(), objSing);
-            if (!valWrite) {
+            if (!currFM->write(i_file.filePath(), signForWrite)) {
                 return false;
             }
-
-        } else {
-            currConfig.setSourceDir(i_file.filePath());
-            checkSign(currConfig);
         }
     }
 
     return true;
 }
 
+const Signature Signer::mergeSign(const Signature &userSign, const Signature &fileSign) const {
+
+    if (!fileSign.isValid()) {
+        return userSign;
+    }
+
+    if (userSign.getLicenseTitle() == fileSign.getLicenseTitle()) {
+
+        if (!fileSign.isValid()) {
+            return userSign;
+        }
+
+        if (userSign.getMapOwn().size() > 1) {
+            QuasarAppUtils::Params::log("Config signature contains more owners.",
+                                        QuasarAppUtils::VerboseLvl::Warning);
+            return fileSign;
+        }
+
+        Signature signForSing = fileSign;
+        if (userSign.getMapOwn().cbegin().value().getOwnerName() == signForSing.getMapOwn().cbegin().value().getOwnerName()) {
+
+            QMap<int, CopyrighFixer::Owner> mapOwners = signForSing.getMapOwn();
+            mapOwners.remove(fileSign.getMapOwn().cbegin().key());
+            mapOwners.insert(userSign.getMapOwn().cbegin().key(),
+                             userSign.getMapOwn().cbegin().value());
+            signForSing.setMapOwners(mapOwners);
+
+            return signForSing;
+
+        } else {
+
+            QMap<int, CopyrighFixer::Owner> mapOwners = signForSing.getMapOwn();
+            mapOwners.insert(userSign.getMapOwn().cbegin().key(),
+                             userSign.getMapOwn().cbegin().value());
+            signForSing.setMapOwners(mapOwners);
+
+            return signForSing;
+
+        }
+
+        return fileSign;
+
+    } else {
+        QuasarAppUtils::Params::log("The signature in the file is different from the config signature.",
+                                    QuasarAppUtils::VerboseLvl::Warning);
+        return fileSign;
+    }
+
+}
+
 IFileManager *Signer::searchFileByExt(const QString &extension) {
 
     for (auto itemFM: _fileManager) {

src/CopyrighFixer/CopyrighFixer/signer.h

@@ -28,6 +28,14 @@ public:
      */
     bool checkSign(const Config &objConf);
 
+    /**
+     * @brief mergeSign The method compares two signatures and merges into one.
+     * @param userSign The signature that is pulled from the configuration.
+     * @param fileSign The signature that is read from the file.
+     * @return Returns the signature for signing a file.
+     */
+    const Signature mergeSign(const Signature &userSign, const Signature &fileSign) const;
+
     /**
      * @brief searchFileByExt The method that searches for files with the desired extension.
      * @param extension This is the file extension to search.

tests/tstMain.cpp

@@ -8,6 +8,7 @@
 #include <QtTest>
 #include "cfixertest.h"
 #include "signtest.h"
+#include "signertest.h"
 #include "configparsertest.h"
 
 // Use This macros for initialize your own test classes.
@@ -34,6 +35,7 @@ private slots:
     // BEGIN TESTS CASES
     TestCase(exampleTest, ExampleTest);
     TestCase(signTest, SignTest);
+    TestCase(signerTest, SignerTest);
     TestCase(configParserTest, ConfigParserTest)
     // END TEST CASES
 

tests/units/signertest.cpp

@@ -20,7 +20,142 @@ void SignerTest::test() {
     testSigner();
 }
 
-void SignerTest::testSigner() {
+CopyrighFixer::Signature SignerTest::genSign(const QString licen,
+                                             const QString nOwn,
+                                             int tP) const {
+
+    CopyrighFixer::Owner ownerObj;
+    ownerObj.setName(nOwn);
+    ownerObj.setTimePoint(tP);
+
+    QMap<int, CopyrighFixer::Owner> OwnerMap;
+    OwnerMap.insert(tP, ownerObj);
+
+    CopyrighFixer::Signature signTest;
+    signTest.setLicenseTitle(licen);
+    signTest.setMessage("Distributed under the lgplv3 software license, see the accompany.");
+    signTest.setMapOwners(OwnerMap);
+
+    return signTest;
+}
+
+CopyrighFixer::Signature SignerTest::genSign(QList<SignerTest::dataOwns> numOwns, const QString licen) const {
+
+    QMap<int, CopyrighFixer::Owner> OwnerMap;
+    for (auto itemOwn: numOwns) {
+        CopyrighFixer::Owner ownerObj;
+        ownerObj.setName(itemOwn.name);
+        ownerObj.setTimePoint(itemOwn.timePoint);
+
+        OwnerMap.insert(itemOwn.timePoint, ownerObj);
+    }
+
+    CopyrighFixer::Signature signTest;
+    signTest.setLicenseTitle(licen);
+    signTest.setMessage("Distributed under the lgplv3 software license, see the accompany.");
+    signTest.setMapOwners(OwnerMap);
+
+    return signTest;
+}
+
+
+QList<SignerTest::Signers> SignerTest::lstSing() const {
+
+    // 1
+    // The case when the signatures in the config and the file match.
+    SignerTest::Signers equalSign;
+    equalSign.signFormConf = genSign("Copyright (C) 2020-2021 QuasarApp.", "QuasarApp", 1622657022);
+    equalSign.signFormFile = genSign("Copyright (C) 2020-2021 QuasarApp.", "QuasarApp", 1622657022);
+    equalSign.signAfterMerge = genSign("Copyright (C) 2020-2021 QuasarApp.", "QuasarApp", 1622657022);
+
+    // 2
+    // The Different licenses.
+    SignerTest::Signers signDiffLic;
+    signDiffLic.signFormConf = genSign("Copyright (C) 2020-2021 QuasarApp.", "QuasarApp", 1622657022);
+    signDiffLic.signFormFile = genSign("Copyright (C) 2019-2020 QuasarApp.", "QuasarApp", 1622657022);
+    signDiffLic.signAfterMerge = genSign("Copyright (C) 2019-2020 QuasarApp.", "QuasarApp", 1622657022);
+
+    // 3
+    // The Different owners.
+    SignerTest::Signers signDiffOwn;
+    signDiffOwn.signFormConf = genSign("Copyright (C) 2020-2021 QuasarApp.", "QuasarApp", 1700000000);
+    signDiffOwn.signFormFile = genSign("Copyright (C) 2020-2021 QuasarApp.", "QuasarAppSdfdf", 1622657022);
+
+    signDiffOwn.signAfterMerge = genSign("Copyright (C) 2020-2021 QuasarApp.", "QuasarAppSdfdf", 1622657022);
+    QMap<int, CopyrighFixer::Owner> multiSign = signDiffOwn.signAfterMerge.getMapOwn();
+    multiSign.insert(1700000000, genSign("Copyright (C) 2020-2021 QuasarApp.", "QuasarApp", 1700000000).getMapOwn().cbegin().value());
+    signDiffOwn.signAfterMerge.setMapOwners(multiSign);
+
+    // 4
+    // The equal owners.
+    SignerTest::Signers signEqualOwn;
+    signEqualOwn.signFormConf = genSign("Copyright (C) 2020-2021 QuasarApp.", "QuasarApp", 1700000000);
+    signEqualOwn.signFormFile = genSign("Copyright (C) 2020-2021 QuasarApp.", "QuasarApp", 1622657022);
+    signEqualOwn.signAfterMerge = genSign("Copyright (C) 2020-2021 QuasarApp.", "QuasarApp", 1700000000);
+
+
+    // 5
+    // The signature is missing from the file.
+    SignerTest::Signers signMissingInFile;
+    signMissingInFile.signFormConf = genSign("Copyright (C) 2020-2021 QuasarApp.", "QuasarApp", 1622657022);
+    signMissingInFile.signFormFile = genSign();
+    signMissingInFile.signAfterMerge = genSign("Copyright (C) 2020-2021 QuasarApp.", "QuasarApp", 1622657022);
+
+    // 6
+    // Here are no owners in the file.
+    SignerTest::Signers signMissOwnInFile;
+    signMissOwnInFile.signFormConf = genSign("Copyright (C) 2020-2021 QuasarApp.", "QuasarApp", 1622657022);
+    signMissOwnInFile.signFormFile = genSign("Copyright (C) 2020-2021 QuasarApp.");
+    signMissOwnInFile.signAfterMerge = genSign("Copyright (C) 2020-2021 QuasarApp.", "QuasarApp", 1622657022);
+
+    // 7
+    // Generating multiple owners.
+    QList<SignerTest::dataOwns> Owns;
+    int temp = 0;
+    for (int i(0); i<3; i++) {
+        temp++;
+
+        dataOwns lO;
+        lO.name = QString("QuasarApp%1").arg(temp);
+        lO.timePoint = 1700000000 + (temp*10);
+
+        Owns.append(lO);
+    }
+
+    // The number of owners differs.
+    SignerTest::Signers signDiffNumOwn;
+    signDiffNumOwn.signFormConf = genSign(Owns, "Copyright (C) 2020-2021 QuasarApp.");
+    signDiffNumOwn.signFormFile = genSign("Copyright (C) 2020-2021 QuasarApp.", "QuasarApp", 1700000000);
+    signDiffNumOwn.signAfterMerge = genSign("Copyright (C) 2020-2021 QuasarApp.", "QuasarApp", 1700000000);
+
+    return {equalSign, signDiffLic, signDiffOwn, signEqualOwn, signMissingInFile, signMissOwnInFile, signDiffNumOwn};
+
+}
+
+void SignerTest::testMergeSign() const {
+
+    QList<SignerTest::Signers> dfd = lstSing();
+
+    for (auto itemSign: lstSing()) {
+
+        CopyrighFixer::Signer resSign;
+        CopyrighFixer::Signature mergeSignUF = resSign.mergeSign(itemSign.signFormConf,
+                                                                 itemSign.signFormFile);
+
+        QVERIFY(mergeSignUF == itemSign.signAfterMerge);
+
+    }
+
+}
+
+void SignerTest::testCheckSign() const {
     qWarning() << "The SignerTest class is not implemented";
     QVERIFY(true);
 }
+
+void SignerTest::testSigner() {
+
+    testMergeSign();
+    testCheckSign();
+
+}

tests/units/signertest.h

@@ -19,6 +19,26 @@ public:
     ~SignerTest();
 
     void test();
+
+    struct dataOwns{
+        QString name;
+        int timePoint;
+    };
+
+    struct Signers {
+        CopyrighFixer::Signature signFormConf;
+        CopyrighFixer::Signature signFormFile;
+        CopyrighFixer::Signature signAfterMerge;
+    };
+
+    CopyrighFixer::Signature genSign(const QString licen = "",
+                                     const QString nOwn = "",
+                                     int tP = 0) const;
+    CopyrighFixer::Signature genSign(QList<dataOwns> numOwns, const QString licen = "") const;
+
+    QList<Signers> lstSing() const;
+    void testMergeSign() const;
+    void testCheckSign() const;
     void testSigner();
 };