ContactDto tests added

Author: Marat-Gumerov

tests/conftest.py

@@ -19,7 +19,7 @@ def pytest_configure(config):
     config.addinivalue_line("markers", "ai")
 
 @pytest.fixture(scope="class")
-def test_data(request):
+def td(request):
     config = _get_config(request)
     app_sid = config["appsid"]
     app_key = config["appkey"]

tests/tests/sdk_test.py

@@ -7,124 +7,124 @@
 from dateutil import tz
 
 @pytest.mark.pipeline
-def test_hierarchical(test_data: TestData):
+def test_hierarchical(td: TestData):
     """
     HierarchicalObject serialization and deserialization test.
     This test checks that BaseObject.Type field filled automatically by SDK
     and properly used in serialization and deserialization
     """
-    calendarFile = _create_calendar(test_data)
-    calendar = test_data.email.get_calendar(requests.GetCalendarRequest(calendarFile, test_data.folder, test_data.storage))
+    calendarFile = _create_calendar(td)
+    calendar = td.email.get_calendar(requests.GetCalendarRequest(calendarFile, td.folder, td.storage))
     assert calendar.name == 'CALENDAR'
     assert calendar.type == 'HierarchicalObject'
     primitive_properties = list(filter(lambda x: x.type == 'PrimitiveObject', calendar.internal_properties))
     assert len(primitive_properties) >= 3
     assert primitive_properties[0].value is not None
 
 @pytest.mark.pipeline
-def test_async(test_data: TestData):
+def test_async(td: TestData):
     """
     Asynchronous API call test
     """
-    calendarFile = _create_calendar(test_data)
-    calendar = test_data.email.get_calendar_async(requests.GetCalendarRequest(calendarFile, test_data.folder, test_data.storage)).get()
+    calendarFile = _create_calendar(td)
+    calendar = td.email.get_calendar_async(requests.GetCalendarRequest(calendarFile, td.folder, td.storage)).get()
     assert calendar.name == 'CALENDAR'
 
 @pytest.mark.pipeline
-def test_file(test_data: TestData):
+def test_file(td: TestData):
     """
     File support test
     """
     sample = os.path.join(os.path.dirname(__file__), '..', 'data', 'sample.ics')
     file_name = str(uuid.uuid4()) + ".ics"
-    storage_location = test_data.folder + "/" + file_name
-    test_data.email.upload_file(requests.UploadFileRequest(storage_location, sample, test_data.storage))
-    rq = requests.UploadFileRequest(storage_location, sample, test_data.storage)
-    downloaded = test_data.email.download_file(requests.DownloadFileRequest(storage_location, test_data.storage))
+    storage_location = td.folder + "/" + file_name
+    td.email.upload_file(requests.UploadFileRequest(storage_location, sample, td.storage))
+    rq = requests.UploadFileRequest(storage_location, sample, td.storage)
+    downloaded = td.email.download_file(requests.DownloadFileRequest(storage_location, td.storage))
     with open(downloaded, 'r') as f:
         filedata = f.read()
         assert 'Broadway' in filedata
 
 @pytest.mark.pipeline
-def test_contact_format(test_data: TestData):
+def test_contact_format(td: TestData):
     """
     Contact format specified as Enum, but SDK represents it as a string.
     Test checks that value parsing works properly
     """
     for contact_format in ['vcard', 'msg']:
         extension = '.vcf' if contact_format == 'vcard' else '.msg'
         name = str(uuid.uuid4()) + extension
-        test_data.email.create_contact(
+        td.email.create_contact(
             requests.CreateContactRequest(
                 contact_format,
                 name,
                 models.HierarchicalObjectRequest(
                     models.HierarchicalObject('CONTACT', internal_properties=[]),
-                    models.StorageFolderLocation(test_data.storage, test_data.folder))))
-        object_exist = test_data.email.object_exists(requests.ObjectExistsRequest(
-            test_data.folder + "/" + name,
-            test_data.storage))
+                    models.StorageFolderLocation(td.storage, td.folder))))
+        object_exist = td.email.object_exists(requests.ObjectExistsRequest(
+            td.folder + "/" + name,
+            td.storage))
         assert object_exist.exists
     pass
 
 @pytest.mark.pipeline
