Esempio n. 1
0
def test_is_file_valid_mdx_server(mocker, current, answer):
    readme_validator = ReadMeValidator(current)
    valid = readme_validator.are_modules_installed_for_verify(
        readme_validator.content_path)
    if not valid:
        pytest.skip('skipping mdx server test. ' + MDX_SKIP_NPM_MESSAGE)
        return
    mocker.patch.dict(os.environ, {'DEMISTO_README_VALIDATION': 'yes'})
    assert readme_validator.is_valid_file() is answer
    assert ReadMeValidator._MDX_SERVER_PROCESS is not None
    ReadMeValidator.stop_mdx_server()
Esempio n. 2
0
def test_is_file_valid(mocker, current, answer):
    readme_validator = ReadMeValidator(current)
    valid = readme_validator.are_modules_installed_for_verify(readme_validator.content_path)
    if not valid:
        pytest.skip('skipping mdx test. ' + MDX_SKIP_NPM_MESSAGE)
        return
    with requests_mock.Mocker() as m:
        # Mock get requests
        m.get('https://github.com/demisto/content/blob/123/Packs/AutoFocus/doc_files/AutoFocusPolling.png',
              status_code=200, text="Test1")
        m.get('https://github.com/demisto/content/blob/123/Packs/FeedOffice365/doc_files/test.png',
              status_code=200, text="Test2")
        m.get('https://github.com/demisto/content/raw/123/Packs/valid/doc_files/test.png',
              status_code=200, text="Test3")
        mocker.patch.dict(os.environ, {'DEMISTO_README_VALIDATION': 'yes', 'DEMISTO_MDX_CMD_VERIFY': 'yes'})
        assert readme_validator.is_valid_file() is answer
        assert not ReadMeValidator._MDX_SERVER_PROCESS
