diff --git a/.travis.yml b/.travis.yml
index ee28ff2..add7187 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,6 +1,5 @@
-# Config file for automatic testing at travis-ci.org
-
 language: python
+sudo: false
 
 python:
     - "3.4"
@@ -9,12 +8,13 @@ python:
     - "2.6"
     - "pypy"
 
-# command to install dependencies, e.g. pip install -r requirements.txt --use-mirrors
-install: 
-    - pip install -r requirements.txt
+install:
+    - python setup.py install
+    - pip install -U -r dev-requirements.txt
     - pip install coverage coveralls nose responses
 
-# command to run tests, e.g. python setup.py test
+before_script: flake8 robobrowser
+
 script: nosetests --with-coverage --cover-package=robobrowser
 
 after_success: coveralls
diff --git a/HISTORY.rst b/HISTORY.rst
index 6d3885f..dd1a5fd 100644
--- a/HISTORY.rst
+++ b/HISTORY.rst
@@ -3,6 +3,35 @@
 History
 -------
 
+0.5.3
+++++++++++++++++++
+* Improve documentation. Thanks tpugsley and rcutmore for improvements!
+* Improve messages in error handling. Thanks again rcutmore!
+* Fix default values for <select> fields. Thanks pohmelie for reporting!
+* Simplify value property of field elements; delete `FieldMeta`.
+* Move retry logic to requests and urllib3.
+
+0.5.2
+++++++++++++++++++
+* Remove requirements parsing from `setup.py`.
+* Don't pin to exact requirements versions. Thanks StuntsPT!
+* Don't install tests along with package. Thanks voyageur!
+* Handle empty select fields. Thanks pratyushmittal!
+* Parse partial document correctly when lxml is installed. Thanks again pratyushmittal!
+* Lint code with flake8.
+
+0.5.0
+++++++++++++++++++
+* Add optional `session` argument to `RoboBrowser::__init__`
+* Add optional `timeout` and `allow_redirects` options to `RoboBrowser::__init__`
+* Allow `RoboBrowser::open`, `RoboBrowser::follow_link`, and `RoboBrowser::submit_form` to accept optional keyword arguments to requests (`timeout`, `verify`, etc.)
+* *Backwards-incompatible*: Remove `auth`, `headers`,  and `verify` arguments `from RoboBrowser::__init__`; session configuration should instead be passed in `session`
+* *Backwards-incompatible*: Restrict `RoboBrowser::follow_link` to `link` argument; text strings and BeautifulSoup arguments no longer accepted
+
+0.4.1
+++++++++++++++++++
+* Handle multi-option fields without "value" attributes
+
 0.4.0
 ++++++++++++++++++
 * Fix modeling of form fields to handle non-unique field names.
diff --git a/README.rst b/README.rst
index e30b0c5..0758232 100644
--- a/README.rst
+++ b/README.rst
@@ -3,7 +3,7 @@ RoboBrowser: Your friendly neighborhood web scraper
 
 .. image:: https://badge.fury.io/py/robobrowser.png
     :target: http://badge.fury.io/py/robobrowser
-    
+
 .. image:: https://travis-ci.org/jmcarp/robobrowser.png?branch=master
         :target: https://travis-ci.org/jmcarp/robobrowser
 
@@ -17,40 +17,41 @@ can fetch a page, click on links and buttons, and fill out and submit forms. If
 that don't have APIs, RoboBrowser can help.
 
 .. code-block:: python
-    
+
     import re
     from robobrowser import RoboBrowser
-    
-    # Browse to Rap Genius
+
+    # Browse to Genius
     browser = RoboBrowser(history=True)
-    browser.open('http://rapgenius.com/')
-    
-    # Search for Queen
+    browser.open('http://genius.com/')
+
+    # Search for Porcupine Tree
     form = browser.get_form(action='/search')
     form                # <RoboForm q=>
-    form['q'].value = 'queen'
+    form['q'].value = 'porcupine tree'
     browser.submit_form(form)
 
     # Look up the first song
-    songs = browser.select('.song_name')
+    songs = browser.select('.song_link')
     browser.follow_link(songs[0])
     lyrics = browser.select('.lyrics')
-    lyrics[0].text      # \n[Intro]\nIs this the real life...
-    
+    lyrics[0].text      # \nHear the sound of music ...
+
     # Back to results page
     browser.back()
 
     # Look up my favorite song
-    browser.follow_link('death on two legs')
+    song_link = browser.get_link('trains')
+    browser.follow_link(song_link)
 
     # Can also search HTML using regex patterns
     lyrics = browser.find(class_=re.compile(r'\blyrics\b'))
-    lyrics.text         # \n[Verse 1]\nYou suck my blood like a leech...
+    lyrics.text         # \nTrain set and match spied under the blind...
 
-RoboBrowser combines the best of two excellent Python libraries: 
-`Requests <http://docs.python-requests.org/en/latest/>`_ and 
-`BeautifulSoup <http://www.crummy.com/software/BeautifulSoup/>`_. 
-RoboBrowser represents browser sessions using Requests and HTML responses 
+RoboBrowser combines the best of two excellent Python libraries:
+`Requests <http://docs.python-requests.org/en/latest/>`_ and
+`BeautifulSoup <http://www.crummy.com/software/BeautifulSoup/>`_.
+RoboBrowser represents browser sessions using Requests and HTML responses
 using BeautifulSoup, transparently exposing methods of both libraries:
 
 .. code-block:: python
@@ -75,11 +76,23 @@ using BeautifulSoup, transparently exposing methods of both libraries:
                                                         # <span class="mega-octicon octicon-checklist"></span>
                                                         # ...
 
+You can also pass a custom `Session` instance for lower-level configuration:
+
+.. code-block:: python
+
+    from requests import Session
+    from robobrowser import RoboBrowser
+
+    session = Session()
+    session.verify = False  # Skip SSL verification
+    session.proxies = {'http': 'http://custom.proxy.com/'}  # Set default proxies
+    browser = RoboBrowser(session=session)
+
 RoboBrowser also includes tools for working with forms, inspired by
 `WebTest <https://github.com/Pylons/webtest>`_ and `Mechanize <http://wwwsearch.sourceforge.net/mechanize/>`_.
 
 .. code-block:: python
-    
+
     from robobrowser import RoboBrowser
 
     browser = RoboBrowser()
@@ -102,9 +115,9 @@ RoboBrowser also includes tools for working with forms, inspired by
 Checkboxes:
 
 .. code-block:: python
-    
+
     from robobrowser import RoboBrowser
-    
+
     # Browse to a page with checkbox inputs
     browser = RoboBrowser()
     browser.open('http://www.w3schools.com/html/html_forms.asp')
@@ -113,26 +126,26 @@ Checkboxes:
     form = browser.get_forms()[3]
     form                            # <RoboForm vehicle=[]>
     form['vehicle']                 # <robobrowser.forms.fields.Checkbox...>
-    
+
     # Checked values can be get and set like lists
     form['vehicle'].options         # [u'Bike', u'Car']
     form['vehicle'].value           # []
     form['vehicle'].value = ['Bike']
     form['vehicle'].value = ['Bike', 'Car']
-    
+
     # Values can also be set using input labels
     form['vehicle'].labels          # [u'I have a bike', u'I have a car \r\n']
     form['vehicle'].value = ['I have a bike']
     form['vehicle'].value           # [u'Bike']
 
-    # Only values that correspond to checkbox values or labels can be set; 
+    # Only values that correspond to checkbox values or labels can be set;
     # this will raise a `ValueError`
     form['vehicle'].value = ['Hot Dogs']
 
 Uploading files:
 
 .. code-block:: python
-    
+
     from robobrowser import RoboBrowser
 
     # Browse to a page with an upload form
@@ -150,6 +163,8 @@ Uploading files:
     # Submit
     browser.submit(upload_form)
 
