Class: VClusterCommandTreeTest

Inherits:
Minitest::Test
  • Object
show all
Defined in:
lib/kube/vcluster/command_tree.rb

Instance Method Summary collapse

Instance Method Details

#assert_results(result, final = nil, commands:, positional:, flags: nil, errors: nil, valid: true) ⇒ Object 



230
231
232
233
234
235
236
237
238
239
240
241
242
 
# File 'lib/kube/vcluster/command_tree.rb', line 230

def assert_results(result, final = nil, commands:, positional:, flags: nil, errors: nil, valid: true)
  assert_equal commands, result.commands, 'commands mismatch'
  assert_equal positional, result.positional, 'positional mismatch'
  if valid
    assert result.valid, "expected valid but got errors: #{result.errors}"
  else
    refute result.valid, 'expected invalid'
  end

  assert_equal flags, result.flags, 'flags mismatch' unless flags.nil?
  assert_equal errors, result.errors, 'errors mismatch' unless errors.nil?
  assert_equal final, result.to_s, 'to_s mismatch' unless final.nil?
end

#setup ⇒ Object 



225
226
227
228
 
# File 'lib/kube/vcluster/command_tree.rb', line 225

def setup
  data = YAML.load_file(File.expand_path('../../../data/vcluster.yaml', __dir__))
  @tree = Kube::VCluster::CommandTree.new(data)
end

#test_connect_with_namespace ⇒ Object

vcluster connect test –namespace test



262
263
264
265
266
267
268
269
270
271
272
 
# File 'lib/kube/vcluster/command_tree.rb', line 262

def test_connect_with_namespace
  result = @tree.evaluate(Kube.vcluster { connect.test.namespace('test') })
  assert_results(
    result,
    'connect test --namespace test',
    commands: ['connect'],
    positional: ['test'],
    flags: ['--namespace test'],
    valid: true
  )
end

#test_create_with_namespace ⇒ Object

vcluster create test –namespace test



249
250
251
252
253
254
255
256
257
258
259
 
# File 'lib/kube/vcluster/command_tree.rb', line 249

def test_create_with_namespace
  result = @tree.evaluate(Kube.vcluster { create.test.namespace('test') })
  assert_results(
    result,
    'create test --namespace test',
    commands: ['create'],
    positional: ['test'],
    flags: ['--namespace test'],
    valid: true
  )
end

#test_debug_shell_with_target ⇒ Object

vcluster debug shell my-vcluster –target=syncer



409
410
411
412
413
414
415
416
417
418
419
 
# File 'lib/kube/vcluster/command_tree.rb', line 409

def test_debug_shell_with_target
  result = @tree.evaluate(Kube.vcluster { debug.shell.my - vcluster.target('syncer') })
  assert_results(
    result,
    'debug shell my-vcluster --target syncer',
    commands: %w[debug shell],
    positional: ['my-vcluster'],
    flags: ['--target syncer'],
    valid: true
  )
end

#test_delete_with_namespace ⇒ Object

vcluster delete test –namespace test



275
276
277
278
279
280
281
282
283
284
285
 
# File 'lib/kube/vcluster/command_tree.rb', line 275

def test_delete_with_namespace
  result = @tree.evaluate(Kube.vcluster { delete.test.namespace('test') })
  assert_results(
    result,
    'delete test --namespace test',
    commands: ['delete'],
    positional: ['test'],
    flags: ['--namespace test'],
    valid: true
  )
end

#test_describe ⇒ Object

vcluster describe test



366
367
368
369
370
371
372
373
374
375
376
 
# File 'lib/kube/vcluster/command_tree.rb', line 366

def test_describe
  result = @tree.evaluate(Kube.vcluster { describe.test })
  assert_results(
    result,
    'describe test',
    commands: ['describe'],
    positional: ['test'],
    flags: [],
    valid: true
  )
end

#test_disconnect ⇒ Object

vcluster disconnect



353
354
355
356
357
358
359
360
361
362
363
 
# File 'lib/kube/vcluster/command_tree.rb', line 353

def test_disconnect
  result = @tree.evaluate(Kube.vcluster { disconnect })
  assert_results(
    result,
    'disconnect',
    commands: ['disconnect'],
    positional: [],
    flags: [],
    valid: true
  )
end

#test_list ⇒ Object

vcluster list



288
289
290
291
292
293
294
295
296
297
298
 
# File 'lib/kube/vcluster/command_tree.rb', line 288

