def test_save_then_read(self): test_session = Session() test_session.username = "******" test_session.server_url = fakeserver test_session.password_file = "users.csv" test_session._save_session_to_json() new_session = Session() new_session._read_from_json() assert new_session.username == "USN", new_session.username assert hasattr(new_session, "password") is False, new_session assert new_session.server_url == fakeserver, new_session.server_url test_session.end_session_and_clear_data()
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 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): 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 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 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 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_save_session_to_json(self, mock_open, mock_path, mock_load, mock_dump): _set_mocks_for_json_file_exists(mock_path) test_session = Session() test_session.username = "******" test_session.server = "SRVR" test_session._save_session_to_json() assert mock_dump.was_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_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_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) 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) 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) 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_load_saved_session_data(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", "username") test_args = Namespace(**vars(args_to_mock)) new_session = Session() new_session._read_existing_state() new_session._update_session_data(test_args) assert new_session, new_session assert new_session.username == "username", new_session.username assert new_session.server_url == fakeserver, new_session.server_url assert mock_tsc.has_been_called()
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) 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))