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
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
|
# Copyright 2022 Google Inc. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from flatc_test import *
class TsTests():
def Base(self):
# Generate just foo with no extra arguments
flatc(["--ts", "foo.fbs"])
# Should generate the module that exports both foo and its direct
# include, bar.
assert_file_and_contents(
"foo_generated.ts",
[
"export { Bar } from './bar.js';",
"export { Foo } from './foo.js';",
],
)
# Foo should be generated in place and exports the Foo table.
assert_file_and_contents("foo.ts", "export class Foo {")
# Included files, like bar, should not be generated.
assert_file_doesnt_exists("bar.ts")
def BaseMultipleFiles(self):
# Generate both foo and bar with no extra arguments
flatc(["--ts", "foo.fbs", "bar/bar.fbs"])
# Should generate the module that exports both foo and its direct
# include, bar.
assert_file_and_contents(
"foo_generated.ts",
[
"export { Bar } from './bar.js';",
"export { Foo } from './foo.js';",
],
)
# Foo should be generated in place and exports the Foo table.
assert_file_and_contents("foo.ts", "export class Foo {")
# Bar should also be generatd in place and exports the Bar table.
assert_file_and_contents("bar.ts", "export class Bar {")
def BaseWithNamespace(self):
# Generate foo with namespacing, with no extra arguments
flatc(["--ts", "foo_with_ns.fbs"])
# Should generate the module that exports both foo in its namespace
# directory and its direct include, bar.
assert_file_and_contents(
"foo_with_ns_generated.ts",
[
"export { Bar } from './bar/bar.js';",
"export { Foo } from './something/foo.js';",
],
)
# Foo should be placed in the namespaced directory. It should export
# Foo, and the import of Bar should be relative to its location.
assert_file_and_contents(
"something/foo.ts",
[
"export class Foo {",
"import { Bar } from '../bar/bar.js';",
],
)
# Included files, like bar, should not be generated.
assert_file_doesnt_exists("bar.ts")
def GenAll(self):
# Generate foo with generate all options
flatc(["--ts", "--gen-all", "foo.fbs"])
# Should generate a single file that exports all the generated types.
assert_file_and_contents(
"foo_generated.ts",
[
"export { Bar } from './bar.js'",
"export { Baz } from './baz.js'",
"export { Foo } from './foo.js'",
],
)
# Foo should be generated with an import to Bar and an export of itself.
assert_file_and_contents(
"foo.ts",
[
"import { Bar } from './bar.js';",
"export class Foo {",
],
)
# Bar should be generated with an import to Baz and an export of itself.
assert_file_and_contents(
"bar.ts",
[
"import { Baz } from './baz.js';",
"export class Bar {",
],
)
# Baz should be generated with an export of itself.
assert_file_and_contents(
"baz.ts",
[
"export enum Baz {",
],
)
def FlatFiles(self):
# Generate just foo with the flat files option
flatc(["--ts", "--ts-flat-files", "foo.fbs"])
# Should generate a single file that imports bar as a single file, and
# exports the Foo table.
assert_file_and_contents(
"foo_generated.ts",
[
"import {Bar as Bar} from './bar_generated.js';",
"export class Foo {",
],
)
# The root type Foo should not be generated in its own file.
assert_file_doesnt_exists("foo.ts")
def FlatFilesWithNamespace(self):
# Generate just foo with the flat files option
flatc(["--ts", "--ts-flat-files", "foo_with_ns.fbs"])
# Should generate a single file that imports bar as a single file, and
# exports the Foo table.
assert_file_and_contents(
"foo_with_ns_generated.ts",
[
"import {Bar as Bar} from './bar_with_ns_generated.js';",
"export class Foo {",
],
)
# The root type Foo should not be generated in its own file.
assert_file_doesnt_exists("foo.ts")
def FlatFilesMultipleFiles(self):
# Generate both foo and bar with the flat files option
flatc(["--ts", "--ts-flat-files", "foo.fbs", "bar/bar.fbs"])
# Should generate a single foo file that imports bar as a single file,
# and exports the Foo table.
assert_file_and_contents(
"foo_generated.ts",
[
"import {Bar as Bar} from './bar_generated.js';",
"export class Foo {",
],
)
# Should generate a single bar file that imports bar as a single file,
# and exports the Bar table.
assert_file_and_contents(
"bar_generated.ts",
[
"import {Baz as Baz} from './baz_generated.js';",
"export class Bar {",
],
)
# The types Foo and Bar should not be generated in their own files
assert_file_doesnt_exists("foo.ts")
assert_file_doesnt_exists("bar.ts")
def FlatFilesGenAll(self):
# Generate foo with all of its dependents with the flat files option
flatc(["--ts", "--ts-flat-files", "--gen-all", "foo.fbs"])
# Should generate a single foo file
assert_file_and_contents(
"foo_generated.ts",
# Should export each of the types within the single file
[
"export class Foo {",
"export class Bar {",
"export enum Baz {",
],
# No includes for the dependent types should be present.
doesnt_contain=[
"import {Bar as Bar}",
"import {Baz as Baz}",
],
)
# The types Foo, Bar and Baz should not be generated in their own files.
assert_file_doesnt_exists("foo.ts")
assert_file_doesnt_exists("bar.ts")
assert_file_doesnt_exists("baz.ts")
def ZFlatFilesGenAllWithNamespacing(self):
# Generate foo with all of its dependents with the flat files option
flatc(["--ts", "--ts-flat-files", "--gen-all", "foo_with_ns.fbs"])
# Should generate a single foo file
assert_file_and_contents(
"foo_with_ns_generated.ts",
# Should export each of the types within the single file
[
"export class bar_Bar {",
"export class bar_Foo {",
"export enum Baz {",
"export enum baz_Baz {",
"export class something_Foo {"
],
# No includes for the dependent types should be present.
doesnt_contain=[
"import {Bar as Bar}",
"import {Baz as Baz}",
],
)
# The types Foo, Bar and Baz should not be generated in their own files.
assert_file_doesnt_exists("foo.ts")
assert_file_doesnt_exists("bar.ts")
assert_file_doesnt_exists("baz.ts")
|