-def test_date_time(test_data: TestData):
+def test_date_time(td: TestData):
     """
     Test datetime serialization and deserialization.
     Checks that SDK and Backend do not change datetime during processing.
     In most cases developer should carefully serialize and deserialize datetime
     """
     start_date = datetime.today() + timedelta(days=1)
     start_date = start_date.replace(microsecond=0, tzinfo=tz.tzutc())
-    calendar_storage = _create_calendar(test_data, start_date)
-    calendar = test_data.email.get_calendar(requests.GetCalendarRequest(
+    calendar_storage = _create_calendar(td, start_date)
+    calendar = td.email.get_calendar(requests.GetCalendarRequest(
         calendar_storage,
-        test_data.folder,
-        test_data.storage)) # type: models.HierarchicalObject
+        td.folder,
+        td.storage)) # type: models.HierarchicalObject
     start_date_property = list(filter(lambda item: item.name == 'STARTDATE', calendar.internal_properties))[0]
     fact_start_date = dateutil.parser.parse(start_date_property.value)
     assert start_date == fact_start_date
 
 @pytest.mark.ai
-def test_ai_bcr_parse_storage(test_data: TestData):
+def test_ai_bcr_parse_storage(td: TestData):
     file_name = str(uuid.uuid4())+ ".png"
     image_file = os.path.join(os.path.dirname(__file__), '..', 'data', 'test_single_0001.png')
     # 1) Upload business card image to storage
-    storage_location = test_data.folder + "/" + file_name
-    test_data.email.upload_file(requests.UploadFileRequest(storage_location, image_file, test_data.storage))
+    storage_location = td.folder + "/" + file_name
+    td.email.upload_file(requests.UploadFileRequest(storage_location, image_file, td.storage))
 
     out_folder = str(uuid.uuid4())
-    out_folder_path = test_data.folder + "/" + out_folder
-    test_data.email.create_folder(requests.CreateFolderRequest(out_folder_path, test_data.storage))
+    out_folder_path = td.folder + "/" + out_folder
+    td.email.create_folder(requests.CreateFolderRequest(out_folder_path, td.storage))
     # 2) Call business card recognition action
-    result = test_data.email.ai_bcr_parse_storage(requests.AiBcrParseStorageRequest(
+    result = td.email.ai_bcr_parse_storage(requests.AiBcrParseStorageRequest(
         models.AiBcrParseStorageRq(
-            images=[models.AiBcrImageStorageFile(True, models.StorageFileLocation(test_data.storage, test_data.folder, file_name))],
-            out_folder=models.StorageFolderLocation(test_data.storage, out_folder_path)))) # type: models.ListResponseOfStorageFileLocation
+            images=[models.AiBcrImageStorageFile(True, models.StorageFileLocation(td.storage, td.folder, file_name))],
+            out_folder=models.StorageFolderLocation(td.storage, out_folder_path)))) # type: models.ListResponseOfStorageFileLocation
     # Check that only one file produced
     assert len(result.value) == 1
     # 3) Get file name from recognition result
     contact_file = result.value[0] # type: models.StorageFileLocation
     # 4) Download VCard file, produced by recognition method, check it contains text "Thomas"
-    downloaded = test_data.email.download_file(requests.DownloadFileRequest(
+    downloaded = td.email.download_file(requests.DownloadFileRequest(
         contact_file.folder_path + "/" + contact_file.file_name,
-        test_data.storage))
+        td.storage))
     with open(downloaded, 'r') as f:
         filedata = f.read()
         assert 'Thomas' in filedata
     # 5) Get VCard object properties list, check that there are 3 properties or more