Esempio n. 3
0
    def validate_added_files(self,
                             added_files,
                             file_type: str = None):  # noqa: C901
        """Validate the added files from your branch.

        In case we encounter an invalid file we set the self._is_valid param to False.

        Args:
            added_files (set): A set of the modified files in the current branch.
            file_type (str): Used only with -p flag (the type of the file).
        """
        for file_path in added_files:
            print('Validating {}'.format(file_path))

            if re.match(TEST_PLAYBOOK_REGEX, file_path,
                        re.IGNORECASE) and not file_type:
                continue

            elif 'README' in file_path:
                readme_validator = ReadMeValidator(file_path)
                if not readme_validator.is_valid_file():
                    self._is_valid = False
                continue

            structure_validator = StructureValidator(
                file_path, is_new_file=True, predefined_scheme=file_type)
            if not structure_validator.is_valid_file():
                self._is_valid = False

            if self.validate_id_set:
                if not self.id_set_validator.is_file_valid_in_set(file_path):
                    self._is_valid = False

                if self.id_set_validator.is_file_has_used_id(file_path):
                    self._is_valid = False

            elif re.match(PLAYBOOK_REGEX, file_path,
                          re.IGNORECASE) or file_type == 'playbook':
                playbook_validator = PlaybookValidator(structure_validator)
                if not playbook_validator.is_valid_playbook():
                    self._is_valid = False

            elif checked_type(
                    file_path,
                    YML_INTEGRATION_REGEXES) or file_type == 'integration':
                image_validator = ImageValidator(file_path)
                # if file_type(non git path) the image is not in a separate path
                image_validator.file_path = file_path if file_type else image_validator.file_path
                if not image_validator.is_valid():
                    self._is_valid = False

                description_validator = DescriptionValidator(file_path)
                if not description_validator.is_valid():
                    self._is_valid = False

                integration_validator = IntegrationValidator(
                    structure_validator)
                if not integration_validator.is_valid_file(
                        validate_rn=not file_type):
                    self._is_valid = False

            elif checked_type(
                    file_path,
                    PACKAGE_SCRIPTS_REGEXES) or file_type == 'script':
                unifier = Unifier(os.path.dirname(file_path))
                yml_path, _ = unifier.get_script_package_data()
                # Set file path to the yml file
                structure_validator.file_path = yml_path
                script_validator = ScriptValidator(structure_validator)

                if not script_validator.is_valid_file(
                        validate_rn=not file_type):
                    self._is_valid = False

            elif re.match(BETA_INTEGRATION_REGEX, file_path, re.IGNORECASE) or \
                    re.match(BETA_INTEGRATION_YML_REGEX, file_path, re.IGNORECASE):
                description_validator = DescriptionValidator(file_path)
                if not description_validator.is_valid_beta_description():
                    self._is_valid = False

                integration_validator = IntegrationValidator(
                    structure_validator)
                if not integration_validator.is_valid_beta_integration():
                    self._is_valid = False

            elif re.match(IMAGE_REGEX, file_path, re.IGNORECASE):
                image_validator = ImageValidator(file_path)
                if not image_validator.is_valid():
                    self._is_valid = False

            # incident fields and indicator fields are using the same scheme.
            elif checked_type(file_path, JSON_INDICATOR_AND_INCIDENT_FIELDS) or \
                    file_type in ('incidentfield', 'indicatorfield'):
                incident_field_validator = IncidentFieldValidator(
                    structure_validator)
                if not incident_field_validator.is_valid_file(
                        validate_rn=not file_type):
                    self._is_valid = False

            elif checked_type(file_path,
                              [REPUTATION_REGEX]) or file_type == 'reputation':
                reputation_validator = ReputationValidator(structure_validator)
                if not reputation_validator.is_valid_file(
                        validate_rn=not file_type):
                    self._is_valid = False

            elif checked_type(
                    file_path,
                    JSON_ALL_LAYOUT_REGEXES) or file_type == 'layout':
                layout_validator = LayoutValidator(structure_validator)
                if not layout_validator.is_valid_layout(
                        validate_rn=not file_type):
                    self._is_valid = False

            elif checked_type(
                    file_path,
                    JSON_ALL_DASHBOARDS_REGEXES) or file_type == 'dashboard':
                dashboard_validator = DashboardValidator(structure_validator)
                if not dashboard_validator.is_valid_dashboard(
                        validate_rn=not file_type):
                    self._is_valid = False

            elif checked_type(file_path, JSON_ALL_INCIDENT_TYPES_REGEXES):
                incident_type_validator = IncidentTypeValidator(
                    structure_validator)
                if not incident_type_validator.is_valid_incident_type(
                        validate_rn=not file_type):
                    self._is_valid = False

            elif 'CHANGELOG' in file_path:
                self.is_valid_release_notes(file_path)

            elif checked_type(file_path, CHECKED_TYPES_REGEXES):
                pass

            else:
                print_error(
                    "The file type of {} is not supported in validate command".
                    format(file_path))
                print_error(
                    "validate command supports: Integrations, Scripts, Playbooks, "
                    "Incident fields, Indicator fields, Images, Release notes, Layouts and Descriptions"
                )
                self._is_valid = False
