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__create_new_token_credential_succeeds_from_args(self, mock_pass):
test_args = Namespace(**vars(args_to_mock))
test_args.token = "gibberish"
test_args.token_name = "readable"
active_session = Session()
active_session._update_session_data(test_args)
auth = active_session._create_new_token_credential()
def test_reuse_session(self):
if not credentials:
return
# TODO current test command doesn't recognize skips - change to proper pytest
# TODO and then we can get rid of the check above
args = argparse.Namespace(
server=None,
site_name=None,
token_name=None,
token=None,
username=None,
password=None,
password_file=None,
logging_level=None,
no_certcheck=True,
certificate=None,
prompt=True,
no_prompt=False,
proxy=None,
no_proxy=True,
timeout=None,
no_cookie=False,
)
test_session = Session()
test_session.create_session(args)
assert test_session.auth_token is not None
assert test_session.site_id is not None
assert test_session.user_id is not None
assert test_session.site_id == E2EServerTests.saved_site_id
def run_command(args):
# A view can be returned in PDF, PNG, or CSV (summary data only) format.
# A Tableau workbook is returned as a TWB if it connects to a datasource/live connection,
# or a TWBX if it uses an extract.
logger = log(__class__.__name__, args.logging_level)
logger.debug(_("tabcmd.launching"))
session = Session()
server = session.create_session(args)
if " " in args.url:
Errors.exit_with_error(
logger, _("export.errors.white_space_workbook_view"))
file_type = GetUrl.get_file_type_from_filename(logger, args.filename,
args.url)
content_type = GetUrl.evaluate_content_type(logger, args.url)
if content_type == "workbook":
if file_type == "twbx" or file_type == "twb":
GetUrl.generate_twb(logger, server, args, file_type)
else:
Errors.exit_with_error(
logger,
message=_(
"publish.errors.mutually_exclusive_option").format(
"twb", "twbx"))
else: # content type = view
if file_type == "pdf":
GetUrl.generate_pdf(logger, server, args)
elif file_type == "png":
GetUrl.generate_png(logger, server, args)
elif file_type == "csv":
GetUrl.generate_csv(logger, server, args)
else:
Errors.exit_with_error(
logger, message=_("tabcmd.get.extension.not_found"))
def run_command(args):
logger = log(__class__.__name__, args.logging_level)
logger.debug(_("tabcmd.launching"))
session = Session()
server = session.create_session(args)
if args.parent_project_path is not None:
project_path = Server.get_project_by_name_and_parent_path(
logger, server, None, args.parent_project_path)
else:
project_path = None
try:
project = PublishSamplesCommand.get_project_by_name_and_parent_path(
logger, server, args.project_name, project_path)
except Exception as e:
Errors.exit_with_error(
logger,
_("tabcmd.report.error.publish_samples.expected_project"),
exception=e)
try:
server.projects.update(project, samples=True)
except Exception as e:
Errors.exit_with_error(logger,
_("tabcmd.result.failure.publish_samples"),
exception=e)
def run_command(args):
logger = log(__class__.__name__, args.logging_level)
logger.debug(_("tabcmd.launching"))
session = Session()
server = session.create_session(args)
logger.info(_("delete.status").format(args.name, ""))
error = None
try:
item_to_delete = DeleteCommand.get_workbook_item(
logger, server, args.name)
item_type = "workbook"
except TSC.ServerResponseError as workbook_error:
error = workbook_error
try:
item_to_delete = DeleteCommand.get_data_source_item(
logger, server, args.name)
item_type = "datasource"
except TSC.ServerResponseError as ds_error:
error = ds_error
if not item_type:
logger.debug(error)
Errors.exit_with_error(
logger, _("delete.errors.requires_workbook_datasource"))
try:
if item_type == "workbook":
server.workbooks.delete(item_to_delete.id)
else:
server.datasources.delete(item_to_delete.id)
logger.info(_("common.output.succeeded"))
except TSC.ServerResponseError as e:
Errors.exit_with_error(logger, "Error deleting from server", e)
def run_command(args):
logger = log(__class__.__name__, args.logging_level)
logger.debug(_("tabcmd.launching"))
session = Session()
server = session.create_session(args)
if args.parent_project_path:
logger.debug("parent path: {}".format(args.parent_project_path))
try:
logger.debug(
_("deleteproject.status").format(args.parent_project_path,
args.project_name))
project = Server.get_project_by_name_and_parent_path(
logger, server, args.project_name, args.parent_project_path)
except TSC.ServerResponseError as e:
Errors.exit_with_error(
logger, _("publish.errors.unexpected_server_response"), e)
project_id = project.id
try:
logger.info(_("deleteproject.status").format(args.project_name))
server.projects.delete(project_id)
logger.info(_("common.output.succeeded"))
except TSC.ServerResponseError as e:
Errors.exit_with_error(logger,
"tabcmd.result.failure.delete.project", e)
def test__create_new_username_credential_succeeds_new_password(
self, mock_pass):
test_password = "******"
active_session = Session()
active_session.username = "******"
active_session.site = ""
auth = active_session._create_new_credential(
test_password, Session.PASSWORD_CRED_TYPE)
assert auth is not None
def test__create_new_token_credential_succeeds_new_token(self, mock_pass):
test_args = Namespace(**vars(args_to_mock))
test_args.token = "gibberish"
active_session = Session()
assert active_session.token is None, active_session.token
active_session.token_name = "readable"
auth = active_session._create_new_token_credential()
assert auth is not None
assert mock_pass.is_not_called()
def test__create_new_username_credential_succeeds_from_args(
self, mock_pass):
test_args = Namespace(**vars(args_to_mock))
test_args.username = "******"
test_args.password = "******"
active_session = Session()
active_session._update_session_data(test_args)
auth = active_session._create_new_credential(
test_args.password, Session.PASSWORD_CRED_TYPE)
def test__create_new_token_credential_succeeds_from_self(self, mock_pass):
active_session = Session()
active_session.token = "gibberish2"
active_session.token_name = "readable2"
auth = active_session._create_new_token_credential()
assert mock_pass.is_not_called()
assert auth is not None
assert auth.token_name == "readable2", auth
assert auth.personal_access_token == "gibberish2", auth
def test_create_session_first_time_no_args(self, mock_tsc, mock_pass,
mock_file, mock_path,
mock_json_load, mock_json_dump):
mock_path = _set_mocks_for_json_file_exists(mock_path, False)
assert mock_path.exists("anything") is False
test_args = Namespace(**vars(args_to_mock))
mock_tsc().users.get_by_id.return_value = None
new_session = Session()
with self.assertRaises(SystemExit):
auth = new_session.create_session(test_args)
def run_command(args):
logger = log(__class__.__name__, args.logging_level)
logger.debug(_("tabcmd.launching"))
session = Session()
server = session.create_session(args)
logger.info(
_("tabcmd.add.users.to_site").format(args.users.name, args.name))
UserCommand.act_on_users(logger, server, "added",
server.groups.add_user, args)
def test__create_new_username_credential_succeeds_from_self(
self, mock_pass):
active_session = Session()
active_session.username = "******"
active_session.site = ""
auth = active_session._create_new_credential(
None, Session.PASSWORD_CRED_TYPE)
assert mock_pass.has_been_called()
assert auth is not None
assert auth.username == "user3", auth
assert auth.password == mock_pass(), auth
def test_read_session_from_json(self, mock_open, mock_path, mock_load,
mock_dump):
_set_mocks_for_json_file_exists(mock_path)
_set_mocks_for_json_file_saved_username(mock_load, "AUTHTOKEN",
"USERNAME")
test_session = Session()
test_session._read_from_json()
assert hasattr(test_session.auth_token,
"AUTHTOKEN") is False, test_session
assert hasattr(test_session, "password") is False, test_session
assert test_session.username == "USERNAME"
assert test_session.server_url == fakeserver, test_session.server_url
def run_command(args):
logger = log(__class__.__name__, args.logging_level)
logger.debug(_("tabcmd.launching"))
session = Session()
server = session.create_session(args)
try:
logger.info(_("tabcmd.find.group").format(args.name))
group_id = Server.find_group_id(logger, server, args.name)
logger.info(_("deletegroup.status").format(group_id))
server.groups.delete(group_id)
logger.info(_("tabcmd.result.succeeded"))
except TSC.ServerResponseError as e:
Errors.exit_with_error(logger, "tabcmd.result.failed.delete.group", e)
def run_command(args):
logger = log(__class__.__name__, args.logging_level)
logger.debug(_("tabcmd.launching"))
session = Session()
server = session.create_session(args)
logger.info(_("export.status").format(args.schedule))
schedule = DatasourcesAndWorkbooks.get_items_by_name(
logger, server.schedules, args.schedule)[0]
if not schedule:
Errors.exit_with_error(
logger, _("publish.errors.server_resource_not_found"))
logger.info(_("runschedule.status"))
Errors.exit_with_error(logger, "Not yet implemented")
def run_command(args):
logger = log(__class__.__name__, args.logging_level)
logger.debug(_("tabcmd.launching"))
session = Session()
server = session.create_session(args)
site_item = Server.get_site_for_command_or_throw(logger, server, args)
try:
logger.info(_("reencryptextracts.status").format(site_item.name))
job = server.sites.encrypt_extracts(site_item.id)
except TSC.ServerResponseError as e:
Errors.exit_with_error(logger, e)
logger.info(_("common.output.job_queued_success"))
logger.debug("Extract re-encryption queued with JobID: {}".format(job.id))
def run_command(args):
logger = log(__class__.__name__, args.logging_level)
logger.debug(_("tabcmd.launching"))
session = Session()
server = session.create_session(args)
site_id = server.sites.get_by_name(args.site_name)
if site_id == session.site_id:
Errors.exit_with_error(
logger, "Cannot delete the site you are logged in to")
try:
server.sites.delete(site_id)
logger.info("Successfully deleted the site")
except TSC.ServerResponseError as e:
Errors.exit_with_error(logger, "Error deleting site", e)
def test_create_session_first_time_with_password_arg(
self, mock_tsc, mock_pass, mock_file, mock_path, mock_json_load,
mock_json_dump):
mock_path = _set_mocks_for_json_file_exists(mock_path, False)
test_args = Namespace(**vars(args_to_mock))
test_args.username = "******"
test_args.password = "******"
new_session = Session()
auth = new_session.create_session(test_args)
assert auth is not None, auth
assert auth.auth_token is not None, auth.auth_token
assert new_session.username == "uuuu", new_session
assert mock_tsc.has_been_called()
def run_command(args):
logger = log(__class__.__name__, args.logging_level)
logger.debug(_("tabcmd.launching"))
session = Session()
server = session.create_session(args)
try:
logger.info(_("creategroup.status").format(args.name))
new_group = TSC.GroupItem(args.name)
server.groups.create(new_group)
logger.info(_("tabcmd.result.succeeded"))
except TSC.ServerResponseError as e:
if args.continue_if_exists and Errors.is_resource_conflict(e):
logger.info(_("tabcmd.result.already_exists.group").format(args.name))
return
Errors.exit_with_error(logger, "tabcmd.result.failed.create_group")
def test_create_session_first_time_with_password_file_as_token(
self, mock_tsc, mock_pass, mock_file, mock_path, mock_json_load,
mock_json_dump):
mock_path = _set_mocks_for_json_file_exists(mock_path, False)
test_args = Namespace(**vars(args_to_mock))
test_args.token_name = "mytoken"
test_args.password_file = "filename"
with mock.patch("builtins.open", mock.mock_open(read_data="my_token")):
new_session = Session()
auth = new_session.create_session(test_args)
assert auth is not None, auth
assert auth.auth_token is not None, auth.auth_token
assert new_session.password_file == "filename", new_session
assert mock_tsc.has_been_called()
def run_command(args):
logger = log(__class__.__name__, args.logging_level)
logger.debug(_("tabcmd.launching"))
session = Session()
server = session.create_session(args)
try:
sites, pagination = server.sites.get()
logger.info(_("listsites.status").format(session.username))
for site in sites:
print("NAME:", site.name)
print("SITEID:", site.content_url)
if args.get_extract_encryption_mode:
print("EXTRACTENCRYPTION:", site.extract_encryption_mode)
print("")
except TSC.ServerResponseError as e:
Errors.exit_with_error(logger, e)
def test_create_session_first_time_with_token_arg(self, mock_tsc,
mock_pass, mock_file,
mock_path,
mock_json_load,
mock_json_dump):
mock_path = _set_mocks_for_json_file_exists(mock_path, False)
assert mock_path.exists("anything") is False
test_args = Namespace(**vars(args_to_mock))
test_args.token_name = "tn"
test_args.token = "foo"
new_session = Session()
auth = new_session.create_session(test_args)
assert auth is not None, auth
assert auth.auth_token is not None, auth.auth_token
assert auth.auth_token.name is not None, auth.auth_token
assert new_session.token == "foo", new_session.token
assert new_session.token_name == "tn", new_session
def run_command(args):
logger = log(__class__.__name__, args.logging_level)
logger.debug(_("tabcmd.launching"))
session = Session()
server = session.create_session(args)
number_of_users_listed = 0
number_of_users_added = 0
number_of_errors = 0
creation_site = "current site"
UserCommand.validate_file_for_import(args.filename,
logger,
detailed=True,
strict=args.require_all_valid)
logger.info(
_("tabcmd.add.users.to_x").format(args.filename.name,
creation_site))
user_obj_list = UserCommand.get_users_from_file(args.filename, logger)
logger.info(_("session.monitorjob.percent_complete").format(0))
error_list = []
for user_obj in user_obj_list:
try:
number_of_users_listed += 1
result = server.users.add(user_obj)
logger.info(
_("tabcmd.result.success.create_user").format(
user_obj.name))
number_of_users_added += 1
except TSC.ServerResponseError as e:
number_of_errors += 1
error_list.append(e)
logger.debug(e)
logger.info(_("session.monitorjob.percent_complete").format(100))
logger.info(
_("importcsvsummary.line.processed").format(
number_of_users_listed))
logger.info(
_("importcsvsummary.line.skipped").format(number_of_errors))
logger.info(
_("importcsvsummary.users.added.count").format(
number_of_users_added))
if number_of_errors > 0:
logger.info(_("importcsvsummary.error.details").format(error_list))
def test_create_session_with_active_session_saved(self, mock_tsc,
mock_pass, mock_file,
mock_path,
mock_json_load,
mock_json_dump):
_set_mocks_for_json_file_exists(mock_path, True)
_set_mocks_for_json_file_saved_username(mock_json_load, "auth_token",
None)
test_args = Namespace(**vars(args_to_mock))
test_args.token = "tn"
test_args.token_name = "tnnnn"
test_args.no_prompt = False
new_session = Session()
auth = new_session.create_session(test_args)
assert auth is not None, auth
assert auth.auth_token is not None, auth.auth_token
assert mock_tsc.has_been_called()
def run_command(args):
logger = log(__class__.__name__, args.logging_level)
logger.debug(_("tabcmd.launching"))
session = Session()
server = session.create_session(args)
parent_id = None
readable_name = args.project_name
if args.parent_project_path:
try:
logger.info(
_("tabcmd.find.parent_project").format(
args.parent_project_path))
parent = Server.get_project_by_name_and_parent_path(
logger, server, None, args.parent_project_path)
except TSC.ServerResponseError as exc:
Errors.exit_with_error(
logger, _("publish.errors.server_resource_not_found"), exc)
readable_name = "{0}/{1}".format(args.parent_project_path,
args.project_name)
parent_id = parent.id
logger.debug("parent project = `{0}`, id = {1}".format(
args.parent_project_path, parent_id))
logger.info(_("createproject.status").format(readable_name))
new_project = TSC.ProjectItem(args.project_name, args.description,
None, parent_id)
try:
project_item = server.projects.create(new_project)
logger.info(_("common.output.succeeded"))
return project_item
except TSC.ServerResponseError as e:
if Errors.is_resource_conflict(e):
if args.continue_if_exists:
logger.info(
_("tabcmd.result.already_exists").format(
args.project_name))
return
else:
Errors.exit_with_error(
logger,
_("tabcmd.result.already_exists").format(
args.project_name))
Errors.exit_with_error(
logger, _("publish.errors.unexpected_server_response"), e)
def run_command(args):
logger = log(__class__.__name__, args.logging_level)
logger.debug(_("tabcmd.launching"))
session = Session()
server = session.create_session(args)
try:
if args.datasource:
logger.info(_("deleteextracts.for.datasource").format(args.datasource))
data_source_item = Server.get_data_source_item(logger, server, args.datasource)
job = server.datasources.delete_extract(data_source_item)
elif args.workbook:
logger.info(_("deleteextracts.for.workbook_name").format(args.workbook))
workbook_item = Server.get_workbook_item(logger, server, args.workbook)
job = server.workbooks.delete_extract(workbook_item)
except TSC.ServerResponseError as e:
Errors.exit_with_error(logger, _("deleteextracts.errors.error"), e)
logger.info(_("common.output.job_queued_success"))
logger.debug("Extract deletion queued with JobID: {}".format(job.id))
def test_create_session_first_time_with_password_file_as_password(
self, mock_tsc, mock_pass, mock_file, mock_path, mock_json_load,
mock_json_dump):
mock_path = _set_mocks_for_json_file_exists(mock_path, False)
test_args = Namespace(**vars(args_to_mock))
test_args.username = "******"
# filename = os.path.join(os.path.dirname(__file__),"test_credential_file.txt")
# test_args.password_file = os.getcwd()+"/test_credential_file.txt"
test_args.password_file = "filename"
with mock.patch("builtins.open",
mock.mock_open(read_data="my_password")):
new_session = Session()
auth = new_session.create_session(test_args)
assert auth is not None, auth
assert auth.auth_token is not None, auth.auth_token
assert new_session.username == "uuuu", new_session
assert new_session.password_file == "filename", new_session
assert mock_tsc.has_been_called()
def run_command(args):
logger = log(__class__.__name__, args.logging_level)
logger.debug(_("tabcmd.launching"))
session = Session()
server = session.create_session(args)
logger.info(_("deleteusers.status").format(args.filename.name))
UserCommand.validate_file_for_import(args.filename,
logger,
strict=args.require_all_valid)
number_of_users_deleted = 0
number_of_errors = 0
user_obj_list = UserCommand.get_users_from_file(args.filename, logger)
logger.debug("Users: {}".format(len(user_obj_list)))
error_list = []
for user_obj in user_obj_list:
logger.info(
_("importcsvsummary.line.processed").format(
number_of_users_deleted))
try:
user_id = UserCommand.find_user_id(logger, server,
user_obj.name)
server.users.remove(user_id)
logger.debug(
_("tabcmd.result.success.delete_user").format(
user_obj.name, user_id))
number_of_users_deleted += 1
except Exception as e:
Errors.check_common_error_codes_and_explain(logger, e)
number_of_errors += 1
error_list.append(e)
logger.info(
_("importcsvsummary.line.processed").format(
number_of_users_deleted))
logger.info(
_("importcsvsummary.errors.count").format(number_of_errors))
if number_of_errors > 0:
logger.info(_("importcsvsummary.error.details").format(error_list))
