package.cpp (7506B)
1 #include "helper.hpp" 2 3 #include <errors.hpp> 4 #include <index.hpp> 5 #include <package.hpp> 6 7 static const char *M = "[package]"; 8 9 TEST_CASE("package type from string", M) { 10 constexpr std::pair<const char *, Package::Type> tests[] { 11 {"yoyo", Package::UnknownType}, 12 {"script", Package::ScriptType}, 13 {"extension", Package::ExtensionType}, 14 {"effect", Package::EffectType}, 15 {"data", Package::DataType}, 16 {"theme", Package::ThemeType}, 17 {"langpack", Package::LangPackType}, 18 {"webinterface", Package::WebInterfaceType}, 19 {"projecttpl", Package::ProjectTemplateType}, 20 {"tracktpl", Package::TrackTemplateType}, 21 {"midinotenames", Package::MIDINoteNamesType}, 22 {"autoitem", Package::AutomationItemType}, 23 }; 24 25 for(const auto &[typeString, typeId] : tests) 26 REQUIRE(Package::getType(typeString) == typeId); 27 } 28 29 TEST_CASE("package type to string", M) { 30 const std::pair<Package::Type, std::string> tests[] { 31 {Package::UnknownType, "Unknown"}, 32 {Package::ScriptType, "Script"}, 33 {Package::ExtensionType, "Extension"}, 34 {Package::EffectType, "Effect"}, 35 {Package::DataType, "Data"}, 36 {Package::ThemeType, "Theme"}, 37 {Package::LangPackType, "Language Pack"}, 38 {Package::WebInterfaceType, "Web Interface"}, 39 {Package::ProjectTemplateType, "Project Template"}, 40 {Package::TrackTemplateType, "Track Template"}, 41 {Package::MIDINoteNamesType, "MIDI Note Names"}, 42 {Package::AutomationItemType, "Automation Item"}, 43 {static_cast<Package::Type>(-1), "Unknown"}, 44 }; 45 46 for(const auto &[type, displayName] : tests) 47 REQUIRE(Package::displayType(type) == displayName); 48 } 49 50 TEST_CASE("invalid package name", M) { 51 SECTION("empty") { 52 try { 53 Package pack(Package::ScriptType, {}, nullptr); 54 FAIL(); 55 } 56 catch(const reapack_error &e) { 57 REQUIRE(std::string{e.what()} == "empty package name"); 58 } 59 } 60 61 SECTION("slash") { 62 try { 63 Package pack(Package::ScriptType, "hello/world", nullptr); 64 FAIL(); 65 } 66 catch(const reapack_error &e) { 67 REQUIRE(std::string{e.what()} == "invalid package name 'hello/world'"); 68 } 69 } 70 71 SECTION("backslash") { 72 try { 73 Package pack(Package::ScriptType, "hello\\world", nullptr); 74 FAIL(); 75 } 76 catch(const reapack_error &e) { 77 REQUIRE(std::string{e.what()} == "invalid package name 'hello\\world'"); 78 } 79 } 80 } 81 82 TEST_CASE("package versions are sorted", M) { 83 Index ri("Remote Name"); 84 Category cat("Category Name", &ri); 85 86 Package pack(Package::ScriptType, "a", &cat); 87 CHECK(pack.versions().size() == 0); 88 89 Version *final = new Version("1", &pack); 90 final->addSource(new Source({}, "google.com", final)); 91 92 Version *alpha = new Version("0.1", &pack); 93 alpha->addSource(new Source({}, "google.com", alpha)); 94 95 REQUIRE(pack.addVersion(final)); 96 REQUIRE(final->package() == &pack); 97 CHECK(pack.versions().size() == 1); 98 99 pack.addVersion(alpha); 100 CHECK(pack.versions().size() == 2); 101 102 REQUIRE(pack.version(0) == alpha); 103 REQUIRE(pack.version(1) == final); 104 REQUIRE(pack.lastVersion() == final); 105 } 106 107 TEST_CASE("get latest stable version", M) { 108 Index ri("Remote Name"); 109 Category cat("Category Name", &ri); 110 Package pack(Package::ScriptType, "a", &cat); 111 112 Version *alpha = new Version("2.0-alpha", &pack); 113 alpha->addSource(new Source({}, "google.com", alpha)); 114 REQUIRE(pack.addVersion(alpha)); 115 116 SECTION("only prereleases are available") 117 REQUIRE(pack.lastVersion(false) == nullptr); 118 119 SECTION("an older stable release is available") { 120 Version *final = new Version("1.0", &pack); 121 final->addSource(new Source({}, "google.com", final)); 122 pack.addVersion(final); 123 124 REQUIRE(pack.lastVersion(false) == final); 125 } 126 127 REQUIRE(pack.lastVersion() == alpha); 128 REQUIRE(pack.lastVersion(true) == alpha); 129 } 130 131 TEST_CASE("pre-release updates", M) { 132 Index ri("Remote Name"); 133 Category cat("Category Name", &ri); 134 Package pack(Package::ScriptType, "a", &cat); 135 136 Version *stable1 = new Version("0.9", &pack); 137 stable1->addSource(new Source({}, "google.com", stable1)); 138 pack.addVersion(stable1); 139 140 Version *alpha1 = new Version("1.0-alpha1", &pack); 141 alpha1->addSource(new Source({}, "google.com", alpha1)); 142 pack.addVersion(alpha1); 143 144 Version *alpha2 = new Version("1.0-alpha2", &pack); 145 alpha2->addSource(new Source({}, "google.com", alpha2)); 146 pack.addVersion(alpha2); 147 148 SECTION("pre-release to next pre-release") 149 REQUIRE(pack.lastVersion(false, {"1.0-alpha1"}) == alpha2); 150 151 SECTION("pre-release to latest stable") { 152 Version *stable2 = new Version("1.0", &pack); 153 stable2->addSource(new Source({}, "google.com", stable2)); 154 pack.addVersion(stable2); 155 156 Version *stable3 = new Version("1.1", &pack); 157 stable3->addSource(new Source({}, "google.com", stable3)); 158 pack.addVersion(stable3); 159 160 Version *beta = new Version("2.0-beta", &pack); 161 beta->addSource(new Source({}, "google.com", beta)); 162 pack.addVersion(beta); 163 164 REQUIRE(pack.lastVersion(false, {"1.0-alpha1"}) == stable3); 165 } 166 } 167 168 TEST_CASE("drop empty version", M) { 169 Package pack(Package::ScriptType, "a", nullptr); 170 const Version ver("1", &pack); 171 REQUIRE_FALSE(pack.addVersion(&ver)); 172 REQUIRE(pack.versions().empty()); 173 REQUIRE(pack.lastVersion() == nullptr); 174 } 175 176 TEST_CASE("add owned version", M) { 177 Package pack1(Package::ScriptType, "a", nullptr); 178 Package pack2(Package::ScriptType, "a", nullptr); 179 180 Version *ver = new Version("1", &pack1); 181 182 try { 183 pack2.addVersion(ver); 184 FAIL(); 185 } 186 catch(const reapack_error &e) { 187 delete ver; 188 REQUIRE(std::string{e.what()} == "version belongs to another package"); 189 } 190 } 191 192 TEST_CASE("add duplicate version", M) { 193 Index ri("r"); 194 Category cat("c", &ri); 195 Package pack(Package::ScriptType, "p", &cat); 196 197 Version *ver = new Version("1", &pack); 198 ver->addSource(new Source({}, "google.com", ver)); 199 pack.addVersion(ver); 200 201 try { 202 pack.addVersion(ver); // could also be an equivalent version with same value 203 FAIL(); 204 } 205 catch(const reapack_error &e) { 206 REQUIRE(std::string{e.what()} == "duplicate version 'r/c/p v1'"); 207 } 208 } 209 210 TEST_CASE("find matching version", M) { 211 Index ri("Remote Name"); 212 Category cat("Category Name", &ri); 213 214 Package pack(Package::ScriptType, "a", &cat); 215 CHECK(pack.versions().size() == 0); 216 217 Version *ver = new Version("1", &pack); 218 ver->addSource(new Source({}, "google.com", ver)); 219 220 REQUIRE(pack.findVersion({"1"}) == nullptr); 221 REQUIRE(pack.findVersion({"2"}) == nullptr); 222 223 pack.addVersion(ver); 224 225 REQUIRE(pack.findVersion({"1"}) == ver); 226 REQUIRE(pack.findVersion({"2"}) == nullptr); 227 } 228 229 TEST_CASE("package full name", M) { 230 const Index ri("Index Name"); 231 const Category cat("Category Name", &ri); 232 Package pack(Package::ScriptType, "file.name", &cat); 233 234 REQUIRE(pack.fullName() == "Index Name/Category Name/file.name"); 235 236 pack.setDescription("Hello World"); 237 REQUIRE(pack.fullName() == "Index Name/Category Name/Hello World"); 238 } 239 240 TEST_CASE("package description", M) { 241 Package pack(Package::ScriptType, "test.lua", nullptr); 242 REQUIRE(pack.description().empty()); 243 244 pack.setDescription("hello world"); 245 REQUIRE(pack.description() == "hello world"); 246 } 247 248 TEST_CASE("package display name", M) { 249 Package pack(Package::ScriptType, "test.lua", nullptr); 250 REQUIRE(pack.displayName() == "test.lua"); 251 252 pack.setDescription("hello world"); 253 REQUIRE(pack.displayName() == "hello world"); 254 }