github.com/Heebron/moby@v0.0.0-20221111184709-6eab4f55faf7/libnetwork/options/options_test.go (about)

     1  package options
     2  
     3  import (
     4  	"reflect"
     5  	"strings"
     6  	"testing"
     7  )
     8  
     9  func TestGenerate(t *testing.T) {
    10  	gen := NewGeneric()
    11  	gen["Int"] = 1
    12  	gen["Rune"] = 'b'
    13  	gen["Float64"] = 2.0
    14  
    15  	type Model struct {
    16  		Int     int
    17  		Rune    rune
    18  		Float64 float64
    19  	}
    20  
    21  	result, err := GenerateFromModel(gen, Model{})
    22  
    23  	if err != nil {
    24  		t.Fatal(err)
    25  	}
    26  
    27  	cast, ok := result.(Model)
    28  	if !ok {
    29  		t.Fatalf("result has unexpected type %s", reflect.TypeOf(result))
    30  	}
    31  	if expected := 1; cast.Int != expected {
    32  		t.Fatalf("wrong value for field Int: expected %v, got %v", expected, cast.Int)
    33  	}
    34  	if expected := 'b'; cast.Rune != expected {
    35  		t.Fatalf("wrong value for field Rune: expected %v, got %v", expected, cast.Rune)
    36  	}
    37  	if expected := 2.0; cast.Float64 != expected {
    38  		t.Fatalf("wrong value for field Int: expected %v, got %v", expected, cast.Float64)
    39  	}
    40  }
    41  
    42  func TestGeneratePtr(t *testing.T) {
    43  	gen := NewGeneric()
    44  	gen["Int"] = 1
    45  	gen["Rune"] = 'b'
    46  	gen["Float64"] = 2.0
    47  
    48  	type Model struct {
    49  		Int     int
    50  		Rune    rune
    51  		Float64 float64
    52  	}
    53  
    54  	result, err := GenerateFromModel(gen, &Model{})
    55  
    56  	if err != nil {
    57  		t.Fatal(err)
    58  	}
    59  
    60  	cast, ok := result.(*Model)
    61  	if !ok {
    62  		t.Fatalf("result has unexpected type %s", reflect.TypeOf(result))
    63  	}
    64  	if expected := 1; cast.Int != expected {
    65  		t.Fatalf("wrong value for field Int: expected %v, got %v", expected, cast.Int)
    66  	}
    67  	if expected := 'b'; cast.Rune != expected {
    68  		t.Fatalf("wrong value for field Rune: expected %v, got %v", expected, cast.Rune)
    69  	}
    70  	if expected := 2.0; cast.Float64 != expected {
    71  		t.Fatalf("wrong value for field Int: expected %v, got %v", expected, cast.Float64)
    72  	}
    73  }
    74  
    75  func TestGenerateMissingField(t *testing.T) {
    76  	type Model struct{}
    77  	_, err := GenerateFromModel(Generic{"foo": "bar"}, Model{})
    78  
    79  	if _, ok := err.(NoSuchFieldError); !ok {
    80  		t.Fatalf("expected NoSuchFieldError, got %#v", err)
    81  	}
    82  
    83  	const expected = "no field"
    84  	if !strings.Contains(err.Error(), expected) {
    85  		t.Fatalf("expected %q in error message, got %s", expected, err.Error())
    86  	}
    87  }
    88  
    89  func TestFieldCannotBeSet(t *testing.T) {
    90  	type Model struct{ foo int } //nolint:nolintlint,unused // un-exported field is used to test error-handling
    91  	_, err := GenerateFromModel(Generic{"foo": "bar"}, Model{})
    92  
    93  	if _, ok := err.(CannotSetFieldError); !ok {
    94  		t.Fatalf("expected CannotSetFieldError, got %#v", err)
    95  	}
    96  
    97  	const expected = "cannot set field"
    98  	if !strings.Contains(err.Error(), expected) {
    99  		t.Fatalf("expected %q in error message, got %s", expected, err.Error())
   100  	}
   101  }
   102  
   103  func TestTypeMismatchError(t *testing.T) {
   104  	type Model struct{ Foo int }
   105  	_, err := GenerateFromModel(Generic{"Foo": "bar"}, Model{})
   106  
   107  	if _, ok := err.(TypeMismatchError); !ok {
   108  		t.Fatalf("expected TypeMismatchError, got %#v", err)
   109  	}
   110  
   111  	const expected = "type mismatch"
   112  	if !strings.Contains(err.Error(), expected) {
   113  		t.Fatalf("expected %q in error message, got %s", expected, err.Error())
   114  	}
   115  }