FilesExpand file tree

 main

/

importDefinitelyTypedTests.mjs

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

178 lines (158 loc) · 6.77 KB

 main

/

importDefinitelyTypedTests.mjs

Copy path

Top

File metadata and controls

• Code
• Blame

178 lines (158 loc) · 6.77 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

import * as childProcess from "child_process";

import * as fs from "fs";

import * as os from "os";

import * as path from "path";

import url from "url";

const __filename = url.fileURLToPath(new URL(import.meta.url));

const __dirname = path.dirname(__filename);

main();

function main() {

const [, progName, tscRoot, definitelyTypedRoot] = process.argv;

if (process.argv.length !== 4) {

if (process.argv.length < 2) {

throw new Error("Expected at least 2 argv elements.");

}

console.log("Usage:");

console.log(` node ${path.relative(__dirname, progName)} [TypeScript Repo Root] [DefinitelyTyped Repo Root]`);

return;

}

const tscPath = path.resolve(tscRoot, "built", "local", "tsc.js");

const rwcTestPath = path.resolve(tscRoot, "internal", "cases", "rwc");

const resolvedDefinitelyTypedRoot = path.resolve(definitelyTypedRoot);

console.log(`Resolved TypeScript Compiler Path: '${tscPath}'.`);

console.log(`Resolved TypeScript RWC Path: '${rwcTestPath}'.`);

console.log(`Resolved DefinitelyTyped Repo Root: '${resolvedDefinitelyTypedRoot}'.`);

importDefinitelyTypedTests(tscPath, rwcTestPath, resolvedDefinitelyTypedRoot);

}

/**

* @param {string} path

* @param {string} endingString

* @returns {boolean}

*/

function filePathEndsWith(path, endingString) {

const pathLen = path.length;

const extLen = endingString.length;

return pathLen > extLen && path.substr(pathLen - extLen, extLen).toLocaleLowerCase() === endingString.toLocaleLowerCase();

}

/**

* @param {string} source

* @param {string} destination

*/

function copyFileSync(source, destination) {

const text = fs.readFileSync(source);

fs.writeFileSync(destination, text);

}

/**

* @param {string} tscPath

* @param {string} rwcTestPath

* @param {string} testCaseName

* @param {string[]} testFiles

* @param {string | undefined} responseFile

*/

function importDefinitelyTypedTest(tscPath, rwcTestPath, testCaseName, testFiles, responseFile) {

let cmd = "node " + tscPath + " --module commonjs " + testFiles.join(" ");

if (responseFile) {

cmd += " @" + responseFile;

}

const testDirectoryName = testCaseName + "_" + Math.floor((Math.random() * 10000) + 1);

const testDirectoryPath = path.join(os.tmpdir(), testDirectoryName);

if (fs.existsSync(testDirectoryPath)) {

throw new Error("Could not create test directory");

}

fs.mkdirSync(testDirectoryPath);

childProcess.exec(cmd, {

maxBuffer: 1 * 1024 * 1024,

cwd: testDirectoryPath

}, (error, stdout, stderr) => {

console.log("importing " + testCaseName + " ...");

console.log(cmd);

if (error) {

console.log("importing " + testCaseName + " ...");

console.log(cmd);

console.log("==> error " + JSON.stringify(error));

console.log("==> stdout " + String(stdout));

console.log("==> stderr " + String(stderr));

console.log("\r\n");

return;

}

// copy generated file to output location

const outputFilePath = path.join(testDirectoryPath, "iocapture0.json");

const testCasePath = path.join(rwcTestPath, "DefinitelyTyped_" + testCaseName + ".json");

copyFileSync(outputFilePath, testCasePath);

//console.log("output generated at: " + outputFilePath);

if (!fs.existsSync(testCasePath)) {

throw new Error("could not find test case at: " + testCasePath);

}

else {

fs.unlinkSync(outputFilePath);

fs.rmdirSync(testDirectoryPath);

//console.log("testcase generated at: " + testCasePath);

//console.log("Done.");

}

//console.log("\r\n");

}).on("error", (error) => {

console.log("==> error " + JSON.stringify(error));

console.log("\r\n");

});

}

/**

* @param {string} tscPath

* @param {string} rwcTestPath

* @param {string} definitelyTypedRoot

*/

function importDefinitelyTypedTests(tscPath, rwcTestPath, definitelyTypedRoot) {

fs.readdir(definitelyTypedRoot, (err, subDirectories) => {

if (err) {

throw err;

}

// When you just want to test the script out on one or two files,

// just add a line like the following:

//

// .filter(d => d.indexOf("sipml") >= 0 )

subDirectories

.filter(d => ["_infrastructure", "node_modules", ".git"].indexOf(d) < 0)

.filter(i => fs.statSync(path.join(definitelyTypedRoot, i)).isDirectory())

.forEach(d => {

const directoryPath = path.join(definitelyTypedRoot, d);

fs.readdir(directoryPath, (err, files) => {

if (err) {

throw err;

}

/** @type {string[]} */

const tsFiles = [];

/** @type {string[]} */

const testFiles = [];

/** @type {string | undefined} */

let paramFile;

for (const filePath of files.map(f => path.join(directoryPath, f))) {

if (filePathEndsWith(filePath, ".ts")) {

tsFiles.push(filePath);

if (filePathEndsWith(filePath, "-tests.ts")) {

testFiles.push(filePath);

}

}

else if (filePathEndsWith(filePath, ".tscparams")) {

paramFile = filePath;

}

}

if (testFiles.length === 0) {

// no test files but multiple d.ts's, e.g. winjs

const regexp = new RegExp(d + "(([-][0-9])|(\\.d\\.ts))");

if (tsFiles.length > 1 && tsFiles.every(t => filePathEndsWith(t, ".d.ts") && regexp.test(t))) {

for (const fileName of tsFiles) {

importDefinitelyTypedTest(tscPath, rwcTestPath, path.basename(fileName, ".d.ts"), [fileName], paramFile);

}

}

else {

importDefinitelyTypedTest(tscPath, rwcTestPath, d, tsFiles, paramFile);

}

}

else {

for (const fileName of tsFiles) {

importDefinitelyTypedTest(tscPath, rwcTestPath, path.basename(fileName, "-tests.ts"), [fileName], paramFile);

}

}

});

});

});

}