+By default, creating a browser instantiates a new requests `Session`. 
+
 Requirements
 ------------
 
diff --git a/dev-requirements.txt b/dev-requirements.txt
index 010863a..640df0d 100644
--- a/dev-requirements.txt
+++ b/dev-requirements.txt
@@ -1,7 +1,7 @@
--r requirements.txt
-
 coverage
 coveralls
+docutils
+flake8
 mock
 nose
 sphinx
diff --git a/requirements.txt b/requirements.txt
deleted file mode 100644
index 84f9a8d..0000000
--- a/requirements.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-beautifulsoup4
-requests
-six
diff --git a/robobrowser/__init__.py b/robobrowser/__init__.py
index f199fb4..8b4d50a 100755
--- a/robobrowser/__init__.py
+++ b/robobrowser/__init__.py
@@ -1,4 +1,5 @@
-__version__ = '0.3.3'
+__version__ = '0.5.3'
 
 from .browser import RoboBrowser
 
+__all__ = ['RoboBrowser']
diff --git a/robobrowser/browser.py b/robobrowser/browser.py
index ed9062e..32e9338 100644
--- a/robobrowser/browser.py
+++ b/robobrowser/browser.py
@@ -5,18 +5,16 @@
 import re
 import requests
 from bs4 import BeautifulSoup
-from bs4.element import Tag
-from requests.exceptions import RequestException
+from werkzeug import cached_property
+from requests.packages.urllib3.util.retry import Retry
 
-from robobrowser.compat import urlparse, string_types
 from robobrowser import helpers
+from robobrowser import exceptions
+from robobrowser.compat import urlparse
 from robobrowser.forms.form import Form
 from robobrowser.cache import RoboHTTPAdapter
-from robobrowser.helpers import retry
 
 
-class RoboError(Exception): pass
-
 _link_ptn = re.compile(r'^(a|button)$', re.I)
 _form_ptn = re.compile(r'^form$', re.I)
 
@@ -31,34 +29,29 @@ def __init__(self, browser, response):
         self.browser = browser
         self.response = response
         self.url = response.url
-        self._parsed = None
 
-    @property
+    @cached_property
     def parsed(self):
         """Lazily parse response content, using HTML parser specified by the
         browser.
-
         """
-        if self._parsed is None:
-            self._parsed = BeautifulSoup(
-                self.response.content,
-                features=self.browser.parser,
-            )
-        return self._parsed
+        return BeautifulSoup(
+            self.response.content,
+            features=self.browser.parser,
+        )
 
 
 class RoboBrowser(object):
     """Robotic web browser. Represents HTTP requests and responses using the
     requests library and parsed HTML using BeautifulSoup.
 
-    :param tuple auth: Tuple of (username, password)
     :param str parser: HTML parser; used by BeautifulSoup
-    :param dict headers: Default headers
     :param str user_agent: Default user-agent
     :param history: History length; infinite if True, 1 if falsy, else
         takes integer value
-    :param int timeout: Default timeout in seconds
-    :param bool verify: Verify SSL
+
+    :param int timeout: Default timeout, in seconds
+    :param bool allow_redirects: Allow redirects on POST/PUT/DELETE
 
     :param bool cache: Cache responses
     :param list cache_patterns: List of URL patterns for cache
@@ -66,31 +59,26 @@ class RoboBrowser(object):
     :param int max_count: Max count for cache
 
     :param int tries: Number of retries
-    :param Exception errors: Exception(s) to catch
+    :param Exception errors: Exception or tuple of exceptions to catch
     :param int delay: Delay between retries
     :param int multiplier: Delay multiplier between retries
 
     """
-    def __init__(self, auth=None, parser=None, headers=None, user_agent=None,
-                 history=True, timeout=None, verify=True, cache=False,
+    def __init__(self, session=None, parser=None, user_agent=None,
+                 history=True, timeout=None, allow_redirects=True, cache=False,
                  cache_patterns=None, max_age=None, max_count=None, tries=None,
-                 errors=RequestException, delay=None, multiplier=None):
+                 multiplier=None):
 
-        self.session = requests.Session()
+        self.session = session or requests.Session()
 
-        # Add default basic auth
-        if auth:
-            self.session.auth = auth
-
-        # Add default headers
-        headers = headers or {}
+        # Add default user agent string
         if user_agent is not None:
-            headers['User-Agent'] = user_agent
-        self.session.headers.update(headers)
+            self.session.headers['User-Agent'] = user_agent
 
         self.parser = parser
+
         self.timeout = timeout
-        self.verify = verify
+        self.allow_redirects = allow_redirects
 
         # Set up caching
         if cache:
