github.com/walkingsparrow/docker@v1.4.2-0.20151218153551-b708a2249bfa/pkg/parsers/parsers_test.go (about)

     1  package parsers
     2  
     3  import (
     4  	"reflect"
     5  	"strings"
     6  	"testing"
     7  )
     8  
     9  func TestParseKeyValueOpt(t *testing.T) {
    10  	invalids := map[string]string{
    11  		"":    "Unable to parse key/value option: ",
    12  		"key": "Unable to parse key/value option: key",
    13  	}
    14  	for invalid, expectedError := range invalids {
    15  		if _, _, err := ParseKeyValueOpt(invalid); err == nil || err.Error() != expectedError {
    16  			t.Fatalf("Expected error %v for %v, got %v", expectedError, invalid, err)
    17  		}
    18  	}
    19  	valids := map[string][]string{
    20  		"key=value":               {"key", "value"},
    21  		" key = value ":           {"key", "value"},
    22  		"key=value1=value2":       {"key", "value1=value2"},
    23  		" key = value1 = value2 ": {"key", "value1 = value2"},
    24  	}
    25  	for valid, expectedKeyValue := range valids {
    26  		key, value, err := ParseKeyValueOpt(valid)
    27  		if err != nil {
    28  			t.Fatal(err)
    29  		}
    30  		if key != expectedKeyValue[0] || value != expectedKeyValue[1] {
    31  			t.Fatalf("Expected {%v: %v} got {%v: %v}", expectedKeyValue[0], expectedKeyValue[1], key, value)
    32  		}
    33  	}
    34  }
    35  
    36  func TestParsePortRange(t *testing.T) {
    37  	if start, end, err := ParsePortRange("8000-8080"); err != nil || start != 8000 || end != 8080 {
    38  		t.Fatalf("Error: %s or Expecting {start,end} values {8000,8080} but found {%d,%d}.", err, start, end)
    39  	}
    40  }
    41  
    42  func TestParsePortRangeEmpty(t *testing.T) {
    43  	if _, _, err := ParsePortRange(""); err == nil || err.Error() != "Empty string specified for ports." {
    44  		t.Fatalf("Expected error 'Empty string specified for ports.', got %v", err)
    45  	}
    46  }
    47  
    48  func TestParsePortRangeWithNoRange(t *testing.T) {
    49  	start, end, err := ParsePortRange("8080")
    50  	if err != nil {
    51  		t.Fatal(err)
    52  	}
    53  	if start != 8080 || end != 8080 {
    54  		t.Fatalf("Expected start and end to be the same and equal to 8080, but were %v and %v", start, end)
    55  	}
    56  }
    57  
    58  func TestParsePortRangeIncorrectRange(t *testing.T) {
    59  	if _, _, err := ParsePortRange("9000-8080"); err == nil || !strings.Contains(err.Error(), "Invalid range specified for the Port") {
    60  		t.Fatalf("Expecting error 'Invalid range specified for the Port' but received %s.", err)
    61  	}
    62  }
    63  
    64  func TestParsePortRangeIncorrectEndRange(t *testing.T) {
    65  	if _, _, err := ParsePortRange("8000-a"); err == nil || !strings.Contains(err.Error(), "invalid syntax") {
    66  		t.Fatalf("Expecting error 'Invalid range specified for the Port' but received %s.", err)
    67  	}
    68  
    69  	if _, _, err := ParsePortRange("8000-30a"); err == nil || !strings.Contains(err.Error(), "invalid syntax") {
    70  		t.Fatalf("Expecting error 'Invalid range specified for the Port' but received %s.", err)
    71  	}
    72  }
    73  
    74  func TestParsePortRangeIncorrectStartRange(t *testing.T) {
    75  	if _, _, err := ParsePortRange("a-8000"); err == nil || !strings.Contains(err.Error(), "invalid syntax") {
    76  		t.Fatalf("Expecting error 'Invalid range specified for the Port' but received %s.", err)
    77  	}
    78  
    79  	if _, _, err := ParsePortRange("30a-8000"); err == nil || !strings.Contains(err.Error(), "invalid syntax") {
    80  		t.Fatalf("Expecting error 'Invalid range specified for the Port' but received %s.", err)
    81  	}
    82  }
    83  
    84  func TestParseUintList(t *testing.T) {
    85  	valids := map[string]map[int]bool{
    86  		"":             {},
    87  		"7":            {7: true},
    88  		"1-6":          {1: true, 2: true, 3: true, 4: true, 5: true, 6: true},
    89  		"0-7":          {0: true, 1: true, 2: true, 3: true, 4: true, 5: true, 6: true, 7: true},
    90  		"0,3-4,7,8-10": {0: true, 3: true, 4: true, 7: true, 8: true, 9: true, 10: true},
    91  		"0-0,0,1-4":    {0: true, 1: true, 2: true, 3: true, 4: true},
    92  		"03,1-3":       {1: true, 2: true, 3: true},
    93  		"3,2,1":        {1: true, 2: true, 3: true},
    94  		"0-2,3,1":      {0: true, 1: true, 2: true, 3: true},
    95  	}
    96  	for k, v := range valids {
    97  		out, err := ParseUintList(k)
    98  		if err != nil {
    99  			t.Fatalf("Expected not to fail, got %v", err)
   100  		}
   101  		if !reflect.DeepEqual(out, v) {
   102  			t.Fatalf("Expected %v, got %v", v, out)
   103  		}
   104  	}
   105  
   106  	invalids := []string{
   107  		"this",
   108  		"1--",
   109  		"1-10,,10",
   110  		"10-1",
   111  		"-1",
   112  		"-1,0",
   113  	}
   114  	for _, v := range invalids {
   115  		if out, err := ParseUintList(v); err == nil {
   116  			t.Fatalf("Expected failure with %s but got %v", v, out)
   117  		}
   118  	}
   119  }