Esempio n. 4
0
    def validate_modified_files(self, modified_files):  # noqa: C901
        """Validate the modified files from your branch.

        In case we encounter an invalid file we set the self._is_valid param to False.

        Args:
            modified_files (set): A set of the modified files in the current branch.
        """
        for file_path in modified_files:
            old_file_path = None
            if isinstance(file_path, tuple):
                old_file_path, file_path = file_path

            print('Validating {}'.format(file_path))
            if not checked_type(file_path):
                print_warning(
                    '- Skipping validation of non-content entity file.')
                continue

            if re.match(TEST_PLAYBOOK_REGEX, file_path, re.IGNORECASE):
                continue

            elif 'README' in file_path:
                readme_validator = ReadMeValidator(file_path)
                if not readme_validator.is_valid_file():
                    self._is_valid = False
                continue

            structure_validator = StructureValidator(
                file_path, old_file_path=old_file_path)
            if not structure_validator.is_valid_file():
                self._is_valid = False

            if self.validate_id_set:
                if not self.id_set_validator.is_file_valid_in_set(file_path):
                    self._is_valid = False

            elif checked_type(file_path, YML_INTEGRATION_REGEXES):
                image_validator = ImageValidator(file_path)
                if not image_validator.is_valid():
                    self._is_valid = False

                description_validator = DescriptionValidator(file_path)
                if not description_validator.is_valid():
                    self._is_valid = False

                integration_validator = IntegrationValidator(
                    structure_validator)
                if self.is_backward_check and not integration_validator.is_backward_compatible(
                ):
                    self._is_valid = False

                if not integration_validator.is_valid_file():
                    self._is_valid = False

            elif checked_type(file_path, YML_BETA_INTEGRATIONS_REGEXES):
                image_validator = ImageValidator(file_path)
                if not image_validator.is_valid():
                    self._is_valid = False

                description_validator = DescriptionValidator(file_path)
                if not description_validator.is_valid_beta_description():
                    self._is_valid = False

                integration_validator = IntegrationValidator(
                    structure_validator)
                if not integration_validator.is_valid_beta_integration():
                    self._is_valid = False

            elif checked_type(file_path, [SCRIPT_REGEX]):
                script_validator = ScriptValidator(structure_validator)
                if self.is_backward_check and not script_validator.is_backward_compatible(
                ):
                    self._is_valid = False
                if not script_validator.is_valid_file():
                    self._is_valid = False

            elif checked_type(file_path, PLAYBOOKS_REGEXES_LIST):
                playbook_validator = PlaybookValidator(structure_validator)
                if not playbook_validator.is_valid_playbook(
                        is_new_playbook=False):
                    self._is_valid = False

            elif checked_type(file_path, PACKAGE_SCRIPTS_REGEXES):
                unifier = Unifier(os.path.dirname(file_path))
                yml_path, _ = unifier.get_script_package_data()
                # Set file path to the yml file
                structure_validator.file_path = yml_path
                script_validator = ScriptValidator(structure_validator)
                if self.is_backward_check and not script_validator.is_backward_compatible(
                ):
                    self._is_valid = False

                if not script_validator.is_valid_file():
                    self._is_valid = False

            elif re.match(IMAGE_REGEX, file_path, re.IGNORECASE):
                image_validator = ImageValidator(file_path)
                if not image_validator.is_valid():
                    self._is_valid = False

            # incident fields and indicator fields are using the same scheme.
            elif checked_type(file_path, JSON_INDICATOR_AND_INCIDENT_FIELDS):
                incident_field_validator = IncidentFieldValidator(
                    structure_validator)
                if not incident_field_validator.is_valid_file(
                        validate_rn=True):
                    self._is_valid = False
                if self.is_backward_check and not incident_field_validator.is_backward_compatible(
                ):
                    self._is_valid = False

            elif checked_type(file_path, [REPUTATION_REGEX]):
                reputation_validator = ReputationValidator(structure_validator)
                if not reputation_validator.is_valid_file(validate_rn=True):
                    self._is_valid = False

            elif checked_type(file_path, JSON_ALL_LAYOUT_REGEXES):
                layout_validator = LayoutValidator(structure_validator)
                if not layout_validator.is_valid_layout(validate_rn=True):
                    self._is_valid = False

            elif checked_type(file_path, JSON_ALL_DASHBOARDS_REGEXES):
                dashboard_validator = DashboardValidator(structure_validator)
                if not dashboard_validator.is_valid_dashboard(
                        validate_rn=True):
                    self._is_valid = False

            elif checked_type(file_path, JSON_ALL_INCIDENT_TYPES_REGEXES):
                incident_type_validator = IncidentTypeValidator(
                    structure_validator)
                if not incident_type_validator.is_valid_incident_type(
                        validate_rn=True):
                    self._is_valid = False
                if self.is_backward_check and not incident_type_validator.is_backward_compatible(
                ):
                    self._is_valid = False

            elif 'CHANGELOG' in file_path:
                self.is_valid_release_notes(file_path)

            elif checked_type(file_path, CHECKED_TYPES_REGEXES):
                pass

            else:
                print_error(
                    "The file type of {} is not supported in validate command".
                    format(file_path))
                print_error(
                    "'validate' command supports: Integrations, Scripts, Playbooks, "
                    "Incident fields, Indicator fields, Images, Release notes, Layouts and Descriptions"
                )
                self._is_valid = False
Esempio n. 5
0
def test_is_file_valid(current, answer):
    readme_validator = ReadMeValidator(current)
    valid = readme_validator.are_modules_installed_for_verify()
    env_var = os.environ.get('DEMISTO_README_VALIDATION')
    if valid and env_var:
        assert readme_validator.is_valid_file() is answer
