From e75a5fe5361dc4ef1d2c4e702aec6bacc141c059 Mon Sep 17 00:00:00 2001 From: Meni Yakove Date: Sat, 8 Mar 2025 00:21:25 +0200 Subject: [PATCH 1/2] Use repo api token for webhooks and set repositories when available --- webhook_server_container/libs/github_api.py | 26 ++-- .../utils/github_repository_settings.py | 122 ++++++++++++------ webhook_server_container/utils/helpers.py | 53 +++++--- webhook_server_container/utils/webhook.py | 65 ++++++++-- 4 files changed, 180 insertions(+), 86 deletions(-) diff --git a/webhook_server_container/libs/github_api.py b/webhook_server_container/libs/github_api.py index 357eedff..498443ea 100644 --- a/webhook_server_container/libs/github_api.py +++ b/webhook_server_container/libs/github_api.py @@ -113,6 +113,17 @@ def __init__(self, hook_data: Dict[Any, Any], headers: Headers, logger: logging. self.owners_content: Dict[str, Any] = {} self.config = Config() + self.github_api, self.token, self.api_user = get_api_with_highest_rate_limit( + config=self.config, repository_name=self.repository_name + ) + + if self.github_api and self.token: + self.repository = get_github_repo_api(github_api=self.github_api, repository=self.repository_full_name) + + else: + self.logger.error(f"Failed to get GitHub API and token for repository {self.repository_name}.") + return + self.log_prefix = self.prepare_log_prefix() self._repo_data_from_config() @@ -129,17 +140,6 @@ def __init__(self, hook_data: Dict[Any, Any], headers: Headers, logger: logging. ) return - self.github_api, self.token = get_api_with_highest_rate_limit( - config=self.config, repository_name=self.repository_name - ) - - if self.github_api and self.token: - self.repository = get_github_repo_api(github_api=self.github_api, repository=self.repository_full_name) - - else: - self.logger.error(f"{self.log_prefix} Failed to get GitHub API and token.") - return - self.repository_by_github_app = get_github_repo_api( github_api=self.github_app_api, repository=self.repository_full_name ) @@ -310,9 +310,9 @@ def _get_random_color(_colors: List[str], _json: Dict[str, str]) -> str: def prepare_log_prefix(self, pull_request: PullRequest | None = None) -> str: _repository_color = self._get_reposiroty_color_for_log_prefix() return ( - f"{_repository_color}[{self.github_event}][{self.x_github_delivery}][PR {pull_request.number}]:" + f"{_repository_color}[{self.github_event}][{self.x_github_delivery}][{self.api_user}][PR {pull_request.number}]:" if pull_request - else f"{_repository_color}[{self.github_event}][{self.x_github_delivery}]:" + else f"{_repository_color}[{self.github_event}][{self.x_github_delivery}][{self.api_user}]:" ) def process_pull_request_check_run_webhook_data(self) -> None: diff --git a/webhook_server_container/utils/github_repository_settings.py b/webhook_server_container/utils/github_repository_settings.py index c1cf2a7e..adb8add8 100644 --- a/webhook_server_container/utils/github_repository_settings.py +++ b/webhook_server_container/utils/github_repository_settings.py @@ -65,11 +65,13 @@ def set_branch_protection( required_approving_review_count: int, required_linear_history: bool, required_conversation_resolution: bool, + api_user: str, ) -> bool: logger = get_logger_with_params(name="github-repository-settings") - api_user = github_api.get_user().login - logger.info(f"Set branch {branch} setting for {repository.name}. enabled checks: {required_status_checks}") + logger.info( + f"[API user {api_user}] - Set branch {branch} setting for {repository.name}. enabled checks: {required_status_checks}" + ) branch.edit_protection( strict=strict, required_conversation_resolution=required_conversation_resolution, @@ -86,17 +88,17 @@ def set_branch_protection( return True -def set_repository_settings(repository: Repository) -> None: +def set_repository_settings(repository: Repository, api_user: str) -> None: logger = get_logger_with_params(name="github-repository-settings") - logger.info(f"Set repository {repository.name} settings") + logger.info(f"[API user {api_user}] - Set repository {repository.name} settings") repository.edit(delete_branch_on_merge=True, allow_auto_merge=True, allow_update_branch=True) if repository.private: logger.warning(f"{repository.name}: Repository is private, skipping setting security settings") return - logger.info(f"Set repository {repository.name} security settings") + logger.info(f"[API user {api_user}] - Set repository {repository.name} security settings") repository._requester.requestJsonAndCheck( "PATCH", f"{repository.url}/code-scanning/default-setup", @@ -157,10 +159,10 @@ def get_user_configures_status_checks(status_checks: Dict[str, Any]) -> Tuple[Li return include_status_checks, exclude_status_checks -def set_repository_labels(repository: Repository) -> str: +def set_repository_labels(repository: Repository, api_user: str) -> str: logger = get_logger_with_params(name="github-repository-settings") - logger.info(f"Set repository {repository.name} labels") + logger.info(f"[API user {api_user}] - Set repository {repository.name} labels") repository_labels: Dict[str, Dict[str, Any]] = {} for label in repository.get_labels(): repository_labels[label.name.lower()] = { @@ -181,7 +183,7 @@ def set_repository_labels(repository: Repository) -> str: logger.debug(f"{repository.name}: Add repository label {label} with color {color}") repository.create_label(name=label, color=color) - return f"{repository}: Setting repository labels is done" + return f"[API user {api_user}] - {repository}: Setting repository labels is done" def get_repo_branch_protection_rules(config_data: dict[str, Any], repo_data: dict[str, Any]) -> dict[str, Any]: @@ -196,7 +198,7 @@ def get_repo_branch_protection_rules(config_data: dict[str, Any], repo_data: dic return repo_data -def set_repositories_settings(config_: Config) -> None: +def set_repositories_settings(config_: Config, apis_dict: dict[str, dict[str, Any]]) -> None: logger = get_logger_with_params(name="github-repository-settings") logger.info("Processing repositories") @@ -213,7 +215,7 @@ def set_repositories_settings(config_: Config) -> None: futures = [] with ThreadPoolExecutor() as executor: - for _, data in config_data["repositories"].items(): + for repo, data in config_data["repositories"].items(): data = get_repo_branch_protection_rules(config_data=config_data, repo_data=data) futures.append( executor.submit( @@ -221,6 +223,8 @@ def set_repositories_settings(config_: Config) -> None: **{ "data": data, "default_status_checks": default_status_checks, + "apis_dict": apis_dict, + "repository_name": repo, }, ) ) @@ -228,36 +232,44 @@ def set_repositories_settings(config_: Config) -> None: get_future_results(futures=futures) -def set_repository(data: Dict[str, Any], default_status_checks: List[str]) -> Tuple[bool, str, Callable]: +def set_repository( + repository_name: str, data: Dict[str, Any], default_status_checks: List[str], apis_dict: dict[str, dict[str, Any]] +) -> Tuple[bool, str, Callable]: logger = get_logger_with_params(name="github-repository-settings") - repository: str = data["name"] - logger.info(f"Processing repository {repository}") + full_repository_name: str = data["name"] + logger.info(f"Processing repository {full_repository_name}") protected_branches: Dict[str, Any] = data.get("protected-branches", {}) repo_branch_protection_rules: Dict[str, Any] = data["branch_protection"] - github_api, _ = get_api_with_highest_rate_limit(config=config, repository_name=repository) + github_api = apis_dict[repository_name].get("api") + api_user = apis_dict[repository_name].get("user", "") + if not github_api: - return False, f"{repository}: Failed to get github api", logger.error + return False, f"{full_repository_name}: Failed to get github api", logger.error - repo = _get_github_repo_api(github_api=github_api, repository=repository) + repo = _get_github_repo_api(github_api=github_api, repository=full_repository_name) if not repo: - return False, f"{repository}: Failed to get repository", logger.error + return False, f"[API user {api_user}] - {full_repository_name}: Failed to get repository", logger.error try: - set_repository_labels(repository=repo) - set_repository_settings(repository=repo) + set_repository_labels(repository=repo, api_user=api_user) + set_repository_settings(repository=repo, api_user=api_user) if repo.private: - return False, f"{repository}: Repository is private, skipping setting branch settings", logger.warning + return ( + False, + f"{full_repository_name}: Repository is private, skipping setting branch settings", + logger.warning, + ) futures: List["Future"] = [] with ThreadPoolExecutor() as executor: for branch_name, status_checks in protected_branches.items(): - logger.debug(f"{repository}: Getting branch {branch_name}") + logger.debug(f"[API user {api_user}] - {full_repository_name}: Getting branch {branch_name}") branch = get_branch_sampler(repo=repo, branch_name=branch_name) if not branch: - logger.error(f"{repository}: Failed to get branch {branch_name}") + logger.error(f"[API user {api_user}] - {full_repository_name}: Failed to get branch {branch_name}") continue _default_status_checks = deepcopy(default_status_checks) @@ -280,6 +292,7 @@ def set_repository(data: Dict[str, Any], default_status_checks: List[str]) -> Tu "repository": repo, "required_status_checks": required_status_checks, "github_api": github_api, + "api_user": api_user, }, **repo_branch_protection_rules, ) @@ -290,12 +303,16 @@ def set_repository(data: Dict[str, Any], default_status_checks: List[str]) -> Tu logger.error(result.exception()) except UnknownObjectException as ex: - return False, f"{repository}: Failed to get repository settings, ex: {ex}", logger.error + return ( + False, + f"[API user {api_user}] - {full_repository_name}: Failed to get repository settings, ex: {ex}", + logger.error, + ) - return True, f"{repository}: Setting repository settings is done", logger.info + return True, f"[API user {api_user}] - {full_repository_name}: Setting repository settings is done", logger.info -def set_all_in_progress_check_runs_to_queued(config_: Config) -> None: +def set_all_in_progress_check_runs_to_queued(config_: Config, apis_dict: dict[str, dict[str, Any]]) -> None: check_runs = ( PYTHON_MODULE_INSTALL_STR, CAN_BE_MERGED_STR, @@ -306,16 +323,16 @@ def set_all_in_progress_check_runs_to_queued(config_: Config) -> None: futures: List["Future"] = [] with ThreadPoolExecutor() as executor: - for _, data in config_.data["repositories"].items(): - github_api, _ = get_api_with_highest_rate_limit(config=config, repository_name=data["name"]) + for repo, data in config_.data["repositories"].items(): futures.append( executor.submit( set_repository_check_runs_to_queued, **{ "config_": config_, "data": data, - "github_api": github_api, + "github_api": apis_dict[repo]["api"], "check_runs": check_runs, + "api_user": apis_dict[repo]["user"], }, ) ) @@ -324,24 +341,28 @@ def set_all_in_progress_check_runs_to_queued(config_: Config) -> None: def set_repository_check_runs_to_queued( - config_: Config, data: Dict[str, Any], github_api: Github, check_runs: Tuple[str] + config_: Config, + data: Dict[str, Any], + github_api: Github, + check_runs: Tuple[str], + api_user: str, ) -> Tuple[bool, str, Callable]: logger = get_logger_with_params(name="github-repository-settings") repository: str = data["name"] repository_app_api = get_repository_github_app_api(config_=config_, repository_name=repository) if not repository_app_api: - return False, "Failed to get repositories GitHub app API", logger.error + return False, f"[API user {api_user}] - {repository}: Failed to get repositories GitHub app API", logger.error app_api = _get_github_repo_api(github_api=repository_app_api, repository=repository) if not app_api: - logger.error(f"Failed to get GitHub app API for repository {repository}") - return False, f"Failed to get GitHub app API for repository {repository}", logger.error + logger.error(f"[API user {api_user}] - Failed to get GitHub app API for repository {repository}") + return False, f"[API user {api_user}] - Failed to get GitHub app API for repository {repository}", logger.error repo = _get_github_repo_api(github_api=github_api, repository=repository) if not repo: - logger.error(f"Failed to get GitHub API for repository {repository}") - return False, f"Failed to get GitHub API for repository {repository}", logger.error + logger.error(f"[API user {api_user}] - Failed to get GitHub API for repository {repository}") + return False, f"[API user {api_user}] - Failed to get GitHub API for repository {repository}", logger.error logger.info(f"{repository}: Set all {IN_PROGRESS_STR} check runs to {QUEUED_STR}") for pull_request in repo.get_pulls(state="open"): @@ -349,12 +370,12 @@ def set_repository_check_runs_to_queued( for check_run in last_commit.get_check_runs(): if check_run.name in check_runs and check_run.status == IN_PROGRESS_STR: logger.warning( - f"{repository}: [PR:{pull_request.number}] {check_run.name} status is {IN_PROGRESS_STR}, " + f"[API user {api_user}] - {repository}: [PR:{pull_request.number}] {check_run.name} status is {IN_PROGRESS_STR}, " f"Setting check run {check_run.name} to {QUEUED_STR}" ) app_api.create_check_run(name=check_run.name, head_sha=last_commit.sha, status=QUEUED_STR) - return True, f"{repository}: Set check run status to {QUEUED_STR} is done", logger.debug + return True, f"[API user {api_user}] - {repository}: Set check run status to {QUEUED_STR} is done", logger.debug def get_repository_github_app_api(config_: Config, repository_name: str) -> Optional[Github]: @@ -380,11 +401,32 @@ def get_repository_github_app_api(config_: Config, repository_name: str) -> Opti return None +def get_repository_api(repository: str) -> tuple[str, github.Github | None, str]: + github_api, _, api_user = get_api_with_highest_rate_limit(config=config, repository_name=repository) + return repository, github_api, api_user + + if __name__ == "__main__": logger = get_logger_with_params(name="github-repository-settings") config = Config() - set_repositories_settings(config_=config) - set_all_in_progress_check_runs_to_queued( - config_=config, - ) + apis_dict: dict[str, dict[str, Any]] = {} + + apis: list = [] + with ThreadPoolExecutor() as executor: + for repo, data in config.data["repositories"].items(): + apis.append( + executor.submit( + get_repository_api, + **{"repository": repo}, + ) + ) + + for result in as_completed(apis): + repository, github_api, api_user = result.result() + apis_dict[repository] = {"api": github_api, "user": api_user} + + logger.debug(f"Repositories APIs: {apis_dict}") + + set_repositories_settings(config_=config, apis_dict=apis_dict) + set_all_in_progress_check_runs_to_queued(config_=config, apis_dict=apis_dict) diff --git a/webhook_server_container/utils/helpers.py b/webhook_server_container/utils/helpers.py index 3a774f70..551e25a2 100644 --- a/webhook_server_container/utils/helpers.py +++ b/webhook_server_container/utils/helpers.py @@ -5,7 +5,7 @@ import subprocess from concurrent.futures import Future, as_completed from logging import Logger -from typing import Any, Dict, List, Optional, Tuple +from typing import Any import github from colorama import Fore @@ -17,23 +17,30 @@ def get_value_from_dicts( - primary_dict: Dict[Any, Any], - secondary_dict: Dict[Any, Any], + primary_dict: dict[Any, Any], + secondary_dict: dict[Any, Any], key: str, - return_on_none: Optional[Any] = None, + return_on_none: Any = None, ) -> Any: """ Get value from two dictionaries. If value is not found in primary_dict, try to get it from secondary_dict, otherwise return return_on_none. """ - return primary_dict.get(key, secondary_dict.get(key, return_on_none)) + if primary_dict.get(key): + return primary_dict[key] + elif secondary_dict.get(key): + return secondary_dict[key] -def get_logger_with_params(name: str, repository_name: Optional[str] = "") -> Logger: + else: + return return_on_none + + +def get_logger_with_params(name: str, repository_name: str = "") -> Logger: _config = Config() config_data = _config.data # Global repositories configuration - repo_data: Dict[str, Any] = {} + repo_data: dict[str, Any] = {} if repository_name: repo_data = _config.repository_data(repository_name=repository_name) # Specific repository configuration @@ -45,7 +52,7 @@ def get_logger_with_params(name: str, repository_name: Optional[str] = "") -> Lo return get_logger(name=name, filename=log_file, level=log_level, file_max_bytes=1048576 * 50) # 50MB -def extract_key_from_dict(key: Any, _dict: Dict[Any, Any]) -> Any: +def extract_key_from_dict(key: Any, _dict: dict[Any, Any]) -> Any: if isinstance(_dict, dict): for _key, _val in _dict.items(): if _key == key: @@ -68,12 +75,12 @@ def run_command( log_prefix: str, verify_stderr: bool = False, shell: bool = False, - timeout: Optional[int] = None, + timeout: int | None = None, capture_output: bool = True, check: bool = False, pipe: bool = False, **kwargs: Any, -) -> Tuple[bool, Any, Any]: +) -> tuple[bool, Any, Any]: """ Run command locally. @@ -140,8 +147,8 @@ def run_command( return False, out_decoded, err_decoded -def get_apis_and_tokes_from_config(config: Config, repository_name: str = "") -> List[Tuple[github.Github, str]]: - apis_and_tokens: List[Tuple[github.Github, str]] = [] +def get_apis_and_tokes_from_config(config: Config, repository_name: str = "") -> list[tuple[github.Github, str]]: + apis_and_tokens: list[tuple[github.Github, str]] = [] tokens = get_value_from_dicts( primary_dict=config.repository_data(repository_name=repository_name), @@ -158,7 +165,7 @@ def get_apis_and_tokes_from_config(config: Config, repository_name: str = "") -> def get_api_with_highest_rate_limit( config: Config, repository_name: str = "" -) -> Tuple[github.Github | None, str | None]: +) -> tuple[github.Github | None, str | None, str]: """ Get API with the highest rate limit @@ -171,27 +178,33 @@ def get_api_with_highest_rate_limit( """ logger = get_logger_with_params(name="helpers") - api: Optional[github.Github] = None - token: Optional[str] = None + api: github.Github | None = None + token: str | None = None _api_user: str = "" - rate_limit: Optional[RateLimit] = None + rate_limit: RateLimit | None = None remaining = 0 + msg = "Get API and token" + + if repository_name: + msg += f" for repository {repository_name}" + + logger.debug(msg) + apis_and_tokens = get_apis_and_tokes_from_config(config=config, repository_name=repository_name) for _api, _token in apis_and_tokens: _api_user = _api.get_user().login rate_limit = _api.get_rate_limit() if rate_limit.core.remaining > remaining: remaining = rate_limit.core.remaining - logger.debug(f"API user {_api_user} remaining rate limit: {remaining}") api, token = _api, _token if rate_limit: log_rate_limit(rate_limit=rate_limit, api_user=_api_user) logger.info(f"API user {_api_user} selected with highest rate limit: {remaining}") - return api, token + return api, token, _api_user def log_rate_limit(rate_limit: RateLimit, api_user: str) -> None: @@ -220,9 +233,9 @@ def log_rate_limit(rate_limit: RateLimit, api_user: str) -> None: logger.warning(msg) -def get_future_results(futures: List["Future"]) -> None: +def get_future_results(futures: list["Future"]) -> None: """ - result must return Tuple[bool, str, Callable] when the Callable is Logger function (LOGGER.info, LOGGER.error, etc) + result must return tuple[bool, str, Callable] when the Callable is Logger function (LOGGER.info, LOGGER.error, etc) """ for result in as_completed(futures): _res = result.result() diff --git a/webhook_server_container/utils/webhook.py b/webhook_server_container/utils/webhook.py index 162eaa40..e7224da8 100644 --- a/webhook_server_container/utils/webhook.py +++ b/webhook_server_container/utils/webhook.py @@ -1,7 +1,7 @@ -from concurrent.futures import ThreadPoolExecutor +from concurrent.futures import ThreadPoolExecutor, as_completed from typing import Any, Callable, Dict, List, Tuple -from github import Github +import github from github.Hook import Hook from webhook_server_container.libs.config import Config @@ -15,11 +15,19 @@ LOGGER = get_logger_with_params(name="webhook") -def process_github_webhook(data: Dict[str, Any], github_api: Github, webhook_ip: str) -> Tuple[bool, str, Callable]: - repository: str = data["name"] - repo = get_github_repo_api(github_api=github_api, repository=repository) +def process_github_webhook( + repository_name: str, data: Dict[str, Any], webhook_ip: str, apis_dict: dict[str, dict[str, Any]] +) -> Tuple[bool, str, Callable]: + full_repository_name: str = data["name"] + github_api = apis_dict[repository_name].get("api") + api_user = apis_dict[repository_name].get("user") + + if not github_api: + return False, f"{full_repository_name}: Failed to get github api", LOGGER.error + + repo = get_github_repo_api(github_api=github_api, repository=full_repository_name) if not repo: - return False, f"Could not find repository {repository}", LOGGER.error + return False, f"[API user {api_user}] - Could not find repository {full_repository_name}", LOGGER.error config_: Dict[str, str] = {"url": f"{webhook_ip}/webhook_server", "content_type": "json"} events: List[str] = data.get("events", ["*"]) @@ -27,29 +35,60 @@ def process_github_webhook(data: Dict[str, Any], github_api: Github, webhook_ip: try: hooks: List[Hook] = list(repo.get_hooks()) except Exception as ex: - return False, f"Could not list webhook for {repository}, check token permissions: {ex}", LOGGER.error + return ( + False, + f"[API user {api_user}] - Could not list webhook for {full_repository_name}, check token permissions: {ex}", + LOGGER.error, + ) for _hook in hooks: if webhook_ip in _hook.config["url"]: - return True, f"{repository}: Hook already exists - {_hook.config['url']}", LOGGER.info + return ( + True, + f"[API user {api_user}] - {full_repository_name}: Hook already exists - {_hook.config['url']}", + LOGGER.info, + ) - LOGGER.info(f"Creating webhook: {config_['url']} for {repository} with events: {events}") + LOGGER.info( + f"[API user {api_user}] - Creating webhook: {config_['url']} for {full_repository_name} with events: {events}" + ) repo.create_hook(name="web", config=config_, events=events, active=True) - return True, f"{repository}: Create webhook is done", LOGGER.info + return True, f"[API user {api_user}] - {full_repository_name}: Create webhook is done", LOGGER.info + + +def get_repository_api(repository: str) -> tuple[str, github.Github | None, str]: + github_api, _, api_user = get_api_with_highest_rate_limit(config=config, repository_name=repository) + return repository, github_api, api_user def create_webhook(config_: Config) -> None: LOGGER.info("Preparing webhook configuration") webhook_ip = config_.data["webhook_ip"] + apis_dict: dict[str, dict[str, Any]] = {} + + apis: list = [] + with ThreadPoolExecutor() as executor: + for repo, data in config_.data["repositories"].items(): + apis.append( + executor.submit( + get_repository_api, + **{"repository": repo}, + ) + ) + + for result in as_completed(apis): + repository, github_api, api_user = result.result() + apis_dict[repository] = {"api": github_api, "user": api_user} + + LOGGER.debug(f"Repositories APIs: {apis_dict}") futures = [] with ThreadPoolExecutor() as executor: - for _, data in config_.data["repositories"].items(): - github_api, _ = get_api_with_highest_rate_limit(config=config, repository_name=data["name"]) + for repo, data in config_.data["repositories"].items(): futures.append( executor.submit( process_github_webhook, - **{"data": data, "github_api": github_api, "webhook_ip": webhook_ip}, + **{"data": data, "webhook_ip": webhook_ip, "apis_dict": apis_dict, "repository_name": repo}, ) ) From e07990ed25933801ce2e4b703d189fee8ebd3d86 Mon Sep 17 00:00:00 2001 From: Meni Yakove Date: Sat, 8 Mar 2025 00:34:30 +0200 Subject: [PATCH 2/2] Fix tests --- webhook_server_container/libs/github_api.py | 2 +- webhook_server_container/tests/conftest.py | 11 ++++++----- webhook_server_container/utils/helpers.py | 4 ++-- 3 files changed, 9 insertions(+), 8 deletions(-) diff --git a/webhook_server_container/libs/github_api.py b/webhook_server_container/libs/github_api.py index 498443ea..c88a8b3c 100644 --- a/webhook_server_container/libs/github_api.py +++ b/webhook_server_container/libs/github_api.py @@ -113,6 +113,7 @@ def __init__(self, hook_data: Dict[Any, Any], headers: Headers, logger: logging. self.owners_content: Dict[str, Any] = {} self.config = Config() + self._repo_data_from_config() self.github_api, self.token, self.api_user = get_api_with_highest_rate_limit( config=self.config, repository_name=self.repository_name ) @@ -125,7 +126,6 @@ def __init__(self, hook_data: Dict[Any, Any], headers: Headers, logger: logging. return self.log_prefix = self.prepare_log_prefix() - self._repo_data_from_config() self.github_app_api = get_repository_github_app_api( config_=self.config, repository_name=self.repository_full_name diff --git a/webhook_server_container/tests/conftest.py b/webhook_server_container/tests/conftest.py index e11fa8d2..2a4d476f 100644 --- a/webhook_server_container/tests/conftest.py +++ b/webhook_server_container/tests/conftest.py @@ -1,10 +1,11 @@ -import pytest -from starlette.datastructures import Headers +import os -from simple_logger.logger import logging import yaml +from simple_logger.logger import logging +from starlette.datastructures import Headers + +import pytest from webhook_server_container.libs.github_api import ProcessGithubWehook -import os ALL_CHANGED_FILES = [ "OWNERS", @@ -99,7 +100,7 @@ def process_github_webhook(mocker, request): mocker.patch(f"{base_import_path}.get_repository_github_app_api", return_value=True) mocker.patch("github.AuthenticatedUser", return_value=True) - mocker.patch(f"{base_import_path}.get_api_with_highest_rate_limit", return_value=("API", "TOKEN")) + mocker.patch(f"{base_import_path}.get_api_with_highest_rate_limit", return_value=("API", "TOKEN", "USER")) mocker.patch(f"{base_import_path}.get_github_repo_api", return_value=Repository()) process_github_webhook = ProcessGithubWehook( diff --git a/webhook_server_container/utils/helpers.py b/webhook_server_container/utils/helpers.py index 551e25a2..952676d8 100644 --- a/webhook_server_container/utils/helpers.py +++ b/webhook_server_container/utils/helpers.py @@ -27,10 +27,10 @@ def get_value_from_dicts( If value is not found in primary_dict, try to get it from secondary_dict, otherwise return return_on_none. """ - if primary_dict.get(key): + if primary_dict.get(key) is not None: return primary_dict[key] - elif secondary_dict.get(key): + elif secondary_dict.get(key) is not None: return secondary_dict[key] else: