Exemple #1
0
    def main(self, folder, **kwargs):
        with utils.stash_local_changes(folder):
            original_merge_base = folder.git_merge_base

            folder.run_git_command("merge", "jira", failure_ok=True)

            final_merge_base = folder.git_merge_base

            new_comments = folder.run_git_command(
                "diff",
                "%s..%s" % (original_merge_base, final_merge_base),
                "--",
                constants.TICKET_COMMENTS,
            ).strip()
            if new_comments:
                folder.log("New comment(s) have been posted.")

            jira_fields = JiraFieldManager.create(folder, revision="jira")
            master_fields = JiraFieldManager.create(
                folder, revision=original_merge_base
            )
            for field, values in (jira_fields - master_fields).items():
                folder.log(
                    u'Field {field} changed: "{fr}" -> "{to}"'.format(
                        field=field,
                        fr=self.truncate_field_value(values[0]),
                        to=self.truncate_field_value(values[1]),
                    )
                )

            jira_links = JiraLinkManager.create(folder, revision="jira")
            master_links = JiraLinkManager.create(folder, revision=original_merge_base)
            for category in ("issue", "remote"):
                values_dict = (jira_links - master_links).get(category, {})
                for field, values in values_dict.items():
                    folder.log(
                        u'Link {field} changed: "{fr}" -> "{to}"'.format(
                            field=field, fr=values[0], to=values[1]
                        )
                    )

            if original_merge_base != final_merge_base:
                folder.log(
                    "Merged 'jira' into 'master'; merge-base is now %s"
                    % (final_merge_base)
                )

            conflicted_files = folder.run_git_command(
                "diff", "--name-only", "--diff-filter=U",
            ).strip()
            if conflicted_files:
                folder.log(
                    "Conflicts between your local changes and Jira were found!",
                    level=logging.WARN,
                )

            return utils.PostStatusResponse(
                original_merge_base == final_merge_base, final_merge_base
            )
    def test_decode(self):
        encoded_values = dedent("""
            * summary:
                This is a test summary
            * longer_message:
                This is a much
                longer message that happens
                to contain newlines.
        """)

        expected_result = {
            'summary': 'This is a test summary',
            'longer_message': (
                'This is a much\n'
                'longer message that happens\n'
                'to contain newlines.'
            )
        }

        actual_result = JiraFieldManager(
            encoded_values
        )

        self.assertEqual(
            expected_result,
            actual_result
        )
    def test_decode_with_human_readable_field_names(self):
        encoded_values = dedent("""
            * Summary:
                This is a test summary
            * Longer Message:
                This is a much
                longer message that happens
                to contain newlines.
            * Something(s) that are Company-Specific (customfield_108234):
                This is something else
        """)

        expected_result = {
            'Summary': 'This is a test summary',
            'Longer_Message': (
                'This is a much\n'
                'longer message that happens\n'
                'to contain newlines.'
            ),
            'customfield_108234': (
                'This is something else'
            )
        }

        actual_result = JiraFieldManager(
            encoded_values
        )

        self.assertEqual(
            expected_result,
            actual_result
        )
Exemple #4
0
    def test_fetch(self):
        self.ticketfolder._issue = self.rehydrate_issue("test_fetch/fetched.json")
        with patch.object(self.ticketfolder, "clear_cache") as clear_cache:
            run_command_method_with_kwargs(
                "fetch", folder=self.ticketfolder,
            )
            self.assertTrue(clear_cache.called)

        expected_result = JiraFieldManager(
            self.get_asset_contents("test_fetch/fetched.jira")
        )
        with io.open(
            self.ticketfolder.get_shadow_path("fields.jira"), encoding="utf-8"
        ) as _in:
            actual_result = JiraFieldManager(_in.read())

        self.assertEqual(actual_result, expected_result)
