@@ -477,7 +477,7 @@ func TestNewOneOfGroupManager(t *testing.T) {
477477 }
478478}
479479
480- func TestValidateOneOfGroups (t * testing.T ) {
480+ func TestValidateRequiredOneOfGroups (t * testing.T ) {
481481 tests := []struct {
482482 name string
483483 setupManager func () * core.OneOfGroupManager
@@ -522,7 +522,7 @@ func TestValidateOneOfGroups(t *testing.T) {
522522 for _ , tt := range tests {
523523 t .Run (tt .name , func (t * testing.T ) {
524524 manager := tt .setupManager ()
525- err := manager .ValidateOneOfGroups (tt .rawArgs )
525+ err := manager .ValidateRequiredOneOfGroups (tt .rawArgs )
526526
527527 if tt .expectedError == "" {
528528 assert .NoError (t , err , "Expected no error, got %v" , err )
@@ -532,3 +532,254 @@ func TestValidateOneOfGroups(t *testing.T) {
532532 })
533533 }
534534}
535+
536+ func TestValidateUniqueOneOfGroups (t * testing.T ) {
537+ tests := []struct {
538+ name string
539+ setupManager func () * core.OneOfGroupManager
540+ rawArgs args.RawArgs
541+ expectedError string
542+ }{
543+ {
544+ name : "Required group satisfied with first argument" ,
545+ setupManager : func () * core.OneOfGroupManager {
546+ return & core.OneOfGroupManager {
547+ Groups : map [string ][]string {"group1" : {"a" , "b" }},
548+ }
549+ },
550+ rawArgs : []string {"a=true" },
551+ expectedError : "" ,
552+ },
553+ {
554+ name : "No arguments passed" ,
555+ setupManager : func () * core.OneOfGroupManager {
556+ return & core.OneOfGroupManager {
557+ Groups : map [string ][]string {"group1" : {"a" , "b" }},
558+ }
559+ },
560+ rawArgs : []string {},
561+ expectedError : "" ,
562+ },
563+ {
564+ name : "Multiple groups, all satisfied" ,
565+ setupManager : func () * core.OneOfGroupManager {
566+ return & core.OneOfGroupManager {
567+ Groups : map [string ][]string {
568+ "group1" : {"a" , "b" },
569+ "group2" : {"c" , "d" },
570+ },
571+ }
572+ },
573+ rawArgs : []string {"a=true" , "c=true" },
574+ expectedError : "" ,
575+ },
576+ {
577+ name : "Multiple groups, one satisfied" ,
578+ setupManager : func () * core.OneOfGroupManager {
579+ return & core.OneOfGroupManager {
580+ Groups : map [string ][]string {
581+ "group1" : {"a" , "b" },
582+ "group2" : {"c" , "d" },
583+ },
584+ }
585+ },
586+ rawArgs : []string {"a=true" },
587+ expectedError : "" ,
588+ },
589+ {
590+ name : "Multiple groups, not exclusive argument for groups 2" ,
591+ setupManager : func () * core.OneOfGroupManager {
592+ return & core.OneOfGroupManager {
593+ Groups : map [string ][]string {
594+ "group1" : {"a" , "b" },
595+ "group2" : {"c" , "d" },
596+ },
597+ }
598+ },
599+ rawArgs : []string {"a=true" , "c=true" , "d=true" },
600+ expectedError : "arguments 'c' and 'd' are mutually exclusive" ,
601+ },
602+ {
603+ name : "Multiple groups, not exclusive argument for groups 1" ,
604+ setupManager : func () * core.OneOfGroupManager {
605+ return & core.OneOfGroupManager {
606+ Groups : map [string ][]string {
607+ "group1" : {"a" , "b" },
608+ "group2" : {"c" , "d" },
609+ },
610+ }
611+ },
612+ rawArgs : []string {"a=true" , "b=true" , "c=true" },
613+ expectedError : "arguments 'a' and 'b' are mutually exclusive" ,
614+ },
615+ {
616+ name : "One group, not exclusive argument for groups 1" ,
617+ setupManager : func () * core.OneOfGroupManager {
618+ return & core.OneOfGroupManager {
619+ Groups : map [string ][]string {
620+ "group1" : {"a" , "b" , "c" , "d" },
621+ },
622+ }
623+ },
624+ rawArgs : []string {"a=true" , "d=true" },
625+ expectedError : "arguments 'a' and 'd' are mutually exclusive" ,
626+ },
627+ }
628+
629+ for _ , tt := range tests {
630+ t .Run (tt .name , func (t * testing.T ) {
631+ manager := tt .setupManager ()
632+ err := manager .ValidateUniqueOneOfGroups (tt .rawArgs )
633+ if tt .expectedError == "" {
634+ assert .NoError (t , err , "Expected no error, got %v" , err )
635+ } else {
636+ assert .EqualError (t , err , tt .expectedError , fmt .Sprintf ("Expected error message '%s', got '%v'" , tt .expectedError , err ))
637+ }
638+ })
639+ }
640+ }
641+
642+ func Test_ValidateOneOf (t * testing.T ) {
643+ t .Run ("Validate OneOf" , core .Test (& core.TestConfig {
644+ Commands : core .NewCommands (& core.Command {
645+ Namespace : "oneof" ,
646+ ArgsType : reflect .TypeOf (args.RawArgs {}),
647+ AllowAnonymousClient : true ,
648+ Run : func (_ context.Context , _ interface {}) (i interface {}, e error ) {
649+ return & core.SuccessResult {}, nil
650+ },
651+ ArgSpecs : core.ArgSpecs {
652+ {
653+ Name : "a" ,
654+ OneOfGroup : "groups1" ,
655+ },
656+ {
657+ Name : "b" ,
658+ OneOfGroup : "groups1" ,
659+ },
660+ },
661+ }),
662+ Cmd : "scw oneof a=yo" ,
663+ Check : core .TestCheckCombine (
664+ core .TestCheckExitCode (0 ),
665+ ),
666+ }))
667+ t .Run ("Required group satisfied" , func (t * testing.T ) {
668+ core .Test (& core.TestConfig {
669+ Commands : core .NewCommands (& core.Command {
670+ Namespace : "oneof" ,
671+ ArgsType : reflect .TypeOf (args.RawArgs {}),
672+ AllowAnonymousClient : true ,
673+ Run : func (_ context.Context , _ interface {}) (i interface {}, e error ) {
674+ return & core.SuccessResult {}, nil
675+ },
676+ ArgSpecs : core.ArgSpecs {
677+ {
678+ Name : "a" ,
679+ OneOfGroup : "group1" ,
680+ Required : true ,
681+ },
682+ {
683+ Name : "b" ,
684+ OneOfGroup : "group1" ,
685+ Required : true ,
686+ },
687+ },
688+ }),
689+ Cmd : "scw oneof b=yo" ,
690+ Check : core .TestCheckCombine (
691+ core .TestCheckExitCode (0 ),
692+ ),
693+ })(t )
694+ })
695+
696+ t .Run ("Required group not satisfied" , func (t * testing.T ) {
697+ core .Test (& core.TestConfig {
698+ Commands : core .NewCommands (& core.Command {
699+ Namespace : "oneof" ,
700+ ArgsType : reflect .TypeOf (args.RawArgs {}),
701+ AllowAnonymousClient : true ,
702+ Run : func (_ context.Context , _ interface {}) (i interface {}, e error ) {
703+ return & core.SuccessResult {}, nil
704+ },
705+ ArgSpecs : core.ArgSpecs {
706+ {
707+ Name : "a" ,
708+ OneOfGroup : "group1" ,
709+ Required : true ,
710+ },
711+ {
712+ Name : "b" ,
713+ OneOfGroup : "group1" ,
714+ Required : true ,
715+ },
716+ },
717+ }),
718+ Cmd : "scw oneof c=yo" ,
719+ Check : core .TestCheckCombine (
720+ core .TestCheckExitCode (1 ),
721+ core .TestCheckError (fmt .Errorf ("at least one argument from the 'group1' group is required" )),
722+ ),
723+ })(t )
724+ })
725+
726+ t .Run ("Arguments are mutually exclusive" , func (t * testing.T ) {
727+ core .Test (& core.TestConfig {
728+ Commands : core .NewCommands (& core.Command {
729+ Namespace : "oneof" ,
730+ ArgsType : reflect .TypeOf (args.RawArgs {}),
731+ AllowAnonymousClient : true ,
732+ Run : func (_ context.Context , _ interface {}) (i interface {}, e error ) {
733+ return & core.SuccessResult {}, nil
734+ },
735+ ArgSpecs : core.ArgSpecs {
736+ {
737+ Name : "a" ,
738+ OneOfGroup : "group1" ,
739+ },
740+ {
741+ Name : "b" ,
742+ OneOfGroup : "group1" ,
743+ },
744+ },
745+ }),
746+ Cmd : "scw oneof a=yo b=no" ,
747+ Check : core .TestCheckCombine (
748+ core .TestCheckExitCode (1 ),
749+ core .TestCheckError (fmt .Errorf ("arguments 'a' and 'b' are mutually exclusive" )),
750+ ),
751+ })(t )
752+ })
753+
754+ t .Run ("Arguments are mutually exclusive with 3 arguments" , func (t * testing.T ) {
755+ core .Test (& core.TestConfig {
756+ Commands : core .NewCommands (& core.Command {
757+ Namespace : "oneof" ,
758+ ArgsType : reflect .TypeOf (args.RawArgs {}),
759+ AllowAnonymousClient : true ,
760+ Run : func (_ context.Context , _ interface {}) (i interface {}, e error ) {
761+ return & core.SuccessResult {}, nil
762+ },
763+ ArgSpecs : core.ArgSpecs {
764+ {
765+ Name : "a" ,
766+ OneOfGroup : "group1" ,
767+ },
768+ {
769+ Name : "b" ,
770+ OneOfGroup : "group1" ,
771+ },
772+ {
773+ Name : "c" ,
774+ OneOfGroup : "group1" ,
775+ },
776+ },
777+ }),
778+ Cmd : "scw oneof a=yo c=no" ,
779+ Check : core .TestCheckCombine (
780+ core .TestCheckExitCode (1 ),
781+ core .TestCheckError (fmt .Errorf ("arguments 'a' and 'c' are mutually exclusive" )),
782+ ),
783+ })(t )
784+ })
785+ }
0 commit comments