-    contact_properties = test_data.email.get_contact_properties(requests.GetContactPropertiesRequest(
+    contact_properties = td.email.get_contact_properties(requests.GetContactPropertiesRequest(
         'VCard', contact_file.file_name, contact_file.folder_path, contact_file.storage)) # type: models.HierarchicalObject
     assert len(contact_properties.internal_properties) >= 3
 
 @pytest.mark.ai
-def test_ai_bcr_parse(test_data: TestData):
+def test_ai_bcr_parse(td: TestData):
     image_file = os.path.join(os.path.dirname(__file__), '..', 'data', 'test_single_0001.png')
     image_data = None
     with open(image_file, 'rb') as f:
         filedata = f.read()
         image_data = str(base64.b64encode(filedata), 'utf-8')
-    result = test_data.email.ai_bcr_parse(requests.AiBcrParseRequest(
+    result = td.email.ai_bcr_parse(requests.AiBcrParseRequest(
         models.AiBcrBase64Rq(images=[models.AiBcrBase64Image(True, image_data)]))) # type: models.ListResponseOfHierarchicalObject
     assert len(result.value) == 1
     display_name = list(filter(
@@ -133,52 +133,52 @@ def test_ai_bcr_parse(test_data: TestData):
     assert 'Thomas' in display_name.value
 
 @pytest.mark.ai
-def test_ai_name_genderize(test_data: TestData):
+def test_ai_name_genderize(td: TestData):
     """ Test name gender detection """
-    result = test_data.email.ai_name_genderize(
+    result = td.email.ai_name_genderize(
         requests.AiNameGenderizeRequest('John Cane')) # type: models.ListResponseOfAiNameGenderHypothesis
     assert len(result.value) >= 1
     assert result.value[0].gender == 'Male'
 
 @pytest.mark.ai
-def test_ai_name_format(test_data: TestData):
-    result = test_data.email.ai_name_format(
+def test_ai_name_format(td: TestData):
+    result = td.email.ai_name_format(
         requests.AiNameFormatRequest(
             'Mr. John Michael Cane',
             format='%t%L%f%m')) # type: models.AiNameFormatted
     assert result.name == 'Mr. Cane J. M.'
 
 @pytest.mark.ai
-def test_ai_name_match(test_data: TestData):
+def test_ai_name_match(td: TestData):
     first = 'John Michael Cane'
     second = 'Cane J.'
-    result = test_data.email.ai_name_match(
+    result = td.email.ai_name_match(
         requests.AiNameMatchRequest(first, second)) # type: models.AiNameMatchResult
     assert result.similarity >= 0.5
 
 @pytest.mark.ai
-def test_ai_name_expand(test_data: TestData):
+def test_ai_name_expand(td: TestData):
     name = 'Smith Bobby'
-    result = test_data.email.ai_name_expand(
+    result = td.email.ai_name_expand(
         requests.AiNameExpandRequest(name)) # type: models.AiNameWeightedVariants
     expandedNames = list(weighted.name for weighted in result.names)
     assert 'Mr. Smith' in expandedNames
     assert 'B. Smith' in expandedNames
 
 @pytest.mark.ai
-def test_ai_name_complete(test_data: TestData):
+def test_ai_name_complete(td: TestData):
     prefix = 'Dav'
-    result = test_data.email.ai_name_complete(
+    result = td.email.ai_name_complete(
         requests.AiNameCompleteRequest(prefix)) # type: models.AiNameWeightedVariants
     names = list(prefix + weighted.name for weighted in result.names)
     assert 'David' in names
     assert 'Dave' in names
     assert 'Davis' in names
 
 @pytest.mark.ai
-def test_ai_name_parse_email_address(test_data: TestData):
+def test_ai_name_parse_email_address(td: TestData):
     address = 'john-cane@gmail.com'
-    result = test_data.email.ai_name_parse_email_address(
+    result = td.email.ai_name_parse_email_address(
         requests.AiNameParseEmailAddressRequest(address))
     names = (extracted.name for extracted in result.value)
     extracted_values = list(functools.reduce(lambda a,b: a+b, names))
@@ -187,8 +187,8 @@ def test_ai_name_parse_email_address(test_data: TestData):
     assert given_name.value == 'John'
     assert surname.value == 'Cane'
 
-@pytest.mark.ai
-def test_create_calendar_email(test_data: TestData):
+@pytest.mark.pipeline
+def test_create_calendar_email(td: TestData):
     calendar = models.CalendarDto()
     calendar.attendees = [models.MailAddress('Attendee Name', 'attendee@aspose.com', 'Accepted')]
     calendar.description = 'Some description'
@@ -198,48 +198,87 @@ def test_create_calendar_email(test_data: TestData):
     calendar.end_date = calendar.start_date + timedelta(hours=1)
     calendar.location = 'Some location'
 
-    folder_location = models.StorageFolderLocation(test_data.storage, test_data.folder)
+    folder_location = models.StorageFolderLocation(td.storage, td.folder)
     calendar_file = str(uuid.uuid4()) + '.ics'
-    test_data.email.save_calendar_model(
+    td.email.save_calendar_model(
         requests.SaveCalendarModelRequest(
             calendar_file,
             models.StorageModelRqOfCalendarDto(calendar, folder_location)))
-    exist_result = test_data.email.object_exists(
-        requests.ObjectExistsRequest(test_data.folder + '/' + calendar_file, test_data.storage))
+    exist_result = td.email.object_exists(
+        requests.ObjectExistsRequest(td.folder + '/' + calendar_file, td.storage))
     assert exist_result.exists
 
-    alternate = test_data.email.convert_calendar_model_to_alternate(
+    alternate = td.email.convert_calendar_model_to_alternate(
         requests.ConvertCalendarModelToAlternateRequest(
             models.CalendarDtoAlternateRq(calendar, 'Create')))
 
-    email = models.EmailDto()
-    email.alternate_views = [alternate]
-    # 'from' is reserved, so from field is named '_from':
-    email._from = models.MailAddress('From Name', 'organizer@aspose.com')
-    email.to = [models.MailAddress('To Name', 'attendee@aspose.com')]
-    email.subject = 'Some subject'
-    email.body = 'Some body'
+    email = models.EmailDto(
+        alternate_views=[alternate],
+        # 'from' is reserved, so from field is named '_from':
+        _from=models.MailAddress('From Name', 'organizer@aspose.com'),
+        to=[models.MailAddress('To Name', 'attendee@aspose.com')],
+        subject='Some subject',
+        body='Some body')
 
     email_file = str(uuid.uuid4())+ '.eml'
-    test_data.email.save_email_model(
+    td.email.save_email_model(
         requests.SaveEmailModelRequest(
             'Eml', email_file,
             models.StorageModelRqOfEmailDto(email, folder_location)))
 
-    downloaded = test_data.email.download_file(
+    downloaded = td.email.download_file(
         requests.DownloadFileRequest(
-            test_data.folder + '/' + email_file,
-            test_data.storage))
+            td.folder + '/' + email_file,
+            td.storage))
     with open(downloaded, 'r') as f:
         file_data = f.read()
         assert 'attendee@aspose.com' in file_data
 
 
-def _create_calendar(test_data, start_date_param=None):
+@pytest.mark.pipeline
+def test_contact_model(td: TestData):
+    contact = models.ContactDto(
+        gender='Male',
+        surname='Thomas',
+        given_name='Alex',
+        email_addresses=[
+            models.EmailAddress(
+                models.EnumWithCustomOfEmailAddressCategory('Work'),
+                'Alex Thomas', True, address='alex.thomas@work.com')],
+        phone_numbers=[
+            models.PhoneNumber(
+                models.EnumWithCustomOfPhoneNumberCategory('Work'),
+                '+49211424721', True)])
+
+    contact_file = str(uuid.uuid4())+ '.vcf'
+    td.email.save_contact_model(
+        requests.SaveContactModelRequest(
+            'VCard', contact_file,
+            models.StorageModelRqOfContactDto(
+                contact,
+                models.StorageFolderLocation(td.storage, td.folder))))
+    exist_result = td.email.object_exists(
+        requests.ObjectExistsRequest(td.folder + '/' + contact_file, td.storage))
+    assert exist_result.exists
+
+@pytest.mark.ai
+def test_ai_bcr_parse_model(td: TestData):
+    image_file = os.path.join(os.path.dirname(__file__), '..', 'data', 'test_single_0001.png')
+    image_data = None
+    with open(image_file, 'rb') as f:
+        filedata = f.read()
+        image_data = str(base64.b64encode(filedata), 'utf-8')
+    result = td.email.ai_bcr_parse_model(requests.AiBcrParseModelRequest(
+        models.AiBcrBase64Rq(images=[models.AiBcrBase64Image(True, image_data)])))
+    assert len(result.value) == 1
+    first_vcard = result.value[0]
+    assert 'Thomas' in first_vcard.display_name
+
+def _create_calendar(td, start_date_param=None):
     name = str(uuid.uuid4())+ '.ics'
-    start_date =
+    start_date = (
         start_date_param if start_date_param is not None
-        else datetime.today() + timedelta(days=1)
+        else datetime.today() + timedelta(days=1))
     end_date = start_date + timedelta(hours=1)
     request = requests.CreateCalendarRequest(
         name,
@@ -259,7 +298,7 @@ def _create_calendar(test_data, start_date_param=None):
                     ])
                 ])
             ]),
-        models.StorageFolderLocation(test_data.storage, test_data.folder)
+        models.StorageFolderLocation(td.storage, td.folder)
     ))
-    test_data.email.create_calendar(request)
+    td.email.create_calendar(request)
     return name