From d996a2f96add9d6a1a36cf0196c75c330661220e Mon Sep 17 00:00:00 2001 From: Brandon Nielsen Date: Oct 27 2022 12:08:30 +0000 Subject: [PATCH 1/2] Add tests for report_results module. The tests attempt to exercise report_results with minimal patching and the patching that is done attempts to be straightforward. This does result in many duplicate assert calls across tests checking things like calls to 'print' to verify program flow progressed as expected during the test. Tests were coverage guided. Additional pull requests will follow to shore up additional gaps in coverage. --- diff --git a/relval/tests/__init__.py b/relval/tests/__init__.py new file mode 100644 index 0000000..348fa77 --- /dev/null +++ b/relval/tests/__init__.py @@ -0,0 +1,20 @@ +# Copyright Red Hat +# +# This file is part of relval. +# +# wikitcms is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . +# +# Authors: +# Brandon Nielsen +# diff --git a/relval/tests/test_report_results.py b/relval/tests/test_report_results.py new file mode 100644 index 0000000..00c2ab4 --- /dev/null +++ b/relval/tests/test_report_results.py @@ -0,0 +1,1827 @@ +# Copyright Red Hat +# +# This file is part of relval. +# +# wikitcms is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . +# +# Authors: +# Brandon Nielsen +# +import unittest + +from relval.report_results import check_nightly, comment_string, get_confirm, get_response, get_response_list, get_result, report_results +from unittest.mock import Mock, call, patch + +# A decorator so we can maintain a reference to a patched +# function and call it +def reference_wrapper(function): + def wrapped(*args, **kwargs): + return function(*args, **kwargs) + + return wrapped + +class TestCommentString(unittest.TestCase): + def test_basic_functionality(self): + self.assertEqual(comment_string("test"), "test") + + # Make sure the string is stripped + self.assertEqual(comment_string("\ttest\n"), "test") + self.assertEqual(comment_string(" test "), "test") + + def test_empty_string(self): + self.assertEqual(comment_string(""), "") + + def test_maxlen(self): + # Repeat "a" 251 times, check exception + with self.assertRaises(ValueError): + comment_string("a" * 251) + + with self.assertRaises(ValueError): + comment_string("test", maxlen=3) + +class TestCheckNightly(unittest.TestCase): + @patch("relval.report_results.get_date_type_respin") + def test_nightly(self, mockGetRespin): + mockGetRespin.return_value = ("", "nightly", "") + + self.assertTrue(check_nightly("teststring")) + + mockGetRespin.assert_called_with("teststring") + + @patch("relval.report_results.get_date_type_respin") + def test_rc(self, mockGetRespin): + mockGetRespin.return_value = ("", "RC", "") + + self.assertFalse(check_nightly("teststring")) + + mockGetRespin.assert_called_with("teststring") + + @patch("relval.report_results.get_date_type_respin") + def test_exception(self, mockGetRespin): + mockGetRespin.side_effect = ValueError() + + self.assertFalse(check_nightly("teststring")) + + mockGetRespin.assert_called_with("teststring") + +class TestGetResponse(unittest.TestCase): + def test_no_accepted_or_accfunc(self): + with self.assertRaises(ValueError): + get_response("test prompt", "test help text") + + @patch("relval.report_results.input") + def test_accfunc(self, mockInput): + # Verify a response can be accepted by accfunc + mockInput.return_value = "test input" + + mockAccFunc = Mock() + + mockAccFunc.return_value = True + + result = get_response("test prompt", "", accfunc=mockAccFunc) + + self.assertEqual(result, "test input") + + mockInput.assert_called_with("test prompt") + mockAccFunc.assert_called_with("test input") + + @patch("relval.report_results.input") + def test_accfunc_case_insensitivity(self, mockInput): + # Verify responses are case insensitive + mockInput.return_value = "tEsT InPuT" + + mockAccFunc = Mock() + + mockAccFunc.return_value = True + + result = get_response("test prompt", "", accfunc=mockAccFunc) + + self.assertEqual(result, "test input") + + mockInput.assert_called_with("test prompt") + mockAccFunc.assert_called_with("test input") + + @patch("relval.report_results.input") + @patch("relval.report_results.print") + def test_accfunc_not_accepted(self, mockPrint, mockInput): + # Don't accept once, accept the second time, ensure the user is + # prompted a second time with help test + mockInput.return_value = "test input" + + mockAccFunc = Mock() + + mockAccFunc.side_effect = [False, True] + + result = get_response("test prompt", "test help text", accfunc=mockAccFunc) + + self.assertEqual(result, "test input") + + self.assertEqual(mockInput.mock_calls, [call("test prompt"), call("test prompt")]) + self.assertEqual(mockAccFunc.mock_calls, [call("test input"), call("test input")]) + mockPrint.assert_called_with("Invalid response. test help text") + + @patch("relval.report_results.input") + def test_accepted(self, mockInput): + # Verify a response can be accepted by a list of accepted values + mockInput.return_value = "test input" + + result = get_response("test prompt", "", accepted=["test input"]) + + self.assertEqual(result, "test input") + + mockInput.assert_called_with("test prompt") + + @patch("relval.report_results.input") + @patch("relval.report_results.print") + def test_accepted_not_accepted(self, mockPrint, mockInput): + # Invalid value once, valid the second time, ensure the user is + # prompted a second time with help test + mockInput.side_effect = ["invalid test input", "test input"] + + result = get_response("test prompt", "test help text", accepted=["test input"]) + + self.assertEqual(result, "test input") + + self.assertEqual(mockInput.mock_calls, [call("test prompt"), call("test prompt")]) + mockPrint.assert_called_with("Invalid response. test help text") + + @patch("relval.report_results.input") + def test_accepted_case_insensitivity(self, mockInput): + # Verify responses are case insensitive + mockInput.return_value = "tEsT InPuT" + + result = get_response("test prompt", "", accepted=["test input"]) + + self.assertEqual(result, "test input") + + mockInput.assert_called_with("test prompt") + +class TestGetConfirm(unittest.TestCase): + @patch("relval.report_results.get_response") + def test_get_confirm(self, mockGetResponse): + # Verify get_confirm just gets a yes or no response + result = get_confirm() + + self.assertEqual(result, mockGetResponse.return_value) + + mockGetResponse.assert_called_with("Confirm y/n? ", helptext="Answer y or n", accepted=("y", "n")) + +class TestGetResponseList(unittest.TestCase): + @patch("relval.report_results.get_response") + def test_get_response_list(self, mockGetResponse): + # Call twice to double check the result in converted to 0 index, and + # cast to an int + mockGetResponse.side_effect = ["2", "1"] + + self.assertEqual(get_response_list("test prompt", ["test item 1", "test item 2"]), 1) + self.assertEqual(get_response_list("test prompt", ["test item 1", "test item 2"]), 0) + + self.assertEqual(mockGetResponse.mock_calls, [call("1) test item 1\n2) test item 2\ntest prompt", "Pick a number between 1 and 2", accepted=["1", "2"]), call("1) test item 1\n2) test item 2\ntest prompt", "Pick a number between 1 and 2", accepted=["1", "2"])]) + +class TestGetResult(unittest.TestCase): + @patch("relval.report_results.get_response") + @patch("relval.report_results.input") + @patch("relval.report_results.wikitcms.result.Result") + def test_get_result_pass(self, mockResult, mockInput, mockGetResponse): + # Test a pass, no issue, no comment + mockGetResponse.return_value = "p" + + mockInput.side_effect = ["", ""] + + result = get_result("testusername") + + self.assertEqual(result, mockResult.return_value) + + mockGetResponse.assert_called_with("Would you like to report a (p)ass, (f)ail or (w)arn? ", "Please choose (p)ass, (f)ail or (w)arn.", accepted=('p', 'f', 'w')) + self.assertEqual(mockInput.mock_calls, [call("Enter the IDs of any bugs associated with this report, separated by commas. "), call("Enter a comment if you like. If not, just hit Enter.\nMaximum length is 250 characters.\nPlease don't leave a comment unless it's really necessary.\nComment: ")]) + mockResult.assert_called_with("pass", "testusername", None, "") + + @patch("relval.report_results.get_response") + @patch("relval.report_results.input") + @patch("relval.report_results.wikitcms.result.Result") + def test_get_result_fail(self, mockResult, mockInput, mockGetResponse): + # Test a fail, no issue, no comment + mockGetResponse.return_value = "f" + + mockInput.side_effect = ["", ""] + + result = get_result("testusername") + + self.assertEqual(result, mockResult.return_value) + + mockGetResponse.assert_called_with("Would you like to report a (p)ass, (f)ail or (w)arn? ", "Please choose (p)ass, (f)ail or (w)arn.", accepted=('p', 'f', 'w')) + self.assertEqual(mockInput.mock_calls, [call("Enter the IDs of any bugs associated with this report, separated by commas. "), call("Enter a comment if you like. If not, just hit Enter.\nMaximum length is 250 characters.\nPlease don't leave a comment unless it's really necessary.\nComment: ")]) + mockResult.assert_called_with("fail", "testusername", None, "") + + @patch("relval.report_results.get_response") + @patch("relval.report_results.input") + @patch("relval.report_results.wikitcms.result.Result") + def test_get_result_warn(self, mockResult, mockInput, mockGetResponse): + # Test a warn, no issue, no comment + mockGetResponse.return_value = "w" + + mockInput.side_effect = ["", ""] + + result = get_result("testusername") + + self.assertEqual(result, mockResult.return_value) + + mockGetResponse.assert_called_with("Would you like to report a (p)ass, (f)ail or (w)arn? ", "Please choose (p)ass, (f)ail or (w)arn.", accepted=('p', 'f', 'w')) + self.assertEqual(mockInput.mock_calls, [call("Enter the IDs of any bugs associated with this report, separated by commas. "), call("Enter a comment if you like. If not, just hit Enter.\nMaximum length is 250 characters.\nPlease don't leave a comment unless it's really necessary.\nComment: ")]) + mockResult.assert_called_with("warn", "testusername", None, "") + + @patch("relval.report_results.get_response") + @patch("relval.report_results.input") + @patch("relval.report_results.wikitcms.result.Result") + def test_get_result_bugs(self, mockResult, mockInput, mockGetResponse): + # Test "bugs" response + mockGetResponse.return_value = "f" + + mockInput.side_effect = ["1,2", ""] + + result = get_result("testusername") + + self.assertEqual(result, mockResult.return_value) + + mockResult.assert_called_with("fail", "testusername", ["1", "2"], "") + + @patch("relval.report_results.get_response") + @patch("relval.report_results.input") + @patch("relval.report_results.wikitcms.result.Result") + def test_get_result_comment(self, mockResult, mockInput, mockGetResponse): + # Test comment, verify it's commented correctly + mockGetResponse.return_value = "p" + + mockInput.side_effect = ["", "test comment"] + + result = get_result("testusername") + + self.assertEqual(result, mockResult.return_value) + + mockResult.assert_called_with("pass", "testusername", None, "test comment") + + @patch("relval.report_results.get_response") + @patch("relval.report_results.input") + @patch("relval.report_results.wikitcms.result.Result") + def test_get_result_comment_length(self, mockResult, mockInput, mockGetResponse): + # Test comment, verify a reprompt if the comment is too long + mockGetResponse.return_value = "p" + + # Repeat "a" 251 times (over the limit), then try again + mockInput.side_effect = ["", "a" * 251, "test comment"] + + result = get_result("testusername") + + self.assertEqual(result, mockResult.return_value) + + mockResult.assert_called_with("pass", "testusername", None, "test comment") + + # Check for reprompt + self.assertEqual(mockInput.mock_calls, [call("Enter the IDs of any bugs associated with this report, separated by commas. "), call("Enter a comment if you like. If not, just hit Enter.\nMaximum length is 250 characters.\nPlease don't leave a comment unless it's really necessary.\nComment: "), call("Comment was too long: 251 characters. Please make it 250 characters or fewer.\nComment: ")]) + +class TestReportResult(unittest.TestCase): + def test_report_results_no_username(self): + mockWiki = Mock() + + # A None username should lead to an exception and a sysexit + mockWiki.username = None + + with self.assertRaises(SystemExit) as exitException: + report_results(mockWiki) + + # Hacky check that the exit was called with the desired message + self.assertEqual(str(exitException.exception), "ERROR: Cannot find wiki username! Not logged in?") + + @patch("relval.report_results.get_response") + @patch("relval.report_results.get_confirm") + @patch("relval.report_results.get_result") + @patch("relval.report_results.print") + @patch("relval.report_results.PAGE") + @patch("relval.report_results.SECTIONS", [{'index': "test 1", 'line': "test section"}]) + def test_report_results(self, mockPage, mockPrint, mockGetResult, mockGetConfirm, mockGetResponse): + mockWiki = Mock() + + mockTestResult = Mock() + mockTestResult.secid = "test 1" + mockTestResult.results = {'1': None} + mockTestResult.testcase = "test case" + + mockPage.name = "test page" + mockPage.get_resultrows.return_value = [mockTestResult] + + mockWiki.get_current_compose.return_value = {'release': 99, 'milestone': "test", 'compose': "", 'date': "20220708"} + + # Quit after get_result + mockGetResponse.return_value = "q" + + # Confirm release 99 + mockGetConfirm.return_value = "y" + + # Result is "pass" + mockGetResult.return_value = "pass" + + with self.assertRaises(SystemExit): + report_results(mockWiki) + + mockPage.add_result.assert_called_with("pass", mockTestResult, "1") + + mockWiki.get_current_compose.assert_called_with(dist="Fedora") + + self.assertEqual(mockGetResponse.mock_calls, [call("Report another result for this (s)ection, or (p)age, or this (c)ompose, or (q)uit? ", "Please choose (s)ection, (p)age, (c)ompose, or (q)uit.", ("s", "p", "c", "q"))]) + + self.assertEqual(mockGetConfirm.mock_calls, [call()]) + + self.assertEqual(mockGetResult.mock_calls, [call(mockWiki.username.lower())]) + + self.assertEqual(mockPrint.mock_calls, [call("Detecting current compose version..."), call("Will report results for compose: Fedora 99 test 20220708"), call("Will report pass for test test case in section test section of test page"), call("Succeeded!")]) + + @patch("relval.report_results.get_response_list") + @patch("relval.report_results.get_response") + @patch("relval.report_results.get_confirm") + @patch("relval.report_results.get_result") + @patch("relval.report_results.print") + @patch("relval.report_results.PAGE") + @patch("relval.report_results.SECTIONS", [{'index': "test 1", 'line': "test section"}]) + def test_report_results_release_and_compose(self, mockPage, mockPrint, mockGetResult, mockGetConfirm, mockGetResponse, mockGetResponseList): + # Test with release and compose provided + mockWiki = Mock() + + mockTestResult = Mock() + mockTestResult.secid = "test 1" + mockTestResult.results = {'1': None} + mockTestResult.testcase = "test case" + + mockPage.name = "test page" + mockPage.get_resultrows.return_value = [mockTestResult] + + # "Fedora" + mockGetResponseList.return_value = 0 + + # Quit after get_result + mockGetResponse.return_value = "q" + + # Confirm release 99 + mockGetConfirm.return_value = "y" + + # Result is "pass" + mockGetResult.return_value = "pass" + + with self.assertRaises(SystemExit): + report_results(mockWiki, release=99, compose="test compose") + + mockPage.add_result.assert_called_with("pass", mockTestResult, "1") + + self.assertEqual(mockGetResponseList.mock_calls, [call("What compose type are you reporting results for? ", ("Fedora", "Fedora-IoT"))]) + + self.assertEqual(mockGetResponse.mock_calls, [call('Report another result for this (s)ection, or (p)age, or this (c)ompose, or (q)uit? ', 'Please choose (s)ection, (p)age, (c)ompose, or (q)uit.', ('s', 'p', 'c', 'q'))]) + + self.assertEqual(mockGetConfirm.mock_calls, [call()]) + + self.assertEqual(mockGetResult.mock_calls, [call(mockWiki.username.lower())]) + + self.assertEqual(mockPrint.mock_calls, [call("Will report results for compose: Fedora 99 test compose"), call("Will report pass for test test case in section test section of test page"), call("Succeeded!")]) + + @patch("relval.report_results.get_response") + @patch("relval.report_results.get_confirm") + @patch("relval.report_results.get_result") + @patch("relval.report_results.print") + @patch("relval.report_results.PAGE") + @patch("relval.report_results.SECTIONS", [{'index': "test 1", 'line': "test section"}]) + def test_report_results_release_only(self, mockPage, mockPrint, mockGetResult, mockGetConfirm, mockGetResponse): + # Test with only release + mockWiki = Mock() + + mockTestResult = Mock() + mockTestResult.secid = "test 1" + mockTestResult.results = {'1': None} + mockTestResult.testcase = "test case" + + mockPage.name = "test page" + mockPage.get_resultrows.return_value = [mockTestResult] + + mockWiki.get_current_compose.return_value = {'release': 99, 'milestone': "test", 'compose': "", 'date': "20220708"} + + # Quit after get_result + mockGetResponse.return_value = "q" + + # Confirm release 99 + mockGetConfirm.return_value = "y" + + # Result is "pass" + mockGetResult.return_value = "pass" + + with self.assertRaises(SystemExit): + report_results(mockWiki, release=97) + + mockPage.add_result.assert_called_with("pass", mockTestResult, "1") + + self.assertEqual(mockGetResponse.mock_calls, [call('Report another result for this (s)ection, or (p)age, or this (c)ompose, or (q)uit? ', 'Please choose (s)ection, (p)age, (c)ompose, or (q)uit.', ('s', 'p', 'c', 'q'))]) + + self.assertEqual(mockGetConfirm.mock_calls, [call()]) + + self.assertEqual(mockGetResult.mock_calls, [call(mockWiki.username.lower())]) + + self.assertEqual(mockPrint.mock_calls, [call("When specifying the compose version by parameters, you must pass at least a release and a compose. Your version-related parameters will not be used."), call("Detecting current compose version..."), call("Will report results for compose: Fedora 99 test 20220708"), call("Will report pass for test test case in section test section of test page"), call("Succeeded!")]) + + @patch("relval.report_results.get_response") + @patch("relval.report_results.get_confirm") + @patch("relval.report_results.get_result") + @patch("relval.report_results.print") + @patch("relval.report_results.PAGE") + @patch("relval.report_results.SECTIONS", [{'index': "test 1", 'line': "test section"}]) + def test_report_results_compose_only(self, mockPage, mockPrint, mockGetResult, mockGetConfirm, mockGetResponse): + # Test with only compose + mockWiki = Mock() + + mockTestResult = Mock() + mockTestResult.secid = "test 1" + mockTestResult.results = {'1': None} + mockTestResult.testcase = "test case" + + mockPage.name = "test page" + mockPage.get_resultrows.return_value = [mockTestResult] + + mockWiki.get_current_compose.return_value = {'release': 99, 'milestone': "test", 'compose': "", 'date': "20220708"} + + # Quit after get_result + mockGetResponse.return_value = "q" + + # Confirm release 99 + mockGetConfirm.return_value = "y" + + # Result is "pass" + mockGetResult.return_value = "pass" + + with self.assertRaises(SystemExit): + report_results(mockWiki, compose="20221006") + + mockPage.add_result.assert_called_with("pass", mockTestResult, "1") + + self.assertEqual(mockGetResponse.mock_calls, [call('Report another result for this (s)ection, or (p)age, or this (c)ompose, or (q)uit? ', 'Please choose (s)ection, (p)age, (c)ompose, or (q)uit.', ('s', 'p', 'c', 'q'))]) + + self.assertEqual(mockGetConfirm.mock_calls, [call()]) + + self.assertEqual(mockGetResult.mock_calls, [call(mockWiki.username.lower())]) + + self.assertEqual(mockPrint.mock_calls, [call("When specifying the compose version by parameters, you must pass at least a release and a compose. Your version-related parameters will not be used."), call("Detecting current compose version..."), call("Will report results for compose: Fedora 99 test 20220708"), call("Will report pass for test test case in section test section of test page"), call("Succeeded!")]) + + @patch("relval.report_results.check_nightly") + @patch("relval.report_results.get_response") + @patch("relval.report_results.get_confirm") + @patch("relval.report_results.get_result") + @patch("relval.report_results.print") + @patch("relval.report_results.PAGE") + @patch("relval.report_results.SECTIONS", [{'index': "test 1", 'line': "test section"}]) + def test_report_results_release_only_no_current_compose(self, mockPage, mockPrint, mockGetResult, mockGetConfirm, mockGetResponse, mockCheckNightly): + # Test with only release without a current compose + mockWiki = Mock() + + mockTestResult = Mock() + mockTestResult.secid = "test 1" + mockTestResult.results = {'1': None} + mockTestResult.testcase = "test case" + + mockPage.name = "test page" + mockPage.get_resultrows.return_value = [mockTestResult] + + mockWiki.get_current_compose.return_value = None + + # Nightly, 20221006.n.1, quit after get_result + mockGetResponse.side_effect = ["n", "20221006.n.1", "q"] + + # Confirm release 99 + mockGetConfirm.return_value = "y" + + # Result is "pass" + mockGetResult.return_value = "pass" + + mockCheckNightly.return_value = True + + with self.assertRaises(SystemExit): + report_results(mockWiki, release=97) + + mockPage.add_result.assert_called_with("pass", mockTestResult, "1") + + self.assertEqual(mockGetResponse.mock_calls, [call("Would you like to report a result for a milestone (c)ompose or a (n)ightly compose? ", "Please choose (c)ompose or (n)ightly.", accepted=("c", "n")), call("What nightly would you like to report a result for? ", "Nightly must be YYYYMMDD.n.N (e.g. 20160314.n.0)", accfunc=mockCheckNightly), call('Report another result for this (s)ection, or (p)age, or this (c)ompose, or (q)uit? ', 'Please choose (s)ection, (p)age, (c)ompose, or (q)uit.', ('s', 'p', 'c', 'q'))]) + + self.assertEqual(mockGetConfirm.mock_calls, [call()]) + + self.assertEqual(mockGetResult.mock_calls, [call(mockWiki.username.lower())]) + + self.assertEqual(mockPrint.mock_calls, [call("When specifying the compose version by parameters, you must pass at least a release and a compose. Your version-related parameters will not be used."), call("Detecting current compose version..."), call("Will report results for compose: Fedora 97 20221006.n.1"), call("Will report pass for test test case in section test section of test page"), call("Succeeded!")]) + + @patch("relval.report_results.check_nightly") + @patch("relval.report_results.get_response") + @patch("relval.report_results.get_confirm") + @patch("relval.report_results.get_result") + @patch("relval.report_results.print") + @patch("relval.report_results.PAGE") + @patch("relval.report_results.SECTIONS", [{'index': "test 1", 'line': "test section"}]) + def test_report_results_compose_only_no_current_compose(self, mockPage, mockPrint, mockGetResult, mockGetConfirm, mockGetResponse, mockCheckNightly): + # Test with only compose without a current compose + mockWiki = Mock() + + mockTestResult = Mock() + mockTestResult.secid = "test 1" + mockTestResult.results = {'1': None} + mockTestResult.testcase = "test case" + + mockPage.name = "test page" + mockPage.get_resultrows.return_value = [mockTestResult] + + mockWiki.get_current_compose.return_value = None + + # Release 97, nightly, quit after get_result + mockGetResponse.side_effect = ["97", "n", "q"] + + # Confirm release + mockGetConfirm.return_value = "y" + + # Result is "pass" + mockGetResult.return_value = "pass" + + mockCheckNightly.return_value = True + + with self.assertRaises(SystemExit): + report_results(mockWiki, compose="20220708") + + mockPage.add_result.assert_called_with("pass", mockTestResult, "1") + + self.assertEqual(mockGetResponse.mock_calls, [call("Which Fedora release would you like to report a result for? ", "Please input a valid Fedora release number.", accepted=[str(num) for num in range(23, 100)]), call("Would you like to report a result for a milestone (c)ompose or a (n)ightly compose? ", "Please choose (c)ompose or (n)ightly.", accepted=("c", "n")), call("Report another result for this (s)ection, or (p)age, or this (c)ompose, or (q)uit? ", "Please choose (s)ection, (p)age, (c)ompose, or (q)uit.", ("s", "p", "c", "q"))]) + + self.assertEqual(mockGetConfirm.mock_calls, [call()]) + + self.assertEqual(mockGetResult.mock_calls, [call(mockWiki.username.lower())]) + + self.assertEqual(mockPrint.mock_calls, [call("When specifying the compose version by parameters, you must pass at least a release and a compose. Your version-related parameters will not be used."), call("Detecting current compose version..."), call("Will report results for compose: Fedora 97 20220708"), call("Will report pass for test test case in section test section of test page"), call("Succeeded!")]) + + @patch("relval.report_results.re") + @patch("relval.report_results.get_response") + @patch("relval.report_results.get_confirm") + @patch("relval.report_results.get_result") + @patch("relval.report_results.print") + @patch("relval.report_results.PAGE") + @patch("relval.report_results.SECTIONS", [{'index': "test 1", 'line': "test section"}]) + def test_report_results_milestone(self, mockPage, mockPrint, mockGetResult, mockGetConfirm, mockGetResponse, mockRegExp): + # Test the milestone flow + mockWiki = Mock() + + mockTestResult = Mock() + mockTestResult.secid = "test 1" + mockTestResult.results = {'1': None} + mockTestResult.testcase = "test case" + + mockPage.name = "test page" + mockPage.get_resultrows.return_value = [mockTestResult] + + mockWiki.get_current_compose.return_value = None + + # Release 99, milestone (c)ompose, (b)eta, 2.1, quit after get_result + mockGetResponse.side_effect = ["99", "c", "b", "2.1", "q"] + + # Confirm release + mockGetConfirm.return_value = "y" + + # Result is "pass" + mockGetResult.return_value = "pass" + + with self.assertRaises(SystemExit): + report_results(mockWiki) + + mockPage.add_result.assert_called_with("pass", mockTestResult, "1") + + self.assertEqual(mockGetResponse.mock_calls, [call("Which Fedora release would you like to report a result for? ", "Please input a valid Fedora release number.", accepted=[str(num) for num in range(23, 100)]), call("Would you like to report a result for a milestone (c)ompose or a (n)ightly compose? ", "Please choose (c)ompose or (n)ightly.", accepted=("c", "n")), call("(B)eta\n(R)C\nWhich milestone would you like to report a milestone for? ", "Please choose (B)eta, or (R)C.", accepted=("b", "r")), call("Which compose would you like to report a result for? ", "Examples: 1.0, 1.1, 2.1", accfunc=mockRegExp.compile().match), call("Report another result for this (s)ection, or (p)age, or this (c)ompose, or (q)uit? ", "Please choose (s)ection, (p)age, (c)ompose, or (q)uit.", ("s", "p", "c", "q"))]) + + self.assertEqual(mockGetConfirm.mock_calls, [call()]) + + self.assertEqual(mockGetResult.mock_calls, [call(mockWiki.username.lower())]) + + self.assertEqual(mockPrint.mock_calls, [call("Detecting current compose version..."), call("Will report results for compose: Fedora 99 Beta 2.1"), call("Will report pass for test test case in section test section of test page"), call("Succeeded!")]) + + @patch("relval.report_results.get_response") + @patch("relval.report_results.get_confirm") + @patch("relval.report_results.get_result") + @patch("relval.report_results.print") + @patch("relval.report_results.PAGE") + @patch("relval.report_results.SECTIONS", [{'index': "test 1", 'line': "test section"}]) + def test_report_results_milestone_compose_set(self, mockPage, mockPrint, mockGetResult, mockGetConfirm, mockGetResponse): + # Test the milestone flow with compose determined by get_current_compose + mockWiki = Mock() + + mockTestResult = Mock() + mockTestResult.secid = "test 1" + mockTestResult.results = {'1': None} + mockTestResult.testcase = "test case" + + mockPage.name = "test page" + mockPage.get_resultrows.return_value = [mockTestResult] + + mockWiki.get_current_compose.return_value = {'release': 0, 'milestone': "RC", 'compose': "RC1", 'date': "20220708"} + + # Release 99, milestone (c)ompose, (b)eta, 2.1, quit after get_result + mockGetResponse.side_effect = ["99", "c", "b", "q"] + + # Confirm release + mockGetConfirm.return_value = "y" + + # Result is "pass" + mockGetResult.return_value = "pass" + + with self.assertRaises(SystemExit): + report_results(mockWiki) + + mockPage.add_result.assert_called_with("pass", mockTestResult, "1") + + self.assertEqual(mockGetResponse.mock_calls, [call("Which Fedora release would you like to report a result for? ", "Please input a valid Fedora release number.", accepted=[str(num) for num in range(23, 100)]), call("Would you like to report a result for a milestone (c)ompose or a (n)ightly compose? ", "Please choose (c)ompose or (n)ightly.", accepted=("c", "n")), call("(B)eta\n(R)C\nWhich milestone would you like to report a milestone for? ", "Please choose (B)eta, or (R)C.", accepted=("b", "r")), call("Report another result for this (s)ection, or (p)age, or this (c)ompose, or (q)uit? ", "Please choose (s)ection, (p)age, (c)ompose, or (q)uit.", ("s", "p", "c", "q"))]) + + self.assertEqual(mockGetConfirm.mock_calls, [call()]) + + self.assertEqual(mockGetResult.mock_calls, [call(mockWiki.username.lower())]) + + self.assertEqual(mockPrint.mock_calls, [call("Detecting current compose version..."), call("Will report results for compose: Fedora 99 Beta RC1"), call("Will report pass for test test case in section test section of test page"), call("Succeeded!")]) + + @patch("relval.report_results.check_nightly") + @patch("relval.report_results.get_response_list") + @patch("relval.report_results.get_response") + @patch("relval.report_results.get_confirm") + @patch("relval.report_results.get_result") + @patch("relval.report_results.print") + @patch("relval.report_results.PAGE") + @patch("relval.report_results.SECTIONS", [{'index': "test 1", 'line': "test section"}]) + def test_report_results_confirm_retry(self, mockPage, mockPrint, mockGetResult, mockGetConfirm, mockGetResponse, mockGetResponseList, mockCheckNightly): + # Test flow for not confirming compose, then confirming + mockWiki = Mock() + + mockTestResult = Mock() + mockTestResult.secid = "test 1" + mockTestResult.results = {'1': None} + mockTestResult.testcase = "test case" + + mockPage.name = "test page" + mockPage.get_resultrows.return_value = [mockTestResult] + + mockWiki.get_current_compose.return_value = {'release': 99, 'milestone': "test", 'compose': "", 'date': "20220708"} + + # "Fedora" + mockGetResponseList.return_value = 0 + + # 99, (n)ightly, 20160314.n.0, quit after get_result + mockGetResponse.side_effect = ["99", "n", "20160314.n.0", "q"] + + # Don't confirm, then confirm release 99 + mockGetConfirm.side_effect = ["n", "y"] + + # Result is "pass" + mockGetResult.return_value = "pass" + + mockCheckNightly.return_value = True + + with self.assertRaises(SystemExit): + report_results(mockWiki) + + mockPage.add_result.assert_called_with("pass", mockTestResult, "1") + + mockWiki.get_current_compose.assert_called_with(dist="Fedora") + + self.assertEqual(mockGetResponse.mock_calls, [call("Which Fedora release would you like to report a result for? ", "Please input a valid Fedora release number.", accepted=[str(num) for num in range(23, 100)]), call("Would you like to report a result for a milestone (c)ompose or a (n)ightly compose? ", "Please choose (c)ompose or (n)ightly.", accepted=("c", "n")), call("What nightly would you like to report a result for? ", "Nightly must be YYYYMMDD.n.N (e.g. 20160314.n.0)", accfunc=mockCheckNightly), call("Report another result for this (s)ection, or (p)age, or this (c)ompose, or (q)uit? ", "Please choose (s)ection, (p)age, (c)ompose, or (q)uit.", ("s", "p", "c", "q"))]) + + self.assertEqual(mockGetConfirm.mock_calls, [call(), call()]) + + self.assertEqual(mockGetResult.mock_calls, [call(mockWiki.username.lower())]) + + self.assertEqual(mockPrint.mock_calls, [call("Detecting current compose version..."), call("Will report results for compose: Fedora 99 test 20220708"), call("Will report results for compose: Fedora 99 20160314.n.0"), call("Will report pass for test test case in section test section of test page"), call("Succeeded!")]) + + @patch("relval.report_results.get_response_list") + @patch("relval.report_results.get_response") + @patch("relval.report_results.get_confirm") + @patch("relval.report_results.get_result") + @patch("relval.report_results.print") + @patch("relval.report_results.PAGE") + @patch("relval.report_results.SECTIONS", [{'index': "test 1", 'line': "test section"}]) + def test_report_results_auto_false(self, mockPage, mockPrint, mockGetResult, mockGetConfirm, mockGetResponse, mockGetResponseList): + # Test with auto set to False + mockWiki = Mock() + + mockTestResult = Mock() + mockTestResult.secid = "test 1" + mockTestResult.results = {'1': None} + mockTestResult.testcase = "test case" + + mockPage.name = "test page" + mockPage.get_resultrows.return_value = [mockTestResult] + + mockWiki.get_current_compose.return_value = {'release': 99, 'milestone': "test", 'compose': "", 'date': "20220708"} + + # "Fedora" + mockGetResponseList.return_value = 0 + + # Release 99, (n)ightly, compose 20220711.n.0, quit after get_result + mockGetResponse.side_effect = ["99", "n", "20220711.n.0", "q"] + + # Confirm release 99 + mockGetConfirm.return_value = "y" + + # Result is "pass" + mockGetResult.return_value = "pass" + + with self.assertRaises(SystemExit): + report_results(mockWiki, auto=False) + + mockPage.add_result.assert_called_with("pass", mockTestResult, "1") + + self.assertEqual(mockGetResponseList.mock_calls, [call("What compose type are you reporting results for? ", ("Fedora", "Fedora-IoT"))]) + + self.assertEqual(mockGetResponse.mock_calls, [call("Which Fedora release would you like to report a result for? ", "Please input a valid Fedora release number.", accepted=[str(num) for num in range(23, 100)]), call("Would you like to report a result for a milestone (c)ompose or a (n)ightly compose? ", "Please choose (c)ompose or (n)ightly.", accepted=("c", "n")), call("What nightly would you like to report a result for? ", "Nightly must be YYYYMMDD.n.N (e.g. 20160314.n.0)", accfunc=check_nightly), call("Report another result for this (s)ection, or (p)age, or this (c)ompose, or (q)uit? ", "Please choose (s)ection, (p)age, (c)ompose, or (q)uit.", ("s", "p", "c", "q"))]) + + self.assertEqual(mockGetConfirm.mock_calls, [call()]) + + self.assertEqual(mockGetResult.mock_calls, [call(mockWiki.username.lower())]) + + self.assertEqual(mockPrint.mock_calls, [call("Will report results for compose: Fedora 99 20220711.n.0"), call("Will report pass for test test case in section test section of test page"), call("Succeeded!")]) + + @patch("relval.report_results.get_response") + @patch("relval.report_results.get_confirm") + @patch("relval.report_results.get_result") + @patch("relval.report_results.print") + @patch("relval.report_results.PAGE") + @patch("relval.report_results.SECTIONS", [{'index': "test 1", 'line': "test section"}]) + def test_report_results_dist(self, mockPage, mockPrint, mockGetResult, mockGetConfirm, mockGetResponse): + mockWiki = Mock() + + mockTestResult = Mock() + mockTestResult.secid = "test 1" + mockTestResult.results = {'1': None} + mockTestResult.testcase = "test case" + + mockPage.name = "test page" + mockPage.get_resultrows.return_value = [mockTestResult] + + mockWiki.get_current_compose.return_value = {'release': 99, 'milestone': "test", 'compose': "", 'date': "20220708"} + + # Quit after get_result + mockGetResponse.return_value = "q" + + # Confirm release 99 + mockGetConfirm.return_value = "y" + + # Result is "pass" + mockGetResult.return_value = "pass" + + with self.assertRaises(SystemExit): + report_results(mockWiki, dist="testdist") + + mockPage.add_result.assert_called_with("pass", mockTestResult, "1") + + mockWiki.get_current_compose.assert_called_with(dist="testdist") + + self.assertEqual(mockGetResponse.mock_calls, [call('Report another result for this (s)ection, or (p)age, or this (c)ompose, or (q)uit? ', 'Please choose (s)ection, (p)age, (c)ompose, or (q)uit.', ('s', 'p', 'c', 'q'))]) + + self.assertEqual(mockGetConfirm.mock_calls, [call()]) + + self.assertEqual(mockGetResult.mock_calls, [call(mockWiki.username.lower())]) + + self.assertEqual(mockPrint.mock_calls, [call("Detecting current compose version..."), call("Will report results for compose: testdist 99 test 20220708"), call("Will report pass for test test case in section test section of test page"), call("Succeeded!")]) + + @patch("relval.report_results.get_response") + @patch("relval.report_results.get_result") + @patch("relval.report_results.print") + @patch("relval.report_results.PAGE") + @patch("relval.report_results.SECTIONS", [{'index': "test 1", 'line': "test section"}]) + def test_report_results_no_checkver(self, mockPage, mockPrint, mockGetResult, mockGetResponse): + # Test with checkver=False + mockWiki = Mock() + + mockTestResult = Mock() + mockTestResult.secid = "test 1" + mockTestResult.results = {'1': None} + mockTestResult.testcase = "test case" + + mockPage.name = "test page" + mockPage.get_resultrows.return_value = [mockTestResult] + + mockWiki.get_current_compose.return_value = {'release': 99, 'milestone': "test", 'compose': "", 'date': "20220708"} + + # Quit after get_result + mockGetResponse.return_value = "q" + + # Result is "pass" + mockGetResult.return_value = "pass" + + with self.assertRaises(SystemExit): + report_results(mockWiki, checkver=False) + + mockPage.add_result.assert_called_with("pass", mockTestResult, "1") + + mockWiki.get_current_compose.assert_called_with(dist="Fedora") + + self.assertEqual(mockGetResponse.mock_calls, [call('Report another result for this (s)ection, or (p)age, or this (c)ompose, or (q)uit? ', 'Please choose (s)ection, (p)age, (c)ompose, or (q)uit.', ('s', 'p', 'c', 'q'))]) + + self.assertEqual(mockGetResult.mock_calls, [call(mockWiki.username.lower())]) + + self.assertEqual(mockPrint.mock_calls, [call("Detecting current compose version..."), call("Will report pass for test test case in section test section of test page"), call("Succeeded!")]) + + @patch("relval.report_results.get_response") + @patch("relval.report_results.get_confirm") + @patch("relval.report_results.get_result") + @patch("relval.report_results.print") + @patch("relval.report_results.PAGE", None) + @patch("relval.report_results.RESPAGES", None) + @patch("relval.report_results.SECTIONS", [{'index': "test 1", 'line': "test section"}]) + def test_report_results_no_respages_testtype(self, mockPrint, mockGetResult, mockGetConfirm, mockGetResponse): + # Test with no RESPAGES global but with a testtype provided + mockWiki = Mock() + + mockTestResult = Mock() + mockTestResult.secid = "test 1" + mockTestResult.results = {'1': None} + mockTestResult.testcase = "test case" + + mockPage = Mock() + mockPage.name = "test page" + mockPage.testtype = "testtesttype" + mockPage.get_resultrows.return_value = [mockTestResult] + + testResPages = [mockPage] + + mockEvent = Mock() + mockEvent.result_pages = testResPages + + mockWiki.get_current_compose.return_value = {'release': 99, 'milestone': "test", 'compose': "", 'date': "20220708"} + mockWiki.get_validation_event.return_value = mockEvent + + # Quit after get_result + mockGetResponse.return_value = "q" + + # Confirm release 99 + mockGetConfirm.return_value = "y" + + # Result is "pass" + mockGetResult.return_value = "pass" + + with self.assertRaises(SystemExit): + report_results(mockWiki, testtype="testtesttype") + + mockPage.add_result.assert_called_with("pass", mockTestResult, "1") + + mockWiki.get_current_compose.assert_called_with(dist="Fedora") + mockWiki.get_validation_event.assert_called_with(release=99, milestone='test', compose='20220708', dist='Fedora') + + self.assertEqual(mockGetResponse.mock_calls, [call('Report another result for this (s)ection, or (p)age, or this (c)ompose, or (q)uit? ', 'Please choose (s)ection, (p)age, (c)ompose, or (q)uit.', ('s', 'p', 'c', 'q'))]) + + self.assertEqual(mockGetConfirm.mock_calls, [call()]) + + self.assertEqual(mockGetResult.mock_calls, [call(mockWiki.username.lower())]) + + self.assertEqual(mockPrint.mock_calls, [call("Detecting current compose version..."), call("Will report results for compose: Fedora 99 test 20220708"), call("Will report pass for test test case in section test section of test page"), call("Succeeded!")]) + + @patch("relval.report_results.get_response_list") + @patch("relval.report_results.get_response") + @patch("relval.report_results.get_confirm") + @patch("relval.report_results.get_result") + @patch("relval.report_results.print") + @patch("relval.report_results.PAGE", None) + @patch("relval.report_results.RESPAGES", None) + @patch("relval.report_results.SECTIONS", [{'index': "test 1", 'line': "test section"}]) + def test_report_results_no_respages_bad_testtype(self, mockPrint, mockGetResult, mockGetConfirm, mockGetResponse, mockGetResponseList): + # Test exception flow when there are no pages with testtype property + mockWiki = Mock() + + mockTestResult = Mock() + mockTestResult.secid = "test 1" + mockTestResult.results = {'1': None} + mockTestResult.testcase = "test case" + + mockPage = Mock() + mockPage.name = "test page" + mockPage.get_resultrows.return_value = [mockTestResult] + + testResPages = [mockPage] + + mockEvent = Mock() + mockEvent.result_pages = testResPages + + mockWiki.get_current_compose.return_value = {'release': 99, 'milestone': "test", 'compose': "", 'date': "20220708"} + mockWiki.get_validation_event.return_value = mockEvent + + # "Fedora" + mockGetResponseList.return_value = 0 + + # Quit after get_result + mockGetResponse.return_value = "q" + + # Confirm release 99 + mockGetConfirm.return_value = "y" + + # Result is "pass" + mockGetResult.return_value = "pass" + + with self.assertRaises(SystemExit): + report_results(mockWiki, testtype="testtesttype") + + mockPage.add_result.assert_called_with("pass", mockTestResult, "1") + + mockWiki.get_current_compose.assert_called_with(dist="Fedora") + mockWiki.get_validation_event.assert_called_with(release=99, milestone='test', compose='20220708', dist='Fedora') + + self.assertEqual(mockGetResponse.mock_calls, [call('Report another result for this (s)ection, or (p)age, or this (c)ompose, or (q)uit? ', 'Please choose (s)ection, (p)age, (c)ompose, or (q)uit.', ('s', 'p', 'c', 'q'))]) + + self.assertEqual(mockGetConfirm.mock_calls, [call()]) + + self.assertEqual(mockGetResult.mock_calls, [call(mockWiki.username.lower())]) + + self.assertEqual(mockPrint.mock_calls, [call("Detecting current compose version..."), call("Will report results for compose: Fedora 99 test 20220708"), call('Error! Specified test type does not exist.'), call("Will report pass for test test case in section test section of test page"), call("Succeeded!")]) + + @patch("relval.report_results.get_response_list") + @patch("relval.report_results.get_response") + @patch("relval.report_results.get_confirm") + @patch("relval.report_results.get_result") + @patch("relval.report_results.print") + @patch("relval.report_results.PAGE", None) + @patch("relval.report_results.RESPAGES", None) + @patch("relval.report_results.SECTIONS", [{'index': "test 1", 'line': "test section"}]) + def test_report_results_no_respages_get_validation_event_exception(self, mockPrint, mockGetResult, mockGetConfirm, mockGetResponse, mockGetResponseList): + # Test with no RESPAGES global, and an exception with get_validation_event + mockWiki = Mock() + + mockTestResult = Mock() + mockTestResult.secid = "test 1" + mockTestResult.results = {'1': None} + mockTestResult.testcase = "test case" + + mockPage = Mock() + mockPage.name = "test page" + mockPage.testtype = "testtesttype" + mockPage.get_resultrows.return_value = [mockTestResult] + + testValidationError = ValueError() + testResPages = [mockPage] + + mockEvent = Mock() + mockEvent.result_pages = testResPages + + mockWiki.get_current_compose.return_value = {'release': 99, 'milestone': "test", 'compose': "", 'date': "20220708"} + mockWiki.get_validation_event.side_effect = [testValidationError, mockEvent] + + # "Fedora" + mockGetResponseList.return_value = 0 + + # Quit after get_result + mockGetResponse.return_value = "q" + + # Confirm release 99 + mockGetConfirm.return_value = "y" + + # Result is "pass" + mockGetResult.return_value = "pass" + + with self.assertRaises(SystemExit): + report_results(mockWiki, testtype="testtesttype") + + mockPage.add_result.assert_called_with("pass", mockTestResult, "1") + + mockWiki.get_current_compose.assert_called_with(dist="Fedora") + mockWiki.get_validation_event.assert_called_with(release=99, milestone="test", compose="20220708", dist="Fedora") + + self.assertEqual(mockGetResponseList.mock_calls, [call("Which test type would you like to report a result for? ", ["testtesttype"])]) + + self.assertEqual(mockGetResponse.mock_calls, [call("Report another result for this (s)ection, or (p)age, or this (c)ompose, or (q)uit? ", "Please choose (s)ection, (p)age, (c)ompose, or (q)uit.", ("s", "p", "c", "q"))]) + + # Confirm twice, first time resulted in an exception + self.assertEqual(mockGetConfirm.mock_calls, [call(), call()]) + + self.assertEqual(mockGetResult.mock_calls, [call(mockWiki.username.lower())]) + + self.assertEqual(mockPrint.mock_calls, [call("Detecting current compose version..."), call("Will report results for compose: Fedora 99 test 20220708"), call(testValidationError), call("Detecting current compose version..."), call("Will report results for compose: Fedora 99 test 20220708"), call("Will report pass for test test case in section test section of test page"), call("Succeeded!")]) + + @patch("relval.report_results.get_response_list") + @patch("relval.report_results.get_response") + @patch("relval.report_results.get_confirm") + @patch("relval.report_results.get_result") + @patch("relval.report_results.print") + @patch("relval.report_results.PAGE", None) + @patch("relval.report_results.RESPAGES", None) + @patch("relval.report_results.SECTIONS", [{'index': "test 1", 'line': "test section"}]) + def test_report_results_no_respages(self, mockPrint, mockGetResult, mockGetConfirm, mockGetResponse, mockGetResponseList): + # Test with no RESPAGES, and empty result pages + mockWiki = Mock() + + mockTestResult = Mock() + mockTestResult.secid = "test 1" + mockTestResult.results = {'1': None} + mockTestResult.testcase = "test case" + + mockPage = Mock() + mockPage.name = "test page" + mockPage.testtype = "testtesttype" + mockPage.get_resultrows.return_value = [mockTestResult] + + testResPages = [mockPage] + + mockEmptyEvent = Mock() + mockEmptyEvent.result_pages = [] + + mockEvent = Mock() + mockEvent.result_pages = testResPages + + mockWiki.get_current_compose.return_value = {'release': 99, 'milestone': "test", 'compose': "", 'date': "20220708"} + mockWiki.get_validation_event.side_effect = [mockEmptyEvent, mockEvent] + + # "Fedora" + mockGetResponseList.return_value = 0 + + # Quit after get_result + mockGetResponse.return_value = "q" + + # Confirm release 99 + mockGetConfirm.return_value = "y" + + # Result is "pass" + mockGetResult.return_value = "pass" + + with self.assertRaises(SystemExit): + report_results(mockWiki) + + mockPage.add_result.assert_called_with("pass", mockTestResult, "1") + + mockWiki.get_current_compose.assert_called_with(dist="Fedora") + mockWiki.get_validation_event.assert_called_with(release=99, milestone='test', compose='20220708', dist='Fedora') + + self.assertEqual(mockGetResponseList.mock_calls, [call("Which test type would you like to report a result for? ", ["testtesttype"])]) + + self.assertEqual(mockGetResponse.mock_calls, [call("Report another result for this (s)ection, or (p)age, or this (c)ompose, or (q)uit? ", "Please choose (s)ection, (p)age, (c)ompose, or (q)uit.", ("s", "p", "c", "q"))]) + + # Confirm twice, first time resulted in an error + self.assertEqual(mockGetConfirm.mock_calls, [call(), call()]) + + self.assertEqual(mockGetResult.mock_calls, [call(mockWiki.username.lower())]) + + self.assertEqual(mockPrint.mock_calls, [call("Detecting current compose version..."), call("Will report results for compose: Fedora 99 test 20220708"), call("Error! You probably chose a compose that doesn't exist."), call("Detecting current compose version..."), call("Will report results for compose: Fedora 99 test 20220708"), call("Will report pass for test test case in section test section of test page"), call("Succeeded!")]) + + @patch("relval.report_results.get_response") + @patch("relval.report_results.get_confirm") + @patch("relval.report_results.get_result") + @patch("relval.report_results.print") + @patch("relval.report_results.PAGE") + @patch("relval.report_results.SECTIONS") + def test_report_results_no_sections(self, mockSections, mockPage, mockPrint, mockGetResult, mockGetConfirm, mockGetResponse): + mockWiki = Mock() + + mockTestResult = Mock() + mockTestResult.secid = "test 1" + mockTestResult.results = {'1': None} + mockTestResult.testcase = "test case" + + mockPage.name = "test page" + mockPage.get_resultrows.return_value = [mockTestResult] + + # Hacky work around for mocking SECTIONS global checks + # First we pretend it's empty to get the "No results found for this + # page." error, then return 1 for the length when we hit that check + # again, then once more to set section = SECTIONS[0] + mockSections.__len__.side_effect = [0, 1, 1] + mockSections.__getitem__.return_value = {'index': "test 1", 'line': "test section"} + + mockWiki.get_current_compose.return_value = {'release': 99, 'milestone': "test", 'compose': "", 'date': "20220708"} + + # Quit after get_result + mockGetResponse.return_value = "q" + + # Confirm release 99 + mockGetConfirm.return_value = "y" + + # Result is "pass" + mockGetResult.return_value = "pass" + + with self.assertRaises(SystemExit): + report_results(mockWiki) + + mockPage.add_result.assert_called_with("pass", mockTestResult, "1") + + mockWiki.get_current_compose.assert_called_with(dist="Fedora") + + self.assertEqual(mockGetResponse.mock_calls, [call("Report another result for this (s)ection, or (p)age, or this (c)ompose, or (q)uit? ", "Please choose (s)ection, (p)age, (c)ompose, or (q)uit.", ("s", "p", "c", "q"))]) + + #Once with the error, once again with the successful run + self.assertEqual(mockGetConfirm.mock_calls, [call(), call()]) + + self.assertEqual(mockGetResult.mock_calls, [call(mockWiki.username.lower())]) + + self.assertEqual(mockPrint.mock_calls, [call("Detecting current compose version..."), call("Will report results for compose: Fedora 99 test 20220708"), call("Error! No results found for this page."), call("Detecting current compose version..."), call("Will report results for compose: Fedora 99 test 20220708"), call("Will report pass for test test case in section test section of test page"), call("Succeeded!")]) + + @patch("relval.report_results.get_response") + @patch("relval.report_results.get_confirm") + @patch("relval.report_results.get_result") + @patch("relval.report_results.print") + @patch("relval.report_results.PAGE") + @patch("relval.report_results.SECTIONS", None) + def test_report_results_sections_type_error(self, mockPage, mockPrint, mockGetResult, mockGetConfirm, mockGetResponse): + # Set SECTIONS to None, which should raise a TypeError when checking the length + mockWiki = Mock() + + mockTestResult = Mock() + mockTestResult.secid = "test 1" + mockTestResult.results = {'1': None} + mockTestResult.testcase = "test case" + + mockPage.name = "test page" + mockPage.get_resultrows.return_value = [mockTestResult] + mockPage.results_sections = [{'index': "test 1", 'line': "test section"}] + + mockWiki.get_current_compose.return_value = {'release': 99, 'milestone': "test", 'compose': "", 'date': "20220708"} + + # Quit after get_result + mockGetResponse.return_value = "q" + + # Confirm release 99 + mockGetConfirm.return_value = "y" + + # Result is "pass" + mockGetResult.return_value = "pass" + + with self.assertRaises(SystemExit): + report_results(mockWiki) + + mockPage.add_result.assert_called_with("pass", mockTestResult, "1") + + mockWiki.get_current_compose.assert_called_with(dist="Fedora") + + self.assertEqual(mockGetResponse.mock_calls, [call("Report another result for this (s)ection, or (p)age, or this (c)ompose, or (q)uit? ", "Please choose (s)ection, (p)age, (c)ompose, or (q)uit.", ("s", "p", "c", "q"))]) + + self.assertEqual(mockGetConfirm.mock_calls, [call()]) + + self.assertEqual(mockGetResult.mock_calls, [call(mockWiki.username.lower())]) + + self.assertEqual(mockPrint.mock_calls, [call("Detecting current compose version..."), call("Will report results for compose: Fedora 99 test 20220708"), call("Will report pass for test test case in section test section of test page"), call("Succeeded!")]) + + @patch("relval.report_results.get_response_list") + @patch("relval.report_results.get_response") + @patch("relval.report_results.get_confirm") + @patch("relval.report_results.get_result") + @patch("relval.report_results.print") + @patch("relval.report_results.PAGE") + @patch("relval.report_results.SECTIONS", [{'index': "test 1", 'line': "test section 1"}, {'index': "test 2", 'line': "test section 2"}]) + def test_report_results_multiple_sections(self, mockPage, mockPrint, mockGetResult, mockGetConfirm, mockGetResponse, mockGetResponseList): + mockWiki = Mock() + + mockTestResult = Mock() + mockTestResult.secid = "test 1" + mockTestResult.results = {'1': None} + mockTestResult.testcase = "test case" + + mockPage.name = "test page" + mockPage.get_resultrows.return_value = [mockTestResult] + + mockWiki.get_current_compose.return_value = {'release': 99, 'milestone': "test", 'compose': "", 'date': "20220708"} + + # Section "test 1" + mockGetResponseList.return_value = 0 + + # Quit after get_result + mockGetResponse.return_value = "q" + + # Confirm release 99 + mockGetConfirm.return_value = "y" + + # Result is "pass" + mockGetResult.return_value = "pass" + + with self.assertRaises(SystemExit): + report_results(mockWiki) + + mockPage.add_result.assert_called_with("pass", mockTestResult, "1") + + mockWiki.get_current_compose.assert_called_with(dist="Fedora") + + self.assertEqual(mockGetResponseList.mock_calls, [call("Which section would you like to report a result in? ", ["test section 1", "test section 2"])]) + + self.assertEqual(mockGetResponse.mock_calls, [call("Report another result for this (s)ection, or (p)age, or this (c)ompose, or (q)uit? ", "Please choose (s)ection, (p)age, (c)ompose, or (q)uit.", ("s", "p", "c", "q"))]) + + self.assertEqual(mockGetConfirm.mock_calls, [call()]) + + self.assertEqual(mockGetResult.mock_calls, [call(mockWiki.username.lower())]) + + self.assertEqual(mockPrint.mock_calls, [call("Detecting current compose version..."), call("Will report results for compose: Fedora 99 test 20220708"), call("Will report pass for test test case in section test section 1 of test page"), call("Succeeded!")]) + + @patch("relval.report_results.get_response_list") + @patch("relval.report_results.get_response") + @patch("relval.report_results.get_confirm") + @patch("relval.report_results.get_result") + @patch("relval.report_results.print") + @patch("relval.report_results.PAGE") + def test_report_results_multiple_tests(self, mockPage, mockPrint, mockGetResult, mockGetConfirm, mockGetResponse, mockGetResponseList): + mockWiki = Mock() + + mockTest1Result = Mock() + mockTest1Result.secid = "test 1" + mockTest1Result.results = {'1': None} + mockTest1Result.testcase = "test case" + mockTest1Result.name = "test name 1" + + mockTest2Result = Mock() + mockTest2Result.secid = "test 1" + mockTest2Result.results = {'1': None} + mockTest2Result.testcase = "test case" + mockTest2Result.name = "test name 2" + + mockPage.name = "test page" + mockPage.get_resultrows.return_value = [mockTest1Result, mockTest2Result] + + mockWiki.get_current_compose.return_value = {'release': 99, 'milestone': "test", 'compose': "", 'date': "20220708"} + + # Select "test case 1" + mockGetResponseList.return_value = 0 + + # Quit after get_result + mockGetResponse.return_value = "q" + + # Confirm release 99 + mockGetConfirm.return_value = "y" + + # Result is "pass" + mockGetResult.return_value = "pass" + + with self.assertRaises(SystemExit): + report_results(mockWiki, section={'index': "test 1", 'line': "test section"}) + + mockPage.add_result.assert_called_with("pass", mockTest1Result, "1") + + mockWiki.get_current_compose.assert_called_with(dist="Fedora") + + self.assertEqual(mockGetResponseList.mock_calls, [call("Which test would you like to report a result for? ", ["test case test name 1", "test case test name 2"])]) + + self.assertEqual(mockGetResponse.mock_calls, [call("Report another result for this (s)ection, or (p)age, or this (c)ompose, or (q)uit? ", "Please choose (s)ection, (p)age, (c)ompose, or (q)uit.", ("s", "p", "c", "q"))]) + + self.assertEqual(mockGetConfirm.mock_calls, [call()]) + + self.assertEqual(mockGetResult.mock_calls, [call(mockWiki.username.lower())]) + + self.assertEqual(mockPrint.mock_calls, [call("Detecting current compose version..."), call("Will report results for compose: Fedora 99 test 20220708"), call("Will report pass for test test case in section test section of test page"), call("Succeeded!")]) + + @patch("relval.report_results.get_response_list") + @patch("relval.report_results.get_response") + @patch("relval.report_results.get_confirm") + @patch("relval.report_results.get_result") + @patch("relval.report_results.print") + @patch("relval.report_results.PAGE") + def test_report_results_multiple_tests_name_matches_testcase(self, mockPage, mockPrint, mockGetResult, mockGetConfirm, mockGetResponse, mockGetResponseList): + # Test building selection list where test result testcase matches name + mockWiki = Mock() + + mockTest1Result = Mock() + mockTest1Result.secid = "test 1" + mockTest1Result.results = {'1': None} + mockTest1Result.testcase = "test name 1" + mockTest1Result.name = "test name 1" + + mockTest2Result = Mock() + mockTest2Result.secid = "test 1" + mockTest2Result.results = {'1': None} + mockTest2Result.testcase = "test name 2" + mockTest2Result.name = "test name 2" + + mockPage.name = "test page" + mockPage.get_resultrows.return_value = [mockTest1Result, mockTest2Result] + + mockWiki.get_current_compose.return_value = {'release': 99, 'milestone': "test", 'compose': "", 'date': "20220708"} + + # Select "test case 1" + mockGetResponseList.return_value = 0 + + # Quit after get_result + mockGetResponse.return_value = "q" + + # Confirm release 99 + mockGetConfirm.return_value = "y" + + # Result is "pass" + mockGetResult.return_value = "pass" + + with self.assertRaises(SystemExit): + report_results(mockWiki, section={'index': "test 1", 'line': "test section"}) + + mockPage.add_result.assert_called_with("pass", mockTest1Result, "1") + + mockWiki.get_current_compose.assert_called_with(dist="Fedora") + + self.assertEqual(mockGetResponseList.mock_calls, [call("Which test would you like to report a result for? ", ["test name 1", "test name 2"])]) + + self.assertEqual(mockGetResponse.mock_calls, [call("Report another result for this (s)ection, or (p)age, or this (c)ompose, or (q)uit? ", "Please choose (s)ection, (p)age, (c)ompose, or (q)uit.", ("s", "p", "c", "q"))]) + + self.assertEqual(mockGetConfirm.mock_calls, [call()]) + + self.assertEqual(mockGetResult.mock_calls, [call(mockWiki.username.lower())]) + + self.assertEqual(mockPrint.mock_calls, [call("Detecting current compose version..."), call("Will report results for compose: Fedora 99 test 20220708"), call("Will report pass for test test name 1 in section test section of test page"), call("Succeeded!")]) + + @patch("relval.report_results.get_response_list") + @patch("relval.report_results.get_response") + @patch("relval.report_results.get_confirm") + @patch("relval.report_results.get_result") + @patch("relval.report_results.print") + @patch("relval.report_results.PAGE") + def test_report_results_multiple_tests(self, mockPage, mockPrint, mockGetResult, mockGetConfirm, mockGetResponse, mockGetResponseList): + mockWiki = Mock() + + mockTest1Result = Mock() + mockTest1Result.secid = "test 1" + mockTest1Result.results = {'1': None} + mockTest1Result.testcase = "test case" + mockTest1Result.name = "test name 1" + + mockTest2Result = Mock() + mockTest2Result.secid = "test 1" + mockTest2Result.results = {'1': None} + mockTest2Result.testcase = "test case" + mockTest2Result.name = "test name 2" + + mockPage.name = "test page" + mockPage.get_resultrows.return_value = [mockTest1Result, mockTest2Result] + + mockWiki.get_current_compose.return_value = {'release': 99, 'milestone': "test", 'compose': "", 'date': "20220708"} + + # Select "test case 1" + mockGetResponseList.return_value = 0 + + # Quit after get_result + mockGetResponse.return_value = "q" + + # Confirm release 99 + mockGetConfirm.return_value = "y" + + # Result is "pass" + mockGetResult.return_value = "pass" + + with self.assertRaises(SystemExit): + report_results(mockWiki, section={'index': "test 1", 'line': "test section"}) + + mockPage.add_result.assert_called_with("pass", mockTest1Result, "1") + + mockWiki.get_current_compose.assert_called_with(dist="Fedora") + + self.assertEqual(mockGetResponseList.mock_calls, [call("Which test would you like to report a result for? ", ["test case test name 1", "test case test name 2"])]) + + self.assertEqual(mockGetResponse.mock_calls, [call("Report another result for this (s)ection, or (p)age, or this (c)ompose, or (q)uit? ", "Please choose (s)ection, (p)age, (c)ompose, or (q)uit.", ("s", "p", "c", "q"))]) + + self.assertEqual(mockGetConfirm.mock_calls, [call()]) + + self.assertEqual(mockGetResult.mock_calls, [call(mockWiki.username.lower())]) + + self.assertEqual(mockPrint.mock_calls, [call("Detecting current compose version..."), call("Will report results for compose: Fedora 99 test 20220708"), call("Will report pass for test test case in section test section of test page"), call("Succeeded!")]) + + @patch("relval.report_results.get_response_list") + @patch("relval.report_results.get_response") + @patch("relval.report_results.get_confirm") + @patch("relval.report_results.get_result") + @patch("relval.report_results.print") + @patch("relval.report_results.PAGE") + @patch("relval.report_results.SECTIONS", [{'index': "test 1", 'line': "test section"}]) + def test_report_results_multiple_envs(self, mockPage, mockPrint, mockGetResult, mockGetConfirm, mockGetResponse, mockGetResponseList): + # Test with multiple envs + mockWiki = Mock() + + mockTestResult = Mock() + mockTestResult.secid = "test 1" + mockTestResult.results = {'testenv1': None, 'testenv2': None} + mockTestResult.testcase = "test case" + + mockPage.name = "test page" + mockPage.get_resultrows.return_value = [mockTestResult] + + mockWiki.get_current_compose.return_value = {'release': 99, 'milestone': "test", 'compose': "", 'date': "20220708"} + + # Select "testenv1" + mockGetResponseList.return_value = 0 + + # Quit after get_result + mockGetResponse.return_value = "q" + + # Confirm release 99 + mockGetConfirm.return_value = "y" + + # Result is "pass" + mockGetResult.return_value = "pass" + + with self.assertRaises(SystemExit): + report_results(mockWiki) + + mockPage.add_result.assert_called_with("pass", mockTestResult, "testenv1") + + mockWiki.get_current_compose.assert_called_with(dist="Fedora") + + self.assertEqual(mockGetResponseList.mock_calls, [call("Which environment would you like to report a result for? ", ["testenv1", "testenv2"])]) + + self.assertEqual(mockGetResponse.mock_calls, [call("Report another result for this (s)ection, or (p)age, or this (c)ompose, or (q)uit? ", "Please choose (s)ection, (p)age, (c)ompose, or (q)uit.", ("s", "p", "c", "q"))]) + + self.assertEqual(mockGetConfirm.mock_calls, [call()]) + + self.assertEqual(mockGetResult.mock_calls, [call(mockWiki.username.lower())]) + + self.assertEqual(mockPrint.mock_calls, [call("Detecting current compose version..."), call("Will report results for compose: Fedora 99 test 20220708"), call("Will report pass for test test case in section test section of test page"), call("Succeeded!")]) + + @patch("relval.report_results.get_confirm") + @patch("relval.report_results.print") + @patch("relval.report_results.PAGE") + @patch("relval.report_results.SECTIONS", [{'index': "test 1", 'line': "test section"}]) + def test_report_results_no_envs(self, mockPage, mockPrint, mockGetConfirm): + # Test with no envs + mockWiki = Mock() + + mockTestResult = Mock() + mockTestResult.secid = "test 1" + mockTestResult.results = {} + mockTestResult.testcase = "test case" + + mockPage.name = "test page" + mockPage.get_resultrows.return_value = [mockTestResult] + + mockWiki.get_current_compose.return_value = {'release': 99, 'milestone': "test", 'compose': "", 'date': "20220708"} + + # Confirm release 99 + mockGetConfirm.return_value = "y" + + with self.assertRaises(UnboundLocalError): + report_results(mockWiki) + + mockPage.add_result.not_called_with() + + mockWiki.get_current_compose.assert_called_with(dist="Fedora") + + self.assertEqual(mockGetConfirm.mock_calls, [call()]) + + self.assertEqual(mockPrint.mock_calls, [call("Detecting current compose version..."), call("Will report results for compose: Fedora 99 test 20220708")]) + + @patch("relval.report_results.get_response") + @patch("relval.report_results.get_confirm") + @patch("relval.report_results.get_result") + @patch("relval.report_results.print") + @patch("relval.report_results.PAGE") + @patch("relval.report_results.SECTIONS", [{'index': "test 1", 'line': "test section"}]) + def test_report_results_current_results(self, mockPage, mockPrint, mockGetResult, mockGetConfirm, mockGetResponse): + # Test with already reported results + mockWiki = Mock() + + mockCurrentResult = Mock() + mockCurrentResult.user = "othertestuser" + + mockTestResult = Mock() + mockTestResult.secid = "test 1" + mockTestResult.results = {'1': [mockCurrentResult]} + mockTestResult.testcase = "test case" + + mockPage.name = "test page" + mockPage.get_resultrows.return_value = [mockTestResult] + + mockWiki.get_current_compose.return_value = {'release': 99, 'milestone': "test", 'compose': "", 'date': "20220708"} + + # Quit after get_result + mockGetResponse.return_value = "q" + + # Confirm release 99 + mockGetConfirm.return_value = "y" + + # Result is "pass" + mockGetResult.return_value = "pass" + + with self.assertRaises(SystemExit): + report_results(mockWiki) + + mockPage.add_result.assert_called_with("pass", mockTestResult, "1") + + mockWiki.get_current_compose.assert_called_with(dist="Fedora") + + self.assertEqual(mockGetResponse.mock_calls, [call("Report another result for this (s)ection, or (p)age, or this (c)ompose, or (q)uit? ", "Please choose (s)ection, (p)age, (c)ompose, or (q)uit.", ("s", "p", "c", "q"))]) + + self.assertEqual(mockGetConfirm.mock_calls, [call()]) + + self.assertEqual(mockGetResult.mock_calls, [call(mockWiki.username.lower())]) + + self.assertEqual(mockPrint.mock_calls, [call("Detecting current compose version..."), call("Will report results for compose: Fedora 99 test 20220708"), call("Current results for this test:"), call(str(mockCurrentResult)), call("Will report pass for test test case in section test section of test page"), call("Succeeded!")]) + + @patch("relval.report_results.get_response") + @patch("relval.report_results.get_confirm") + @patch("relval.report_results.get_result") + @patch("relval.report_results.print") + @patch("relval.report_results.PAGE") + @patch("relval.report_results.SECTIONS", [{'index': "test 1", 'line': "test section"}]) + def test_report_results_additional_result(self, mockPage, mockPrint, mockGetResult, mockGetConfirm, mockGetResponse): + # Test a user submitting an additional result + mockWiki = Mock() + + mockCurrentResult = Mock() + mockCurrentResult.user = mockWiki.username.lower() + + mockTestResult = Mock() + mockTestResult.secid = "test 1" + mockTestResult.results = {'1': [mockCurrentResult]} + mockTestResult.testcase = "test case" + + mockPage.name = "test page" + mockPage.get_resultrows.return_value = [mockTestResult] + + mockWiki.get_current_compose.return_value = {'release': 99, 'milestone': "test", 'compose': "", 'date': "20220708"} + + # Quit after get_result + mockGetResponse.return_value = "q" + + # Confirm release 99, confirm additional result + mockGetConfirm.side_effect = ["y", "y"] + + # Result is "pass" + mockGetResult.return_value = "pass" + + with self.assertRaises(SystemExit): + report_results(mockWiki) + + mockPage.add_result.assert_called_with("pass", mockTestResult, "1") + + mockWiki.get_current_compose.assert_called_with(dist="Fedora") + + self.assertEqual(mockGetResponse.mock_calls, [call("Report another result for this (s)ection, or (p)age, or this (c)ompose, or (q)uit? ", "Please choose (s)ection, (p)age, (c)ompose, or (q)uit.", ("s", "p", "c", "q"))]) + + self.assertEqual(mockGetConfirm.mock_calls, [call(), call()]) + + self.assertEqual(mockGetResult.mock_calls, [call(mockWiki.username.lower())]) + + self.assertEqual(mockPrint.mock_calls, [call("Detecting current compose version..."), call("Will report results for compose: Fedora 99 test 20220708"), call("Current results for this test:"), call(str(mockCurrentResult)), call("You have already reported result(s) for this test! Do you still want to report this result?"), call("Will report pass for test test case in section test section of test page"), call("Succeeded!")]) + + @patch("relval.report_results.get_response") + @patch("relval.report_results.get_confirm") + @patch("relval.report_results.get_result") + @patch("relval.report_results.print") + @patch("relval.report_results.PAGE") + @patch("relval.report_results.SECTIONS", [{'index': "test 1", 'line': "test section"}]) + def test_report_results_no_additional_result(self, mockPage, mockPrint, mockGetResult, mockGetConfirm, mockGetResponse): + # Test a user not submitting an additional result + mockWiki = Mock() + + mockCurrentResult = Mock() + mockCurrentResult.user = mockWiki.username.lower() + + # Test results with a result from the current user + mockOwnTestResult = Mock() + mockOwnTestResult.secid = "test 1" + mockOwnTestResult.results = {'1': [mockCurrentResult]} + mockOwnTestResult.testcase = "test case" + + # Empty test results + mockTestResult = Mock() + mockTestResult.secid = "test 1" + mockTestResult.results = {'1': None} + mockTestResult.testcase = "test case" + + mockPage.name = "test page" + mockPage.get_resultrows.side_effect = [[mockOwnTestResult], [mockTestResult]] + + mockWiki.get_current_compose.return_value = {'release': 99, 'milestone': "test", 'compose': "", 'date': "20220708"} + + # Quit after get_result + mockGetResponse.return_value = "q" + + # Confirm release 99, no additional result, confirm release again + mockGetConfirm.side_effect = ["y", "n", "y"] + + # Result is "pass" + mockGetResult.return_value = "pass" + + with self.assertRaises(SystemExit): + report_results(mockWiki) + + mockPage.add_result.assert_called_with("pass", mockTestResult, "1") + + mockWiki.get_current_compose.assert_called_with(dist="Fedora") + + self.assertEqual(mockGetResponse.mock_calls, [call("Report another result for this (s)ection, or (p)age, or this (c)ompose, or (q)uit? ", "Please choose (s)ection, (p)age, (c)ompose, or (q)uit.", ("s", "p", "c", "q"))]) + + self.assertEqual(mockGetConfirm.mock_calls, [call(), call(), call()]) + + self.assertEqual(mockGetResult.mock_calls, [call(mockWiki.username.lower())]) + + self.assertEqual(mockPrint.mock_calls, [call("Detecting current compose version..."), call("Will report results for compose: Fedora 99 test 20220708"), call("Current results for this test:"), call(str(mockCurrentResult)), call("You have already reported result(s) for this test! Do you still want to report this result?"), call("Will report results for compose: Fedora 99 test 20220708"), call("Will report pass for test test case in section test section of test page"), call("Succeeded!")]) + + @patch("relval.report_results.get_response") + @patch("relval.report_results.get_confirm") + @patch("relval.report_results.get_result") + @patch("relval.report_results.print") + @patch("relval.report_results.PAGE") + @patch("relval.report_results.SECTIONS", [{'index': "test 1", 'line': "test section"}]) + def test_report_results_add_result_exception(self, mockPage, mockPrint, mockGetResult, mockGetConfirm, mockGetResponse): + mockWiki = Mock() + + mockTestResult = Mock() + mockTestResult.secid = "test 1" + mockTestResult.results = {'1': None} + mockTestResult.testcase = "test case" + + mockPage.name = "test page" + mockPage.get_resultrows.return_value = [mockTestResult] + mockPage.add_result.side_effect = Exception("test exception") + + mockWiki.get_current_compose.return_value = {'release': 99, 'milestone': "test", 'compose': "", 'date': "20220708"} + + # Quit after get_result + mockGetResponse.return_value = "q" + + # Confirm release 99 + mockGetConfirm.return_value = "y" + + # Result is "pass" + mockGetResult.return_value = "pass" + + with self.assertRaises(Exception) as e: + report_results(mockWiki) + + self.assertEqual(str(e.exception), "test exception") + + mockPage.add_result.assert_called_with("pass", mockTestResult, "1") + + mockWiki.get_current_compose.assert_called_with(dist="Fedora") + + mockGetResponse.assert_not_called() + + self.assertEqual(mockGetConfirm.mock_calls, [call()]) + + self.assertEqual(mockGetResult.mock_calls, [call(mockWiki.username.lower())]) + + self.assertEqual(mockPrint.mock_calls, [call("Detecting current compose version..."), call("Will report results for compose: Fedora 99 test 20220708"), call("Will report pass for test test case in section test section of test page")]) + + @patch("relval.report_results.get_response") + @patch("relval.report_results.get_confirm") + @patch("relval.report_results.get_result") + @patch("relval.report_results.print") + @patch("relval.report_results.PAGE") + @patch("relval.report_results.SECTIONS") + def test_report_results_another_section(self, mockSections, mockPage, mockPrint, mockGetResult, mockGetConfirm, mockGetResponse): + # Test reporting another result for (s)ection + import relval.report_results # Access to globals + + original_report_result = reference_wrapper(report_results) + + mockWiki = Mock() + + mockTestResult = Mock() + mockTestResult.secid = "test 1" + mockTestResult.results = {'1': None} + mockTestResult.testcase = "test case" + + mockPage.name = "test page" + mockPage.get_resultrows.return_value = [mockTestResult] + + mockSections.__len__.return_value = 1 + mockSections.__getitem__.return_value = {'index': "test 1", 'line': "test section"} + + mockWiki.get_current_compose.return_value = {'release': 99, 'milestone': "test", 'compose': "", 'date': "20220708"} + + # Report another result for this (s)ection + mockGetResponse.return_value = "s" + + # Confirm release 99 + mockGetConfirm.return_value = "y" + + # Result is "pass" + mockGetResult.return_value = "pass" + + with patch("relval.report_results.report_results") as mockReportResults: + # Call the original, unpatched report_result + original_report_result(mockWiki) + + mockReportResults.assert_called_with(mockWiki, 99, "test", "20220708", None, {"index": "test 1", "line": "test section"}, checkver=False, dist="Fedora") + + self.assertEqual(relval.report_results.PAGE, mockPage) + self.assertEqual(relval.report_results.SECTIONS, mockSections) + + mockPage.add_result.assert_called_with("pass", mockTestResult, "1") + + mockWiki.get_current_compose.assert_called_with(dist="Fedora") + + self.assertEqual(mockGetResponse.mock_calls, [call("Report another result for this (s)ection, or (p)age, or this (c)ompose, or (q)uit? ", "Please choose (s)ection, (p)age, (c)ompose, or (q)uit.", ("s", "p", "c", "q"))]) + + self.assertEqual(mockGetConfirm.mock_calls, [call()]) + + self.assertEqual(mockGetResult.mock_calls, [call(mockWiki.username.lower())]) + + self.assertEqual(mockPrint.mock_calls, [call("Detecting current compose version..."), call("Will report results for compose: Fedora 99 test 20220708"), call("Will report pass for test test case in section test section of test page"), call("Succeeded!")]) + + @patch("relval.report_results.get_response") + @patch("relval.report_results.get_confirm") + @patch("relval.report_results.get_result") + @patch("relval.report_results.print") + @patch("relval.report_results.PAGE") + @patch("relval.report_results.SECTIONS") + def test_report_results_another_page(self, mockSections, mockPage, mockPrint, mockGetResult, mockGetConfirm, mockGetResponse): + # Test reporting another result for (p)age + import relval.report_results # Access to globals + + original_report_result = reference_wrapper(report_results) + + mockWiki = Mock() + + mockTestResult = Mock() + mockTestResult.secid = "test 1" + mockTestResult.results = {'1': None} + mockTestResult.testcase = "test case" + + mockPage.name = "test page" + mockPage.get_resultrows.return_value = [mockTestResult] + + mockSections.__len__.return_value = 1 + mockSections.__getitem__.return_value = {'index': "test 1", 'line': "test section"} + + mockWiki.get_current_compose.return_value = {'release': 99, 'milestone': "test", 'compose': "", 'date': "20220708"} + + # Report another result for this (p)age + mockGetResponse.return_value = "p" + + # Confirm release 99 + mockGetConfirm.return_value = "y" + + # Result is "pass" + mockGetResult.return_value = "pass" + + with patch("relval.report_results.report_results") as mockReportResults: + # Call the original, unpatched report_result + original_report_result(mockWiki) + + mockReportResults.assert_called_with(mockWiki, 99, "test", "20220708", None, None, checkver=False, dist="Fedora") + + self.assertEqual(relval.report_results.PAGE, mockPage) + self.assertEqual(relval.report_results.SECTIONS, mockSections) + + mockPage.add_result.assert_called_with("pass", mockTestResult, "1") + + mockWiki.get_current_compose.assert_called_with(dist="Fedora") + + self.assertEqual(mockGetResponse.mock_calls, [call("Report another result for this (s)ection, or (p)age, or this (c)ompose, or (q)uit? ", "Please choose (s)ection, (p)age, (c)ompose, or (q)uit.", ("s", "p", "c", "q"))]) + + self.assertEqual(mockGetConfirm.mock_calls, [call()]) + + self.assertEqual(mockGetResult.mock_calls, [call(mockWiki.username.lower())]) + + self.assertEqual(mockPrint.mock_calls, [call("Detecting current compose version..."), call("Will report results for compose: Fedora 99 test 20220708"), call("Will report pass for test test case in section test section of test page"), call("Succeeded!")]) + + @patch("relval.report_results.get_response") + @patch("relval.report_results.get_confirm") + @patch("relval.report_results.get_result") + @patch("relval.report_results.print") + @patch("relval.report_results.PAGE") + @patch("relval.report_results.SECTIONS") + def test_report_results_another_compose(self, mockSections, mockPage, mockPrint, mockGetResult, mockGetConfirm, mockGetResponse): + # Test reporting another result for (c)ompose + import relval.report_results # Access to globals + + original_report_result = reference_wrapper(report_results) + + mockWiki = Mock() + + mockTestResult = Mock() + mockTestResult.secid = "test 1" + mockTestResult.results = {'1': None} + mockTestResult.testcase = "test case" + + mockPage.name = "test page" + mockPage.get_resultrows.return_value = [mockTestResult] + + mockSections.__len__.return_value = 1 + mockSections.__getitem__.return_value = {'index': "test 1", 'line': "test section"} + + mockWiki.get_current_compose.return_value = {'release': 99, 'milestone': "test", 'compose': "", 'date': "20220708"} + + # Report another result for this (c)ompose + mockGetResponse.return_value = "c" + + # Confirm release 99 + mockGetConfirm.return_value = "y" + + # Result is "pass" + mockGetResult.return_value = "pass" + + with patch("relval.report_results.report_results") as mockReportResults: + # Call the original, unpatched report_result + original_report_result(mockWiki) + + mockReportResults.assert_called_with(mockWiki, 99, "test", "20220708", None, None, checkver=False, dist="Fedora") + + self.assertIsNone(relval.report_results.PAGE) + self.assertIsNone(relval.report_results.SECTIONS) + + mockPage.add_result.assert_called_with("pass", mockTestResult, "1") + + mockWiki.get_current_compose.assert_called_with(dist="Fedora") + + self.assertEqual(mockGetResponse.mock_calls, [call("Report another result for this (s)ection, or (p)age, or this (c)ompose, or (q)uit? ", "Please choose (s)ection, (p)age, (c)ompose, or (q)uit.", ("s", "p", "c", "q"))]) + + self.assertEqual(mockGetConfirm.mock_calls, [call()]) + + self.assertEqual(mockGetResult.mock_calls, [call(mockWiki.username.lower())]) + + self.assertEqual(mockPrint.mock_calls, [call("Detecting current compose version..."), call("Will report results for compose: Fedora 99 test 20220708"), call("Will report pass for test test case in section test section of test page"), call("Succeeded!")]) From 1e3eae7b8cc80b735ed582a01379a7fcc92ef06c Mon Sep 17 00:00:00 2001 From: Brandon Nielsen Date: Oct 27 2022 15:40:36 +0000 Subject: [PATCH 2/2] Improve handling of bugs string with no bugs. The result of a string split operation is always an array, so the `if bugs == ''` conditional would never evaluate to true. This works around that with a filter of the split result to remove empty strings and changes the conditional to an array length check. --- diff --git a/relval/report_results.py b/relval/report_results.py index d704521..7168778 100644 --- a/relval/report_results.py +++ b/relval/report_results.py @@ -123,7 +123,9 @@ def get_result(username): white = re.compile(r'\s') bugs = white.sub('', bugs) bugs = bugs.split(',') - if bugs == '': + # Filter empty strings + bugs = [bug for bug in bugs if bug != ''] + if len(bugs) == 0: bugs = None comment = '' comm = input("Enter a comment if you like. If not, just hit Enter.\n" diff --git a/relval/tests/test_report_results.py b/relval/tests/test_report_results.py index 00c2ab4..9bc91d9 100644 --- a/relval/tests/test_report_results.py +++ b/relval/tests/test_report_results.py @@ -259,6 +259,21 @@ class TestGetResult(unittest.TestCase): @patch("relval.report_results.get_response") @patch("relval.report_results.input") @patch("relval.report_results.wikitcms.result.Result") + def test_get_result_bugs_whitespace(self, mockResult, mockInput, mockGetResponse): + # Test "bugs" response which is only whitespace + mockGetResponse.return_value = "p" + + mockInput.side_effect = [" ", ""] + + result = get_result("testusername") + + self.assertEqual(result, mockResult.return_value) + + mockResult.assert_called_with("pass", "testusername", None, "") + + @patch("relval.report_results.get_response") + @patch("relval.report_results.input") + @patch("relval.report_results.wikitcms.result.Result") def test_get_result_comment(self, mockResult, mockInput, mockGetResponse): # Test comment, verify it's commented correctly mockGetResponse.return_value = "p"