availcheck.checker

  1# -*- coding: utf-8 -*-
  2# Copyright (C) 2024 TU Dresden
  3# ralf.klammer@tu-dresden.de
  4
  5import logging
  6
  7from json import dumps
  8
  9from . import (
 10    BROWSER_DIR,
 11    O4A_URL,
 12    O4A_SOLR_SUBPATH,
 13    O4A_ENTITIES_COUNT,
 14    EDU_URL,
 15    SUPPORT_APPS_URL,
 16    KNOWLEDGEHUB_URL,
 17    WEBAPPS_URL,
 18)
 19from .selenium import SeleniumAgent
 20
 21log = logging.getLogger(__name__)
 22
 23
 24def resolve_url(func):
 25    def wrap(self, *args, **kwargs):
 26        current_url = self.selenium.get_url()
 27        if current_url != self.url:
 28            try:
 29                self.selenium.get(self.url)
 30                if getattr(self, "shadow_root", None):
 31                    self.shadow_host = self.selenium.get_shadow_root(
 32                        self.shadow_root
 33                    )
 34            except Exception as e:
 35                log.error(f"Unable to open URL: {self.url}")
 36                log.error(e)
 37                return False
 38
 39            return func(self, *args, **kwargs)
 40        else:
 41            return func(self, *args, **kwargs)
 42
 43    return wrap
 44
 45
 46class CheckerBase(object):
 47    def __init__(self, url=None, instance="prod", path_of_screenshots=None):
 48        self.url = url
 49        self.instance = instance
 50        self.selenium = SeleniumAgent(
 51            path_of_screenshots=path_of_screenshots,
 52            implicit_wait=10,
 53            browser_dir=(
 54                f"{BROWSER_DIR}_{self.__class__.__name__}_{self.instance}"
 55                if BROWSER_DIR
 56                else None
 57            ),
 58        )
 59
 60        self.url = url
 61
 62    def run_checks(self):
 63        """
 64        Run all checks defined in `self.checks` for the given instance.
 65        """
 66        results = {}
 67        for check in self.checks:
 68            if self.instance not in self.checks[check]:
 69                continue
 70            method = getattr(self, check)
 71            result = method()
 72            log.info(
 73                f"{self.__class__.__name__} ({self.instance}) - {check}: {result}"
 74            )
 75            results[check] = result
 76
 77        return results
 78
 79    def save_checks(self, path):
 80        """
 81        Save the results of the checks to a file.
 82        """
 83        results = self.run_checks()
 84        filename = f"{self.__class__.__name__}_{self.instance}.json"
 85        with open(f"{path.rstrip('/')}/{filename}", "w") as f:
 86            f.write(dumps(results))
 87        return filename
 88
 89    def create_var_url(
 90        self,
 91        env_var,
 92        instance,
 93        subdomain=None,
 94        path="",
 95    ):
 96        """
 97        Cutting the url and setting subdomains based
 98        if production or testing instance set.
 99        """
