Adding testing pipline to the testing branch

.github/workflows/testing-pipline.yml

@@ -0,0 +1,134 @@
+name: Integration-test
+
+on:
+  pull_request:
+    paths:
+      - 'CodeListLibrary_project/**'
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  pre-deploy-test:
+    env:
+      working-directory: ./concept-library
+    runs-on:
+      labels: [self-hosted, linux, x64]
+      group: heavy
+    strategy:
+      max-parallel: 4
+      matrix:
+        python-version: [3.11]
+
+    services:
+      db:
+        image: postgres
+        env:
+          POSTGRES_DB: concept_library
+          POSTGRES_USER: clluser_test
+          POSTGRES_PASSWORD: password
+        ports:
+          - 5432:5432
+        options: --health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5
+
+    steps:
+      - uses: actions/checkout@v3
+      - uses: browser-actions/setup-chrome@v1
+      - uses: actions/cache@v3
+        with:
+          path: ~/.cache/pip
+          key: ${{ runner.os }}-pip-${{ hashFiles('docker/requirements/test-requirements.txt') }}
+          restore-keys: |
+            ${{ runner.os }}-pip-
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v3
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install LDAP files
+        run: |
+          sudo apt-get install -y -q libsasl2-dev libldap2-dev libssl-dev
+
+      - name: Install Dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install --upgrade --upgrade-strategy eager -r docker/requirements/test-requirements.txt
+
+      - name: Prepare Selenium
+        uses: nanasess/setup-chromedriver@v2
+      - name: Run Browser
+        run: |
+          chrome --version
+      - name: Run chromedriver
+        run: |
+          export DISPLAY=:99
+          chromedriver --url-base=/wd/hub &
+          sudo Xvfb -ac :99 -screen 0 1280x1024x24 > /dev/null 2>&1 & # optional
+
+      - name: Run application
+        run: |
+          export $(grep -v '^#' docker/selenium-testing/env/remotetest.compose.env | xargs)
+          cd CodeListLibrary_project
+          python manage.py makemigrations
+          python manage.py migrate
+          python manage.py runserver 0.0.0.0:8000 > /dev/null &
+
+      - name: Run tests
+        if: success() || failure()
+        run: |
+          export $(grep -v '^#' docker/selenium-testing/env/remotetest.compose.env | xargs)
+          cd CodeListLibrary_project
+          pytest -v -s --cov-report xml --cov . --html=report.html --self-contained-html --alluredir=./clinicalcode/tests/allure-results
+        env:
+          DISPLAY: ":99"
+
+      - name: Coverage report
+        if: success() || failure()
+        uses: 5monkeys/cobertura-action@v13
+        with:
+          path: CodeListLibrary_project/coverage.xml
+          minimum_coverage: 25
+
+      - name: "Upload Test Results"
+        if: success() || failure()
+        uses: actions/upload-artifact@v3
+        with:
+          name: test-results
+          path: CodeListLibrary_project/report.html
+          retention-days: 5
+
+      - name: Get Allure history
+        uses: actions/checkout@v3
+        if: success() || failure()
+        continue-on-error: true
+        with:
+          ref: gh-pages
+          path: gh-pages
+
+      - name: Allure report action # Step to generate Allure report
+        if: success() || failure()
+        uses: simple-elf/allure-report-action@master
+        with:
+          allure_results: CodeListLibrary_project/clinicalcode/tests/allure-results
+          allure_report: CodeListLibrary_project/clinicalcode/tests/allure-report
+          allure_history: allure-history
+          gh_pages: gh-pages
+          keep_reports: 10 # Specify the number of previous reports to keep
+
+      - name: Upload an artifact for GitHub Pages
+        uses: actions/upload-pages-artifact@v2
+        if: success() || failure()
+        with:
+          name: allure-report
+          path: CodeListLibrary_project/clinicalcode/tests/allure-report
+
+      - name: Deploy report to testing-result-pages branch
+        if: always()
+        uses: peaceiris/actions-gh-pages@v2
+        env:
+          PERSONAL_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          PUBLISH_BRANCH: gh-pages
+          PUBLISH_DIR: allure-history
+          keep_files: true

.gitignore

@@ -23,3 +23,5 @@ docker/CodeListLibrary_project
 # macOS system files
 .DS_Stores
 .idea
+
+CodeListLibrary_project/clinicalcode/tests/allure-results/

CodeListLibrary_project/clinicalcode/entity_utils/entity_db_utils.py

@@ -804,3 +804,4 @@ def chk_valid_id(request, set_class, pk, chk_permission=False):
         ret_id = set_class.objects.get(pk=actual_pk).id
 
     return is_valid_id, err, ret_id
+

CodeListLibrary_project/clinicalcode/tests/conftest.py

@@ -0,0 +1,125 @@
+from datetime import datetime
+
+import pytest
+from clinicalcode.models import GenericEntity
+from django.contrib.auth.models import User, Group
+from django.utils.timezone import make_aware
+
+from selenium.webdriver import Keys
+from selenium import webdriver
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support.wait import WebDriverWait
+
+from cll.test_settings import WEBAPP_HOST, REMOTE_TEST_HOST, REMOTE_TEST, chrome_options
+
+
+@pytest.fixture
+def generate_user():
+    su_user = User.objects.create_superuser(username='superuser', password='superpassword', email=None)
+    nm_user = User.objects.create_user(username='normaluser', password='normalpassword', email=None)
+    ow_user = User.objects.create_user(username='owneruser', password='ownerpassword', email=None)
+    gp_user = User.objects.create_user(username='groupuser', password='grouppassword', email=None)
+    vgp_user = User.objects.create_user(username='viewgroupuser', password='viewgrouppassword', email=None)
+    egp_user = User.objects.create_user(username='editgroupuser', password='editgrouppassword', email=None)
+
+    users = {
+        'super_user': su_user,
+        'normal_user': nm_user,
+        'owner_user': ow_user,
+        'group_user': gp_user,
+        'view_group_user': vgp_user,
+        'edit_group_user': egp_user,
+    }
+
+    yield users
+
+    # Clean up the users after the tests are finished
+    for user in users.values():
+        user.delete()
+
+
+@pytest.fixture
+def create_groups():
+    permitted_group = Group.objects.create(name="permitted_group")
+    forbidden_group = Group.objects.create(name="forbidden_group")
+    view_group = Group.objects.create(name="view_group")
+    edit_group = Group.objects.create(name="edit_group")
+
+    # Yield the created groups so they can be used in tests
+    yield {
+        'permitted_group': permitted_group,
+        'forbidden_group': forbidden_group,
+        'view_group': view_group,
+        'edit_group': edit_group,
+    }
+
+    # Clean up the groups after the tests are finished
+    for group in [permitted_group, forbidden_group, view_group, edit_group]:
+        group.delete()
+
+@pytest.fixture
+def generate_entity(create_groups):
+    template_data = {
+        "sex": "3",
+        "type": "1",
+        "version": 1,
+        "phenoflowid": "",
+        "data_sources": [
+            5
+        ],
+        "coding_system": [],
+        "agreement_date": "2012-11-23",
+        "phenotype_uuid": "4",
+        "event_date_range": "01/01/1999 - 01/07/2016",
+        "source_reference": "https://portal.caliberresearch.org/phenotypes/archangelidi-heart-rate-6keWsw2mW2TQjDMhNAUETt",
+        "concept_information": []
+    }
+    generate_entity = GenericEntity.objects.create(name="Test entity",
+                                                   group=create_groups['permitted_group'],
+                                                   template_data=template_data,updated=make_aware(datetime.now()))
+    return generate_entity
+
+
+@pytest.fixture(scope="class")
+def setup_webdriver(request):
+    if REMOTE_TEST:
+        driver = webdriver.Chrome(options=chrome_options)
+    else:
+        driver = webdriver.Remote(command_executor=REMOTE_TEST_HOST, options=chrome_options)
+
+    wait = WebDriverWait(driver, 10)
+    driver.maximize_window()
+    request.cls.driver = driver
+    request.cls.wait = wait
+    yield
+    driver.quit()
+
+
+@pytest.fixture(scope="function")
+def login():
+    def _login(driver, username, password):
+        driver.get(WEBAPP_HOST + "/account/login/")
+        username_input = driver.find_element(By.NAME, "username")
+        password_input = driver.find_element(By.NAME, "password")
+
+        # Input username and password
+        username_input.send_keys(username)
+        password_input.send_keys(password)
+
+        # Submit the form by pressing Enter
+        password_input.send_keys(Keys.ENTER)
+
+    yield _login
+
+
+@pytest.fixture(scope="function")
+def logout():
+    def _logout(driver):
+        driver.get(WEBAPP_HOST + "/account/logout/")
+    yield _logout
+
+
+
+
+
+

CodeListLibrary_project/clinicalcode/tests/functional_tests/test_search_filters.py

@@ -0,0 +1,27 @@
+import time
+
+import pytest
+from selenium.webdriver.common.by import By
+
+from cll.test_settings import WEBAPP_HOST
+
+@pytest.mark.django_db
+@pytest.mark.usefixtures("setup_webdriver")
+class TestSearchFilters:
+
+    @pytest.mark.parametrize('user_type', ['super_user'])
+    def test_tags_filter(self, login, logout, generate_user, user_type):
+        user = generate_user[user_type]
+        login(self.driver, user.username, user.password)
+
+        self.driver.get(WEBAPP_HOST +"/phenotypes")
+        accordian = self.driver.find_element(By.XPATH, "/html/body/main/div/div/aside/div[2]/div[4]")
+        time.sleep(5)
+        accordian.click()
+        checkboxes = self.driver.find_elements(By.XPATH, "//input[(@class='checkbox-item') and (@aria-label = 'Tags')]")
+
+        for checkbox in checkboxes:
+            assert checkbox.is_enabled() is True
+
+        logout(self.driver)
+

CodeListLibrary_project/clinicalcode/tests/unit_tests/test_read_only_permmisions.py

@@ -0,0 +1,38 @@
+from pytest import mark
+from clinicalcode.entity_utils.permission_utils import allowed_to_create, can_user_edit_entity
+import pytest
+from datetime import datetime
+
+
+@pytest.mark.django_db
+class TestReadOnlyPermissions:
+
+    def test_my_user(self, generate_user):
+        super_user = generate_user['super_user']
+        assert super_user.username == 'superuser'
+
+    @pytest.mark.parametrize('user_type', ['super_user'])
+    def test_genereic_entity(self, generate_entity, generate_user, user_type):
+        generate_entity.owner = generate_user[user_type]
+        generate_entity.created_by = generate_user[user_type]
+        assert generate_entity.name == 'Test entity'
+
+    @pytest.mark.parametrize('user_type', ['super_user', 'owner_user'])
+    def test_users_to_edit(self, generate_user, generate_entity, user_type):
+        generate_entity.owner = generate_user[user_type]
+        generate_entity.created_by = generate_user[user_type]
+        assert can_user_edit_entity(
+            None, generate_entity, generate_user[user_type]) == False
+
+    def test_user_not_allowed_to_create(self):
+        assert allowed_to_create() == False
+
+    def test_wrong_answer(self):
+        assert allowed_to_create() == True
+
+    def test_wrong_again():
+        assert 1 == 2
+
+
+
+