@@ -118,25 +106,24 @@ def __init__(self, auth=None, parser=None, headers=None, user_agent=None,
 
         # Set up retries
         if tries:
-            decorator = retry(tries, errors, delay, multiplier)
-            self._open, self.open = self.open, decorator(self.open)
-            self._submit_form, self.submit_form = \
-                self.submit_form, decorator(self.submit_form)
+            retry = Retry(tries, backoff_factor=multiplier)
+            for protocol in ['http://', 'https://']:
+                self.session.adapters[protocol].max_retries = retry
 
     def __repr__(self):
         try:
             return '<RoboBrowser url={0}>'.format(self.url)
-        except RoboError:
+        except exceptions.RoboError:
             return '<RoboBrowser>'
 
     @property
     def state(self):
         if self._cursor == -1:
-            raise RoboError('No state')
+            raise exceptions.RoboError('No state')
         try:
             return self._states[self._cursor]
         except IndexError:
-            raise RoboError('Index out of range')
+            raise exceptions.RoboError('Index out of range')
 
     @property
     def response(self):
@@ -156,7 +143,7 @@ def find(self):
         try:
             return self.parsed.find
         except AttributeError:
-            raise RoboError
+            raise exceptions.RoboError
 
     @property
     def find_all(self):
@@ -164,7 +151,7 @@ def find_all(self):
         try:
             return self.parsed.find_all
         except AttributeError:
-            raise RoboError
+            raise exceptions.RoboError
 
     @property
     def select(self):
@@ -172,7 +159,7 @@ def select(self):
         try:
             return self.parsed.select
         except AttributeError:
-            raise RoboError
+            raise exceptions.RoboError
 
     def _build_url(self, url):
         """Build absolute URL.
@@ -186,19 +173,36 @@ def _build_url(self, url):
             url
         )
 
-    def open(self, url, timeout=None, verify=None):
+    @property
+    def _default_send_args(self):
+        """
+
+        """
+        return {
+            'timeout': self.timeout,
+            'allow_redirects': self.allow_redirects,
+        }
+
+    def _build_send_args(self, **kwargs):
+        """Merge optional arguments with defaults.
+
+        :param kwargs: Keyword arguments to `Session::send`
+
+        """
+        out = {}
+        out.update(self._default_send_args)
+        out.update(kwargs)
+        return out
+
+    def open(self, url, method='get', **kwargs):
         """Open a URL.
 
-        :param str url: URL
-        :param int timeout: Timeout in seconds
-        :param bool verify: Verify SSL
+        :param str url: URL to open
+        :param str method: Optional method; defaults to `'get'`
+        :param kwargs: Keyword arguments to `Session::request`
 
         """
-        response = self.session.get(
-            url,
-            timeout=timeout or self.timeout,
-            verify=verify if verify is not None else self.verify,
-        )
+        response = self.session.request(method, url, **self._build_send_args(**kwargs))
         self._update_state(response)
 
     def _update_state(self, response):
@@ -231,10 +235,10 @@ def _traverse(self, n=1):
 
         """
         if not self.history:
-            raise RoboError('Not tracking history')
+            raise exceptions.RoboError('Not tracking history')
         cursor = self._cursor + n
         if cursor >= len(self._states) or cursor < 0:
-            raise RoboError('Index out of range')
+            raise exceptions.RoboError('Index out of range')
         self._cursor = cursor
 
     def back(self, n=1):
@@ -292,6 +296,8 @@ def get_form(self, id=None, *args, **kwargs):
 
     def get_forms(self, *args, **kwargs):
         """Find forms by standard BeautifulSoup arguments.
+        :args: Positional arguments to `BeautifulSoup::find_all`
+        :args: Keyword arguments to `BeautifulSoup::find_all`
 
         :return: List of BeautifulSoup tags
 
@@ -302,33 +308,27 @@ def get_forms(self, *args, **kwargs):
             for form in forms
         ]
 
-    def follow_link(self, value=None, *args, **kwargs):
-        """Find a click a link by tag, pattern, and/or BeautifulSoup
-        arguments.
+    def follow_link(self, link, **kwargs):
+        """Click a link.
 
-        :param value: BeautifulSoup tag, string, or regex. If tag, follow its
-            href; if string or regex, search parsed document for match.
+        :param Tag link: Link to click
+        :param kwargs: Keyword arguments to `Session::send`
 
         """
-        if isinstance(value, Tag):
-            link = value
-        elif isinstance(value, string_types):
-            link = self.get_link(text=value, *args, **kwargs)
-        elif isinstance(value, re._pattern_type):
-            link = self.get_link(text=value, *args, **kwargs)
-        else:
-            link = self.get_link(*args, **kwargs)
-        if link is None:
-            raise RoboError('No results found')
-        href = link.get('href')
-        if href is None:
-            raise RoboError('Link element must have href attribute')
-        self.open(self._build_url(href))
-
-    def submit_form(self, form):
+        try:
+            href = link['href']
+        except KeyError:
+            raise exceptions.RoboError('Link element must have "href" '
+                                       'attribute')
+        self.open(self._build_url(href), **kwargs)
+
+    def submit_form(self, form, submit=None, **kwargs):
         """Submit a form.
 
         :param Form form: Filled-out form object
+        :param Submit submit: Optional `Submit` to click, if form includes
+            multiple submits
+        :param kwargs: Keyword arguments to `Session::send`
 
         """
         # Get HTTP verb
@@ -336,8 +336,11 @@ def submit_form(self, form):
 
         # Send request
         url = self._build_url(form.action) or self.url
-        form_data = form.serialize()
-        response = self.session.request(method, url, **form_data.to_requests(method))
+        payload = form.serialize(submit=submit)
+        serialized = payload.to_requests(method)
+        send_args = self._build_send_args(**kwargs)
+        send_args.update(serialized)
+        response = self.session.request(method, url, **send_args)
 
         # Update history
         self._update_state(response)
diff --git a/robobrowser/cache.py b/robobrowser/cache.py
index a931a2e..c106d8a 100644
--- a/robobrowser/cache.py
+++ b/robobrowser/cache.py
@@ -30,9 +30,12 @@ def _reduce_age(self, now):
 
         """
         if self.max_age:
-            for key, value in iteritems(self.data):
-                if now - value['date'] > self.max_age:
-                    del self.data[key]
+            keys = [
+                key for key, value in iteritems(self.data)
+                if now - value['date'] > self.max_age
+            ]
+            for key in keys:
+                del self.data[key]
 
     def _reduce_count(self):
         """Reduce size of cache by count.
diff --git a/robobrowser/compat.py b/robobrowser/compat.py
index 4f70a92..fd9163b 100644
--- a/robobrowser/compat.py
+++ b/robobrowser/compat.py
@@ -9,6 +9,7 @@
     from collections import OrderedDict
 OrderedDict = OrderedDict
 
+
 if PY2:
     import urlparse
     urlparse = urlparse
@@ -30,22 +31,16 @@
     iteritems = lambda d: iter(d.items())
     builtin_name = 'builtins'
 
-def with_metaclass(meta, *bases):
-    """Defines a metaclass.
-
-    Creates a dummy class with a dummy metaclass. When subclassed, the dummy
-    metaclass is used, which has a constructor that instantiates a
-    new class from the original parent. This ensures that the dummy class and
-    dummy metaclass are not in the inheritance tree.
-
-    Credit to Armin Ronacher.
 
+def encode_if_py2(func):
+    """If Python 2.x, return decorated function encoding unicode return value
+    to UTF-8; else noop.
     """
-    class metaclass(meta):
-        __call__ = type.__call__
-        __init__ = type.__init__
-        def __new__(cls, name, this_bases, d):
-            if this_bases is None:
-                return type.__new__(cls, name, (), d)
-            return meta(name, bases, d)
-    return metaclass('temporary_class', None, {})
+    if not PY2:
+        return func
+    def wrapped(*args, **kwargs):
+        ret = func(*args, **kwargs)
+        if not isinstance(ret, unicode):
+            raise TypeError('Wrapped function must return `unicode`')
+        return ret.encode('utf-8', 'ignore')
+    return wrapped
diff --git a/robobrowser/exceptions.py b/robobrowser/exceptions.py
index 423d47a..d437bb9 100644
--- a/robobrowser/exceptions.py
+++ b/robobrowser/exceptions.py
@@ -1,5 +1,13 @@
 # -*- coding: utf-8 -*-
 
 
-class InvalidNameError(Exception):
+class RoboError(Exception):
+    pass
+
+
+class InvalidNameError(RoboError):
+    pass
+
+
+class InvalidSubmitError(RoboError):
     pass
diff --git a/robobrowser/forms/__init__.py b/robobrowser/forms/__init__.py
index 6a2c75e..989961c 100644
--- a/robobrowser/forms/__init__.py
+++ b/robobrowser/forms/__init__.py
@@ -1,2 +1,4 @@
 from . import fields
 from .form import Form
+
+__all__ = ['fields', 'Form']
diff --git a/robobrowser/forms/fields.py b/robobrowser/forms/fields.py
index da8f229..c6ddeb3 100644
--- a/robobrowser/forms/fields.py
+++ b/robobrowser/forms/fields.py
@@ -3,46 +3,27 @@
 """
 
 import abc
+import six
 
-from robobrowser.compat import with_metaclass, string_types
+from robobrowser.compat import string_types
 from robobrowser import helpers
 from robobrowser import exceptions
 
 
-class ValueMeta(type):
-    """Metaclass that creates a value property on class creation. Classes
-    with this metaclass should define _get_value and optionally _set_value
-    methods.
-
-    """
-    def __init__(cls, name, bases, dct):
-        cls.value = property(
-            getattr(cls, '_get_value'),
-            getattr(cls, '_set_value', None),
-        )
-        super(ValueMeta, cls).__init__(name, bases, dct)
-
-
-class FieldMeta(ValueMeta, abc.ABCMeta):
-    """Multiply inherit from ValueMeta and ABCMeta; classes with this metaclass
-    are automatically assigned a value property and can use methods from
-    ABCMeta (e.g. abstractmethod).
-
-    """
-    pass
-
-
-class BaseField(with_metaclass(FieldMeta)):
+class BaseField(six.with_metaclass(abc.ABCMeta, object)):
     """Abstract base class for form fields.
 
     :param parsed: String or BeautifulSoup tag
-
     """
     def __init__(self, parsed):
-        self._parsed = helpers.ensure_soup(parsed)
+        self._parsed = helpers.ensure_soup(parsed, parser='html.parser')
         self._value = None
         self.name = self._get_name(self._parsed)
 
+    @property
+    def disabled(self):
+        return 'disabled' in self._parsed.attrs
+
     def _get_name(self, parsed):
         name = parsed.get('name')
         if name is not None:
@@ -51,16 +32,17 @@ def _get_name(self, parsed):
 
     # Different form fields may serialize their values under different keys.
     # See `FormData` for details.
-    form_data_key = None
+    payload_key = None
 
     def serialize(self):
         return {self.name: self.value}
 
-    # Property methods
-    def _get_value(self):
+    @property
+    def value(self):
         return self._value if self._value else ''
 
-    def _set_value(self, value):
+    @value.setter
+    def value(self, value):
         self._value = value
 
 
@@ -71,9 +53,14 @@ def __init__(self, parsed):
         self.value = self._parsed.get('value')
 
 
+class Submit(Input):
+    pass
+
+
 class FileInput(BaseField):
 
-    def _set_value(self, value):
+    @BaseField.value.setter
+    def value(self, value):
         if hasattr(value, 'read'):
             self._value = value
         elif isinstance(value, string_types):
@@ -83,10 +70,7 @@ def _set_value(self, value):
 
     # Serialize value to 'files' key for compatibility with file attachments
     # in requests.
-    form_data_key = 'files'
-
-    def serialize(self):
-        return {self.name: self.value}
+    payload_key = 'files'
 
 
 class MultiOptionField(BaseField):
@@ -111,18 +95,17 @@ def _value_to_index(self, value):
         if value in self.options:
             return self.options.index(value)
         if value in self.labels:
-            index = self.labels.index(value)
-            if index not in self.labels[index:]:
-                return index
-        raise ValueError
+            return self.labels.index(value)
+        raise ValueError('Option {0} not found in field {1!r}'.format(value, self))
 
-    # Property methods
-    def _get_value(self):
+    @property
+    def value(self):
         if self._value is None:
             return ''
         return self.options[self._value]
 
-    def _set_value(self, value):
+    @value.setter
+    def value(self, value):
         self._value = self._value_to_index(value)
 
 
@@ -131,14 +114,15 @@ class MultiValueField(MultiOptionField):
     def _set_initial(self, initial):
         self.value = initial
 
-    # Property methods
-    def _get_value(self):
+    @property
+    def value(self):
         return [
             self.options[idx]
             for idx in self._value
         ]
 
-    def _set_value(self, value):
+    @value.setter
+    def value(self, value):
         if not isinstance(value, list):
             value = [value]
         self._value = [
@@ -150,7 +134,7 @@ def _set_value(self, value):
     def append(self, value):
         index = self._value_to_index(value)
         if index in self._value:
-            raise ValueError
+            raise ValueError('Option {0} already in field {1!r}'.format(value, self))
         self._value.append(index)
         self._value.sort()
 
@@ -161,16 +145,17 @@ def remove(self, value):
 
 class FlatOptionField(MultiOptionField):
 
+    @property
+    def disabled(self):
+        return all('disabled' in each.attrs for each in self._parsed)
+
     def _get_name(self, parsed):
-        name = parsed[0].get('name')
-        if name is not None:
-            return name
-        raise exceptions.InvalidNameError
+        return super(FlatOptionField, self)._get_name(parsed[0])
 
     def _get_options(self, parsed):
         options, labels, initial = [], [], []
         for option in parsed:
-            value = option.get('value')
+            value = option.get('value', 'on')
             checked = option.get('checked')
             options.append(value)
             labels.append(
@@ -185,10 +170,17 @@ def _get_options(self, parsed):
 
 class NestedOptionField(MultiOptionField):
 
+    @property
+    def disabled(self):
+        return (
+            super(NestedOptionField, self).disabled or
+            all('disabled' in each.attrs for each in self._parsed.find_all('option'))
+        )
+
     def _get_options(self, parsed):
         options, labels, initial = [], [], []
         for option in parsed.find_all('option'):
-            value = option.get('value')
+            value = option.get('value', option.text)
             selected = option.get('selected')
             options.append(value)
             labels.append(option.text)
@@ -213,12 +205,12 @@ class Radio(FlatOptionField, MultiOptionField):
 
 
 class Select(NestedOptionField, MultiOptionField):
+
     def _set_initial(self, initial):
         """If no option is selected initially, select the first option.
-
         """
         super(Select, self)._set_initial(initial)
-        if not self._value:
+        if not self._value and self.options:
             self.value = self.options[0]
 
 
diff --git a/robobrowser/forms/form.py b/robobrowser/forms/form.py
index bcd848d..00b7222 100644
--- a/robobrowser/forms/form.py
+++ b/robobrowser/forms/form.py
@@ -4,8 +4,9 @@
 
 import re
 import collections
+from werkzeug.datastructures import OrderedMultiDict
 
-from robobrowser.compat import OrderedDict, iteritems
+from robobrowser.compat import iteritems, encode_if_py2
 
 from . import fields
 from .. import helpers
@@ -41,23 +42,23 @@ def _parse_field(tag, tags):
 
     if tag_type == 'input':
         tag_type = tag.get('type', '').lower()
+        if tag_type == 'submit':
+            return fields.Submit(tag)
         if tag_type == 'file':
             return fields.FileInput(tag)
-        elif tag_type == 'radio':
+        if tag_type == 'radio':
             radios = _group_flat_tags(tag, tags)
             return fields.Radio(radios)
-        elif tag_type == 'checkbox':
+        if tag_type == 'checkbox':
             checkboxes = _group_flat_tags(tag, tags)
             return fields.Checkbox(checkboxes)
-        else:
-            return fields.Input(tag)
-    elif tag_type == 'textarea':
+        return fields.Input(tag)
+    if tag_type == 'textarea':
         return fields.Textarea(tag)
-    elif tag_type == 'select':
+    if tag_type == 'select':
         if tag.get('multiple') is not None:
             return fields.MultiSelect(tag)
-        else:
-            return fields.Select(tag)
+        return fields.Select(tag)
 
 
 def _parse_fields(parsed):
@@ -87,15 +88,36 @@ def _parse_fields(parsed):
     return out
 
 
-class FormData(object):
+def _filter_fields(fields, predicate):
+    return OrderedMultiDict([
+        (key, value)
+        for key, value in fields.items(multi=True)
+        if predicate(value)
+    ])
+
+
+class Payload(object):
     """Container for serialized form outputs that knows how to export to
     the format expected by Requests. By default, form values are stored in
-    `payload`.
+    `data`.
 
     """
     def __init__(self):
-        self.payload = {}
-        self.options = collections.defaultdict(dict)
+        self.data = OrderedMultiDict()
+        self.options = collections.defaultdict(OrderedMultiDict)
+
+    @classmethod
+    def from_fields(cls, fields):
+        """
+
+        :param OrderedMultiDict fields:
+
+        """
+        payload = cls()
+        for _, field in fields.items(multi=True):
+            if not field.disabled:
+                payload.add(field.serialize(), field.payload_key)
+        return payload
 
     def add(self, data, key=None):
         """Add field values to container.
@@ -105,8 +127,9 @@ def add(self, data, key=None):
             to `self.payload`.
 
         """
-        sink = self.options[key] if key is not None else self.payload
-        sink.update(data)
+        sink = self.options[key] if key is not None else self.data
+        for key, value in iteritems(data):
+            sink.add(key, value)
 
     def to_requests(self, method='get'):
         """Export to Requests format.
@@ -116,10 +139,26 @@ def to_requests(self, method='get'):
 
         """
         out = {}
-        payload_key = 'params' if method.lower() == 'get' else 'data'
-        out[payload_key] = self.payload
+        data_key = 'params' if method.lower() == 'get' else 'data'
+        out[data_key] = self.data
         out.update(self.options)
-        return out
+        return dict([
+            (key, list(value.items(multi=True)))
+            for key, value in iteritems(out)
+        ])
+
+
+def prepare_fields(all_fields, submit_fields, submit):
+    if len(list(submit_fields.items(multi=True))) > 1:
+        if not submit:
+            raise exceptions.InvalidSubmitError()
+        if submit not in submit_fields.getlist(submit.name):
+            raise exceptions.InvalidSubmitError()
+        return _filter_fields(
+            all_fields,
+            lambda f: not isinstance(f, fields.Submit) or f == submit
+        )
+    return all_fields
 
 
 class Form(object):
@@ -132,7 +171,7 @@ def __init__(self, parsed):
         self.parsed = parsed
         self.action = self.parsed.get('action')
         self.method = self.parsed.get('method', 'get')
-        self.fields = OrderedDict()
+        self.fields = OrderedMultiDict()
         for field in _parse_fields(self.parsed):
             self.add_field(field)
 
@@ -146,18 +185,26 @@ def add_field(self, field):
         if not isinstance(field, fields.BaseField):
             raise ValueError('Argument "field" must be an instance of '
                              'BaseField')
-        self.fields[field.name] = field
+        self.fields.add(field.name, field)
+
+    @property
+    def submit_fields(self):
+        return _filter_fields(
+            self.fields,
+            lambda field: isinstance(field, fields.Submit)
+        )
 
+    @encode_if_py2
     def __repr__(self):
-        state = ', '.join(
+        state = u', '.join(
             [
-                '{0}={1}'.format(name, field.value)
-                for name, field in iteritems(self.fields)
+                u'{0}={1}'.format(name, field.value)
+                for name, field in self.fields.items(multi=True)
             ]
         )
         if state:
-            return '<RoboForm {0}>'.format(state)
-        return '<RoboForm>'
+            return u'<RoboForm {0}>'.format(state)
+        return u'<RoboForm>'
 
     def keys(self):
         return self.fields.keys()
@@ -168,13 +215,13 @@ def __getitem__(self, item):
     def __setitem__(self, key, value):
         self.fields[key].value = value
 
-    def serialize(self):
-        """Serialize each form field to a FormData container.
+    def serialize(self, submit=None):
+        """Serialize each form field to a Payload container.
 
-        :return: FormData instance
+        :param Submit submit: Optional `Submit` to click, if form includes
+            multiple submits
+        :return: Payload instance
 
         """
-        form_data = FormData()
-        for field in self.fields.values():
-            form_data.add(field.serialize(), field.form_data_key)
-        return form_data
+        include_fields = prepare_fields(self.fields, self.submit_fields, submit)
+        return Payload.from_fields(include_fields)
diff --git a/robobrowser/helpers.py b/robobrowser/helpers.py
index 485778f..95453d5 100644
--- a/robobrowser/helpers.py
+++ b/robobrowser/helpers.py
@@ -3,9 +3,6 @@
 """
 
 import re
-import time
-import logging
-import functools
 
 from bs4 import BeautifulSoup
 from bs4.element import Tag
@@ -57,10 +54,11 @@ def find(soup, name=None, attrs=None, recursive=True, text=None, **kwargs):
         return tags[0]
 
 
-def ensure_soup(value):
+def ensure_soup(value, parser=None):
     """Coerce a value (or list of values) to Tag (or list of Tag).
 
     :param value: String, BeautifulSoup, Tag, or list of the above
+    :param str parser: Parser to use; defaults to BeautifulSoup default
     :return: Tag or list of Tags
 
     """
@@ -70,10 +68,10 @@ def ensure_soup(value):
         return value
     if isinstance(value, list):
         return [
-            ensure_soup(item)
+            ensure_soup(item, parser=parser)
             for item in value
         ]
-    parsed = BeautifulSoup(value)
+    parsed = BeautifulSoup(value, features=parser)
     return parsed.find()
 
 
@@ -90,26 +88,3 @@ def lowercase_attr_names(tag):
         (key.lower(), value)
         for key, value in iteritems(tag.attrs)
     ])
-
-
-def retry(tries, errors=None, delay=3, multiplier=2, logger=None):
-
-    errors = errors or Exception
-    logger = logger or logging.getLogger(__name__)
-
-    def decorator(func):
-
-        @functools.wraps(func)
-        def decorated(*args, **kwargs):
-            mdelay = delay
-            for _ in range(tries - 1):
-                try:
-                    return func(*args, **kwargs)
-                except errors as error:
-                    logger.exception(error)
-                    time.sleep(mdelay)
-                    mdelay *= multiplier
-                return func(*args, **kwargs)
-        return decorated
-
-    return decorator
diff --git a/setup.cfg b/setup.cfg
new file mode 100644
index 0000000..a5e2c09
--- /dev/null
+++ b/setup.cfg
@@ -0,0 +1,4 @@
+[flake8]
+ignore = E127,E128,E265,E302,N803,N804,N806,E731,E402
+exclude = compat.py,ordereddict.py
+max-line-length = 90
diff --git a/setup.py b/setup.py
index e5914d4..2479cf1 100755
--- a/setup.py
+++ b/setup.py
@@ -1,21 +1,38 @@
-#!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
 import os
 import re
 import sys
 
-from setuptools import setup, find_packages
-from pip.req import parse_requirements
+from setuptools import setup
+from setuptools import find_packages
+
+
+REQUIREMENTS = [
+    'beautifulsoup4>=4.3.2',
+    'requests>=2.6.0',
+    'six>=1.9.0',
+    'Werkzeug>=0.10.4',
+]
+TEST_REQUIREMENTS = [
+    'coverage',
+    'coveralls',
+    'docutils',
+    'mock',
+    'nose',
+    'sphinx',
+    'tox',
+]
+
 
 if sys.argv[-1] == 'publish':
     os.system('python setup.py sdist upload')
     sys.exit()
 
+
 def find_version(fname):
     """Attempts to find the version number in the file names fname.
     Raises RuntimeError if not found.
-
     """
     version = ''
     with open(fname, 'r') as fp:
@@ -29,29 +46,19 @@ def find_version(fname):
         raise RuntimeError('Cannot find version information')
     return version
 
-__version__ = find_version('robobrowser/__init__.py')
-
-readme = open('README.rst').read()
-history = open('HISTORY.rst').read().replace('.. :changelog:', '')
-requirements = [
-    str(requirement.req)
-    for requirement in parse_requirements('requirements.txt')
-]
 
 setup(
     name='robobrowser',
-    version=__version__,
+    version=find_version('robobrowser/__init__.py'),
     description='Your friendly neighborhood web scraper',
     author='Joshua Carp',
     author_email='jm.carp@gmail.com',
     url='https://github.com/jmcarp/robobrowser',
-    packages=find_packages(),
+    packages=find_packages(exclude=('tests',)),
     package_dir={'robobrowser': 'robobrowser'},
     include_package_data=True,
-    install_requires=requirements,
-    tests_require=[
-        'nose',
-    ],
+    install_requires=REQUIREMENTS,
+    tests_require=TEST_REQUIREMENTS,
     license='MIT',
     zip_safe=False,
     keywords='robobrowser',
diff --git a/tests/__init__.py b/tests/__init__.py
index faa18be..e69de29 100755
--- a/tests/__init__.py
+++ b/tests/__init__.py
@@ -1,2 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
diff --git a/tests/test_browser.py b/tests/test_browser.py
index 7a703a3..45731ca 100644
--- a/tests/test_browser.py
+++ b/tests/test_browser.py
@@ -1,112 +1,20 @@
 import mock
 import unittest
-from nose.tools import *
+from nose.tools import *  # noqa
 
 import re
 import requests
-import functools
+from bs4 import BeautifulSoup
 
-from robobrowser import responses
 from robobrowser.browser import RoboBrowser
-from robobrowser.browser import RoboError
-from tests.utils import ArgCatcher
-
-
-def mock_responses(resps):
-    """Decorator factory to make tests more DRY. Bundles responses.activate
-    with a collection of response rules.
-
-    :param list resps: List of response-formatted ArgCatcher arguments.
-
-    """
-    def wrapper(func):
-        @responses.activate
-        @functools.wraps(func)
-        def wrapped(*args, **kwargs):
-            for resp in resps:
-                responses.add(*resp.args, **resp.kwargs)
-            return func(*args, **kwargs)
-        return wrapped
-    return wrapper
-
-mock_links = mock_responses(
-    [
-        ArgCatcher(
-            responses.GET, 'http://robobrowser.com/links/',
-            body=b'''
-                <a href="/link1/">sheer heart attack</a>
-                <a href="/link2/" class="song">night at the opera</a>
-            '''
-        ),
-        ArgCatcher(responses.GET, 'http://robobrowser.com/link1/'),
-        ArgCatcher(responses.GET, 'http://robobrowser.com/link2/'),
-    ]
-)
-
-mock_forms = mock_responses(
-    [
-        ArgCatcher(
-            responses.GET, 'http://robobrowser.com/get_form/',
-            body=b'''
-                <form id="bass" method="get" action="/get_form/">'
-                    <input name="deacon" value="john" />
-                </form>
-                <form id="drums" method="post" action="/get_form/">'
-                    <input name="deacon" value="john" />
-                </form>
-            '''
-        ),
-        ArgCatcher(
-            responses.GET, 'http://robobrowser.com/post_form/',
-            body=b'''
-                <form id="bass" method="post" action="/submit/">'
-                    <input name="deacon" value="john" />
-                </form>
-                <form id="drums" method="post" action="/submit/">'
-                    <input name="deacon" value="john" />
-                </form>
-            '''
-        ),
-        ArgCatcher(
-            responses.GET, 'http://robobrowser.com/noname/',
-            body=b'''
-                <form name="input" action="action" method="get">
-                <input type="checkbox" name="vehicle" value="Bike">
-                    I have a bike<br>
-                <input type="checkbox" name="vehicle" value="Car">I have a car
-                <br><br>
-                <input type="submit" value="Submit">
-                </form>
-            '''
-        ),
-        ArgCatcher(
-            responses.POST, 'http://robobrowser.com/submit/',
-        ),
-    ]
-)
-
-mock_urls = mock_responses(
-    [
-        ArgCatcher(responses.GET, 'http://robobrowser.com/page1/'),
-        ArgCatcher(responses.GET, 'http://robobrowser.com/page2/'),
-        ArgCatcher(responses.GET, 'http://robobrowser.com/page3/'),
-        ArgCatcher(responses.GET, 'http://robobrowser.com/page4/'),
-    ]
-)
+from robobrowser import exceptions
 
+from tests.fixtures import mock_links, mock_urls, mock_forms
 
-class TestHeaders(unittest.TestCase):
 
-    def test_headers(self):
-        headers = {
-            'X-Song': 'Innuendo',
-            'X-Writer': 'Freddie',
-        }
-        browser = RoboBrowser(headers=headers)
-        browser.open('http://robobrowser.com/links/')
-        for key, value in headers.items():
-            assert_equal(browser.session.headers[key], value)
+class TestHeaders(unittest.TestCase):
 
+    @mock_links
     def test_user_agent(self):
         browser = RoboBrowser(user_agent='freddie')
         browser.open('http://robobrowser.com/links/')
@@ -120,6 +28,28 @@ def test_default_headers(self):
         assert_equal(browser.session.headers, requests.Session().headers)
 
 
+class TestOpen(unittest.TestCase):
+
+    def setUp(self):
+        self.browser = RoboBrowser()
+
+    @mock.patch('requests.Session.request')
+    def test_open_default_method(self, mock_request):
+        url = 'http://robobrowser.com'
+        self.browser.open(url)
+        assert_true(mock_request.called)
+        args = mock_request.mock_calls[0][1]
+        assert_equal(args, ('get', url))
+
+    @mock.patch('requests.Session.request')
+    def test_open_custom_method(self, mock_request):
+        url = 'http://robobrowser.com'
+        self.browser.open(url, method='post')
+        assert_true(mock_request.called)
+        args = mock_request.mock_calls[0][1]
+        assert_equal(args, ('post', url))
+
+
 class TestLinks(unittest.TestCase):
 
     @mock_links
@@ -135,12 +65,7 @@ def test_get_link(self):
     @mock_links
     def test_get_links(self):
         links = self.browser.get_links()
-        assert_equal(len(links), 2)
-
-    @mock_links
-    def test_get_link_by_text(self):
-        link = self.browser.get_link('opera')
-        assert_equal(link.get('href'), '/link2/')
+        assert_equal(len(links), 3)
 
     @mock_links
     def test_follow_link_tag(self):
@@ -149,19 +74,12 @@ def test_follow_link_tag(self):
         assert_equal(self.browser.url, 'http://robobrowser.com/link1/')
 
     @mock_links
-    def test_follow_link_text(self):
-        self.browser.follow_link('heart attack')
-        assert_equal(self.browser.url, 'http://robobrowser.com/link1/')
-
-    @mock_links
-    def test_follow_link_regex(self):
-        self.browser.follow_link(re.compile(r'opera'))
-        assert_equal(self.browser.url, 'http://robobrowser.com/link2/')
-
-    @mock_links
-    def test_follow_link_bs_args(self):
-        self.browser.follow_link(class_=re.compile(r'song'))
-        assert_equal(self.browser.url, 'http://robobrowser.com/link2/')
+    def test_follow_link_no_href(self):
+        link = BeautifulSoup('<a>nohref</a>').find('a')
+        assert_raises(
+            exceptions.RoboError,
+            lambda: self.browser.follow_link(link)
+        )
 
 
 class TestForms(unittest.TestCase):
@@ -192,6 +110,18 @@ def test_submit_form_get(self):
         )
         assert_true(self.browser.state.response.request.body is None)
 
+    @mock_forms
+    def test_submit_form_multi_submit(self):
+        self.browser.open('http://robobrowser.com/multi_submit_form/')
+        form = self.browser.get_form()
+        submit = form.submit_fields['submit2']
+        self.browser.submit_form(form, submit=submit)
+        assert_equal(
+            self.browser.url,
+            'http://robobrowser.com/multi_submit_form/'
+            '?deacon=john&submit2=value2'
+        )
+
     @mock_forms
     def test_submit_form_post(self):
         self.browser.open('http://robobrowser.com/post_form/')
@@ -317,67 +247,99 @@ def test_open_clears_forward(self):
             len(self.browser._states) - 1
         )
         assert_raises(
-            RoboError,
+            exceptions.RoboError,
             self.browser.forward
         )
 
     def test_back_error(self):
         assert_raises(
-            RoboError,
+            exceptions.RoboError,
             self.browser.back,
             5
         )
 
 
+class TestCustomSession(unittest.TestCase):
+
+    @mock_links
+    def test_custom_headers(self):
+        session = requests.Session()
+        session.headers.update({
+            'Content-Encoding': 'gzip',
+        })
+        browser = RoboBrowser(session=session)
+        browser.open('http://robobrowser.com/links/')
+        assert_equal(
+            browser.response.request.headers.get('Content-Encoding'),
+            'gzip'
+        )
+
+    @mock_links
+    def test_custom_headers_override(self):
+        session = requests.Session()
+        session.headers.update({
+            'Content-Encoding': 'gzip',
+        })
+        browser = RoboBrowser(session=session)
+        browser.open(
+            'http://robobrowser.com/links/',
+            headers={'Content-Encoding': 'identity'}
+        )
+        assert_equal(
+            browser.response.request.headers.get('Content-Encoding'),
+            'identity'
+        )
+
+
 class TestTimeout(unittest.TestCase):
 
-    @mock.patch('requests.Session.get')
-    def test_no_timeout(self, mock_get):
+    @mock.patch('requests.Session.request')
+    def test_no_timeout(self, mock_request):
         browser = RoboBrowser()
         browser.open('http://robobrowser.com/')
-        mock_get.assert_called_once_with(
-            'http://robobrowser.com/', timeout=None, verify=True
-        )
+        assert_true(mock_request.called)
+        kwargs = mock_request.mock_calls[0][2]
+        assert_true(kwargs.get('timeout') is None)
 
-    @mock.patch('requests.Session.get')
-    def test_instance_timeout(self, mock_get):
+    @mock.patch('requests.Session.request')
+    def test_instance_timeout(self, mock_request):
         browser = RoboBrowser(timeout=5)
         browser.open('http://robobrowser.com/')
-        mock_get.assert_called_once_with(
-            'http://robobrowser.com/', timeout=5, verify=True
-        )
+        assert_true(mock_request.called)
+        kwargs = mock_request.mock_calls[0][2]
+        assert_equal(kwargs.get('timeout'), 5)
 
-    @mock.patch('requests.Session.get')
-    def test_call_timeout(self, mock_get):
+    @mock.patch('requests.Session.request')
+    def test_call_timeout(self, mock_request):
         browser = RoboBrowser(timeout=5)
         browser.open('http://robobrowser.com/', timeout=10)
-        mock_get.assert_called_once_with(
-            'http://robobrowser.com/', timeout=10, verify=True
-        )
+        assert_true(mock_request.called)
+        kwargs = mock_request.mock_calls[0][2]
+        assert_equal(kwargs.get('timeout'), 10)
 
 
-class TestVerify(unittest.TestCase):
+class TestAllowRedirects(unittest.TestCase):
 
-    @mock.patch('requests.Session.get')
-    def test_no_verify(self, mock_get):
+    @mock.patch('requests.Session.request')
+    def test_no_allow_redirects(self, mock_request):
         browser = RoboBrowser()
         browser.open('http://robobrowser.com/')
-        mock_get.assert_called_once_with(
-            'http://robobrowser.com/', verify=True, timeout=None
-        )
+        assert_true(mock_request.called)
+        kwargs = mock_request.mock_calls[0][2]
+        assert_true(kwargs.get('allow_redirects') is True)
 
-    @mock.patch('requests.Session.get')
-    def test_instance_verify(self, mock_get):
-        browser = RoboBrowser(verify=True)
+    @mock.patch('requests.Session.request')
+    def test_instance_allow_redirects(self, mock_request):
+        browser = RoboBrowser(allow_redirects=False)
         browser.open('http://robobrowser.com/')
-        mock_get.assert_called_once_with(
-            'http://robobrowser.com/', verify=True, timeout=None
-        )
-
-    @mock.patch('requests.Session.get')
-    def test_call_verify(self, mock_get):
-        browser = RoboBrowser(verify=True)
-        browser.open('http://robobrowser.com/', verify=False)
-        mock_get.assert_called_once_with(
-            'http://robobrowser.com/', verify=False, timeout=None
-        )
+        assert_true(mock_request.called)
+        kwargs = mock_request.mock_calls[0][2]
+        assert_true(kwargs.get('allow_redirects') is False)
+
+    @mock.patch('requests.Session.request')
+    def test_call_allow_redirects(self, mock_request):
+        browser = RoboBrowser(allow_redirects=True)
+        browser.open('http://robobrowser.com/', allow_redirects=False)
+        assert_true(mock_request.called)
+        kwargs = mock_request.mock_calls[0][2]
+        assert_true(kwargs.get('allow_redirects') is False)
diff --git a/tests/test_cache.py b/tests/test_cache.py
index c29c5f2..92967c5 100644
--- a/tests/test_cache.py
+++ b/tests/test_cache.py
@@ -7,6 +7,7 @@
 from robobrowser.cache import RoboCache
 from tests.utils import KwargSetter
 
+
 class TestAdapter(unittest.TestCase):
 
     def test_cache_on(self):
@@ -25,6 +26,7 @@ def test_cache_off(self):
         resp2 = self.browser.state.response
         assert_true(resp1 is not resp2)
 
+
 class TestCache(unittest.TestCase):
 
     def setUp(self):
diff --git a/tests/test_forms.py b/tests/test_forms.py
index 7dbfac4..51128a8 100644
--- a/tests/test_forms.py
+++ b/tests/test_forms.py
@@ -1,45 +1,47 @@
+# -*- coding: utf-8 -*-
+
 import mock
 import unittest
-from nose.tools import *
+from nose.tools import *  # noqa
 
 import tempfile
 from bs4 import BeautifulSoup
 
 from robobrowser.compat import builtin_name
-from robobrowser.forms.form import Form, FormData, fields, _parse_fields
+from robobrowser.forms.form import Form, Payload, fields, _parse_fields
 from robobrowser import exceptions
 
 
-class TestFormData(unittest.TestCase):
+class TestPayload(unittest.TestCase):
 
     def setUp(self):
-        self.form_data = FormData()
-        self.form_data.add({'red': 'special'})
+        self.payload = Payload()
+        self.payload.add({'red': 'special'})
 
     def test_add_payload(self):
-        self.form_data.add({'lazing': 'sunday'})
-        assert_true('lazing' in self.form_data.payload)
-        assert_equal(self.form_data.payload['lazing'], 'sunday')
+        self.payload.add({'lazing': 'sunday'})
+        assert_true('lazing' in self.payload.data)
+        assert_equal(self.payload.data['lazing'], 'sunday')
 
     def test_add_by_key(self):
-        self.form_data.add({'lazing': 'sunday'}, 'afternoon')
-        assert_false('lazing' in self.form_data.payload)
-        assert_true('afternoon' in self.form_data.options)
-        assert_true('lazing' in self.form_data.options['afternoon'])
+        self.payload.add({'lazing': 'sunday'}, 'afternoon')
+        assert_false('lazing' in self.payload.data)
+        assert_true('afternoon' in self.payload.options)
+        assert_true('lazing' in self.payload.options['afternoon'])
         assert_equal(
-            self.form_data.options['afternoon']['lazing'],
+            self.payload.options['afternoon']['lazing'],
             'sunday'
         )
 
     def test_requests_get(self):
-        out = self.form_data.to_requests('get')
+        out = self.payload.to_requests('get')
         assert_true('params' in out)
-        assert_equal(out['params'], {'red': 'special'})
+        assert_equal(list(out['params']), [('red', 'special')])
 
     def test_requests_post(self):
-        out = self.form_data.to_requests('post')
+        out = self.payload.to_requests('post')
         assert_true('data' in out)
-        assert_equal(out['data'], {'red': 'special'})
+        assert_equal(list(out['data']), [('red', 'special')])
 
 
 class TestForm(unittest.TestCase):
@@ -55,12 +57,15 @@ def setUp(self):
                 </select>
                 <input type="radio" name="bass" value="Roger">Roger<br />
                 <input type="radio" name="bass" value="John">John<br />
+                <input name="multi" value="multi1" />
+                <input name="multi" value="multi2" />
+                <input type="submit" name="submit" value="submit" />
             </form>
         '''
         self.form = Form(self.html)
 
     def test_fields(self):
-        keys = set(('vocals', 'guitar', 'drums', 'bass'))
+        keys = set(('vocals', 'guitar', 'drums', 'bass', 'multi', 'submit'))
         assert_equal(set(self.form.fields.keys()), keys)
         assert_equal(set(self.form.keys()), keys)
 
@@ -76,7 +81,8 @@ def test_add_field_wrong_type(self):
     def test_repr(self):
         assert_equal(
             repr(self.form),
-            '<RoboForm vocals=, guitar=, drums=roger, bass=>'
+            '<RoboForm vocals=, guitar=, drums=roger, bass=, '
+            'multi=multi1, multi=multi2, submit=submit>'
         )
 
     def test_repr_empty(self):
@@ -85,6 +91,61 @@ def test_repr_empty(self):
             '<RoboForm>'
         )
 
+    def test_repr_unicode(self):
+        form = Form(u'<form><input name="drüms" value="bäss" /></form>')
+        assert_equal(
+            repr(form),
+            '<RoboForm drüms=bäss>'
+        )
+
+    def test_serialize(self):
+        serialized = self.form.serialize()
+        assert_equal(serialized.data.getlist('multi'), ['multi1', 'multi2'])
+        assert_equal(serialized.data['submit'], 'submit')
+
+    def test_serialize_skips_disabled(self):
+        html = '''
+            <form>
+                <input name="vocals" />
+                <input name="guitar" disabled />
+                <input type="submit" name="submit" value="submit" />
+            </form>
+        '''
+        form = Form(html)
+        serialized = form.serialize()
+        assert_false('guitar' in serialized.data)
+
+
+class TestFormMultiSubmit(unittest.TestCase):
+
+    def setUp(self):
+        self.html = '''
+            <form>
+                <input type="submit" name="submit1" value="value1" />
+                <input type="submit" name="submit2" value="value2" />
+            </form>
+        '''
+        self.form = Form(self.html)
+
+    def test_serialize_multi_no_submit_specified(self):
+        assert_raises(
+            exceptions.InvalidSubmitError,
+            lambda: self.form.serialize()
+        )
+
+    def test_serialize_multi_wrong_submit_specified(self):
+        fake_submit = fields.Submit('<input type="submit" name="fake" />')
+        assert_raises(
+            exceptions.InvalidSubmitError,
+            lambda: self.form.serialize(submit=fake_submit)
+        )
+
+    def test_serialize_multi(self):
+        submit = self.form.submit_fields['submit1']
+        serialized = self.form.serialize(submit)
+        assert_equal(serialized.data['submit1'], 'value1')
+        assert_false('submit2' in serialized.data)
+
 
 class TestParser(unittest.TestCase):
 
@@ -169,6 +230,16 @@ def test_parse_select(self):
         assert_equal(len(_fields), 1)
         assert_true(isinstance(_fields[0], fields.Select))
 
+    def test_parse_empty_select(self):
+        html = '''
+            <select name="instrument"></select>
+        '''
+        _fields = _parse_fields(BeautifulSoup(html))
+        assert_equal(len(_fields), 1)
+        assert_true(isinstance(_fields[0], fields.Select))
+        assert_equal(_fields[0].value, '')
+        assert_equal(_fields[0].options, [])
+
     def test_parse_select_multi(self):
         html = '''
             <select name="instrument" multiple>
@@ -473,7 +544,7 @@ def test_value(self):
         assert_equal(self.input._value, [2])
         assert_equal(self.input.value, ['taylor'])
 
-    def test_value(self):
+    def test_values(self):
         self.input.value = ['taylor', 'deacon']
         assert_equal(self.input._value, [2, 3])
         assert_equal(self.input.value, ['taylor', 'deacon'])
@@ -543,3 +614,104 @@ def test_serialize(self):
             self.input.serialize(),
             {'song': file}
         )