Esempio n. 6
0
    def run_all_validations_on_file(self,
                                    file_path: str,
                                    file_type: str = None) -> None:
        """
        Runs all validations on file specified in 'file_path'
        Args:
            file_path: A relative content path to a file to be validated
            file_type: The output of 'find_type' method
        """
        file_extension = os.path.splitext(file_path)[-1]
        # We validate only yml json and .md files
        if file_extension not in ['.yml', '.json', '.md']:
            return

        # Ignoring changelog and description files since these are checked on the integration validation
        if 'changelog' in file_path.lower(
        ) or 'description' in file_path.lower():
            return
        # unified files should not be validated
        if file_path.endswith('_unified.yml'):
            return

        print(f'Validating {file_path}')

        if 'README' in file_path:
            readme_validator = ReadMeValidator(file_path)
            if not readme_validator.is_valid_file():
                self._is_valid = False
            return
        structure_validator = StructureValidator(file_path,
                                                 predefined_scheme=file_type)
        if not structure_validator.is_valid_file():
            self._is_valid = False

        elif re.match(TEST_PLAYBOOK_REGEX, file_path, re.IGNORECASE):
            playbook_validator = PlaybookValidator(structure_validator)
            if not playbook_validator.is_valid_playbook():
                self._is_valid = False

        elif re.match(PLAYBOOK_REGEX, file_path,
                      re.IGNORECASE) or file_type == 'playbook':
            playbook_validator = PlaybookValidator(structure_validator)
            if not playbook_validator.is_valid_playbook(validate_rn=False):
                self._is_valid = False

        elif checked_type(file_path,
                          INTEGRATION_REGXES) or file_type == 'integration':
            integration_validator = IntegrationValidator(structure_validator)
            if not integration_validator.is_valid_file(validate_rn=False):
                self._is_valid = False

        elif checked_type(file_path,
                          YML_ALL_SCRIPTS_REGEXES) or file_type == 'script':
            # Set file path to the yml file
            structure_validator.file_path = file_path
            script_validator = ScriptValidator(structure_validator)

            if not script_validator.is_valid_file(validate_rn=False):
                self._is_valid = False

        elif checked_type(file_path, YML_BETA_INTEGRATIONS_REGEXES
                          ) or file_type == 'betaintegration':
            integration_validator = IntegrationValidator(structure_validator)
            if not integration_validator.is_valid_beta_integration():
                self._is_valid = False

        # incident fields and indicator fields are using the same scheme.
        elif checked_type(file_path, JSON_INDICATOR_AND_INCIDENT_FIELDS) or \
                file_type in ('incidentfield', 'indicatorfield'):
            incident_field_validator = IncidentFieldValidator(
                structure_validator)
            if not incident_field_validator.is_valid_file(validate_rn=False):
                self._is_valid = False

        elif checked_type(
                file_path,
                JSON_ALL_INDICATOR_TYPES_REGEXES) or file_type == 'reputation':
            reputation_validator = ReputationValidator(structure_validator)
            if not reputation_validator.is_valid_file(validate_rn=False):
                self._is_valid = False

        elif checked_type(file_path,
                          JSON_ALL_LAYOUT_REGEXES) or file_type == 'layout':
            layout_validator = LayoutValidator(structure_validator)
            if not layout_validator.is_valid_layout(validate_rn=False):
                self._is_valid = False

        elif checked_type(
                file_path,
                JSON_ALL_DASHBOARDS_REGEXES) or file_type == 'dashboard':
            dashboard_validator = DashboardValidator(structure_validator)
            if not dashboard_validator.is_valid_dashboard(validate_rn=False):
                self._is_valid = False

        elif checked_type(file_path, JSON_ALL_INCIDENT_TYPES_REGEXES
                          ) or file_type == 'incidenttype':
            incident_type_validator = IncidentTypeValidator(
                structure_validator)
            if not incident_type_validator.is_valid_incident_type(
                    validate_rn=False):
                self._is_valid = False

        elif checked_type(file_path, CHECKED_TYPES_REGEXES):
            print(f'Could not find validations for file {file_path}')

        else:
            print_error(
                'The file type of {} is not supported in validate command'.
                format(file_path))
            print_error(
                'validate command supports: Integrations, Scripts, Playbooks, dashboards, incident types, '
                'reputations, Incident fields, Indicator fields, Images, Release notes, '
                'Layouts and Descriptions')
            self._is_valid = False
Esempio n. 7
0
 def validate_readme(self, file_path, pack_error_ignore_list):
     readme_validator = ReadMeValidator(file_path, ignored_errors=pack_error_ignore_list,
                                        print_as_warnings=self.print_ignored_errors)
     return readme_validator.is_valid_file()