100
101        base_url = env_var.get(self.instance, None)
102
103        if base_url is None:
104            raise ValueError(
105                f"self.Instance '{instance}' is not supported. "
106                "Please provide a valid URL."
107            )
108        if subdomain is None:
109            var_url = f"https://{base_url.split('://')[1]}{path}"
110        else:
111            var_url = f"https://{subdomain}.{base_url.split('://')[1]}{path}"
112
113        return var_url
114
115    def quit(self):
116        self.selenium.quit()
117
118
119class CheckerWebApps(CheckerBase):
120
121    checks = {"landing_page_webapps": ["prod"]}
122
123    @resolve_url
124    def _landing_page_webapps(self):
125
126        result = self.selenium.find_by_css(
127            css="img[alt='Logo des NFDI Konsortiums NFDI4Earth']"
128        )
129
130        return bool(result)
131
132    def landing_page_webapps(self):
133        """
134        Checks if the landing Page for Webapps is available
135        """
136        self.url = self.create_var_url(
137            WEBAPPS_URL,
138            self.instance,
139        )
140
141        return self._landing_page_webapps()
142
143
144class CheckerKnowledgeHub(CheckerBase):
145    checks = {
146        "sparql": ["prod", "test"],
147        "cordra": ["prod", "test"],
148        "landing_page_knowledgehub": ["prod", "test"],
149        "more_examples_loaded": ["prod", "test"],
150        "table_is_displayed": ["prod", "test"],
151    }
152
153    @resolve_url
154    def _sparql(self):
155        result = self.selenium.find_by_css(css="circle[class='success']")
156
157        return bool(result)
158
159    def sparql(self):
160        """
161        Checks if the Knowledgehub-SPARQL Endpoint is availiable
162        This is done by checking for the "server status" circle.
163        """
164        self.url = self.create_var_url(
165            KNOWLEDGEHUB_URL,
166            self.instance,
167            subdomain="sparql",
168        )
169
170        return self._sparql()
171
172    @resolve_url
173    def _cordra(self):
174        result = self.selenium.find_by_css(css="input[placeholder='Search']")
175
176        return bool(result)
177
178    def cordra(self):
179        """
180        Checks if cordra is available,
181        This is done by checking for the searchbar.
182        """
183        self.url = self.create_var_url(
184            KNOWLEDGEHUB_URL, self.instance, subdomain="cordra"
185        )
186
187        return self._cordra()
188
189    @resolve_url
190    def _landing_page_knowledgehub(self):
191        current_url = self.selenium.get_url()
192        result = current_url.startswith("https://knowledgehub")
193
194        return bool(result)
195
196    def landing_page_knowledgehub(self):
197        """
198        Checks if the Landingpage of Knowlegehub is available.
199        """
200        self.url = self.create_var_url(KNOWLEDGEHUB_URL, self.instance)
201        return self._landing_page_knowledgehub()
202
203    @resolve_url
204    def _more_examples_loaded(self):
205        toggle_button = self.selenium.find_by_css(
206            css=("#hidden-card-deck-toggle")
207        )
208        if toggle_button is None:
209            log.warning(f"{toggle_button} not found")
210            return False
211        else:
212            self.selenium.zoom()
213            toggle_button.click()
214            result = self.selenium.wait_until(
215                css="div[class='row mb-3'][id='card-deck']", want_bool=True
216            )
217        return result
218
219    def more_examples_loaded(self):
220        """
221        Check if more cards appear after button click.
222        """
223        self.url = self.create_var_url(KNOWLEDGEHUB_URL, self.instance)
224        return self._more_examples_loaded()
225
226    @resolve_url
227    def _table_is_displayed(self):
228        self.selenium.zoom()
229        self.selenium.save_screenshot("/tmp/table.png")
230        self.selenium.wait_until(css=".col-3.border")
231        result = self.selenium.amount_of_elements(css=".col-3.border")
232        return bool(result)
233
234    def table_is_displayed(self):
235        """
236        Checks if the "Harvested Ressources table appears
237        with atleast 10 Entries fetched.
238        """
239        self.url = self.create_var_url(KNOWLEDGEHUB_URL, self.instance)
240        return self._table_is_displayed()
241
242
243class CheckerSupportApps(CheckerBase):
244    # define checks to run in `run_checks` AND
245    # define for which instances to run them
246    checks = {"jupyterhub": ["prod"]}
247
248    @resolve_url
249    def _jupyterhub(self):
250        """
251        Checks if entry level of JupyterHub is restricted / service is running
252        This is done by checking if Logo and corresponding error code is shown.
253        """
254
255        results = []
256
257        #  Check error
258        result = self.selenium.find_by_text(
259            css=".error",
260            text="405 : Method Not Allowed",
261            case_sensitive=False,
262        )
263        results.append(result)
264
265        #  Check logo
266        result = self.selenium.find_by_css(css="img[src='/hub/logo']")
267        results.append(result)
268
269        return all(results)
270
271    def jupyterhub(self):
272        self.url = self.create_var_url(
273            SUPPORT_APPS_URL, self.instance, subdomain="jupyterhub"
274        )
275        return self._jupyterhub()
276
277
278class CheckerEduTrain(CheckerBase):
279    # define checks to run in `run_checks` AND
280    # define for which instances to run them
281    checks = {
282        "openedx_lms": ["prod", "test"],
283        "openedx_cms": ["prod", "test"],
284        "authentication": ["prod", "test"],
285    }
286
287    def openedx_lms(self):
288        """
289        Check if the main page is loaded correctly.
290        This is done by checking if the DFG logo is present.
291        """
292
293        self.url = self.create_var_url(
294            EDU_URL, self.instance, subdomain="teacher"
295        )
296        self.selenium.get(self.url)
297        return self._openedx_lms()
298
299    @resolve_url
300    def _openedx_lms(self):
301        result = self.selenium.find_by_css(
302            # Path may change on a regular, check again once more
303            css='img[src="/static/studio/edutrain/images/studio-logo.419852c6db47.png"]'
304        )
305
306        return bool(result)
307
308    @resolve_url
309    def _openedx_cms(self):
310        result = self.selenium.find_by_css(
311            css='img[src="/static/studio/edutrain/images/studio-logo.419852c6db47.png"]'
312        )
313        return bool(result)
314
315    def openedx_cms(self):
316        """
317        Check if Educational Portal is Working
318        This is achieved by checking for the appearance of the logo
319        """
320
321        self.url = self.create_var_url(
322            EDU_URL, self.instance, subdomain="teacher"
323        )
324
325        return self._openedx_cms()
326
327    @resolve_url
328    def _authentication(self):
329        results = []
330        academy_button = self.selenium.find_by_css(
331            css='button[id="oa2-academicid-oauth2"]'
332        )
333
334        academy_button.click()
335
336        current_url = self.selenium.get_url()
337        target_page_reached = current_url.startswith(
338            "https://sso.academiccloud.de/simplesaml/module.php/"
339        )
340
341        results.append(target_page_reached)
342        return all(results)
343
344    def authentication(self):
345        """
346        Check if URL is available, if "AcademicID" button
347        is available and leads to login page
348        """
349
350        self.url = self.create_var_url(
351            EDU_URL,
352            self.instance,
353            subdomain="apps",
354            path="/authn/login?next=%2F",
355        )
356
357        return self._authentication()
358
359
360class CheckerOneStop4All(CheckerBase):
361    # define checks to run in `run_checks` AND
362    # define for which instances to run them
363    checks = {
364        "main_page": ["prod", "test"],
365        "number_of_entities": ["prod"],
366        "involvement": ["prod", "test"],
367        "support_form": ["prod", "test"],
368        "captcha_in_support_form": ["prod", "test"],
369        "solr": ["prod", "test"],
370    }
371
372    def __init__(self, url=None, instance=None, *args, **kwargs):
373        super().__init__(url=url, instance=instance, *args, **kwargs)
374
375        self.url = self.create_var_url(O4A_URL, self.instance)
376
377        self.shadow_root = "onestop4all-app"
378
379    @resolve_url
380    def main_page(self):
381        """
382        Check if the main page is loaded correctly.
383        This is done by checking if the DFG logo is present.
384        """
385        result = self.selenium.find_by_css(
386            css='img[src="/dfg-logo.svg"]', elem=self.shadow_host
387        )
388        return bool(result)
389
390    @resolve_url
391    def number_of_entities(self):
392        """
393        Check if the number of entities is correct.
394        By checking if there is the correct amount of buttons on the webpage.
395        """
396        results = self.selenium.find_by_css(
397            css="div.resourceEntries",
398            elem=self.shadow_host,
399            as_list=True,
400        )
401        return len(results) == O4A_ENTITIES_COUNT
402
403    @resolve_url
404    def involvement(self):
405        """
406        Check if the buttons withing involvement section is loaded correctly.
407        This is simply done, by checking if there are any buttons.
408        """
409        results = self.selenium.find_by_css(
410            css="div.get-involved div.overlap > img",
411            elem=self.shadow_host,
412            as_list=True,
413        )
414        return len(results) > 0
415
416    @resolve_url
417    def support_form(self, close_modal=True):
418        """
419        Check if the support form is loaded correctly.
420        This is done by checking if the subject input field is present.
421        """
422        # try to find the support form button
423        support_form_button = self.selenium.find_by_text(
424            css=".chakra-link",
425            text="user Support",
426            elem=self.shadow_host,
427            case_sensitive=False,
428        )
429
430        # stop check if no support form button was found
431        if not support_form_button:
432            return False
433
434        # click on the support form button to open modal window
435        support_form_button.click()
436
437        subject = self.selenium.find_by_css(
438            css="input[name='subject']", elem=self.shadow_host
439        )
440        if subject and close_modal:
441            # close the modal window finally
442            self.selenium.find_by_css(
443                css="button[aria-label='Close']", elem=self.shadow_host
444            ).click()
445        return bool(subject)
446
447    @resolve_url
448    def captcha_in_support_form(self):
449        """
450        Check if the CAPTCHA is loaded correctly in the support form.
451        This is done by:
452            1. checking if the CAPTCHA checkbox is present
453            2. clicking on the CAPTCHA checkbox
454            3. checking if the CAPTCHA input field is present AND
455                its value is not empty
456        """
457        if self.support_form(close_modal=False):
458            altcha_checkbox = self.selenium.wait_until(
459                css="input#altcha_checkbox",
460                elem=self.shadow_host,
461            )
462            if altcha_checkbox:
463                altcha_checkbox.click()
464                altcha_input = self.selenium.wait_until(
465                    css="input[type='hidden'][name='altcha']",
466                    elem=self.shadow_host,
467                )
468                if altcha_input and altcha_input.get_attribute("value") != "":
469                    return True
470        return False
471
472    @property
473    def _solr_url(self):
474        return f"{self.url.rstrip('/')}/{O4A_SOLR_SUBPATH.lstrip('/')}"
475
476    @resolve_url
477    def solr(self):
478        """
479        Check if the Solr login page is loaded correctly.
480        This is done by checking if the Solr logo is present.
481        """
482        self.selenium.get(self._solr_url)
483        logo = self.selenium.find_by_css(css="a#solr span")
484        return bool(logo)