+
+
+class TestDisabledValues(unittest.TestCase):
+
+    def test_input_enabled(self):
+        html = '<input name="brian" value="may" />'
+        input = fields.Input(BeautifulSoup(html).find('input'))
+        assert_false(input.disabled)
+
+    def test_input_disabled(self):
+        html = '<input name="brian" value="may" disabled />'
+        input = fields.Input(BeautifulSoup(html).find('input'))
+        assert_true(input.disabled)
+
+    def test_checkbox_enabled(self):
+        html = '''
+            <input type="checkbox" name="member" value="mercury" checked />vocals<br />
+            <input type="checkbox" name="member" value="may" />guitar<br />
+            <input type="checkbox" name="member" value="taylor" disabled />drums<br />
+            <input type="checkbox" name="member" value="deacon" checked />bass<br />
+        '''
+        input = fields.Checkbox(BeautifulSoup(html).find_all('input'))
+        assert_false(input.disabled)
+
+    def test_checkbox_disabled(self):
+        html = '''
+            <input type="checkbox" name="member" value="mercury" checked disabled />vocals<br />
+            <input type="checkbox" name="member" value="may" disabled />guitar<br />
+            <input type="checkbox" name="member" value="taylor" disabled />drums<br />
+            <input type="checkbox" name="member" value="deacon" checked disabled />bass<br />
+        '''
+        input = fields.Checkbox(BeautifulSoup(html).find_all('input'))
+        assert_true(input.disabled)
+
+    def test_select_enabled(self):
+        html = '''
+            <select name="john">
+                <option value="tie">your mother down</option>
+                <option value="you're" selected>my best friend</option>
+                <option value="the">millionaire waltz</option>
+            </select>
+        '''
+        input = fields.Select(BeautifulSoup(html).find('select'))
+        assert_false(input.disabled)
+
+    def test_select_disabled_root(self):
+        html = '''
+            <select name="john" disabled>
+                <option value="tie">your mother down</option>
+                <option value="you're" selected>my best friend</option>
+                <option value="the">millionaire waltz</option>
+            </select>
+        '''
+        input = fields.Select(BeautifulSoup(html).find('select'))
+        assert_true(input.disabled)
+
+    def test_select_disabled_options(self):
+        html = '''
+            <select name="john">
+                <option value="tie" disabled>your mother down</option>
+                <option value="you're" selected disabled>my best friend</option>
+                <option value="the" disabled>millionaire waltz</option>
+            </select>
+        '''
+        input = fields.Select(BeautifulSoup(html).find('select'))
+        assert_true(input.disabled)
+
+
+class TestDefaultValues(unittest.TestCase):
+
+    def test_checkbox_default(self):
+        inputs = BeautifulSoup('''
+            <input type="checkbox" name="checkbox" />
+        ''').find_all('input')
+        checkbox = fields.Checkbox(inputs)
+        assert_equal(checkbox.options, ['on'])
+
+    def test_radio_default(self):
+        inputs = BeautifulSoup('''
+            <input type="radio" name="checkbox" />
+        ''').find_all('input')
+        radio = fields.Radio(inputs)
+        assert_equal(radio.options, ['on'])
+
+    def test_select_default(self):
+        parsed = BeautifulSoup('''
+            <select name="select">
+                <option>opt</option>
+            </select>
+        ''', 'html.parser')
+        select = fields.Select(parsed)
+        assert_equal(select.options, ['opt'])
+
+    def test_multi_select_default(self):
+        parsed = BeautifulSoup('''
+            <select name="select" multiple>
+                <option>opt</option>
+            </select>
+        ''', 'html.parser')
+        select = fields.Select(parsed)
+        assert_equal(select.options, ['opt'])
diff --git a/tests/utils.py b/tests/utils.py
index 51aaf53..0a567f7 100644
--- a/tests/utils.py
+++ b/tests/utils.py
@@ -1,5 +1,9 @@
+import functools
+
+from robobrowser import responses
 from robobrowser.compat import iteritems
 
+
 class ArgCatcher(object):
     """Simple class for memorizing positional and keyword arguments. Used to
     capture responses for mock_responses.
@@ -9,6 +13,7 @@ def __init__(self, *args, **kwargs):
         self.args = args
         self.kwargs = kwargs
 
+
 class KwargSetter(object):
     """Simple class for memorizing keyword arguments as instance attributes.
     Used to mock requests and responses for testing.
@@ -17,3 +22,21 @@ class KwargSetter(object):
     def __init__(self, **kwargs):
         for key, value in iteritems(kwargs):
             setattr(self, key, value)
+
+
+def mock_responses(resps):
+    """Decorator factory to make tests more DRY. Bundles responses.activate
+    with a collection of response rules.
+
+    :param list resps: List of response-formatted ArgCatcher arguments.
+
+    """
+    def wrapper(func):
+        @responses.activate
+        @functools.wraps(func)
+        def wrapped(*args, **kwargs):
+            for resp in resps:
+                responses.add(*resp.args, **resp.kwargs)
+            return func(*args, **kwargs)
+        return wrapped
+    return wrapper