Make option parsing more conformant to libpq behaviour.

conn.go

@@ -187,7 +187,6 @@ func (s *scanner) SkipSpaces() (rune, bool) {
 func parseOpts(name string, o values) error {
 	s := newScanner(name)
 
-top:
 	for {
 		var (
 			keyRunes, valRunes []rune
@@ -203,25 +202,25 @@ top:
 		for !unicode.IsSpace(r) && r != '=' {
 			keyRunes = append(keyRunes, r)
 			if r, ok = s.Next(); !ok {
-				break top
+				break
 			}
 		}
 
 		// Skip any whitespace if we're not at the = yet
 		if r != '=' {
-			if r, ok = s.SkipSpaces(); !ok {
-				break
-			}
+			r, ok = s.SkipSpaces()
 		}
 
 		// The current character should be =
-		if r != '=' {
+		if r != '=' || !ok {
 			return fmt.Errorf(`missing "=" after %q in connection info string"`, string(keyRunes))
 		}
 
 		// Skip any whitespace after the =
 		if r, ok = s.SkipSpaces(); !ok {
-			break top
+			// If we reach the end here, the last value is just an empty string as per libpq.
+			o.Set(string(keyRunes), "")
+			break
 		}
 
 		if r != '\'' {

conn_test.go

@@ -678,28 +678,35 @@ func TestParseOpts(t *testing.T) {
 		{"dbname=hello user= goodbye", values{"dbname": "hello", "user": "goodbye"}, true},
 		{"host=localhost password='correct horse battery staple'", values{"host": "localhost", "password": "correct horse battery staple"}, true},
 		{"dbname=データベース password=パスワード", values{"dbname": "データベース", "password": "パスワード"}, true},
+		{"dbname=hello user=''", values{"dbname": "hello", "user": ""}, true},
+		{"user='' dbname=hello", values{"dbname": "hello", "user": ""}, true},
+		// The last option value is an empty string if there's no non-whitespace after its =
+		{"dbname=hello user=   ", values{"dbname": "hello", "user": ""}, true},
 
 		// The parser ignores spaces after = and interprets the next set of non-whitespace characters as the value.
 		{"user= password=foo", values{"user": "password=foo"}, true},
 
-		// The parser ignores trailing keys
-		{"user=foo blah", values{"user": "foo"}, true},
-		{"user=foo blah   ", values{"user": "foo"}, true},
-		{"user=foo blah=   ", values{"user": "foo"}, true},
-
 		// No '=' after the key
+		{"postgre://marko@internet", values{}, false},
 		{"dbname user=goodbye", values{}, false},
+		{"user=foo blah", values{}, false},
+		{"user=foo blah   ", values{}, false},
+
 		// Unterminated quoted value
 		{"dbname=hello user='unterminated", values{}, false},
 	}
 
 	for _, test := range tests {
 		o := make(values)
 		err := parseOpts(test.in, o)
-		if err != nil && test.valid {
+
+		switch {
+		case err != nil && test.valid:
 			t.Errorf("%q got unexpected error: %s", test.in, err)
-		} else if err == nil && !reflect.DeepEqual(test.expected, o) {
+		case err == nil && test.valid && !reflect.DeepEqual(test.expected, o):
 			t.Errorf("%q got: %#v want: %#v", test.in, o, test.expected)
+		case err == nil && !test.valid:
+			t.Errorf("%q expected an error", test.in)
 		}
 	}
 }