Ejemplo n.º 1
0
 def post_conf_init(self):
     self.server = self._get_conf('server') 
     self.base_uri = '%s://%s:%s@%s/%s' % (
         self._get_conf('method'), 
         urlencode_str(self._get_conf('user')),
         urlencode_str(self._get_conf('pass')),
         self.server, 
         self.base_path)
Ejemplo n.º 2
0
    def alm_connect_project(self):
        """ Verifies that the GitHub repo exists """
        self.project_uri = '%s/%s' % (urlencode_str(self.config[self.GITHUB_REPO_OWNER]),
                                      urlencode_str(self.config['alm_project']))

        # Check if GitHub repo is accessible
        try:
            repo_info = self.alm_plugin.call_api('repos/%s' % self.project_uri)
        except APIError, err:
            raise AlmException('Unable to find GitHub repo. Reason: %s' % err)
 def __init__(self, config, test_dir=None):
     resource_templates = ['card.xml']
     self.project_uri = '/org_name/api/v2/projects/%s' % urlencode_str(urlencode_str(config['alm_project']))
     rest_api_targets = {
         '/org_name/api/v2/projects.xml': 'get_projects',
         '%s.xml' % self.project_uri: 'get_project',
         '%s/cards.xml' % self.project_uri: 'call_cards',
         '%s/cards/[0-9]+.xml' % self.project_uri: 'call_card_by_number',
         '%s/card_types.xml' % self.project_uri: 'get_card_types',
         '%s/property_definitions.xml' % self.project_uri: 'get_property_definitions',
         '%s/property_definitions/[0-9]+.xml' % self.project_uri: 'get_property_definition_by_id'
     }
     super(MingleResponseGenerator, self).__init__(rest_api_targets, resource_templates, test_dir)
Ejemplo n.º 4
0
    def alm_connect_project(self):
        """ Verifies that the GitHub repo exists """
        self.project_uri = '%s/%s' % (urlencode_str(self.config[self.GITHUB_REPO_OWNER]),
                                      urlencode_str(self.config['alm_project']))

        # Check if GitHub repo is accessible
        try:
            repo_info = self.alm_plugin.call_api('repos/%s' % self.project_uri)
        except APIError as err:
            raise AlmException('Unable to find GitHub repo. Reason: %s' % str(err))

        self.sync_titles_only = not repo_info.get('private')

        """ Validate project configurations """
        self.milestone_id = self.github_get_milestone_id(self.config[self.ALM_PROJECT_VERSION])
 def __init__(self, config, test_dir=None):
     project_uri = '%s/%s' % (urlencode_str(config['github_repo_owner']), urlencode_str(config['alm_project']))
     self.project_milestone = config['alm_project_version']
     self.username = config['alm_user']
     self.alm_project = config['alm_project']
     resource_templates = ['user.json', 'issue.json', 'repo.json', 'milestone.json']
     rest_api_targets = {
         '/user': '******',
         '/repos/%s$' % project_uri: 'get_repo',
         '/repos/%s/milestones' % project_uri: 'get_milestones',
         '/legacy/issues/search/%s' % project_uri: 'get_issue',
         '/repos/%s/issues$' % project_uri: 'post_issue',
         '/repos/%s/issues/[0-9]*$' % project_uri: 'update_status'
     }
     super(GitHubResponseGenerator, self).__init__(rest_api_targets, resource_templates, test_dir)
Ejemplo n.º 6
0
    def alm_get_task(self, task):
        task_id = task['title']

        try:
            # We need to perform 2 API calls to search open and closed issues
            open_issues = self.alm_plugin.call_api('legacy/issues/search/%s/%s/%s' %
                                                   (self.project_uri,
                                                    self.config[self.ALM_NEW_STATUS],
                                                    urlencode_str(task_id)))
            closed_issues = self.alm_plugin.call_api('legacy/issues/search/%s/%s/%s' %
                                                     (self.project_uri,
                                                      self.config[self.ALM_DONE_STATUSES][0],
                                                      urlencode_str(task_id)))
        except APIError, err:
            logger.error(err)
            raise AlmException('Unable to get task %s from GitHub' % task_id)
