def test2_create_user(self): login = create_unique_name("testuser") password = create_unique_name("P@ssw0rd") profile = UserProfile("{0}@{1}".format(login, test_tenant), password) new_user = self.client.users.add(profile).execute_query() self.assertIsNotNone(new_user.id) self.__class__.test_user = new_user
def setUpClass(cls): super(TestSharePointFolder, cls).setUpClass() cls.target_list = cls.ensure_list(cls.client.web, ListCreationInformation( create_unique_name("Documents"), None, ListTemplateType.DocumentLibrary))
class TestApplication(GraphTestCase): target_app = None # type: Application target_password = None # type: PasswordCredential app_name = create_unique_name("App") def test1_list_apps(self): apps = self.client.applications.get().execute_query() self.assertIsNotNone(apps.resource_path) def test2_create_app(self): new_app = self.client.applications.add(self.app_name).execute_query() self.assertIsNotNone(new_app.resource_path) self.__class__.target_app = new_app def test3_add_password(self): password = self.__class__.target_app.add_password("New password") self.client.execute_query() self.assertIsNotNone(password.secretText) self.__class__.target_password = password def test4_remove_password(self): self.__class__.target_app.remove_password( self.__class__.target_password.keyId) self.client.execute_query() def test5_delete_app(self): app_to_del = self.__class__.target_app app_to_del.delete_object(True).execute_query()
def setUpClass(cls): super(TestSharePointListItem, cls).setUpClass() target_list_title = "Tasks" + str(randint(0, 10000)) cls.target_list = cls.ensure_list( cls.client.web, ListCreationInformation(target_list_title, None, ListTemplateType.Tasks)) cls.default_title = create_unique_name("Task") cls.batch_items_count = 3
def test_10_execute_update_batch_request(self): client = ClientContext(test_site_url).with_credentials(test_user_credentials) web = client.web new_web_title = create_unique_name("Site") web.set_property("Title", new_web_title).update() client.execute_batch() updated_web = client.web.get().execute_query() self.assertEqual(updated_web.properties['Title'], new_web_title)
def test8_systemUpdate_listItem(self): item_to_update = self.__class__.target_item.get().execute_query() last_updated = item_to_update.properties['Modified'] new_title = create_unique_name("Task item %s") item_to_update.set_property('Title', new_title).system_update() self.client.load(item_to_update) # retrieve updated self.client.execute_query() self.assertEqual(item_to_update.properties["Modified"], last_updated) self.assertNotEqual(self.default_title, new_title)
def test3_update_user(self): user_to_update = self.__class__.test_user prop_name = 'city' prop_val = create_unique_name("city_") user_to_update.set_property(prop_name, prop_val).update().execute_query() result = self.client.users.filter("{0} eq '{1}'".format( prop_name, prop_val)).get().execute_query() self.assertEqual(1, len(result))
def test2_create_view(self): view_properties = ViewCreationInformation() view_properties.Title = create_unique_name("My Tasks") view_properties.PersonalView = True view_properties.Query = "<Where><Eq><FieldRef ID='AssignedTo' /><Value " \ "Type='Integer'><UserID/></Value></Eq></Where> " new_view = self.target_list.views.add(view_properties).execute_query() self.assertEqual(view_properties.Title, new_view.properties['Title']) self.__class__.target_view = new_view
def test_11_execute_get_and_update_batch_request(self): client = ClientContext(test_site_url).with_credentials(test_user_credentials) list_item = client.web.get_file_by_server_relative_url("/SitePages/Home.aspx").listItemAllFields new_title = create_unique_name("Page") list_item.set_property("Title", new_title).update() client.execute_batch() updated_list_item = client.web.get_file_by_server_relative_url("/SitePages/Home.aspx").listItemAllFields client.load(updated_list_item) client.execute_query() self.assertEqual(updated_list_item.properties['Title'], new_title)
def create_tasks_list(client): """ :type client: ClientContext """ list_title = create_unique_name("Tasks N") list_create_info = ListCreationInformation(list_title, None, ListTemplateType.TasksWithTimelineAndHierarchy) target_list = client.web.lists.add(list_create_info).execute_query() field_info = FieldCreationInformation("Manager", FieldType.User) user_field = target_list.fields.add(field_info).execute_query() return target_list
def generate_user_profile(): fake = Faker() user_json = { 'given_name': fake.name(), 'company_name': fake.company(), 'business_phones': [fake.phone_number()], 'office_location': fake.street_address(), 'city': fake.city(), 'country': fake.country(), 'principal_name': "{0}@{1}".format(fake.user_name(), test_tenant), 'password': create_unique_name("P@ssw0rd"), 'account_enabled': True } return UserProfile(**user_json)
def setUpClass(cls): super(TestFieldValue, cls).setUpClass() cls.multi_lookup_field_name = "PredecessorsAlt" cls.url_field_name = "DocumentationLink" cls.geo_field_name = "Place" cls.choice_field_name = "TaskStatus" cls.multi_choice_field_name = "TaskStatuses" cls.user_field_name = "PrimaryApprover" cls.lookup_field_name = "RelatedDocuments" cls.target_list = cls.ensure_list(cls.client.web, ListCreationInformation( create_unique_name("Tasks N"), None, ListTemplateType.TasksWithTimelineAndHierarchy)) cls.lookup_list = cls.client.web.default_document_library().get().execute_query()
class TestContacts(GraphTestCase): """Tests for Calendar""" cal_name = create_unique_name("Volunteer") target_cal = None # type: Calendar @classmethod def setUpClass(cls): super(TestContacts, cls).setUpClass() @classmethod def tearDownClass(cls): pass def test1_list_contacts(self): contacts = self.client.me.contacts.top(10).get().execute_query() self.assertIsNotNone(contacts.resource_path)
def test2_create_column(self): column_name = create_unique_name("TextColumn") column = self.doclib.columns.add_text(column_name).execute_query() self.assertIsNotNone(column.resource_path) self.__class__.target_column = column
def test4_create_section(self): name = create_unique_name("Section name") new_section = self.__class__.target_notebook.sections.add( displayName=name).execute_query() self.assertIsNotNone(new_section.resource_path) self.__class__.target_section = new_section
def test4_create_list_column(self): column_name = create_unique_name("Text") text_column = self.target_list.columns.add_text(column_name).execute_query() self.assertIsNotNone(text_column.resource_path) self.__class__.target_column = text_column
from office365.sharepoint.client_context import ClientContext from office365.sharepoint.fields.field_multi_user_value import FieldMultiUserValue from office365.sharepoint.fields.field_user_value import FieldUserValue from office365.sharepoint.lists.list_creation_information import ListCreationInformation from office365.sharepoint.lists.list_template_type import ListTemplateType from tests import create_unique_name, test_site_url, test_client_credentials ctx = ClientContext(test_site_url).with_credentials(test_client_credentials) list_title = create_unique_name("Tasks N") list_create_info = ListCreationInformation( list_title, None, ListTemplateType.TasksWithTimelineAndHierarchy) tasks_list = ctx.web.lists.add(list_create_info).execute_query() current_user = ctx.web.current_user.get().execute_query() multi_user_value = FieldMultiUserValue() multi_user_value.add(FieldUserValue.from_user(current_user)) item_to_create = tasks_list.add_item({ "Title": "New Task", "AssignedTo": multi_user_value }).execute_query() multi_user_value_alt = FieldMultiUserValue() multi_user_value_alt.add(FieldUserValue(current_user.id)) item_to_create_alt = tasks_list.add_item({ "Title": "New Task 2", "AssignedTo": multi_user_value_alt }).execute_query()
def test1_create_notebook(self): notebook_name = create_unique_name("My Private notebook") new_notebook = self.client.me.onenote.notebooks.add( displayName=notebook_name).execute_query() self.assertIsNotNone(new_notebook.resource_path) self.__class__.target_notebook = new_notebook
from office365.sharepoint.client_context import ClientContext from tests import test_client_credentials, test_team_site_url, create_unique_name ctx = ClientContext(test_team_site_url).with_credentials( test_client_credentials) list_tasks = ctx.web.lists.get_by_title("Tasks") task_items = [ list_tasks.add_item({"Title": create_unique_name("Task")}) for idx in range(0, 9) ] ctx.execute_batch() print(" {0} task items created".format(len(task_items)))
class TestCalendar(GraphTestCase): """Tests for Calendar""" cal_name = create_unique_name("Volunteer") target_cal = None # type: Calendar @classmethod def setUpClass(cls): super(TestCalendar, cls).setUpClass() @classmethod def tearDownClass(cls): pass def test1_find_meeting_times(self): meeting_times = self.client.me.find_meeting_times() self.client.execute_query() self.assertIsNotNone(meeting_times.meetingTimeSuggestions) def test2_get_schedule(self): end_time = datetime.utcnow() start_time = end_time - timedelta(days=7) schedule = self.client.me.calendar.get_schedule(schedules=[test_user_principal_name], startTime=start_time, endTime=end_time) self.client.execute_query() self.assertIsNotNone(schedule) def test3_get_calendar_groups(self): cal_groups = self.client.me.calendarGroups.get().execute_query() self.assertIsNotNone(cal_groups.resource_path) def test4_list_calendar_view(self): end_time = datetime.utcnow() start_time = end_time - timedelta(days=14) events = self.client.me.get_calendar_view(start_dt=start_time, end_dt=end_time).execute_query() self.assertIsNotNone(events.resource_path) def test4_get_reminder_view(self): end_time = datetime.utcnow() start_time = end_time - timedelta(days=14) reminders = self.client.me.get_reminder_view(start_dt=start_time, end_dt=end_time) self.client.execute_query() self.assertIsNotNone(reminders) def test5_list_events(self): events = self.client.me.calendar.events.get().execute_query() self.assertIsNotNone(events.resource_path) def test6_get_user_calendars(self): cals = self.client.me.calendars.get().execute_query() self.assertIsNotNone(cals.resource_path) def test7_create_calendar(self): new_cal = self.client.me.calendars.add(self.cal_name).execute_query() self.assertIsNotNone(new_cal.resource_path) self.__class__.target_cal = new_cal def test8_update_calendar(self): cal_to_update = self.__class__.target_cal self.__class__.cal_name = self.cal_name + "_Updated" cal_to_update.set_property("name", self.cal_name).update().execute_query() def test9_get_calendar(self): cal_id = self.__class__.target_cal.id cal = self.client.me.calendars[cal_id].select(["name", "owner"]).get().execute_query() self.assertEqual(cal.name, self.cal_name) self.assertIsInstance(cal.owner, EmailAddress) def test_10_delete_calendar(self): cal_to_del = self.__class__.target_cal cal_to_del.delete_object().execute_query()
from examples import acquire_token_by_username_password from office365.graph_client import GraphClient from office365.onedrive.lists.list import List from tests import create_unique_name client = GraphClient(acquire_token_by_username_password) lib = client.sites.root.lists["Documents"] # type: List column_name = create_unique_name("TextColumn") column = lib.columns.add_text(column_name).execute_query() print(column.display_name) column.delete_object().execute_query() # cleanup
def setUpClass(cls): super(TestExtensions, cls).setUpClass() app_name = create_unique_name("App") cls.target_app = cls.client.applications.add( displayName=app_name).execute_query()
class TestSharePointFile(SPTestCase): content_placeholder = create_unique_name("1234567890 abcdABCD") file_entries = [{ "Name": "Sample.txt", "Type": "Text" }, { "Name": "SharePoint User Guide.docx", "Type": "Binary" }] target_list = None # type: List target_file = None # type: File @classmethod def setUpClass(cls): super(TestSharePointFile, cls).setUpClass() cls.target_list = cls.ensure_list( cls.client.web, ListCreationInformation(create_unique_name("Archive Documents"), None, ListTemplateType.DocumentLibrary)) @classmethod def tearDownClass(cls): cls.target_list.delete_object().execute_query() def test1_upload_files(self): for entry in self.file_entries: path = "{0}/../data/{1}".format(os.path.dirname(__file__), entry["Name"]) if entry["Type"] == "Binary": file_content = self.read_file_as_binary(path) else: file_content = self.read_file_as_text(path) target_folder = self.__class__.target_list.root_folder uploaded_file = target_folder.upload_file( entry["Name"], file_content).execute_query() self.assertEqual(uploaded_file.name, entry["Name"]) def test2_upload_large_file(self): path = "{0}/../data/big_buck_bunny.mp4".format( os.path.dirname(__file__)) file_size = os.path.getsize(path) size_1mb = 1000000 result_file = self.__class__.target_list.root_folder.files.create_upload_session( path, size_1mb).execute_query() self.assertEqual(file_size, int(result_file.length)) def test3_get_first_file(self): files = self.__class__.target_list.root_folder.files.top( 1).get().execute_query() self.assertEqual(len(files), 1) self.__class__.target_file = files[0] def test4_get_file_from_absolute_url(self): file_abs_url = self.client.base_url + self.__class__.target_file.serverRelativeUrl file = File.from_url(file_abs_url).with_credentials( test_client_credentials).get().execute_query() self.assertIsNotNone(file.serverRelativeUrl) def test5_create_file_anon_link(self): file_url = self.__class__.target_file.serverRelativeUrl result = Web.create_anonymous_link(self.client, file_url, False).execute_query() self.assertIsNotNone(result.value) def test6_load_file_metadata(self): list_item = self.__class__.target_file.listItemAllFields.expand( ["File"]).get().execute_query() self.assertIsInstance(list_item.file, File) def test7_load_file_metadata_alt(self): list_item = self.__class__.target_file.listItemAllFields self.client.load(list_item, ["File"]) self.client.execute_query() self.assertIsInstance(list_item.file, File) def test8_update_file_content(self): """Test file upload operation""" files = self.__class__.target_list.root_folder.files.get( ).execute_query() for file_upload in files: response = File.save_binary( self.client, file_upload.properties["ServerRelativeUrl"], self.content_placeholder) self.assertTrue(response.ok) def test9_update_file_metadata(self): """Test file update metadata""" list_item = self.__class__.target_file.listItemAllFields # get metadata list_item.set_property('Title', 'Updated') list_item.update().execute_query() def test_10_list_file_versions(self): """Test file update metadata""" file_with_versions = self.__class__.target_file.expand( ["Versions"]).get().execute_query() self.assertGreater(len(file_with_versions.versions), 0) def test_11_delete_file_version(self): versions = self.__class__.target_file.versions.top( 1).get().execute_query() self.assertEqual(len(versions), 1) self.assertIsNotNone(versions[0].resource_path) versions[0].delete_object().execute_query() def test_12_download_file(self): """Test file upload operation""" files = self.__class__.target_list.root_folder.files.get( ).execute_query() for file_download in files: content = file_download.read() enc_content = normalize_response(content) self.assertEqual(enc_content, self.content_placeholder) def test_13_copy_file(self): files = self.__class__.target_list.root_folder.files.get( ).execute_query() for cur_file in files: file_url = cur_file.properties["ServerRelativeUrl"] path, file_name = os.path.split(file_url) new_file_url = '/'.join([path, "copied_" + file_name]) cur_file.copyto(new_file_url, True) self.client.execute_query() moved_file = self.client.web.get_file_by_server_relative_url( new_file_url).get().execute_query() self.assertEqual(new_file_url, moved_file.serverRelativeUrl) def test_14_move_file(self): files = self.__class__.target_list.root_folder.files.get( ).execute_query() for cur_file in files: file_url = cur_file.properties["ServerRelativeUrl"] path, file_name = os.path.split(file_url) new_file_url = '/'.join([path, "moved_" + file_name]) cur_file.moveto(new_file_url, 1).execute_query() moved_file = self.client.web.get_file_by_server_relative_url( new_file_url).get().execute_query() self.assertEqual(new_file_url, moved_file.properties["ServerRelativeUrl"]) def test_15_recycle_first_file(self): """Test file upload operation""" files = self.__class__.target_list.root_folder.files.get( ).execute_query() files_count = len(files) if files_count > 0: first_file = files[0] first_file.recycle() first_file.execute_query() files_after = self.__class__.target_list.root_folder.files.get( ).execute_query() self.assertEqual(len(files) - 1, len(files_after)) def test_16_create_template_file(self): target_folder = self.__class__.target_list.root_folder.get( ).execute_query() file_url = '/'.join([target_folder.serverRelativeUrl, "WikiPage.aspx"]) file_new = self.__class__.target_list.root_folder.files.add_template_file( file_url, TemplateFileType.WikiPage) self.client.execute_query() self.assertEqual(file_new.serverRelativeUrl, file_url) self.__class__.target_file = file_new def test_17_get_folder_changes(self): changes = self.__class__.target_file.listItemAllFields.get_changes( ChangeQuery(item=True)).execute_query() self.assertGreater(len(changes), 0) def test_18_delete_files(self): files_to_delete = self.__class__.target_list.root_folder.files.get( ).execute_query() for file_to_delete in files_to_delete: file_to_delete.delete_object().execute_query() result = self.__class__.target_list.root_folder.files.get( ).execute_query() files_items = list(result) self.assertEqual(len(files_items), 0)
def test1_create_task_list(self): name = create_unique_name("TaskList") task_list = self.client.me.todo.lists.add(name).execute_query() self.__class__.task_list = task_list
def test1_create_document_set(self): doc_set_title = create_unique_name("DocSet N") doc_set = DocumentSet.create(self.client, self.target_lib.root_folder, doc_set_title).execute_query() self.assertEqual(doc_set.name, doc_set_title) self.__class__.target_doc_set = doc_set