Mercurial > hg > orthanc
comparison UnitTestsSources/MultiThreadingTests.cpp @ 2666:2540ac79ab6c jobs
SequenceOfOperationsJob serialization
author | Sebastien Jodogne <s.jodogne@gmail.com> |
---|---|
date | Fri, 08 Jun 2018 15:05:32 +0200 |
parents | 389d050a2e66 |
children | 5fa2f2ce74f0 |
comparison
equal
deleted
inserted
replaced
2665:389d050a2e66 | 2666:2540ac79ab6c |
---|---|
34 #include "PrecompiledHeadersUnitTests.h" | 34 #include "PrecompiledHeadersUnitTests.h" |
35 #include "gtest/gtest.h" | 35 #include "gtest/gtest.h" |
36 | 36 |
37 #include "../Core/FileStorage/MemoryStorageArea.h" | 37 #include "../Core/FileStorage/MemoryStorageArea.h" |
38 #include "../Core/JobsEngine/JobsEngine.h" | 38 #include "../Core/JobsEngine/JobsEngine.h" |
39 #include "../Core/Logging.h" | |
39 #include "../Core/MultiThreading/SharedMessageQueue.h" | 40 #include "../Core/MultiThreading/SharedMessageQueue.h" |
40 #include "../Core/OrthancException.h" | 41 #include "../Core/OrthancException.h" |
41 #include "../Core/SerializationToolbox.h" | 42 #include "../Core/SerializationToolbox.h" |
42 #include "../Core/SystemToolbox.h" | 43 #include "../Core/SystemToolbox.h" |
43 #include "../Core/Toolbox.h" | 44 #include "../Core/Toolbox.h" |
742 | 743 |
743 engine.Stop(); | 744 engine.Stop(); |
744 } | 745 } |
745 | 746 |
746 | 747 |
748 static bool CheckSameJson(const Json::Value& a, | |
749 const Json::Value& b) | |
750 { | |
751 std::string s = a.toStyledString(); | |
752 std::string t = b.toStyledString(); | |
753 | |
754 if (s == t) | |
755 { | |
756 return true; | |
757 } | |
758 else | |
759 { | |
760 LOG(ERROR) << "Expected serialization: " << s; | |
761 LOG(ERROR) << "Actual serialization: " << t; | |
762 return false; | |
763 } | |
764 } | |
765 | |
766 | |
767 static bool CheckIdempotentSerialization(IJobUnserializer& unserializer, | |
768 IJob& job) | |
769 { | |
770 Json::Value a = 42; | |
771 | |
772 if (!job.Serialize(a)) | |
773 { | |
774 return false; | |
775 } | |
776 else | |
777 { | |
778 std::auto_ptr<IJob> unserialized(unserializer.UnserializeJob(a)); | |
779 | |
780 Json::Value b = 43; | |
781 if (unserialized->Serialize(b)) | |
782 { | |
783 return CheckSameJson(a, b); | |
784 } | |
785 else | |
786 { | |
787 return false; | |
788 } | |
789 } | |
790 } | |
791 | |
792 | |
793 static bool CheckIdempotentSerialization(IJobUnserializer& unserializer, | |
794 IJobOperation& operation) | |
795 { | |
796 Json::Value a = 42; | |
797 operation.Serialize(a); | |
798 | |
799 std::auto_ptr<IJobOperation> unserialized(unserializer.UnserializeOperation(a)); | |
800 | |
801 Json::Value b = 43; | |
802 unserialized->Serialize(b); | |
803 | |
804 return CheckSameJson(a, b); | |
805 } | |
806 | |
807 | |
808 static bool CheckIdempotentSerialization(IJobUnserializer& unserializer, | |
809 JobOperationValue& value) | |
810 { | |
811 Json::Value a = 42; | |
812 value.Serialize(a); | |
813 | |
814 std::auto_ptr<JobOperationValue> unserialized(unserializer.UnserializeValue(a)); | |
815 | |
816 Json::Value b = 43; | |
817 unserialized->Serialize(b); | |
818 | |
819 return CheckSameJson(a, b); | |
820 } | |
821 | |
822 | |
747 TEST(JobsSerialization, BadFileFormat) | 823 TEST(JobsSerialization, BadFileFormat) |
748 { | 824 { |
749 GenericJobUnserializer unserializer; | 825 GenericJobUnserializer unserializer; |
750 | 826 |
751 Json::Value s; | 827 Json::Value s; |
800 } | 876 } |
801 | 877 |
802 | 878 |
803 TEST(JobsSerialization, GenericValues) | 879 TEST(JobsSerialization, GenericValues) |
804 { | 880 { |
881 GenericJobUnserializer unserializer; | |
805 Json::Value s; | 882 Json::Value s; |
806 | 883 |
807 { | 884 { |
808 NullOperationValue null; | 885 NullOperationValue null; |
809 | 886 |
810 s = 42; | 887 ASSERT_TRUE(CheckIdempotentSerialization(unserializer, null)); |
811 null.Serialize(s); | 888 null.Serialize(s); |
812 } | 889 } |
813 | 890 |
814 GenericJobUnserializer unserializer; | |
815 ASSERT_THROW(unserializer.UnserializeJob(s), OrthancException); | 891 ASSERT_THROW(unserializer.UnserializeJob(s), OrthancException); |
816 ASSERT_THROW(unserializer.UnserializeOperation(s), OrthancException); | 892 ASSERT_THROW(unserializer.UnserializeOperation(s), OrthancException); |
817 | 893 |
818 std::auto_ptr<JobOperationValue> value; | 894 std::auto_ptr<JobOperationValue> value; |
819 value.reset(unserializer.UnserializeValue(s)); | 895 value.reset(unserializer.UnserializeValue(s)); |
821 ASSERT_EQ(JobOperationValue::Type_Null, value->GetType()); | 897 ASSERT_EQ(JobOperationValue::Type_Null, value->GetType()); |
822 | 898 |
823 { | 899 { |
824 StringOperationValue str("Hello"); | 900 StringOperationValue str("Hello"); |
825 | 901 |
826 s = 42; | 902 ASSERT_TRUE(CheckIdempotentSerialization(unserializer, str)); |
827 str.Serialize(s); | 903 str.Serialize(s); |
828 } | 904 } |
829 | 905 |
830 ASSERT_THROW(unserializer.UnserializeJob(s), OrthancException); | 906 ASSERT_THROW(unserializer.UnserializeJob(s), OrthancException); |
831 ASSERT_THROW(unserializer.UnserializeOperation(s), OrthancException); | 907 ASSERT_THROW(unserializer.UnserializeOperation(s), OrthancException); |
836 } | 912 } |
837 | 913 |
838 | 914 |
839 TEST(JobsSerialization, GenericOperations) | 915 TEST(JobsSerialization, GenericOperations) |
840 { | 916 { |
917 DummyUnserializer unserializer; | |
841 Json::Value s; | 918 Json::Value s; |
842 | 919 |
843 { | 920 { |
844 LogJobOperation operation; | 921 LogJobOperation operation; |
845 | 922 |
846 s = 42; | 923 ASSERT_TRUE(CheckIdempotentSerialization(unserializer, operation)); |
847 operation.Serialize(s); | 924 operation.Serialize(s); |
848 } | 925 } |
849 | 926 |
850 DummyUnserializer unserializer; | |
851 ASSERT_THROW(unserializer.UnserializeJob(s), OrthancException); | 927 ASSERT_THROW(unserializer.UnserializeJob(s), OrthancException); |
852 ASSERT_THROW(unserializer.UnserializeValue(s), OrthancException); | 928 ASSERT_THROW(unserializer.UnserializeValue(s), OrthancException); |
853 | 929 |
854 { | 930 { |
855 std::auto_ptr<IJobOperation> operation; | 931 std::auto_ptr<IJobOperation> operation; |
878 ASSERT_THROW(job.ExecuteStep(), OrthancException); // Not started yet | 954 ASSERT_THROW(job.ExecuteStep(), OrthancException); // Not started yet |
879 job.Start(); | 955 job.Start(); |
880 job.ExecuteStep(); | 956 job.ExecuteStep(); |
881 job.ExecuteStep(); | 957 job.ExecuteStep(); |
882 | 958 |
883 s = 42; | 959 { |
960 DummyUnserializer unserializer; | |
961 ASSERT_TRUE(CheckIdempotentSerialization(unserializer, job)); | |
962 } | |
963 | |
884 ASSERT_TRUE(job.Serialize(s)); | 964 ASSERT_TRUE(job.Serialize(s)); |
885 } | 965 } |
886 | 966 |
887 { | 967 { |
888 DummyUnserializer unserializer; | 968 DummyUnserializer unserializer; |
902 ASSERT_EQ("hello", tmp.GetInstance(0)); | 982 ASSERT_EQ("hello", tmp.GetInstance(0)); |
903 ASSERT_EQ("nope", tmp.GetInstance(1)); | 983 ASSERT_EQ("nope", tmp.GetInstance(1)); |
904 ASSERT_EQ("world", tmp.GetInstance(2)); | 984 ASSERT_EQ("world", tmp.GetInstance(2)); |
905 ASSERT_TRUE(tmp.IsFailedInstance("nope")); | 985 ASSERT_TRUE(tmp.IsFailedInstance("nope")); |
906 } | 986 } |
987 | |
988 // SequenceOfOperationsJob | |
989 | |
990 { | |
991 SequenceOfOperationsJob job; | |
992 job.SetDescription("hello"); | |
993 | |
994 { | |
995 SequenceOfOperationsJob::Lock lock(job); | |
996 size_t a = lock.AddOperation(new LogJobOperation); | |
997 size_t b = lock.AddOperation(new LogJobOperation); | |
998 lock.Connect(a, b); | |
999 lock.AddInput(a, StringOperationValue("hello")); | |
1000 lock.AddInput(a, StringOperationValue("world")); | |
1001 lock.SetDicomAssociationTimeout(200); | |
1002 lock.SetTrailingOperationTimeout(300); | |
1003 } | |
1004 | |
1005 ASSERT_EQ(JobStepCode_Continue, job.ExecuteStep().GetCode()); | |
1006 | |
1007 { | |
1008 GenericJobUnserializer unserializer; | |
1009 ASSERT_TRUE(CheckIdempotentSerialization(unserializer, job)); | |
1010 } | |
1011 | |
1012 ASSERT_TRUE(job.Serialize(s)); | |
1013 } | |
1014 | |
1015 { | |
1016 GenericJobUnserializer unserializer; | |
1017 ASSERT_THROW(unserializer.UnserializeValue(s), OrthancException); | |
1018 ASSERT_THROW(unserializer.UnserializeOperation(s), OrthancException); | |
1019 | |
1020 std::auto_ptr<IJob> job; | |
1021 job.reset(unserializer.UnserializeJob(s)); | |
1022 | |
1023 std::string tmp; | |
1024 dynamic_cast<SequenceOfOperationsJob&>(*job).GetDescription(tmp); | |
1025 ASSERT_EQ("hello", tmp); | |
1026 } | |
907 } | 1027 } |
908 | 1028 |
909 | 1029 |
910 static bool IsSameTagValue(ParsedDicomFile& dicom1, | 1030 static bool IsSameTagValue(ParsedDicomFile& dicom1, |
911 ParsedDicomFile& dicom2, | 1031 ParsedDicomFile& dicom2, |
1042 ASSERT_EQ(RequestOrigin_Plugins, origin.GetRequestOrigin()); | 1162 ASSERT_EQ(RequestOrigin_Plugins, origin.GetRequestOrigin()); |
1043 } | 1163 } |
1044 } | 1164 } |
1045 | 1165 |
1046 | 1166 |
1047 TEST(JobsSerialization, Registry) | |
1048 { | |
1049 // TODO : Test serialization of JobsRegistry | |
1050 } | |
1051 | |
1052 | |
1053 namespace | 1167 namespace |
1054 { | 1168 { |
1055 class OrthancJobsSerialization : public testing::Test | 1169 class OrthancJobsSerialization : public testing::Test |
1056 { | 1170 { |
1057 private: | 1171 private: |
1099 { | 1213 { |
1100 std::string id; | 1214 std::string id; |
1101 ASSERT_TRUE(CreateInstance(id)); | 1215 ASSERT_TRUE(CreateInstance(id)); |
1102 | 1216 |
1103 Json::Value s; | 1217 Json::Value s; |
1104 | |
1105 { | |
1106 DicomInstanceOperationValue instance(GetContext(), id); | |
1107 | |
1108 s = 42; | |
1109 instance.Serialize(s); | |
1110 } | |
1111 | |
1112 OrthancJobUnserializer unserializer(GetContext()); | 1218 OrthancJobUnserializer unserializer(GetContext()); |
1113 | 1219 |
1220 { | |
1221 DicomInstanceOperationValue instance(GetContext(), id); | |
1222 | |
1223 ASSERT_TRUE(CheckIdempotentSerialization(unserializer, instance)); | |
1224 instance.Serialize(s); | |
1225 } | |
1226 | |
1114 std::auto_ptr<JobOperationValue> value; | 1227 std::auto_ptr<JobOperationValue> value; |
1115 value.reset(unserializer.UnserializeValue(s)); | 1228 value.reset(unserializer.UnserializeValue(s)); |
1116 ASSERT_EQ(JobOperationValue::Type_DicomInstance, value->GetType()); | 1229 ASSERT_EQ(JobOperationValue::Type_DicomInstance, value->GetType()); |
1117 ASSERT_EQ(id, dynamic_cast<DicomInstanceOperationValue&>(*value).GetId()); | 1230 ASSERT_EQ(id, dynamic_cast<DicomInstanceOperationValue&>(*value).GetId()); |
1118 | 1231 |
1131 { | 1244 { |
1132 std::string id; | 1245 std::string id; |
1133 ASSERT_TRUE(CreateInstance(id)); | 1246 ASSERT_TRUE(CreateInstance(id)); |
1134 | 1247 |
1135 Json::Value s; | 1248 Json::Value s; |
1249 OrthancJobUnserializer unserializer(GetContext()); | |
1136 | 1250 |
1137 // DeleteResourceOperation | 1251 // DeleteResourceOperation |
1138 | 1252 |
1139 { | 1253 { |
1140 DeleteResourceOperation operation(GetContext()); | 1254 DeleteResourceOperation operation(GetContext()); |
1141 | 1255 |
1142 s = 42; | 1256 ASSERT_TRUE(CheckIdempotentSerialization(unserializer, operation)); |
1143 operation.Serialize(s); | 1257 operation.Serialize(s); |
1144 } | 1258 } |
1145 | 1259 |
1146 OrthancJobUnserializer unserializer(GetContext()); | |
1147 std::auto_ptr<IJobOperation> operation; | 1260 std::auto_ptr<IJobOperation> operation; |
1148 | 1261 |
1149 { | 1262 { |
1150 operation.reset(unserializer.UnserializeOperation(s)); | 1263 operation.reset(unserializer.UnserializeOperation(s)); |
1151 | 1264 |
1162 peer.SetPassword("password"); | 1275 peer.SetPassword("password"); |
1163 peer.SetPkcs11Enabled(true); | 1276 peer.SetPkcs11Enabled(true); |
1164 | 1277 |
1165 StorePeerOperation operation(peer); | 1278 StorePeerOperation operation(peer); |
1166 | 1279 |
1167 s = 42; | 1280 ASSERT_TRUE(CheckIdempotentSerialization(unserializer, operation)); |
1168 operation.Serialize(s); | 1281 operation.Serialize(s); |
1169 } | 1282 } |
1170 | 1283 |
1171 { | 1284 { |
1172 operation.reset(unserializer.UnserializeOperation(s)); | 1285 operation.reset(unserializer.UnserializeOperation(s)); |
1187 modality.SetPort(1000); | 1300 modality.SetPort(1000); |
1188 modality.SetManufacturer(ModalityManufacturer_StoreScp); | 1301 modality.SetManufacturer(ModalityManufacturer_StoreScp); |
1189 | 1302 |
1190 StoreScuOperation operation("TEST", modality); | 1303 StoreScuOperation operation("TEST", modality); |
1191 | 1304 |
1192 s = 42; | 1305 ASSERT_TRUE(CheckIdempotentSerialization(unserializer, operation)); |
1193 operation.Serialize(s); | 1306 operation.Serialize(s); |
1194 } | 1307 } |
1195 | 1308 |
1196 { | 1309 { |
1197 operation.reset(unserializer.UnserializeOperation(s)); | 1310 operation.reset(unserializer.UnserializeOperation(s)); |
1210 SystemCallOperation operation(std::string("echo")); | 1323 SystemCallOperation operation(std::string("echo")); |
1211 operation.AddPreArgument("a"); | 1324 operation.AddPreArgument("a"); |
1212 operation.AddPreArgument("b"); | 1325 operation.AddPreArgument("b"); |
1213 operation.AddPostArgument("c"); | 1326 operation.AddPostArgument("c"); |
1214 | 1327 |
1215 s = 42; | 1328 ASSERT_TRUE(CheckIdempotentSerialization(unserializer, operation)); |
1216 operation.Serialize(s); | 1329 operation.Serialize(s); |
1217 } | 1330 } |
1218 | 1331 |
1219 { | 1332 { |
1220 operation.reset(unserializer.UnserializeOperation(s)); | 1333 operation.reset(unserializer.UnserializeOperation(s)); |
1234 std::auto_ptr<DicomModification> modification(new DicomModification); | 1347 std::auto_ptr<DicomModification> modification(new DicomModification); |
1235 modification->SetupAnonymization(DicomVersion_2008); | 1348 modification->SetupAnonymization(DicomVersion_2008); |
1236 | 1349 |
1237 ModifyInstanceOperation operation(GetContext(), RequestOrigin_Lua, modification.release()); | 1350 ModifyInstanceOperation operation(GetContext(), RequestOrigin_Lua, modification.release()); |
1238 | 1351 |
1239 s = 42; | 1352 ASSERT_TRUE(CheckIdempotentSerialization(unserializer, operation)); |
1240 operation.Serialize(s); | 1353 operation.Serialize(s); |
1241 } | 1354 } |
1242 | 1355 |
1243 { | 1356 { |
1244 operation.reset(unserializer.UnserializeOperation(s)); | 1357 operation.reset(unserializer.UnserializeOperation(s)); |
1261 ArchiveJob job(tmp, GetContext(), false, false); | 1374 ArchiveJob job(tmp, GetContext(), false, false); |
1262 ASSERT_FALSE(job.Serialize(s)); // Cannot serialize this | 1375 ASSERT_FALSE(job.Serialize(s)); // Cannot serialize this |
1263 } | 1376 } |
1264 | 1377 |
1265 // DicomModalityStoreJob | 1378 // DicomModalityStoreJob |
1379 | |
1380 OrthancJobUnserializer unserializer(GetContext()); | |
1266 | 1381 |
1267 { | 1382 { |
1268 RemoteModalityParameters modality; | 1383 RemoteModalityParameters modality; |
1269 modality.SetApplicationEntityTitle("REMOTE"); | 1384 modality.SetApplicationEntityTitle("REMOTE"); |
1270 modality.SetHost("192.168.1.1"); | 1385 modality.SetHost("192.168.1.1"); |
1274 DicomModalityStoreJob job(GetContext()); | 1389 DicomModalityStoreJob job(GetContext()); |
1275 job.SetLocalAet("LOCAL"); | 1390 job.SetLocalAet("LOCAL"); |
1276 job.SetRemoteModality(modality); | 1391 job.SetRemoteModality(modality); |
1277 job.SetMoveOriginator("MOVESCU", 42); | 1392 job.SetMoveOriginator("MOVESCU", 42); |
1278 | 1393 |
1279 s = 42; | 1394 ASSERT_TRUE(CheckIdempotentSerialization(unserializer, job)); |
1280 ASSERT_TRUE(job.Serialize(s)); | 1395 ASSERT_TRUE(job.Serialize(s)); |
1281 } | 1396 } |
1282 | |
1283 OrthancJobUnserializer unserializer(GetContext()); | |
1284 | 1397 |
1285 { | 1398 { |
1286 std::auto_ptr<IJob> job; | 1399 std::auto_ptr<IJob> job; |
1287 job.reset(unserializer.UnserializeJob(s)); | 1400 job.reset(unserializer.UnserializeJob(s)); |
1288 | 1401 |
1307 peer.SetPkcs11Enabled(true); | 1420 peer.SetPkcs11Enabled(true); |
1308 | 1421 |
1309 OrthancPeerStoreJob job(GetContext()); | 1422 OrthancPeerStoreJob job(GetContext()); |
1310 job.SetPeer(peer); | 1423 job.SetPeer(peer); |
1311 | 1424 |
1312 s = 42; | 1425 ASSERT_TRUE(CheckIdempotentSerialization(unserializer, job)); |
1313 ASSERT_TRUE(job.Serialize(s)); | 1426 ASSERT_TRUE(job.Serialize(s)); |
1314 } | 1427 } |
1315 | 1428 |
1316 { | 1429 { |
1317 std::auto_ptr<IJob> job; | 1430 std::auto_ptr<IJob> job; |
1332 | 1445 |
1333 ResourceModificationJob job(GetContext()); | 1446 ResourceModificationJob job(GetContext()); |
1334 job.SetModification(modification.release(), true); | 1447 job.SetModification(modification.release(), true); |
1335 job.SetOrigin(DicomInstanceOrigin::FromLua()); | 1448 job.SetOrigin(DicomInstanceOrigin::FromLua()); |
1336 | 1449 |
1337 s = 42; | 1450 ASSERT_TRUE(CheckIdempotentSerialization(unserializer, job)); |
1338 ASSERT_TRUE(job.Serialize(s)); | 1451 ASSERT_TRUE(job.Serialize(s)); |
1339 } | 1452 } |
1340 | 1453 |
1341 { | 1454 { |
1342 std::auto_ptr<IJob> job; | 1455 std::auto_ptr<IJob> job; |
1345 ResourceModificationJob& tmp = dynamic_cast<ResourceModificationJob&>(*job); | 1458 ResourceModificationJob& tmp = dynamic_cast<ResourceModificationJob&>(*job); |
1346 ASSERT_TRUE(tmp.IsAnonymization()); | 1459 ASSERT_TRUE(tmp.IsAnonymization()); |
1347 ASSERT_EQ(RequestOrigin_Lua, tmp.GetOrigin().GetRequestOrigin()); | 1460 ASSERT_EQ(RequestOrigin_Lua, tmp.GetOrigin().GetRequestOrigin()); |
1348 ASSERT_TRUE(tmp.GetModification().IsRemoved(DICOM_TAG_STUDY_DESCRIPTION)); | 1461 ASSERT_TRUE(tmp.GetModification().IsRemoved(DICOM_TAG_STUDY_DESCRIPTION)); |
1349 } | 1462 } |
1350 | 1463 } |
1351 // SequenceOfOperationsJob.h | 1464 |
1352 | 1465 |
1353 { | 1466 TEST(JobsSerialization, Registry) |
1354 SequenceOfOperationsJob job; | 1467 { |
1355 | 1468 // TODO : Test serialization of JobsRegistry |
1356 s = 42; | 1469 } |
1357 ASSERT_TRUE(job.Serialize(s)); | |
1358 } | |
1359 | |
1360 std::cout << s; | |
1361 } |