Mercurial > hg > orthanc

comparison UnitTestsSources/MultiThreadingTests.cpp @ 2655:c196d76cb8fa jobs

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
serialization
author Sebastien Jodogne <s.jodogne@gmail.com>
date Tue, 05 Jun 2018 17:57:49 +0200
parents d7815540bd81
children a6d3e45eeff5
comparison
equal deleted inserted replaced
2654:761031029aa9 2655:c196d76cb8fa
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/JobsEngine/Operations/LogJobOperation.h"
40 #include "../Core/JobsEngine/Operations/NullOperationValue.h"
41 #include "../Core/JobsEngine/Operations/StringOperationValue.h"
42 #include "../Core/MultiThreading/SharedMessageQueue.h" 39 #include "../Core/MultiThreading/SharedMessageQueue.h"
43 #include "../Core/OrthancException.h" 40 #include "../Core/OrthancException.h"
44 #include "../Core/SystemToolbox.h" 41 #include "../Core/SystemToolbox.h"
45 #include "../Core/Toolbox.h" 42 #include "../Core/Toolbox.h"
46 #include "../OrthancServer/DatabaseWrapper.h" 43 #include "../OrthancServer/DatabaseWrapper.h"
47 #include "../OrthancServer/ServerContext.h" 44 #include "../OrthancServer/ServerContext.h"
48 #include "../OrthancServer/ServerJobs/LuaJobManager.h" 45 #include "../OrthancServer/ServerJobs/LuaJobManager.h"
46 #include "../OrthancServer/ServerJobs/OrthancJobUnserializer.h"
47
48 #include "../Core/JobsEngine/Operations/JobOperationValues.h"
49 #include "../Core/JobsEngine/Operations/NullOperationValue.h"
50 #include "../Core/JobsEngine/Operations/StringOperationValue.h"
49 #include "../OrthancServer/ServerJobs/Operations/DicomInstanceOperationValue.h" 51 #include "../OrthancServer/ServerJobs/Operations/DicomInstanceOperationValue.h"
50 #include "../OrthancServer/ServerJobs/OrthancJobUnserializer.h" 52
53 #include "../Core/JobsEngine/Operations/LogJobOperation.h"
54 #include "../OrthancServer/ServerJobs/Operations/DeleteResourceOperation.h"
55 #include "../OrthancServer/ServerJobs/Operations/ModifyInstanceOperation.h"
56 #include "../OrthancServer/ServerJobs/Operations/StorePeerOperation.h"
57 #include "../OrthancServer/ServerJobs/Operations/StoreScuOperation.h"
58 #include "../OrthancServer/ServerJobs/Operations/SystemCallOperation.h"
59
60
51 61
52 using namespace Orthanc; 62 using namespace Orthanc;
53 63
54 namespace 64 namespace
55 { 65 {
157 class DummyUnserializer : public GenericJobUnserializer 167 class DummyUnserializer : public GenericJobUnserializer
158 { 168 {
159 public: 169 public:
160 virtual IJob* UnserializeJob(const Json::Value& value) 170 virtual IJob* UnserializeJob(const Json::Value& value)
161 { 171 {
162 if (GetString(value, "Type") == "DummyInstancesJob") 172 if (ReadString(value, "Type") == "DummyInstancesJob")
163 { 173 {
164 return new DummyInstancesJob(value); 174 return new DummyInstancesJob(value);
165 } 175 }
166 else 176 else
167 { 177 {
723 733
724 engine.Stop(); 734 engine.Stop();
725 } 735 }
726 736
727 737
738 TEST(JobsSerialization, BadFileFormat)
739 {
740 GenericJobUnserializer unserializer;
741
742 Json::Value s;
743
744 s = Json::objectValue;
745 ASSERT_THROW(unserializer.UnserializeValue(s), OrthancException);
746 ASSERT_THROW(unserializer.UnserializeJob(s), OrthancException);
747 ASSERT_THROW(unserializer.UnserializeOperation(s), OrthancException);
748
749 s = Json::arrayValue;
750 ASSERT_THROW(unserializer.UnserializeValue(s), OrthancException);
751 ASSERT_THROW(unserializer.UnserializeJob(s), OrthancException);
752 ASSERT_THROW(unserializer.UnserializeOperation(s), OrthancException);
753
754 s = "hello";
755 ASSERT_THROW(unserializer.UnserializeValue(s), OrthancException);
756 ASSERT_THROW(unserializer.UnserializeJob(s), OrthancException);
757 ASSERT_THROW(unserializer.UnserializeOperation(s), OrthancException);
758
759 s = 42;
760 ASSERT_THROW(unserializer.UnserializeValue(s), OrthancException);
761 ASSERT_THROW(unserializer.UnserializeJob(s), OrthancException);
762 ASSERT_THROW(unserializer.UnserializeOperation(s), OrthancException);
763 }
764
765
728 TEST(JobsSerialization, GenericValues) 766 TEST(JobsSerialization, GenericValues)
729 { 767 {
730 GenericJobUnserializer unserializer;
731
732 Json::Value s; 768 Json::Value s;
733 769
734 { 770 {
735 NullOperationValue null; 771 NullOperationValue null;
736 null.Serialize(s); 772 null.Serialize(s);
737 } 773 }
738 774
775 GenericJobUnserializer unserializer;
776 ASSERT_THROW(unserializer.UnserializeJob(s), OrthancException);
777 ASSERT_THROW(unserializer.UnserializeOperation(s), OrthancException);
778
739 std::auto_ptr<JobOperationValue> value; 779 std::auto_ptr<JobOperationValue> value;
780 value.reset(unserializer.UnserializeValue(s));
781
782 ASSERT_EQ(JobOperationValue::Type_Null, value->GetType());
783
784 {
785 StringOperationValue str("Hello");
786 str.Serialize(s);
787 }
788
740 ASSERT_THROW(unserializer.UnserializeJob(s), OrthancException); 789 ASSERT_THROW(unserializer.UnserializeJob(s), OrthancException);
741 ASSERT_THROW(unserializer.UnserializeOperation(s), OrthancException); 790 ASSERT_THROW(unserializer.UnserializeOperation(s), OrthancException);
742 value.reset(unserializer.UnserializeValue(s)); 791 value.reset(unserializer.UnserializeValue(s));
743
744 ASSERT_EQ(JobOperationValue::Type_Null, value->GetType());
745
746 {
747 StringOperationValue str("Hello");
748 str.Serialize(s);
749 }
750
751 ASSERT_THROW(unserializer.UnserializeJob(s), OrthancException);
752 ASSERT_THROW(unserializer.UnserializeOperation(s), OrthancException);
753 value.reset(unserializer.UnserializeValue(s));
754 792
755 ASSERT_EQ(JobOperationValue::Type_String, value->GetType()); 793 ASSERT_EQ(JobOperationValue::Type_String, value->GetType());
756 ASSERT_EQ("Hello", dynamic_cast<StringOperationValue&>(*value).GetContent()); 794 ASSERT_EQ("Hello", dynamic_cast<StringOperationValue&>(*value).GetContent());
757 } 795 }
758 796
759 797
798 TEST(JobsSerialization, JobOperationValues)
799 {
800 Json::Value s;
801
802 {
803 JobOperationValues values;
804 values.Append(new NullOperationValue);
805 values.Append(new StringOperationValue("hello"));
806 values.Append(new StringOperationValue("world"));
807 values.Serialize(s);
808 }
809
810 {
811 GenericJobUnserializer unserializer;
812 std::auto_ptr<JobOperationValues> values(JobOperationValues::Unserialize(unserializer, s));
813 ASSERT_EQ(3u, values->GetSize());
814 ASSERT_EQ(JobOperationValue::Type_Null, values->GetValue(0).GetType());
815 ASSERT_EQ(JobOperationValue::Type_String, values->GetValue(1).GetType());
816 ASSERT_EQ(JobOperationValue::Type_String, values->GetValue(2).GetType());
817
818 ASSERT_EQ("hello", dynamic_cast<const StringOperationValue&>(values->GetValue(1)).GetContent());
819 ASSERT_EQ("world", dynamic_cast<const StringOperationValue&>(values->GetValue(2)).GetContent());
820 }
821 }
822
823
824 TEST(JobsSerialization, GenericOperations)
825 {
826 Json::Value s;
827
828 {
829 LogJobOperation operation;
830 operation.Serialize(s);
831 }
832
833 DummyUnserializer unserializer;
834 ASSERT_THROW(unserializer.UnserializeJob(s), OrthancException);
835 ASSERT_THROW(unserializer.UnserializeValue(s), OrthancException);
836
837 {
838 std::auto_ptr<IJobOperation> operation;
839 operation.reset(unserializer.UnserializeOperation(s));
840
841 }
842
843 {
844
845 }
846 }
847
848
849
760 TEST(JobsSerialization, GenericJobs) 850 TEST(JobsSerialization, GenericJobs)
761 { 851 {
762 DummyUnserializer unserializer;
763
764 Json::Value s; 852 Json::Value s;
765 853
766 { 854 {
767 DummyInstancesJob job; 855 DummyInstancesJob job;
768 job.SetDescription("description"); 856 job.SetDescription("description");
770 job.AddInstance("ok"); 858 job.AddInstance("ok");
771 job.SetPermissive(true); 859 job.SetPermissive(true);
772 job.Serialize(s); 860 job.Serialize(s);
773 } 861 }
774 862
775 ASSERT_THROW(unserializer.UnserializeValue(s), OrthancException); 863 {
776 ASSERT_THROW(unserializer.UnserializeOperation(s), OrthancException); 864 DummyUnserializer unserializer;
777 865 ASSERT_THROW(unserializer.UnserializeValue(s), OrthancException);
778 std::auto_ptr<IJob> job; 866 ASSERT_THROW(unserializer.UnserializeOperation(s), OrthancException);
779 job.reset(unserializer.UnserializeJob(s)); 867
780 ASSERT_EQ("description", dynamic_cast<DummyInstancesJob&>(*job).GetDescription()); 868 std::auto_ptr<IJob> job;
781 //ASSERT_EQ("nope", dynamic_cast<DummyInstancesJob&>(*job).GetInstance(0)); 869 job.reset(unserializer.UnserializeJob(s));
782 } 870 ASSERT_EQ("description", dynamic_cast<DummyInstancesJob&>(*job).GetDescription());
783 871 //ASSERT_EQ("nope", dynamic_cast<DummyInstancesJob&>(*job).GetInstance(0));
784 872 }
785 TEST(JobsSerialization, OrthancValues) 873 }
786 { 874
787 MemoryStorageArea storage; 875
788 DatabaseWrapper db; // The SQLite DB is in memory 876 namespace
789 db.Open(); 877 {
790 ServerContext context(db, storage); 878 class OrthancJobsSerialization : public testing::Test
791 879 {
880 private:
881 MemoryStorageArea storage_;
882 DatabaseWrapper db_; // The SQLite DB is in memory
883 std::auto_ptr<ServerContext> context_;
884 TimeoutDicomConnectionManager manager_;
885
886 public:
887 OrthancJobsSerialization()
888 {
889 db_.Open();
890 context_.reset(new ServerContext(db_, storage_));
891 }
892
893 virtual ~OrthancJobsSerialization()
894 {
895 context_->Stop();
896 context_.reset(NULL);
897 db_.Close();
898 }
899
900 ServerContext& GetContext()
901 {
902 return *context_;
903 }
904
905 bool CreateInstance(std::string& id)
906 {
907 // Create a sample DICOM file
908 ParsedDicomFile dicom(true);
909 dicom.Replace(DICOM_TAG_PATIENT_NAME, std::string("JODOGNE"),
910 false, DicomReplaceMode_InsertIfAbsent);
911
912 DicomInstanceToStore toStore;
913 toStore.SetParsedDicomFile(dicom);
914
915 return (context_->Store(id, toStore) == StoreStatus_Success);
916 }
917 };
918 }
919
920
921 TEST_F(OrthancJobsSerialization, Values)
922 {
792 std::string id; 923 std::string id;
793 924 ASSERT_TRUE(CreateInstance(id));
794 { 925
795 ParsedDicomFile dicom(true); 926 Json::Value s;
796 dicom.Replace(DICOM_TAG_PATIENT_NAME, std::string("JODOGNE"), 927
797 false, DicomReplaceMode_InsertIfAbsent); 928 {
798 929 DicomInstanceOperationValue instance(GetContext(), id);
799 DicomInstanceToStore toStore; 930 instance.Serialize(s);
800 toStore.SetParsedDicomFile(dicom); 931 }
801 ASSERT_EQ(StoreStatus_Success, context.Store(id, toStore)); 932
802 } 933 OrthancJobUnserializer unserializer(GetContext());
803
804 {
805 OrthancJobUnserializer unserializer(context);
806 934
807 Json::Value s; 935 std::auto_ptr<JobOperationValue> value;
808 936 value.reset(unserializer.UnserializeValue(s));
809 { 937 ASSERT_EQ(JobOperationValue::Type_DicomInstance, value->GetType());
810 DicomInstanceOperationValue instance(context, id); 938 ASSERT_EQ(id, dynamic_cast<DicomInstanceOperationValue&>(*value).GetId());
811 instance.Serialize(s); 939
812 } 940 {
813 941 std::string content;
814 std::auto_ptr<JobOperationValue> value; 942 dynamic_cast<DicomInstanceOperationValue&>(*value).ReadDicom(content);
815 value.reset(unserializer.UnserializeValue(s)); 943
816 ASSERT_EQ(JobOperationValue::Type_DicomInstance, value->GetType()); 944 ParsedDicomFile dicom(content);
817 ASSERT_EQ(id, dynamic_cast<DicomInstanceOperationValue&>(*value).GetId()); 945 ASSERT_TRUE(dicom.GetTagValue(content, DICOM_TAG_PATIENT_NAME));
818 946 ASSERT_EQ("JODOGNE", content);
819 { 947 }
820 std::string content; 948 }
821 dynamic_cast<DicomInstanceOperationValue&>(*value).ReadDicom(content); 949
822 950
823 ParsedDicomFile dicom(content); 951 TEST_F(OrthancJobsSerialization, Operations)
824 ASSERT_TRUE(dicom.GetTagValue(content, DICOM_TAG_PATIENT_NAME)); 952 {
825 ASSERT_EQ("JODOGNE", content); 953 std::string id;
826 } 954 ASSERT_TRUE(CreateInstance(id));
827 } 955
828 956 Json::Value s;
829 context.Stop(); 957
830 } 958 {
959 DeleteResourceOperation operation(GetContext());
960 operation.Serialize(s);
961 }
962
963 OrthancJobUnserializer unserializer(GetContext());
964
965 std::auto_ptr<IJobOperation> operation;
966 operation.reset(unserializer.UnserializeOperation(s));
967 }