Ejemplo n.º 7
0
    def alm_get_task_legacy(self, task):
        """
        Returns a RationalTask object that has the same ID as the given task
        """
        try:
            work_items = self._call_api(
                '%s/workitems?oslc.where=dcterms:title="%s*"' % (self.query_url, urlencode_str(task["alm_fixed_title"]))
            )
        except APIError as err:
            logger.error(err)
            raise AlmException("Unable to get task %s from %s" % (task["task_id"], self.alm_name))

        if work_items["oslc:responseInfo"]["oslc:totalCount"] == 0:
            return None

        work_item_url = work_items["oslc:results"][0]["rdf:resource"]
        work_item_target = work_item_url.replace(self.alm_plugin.base_uri + "/", "")
        try:
            work_item = self._call_api(work_item_target)
        except APIError as err:
            logger.error(err)
            raise AlmException("Unable to get task %s from %s" % (task["task_id"], self.alm_name))

        logger.info("Found task: %s", task["task_id"])
        return self.get_task_object(task, work_item)
Ejemplo n.º 8
0
    def pt_get_epic(self, group_name):
        try:
            epic = self.alm_plugin.call_api('%s/epics?filter=%s&fields=id' %
                                            (self.project_uri, urlencode_str(group_name)))
        except APIError as err:
            raise AlmException('Unable to get epic %s from PivotalTracker because of %s'
                               % (group_name, err))

        return epic
Ejemplo n.º 9
0
    def alm_connect_project(self):
        # Connect to the project
        try:
            user = self._call_api('%s/customization/users/%s' % (self.project_uri, urlencode_str(self.config['alm_user'])))
        except APIError as err:
            raise AlmException('Unable to verify domain and project details: %s' % (err))

        if user['Name'] != self.config['alm_user']:
            raise AlmException('Unable to verify user access to domain and project')
Ejemplo n.º 10
0
    def initialize(self):
        super(HPAlmConnector, self).initialize()
        # Verify that the configuration options are set properly
        for item in ['hp_alm_done_statuses', 'hp_alm_issue_type', 'hp_alm_new_status', 'hp_alm_domain']:
            if not self.config[item]:
                raise AlmException('Missing %s in configuration' % item)

        self.config.process_list_config('hp_alm_done_statuses')
        self.COOKIE_LWSSO = None
        self.COOKIE_QCSession = None
        self.issue_type = None
        self.mark_down_converter = markdown.Markdown(safe_mode="escape")
        self.project_uri = 'rest/domains/%s/projects/%s' % (urlencode_str(self.config['hp_alm_domain']),
                                                            urlencode_str(self.config['alm_project']))
        self.test_plan_folder_id = None
        self.hp_alm_test_type_id = None
        # We will map requirements its associated tests based on the problem id
        self.requirement_to_test_mapping = {}
        self.fields = {}
        self.references = {}
Ejemplo n.º 11
0
    def alm_get_task_legacy(self, task):
        try:
            # We need to perform 2 API calls to search open and closed issues
            open_issues = self.alm_plugin.call_api('legacy/issues/search/%s/%s/%s' %
                                                   (self.project_uri,
                                                    GITHUB_NEW_STATUS,
                                                    urlencode_str(task['alm_fixed_title'])))
            closed_issues = self.alm_plugin.call_api('legacy/issues/search/%s/%s/%s' %
                                                     (self.project_uri,
                                                      GITHUB_DONE_STATUS,
                                                      urlencode_str(task['alm_fixed_title'])))
        except APIError as err:
            raise AlmException('Unable to get task %s from GitHub. Reason: %s' % (task['task_id'], str(err)))

        issues_list = open_issues['issues']
        issues_list.extend(closed_issues['issues'])

        if not issues_list:
            return None

        index = 0

        # Prune list of issues labeled as duplicate
        while index < len(issues_list):
            issue = issues_list[index]
            duplicate_label = self.config[self.GITHUB_DUPLICATE_LABEL]

            if issue['labels'].count(duplicate_label) > 0:
                issues_list.pop(index)
            else:
                index += 1

        if len(issues_list) > 1:
            logger.warning('Found multiple issues with the title %s that are not labeled as duplicates.'
                           'Selecting the first task found with id %s' % (task['task_id'], issues_list[0]['number']))
        elif not issues_list:
            return None

        logger.info('Found task: %s', task['task_id'])
        return self.get_task_object(task, issues_list[0])
 def __init__(self, config, test_dir=None):
     self.new_status = config['hp_alm_new_status']
     hp_alm_domain = urlencode_str(config['hp_alm_domain'])
     hp_alm_project = urlencode_str(config['alm_project'])
     self.hp_alm_user = config['alm_user']
     project_uri = '/qcbin/rest/domains/%s/projects/%s' % (hp_alm_domain, hp_alm_project)
     resource_templates = ['user.json', 'requirement.json', 'test.json', 'test-folder.json', 'requirement-coverage.json']
     rest_api_targets = {
         '/qcbin/authentication-point/authenticate': 'authenticate',
         '/qcbin/rest/site-session': 'get_session',
         '%s/requirements' % project_uri: 'call_requirements',
         '%s/customization/users/%s' % (project_uri, urlencode_str(self.hp_alm_user)): 'get_user',
         '%s/customization/entities/requirement/types/' % project_uri: 'get_requirement_types',
         '%s/customization/entities/test/types/' % project_uri: 'get_test_types',
         '%s/customization/used-lists\?name=Status' % project_uri: 'get_status_types',
         '%s/customization/entities/requirement/fields/' % project_uri: 'get_entity_fields',
         '%s/customization/entities/test/fields/' % project_uri: 'get_entity_fields',
         '%s/test-folders' % project_uri: 'call_test_folders',
         '%s/tests' % project_uri: 'call_tests',
         '/qcbin/authentication-point/logout': 'logout',
         '%s/requirement-coverages' % project_uri: 'call_requirement_coverage'
     }
     super(HPAlmResponseGenerator, self).__init__(rest_api_targets, resource_templates, test_dir)
