def setUpClass(self): """Database setup before the CRUD tests.""" print("Creating a temporary datatbsse...") engine = create_engine('sqlite:///:memory:') Base.metadata.create_all(engine) session = scoped_session(sessionmaker(bind=engine)) self.API_NAME = "demoapi" self.HYDRUS_SERVER_URL = "http://hydrus.com/" self.session = session self.doc = doc_maker.create_doc(doc, self.HYDRUS_SERVER_URL, self.API_NAME) test_classes = doc_parse.get_classes(self.doc.generate()) # Getting list of classes from APIDoc self.doc_collection_classes = [ self.doc.collections[i]["collection"].class_.title for i in self.doc.collections ] print(self.doc_collection_classes) print(random.choice(self.doc_collection_classes)) test_properties = doc_parse.get_all_properties(test_classes) doc_parse.insert_classes(test_classes, self.session) doc_parse.insert_properties(test_properties, self.session) print("Classes and properties added successfully.") print("Setup done, running tests...")
def main(): """Initialize the drone database.""" # Drop database if exists and create a new one. print("Droping database if exist") Base.metadata.drop_all(engine) print("Creating models....") Base.metadata.create_all(engine) print("Done") # Parse and insert classes to DB Session = sessionmaker(bind=engine) session = Session() doc = doc_gen("dummy", "dummy") doc_classes = get_classes(doc.generate()) doc_properties = get_all_properties(doc_classes) insert_classes(doc_classes, session=session) print("Classes inserted successfully.") insert_properties(doc_properties, session=session) print("Properties inserted successfully.") return None
def setUpClass(self): """Database setup before the tests.""" print("Creating a temporary datatbsse...") engine = create_engine('sqlite:///:memory:') Base.metadata.create_all(engine) Session = sessionmaker(bind=engine) session = Session() self.session = session self.API_NAME = "demoapi" self.HYDRUS_SERVER_URL = "http://hydrus.com/" self.app = app_factory(self.API_NAME) self.doc = doc_maker.createDoc(doc_writer_sample.api_doc.generate(), self.HYDRUS_SERVER_URL, self.API_NAME) test_classes = doc_parse.get_classes(self.doc.generate()) test_properties = doc_parse.get_all_properties(test_classes) doc_parse.insert_classes(test_classes, self.session) doc_parse.insert_properties(test_properties, self.session) add_user(1, "test", self.session) self.auth_header = { "Authorization": "Basic " + generate_basic_digest(1, "test") } print("Classes, Properties and Users added successfully.") print("Setup done, running tests...")
def setUp(self): """Database setup before the tests.""" super(AuthTestCase, self).setUp() print("Creating a temporary datatbase...") engine = create_engine('sqlite:///:memory:') Base.metadata.create_all(engine) session = scoped_session(sessionmaker(bind=engine)) self.session = session self.API_NAME = "demoapi" self.HYDRUS_SERVER_URL = "http://hydrus.com/" self.doc = doc_maker.create_doc(doc_writer_sample.api_doc.generate(), self.HYDRUS_SERVER_URL, self.API_NAME) self.gs = Getter_setter(self.session, self.HYDRUS_SERVER_URL, self.API_NAME, self.doc, True) self.app = app_factory(self.API_NAME, self.gs) test_classes = doc_parse.get_classes(self.doc.generate()) test_properties = doc_parse.get_all_properties(test_classes) doc_parse.insert_classes(test_classes, self.session) doc_parse.insert_properties(test_properties, self.session) add_user(1, "test", self.session) self.auth_header = {"Authorization": "Basic " + b64encode(b"1:test").decode("utf-8")} self.wrong_id = {"Authorization": "Basic " + b64encode(b"2:test").decode("utf-8")} self.wrong_pass = {"Authorization": "Basic " + b64encode(b"1:test2").decode("utf-8")} print("Classes, Properties and Users added successfully.") print("Setting up Hydrus utilities... ") print("Creating utilities context... ") print("Setup done, running tests...")
def setUpClass(self): """Database setup before the tests.""" print("Creating a temporary database...") engine = create_engine('sqlite:///:memory:') Base.metadata.create_all(engine) session = scoped_session(sessionmaker(bind=engine)) self.session = session self.API_NAME = "demoapi" self.HYDRUS_SERVER_URL = "http://hydrus.com/" self.app = app_factory(self.API_NAME) self.doc = doc_maker.create_doc(doc_writer_sample.api_doc.generate(), self.HYDRUS_SERVER_URL, self.API_NAME) test_classes = doc_parse.get_classes(self.doc.generate()) test_properties = doc_parse.get_all_properties(test_classes) doc_parse.insert_classes(test_classes, self.session) doc_parse.insert_properties(test_properties, self.session) print("Classes and properties added successfully.") print("Setting up Hydrus utilities... ") self.api_name_util = set_api_name(self.app, self.API_NAME) self.session_util = set_session(self.app, self.session) self.doc_util = set_doc(self.app, self.doc) self.client = self.app.test_client() print("Creating utilities context... ") self.api_name_util.__enter__() self.session_util.__enter__() self.doc_util.__enter__() self.client.__enter__() print("Setup done, running tests...")
def setUpClass(self): """Database setup before the tests.""" print("Creating a temporary datatbase...") engine = create_engine('sqlite:///:memory:') Base.metadata.create_all(engine) session = scoped_session(sessionmaker(bind=engine)) self.session = session self.API_NAME = "demoapi" self.HYDRUS_SERVER_URL = "http://hydrus.com/" self.app = app_factory(self.API_NAME) self.doc = doc_maker.create_doc(doc_writer_sample.api_doc.generate(), self.HYDRUS_SERVER_URL, self.API_NAME) test_classes = doc_parse.get_classes(self.doc.generate()) test_properties = doc_parse.get_all_properties(test_classes) doc_parse.insert_classes(test_classes, self.session) doc_parse.insert_properties(test_properties, self.session) add_user(1, "test", self.session) self.auth_header = { "X-Authentication": "", "Authorization": "Basic {}".format(b64encode(b"1:test").decode("ascii")) } self.wrong_id = { "X-Authentication": "", "Authorization": "Basic {}".format(b64encode(b"2:test").decode("ascii")) } self.wrong_pass = { "X-Authentication": "", "Authorization": "Basic {}".format(b64encode(b"1:test2").decode("ascii")) } print("Classes, Properties and Users added successfully.") print("Setting up Hydrus utilities... ") self.api_name_util = set_api_name(self.app, self.API_NAME) self.session_util = set_session(self.app, self.session) self.doc_util = set_doc(self.app, self.doc) self.auth_util = set_authentication(self.app, True) self.token_util = set_token(self.app, False) self.client = self.app.test_client() print("Creating utilities context... ") self.api_name_util.__enter__() self.session_util.__enter__() self.doc_util.__enter__() self.auth_util.__enter__() self.token_util.__enter__() self.client.__enter__() print("Setup done, running tests...")
def get_doc_classes_and_properties(doc): """ Extract classes and properties from a given HydraDoc object :param doc: HydraDoc object whose classes and properties have to extracted :type doc: HydraDoc :return: classes and properties in the HydraDoc object in a tuple :rtype: tuple(list, set) """ test_classes = doc_parse.get_classes(doc) test_properties = doc_parse.get_all_properties(test_classes) return (test_classes, test_properties)
def setUpClass(self): """Database setup before the CRUD tests.""" print("Creating a temporary datatbsse...") engine = create_engine('sqlite:///:memory:') Base.metadata.create_all(engine) session = scoped_session(sessionmaker(bind=engine)) self.session = session self.doc = doc test_classes = doc_parse.get_classes(self.doc.generate()) test_properties = doc_parse.get_all_properties(test_classes) doc_parse.insert_classes(test_classes, self.session) doc_parse.insert_properties(test_properties, self.session) print("Classes and properties added successfully.") print("Setup done, running tests...")
def setUpClass(self): """Database setup before the CRUD tests.""" print("Creating a temporary datatbsse...") engine = create_engine('sqlite:///:memory:') Base.metadata.create_all(engine) session = scoped_session(sessionmaker(bind=engine)) self.API_NAME = "demoapi" self.HYDRUS_SERVER_URL = "http://hydrus.com/" self.session = session self.doc = doc_maker.create_doc( doc_writer_sample.api_doc.generate(), self.HYDRUS_SERVER_URL, self.API_NAME) test_classes = doc_parse.get_classes(self.doc.generate()) test_properties = doc_parse.get_all_properties(test_classes) doc_parse.insert_classes(test_classes, self.session) doc_parse.insert_properties(test_properties, self.session) print("Classes and properties added successfully.") print("Setup done, running tests...")
def setUp(self): """Database setup before the tests.""" super(ViewsTestCase, self).setUp() print("Creating a temporary database...") engine = create_engine('sqlite:///:memory:') Base.metadata.create_all(engine) self.session = scoped_session(sessionmaker(bind=engine)) self.HYDRUS_SERVER_URL = "http://hydrus.com" self.API_NAME = "demoapi" self.doc = doc_maker.create_doc(doc_writer_sample.api_doc.generate(), self.HYDRUS_SERVER_URL, self.API_NAME) self.gs = Getter_setter(self.session, self.HYDRUS_SERVER_URL, self.API_NAME, self.doc, False) self.app = app_factory(self.API_NAME, self.gs) test_classes = doc_parse.get_classes(self.doc.generate()) test_properties = doc_parse.get_all_properties(test_classes) doc_parse.insert_classes(test_classes, self.session) doc_parse.insert_properties(test_properties, self.session) print("Classes and properties added successfully.") print("Setting up Hydrus utilities... ") print("Creating utilities context... ") print("Setup done, running tests...")
engine = create_engine(DB_URL) print("Droping database if exist") Base.metadata.drop_all(engine) print("Creating models....") Base.metadata.create_all(engine) print("Done") apidoc = doc_maker.create_doc(doc, HYDRUS_SERVER_URL, API_NAME) session = sessionmaker(bind=engine)() classes = doc_parse.get_classes(apidoc.generate()) properties = doc_parse.get_all_properties(classes) doc_parse.insert_classes(classes, session) doc_parse.insert_properties(properties, session) app = app_factory(API_NAME) with set_doc(app, apidoc): with set_authentication(app, False): with set_token(app, False): with set_hydrus_server_url(app, HYDRUS_SERVER_URL): with set_session(app, session): http_server = WSGIServer(('', PORT), app) http_server.serve_forever()
def startserver(adduser: Tuple, api: str, auth: bool, dburl: str, hydradoc: str, port: int, serverurl: str, token: bool, serve: None) -> None: """ Python Hydrus CLI :param adduser <tuple> : Contains the user credentials. :param api <str> : Sets the API name for the server. :param auth <bool> : Toggles the authentication. :param dburl <str> : Sets the database URL. :param hydradoc <str> : Sets the link to the HydraDoc file. :param port <int> : Sets the API server port. :param serverurl <str> : Sets the API server url. :param token <bool> : Toggle token based user auth. :param serve : Starts up the server. :return : None. """ # The database connection URL # See http://docs.sqlalchemy.org/en/rel_1_0/core/engines.html#sqlalchemy.create_engine for more info # DB_URL = 'sqlite:///database.db' DB_URL = dburl # Define the server URL, this is what will be displayed on the Doc HYDRUS_SERVER_URL = "{}:{}/".format(serverurl, str(port)) # The name of the API or the EntryPoint, the api will be at http://localhost/<API_NAME> API_NAME = api click.echo("Setting up the database") # Create a connection to the database you want to use engine = create_engine(DB_URL) click.echo("Creating models") # Add the required Models to the database Base.metadata.create_all(engine) # Define the Hydra API Documentation # NOTE: You can use your own API Documentation and create a HydraDoc object using doc_maker # Or you may create your own HydraDoc Documentation using doc_writer [see hydrus/hydraspec/doc_writer_sample] click.echo("Creating the API Documentation") apidoc = doc_maker.create_doc(json.loads(hydradoc.read()), HYDRUS_SERVER_URL, API_NAME) # Start a session with the DB and create all classes needed by the APIDoc session = scoped_session(sessionmaker(bind=engine)) click.echo("Adding Classes and Properties") # Get all the classes from the doc # You can also pass dictionary defined in hydrus/hydraspec/doc_writer_sample_output.py classes = doc_parse.get_classes(apidoc.generate()) # Get all the properties from the classes properties = doc_parse.get_all_properties(classes) # Insert them into the database doc_parse.insert_classes(classes, session) doc_parse.insert_properties(properties, session) click.echo("Adding authorized users") add_user(id_=adduser[0], paraphrase=adduser[1], session=session) # Insert them into the database doc_parse.insert_classes(classes, session) doc_parse.insert_properties(properties, session) click.echo("Creating the application") # Create a Hydrus app with the API name you want, default will be "api" app = app_factory(API_NAME) # Set the name of the API click.echo("Starting the application") with set_authentication(app, auth): # Use authentication for all requests with set_token(app, token): with set_api_name(app, api): # Set the API Documentation with set_doc(app, apidoc): # Set HYDRUS_SERVER_URL with set_hydrus_server_url(app, HYDRUS_SERVER_URL): # Set the Database session with set_session(app, session): # Start the Hydrus app http_server = WSGIServer(('', port), app) click.echo("Server running at:") click.echo(HYDRUS_SERVER_URL + API_NAME) try: http_server.serve_forever() except KeyboardInterrupt: pass
def startserver(adduser: Tuple, api: str, auth: bool, dburl: str, hydradoc: str, port: int, serverurl: str, token: bool, serve: None) -> None: """ Python Hydrus CLI :param openapi: : Sets the link to the Open Api Doc file. :param adduser <tuple> : Contains the user credentials. :param api <str> : Sets the API name for the server. :param auth <bool> : Toggles the authentication. :param dburl <str> : Sets the database URL. :param hydradoc <str> : Sets the link to the HydraDoc file (Supported formats - [.py, .jsonld, .yaml]) :param port <int> : Sets the API server port. :param serverurl <str> : Sets the API server url. :param token <bool> : Toggle token based user auth. :param serve : Starts up the server. :return : None. Raises: Error: If `hydradoc` is not of a supported format[.py, .jsonld, .yaml]. """ # The database connection URL # See http://docs.sqlalchemy.org/en/rel_1_0/core/engines.html for more info # DB_URL = 'sqlite:///database.db' DB_URL = dburl # Define the server URL, this is what will be displayed on the Doc HYDRUS_SERVER_URL = "{}:{}/".format(serverurl, str(port)) # The name of the API or the EntryPoint, the api will be at # http://localhost/<API_NAME> API_NAME = api click.echo("Setting up the database") # Create a connection to the database you want to use engine = create_engine(DB_URL) click.echo("Creating models") # Add the required Models to the database Base.metadata.create_all(engine) # Define the Hydra API Documentation # NOTE: You can use your own API Documentation and create a HydraDoc object # using doc_maker or you may create your own HydraDoc Documentation using # doc_writer [see hydra_python_core/doc_writer_sample] click.echo("Creating the API Documentation") if hydradoc: # Getting hydradoc format # Currently supported formats [.jsonld, .py, .yaml] try: hydradoc_format = hydradoc.split(".")[-1] if hydradoc_format == 'jsonld': with open(hydradoc, 'r') as f: doc = json.load(f) elif hydradoc_format == 'py': doc = SourceFileLoader( "doc", "./examples/drones/doc.py").load_module().doc elif hydradoc_format == 'yaml': with open(hydradoc, 'r') as stream: doc = parse(yaml.load(stream)) else: raise ("Error - hydradoc format not supported.") click.echo("Using %s as hydradoc" % hydradoc) apidoc = doc_maker.create_doc(doc, HYDRUS_SERVER_URL, API_NAME) except BaseException: click.echo("Problem parsing specified hydradoc file, " "using sample hydradoc as default.") apidoc = doc_maker.create_doc(api_document, HYDRUS_SERVER_URL, API_NAME) else: click.echo("No hydradoc specified, using sample hydradoc as default.\n" "For creating api documentation see this " "https://www.hydraecosystem.org/01-Usage.html#newdoc\n" "You can find the example used in examples/drones/doc.py") apidoc = doc_maker.create_doc(api_document, HYDRUS_SERVER_URL, API_NAME) # Start a session with the DB and create all classes needed by the APIDoc session = scoped_session(sessionmaker(bind=engine)) click.echo("Adding Classes and Properties") # Get all the classes from the doc # You can also pass dictionary defined in # hydra_python_core/doc_writer_sample_output.py classes = doc_parse.get_classes(apidoc.generate()) # Get all the properties from the classes properties = doc_parse.get_all_properties(classes) # Insert them into the database doc_parse.insert_classes(classes, session) doc_parse.insert_properties(properties, session) click.echo("Adding authorized users") add_user(id_=adduser[0], paraphrase=adduser[1], session=session) # Insert them into the database doc_parse.insert_classes(classes, session) doc_parse.insert_properties(properties, session) click.echo("Creating the application") # Create a Hydrus app with the API name you want, default will be "api" app = app_factory(API_NAME) # Set the name of the API click.echo("Starting the application") with set_authentication(app, auth): # Use authentication for all requests with set_token(app, token): with set_api_name(app, api): # Set the API Documentation with set_doc(app, apidoc): # Set HYDRUS_SERVER_URL with set_hydrus_server_url(app, HYDRUS_SERVER_URL): # Set the Database session with set_session(app, session): # Start the Hydrus app http_server = WSGIServer(('', port), app) click.echo("Server running at:") click.echo("{}{}".format(HYDRUS_SERVER_URL, API_NAME)) try: http_server.serve_forever() except KeyboardInterrupt: pass
def startserver(adduser, api, auth, hydradoc, port, serve): """Python Hydrus CLI""" # The database connection URL # See http://docs.sqlalchemy.org/en/rel_1_0/core/engines.html#sqlalchemy.create_engine for more info # DB_URL = 'sqlite:///database.db' DB_URL = 'sqlite:///:memory:' # Define the server URL, this is what will be displayed on the Doc HYDRUS_SERVER_URL = "http://localhost:" + str(port) + "/" # The name of the API or the EntryPoint, the api will be at http://localhost/<API_NAME> API_NAME = api click.echo("Setting up the database") # Create a connection to the database you want to use engine = create_engine(DB_URL) click.echo("Creating models") # Add the required Models to the database Base.metadata.create_all(engine) # Define the Hydra API Documentation # NOTE: You can use your own API Documentation and create a HydraDoc object using doc_maker # Or you may create your own HydraDoc Documentation using doc_writer [see hydrus/hydraspec/doc_writer_sample] click.echo("Creating the API Documentation") apidoc = doc_maker.create_doc(json.loads(hydradoc.read()), HYDRUS_SERVER_URL, API_NAME) # Start a session with the DB and create all classes needed by the APIDoc session = scoped_session(sessionmaker(bind=engine)) click.echo("Adding Classes and Properties") # Get all the classes from the doc classes = doc_parse.get_classes( apidoc.generate() ) # You can also pass dictionary defined in hydrus/hydraspec/doc_writer_sample_output.py # Get all the properties from the classes properties = doc_parse.get_all_properties(classes) # Insert them into the database doc_parse.insert_classes(classes, session) doc_parse.insert_properties(properties, session) click.echo("Adding authorized users") add_user(id_=adduser[0], paraphrase=adduser[1], session=session) # Insert them into the database doc_parse.insert_classes(classes, session) doc_parse.insert_properties(properties, session) getter_setter = Getter_setter(session, HYDRUS_SERVER_URL, API_NAME, apidoc, True) print("Creating the application") # Create a Hydrus app with the API name you want, default will be "api" app = app_factory(API_NAME, getter_setter) # Set the name of the API print("Starting the application") http_server = WSGIServer(('', 8080), app) print("Server running at:") print(HYDRUS_SERVER_URL + API_NAME) try: http_server.serve_forever() except KeyboardInterrupt: pass
print("Droping database if exist") Base.metadata.drop_all(engine) print("Creating models....") Base.metadata.create_all(engine) print("Done") apidoc = doc_maker.create_doc(doc, HYDRUS_SERVER_URL, API_NAME) session = sessionmaker(bind=engine)() classes = doc_parse.get_classes(apidoc.generate()) properties = doc_parse.get_all_properties(classes) doc_parse.insert_classes(classes, session) doc_parse.insert_properties(properties, session) app = app_factory(API_NAME) # Set the API Documentation with set_doc(app, apidoc): # Set HYDRUS_SERVER_URL with set_hydrus_server_url(app, HYDRUS_SERVER_URL): # Set the Database session with set_session(app, session): http_server = WSGIServer(('', PORT), app) print("Server running") http_server.serve_forever()