def main(): parser = argparse.ArgumentParser() parser.add_argument("--auth", choices=["rsa", "cert"], default="rsa", help="Authentication method to use") parser.add_argument("--config", help="Config json file to be used") args = parser.parse_args() # Configure log configure_logging() # Cert Auth flow: pass path to certificate config.json file if args.config is None: config_path = os.path.join(os.path.dirname(__file__), "..", "resources", "config.json") else: config_path = args.config configure = SymConfig(config_path, config_path) configure.load_config() if args.auth == "rsa": auth = SymBotRSAAuth(configure) elif args.auth == "cert": auth = Auth(configure) else: raise ValueError("Unexpected value for auth: " + args.auth) auth.authenticate() # Initialize SymBotClient with auth and configure objects bot_client = SymBotClient(auth, configure) # Initialize datafeed service datafeed_event_service = bot_client.get_async_datafeed_event_service() # Initialize listener objects and append them to datafeed_event_service # Datafeed_event_service polls the datafeed and the event listeners # respond to the respective types of events im_listener_test = AsyncIMListenerImp(bot_client) datafeed_event_service.add_im_listener(im_listener_test) room_listener_test = AsyncRoomListenerImp(bot_client) datafeed_event_service.add_room_listener(room_listener_test) # This is just a function to demonstrate the non-blocking nature of the async datafeed async def timed_ringer(period_in_seconds, message): while True: await asyncio.sleep(period_in_seconds) print(message) # Create and read the datafeed print('Starting datafeed') loop = asyncio.get_event_loop() awaitables = asyncio.gather(timed_ringer(2, "Ding"), timed_ringer(5, "Dong"), datafeed_event_service.start_datafeed()) loop.run_until_complete(awaitables)
def main(): print('Python Client runs using Cert authentication') # Configure log configure_logging() # Cert Auth flow: pass path to certificate config.json file configure = SymConfig('../resources/config.json') configure.load_config() auth = Auth(configure) auth.authenticate() # Initialize SymBotClient with auth and configure objects bot_client = SymBotClient(auth, configure) # Initialize datafeed service datafeed_event_service = bot_client.get_datafeed_event_service() # Initialize listener objects and append them to datafeed_event_service # Datafeed_event_service polls the datafeed and the event listeners # respond to the respective types of events im_listener_test = IMListenerTestImp(bot_client) datafeed_event_service.add_im_listener(im_listener_test) room_listener_test = RoomListenerTestImp(bot_client) datafeed_event_service.add_room_listener(room_listener_test) # Create and read the datafeed print('Starting datafeed') datafeed_event_service.start_datafeed()
def setUp(self): configure = SymConfig( get_path_relative_to_resources_folder('./bot-config.json')) configure.load_config() configure.data['datafeedVersion'] = 'v2' bot_client = SymBotClient(SymBotRSAAuth(configure), configure) self.datafeed_client = bot_client.get_datafeed_client()
def setUp(self): try: conf, auth = load_from_env_var("SYMPHONY_TEST_CONFIG") self.configure = conf self.auth = auth except ValueError: #RSA Auth flow: self.configure = SymConfig( 'sym_api_client_python/resources/config.json') self.configure.load_config() auth = SymBotRSAAuth(self.configure) auth.authenticate() # Initialize SymBotClient with auth and configure objects self.bot_client = SymBotClient(auth, self.configure)
def setUp(self): try: conf, auth = load_from_env_var("SYMPHONY_TEST_CONFIG") self.configure = conf self.auth = auth except ValueError: #RSA Auth flow: self.configure = SymConfig('sym_api_client_python/resources/config.json') self.configure.load_config() auth = SymBotRSAAuth(self.configure) auth.authenticate() # Initialize SymBotClient with auth and configure objects self.bot_client = SymBotClient(self.auth, self.configure) self.streamId = 'qfC1jCKzQ0ELq96TMs58dX___o_kveOkdA' self.user_id = '349026222344902'
def main(): global loopCount parser = argparse.ArgumentParser() parser.add_argument("--auth", choices=["rsa", "cert"], default="rsa", help="Authentication method to use") parser.add_argument("--config", help="Config json file to be used") args = parser.parse_args() # Configure log configure_logging() configure = SymConfig(_configPath, _configPath) configure.load_config() if args.auth == "rsa": auth = SymBotRSAAuth(configure) elif args.auth == "cert": auth = Auth(configure) else: raise ValueError("Unexpected value for auth: " + args.auth) auth.authenticate() # Initialize SymBotClient with auth and configure objects bot_client = SymBotClient(auth, configure) # Initialize datafeed service datafeed_event_service = bot_client.get_async_datafeed_event_service() # Initialize listener objects and append them to datafeed_event_service # Datafeed_event_service polls the datafeed and the event listeners # respond to the respective types of events im_listener_test = AsyncIMListenerImp(bot_client) datafeed_event_service.add_im_listener(im_listener_test) room_listener_test = AsyncRoomListenerImp(bot_client) datafeed_event_service.add_room_listener(room_listener_test) # Create and read the datafeed logging.debug('Starting datafeed') logging.info('Datafeed started - bot is ready') loop = asyncio.get_event_loop() awaitables = asyncio.gather(datafeed_event_service.start_datafeed()) loop.run_until_complete(awaitables)
def setUp(self): try: conf, auth = load_from_env_var("SYMPHONY_TEST_CONFIG") self.configure = conf self.auth = auth except ValueError: #RSA Auth flow: self.configure = SymConfig('sym_api_client_python/resources/config.json') self.configure.load_config() auth = SymBotRSAAuth(self.configure) auth.authenticate() #initialize SymBotClient with auth and configure objects self.bot_client = SymBotClient(self.auth, self.configure) self.streamId = 'ychiFHXta__zF7YqoLOnN3___pBQNr6mdA' self.messageId = 'g05bspw5c5E7Aq2SMZjIJX___o_KIUG2bQ' self.test_message = dict(message = '<messageML><hash tag="reed"/></messageML>') self.params = {"text" : "hi", "streamId" : "ychiFHXta__zF7YqoLOnN3___pBQNr6mdA"}
def main(): print('Python Client runs using RSA authentication') parser = argparse.ArgumentParser() parser.add_argument("--config", help="Config json file to be used") args = parser.parse_args() # Configure log configure_logging() # Cert Auth flow: pass path to certificate config.json file if args.config is None: config_path = os.path.join(os.path.dirname(__file__), "..", "sym_api_client_python", "resources", "rsa_config.json") else: config_path = args.config # RSA Auth flow: pass path to rsa config.json file) configure = SymConfig(config_path, __file__) configure.load_config() #auth = SymBotRSAAuth(configure) auth = SymBotRSAAuth(configure) auth.authenticate() # Initialize SymBotClient with auth and configure objects bot_client = SymBotClient(auth, configure) # Initialize datafeed service datafeed_event_service = bot_client.get_datafeed_event_service() # Initialize listener objects and append them to datafeed_event_service # Datafeed_event_service polls the datafeed and the event listeners # respond to the respective types of events im_listener_test = IMListenerTestImp(bot_client) datafeed_event_service.add_im_listener(im_listener_test) room_listener_test = RoomListenerTestImp(bot_client) datafeed_event_service.add_room_listener(room_listener_test) # Create and read the datafeed print('Starting datafeed') datafeed_event_service.start_datafeed()
def setUp(self): logging.debug('hi') #RSA Auth flow: configure = SymConfig( 'sym_api_client_python/resources/rsa_config.json') configure.load_rsa_config() auth = SymBotRSAAuth(configure) auth.authenticate() #initialize SymBotClient with auth and configure objects self.botClient = SymBotClient(auth, configure)
def main(): print('Python Client runs using RSA authentication') # Configure log configure_logging() # RSA Auth flow: pass path to rsa config.json file configure = SymConfig('../resources/config.json') configure.load_config() auth = SymBotRSAAuth(configure) auth.authenticate() # Initialize SymBotClient with auth and configure objects bot_client = SymBotClient(auth, configure) df = DataFeedClient2(bot_client) bot_client.datafeed_client = df # Initialize datafeed service datafeed_event_service = bot_client.get_datafeed_event_service() # Initialize listener objects and append them to datafeed_event_service # Datafeed_event_service polls the datafeed and the event listeners # respond to the respective types of events null_response = mvc.NullResponse() controllers = mvc.Controllers() controllers.add(info.Controller(null_response, info.View())) cc = summary.Controller(null_response, summary.View()) c = tweets.Controller(tweets.Response(bot_client, cc), tweets.View()) controllers.add(c) controllers.add( create.Controller(create.Response(bot_client, c), create.View())) room_listener_test = GeneralRoomListener(bot_client, controllers) datafeed_event_service.add_room_listener(room_listener_test) elements_listener_test = GeneralElementsListener(bot_client, controllers) datafeed_event_service.add_elements_listener(elements_listener_test) # Create and read the datafeed print('Starting datafeed') datafeed_event_service.start_datafeed()
def main(): configure_logging() configure = SymConfig('./config.json') configure.load_config() bot_env = load_env('./environment.json') auth = SymBotRSAAuth(configure) auth.authenticate() # Initialize SymBotClient with auth and configure objects bot_client = SymBotClient(auth, configure) bot_client.bot_id = bot_env['bot_id'] # Initialize datafeed service datafeed_event_service = bot_client.get_datafeed_event_service() # Add Listeners to datafeed event service im_listener_test = IMListenerTestImp(bot_client) datafeed_event_service.add_im_listener(im_listener_test) element_listener_test = ElementsListenerTestImp(bot_client) datafeed_event_service.add_elements_listener(element_listener_test) # Create and read the datafeed print('Starting datafeed') datafeed_event_service.start_datafeed()
def __init__(self, bot=None, *, threads=None, debug=False, symphony_config="symphony.json", symphony_log="symphony.log", **kwargs): """ Parameters ---------- bot : minette.Minette, default None Instance of Minette. If None, create new instance of Minette by using `**kwargs` symphony_config : str, default 'symphony.json' Config file for Symphony SDK symphony_log : str, defautl 'symphony.log' Log file of Symphony SDK threads : int, default None Max number of worker threads. If None, number of processors on the machine, multiplied by 5 debug : bool, default False Debug mode """ super().__init__(bot=bot, threads=threads, debug=debug, **kwargs) # setup root logger (used internally in symphony libraries) logging.basicConfig( filename=symphony_log, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", filemode="w", level=logging.DEBUG) # set logging level for urllib3 used in symphony libraries logging.getLogger("urllib3").setLevel(logging.WARNING) # configure and authenticate config = SymConfig(symphony_config) config.load_config() auth = SymBotRSAAuth(config) auth.authenticate() # initialize SymBotClient with auth and configure objects self.bot_client = SymBotClient(auth, config) self.datafeed_client = self.bot_client.get_datafeed_client()
class TestUsers(unittest.TestCase): def setUp(self): try: conf, auth = load_from_env_var("SYMPHONY_TEST_CONFIG") self.configure = conf self.auth = auth except ValueError: #RSA Auth flow: self.configure = SymConfig( 'sym_api_client_python/resources/config.json') self.configure.load_config() auth = SymBotRSAAuth(self.configure) auth.authenticate() # Initialize SymBotClient with auth and configure objects self.bot_client = SymBotClient(auth, self.configure) #pass def test_getUserFromUsername(self): print('testing get_user_from_user_name function') username = self.configure.data["botUsername"] self.assertTrue( self.bot_client.get_user_client().get_user_from_user_name( username)) #pass def test_getUserFromEmail(self): print('testing get_user_from_email function') email = self.configure.data["botEmailAddress"] self.assertTrue( self.bot_client.get_user_client().get_user_from_email(email)) #pass def test_getUserFromId(self): print('testing get_user_from_id function') self.assertTrue(self.bot_client.get_user_client().get_user_from_id( '344147139494909')) #pass def test_getUsersFromIdList(self): print('testing get_users_from_id_list function') self.assertTrue( self.bot_client.get_user_client().get_users_from_id_list( ['344147139494862', '344147139494909'])) #pass def test_getUsersFromEmailList(self): print('testing get_users_from_email_list function') self.assertTrue( self.bot_client.get_user_client().get_users_from_email_list( ['*****@*****.**', '*****@*****.**'])) #pass def test_searchUsers(self): print('testing search users function') username = self.configure.data["botUsername"] # Make a search string by taking the first half of the username search_string = username[:int(len(username) / 2)] self.assertTrue( self.bot_client.get_user_client().search_users(search_string))
def main(): global loopCount # Configure log configure_logging() # Cert Auth flow: pass path to certificate config.json file config_path = os.path.join(os.path.dirname(__file__), "../resources", "config.json") configure = SymConfig(config_path, config_path) configure.load_config() auth = SymBotRSAAuth(configure) auth.authenticate() # Initialize SymBotClient with auth and configure objects bot_client = SymBotClient(auth, configure) # add rss instance to bot mr = reader.RssReader('../resources/state.json') bot_client.reader = mr # Initialize datafeed service datafeed_event_service = bot_client.get_async_datafeed_event_service() # Initialize listener objects and append them to datafeed_event_service # Datafeed_event_service polls the datafeed and the event listeners # respond to the respective types of events im_listener = AsyncIMListenerImp(bot_client) datafeed_event_service.add_im_listener(im_listener) room_listener = AsyncRoomListenerImp(bot_client) datafeed_event_service.add_room_listener(room_listener) # Create and read the datafeed logging.info('Datafeed started - bot is ready') loop = asyncio.get_event_loop() awaitables = asyncio.gather(datafeed_event_service.start_datafeed()) loop.run_until_complete(awaitables)
def main(): # Configure log configure_logging() # Load configuration configure = SymConfig('../resources/config.json') configure.load_config() # Authenticate based on authType in config if ('authType' not in configure.data or configure.data['authType'] == 'rsa'): print('Python Client runs using RSA authentication') auth = SymBotRSAAuth(configure) else: print('Python Client runs using certificate authentication') auth = Auth(configure) auth.authenticate() # Initialize SymBotClient with auth and configure objects bot_client = SymBotClient(auth, configure) # Initialize datafeed service datafeed_event_service = bot_client.get_async_datafeed_event_service() # Initialize listener objects and append them to datafeed_event_service # Datafeed_event_service polls the datafeed and the event listeners # respond to the respective types of events datafeed_event_service.add_im_listener(IMListenerImpl(bot_client)) datafeed_event_service.add_room_listener(RoomListenerImpl(bot_client)) datafeed_event_service.add_elements_listener(ElementsListenerImpl(bot_client)) # Create and read the datafeed print('Starting datafeed') try: loop = asyncio.get_event_loop() loop.run_until_complete(datafeed_event_service.start_datafeed()) except (KeyboardInterrupt, SystemExit): None except: raise
def setUpClass(cls): logging.debug('testing health_check file:') try: conf, auth = load_from_env_var("SYMPHONY_TEST_CONFIG") cls.configure = conf cls.auth = auth except ValueError: #RSA Auth flow: cls.configure = SymConfig( 'sym_api_client_python/resources/config.json') cls.configure.load_config() cls.auth = SymBotRSAAuth(cls.configure) cls.auth.authenticate() # Initialize SymBotClient with auth and configure objects cls.bot_client = SymBotClient(cls.auth, cls.configure)
def setUpClass(cls): logging.debug('testing synchronous datafeed') try: conf, auth = load_from_env_var("SYMPHONY_TEST_CONFIG") cls.configure = conf cls.auth = auth except ValueError: logging.error("Unable to find config from environment variables") #RSA Auth flow: cls.configure = SymConfig( 'sym_api_client_python/resources/config.json') cls.configure.load_config() cls.auth = SymBotRSAAuth(cls.configure) cls.auth.authenticate() # Initialize SymBotClient with auth and configure objects cls.bot_client = SymBotClient(cls.auth, cls.configure)
def main(): global loopCount # Configure log configure_logging() # Cert Auth flow: pass path to certificate config.json file config_path = os.path.join(os.path.dirname(__file__), "../resources", "config.json") configure = SymConfig(config_path, config_path) configure.load_config() auth = SymBotRSAAuth(configure) auth.authenticate() # Initialize SymBotClient with auth and configure objects bot_client = SymBotClient(auth, configure) # add rss instance to bot #bot_client.reader = mr stream = 'JjRqq6OBIa7s5wkdNI1b8n___otjgHfIdA' count = 0 while True: logging.debug('XXXX Loop stream ' + stream) count = count + 1 display = "<card accent='tempo-bg-color--blue' iconSrc=''><body><h1>LOOP: " + str( count) + "</h1></body></card>" bot_client.get_message_client().send_msg( stream, dict(message="""<messageML>""" + display + """</messageML>""")) time.sleep(3) display = "<card accent='tempo-bg-color--blue' iconSrc=''><body>" mr = reader.RssReader('../resources/state.json') feeds = mr.checkrss() if len(feeds) == 0: display += "No Feeds" for topic in feeds: for feed in feeds[topic]: logging.debug('adding feeed to show') display += "<p><a href='" + feed['link'] + "'>" + feed[ 'title'] + "</a></p>" display += "</body></card>" print(display) bot_client.get_message_client().send_msg( stream, dict(message="""<messageML>""" + display + """</messageML>"""))
def main(): parser = argparse.ArgumentParser() parser.add_argument("--auth", choices=["rsa", "cert"], default="rsa", help="Authentication method to use") parser.add_argument("--config", help="Config json file to be used") args = parser.parse_args() # Cert Auth flow: pass path to certificate config.json file config_path = args.config configure = SymConfig(config_path, config_path) configure.load_config() if args.auth == "rsa": auth = SymBotRSAAuth(configure) elif args.auth == "cert": auth = Auth(configure) else: raise ValueError("Unexpected value for auth: " + args.auth) auth.authenticate() # Initialize SymBotClient with auth and configure objects bot_client = SymBotClient(auth, configure) print('successfully authenticated') run_import(bot_client) print('successfully imported')
class SymphonyAdapter(Adapter): """ Adapter for LINE Messaging API Attributes ---------- bot : minette.Minette Instance of Minette bot_client : SymBotClient Symphony chatbot client datafeed_client : DataFeedClient Datafeed client using long polling config : minette.Config Configuration timezone : pytz.timezone Timezone logger : logging.Logger Logger threads : int Number of worker threads to process requests executor : ThreadPoolExecutor Thread pool of workers debug : bool Debug mode """ def __init__(self, bot=None, *, threads=None, debug=False, symphony_config="symphony.json", symphony_log="symphony.log", **kwargs): """ Parameters ---------- bot : minette.Minette, default None Instance of Minette. If None, create new instance of Minette by using `**kwargs` symphony_config : str, default 'symphony.json' Config file for Symphony SDK symphony_log : str, defautl 'symphony.log' Log file of Symphony SDK threads : int, default None Max number of worker threads. If None, number of processors on the machine, multiplied by 5 debug : bool, default False Debug mode """ super().__init__(bot=bot, threads=threads, debug=debug, **kwargs) # setup root logger (used internally in symphony libraries) logging.basicConfig( filename=symphony_log, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", filemode="w", level=logging.DEBUG) # set logging level for urllib3 used in symphony libraries logging.getLogger("urllib3").setLevel(logging.WARNING) # configure and authenticate config = SymConfig(symphony_config) config.load_config() auth = SymBotRSAAuth(config) auth.authenticate() # initialize SymBotClient with auth and configure objects self.bot_client = SymBotClient(auth, config) self.datafeed_client = self.bot_client.get_datafeed_client() def start_datafeed(self): """ Start datafeed to read and process events from Symphony """ # get datafeed id datafeed_id = self.datafeed_client.create_datafeed() self.logger.info("Datafeed client is ready") # datafeed loop forever while True: try: # read datafeed by datafeed_id (30 sec long polling) data = self.datafeed_client.read_datafeed(datafeed_id) if data: # api returns list of events but SDK nest it to array.(I don't know why...) events = data[0] for event in events: if event["initiator"]["user"][ "userId"] != self.bot_client.get_bot_user_info( )["id"]: if self.executor: self.executor.submit(self.handle_event, event) else: self.handle_event(event) except Exception as ex: self.logger.error("Error occured in datafeed loop: " + str(ex) + "\n" + traceback.format_exc()) def handle_event(self, event): """ Handle event and reply message Parameters ---------- event : Event Event data from Symphony """ channel_messages, stream_id = super().handle_event(event) if channel_messages: for msg in channel_messages: self.logger.info("Minette> {}".format( msg["message"] if "message" in msg else msg)) self.bot_client.get_message_client().send_msg(stream_id, msg) def _extract_token(self, event): """ Extract token from event Parameters ---------- event : Event Event from LINE Messaging API Returns ------- message : Message Request message object """ return event["payload"]["messageSent"]["message"]["stream"]["streamId"] def _to_minette_message(self, event): """ Convert Symphony Event object to Minette Message object Parameters ---------- event : Event Event from Symphony. See the url below for information https://developers.symphony.com/restapi/docs/real-time-events Returns ------- message : minette.Message Request message object """ if self.debug: self.logger.info(event) msg = Message(type=event["type"], channel="Symphony", channel_detail="", channel_user_id=str( event["initiator"]["user"]["userId"]), channel_message=event) if msg.type == "MESSAGESENT": m = event["payload"]["messageSent"]["message"] msg.token = m["stream"]["streamId"] msg.text = lxml.html.fromstring(m["message"]).text_content() if m["stream"]["streamType"] == "ROOM": msg.group = Group(id=m["stream"]["streamId"], type="ROOM") if "attachments" in m: for a in m["attachments"]: if len(a["images"]) > 0: content_type = "image" else: content_type = "file" msg.payloads.append( Payload(content_type=content_type, content=a)) return msg @staticmethod def _to_channel_message(message): """ Convert Minette Message object to Symphony message dict Parameters ---------- message : Message Response message object Returns ------- response : dict Message dict for Symphony """ return {"message": "<messageML>{}</messageML>".format(message.text)}
def setUp(self): self.config = SymConfig( get_path_relative_to_resources_folder('./bot-config.json')) self.config.load_config() self.client = SymBotClient(None, self.config) self.ran = False
class TestStreams(unittest.TestCase): # run before each test function def setUp(self): try: conf, auth = load_from_env_var("SYMPHONY_TEST_CONFIG") self.configure = conf self.auth = auth except ValueError: #RSA Auth flow: self.configure = SymConfig('sym_api_client_python/resources/config.json') self.configure.load_config() auth = SymBotRSAAuth(self.configure) auth.authenticate() # Initialize SymBotClient with auth and configure objects self.bot_client = SymBotClient(self.auth, self.configure) self.streamId = 'qfC1jCKzQ0ELq96TMs58dX___o_kveOkdA' self.user_id = '349026222344902' #always passes # def test_facts(self): # self.assertEqual(1,1) #pass def test_createIM(self): print('testing CreateIm function') self.assertTrue(self.bot_client.get_stream_client().create_im([self.user_id])) #pass but will fail if you pass data thats already been used like name and description def test_createRoom(self): print('testing create_room function') self.assertTrue(self.bot_client.get_stream_client().create_room()) #pass: make sure that bot or user that is making update_room call is owner of room def test_updateRoom(self): print('testing update_room function') self.assertTrue(self.bot_client.get_stream_client().update_room(self.room_id)) #pass def test_roomInfo(self): print('testing roomInfo function') self.assertTrue(self.bot_client.get_stream_client().get_room_info(self.streamId)) #pass def test_activateRoom(self): print('testing activate_room function') active = False self.assertTrue(self.bot_client.get_stream_client().activate_room(self.streamId)) #pass def test_getRoomMembers(self): self.assertTrue(self.bot_client.get_stream_client().get_room_members(self.streamId)) #pass def test_addMember(self): print('testing addmember function') userId = '344147139494862' self.assertTrue(self.bot_client.get_stream_client().add_member_to_room(self.streamId, self.user_id)) #pass def test_shareRoom(self): print('testing share_room function') self.assertTrue(self.bot_client.get_stream_client().share_room(self.stream_id)) #pass def test_removeMemberFromRoom(self): print('testing remove Member function') userId = '344147139494862' self.assertTrue(self.bot_client.get_stream_client().remove_member_from_room(self.stream_id, self.user_id)) #pass def test_promoteUserToOwner(self): print('testing promote owner function') userId = '344147139494862' self.assertTrue(self.bot_client.get_stream_client().promote_user_to_owner(self.stream_id, self.user_id)) #pass def test_demoteUserFromOwner(self): print('testing demote owner function') userId = '344147139494862' self.assertTrue(self.bot_client.get_stream_client().demote_user_from_owner(self.stream_id, self.user_id)) #pass def test_searchRooms(self): print('testing roomSearch function') self.assertTrue(self.bot_client.get_stream_client().search_rooms()) #pass def test_getUserStreams(self): print('testing listUserStreams fucntion') self.assertTrue(self.bot_client.get_stream_client().get_user_streams()) #pass def test_getRoomInfo(self): print('testing streamInfo function') self.assertTrue(self.bot_client.get_stream_client().get_room_info(self.room_id)) #pass def test_streamInfo(self): print('testing streamInfo V2 function') self.assertTrue(self.bot_client.get_stream_client().streamInfo(self.room_id)) #pass def test_listStreamsEnterprise(self): print('testing list streams enterprise function') self.assertTrue(self.bot_client.get_stream_client().list_streams_enterprise()) #DOESNOTPASS def test_listStreamsEnterpriseV2(self): print('testing list streamsV2 enterprise function') self.assertTrue(self.bot_client.get_stream_client().list_streams_enterprise_v2()) #DOESNOTPASS --> 405: verify if endpoint is still live def test_getStreamMembers(self): print('testing getstreamMembers function') self.assertTrue(self.bot_client.get_stream_client().get_stream_members(self.streamId))
class TestMessages(unittest.TestCase): def setUp(self): try: conf, auth = load_from_env_var("SYMPHONY_TEST_CONFIG") self.configure = conf self.auth = auth except ValueError: #RSA Auth flow: self.configure = SymConfig('sym_api_client_python/resources/config.json') self.configure.load_config() auth = SymBotRSAAuth(self.configure) auth.authenticate() #initialize SymBotClient with auth and configure objects self.bot_client = SymBotClient(self.auth, self.configure) self.streamId = 'ychiFHXta__zF7YqoLOnN3___pBQNr6mdA' self.messageId = 'g05bspw5c5E7Aq2SMZjIJX___o_KIUG2bQ' self.test_message = dict(message = '<messageML><hash tag="reed"/></messageML>') self.params = {"text" : "hi", "streamId" : "ychiFHXta__zF7YqoLOnN3___pBQNr6mdA"} def test_createMessage(self): print('testing create messages function') message = self.test_message self.assertTrue(self.bot_client.get_message_client().send_msg(self.streamId, message)) def test_create_message_async(self): asyncio.get_event_loop().run_until_complete( self.bot_client.get_message_client().send_msg_async(self.streamId, self.test_message) ) def test_getMessageFromStream(self): print('testing get_msg_from_stream function') self.assertTrue(self.bot_client.get_message_client().get_msg_from_stream(self.streamId, 0)) def test_get_message_from_stream_async(self): asyncio.get_event_loop().run_until_complete( self.bot_client.get_message_client().get_msg_from_stream_async(self.streamId, 0) ) def test_create_message_attachment(self): fp = __file__ self.bot_client.get_message_client().send_msg_with_attachment( self.streamId, self.test_message["message"], "testfilename.txt", fp ) def test_create_message_attachment_iostream(self): file_like_object = io.StringIO("This is a test") self.bot_client.get_message_client().send_msg_with_attachment( self.streamId, self.test_message["message"], "testfilename.txt", file_like_object ) def test_create_message_attachment_async(self): file_like_object = io.StringIO("This is a test") asyncio.get_event_loop().run_until_complete( self.bot_client.get_message_client().send_msg_with_attachment_async( self.streamId, self.test_message["message"], "testfilename.txt", file_like_object ) ) def test_create_message_attachment_iostream_async(self): file_like_object = io.StringIO("This is a test") asyncio.get_event_loop().run_until_complete( self.bot_client.get_message_client().send_msg_with_attachment_async( self.streamId, self.test_message["message"], "testfilename.txt", file_like_object ) ) def test_getMessageAttachments(self): pass def test_importMessage(self): pass #this function returns a 200 but its empty def test_postMessageSearch(self): print('testing post Message search function') self.assertTrue(self.bot_client.get_message_client().post_msg_search(self.params)) def test_getMessageSearch(self): print('testing getMessage Search function') self.assertTrue(self.bot_client.get_message_client().get_msg_search({'streamId' : self.streamId, 'text'})) def test_getMessageStatus(self): print('testing getMessage Status function') self.assertTrue(self.bot_client.get_message_client().get_msg_status(self.messageId)) def test_getSupportedAttachmentTypes(self): print('testing getAttachmentType function') self.assertTrue(self.bot_client.get_message_client().get_supported_attachment_types())