| OLD | NEW |
|---|
| (Empty) | |
| 1 # Copyright 2016 The Chromium Authors. All rights reserved. |
| 2 # Use of this source code is governed by a BSD-style license that can be |
| 3 # found in the LICENSE file. |
| 4 |
| 5 import argparse |
| 6 import client_api_generator |
| 7 import shutil |
| 8 import sys |
| 9 import tempfile |
| 10 import unittest |
| 11 |
| 12 |
| 13 class ClientApiGeneratorTest(unittest.TestCase): |
| 14 |
| 15 def test_ArgumentParsing(self): |
| 16 with tempfile.NamedTemporaryFile() as f: |
| 17 f.write('{"foo": true}') |
| 18 f.flush() |
| 19 json_api, output_dir = client_api_generator.ParseArguments([ |
| 20 '--protocol', f.name, '--output_dir', 'out']) |
| 21 self.assertEqual({'foo': True}, json_api) |
| 22 self.assertEqual('out', output_dir) |
| 23 |
| 24 def test_ToTitleCase(self): |
| 25 self.assertEqual(client_api_generator.ToTitleCase('fooBar'), 'FooBar') |
| 26 |
| 27 def test_DashToCamelCase(self): |
| 28 self.assertEqual(client_api_generator.DashToCamelCase('foo-bar'), 'FooBar') |
| 29 self.assertEqual(client_api_generator.DashToCamelCase('foo-'), 'Foo') |
| 30 self.assertEqual(client_api_generator.DashToCamelCase('-bar'), 'Bar') |
| 31 |
| 32 def test_CamelCaseToHackerStyle(self): |
| 33 self.assertEqual(client_api_generator.CamelCaseToHackerStyle('FooBar'), |
| 34 'foo_bar') |
| 35 self.assertEqual(client_api_generator.CamelCaseToHackerStyle('LoLoLoL'), |
| 36 'lo_lo_lol') |
| 37 |
| 38 def test_MangleEnum(self): |
| 39 self.assertEqual(client_api_generator.MangleEnum('FOO'), 'FOO') |
| 40 self.assertEqual(client_api_generator.MangleEnum('NULL'), 'NONE') |
| 41 |
| 42 def test_PatchFullQualifiedRefs(self): |
| 43 json_api = { |
| 44 'domains': [ |
| 45 { |
| 46 'domain': 'domain0', |
| 47 '$ref': 'reference', |
| 48 }, |
| 49 { |
| 50 'domain': 'domain1', |
| 51 '$ref': 'reference', |
| 52 'more': [{'$ref': 'domain0.thing'}], |
| 53 } |
| 54 ] |
| 55 } |
| 56 expected_json_api = { |
| 57 'domains': [ |
| 58 { |
| 59 'domain': 'domain0', |
| 60 '$ref': 'domain0.reference', |
| 61 }, |
| 62 { |
| 63 'domain': 'domain1', |
| 64 '$ref': 'domain1.reference', |
| 65 'more': [{'$ref': 'domain0.thing'}], |
| 66 } |
| 67 ] |
| 68 } |
| 69 client_api_generator.PatchFullQualifiedRefs(json_api) |
| 70 self.assertDictEqual(json_api, expected_json_api) |
| 71 |
| 72 def test_NumberType(self): |
| 73 json_api = { |
| 74 'domains': [ |
| 75 { |
| 76 'domain': 'domain', |
| 77 'types': [ |
| 78 { |
| 79 'id': 'TestType', |
| 80 'type': 'number', |
| 81 }, |
| 82 ] |
| 83 }, |
| 84 ] |
| 85 } |
| 86 client_api_generator.CreateTypeDefinitions(json_api) |
| 87 type = json_api['domains'][0]['types'][0] |
| 88 resolved = client_api_generator.ResolveType(type) |
| 89 self.assertEqual('double', resolved['raw_type']) |
| 90 |
| 91 def test_IntegerType(self): |
| 92 json_api = { |
| 93 'domains': [ |
| 94 { |
| 95 'domain': 'domain', |
| 96 'types': [ |
| 97 { |
| 98 'id': 'TestType', |
| 99 'type': 'integer', |
| 100 }, |
| 101 ] |
| 102 }, |
| 103 ] |
| 104 } |
| 105 client_api_generator.CreateTypeDefinitions(json_api) |
| 106 type = json_api['domains'][0]['types'][0] |
| 107 resolved = client_api_generator.ResolveType(type) |
| 108 self.assertEqual('int', resolved['raw_type']) |
| 109 |
| 110 def test_BooleanType(self): |
| 111 json_api = { |
| 112 'domains': [ |
| 113 { |
| 114 'domain': 'domain', |
| 115 'types': [ |
| 116 { |
| 117 'id': 'TestType', |
| 118 'type': 'boolean', |
| 119 }, |
| 120 ] |
| 121 }, |
| 122 ] |
| 123 } |
| 124 client_api_generator.CreateTypeDefinitions(json_api) |
| 125 type = json_api['domains'][0]['types'][0] |
| 126 resolved = client_api_generator.ResolveType(type) |
| 127 self.assertEqual('bool', resolved['raw_type']) |
| 128 |
| 129 def test_StringType(self): |
| 130 json_api = { |
| 131 'domains': [ |
| 132 { |
| 133 'domain': 'domain', |
| 134 'types': [ |
| 135 { |
| 136 'id': 'TestType', |
| 137 'type': 'string', |
| 138 }, |
| 139 ] |
| 140 }, |
| 141 ] |
| 142 } |
| 143 client_api_generator.CreateTypeDefinitions(json_api) |
| 144 type = json_api['domains'][0]['types'][0] |
| 145 resolved = client_api_generator.ResolveType(type) |
| 146 self.assertEqual('std::string', resolved['raw_type']) |
| 147 |
| 148 def test_ObjectType(self): |
| 149 json_api = { |
| 150 'domains': [ |
| 151 { |
| 152 'domain': 'domain', |
| 153 'types': [ |
| 154 { |
| 155 'id': 'TestType', |
| 156 'type': 'object', |
| 157 'properties': [ |
| 158 {'name': 'p1', 'type': 'number'}, |
| 159 {'name': 'p2', 'type': 'integer'}, |
| 160 {'name': 'p3', 'type': 'boolean'}, |
| 161 {'name': 'p4', 'type': 'string'}, |
| 162 {'name': 'p5', 'type': 'any'}, |
| 163 {'name': 'p6', 'type': 'object', '$ref': 'TestType'}, |
| 164 ], |
| 165 'returns': [ |
| 166 {'name': 'r1', 'type': 'number'}, |
| 167 {'name': 'r2', 'type': 'integer'}, |
| 168 {'name': 'r3', 'type': 'boolean'}, |
| 169 {'name': 'r4', 'type': 'string'}, |
| 170 {'name': 'r5', 'type': 'any'}, |
| 171 {'name': 'r6', 'type': 'object', '$ref': 'TestType'}, |
| 172 ], |
| 173 }, |
| 174 ] |
| 175 }, |
| 176 ] |
| 177 } |
| 178 client_api_generator.CreateTypeDefinitions(json_api) |
| 179 type = json_api['domains'][0]['types'][0] |
| 180 resolved = client_api_generator.ResolveType(type) |
| 181 self.assertEqual('TestType', resolved['raw_type']) |
| 182 |
| 183 def test_AnyType(self): |
| 184 json_api = { |
| 185 'domains': [ |
| 186 { |
| 187 'domain': 'domain', |
| 188 'types': [ |
| 189 { |
| 190 'id': 'TestType', |
| 191 'type': 'any', |
| 192 }, |
| 193 ] |
| 194 }, |
| 195 ] |
| 196 } |
| 197 client_api_generator.CreateTypeDefinitions(json_api) |
| 198 type = json_api['domains'][0]['types'][0] |
| 199 resolved = client_api_generator.ResolveType(type) |
| 200 self.assertEqual('base::Value', resolved['raw_type']) |
| 201 |
| 202 def test_ArrayType(self): |
| 203 json_api = { |
| 204 'domains': [ |
| 205 { |
| 206 'domain': 'domain', |
| 207 'types': [ |
| 208 { |
| 209 'id': 'TestType', |
| 210 'type': 'array', |
| 211 'items': {'type': 'integer'} |
| 212 }, |
| 213 ] |
| 214 }, |
| 215 ] |
| 216 } |
| 217 client_api_generator.CreateTypeDefinitions(json_api) |
| 218 type = json_api['domains'][0]['types'][0] |
| 219 resolved = client_api_generator.ResolveType(type) |
| 220 self.assertEqual('std::vector<int>', resolved['raw_type']) |
| 221 |
| 222 def test_EnumType(self): |
| 223 json_api = { |
| 224 'domains': [ |
| 225 { |
| 226 'domain': 'domain', |
| 227 'types': [ |
| 228 { |
| 229 'id': 'TestType', |
| 230 'type': 'string', |
| 231 'enum': ['a', 'b', 'c'] |
| 232 }, |
| 233 ] |
| 234 }, |
| 235 ] |
| 236 } |
| 237 client_api_generator.CreateTypeDefinitions(json_api) |
| 238 type = json_api['domains'][0]['types'][0] |
| 239 resolved = client_api_generator.ResolveType(type) |
| 240 self.assertEqual('headless::domain::TestType', resolved['raw_type']) |
| 241 |
| 242 def test_SynthesizeCommandTypes(self): |
| 243 json_api = { |
| 244 'domains': [ |
| 245 { |
| 246 'domain': 'domain', |
| 247 'commands': [ |
| 248 { |
| 249 'name': 'TestCommand', |
| 250 'parameters': [ |
| 251 {'name': 'p1', 'type': 'number'}, |
| 252 {'name': 'p2', 'type': 'integer'}, |
| 253 {'name': 'p3', 'type': 'boolean'}, |
| 254 {'name': 'p4', 'type': 'string'}, |
| 255 {'name': 'p5', 'type': 'any'}, |
| 256 {'name': 'p6', 'type': 'object', '$ref': 'TestType'}, |
| 257 ], |
| 258 'returns': [ |
| 259 {'name': 'r1', 'type': 'number'}, |
| 260 {'name': 'r2', 'type': 'integer'}, |
| 261 {'name': 'r3', 'type': 'boolean'}, |
| 262 {'name': 'r4', 'type': 'string'}, |
| 263 {'name': 'r5', 'type': 'any'}, |
| 264 {'name': 'r6', 'type': 'object', '$ref': 'TestType'}, |
| 265 ], |
| 266 }, |
| 267 ] |
| 268 }, |
| 269 ] |
| 270 } |
| 271 expected_types = [ |
| 272 { |
| 273 'type': 'object', |
| 274 'id': 'TestCommandParams', |
| 275 'description': 'Parameters for the TestCommand command.', |
| 276 'properties': [ |
| 277 {'type': 'number', 'name': 'p1'}, |
| 278 {'type': 'integer', 'name': 'p2'}, |
| 279 {'type': 'boolean', 'name': 'p3'}, |
| 280 {'type': 'string', 'name': 'p4'}, |
| 281 {'type': 'any', 'name': 'p5'}, |
| 282 {'type': 'object', 'name': 'p6', '$ref': 'TestType'} |
| 283 ], |
| 284 }, |
| 285 { |
| 286 'type': 'object', |
| 287 'id': 'TestCommandResult', |
| 288 'description': 'Result for the TestCommand command.', |
| 289 'properties': [ |
| 290 {'type': 'number', 'name': 'r1'}, |
| 291 {'type': 'integer', 'name': 'r2'}, |
| 292 {'type': 'boolean', 'name': 'r3'}, |
| 293 {'type': 'string', 'name': 'r4'}, |
| 294 {'type': 'any', 'name': 'r5'}, |
| 295 {'type': 'object', 'name': 'r6', '$ref': 'TestType'} |
| 296 ], |
| 297 } |
| 298 ] |
| 299 client_api_generator.SynthesizeCommandTypes(json_api) |
| 300 types = json_api['domains'][0]['types'] |
| 301 self.assertListEqual(types, expected_types) |
| 302 |
| 303 def test_Generate(self): |
| 304 json_api = { |
| 305 'domains': [ |
| 306 { |
| 307 'domain': 'domain', |
| 308 'types': [ |
| 309 { |
| 310 'id': 'TestType', |
| 311 'type': 'object', |
| 312 'properties': [ |
| 313 {'name': 'p1', 'type': 'number'}, |
| 314 {'name': 'p2', 'type': 'integer'}, |
| 315 {'name': 'p3', 'type': 'boolean'}, |
| 316 {'name': 'p4', 'type': 'string'}, |
| 317 {'name': 'p5', 'type': 'any'}, |
| 318 {'name': 'p6', 'type': 'object', '$ref': 'domain.TestType'}, |
| 319 ], |
| 320 'returns': [ |
| 321 {'name': 'r1', 'type': 'number'}, |
| 322 {'name': 'r2', 'type': 'integer'}, |
| 323 {'name': 'r3', 'type': 'boolean'}, |
| 324 {'name': 'r4', 'type': 'string'}, |
| 325 {'name': 'r5', 'type': 'any'}, |
| 326 {'name': 'r6', 'type': 'object', '$ref': 'domain.TestType'}, |
| 327 ], |
| 328 }, |
| 329 ] |
| 330 }, |
| 331 ] |
| 332 } |
| 333 try: |
| 334 dirname = tempfile.mkdtemp() |
| 335 jinja_env = client_api_generator.InitializeJinjaEnv(dirname) |
| 336 client_api_generator.Generate(jinja_env, dirname, json_api, 'types', |
| 337 ['cc']) |
| 338 client_api_generator.Generate(jinja_env, dirname, json_api, 'types', |
| 339 ['h']) |
| 340 # This is just a smoke test; we don't actually verify the generated output |
| 341 # here. |
| 342 finally: |
| 343 shutil.rmtree(dirname) |
| 344 |
| 345 def test_GenerateDomains(self): |
| 346 json_api = { |
| 347 'domains': [ |
| 348 { |
| 349 'domain': 'domain0', |
| 350 'types': [ |
| 351 { |
| 352 'id': 'TestType', |
| 353 'type': 'object', |
| 354 }, |
| 355 ] |
| 356 }, |
| 357 { |
| 358 'domain': 'domain1', |
| 359 'types': [ |
| 360 { |
| 361 'id': 'TestType', |
| 362 'type': 'object', |
| 363 }, |
| 364 ] |
| 365 }, |
| 366 ] |
| 367 } |
| 368 try: |
| 369 dirname = tempfile.mkdtemp() |
| 370 jinja_env = client_api_generator.InitializeJinjaEnv(dirname) |
| 371 client_api_generator.GenerateDomains(jinja_env, dirname, json_api, |
| 372 'domain', ['cc', 'h']) |
| 373 # This is just a smoke test; we don't actually verify the generated output |
| 374 # here. |
| 375 finally: |
| 376 shutil.rmtree(dirname) |
| 377 |
| 378 |
| 379 if __name__ == '__main__': |
| 380 cmdline_parser = argparse.ArgumentParser() |
| 381 cmdline_parser.add_argument('--stamp') |
| 382 args = cmdline_parser.parse_args() |
| 383 unittest.main(verbosity=2, exit=False, argv=sys.argv[:1]) |
| 384 if args.stamp: |
| 385 with open(args.stamp, 'a') as f: |
| 386 pass |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1805983002:
headless: Implement client API generation (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master