Exemple #5
0
    def merge(self, folder):
        with utils.stash_local_changes(folder):
            original_merge_base = folder.git_merge_base
            folder.run_git_command('merge', 'jira')
            final_merge_base = folder.git_merge_base

            new_comments = folder.run_git_command(
                'diff',
                '%s..%s' % (original_merge_base, final_merge_base),
                '--',
                constants.TICKET_COMMENTS,
            ).strip()
            if new_comments:
                folder.log("New comment(s) have been posted.")

            jira_fields = JiraFieldManager.create(folder, revision='jira')
            master_fields = JiraFieldManager.create(
                folder, revision=original_merge_base)
            for field, values in (jira_fields - master_fields).items():
                folder.log(
                    "Field {field} changed: \"{fr}\" -> \"{to}\"".format(
                        field=field, fr=values[0], to=values[1]))

            jira_links = JiraLinkManager.create(folder, revision='jira')
            master_links = JiraLinkManager.create(folder,
                                                  revision=original_merge_base)
            for category in ('issue', 'remote'):
                values_dict = (jira_links - master_links).get(category, {})
                for field, values in values_dict.items():
                    folder.log(
                        "Link {field} changed: \"{fr}\" -> \"{to}\"".format(
                            field=field, fr=values[0], to=values[1]))

            if original_merge_base != final_merge_base:
                folder.log(
                    "Merged 'jira' into 'master'; merge-base is now %s" %
                    (final_merge_base))
            return utils.PostStatusResponse(
                original_merge_base == final_merge_base, final_merge_base)
    def test_decode_with_json_values(self):
        encoded_values = dedent("""
            * dictionary_field:
                {
                    "name": "Adam Coddington"
                }
            * integer_field:
                10
            * string_field:
                Hello
            * list_field:
                [
                    "Alphabet",
                    {
                        "One": "Two"
                    }
                ]
        """)

        expected_result = {
            "dictionary_field": {
                "name": "Adam Coddington"
            },
            "integer_field": 10,
            "string_field": "Hello",
            "list_field": [
                "Alphabet",
                {
                    "One": "Two",
                }
            ]
        }

        actual_result = JiraFieldManager(
            encoded_values
        )

        self.assertEqual(
            expected_result,
            actual_result,
        )
    def test_decode(self):
        encoded_values = dedent("""
            * summary (summary):
                This is a test summary
            * Longer Message (longer_message):
                This is a much
                longer message that happens
                to contain newlines.
        """)

        expected_result = {
            "summary":
            "This is a test summary",
            "longer_message": ("This is a much\n"
                               "longer message that happens\n"
                               "to contain newlines."),
        }

        actual_result = JiraFieldManager(encoded_values)

        self.assertEqual(expected_result, actual_result)
Exemple #8
0
    def main(self, folder, **kwargs):
        with utils.stash_local_changes(folder):
            original_merge_base = folder.git_merge_base
            folder.run_git_command('merge', 'jira')
            final_merge_base = folder.git_merge_base

            new_comments = folder.run_git_command(
                'diff',
                '%s..%s' % (
                    original_merge_base,
                    final_merge_base
                ),
                '--',
                constants.TICKET_COMMENTS,
            ).strip()
            if new_comments:
                folder.log(
                    "New comment(s) have been posted."
                )

            jira_fields = JiraFieldManager.create(
                folder, revision='jira'
            )
            master_fields = JiraFieldManager.create(
                folder, revision=original_merge_base
            )
            for field, values in (jira_fields - master_fields).items():
                folder.log(
                    u"Field {field} changed: \"{fr}\" -> \"{to}\"".format(
                        field=field,
                        fr=self.truncate_field_value(values[0]),
                        to=self.truncate_field_value(values[1])
                    )
                )

            jira_links = JiraLinkManager.create(
                folder, revision='jira'
            )
            master_links = JiraLinkManager.create(
                folder, revision=original_merge_base
            )
            for category in ('issue', 'remote'):
                values_dict = (jira_links - master_links).get(category, {})
                for field, values in values_dict.items():
                    folder.log(
                        u"Link {field} changed: \"{fr}\" -> \"{to}\"".format(
                            field=field,
                            fr=values[0],
                            to=values[1]
                        )
                    )

            if original_merge_base != final_merge_base:
                folder.log(
                    "Merged 'jira' into 'master'; merge-base is now %s" % (
                        final_merge_base
                    )
                )
            return utils.PostStatusResponse(
                original_merge_base == final_merge_base,
                final_merge_base
            )