def test_list
  result = @tree.evaluate(Kube.vcluster { list })
  assert_results(
    result,
    'list',
    commands: ['list'],
    positional: [],
    flags: [],
    valid: true
  )
end

#test_list_namespace ⇒ Object

vcluster list –namespace test



314
315
316
317
318
319
320
321
322
323
324
 
# File 'lib/kube/vcluster/command_tree.rb', line 314

def test_list_namespace
  result = @tree.evaluate(Kube.vcluster { list.namespace('test') })
  assert_results(
    result,
    'list --namespace test',
    commands: ['list'],
    positional: [],
    flags: ['--namespace test'],
    valid: true
  )
end

#test_list_output_json ⇒ Object

vcluster list –output json



301
302
303
304
305
306
307
308
309
310
311
 
# File 'lib/kube/vcluster/command_tree.rb', line 301

def test_list_output_json
  result = @tree.evaluate(Kube.vcluster { list.output('json') })
  assert_results(
    result,
    'list --output json',
    commands: ['list'],
    positional: [],
    flags: ['--output json'],
    valid: true
  )
end

#test_logout ⇒ Object

vcluster logout



392
393
394
395
396
397
398
399
400
401
402
 
# File 'lib/kube/vcluster/command_tree.rb', line 392

def test_logout
  result = @tree.evaluate(Kube.vcluster { logout })
  assert_results(
    result,
    'logout',
    commands: ['logout'],
    positional: [],
    flags: [],
    valid: true
  )
end

#test_pause_with_namespace ⇒ Object

vcluster pause test –namespace test



327
328
329
330
331
332
333
334
335
336
337
 
# File 'lib/kube/vcluster/command_tree.rb', line 327

def test_pause_with_namespace
  result = @tree.evaluate(Kube.vcluster { pause.test.namespace('test') })
  assert_results(
    result,
    'pause test --namespace test',
    commands: ['pause'],
    positional: ['test'],
    flags: ['--namespace test'],
    valid: true
  )
end

#test_platform_add_cluster ⇒ Object 



736
737
738
739
740
741
742
743
744
745
746
 
# File 'lib/kube/vcluster/command_tree.rb', line 736

def test_platform_add_cluster
  result = @tree.evaluate(Kube.vcluster { platform.add.cluster.my - cluster })
  assert_results(
    result,
    'platform add cluster my-cluster',
    commands: %w[platform add cluster],
    positional: ['my-cluster'],
    flags: [],
    valid: true
  )
end

#test_platform_backup_management ⇒ Object

Platform — other



719
720
721
722
 
# File 'lib/kube/vcluster/command_tree.rb', line 719

def test_platform_backup_management
  result = @tree.evaluate(Kube.vcluster { platform.backup.management })
  assert_results(result, 'platform backup management', commands: %w[platform backup management], positional: [], flags: [], valid: true)
end

#test_platform_connect_cluster ⇒ Object

Platform — connect



613
614
615
616
 
# File 'lib/kube/vcluster/command_tree.rb', line 613

def test_platform_connect_cluster
  result = @tree.evaluate(Kube.vcluster { platform.connect.cluster.mycluster })
  assert_results(result, 'platform connect cluster mycluster', commands: %w[platform connect cluster], positional: ['mycluster'], flags: [], valid: true)
end

#test_platform_connect_management ⇒ Object 



618
619
620
621
 
# File 'lib/kube/vcluster/command_tree.rb', line 618

def test_platform_connect_management
  result = @tree.evaluate(Kube.vcluster { platform.connect.management })
  assert_results(result, 'platform connect management', commands: %w[platform connect management], positional: [], flags: [], valid: true)
end

#test_platform_connect_namespace_with_project ⇒ Object 



623
624
625
626
627
628
629
630
631
632
633
 
# File 'lib/kube/vcluster/command_tree.rb', line 623

def test_platform_connect_namespace_with_project
  result = @tree.evaluate(Kube.vcluster { platform.connect.namespace.myspace.project('myproject') })
  assert_results(
    result,
    'platform connect namespace myspace --project myproject',
    commands: %w[platform connect namespace],
    positional: ['myspace'],
    flags: ['--project myproject'],
    valid: true
  )
end

#test_platform_connect_vcluster ⇒ Object 



635
636
637
638
639
640
641
642
643
644
645
 
# File 'lib/kube/vcluster/command_tree.rb', line 635

def test_platform_connect_vcluster
  result = @tree.evaluate(Kube.vcluster { platform.connect.vcluster.test.namespace('test') })
  assert_results(
    result,
    'platform connect vcluster test --namespace test',
    commands: %w[platform connect vcluster],
    positional: ['test'],
    flags: ['--namespace test'],
    valid: true
  )
