diff --git a/.github/workflows/dev.yml b/.github/workflows/dev.yml index 7effea3..3970e3e 100644 --- a/.github/workflows/dev.yml +++ b/.github/workflows/dev.yml @@ -35,6 +35,21 @@ jobs: - name: Run Tests run: pytest + + - name: Set up SSH key + run: | + mkdir -p ~/.ssh + echo "${{ secrets.ARTIFACT_SSH_KEY }}" > ~/.ssh/id_rsa + chmod 600 ~/.ssh/id_rsa + echo ${{ secrets.ARTIFACT_HOST }} >> ~/.ssh/known_hosts + sudo apt-get install sshpass + - name: Execute remote SSH + run: | + sshpass -p '${{ secrets.SERVER_PASS }}' ssh -v -o StrictHostKeyChecking=no ${{ secrets.SERVERLOGIN }}@${{ secrets.SERVER_ADDR }} <<'ENDSSH' + echo ${{ secrets.SERVER_PASS }} | sudo -S systemctl stop sacsock + echo ${{ secrets.SERVER_PASS }} | sudo -S systemctl start sacsock + ENDSSH + # - name: Use Node.js ${{ matrix.node-version }} # uses: actions/setup-node@v3 # with: diff --git a/.github/workflows/updateServer.yml b/.github/workflows/updateServer.yml deleted file mode 100644 index 115fd6e..0000000 --- a/.github/workflows/updateServer.yml +++ /dev/null @@ -1,41 +0,0 @@ -# This is a basic workflow that is manually triggered - -name: Push Changes to Server -on: - push: - branches: - - main - pull_request: - types: [opened, synchronize, reopened, closed] - branches: - - main -permissions: - issues: write - contents: read - pull-requests: write - -# A workflow run is made up of one or more jobs that can run sequentially or in parallel -jobs: - update: - # The type of runner that the job will run on - runs-on: ubuntu-latest - - # Steps represent a sequence of tasks that will be executed as part of the job - steps: - - name: Set up SSH key - run: | - mkdir -p ~/.ssh - echo "${{ secrets.ARTIFACT_SSH_KEY }}" > ~/.ssh/id_rsa - chmod 600 ~/.ssh/id_rsa - echo ${{ secrets.ARTIFACT_HOST }} >> ~/.ssh/known_hosts - sudo apt-get install sshpass - - name: Execute remote SSH - run: | - sshpass -p '${{ secrets.SERVER_PASS }}' ssh -v -o StrictHostKeyChecking=no ${{ secrets.SERVERLOGIN }}@${{ secrets.SERVER_ADDR }} <<'ENDSSH' - echo ${{ secrets.SERVER_PASS }} | sudo -S systemctl stop sacsock - echo ${{ secrets.SERVER_PASS }} | sudo -S systemctl start sacsock - ENDSSH - - - - diff --git a/App/controllers/area.py b/App/controllers/area.py index 196248c..1375df2 100644 --- a/App/controllers/area.py +++ b/App/controllers/area.py @@ -39,19 +39,6 @@ def get_lockers_in_area(id): raise("Area does not exist") return area.getLockersInArea() -def get_area_by_description(description): - areas = Area.query.filter(Area.description.contains(description)).all() - if not areas: - return None - return areas - -def get_area_by_description_toJSON(description): - areas = get_area_by_description(description) - if not areas: - return None - return [a.toJSON() for a in areas] - - def set_description(id,new_description): area = get_area_by_id(id) if not area: @@ -91,9 +78,7 @@ def set_longitude(id,new_longitude): except SQLAlchemyError as e: db.session.rollback() raise("Unable to set longitude. Check Error Log for more Details") - - - + def delete_area(id): area = get_area_by_id(id) if not area: diff --git a/App/controllers/key.py b/App/controllers/key.py index 884bb30..c757dec 100644 --- a/App/controllers/key.py +++ b/App/controllers/key.py @@ -66,16 +66,18 @@ def update_key_id(id,new_key_id): def update_key_masterkey_id(id,new_id): + from App.controllers import get_masterkey_by_id key = get_key_by_id(id) + masterkey = get_masterkey_by_id(new_id) - if not key: + if not key or not masterkey: return None try: key.masterkey_id = new_id db.session.add(key) db.session.commit() - return Key + return key except SQLAlchemyError: db.session.rollback() return None @@ -83,12 +85,14 @@ def update_key_masterkey_id(id,new_id): def update_key_status(id,new_status): key = get_key_by_id(id) - if not key: + if not key or new_status is None: return None try: if new_status.upper() in Key_Status.__members__: key.key_status = Key_Status[new_status.upper()] + else: + return None db.session.add(key) db.session.commit() return key diff --git a/App/controllers/lockers.py b/App/controllers/lockers.py index 491f476..eb2acd6 100644 --- a/App/controllers/lockers.py +++ b/App/controllers/lockers.py @@ -4,7 +4,7 @@ from App.models.rent import RentStatus as RStatus from App.models.locker import LockerStatus as Status, LockerTypes from App.database import db -from App.controllers.area import get_area_by_id,get_area_by_description +from App.controllers.area import get_area_by_id from App.controllers.key_history import new_keyHistory,getKeyHistory,deactivate from datetime import datetime from App.controllers.key import get_key_by_id,new_key as create_key @@ -64,18 +64,6 @@ def get_locker_by_area_id_toJSON(id): return [l.toJSON() for l in lockers] -def get_lockers_by_area_description(description): - area = get_area_by_description(description) - - lockers = [] - - if not area: - return None - for a in area: - lockers = lockers + get_locker_by_area_id_toJSON(a.id) - return lockers - - def get_locker_id(id): locker = db.session.query(Locker,Area,KeyHistory).join(Area,KeyHistory).filter(Locker.locker_code == id,KeyHistory.isActive == Active.ACTIVE).first() if not locker: @@ -155,6 +143,9 @@ def rent_locker(id): def not_verified(id): keyH = getKeyHistory(id) + if not keyH: + return None + locker = get_locker_id_locker(keyH.locker_id) if not locker : @@ -173,6 +164,8 @@ def not_verified(id): def release_locker(id): keyH = getKeyHistory(id) + if keyH is None: + return None locker = get_locker_id_locker(keyH.locker_id) if not locker: return None diff --git a/App/controllers/masterkey.py b/App/controllers/masterkey.py index 01ed9aa..323b475 100644 --- a/App/controllers/masterkey.py +++ b/App/controllers/masterkey.py @@ -51,6 +51,9 @@ def get_all_masterkeys_no_offset(): def get_masterkey_by_id(id): + if id == '' or id is None: + return None + masterkey = MasterKey.query.filter(MasterKey.masterkey_id.contains(id)).first() if not masterkey: @@ -61,6 +64,9 @@ def get_masterkey_by_id(id): def update_series(id,new_series): masterkey = get_masterkey_by_id(id) + if new_series is None or new_series == '': + return None + if not masterkey: return None @@ -103,6 +109,8 @@ def delete_masterkey(id): return None def update_masterkey_type(id, new_type): + if new_type is None: + return None masterkey = get_masterkey_by_id(id) if not masterkey: return None @@ -118,6 +126,8 @@ def update_masterkey_type(id, new_type): return None def search_masterkey(query,offset,size): + if query is None or query == '': + return None if query.upper() in Key_Type.__members__: data = db.session.query(MasterKey).filter(or_(MasterKey.key_type == Key_Type[query.upper()],MasterKey.masterkey_id.contains(query),MasterKey.series.contains(query))).all() else: diff --git a/App/controllers/rent.py b/App/controllers/rent.py index 1d9e59c..106843a 100644 --- a/App/controllers/rent.py +++ b/App/controllers/rent.py @@ -60,7 +60,6 @@ def recal_amount_owed(rent,rentType_id,date_returned,rent_date_from,rent_date_to timestamp = datetime.now() semester_period = get_rentType_by_id(rentType_id) orignal_duration = period_elapsed(semester_period,rent_date_from,rent_date_to) - if date_returned: date_returned_1 = date_returned return_duration = period_elapsed(semester_period,rent_date_from,date_returned) @@ -84,7 +83,6 @@ def late_fees(type, duration, original_duration): timestamp = datetime.now() if not type: return -1 - return (duration - original_duration) * type.price def cal_fixed_price(rentType_id): @@ -195,6 +193,7 @@ def rent_additional_payments(id,monetary_value): try: db.session.add(rent) db.session.commit() + return rent except: db.session.rollback() return None @@ -231,20 +230,6 @@ def update_rent(id): raise("Unable to create rent. Check Error Log for more Details") -def get_overdue_rent_by_student(s_id): - rent = Rent.query.filter(and_(Rent.student_id == s_id,Rent.status == Status.OVERDUE)).first() - if not rent : - return None - rent = update_rent(rent.id) - return rent - -def get_owed_rent_by_student(s_id): - rent = Rent.query.filter(and_(Rent.student_id== s_id,Rent.status == Status.OWED)).first() - if not rent : - return None - rent = update_rent(rent.id) - return rent - def get_student_current_rental(s_id): rent = Rent.query.filter(and_(Rent.student_id == s_id, Rent.status != Status.RETURNED, Rent.status != Status.VERIFIED)).first() diff --git a/App/controllers/rentType.py b/App/controllers/rentType.py index f5d9ed6..b0e3955 100644 --- a/App/controllers/rentType.py +++ b/App/controllers/rentType.py @@ -36,29 +36,18 @@ def get_rentType_by_id(id): return rentType -def get_rentType_daily_period(period_from, period_to): - rentType = RentTypes.query.filter(and_(RentTypes.period_to >= period_to, RentTypes.period_from <= period_from,RentTypes.type == Types.DAILY)).first() - +def get_rentType_by_period(period_from, period_to,type): + if type.upper() in Types.__members__: + typeEnum = Types[type.upper()] + else: + raise Exception("Type doesn't exist") + rentType = RentTypes.query.filter(and_(RentTypes.period_to <= period_to, RentTypes.period_from >= period_from,RentTypes.type == typeEnum)).first() + print(rentType) if not rentType: return None return rentType -def get_rentType_period(period_to): - rentType = RentTypes.query.filter_by(period_to = period_to) - - if not rentType: - return None - - return [r.toJSON() for r in rentType] - -def get_rentType_price(price): - rentType = RentTypes.query.filter_by(price = price) - - if not rentType: - return None - - return [r.toJSON() for r in rentType] def update_rentType_price(id,new_price): #first check to see if a rentType exist in rent diff --git a/App/controllers/student.py b/App/controllers/student.py index d7788f9..6450701 100644 --- a/App/controllers/student.py +++ b/App/controllers/student.py @@ -5,6 +5,7 @@ from sqlalchemy.exc import SQLAlchemyError from sqlalchemy import or_, and_ from datetime import datetime +from math import ceil def add_new_student(s_id, f_name, l_name, faculty,p_no,email): if get_student_by_id(s_id): @@ -104,6 +105,7 @@ def update_student_email(s_id, new_email): student.email = new_email db.session.add(student) db.session.commit() + return student except SQLAlchemyError as e: db.session.rollback() @@ -136,12 +138,18 @@ def update_student_status(id,status): student.rentStanding = RentStanding[status.upper()] db.session.add(student) db.session.commit() + return student except SQLAlchemyError as e: db.session.rollback() return None def get_available_student(size,offset): + if size < 1 or type(size) is not int: + size = 6 + if offset < 1 or type(offset) is not int: + offset = 1 + s_offset = (offset *size) - size students = Student.query.filter(Student.rentStanding != RentStanding.OVERDUE).limit(size).offset(s_offset) @@ -151,7 +159,7 @@ def get_available_student(size,offset): s_list = [] for s in students: s_list.append(s.toJSON()) - return {"num_pages":len(s_list), "data":s_list} + return {"num_pages":ceil(len(s_list)/size), "data":s_list} def get_all_students(): students = Student.query.all() @@ -221,24 +229,6 @@ def search_student(query,size,offset): return {"num_pages":num_pages,"data":s_list} -def get_student_by_first_name(query): - student = Student.query.filter_by(first_name = query).all() - if not student: - return None - return [s.toJSON() for s in student] - -def get_student_by_last_name(query): - student = Student.query.filter_by(last_name = query).all() - if not student: - return None - return [s.toJSON() for s in student] - -def get_student_by_faculty(query): - student = Student.query.filter_by(faculty = query).all() - if not student: - return None - return [s.toJSON() for s in student] - def get_student_current_rental(id): current_rental = Rent.query.filter(and_(Rent.student_id == id, Rent.status != RStatus.VERIFIED)).first() if current_rental: @@ -271,9 +261,3 @@ def get_rental_student(id,size,offset): r_list.append(r.toJSON()) return {"num_pages":num_pages,"data":r_list} - -def get_all_available_student(): - students = Student.query.all() - if not students: - return {} - return [S.toJSON() for S in students] \ No newline at end of file diff --git a/App/controllers/transactionLog.py b/App/controllers/transactionLog.py index 8046931..891db6c 100644 --- a/App/controllers/transactionLog.py +++ b/App/controllers/transactionLog.py @@ -77,6 +77,10 @@ def get_num_transactions_page(size): return int(count/size) def get_transactions_by_offset(size, offset): + if size < 1 or type(size) is not int: + size = 6 + if offset < 1 or type(offset) is not int: + offset = 1 t_offset = (offset * size) - size transactions = TransactionLog.query.order_by(TransactionLog.id.desc()).limit(size).offset(t_offset) diff --git a/App/default_config.py b/App/default_config.py index 622bdc4..961d352 100644 --- a/App/default_config.py +++ b/App/default_config.py @@ -1,5 +1,5 @@ -SQLALCHEMY_DATABASE_URI = "postgresql://sactest:sactest@db/sacdb" -"sqlite:///temp-database.db" +SQLALCHEMY_DATABASE_URI = "sqlite:///temp-database.db" +"postgresql://sactest:sactest@db/sacdb" SECRET_KEY = "secret key" JWT_ACCESS_TOKEN_EXPIRES = 7 ENV = "DEVELOPMENT" \ No newline at end of file diff --git a/App/models/key.py b/App/models/key.py index ba0ca21..6c9cb9b 100644 --- a/App/models/key.py +++ b/App/models/key.py @@ -27,7 +27,10 @@ def __init__(self, key_id,masterkey_id,key_status, date_added): def toJSON(self): from App.models import KeyHistory - keyHistory = self.KeyH.order_by(KeyHistory.id.desc()).first() + try: + keyHistory = self.KeyH.order_by(KeyHistory.id.desc()).first() + except: + keyHistory = None if keyHistory: historyJSON = keyHistory.toJSON() else: diff --git a/App/models/transactionLog.py b/App/models/transactionLog.py index 182ae26..92ea049 100644 --- a/App/models/transactionLog.py +++ b/App/models/transactionLog.py @@ -17,7 +17,7 @@ class TransactionLog(db.Model): transaction_date = db.Column(db.Date,nullable = False) amount = db.Column(db.Float , nullable = False) description = db.Column(db.String, nullable = False) - receipt_number = db.Column(db.Integer,seq,nullable=False,unique=True) + receipt_number = db.Column(db.Integer,seq,nullable=True) type = db.Column(db.Enum(TransactionType), nullable = False) def __init__(self, rent_id, currency, transaction_date, amount, description, type): diff --git a/App/py_test.db b/App/py_test.db new file mode 100644 index 0000000..7625d05 Binary files /dev/null and b/App/py_test.db differ diff --git a/App/tests/test_app.py b/App/tests/test_app.py index 3b32c56..efeb726 100644 --- a/App/tests/test_app.py +++ b/App/tests/test_app.py @@ -15,7 +15,6 @@ from wsgi import app - LOGGER = logging.getLogger(__name__) ''' @@ -51,10 +50,11 @@ def test_check_password(self): # scope="class" would execute the fixture once and resued for all methods in the class @pytest.fixture(autouse=True, scope="module") def empty_db(): + os.unlink(os.getcwd()+'/App/test.db') app.config.update({'TESTING': True, 'SQLALCHEMY_DATABASE_URI': 'sqlite:///test.db'}) create_db(app) yield app.test_client() - os.unlink(os.getcwd()+'/App/test.db') + def test_authenticate(): diff --git a/App/tests/test_area.py b/App/tests/test_area.py index 889d1f4..e4caf86 100644 --- a/App/tests/test_area.py +++ b/App/tests/test_area.py @@ -1,119 +1,140 @@ import os, pytest, logging, unittest -from main import app -from database import create_db -from models import Locker, Area -from controllers import ( +from App.main import create_app +from App.database import create_db +from App.models import Locker, Area +from App.controllers import ( add_new_area, + add_new_locker, delete_area, get_area_by_id, get_area_all, + get_lockers_in_area, set_description, set_latitude, set_longitude, ) +from wsgi import app + LOGGER = logging.getLogger(__name__) class AreaUnitTests(unittest.TestCase): def test_new_area(self): - new_locker = Locker('A1001','MEDIUM','FREE','AVAILABLE') - new_area = Area(new_locker.locker_code,'A locker description',10.283759,-61.404937) - assert new_area.locker_id == 'A1001' + new_area = Area('A locker description',10.283759,-61.404937) assert new_area.longitude == 10.283759 assert new_area.latitude == -61.404937 assert new_area.description == 'A locker description' def test_new_area_toJSON(self): - new_locker = Locker('A2010','SMALL','RENTED','UNAVAILABLE') - new_area = Area(new_locker.locker_code,'A locker description',10.259674,-61.411548) + new_area = Area('A locker description',10.259674,-61.411548) expected_json = { 'id':None, - 'locker_id':'A2010', 'description':'A locker description', 'longitude': 10.259674, 'latitude': -61.411548 } self.assertDictEqual(expected_json,new_area.toJSON()) -@pytest.fixture(autouse=True, scope="class") +@pytest.fixture(autouse=True, scope="module") def empty_db(): + os.unlink(os.getcwd()+"/App/py_test.db") app.config.update({'TESTING': True, 'SQLALCHEMY_DATABASE_URI': 'sqlite:///py_test.db'}) create_db(app) yield app.test_client() - os.unlink(os.getcwd()+"//py_test.db") + class AreaIntegratedTests (unittest.TestCase): def test_add_new_area(self): - new_area = add_new_area('A1001','A locker description',10.283759,-61.404937) - assert new_area.id == 1 - assert new_area.locker_id == 'A1001' + new_area = add_new_area('A locker description',10.283759,-61.404937) + #assert new_area.id == 1 assert new_area.longitude == 10.283759 assert new_area.latitude == -61.404937 assert new_area.description == 'A locker description' - - def test_add_new_area_duplicate(self): - new_area = add_new_area('A1001','A locker description',10.283759,-61.404937) - self.assertIsNone(new_area) def test_get_area_by_id(self): area = get_area_by_id(1) assert area.id == 1 - assert area.locker_id == 'A1001' assert area.longitude == 10.283759 assert area.latitude == -61.404937 assert area.description == 'A locker description' def test_get_area_by_id_invalid(self): - area = get_area_by_id(0) - self.assertIsNone(area) + with pytest.raises(Exception) as E: + area = get_area_by_id(0) + self.assertIsNone(area) def test_set_description(self): area = set_description(1,'A new locker description') assert area.description == 'A new locker description' def test_set_description_invalid(self): - area = set_description(0,'A invalid locker description') - self.assertIsNone(area) + with pytest.raises(Exception) as E: + area = set_description(0,'A invalid locker description') + self.assertIsNone(area) def test_set_latitude(self): area = set_latitude(1,9.47893) assert area.latitude == 9.47893 def test_set_latitude_invalid(self): - area = set_latitude(0,9.47893) - self.assertIsNone(area) + with pytest.raises(Exception) as E: + area = set_latitude(0,9.47893) + self.assertIsNone(area) def test_set_longitude(self): area = set_longitude(1,-99.40400) assert area.longitude == -99.40400 def test_set_longitude_invalid(self): - area = set_longitude(0,-99.40400) - self.assertIsNone(area) + with pytest.raises(Exception) as E: + area = set_longitude(0,-99.40400) + self.assertIsNone(area) def test_delete_area(self): - add_new_area('A1111','A locker description',45.85739, -25.45543) - area = delete_area(2) - self.assertIsNotNone(area) - self.assertIsNone(get_area_by_id(2)) + with pytest.raises(Exception) as E: + add_new_area('A locker description',45.85739, -25.45543) + area = delete_area(2) + self.assertIsNotNone(area) + self.assertIsNone(get_area_by_id(2)) def test_delete_area_invalid(self): - area = delete_area(2) - self.assertIsNone(area) + with pytest.raises(Exception) as E: + area = delete_area(2) + self.assertIsNone(area) def test_get_all_area(self): results = get_area_all() expectedList = [{ 'id':1, - 'locker_id':'A1001', 'description':'A locker description', 'longitude': 10.283759, 'latitude': -61.404937 }] self.assertListEqual(expectedList,results) - - - - - + + def test_get_lockers_in_area(self): + add_new_locker('AreaTestLocker','LARGE', 'FREE','TESTKEY1',1) + add_new_locker('AreaTestLocker2','LARGE', 'FREE','TESTKEY2',1) + lockers = get_lockers_in_area(1) + expectedList = [{ + 'locker_code':'AreaTestLocker', + 'locker_type':'Large', + 'status':'Free', + 'area':1 + },{ + 'locker_code':'AreaTestLocker2', + 'locker_type':'Large', + 'status':'Free', + 'area':1 + }] + self.assertListEqual(expectedList,lockers) + + def test_get_lockers_in_area_invalid(self): + with pytest.raises(Exception) as E: + lockers = get_lockers_in_area(999) + lockers1 = get_lockers_in_area(None) + lockers2 = get_lockers_in_area('1') + self.assertIsNone(locker) + self.assertIsNone(locker1) + self.assertIsNone(locker2) \ No newline at end of file diff --git a/App/tests/test_key.py b/App/tests/test_key.py new file mode 100644 index 0000000..ce0eb79 --- /dev/null +++ b/App/tests/test_key.py @@ -0,0 +1,162 @@ +import os, pytest,logging,unittest +from App.main import create_app +from App.database import create_db +from App.models import Key +from App.controllers import ( + delete_key, + get_all_keys, + get_all_keys_id, + get_key_by_id, + get_key_statuses, + new_key, + new_masterkey, + update_key_masterkey_id, + update_key_status, + +) + +from wsgi import app +from datetime import datetime +LOGGER = logging.getLogger(__name__) + +class KeyUnitTests(unittest.TestCase): + def test_create_key(self): + date = datetime.now() + key = Key('TestKey', 'Master1','AVAILABLE',date.date()) + assert key.key_id == 'TestKey' + assert key.masterkey_id == 'Master1' + assert key.key_status.value == 'Available' + assert key.date_added == date.date() + + def test_create_key_toJSON(self): + date = datetime.now() + key = Key('TestKey3', 'Master3','Lost',date.date()) + expected_json = { + 'key_id':'TestKey3', + 'masterkey_id':'Master3', + 'key_status':'Lost', + 'date_added': datetime.strftime(date,'%Y-%m-%d'), + 'KeyHistory': None, + } + self.assertDictEqual(expected_json,key.toJSON()) + + +@pytest.fixture(autouse=True, scope="module") +def empty_db(): + os.unlink(os.getcwd()+"/App/py_test.db") + app.config.update({'TESTING': True, 'SQLALCHEMY_DATABASE_URI': 'sqlite:///py_test.db'}) + create_db(app) + yield app.test_client() + + +class KeyIntegratedTests(unittest.TestCase): + def test_new_key(self): + date = datetime.now() + new_masterkey('TestMasterKey1', 'Series', 'LOCK',date) + key = new_key('TestKey1', 'TestMasterKey1','AVAILABLE',date) + assert key.key_id == 'TestKey1' + assert key.masterkey_id == 'TestMasterKey1' + assert key.key_status.value == 'Available' + assert key.date_added == date.date() + + def test_get_all_keys(self): + date = datetime.now().date() + new_masterkey('TestMasterKey2', 'Series', 'COMBINATION',date) + new_key('TestKey2', 'TestMasterKey2','AVAILABLE',date) + new_key('TestKey21', 'TestMasterKey2','AVAILABLE',date) + keys = get_all_keys(6,1) + expected_json ={ + "num_pages":1, + "data": [{ + 'key_id':'TestKey2', + 'masterkey_id':'TestMasterKey2', + 'key_status':'Available', + 'date_added': datetime.strftime(date,'%Y-%m-%d'), + 'KeyHistory': None, + },{ + 'key_id':'TestKey21', + 'masterkey_id':'TestMasterKey2', + 'key_status':'Available', + 'date_added': datetime.strftime(date,'%Y-%m-%d'), + 'KeyHistory': None, + }]} + self.assertDictEqual(expected_json,keys) + + def test_get_key_by_id(self): + date = datetime.now() + key = get_key_by_id('TestKey2') + self.assertIsNotNone(key) + assert key.key_id == 'TestKey2' + assert key.masterkey_id == 'TestMasterKey2' + assert key.key_status.value == 'Available' + assert key.date_added == date.date() + + def test_get_key_by_id_invalid(self): + key = get_key_by_id('InvalidKey') + key2 = get_key_by_id('') + key3 = get_key_by_id(None) + self.assertIsNone(key) + self.assertIsNone(key2) + self.assertIsNone(key3) + + def test_update_key_masterkey_id(self): + date = datetime.now() + key = update_key_masterkey_id('TestKey21','TestMasterKey1') + self.assertIsNotNone(key) + assert key.key_id == 'TestKey21' + assert key.masterkey_id == 'TestMasterKey1' + assert key.key_status.value == 'Available' + assert key.date_added == date.date() + + def test_update_key_masterkey_id_invalid(self): + key = update_key_masterkey_id('InvalidKey','TestMasterKey1') + key2 = update_key_masterkey_id('TestKey21','InvalidMKey') + key3 = update_key_masterkey_id(None,None) + key4 = update_key_masterkey_id('','') + self.assertIsNone(key) + self.assertIsNone(key2) + self.assertIsNone(key3) + self.assertIsNone(key4) + + def test_update_key_status(self): + date = datetime.now() + new_key('TestKey47', 'TestMasterKey2','LOST',date) + key = update_key_status('TestKey47','Cutting') + self.assertIsNotNone(key) + assert key.key_id == 'TestKey47' + assert key.masterkey_id == 'TestMasterKey2' + assert key.key_status.value == 'Cutting' + assert key.date_added == date.date() + + def test_update_key_status_invalid(self): + key = update_key_status('TestKey47','InvalidStatus') + key2 = update_key_status('InvalidKey','Cutting') + key3 = update_key_status('','') + key4 = update_key_status('TestKey47',None) + self.assertIsNone(key) + self.assertIsNone(key2) + self.assertIsNone(key3) + self.assertIsNone(key4) + + + def test_delete_key(self): + date = datetime.now().date() + new_key('DeleteKey', 'TestMasterKey2','LOST',date) + self.assertIsNotNone(delete_key("DeleteKey")) + self.assertIsNone(get_key_by_id('DeleteKey')) + + def test_delete_key_invalid(self): + self.assertIsNone(delete_key("DeleteKeyInvalid")) + + def test_get_key_statuses(self): + expected_list= ['Available', 'Unavailable','Lost','Cutting','Ready'] + key_statuses = get_key_statuses() + self.assertListEqual(expected_list,key_statuses) + + def test_get_all_keys_id(self): + keys = get_all_keys_id() + expected_list = ['TestKey2','TestKey21'] + self.assertListEqual(expected_list,keys) + + + diff --git a/App/tests/test_keyHistory.py b/App/tests/test_keyHistory.py new file mode 100644 index 0000000..4cb3592 --- /dev/null +++ b/App/tests/test_keyHistory.py @@ -0,0 +1,88 @@ +import os, pytest,logging,unittest +from App.main import create_app +from datetime import datetime +from App.database import create_db +from App.models import KeyHistory +from App.controllers import ( + new_keyHistory, + restore_keyHistory, + deactivate, + getKeyHistory, + getKeyHistory_by_id, + changeDateMove, + getKeyHistory_all +) + +from wsgi import app +LOGGER = logging.getLogger(__name__) + +class KeyHistoryUnitTest(unittest.TestCase): + def empty_test(self): + return + + def test_KeyHistory(self): + date = datetime.now() + key_history = KeyHistory('K101', 'A101', date, 'Active') + assert key_history.key_id == 'K101' + assert key_history.locker_id == 'A101' + assert key_history.date_moved == date + + def test_keyHistory_toJSON(self): + date = datetime.now() + key_history = KeyHistory('K101','A101', date, 'Active') + expected_json = { + 'id': None, + 'key_id':'K101', + 'locker_id':'A101', + 'date_moved': date + } + self.assertDictEqual(expected_json,key_history.toJSON()) + +@pytest.fixture(autouse=True, scope="module") +def empty_db(): + os.unlink(os.getcwd()+"/App/py_test.db") + app.config.update({'TESTING': True, 'SQLALCHEMY_DATABASE_URI': 'sqlite:///py_test.db'}) + create_db(app) + yield app.test_client() + + +class KeyHistoryIntegratedTest(unittest.TestCase): + def empty_i_test(self): + return + + def test_new_keyHistory(self): + date = datetime.now().date() + newkeyH = new_keyHistory('K101','A101',date) + assert newkeyH.key_id == 'K101' + assert newkeyH.locker_id == 'A101' + assert newkeyH.date_moved == date + + def test_deactivate(self): + date = datetime.now().date() + newkeyH = new_keyHistory('K101','A101',date) + deactivate_key = deactivate(newkeyH.id) + assert deactivate_key.id == newkeyH.id + assert deactivate_key.key_id == 'K101' + assert deactivate_key.locker_id == 'A101' + assert deactivate_key.date_moved == date + assert deactivate_key.isActive.value == 'Inactive' + + def test_getKeyHistory(self): + date = datetime.now().date() + newkeyH = new_keyHistory('K105','A105',date) + getkeyH = getKeyHistory(newkeyH.id) + assert getkeyH.id == newkeyH.id + assert getkeyH.key_id == 'K105' + assert getkeyH.locker_id == 'A105' + assert getkeyH.date_moved == date + assert getkeyH.isActive.value == 'Active' + + def test_getKeyHistory_by_id(self): + expected_json ={'num_pages':1, "data":[{ + 'id': 1, + 'key_id':'K101', + 'locker_id':'A101', + 'date_moved': datetime.now().date() + }]} + getkeyH_id = getKeyHistory_by_id('K101',6,1) + self.assertDictEqual(expected_json, getkeyH_id) \ No newline at end of file diff --git a/App/tests/test_lockers.py b/App/tests/test_lockers.py index 16b0ca0..d9a68b0 100644 --- a/App/tests/test_lockers.py +++ b/App/tests/test_lockers.py @@ -1,65 +1,80 @@ import os, pytest, logging, unittest -from main import app -from database import create_db -from models import Locker -from models.locker import Status,Key,LockerTypes -from controllers import ( +from App.main import create_app +from App.database import create_db +from App.models import Locker +from App.models.locker import LockerStatus as Status,LockerTypes +from App.controllers import ( + add_new_area, + get_locker_id_locker, + get_current_locker_instance, add_new_locker, + add_new_student, + new_rentType, get_lockers_available, + get_locker_by_area_id_toJSON, get_locker_id, get_all_lockers, getLockerTypes, getStatuses, - getKey, rent_locker, release_locker, + update_locker_area, delete_locker, + not_verified, update_key, update_locker_type, - update_locker_status + update_locker_status, + swap_key, + create_rent, + get_locker_rent_history, + get_current_rental_c, ) +from wsgi import app +from datetime import datetime,timedelta + LOGGER = logging.getLogger(__name__) class LockerUnitTests(unittest.TestCase): def test_new_locker(self): - new_locker = Locker('A1001','MEDIUM','FREE','AVAILABLE') + new_locker = Locker('A1001','MEDIUM','FREE',2) assert new_locker.locker_code =='A1001' assert new_locker.locker_type.value == 'Medium' assert new_locker.status.value == 'Free' - assert new_locker.key.value == 'Available' + assert new_locker.area == 2 def test_new_locker_toJSON(self): - new_locker = Locker('A2010','SMALL','RENTED','UNAVAILABLE') + new_locker = Locker('A2010','SMALL','RENTED', 1) expected_json = { 'locker_code':'A2010', 'locker_type':'Small', 'status':'Rented', - 'key': 'Unavailable', - 'area': [] + 'area': 1 } self.assertDictEqual(new_locker.toJSON(),expected_json) -@pytest.fixture(autouse=True, scope="class") +@pytest.fixture(autouse=True, scope="module") def empty_db(): + os.unlink(os.getcwd()+"/App/py_test.db") app.config.update({'TESTING': True, 'SQLALCHEMY_DATABASE_URI': 'sqlite:///py_test.db'}) create_db(app) yield app.test_client() - os.unlink(os.getcwd()+"//py_test.db") + class LockerIntegrationTests(unittest.TestCase): def test_add_new_locker(self): - new_locker = add_new_locker('A1001','MEDIUM','FREE','AVAILABLE') + new_area = add_new_area('A locker description',10.283759,-61.404937) + new_locker = add_new_locker('A1001','MEDIUM','FREE','test01', 1) self.assertIsNotNone(new_locker) assert new_locker.locker_code =='A1001' assert new_locker.locker_type.value == 'Medium' assert new_locker.status.value == 'Free' - assert new_locker.key.value == 'Available' + assert new_locker.area == 1 def test_add_new_locker_duplicate(self): - new_locker = add_new_locker('A1001','MEDIUM','FREE','AVAILABLE') + new_locker = add_new_locker('A1001','MEDIUM','FREE','TEST', 1) self.assertIsNone(new_locker) def test_get_available_lockers(self): @@ -68,8 +83,7 @@ def test_get_available_lockers(self): 'locker_code':'A1001', 'locker_type':'Medium', 'status':'Free', - 'key': 'Available', - 'area': [] + 'area': 1 }] self.assertListEqual(expected_list, result) @@ -79,15 +93,16 @@ def test_get_all_lockers(self): 'locker_code':'A1001', 'locker_type':'Medium', 'status':'Free', - 'key': 'Available', - 'area': [] + 'key': 'test01', + 'area': 1, + 'area_description': 'A locker description' }] self.assertListEqual(expected_list, result) def test_rent_locker(self): result = rent_locker('A1001') self.assertTrue(result) - locker = get_locker_id('A1001') + locker = get_locker_id_locker('A1001') assert locker.status == Status.RENTED def test_rent_locker_rented(self): @@ -99,17 +114,29 @@ def test_rent_locker_invalid(self): self.assertIsNone(result) def test_release_locker(self): - result = release_locker('A1001') + keyHistoryID = get_current_locker_instance('A1001') + result = release_locker(keyHistoryID.id) self.assertTrue(result) - locker = get_locker_id('A1001') + locker = get_locker_id_locker('A1001') assert locker.status == Status.FREE def test_release_locker_invalid(self): - result = release_locker('A1241') + result = release_locker(654321) + self.assertIsNone(result) + + def test_not_verified(self): + keyHistoryID = get_current_locker_instance('A1001') + result = not_verified(keyHistoryID.id) + self.assertTrue(result) + locker = get_locker_id_locker('A1001') + assert locker.status == Status.NVERIFIED + + def test_not_verified_invalid(self): + result = not_verified(654321) self.assertIsNone(result) def test_delete_locker(self): - add_new_locker('A1111','COMBINATION','RENTED','UNAVAILABLE') + add_new_locker('A1111','COMBINATION','RENTED','TEST', 1) locker = delete_locker('A1111') self.assertIsNotNone(locker) self.assertIsNone(get_locker_id('A1111')) @@ -118,26 +145,6 @@ def test_delete_locker_invalid(self): result = delete_locker('A1241') self.assertIsNone(result) - def test_update_key_unavailble(self): - locker = update_key('A1001','Unavailable') - assert locker.key == Key.UNAVAILABLE - - def test_update_key_Lost(self): - locker = update_key('A1001','Lost') - assert locker.key == Key.LOST - - def test_update_key_available(self): - locker = update_key('A1001','available') - assert locker.key == Key.AVAILABLE - - def test_update_key_invalidLocker(self): - locker = update_key('A1111','Unavailable') - self.assertIsNone(locker) - - def test_update_key_invalidKeyStatus(self): - locker = update_key('A1001','Not available') - self.assertIsNone(locker) - def test_update_locker_type_small(self): locker = update_locker_type('A1001','Small') assert locker.locker_type == LockerTypes.SMALL @@ -151,7 +158,7 @@ def test_update_locker_type_medium(self): assert locker.locker_type == LockerTypes.MEDIUM def test_update_locker_type_invalid(self): - locker = update_locker_type('A1001','Large') + locker = update_locker_type('A1001','Circle') self.assertIsNone(locker) def test_update_locker_status_rented (self): @@ -171,16 +178,102 @@ def test_update_locker_status_invalid (self): self.assertIsNone(locker) def test_getStatuses(self): - expectedList =['Rented','Repair','Free'] + expectedList =['Rented','Repair','Free','Not Verified'] result = getStatuses() self.assertListEqual(expectedList,result) def test_getLockerTypes(self): - expectedList =['Small','Medium','Combination'] + expectedList =['Small','Medium','Large','Combination'] result = getLockerTypes() self.assertListEqual(expectedList,result) + + def test_swap_key(self): + locker1 = add_new_locker('A2001','MEDIUM','FREE','K201', 1) + locker2 = add_new_locker('A3001','MEDIUM','FREE','K301', 1) + result = swap_key(locker1.locker_code, locker2.locker_code) + assert result[0][2].key_id == 'K301' + assert result[1][2].key_id == 'K201' + + def test_swap_key_invalid(self): + result = swap_key('invalid', 'invalid2') + self.assertIsNone(result) + + def test_update_key(self): + update = update_key('A1001', 'K101') + locker = get_locker_id('A1001') + assert locker[2].key_id == 'K101' + + def test_update_key_invalid_key(self): + with pytest.raises(Exception) as e: + update = update_key('A1001', None) + update2 = update_key('A1001', '') + assert str(e) == 'Key cannot be empty' + + def test_update_key_invalid_locker(self): + update = update_key('A1001', 'K101') + self.assertIsNone(update) + + def test_get_lockers_by_area_id(self): + lockers = get_locker_by_area_id_toJSON(1) + expected_list = [{ + 'locker_code':'A1001', + 'locker_type':'Medium', + 'status':'Free', + 'area': 1, + }] + self.assertListEqual(expected_list, lockers) + + def test_update_locker_area(self): + new_area = add_new_area('An area description',10.283759,-61.404937) + new_locker = add_new_locker('TEST10101','MEDIUM','FREE','test01', new_area.id) + result = update_locker_area(new_locker.locker_code,new_area.id) + assert result.locker_code == 'TEST10101' + assert result.area == new_area.id + + def test_get_current_rental_c(self): + new_area = add_new_area('Area3?',10.283759,-61.404937) + new_locker = add_new_locker('NewLocker2','MEDIUM','FREE','TestlockerKey', new_area.id) + add_new_student('123456789','Victory','Friends','FSS','18684981333','victoria.friends@my.uwi.edu') + period_from = datetime(2022,8,31) + period_to = datetime(2023,7,31) + rent_type = new_rentType(period_from,period_to,'Daily',4) + rent_period_from = datetime.now() + rent_period_from = rent_period_from.replace(hour = 8, minute = 0 ,second= 0, microsecond= 0) + rent_period_to = rent_period_from + timedelta(days=5) + create_rent('123456789','NewLocker2',1,rent_period_from,rent_period_to, 'RATE', None) + rent = get_current_rental_c('NewLocker2') + assert rent.student_id == '123456789' + assert rent.rent_type == 1 + assert rent.rent_date_from == rent_period_from + assert rent.rent_date_to == rent_period_to + assert rent.date_returned is None + assert rent.amount_owed == 20 + assert rent.status.value == 'Owed' + + def test_get_locker_rent_history(self): + rent_period_from = datetime.now() + rent_period_from = rent_period_from.replace(hour = 8, minute = 0 ,second= 0, microsecond= 0) + rent_period_to = rent_period_from + timedelta(days=5) + locker_rents = get_locker_rent_history('NewLocker2',6,1) + expected_list= [{ + 'id': 1, + 'student_id': '123456789', + 'keyHistory_id':2, + "additional_fees":0.0, + 'late_fees':0.0, + 'rent_type':1, + 'rent_method':'Rate', + 'rent_date_from':datetime.strftime(rent_period_from,'%Y-%m-%d %H:%M:%S'), + 'rent_date_to':datetime.strftime(rent_period_to,'%Y-%m-%d %H:%M:%S'), + 'date_returned':"", + 'amount_owed':20.0, + 'status':'Owed' + }] + self.assertListEqual(expected_list, locker_rents["data"]) + + + + + + - def test_getKey(self): - expectedList =['Available','Unavailable','Lost'] - result = getKey() - self.assertListEqual(expectedList,result) \ No newline at end of file diff --git a/App/tests/test_masterkey.py b/App/tests/test_masterkey.py new file mode 100644 index 0000000..9045cd3 --- /dev/null +++ b/App/tests/test_masterkey.py @@ -0,0 +1,158 @@ +import os, pytest,logging,unittest +from App.main import create_app +from App.database import create_db +from App.models import MasterKey +from App.controllers import ( + new_masterkey, + get_all_masterkeys, + get_all_masterkeys_no_offset, + get_masterkey_by_id, + update_series, + update_masterkey_id, + delete_masterkey, + update_masterkey_type, + search_masterkey, + get_key_masterkey_offset, +) +from datetime import datetime + +from wsgi import app + +LOGGER = logging.getLogger(__name__) + +class MasterkeyUnitTests(unittest.TestCase): + def test_create_new_masterkey(self): + date = datetime(2023,1,31) + new_m_key = MasterKey('TestMasterkey','MasterkeySeries','Lock',date.date()) + assert new_m_key.masterkey_id == "TestMasterkey" + assert new_m_key.series == "MasterkeySeries" + assert new_m_key.key_type.value == "Lock" + assert new_m_key.date_added == date.date() + + def test_create_new_masterkey_toJSON(self): + date = datetime(2023,1,31) + new_m_key = MasterKey('TestMasterkey2','MasterkeySeries2','Combination',date) + expected_json = { + 'masterkey_id':'TestMasterkey2', + 'series':'MasterkeySeries2', + 'key_type':'Combination', + 'date_added': datetime.strftime(date,'%Y-%m-%d') + } + self.assertDictEqual(expected_json,new_m_key.toJSON()) + + +@pytest.fixture(autouse=True, scope="module") +def empty_db(): + os.unlink(os.getcwd()+"/App/py_test.db") + app.config.update({'TESTING': True, 'SQLALCHEMY_DATABASE_URI': 'sqlite:///py_test.db'}) + create_db(app) + yield app.test_client() + + +class MasterkeyIntegratedTests(unittest.TestCase): + def test_new_masterkey(self): + date = datetime(2023,1,31) + new_m_key = new_masterkey('TestMKey', 'TestSeries','LOCK', date) + assert new_m_key.masterkey_id == "TestMKey" + assert new_m_key.series == "TestSeries" + assert new_m_key.key_type.value == "Lock" + assert new_m_key.date_added == date.date() + + def test_get_all_masterkeys(self): + date = datetime(2023,1,31) + new_masterkey('Master1', 'M1','LOCK', date) + new_masterkey('Master2', 'M2','Combination', date) + new_masterkey('Master3', 'M3','LOCK', date) + new_masterkey('Master4', 'M4','Combination', date) + master_key_list = get_all_masterkeys(3,1) + expected_json = {'num_pages':2, "data":[{ + 'masterkey_id':'Master1', + 'series':'M1', + 'key_type':'Lock', + 'date_added': datetime.strftime(date,'%Y-%m-%d') + }, { + 'masterkey_id':'Master2', + 'series':'M2', + 'key_type':'Combination', + 'date_added': datetime.strftime(date,'%Y-%m-%d') + }, { + 'masterkey_id':'Master3', + 'series':'M3', + 'key_type':'Lock', + 'date_added': datetime.strftime(date,'%Y-%m-%d') + }]} + self.assertDictEqual(expected_json,master_key_list) + + def test_get_all_masterkeys_no_offset(self): + date = datetime(2023,1,31) + expected_list = ['Master1', 'Master2','Master3','Master4'] + master_key_list = get_all_masterkeys_no_offset() + self.assertListEqual(expected_list,master_key_list) + + def test_get_masterkey_by_id(self): + date = datetime(2023,1,31) + masterkey = get_masterkey_by_id('Master1') + assert masterkey.masterkey_id == "Master1" + assert masterkey.series == "M1" + assert masterkey.key_type.value == "Lock" + assert masterkey.date_added == date.date() + + def test_get_masterkey_by_id_invalid(self): + date = datetime(2023,1,31) + masterkey = get_masterkey_by_id('') + masterkey_2 = get_masterkey_by_id(None) + masterkey_3 = get_masterkey_by_id('Invalid') + self.assertIsNone(masterkey) + self.assertIsNone(masterkey_2) + self.assertIsNone(masterkey_3) + + def test_update_series(self): + new_masterkey('Master5', 'z1','LOCK', datetime.now()) + masterkey = update_series('Master5','M5') + assert masterkey.masterkey_id == 'Master5' + assert masterkey.series == 'M5' + + def test_update_series_invalid(self): + masterkey = update_series('','M5') + masterkey2 = update_series(None,'Bubbles') + masterkey3 = update_series('Master5',None) + self.assertIsNone(masterkey) + self.assertIsNone(masterkey2) + self.assertIsNone(masterkey3) + + def test_update_masterkey_type(self): + new_masterkey('Master6', 'M6','Combination', datetime.now()) + masterkey = update_masterkey_type('Master6','LOCK') + assert masterkey.masterkey_id == 'Master6' + assert masterkey.key_type.value == 'Lock' + + def test_update_masterkey_type_invalid(self): + masterkey = update_masterkey_type('','LOCK') + masterkey2 = update_masterkey_type('Master6',None) + masterkey3 = update_masterkey_type(None,'') + self.assertIsNone(masterkey) + self.assertIsNone(masterkey2) + self.assertIsNone(masterkey3) + + def test_search_masterkey(self): + date = datetime(2023,1,31) + query = search_masterkey('Combination',1,6) + expected_json = {'num_pages':1, "data":[{ + 'masterkey_id':'Master2', + 'series':'M2', + 'key_type':'Combination', + 'date_added': datetime.strftime(date,'%Y-%m-%d') + },{ + 'masterkey_id':'Master4', + 'series':'M4', + 'key_type':'Combination', + 'date_added': datetime.strftime(date,'%Y-%m-%d') + }]} + self.assertDictEqual(expected_json,query) + + + + + + + \ No newline at end of file diff --git a/App/tests/test_notes.py b/App/tests/test_notes.py new file mode 100644 index 0000000..dee8841 --- /dev/null +++ b/App/tests/test_notes.py @@ -0,0 +1,92 @@ +import os, pytest,logging,unittest +from App.main import create_app +from App.database import create_db +from App.models import Notes +from App.controllers import ( + create_comment, + add_new_area, + add_new_locker, + add_new_student, + create_rent, + get_comment, + get_all_comments, + get_comments_offset, + new_rentType, + +) + +from wsgi import app +from datetime import datetime,timedelta + +LOGGER = logging.getLogger(__name__) + +class NotesUnitTest(unittest.TestCase): + def test_create_note(self): + date = datetime.now().date() + new_note = Notes(1,'Test Comment', date) + assert new_note.rent_id == 1 + assert new_note.comment == 'Test Comment' + assert new_note.date_created == date + + def test_create_note_toJSON(self): + date = datetime.now().date() + new_note = Notes(1,'Test2Comment', date) + expected_json = { + "id":None, + "rent_id":1, + "comment":"Test2Comment", + "date_created":datetime.strftime(date,'%Y-%m-%d') + } + self.assertDictEqual(expected_json, new_note.toJSON()) + +@pytest.fixture(autouse=True, scope="module") +def empty_db(): + os.unlink(os.getcwd()+"/App/py_test.db") + app.config.update({'TESTING': True, 'SQLALCHEMY_DATABASE_URI': 'sqlite:///py_test.db'}) + create_db(app) + yield app.test_client() + + +class NotesIntegratedTest(unittest.TestCase): + def test_create_comment(self): + date = datetime.now() + area = add_new_area('NotesTestArea',12,12) + locker = add_new_locker('NotesLocker','Large','Free','NotesKey',area.id) + student = add_new_student('00001111','Notes','StudentTest','TST','18008001234','notes@email.com') + rentType = new_rentType(date, timedelta(days=1825) + date,'SemesterLarge',200) + rent = create_rent(student.student_id,locker.locker_code,rentType.id,date, timedelta(days=90)+date,'FIXED',None) + note = create_comment(rent.id,'Student left locker in good condition',date.date()) + assert note.comment == 'Student left locker in good condition' + assert note.rent_id == rent.id + + def test_get_comment(self): + note = get_comment(1) + assert note.comment == 'Student left locker in good condition' + assert note.rent_id == 1 + + def test_get_comments_all(self): + date = datetime.strftime(datetime.now(),'%Y-%m-%d') + notes = get_all_comments(1) + notes = [n.toJSON() for n in notes] + expected_list = [{ + "id":1, + "rent_id":1, + "comment": 'Student left locker in good condition', + "date_created":date + }] + self.assertListEqual(expected_list,notes) + + def test_get_comments_offset(self): + date = datetime.strftime(datetime.now(),'%Y-%m-%d') + notes = get_comments_offset(1,6,1) + expected_list = [{ + "id":1, + "rent_id":1, + "comment": 'Student left locker in good condition', + "date_created":date + }] + self.assertIsNotNone(notes) + self.assertListEqual(expected_list,notes['data']) + assert notes['num_pages'] == 1 + + diff --git a/App/tests/test_rent.py b/App/tests/test_rent.py index e85c00c..615ca91 100644 --- a/App/tests/test_rent.py +++ b/App/tests/test_rent.py @@ -1,39 +1,54 @@ import os, pytest, logging, unittest -from database import create_db -from main import app -from models import RentTypes,Rent,TransactionLog -from controllers import ( +from App.database import create_db +from App.main import create_app +from App.models import RentTypes,Rent,TransactionLog +from App.controllers import ( add_new_transaction, + add_new_area, create_rent, init_amount_owed, + get_rentType_by_id, + get_rent_by_id, + get_all_rentals_active, + get_all_rentals_inactive, + get_rentType_by_period, add_new_locker, add_new_student, get_all_rentals, new_rentType, period_elapsed, recal_amount_owed, - release_rental + release_rental, + add_new_area, + swap_rent, + verify_rental, + get_transactions, + rent_additional_payments, + update_rent_values, ) -from models.rent import Status +from App.models.rent import RentStatus from datetime import datetime,timedelta +from wsgi import app LOGGER = logging.getLogger(__name__) class RentTypeUnitTests(unittest.TestCase): def test_new_rent(self): - new_rent = Rent('816000000','A1001','1', datetime(2023,2,15), datetime(2023,2,18),22.50) + date1 = datetime.now() + date2 = timedelta(days = 30) + date1 + new_rent = Rent('816000000','1','1', date1, date2, 22.5, 'FIXED', None) assert new_rent.student_id == '816000000' - assert new_rent.locker_id == 'A1001' - assert new_rent.rent_date_from == datetime(2023,2,15) - assert new_rent.rent_date_to == datetime(2023,2,18) + assert new_rent.keyHistory_id == '1' + assert new_rent.rent_date_from == date1 + assert new_rent.rent_date_to == date2 assert new_rent.date_returned == None assert new_rent.amount_owed == 22.5 assert new_rent.status.value == "Owed" def test_new_rent_overdue(self): - new_rent = Rent('816001110','A1111','1', datetime(2022,2,15), datetime(2022,2,18),22.50) + new_rent = Rent('816001110','1','1', datetime(2022,2,15), datetime(2022,2,18),22.50, 'FIXED', None) assert new_rent.student_id == '816001110' - assert new_rent.locker_id == 'A1111' + assert new_rent.keyHistory_id == '1' assert new_rent.rent_date_from == datetime(2022,2,15) assert new_rent.rent_date_to == datetime(2022,2,18) assert new_rent.date_returned == None @@ -41,124 +56,132 @@ def test_new_rent_overdue(self): assert new_rent.status.value == "Overdue" def test_new_rent_paid(self): - new_rent = Rent('816000000','A1001','1', datetime(2023,2,15), datetime(2023,2,18),0) - new_rent.Transactions = [TransactionLog(None,'TTD',datetime(2023,1,1),15,'Description','Debit'),TransactionLog(None,'TTD',datetime(2023,1,5),15,'Description','Debit')] + new_rent = Rent('816000000','1','1', datetime(2023,2,15), datetime(2023,2,18),100, 'FIXED', None) + new_rent.late_fees = 0 + new_rent.additional_fees = 0 + new_rent.update_payments(100) new_rent.status = new_rent.check_status() assert new_rent.student_id == '816000000' - assert new_rent.locker_id == 'A1001' + assert new_rent.keyHistory_id == '1' assert new_rent.rent_date_from == datetime(2023,2,15) assert new_rent.rent_date_to == datetime(2023,2,18) assert new_rent.date_returned == None - assert new_rent.amount_owed == 0 + assert new_rent.cal_amount_owed() == 0 assert new_rent.status.value == "Paid" def test_new_rent_partial(self): - new_rent = Rent('816000000','A1001','1', datetime(2023,2,15), datetime(2023,2,18),200) - new_rent.Transactions = [TransactionLog(None,'TTD',datetime(2023,1,1),15,'Description','Debit'),TransactionLog(None,'TTD',datetime(2023,1,5),15,'Description','Debit')] + new_rent = Rent('816000000','1','1', datetime(2023,2,15), datetime(2023,2,18),200, 'FIXED', None) + new_rent.late_fees = 0 + new_rent.additional_fees = 0 + new_rent.update_payments(100) new_rent.status = new_rent.check_status() assert new_rent.student_id == '816000000' - assert new_rent.locker_id == 'A1001' + assert new_rent.keyHistory_id == '1' assert new_rent.rent_date_from == datetime(2023,2,15) assert new_rent.rent_date_to == datetime(2023,2,18) assert new_rent.date_returned == None - assert new_rent.amount_owed == 200 + assert new_rent.cal_amount_owed() == 100 assert new_rent.status.value == "Partial" def test_new_rent_returned(self): - new_rent = Rent('816001110','A1111','1', datetime(2022,2,15), datetime(2022,2,18),0) - new_rent.status = Status.RETURNED + new_rent = Rent('816001110','1','1', datetime(2022,2,15), datetime(2022,2,18),40, 'FIXED', datetime(2022, 2, 18)) + new_rent.late_fees = 0 + new_rent.additional_fees = 0 + new_rent.update_payments(40) + new_rent.status = new_rent.check_status() assert new_rent.student_id == '816001110' - assert new_rent.locker_id == 'A1111' + assert new_rent.keyHistory_id == '1' assert new_rent.rent_date_from == datetime(2022,2,15) assert new_rent.rent_date_to == datetime(2022,2,18) - assert new_rent.date_returned == None - assert new_rent.amount_owed == 0 + assert new_rent.date_returned == datetime(2022, 2, 18) + assert new_rent.cal_amount_owed() == 0 assert new_rent.status.value == "Returned" def test_new_rent_toJSON(self): - new_rent = Rent('816001110','A1111','1', datetime(2023,2,15), datetime(2023,2,18),22.50) + rent_date_from = datetime.now() + rent_date_to = timedelta(days=30) + rent_date_from + new_rent = Rent('816001110','1','1', rent_date_from, rent_date_to,22.50, 'FIXED', None) + new_rent.late_fees = 0 + new_rent.additional_fees = 0 expected_json = { 'id': None, 'student_id': '816001110', - 'locker_id':'A1111', + 'keyHistory_id':'1', 'rent_type':'1', - 'rent_date_from':datetime(2023,2,15), - 'rent_date_to':datetime(2023,2,18), - 'date_returned':None, + 'rent_date_from':datetime.strftime(rent_date_from,'%Y-%m-%d %H:%M:%S'), + 'rent_date_to':datetime.strftime(rent_date_to,'%Y-%m-%d %H:%M:%S'), + 'rent_method': 'Period', + 'date_returned':'', + 'additional_fees': 0, + 'late_fees' : 0, 'amount_owed':22.5, - 'status':Status.OWED + 'status': 'Owed' } self.assertDictEqual(expected_json,new_rent.toJSON()) -@pytest.fixture(autouse=True, scope="class") +@pytest.fixture(autouse=True, scope="module") def empty_db(): + os.unlink(os.getcwd()+"/App/py_test.db") app.config.update({'TESTING': True, 'SQLALCHEMY_DATABASE_URI': 'sqlite:///py_test.db'}) create_db(app) yield app.test_client() - os.unlink(os.getcwd()+"//py_test.db") + class RentIntegratedTest(unittest.TestCase): def test_create_rent(self): + area = add_new_area('ENG', 12, 20) add_new_student('816000111','Remmy','Dreamer','FST','18684981333','remmy.dreamer@my.uwi.edu') - add_new_locker('A1001','MEDIUM','FREE','AVAILABLE') - + add_new_locker('A1001','MEDIUM','FREE','AVAILABLE',area.id) period_from = datetime(2022,8,31) period_to = datetime(2023,7,31) - new_rentType(period_from,period_to,'Daily',4) - + rent_type = get_rentType_by_period(period_from,period_to,'Daily') + if rent_type is None: + new_rentType(period_from,period_to,'Daily',4) rent_period_from = datetime.now() rent_period_from = rent_period_from.replace(hour = 8, minute = 0 ,second= 0, microsecond= 0) rent_period_to = rent_period_from + timedelta(days=5) - rent = create_rent('816000111','A1001',1,rent_period_from,rent_period_to) - assert rent.student_id == 816000111 - assert rent.locker_id == 'A1001' + rent = create_rent('816000111','A1001',1,rent_period_from,rent_period_to, 'RATE', None) + assert rent.student_id == '816000111' + assert rent.key_history.id == 1 assert rent.rent_type == 1 assert rent.rent_date_from == rent_period_from assert rent.rent_date_to == rent_period_to assert rent.date_returned is None assert rent.amount_owed == 20 - assert rent.status == Status.OWED + assert rent.status.value == 'Owed' + def test_period_elaspsed_daily(self): + period_from = datetime(2022,8,31) + period_to = datetime(2023,7,31) + rent_type = get_rentType_by_period(period_from,period_to,'Daily') + if rent_type is None: + rent_type = new_rentType(period_from,period_to,'Daily',4) rent_date_from = datetime.now() rent_date_to = rent_date_from + timedelta(18) - time = period_elapsed(1,rent_date_from,rent_date_to) + time = period_elapsed(rent_type,rent_date_from,rent_date_to) assert time == 18 def test_period_elaspsed_hourly(self): period_from = datetime(2022,8,31) period_to = datetime(2023,7,31) - new_rentType(period_from,period_to,'Hourly',2.50) + rent_type = get_rentType_by_period(period_from,period_to,'Hourly') + if rent_type is None: + rent_type = new_rentType(period_from,period_to,'Hourly',2.50) rent_date_from = datetime.now() rent_date_to = rent_date_from + timedelta(hours=5) - time = period_elapsed(2,rent_date_from,rent_date_to) + time = period_elapsed(rent_type,rent_date_from,rent_date_to) assert time == 5 - def test_period_elaspsed_t_weekly(self): - period_from = datetime(2022,8,31) - period_to = datetime(2023,7,31) - new_rentType(period_from,period_to,'Weekly',8) - rent_date_from = datetime.now() - rent_date_to = rent_date_from + timedelta(days = 21) - time = period_elapsed(5,rent_date_from,rent_date_to) - assert time == 3 - - def test_period_elaspsed_monthly(self): - period_from = datetime(2022,8,31) - period_to = datetime(2023,7,31) - new_rentType(period_from,period_to,'Monthly',30) - rent_date_from = datetime.now() - rent_date_to = rent_date_from + timedelta(days = 31) - time = period_elapsed(3,rent_date_from,rent_date_to) - assert time == 1 - def test_period_elaspsed_semester(self): period_from = datetime(2022,8,31) period_to = datetime(2023,7,31) - new_rentType(period_from,period_to,'Semester',100) + rent_type = get_rentType_by_period(period_from,period_to,'SEMESTERMEDIUM') + if rent_type is None: + rent_type = new_rentType(period_from,period_to,'SEMESTERMEDIUM',100) rent_date_from = datetime.now() rent_date_to = rent_date_from + timedelta(days = 93) - time = period_elapsed(4,rent_date_from,rent_date_to) + time = period_elapsed(rent_type,rent_date_from,rent_date_to) assert time == 1 def test_q_init_amount_owed_daily(self): @@ -168,92 +191,105 @@ def test_q_init_amount_owed_daily(self): assert amount == 12 def test_q_init_amount_owed_hourly(self): + period_from = datetime(2022,8,31) + period_to = datetime(2023,7,31) rent_date_from = datetime.now() + rent_type = get_rentType_by_period(period_from,period_to,'Hourly') + if rent_type is None: + rent_type = new_rentType(period_from,period_to,'Hourly',2.50) rent_date_to = rent_date_from + timedelta(hours=5) - amount = init_amount_owed(2,rent_date_from,rent_date_to) + amount = init_amount_owed(rent_type.id,rent_date_from,rent_date_to) assert amount == 12.50 def test_q_init_amount_owed_monthly(self): + period_from = datetime(2022,8,31) + period_to = datetime(2023,7,31) rent_date_from = datetime.now() - rent_date_to = rent_date_from + timedelta(days=62) - amount = init_amount_owed(3,rent_date_from,rent_date_to) - assert amount == 60 + rent_date_to = rent_date_from + timedelta(days=31) + rent_type = get_rentType_by_period(period_from,period_to,'DAILY') + if rent_type is None: + rent_type = new_rentType(period_from,period_to,'Daily',4) + amount = init_amount_owed(rent_type.id,rent_date_from,rent_date_to) + assert amount == 124 def test_q_init_amount_owed_semester(self): + period_from = datetime(2022,8,31) + period_to = datetime(2023,7,31) rent_date_from = datetime.now() - rent_date_to = rent_date_from + timedelta(days=93) - amount = init_amount_owed(4,rent_date_from,rent_date_to) + rent_type = get_rentType_by_period(period_from,period_to,'SEMESTERMEDIUM') + rent_date_to = rent_date_from + timedelta(days=90) + if rent_type is None: + rent_type = new_rentType(period_from,period_to,'SEMESTERMEDIUM',100) + amount = init_amount_owed(rent_type.id,rent_date_from,rent_date_to) assert amount == 100 - def test_recal_amount_owed_daily_ontime(self): + def test_recal_amount_owed_daily(self): rent_date_from = datetime(2023,1,8) rent_date_to = rent_date_from + timedelta(days=2) - date_returned = datetime.now() - amt = recal_amount_owed(1,date_returned,rent_date_from,rent_date_to) - assert amt == 8 - - def test_recal_amount_owed_daily_late(self): - rent_date_from = datetime(2023,1,2) - rent_date_to = rent_date_from + timedelta(days=2) - date_returned = datetime.now() - amt = recal_amount_owed(1,date_returned,rent_date_from,rent_date_to) - assert amt == 32 - - def test_recal_amount_owed_hourly_ontime(self): - rent_date_from = datetime(2023,1,8,7,30,0) - rent_date_to = rent_date_from + timedelta(hours=5) - date_returned = rent_date_to - amt = recal_amount_owed(2,date_returned,rent_date_from,rent_date_to) - assert amt == 12.50 + date_returned = rent_date_to + timedelta(days=4) + new_rent = Rent('816000000','1','1', rent_date_from, rent_date_to, 8, 'RATE', date_returned) + new_rent = recal_amount_owed(new_rent,1,date_returned,rent_date_from,rent_date_to) + assert new_rent.amount_owed == 8 + assert new_rent.late_fees == 16 + - def test_recal_amount_owed_hourly_late(self): - rent_date_from = datetime(2023,1,2,8,0,0) + def test_recal_amount_owed_hourly(self): + period_from = datetime(2022,8,31) + period_to = datetime(2023,7,31) + rent_date_from = datetime(2023,1,8) rent_date_to = rent_date_from + timedelta(hours=2) - date_returned = rent_date_to + timedelta(hours=4) - amt = recal_amount_owed(2,date_returned,rent_date_from,rent_date_to) - assert amt == 15 + date_returned = rent_date_to + timedelta(hours=480) + + rent_type = get_rentType_by_period(period_from,period_to,'Hourly') + if rent_type is None: + rent_type = new_rentType(period_from,period_to,'Hourly',2.50) + new_rent = Rent('816000000','1','1', rent_date_from, rent_date_to, 5,'RATE' , date_returned) + new_rent = recal_amount_owed(new_rent,rent_type.id,date_returned,rent_date_from,rent_date_to) + assert new_rent.amount_owed == 5 + assert new_rent.late_fees == 1200 - def test_recal_amount_owed_weekly_ontime(self): + def test_recal_amount_owed_weekly(self): + period_from = datetime(2022,8,31) + period_to = datetime(2023,7,31) rent_date_from = datetime(2023,1,8) - rent_date_to = rent_date_from + timedelta(days=7) - date_returned = rent_date_to - amt = recal_amount_owed(5,date_returned,rent_date_from,rent_date_to) - assert amt == 8 + rent_date_to = rent_date_from + timedelta(days=3) + date_returned = rent_date_to + timedelta(days=41) + rent_type = get_rentType_by_period(period_from,period_to,'Daily') + if rent_type is None: + rent_type = new_rentType(period_from,period_to,'Daily',4) + new_rent = Rent('816000000','1',rent_type.id, rent_date_from, rent_date_to, 12,'RATE' , date_returned) + new_rent = recal_amount_owed(new_rent,rent_type.id,date_returned,rent_date_from,rent_date_to) + assert new_rent.amount_owed == 12 + assert new_rent.late_fees == 164 - def test_recal_amount_owed_weekly_late(self): - rent_date_from = datetime(2023,1,2) - rent_date_to = rent_date_from + timedelta(days=21) - date_returned = rent_date_to + timedelta(days=3) - amt = recal_amount_owed(5,date_returned,rent_date_from,rent_date_to) - assert amt == 36 def test_recal_amount_owed_monthly_ontime(self): + period_from = datetime(2022,8,31) + period_to = datetime(2023,7,31) rent_date_from = datetime(2023,1,8) rent_date_to = rent_date_from + timedelta(days=31) - date_returned = datetime.now() - amt = recal_amount_owed(3,date_returned,rent_date_from,rent_date_to) - assert amt == 30 - - def test_recal_amount_owed_monthly_late(self): - rent_date_from = datetime(2023,1,2) - rent_date_to = rent_date_from + timedelta(days=30) - date_returned = rent_date_to + timedelta(days=10) - amt = recal_amount_owed(3,date_returned,rent_date_from,rent_date_to) - assert amt == 70 + date_returned = rent_date_to + timedelta(days=375) + rent_type = get_rentType_by_period(period_from,period_to,'Daily') + if rent_type is None: + rent_type = new_rentType(period_from,period_to,'Daily',4) + new_rent = Rent('816000000','1',rent_type.id, rent_date_from, rent_date_to, 124,'RATE' , date_returned) + new_rent = recal_amount_owed(new_rent,rent_type.id,date_returned,rent_date_from,rent_date_to) + assert new_rent.amount_owed == 124 + assert new_rent.late_fees == 1500 def test_recal_amount_owed_semester_ontime(self): + period_from = datetime(2022,8,31) + period_to = datetime(2023,7,31) rent_date_from = datetime(2023,1,8) rent_date_to = rent_date_from + timedelta(days=93) - date_returned = rent_date_to - amt = recal_amount_owed(4,date_returned,rent_date_from,rent_date_to) - assert amt == 100 - - def test_recal_amount_owed_semester_late(self): - rent_date_from = datetime(2023,1,2) - rent_date_to = rent_date_from + timedelta(days=93) - date_returned = rent_date_to + timedelta(days = 15) - amt = recal_amount_owed(4,date_returned,rent_date_from,rent_date_to) - assert amt == 160 + date_returned = rent_date_to + timedelta(days=375) + rent_type = get_rentType_by_period(period_from,period_to,'SEMESTERMEDIUM') + if rent_type is None: + rent_type = new_rentType(period_from,period_to,'SEMESTERMEDIUM',4) + new_rent = Rent('816000000','1',rent_type.id, rent_date_from, rent_date_to, 100,'FIXED' , date_returned) + new_rent = recal_amount_owed(new_rent,rent_type.id,date_returned,rent_date_from,rent_date_to) + assert new_rent.amount_owed == 100 + assert new_rent.late_fees == 0 def release_rental(self): add_new_student('816000222','Test','Student','ENG','18684998888','test.student@my.uwi.edu') @@ -273,14 +309,131 @@ def test_get_all_rentals(self): rent_period_to = rent_period_from + timedelta(days=5) expected_list = [{ 'id': 1, - 'student_id': 816000111, - 'locker_id':'A1001', + 'student_id': '816000111', + 'keyHistory_id':1, + "additional_fees":0, + 'late_fees':0, 'rent_type':1, - 'rent_date_from':rent_period_from, - 'rent_date_to':rent_period_to, - 'date_returned':None, + 'rent_method':'Rate', + 'rent_date_from':datetime.strftime(rent_period_from,'%Y-%m-%d %H:%M:%S'), + 'rent_date_to':datetime.strftime(rent_period_to,'%Y-%m-%d %H:%M:%S'), + 'date_returned':"", 'amount_owed':20.0, - 'status':Status.OWED + 'status':'Owed' }] actual_list = get_all_rentals() - self.assertListEqual(expected_list,actual_list) \ No newline at end of file + self.assertListEqual(expected_list,actual_list) + + def test_get_rent_by_id(self): + rent_period_from = datetime.now() + rent_period_from = rent_period_from.replace(hour = 8, minute = 0 ,second= 0, microsecond= 0) + rent_period_to = rent_period_from + timedelta(days=5) + rent = get_rent_by_id(1) + assert rent.student_id == '816000111' + assert rent.key_history.id == 1 + assert rent.rent_type == 1 + assert rent.rent_date_from == rent_period_from + assert rent.rent_date_to == rent_period_to + assert rent.date_returned is None + assert rent.amount_owed == 20 + assert rent.status.value == 'Owed' + + def test_get_all_rentals_active(self): + rent_period_from = datetime.now() + rent_period_from = rent_period_from.replace(hour = 8, minute = 0 ,second= 0, microsecond= 0) + rent_period_to = rent_period_from + timedelta(days=5) + rents = get_all_rentals_active() + expected_list = [{ + 'key':'AVAILABLE', + 'keyHistory_id':1, + 'id':1, + 'late_fees':0.0, + 'amount_owed':20.0, + 'additional_fees':0.0, + 'locker_code':'A1001', + 'rent_type':1, + 'rent_date_from':datetime.strftime(rent_period_from,'%Y-%m-%d %H:%M:%S'), + 'rent_date_to':datetime.strftime(rent_period_to,'%Y-%m-%d %H:%M:%S'), + 'date_returned':'', + 'rent_types':'Daily', + 'rent_method':'Rate', + 'status':'Owed', + 'student_id':'816000111', + 'rent_size':'Medium', + }] + self.assertListEqual(expected_list,rents) + + def test_get_all_rentals_inactive(self): + rent_period_from = datetime.now() + rent_period_to = timedelta(days = 30) + rent_period_from + add_new_locker('TESTINACTIVE','Small','FREE','TKEY6',1) + rent = create_rent('180058823','TESTINACTIVE',1,rent_period_from,rent_period_to,'RATE',None) + add_new_transaction(rent.id,'TTD',rent_period_from,rent.amount_owed,'Description','DEBIT') + release_rental(rent.id,rent_period_to) + verify_rental(rent.id) + rents = get_all_rentals_inactive() + expected_list = [{ + 'key':'TKEY6', + 'keyHistory_id':2, + 'id':2, + 'late_fees':0.0, + 'amount_owed':0.0, + 'additional_fees':0.0, + 'locker_code':'TESTINACTIVE', + 'rent_type':1, + 'rent_date_from':datetime.strftime(rent_period_from,'%Y-%m-%d %H:%M:%S'), + 'rent_date_to':datetime.strftime(rent_period_to,'%Y-%m-%d %H:%M:%S'), + 'date_returned':datetime.strftime(rent_period_to,'%Y-%m-%d %H:%M:%S'), + 'rent_types':'Daily', + 'rent_method':'Rate', + 'status':'Verified', + 'student_id':'180058823', + }] + self.assertListEqual(expected_list,rents) + def test_swap_rent(self): + rent_period_from = datetime.now() + rent_period_to = timedelta(days = 30) + rent_period_from + add_new_locker('TESTSWAPRENT1','Small','FREE','TKEY6',1) + add_new_locker('TESTSWAPRENT2','Small','FREE','TKEY7',1) + create_rent('180058823','TESTSWAPRENT1',1,rent_period_from,rent_period_to,'RATE',None) + rent = swap_rent('TESTSWAPRENT1','TESTSWAPRENT2',1,rent_period_from,rent_period_to,'RATE',None) + assert rent.student_id == '180058823' + assert rent.key_history.id == 4 + assert rent.date_returned is None + assert rent.amount_owed == 120 + assert rent.status.value == 'Owed' + + def test_rent_additional_payments(self): + rent = rent_additional_payments(1,30) + assert rent.additional_fees == 30 + + def test_update_rent_values(self): + rent_period_from = datetime.now() + rent_period_to = timedelta(days = 90) + rent_period_from + rent_type = new_rentType(rent_period_from,rent_period_from + timedelta(days=2782),'SEMESTERLARGE',170) + add_new_locker('TESTUPDATERENT','Large','FREE','TKEY9',1) + rent = create_rent('180058823','TESTUPDATERENT',1,rent_period_from,rent_period_to,'RATE',None) + updated_rent = update_rent_values(rent.id,rent_type.id,'FIXED',rent_period_from,rent_period_to,None,0,0) + assert rent.student_id == '180058823' + assert rent.rent_type == rent_type.id + assert rent.rent_method.value == "Period" + assert rent.rent_date_from == rent_period_from + assert rent.rent_date_to == rent_period_to + assert rent.date_returned is None + assert rent.amount_owed == 170 + assert rent.status.value == 'Owed' + + def test_get_transaction(self): + date = datetime.now() + transactions = get_transactions(2,6,1) + expected_list = [{ + 'id': 1, + 'rent_id':2, + 'currency':'TTD', + 'transaction_date':date.date(), + 'amount':120.00, + 'description':'Description', + 'type': 'debit', + 'receipt_number': None + }] + self.assertListEqual(expected_list, transactions['data']) \ No newline at end of file diff --git a/App/tests/test_rentTypes.py b/App/tests/test_rentTypes.py index 7cb2a64..4bccba1 100644 --- a/App/tests/test_rentTypes.py +++ b/App/tests/test_rentTypes.py @@ -1,19 +1,19 @@ import os, pytest, logging, unittest -from models import RentTypes -from models.rentTypes import Types -from main import app -from database import create_db -from controllers import ( +from App.models import RentTypes +from App.models.rentTypes import Types +from App.main import create_app +from App.database import create_db +from App.controllers import ( new_rentType, delete_rent_type, get_All_rentType, - get_rentType_daily_period, get_rentType_by_id, update_rentType_period, update_rentType_price, update_rentType_type, ) from datetime import datetime +from wsgi import app LOGGER = logging.getLogger(__name__) @@ -30,23 +30,24 @@ def test_new_rentType(self): def test_new_rentType(self): period_from = datetime(2021,8,31) period_to = datetime(2022,7,31) - new_rentType = RentTypes(period_from,period_to,'Semester',400) + new_rentType = RentTypes(period_from,period_to,'SEMESTERMEDIUM',400) expected_json = { 'id':None, - 'period_from': period_from, - 'period_to': period_to, - 'type':'Semester', + 'period_from': datetime.strftime(period_from,'%Y-%m-%d'), + 'period_to': datetime.strftime(period_to,'%Y-%m-%d'), + 'type': 'Semester Medium', 'price':400 } self.assertDictEqual(expected_json,new_rentType.toJSON()) @pytest.fixture(autouse=True, scope="class") def empty_db(): + os.unlink(os.getcwd()+"/App/py_test.db") app.config.update({'TESTING': True, 'SQLALCHEMY_DATABASE_URI': 'sqlite:///py_test.db'}) create_db(app) yield app.test_client() - os.unlink(os.getcwd()+"//py_test.db") + class RentTypeIntegerationTest(unittest.TestCase): def test_new_rentType(self): @@ -58,21 +59,6 @@ def test_new_rentType(self): assert new_Type.period_from == period_from.date() assert new_Type.period_to == period_to.date() assert new_Type.price == 4 - - def test_rentType_daily_period(self): - period_from = datetime(2022,8,31) - period_to = datetime(2023,7,31) - result = get_rentType_daily_period(period_from.date(),period_to.date()) - assert result.type.value == "Daily" - assert result.period_from == period_from.date() - assert result.period_to == period_to.date() - assert result.price == 4 - - def test_rentType_daily_period_invalid(self): - period_from = datetime(2024,12,31) - period_to = datetime(1999,1,31) - result = get_rentType_daily_period(period_from,period_to) - self.assertIsNone(result) def test_update_rentType_price(self): result = update_rentType_price(1,8) @@ -103,23 +89,11 @@ def update_rentType_type_z_daily(self): result = update_rentType_type(1,'Daily') assert result.type == Types.DAILY - def update_rentType_type_weekly(self): - result = update_rentType_type(1,'Weekly') - assert result.type == Types.WEEKLY - - def update_rentType_type_month(self): - result = update_rentType_type(1,'Month') - assert result.type == Types.MONTH - - def update_rentType_type_semester(self): - result = update_rentType_type(1,'Semester') - assert result.type == Types.HOURLY - def test_rentType_delete(self): period_from = datetime(2022,8,31) period_to = datetime(2023,7,31) - new_rentType(period_from,period_to,'Semester',4) - result = delete_rent_type(2) + rent = new_rentType(period_from,period_to,'Daily',4) + result = delete_rent_type(rent.id) self.assertIsNotNone(result) self.assertIsNone(get_rentType_by_id(2)) @@ -132,15 +106,10 @@ def test_rentType_get_all(self): period_to = datetime(2023,7,31) expectedList =[{ 'id':1, - 'period_from': period_from.date(), - 'period_to': period_to.date(), + 'period_from': datetime.strftime(period_from,'%Y-%m-%d'), + 'period_to': datetime.strftime(period_to,'%Y-%m-%d'), 'type':'Daily', 'price':4 }] self.assertListEqual(expectedList, get_All_rentType()) - - - - - diff --git a/App/tests/test_student.py b/App/tests/test_student.py index 2a86b27..48d64e2 100644 --- a/App/tests/test_student.py +++ b/App/tests/test_student.py @@ -1,17 +1,30 @@ import os, pytest, logging, unittest,tempfile -from models import Student -from controllers import ( +from App.models import Student +from App.controllers import ( add_new_student, + add_new_area, + add_new_locker, + new_rentType, + create_rent, + get_available_student, get_student_by_id, + get_students_by_offset, get_student_by_id_json, + get_student_current_rental, + get_rental_student, get_all_students, + search_student, update_student_first_name, + update_student_email, update_student_last_name, update_student_phone_number, + update_student_status, update_student_faculty ) -from main import app -from database import create_db,get_migrate +from App.main import create_app +from App.database import create_db,get_migrate +from wsgi import app +from datetime import datetime,timedelta LOGGER = logging.getLogger(__name__) @@ -39,19 +52,20 @@ def test_new_student_toJSON(self): self.assertDictEqual(expected_json,new_student.toJSON()) -@pytest.fixture(autouse=True, scope="class") +@pytest.fixture(autouse=True, scope="module") def empty_db(): + os.unlink(os.getcwd()+"/App/py_test.db") app.config.update({'TESTING': True, 'SQLALCHEMY_DATABASE_URI': 'sqlite:///py_test.db'}) create_db(app) yield app.test_client() - os.unlink(os.getcwd()+"//py_test.db") + class StudentIntegrationTest(unittest.TestCase): def test_add_student(self): add_new_student('816000111','Remmy','Dreamer','FST','18684981333','remmy.dreamer@my.uwi.edu') - result = get_student_by_id(816000111) - assert result.student_id == 816000111 + result = get_student_by_id('816000111') + assert result.student_id == '816000111' assert result.first_name == 'Remmy' assert result.last_name == 'Dreamer' assert result.faculty == 'FST' @@ -60,9 +74,9 @@ def test_add_student(self): def test_get_student_by_id_json(self): add_new_student('816000111','Remmy','Dreamer','FST','18684981333','remmy.dreamer@my.uwi.edu') - result = get_student_by_id_json(816000111) + result = get_student_by_id_json('816000111') expected_json = { - 'student_id':816000111, + 'student_id':'816000111', 'first_name':'Remmy', 'last_name': 'Dreamer', 'faculty':'FST', @@ -73,7 +87,7 @@ def test_get_student_by_id_json(self): self.assertDictEqual(expected_json,result) def test_get_student_by_id_json_invalid(self): - result = get_student_by_id_json(816000000) + result = get_student_by_id_json('816000000') self.assertIsNone(None,result) def test_update_student_fName(self): @@ -89,7 +103,7 @@ def test_update_student_fName_invalid(self): def test_update_student_lName(self): add_new_student('816000111','Remmy','Dreamer','FST','18684981333','remmy.dreamer@my.uwi.edu') update_student_last_name('816000111', 'Sleeper') - result = get_student_by_id(816000111) + result = get_student_by_id('816000111') assert result.last_name == "Sleeper" def test_update_student_lName_invalid(self): @@ -99,7 +113,7 @@ def test_update_student_lName_invalid(self): def test_update_student_phone_number(self): add_new_student('816000111','Remmy','Dreamer','FST','18684981333','remmy.dreamer@my.uwi.edu') update_student_phone_number('816000111', 18681112222) - result = get_student_by_id(816000111) + result = get_student_by_id('816000111') assert result.phone_number == '18681112222' def test_update_student_phone_number_invalid(self): @@ -109,17 +123,34 @@ def test_update_student_phone_number_invalid(self): def test_update_student_faculty(self): add_new_student('816000111','Remmy','Dreamer','FST','18684981333','remmy.dreamer@my.uwi.edu') update_student_faculty('816000111', 'ENG') - result = get_student_by_id(816000111) + result = get_student_by_id('816000111') assert result.faculty == 'ENG' def test_update_student_lName_invalid(self): result = update_student_faculty('81600000', 'ENG') self.assertIsNone (result) + + def test_update_student_email(self): + add_new_student('812345678','Test','Student','AAA','18680001111','falseemail@my.uwi.edu') + student = update_student_email('812345678','test.student@my.uwi.edu') + assert student.student_id == '812345678' + assert student.email == 'test.student@my.uwi.edu' + + def test_update_student_status(self): + student = add_new_student('0101010','Space','Time','AAA','18681111111','spacetime@my.uwi.edu') + assert student.rentStanding.value == "GOOD" + student = update_student_status('0101010','Renting') + assert student.rentStanding.value == "RENTING" + student = update_student_status('0101010','Overdue') + assert student.rentStanding.value == "OVERDUE" + student = update_student_status('0101010','Owed') + assert student.rentStanding.value == "OWED" + def test_get_all_students(self): result = get_all_students() expected_list = [{ - 'student_id':816000111, + 'student_id':'816000111', 'first_name':'Remmy', 'last_name': 'Dreamer', 'faculty':'FST', @@ -129,8 +160,176 @@ def test_get_all_students(self): }] self.assertListEqual(expected_list,result) + def test_get_available_student(self): + add_new_student('00001111','Emmy','Style','AAA','18689998888','emmy.style@my.uwi.edu') + add_new_student('22221111','George','Style','AAA','18689998888','gstyle@my.uwi.edu') + update_student_status('00001111','Overdue') + update_student_status('22221111','RENTING') + students = get_available_student(6,1) + expected_json = {'num_pages':1, 'data':[{ + 'student_id':'816000111', + 'first_name':'Remmy', + 'last_name': 'Dreamer', + 'faculty':'FST', + 'phone_number':'18684981333', + 'email': 'remmy.dreamer@my.uwi.edu', + 'rentStanding' :'GOOD' + },{ + 'student_id':'22221111', + 'first_name':'George', + 'last_name': 'Style', + 'faculty':'AAA', + 'phone_number':'18689998888', + 'email': 'gstyle@my.uwi.edu', + 'rentStanding' :'RENTING' + }]} + self.assertDictEqual(expected_json,students) + def test_get_students_by_offset(self): + students = get_students_by_offset(2,1) + expected_json = {'num_pages':4, 'data':[{ + 'student_id':'816000111', + 'first_name':'Remmy', + 'last_name': 'Dreamer', + 'faculty':'FST', + 'phone_number':'18684981333', + 'email': 'remmy.dreamer@my.uwi.edu', + 'rentStanding' :'GOOD' + },{ + 'student_id':'00001111', + 'first_name':'Emmy', + 'last_name': 'Style', + 'faculty':'AAA', + 'phone_number':'18689998888', + 'email': 'emmy.style@my.uwi.edu', + 'rentStanding' :'OVERDUE' + }]} + self.assertDictEqual(expected_json,students) + + def test_search_student(self): + search_f_name = search_student('Emmy',1,2) + search_l_name =search_student('Style',2,1) + search_id = search_student('816000111',3,1) + search_faculty = search_student('AAA',3,1) + search_email = search_student('@my.uwi.edu',3,1) + search_phone = search_student('18689998888',3,1) + search_rent_standing = search_student('GOOD',1,1) + expected_json1 = {'num_pages':2, 'data':[{ + 'student_id':'00001111', + 'first_name':'Emmy', + 'last_name': 'Style', + 'faculty':'AAA', + 'phone_number':'18689998888', + 'email': 'emmy.style@my.uwi.edu', + 'rentStanding' :'OVERDUE' + }]} + expected_json2 = {'num_pages':1, 'data':[{ + 'student_id':'00001111', + 'first_name':'Emmy', + 'last_name': 'Style', + 'faculty':'AAA', + 'phone_number':'18689998888', + 'email': 'emmy.style@my.uwi.edu', + 'rentStanding' :'OVERDUE' + },{ + 'student_id':'22221111', + 'first_name':'George', + 'last_name': 'Style', + 'faculty':'AAA', + 'phone_number':'18689998888', + 'email': 'gstyle@my.uwi.edu', + 'rentStanding' :'RENTING' + }]} + + expected_json3 = {'num_pages':1, 'data':[{ + 'student_id':'816000111', + 'first_name':'Remmy', + 'last_name': 'Dreamer', + 'faculty':'FST', + 'phone_number':'18684981333', + 'email': 'remmy.dreamer@my.uwi.edu', + 'rentStanding' :'GOOD' + }]} + expected_json4 = {'num_pages':1, 'data':[{ + 'student_id':'816000111', + 'first_name':'Remmy', + 'last_name': 'Dreamer', + 'faculty':'FST', + 'phone_number':'18684981333', + 'email': 'remmy.dreamer@my.uwi.edu', + 'rentStanding' :'GOOD' + },{ + 'student_id':'00001111', + 'first_name':'Emmy', + 'last_name': 'Style', + 'faculty':'AAA', + 'phone_number':'18689998888', + 'email': 'emmy.style@my.uwi.edu', + 'rentStanding' :'OVERDUE' + },{ + 'student_id':'22221111', + 'first_name':'George', + 'last_name': 'Style', + 'faculty':'AAA', + 'phone_number':'18689998888', + 'email': 'gstyle@my.uwi.edu', + 'rentStanding' :'RENTING' + }]} + self.assertDictEqual(expected_json1, search_f_name) + self.assertDictEqual(expected_json2, search_l_name) + self.assertDictEqual(expected_json3, search_id) + self.assertDictEqual(expected_json2, search_faculty) + self.assertDictEqual(expected_json2, search_phone) + self.assertDictEqual(expected_json4, search_email) + self.assertDictEqual(expected_json3, search_rent_standing) + def test_get_current_rental_student(self): + area = add_new_area('ENG', 12, 20) + add_new_student('845454545','Test','StudentRent','FSS','18005882300','test.StudenntRent@my.gmail.edu') + add_new_locker('A1001','MEDIUM','FREE','AVAILABLE',area.id) + period_from = datetime(2022,8,31) + period_to = datetime(2023,7,31) + rent_type = new_rentType(period_from,period_to,'Daily',4) + rent_period_from = datetime.now() + rent_period_from = rent_period_from.replace(hour = 8, minute = 0 ,second= 0, microsecond= 0) + rent_period_to = rent_period_from + timedelta(days=5) + create_rent('845454545','A1001',1,rent_period_from,rent_period_to, 'RATE', None) + rental = get_student_current_rental('845454545') + expected_json = { + 'id': 1, + 'student_id': '845454545', + 'keyHistory_id':1, + 'rent_type':1, + 'rent_date_from':datetime.strftime(rent_period_from,'%Y-%m-%d %H:%M:%S'), + 'rent_date_to':datetime.strftime(rent_period_to,'%Y-%m-%d %H:%M:%S'), + 'rent_method': 'Rate', + 'date_returned':'', + 'additional_fees': 0.0, + 'late_fees' : 0.0, + 'amount_owed':20.00, + 'status': 'Owed' + } + self.assertDictEqual(expected_json,rental) + + def test_get_rental_student(self): + rent_period_from = datetime.now() + rent_period_from = rent_period_from.replace(hour = 8, minute = 0 ,second= 0, microsecond= 0) + rent_period_to = rent_period_from + timedelta(days=5) + rental = get_rental_student('845454545',6,1) + expected_json = {'num_pages':1, 'data':[{ 'id': 1, + 'student_id': '845454545', + 'keyHistory_id':1, + 'rent_type':1, + 'rent_date_from':datetime.strftime(rent_period_from,'%Y-%m-%d %H:%M:%S'), + 'rent_date_to':datetime.strftime(rent_period_to,'%Y-%m-%d %H:%M:%S'), + 'rent_method': 'Rate', + 'date_returned':'', + 'additional_fees': 0.0, + 'late_fees' : 0.0, + 'amount_owed':20.00, + 'status': 'Owed'}] + } + self.assertDictEqual(expected_json,rental) diff --git a/App/tests/test_transactionLog.py b/App/tests/test_transactionLog.py index 6c8be27..0f17fe6 100644 --- a/App/tests/test_transactionLog.py +++ b/App/tests/test_transactionLog.py @@ -1,15 +1,25 @@ import os, pytest, logging, unittest -from models import TransactionLog,Rent,RentTypes -from main import app -from database import create_db -from datetime import datetime -from controllers import ( +from App.models import TransactionLog,Rent,RentTypes +from App.main import create_app +from App.database import create_db +from datetime import datetime, timedelta +from App.controllers import ( add_new_transaction, + get_transactions_by_offset, get_transaction_id, get_transaction_json, get_all_transactions, - getT_Type + getT_Type, + new_key, + new_masterkey, + add_new_area, + add_new_locker, + add_new_student, + new_rentType, + search_transaction, + create_rent ) +from wsgi import app LOGGER = logging.getLogger(__name__) @@ -35,21 +45,31 @@ def test_new_Transaction_toJSON(self): 'transaction_date':date, 'amount':40.00, 'description':'Overdue Payment', - 'type': 'debit' + 'type': 'debit', + 'receipt_number': None } self.assertDictEqual(expected_json,new_trans.toJSON()) -@pytest.fixture(autouse=True, scope="class") +@pytest.fixture(autouse=True, scope="module") def empty_db(): + os.unlink(os.getcwd()+"/App/py_test.db") app.config.update({'TESTING': True, 'SQLALCHEMY_DATABASE_URI': 'sqlite:///py_test.db'}) create_db(app) yield app.test_client() - os.unlink(os.getcwd()+"//py_test.db") + class TransactionLogIntegrationTest(unittest.TestCase): - def test_add_transaction(self): + def test_add_transaction(self): date = datetime.now() - transaction = add_new_transaction('1','TTD',date,'100', 'Downpayment','DEBIT') + masterkey = new_masterkey('test101','series','lock',date) + key = new_key('k101','test101','Free',date) + area = add_new_area('description', 10, 12) + locker = add_new_locker('locker101','Small','Free','k101',area.id) + student = add_new_student('816024666', 'Chris', 'Rock', 'FST','18681234567','chrisrock@myuwi.edu') + rentType = new_rentType(date, timedelta(days = 2555) + date, 'SemesterSmall', 5) + rent = create_rent('816024666', 'locker101',rentType.id, date, timedelta(weeks = 8) + date,'fixed',None) + transaction = add_new_transaction(rent.id,'TTD',date,'100', 'Downpayment','DEBIT') + print(transaction) self.assertIsNotNone(transaction) new_trans = get_transaction_id(1) assert new_trans.rent_id == 1 @@ -70,7 +90,8 @@ def test_get_Transaction_by_id_json(self): 'transaction_date':date.date(), 'amount':100.00, 'description':'Downpayment', - 'type': 'debit' + 'type': 'debit', + 'receipt_number': None } self.assertDictEqual(expected_json,result) @@ -86,7 +107,8 @@ def test_get_all_transactions(self): 'transaction_date':date.date(), 'amount':100.00, 'description':'Downpayment', - 'type': 'debit' + 'type': 'debit', + 'receipt_number': None }] self.assertListEqual(expected_list,result) @@ -96,3 +118,45 @@ def test_get_TransactionType(self): result = getT_Type() self.assertListEqual(expected_list,result) + def test_search_transaction(self): + search_id = search_transaction(1,6,1) + search_student = search_transaction('816024666',6,1) + search_amount = search_transaction(100,6,1) + search_tType = search_transaction('debit', 6, 1) + + date = datetime.now() + expected_list = [{ + 'id': 1, + 'rent_id':1, + 'currency':'TTD', + 'transaction_date':date.date(), + 'amount':100.00, + 'description':'Downpayment', + 'type': 'debit', + 'receipt_number': None + }] + self.assertIsNotNone(search_id) + self.assertIsNotNone(search_student) + self.assertIsNotNone(search_amount) + self.assertIsNotNone(search_tType) + self.assertListEqual(expected_list,search_id['data']) + self.assertListEqual(expected_list,search_student['data']) + self.assertListEqual(expected_list,search_amount['data']) + self.assertListEqual(expected_list,search_tType['data']) + + def test_get_transaction_by_offset(self): + date = datetime.now() + transactions = get_transactions_by_offset(6,1) + expected_list = [{ + 'id': 1, + 'rent_id':1, + 'currency':'TTD', + 'transaction_date':date.date(), + 'amount':100.00, + 'description':'Downpayment', + 'type': 'debit', + 'receipt_number': None + }] + self.assertListEqual(expected_list,transactions) + + diff --git a/App/tests/tests/__init__.py b/App/tests/tests/__init__.py deleted file mode 100644 index 6014748..0000000 --- a/App/tests/tests/__init__.py +++ /dev/null @@ -1 +0,0 @@ -#from .test_app import * \ No newline at end of file diff --git a/App/tests/tests/test_app.py b/App/tests/tests/test_app.py deleted file mode 100644 index 773234a..0000000 --- a/App/tests/tests/test_app.py +++ /dev/null @@ -1,77 +0,0 @@ -import os, tempfile, pytest, logging, unittest -from werkzeug.security import check_password_hash, generate_password_hash - -from main import create_app -from database import create_db -from models import User -from controllers import ( - create_user, - get_all_users_json, - authenticate, - get_user, - get_user_by_username, - update_user -) - -from wsgi import app - - -LOGGER = logging.getLogger(__name__) - -''' - Unit Tests -''' -class UserUnitTests(unittest.TestCase): - - def test_new_user(self): - user = User("bob", "bobpass") - assert user.username == "bob" - - def test_toJSON(self): - user = User("bob", "bobpass") - user_json = user.toJSON() - self.assertDictEqual(user_json, {"id":None, "username":"bob"}) - - def test_hashed_password(self): - password = "mypass" - hashed = generate_password_hash(password, method='sha256') - user = User("bob", password) - assert user.password != password - - def test_check_password(self): - password = "mypass" - user = User("bob", password) - assert user.check_password(password) - -''' - Integration Tests -''' - -# This fixture creates an empty database for the test and deletes it after the test -# scope="class" would execute the fixture once and resued for all methods in the class -@pytest.fixture(autouse=True, scope="module") -def empty_db(): - app.config.update({'TESTING': True, 'SQLALCHEMY_DATABASE_URI': 'sqlite:///test.db'}) - create_db(app) - yield app.test_client() - os.unlink(os.getcwd()+'/App/test.db') - - -def test_authenticate(): - user = create_user("bob", "bobpass") - assert authenticate("bob", "bobpass") != None - -class UsersIntegrationTests(unittest.TestCase): - - def test_create_user(self): - user = create_user("rick", "bobpass") - assert user.username == "rick" - - def test_get_all_users_json(self): - users_json = get_all_users_json() - self.assertListEqual([{"id":1, "username":"bob"}, {"id":2, "username":"rick"}], users_json) - - def test_update_user(self): - update_user(1, "ronnie") - user = get_user(1) - assert user.username == "ronnie" diff --git a/App/tests/tests/test_area.py b/App/tests/tests/test_area.py deleted file mode 100644 index 889d1f4..0000000 --- a/App/tests/tests/test_area.py +++ /dev/null @@ -1,119 +0,0 @@ -import os, pytest, logging, unittest -from main import app -from database import create_db -from models import Locker, Area -from controllers import ( - add_new_area, - delete_area, - get_area_by_id, - get_area_all, - set_description, - set_latitude, - set_longitude, -) - -LOGGER = logging.getLogger(__name__) - -class AreaUnitTests(unittest.TestCase): - def test_new_area(self): - new_locker = Locker('A1001','MEDIUM','FREE','AVAILABLE') - new_area = Area(new_locker.locker_code,'A locker description',10.283759,-61.404937) - assert new_area.locker_id == 'A1001' - assert new_area.longitude == 10.283759 - assert new_area.latitude == -61.404937 - assert new_area.description == 'A locker description' - - def test_new_area_toJSON(self): - new_locker = Locker('A2010','SMALL','RENTED','UNAVAILABLE') - new_area = Area(new_locker.locker_code,'A locker description',10.259674,-61.411548) - - expected_json = { - 'id':None, - 'locker_id':'A2010', - 'description':'A locker description', - 'longitude': 10.259674, - 'latitude': -61.411548 - } - self.assertDictEqual(expected_json,new_area.toJSON()) - -@pytest.fixture(autouse=True, scope="class") -def empty_db(): - app.config.update({'TESTING': True, 'SQLALCHEMY_DATABASE_URI': 'sqlite:///py_test.db'}) - create_db(app) - yield app.test_client() - os.unlink(os.getcwd()+"//py_test.db") - -class AreaIntegratedTests (unittest.TestCase): - def test_add_new_area(self): - new_area = add_new_area('A1001','A locker description',10.283759,-61.404937) - assert new_area.id == 1 - assert new_area.locker_id == 'A1001' - assert new_area.longitude == 10.283759 - assert new_area.latitude == -61.404937 - assert new_area.description == 'A locker description' - - def test_add_new_area_duplicate(self): - new_area = add_new_area('A1001','A locker description',10.283759,-61.404937) - self.assertIsNone(new_area) - - def test_get_area_by_id(self): - area = get_area_by_id(1) - assert area.id == 1 - assert area.locker_id == 'A1001' - assert area.longitude == 10.283759 - assert area.latitude == -61.404937 - assert area.description == 'A locker description' - - def test_get_area_by_id_invalid(self): - area = get_area_by_id(0) - self.assertIsNone(area) - - def test_set_description(self): - area = set_description(1,'A new locker description') - assert area.description == 'A new locker description' - - def test_set_description_invalid(self): - area = set_description(0,'A invalid locker description') - self.assertIsNone(area) - - def test_set_latitude(self): - area = set_latitude(1,9.47893) - assert area.latitude == 9.47893 - - def test_set_latitude_invalid(self): - area = set_latitude(0,9.47893) - self.assertIsNone(area) - - def test_set_longitude(self): - area = set_longitude(1,-99.40400) - assert area.longitude == -99.40400 - - def test_set_longitude_invalid(self): - area = set_longitude(0,-99.40400) - self.assertIsNone(area) - - def test_delete_area(self): - add_new_area('A1111','A locker description',45.85739, -25.45543) - area = delete_area(2) - self.assertIsNotNone(area) - self.assertIsNone(get_area_by_id(2)) - - def test_delete_area_invalid(self): - area = delete_area(2) - self.assertIsNone(area) - - def test_get_all_area(self): - results = get_area_all() - expectedList = [{ - 'id':1, - 'locker_id':'A1001', - 'description':'A locker description', - 'longitude': 10.283759, - 'latitude': -61.404937 - }] - self.assertListEqual(expectedList,results) - - - - - diff --git a/App/tests/tests/test_lockers.py b/App/tests/tests/test_lockers.py deleted file mode 100644 index 16b0ca0..0000000 --- a/App/tests/tests/test_lockers.py +++ /dev/null @@ -1,186 +0,0 @@ -import os, pytest, logging, unittest -from main import app -from database import create_db -from models import Locker -from models.locker import Status,Key,LockerTypes -from controllers import ( - add_new_locker, - get_lockers_available, - get_locker_id, - get_all_lockers, - getLockerTypes, - getStatuses, - getKey, - rent_locker, - release_locker, - delete_locker, - update_key, - update_locker_type, - update_locker_status -) - -LOGGER = logging.getLogger(__name__) - -class LockerUnitTests(unittest.TestCase): - - def test_new_locker(self): - new_locker = Locker('A1001','MEDIUM','FREE','AVAILABLE') - assert new_locker.locker_code =='A1001' - assert new_locker.locker_type.value == 'Medium' - assert new_locker.status.value == 'Free' - assert new_locker.key.value == 'Available' - - def test_new_locker_toJSON(self): - new_locker = Locker('A2010','SMALL','RENTED','UNAVAILABLE') - - expected_json = { - 'locker_code':'A2010', - 'locker_type':'Small', - 'status':'Rented', - 'key': 'Unavailable', - 'area': [] - } - self.assertDictEqual(new_locker.toJSON(),expected_json) - -@pytest.fixture(autouse=True, scope="class") -def empty_db(): - app.config.update({'TESTING': True, 'SQLALCHEMY_DATABASE_URI': 'sqlite:///py_test.db'}) - create_db(app) - yield app.test_client() - os.unlink(os.getcwd()+"//py_test.db") - -class LockerIntegrationTests(unittest.TestCase): - def test_add_new_locker(self): - new_locker = add_new_locker('A1001','MEDIUM','FREE','AVAILABLE') - self.assertIsNotNone(new_locker) - assert new_locker.locker_code =='A1001' - assert new_locker.locker_type.value == 'Medium' - assert new_locker.status.value == 'Free' - assert new_locker.key.value == 'Available' - - def test_add_new_locker_duplicate(self): - new_locker = add_new_locker('A1001','MEDIUM','FREE','AVAILABLE') - self.assertIsNone(new_locker) - - def test_get_available_lockers(self): - result = get_lockers_available() - expected_list = [{ - 'locker_code':'A1001', - 'locker_type':'Medium', - 'status':'Free', - 'key': 'Available', - 'area': [] - }] - self.assertListEqual(expected_list, result) - - def test_get_all_lockers(self): - result = get_all_lockers() - expected_list = [{ - 'locker_code':'A1001', - 'locker_type':'Medium', - 'status':'Free', - 'key': 'Available', - 'area': [] - }] - self.assertListEqual(expected_list, result) - - def test_rent_locker(self): - result = rent_locker('A1001') - self.assertTrue(result) - locker = get_locker_id('A1001') - assert locker.status == Status.RENTED - - def test_rent_locker_rented(self): - result = rent_locker('A1001') - self.assertIsNone(result) - - def test_rent_locker_invalid(self): - result = rent_locker('A1241') - self.assertIsNone(result) - - def test_release_locker(self): - result = release_locker('A1001') - self.assertTrue(result) - locker = get_locker_id('A1001') - assert locker.status == Status.FREE - - def test_release_locker_invalid(self): - result = release_locker('A1241') - self.assertIsNone(result) - - def test_delete_locker(self): - add_new_locker('A1111','COMBINATION','RENTED','UNAVAILABLE') - locker = delete_locker('A1111') - self.assertIsNotNone(locker) - self.assertIsNone(get_locker_id('A1111')) - - def test_delete_locker_invalid(self): - result = delete_locker('A1241') - self.assertIsNone(result) - - def test_update_key_unavailble(self): - locker = update_key('A1001','Unavailable') - assert locker.key == Key.UNAVAILABLE - - def test_update_key_Lost(self): - locker = update_key('A1001','Lost') - assert locker.key == Key.LOST - - def test_update_key_available(self): - locker = update_key('A1001','available') - assert locker.key == Key.AVAILABLE - - def test_update_key_invalidLocker(self): - locker = update_key('A1111','Unavailable') - self.assertIsNone(locker) - - def test_update_key_invalidKeyStatus(self): - locker = update_key('A1001','Not available') - self.assertIsNone(locker) - - def test_update_locker_type_small(self): - locker = update_locker_type('A1001','Small') - assert locker.locker_type == LockerTypes.SMALL - - def test_update_locker_type_combination(self): - locker = update_locker_type('A1001','Combination') - assert locker.locker_type == LockerTypes.COMBINATION - - def test_update_locker_type_medium(self): - locker = update_locker_type('A1001','Medium') - assert locker.locker_type == LockerTypes.MEDIUM - - def test_update_locker_type_invalid(self): - locker = update_locker_type('A1001','Large') - self.assertIsNone(locker) - - def test_update_locker_status_rented (self): - locker = update_locker_status('A1001','Rented') - assert locker.status == Status.RENTED - - def test_update_locker_status_repair (self): - locker = update_locker_status('A1001','Repair') - assert locker.status == Status.REPAIR - - def test_update_locker_status_free (self): - locker = update_locker_status('A1001','Free') - assert locker.status == Status.FREE - - def test_update_locker_status_invalid (self): - locker = update_locker_status('A1001','Broken') - self.assertIsNone(locker) - - def test_getStatuses(self): - expectedList =['Rented','Repair','Free'] - result = getStatuses() - self.assertListEqual(expectedList,result) - - def test_getLockerTypes(self): - expectedList =['Small','Medium','Combination'] - result = getLockerTypes() - self.assertListEqual(expectedList,result) - - def test_getKey(self): - expectedList =['Available','Unavailable','Lost'] - result = getKey() - self.assertListEqual(expectedList,result) \ No newline at end of file diff --git a/App/tests/tests/test_rent.py b/App/tests/tests/test_rent.py deleted file mode 100644 index e85c00c..0000000 --- a/App/tests/tests/test_rent.py +++ /dev/null @@ -1,286 +0,0 @@ -import os, pytest, logging, unittest -from database import create_db -from main import app -from models import RentTypes,Rent,TransactionLog -from controllers import ( - add_new_transaction, - create_rent, - init_amount_owed, - add_new_locker, - add_new_student, - get_all_rentals, - new_rentType, - period_elapsed, - recal_amount_owed, - release_rental -) -from models.rent import Status -from datetime import datetime,timedelta - -LOGGER = logging.getLogger(__name__) - -class RentTypeUnitTests(unittest.TestCase): - def test_new_rent(self): - new_rent = Rent('816000000','A1001','1', datetime(2023,2,15), datetime(2023,2,18),22.50) - assert new_rent.student_id == '816000000' - assert new_rent.locker_id == 'A1001' - assert new_rent.rent_date_from == datetime(2023,2,15) - assert new_rent.rent_date_to == datetime(2023,2,18) - assert new_rent.date_returned == None - assert new_rent.amount_owed == 22.5 - assert new_rent.status.value == "Owed" - - def test_new_rent_overdue(self): - new_rent = Rent('816001110','A1111','1', datetime(2022,2,15), datetime(2022,2,18),22.50) - assert new_rent.student_id == '816001110' - assert new_rent.locker_id == 'A1111' - assert new_rent.rent_date_from == datetime(2022,2,15) - assert new_rent.rent_date_to == datetime(2022,2,18) - assert new_rent.date_returned == None - assert new_rent.amount_owed == 22.5 - assert new_rent.status.value == "Overdue" - - def test_new_rent_paid(self): - new_rent = Rent('816000000','A1001','1', datetime(2023,2,15), datetime(2023,2,18),0) - new_rent.Transactions = [TransactionLog(None,'TTD',datetime(2023,1,1),15,'Description','Debit'),TransactionLog(None,'TTD',datetime(2023,1,5),15,'Description','Debit')] - new_rent.status = new_rent.check_status() - assert new_rent.student_id == '816000000' - assert new_rent.locker_id == 'A1001' - assert new_rent.rent_date_from == datetime(2023,2,15) - assert new_rent.rent_date_to == datetime(2023,2,18) - assert new_rent.date_returned == None - assert new_rent.amount_owed == 0 - assert new_rent.status.value == "Paid" - - def test_new_rent_partial(self): - new_rent = Rent('816000000','A1001','1', datetime(2023,2,15), datetime(2023,2,18),200) - new_rent.Transactions = [TransactionLog(None,'TTD',datetime(2023,1,1),15,'Description','Debit'),TransactionLog(None,'TTD',datetime(2023,1,5),15,'Description','Debit')] - new_rent.status = new_rent.check_status() - assert new_rent.student_id == '816000000' - assert new_rent.locker_id == 'A1001' - assert new_rent.rent_date_from == datetime(2023,2,15) - assert new_rent.rent_date_to == datetime(2023,2,18) - assert new_rent.date_returned == None - assert new_rent.amount_owed == 200 - assert new_rent.status.value == "Partial" - - def test_new_rent_returned(self): - new_rent = Rent('816001110','A1111','1', datetime(2022,2,15), datetime(2022,2,18),0) - new_rent.status = Status.RETURNED - assert new_rent.student_id == '816001110' - assert new_rent.locker_id == 'A1111' - assert new_rent.rent_date_from == datetime(2022,2,15) - assert new_rent.rent_date_to == datetime(2022,2,18) - assert new_rent.date_returned == None - assert new_rent.amount_owed == 0 - assert new_rent.status.value == "Returned" - - def test_new_rent_toJSON(self): - new_rent = Rent('816001110','A1111','1', datetime(2023,2,15), datetime(2023,2,18),22.50) - expected_json = { - 'id': None, - 'student_id': '816001110', - 'locker_id':'A1111', - 'rent_type':'1', - 'rent_date_from':datetime(2023,2,15), - 'rent_date_to':datetime(2023,2,18), - 'date_returned':None, - 'amount_owed':22.5, - 'status':Status.OWED - } - self.assertDictEqual(expected_json,new_rent.toJSON()) - -@pytest.fixture(autouse=True, scope="class") -def empty_db(): - app.config.update({'TESTING': True, 'SQLALCHEMY_DATABASE_URI': 'sqlite:///py_test.db'}) - create_db(app) - yield app.test_client() - os.unlink(os.getcwd()+"//py_test.db") - -class RentIntegratedTest(unittest.TestCase): - def test_create_rent(self): - add_new_student('816000111','Remmy','Dreamer','FST','18684981333','remmy.dreamer@my.uwi.edu') - add_new_locker('A1001','MEDIUM','FREE','AVAILABLE') - - period_from = datetime(2022,8,31) - period_to = datetime(2023,7,31) - new_rentType(period_from,period_to,'Daily',4) - - rent_period_from = datetime.now() - rent_period_from = rent_period_from.replace(hour = 8, minute = 0 ,second= 0, microsecond= 0) - rent_period_to = rent_period_from + timedelta(days=5) - rent = create_rent('816000111','A1001',1,rent_period_from,rent_period_to) - assert rent.student_id == 816000111 - assert rent.locker_id == 'A1001' - assert rent.rent_type == 1 - assert rent.rent_date_from == rent_period_from - assert rent.rent_date_to == rent_period_to - assert rent.date_returned is None - assert rent.amount_owed == 20 - assert rent.status == Status.OWED - - def test_period_elaspsed_daily(self): - rent_date_from = datetime.now() - rent_date_to = rent_date_from + timedelta(18) - time = period_elapsed(1,rent_date_from,rent_date_to) - assert time == 18 - - def test_period_elaspsed_hourly(self): - period_from = datetime(2022,8,31) - period_to = datetime(2023,7,31) - new_rentType(period_from,period_to,'Hourly',2.50) - rent_date_from = datetime.now() - rent_date_to = rent_date_from + timedelta(hours=5) - time = period_elapsed(2,rent_date_from,rent_date_to) - assert time == 5 - - def test_period_elaspsed_t_weekly(self): - period_from = datetime(2022,8,31) - period_to = datetime(2023,7,31) - new_rentType(period_from,period_to,'Weekly',8) - rent_date_from = datetime.now() - rent_date_to = rent_date_from + timedelta(days = 21) - time = period_elapsed(5,rent_date_from,rent_date_to) - assert time == 3 - - def test_period_elaspsed_monthly(self): - period_from = datetime(2022,8,31) - period_to = datetime(2023,7,31) - new_rentType(period_from,period_to,'Monthly',30) - rent_date_from = datetime.now() - rent_date_to = rent_date_from + timedelta(days = 31) - time = period_elapsed(3,rent_date_from,rent_date_to) - assert time == 1 - - def test_period_elaspsed_semester(self): - period_from = datetime(2022,8,31) - period_to = datetime(2023,7,31) - new_rentType(period_from,period_to,'Semester',100) - rent_date_from = datetime.now() - rent_date_to = rent_date_from + timedelta(days = 93) - time = period_elapsed(4,rent_date_from,rent_date_to) - assert time == 1 - - def test_q_init_amount_owed_daily(self): - rent_date_from = datetime.now() - rent_date_to = rent_date_from + timedelta(days=3) - amount = init_amount_owed(1,rent_date_from,rent_date_to) - assert amount == 12 - - def test_q_init_amount_owed_hourly(self): - rent_date_from = datetime.now() - rent_date_to = rent_date_from + timedelta(hours=5) - amount = init_amount_owed(2,rent_date_from,rent_date_to) - assert amount == 12.50 - - def test_q_init_amount_owed_monthly(self): - rent_date_from = datetime.now() - rent_date_to = rent_date_from + timedelta(days=62) - amount = init_amount_owed(3,rent_date_from,rent_date_to) - assert amount == 60 - - def test_q_init_amount_owed_semester(self): - rent_date_from = datetime.now() - rent_date_to = rent_date_from + timedelta(days=93) - amount = init_amount_owed(4,rent_date_from,rent_date_to) - assert amount == 100 - - def test_recal_amount_owed_daily_ontime(self): - rent_date_from = datetime(2023,1,8) - rent_date_to = rent_date_from + timedelta(days=2) - date_returned = datetime.now() - amt = recal_amount_owed(1,date_returned,rent_date_from,rent_date_to) - assert amt == 8 - - def test_recal_amount_owed_daily_late(self): - rent_date_from = datetime(2023,1,2) - rent_date_to = rent_date_from + timedelta(days=2) - date_returned = datetime.now() - amt = recal_amount_owed(1,date_returned,rent_date_from,rent_date_to) - assert amt == 32 - - def test_recal_amount_owed_hourly_ontime(self): - rent_date_from = datetime(2023,1,8,7,30,0) - rent_date_to = rent_date_from + timedelta(hours=5) - date_returned = rent_date_to - amt = recal_amount_owed(2,date_returned,rent_date_from,rent_date_to) - assert amt == 12.50 - - def test_recal_amount_owed_hourly_late(self): - rent_date_from = datetime(2023,1,2,8,0,0) - rent_date_to = rent_date_from + timedelta(hours=2) - date_returned = rent_date_to + timedelta(hours=4) - amt = recal_amount_owed(2,date_returned,rent_date_from,rent_date_to) - assert amt == 15 - - def test_recal_amount_owed_weekly_ontime(self): - rent_date_from = datetime(2023,1,8) - rent_date_to = rent_date_from + timedelta(days=7) - date_returned = rent_date_to - amt = recal_amount_owed(5,date_returned,rent_date_from,rent_date_to) - assert amt == 8 - - def test_recal_amount_owed_weekly_late(self): - rent_date_from = datetime(2023,1,2) - rent_date_to = rent_date_from + timedelta(days=21) - date_returned = rent_date_to + timedelta(days=3) - amt = recal_amount_owed(5,date_returned,rent_date_from,rent_date_to) - assert amt == 36 - - def test_recal_amount_owed_monthly_ontime(self): - rent_date_from = datetime(2023,1,8) - rent_date_to = rent_date_from + timedelta(days=31) - date_returned = datetime.now() - amt = recal_amount_owed(3,date_returned,rent_date_from,rent_date_to) - assert amt == 30 - - def test_recal_amount_owed_monthly_late(self): - rent_date_from = datetime(2023,1,2) - rent_date_to = rent_date_from + timedelta(days=30) - date_returned = rent_date_to + timedelta(days=10) - amt = recal_amount_owed(3,date_returned,rent_date_from,rent_date_to) - assert amt == 70 - - def test_recal_amount_owed_semester_ontime(self): - rent_date_from = datetime(2023,1,8) - rent_date_to = rent_date_from + timedelta(days=93) - date_returned = rent_date_to - amt = recal_amount_owed(4,date_returned,rent_date_from,rent_date_to) - assert amt == 100 - - def test_recal_amount_owed_semester_late(self): - rent_date_from = datetime(2023,1,2) - rent_date_to = rent_date_from + timedelta(days=93) - date_returned = rent_date_to + timedelta(days = 15) - amt = recal_amount_owed(4,date_returned,rent_date_from,rent_date_to) - assert amt == 160 - - def release_rental(self): - add_new_student('816000222','Test','Student','ENG','18684998888','test.student@my.uwi.edu') - add_new_locker('A1231','Small','FREE','AVAILABLE') - rent_period_from = datetime.now() - rent_period_from = rent_period_from.replace(hour = 8, minute = 0 ,second= 0, microsecond= 0) - rent_period_to = rent_period_from + timedelta(days=2) - add_new_transaction(2,'TTD',rent_period_to,4,'Payment','Debit') - create_rent('816000111','A1231',1,rent_period_from,rent_period_to) - rent = release_rental(2,rent_period_to) - self.assertIsNotNone(rent) - assert rent.status == Status.RETURNED - - def test_get_all_rentals(self): - rent_period_from = datetime.now() - rent_period_from = rent_period_from.replace(hour = 8, minute = 0 ,second= 0, microsecond= 0) - rent_period_to = rent_period_from + timedelta(days=5) - expected_list = [{ - 'id': 1, - 'student_id': 816000111, - 'locker_id':'A1001', - 'rent_type':1, - 'rent_date_from':rent_period_from, - 'rent_date_to':rent_period_to, - 'date_returned':None, - 'amount_owed':20.0, - 'status':Status.OWED - }] - actual_list = get_all_rentals() - self.assertListEqual(expected_list,actual_list) \ No newline at end of file diff --git a/App/tests/tests/test_rentTypes.py b/App/tests/tests/test_rentTypes.py deleted file mode 100644 index 7cb2a64..0000000 --- a/App/tests/tests/test_rentTypes.py +++ /dev/null @@ -1,146 +0,0 @@ -import os, pytest, logging, unittest -from models import RentTypes -from models.rentTypes import Types -from main import app -from database import create_db -from controllers import ( - new_rentType, - delete_rent_type, - get_All_rentType, - get_rentType_daily_period, - get_rentType_by_id, - update_rentType_period, - update_rentType_price, - update_rentType_type, -) -from datetime import datetime - -LOGGER = logging.getLogger(__name__) - -class RentTypeUnitTests(unittest.TestCase): - def test_new_rentType(self): - period_from = datetime(2022,8,31) - period_to = datetime(2023,7,31) - new_rentType = RentTypes(period_from,period_to,'Daily',4) - assert new_rentType.period_from == period_from - assert new_rentType.period_to == period_to - assert new_rentType.type == 'Daily' - assert new_rentType.price == 4 - - def test_new_rentType(self): - period_from = datetime(2021,8,31) - period_to = datetime(2022,7,31) - new_rentType = RentTypes(period_from,period_to,'Semester',400) - - expected_json = { - 'id':None, - 'period_from': period_from, - 'period_to': period_to, - 'type':'Semester', - 'price':400 - } - self.assertDictEqual(expected_json,new_rentType.toJSON()) - -@pytest.fixture(autouse=True, scope="class") -def empty_db(): - app.config.update({'TESTING': True, 'SQLALCHEMY_DATABASE_URI': 'sqlite:///py_test.db'}) - create_db(app) - yield app.test_client() - os.unlink(os.getcwd()+"//py_test.db") - -class RentTypeIntegerationTest(unittest.TestCase): - def test_new_rentType(self): - period_from = datetime(2022,8,31) - period_to = datetime(2023,7,31) - new_Type = new_rentType(period_from,period_to,'Daily',4) - self.assertIsNotNone(new_Type) - assert new_Type.id == 1 - assert new_Type.period_from == period_from.date() - assert new_Type.period_to == period_to.date() - assert new_Type.price == 4 - - def test_rentType_daily_period(self): - period_from = datetime(2022,8,31) - period_to = datetime(2023,7,31) - result = get_rentType_daily_period(period_from.date(),period_to.date()) - assert result.type.value == "Daily" - assert result.period_from == period_from.date() - assert result.period_to == period_to.date() - assert result.price == 4 - - def test_rentType_daily_period_invalid(self): - period_from = datetime(2024,12,31) - period_to = datetime(1999,1,31) - result = get_rentType_daily_period(period_from,period_to) - self.assertIsNone(result) - - def test_update_rentType_price(self): - result = update_rentType_price(1,8) - assert result.price == 8 - - def test_update_rentType_price_invalid(self): - result = update_rentType_price(0,800) - self.assertIsNone(result) - - def test_update_rentType_period(self): - period_from = datetime(2021,8,31) - period_to = datetime(2022,7,31) - result = update_rentType_period(1,period_from,period_to) - assert result.period_from == period_from.date() - assert result.period_to == period_to.date() - - def test_update_rentType_period_invalid(self): - period_from = datetime(2021,8,31) - period_to = datetime(2022,7,31) - result = update_rentType_period(0,period_from,period_to) - self.assertIsNone(result) - - def update_rentType_type_hourly(self): - result = update_rentType_type(1,'Hourly') - assert result.type == Types.HOURLY - - def update_rentType_type_z_daily(self): - result = update_rentType_type(1,'Daily') - assert result.type == Types.DAILY - - def update_rentType_type_weekly(self): - result = update_rentType_type(1,'Weekly') - assert result.type == Types.WEEKLY - - def update_rentType_type_month(self): - result = update_rentType_type(1,'Month') - assert result.type == Types.MONTH - - def update_rentType_type_semester(self): - result = update_rentType_type(1,'Semester') - assert result.type == Types.HOURLY - - def test_rentType_delete(self): - period_from = datetime(2022,8,31) - period_to = datetime(2023,7,31) - new_rentType(period_from,period_to,'Semester',4) - result = delete_rent_type(2) - self.assertIsNotNone(result) - self.assertIsNone(get_rentType_by_id(2)) - - def test_rentType_delete_invalid(self): - result = delete_rent_type(45) - self.assertIsNone(result) - - def test_rentType_get_all(self): - period_from = datetime(2022,8,31) - period_to = datetime(2023,7,31) - expectedList =[{ - 'id':1, - 'period_from': period_from.date(), - 'period_to': period_to.date(), - 'type':'Daily', - 'price':4 - }] - - self.assertListEqual(expectedList, get_All_rentType()) - - - - - diff --git a/App/tests/tests/test_student.py b/App/tests/tests/test_student.py deleted file mode 100644 index 2a86b27..0000000 --- a/App/tests/tests/test_student.py +++ /dev/null @@ -1,136 +0,0 @@ -import os, pytest, logging, unittest,tempfile -from models import Student -from controllers import ( - add_new_student, - get_student_by_id, - get_student_by_id_json, - get_all_students, - update_student_first_name, - update_student_last_name, - update_student_phone_number, - update_student_faculty -) -from main import app -from database import create_db,get_migrate - -LOGGER = logging.getLogger(__name__) - -class StudentUnitTests(unittest.TestCase): - def test_new_student(self): - new_student = Student('816000000','Test','Student','FSS','18684993333','test.student@my.uwi.edu') - assert new_student.student_id == '816000000' - assert new_student.first_name == 'Test' - assert new_student.last_name == 'Student' - assert new_student.faculty == 'FSS' - assert new_student.phone_number == '18684993333' - assert new_student.email == 'test.student@my.uwi.edu' - - def test_new_student_toJSON(self): - new_student = Student('816000111','Remmy','Dreamer','FST','18684981333','remmy.dreamer@my.uwi.edu') - expected_json = { - 'student_id':'816000111', - 'first_name':'Remmy', - 'last_name': 'Dreamer', - 'faculty':'FST', - 'phone_number':'18684981333', - 'email': 'remmy.dreamer@my.uwi.edu', - 'rentStanding' :'GOOD' - } - - self.assertDictEqual(expected_json,new_student.toJSON()) - -@pytest.fixture(autouse=True, scope="class") -def empty_db(): - app.config.update({'TESTING': True, 'SQLALCHEMY_DATABASE_URI': 'sqlite:///py_test.db'}) - create_db(app) - yield app.test_client() - os.unlink(os.getcwd()+"//py_test.db") - - -class StudentIntegrationTest(unittest.TestCase): - def test_add_student(self): - add_new_student('816000111','Remmy','Dreamer','FST','18684981333','remmy.dreamer@my.uwi.edu') - result = get_student_by_id(816000111) - assert result.student_id == 816000111 - assert result.first_name == 'Remmy' - assert result.last_name == 'Dreamer' - assert result.faculty == 'FST' - assert result.phone_number == '18684981333' - assert result.email == 'remmy.dreamer@my.uwi.edu' - - def test_get_student_by_id_json(self): - add_new_student('816000111','Remmy','Dreamer','FST','18684981333','remmy.dreamer@my.uwi.edu') - result = get_student_by_id_json(816000111) - expected_json = { - 'student_id':816000111, - 'first_name':'Remmy', - 'last_name': 'Dreamer', - 'faculty':'FST', - 'phone_number':'18684981333', - 'email': 'remmy.dreamer@my.uwi.edu', - 'rentStanding' :'GOOD' - } - self.assertDictEqual(expected_json,result) - - def test_get_student_by_id_json_invalid(self): - result = get_student_by_id_json(816000000) - self.assertIsNone(None,result) - - def test_update_student_fName(self): - add_new_student('816000111','Remmy','Dreamer','FST','18684981333','remmy.dreamer@my.uwi.edu') - update_student_first_name('816000111', 'Rem') - result = get_student_by_id(816000111) - assert result.first_name == "Rem" - - def test_update_student_fName_invalid(self): - result = update_student_first_name('816000111', 'Rem') - self.assertIsNone(result) - - def test_update_student_lName(self): - add_new_student('816000111','Remmy','Dreamer','FST','18684981333','remmy.dreamer@my.uwi.edu') - update_student_last_name('816000111', 'Sleeper') - result = get_student_by_id(816000111) - assert result.last_name == "Sleeper" - - def test_update_student_lName_invalid(self): - result = update_student_last_name('81600000', 'Sleeper') - self.assertIsNone (result) - - def test_update_student_phone_number(self): - add_new_student('816000111','Remmy','Dreamer','FST','18684981333','remmy.dreamer@my.uwi.edu') - update_student_phone_number('816000111', 18681112222) - result = get_student_by_id(816000111) - assert result.phone_number == '18681112222' - - def test_update_student_phone_number_invalid(self): - result = update_student_phone_number('81600000', 18991112222) - self.assertIsNone (result) - - def test_update_student_faculty(self): - add_new_student('816000111','Remmy','Dreamer','FST','18684981333','remmy.dreamer@my.uwi.edu') - update_student_faculty('816000111', 'ENG') - result = get_student_by_id(816000111) - assert result.faculty == 'ENG' - - def test_update_student_lName_invalid(self): - result = update_student_faculty('81600000', 'ENG') - self.assertIsNone (result) - - def test_get_all_students(self): - result = get_all_students() - expected_list = [{ - 'student_id':816000111, - 'first_name':'Remmy', - 'last_name': 'Dreamer', - 'faculty':'FST', - 'phone_number':'18684981333', - 'email': 'remmy.dreamer@my.uwi.edu', - 'rentStanding' :'GOOD' - }] - self.assertListEqual(expected_list,result) - - - - - - diff --git a/App/tests/tests/test_transactionLog.py b/App/tests/tests/test_transactionLog.py deleted file mode 100644 index 6c8be27..0000000 --- a/App/tests/tests/test_transactionLog.py +++ /dev/null @@ -1,98 +0,0 @@ -import os, pytest, logging, unittest -from models import TransactionLog,Rent,RentTypes -from main import app -from database import create_db -from datetime import datetime -from controllers import ( - add_new_transaction, - get_transaction_id, - get_transaction_json, - get_all_transactions, - getT_Type -) - -LOGGER = logging.getLogger(__name__) - -class TransactionLogUnitTests(unittest.TestCase): - def test_new_Transaction(self): - date = datetime.now() - new_trans = TransactionLog(1,'TTD',date,10.00,'Initial Deposit','Debit') - assert new_trans.rent_id == 1 - assert new_trans.currency == 'TTD' - assert new_trans.transaction_date == date - assert new_trans.amount == 10.00 - assert new_trans.description == 'Initial Deposit' - assert new_trans.type.value == 'debit' - - def test_new_Transaction_toJSON(self): - date = datetime.now() - new_trans = TransactionLog(2,'USD',date,40.00,'Overdue Payment','debit') - - expected_json ={ - 'id': None, - 'rent_id':2, - 'currency':'USD', - 'transaction_date':date, - 'amount':40.00, - 'description':'Overdue Payment', - 'type': 'debit' - } - self.assertDictEqual(expected_json,new_trans.toJSON()) - -@pytest.fixture(autouse=True, scope="class") -def empty_db(): - app.config.update({'TESTING': True, 'SQLALCHEMY_DATABASE_URI': 'sqlite:///py_test.db'}) - create_db(app) - yield app.test_client() - os.unlink(os.getcwd()+"//py_test.db") - -class TransactionLogIntegrationTest(unittest.TestCase): - def test_add_transaction(self): - date = datetime.now() - transaction = add_new_transaction('1','TTD',date,'100', 'Downpayment','DEBIT') - self.assertIsNotNone(transaction) - new_trans = get_transaction_id(1) - assert new_trans.rent_id == 1 - assert new_trans.currency == 'TTD' - assert new_trans.transaction_date == date.date() - assert new_trans.amount == 100.00 - assert new_trans.description == 'Downpayment' - assert new_trans.type.value == 'debit' - - def test_get_Transaction_by_id_json(self): - date = datetime.now() - result = get_transaction_json(1) - - expected_json ={ - 'id': 1, - 'rent_id':1, - 'currency':'TTD', - 'transaction_date':date.date(), - 'amount':100.00, - 'description':'Downpayment', - 'type': 'debit' - } - - self.assertDictEqual(expected_json,result) - - def test_get_all_transactions(self): - date = datetime.now() - result = get_all_transactions() - - expected_list = [{ - 'id': 1, - 'rent_id':1, - 'currency':'TTD', - 'transaction_date':date.date(), - 'amount':100.00, - 'description':'Downpayment', - 'type': 'debit' - }] - - self.assertListEqual(expected_list,result) - - def test_get_TransactionType(self): - expected_list = ['credit','debit'] - result = getT_Type() - self.assertListEqual(expected_list,result) - diff --git a/docker-compose.yml b/docker-compose.yml index 3ee9dc9..c6a219c 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -1,5 +1,3 @@ -version: '4.24' - services: web: build: ./ @@ -30,6 +28,15 @@ services: - 15432:80 depends_on: - db + locust: + build: ./ + command: locust + volumes: + - ./:/usr/src/app/ + ports: + - 8089:8089 + depends_on: + - web volumes: diff --git a/locustfile.py b/locustfile.py index 558fa86..a4f5773 100644 --- a/locustfile.py +++ b/locustfile.py @@ -1,11 +1,29 @@ -import time, uuid, random +import time, uuid +from random import random,randint +import sys from locust import User, HttpUser, task, between +from locust.clients import HttpSession class QuickstartUser(HttpUser): - wait_time = between(1, 5) + wait_time = between(0.09, 0.4) - @task(5) - def testLocker(self): + def on_start(self): + self.client.post("/login",data={"username":"bob","password":"bobpass"},headers={"content-type":"application/x-www-form-urlencoded"}) + + def on_end(self): + self.client.cookies.clear() + @task(1) + def testLockerPUT(self): + payload = { + "locker_code":"A104", + "locker_type":"Large", + "area":19, + "status":"Free", + "key":str(randint(10000,11000)), + } + self.client.request('PUT',"/api/locker",json=payload,headers={'Content-Type':'application/json'}) + + """def testLocker(self): self.client.get("/locker") payload = { "locker_code": str(uuid.uuid4()).split("-")[0]+"TEST4", @@ -38,7 +56,7 @@ def testArea(self): @task(4) def testTransactionLog(self): - self.client.get("/transactionLog") + #self.client.get("/transactionLog") @task(3) def testStudent(self): @@ -64,8 +82,8 @@ def testRentType(self): @task(4) def testKey(self): - self.client.get("/key") + #self.client.get("/key") @task(4) def testMasterkey(self): - self.client.get("/masterkey") \ No newline at end of file + #self.client.get("/masterkey")""" \ No newline at end of file diff --git a/wsgi.py b/wsgi.py index e4afe77..1a79043 100644 --- a/wsgi.py +++ b/wsgi.py @@ -114,7 +114,7 @@ def user_tests_command(type): elif type == "int": sys.exit(pytest.main(["-k", "UserIntegrationTests"])) else: - sys.exit(pytest.main(["-k", "App"])) + sys.exit(pytest.main(["-x", "App/tests"])) app.cli.add_command(test) \ No newline at end of file