Coverage for src/jtech_installer/core/engine.py: 22%

1""" 

2Core engine for JTECH™ Installer 

3""" 

4 

5import time 

6from pathlib import Path 

7from typing import Optional 

8 

9from jtech_installer.analyzer.environment import AdvancedEnvironmentAnalyzer 

10from jtech_installer.core.models import ( 

11 InstallationConfig, 

12 InstallationResult, 

13 InstallationType, 

14 SystemInfo, 

15 TeamType, 

16) 

17from jtech_installer.detector.prerequisites import PrerequisitesChecker 

18from jtech_installer.detector.system import SystemDetector 

19from jtech_installer.installer.asset_copier import AssetCopier 

20from jtech_installer.installer.config_generator import ConfigGenerator 

21from jtech_installer.installer.structure import StructureCreator 

22from jtech_installer.installer.vscode_configurator import VSCodeConfigurator 

23from jtech_installer.validator.integrity import IntegrityValidator 

24from jtech_installer.validator.post_installation import PostInstallationValidator 

25 

26 

27class InstallerEngine: 

28 """Engine principal de instalação do JTECH™ Core""" 

29 

30 def __init__( 

31 self, 

32 target_path: Path, 

33 install_type: InstallationType, 

34 team_type: Optional[TeamType] = None, 

35 vscode_integration: bool = True, 

36 framework_source_path: Optional[Path] = None, 

37 dry_run: bool = False, 

38 ): 

39 self.config = InstallationConfig( 

40 project_path=target_path, 

41 install_type=install_type, 

42 team_type=team_type or TeamType.FULLSTACK, 

43 vs_code_integration=vscode_integration, 

44 custom_config={}, 

45 framework_source_path=framework_source_path, 

46 ) 

47 self.dry_run = dry_run 

48 self.start_time = time.time() 

49 

50 def detect_system(self) -> SystemInfo: 

51 """Detecta informações do sistema""" 

52 detector = SystemDetector() 

53 return detector.detect() 

54 

55 def check_prerequisites(self, system_info: SystemInfo) -> None: 

56 """Verifica pré-requisitos do sistema""" 

57 checker = PrerequisitesChecker() 

58 checker.check_all(system_info) 

59 

60 def analyze_environment(self): 

61 """ 

62 Executa análise avançada do ambiente. 

63 

64 Returns: 

65 Resultado da análise de ambiente 

66 """ 

67 analyzer = AdvancedEnvironmentAnalyzer(self.config) 

68 return analyzer.analyze_environment() 

69 

70 def install(self) -> InstallationResult: 

71 """Executa a instalação completa""" 

72 try: 

73 installed_components = [] 

74 errors = [] 

75 warnings = [] 

76 

77 # Criar estrutura de diretórios 

78 structure_creator = StructureCreator(self.config, self.dry_run) 

79 if structure_creator.create_structure(): 

80 installed_components.append("directory_structure") 

81 

82 # Copiar assets do framework 

83 asset_copier = AssetCopier(self.config, self.dry_run) 

84 try: 

85 assets_result = asset_copier.copy_all() 

86 

87 # Contar componentes instalados 

88 for asset_type, assets in assets_result.items(): 

89 if assets: 

90 installed_components.append( 

91 f"{asset_type}_{len(assets)}_files" 

92 ) 

93 

94 except Exception as e: 

95 errors.append(f"Erro ao copiar assets: {e}") 

96 warnings.append( 

97 "Alguns componentes podem não ter sido instalados" 

98 ) 

99 

100 # Gerar configuração personalizada 

101 config_generator = ConfigGenerator() 

102 try: 

103 core_config = config_generator.generate_config( 

104 self.config, self.config.project_path 

105 ) 

106 

107 if not self.dry_run: 

108 config_file = config_generator.write_config( 

109 core_config, self.config.project_path 

110 ) 

111 

112 # Validar configuração gerada 

113 if config_generator.validate_config(core_config): 

114 installed_components.append("core_config") 

115 else: 

116 warnings.append( 

117 "Configuração gerada pode ter problemas" 

118 ) 

119 

120 else: 

121 installed_components.append("core_config_simulated") 

122 

123 except Exception as e: 

124 errors.append(f"Erro ao gerar configuração: {e}") 

125 warnings.append("Configuração core-config.yml não foi gerada") 

126 

127 # Configurar VS Code se habilitado 

128 if self.config.vs_code_integration: 

129 vscode_configurator = VSCodeConfigurator( 

130 self.config, self.dry_run 

131 ) 

132 try: 

133 vscode_results = vscode_configurator.configure_all() 

134 

135 # Contar configurações aplicadas 

136 applied_configs = sum( 

137 1 for result in vscode_results.values() if result 

138 ) 

139 if applied_configs > 0: 

140 installed_components.append( 

141 f"vscode_{applied_configs}_configs" 

142 ) 

143 

144 # Validar configurações 

145 validation_results = ( 

146 vscode_configurator.validate_configuration() 

147 ) 

148 failed_validations = [ 

149 name 

150 for name, valid in validation_results.items() 

151 if not valid 

152 ] 

153 

154 if failed_validations: 

155 warnings.append( 

156 f"Alguns arquivos VS Code podem ter problemas: {', '.join(failed_validations)}" 

157 ) 

158 

159 except Exception as e: 

160 errors.append(f"Erro ao configurar VS Code: {e}") 

161 warnings.append("Configuração do VS Code não foi aplicada") 

162 

163 # Validação pós-instalação 

164 validation_passed = False 

165 try: 

166 validator = PostInstallationValidator(self.config) 

167 validation_report = validator.validate_all() 

168 

169 validation_passed = validation_report.overall_status 

170 

171 if validation_passed: 

172 installed_components.append("validation_passed") 

173 else: 

174 failed_components = [ 

175 result.component 

176 for result in validation_report.results 

177 if not result.status 

178 ] 

179 warnings.append( 

180 f"Validação falhou em: {', '.join(failed_components)}" 

181 ) 

182 

183 except Exception as e: 

184 errors.append(f"Erro durante validação: {e}") 

185 warnings.append( 

186 "Validação pós-instalação não pôde ser executada" 

187 ) 

188 

189 # TODO: Implementar outras fases da instalação 

190 

191 duration = time.time() - self.start_time 

192 

193 return InstallationResult( 

194 success=len(errors) == 0, 

195 installed_components=installed_components, 

196 errors=errors, 

197 warnings=warnings, 

198 duration=duration, 

199 config_generated=True, 

200 validation_passed=validation_passed, 

201 ) 

202 

203 except Exception as e: 

204 duration = time.time() - self.start_time 

205 return InstallationResult( 

206 success=False, 

207 installed_components=[], 

208 errors=[str(e)], 

209 warnings=[], 

210 duration=duration, 

211 ) 

212 

213 def validate_installation(self) -> bool: 

214 """Valida a instalação realizada""" 

215 validator = IntegrityValidator(self.config) 

216 return validator.validate_all()