end

#test_platform_create_accesskey_in_cluster ⇒ Object 



581
582
583
584
585
586
587
588
589
590
591
 
# File 'lib/kube/vcluster/command_tree.rb', line 581

def test_platform_create_accesskey_in_cluster
  result = @tree.evaluate(Kube.vcluster { platform.create.accesskey.test.in_cluster(true).user('admin') })
  assert_results(
    result,
    'platform create accesskey test --in-cluster --user admin',
    commands: %w[platform create accesskey],
    positional: ['test'],
    flags: ['--in-cluster', '--user admin'],
    valid: true
  )
end

#test_platform_create_namespace_with_project_and_team ⇒ Object 



569
570
571
572
573
574
575
576
577
578
579
 
# File 'lib/kube/vcluster/command_tree.rb', line 569

def test_platform_create_namespace_with_project_and_team
  result = @tree.evaluate(Kube.vcluster { platform.create.namespace.myspace.project('myproject').team('myteam') })
  assert_results(
    result,
    'platform create namespace myspace --project myproject --team myteam',
    commands: %w[platform create namespace],
    positional: ['myspace'],
    flags: ['--project myproject', '--team myteam'],
    valid: true
  )
end

#test_platform_create_vcluster ⇒ Object

Platform — create



557
558
559
560
561
562
563
564
565
566
567
 
# File 'lib/kube/vcluster/command_tree.rb', line 557

def test_platform_create_vcluster
  result = @tree.evaluate(Kube.vcluster { platform.create.vcluster.test.namespace('test') })
  assert_results(
    result,
    'platform create vcluster test --namespace test',
    commands: %w[platform create vcluster],
    positional: ['test'],
    flags: ['--namespace test'],
    valid: true
  )
end

#test_platform_delete_namespace_with_project ⇒ Object

Platform — delete



597
598
599
600
601
602
603
604
605
606
607
 
# File 'lib/kube/vcluster/command_tree.rb', line 597

def test_platform_delete_namespace_with_project
  result = @tree.evaluate(Kube.vcluster { platform.delete.namespace.myspace.project('myproject') })
  assert_results(
    result,
    'platform delete namespace myspace --project myproject',
    commands: %w[platform delete namespace],
    positional: ['myspace'],
    flags: ['--project myproject'],
    valid: true
  )
end

#test_platform_get_current_user ⇒ Object

Platform — get



536
537
538
539
 
# File 'lib/kube/vcluster/command_tree.rb', line 536

def test_platform_get_current_user
  result = @tree.evaluate(Kube.vcluster { platform.get.current - user })
  assert_results(result, 'platform get current-user', commands: %w[platform get current-user], positional: [], flags: [], valid: true)
end

#test_platform_get_secret_with_project ⇒ Object 



541
542
543
544
545
546
547
548
549
550
551
 
# File 'lib/kube/vcluster/command_tree.rb', line 541

def test_platform_get_secret_with_project
  result = @tree.evaluate(Kube.vcluster { platform.get.secret.call('test-secret.key').project('myproject') })
  assert_results(
    result,
    'platform get secret test-secret.key --project myproject',
    commands: %w[platform get secret],
    positional: ['test-secret.key'],
    flags: ['--project myproject'],
    valid: true
  )
end

#test_platform_list_clusters ⇒ Object

Platform — list



502
503
504
505
 
# File 'lib/kube/vcluster/command_tree.rb', line 502

def test_platform_list_clusters
  result = @tree.evaluate(Kube.vcluster { platform.list.clusters })
  assert_results(result, 'platform list clusters', commands: %w[platform list clusters], positional: [], flags: [], valid: true)
end

#test_platform_list_namespaces ⇒ Object 



512
513
514
515
 
# File 'lib/kube/vcluster/command_tree.rb', line 512

def test_platform_list_namespaces
  result = @tree.evaluate(Kube.vcluster { platform.list.namespaces })
  assert_results(result, 'platform list namespaces', commands: %w[platform list namespaces], positional: [], flags: [], valid: true)
end

#test_platform_list_projects ⇒ Object 



517
518
519
520
 
# File 'lib/kube/vcluster/command_tree.rb', line 517

def test_platform_list_projects
  result = @tree.evaluate(Kube.vcluster { platform.list.projects })
  assert_results(result, 'platform list projects', commands: %w[platform list projects], positional: [], flags: [], valid: true)
