winget-cli

Unnamed repository; edit this file 'description' to name the repository.
Log | Files | Refs | README | LICENSE

AppContentTests.cpp (10597B)

      1 // Copyright (c) Microsoft Corporation.
      2 // Licensed under the MIT License.
      3 
      4 #include "ContentUtil.h"
      5 #include "sfsclient/AppContent.h"
      6 
      7 #include <catch2/catch_test_macros.hpp>
      8 
      9 #define TEST(...) TEST_CASE("[AppContentTests] " __VA_ARGS__)
     10 #define TEST_SCENARIO(...) TEST_CASE("[AppContentTests] Scenario: " __VA_ARGS__)
     11 
     12 using namespace SFS;
     13 using namespace SFS::details;
     14 using namespace SFS::details::contentutil;
     15 
     16 namespace
     17 {
     18 std::unique_ptr<ContentId> GetContentId(const std::string& nameSpace,
     19                                         const std::string& name,
     20                                         const std::string& version)
     21 {
     22     std::unique_ptr<ContentId> contentId;
     23     REQUIRE(ContentId::Make(nameSpace, name, version, contentId) == Result::Success);
     24     REQUIRE(contentId != nullptr);
     25     return contentId;
     26 }
     27 
     28 std::unique_ptr<AppFile> GetAppFile(const std::string& fileId,
     29                                     const std::string& url,
     30                                     uint64_t sizeInBytes,
     31                                     const std::unordered_map<HashType, std::string>& hashes,
     32                                     std::vector<Architecture> architectures,
     33                                     std::vector<std::string> platformApplicabilityForPackage,
     34                                     std::string fileMoniker)
     35 {
     36     std::unique_ptr<AppFile> file;
     37     REQUIRE(AppFile::Make(fileId,
     38                           url,
     39                           sizeInBytes,
     40                           hashes,
     41                           architectures,
     42                           platformApplicabilityForPackage,
     43                           fileMoniker,
     44                           file) == Result::Success);
     45     REQUIRE(file != nullptr);
     46     return file;
     47 }
     48 
     49 std::unique_ptr<AppPrerequisiteContent> GetPrerequisiteContent(const std::string& contentNameSpace,
     50                                                                const std::string& contentName,
     51                                                                const std::string& contentVersion,
     52                                                                const std::vector<AppFile>& files)
     53 {
     54     std::unique_ptr<ContentId> contentId = GetContentId(contentNameSpace, contentName, contentVersion);
     55     std::vector<AppFile> clonedFiles;
     56     for (auto& file : files)
     57     {
     58         clonedFiles.push_back(std::move(*GetAppFile(file.GetFileId(),
     59                                                     file.GetUrl(),
     60                                                     file.GetSizeInBytes(),
     61                                                     file.GetHashes(),
     62                                                     file.GetApplicabilityDetails().GetArchitectures(),
     63                                                     file.GetApplicabilityDetails().GetPlatformApplicabilityForPackage(),
     64                                                     file.GetFileMoniker())));
     65     }
     66 
     67     std::unique_ptr<AppPrerequisiteContent> content;
     68     REQUIRE(AppPrerequisiteContent::Make(std::move(contentId), std::move(clonedFiles), content) == Result::Success);
     69     REQUIRE(content != nullptr);
     70     return content;
     71 }
     72 
     73 std::unique_ptr<AppContent> GetAppContent(const std::string& contentNameSpace,
     74                                           const std::string& contentName,
     75                                           const std::string& contentVersion,
     76                                           const std::string& updateId,
     77                                           const std::vector<AppPrerequisiteContent>& prerequisites,
     78                                           const std::vector<AppFile>& files)
     79 {
     80     std::unique_ptr<ContentId> contentId = GetContentId(contentNameSpace, contentName, contentVersion);
     81     std::vector<AppPrerequisiteContent> clonedPreqs;
     82     for (const auto& prereq : prerequisites)
     83     {
     84         clonedPreqs.push_back(std::move(*GetPrerequisiteContent(prereq.GetContentId().GetNameSpace(),
     85                                                                 prereq.GetContentId().GetName(),
     86                                                                 prereq.GetContentId().GetVersion(),
     87                                                                 prereq.GetFiles())));
     88     }
     89 
     90     std::vector<AppFile> clonedFiles;
     91     for (auto& file : files)
     92     {
     93         clonedFiles.push_back(std::move(*GetAppFile(file.GetFileId(),
     94                                                     file.GetUrl(),
     95                                                     file.GetSizeInBytes(),
     96                                                     file.GetHashes(),
     97                                                     file.GetApplicabilityDetails().GetArchitectures(),
     98                                                     file.GetApplicabilityDetails().GetPlatformApplicabilityForPackage(),
     99                                                     file.GetFileMoniker())));
    100     }
    101 
    102     std::unique_ptr<AppContent> appContent;
    103     REQUIRE(
    104         AppContent::Make(std::move(contentId), updateId, std::move(clonedPreqs), std::move(clonedFiles), appContent) ==
    105         Result::Success);
    106     REQUIRE(appContent != nullptr);
    107     return appContent;
    108 }
    109 } // namespace
    110 
    111 TEST("Testing AppContent::Make()")
    112 {
    113     const std::string contentNameSpace{"myNameSpace"};
    114     const std::string contentName{"myName"};
    115     const std::string contentVersion{"myVersion"};
    116 
    117     std::unique_ptr<AppFile> file1 = GetAppFile("fileId1",
    118                                                 "url1",
    119                                                 1 /*sizeInBytes*/,
    120                                                 {{HashType::Sha1, "sha1"}},
    121                                                 {Architecture::Amd64},
    122                                                 {"myPlatformApplicabilityForPackage1"},
    123                                                 "fileMoniker1");
    124     std::unique_ptr<AppFile> file2 = GetAppFile("fileId2",
    125                                                 "url2",
    126                                                 1 /*sizeInBytes*/,
    127                                                 {{HashType::Sha256, "sha256"}},
    128                                                 {Architecture::Amd64},
    129                                                 {"myPlatformApplicabilityForPackage1"},
    130                                                 "fileMoniker1");
    131 
    132     std::vector<AppFile> files;
    133     files.push_back(std::move(*file1));
    134     files.push_back(std::move(*file2));
    135 
    136     std::vector<AppFile> prereqFiles;
    137     prereqFiles.push_back(std::move(*GetAppFile("prereqFileId",
    138                                                 "url",
    139                                                 1 /*sizeInBytes*/,
    140                                                 {{HashType::Sha1, "sha1"}},
    141                                                 {Architecture::Amd64},
    142                                                 {"myPlatformApplicabilityForPackage"},
    143                                                 "fileMoniker")));
    144 
    145     std::vector<AppPrerequisiteContent> prerequisites;
    146     prerequisites.push_back(
    147         std::move(*GetPrerequisiteContent(contentNameSpace, "prereqName", "prereqVersion", prereqFiles)));
    148 
    149     std::unique_ptr<AppContent> appContent =
    150         GetAppContent(contentNameSpace, contentName, contentVersion, "updateId", prerequisites, files);
    151     REQUIRE(appContent != nullptr);
    152 }
    153 
    154 TEST("Testing AppContent equality operators")
    155 {
    156     const std::string contentNameSpace{"myNameSpace"};
    157     const std::string contentName{"myName"};
    158     const std::string contentVersion{"myVersion"};
    159     const std::string updateId{"myUpdateId"};
    160 
    161     std::unique_ptr<AppFile> file = GetAppFile("fileId",
    162                                                "url",
    163                                                1 /*sizeInBytes*/,
    164                                                {{HashType::Sha1, "sha1"}},
    165                                                {Architecture::Amd64},
    166                                                {"myPlatformApplicabilityForPackage"},
    167                                                "fileMoniker");
    168 
    169     std::vector<AppFile> files;
    170     files.push_back(std::move(*file));
    171 
    172     std::vector<AppFile> prereqFiles;
    173     prereqFiles.push_back(std::move(*GetAppFile("prereqFileId",
    174                                                 "url",
    175                                                 1 /*sizeInBytes*/,
    176                                                 {{HashType::Sha1, "sha1"}},
    177                                                 {Architecture::Amd64},
    178                                                 {"myPlatformApplicabilityForPackage"},
    179                                                 "fileMoniker")));
    180 
    181     std::vector<AppPrerequisiteContent> prerequisites;
    182     prerequisites.push_back(
    183         std::move(*GetPrerequisiteContent(contentNameSpace, "prereqName", "prereqVersion", prereqFiles)));
    184 
    185     const std::unique_ptr<AppContent> content =
    186         GetAppContent(contentNameSpace, contentName, contentVersion, updateId, prerequisites, files);
    187 
    188     SECTION("Equal")
    189     {
    190         auto CompareAppContentEqual = [&content](const std::unique_ptr<AppContent>& sameContent) {
    191             REQUIRE((*content == *sameContent));
    192             REQUIRE_FALSE((*content != *sameContent));
    193         };
    194 
    195         CompareAppContentEqual(
    196             GetAppContent(contentNameSpace, contentName, contentVersion, updateId, prerequisites, files));
    197     }
    198 
    199     SECTION("Not equal")
    200     {
    201         auto CompareAppContentNotEqual = [&content](const std::unique_ptr<AppContent>& otherContent) {
    202             REQUIRE((*content != *otherContent));
    203             REQUIRE_FALSE((*content == *otherContent));
    204         };
    205 
    206         CompareAppContentNotEqual(GetAppContent("", contentName, contentVersion, updateId, prerequisites, files));
    207         CompareAppContentNotEqual(GetAppContent(contentNameSpace, "", contentVersion, updateId, prerequisites, files));
    208         CompareAppContentNotEqual(GetAppContent(contentNameSpace, contentName, "", updateId, prerequisites, files));
    209         CompareAppContentNotEqual(
    210             GetAppContent(contentNameSpace, contentName, contentVersion, "", prerequisites, files));
    211         CompareAppContentNotEqual(GetAppContent(contentNameSpace, contentName, contentVersion, updateId, {}, files));
    212         CompareAppContentNotEqual(
    213             GetAppContent(contentNameSpace, contentName, contentVersion, updateId, prerequisites, {}));
    214     }
    215 }