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