Ejemplo n.º 13
0
    def add_epic(self, target, flag, data, method):
        if not flag and data:
            epic_name = urlencode_str(data['name'])

            if len(self.generator_get_filtered_resource('epic', {'name': epic_name})) == 0:
                resource_data = data
                resource_data['project_id'] = self.project_id
                resource_data['id'] = random.randint(1, 999999999)
                self.generator_add_resource('epic', resource_data['id'], resource_data)

                return RESPONSE_HEADERS, self.generate_resource_from_template('epic', resource_data)
            else:
                self.raise_error('500', 'Epic %s already exists!' % data['name'])
        else:
            self.raise_error('401')
Ejemplo n.º 14
0
    def pt_get_release_marker_id(self, release_name):
        try:
            release_markers = self.alm_plugin.call_api('%s/stories?filter=type:release,%s&fields=id' %
                                                       (self.project_uri, urlencode_str(release_name)))
        except APIError as err:
            raise AlmException('Could not find release marker %s in PivotalTracker because of %s'
                               % (release_name, err))

        if not release_markers:
            raise AlmException('Could not find release marker %s in PivotalTracker' % release_name)

        release_marker = release_markers[0]

        if len(release_markers) > 1:
            logger.warning('Found multiple release markers with the title %s. Selecting the first release marker'
                           'found with id %s' % (release_name, release_marker['id']))

        if release_marker.get('error'):
            raise AlmException('Could not find release marker %s in PivotalTracker. Reason: %s - %s'
                               % (release_name, release_marker['code'], release_marker['general_problem']))
        else:
            return release_marker['id']
Ejemplo n.º 15
0
    def alm_get_task_legacy(self, task):
        alm_identity = self._clean_title(task['alm_fixed_title'])
        try:
            # Fields parameter will filter response data to only contain story status, name, timestamp and id
            target = ('%s/stories?filter="%s"&fields=url,current_state,name,updated_at,id,estimate,story_type' %
                      (self.project_uri, urlencode_str(alm_identity)))
            stories = self.alm_plugin.call_api(target)
        except APIError as err:
            logger.error(err)
            raise AlmException('Unable to get story from PivotalTracker for task %s' % task['task_id'])

        if not stories:
            return None

        story = stories[0]

        if len(stories) > 1:
            logger.warning('Found multiple issues with the title %s. Selecting the first task found with id %s'
                           % (alm_identity, story['id']))

        logger.info('Found task: %s', task['task_id'])
        updateable = story['story_type'] not in self.requires_estimate or story.get('estimate') is not None

        return self.get_task_object(task, story, updateable)
Ejemplo n.º 16
0
 def _hp_query_encoder(query):
     return urlencode_str(query).replace('+', '%20')