disallow moving up and down the path with .. and .

Before using the path, compare it with the cleaned-up
version of itself (given by os.path.normpath). It it's
different, so eitehr there's a ../ or /./ or // (double slash),
deny access and throw a 400 bad request.

The storage layer gives a MalformedPathException, the cdmi layer
hands this to the client as 400.
update gevent startup script for create_app()
extend comment on read_stream_generator
add patch-able read/write/open funcs; refactor read_stream_gen

1. add proxy functions for read/write/seek/open/close,
    which are patchable by mock.patch for unit tests.
    those are in *storage and called _read/_write and so on.
2. refactor read_stream_generator
    - change the signature to take the new proxy functions
    - simplify the structure by removing the special case
      for a segment going to the end of the file.
      Now we also do the segment size counter if it's going
      to the end and adjust the buffer_size, but the
      performance drawback should be minimal.
      The code is much simpler now.
3. adjust irodsstorage to use the common read_stream_generator
    that also simplifies maintenance.
fix the segment size of a segment reaching file_size

The calculation of a segment with segment_end == file_size
was one too long.
This happened because we have to add one to all other
segment to include the last element when we count from zero.
example:
'abcdefg' len 7
segment 0-3 (without +1) -> 'abc' len 3, element 0,1,2
it should be
                         -> 'abcd' len 4, element 0,1,2,3

When we add one to the file_size segment, it became one too long.

The change is replacing segment_ends of file_size with the
END symbol from storage_common, then the adjustment that we
already do works fine.

side-note: The code could be further simplified by removing
all START and END markers inside the read() functions of the
storage before giving the range_list to read_stream_generator().
This would tie us in a bit more in that we have to know the file_size
before retrieving the file.
(currently we need this information to build the content_length
 response header, so it's reasonable, but I'd leave it for now)
fix indentation
put user and url list creation in the unittest on the module level

move get_url_list and get_user_list out of the
TestHttpApi (renamed from TestHttpStorageApi) class
to the module level so that they can be used by other
test classes.
fix private function names in irodsstorage

private modules functions should have only
one _ instead of two.
(__ is for private class methods)
update file and folder definitions in mockstorage
add test for the storage API; add file definitions

add a new class with tests against the storage API.
This complements the http tests.
- httptests runs with a fully mocked storage and expect
    a well-implemented storage interface to test cdmi.py
- the storagetests test if the storages implement the
    API correctly.
    The aim is to detach the storages from the backend
    so that we can mock the backend functions, but it's
    not clear if that's possible.

    Either way the tests should run without further mockin
    as functional tests. Mocking is only to enable them to
    be run as automated unit tests.
remove argparse and PyRods from requirements

argparse is not needed
PyRods cannot be installed with pip
add .travis.yml for automatic testing
add more requirements
remove flask-testing requirement
update .travis.yml to only tests unittests.py
add installation of pyrods on travis
install irods on travis
add support for reading test config files per env

the test classes now read in a variable called
TEST_CONFIG to get their configuration.
If this config does not exist, they read a local one
(in the same module as the test)
use env var for reading test config in travis
add fake authentication to localstorage

to let the unit tests pass. the usernames and password
are given through the config.py.
if none are, everyone can access -- this helps the dev use case