Coverage for tests / test_get_request_type_fields.py: 100%

1""" 

2Tests for get_request_type_fields.py script. 

3""" 

4 

5import sys 

6import json 

7from pathlib import Path 

8from unittest.mock import patch, MagicMock 

9 

10import pytest 

11 

12# Add scripts directory to path 

13sys.path.insert(0, str(Path(__file__).parent.parent / 'scripts')) 

14 

15 

16def test_get_request_type_fields(mock_jira_client): 

17 """Test fetching fields for a request type.""" 

18 from get_request_type_fields import get_request_type_fields 

19 

20 mock_jira_client.get_request_type_fields.return_value = { 

21 "requestTypeFields": [ 

22 {"fieldId": "summary", "name": "Summary", "required": True, "jiraSchema": {"type": "string"}}, 

23 {"fieldId": "description", "name": "Description", "required": False, "jiraSchema": {"type": "string"}} 

24 ], 

25 "canRaiseOnBehalfOf": False, 

26 "canAddRequestParticipants": True 

27 } 

28 

29 with patch('get_request_type_fields.get_jira_client', return_value=mock_jira_client): 

30 result = get_request_type_fields("1", "25") 

31 

32 assert result is not None 

33 assert 'requestTypeFields' in result 

34 assert len(result['requestTypeFields']) == 2 

35 

36 

37def test_required_fields_marked(mock_jira_client): 

38 """Test that required fields are clearly marked.""" 

39 from get_request_type_fields import get_request_type_fields 

40 

41 mock_jira_client.get_request_type_fields.return_value = { 

42 "requestTypeFields": [ 

43 {"fieldId": "summary", "name": "Summary", "required": True}, 

44 {"fieldId": "description", "name": "Description", "required": False} 

45 ] 

46 } 

47 

48 with patch('get_request_type_fields.get_jira_client', return_value=mock_jira_client): 

49 result = get_request_type_fields("1", "25") 

50 

51 fields = result['requestTypeFields'] 

52 assert fields[0]['required'] == True 

53 assert fields[1]['required'] == False 

54 

55 

56def test_field_types(mock_jira_client): 

57 """Test that field types are correctly identified.""" 

58 from get_request_type_fields import get_request_type_fields 

59 

60 mock_jira_client.get_request_type_fields.return_value = { 

61 "requestTypeFields": [ 

62 {"fieldId": "summary", "name": "Summary", "required": True, "jiraSchema": {"type": "string"}}, 

63 {"fieldId": "customfield_10050", "name": "Category", "required": True, "jiraSchema": {"type": "option"}} 

64 ] 

65 } 

66 

67 with patch('get_request_type_fields.get_jira_client', return_value=mock_jira_client): 

68 result = get_request_type_fields("1", "25") 

69 

70 fields = result['requestTypeFields'] 

71 assert fields[0]['jiraSchema']['type'] == 'string' 

72 assert fields[1]['jiraSchema']['type'] == 'option' 

73 

74 

75def test_valid_values(mock_jira_client): 

76 """Test showing valid values for select/option fields.""" 

77 from get_request_type_fields import get_request_type_fields 

78 

79 mock_jira_client.get_request_type_fields.return_value = { 

80 "requestTypeFields": [ 

81 { 

82 "fieldId": "customfield_10050", 

83 "name": "Category", 

84 "required": True, 

85 "validValues": [ 

86 {"value": "Hardware", "label": "Hardware"}, 

87 {"value": "Software", "label": "Software"} 

88 ] 

89 } 

90 ] 

91 } 

92 

93 with patch('get_request_type_fields.get_jira_client', return_value=mock_jira_client): 

94 result = get_request_type_fields("1", "25") 

95 

96 field = result['requestTypeFields'][0] 

97 assert 'validValues' in field 

98 assert len(field['validValues']) == 2 

99 

100 

101def test_default_values(mock_jira_client): 

102 """Test showing default values when present.""" 

103 from get_request_type_fields import get_request_type_fields 

104 

105 mock_jira_client.get_request_type_fields.return_value = { 

106 "requestTypeFields": [ 

107 { 

108 "fieldId": "customfield_10050", 

109 "name": "Priority", 

110 "required": False, 

111 "defaultValues": [{"value": "Medium"}] 

112 } 

113 ] 

114 } 

115 

116 with patch('get_request_type_fields.get_jira_client', return_value=mock_jira_client): 

117 result = get_request_type_fields("1", "25") 

118 

119 field = result['requestTypeFields'][0] 

120 assert 'defaultValues' in field 

121 assert len(field['defaultValues']) == 1 

122 

123 

124def test_format_text_output(mock_jira_client, capsys): 

125 """Test human-readable table output with field details.""" 

126 from get_request_type_fields import format_fields_text 

127 

128 fields_data = { 

129 "requestTypeFields": [ 

130 {"fieldId": "summary", "name": "Summary", "required": True, "jiraSchema": {"type": "string"}}, 

131 {"fieldId": "description", "name": "Description", "required": False, "jiraSchema": {"type": "string"}} 

132 ], 

133 "canRaiseOnBehalfOf": False, 

134 "canAddRequestParticipants": True 

135 } 

136 

137 format_fields_text(fields_data, "Get IT help") 

138 

139 captured = capsys.readouterr() 

140 assert 'Request Type Fields' in captured.out 

141 assert 'Summary' in captured.out 

142 assert 'Required Fields' in captured.out 

143 

144 

145def test_format_json_output(mock_jira_client): 

146 """Test JSON output format.""" 

147 from get_request_type_fields import format_fields_json 

148 

149 fields_data = { 

150 "requestTypeFields": [ 

151 {"fieldId": "summary", "name": "Summary", "required": True} 

152 ] 

153 } 

154 

155 json_output = format_fields_json(fields_data) 

156 parsed = json.loads(json_output) 

157 

158 assert 'requestTypeFields' in parsed 

159 assert len(parsed['requestTypeFields']) == 1 

160 

161 

162def test_filter_required_only(mock_jira_client): 

163 """Test showing only required fields.""" 

164 from get_request_type_fields import filter_fields 

165 

166 fields_data = { 

167 "requestTypeFields": [ 

168 {"fieldId": "summary", "name": "Summary", "required": True}, 

169 {"fieldId": "description", "name": "Description", "required": False}, 

170 {"fieldId": "priority", "name": "Priority", "required": True} 

171 ] 

172 } 

173 

174 filtered = filter_fields(fields_data, required_only=True) 

175 

176 assert len(filtered['requestTypeFields']) == 2 

177 for field in filtered['requestTypeFields']: 

178 assert field['required'] == True