end

#test_platform_list_secrets ⇒ Object 



522
523
524
525
 
# File 'lib/kube/vcluster/command_tree.rb', line 522

def test_platform_list_secrets
  result = @tree.evaluate(Kube.vcluster { platform.list.secrets })
  assert_results(result, 'platform list secrets', commands: %w[platform list secrets], positional: [], flags: [], valid: true)
end

#test_platform_list_teams ⇒ Object 



527
528
529
530
 
# File 'lib/kube/vcluster/command_tree.rb', line 527

def test_platform_list_teams
  result = @tree.evaluate(Kube.vcluster { platform.list.teams })
  assert_results(result, 'platform list teams', commands: %w[platform list teams], positional: [], flags: [], valid: true)
end

#test_platform_list_vclusters ⇒ Object 



507
508
509
510
 
# File 'lib/kube/vcluster/command_tree.rb', line 507

def test_platform_list_vclusters
  result = @tree.evaluate(Kube.vcluster { platform.list.vclusters })
  assert_results(result, 'platform list vclusters', commands: %w[platform list vclusters], positional: [], flags: [], valid: true)
end

#test_platform_login ⇒ Object

vcluster platform login my-vcluster-platform.com



458
459
460
461
462
463
464
465
466
467
468
 
# File 'lib/kube/vcluster/command_tree.rb', line 458

def 
  result = @tree.evaluate(Kube.vcluster { platform..call('https://my-vcluster-platform.com') })
  assert_results(
    result,
    'platform login https://my-vcluster-platform.com',
    commands: %w[platform login],
    positional: ['https://my-vcluster-platform.com'],
    flags: [],
    valid: true
  )
end

#test_platform_login_with_access_key ⇒ Object

vcluster platform login https://… –access-key myaccesskey



471
472
473
474
475
476
477
478
479
480
481
482
483
 
# File 'lib/kube/vcluster/command_tree.rb', line 471

def 
  result = @tree.evaluate(Kube.vcluster do
    platform..call('https://my-vcluster-platform.com').access_key('myaccesskey')
  end)
  assert_results(
    result,
    'platform login https://my-vcluster-platform.com --access-key myaccesskey',
    commands: %w[platform login],
    positional: ['https://my-vcluster-platform.com'],
    flags: ['--access-key myaccesskey'],
    valid: true
  )
end

#test_platform_logout ⇒ Object

vcluster platform logout



486
487
488
489
490
491
492
493
494
495
496
 
# File 'lib/kube/vcluster/command_tree.rb', line 486

def test_platform_logout
  result = @tree.evaluate(Kube.vcluster { platform.logout })
  assert_results(
    result,
    'platform logout',
    commands: %w[platform logout],
    positional: [],
    flags: [],
    valid: true
  )
end

#test_platform_reset_password_with_user ⇒ Object 



724
725
726
727
728
729
730
731
732
733
734
 
# File 'lib/kube/vcluster/command_tree.rb', line 724

def test_platform_reset_password_with_user
  result = @tree.evaluate(Kube.vcluster { platform.reset.password.user('admin') })
  assert_results(
    result,
    'platform reset password --user admin',
    commands: %w[platform reset password],
    positional: [],
    flags: ['--user admin'],
    valid: true
  )
end

#test_platform_share_namespace_with_project_and_user ⇒ Object

Platform — share



651
652
653
654
655
656
657
658
659
660
661
 
# File 'lib/kube/vcluster/command_tree.rb', line 651

def test_platform_share_namespace_with_project_and_user
  result = @tree.evaluate(Kube.vcluster { platform.share.namespace.myspace.project('myproject').user('admin') })
  assert_results(
    result,
    'platform share namespace myspace --project myproject --user admin',
    commands: %w[platform share namespace],
    positional: ['myspace'],
    flags: ['--project myproject', '--user admin'],
    valid: true
  )
end

#test_platform_share_vcluster_with_project_and_user ⇒ Object 



663
664
665
666
667
668
669
670
671
672
673
 
# File 'lib/kube/vcluster/command_tree.rb', line 663

def test_platform_share_vcluster_with_project_and_user
  result = @tree.evaluate(Kube.vcluster { platform.share.vcluster.myvcluster.project('myproject').user('admin') })
  assert_results(
    result,
    'platform share vcluster myvcluster --project myproject --user admin',
    commands: %w[platform share vcluster],
    positional: ['myvcluster'],
    flags: ['--project myproject', '--user admin'],
    valid: true
  )
