setup-java@e150063 (original) (raw)

1

import * as fs from 'fs';

2

import os from 'os';

3

import * as path from 'path';

4

import * as core from '@actions/core';

5

import * as io from '@actions/io';

6

import * as toolchains from '../src/toolchains';

7

import { M2_DIR, MVN_TOOLCHAINS_FILE } from '../src/constants';

8

+

9

const m2Dir = path.join(__dirname, M2_DIR);

10

const toolchainsFile = path.join(m2Dir, MVN_TOOLCHAINS_FILE);

11

+

12

describe('toolchains tests', () => {

13

let spyOSHomedir: jest.SpyInstance;

14

let spyInfo: jest.SpyInstance;

15

+

16

beforeEach(async () => {

17

await io.rmRF(m2Dir);

18

spyOSHomedir = jest.spyOn(os, 'homedir');

19

spyOSHomedir.mockReturnValue(__dirname);

20

spyInfo = jest.spyOn(core, 'info');

21

spyInfo.mockImplementation(() => null);

22

}, 300000);

23

+

24

afterAll(async () => {

25

try {

26

await io.rmRF(m2Dir);

27

} catch {

28

console.log('Failed to remove test directories');

29

}

30

jest.resetAllMocks();

31

jest.clearAllMocks();

32

jest.restoreAllMocks();

33

}, 100000);

34

+

35

it('creates toolchains.xml in alternate locations', async () => {

36

const jdkInfo = {

37

version: '17',

38

vendor: 'Eclipse Temurin',

39

id: 'temurin_17',

40

jdkHome: '/opt/hostedtoolcache/Java_Temurin-Hotspot_jdk/17.0.1-12/x64'

41

};

42

+

43

const altHome = path.join(__dirname, 'runner', 'toolchains');

44

const altToolchainsFile = path.join(altHome, MVN_TOOLCHAINS_FILE);

45

await io.rmRF(altHome); // ensure it doesn't already exist

46

+

47

await toolchains.createToolchainsSettings({

48

jdkInfo,

49

settingsDirectory: altHome,

50

overwriteSettings: true

51

});

52

+

53

expect(fs.existsSync(m2Dir)).toBe(false);

54

expect(fs.existsSync(toolchainsFile)).toBe(false);

55

+

56

expect(fs.existsSync(altHome)).toBe(true);

57

expect(fs.existsSync(altToolchainsFile)).toBe(true);

58

expect(fs.readFileSync(altToolchainsFile, 'utf-8')).toEqual(

59

toolchains.generateToolchainDefinition(

60

'',

61

jdkInfo.version,

62

jdkInfo.vendor,

63

jdkInfo.id,

64

jdkInfo.jdkHome

65

)

66

);

67

+

68

await io.rmRF(altHome);

69

}, 100000);

70

+

71

it('creates toolchains.xml with minimal configuration', async () => {

72

const jdkInfo = {

73

version: '17',

74

vendor: 'Eclipse Temurin',

75

id: 'temurin_17',

76

jdkHome: '/opt/hostedtoolcache/Java_Temurin-Hotspot_jdk/17.0.1-12/x64'

77

};

78

+

79

`` +

const result = `

80

<toolchains xmlns="https://maven.apache.org/TOOLCHAINS/1.1.0"

81

xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"

82

xsi:schemaLocation="https://maven.apache.org/TOOLCHAINS/1.1.0 " title="undefined" rel="noopener noreferrer">https://maven.apache.org/xsd/toolchains-1.1.0.xsd">

83

84

jdk

85

86

87

Eclipse Temurin

88

temurin_17

89

90

91

/opt/hostedtoolcache/Java_Temurin-Hotspot_jdk/17.0.1-12/x64

92

93

94

`` +

95

+

96

await toolchains.createToolchainsSettings({

97

jdkInfo,

98

settingsDirectory: m2Dir,

99

overwriteSettings: true

100

});

101

+

102

expect(fs.existsSync(m2Dir)).toBe(true);

103

expect(fs.existsSync(toolchainsFile)).toBe(true);

104

expect(fs.readFileSync(toolchainsFile, 'utf-8')).toEqual(

105

toolchains.generateToolchainDefinition(

106

'',

107

jdkInfo.version,

108

jdkInfo.vendor,

109

jdkInfo.id,

110

jdkInfo.jdkHome

111

)

112

);

113

expect(

114

toolchains.generateToolchainDefinition(

115

'',

116

jdkInfo.version,

117

jdkInfo.vendor,

118

jdkInfo.id,

119

jdkInfo.jdkHome

120

)

121

).toEqual(result);

122

}, 100000);

123

+

124

it('reuses existing toolchains.xml files', async () => {

125

const jdkInfo = {

126

version: '17',

127

vendor: 'Eclipse Temurin',

128

id: 'temurin_17',

129

jdkHome: '/opt/hostedtoolcache/Java_Temurin-Hotspot_jdk/17.0.1-12/x64'

130

};

131

+

132

`` +

const originalFile = `

133

134

jdk

135

136

1.6

137

Sun

138

sun_1.6

139

140

141

/opt/jdk/sun/1.6

142

143

144

`` +

145

`` +

const result = `

146

147

148

jdk

149

150

1.6

151

Sun

152

sun_1.6

153

154

155

/opt/jdk/sun/1.6

156

157

158

159

jdk

160

161

162

Eclipse Temurin

163

temurin_17

164

165

166

/opt/hostedtoolcache/Java_Temurin-Hotspot_jdk/17.0.1-12/x64

167

168

169

`` +

170

+

171

fs.mkdirSync(m2Dir, { recursive: true });

172

fs.writeFileSync(toolchainsFile, originalFile);

173

expect(fs.existsSync(m2Dir)).toBe(true);

174

expect(fs.existsSync(toolchainsFile)).toBe(true);

175

+

176

await toolchains.createToolchainsSettings({

177

jdkInfo,

178

settingsDirectory: m2Dir,

179

overwriteSettings: true

180

});

181

+

182

expect(fs.existsSync(m2Dir)).toBe(true);

183

expect(fs.existsSync(toolchainsFile)).toBe(true);

184

expect(fs.readFileSync(toolchainsFile, 'utf-8')).toEqual(

185

toolchains.generateToolchainDefinition(

186

originalFile,

187

jdkInfo.version,

188

jdkInfo.vendor,

189

jdkInfo.id,

190

jdkInfo.jdkHome

191

)

192

);

193

expect(

194

toolchains.generateToolchainDefinition(

195

originalFile,

196

jdkInfo.version,

197

jdkInfo.vendor,

198

jdkInfo.id,

199

jdkInfo.jdkHome

200

)

201

).toEqual(result);

202

}, 100000);

203

+

204

it('does not overwrite existing toolchains.xml files', async () => {

205

const jdkInfo = {

206

version: '17',

207

vendor: 'Eclipse Temurin',

208

id: 'temurin_17',

209

jdkHome: '/opt/hostedtoolcache/Java_Temurin-Hotspot_jdk/17.0.1-12/x64'

210

};

211

+

212

`` +

const originalFile = `

213

214

jdk

215

216

1.6

217

Sun

218

sun_1.6

219

220

221

/opt/jdk/sun/1.6

222

223

224

`` +

225

+

226

fs.mkdirSync(m2Dir, { recursive: true });

227

fs.writeFileSync(toolchainsFile, originalFile);

228

expect(fs.existsSync(m2Dir)).toBe(true);

229

expect(fs.existsSync(toolchainsFile)).toBe(true);

230

+

231

await toolchains.createToolchainsSettings({

232

jdkInfo,

233

settingsDirectory: m2Dir,

234

overwriteSettings: false

235

});

236

+

237

expect(fs.existsSync(m2Dir)).toBe(true);

238

expect(fs.existsSync(toolchainsFile)).toBe(true);

239

expect(fs.readFileSync(toolchainsFile, 'utf-8')).toEqual(originalFile);

240

}, 100000);

241

+

242

it('generates valid toolchains.xml with minimal configuration', () => {

243

const jdkInfo = {

244

version: 'JAVA_VERSION',

245

vendor: 'JAVA_VENDOR',

246

id: 'VENDOR_VERSION',

247

jdkHome: 'JAVA_HOME'

248

};

249

+

250

`` +

const expectedToolchains = `

251

<toolchains xmlns="https://maven.apache.org/TOOLCHAINS/1.1.0"

252

xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"

253

xsi:schemaLocation="https://maven.apache.org/TOOLCHAINS/1.1.0 " title="undefined" rel="noopener noreferrer">https://maven.apache.org/xsd/toolchains-1.1.0.xsd">

254

255

jdk

256

257

${jdkInfo.version}

258

${jdkInfo.vendor}

259

${jdkInfo.id}

260

261

262

${jdkInfo.jdkHome}

263

264

265

`` +

266

+

267

expect(

268

toolchains.generateToolchainDefinition(

269

'',

270

jdkInfo.version,

271

jdkInfo.vendor,

272

jdkInfo.id,

273

jdkInfo.jdkHome

274

)

275

).toEqual(expectedToolchains);

276

}, 100000);

277

+

278

it('creates toolchains.xml with correct id when none is supplied', async () => {

279

const version = '17';

280

const distributionName = 'temurin';

281

const id = 'temurin_17';

282

const jdkHome = '/opt/hostedtoolcache/Java_Temurin-Hotspot_jdk/17.0.1-12/x64';

283

+

284

await toolchains.configureToolchains(version, distributionName, jdkHome, undefined);

285

+

286

expect(fs.existsSync(m2Dir)).toBe(true);

287

expect(fs.existsSync(toolchainsFile)).toBe(true);

288

expect(fs.readFileSync(toolchainsFile, 'utf-8')).toEqual(

289

toolchains.generateToolchainDefinition('', version, distributionName, id, jdkHome)

290

);

291

}, 100000);

292

});