def test_create(self) -> None:
with open(CREATE_XML, "rb") as f:
response_xml = f.read().decode("utf-8")
with requests_mock.mock() as m:
m.post(self.baseurl, text=response_xml)
new_site = TSC.SiteItem(
name="Tableau",
content_url="tableau",
admin_mode=TSC.SiteItem.AdminMode.ContentAndUsers,
user_quota=15,
storage_quota=1000,
disable_subscriptions=True,
)
new_site = self.server.sites.create(new_site)
new_site._tier_viewer_capacity = None
new_site._tier_creator_capacity = None
new_site._tier_explorer_capacity = None
self.assertEqual("0626857c-1def-4503-a7d8-7907c3ff9d9f", new_site.id)
self.assertEqual("tableau", new_site.content_url)
self.assertEqual("Tableau", new_site.name)
self.assertEqual("Active", new_site.state)
self.assertEqual("ContentAndUsers", new_site.admin_mode)
self.assertEqual(False, new_site.revision_history_enabled)
self.assertEqual(True, new_site.subscribe_others_enabled)
self.assertEqual(True, new_site.disable_subscriptions)
self.assertEqual(15, new_site.user_quota)
def run_command(args):
logger = log(__class__.__name__, args.logging_level)
logger.debug(_("tabcmd.launching"))
session = Session()
server = session.create_session(args)
new_site = TSC.SiteItem(
name=args.site_name,
content_url=args.url,
admin_mode=args.admin_mode,
user_quota=args.user_quota,
storage_quota=args.storage_quota,
)
try:
logger.info(_("createsite.status").format(args.site_name))
server.sites.create(new_site)
logger.info(_("common.output.succeeded"))
except TSC.ServerResponseError as e:
if Errors.is_resource_conflict(e):
if args.continue_if_exists:
logger.info(
_("createsite.errors.site_name_already_exists").format(
args.site_name))
return
else:
Errors.exit_with_error(
logger,
_("createsite.errors.site_name_already_exists").format(
args.site_name))
Errors.exit_with_error(
logger, _("publish.errors.unexpected_server_response"), e)
def test_update(self):
with open(UPDATE_XML, 'rb') as f:
response_xml = f.read().decode('utf-8')
with requests_mock.mock() as m:
m.put(self.baseurl + '/6b7179ba-b82b-4f0f-91ed-812074ac5da6',
text=response_xml)
single_site = TSC.SiteItem(
name='Tableau',
content_url='tableau',
admin_mode=TSC.SiteItem.AdminMode.ContentAndUsers,
user_quota=15,
storage_quota=1000,
disable_subscriptions=True,
revision_history_enabled=False)
single_site._id = '6b7179ba-b82b-4f0f-91ed-812074ac5da6'
single_site = self.server.sites.update(single_site)
self.assertEqual('6b7179ba-b82b-4f0f-91ed-812074ac5da6',
single_site.id)
self.assertEqual('tableau', single_site.content_url)
self.assertEqual('Suspended', single_site.state)
self.assertEqual('Tableau', single_site.name)
self.assertEqual('ContentAndUsers', single_site.admin_mode)
self.assertEqual(True, single_site.revision_history_enabled)
self.assertEqual(13, single_site.revision_limit)
self.assertEqual(True, single_site.disable_subscriptions)
self.assertEqual(15, single_site.user_quota)
def test_invalid_subscribe_others_enabled(self):
site = TSC.SiteItem("site", "url")
with self.assertRaises(ValueError):
site.subscribe_others_enabled = "Hello"
with self.assertRaises(ValueError):
site.subscribe_others_enabled = None
def test_invalid_revision_history_enabled(self):
site = TSC.SiteItem("site", "url")
with self.assertRaises(ValueError):
site.revision_history_enabled = "Hello"
with self.assertRaises(ValueError):
site.revision_history_enabled = None
def test_invalid_disable_subscriptions(self):
site = TSC.SiteItem("site", "url")
with self.assertRaises(ValueError):
site.disable_subscriptions = "Hello"
with self.assertRaises(ValueError):
site.disable_subscriptions = None
def test_null_site_quota(self) -> None:
test_site = TSC.SiteItem("testname", "testcontenturl", tier_explorer_capacity=1, user_quota=None)
assert test_site.tier_explorer_capacity == 1
with self.assertRaises(ValueError):
test_site.user_quota = 1
test_site.tier_explorer_capacity = None
test_site.user_quota = 1
def test_replace_license_tiers_with_user_quota(self) -> None:
test_site = TSC.SiteItem("testname", "testcontenturl", tier_explorer_capacity=1, user_quota=None)
assert test_site.tier_explorer_capacity == 1
with self.assertRaises(ValueError):
test_site.user_quota = 1
test_site.replace_license_tiers_with_user_quota(1)
self.assertEqual(1, test_site.user_quota)
self.assertIsNone(test_site.tier_explorer_capacity)
def test_invalid_name(self):
self.assertRaises(ValueError, TSC.SiteItem, None, "url")
self.assertRaises(ValueError, TSC.SiteItem, "", "url")
site = TSC.SiteItem("site", "url")
with self.assertRaises(ValueError):
site.name = None
with self.assertRaises(ValueError):
site.name = ""
def test_update(self):
with open(UPDATE_XML, 'rb') as f:
response_xml = f.read().decode('utf-8')
with requests_mock.mock() as m:
m.put(self.baseurl + '/6b7179ba-b82b-4f0f-91ed-812074ac5da6', text=response_xml)
single_site = TSC.SiteItem(name='Tableau', content_url='tableau',
admin_mode=TSC.SiteItem.AdminMode.ContentAndUsers,
user_quota=15, storage_quota=1000,
disable_subscriptions=True, revision_history_enabled=False,
data_acceleration_mode='disable', flow_auto_save_enabled=True,
web_extraction_enabled=False, metrics_content_type_enabled=True,
notify_site_admins_on_throttle=False, authoring_enabled=True,
custom_subscription_email_enabled=True,
custom_subscription_email='*****@*****.**',
custom_subscription_footer_enabled=True,
custom_subscription_footer='example_footer', ask_data_mode='EnabledByDefault',
named_sharing_enabled=False, mobile_biometrics_enabled=True,
sheet_image_enabled=False, derived_permissions_enabled=True,
user_visibility_mode='FULL', use_default_time_zone=False,
time_zone='America/Los_Angeles', auto_suspend_refresh_enabled=True,
auto_suspend_refresh_inactivity_window=55)
single_site._id = '6b7179ba-b82b-4f0f-91ed-812074ac5da6'
single_site = self.server.sites.update(single_site)
self.assertEqual('6b7179ba-b82b-4f0f-91ed-812074ac5da6', single_site.id)
self.assertEqual('tableau', single_site.content_url)
self.assertEqual('Suspended', single_site.state)
self.assertEqual('Tableau', single_site.name)
self.assertEqual('ContentAndUsers', single_site.admin_mode)
self.assertEqual(True, single_site.revision_history_enabled)
self.assertEqual(13, single_site.revision_limit)
self.assertEqual(True, single_site.disable_subscriptions)
self.assertEqual(15, single_site.user_quota)
self.assertEqual('disable', single_site.data_acceleration_mode)
self.assertEqual(True, single_site.flows_enabled)
self.assertEqual(True, single_site.cataloging_enabled)
self.assertEqual(True, single_site.flow_auto_save_enabled)
self.assertEqual(False, single_site.web_extraction_enabled)
self.assertEqual(True, single_site.metrics_content_type_enabled)
self.assertEqual(False, single_site.notify_site_admins_on_throttle)
self.assertEqual(True, single_site.authoring_enabled)
self.assertEqual(True, single_site.custom_subscription_email_enabled)
self.assertEqual('*****@*****.**', single_site.custom_subscription_email)
self.assertEqual(True, single_site.custom_subscription_footer_enabled)
self.assertEqual('example_footer', single_site.custom_subscription_footer)
self.assertEqual('EnabledByDefault', single_site.ask_data_mode)
self.assertEqual(False, single_site.named_sharing_enabled)
self.assertEqual(True, single_site.mobile_biometrics_enabled)
self.assertEqual(False, single_site.sheet_image_enabled)
self.assertEqual(True, single_site.derived_permissions_enabled)
self.assertEqual('FULL', single_site.user_visibility_mode)
self.assertEqual(False, single_site.use_default_time_zone)
self.assertEqual('America/Los_Angeles', single_site.time_zone)
self.assertEqual(True, single_site.auto_suspend_refresh_enabled)
self.assertEqual(55, single_site.auto_suspend_refresh_inactivity_window)
def test_switch_site(self):
self.server.version = '2.6'
baseurl = self.server.auth.baseurl
site_id, user_id, auth_token = list('123')
self.server._set_auth(site_id, user_id, auth_token)
with open(SIGN_IN_XML, 'rb') as f:
response_xml = f.read().decode('utf-8')
with requests_mock.mock() as m:
m.post(baseurl + '/switchSite', text=response_xml)
site = TSC.SiteItem('Samples', 'Samples')
self.server.auth.switch_site(site)
self.assertEqual('eIX6mvFsqyansa4KqEI1UwOpS8ggRs2l', self.server.auth_token)
self.assertEqual('6b7179ba-b82b-4f0f-91ed-812074ac5da6', self.server.site_id)
self.assertEqual('1a96d216-e9b8-497b-a82a-0b899a965e01', self.server.user_id)
def create_site(server="out"):
new_site = TSC.SiteItem(name=tableau_servers[server]["site_name"],
content_url=tableau_servers[server]["site_id"])
tableau_servers["out"]["auth"] = TSC.TableauAuth(
tableau_servers["out"]["user"], tableau_servers["out"]["password"])
with tableau_servers[server]["server"].auth.sign_in(
tableau_servers[server]["auth"]):
try:
tableau_servers[server]["server"].sites.create(new_site)
except Exception as e:
print("WARNING: {}".format(e))
tableau_servers[server]["auth"] = TSC.TableauAuth(
tableau_servers[server]["user"],
tableau_servers[server]["password"],
site_id=tableau_servers[server]["site_id"])
def test_switch_site(self):
self.server.version = "2.6"
baseurl = self.server.auth.baseurl
site_id, user_id, auth_token = list("123")
self.server._set_auth(site_id, user_id, auth_token)
with open(SIGN_IN_XML, "rb") as f:
response_xml = f.read().decode("utf-8")
with requests_mock.mock() as m:
m.post(baseurl + "/switchSite", text=response_xml)
site = TSC.SiteItem("Samples", "Samples")
self.server.auth.switch_site(site)
self.assertEqual("eIX6mvFsqyansa4KqEI1UwOpS8ggRs2l",
self.server.auth_token)
self.assertEqual("6b7179ba-b82b-4f0f-91ed-812074ac5da6",
self.server.site_id)
self.assertEqual("1a96d216-e9b8-497b-a82a-0b899a965e01",
self.server.user_id)
def test_create(self):
with open(CREATE_XML, 'rb') as f:
response_xml = f.read().decode('utf-8')
with requests_mock.mock() as m:
m.post(self.baseurl, text=response_xml)
new_site = TSC.SiteItem(name='Tableau', content_url='tableau',
admin_mode=TSC.SiteItem.AdminMode.ContentAndUsers, user_quota=15,
storage_quota=1000, disable_subscriptions=True)
new_site = self.server.sites.create(new_site)
self.assertEqual('0626857c-1def-4503-a7d8-7907c3ff9d9f', new_site.id)
self.assertEqual('tableau', new_site.content_url)
self.assertEqual('Tableau', new_site.name)
self.assertEqual('Active', new_site.state)
self.assertEqual('ContentAndUsers', new_site.admin_mode)
self.assertEqual(False, new_site.revision_history_enabled)
self.assertEqual(True, new_site.subscribe_others_enabled)
self.assertEqual(True, new_site.disable_subscriptions)
self.assertEqual(15, new_site.user_quota)
def test_invalid_state(self):
site = TSC.SiteItem("site", "url")
with self.assertRaises(ValueError):
site.state = "Hello"
def test_update_missing_id(self):
single_site = TSC.SiteItem('test', 'test')
self.assertRaises(TSC.MissingRequiredFieldError,
self.server.sites.update, single_site)
with server.auth.sign_in(tableau_auth):
all_sites, pagination_item = server.sites.get()
site_check = 0
for i in range(0, len(uniqueField)):
###Ignoring process if site already exists###
for site in all_sites:
if site.name == uniqueField[i]:
site_check = 1
break
###Creating site and user###
if site_check == 0:
with server.auth.sign_in(tableau_auth):
new_site = TSC.SiteItem(name=uniqueField[i],
content_url=uniqueField[i].replace(
" ", ""))
server.sites.create(new_site)
time.sleep(0.5)
with server.auth.sign_in(tableau_auth):
all_sites, pagination_item = server.sites.get()
for site in all_sites:
if site.name == uniqueField[i]:
tableau_auth.site_id = site.content_url
break
with server.auth.sign_in(tableau_auth):
user = TSC.UserItem(server_username[i], 'SiteAdministrator')
user = server.users.add(user)
user = server.users.update(user, 'password')
#Getting the default project and publishing workbook and datasource###
def main():
parser = argparse.ArgumentParser(
description='Initialize a server with content.')
parser.add_argument('--server', '-s', required=True, help='server address')
parser.add_argument('--datasources-folder',
'-df',
required=True,
help='folder containing datasources')
parser.add_argument('--workbooks-folder',
'-wf',
required=True,
help='folder containing workbooks')
parser.add_argument('--site',
'-si',
required=False,
default='Default',
help='site to use')
parser.add_argument('--project',
'-p',
required=False,
default='Default',
help='project to use')
parser.add_argument('--username',
'-u',
required=True,
help='username to sign into server')
parser.add_argument('--logging-level',
'-l',
choices=['debug', 'info', 'error'],
default='error',
help='desired logging level (set to error by default)')
args = parser.parse_args()
password = getpass.getpass("Password: "******"Checking to see if we need to create the site...")
all_sites, _ = server.sites.get()
existing_site = next((s for s in all_sites if s.name == args.site),
None)
# Create the site if it doesn't exist
if existing_site is None:
print("Site not found: {0} Creating it...").format(args.site)
new_site = TSC.SiteItem(
name=args.site,
content_url=args.site.replace(" ", ""),
admin_mode=TSC.SiteItem.AdminMode.ContentAndUsers)
server.sites.create(new_site)
else:
print("Site {0} exists. Moving on...").format(args.site)
################################################################################
# Step 3: Sign-in to our target site
################################################################################
print("Starting our content upload...")
server_upload = TSC.Server(args.server)
tableau_auth.site = args.site
with server_upload.auth.sign_in(tableau_auth):
################################################################################
# Step 4: Create the project we need only if it doesn't exist
################################################################################
all_projects, _ = server_upload.projects.get()
project = next((p for p in all_projects if p.name == args.project),
None)
# Create our project if it doesn't exist
if project is None:
print("Project not found: {0} Creating it...").format(args.project)
new_project = TSC.ProjectItem(name=args.project)
project = server_upload.projects.create(new_project)
################################################################################
# Step 5: Set up our content
# Publish datasources to our site and project
# Publish workbooks to our site and project
################################################################################
publish_datasources_to_site(server_upload, project,
args.datasources_folder)
publish_workbooks_to_site(server_upload, project,
args.workbooks_folder)
def main():
parser = argparse.ArgumentParser(description='Initialize a server with content.')
# Common options; please keep those in sync across all samples
parser.add_argument('--server', '-s', required=True, help='server address')
parser.add_argument('--site', '-S', help='site name')
parser.add_argument('--token-name', '-p', required=True,
help='name of the personal access token used to sign into the server')
parser.add_argument('--token-value', '-v', required=True,
help='value of the personal access token used to sign into the server')
parser.add_argument('--logging-level', '-l', choices=['debug', 'info', 'error'], default='error',
help='desired logging level (set to error by default)')
# Options specific to this sample
parser.add_argument('--datasources-folder', '-df', required=True, help='folder containing datasources')
parser.add_argument('--workbooks-folder', '-wf', required=True, help='folder containing workbooks')
parser.add_argument('--project', required=False, default='Default', help='project to use')
args = parser.parse_args()
# Set logging level based on user input, or error by default
logging_level = getattr(logging, args.logging_level.upper())
logging.basicConfig(level=logging_level)
################################################################################
# Step 1: Sign in to server.
################################################################################
tableau_auth = TSC.PersonalAccessTokenAuth(args.token_name, args.token_value, site_id=args.site)
server = TSC.Server(args.server, use_server_version=True)
with server.auth.sign_in(tableau_auth):
################################################################################
# Step 2: Create the site we need only if it doesn't exist
################################################################################
print("Checking to see if we need to create the site...")
all_sites = TSC.Pager(server.sites)
existing_site = next((s for s in all_sites if s.content_url == args.site_id), None)
# Create the site if it doesn't exist
if existing_site is None:
print("Site not found: {0} Creating it...").format(args.site_id)
new_site = TSC.SiteItem(name=args.site_id, content_url=args.site_id.replace(" ", ""),
admin_mode=TSC.SiteItem.AdminMode.ContentAndUsers)
server.sites.create(new_site)
else:
print("Site {0} exists. Moving on...").format(args.site_id)
################################################################################
# Step 3: Sign-in to our target site
################################################################################
print("Starting our content upload...")
server_upload = TSC.Server(args.server)
tableau_auth.site_id = args.site_id
with server_upload.auth.sign_in(tableau_auth):
################################################################################
# Step 4: Create the project we need only if it doesn't exist
################################################################################
import time
time.sleep(2) # sad panda...something about eventually consistent model
all_projects = TSC.Pager(server_upload.projects)
project = next((p for p in all_projects if p.name.lower() == args.project.lower()), None)
# Create our project if it doesn't exist
if project is None:
print("Project not found: {0} Creating it...").format(args.project)
new_project = TSC.ProjectItem(name=args.project)
project = server_upload.projects.create(new_project)
################################################################################
# Step 5: Set up our content
# Publish datasources to our site and project
# Publish workbooks to our site and project
################################################################################
publish_datasources_to_site(server_upload, project, args.datasources_folder)
publish_workbooks_to_site(server_upload, project, args.workbooks_folder)
def test_update(self) -> None:
with open(UPDATE_XML, "rb") as f:
response_xml = f.read().decode("utf-8")
with requests_mock.mock() as m:
m.put(self.baseurl + "/6b7179ba-b82b-4f0f-91ed-812074ac5da6", text=response_xml)
single_site = TSC.SiteItem(
name="Tableau",
content_url="tableau",
admin_mode=TSC.SiteItem.AdminMode.ContentAndUsers,
user_quota=15,
storage_quota=1000,
disable_subscriptions=True,
revision_history_enabled=False,
data_acceleration_mode="disable",
flow_auto_save_enabled=True,
web_extraction_enabled=False,
metrics_content_type_enabled=True,
notify_site_admins_on_throttle=False,
authoring_enabled=True,
custom_subscription_email_enabled=True,
custom_subscription_email="*****@*****.**",
custom_subscription_footer_enabled=True,
custom_subscription_footer="example_footer",
ask_data_mode="EnabledByDefault",
named_sharing_enabled=False,
mobile_biometrics_enabled=True,
sheet_image_enabled=False,
derived_permissions_enabled=True,
user_visibility_mode="FULL",
use_default_time_zone=False,
time_zone="America/Los_Angeles",
auto_suspend_refresh_enabled=True,
auto_suspend_refresh_inactivity_window=55,
tier_creator_capacity=5,
tier_explorer_capacity=5,
tier_viewer_capacity=5,
)
single_site._id = "6b7179ba-b82b-4f0f-91ed-812074ac5da6"
single_site = self.server.sites.update(single_site)
self.assertEqual("6b7179ba-b82b-4f0f-91ed-812074ac5da6", single_site.id)
self.assertEqual("tableau", single_site.content_url)
self.assertEqual("Suspended", single_site.state)
self.assertEqual("Tableau", single_site.name)
self.assertEqual("ContentAndUsers", single_site.admin_mode)
self.assertEqual(True, single_site.revision_history_enabled)
self.assertEqual(13, single_site.revision_limit)
self.assertEqual(True, single_site.disable_subscriptions)
self.assertEqual(None, single_site.user_quota)
self.assertEqual(5, single_site.tier_creator_capacity)
self.assertEqual(5, single_site.tier_explorer_capacity)
self.assertEqual(5, single_site.tier_viewer_capacity)
self.assertEqual("disable", single_site.data_acceleration_mode)
self.assertEqual(True, single_site.flows_enabled)
self.assertEqual(True, single_site.cataloging_enabled)
self.assertEqual(True, single_site.flow_auto_save_enabled)
self.assertEqual(False, single_site.web_extraction_enabled)
self.assertEqual(True, single_site.metrics_content_type_enabled)
self.assertEqual(False, single_site.notify_site_admins_on_throttle)
self.assertEqual(True, single_site.authoring_enabled)
self.assertEqual(True, single_site.custom_subscription_email_enabled)
self.assertEqual("*****@*****.**", single_site.custom_subscription_email)
self.assertEqual(True, single_site.custom_subscription_footer_enabled)
self.assertEqual("example_footer", single_site.custom_subscription_footer)
self.assertEqual("EnabledByDefault", single_site.ask_data_mode)
self.assertEqual(False, single_site.named_sharing_enabled)
self.assertEqual(True, single_site.mobile_biometrics_enabled)
self.assertEqual(False, single_site.sheet_image_enabled)
self.assertEqual(True, single_site.derived_permissions_enabled)
self.assertEqual("FULL", single_site.user_visibility_mode)
self.assertEqual(False, single_site.use_default_time_zone)
self.assertEqual("America/Los_Angeles", single_site.time_zone)
self.assertEqual(True, single_site.auto_suspend_refresh_enabled)
self.assertEqual(55, single_site.auto_suspend_refresh_inactivity_window)
def test_update_missing_id(self) -> None:
single_site = TSC.SiteItem("test", "test")
self.assertRaises(TSC.MissingRequiredFieldError, self.server.sites.update, single_site)
