Coverage for ingadhoc-odoo-saas-adhoc / saas_provider_upgrade / tests / test_upgrade_line.py: 100%

1from unittest.mock import patch 

2 

3from odoo import Command 

4from odoo.exceptions import UserError 

5 

6from .test_provider_upgrade_base import TestProviderUpgradeCommon 

7 

8 

9class TestProviderUpgradeLine(TestProviderUpgradeCommon): 

10 def test_approve_and_revert_script(self): 

11 ul = self.upgrade_line_02 

12 

13 # Guardamos el old_script para el revert 

14 old_script = ul.script 

15 

16 # Suponemos que estamos desarrollando un nuevo script 

17 dev_script = "x = 1" 

18 ul.dev_script = dev_script 

19 

20 # Aprobamos el scirpt sin testear (mock _validate_ops to bypass request requirement) 

21 with patch.object(type(ul), "_validate_ops"): 

22 ul.with_context(skip_test=True).action_approve_script() 

23 

24 self.assertFalse(ul.dev_script) 

25 self.assertEqual(ul.script, dev_script) 

26 self.assertEqual(ul.script_version, 2) 

27 self.assertEqual(ul.state, "approved") 

28 

29 # Revertimos el cambio 

30 revert_wizard = ( 

31 self.env["saas.provider.upgrade.revert.wizard"] 

32 .with_context(to_version=1, upgrade_line_id=ul.id) 

33 .create([{}]) 

34 ) 

35 revert_wizard.confirm() 

36 

37 # Se deberia volver al old_script con una version nueva 

38 self.assertFalse(ul.dev_script) 

39 self.assertEqual(ul.script, old_script) 

40 self.assertEqual(ul.script_version, 3) 

41 self.assertEqual(ul.state, "approved") 

42 

43 def test_get_script_version_test_dev_returns_dev_script(self): 

44 """In test_dev context, return a temporary script built from `dev_script`.""" 

45 request = self.env["helpdesk.ticket.upgrade.request"]._create_request(self.upgrade_ticket.id, "test") 

46 

47 ul = self.upgrade_line_02 

48 ul.dev_script = "dev_x = 42" 

49 ul.dev_execution_mode = "odooly" 

50 

51 script_version = ul.with_context(test_dev=True, ticket_request_id=request.id)._get_script_version() 

52 

53 self.assertEqual(script_version.script, "dev_x = 42") 

54 self.assertEqual(script_version.execution_mode, "odooly") 

55 self.assertFalse(bool(script_version.id)) 

56 

57 def test_get_script_version_no_actual_script_with_customer_note(self): 

58 """When no actual script exists and customer notes are enabled, return a temporary empty script.""" 

59 request = self.env["helpdesk.ticket.upgrade.request"]._create_request(self.upgrade_ticket.id, "test") 

60 

61 # Create an upgrade line without an actual script but that generates a customer note 

62 ul = self.env["saas.upgrade.line"].create( 

63 { 

64 "name": "[Test] UL no actual script with note", 

65 "upgrade_type_ids": [Command.link(self.upgrade_type.id)], 

66 "type": "4_post", 

67 "state": "approved", 

68 "run_type": "test", 

69 "add_customer_note": True, 

70 "adhoc_product_id": self.env.ref("saas_provider_adhoc.adhoc_product_actualizacion_actualizacion").id, 

71 } 

72 ) 

73 

74 script_version = ul.with_context(ticket_request_id=request.id)._get_script_version() 

75 

76 # Should return a temporary (new) record with empty script and 'odooly' execution mode 

77 self.assertEqual(script_version.script, "") 

78 self.assertEqual(script_version.execution_mode, "odooly") 

79 # New records are not persisted and therefore have falsy id 

80 self.assertFalse(bool(script_version.id)) 

81 

82 def test_get_script_version_run_type_production_returns_actual(self): 

83 """If `run_type` is 'production', return the actual persisted script.""" 

84 request = self.env["helpdesk.ticket.upgrade.request"]._create_request(self.upgrade_ticket.id, "test") 

85 

86 ul = self.upgrade_line_02 

87 # ensure there is an actual script 

88 actual = ul.actual_script_id 

89 ul.run_type = "production" 

90 

91 script_version = ul.with_context(ticket_request_id=request.id)._get_script_version() 

92 self.assertEqual(script_version, actual) 

93 

94 def test_get_script_version_condition_true_returns_mapped_version(self): 

95 """When production freeze applies and the request mapping specifies a version, return that mapped script.""" 

96 request = self.env["helpdesk.ticket.upgrade.request"]._create_request(self.upgrade_ticket.id, "test") 

97 request.active_production_freeze = True 

98 request.aim = "production" 

99 

100 ul = self.upgrade_line_02 

101 # create a script version to be returned 

102 version = 99 

103 desired_script = self.env["saas.upgrade.line.script"].create( 

104 {"upgrade_line_id": ul.id, "version": version, "script": "x = 1"} 

105 ) 

106 

107 # patch request mapping and production_freeze_ignore 

108 with patch.object( 

109 type(request), "_get_upgrade_line_versions_to_use", return_value={str(ul.id): version} 

110 ), patch.object(type(ul), "_production_freeze_ignore", return_value=False): 

111 script_version = ul.with_context(ticket_request_id=request.id)._get_script_version() 

112 self.assertEqual(script_version, desired_script) 

113 

114 def test_get_script_version_condition_true_missing_version_raises(self): 

115 """When production freeze applies but the mapped version does not exist, raise `UserError`.""" 

116 request = self.env["helpdesk.ticket.upgrade.request"]._create_request(self.upgrade_ticket.id, "test") 

117 request.active_production_freeze = True 

118 request.aim = "production" 

119 

120 ul = self.upgrade_line_02 

121 missing_version = 12345 

122 with patch.object( 

123 type(request), "_get_upgrade_line_versions_to_use", return_value={str(ul.id): missing_version} 

124 ), patch.object(type(ul), "_production_freeze_ignore", return_value=False): 

125 with self.assertRaises(UserError): 

126 ul.with_context(ticket_request_id=request.id)._get_script_version()