public inbox for [email protected]
help / color / mirror / Atom feedFrom: Navnath Gadakh <[email protected]>
To: Dave Page <[email protected]>
Cc: pgadmin-hackers <[email protected]>
Cc: Kanchan Mohitey <[email protected]>
Subject: Re: pgAdmin IV : Unittest modular patch
Date: Mon, 8 Aug 2016 19:37:32 +0530
Message-ID: <CAOAJCYqSdptT3Tyt+nNXxhMd5C2Z-u7yVM6TD4bUQUqE3nsQDg@mail.gmail.com> (raw)
In-Reply-To: <CA+OCxoyi_BC++vo79HuYf9RF1YY6Q2CM=zRNT1eGn4nc-r5Vwg@mail.gmail.com>
References: <CAOAJCYrcxBN2J_3dWq0Cwc82fkugzUi3NKD4jKoTKRBot=ev8w@mail.gmail.com>
<CAOAJCYpSBXcfEC5d4Sv_=jV86m1=rKUK0tMkZFhdSHkPb=XT3A@mail.gmail.com>
<CA+OCxowW0wjpNT-o0YF1Bg9rtD6Z7sqp35ZRUgoEguVKO4OtSw@mail.gmail.com>
<CAOAJCYr1JwYK4x2wDYw2UVAZoXC5a0FQT7Yz1Y_Wn46kzPMmQg@mail.gmail.com>
<CA+OCxoxqahNgLmvQqqErQZL2JS0EaQwyXkgkzvkFtGNh0OKV6w@mail.gmail.com>
<CAOAJCYqQQ4MaudVaVwfcateuxum-W39HwRiEorhYP8zbqjxN0g@mail.gmail.com>
<CA+OCxozZVCwB4t6hXjMeHbBV8Fx1cm_Cg1tknjWyYxLFZNYsEQ@mail.gmail.com>
<CAFOhELes8Vu_VciiVu31wfaYtTuCFUReEF1mfNXB4nSMcTNrHA@mail.gmail.com>
<CAOAJCYpY=u4T38s+XqQDOky10e7A_Wb_q9bbiwhx_=eF-6i-dQ@mail.gmail.com>
<CA+OCxoxm9_f5PJVLhwrSk6bozmivv_-=o+spffXjkYk+qPDKeg@mail.gmail.com>
<CAOAJCYpcye6nQAPB8os9vZXOhAf9wEvr6rA9i4vuZLDVrRYF0g@mail.gmail.com>
<CA+OCxowE5D0N2oq-Da+eXh4+cZMA3=GqB85-nE+YHuaACfjhbQ@mail.gmail.com>
<CAOAJCYonmDD-oqjwhJNVpWVHxyf-bTn_eJ8o7wNMr7sOOpBvkA@mail.gmail.com>
<CA+OCxozHiy2UsJp6jvYRNfYv3RWTijdFeoPuZH4dqyyT-knnjQ@mail.gmail.com>
<CAOAJCYo4Lyc3f+-6a7cYxsxjn9GKG7j7R8VYiDmxgrntyds-xg@mail.gmail.com>
<CA+OCxoxKo1L9ZNH81h-kmzWvzn7Pj=T4fUnP6FpvchePpoAB0A@mail.gmail.com>
<CAOAJCYq94E=zhaVWWUORP62nSD-PJ2y2crJeL41Mmv-50i-VbQ@mail.gmail.com>
<CA+OCxoy2kSbeBDCYaXGKOvEZAtpEO7uviL5cPakNf0FM=C=dzg@mail.gmail.com>
<CAOAJCYpPicjz4cOsTHHGfMRN7qgeNwdvbkyS4ihy5FZYPgUyHQ@mail.gmail.com>
<CA+OCxowBEaow-6X1NzcA_i1qzKoiXJprh33s1wciriMup3_omA@mail.gmail.com>
<CAOAJCYrzjjrf-qpGH+rm4cWajvcYuyQH8jufqWBFL3qVAVpSoA@mail.gmail.com>
<CA+OCxozcDPW47_FMgfpqrTyVN4=Ldu7dqkFWRR_bvMkxBEQvWA@mail.gmail.com>
<CAOAJCYqj1BxDfATGR+VKoyacjSZ+f4rK5ZtGDz==JW7GC5FKMA@mail.gmail.com>
<CA+OCxoyi_BC++vo79HuYf9RF1YY6Q2CM=zRNT1eGn4nc-r5Vwg@mail.gmail.com>
List-Unsubscribe: <mailto:[email protected]?body=unsub%20pgadmin-hackers>
Hi Dave,
Please find the updated patch for API unit test cases for *Roles and
Tablespaces *nodes
As we finalized
Now,
1. The user will specify the tablespace path in test_config.json.in
2. If tablespace path not found, skip the test cases for that
server(Only tablespace test cases)
3. Add the skipped test summary in the test result. (Now it's
showing on console + in log file, but need to update in a final enhanced
test summary report. Which is research point we will work on that after
finishing all nodes API test cases)
4. Removed the test_ prefix from the values in the config files.
Thanks!
On Thu, Aug 4, 2016 at 5:55 PM, Dave Page <[email protected]>
wrote:
> On Thu, Aug 4, 2016 at 1:02 PM, Navnath Gadakh
> <[email protected]> wrote:
> > Hi Dave,
> >
> > On Thu, Aug 4, 2016 at 4:04 PM, Dave Page <[email protected]>
> > wrote:
> >>
> >> Hi
> >>
> >> On Thu, Aug 4, 2016 at 10:27 AM, Navnath Gadakh
> >> <[email protected]> wrote:
> >>
> >> >> Oh - does the per-server config override the main config? That's
> >> >> useful. So anything that's in test_advanced_config.py can be
> >> >> overridden on a per-server basis in test_config.py?
> >> >
> >> > No.
> >> > per-server i.e advance config(test_advanced_config.json.in) and
> main
> >> > config(test_config.json) both are different files. In main config we
> >> > just
> >> > mention the server’s credentials.(We can also mention per server
> >> > credentails) and in test_advanced_config.json.in(here we say
> per-server
> >> > config)
> >> > we mention the advanced configurations i.e. test data for each node.
> >>
> >> OK.
> >>
> >> > So, let's summarize the discussion:
> >> > - Let user specify the tablespace path in
> >> > test_advanced_config.json.in
> >>
> >> No - test_config.py. It should be per-server.
> >
> > We don't have a file named 'test_config.py' but we have a server's
> > credential file named 'test_config.json'.
> > So, you are saying the tablespace path to be added in
> > 'test_config.json'.
> > Am I correct?
>
> Yeah, sorry. It should be a property of the server configuration.
>
>
> --
> Dave Page
> VP, Chief Architect, Tools & Installers
> EnterpriseDB: http://www.enterprisedb.com
> The Enterprise PostgreSQL Company
>
> Blog: http://pgsnake.blogspot.com
> Twitter: @pgsnake
>
--
Thanks,
Navnath Gadakh
Software Engineer
EnterpriseDB Corporation
Mobile: +91 9975389878
--
Sent via pgadmin-hackers mailing list ([email protected])
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgadmin-hackers
Attachments:
[application/octet-stream] pgadmin_unittest_roles_tablespaces.patch (104.9K, 3-pgadmin_unittest_roles_tablespaces.patch)
download | inline diff:
diff --git a/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_add.py b/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_add.py
index 85dcc6c..490e7d9 100644
--- a/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_add.py
+++ b/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_add.py
@@ -7,10 +7,11 @@
#
# ##################################################################
-import json
from pgadmin.utils.route import BaseTestGenerator
from regression import test_utils as utils
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from . import utils as database_utils
class DatabaseAddTestCase(BaseTestGenerator):
@@ -24,7 +25,8 @@ class DatabaseAddTestCase(BaseTestGenerator):
('Check Databases Node URL', dict(url='/browser/database/obj/'))
]
- def setUp(self):
+ @classmethod
+ def setUpClass(cls):
"""
This function used to add the sever
@@ -32,27 +34,23 @@ class DatabaseAddTestCase(BaseTestGenerator):
"""
# Add the server
- utils.add_server(self.tester)
+ server_utils.add_server(cls.tester)
+
+ # Connect to server
+ cls.server_connect_response, cls.server_group, cls.server_ids = \
+ server_utils.connect_server(cls.tester)
+
+ if len(cls.server_connect_response) == 0:
+ raise Exception("No Server(s) connected to add the database!!!")
def runTest(self):
""" This function will add database under 1st server of tree node. """
- server_connect_response, server_group, server_ids = \
- utils.connect_server(self.tester)
-
- for server_connect, server_id in zip(server_connect_response,
- server_ids):
- if server_connect['data']['connected']:
- data = utils.get_db_data(server_connect)
- db_response = self.tester.post(self.url + str(server_group) +
- "/" + server_id + "/",
- data=json.dumps(data),
- content_type='html/json')
- self.assertTrue(db_response.status_code, 200)
- response_data = json.loads(db_response.data.decode('utf-8'))
- utils.write_db_parent_id(response_data)
+ database_utils.add_database(self.tester, self.server_connect_response,
+ self.server_ids)
- def tearDown(self):
+ @classmethod
+ def tearDownClass(cls):
"""
This function deletes the added database, added server and the
'parent_id.pkl' file which is created in setup()
@@ -60,6 +58,6 @@ class DatabaseAddTestCase(BaseTestGenerator):
:return: None
"""
- utils.delete_database(self.tester)
- utils.delete_server(self.tester)
+ database_utils.delete_database(cls.tester)
+ server_utils.delete_server(cls.tester)
utils.delete_parent_id_file()
diff --git a/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_delete.py b/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_delete.py
index 6830b5a..756a689 100644
--- a/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_delete.py
+++ b/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_delete.py
@@ -7,12 +7,10 @@
#
# ##################################################################
-import json
-
from pgadmin.utils.route import BaseTestGenerator
from regression import test_utils as utils
-from regression.test_setup import config_data
-from regression.test_utils import get_ids
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from . import utils as database_utils
class DatabaseDeleteTestCase(BaseTestGenerator):
@@ -23,43 +21,38 @@ class DatabaseDeleteTestCase(BaseTestGenerator):
('Check Databases Node URL', dict(url='/browser/database/obj/'))
]
- def setUp(self):
+ @classmethod
+ def setUpClass(cls):
"""
This function perform the three tasks
1. Add the test server
2. Connect to server
+ 3. Add the databases
:return: None
"""
# Firstly, add the server
- utils.add_server(self.tester)
- # Secondly, connect to server/database
- utils.connect_server(self.tester)
+ server_utils.add_server(cls.tester)
- def runTest(self):
- """ This function will delete the database."""
+ # Connect to server
+ cls.server_connect_response, cls.server_group, cls.server_ids = \
+ server_utils.connect_server(cls.tester)
- srv_grp = config_data['test_server_group']
- all_id = get_ids()
- server_ids = all_id["sid"]
- db_ids_dict = all_id["did"][0]
+ if len(cls.server_connect_response) == 0:
+ raise Exception("No Server(s) connected to add the database!!!")
- for server_id in server_ids:
- db_id = db_ids_dict[int(server_id)]
- db_con = utils.verify_database(self.tester, srv_grp, server_id,
- db_id)
- if len(db_con) == 0:
- raise Exception("No database(s) to delete for server id %s"
- % server_id)
- response = self.tester.delete(self.url + str(srv_grp) + '/' +
- str(server_id) + '/' + str(db_id),
- follow_redirects=True)
+ # Add database
+ database_utils.add_database(cls.tester, cls.server_connect_response,
+ cls.server_ids)
+
+ def runTest(self):
+ """ This function will delete the database."""
- response_data = json.loads(response.data.decode('utf-8'))
- self.assertTrue(response_data['success'], 1)
+ database_utils.delete_database(self.tester)
- def tearDown(self):
+ @classmethod
+ def tearDownClass(cls):
"""
This function deletes the added server and the 'parent_id.pkl' file
which is created in setup() function.
@@ -67,5 +60,5 @@ class DatabaseDeleteTestCase(BaseTestGenerator):
:return: None
"""
- utils.delete_server(self.tester)
+ server_utils.delete_server(cls.tester)
utils.delete_parent_id_file()
diff --git a/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_get.py b/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_get.py
index 7350f72..739dff8 100644
--- a/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_get.py
+++ b/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_get.py
@@ -11,6 +11,8 @@ from pgadmin.utils.route import BaseTestGenerator
from regression import test_utils as utils
from regression.test_setup import config_data
from regression.test_utils import get_ids
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from . import utils as database_utils
class DatabasesGetTestCase(BaseTestGenerator):
@@ -20,22 +22,33 @@ class DatabasesGetTestCase(BaseTestGenerator):
scenarios = [
# Fetching default URL for database node.
- ('Check Databases Node URL', dict(url='/browser/database/obj/'))
+ ('Check Dat abases Node URL', dict(url='/browser/database/obj/'))
]
- def setUp(self):
+ @classmethod
+ def setUpClass(cls):
"""
This function perform the three tasks
1. Add the test server
2. Connect to server
+ 3. Add the databases
:return: None
"""
# Firstly, add the server
- utils.add_server(self.tester)
- # Secondly, connect to server/database
- utils.connect_server(self.tester)
+ server_utils.add_server(cls.tester)
+
+ # Connect to server
+ cls.server_connect_response, cls.server_group, cls.server_ids = \
+ server_utils.connect_server(cls.tester)
+
+ if len(cls.server_connect_response) == 0:
+ raise Exception("No Server(s) connected to add the database!!!")
+
+ # Add database
+ database_utils.add_database(cls.tester, cls.server_connect_response,
+ cls.server_ids)
def runTest(self):
""" This function will fetch added database. """
@@ -44,19 +57,21 @@ class DatabasesGetTestCase(BaseTestGenerator):
server_ids = all_id["sid"]
db_ids_dict = all_id["did"][0]
- srv_grp = config_data['test_server_group']
+ srv_grp = config_data['server_group']
for server_id in server_ids:
db_id = db_ids_dict[int(server_id)]
- db_con = utils.verify_database(self.tester, srv_grp, server_id,
- db_id)
+ db_con = database_utils.verify_database(self.tester, srv_grp,
+ server_id,
+ db_id)
if db_con["info"] == "Database connected.":
response = self.tester.get(
self.url + str(srv_grp) + '/' + str(server_id) + '/' +
str(db_id), follow_redirects=True)
self.assertEquals(response.status_code, 200)
- def tearDown(self):
+ @classmethod
+ def tearDownClass(cls):
"""
This function deletes the added database, added server
and the 'parent_id.pkl' file which is created in setup() function.
@@ -64,6 +79,6 @@ class DatabasesGetTestCase(BaseTestGenerator):
:return: None
"""
- utils.delete_database(self.tester)
- utils.delete_server(self.tester)
+ database_utils.delete_database(cls.tester)
+ server_utils.delete_server(cls.tester)
utils.delete_parent_id_file()
diff --git a/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_put.py b/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_put.py
index 4615d34..c32e3ca 100644
--- a/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_put.py
+++ b/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_put.py
@@ -11,8 +11,10 @@ import json
from pgadmin.utils.route import BaseTestGenerator
from regression import test_utils as utils
-from regression.test_setup import config_data, advanced_config_data
+from regression.test_setup import advanced_config_data
from regression.test_utils import get_ids
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from . import utils as database_utils
class DatabasesUpdateTestCase(BaseTestGenerator):
@@ -25,44 +27,58 @@ class DatabasesUpdateTestCase(BaseTestGenerator):
('Check Databases Node', dict(url='/browser/database/obj/'))
]
- def setUp(self):
+ @classmethod
+ def setUpClass(cls):
"""
This function perform the three tasks
1. Add the test server
2. Connect to server
+ 3. Add the databases
:return: None
"""
# Firstly, add the server
- utils.add_server(self.tester)
- # Secondly, connect to server/database
- utils.connect_server(self.tester)
+ server_utils.add_server(cls.tester)
+
+ # Connect to server
+ cls.server_connect_response, cls.server_group, cls.server_ids = \
+ server_utils.connect_server(cls.tester)
+
+ if len(cls.server_connect_response) == 0:
+ raise Exception("No Server(s) connected to add the database!!!")
+
+ # Add database
+ database_utils.add_database(cls.tester, cls.server_connect_response,
+ cls.server_ids)
def runTest(self):
""" This function will update the comments field of database."""
- srv_grp = config_data['test_server_group']
all_id = get_ids()
server_ids = all_id["sid"]
db_ids_dict = all_id["did"][0]
for server_id in server_ids:
db_id = db_ids_dict[int(server_id)]
- db_con = utils.verify_database(self.tester, srv_grp, server_id,
- db_id)
+ db_con = database_utils.verify_database(self.tester,
+ utils.SERVER_GROUP,
+ server_id,
+ db_id)
if db_con["info"] == "Database connected.":
data = {
- "comments": advanced_config_data["test_db_update_data"][0]
- ["test_comment"],
+ "comments": advanced_config_data["db_update_data"][0]
+ ["comment"],
"id": db_id
}
put_response = self.tester.put(
- self.url + str(srv_grp) + '/' + str(server_id) + '/' +
+ self.url + str(utils.SERVER_GROUP) + '/' + str(
+ server_id) + '/' +
str(db_id), data=json.dumps(data), follow_redirects=True)
self.assertEquals(put_response.status_code, 200)
- def tearDown(self):
+ @classmethod
+ def tearDownClass(self):
"""
This function deletes the added server and 'parent_id.pkl' file
which is created in setup() function.
@@ -70,5 +86,6 @@ class DatabasesUpdateTestCase(BaseTestGenerator):
:return: None
"""
- utils.delete_server(self.tester)
+ database_utils.delete_database(self.tester)
+ server_utils.delete_server(self.tester)
utils.delete_parent_id_file()
diff --git a/web/pgadmin/browser/server_groups/servers/databases/tests/utils.py b/web/pgadmin/browser/server_groups/servers/databases/tests/utils.py
new file mode 100644
index 0000000..fcffaf4
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/tests/utils.py
@@ -0,0 +1,176 @@
+# ##########################################################################
+#
+# #pgAdmin 4 - PostgreSQL Tools
+#
+# #Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# #This software is released under the PostgreSQL Licence
+#
+# ##########################################################################
+
+import json
+import os
+import pickle
+import uuid
+
+from regression.test_setup import pickle_path, config_data, advanced_config_data
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from regression import test_utils as utils
+
+
+DATABASE_URL = '/browser/database/obj/'
+DATABASE_CONNECT_URL = 'browser/database/connect/'
+
+
+def get_db_data(server_connect_data):
+ """
+ This function is used to get advance config test data for appropriate
+ server
+
+ :param server_connect_data: list of server details
+ :return data: database details
+ :rtype: dict
+ """
+
+ adv_config_data = None
+ data = None
+ db_user = server_connect_data['data']['user']['name']
+
+ # Get the config data of appropriate db user
+ for config_test_data in advanced_config_data['add_database_data']:
+ if db_user == config_test_data['owner']:
+ adv_config_data = config_test_data
+
+ if adv_config_data is not None:
+ data = {
+ "datacl": adv_config_data['privileges_acl'],
+ "datconnlimit": adv_config_data['conn_limit'],
+ "datowner": adv_config_data['owner'],
+ "deffuncacl": adv_config_data['fun_acl'],
+ "defseqacl": adv_config_data['seq_acl'],
+ "deftblacl": adv_config_data['tbl_acl'],
+ "deftypeacl": adv_config_data['type_acl'],
+ "encoding": adv_config_data['encoding'],
+ "name": str(uuid.uuid4())[1:8],
+ "privileges": adv_config_data['privileges'],
+ "securities": adv_config_data['securities'],
+ "variables": adv_config_data['variables']
+ }
+ return data
+
+
+def write_db_id(response_data):
+ """
+ This function writes the server and database related data like server
+ name, server id , database name, database id etc.
+
+ :param response_data: server and databases details
+ :type response_data: dict
+ :return: None
+ """
+
+ db_id = response_data['node']['_id']
+ server_id = response_data['node']['_pid']
+ pickle_id_dict = utils.get_pickle_id_dict()
+ if os.path.isfile(pickle_path):
+ existing_server_id = open(pickle_path, 'rb')
+ tol_server_id = pickle.load(existing_server_id)
+ pickle_id_dict = tol_server_id
+ if 'did' in pickle_id_dict:
+ if pickle_id_dict['did']:
+ # Add the db_id as value in dict
+ pickle_id_dict["did"][0].update({server_id: db_id})
+ else:
+ # Create new dict with server_id and db_id
+ pickle_id_dict["did"].append({server_id: db_id})
+ db_output = open(pickle_path, 'wb')
+ pickle.dump(pickle_id_dict, db_output)
+ db_output.close()
+
+
+def add_database(tester, server_connect_response, server_ids):
+ """
+ This function add the database into servers
+
+ :param tester: flask test client
+ :type tester: flask test object
+ :param server_connect_response: server response
+ :type server_connect_response: dict
+ :param server_ids: server ids
+ :type server_ids: list
+ :return: None
+ """
+
+ for server_connect, server_id in zip(server_connect_response, server_ids):
+ if server_connect['data']['connected']:
+ data = get_db_data(server_connect)
+ db_response = tester.post(DATABASE_URL + str(utils.SERVER_GROUP) +
+ "/" + server_id + "/",
+ data=json.dumps(data),
+ content_type='html/json')
+ assert db_response.status_code == 200
+ response_data = json.loads(db_response.data.decode('utf-8'))
+ write_db_id(response_data)
+
+
+def verify_database(tester, server_group, server_id, db_id):
+ """
+ This function verifies that database is exists and whether it connect
+ successfully or not
+
+ :param tester: test client
+ :type tester: flask test client object
+ :param server_group: server group id
+ :type server_group: int
+ :param server_id: server id
+ :type server_id: str
+ :param db_id: database id
+ :type db_id: str
+ :return: temp_db_con
+ :rtype: list
+ """
+
+ # Verify servers
+ server_utils.verify_server(tester,server_group,server_id)
+
+ # Connect to database
+ con_response = tester.post('{0}{1}/{2}/{3}'.format(
+ DATABASE_CONNECT_URL, server_group, server_id, db_id),
+ follow_redirects=True)
+ temp_db_con = json.loads(con_response.data.decode('utf-8'))
+
+ return temp_db_con
+
+
+def delete_database(tester):
+ """
+ This function used to delete the added databases
+
+ :param tester: test client object
+ :return: None
+ """
+
+ server_ids = None
+ db_ids_dict = None
+
+ all_id = utils.get_ids()
+ if "sid" and "did" in all_id.keys():
+ server_ids = all_id["sid"]
+ if all_id['did']:
+ db_ids_dict = all_id['did'][0]
+ else:
+ raise Exception("Keys are not found in pickle dict: {}".format(["sid", "did"]))
+
+ if server_ids and db_ids_dict is not None:
+ for server_id in server_ids:
+ server_response = server_utils.verify_server(tester, utils.SERVER_GROUP, server_id)
+ if server_response["data"]["connected"]:
+ db_id = db_ids_dict[int(server_id)]
+ response = tester.delete(DATABASE_URL + str(utils.SERVER_GROUP) + '/' +
+ str(server_id) + '/' + str(db_id),
+ follow_redirects=True)
+ assert response.status_code == 200
+ response_data = json.loads(response.data.decode('utf-8'))
+ assert response_data['success'] == 1
+ else:
+ raise Exception("No servers/databases found.")
+
diff --git a/web/pgadmin/browser/server_groups/servers/roles/tests/__init__.py b/web/pgadmin/browser/server_groups/servers/roles/tests/__init__.py
new file mode 100644
index 0000000..4a11bf8
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/roles/tests/__init__.py
@@ -0,0 +1,16 @@
+# #################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+# ##################################################################
+
+from pgadmin.utils.route import BaseTestGenerator
+
+
+class RoleGeneratorTestCase(BaseTestGenerator):
+
+ def runTest(self):
+ return
diff --git a/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_add.py b/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_add.py
new file mode 100644
index 0000000..9d8f949
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_add.py
@@ -0,0 +1,55 @@
+# #################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+# ##################################################################
+
+from pgadmin.utils.route import BaseTestGenerator
+from regression import test_utils as utils
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from . import utils as roles_utils
+
+
+class LoginRoleAddTestCase(BaseTestGenerator):
+ """This class has add role scenario"""
+
+ scenarios = [
+ # Fetching default URL for roles node.
+ ('Check Role Node', dict(url='/browser/role/obj/'))
+ ]
+
+ @classmethod
+ def setUpClass(cls):
+ """
+ This function used to add the sever
+
+ :return: None
+ """
+
+ # Add the server
+ server_utils.add_server(cls.tester)
+
+ # Connect to server
+ cls.server_connect_response, cls.server_group, cls.server_ids = \
+ server_utils.connect_server(cls.tester)
+
+ if len(cls.server_connect_response) == 0:
+ raise Exception("No Server(s) connected to add the roles!!!")
+
+ def runTest(self):
+ """This function test the add role scenario"""
+
+ roles_utils.add_role(self.tester, self.server_connect_response,
+ self.server_group, self.server_ids)
+
+ @classmethod
+ def tearDownClass(cls):
+ """This function deletes the role,server and parent id file"""
+
+ roles_utils.delete_role(cls.tester)
+ server_utils.delete_server(cls.tester)
+ utils.delete_parent_id_file()
+
diff --git a/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_delete.py b/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_delete.py
new file mode 100644
index 0000000..f3204cd
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_delete.py
@@ -0,0 +1,58 @@
+# #################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+# ##################################################################
+
+
+from pgadmin.utils.route import BaseTestGenerator
+from regression import test_utils as utils
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from . import utils as roles_utils
+
+
+class LoginRoleDeleteTestCase(BaseTestGenerator):
+ """This class has delete role scenario"""
+
+ scenarios = [
+ # Fetching default URL for roles node.
+ ('Check Role Node', dict(url='/browser/role/obj/'))
+ ]
+
+ @classmethod
+ def setUpClass(cls):
+ """
+ This function used to add the sever and roles
+
+ :return: None
+ """
+
+ # Add the server
+ server_utils.add_server(cls.tester)
+
+ # Connect to server
+ cls.server_connect_response, cls.server_group, cls.server_ids = \
+ server_utils.connect_server(cls.tester)
+
+ if len(cls.server_connect_response) == 0:
+ raise Exception("No Server(s) connected to add the roles!!!")
+
+ # Add the role
+ roles_utils.add_role(cls.tester, cls.server_connect_response,
+ cls.server_group, cls.server_ids)
+
+ def runTest(self):
+ """This function tests the delete role scenario"""
+
+ roles_utils.delete_role(self.tester)
+
+ @classmethod
+ def tearDownClass(self):
+ """This function deletes the role,server and parent id file"""
+
+ server_utils.delete_server(self.tester)
+ utils.delete_parent_id_file()
+
diff --git a/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_get.py b/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_get.py
new file mode 100644
index 0000000..4187fca
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_get.py
@@ -0,0 +1,67 @@
+# #################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+# ##################################################################
+
+from pgadmin.utils.route import BaseTestGenerator
+from regression import test_utils as utils
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from . import utils as roles_utils
+
+
+class LoginRoleGetTestCase(BaseTestGenerator):
+ """This class tests the get role scenario"""
+
+ scenarios = [
+ # Fetching default URL for roles node.
+ ('Check Role Node', dict(url='/browser/role/obj/'))
+ ]
+
+ @classmethod
+ def setUpClass(cls):
+ """
+ This function used to add the sever and roles
+
+ :return: None
+ """
+
+ # Add the server
+ server_utils.add_server(cls.tester)
+
+ # Connect to server
+ cls.server_connect_response, cls.server_group, cls.server_ids = \
+ server_utils.connect_server(cls.tester)
+
+ if len(cls.server_connect_response) == 0:
+ raise Exception("No Server(s) connected to get the roles!!!")
+
+ # Add the role
+ roles_utils.add_role(cls.tester, cls.server_connect_response,
+ cls.server_group, cls.server_ids)
+
+ def runTest(self):
+ """This function test the get role scenario"""
+
+ all_id = utils.get_ids()
+ server_ids = all_id["sid"]
+ role_ids_dict = all_id["lrid"][0]
+
+ for server_id in server_ids:
+ role_id = role_ids_dict[int(server_id)]
+ response = self.tester.get(
+ self.url + str(utils.SERVER_GROUP) + '/' +
+ str(server_id) + '/' + str(role_id),
+ follow_redirects=True)
+ self.assertEquals(response.status_code, 200)
+
+ @classmethod
+ def tearDownClass(cls):
+ """This function deletes the role,server and parent id file"""
+
+ roles_utils.delete_role(cls.tester)
+ server_utils.delete_server(cls.tester)
+ utils.delete_parent_id_file()
diff --git a/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_put.py b/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_put.py
new file mode 100644
index 0000000..f8c353e
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_put.py
@@ -0,0 +1,84 @@
+# #################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+# ##################################################################
+
+import json
+
+from pgadmin.utils.route import BaseTestGenerator
+from regression import test_utils as utils
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from regression.test_setup import advanced_config_data
+from . import utils as roles_utils
+
+
+class LoginRolePutTestCase(BaseTestGenerator):
+ """This class has update role scenario"""
+
+ scenarios = [
+ # Fetching default URL for roles node.
+ ('Check Role Node', dict(url='/browser/role/obj/'))
+ ]
+
+ @classmethod
+ def setUpClass(cls):
+ """
+ This function used to add the sever and roles
+
+ :return: None
+ """
+
+ # Add the server
+ server_utils.add_server(cls.tester)
+
+ # Connect to server
+ cls.server_connect_response, cls.server_group, cls.server_ids = \
+ server_utils.connect_server(cls.tester)
+
+ if len(cls.server_connect_response) == 0:
+ raise Exception("No Server(s) connected to get the roles!!!")
+
+ # Add the role
+ roles_utils.add_role(cls.tester, cls.server_connect_response,
+ cls.server_group, cls.server_ids)
+
+ def runTest(self):
+ """This function tests the update role data scenario"""
+
+ all_id = utils.get_ids()
+ server_ids = all_id["sid"]
+ role_ids_dict = all_id["lrid"][0]
+
+ for server_id in server_ids:
+ role_id = role_ids_dict[int(server_id)]
+ role_response = roles_utils.verify_role(self.tester,
+ utils.SERVER_GROUP,
+ server_id,
+ role_id)
+ if len(role_response) == 0:
+ raise Exception("No roles(s) to update!!!")
+
+ data = {
+ "description": advanced_config_data["lr_update_data"]
+ ["comment"],
+ "lrid": role_id
+ }
+ put_response = self.tester.put(
+ self.url + str(utils.SERVER_GROUP) + '/' +
+ str(server_id) + '/' + str(role_id),
+ data=json.dumps(data),
+ follow_redirects=True)
+
+ self.assertEquals(put_response.status_code, 200)
+
+ @classmethod
+ def tearDownClass(cls):
+ """This function deletes the role,server and parent id file"""
+
+ roles_utils.delete_role(cls.tester)
+ server_utils.delete_server(cls.tester)
+ utils.delete_parent_id_file()
diff --git a/web/pgadmin/browser/server_groups/servers/roles/tests/utils.py b/web/pgadmin/browser/server_groups/servers/roles/tests/utils.py
new file mode 100644
index 0000000..85e0990
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/roles/tests/utils.py
@@ -0,0 +1,187 @@
+# #################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+# ##################################################################
+
+import json
+import os
+import pickle
+import uuid
+
+from regression.test_setup import pickle_path, config_data, advanced_config_data
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from regression import test_utils as utils
+
+
+ROLE_URL = '/browser/role/obj/'
+
+
+def verify_role(tester, server_group, server_id, role_id):
+ """
+ This function calls the GET API for role to verify
+
+ :param tester: test client
+ :type tester: flask test client object
+ :param server_group: server group id
+ :type server_group: int
+ :param server_id: server id
+ :type server_id: str
+ :param role_id: role id
+ :type role_id: int
+ :return: dict/None
+ """
+
+ srv_connect = server_utils.verify_server(tester, server_group, server_id)
+ if srv_connect['data']['connected']:
+ response = tester.get(
+ '{0}{1}/{2}/{3}'.format(ROLE_URL, server_group, server_id,
+ role_id),
+ content_type='html/json')
+ temp_response = json.loads(response.data.decode('utf-8'))
+ return temp_response
+ else:
+ return None
+
+
+def test_getrole(tester):
+ if not tester:
+ return None
+
+ all_id = utils.get_ids()
+
+ server_ids = all_id["sid"]
+ role_ids_dict = all_id["lrid"][0]
+ server_group = config_data['server_group']
+
+ role_response_data = []
+ for server_id in server_ids:
+ role_id = role_ids_dict[int(server_id)]
+ role_response_data.append(
+ verify_role(tester, server_group, server_id, role_id))
+ return role_response_data
+
+
+def get_role_data():
+ """This function returns the role data from config file"""
+
+ data = {
+ "rolcanlogin": advanced_config_data['lr_credentials']
+ ['can_login'],
+ "rolconnlimit": advanced_config_data['lr_credentials']
+ ['conn_limit'],
+ "rolcreaterole": advanced_config_data['lr_credentials']
+ ['create_role'],
+ "rolinherit": advanced_config_data['lr_credentials']
+ ['role_inherit'],
+ "rolmembership": advanced_config_data['lr_credentials']
+ ['role_membership'],
+ "rolname": str(uuid.uuid4())[1:8],
+ "rolpassword": advanced_config_data['lr_credentials']
+ ['lr_password'],
+ "rolvaliduntil": advanced_config_data['lr_credentials']
+ ['lr_validity'],
+ "seclabels": advanced_config_data['lr_credentials']
+ ['sec_lable'],
+ "variables": advanced_config_data['lr_credentials']
+ ['variable']
+ }
+ return data
+
+
+def add_role(tester, server_connect_response, server_group, server_ids):
+ """
+ This function is used to add the roles to server
+
+ :param tester: flask test client
+ :type tester: flask test client object
+ :param server_connect_response: server connect API response
+ :type server_connect_response: dict
+ :param server_group: server group
+ :type server_group: int
+ :param server_ids: list of server id
+ :type server_ids: list
+ :return: None
+ """
+
+ for server_connect, server_id in zip(server_connect_response,
+ server_ids):
+ if server_connect['data']['connected']:
+ data = get_role_data()
+ response = tester.post(ROLE_URL + str(server_group) + '/'
+ + server_id + '/', data=json.dumps(data),
+ content_type='html/json')
+ assert response.status_code == 200
+ response_data = json.loads(response.data.decode('utf-8'))
+ write_role_id(response_data)
+
+
+def write_role_id(response_data):
+ """
+
+ :param response_data:
+ :return:
+ """
+
+ lr_id = response_data['node']['_id']
+ server_id = response_data['node']['_pid']
+ pickle_id_dict = utils.get_pickle_id_dict()
+ # TODO: modify logic to write in file / file exists or create new check
+ # old file
+ if os.path.isfile(pickle_path):
+ existing_server_id = open(pickle_path, 'rb')
+ tol_server_id = pickle.load(existing_server_id)
+ pickle_id_dict = tol_server_id
+ if 'lrid' in pickle_id_dict:
+ if pickle_id_dict['lrid']:
+ # Add the db_id as value in dict
+ pickle_id_dict["lrid"][0].update({server_id: lr_id})
+ else:
+ # Create new dict with server_id and db_id
+ pickle_id_dict["lrid"].append({server_id: lr_id})
+ db_output = open(pickle_path, 'wb')
+ pickle.dump(pickle_id_dict, db_output)
+ db_output.close()
+
+
+def delete_role(tester):
+ """
+ This function use to delete the existing roles in the servers
+
+ :param tester: flask test client
+ :type tester: flask test object
+ :return: None
+ """
+
+ server_ids = None
+ role_ids_dict = None
+
+ all_id = utils.get_ids()
+ if "sid" and "lrid" in all_id.keys():
+ server_ids = all_id["sid"]
+ if all_id['lrid']:
+ role_ids_dict = all_id['lrid'][0]
+ else:
+ raise Exception("Keys are not found: {}".format(["sid", "lrid"]))
+
+ if server_ids and role_ids_dict is not None:
+ for server_id in server_ids:
+ server_response = server_utils.verify_server(tester,
+ utils.SERVER_GROUP,
+ server_id)
+ if server_response["data"]["connected"]:
+ role_id = role_ids_dict[int(server_id)]
+ response = tester.delete(
+ ROLE_URL + str(utils.SERVER_GROUP) + '/' +
+ str(server_id) + '/' + str(role_id),
+ follow_redirects=True)
+ assert response.status_code == 200
+ response_data = json.loads(response.data.decode('utf-8'))
+ assert response_data['success'] == 1
+ else:
+ raise Exception("No servers/roles found.")
+
+
diff --git a/web/pgadmin/browser/server_groups/servers/tablespaces/tests/__init__.py b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/__init__.py
new file mode 100644
index 0000000..3302027
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/__init__.py
@@ -0,0 +1,16 @@
+# #################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+# ##################################################################
+
+from pgadmin.utils.route import BaseTestGenerator
+
+
+class TblspaceGeneratorTestCase(BaseTestGenerator):
+
+ def runTest(self):
+ return
diff --git a/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_add.py b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_add.py
new file mode 100644
index 0000000..caa6966
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_add.py
@@ -0,0 +1,55 @@
+# #################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+# ##################################################################
+
+from pgadmin.utils.route import BaseTestGenerator
+from regression import test_utils as utils
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from . import utils as tablespace_utils
+
+
+class TableSpaceAddTestCase(BaseTestGenerator):
+ """This class will add tablespace node under server"""
+
+ scenarios = [
+ # Fetching default URL for tablespace node.
+ ('Check Tablespace Node', dict(url='/browser/tablespace/obj/'))
+ ]
+
+ @classmethod
+ def setUpClass(cls):
+ """
+ This function used to add the sever
+
+ :return: None
+ """
+
+ # Add the server
+ server_utils.add_server(cls.tester)
+
+ # Connect to server
+ cls.server_connect_response, cls.server_group, cls.server_ids = \
+ server_utils.connect_server(cls.tester)
+
+ if len(cls.server_connect_response) == 0:
+ raise Exception("No Server(s) connected to add the roles!!!")
+
+ def runTest(self):
+ """This function test the add tablespace scenario"""
+
+ tablespace_status = tablespace_utils.add_table_space(
+ self.tester, self.server_connect_response, self.server_group,
+ self.server_ids)
+
+ @classmethod
+ def tearDownClass(cls):
+ """This function deletes the tablespaces,server and parent_id file"""
+
+ tablespace_utils.delete_table_space(cls.tester)
+ server_utils.delete_server(cls.tester)
+ utils.delete_parent_id_file()
diff --git a/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_delete.py b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_delete.py
new file mode 100644
index 0000000..f280ee6
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_delete.py
@@ -0,0 +1,58 @@
+# #################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+# ##################################################################
+
+
+from pgadmin.utils.route import BaseTestGenerator
+from regression import test_utils as utils
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from . import utils as tablespace_utils
+
+
+class TableSpaceDeleteTestCase(BaseTestGenerator):
+ """This class has delete table space scenario"""
+
+ scenarios = [
+ # Fetching default URL for tablespace node.
+ ('Check Tablespace Node', dict(url='/browser/tablespace/obj/'))
+ ]
+
+ @classmethod
+ def setUpClass(cls):
+ """
+ This function used to add the sever
+
+ :return: None
+ """
+
+ # Add the server
+ server_utils.add_server(cls.tester)
+
+ # Connect to server
+ cls.server_connect_response, cls.server_group, cls.server_ids = \
+ server_utils.connect_server(cls.tester)
+
+ if len(cls.server_connect_response) == 0:
+ raise Exception("No Server(s) connected to add the roles!!!")
+
+ # Add tablespace
+ tablespace_utils.add_table_space(cls.tester,
+ cls.server_connect_response,
+ cls.server_group, cls.server_ids)
+
+ def runTest(self):
+ """This function tests the delete table space scenario"""
+
+ tablespace_utils.delete_table_space(self.tester)
+
+ @classmethod
+ def tearDownClass(cls):
+ """This function deletes the server and parent id file"""
+
+ server_utils.delete_server(cls.tester)
+ utils.delete_parent_id_file()
diff --git a/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_get.py b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_get.py
new file mode 100644
index 0000000..b26d71d
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_get.py
@@ -0,0 +1,78 @@
+# #################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+# ##################################################################
+
+from pgadmin.utils.route import BaseTestGenerator
+from regression import test_utils as utils
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from . import utils as tablespace_utils
+
+
+class TablespaceGetTestCase(BaseTestGenerator):
+ """This class tests the get table space scenario"""
+
+ scenarios = [
+ # Fetching default URL for roles node.
+ ('Check Tablespace Node', dict(url='/browser/tablespace/obj/'))
+ ]
+
+ @classmethod
+ def setUpClass(cls):
+ """
+ This function used to add the sever
+
+ :return: None
+ """
+
+ # Add the server
+ server_utils.add_server(cls.tester)
+
+ # Connect to server
+ cls.server_connect_response, cls.server_group, cls.server_ids = \
+ server_utils.connect_server(cls.tester)
+
+ if len(cls.server_connect_response) == 0:
+ raise Exception("No Server(s) connected to add the roles!!!")
+
+ # Add tablespace
+ tablespace_utils.add_table_space(cls.tester,
+ cls.server_connect_response,
+ cls.server_group, cls.server_ids)
+
+ def runTest(self):
+ """This function test the get table space scenario"""
+
+ tablespace_ids_dict = None
+ all_id = utils.get_ids()
+ server_ids = all_id["sid"]
+ if "tsid" in all_id and all_id["tsid"]:
+ tablespace_ids_dict = all_id["tsid"][0]
+
+ if tablespace_ids_dict:
+ for server_id in server_ids:
+ tablespace_id = tablespace_ids_dict[int(server_id)]
+ server_response = server_utils.verify_server(self.tester,
+ utils.SERVER_GROUP,
+ server_id)
+ if server_response['data']['connected']:
+ tablespace_utils.verify_table_space(
+ self.tester, utils.SERVER_GROUP, server_id, tablespace_id)
+ response = self.tester.get(
+ self.url + str(utils.SERVER_GROUP) + '/' +
+ str(server_id) + '/' + str(
+ tablespace_id),
+ follow_redirects=True)
+ self.assertEquals(response.status_code, 200)
+
+ @classmethod
+ def tearDownClass(cls):
+ """This function deletes the tablespaces,server and parent id file"""
+
+ tablespace_utils.delete_table_space(cls.tester)
+ server_utils.delete_server(cls.tester)
+ utils.delete_parent_id_file()
diff --git a/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_put.py b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_put.py
new file mode 100644
index 0000000..22257f9
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_put.py
@@ -0,0 +1,90 @@
+# #################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+# ##################################################################
+
+import json
+
+from pgadmin.utils.route import BaseTestGenerator
+from regression import test_utils as utils
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from test_setup import advanced_config_data
+from . import utils as tablespace_utils
+
+
+class TableSpaceUpdateTestCase(BaseTestGenerator):
+ """This class has update tablespace scenario"""
+
+ scenarios = [
+ # Fetching default URL for roles node.
+ ('Check Tablespace Node', dict(url='/browser/tablespace/obj/'))
+ ]
+
+ @classmethod
+ def setUpClass(cls):
+ """
+ This function used to add the sever
+
+ :return: None
+ """
+
+ # Add the server
+ server_utils.add_server(cls.tester)
+
+ # Connect to server
+ cls.server_connect_response, cls.server_group, cls.server_ids = \
+ server_utils.connect_server(cls.tester)
+
+ if len(cls.server_connect_response) == 0:
+ raise Exception("No Server(s) connected to add the roles!!!")
+
+ # Add tablespace
+ tablespace_utils.add_table_space(cls.tester,
+ cls.server_connect_response,
+ cls.server_group, cls.server_ids)
+
+ def runTest(self):
+ """This function tests the update tablespace data scenario"""
+
+ tablespace_ids_dict = None
+ all_id = utils.get_ids()
+ server_ids = all_id["sid"]
+ if "tsid" in all_id and all_id["tsid"]:
+ tablespace_ids_dict = all_id["tsid"][0]
+
+ if tablespace_ids_dict:
+ for server_id in server_ids:
+ tablespace_id = tablespace_ids_dict[int(server_id)]
+ tablespace_response = tablespace_utils.verify_table_space(
+ self.tester,
+ utils.SERVER_GROUP, server_id,
+ tablespace_id)
+ if len(tablespace_response) == 0:
+ raise Exception("No tablespace(s) to update!!!")
+
+ data = {
+ "description": advanced_config_data["tbspc_update_data"]
+ ["comment"],
+ "table_space_id": tablespace_id
+ }
+
+ put_response = self.tester.put(
+ self.url + str(utils.SERVER_GROUP) + '/' +
+ str(server_id) + '/' + str(
+ tablespace_id),
+ data=json.dumps(data),
+ follow_redirects=True)
+
+ self.assertEquals(put_response.status_code, 200)
+
+ @classmethod
+ def tearDownClass(cls):
+ """This function deletes the tablespaces,server and parent id file"""
+
+ tablespace_utils.delete_table_space(cls.tester)
+ server_utils.delete_server(cls.tester)
+ utils.delete_parent_id_file()
diff --git a/web/pgadmin/browser/server_groups/servers/tablespaces/tests/utils.py b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/utils.py
new file mode 100644
index 0000000..6943842
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/utils.py
@@ -0,0 +1,190 @@
+# #################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+# ##################################################################
+
+from __future__ import print_function
+
+import json
+import os
+import pickle
+import uuid
+import sys
+
+from regression.test_setup import pickle_path, config_data, \
+ advanced_config_data
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from regression import test_utils as utils
+
+TABLE_SPACE_URL = '/browser/tablespace/obj/'
+
+
+# Tablespace utility
+def get_tablespace_data(server_connect):
+ """This function returns the tablespace data from config file"""
+
+ adv_config_data = None
+ data = None
+ db_user = server_connect['data']['user']['name']
+ server_config_data = config_data['server_credentials']
+
+ # Get the config data of appropriate db user
+ for config_test_data in advanced_config_data['tablespc_credentials']:
+ if db_user == config_test_data['spc_user']:
+ # Add the tablespace path from server config
+ server_config = (item for item in server_config_data if
+ item["db_username"] == db_user).next()
+ config_test_data['spc_location'] = server_config['tablespace_path']
+ adv_config_data = config_test_data
+
+ if adv_config_data is not None:
+ data = {
+ "name": str(uuid.uuid4())[1:8],
+ "seclabels": adv_config_data["spc_seclable"],
+ "spcacl": adv_config_data["spc_acl"],
+ "spclocation": adv_config_data["spc_location"],
+ "spcoptions": adv_config_data["spc_opts"],
+ "spcuser": adv_config_data["spc_user"]
+ }
+ return data
+
+
+def write_tablespace_id(response_data):
+ """
+ This function write the table space id to parent_id.pkl
+
+ :param response_data: create table space API response data
+ :type response_data: dict
+ :return: None
+ """
+
+ table_space_id = response_data['node']['_id']
+ server_id = response_data['node']['_pid']
+ pickle_id_dict = utils.get_pickle_id_dict()
+ if os.path.isfile(pickle_path):
+ existing_server_id = open(pickle_path, 'rb')
+ tol_server_id = pickle.load(existing_server_id)
+ pickle_id_dict = tol_server_id
+ if 'tsid' in pickle_id_dict:
+ if pickle_id_dict['tsid']:
+ # Add the db_id as value in dict
+ pickle_id_dict["tsid"][0].update(
+ {server_id: table_space_id})
+ else:
+ # Create new dict with server_id and db_id
+ pickle_id_dict["tsid"].append(
+ {server_id: table_space_id})
+ db_output = open(pickle_path, 'wb')
+ pickle.dump(pickle_id_dict, db_output)
+ db_output.close()
+
+
+def add_table_space(tester, server_connect_response, server_group, server_ids):
+ """
+ This function is used to add the roles to server
+
+ :param tester: flask test client
+ :type tester: flask test client object
+ :param server_connect_response: server connect API response
+ :type server_connect_response: dict
+ :param server_group: server group
+ :type server_group: int
+ :param server_ids: list of server id
+ :type server_ids: list
+ :return: None
+ """
+
+ total_servers_count = len(server_ids)
+ servers_without_tablespace_path = []
+
+ for server_connect, server_id in zip(server_connect_response,
+ server_ids):
+ file_name = os.path.basename(sys._getframe().f_back.f_code.co_filename)
+ # Skip the test case if tablespace_path does not exist
+ if not str(server_connect['tablespace_path']):
+ servers_without_tablespace_path.append(server_id)
+ if total_servers_count == len(servers_without_tablespace_path):
+ print("Skipping tablespaces test cases for the file <{0}>, "
+ "Tablespace path not found for any of the server : "
+ "{1}".format(file_name, server_ids), file=sys.stderr)
+ return
+ else:
+ print("Skipping tablespaces test case for the file <{0}>: "
+ "Tablespace path not found for server : {1}".format(
+ file_name, server_id), file=sys.stderr)
+ continue
+
+ if server_connect['data']['connected']:
+ data = get_tablespace_data(server_connect)
+ response = tester.post(TABLE_SPACE_URL + str(server_group) + '/'
+ + server_id + '/',
+ data=json.dumps(data),
+ content_type='html/json')
+ assert response.status_code == 200
+ response_data = json.loads(response.data.decode('utf-8'))
+ write_tablespace_id(response_data)
+
+
+def verify_table_space(tester, server_group, server_id, tablespace_id):
+ """
+ This function calls the GET API for role to verify
+
+ :param tester: test client
+ :type tester: flask test client object
+ :param server_group: server group id
+ :type server_group: int
+ :param server_id: server id
+ :type server_id: str
+ :param tablespace_id: table space id
+ :type tablespace_id: int
+ :return: dict/None
+ """
+
+ srv_connect = server_utils.verify_server(tester, server_group, server_id)
+ if srv_connect['data']['connected']:
+ response = tester.get(
+ '{0}{1}/{2}/{3}'.format(TABLE_SPACE_URL, server_group, server_id,
+ tablespace_id),
+ content_type='html/json')
+ assert response.status_code == 200
+ temp_response = json.loads(response.data.decode('utf-8'))
+ return temp_response
+ else:
+ return None
+
+
+def delete_table_space(tester):
+ """
+ This function use to delete the existing tablespace in the servers
+
+ :param tester: flask test client
+ :type tester: flask test object
+ :return: None
+ """
+
+ all_id = utils.get_ids()
+ server_ids = all_id["sid"]
+ if "tsid" in all_id and all_id["tsid"]:
+ tablespace_ids_dict = all_id["tsid"][0]
+ else:
+ tablespace_ids_dict = None
+
+ if tablespace_ids_dict is not None:
+ for server_id in server_ids:
+ tablespace_id = tablespace_ids_dict[int(server_id)]
+ role_response = verify_table_space(tester, utils.SERVER_GROUP,
+ server_id,
+ tablespace_id)
+ if len(role_response) == 0:
+ raise Exception("No tablespace(s) to delete!!!")
+ response = tester.delete(
+ TABLE_SPACE_URL + str(utils.SERVER_GROUP) + '/' +
+ str(server_id) + '/' + str(tablespace_id),
+ follow_redirects=True)
+ assert response.status_code == 200
+ delete_response_data = json.loads(response.data.decode('utf-8'))
+ assert delete_response_data['success'] == 1
diff --git a/web/pgadmin/browser/server_groups/servers/tests/test_server_add.py b/web/pgadmin/browser/server_groups/servers/tests/test_server_add.py
index 2b1eb45..7348a47 100644
--- a/web/pgadmin/browser/server_groups/servers/tests/test_server_add.py
+++ b/web/pgadmin/browser/server_groups/servers/tests/test_server_add.py
@@ -7,10 +7,9 @@
#
# ##########################################################################
-import json
-
from pgadmin.utils.route import BaseTestGenerator
from regression import test_utils as utils
+from . import utils as server_utils
class ServersAddTestCase(BaseTestGenerator):
@@ -21,24 +20,17 @@ class ServersAddTestCase(BaseTestGenerator):
('Default Server Node url', dict(url='/browser/server/obj/'))
]
- def setUp(self):
+ @classmethod
+ def setUpClass(cls):
pass
def runTest(self):
""" This function will add the server under default server group."""
- server_group, config_data, pickle_id_dict = utils.get_config_data()
- for server_data in config_data:
- url = "{0}{1}/".format(self.url, server_group)
- response = self.tester.post(url, data=json.dumps(server_data),
- content_type='html/json')
-
- self.assertTrue(response.status_code, 200)
-
- response_data = json.loads(response.data.decode())
- utils.write_parent_id(response_data, pickle_id_dict)
+ server_utils.add_server(self.tester)
- def tearDown(self):
+ @classmethod
+ def tearDownClass(cls):
"""
This function deletes the added server and the 'parent_id.pkl' file
which is created in setup() function.
@@ -46,5 +38,5 @@ class ServersAddTestCase(BaseTestGenerator):
:return: None
"""
- utils.delete_server(self.tester)
+ server_utils.delete_server(cls.tester)
utils.delete_parent_id_file()
diff --git a/web/pgadmin/browser/server_groups/servers/tests/test_server_delete.py b/web/pgadmin/browser/server_groups/servers/tests/test_server_delete.py
index 4fd207b..6431bec 100644
--- a/web/pgadmin/browser/server_groups/servers/tests/test_server_delete.py
+++ b/web/pgadmin/browser/server_groups/servers/tests/test_server_delete.py
@@ -7,12 +7,11 @@
#
# ##################################################################
-import json
from pgadmin.utils.route import BaseTestGenerator
from regression import test_utils as utils
-from regression.test_setup import config_data
-from regression.test_utils import get_ids
+
+from . import utils as server_utils
class ServerDeleteTestCase(BaseTestGenerator):
@@ -23,7 +22,8 @@ class ServerDeleteTestCase(BaseTestGenerator):
('Default Server Node url', dict(url='/browser/server/obj/'))
]
- def setUp(self):
+ @classmethod
+ def setUpClass(cls):
"""
This function is used to add the server
@@ -31,28 +31,16 @@ class ServerDeleteTestCase(BaseTestGenerator):
"""
# Firstly, add the server
- utils.add_server(self.tester)
+ server_utils.add_server(cls.tester)
def runTest(self):
""" This function will get all available servers under object browser
and delete the last server using server id."""
- srv_grp = config_data['test_server_group']
- all_id = get_ids()
- server_ids = all_id["sid"]
-
- url = self.url + str(srv_grp) + "/"
- if len(server_ids) == 0:
- raise Exception("No server(s) to delete!!!")
-
- # Call api to delete the servers
- for server_id in server_ids:
- response = self.tester.delete(url + str(server_id))
- self.assertTrue(response.status_code, 200)
- response_data = json.loads(response.data.decode())
- self.assertTrue(response_data['success'], 1)
+ server_utils.delete_server(self.tester)
- def tearDown(self):
+ @classmethod
+ def tearDownClass(cls):
"""
This function deletes the 'parent_id.pkl' file which is created in
setup() function.
diff --git a/web/pgadmin/browser/server_groups/servers/tests/test_server_get.py b/web/pgadmin/browser/server_groups/servers/tests/test_server_get.py
index ea3c63f..e541247 100644
--- a/web/pgadmin/browser/server_groups/servers/tests/test_server_get.py
+++ b/web/pgadmin/browser/server_groups/servers/tests/test_server_get.py
@@ -9,8 +9,7 @@
from pgadmin.utils.route import BaseTestGenerator
from regression import test_utils as utils
-from regression.test_setup import config_data
-from regression.test_utils import get_ids
+from . import utils as server_utils
class ServersGetTestCase(BaseTestGenerator):
@@ -24,28 +23,23 @@ class ServersGetTestCase(BaseTestGenerator):
('Default Server Node url', dict(url='/browser/server/obj/'))
]
- def setUp(self):
+ @classmethod
+ def setUpClass(cls):
"""
This function is used to add the server
:return: None
"""
- utils.add_server(self.tester)
+ server_utils.add_server(cls.tester)
def runTest(self):
""" This function will fetch the added servers to object browser. """
- all_id = get_ids()
- server_ids = all_id["sid"]
- srv_grp = config_data['test_server_group']
+ server_utils.get_server(self.tester)
- for server_id in server_ids:
- url = "{0}{1}/{2}".format(self.url, srv_grp, server_id)
- response = self.tester.get(url, content_type='html/json')
- self.assertEquals(response.status_code, 200)
-
- def tearDown(self):
+ @classmethod
+ def tearDownClass(cls):
"""
This function deletes the added server and the 'parent_id.pkl' file
which is created in setup() function.
@@ -53,5 +47,5 @@ class ServersGetTestCase(BaseTestGenerator):
:return: None
"""
- utils.delete_server(self.tester)
+ server_utils.delete_server(cls.tester)
utils.delete_parent_id_file()
diff --git a/web/pgadmin/browser/server_groups/servers/tests/test_server_put.py b/web/pgadmin/browser/server_groups/servers/tests/test_server_put.py
index 5e810ba..9ac6468 100644
--- a/web/pgadmin/browser/server_groups/servers/tests/test_server_put.py
+++ b/web/pgadmin/browser/server_groups/servers/tests/test_server_put.py
@@ -8,10 +8,9 @@
# ##########################################################################
import json
-
from pgadmin.utils.route import BaseTestGenerator
from regression import test_utils as utils
-from regression.test_setup import config_data
+from . import utils as server_utils
class ServerUpdateTestCase(BaseTestGenerator):
@@ -22,7 +21,8 @@ class ServerUpdateTestCase(BaseTestGenerator):
('Default Server Node url', dict(url='/browser/server/obj/'))
]
- def setUp(self):
+ @classmethod
+ def setUpClass(cls):
"""
This function perform the four tasks
1. Add the test server
@@ -33,13 +33,16 @@ class ServerUpdateTestCase(BaseTestGenerator):
"""
# Firstly, add the server
- utils.add_server(self.tester)
+ server_utils.add_server(cls.tester)
+
# Get the server
- utils.get_server(self.tester)
+ server_utils.get_server(cls.tester)
+
# Connect to server
- self.server_connect, self.server_group, self.server_ids = \
- utils.connect_server(self.tester)
- if len(self.server_connect) == 0:
+ cls.server_connect, cls.server_group, cls.server_ids = \
+ server_utils.connect_server(cls.tester)
+
+ if len(cls.server_connect) == 0:
raise Exception("No Server(s) connected to update!!!")
def runTest(self):
@@ -48,7 +51,8 @@ class ServerUpdateTestCase(BaseTestGenerator):
for server_id in self.server_ids:
data = {
"comment":
- config_data['test_server_update_data'][0]['test_comment'],
+ server_utils.config_data['server_update_data'][0][
+ 'comment'],
"id": server_id
}
put_response = self.tester.put(
@@ -60,7 +64,8 @@ class ServerUpdateTestCase(BaseTestGenerator):
response_data = json.loads(put_response.data.decode())
self.assertTrue(response_data['success'], 1)
- def tearDown(self):
+ @classmethod
+ def tearDownClass(cls):
"""
This function deletes the added server and the 'parent_id.pkl' file
which is created in setup() function.
@@ -68,5 +73,5 @@ class ServerUpdateTestCase(BaseTestGenerator):
:return: None
"""
- utils.delete_server(self.tester)
+ server_utils.delete_server(cls.tester)
utils.delete_parent_id_file()
diff --git a/web/pgadmin/browser/server_groups/servers/tests/utils.py b/web/pgadmin/browser/server_groups/servers/tests/utils.py
new file mode 100644
index 0000000..6e3f166
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/tests/utils.py
@@ -0,0 +1,160 @@
+# ##########################################################################
+#
+# #pgAdmin 4 - PostgreSQL Tools
+#
+# #Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# #This software is released under the PostgreSQL Licence
+#
+# ##########################################################################
+
+import json
+import os
+import pickle
+
+from regression import test_utils as utils
+from regression.test_setup import pickle_path, config_data
+
+SERVER_URL = '/browser/server/obj/'
+SERVER_CONNECT_URL = 'browser/server/connect/'
+
+
+def write_server_id(response_data, pickle_id_dict):
+ """
+ This function writes the server's details to file parent_id.pkl
+
+ :param response_data: server's data
+ :type response_data: list of dictionary
+ :param pickle_id_dict: contains ids of server,database,tables etc.
+ :type pickle_id_dict: dict
+ :return: None
+ """
+
+ server_id = response_data['node']['_id']
+ if os.path.isfile(pickle_path):
+ existed_server_id = open(pickle_path, 'rb')
+ pickle_id_dict = pickle.load(existed_server_id)
+
+ pickle_id_dict["sid"].append(str(server_id))
+ output = open(pickle_path, 'wb')
+ pickle.dump(pickle_id_dict, output)
+ output.close()
+
+
+def add_server(tester):
+ """
+ This function add the server in the existing server group
+
+ :param tester: test object
+ :type tester: flask test object
+ :return:None
+ """
+
+ server_group, db_data, pickle_id_dict = utils.get_config_data()
+ url = "{0}{1}/".format(SERVER_URL, server_group)
+ for db_detail in db_data:
+ response = tester.post(url, data=json.dumps(db_detail),
+ content_type='html/json')
+ assert response.status_code == 200
+ response_data = json.loads(response.data.decode('utf-8'))
+ write_server_id(response_data, pickle_id_dict)
+
+
+def get_server(tester):
+ """
+ This function gets the added serer details
+
+ :param tester: test client object
+ :type tester: flask test object
+ :return: response_data
+ :rtype: list
+ """
+
+ all_id = utils.get_ids()
+ server_ids = all_id["sid"]
+ for server_id in server_ids:
+ response = tester.get(SERVER_URL + str(utils.SERVER_GROUP) + '/' +
+ str(server_id),
+ follow_redirects=True)
+ assert response.status_code == 200
+
+
+def connect_server(tester):
+ """
+ This function used to connect added server
+
+ :param tester:test client object
+ :type tester: flask test object
+ :param add_db_flag: flag for db add test case
+ :type add_db_flag: bool
+ :return: server_connect, server_group, server_id
+ :rtype: server_connect:dict, server_group:dict, server_id:str
+ """
+
+ server_connect = []
+ servers = []
+ server_config = None
+
+ srv_id = utils.get_ids()
+ server_ids = srv_id["sid"]
+
+ # Connect to all servers
+ for server_id in server_ids:
+ response = tester.post(SERVER_CONNECT_URL + str(utils.SERVER_GROUP) +
+ '/' + server_id,
+ data=dict(
+ password=config_data
+ ['server_credentials'][0]
+ ['db_password']),
+ follow_redirects=True)
+ server_connect_detail = json.loads(response.data.decode('utf-8'))
+ db_user = server_connect_detail['data']['user']['name']
+ server_connect_detail['tablespace_path'] = None
+
+ # Get the server config of appropriate db user
+ for config in config_data['server_credentials']:
+ if db_user == config['db_username']:
+ server_config = config
+
+ if "tablespace_path" in server_config:
+ server_connect_detail['tablespace_path'] = \
+ server_config['tablespace_path']
+
+ server_connect.append(server_connect_detail)
+ servers.append(server_id)
+ return server_connect, utils.SERVER_GROUP, servers
+
+
+def verify_server(tester, server_group, server_id):
+ """This function verifies that server is connecting or not"""
+
+ response = tester.post(
+ '{0}{1}/{2}'.format(SERVER_CONNECT_URL, server_group, server_id),
+ data=dict(password=config_data
+ ['server_credentials'][0]
+ ['db_password']),
+ follow_redirects=True)
+ srv_connect = json.loads(response.data.decode('utf-8'))
+ return srv_connect
+
+
+def delete_server(tester):
+ """
+ This function used to delete the added servers
+
+ :param tester: test client object
+ :return: None
+ """
+
+ all_id = utils.get_ids()
+ server_ids = all_id["sid"]
+ url = SERVER_URL + str(utils.SERVER_GROUP) + "/"
+
+ if len(server_ids) == 0:
+ raise Exception("No server(s) to delete!!!")
+
+ # Call api to delete the servers
+ for server_id in server_ids:
+ response = tester.delete(url + str(server_id))
+ assert response.status_code == 200
+ response_data = json.loads(response.data.decode('utf-8'))
+ assert response_data['success'] == 1
\ No newline at end of file
diff --git a/web/pgadmin/browser/server_groups/tests/test_sg_get.py b/web/pgadmin/browser/server_groups/tests/test_sg_get.py
index 6c164be..5df67c9 100644
--- a/web/pgadmin/browser/server_groups/tests/test_sg_get.py
+++ b/web/pgadmin/browser/server_groups/tests/test_sg_get.py
@@ -26,7 +26,7 @@ class SgNodeTestCase(BaseTestGenerator):
def runTest(self):
"""This function will check available server groups."""
- server_group_id = config_data['test_server_group']
+ server_group_id = config_data['server_group']
response = self.tester.get(self.url + str(server_group_id),
content_type='html/json')
self.assertTrue(response.status_code, 200)
diff --git a/web/pgadmin/browser/tests/test_change_password.py b/web/pgadmin/browser/tests/test_change_password.py
index 2f714a7..5b7c918 100644
--- a/web/pgadmin/browser/tests/test_change_password.py
+++ b/web/pgadmin/browser/tests/test_change_password.py
@@ -8,9 +8,12 @@
# ##########################################################################
import uuid
+import json
from pgadmin.utils.route import BaseTestGenerator
from regression.test_setup import config_data
+from regression import test_utils as utils
+from utils import change_password
class ChangePasswordTestCase(BaseTestGenerator):
@@ -24,9 +27,9 @@ class ChangePasswordTestCase(BaseTestGenerator):
# This testcase validates invalid confirmation password
('TestCase for Validating Incorrect_New_Password', dict(
password=(config_data['pgAdmin4_login_credentials']
- ['test_login_password']),
+ ['login_password']),
new_password=(config_data['pgAdmin4_login_credentials']
- ['test_new_password']),
+ ['new_password']),
new_password_confirm=str(uuid.uuid4())[4:8],
respdata='Passwords do not match')),
@@ -34,7 +37,7 @@ class ChangePasswordTestCase(BaseTestGenerator):
# minimum length
('TestCase for Validating New_Password_Less_Than_Min_Length',
dict(password=(config_data['pgAdmin4_login_credentials']
- ['test_login_password']),
+ ['login_password']),
new_password=str(uuid.uuid4())[4:8],
new_password_confirm=str(uuid.uuid4())[4:8],
respdata='Password must be at least 6 characters')),
@@ -42,7 +45,7 @@ class ChangePasswordTestCase(BaseTestGenerator):
# This testcase validates if both password fields are left blank
('TestCase for Validating Empty_New_Password', dict(
password=(config_data['pgAdmin4_login_credentials']
- ['test_login_password']),
+ ['login_password']),
new_password='', new_password_confirm='',
respdata='Password not provided')),
@@ -50,57 +53,66 @@ class ChangePasswordTestCase(BaseTestGenerator):
('TestCase for Validating Incorrect_Current_Password', dict(
password=str(uuid.uuid4())[4:8],
new_password=(config_data['pgAdmin4_login_credentials']
- ['test_new_password']),
+ ['new_password']),
new_password_confirm=(
config_data['pgAdmin4_login_credentials']
- ['test_new_password']),
+ ['new_password']),
respdata='Invalid password')),
- # This testcase checks for valid password
+ # This test case checks for valid password
('TestCase for Changing Valid_Password', dict(
- password=(config_data['pgAdmin4_login_credentials']
- ['test_login_password']),
- new_password=(config_data['pgAdmin4_login_credentials']
- ['test_new_password']),
- new_password_confirm=(
- config_data['pgAdmin4_login_credentials']
- ['test_new_password']),
- respdata='You successfully changed your password.')),
- ('Reassigning_Password', dict(
- test_case='reassigning_password',
- password=(config_data['pgAdmin4_login_credentials']
- ['test_new_password']),
- new_password=(config_data['pgAdmin4_login_credentials']
- ['test_login_password']),
+ valid_password='reassigning_password',
+ username=(config_data['pgAdmin4_test_user_credentials']
+ ['login_username']),
+ password=(config_data['pgAdmin4_test_user_credentials']
+ ['login_password']),
+ new_password=(config_data['pgAdmin4_test_user_credentials']
+ ['new_password']),
new_password_confirm=(
- config_data['pgAdmin4_login_credentials']
- ['test_login_password']),
+ config_data['pgAdmin4_test_user_credentials']
+ ['new_password']),
respdata='You successfully changed your password.'))
-
]
+ @classmethod
+ def setUpClass(cls):
+ pass
+
def runTest(self):
"""This function will check change password functionality."""
- # Check for 'test_case' exists in self For reassigning the password.
- # Password gets change in change password test case.
- if 'test_case' in dir(self):
- email = \
- config_data['pgAdmin4_login_credentials'][
- 'test_login_username']
- password = \
- config_data['pgAdmin4_login_credentials'][
- 'test_new_password']
+ # Check for 'valid_password' exists in self to test 'valid password'
+ # test case
+ if 'valid_password' in dir(self):
+ response = self.tester.post('/user_management/user/', data=dict(
+ email=self.username, newPassword=self.password,
+ confirmPassword=self.password, active=1, role="2"),
+ follow_redirects=True)
+ user_id = json.loads(response.data.decode('utf-8'))['id']
+
+ # Logout the Administrator before login normal user
+ utils.logout_tester_account(self.tester)
+
response = self.tester.post('/login', data=dict(
- email=email, password=password), follow_redirects=True)
-
- response = self.tester.get('/change', follow_redirects=True)
- self.assertIn('pgAdmin 4 Password Change', response.data.decode(
- 'utf-8'))
-
- response = self.tester.post('/change', data=dict(
- password=self.password,
- new_password=self.new_password,
- new_password_confirm=self.new_password_confirm),
- follow_redirects=True)
- self.assertIn(self.respdata, response.data.decode('utf-8'))
+ email=self.username, password=self.password),
+ follow_redirects=True)
+ assert response.status_code == 200
+
+ # test the 'change password' test case
+ change_password(self)
+
+ # Delete the normal user after changing it's password
+ utils.logout_tester_account(self.tester)
+
+ # Login the Administrator before deleting normal user
+ utils.login_tester_account(self.tester)
+ response = self.tester.delete(
+ '/user_management/user/' + str(user_id),
+ follow_redirects=True)
+ assert response.status_code == 200
+ else:
+ change_password(self)
+
+ @classmethod
+ def tearDownClass(cls):
+ utils.login_tester_account(cls.tester)
diff --git a/web/pgadmin/browser/tests/test_login.py b/web/pgadmin/browser/tests/test_login.py
index b0ea361..f6bc6b5 100644
--- a/web/pgadmin/browser/tests/test_login.py
+++ b/web/pgadmin/browser/tests/test_login.py
@@ -24,20 +24,20 @@ class LoginTestCase(BaseTestGenerator):
# This test case validates the invalid/incorrect password
('TestCase for Checking Invalid_Password', dict(
email=(config_data['pgAdmin4_login_credentials']
- ['test_login_username']),
+ ['login_username']),
password=str(uuid.uuid4())[4:8],
respdata='Invalid password')),
# This test case validates the empty password field
('Empty_Password', dict(
email=(config_data['pgAdmin4_login_credentials']
- ['test_login_username']), password='',
+ ['login_username']), password='',
respdata='Password not provided')),
# This test case validates blank email field
('Empty_Email', dict(
email='', password=(config_data['pgAdmin4_login_credentials']
- ['test_login_password']),
+ ['login_password']),
respdata='Email not provided')),
# This test case validates empty email and password
@@ -49,7 +49,7 @@ class LoginTestCase(BaseTestGenerator):
('Invalid_Email', dict(
email=str(uuid.uuid4())[1:6] + '@xyz.com',
password=(config_data['pgAdmin4_login_credentials']
- ['test_login_password']),
+ ['login_password']),
respdata='Specified user does not exist')),
# This test case validates invalid email and password
@@ -62,21 +62,22 @@ class LoginTestCase(BaseTestGenerator):
# to login pgAdmin 4
('Valid_Credentials', dict(
email=(config_data['pgAdmin4_login_credentials']
- ['test_login_username']),
+ ['login_username']),
password=(config_data['pgAdmin4_login_credentials']
- ['test_login_password']),
+ ['login_password']),
respdata='Gravatar image for %s' %
config_data['pgAdmin4_login_credentials']
- ['test_login_username']))
+ ['login_username']))
]
- def setUp(self):
+ @classmethod
+ def setUpClass(cls):
"""
We need to logout the test client as we are testing scenarios of
logging in the client like invalid password, invalid emails,
empty credentials etc.
"""
- utils.logout_tester_account(self.tester)
+ utils.logout_tester_account(cls.tester)
def runTest(self):
"""This function checks login functionality."""
@@ -86,9 +87,10 @@ class LoginTestCase(BaseTestGenerator):
follow_redirects=True)
self.assertIn(self.respdata, response.data.decode('utf8'))
- def tearDown(self):
+ @classmethod
+ def tearDownClass(cls):
"""
We need to again login the test client as soon as test scenarios
finishes.
"""
- utils.login_tester_account(self.tester)
+ utils.login_tester_account(cls.tester)
diff --git a/web/pgadmin/browser/tests/test_logout.py b/web/pgadmin/browser/tests/test_logout.py
index 729f7b1..5697de6 100644
--- a/web/pgadmin/browser/tests/test_logout.py
+++ b/web/pgadmin/browser/tests/test_logout.py
@@ -24,7 +24,8 @@ class LogoutTest(BaseTestGenerator):
('Logging Out', dict(respdata='Redirecting...'))
]
- def setUp(self):
+ @classmethod
+ def setUpClass(cls):
pass
def runTest(self):
@@ -33,9 +34,10 @@ class LogoutTest(BaseTestGenerator):
response = self.tester.get('/logout')
self.assertIn(self.respdata, response.data.decode('utf8'))
- def tearDown(self):
+ @classmethod
+ def tearDownClass(cls):
"""
We need to again login the test client as soon as test scenarios
finishes.
"""
- utils.login_tester_account(self.tester)
+ utils.login_tester_account(cls.tester)
diff --git a/web/pgadmin/browser/tests/test_reset_password.py b/web/pgadmin/browser/tests/test_reset_password.py
index 9420c72..0dcf0bd 100644
--- a/web/pgadmin/browser/tests/test_reset_password.py
+++ b/web/pgadmin/browser/tests/test_reset_password.py
@@ -34,11 +34,12 @@ class ResetPasswordTestCase(BaseTestGenerator):
# This test case validates the valid email id
('TestCase for Validating Valid_Email', dict(
email=config_data['pgAdmin4_login_credentials']
- ['test_login_username'], respdata='pgAdmin 4'))
+ ['login_username'], respdata='pgAdmin 4'))
]
- def setUp(self):
- logout_tester_account(self.tester)
+ @classmethod
+ def setUpClass(cls):
+ logout_tester_account(cls.tester)
def runTest(self):
"""This function checks reset password functionality."""
@@ -51,5 +52,6 @@ class ResetPasswordTestCase(BaseTestGenerator):
follow_redirects=True)
self.assertIn(self.respdata, response.data.decode('utf-8'))
- def tearDown(self):
- login_tester_account(self.tester)
+ @classmethod
+ def tearDownClass(cls):
+ login_tester_account(cls.tester)
diff --git a/web/pgadmin/browser/tests/utils.py b/web/pgadmin/browser/tests/utils.py
new file mode 100644
index 0000000..18548ce
--- /dev/null
+++ b/web/pgadmin/browser/tests/utils.py
@@ -0,0 +1,21 @@
+# ##########################################################################
+#
+# #pgAdmin 4 - PostgreSQL Tools
+#
+# #Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# #This software is released under the PostgreSQL Licence
+#
+# ##########################################################################
+
+
+def change_password(self):
+ response = self.tester.get('/change', follow_redirects=True)
+ self.assertIn('pgAdmin 4 Password Change', response.data.decode(
+ 'utf-8'))
+
+ response = self.tester.post('/change', data=dict(
+ password=self.password,
+ new_password=self.new_password,
+ new_password_confirm=self.new_password_confirm),
+ follow_redirects=True)
+ self.assertIn(self.respdata, response.data.decode('utf-8'))
\ No newline at end of file
diff --git a/web/pgadmin/utils/route.py b/web/pgadmin/utils/route.py
index c7ef1f8..0226e8d 100644
--- a/web/pgadmin/utils/route.py
+++ b/web/pgadmin/utils/route.py
@@ -84,5 +84,6 @@ class BaseTestGenerator(unittest.TestCase):
self.app = app
# Initializing test_client.
- def setTestClient(self, test_client):
- self.tester = test_client
+ @classmethod
+ def setTestClient(cls, test_client):
+ cls.tester = test_client
diff --git a/web/regression/test_advanced_config.json.in b/web/regression/test_advanced_config.json.in
index c0d278b..fc8d98f 100644
--- a/web/regression/test_advanced_config.json.in
+++ b/web/regression/test_advanced_config.json.in
@@ -1,7 +1,7 @@
{
- "test_add_database_data": [
+ "add_database_data": [
{
- "test_privileges_acl": [
+ "privileges_acl": [
{
"grantee": "postgres",
"grantor": "postgres",
@@ -19,9 +19,9 @@
]
}
],
- "test_conn_limit": -1,
- "test_owner": "postgres",
- "test_fun_acl": [
+ "conn_limit": -1,
+ "owner": "postgres",
+ "fun_acl": [
{
"grantee": "postgres",
"grantor": "postgres",
@@ -34,7 +34,7 @@
]
}
],
- "test_seq_acl": [
+ "seq_acl": [
{
"grantee": "postgres",
"grantor": "postgres",
@@ -57,7 +57,7 @@
]
}
],
- "test_tbl_acl": [
+ "tbl_acl": [
{
"grantee": "postgres",
"grantor": "postgres",
@@ -75,7 +75,7 @@
]
}
],
- "test_type_acl": [
+ "type_acl": [
{
"grantee": "postgres",
"grantor": "postgres",
@@ -88,112 +88,60 @@
]
}
],
- "test_encoding": "UTF8",
- "test_name": "test_db_automation",
- "test_privileges": [],
- "test_securities": [],
- "test_variables": []
- },
- {
- "test_privileges_acl": [
- {
- "grantee": "enterprisedb",
- "grantor": "enterprisedb",
- "privileges": [
- {
- "privilege_type": "C",
- "privilege": true,
- "with_grant": true
- },
- {
- "privilege_type": "T",
- "privilege": true,
- "with_grant": false
- }
- ]
- }
- ],
- "test_conn_limit": -1,
- "test_owner": "enterprisedb",
- "test_fun_acl": [
- {
- "grantee": "enterprisedb",
- "grantor": "enterprisedb",
- "privileges": [
- {
- "privilege_type": "X",
- "privilege": true,
- "with_grant": false
- }
- ]
- }
- ],
- "test_seq_acl": [
- {
- "grantee": "enterprisedb",
- "grantor": "enterprisedb",
- "privileges": [
- {
- "privilege_type": "r",
- "privilege": true,
- "with_grant": false
- },
- {
- "privilege_type": "w",
- "privilege": true,
- "with_grant": false
- },
- {
- "privilege_type": "U",
- "privilege": true,
- "with_grant": false
- }
- ]
- }
- ],
- "test_tbl_acl": [
- {
- "grantee": "enterprisedb",
- "grantor": "enterprisedb",
- "privileges": [
- {
- "privilege_type": "a",
- "privilege": true,
- "with_grant": true
- },
- {
- "privilege_type": "r",
- "privilege": true,
- "with_grant": false
- }
- ]
- }
- ],
- "test_type_acl": [
- {
- "grantee": "enterprisedb",
- "grantor": "enterprisedb",
- "privileges": [
- {
- "privilege_type": "U",
- "privilege": true,
- "with_grant": false
- }
- ]
- }
- ],
- "test_encoding": "UTF8",
- "test_name": "test_db_automation",
- "test_privileges": [],
- "test_securities": [],
- "test_variables": []
- }
+ "encoding": "UTF8",
+ "name": "test_db_automation",
+ "privileges": [],
+ "securities": [],
+ "variables": []
+ }
],
-
- "test_db_update_data": [
+ "db_update_data": [
{
- "test_comment": "This is db update comment"
+ "comment": "This is db update comment"
}
- ]
+ ],
+
+ "lr_credentials": {
+ "can_login": "true",
+ "conn_limit": -1,
+ "create_role": "true",
+ "role_inherit": "true",
+ "role_membership": [],
+ "lr_name": "testlrg1",
+ "lr_password": "edb",
+ "lr_validity": "12/27/2016",
+ "sec_lable": [],
+ "variable":[
+ {"name":"work_mem",
+ "database":"postgres",
+ "value":65
+ }]
+ },
+ "lr_update_data": {
+ "comment": "This is db update comment"
+ },
+
+ "tablespc_credentials":[{
+ "tblspace_name": "test_tablespace",
+ "spc_seclable": [],
+ "spc_acl": [
+ {
+ "grantee":"postgres",
+ "grantor":"postgres",
+ "privileges":[
+ {
+ "privilege_type":"C",
+ "privilege":true,
+ "with_grant":false
+ }
+ ]
+ }
+ ],
+ "spc_opts": [],
+ "spc_user": "postgres"
+ }],
+ "tbspc_update_data": {
+ "comment": "This is tablespace update comment"
+ }
}
\ No newline at end of file
diff --git a/web/regression/test_config.json.in b/web/regression/test_config.json.in
index 028d1e7..1328b6b 100644
--- a/web/regression/test_config.json.in
+++ b/web/regression/test_config.json.in
@@ -1,35 +1,31 @@
{
"pgAdmin4_login_credentials": {
- "test_new_password": "NEWPASSWORD",
- "test_login_password": "PASSWORD",
- "test_login_username": "[email protected]"
+ "new_password": "NEWPASSWORD",
+ "login_password": "PASSWORD",
+ "login_username": "[email protected]"
},
- "test_server_group": 1,
- "test_server_credentials": [
+ "pgAdmin4_test_user_credentials": {
+ "new_password": "NEWPASSWORD",
+ "login_password": "PASSWORD",
+ "login_username": "[email protected]"
+ },
+ "server_group": 1,
+ "server_credentials": [
{
- "test_name": "PostgreSQL 9.4",
- "test_comment": "PostgreSQL 9.4 Server (EDB Installer)",
- "test_db_username": "postgres",
- "test_host": "localhost",
- "test_db_password": "PASSWORD",
- "test_db_port": 5432,
- "test_maintenance_db": "postgres",
- "test_sslmode": "prefer"
- },
- {
- "test_name": "Postgres Plus Advanced Server 9.4",
- "test_comment": "Postgres Plus Advanced 9.4 Server (EDB Installer)",
- "test_db_username": "enterprisedb",
- "test_host": "localhost",
- "test_db_password": "edb",
- "test_db_port": 5444,
- "test_maintenance_db": "edb",
- "test_sslmode": "prefer"
- }
+ "name": "PostgreSQL 9.4",
+ "comment": "PostgreSQL 9.4 Server (EDB Installer)",
+ "db_username": "postgres",
+ "host": "localhost",
+ "db_password": "PASSWORD",
+ "db_port": 5432,
+ "maintenance_db": "postgres",
+ "sslmode": "prefer",
+ "tablespace_path": ""
+ }
],
- "test_server_update_data": [
+ "server_update_data": [
{
- "test_comment": "This is test update comment"
+ "comment": "This is test update comment"
}
]
}
\ No newline at end of file
diff --git a/web/regression/test_setup.py b/web/regression/test_setup.py
index f7765bc..c805b1e 100644
--- a/web/regression/test_setup.py
+++ b/web/regression/test_setup.py
@@ -12,10 +12,24 @@ import os
CURRENT_PATH = os.path.dirname(os.path.realpath(__file__))
-with open(CURRENT_PATH + '/test_config.json') as data_file:
- config_data = json.load(data_file)
+# with open(CURRENT_PATH + '/test_config.json') as data_file:
+# config_data = json.load(data_file)
+#
+# with open(CURRENT_PATH + '/test_advanced_config.json') as data_file:
+# advanced_config_data = json.load(data_file)
+
+try:
+ with open(CURRENT_PATH + '/test_config.json') as data_file:
+ config_data = json.load(data_file)
+except:
+ with open(CURRENT_PATH + '/test_config.json.in') as data_file:
+ config_data = json.load(data_file)
-with open(CURRENT_PATH + '/test_advanced_config.json') as data_file:
- advanced_config_data = json.load(data_file)
+try:
+ with open(CURRENT_PATH + '/test_advanced_config.json') as data_file:
+ advanced_config_data = json.load(data_file)
+except:
+ with open(CURRENT_PATH + '/test_advanced_config.json.in') as data_file:
+ advanced_config_data = json.load(data_file)
pickle_path = os.path.join(CURRENT_PATH, 'parent_id.pkl')
diff --git a/web/regression/test_utils.py b/web/regression/test_utils.py
index 6be2bb2..16c2d46 100644
--- a/web/regression/test_utils.py
+++ b/web/regression/test_utils.py
@@ -9,16 +9,24 @@
import os
import pickle
-import json
-import uuid
-from test_setup import config_data, advanced_config_data, \
- pickle_path
+from test_setup import config_data, pickle_path
-SERVER_URL = '/browser/server/obj/'
-SERVER_CONNECT_URL = 'browser/server/connect/'
-DATABASE_URL = '/browser/database/obj/'
-DATABASE_CONNECT_URL = 'browser/database/connect/'
+
+SERVER_GROUP = config_data['server_group']
+
+
+def get_pickle_id_dict():
+ """This function returns the empty dict of server config data"""
+
+ pickle_id_dict = {
+ "sid": [], # server
+ "did": [], # database
+ "lrid": [], # role
+ "tsid": [], # tablespace
+ "scid": [] # schema
+ }
+ return pickle_id_dict
def get_ids(url=pickle_path):
@@ -34,43 +42,9 @@ def get_ids(url=pickle_path):
output = open(url, 'rb')
ids = pickle.load(output)
output.close()
-
return ids
-def verify_database(tester, server_group, server_id, db_id):
- """
- This function verifies that database is exists and whether it connect
- successfully or not
-
- :param tester: test client
- :type tester: flask test client object
- :param server_group: server group id
- :type server_group: int
- :param server_id: server id
- :type server_id: str
- :param db_id: database id
- :type db_id: str
- :return: temp_db_con
- :rtype: list
- """
-
- # Connect to server
- response = tester.post('{0}{1}/{2}'.format(
- SERVER_CONNECT_URL, server_group, server_id), data=dict(
- password=config_data['test_server_credentials'][0][
- 'test_db_password']),
- follow_redirects=True)
-
- # Connect to database
- con_response = tester.post('{0}{1}/{2}/{3}'.format(
- DATABASE_CONNECT_URL, server_group, server_id, db_id),
- follow_redirects=True)
- temp_db_con = json.loads(con_response.data.decode('utf-8'))
-
- return temp_db_con
-
-
def test_getnodes(tester=None):
# Connect to server and database.
@@ -81,53 +55,14 @@ def test_getnodes(tester=None):
server_ids = all_id["sid"]
db_ids_dict = all_id["did"][0]
- srv_grp = config_data['test_server_group']
db_con = []
for server_id in server_ids:
db_id = db_ids_dict[int(server_id)]
- db_con.append(verify_database(tester, srv_grp, server_id, db_id))
+ db_con.append(verify_database(tester, SERVER_GROUP, server_id, db_id))
return db_con
-def get_db_data(server_connect_data):
- """
- This function is used to get advance config test data for appropriate
- server
-
- :param server_connect_data: list of server details
- :return data: database details
- :rtype: dict
- """
-
- adv_config_data = None
- data = None
- db_user = server_connect_data['data']['user']['name']
-
- # Get the config data of appropriate db user
- for config_test_data in advanced_config_data['test_add_database_data']:
- if db_user == config_test_data['test_owner']:
- adv_config_data = config_test_data
-
- if adv_config_data is not None:
- data = {
- "datacl": adv_config_data['test_privileges_acl'],
- "datconnlimit": adv_config_data['test_conn_limit'],
- "datowner": adv_config_data['test_owner'],
- "deffuncacl": adv_config_data['test_fun_acl'],
- "defseqacl": adv_config_data['test_seq_acl'],
- "deftblacl": adv_config_data['test_tbl_acl'],
- "deftypeacl": adv_config_data['test_type_acl'],
- "encoding": adv_config_data['test_encoding'],
- "name": str(uuid.uuid4())[1:8],
- "privileges": adv_config_data['test_privileges'],
- "securities": adv_config_data['test_securities'],
- "variables": adv_config_data['test_variables']
- }
-
- return data
-
-
def login_tester_account(tester):
"""
This function login the test account using credentials mentioned in
@@ -139,9 +74,9 @@ def login_tester_account(tester):
"""
email = \
- config_data['pgAdmin4_login_credentials']['test_login_username']
+ config_data['pgAdmin4_login_credentials']['login_username']
password = \
- config_data['pgAdmin4_login_credentials']['test_login_password']
+ config_data['pgAdmin4_login_credentials']['login_password']
response = tester.post('/login', data=dict(
email=email, password=password), follow_redirects=True)
@@ -158,6 +93,7 @@ def logout_tester_account(tester):
response = tester.get('/logout')
+# Config data for parent_id.pkl
def get_config_data():
"""
This function get the data related to server group and database
@@ -168,23 +104,18 @@ def get_config_data():
"""
db_data = []
+ pickle_id_dict = get_pickle_id_dict()
+ server_group = config_data['server_group']
- pickle_id_dict = {
- "sid": [], # server
- "did": [] # database
- }
-
- server_group = config_data['test_server_group']
-
- for srv in config_data['test_server_credentials']:
- data = {"name": srv['test_name'],
+ for srv in config_data['server_credentials']:
+ data = {"name": srv['name'],
"comment": "",
- "host": srv['test_host'],
- "port": srv['test_db_port'],
- "db": srv['test_maintenance_db'],
- "username": srv['test_db_username'],
+ "host": srv['host'],
+ "port": srv['db_port'],
+ "db": srv['maintenance_db'],
+ "username": srv['db_username'],
"role": "",
- "sslmode": srv['test_sslmode']}
+ "sslmode": srv['sslmode']}
db_data.append(data)
return server_group, db_data, pickle_id_dict
@@ -205,40 +136,12 @@ def write_parent_id(response_data, pickle_id_dict):
existed_server_id = open(pickle_path, 'rb')
pickle_id_dict = pickle.load(existed_server_id)
- pickle_id_dict["sid"].append(server_id)
+ pickle_id_dict["sid"].append(str(server_id))
output = open(pickle_path, 'wb')
pickle.dump(pickle_id_dict, output)
output.close()
-def write_db_parent_id(response_data):
- """
- This function writes the server and database related data like server
- name, server id , database name, database id etc.
-
- :param response_data: server and databases details
- :type response_data: dict
- :return: None
- """
-
- db_id = response_data['node']['_id']
- server_id = response_data['node']['_pid']
- if os.path.isfile(pickle_path):
- existing_server_id = open(pickle_path, 'rb')
- tol_server_id = pickle.load(existing_server_id)
- pickle_id_dict = tol_server_id
- if 'did' in pickle_id_dict:
- if pickle_id_dict['did']:
- # Add the db_id as value in dict
- pickle_id_dict["did"][0].update({server_id: db_id})
- else:
- # Create new dict with server_id and db_id
- pickle_id_dict["did"].append({server_id: db_id})
- db_output = open(pickle_path, 'wb')
- pickle.dump(pickle_id_dict, db_output)
- db_output.close()
-
-
def delete_parent_id_file():
"""
This function deletes the file parent_id.pkl which contains server and
@@ -250,148 +153,3 @@ def delete_parent_id_file():
if os.path.isfile(pickle_path):
os.remove(pickle_path)
-
-def add_server(tester):
- """
- This function add the server in the existing server group
-
- :param tester: test object
- :type tester: flask test object
- :return:None
- """
-
- server_group, db_data, pickle_id_dict = get_config_data()
- url = "{0}{1}/".format(SERVER_URL, server_group)
- for db_detail in db_data:
- response = tester.post(url, data=json.dumps(db_detail),
- content_type='html/json')
- response_data = json.loads(response.data.decode())
- write_parent_id(response_data, pickle_id_dict)
-
-
-def get_server(tester):
- """
- This function gets the added serer details
-
- :param tester: test client object
- :type tester: flask test object
- :return: response_data
- :rtype: list
- """
-
- all_id = get_ids()
- server_ids = all_id["sid"]
- server_group = config_data['test_server_group']
- for server_id in server_ids:
- response = tester.get(SERVER_URL + str(server_group) + '/' +
- str(server_id),
- follow_redirects=True)
- response_data = json.loads(response.data.decode())
-
-
-def connect_server(tester):
- """
- This function used to connect added server
-
- :param tester:test client object
- :type tester: flask test object
- :return: server_connect, server_group, server_id
- :rtype: server_connect:dict, server_group:dict, server_id:str
- """
-
- server_connect = []
- servers = []
-
- srv_id = get_ids()
- server_ids = srv_id["sid"]
- server_group = config_data['test_server_group']
-
- # Connect to all servers
- for server_id in server_ids:
- response = tester.post(SERVER_CONNECT_URL + str(server_group) +
- '/' + server_id,
- data=dict(
- password=config_data
- ['test_server_credentials'][0]
- ['test_db_password']),
- follow_redirects=True)
- server_connect_detail = json.loads(response.data.decode())
- connect_database(tester, server_connect_detail, server_id,
- server_group)
- server_connect.append(server_connect_detail)
- servers.append(server_id)
- return server_connect, server_group, servers
-
-
-def connect_database(tester, server_connect, server_id, server_group):
- """
- This function is used to connect database and writes it's details to
- file 'parent_id.pkl'
-
- :param tester: test client object
- :type tester: flask test client object
- :param server_connect: server's data
- :type server_connect: dict
- :param server_id: server id
- :type server_id: str
- :param server_group: server group name
- :type server_group: str
- :return: None
- """
-
- if server_connect['data']['connected']:
- db_data = get_db_data(server_connect)
- db_response = tester.post(
- DATABASE_URL + str(server_group) + "/" + server_id + "/",
- data=json.dumps(db_data),
- content_type='html/json')
- response_data = json.loads(db_response.data.decode())
- write_db_parent_id(response_data)
-
-
-def delete_server(tester):
- """
- This function used to delete the added servers
-
- :param tester: test client object
- :return: None
- """
-
- srv_grp = config_data['test_server_group']
- all_id = get_ids()
- server_ids = all_id["sid"]
- url = SERVER_URL + str(srv_grp) + "/"
-
- # Call api to delete the servers
- for server_id in server_ids:
- response = tester.delete(url + str(server_id))
- assert response.status_code == 200
- response_data = json.loads(response.data.decode())
- assert response_data['success'] == 1
-
-
-def delete_database(tester):
- """
- This function used to delete the added databases
-
- :param tester: test client object
- :return: None
- """
-
- srv_grp = config_data['test_server_group']
- all_id = get_ids()
- server_ids = all_id["sid"]
- db_ids_dict = all_id['did'][0]
-
- db_con = test_getnodes(tester)
- if len(db_con) == 0:
- raise Exception("No database(s) to delete.")
-
- for server_id in server_ids:
- db_id = db_ids_dict[int(server_id)]
- response = tester.delete(DATABASE_URL + str(srv_grp) + '/' +
- str(server_id) + '/' + str(db_id),
- follow_redirects=True)
- assert response.status_code == 200
- response_data = json.loads(response.data.decode('utf-8'))
- assert response_data['success'] == 1
view thread (29+ messages) latest in thread
reply
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Reply to all the recipients using the --to and --cc options:
reply via email
To: [email protected]
Cc: [email protected], [email protected], [email protected]
Subject: Re: pgAdmin IV : Unittest modular patch
In-Reply-To: <CAOAJCYqSdptT3Tyt+nNXxhMd5C2Z-u7yVM6TD4bUQUqE3nsQDg@mail.gmail.com>
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
This inbox is served by agora; see mirroring instructions
for how to clone and mirror all data and code used for this inbox