end

#test_platform_sleep_vcluster ⇒ Object

Platform — sleep/wakeup



679
680
681
682
683
684
685
686
687
688
689
 
# File 'lib/kube/vcluster/command_tree.rb', line 679

def test_platform_sleep_vcluster
  result = @tree.evaluate(Kube.vcluster { platform.sleep.vcluster.test.namespace('test') })
  assert_results(
    result,
    'platform sleep vcluster test --namespace test',
    commands: %w[platform sleep vcluster],
    positional: ['test'],
    flags: ['--namespace test'],
    valid: true
  )
end

#test_platform_wakeup_namespace_with_project ⇒ Object 



703
704
705
706
707
708
709
710
711
712
713
 
# File 'lib/kube/vcluster/command_tree.rb', line 703

def test_platform_wakeup_namespace_with_project
  result = @tree.evaluate(Kube.vcluster { platform.wakeup.namespace.myspace.project('myproject') })
  assert_results(
    result,
    'platform wakeup namespace myspace --project myproject',
    commands: %w[platform wakeup namespace],
    positional: ['myspace'],
    flags: ['--project myproject'],
    valid: true
  )
end

#test_platform_wakeup_vcluster ⇒ Object 



691
692
693
694
695
696
697
698
699
700
701
 
# File 'lib/kube/vcluster/command_tree.rb', line 691

def test_platform_wakeup_vcluster
  result = @tree.evaluate(Kube.vcluster { platform.wakeup.vcluster.test.namespace('test') })
  assert_results(
    result,
    'platform wakeup vcluster test --namespace test',
    commands: %w[platform wakeup vcluster],
    positional: ['test'],
    flags: ['--namespace test'],
    valid: true
  )
end

#test_restore_s3 ⇒ Object

vcluster restore my-vcluster s3://my-bucket/my-bucket-key



441
442
443
444
445
446
447
448
449
450
451
 
# File 'lib/kube/vcluster/command_tree.rb', line 441

def test_restore_s3
  result = @tree.evaluate(Kube.vcluster { restore.my - vcluster.call('s3://my-bucket/my-bucket-key') })
  assert_results(
    result,
    'restore my-vcluster s3://my-bucket/my-bucket-key',
    commands: ['restore'],
    positional: ['my-vcluster', 's3://my-bucket/my-bucket-key'],
    flags: [],
    valid: true
  )
end

#test_resume_with_namespace ⇒ Object

vcluster resume test –namespace test



340
341
342
343
344
345
346
347
348
349
350
 
# File 'lib/kube/vcluster/command_tree.rb', line 340

def test_resume_with_namespace
  result = @tree.evaluate(Kube.vcluster { resume.test.namespace('test') })
  assert_results(
    result,
    'resume test --namespace test',
    commands: ['resume'],
    positional: ['test'],
    flags: ['--namespace test'],
    valid: true
  )
end

#test_snapshot_create_oci ⇒ Object

vcluster snapshot create my-vcluster oci://…



426
427
428
429
430
431
432
433
434
435
436
437
438
 
# File 'lib/kube/vcluster/command_tree.rb', line 426

def test_snapshot_create_oci
  result = @tree.evaluate(Kube.vcluster do
    snapshot.create.my - vcluster.call('oci://ghcr.io/my-user/my-repo:my-tag')
  end)
  assert_results(
    result,
    'snapshot create my-vcluster oci://ghcr.io/my-user/my-repo:my-tag',
    commands: %w[snapshot create],
    positional: ['my-vcluster', 'oci://ghcr.io/my-user/my-repo:my-tag'],
    flags: [],
    valid: true
  )
end

#test_ui ⇒ Object

vcluster ui



379
380
381
382
383
384
385
386
387
388
389
 
# File 'lib/kube/vcluster/command_tree.rb', line 379

def test_ui
  result = @tree.evaluate(Kube.vcluster { ui })
  assert_results(
    result,
    'ui',
    commands: ['ui'],
    positional: [],
    flags: [],
    valid: true
  )
end

#test_unknown_command_returns_error ⇒ Object

Error case



752
753
754
755
756
757
758
759
760
761
 
# File 'lib/kube/vcluster/command_tree.rb', line 752

def test_unknown_command_returns_error
  result = @tree.evaluate(Kube.vcluster { definitely_missing })
  assert_results(
    result,
    commands: [],
    positional: ['definitely_missing'],
    errors: ['invalid command start: `definitely_missing`'],
    valid: false
  )
end