Merge lp:~jamesh/storage-provider-webdav/landing-20161118 into lp:storage-provider-webdav

[James Henstridge]

Merge lp:storage-provider-webdav/devel r22 to trunk.

Merge lp:storage-provider-webdav/devel r22 to trunk.

[lp:~jamesh/storage-provider-webdav/landing-20161118]

21. By James Henstridge on 2016-11-24

Remove the item ID check in RetrievMetadataHandler::finish(), since the WebDAV server may encode URIs differently to Qt.

Approved by unity-api-1-bot, Michi Henning.

[Michi Henning (michihenning)]

Yep!

review: Approve

[lp:~jamesh/storage-provider-webdav/landing-20161118]

22. By James Henstridge on 2016-11-25

Update the test suite to use the v2 client API.

Approved by Michi Henning, unity-api-1-bot.

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2016-09-27 07:08:19 +0000
+++ CMakeLists.txt	2016-11-25 05:01:23 +0000
@@ -16,12 +16,13 @@
 find_package(Qt5Network REQUIRED)
 find_package(Qt5Test REQUIRED)
 find_package(Qt5Xml REQUIRED)
-pkg_check_modules(SF_PROVIDER REQUIRED storage-framework-provider-1)
-pkg_check_modules(SF_CLIENT REQUIRED storage-framework-qt-client-1)
+pkg_check_modules(SF_PROVIDER REQUIRED storage-framework-provider-1>=0.2)
+pkg_check_modules(SF_CLIENT REQUIRED storage-framework-qt-client-2>=0.2)
 
 add_definitions(-DQT_NO_KEYWORDS)
 
 add_subdirectory(src)
+add_subdirectory(data)
 add_subdirectory(tests)
 
 enable_coverage_report(

=== added file 'COPYING.GPL'
--- COPYING.GPL	1970-01-01 00:00:00 +0000
+++ COPYING.GPL	2016-11-25 05:01:23 +0000
@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.

=== added file 'COPYING.LGPL'
--- COPYING.LGPL	1970-01-01 00:00:00 +0000
+++ COPYING.LGPL	2016-11-25 05:01:23 +0000
@@ -0,0 +1,165 @@
+		   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions. 
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version. 
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

=== added directory 'data'
=== added file 'data/CMakeLists.txt'
--- data/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ data/CMakeLists.txt	2016-11-25 05:01:23 +0000
@@ -0,0 +1,17 @@
+# OnlineAccounts support files
+install(FILES storage-provider-owncloud.service
+  DESTINATION "${CMAKE_INSTALL_DATADIR}/accounts/services")
+install(FILES storage-provider-owncloud.application
+  DESTINATION "${CMAKE_INSTALL_DATADIR}/accounts/applications")
+install(FILES storage-provider-owncloud.desktop
+  DESTINATION "${CMAKE_INSTALL_DATADIR}/applications")
+
+# D-Bus serice activation
+configure_file(
+  com.canonical.StorageFramework.Provider.OwnCloud.service.in
+  com.canonical.StorageFramework.Provider.OwnCloud.service
+)
+install(
+  FILES ${CMAKE_CURRENT_BINARY_DIR}/com.canonical.StorageFramework.Provider.OwnCloud.service
+  DESTINATION ${CMAKE_INSTALL_DATADIR}/dbus-1/services
+)

=== added file 'data/com.canonical.StorageFramework.Provider.OwnCloud.service.in'
--- data/com.canonical.StorageFramework.Provider.OwnCloud.service.in	1970-01-01 00:00:00 +0000
+++ data/com.canonical.StorageFramework.Provider.OwnCloud.service.in	2016-11-25 05:01:23 +0000
@@ -0,0 +1,3 @@
+[D-BUS Service]
+Name=com.canonical.StorageFramework.Provider.OwnCloud
+Exec=@CMAKE_INSTALL_FULL_LIBDIR@/@PROJECT_NAME@/storage-provider-owncloud

=== added file 'data/storage-provider-owncloud.application'
--- data/storage-provider-owncloud.application	1970-01-01 00:00:00 +0000
+++ data/storage-provider-owncloud.application	2016-11-25 05:01:23 +0000
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!-- -*- mode: nxml -*- -->
+<application id="storage-provider-owncloud">
+  <description>OwnCloud storage provider</description>
+  <desktop-entry>storage-provider-owncloud.desktop</desktop-entry>
+
+  <services>
+    <service id="storage-provider-owncloud">
+      <description>Access your Owncloud documents</description>
+    </service>
+  </services>
+</application>

=== added file 'data/storage-provider-owncloud.desktop'
--- data/storage-provider-owncloud.desktop	1970-01-01 00:00:00 +0000
+++ data/storage-provider-owncloud.desktop	2016-11-25 05:01:23 +0000
@@ -0,0 +1,5 @@
+[Desktop Entry]
+Type=Application
+NoDisplay=true
+Name=OwnCloud storage provider
+Icon=online-accounts-owncloud

=== added file 'data/storage-provider-owncloud.service'
--- data/storage-provider-owncloud.service	1970-01-01 00:00:00 +0000
+++ data/storage-provider-owncloud.service	2016-11-25 05:01:23 +0000
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!-- -*- mode: nxml -*- -->
+<service id="storage-provider-owncloud">
+  <type>storage-provider</type>
+  <name>OwnCloud</name>
+  <icon>online-accounts-owncloud</icon>
+  <provider>owncloud</provider>
+</service>

=== modified file 'debian/control'
--- debian/control	2016-09-27 07:08:19 +0000
+++ debian/control	2016-11-25 05:01:23 +0000
@@ -1,8 +1,8 @@
 Source: storage-provider-webdav
-Section: ???
+Section: net
 Priority: optional
-Maintainer: Ubuntu Core Developers <[e-mail]>
-Standards-Version: 3.9.6
+Maintainer: Ubuntu Developers <[e-mail]>
+Standards-Version: 3.9.8
 Build-Depends: cmake,
                cmake-extras (>= 0.4),
                debhelper (>= 9),
@@ -12,8 +12,9 @@
                libgtest-dev,
                libonline-accounts-qt-dev,
                libqtdbustest1-dev,
-               storage-framework-provider-dev,
-               storage-framework-client-dev,
+               libstorage-framework-qt-client-2-0,
+               storage-framework-provider-dev (>= 0.2),
+               storage-framework-client-dev (>= 0.2),
                php-cli | php5-cli <!nocheck>,
                php-sabre-dav <!nocheck>,
                pkg-config,
@@ -31,8 +32,8 @@
 Architecture: any
 Multi-Arch: foreign
 Pre-Depends: ${misc:Pre-Depends},
-Depends: ${misc:Depends},
+Depends: account-plugin-owncloud,
+         ${misc:Depends},
          ${shlibs:Depends},
-         account-plugin-owncloud
 Description: Owncloud plugin for Storage Framework
  A Storage Framework plugin providing access to Owncloud servers.

=== added file 'debian/copyright'
--- debian/copyright	1970-01-01 00:00:00 +0000
+++ debian/copyright	2016-11-25 05:01:23 +0000
@@ -0,0 +1,36 @@
+Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
+Upstream-Name: storage-provider-webdav
+Source: https://launchpad.net/storage-provider-webdav
+
+Files: *
+Copyright: 2016 Canonical Ltd.
+License: GPL-3
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License version 3 as
+ published by the Free Software Foundation.
+ .
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+ .
+ On Debian/Ubuntu systems, the full text of the GPL v3 can be found in
+ `/usr/share/common-licenses/GPL-3'
+
+Files: tests/utils/DBusEnvironment.*
+       tests/utils/ProviderEnvironment.*
+       tests/utils/fake-onlye-accounts-daemon.py
+Copyright: 2016 Canonical Ltd.
+License: LGPL-3
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of version 3 of the GNU Lesser General Public
+ License as published by  the Free Software Foundation.
+ .
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU Lesser General Public License for more details.
+ .
+ On Debian systems, the full text of the GNU Lesser General Public
+ License version 3 can be found in the file
+ `/usr/share/common-licenses/LGPL-3'

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2016-09-27 07:08:19 +0000
+++ src/CMakeLists.txt	2016-11-25 05:01:23 +0000
@@ -1,9 +1,20 @@
 
 add_library(dav-provider-lib STATIC
   DavProvider.cpp
-  RootsHandler.cpp
+  DavDownloadJob.cpp
+  DavUploadJob.cpp
   MultiStatusParser.cpp
+  http_error.cpp
   item_id.cpp
+  CopyMoveHandler.cpp
+  CreateFolderHandler.cpp
+  DeleteHandler.cpp
+  PropFindHandler.cpp
+  ListHandler.cpp
+  LookupHandler.cpp
+  MetadataHandler.cpp
+  RetrieveMetadataHandler.cpp
+  RootsHandler.cpp
 )
 target_compile_options(dav-provider-lib PUBLIC
   ${SF_PROVIDER_CFLAGS}
@@ -28,3 +39,8 @@
 target_link_libraries(storage-provider-owncloud
   dav-provider-lib
 )
+
+install(
+  TARGETS storage-provider-owncloud
+  RUNTIME DESTINATION "${CMAKE_INSTALL_LIBDIR}/${PROJECT_NAME}"
+)

=== added file 'src/CopyMoveHandler.cpp'
--- src/CopyMoveHandler.cpp	1970-01-01 00:00:00 +0000
+++ src/CopyMoveHandler.cpp	2016-11-25 05:01:23 +0000
@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: James Henstridge <[e-mail]>
+ */
+
+#include "CopyMoveHandler.h"
+#include "RetrieveMetadataHandler.h"
+#include "item_id.h"
+#include "http_error.h"
+
+using namespace std;
+using namespace unity::storage::provider;
+
+CopyMoveHandler::CopyMoveHandler(shared_ptr<DavProvider> const& provider,
+                                 string const& item_id,
+                                 string const& new_parent_id,
+                                 string const& new_name,
+                                 bool copy,
+                                 Context const& ctx)
+    : provider_(provider), item_id_(item_id),
+      new_item_id_(make_child_id(new_parent_id, new_name, is_folder(item_id))),
+      context_(ctx)
+{
+    QUrl const base_url = provider->base_url(ctx);
+    QNetworkRequest request(id_to_url(item_id_, base_url));
+    request.setRawHeader(QByteArrayLiteral("Destination"),
+                         id_to_url(new_item_id_, base_url).toEncoded());
+    // Error out of the operation would overwrite an existing resource.
+    request.setRawHeader(QByteArrayLiteral("Overwrite"),
+                         QByteArrayLiteral("F"));
+
+    reply_.reset(provider->send_request(
+        request, copy ? QByteArrayLiteral("COPY") : QByteArrayLiteral("MOVE"),
+        nullptr, ctx));
+    connect(reply_.get(), &QNetworkReply::finished,
+            this, &CopyMoveHandler::onFinished);
+}
+
+CopyMoveHandler::~CopyMoveHandler() = default;
+
+boost::future<Item> CopyMoveHandler::get_future()
+{
+    return promise_.get_future();
+}
+
+void CopyMoveHandler::onFinished()
+{
+    auto status = reply_->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+
+    if (status != 201 && status != 204)
+    {
+        promise_.set_exception(
+            translate_http_error(reply_.get(), QByteArray(), item_id_));
+        deleteLater();
+        return;
+    }
+
+    metadata_.reset(
+        new RetrieveMetadataHandler(
+            provider_, new_item_id_, context_,
+            [this](Item const& item, boost::exception_ptr const& error) {
+                if (error)
+                {
+                    promise_.set_exception(error);
+                }
+                else
+                {
+                    promise_.set_value(item);
+                }
+                deleteLater();
+            }));
+}

=== added file 'src/CopyMoveHandler.h'
--- src/CopyMoveHandler.h	1970-01-01 00:00:00 +0000
+++ src/CopyMoveHandler.h	2016-11-25 05:01:23 +0000
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: James Henstridge <[e-mail]>
+ */
+
+#pragma once
+
+#include <QBuffer>
+#include <QObject>
+#include <QNetworkReply>
+#include <unity/storage/provider/ProviderBase.h>
+
+#include <memory>
+
+class DavProvider;
+class RetrieveMetadataHandler;
+
+class CopyMoveHandler : public QObject {
+    Q_OBJECT
+public:
+    CopyMoveHandler(std::shared_ptr<DavProvider> const& provider,
+                    std::string const& item_id,
+                    std::string const& new_parent_id,
+                    std::string const& new_name,
+                    bool copy,
+                    unity::storage::provider::Context const& ctx);
+    ~CopyMoveHandler();
+
+    boost::future<unity::storage::provider::Item> get_future();
+
+private Q_SLOTS:
+    void onFinished();
+
+private:
+    boost::promise<unity::storage::provider::Item> promise_;
+
+    std::shared_ptr<DavProvider> const provider_;
+    std::string const item_id_;
+    std::string const new_item_id_;
+    unity::storage::provider::Context const context_;
+
+    std::unique_ptr<QNetworkReply> reply_;
+    std::unique_ptr<RetrieveMetadataHandler> metadata_;
+};

=== added file 'src/CreateFolderHandler.cpp'
--- src/CreateFolderHandler.cpp	1970-01-01 00:00:00 +0000
+++ src/CreateFolderHandler.cpp	2016-11-25 05:01:23 +0000
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: James Henstridge <[e-mail]>
+ */
+
+#include "CreateFolderHandler.h"
+#include "RetrieveMetadataHandler.h"
+#include "item_id.h"
+#include "http_error.h"
+
+using namespace std;
+using namespace unity::storage::provider;
+
+CreateFolderHandler::CreateFolderHandler(shared_ptr<DavProvider> const& provider,
+                                         string const& parent_id,
+                                         string const& name,
+                                         Context const& ctx)
+    : provider_(provider), item_id_(make_child_id(parent_id, name, true)),
+      context_(ctx)
+{
+    QUrl const base_url = provider->base_url(ctx);
+    QNetworkRequest request(id_to_url(item_id_, base_url));
+    reply_.reset(provider->send_request(request, QByteArrayLiteral("MKCOL"),
+                                        nullptr, ctx));
+    connect(reply_.get(), &QNetworkReply::finished,
+            this, &CreateFolderHandler::onFinished);
+}
+
+CreateFolderHandler::~CreateFolderHandler() = default;
+
+boost::future<Item> CreateFolderHandler::get_future()
+{
+    return promise_.get_future();
+}
+
+void CreateFolderHandler::onFinished()
+{
+    auto status = reply_->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+
+    if (status != 201)
+    {
+        promise_.set_exception(
+            translate_http_error(reply_.get(), QByteArray(), item_id_));
+        deleteLater();
+        return;
+    }
+
+    metadata_.reset(
+        new RetrieveMetadataHandler(
+            provider_, item_id_, context_,
+            [this](Item const& item, boost::exception_ptr const& error) {
+                if (error)
+                {
+                    promise_.set_exception(error);
+                }
+                else
+                {
+                    promise_.set_value(item);
+                }
+                deleteLater();
+            }));
+}

=== added file 'src/CreateFolderHandler.h'
--- src/CreateFolderHandler.h	1970-01-01 00:00:00 +0000
+++ src/CreateFolderHandler.h	2016-11-25 05:01:23 +0000
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: James Henstridge <[e-mail]>
+ */
+
+#pragma once
+
+#include <QBuffer>
+#include <QObject>
+#include <QNetworkReply>
+#include <unity/storage/provider/ProviderBase.h>
+
+#include <memory>
+
+class DavProvider;
+class RetrieveMetadataHandler;
+
+class CreateFolderHandler : public QObject {
+    Q_OBJECT
+public:
+    CreateFolderHandler(std::shared_ptr<DavProvider> const& provider,
+                        std::string const& parent_id, std::string const& name,
+                        unity::storage::provider::Context const& ctx);
+    ~CreateFolderHandler();
+
+    boost::future<unity::storage::provider::Item> get_future();
+
+private Q_SLOTS:
+    void onFinished();
+
+private:
+    boost::promise<unity::storage::provider::Item> promise_;
+
+    std::shared_ptr<DavProvider> const provider_;
+    std::string const item_id_;
+    unity::storage::provider::Context const context_;
+
+    std::unique_ptr<QNetworkReply> reply_;
+    std::unique_ptr<RetrieveMetadataHandler> metadata_;
+};

=== added file 'src/DavDownloadJob.cpp'
--- src/DavDownloadJob.cpp	1970-01-01 00:00:00 +0000
+++ src/DavDownloadJob.cpp	2016-11-25 05:01:23 +0000
@@ -0,0 +1,215 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: James Henstridge <[e-mail]>
+ */
+
+#include "DavDownloadJob.h"
+#include "DavProvider.h"
+#include "RetrieveMetadataHandler.h"
+#include "item_id.h"
+#include "http_error.h"
+
+#include <unity/storage/provider/Exceptions.h>
+
+#include <unistd.h>
+#include <cassert>
+#include <cstdint>
+#include <string>
+
+using namespace std;
+using namespace unity::storage::provider;
+using unity::storage::ItemType;
+
+namespace
+{
+
+string make_download_id()
+{
+    static int counter = 0;
+    return to_string(counter++);
+}
+
+constexpr int CHUNK_SIZE = 64 * 1024;
+
+}
+
+DavDownloadJob::DavDownloadJob(shared_ptr<DavProvider> const& provider,
+                               string const& item_id,
+                               string const& match_etag,
+                               Context const& ctx)
+    : QObject(), DownloadJob(make_download_id()), provider_(provider),
+      item_id_(item_id)
+{
+    QUrl base_url = provider->base_url(ctx);
+    QNetworkRequest request(id_to_url(item_id, base_url));
+    if (!match_etag.empty())
+    {
+        request.setRawHeader(QByteArrayLiteral("If-Match"),
+                             QByteArray::fromStdString(match_etag));
+    }
+
+    reply_.reset(provider->send_request(
+        request, QByteArrayLiteral("GET"), nullptr, ctx));
+    assert(reply_.get() != nullptr);
+    reply_->setReadBufferSize(CHUNK_SIZE);
+    connect(reply_.get(), &QNetworkReply::finished,
+            this, &DavDownloadJob::onReplyFinished);
+    connect(reply_.get(), &QIODevice::readyRead,
+            this, &DavDownloadJob::onReplyReadyRead);
+    connect(reply_.get(), &QIODevice::readChannelFinished,
+            this, &DavDownloadJob::onReplyReadChannelFinished);
+    writer_.setSocketDescriptor(
+        dup(write_socket()), QLocalSocket::ConnectedState, QIODevice::WriteOnly);
+    connect(&writer_, &QIODevice::bytesWritten,
+            this, &DavDownloadJob::onSocketBytesWritten);
+}
+
+DavDownloadJob::~DavDownloadJob() = default;
+
+void DavDownloadJob::onReplyFinished()
+{
+    if (!seen_header_ || is_error_)
+    {
+        try
+        {
+            boost::rethrow_exception(
+                translate_http_error(reply_.get(), error_body_, item_id_));
+        }
+        catch (...)
+        {
+            handle_error(std::current_exception());
+        }
+    }
+}
+
+void DavDownloadJob::onReplyReadyRead()
+{
+    if (!seen_header_)
+    {
+        seen_header_ = true;
+        auto status = reply_->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+        if (status != 200)
+        {
+            is_error_ = true;
+        }
+    }
+
+    if (is_error_)
+    {
+        if (error_body_.size() < MAX_ERROR_BODY_LENGTH)
+        {
+            error_body_.append(reply_->readAll());
+        }
+        else
+        {
+            reply_->close();
+        }
+    }
+    else
+    {
+        maybe_send_chunk();
+    }
+}
+
+void DavDownloadJob::onReplyReadChannelFinished()
+{
+    if (is_error_)
+    {
+        return;
+    }
+
+    read_channel_finished_ = true;
+    maybe_send_chunk();
+}
+
+void DavDownloadJob::onSocketBytesWritten(int64_t bytes)
+{
+    if (is_error_)
+    {
+        return;
+    }
+
+    bytes_written_ += bytes;
+    maybe_send_chunk();
+}
+
+void DavDownloadJob::maybe_send_chunk()
+{
+    assert(bytes_written_ <= bytes_read_);
+    // If there are outstanding writes, do nothing.
+    if (bytes_written_ < bytes_read_)
+    {
+        return;
+    }
+    // If there are no bytes available, return.
+    if (reply_->bytesAvailable() == 0)
+    {
+        // If we've reached the end of the input, and all data has been
+        // written out, signal completion.
+        if (read_channel_finished_ && bytes_written_ == bytes_read_)
+        {
+            writer_.close();
+            report_complete();
+        }
+        return;
+    }
+
+    char buffer[CHUNK_SIZE];
+    int n_read = reply_->read(buffer, CHUNK_SIZE);
+    if (n_read < 0)
+    {
+        handle_error(RemoteCommsException("Failed to read from server: " +
+                                          reply_->errorString().toStdString()));
+        return;
+    }
+    bytes_read_ += n_read;
+
+    int n_written = writer_.write(buffer, n_read);
+    if (n_written < 0)
+    {
+        handle_error(ResourceException(
+                         "Error writing to socket: "
+                         + writer_.errorString().toStdString(), 0));
+        return;
+    }
+}
+
+void DavDownloadJob::handle_error(StorageException const& exc)
+{
+    handle_error(std::make_exception_ptr(exc));
+}
+
+void DavDownloadJob::handle_error(std::exception_ptr ep)
+{
+    is_error_ = true;
+    reply_->close();
+    writer_.close();
+    report_error(ep);
+}
+
+
+boost::future<void> DavDownloadJob::cancel()
+{
+    reply_->abort();
+    writer_.close();
+    return boost::make_ready_future();
+}
+
+boost::future<void> DavDownloadJob::finish()
+{
+    return boost::make_exceptional_future<void>(
+        LogicException("finish called before all data sent"));
+}

=== added file 'src/DavDownloadJob.h'
--- src/DavDownloadJob.h	1970-01-01 00:00:00 +0000
+++ src/DavDownloadJob.h	2016-11-25 05:01:23 +0000
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: James Henstridge <[e-mail]>
+ */
+
+#pragma once
+
+#include <QByteArray>
+#include <QLocalSocket>
+#include <QNetworkReply>
+#include <QObject>
+#include <QUrl>
+#include <unity/storage/provider/Exceptions.h>
+#include <unity/storage/provider/ProviderBase.h>
+#include <unity/storage/provider/DownloadJob.h>
+
+#include <cstdint>
+#include <memory>
+#include <string>
+
+class DavProvider;
+
+class DavDownloadJob : public QObject, public unity::storage::provider::DownloadJob
+{
+    Q_OBJECT
+public:
+    DavDownloadJob(std::shared_ptr<DavProvider> const& provider,
+                   std::string const& item_id, std::string const& match_etag,
+                   unity::storage::provider::Context const& ctx);
+    ~DavDownloadJob();
+
+    boost::future<void> cancel() override;
+    boost::future<void> finish() override;
+
+private Q_SLOTS:
+    void onReplyFinished();
+    void onReplyReadyRead();
+    void onReplyReadChannelFinished();
+
+    void onSocketBytesWritten(int64_t bytes);
+
+private:
+    void maybe_send_chunk();
+    void handle_error(unity::storage::provider::StorageException const& exc);
+    void handle_error(std::exception_ptr ep);
+
+    std::shared_ptr<DavProvider> const provider_;
+    std::string const item_id_;
+    QLocalSocket writer_;
+    std::unique_ptr<QNetworkReply> reply_;
+
+    bool seen_header_ = false;
+    bool read_channel_finished_ = false;
+    int64_t bytes_read_ = 0;
+    int64_t bytes_written_ = 0;
+
+    bool is_error_ = false;
+    QByteArray error_body_;
+};

=== modified file 'src/DavProvider.cpp'
--- src/DavProvider.cpp	2016-09-22 06:40:07 +0000
+++ src/DavProvider.cpp	2016-11-25 05:01:23 +0000
@@ -1,12 +1,46 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: James Henstridge <[e-mail]>
+ */
+
 #include "DavProvider.h"
+#include "MultiStatusParser.h"
 #include "RootsHandler.h"
+#include "ListHandler.h"
+#include "LookupHandler.h"
+#include "MetadataHandler.h"
+#include "DavDownloadJob.h"
+#include "DavUploadJob.h"
+#include "CreateFolderHandler.h"
+#include "DeleteHandler.h"
+#include "CopyMoveHandler.h"
+#include "item_id.h"
 
+#include <QDateTime>
+#include <QDebug>
 #include <QNetworkAccessManager>
 #include <QNetworkReply>
 #include <QNetworkRequest>
+#include <unity/storage/common.h>
+#include <unity/storage/provider/Exceptions.h>
 
 using namespace std;
 using namespace unity::storage::provider;
+using namespace unity::storage::metadata;
+using unity::storage::ItemType;
 
 DavProvider::DavProvider()
     : network_(new QNetworkAccessManager)
@@ -15,62 +49,198 @@
 
 DavProvider::~DavProvider() = default;
 
-boost::future<ItemList> DavProvider::roots(Context const& ctx)
-{
-    auto handler = new RootsHandler(*this, ctx);
+std::shared_ptr<DavProvider> DavProvider::shared_from_this()
+{
+    return static_pointer_cast<DavProvider>(ProviderBase::shared_from_this());
+}
+
+boost::future<ItemList> DavProvider::roots(
+    vector<string> const& metadata_keys, Context const& ctx)
+{
+    Q_UNUSED(metadata_keys);
+    auto handler = new RootsHandler(shared_from_this(), ctx);
     return handler->get_future();
 }
 
 boost::future<tuple<ItemList,string>> DavProvider::list(
-    string const& item_id, string const& page_token, Context const& ctx)
+    string const& item_id, string const& page_token,
+    vector<string> const& metadata_keys, Context const& ctx)
 {
+    Q_UNUSED(metadata_keys);
+    if (!page_token.empty())
+    {
+        throw InvalidArgumentException("Invalid paging token: " + page_token);
+    }
+    auto handler = new ListHandler(shared_from_this(), item_id, ctx);
+    return handler->get_future();
 }
 
 boost::future<ItemList> DavProvider::lookup(
-    string const& parent_id, string const& name, Context const& ctx)
+    string const& parent_id, string const& name,
+    vector<string> const& metadata_keys, Context const& ctx)
 {
+    Q_UNUSED(metadata_keys);
+    string item_id = make_child_id(parent_id, name);
+    auto handler = new LookupHandler(shared_from_this(), item_id, ctx);
+    return handler->get_future();
 }
 
 boost::future<Item> DavProvider::metadata(
-    string const& item_id, Context const& ctx)
+    string const& item_id, vector<string> const& metadata_keys,
+    Context const& ctx)
 {
+    Q_UNUSED(metadata_keys);
+    auto handler = new MetadataHandler(shared_from_this(), item_id, ctx);
+    return handler->get_future();
 }
 
 boost::future<Item> DavProvider::create_folder(
-    string const& parent_id, string const& name, Context const& ctx)
+    string const& parent_id, string const& name,
+    vector<string> const& metadata_keys, Context const& ctx)
 {
+    Q_UNUSED(metadata_keys);
+    auto handler = new CreateFolderHandler(
+        shared_from_this(), parent_id, name, ctx);
+    return handler->get_future();
 }
 
 boost::future<unique_ptr<UploadJob>> DavProvider::create_file(
     string const& parent_id, string const& name, int64_t size,
-    string const& content_type, bool allow_overwrite, Context const& ctx)
+    string const& content_type, bool allow_overwrite,
+    vector<string> const& metadata_keys, Context const& ctx)
 {
+    Q_UNUSED(metadata_keys);
+    string item_id = make_child_id(parent_id, name);
+    boost::promise<unique_ptr<UploadJob>> p;
+    p.set_value(unique_ptr<UploadJob>(new DavUploadJob(
+        shared_from_this(), item_id, size, content_type, allow_overwrite,
+        string(), ctx)));
+    return p.get_future();
 }
 
 boost::future<unique_ptr<UploadJob>> DavProvider::update(
     string const& item_id, int64_t size, string const& old_etag,
-    Context const& ctx)
+    vector<string> const& metadata_keys, Context const& ctx)
 {
+    Q_UNUSED(metadata_keys);
+    boost::promise<unique_ptr<UploadJob>> p;
+    p.set_value(unique_ptr<UploadJob>(new DavUploadJob(
+        shared_from_this(), item_id, size, string(), true, old_etag, ctx)));
+    return p.get_future();
 }
 
 boost::future<unique_ptr<DownloadJob>> DavProvider::download(
-    string const& item_id, Context const& ctx)
+    string const& item_id, string const& match_etag, Context const& ctx)
 {
+    boost::promise<unique_ptr<DownloadJob>> p;
+    p.set_value(unique_ptr<DownloadJob>(new DavDownloadJob(
+        shared_from_this(), item_id, match_etag, ctx)));
+    return p.get_future();
 }
 
 boost::future<void> DavProvider::delete_item(
     string const& item_id, Context const& ctx)
 {
+    auto handler = new DeleteHandler(shared_from_this(), item_id, ctx);
+    return handler->get_future();
 }
 
 boost::future<Item> DavProvider::move(
     string const& item_id, string const& new_parent_id, string const& new_name,
-    Context const& ctx)
+    vector<string> const& metadata_keys, Context const& ctx)
 {
+    Q_UNUSED(metadata_keys);
+    auto handler = new CopyMoveHandler(
+        shared_from_this(), item_id, new_parent_id, new_name, false, ctx);
+    return handler->get_future();
 }
 
 boost::future<Item> DavProvider::copy(
     string const& item_id, string const& new_parent_id, string const& new_name,
-    Context const& ctx)
-{
+    vector<string> const& metadata_keys, Context const& ctx)
+{
+    Q_UNUSED(metadata_keys);
+    auto handler = new CopyMoveHandler(
+        shared_from_this(), item_id, new_parent_id, new_name, true, ctx);
+    return handler->get_future();
+}
+
+Item DavProvider::make_item(QUrl const& href, QUrl const& base_url,
+                            vector<MultiStatusProperty> const& properties) const
+{
+    Item item;
+    item.item_id = url_to_id(href, base_url);
+
+    QByteArray path = href.path(QUrl::FullyEncoded |
+                                QUrl::StripTrailingSlash).toUtf8();
+    int pos = path.lastIndexOf('/');
+    assert(pos >= 0);
+    try
+    {
+        item.parent_ids.emplace_back(url_to_id(
+            href.resolved(QUrl::fromEncoded(path.mid(0, pos+1),
+                                            QUrl::StrictMode)), base_url));
+    }
+    catch (RemoteCommsException const&)
+    {
+        // Path is outside of base URL: don't expose.
+    }
+
+    item.name = QUrl::fromPercentEncoding(path.mid(pos+1)).toStdString();
+    item.type = ItemType::file;
+
+    for (const auto& prop : properties)
+    {
+        if (prop.status != 200)
+        {
+            // Don't warn about "404 Not Found" properties
+            if (prop.status != 404)
+            {
+                qWarning() << "Got status" << prop.status << "for property"
+                           << prop.ns << prop.name;
+            }
+            continue;
+        }
+        if (prop.ns == "DAV:")
+        {
+            if (prop.name == "resourcetype")
+            {
+                if (prop.value == "DAV:collection") {
+                    item.type = ItemType::folder;
+                }
+            }
+            if (prop.name == "getetag")
+            {
+                item.etag = prop.value.toStdString();
+            }
+            else if (prop.name == "getcontentlength")
+            {
+                item.metadata[SIZE_IN_BYTES] = static_cast<int64_t>(prop.value.toLongLong());
+            }
+            else if (prop.name == "creationdate")
+            {
+                auto date = QDateTime::fromString(prop.value, Qt::RFC2822Date);
+                if (date.isValid())
+                {
+                    item.metadata[CREATION_TIME] = date.toString(Qt::ISODate).toStdString();
+                }
+            }
+            else if (prop.name == "getlastmodified")
+            {
+                auto date = QDateTime::fromString(prop.value, Qt::RFC2822Date);
+                if (date.isValid())
+                {
+                    item.metadata[LAST_MODIFIED_TIME] = date.toString(Qt::ISODate).toStdString();
+                }
+            }
+        }
+    }
+
+    if (href == base_url)
+    {
+        item.type = ItemType::root;
+        item.name = "Root";
+        item.parent_ids.clear();
+    }
+    return item;
 }

=== modified file 'src/DavProvider.h'
--- src/DavProvider.h	2016-09-22 03:36:22 +0000
+++ src/DavProvider.h	2016-11-25 05:01:23 +0000
@@ -1,3 +1,21 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: James Henstridge <[e-mail]>
+ */
+
 #pragma once
 
 #include <unity/storage/provider/ProviderBase.h>
@@ -10,6 +28,7 @@
 class QNetworkReply;
 class QNetworkRequest;
 class QUrl;
+struct MultiStatusProperty;
 
 class DavProvider : public unity::storage::provider::ProviderBase
 {
@@ -18,31 +37,39 @@
     virtual ~DavProvider();
 
     boost::future<unity::storage::provider::ItemList> roots(
+        std::vector<std::string> const& metadata_keys,
         unity::storage::provider::Context const& ctx) override;
     boost::future<std::tuple<unity::storage::provider::ItemList,std::string>> list(
         std::string const& item_id, std::string const& page_token,
+        std::vector<std::string> const& metadata_keys,
         unity::storage::provider::Context const& ctx) override;
     boost::future<unity::storage::provider::ItemList> lookup(
         std::string const& parent_id, std::string const& name,
+        std::vector<std::string> const& metadata_keys,
         unity::storage::provider::Context const& ctx) override;
     boost::future<unity::storage::provider::Item> metadata(
         std::string const& item_id,
+        std::vector<std::string> const& metadata_keys,
         unity::storage::provider::Context const& ctx) override;
 
     boost::future<unity::storage::provider::Item> create_folder(
         std::string const& parent_id, std::string const& name,
+        std::vector<std::string> const& metadata_keys,
         unity::storage::provider::Context const& ctx) override;
     boost::future<std::unique_ptr<unity::storage::provider::UploadJob>> create_file(
         std::string const& parent_id, std::string const& name,
         int64_t size, std::string const& content_type, bool allow_overwrite,
+        std::vector<std::string> const& metadata_keys,
         unity::storage::provider::Context const& ctx) override;
     boost::future<std::unique_ptr<unity::storage::provider::UploadJob>> update(
         std::string const& item_id, int64_t size,
         std::string const& old_etag,
+        std::vector<std::string> const& metadata_keys,
         unity::storage::provider::Context const& ctx) override;
 
     boost::future<std::unique_ptr<unity::storage::provider::DownloadJob>> download(
         std::string const& item_id,
+        std::string const& match_etag,
         unity::storage::provider::Context const& ctx) override;
 
     boost::future<void> delete_item(std::string const& item_id,
@@ -50,10 +77,12 @@
     boost::future<unity::storage::provider::Item> move(
         std::string const& item_id, std::string const& new_parent_id,
         std::string const& new_name,
+        std::vector<std::string> const& metadata_keys,
         unity::storage::provider::Context const& ctx) override;
     boost::future<unity::storage::provider::Item> copy(
         std::string const& item_id, std::string const& new_parent_id,
         std::string const& new_name,
+        std::vector<std::string> const& metadata_keys,
         unity::storage::provider::Context const& ctx) override;
 
     virtual QUrl base_url(
@@ -61,7 +90,13 @@
     virtual QNetworkReply *send_request(
         QNetworkRequest& request, QByteArray const& verb, QIODevice* data,
         unity::storage::provider::Context const& ctx) const = 0;
+    virtual unity::storage::provider::Item make_item(
+        QUrl const& href, QUrl const& base_url,
+        std::vector<MultiStatusProperty> const& properties) const;
 
 protected:
     std::unique_ptr<QNetworkAccessManager> const network_;
+
+private:
+    inline std::shared_ptr<DavProvider> shared_from_this();
 };

=== added file 'src/DavUploadJob.cpp'
--- src/DavUploadJob.cpp	1970-01-01 00:00:00 +0000
+++ src/DavUploadJob.cpp	2016-11-25 05:01:23 +0000
@@ -0,0 +1,140 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: James Henstridge <[e-mail]>
+ */
+
+#include "DavUploadJob.h"
+#include "DavProvider.h"
+#include "RetrieveMetadataHandler.h"
+#include "item_id.h"
+#include "http_error.h"
+
+#include <unity/storage/provider/Exceptions.h>
+
+#include <unistd.h>
+#include <cassert>
+#include <cstdint>
+#include <string>
+
+using namespace std;
+using namespace unity::storage::provider;
+using unity::storage::ItemType;
+
+namespace
+{
+
+string make_upload_id()
+{
+    static int counter = 0;
+    return to_string(counter++);
+}
+
+}
+
+DavUploadJob::DavUploadJob(shared_ptr<DavProvider> const& provider,
+                           string const& item_id, int64_t size,
+                           string const& content_type, bool allow_overwrite,
+                           string const& old_etag, Context const& ctx)
+    : QObject(), UploadJob(make_upload_id()), provider_(provider),
+      item_id_(item_id), base_url_(provider->base_url(ctx)), size_(size),
+      context_(ctx)
+{
+    QNetworkRequest request(id_to_url(item_id, base_url_));
+    if (!content_type.empty())
+    {
+        request.setHeader(QNetworkRequest::ContentTypeHeader,
+                          QByteArray::fromStdString(content_type));
+    }
+    if (!allow_overwrite)
+    {
+        request.setRawHeader(QByteArrayLiteral("If-None-Match"),
+                             QByteArrayLiteral("*"));
+    }
+    if (!old_etag.empty())
+    {
+        request.setRawHeader(QByteArrayLiteral("If-Match"),
+                             QByteArray::fromStdString(old_etag));
+    }
+    request.setHeader(QNetworkRequest::ContentLengthHeader, QVariant::fromValue(size));
+    request.setAttribute(QNetworkRequest::DoNotBufferUploadDataAttribute, true);
+
+    reader_.setSocketDescriptor(
+        dup(read_socket()), QLocalSocket::ConnectedState, QIODevice::ReadOnly);
+    reply_.reset(provider->send_request(
+        request, QByteArrayLiteral("PUT"), &reader_, ctx));
+    assert(reply_.get() != nullptr);
+    connect(reply_.get(), &QNetworkReply::finished,
+            this, &DavUploadJob::onReplyFinished);
+}
+
+DavUploadJob::~DavUploadJob() = default;
+
+void DavUploadJob::onReplyFinished()
+{
+    if (promise_set_)
+    {
+        return;
+    }
+    auto status = reply_->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+    // Is this a success status code?
+    if (status / 100 != 2)
+    {
+        promise_.set_exception(
+            translate_http_error(reply_.get(), QByteArray(), item_id_));
+        promise_set_ = true;
+        return;
+    }
+    // Queue up a PROPFIND request to retrieve the metadata for the upload.
+    metadata_.reset(
+        new RetrieveMetadataHandler(
+            provider_, item_id_, context_,
+            [this](Item const& item, boost::exception_ptr const& error) {
+                if (promise_set_)
+                {
+                    return;
+                }
+                if (error)
+                {
+                    promise_.set_exception(error);
+                }
+                else
+                {
+                    promise_.set_value(item);
+                }
+                promise_set_ = true;
+            }));
+}
+
+boost::future<void> DavUploadJob::cancel()
+{
+    if (!promise_set_)
+    {
+        if (metadata_)
+        {
+            metadata_->abort();
+        }
+        else
+        {
+            reply_->abort();
+        }
+    }
+    return boost::make_ready_future();
+}
+
+boost::future<Item> DavUploadJob::finish()
+{
+    return promise_.get_future();
+}

=== added file 'src/DavUploadJob.h'
--- src/DavUploadJob.h	1970-01-01 00:00:00 +0000
+++ src/DavUploadJob.h	2016-11-25 05:01:23 +0000
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: James Henstridge <[e-mail]>
+ */
+
+#pragma once
+
+#include <QLocalSocket>
+#include <QNetworkReply>
+#include <QObject>
+#include <QUrl>
+#include <unity/storage/provider/ProviderBase.h>
+#include <unity/storage/provider/UploadJob.h>
+
+#include <cstdint>
+#include <memory>
+#include <string>
+
+class DavProvider;
+class RetrieveMetadataHandler;
+
+class DavUploadJob : public QObject, public unity::storage::provider::UploadJob
+{
+    Q_OBJECT
+public:
+    DavUploadJob(std::shared_ptr<DavProvider> const& provider,
+                 std::string const& item_id, int64_t size,
+                 std::string const& content_type, bool allow_overwrite,
+                 std::string const& old_etag,
+                 unity::storage::provider::Context const& ctx);
+    ~DavUploadJob();
+
+    boost::future<void> cancel() override;
+    boost::future<unity::storage::provider::Item> finish() override;
+
+private Q_SLOTS:
+    void onReplyFinished();
+
+private:
+    std::shared_ptr<DavProvider> const provider_;
+    std::string const item_id_;
+    QUrl const base_url_;
+    int64_t const size_;
+    unity::storage::provider::Context const context_;
+    QLocalSocket reader_;
+    std::unique_ptr<QNetworkReply> reply_;
+
+    std::unique_ptr<RetrieveMetadataHandler> metadata_;
+
+    bool promise_set_ = false;
+    boost::promise<unity::storage::provider::Item> promise_;
+};

=== added file 'src/DeleteHandler.cpp'
--- src/DeleteHandler.cpp	1970-01-01 00:00:00 +0000
+++ src/DeleteHandler.cpp	2016-11-25 05:01:23 +0000
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: James Henstridge <[e-mail]>
+ */
+
+#include "DeleteHandler.h"
+#include "DavProvider.h"
+#include "item_id.h"
+#include "http_error.h"
+
+using namespace std;
+using namespace unity::storage::provider;
+
+DeleteHandler::DeleteHandler(shared_ptr<DavProvider> const& provider,
+                             string const& item_id,
+                             Context const& ctx)
+    : provider_(provider), item_id_(item_id)
+{
+    QUrl const base_url = provider->base_url(ctx);
+    QNetworkRequest request(id_to_url(item_id_, base_url));
+    reply_.reset(provider->send_request(request, QByteArrayLiteral("DELETE"),
+                                        nullptr, ctx));
+    connect(reply_.get(), &QNetworkReply::finished,
+            this, &DeleteHandler::onFinished);
+}
+
+DeleteHandler::~DeleteHandler() = default;
+
+boost::future<void> DeleteHandler::get_future()
+{
+    return promise_.get_future();
+}
+
+void DeleteHandler::onFinished()
+{
+    auto status = reply_->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+
+    if (status / 100 == 2)
+    {
+        promise_.set_value();
+    }
+    else
+    {
+        promise_.set_exception(
+            translate_http_error(reply_.get(), QByteArray(), item_id_));
+    }
+
+    deleteLater();
+}

=== added file 'src/DeleteHandler.h'
--- src/DeleteHandler.h	1970-01-01 00:00:00 +0000
+++ src/DeleteHandler.h	2016-11-25 05:01:23 +0000
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: James Henstridge <[e-mail]>
+ */
+
+#pragma once
+
+#include <QBuffer>
+#include <QObject>
+#include <QNetworkReply>
+#include <unity/storage/provider/ProviderBase.h>
+
+#include <memory>
+
+class DavProvider;
+
+class DeleteHandler : public QObject {
+    Q_OBJECT
+public:
+    DeleteHandler(std::shared_ptr<DavProvider> const& provider, std::string const& item_id,
+                  unity::storage::provider::Context const& ctx);
+    ~DeleteHandler();
+
+    boost::future<void> get_future();
+
+private Q_SLOTS:
+    void onFinished();
+
+private:
+    boost::promise<void> promise_;
+
+    std::shared_ptr<DavProvider> const provider_;
+    std::string const item_id_;
+
+    std::unique_ptr<QNetworkReply> reply_;
+};

=== added file 'src/ListHandler.cpp'
--- src/ListHandler.cpp	1970-01-01 00:00:00 +0000
+++ src/ListHandler.cpp	2016-11-25 05:01:23 +0000
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: James Henstridge <[e-mail]>
+ */
+
+#include "ListHandler.h"
+
+#include <unity/storage/provider/Exceptions.h>
+
+#include <algorithm>
+#include <cassert>
+
+using namespace std;
+using namespace unity::storage::provider;
+
+ListHandler::ListHandler(std::shared_ptr<DavProvider> const& provider,
+                         string const& parent_id, Context const& ctx)
+    : PropFindHandler(provider, parent_id, 1, ctx)
+{
+}
+
+ListHandler::~ListHandler() = default;
+
+boost::future<tuple<ItemList,string>> ListHandler::get_future()
+{
+    return promise_.get_future();
+}
+
+void ListHandler::finish()
+{
+    deleteLater();
+
+    if (error_)
+    {
+        promise_.set_exception(error_);
+        return;
+    }
+    // A "Depth: 1" PROPFIND will also return data for the parent URL
+    // itself, so remove it from the list.
+    items_.erase(remove_if(items_.begin(), items_.end(),
+                           [&](Item const& item) -> bool {
+                               return item.item_id == item_id_;
+                           }), items_.end());
+
+    promise_.set_value(make_tuple(move(items_), string()));
+}

=== added file 'src/ListHandler.h'
--- src/ListHandler.h	1970-01-01 00:00:00 +0000
+++ src/ListHandler.h	2016-11-25 05:01:23 +0000
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: James Henstridge <[e-mail]>
+ */
+
+#pragma once
+
+#include <QObject>
+
+#include <memory>
+#include <tuple>
+
+#include "PropFindHandler.h"
+
+class ListHandler : public PropFindHandler {
+    Q_OBJECT
+public:
+    ListHandler(std::shared_ptr<DavProvider> const& provider,
+                std::string const& parent_id,
+                unity::storage::provider::Context const& ctx);
+    ~ListHandler();
+
+    boost::future<std::tuple<unity::storage::provider::ItemList,std::string>> get_future();
+
+private:
+    boost::promise<std::tuple<unity::storage::provider::ItemList,std::string>> promise_;
+
+protected:
+    void finish() override;
+};

=== added file 'src/LookupHandler.cpp'
--- src/LookupHandler.cpp	1970-01-01 00:00:00 +0000
+++ src/LookupHandler.cpp	2016-11-25 05:01:23 +0000
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: James Henstridge <[e-mail]>
+ */
+
+#include "LookupHandler.h"
+
+#include <cassert>
+
+using namespace std;
+using namespace unity::storage::provider;
+
+LookupHandler::LookupHandler(std::shared_ptr<DavProvider> const& provider,
+                             string const& item_id, Context const& ctx)
+    : PropFindHandler(provider, item_id, 0, ctx)
+{
+}
+
+LookupHandler::~LookupHandler() = default;
+
+boost::future<ItemList> LookupHandler::get_future()
+{
+    return promise_.get_future();
+}
+
+void LookupHandler::finish()
+{
+    if (error_)
+    {
+        promise_.set_exception(error_);
+        return;
+    }
+    // Perform some sanity checks on the result
+    if (items_.size() != 1)
+    {
+        promise_.set_exception(RemoteCommsException("Unexpectedly received " + to_string(items_.size()) + " items from PROPFIND request"));
+        return;
+    }
+
+    promise_.set_value(move(items_));
+}

=== added file 'src/LookupHandler.h'
--- src/LookupHandler.h	1970-01-01 00:00:00 +0000
+++ src/LookupHandler.h	2016-11-25 05:01:23 +0000
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: James Henstridge <[e-mail]>
+ */
+
+#pragma once
+
+#include <QObject>
+
+#include <memory>
+
+#include "PropFindHandler.h"
+
+class LookupHandler : public PropFindHandler {
+    Q_OBJECT
+public:
+    LookupHandler(std::shared_ptr<DavProvider> const& provider,
+                  std::string const& item_id,
+                  unity::storage::provider::Context const& ctx);
+    ~LookupHandler();
+
+    boost::future<unity::storage::provider::ItemList> get_future();
+
+private:
+    boost::promise<unity::storage::provider::ItemList> promise_;
+
+protected:
+    void finish() override;
+};

=== added file 'src/MetadataHandler.cpp'
--- src/MetadataHandler.cpp	1970-01-01 00:00:00 +0000
+++ src/MetadataHandler.cpp	2016-11-25 05:01:23 +0000
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: James Henstridge <[e-mail]>
+ */
+
+#include "MetadataHandler.h"
+
+#include <cassert>
+
+using namespace std;
+using namespace unity::storage::provider;
+
+MetadataHandler::MetadataHandler(shared_ptr<DavProvider> const& provider,
+                                 string const& item_id, Context const& ctx)
+    : PropFindHandler(provider, item_id, 0, ctx)
+{
+}
+
+MetadataHandler::~MetadataHandler() = default;
+
+boost::future<Item> MetadataHandler::get_future()
+{
+    return promise_.get_future();
+}
+
+void MetadataHandler::finish()
+{
+    deleteLater();
+
+    if (error_)
+    {
+        promise_.set_exception(error_);
+        return;
+    }
+    // Perform some sanity checks on the result
+    if (items_.size() != 1)
+    {
+        promise_.set_exception(RemoteCommsException("Unexpectedly received " + to_string(items_.size()) + " items from PROPFIND request"));
+        return;
+    }
+    if (items_[0].item_id != item_id_)
+    {
+        promise_.set_exception(RemoteCommsException("PROPFIND request returned data about the wrong item"));
+        return;
+    }
+
+    promise_.set_value(move(items_[0]));
+}

=== added file 'src/MetadataHandler.h'
--- src/MetadataHandler.h	1970-01-01 00:00:00 +0000
+++ src/MetadataHandler.h	2016-11-25 05:01:23 +0000
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: James Henstridge <[e-mail]>
+ */
+
+#pragma once
+
+#include <QObject>
+
+#include <memory>
+
+#include "PropFindHandler.h"
+
+class MetadataHandler : public PropFindHandler {
+    Q_OBJECT
+public:
+    MetadataHandler(std::shared_ptr<DavProvider> const& provider,
+                    std::string const& item_id,
+                    unity::storage::provider::Context const& ctx);
+    ~MetadataHandler();
+
+    boost::future<unity::storage::provider::Item> get_future();
+
+private:
+    boost::promise<unity::storage::provider::Item> promise_;
+
+protected:
+    void finish() override;
+};

=== modified file 'src/MultiStatusParser.cpp'
--- src/MultiStatusParser.cpp	2016-09-20 01:50:46 +0000
+++ src/MultiStatusParser.cpp	2016-11-25 05:01:23 +0000
@@ -1,3 +1,21 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: James Henstridge <[e-mail]>
+ */
+
 #include "MultiStatusParser.h"
 
 #include <QDebug>
@@ -127,10 +145,16 @@
     {
         return;
     }
-    // Perform one final call to parseContinue() to signal end of file
     if (started_)
     {
-        reader_.parseContinue();
+        // Drain the remaining data from the input channel
+        while (reader_.parseContinue())
+        {
+            if (handler_->atEnd())
+            {
+                break;
+            }
+        }
     }
     if (error_string_.isEmpty() && !handler_->atEnd())
     {
@@ -146,7 +170,6 @@
     return true;
 }
 
-
 bool MultiStatusParser::Handler::startElement(QString const& namespace_uri,
                                               QString const& local_name,
                                               QString const& qname,
@@ -297,6 +320,7 @@
         break;
     case ParseState::multistatus:
         state_ = ParseState::start;
+        at_end_ = true;
         break;
     case ParseState::response:
         Q_EMIT parser_->response(current_href_, current_properties_,
@@ -318,7 +342,7 @@
         for (auto& prop : current_propstat_)
         {
             prop.status = current_propstat_status_;
-            current_properties_.emplace_back(std::move(prop));
+            current_properties_.emplace_back(move(prop));
         }
         current_propstat_.clear();
         state_ = ParseState::response;

=== modified file 'src/MultiStatusParser.h'
--- src/MultiStatusParser.h	2016-09-20 01:50:46 +0000
+++ src/MultiStatusParser.h	2016-11-25 05:01:23 +0000
@@ -1,3 +1,21 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: James Henstridge <[e-mail]>
+ */
+
 #pragma once
 
 #include <QIODevice>

=== modified file 'src/OwncloudProvider.cpp'
--- src/OwncloudProvider.cpp	2016-09-22 06:40:07 +0000
+++ src/OwncloudProvider.cpp	2016-11-25 05:01:23 +0000
@@ -1,3 +1,21 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: James Henstridge <[e-mail]>
+ */
+
 #include "OwncloudProvider.h"
 
 #include <QNetworkAccessManager>
@@ -15,8 +33,8 @@
 
 QUrl OwncloudProvider::base_url(Context const& ctx) const
 {
-    Q_UNUSED(ctx);
-    return QUrl("http://localhost:8080/");
+    const auto& creds = boost::get<PasswordCredentials>(ctx.credentials);
+    return QUrl(QStringLiteral("http://localhost:8888/owncloud/remote.php/dav/files/%1/").arg(QString::fromStdString(creds.username)));
 }
 
 QNetworkReply *OwncloudProvider::send_request(
@@ -25,9 +43,13 @@
 {
     Q_UNUSED(ctx);
 
-    const auto credentials = QByteArrayLiteral("user:pass");
+    const auto& creds = boost::get<PasswordCredentials>(ctx.credentials);
+    const auto credentials = QByteArray::fromStdString(creds.username + ":" +
+                                                       creds.password);
     request.setRawHeader(QByteArrayLiteral("Authorization"),
                          QByteArrayLiteral("Basic ") + credentials.toBase64());
+    printf("Sending request to %s with credentials %s\n",
+           request.url().toEncoded().constData(), credentials.constData());
     QNetworkReply *reply = network_->sendCustomRequest(request, verb, data);
     return reply;
 }

=== modified file 'src/OwncloudProvider.h'
--- src/OwncloudProvider.h	2016-09-22 03:36:22 +0000
+++ src/OwncloudProvider.h	2016-11-25 05:01:23 +0000
@@ -1,3 +1,21 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: James Henstridge <[e-mail]>
+ */
+
 #pragma once
 
 #include "DavProvider.h"

=== renamed file 'src/RootsHandler.cpp' => 'src/PropFindHandler.cpp'
--- src/RootsHandler.cpp	2016-09-27 06:28:45 +0000
+++ src/PropFindHandler.cpp	2016-11-25 05:01:23 +0000
@@ -1,15 +1,29 @@
-#include "RootsHandler.h"
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: James Henstridge <[e-mail]>
+ */
+
+#include "PropFindHandler.h"
 #include "item_id.h"
-
-#include <QDateTime>
-#include <QDebug>
-#include <unity/storage/provider/metadata_keys.h>
+#include "http_error.h"
 
 #include <cassert>
 
 using namespace std;
 using namespace unity::storage::provider;
-using unity::storage::ItemType;
 
 namespace
 {
@@ -26,161 +40,143 @@
 </D:propfind>)");
 }
 
-RootsHandler::RootsHandler(DavProvider const& provider, Context const& ctx)
-    : provider_(provider), base_url_(provider.base_url(ctx))
+PropFindHandler::PropFindHandler(shared_ptr<DavProvider> const& provider,
+                                 string const& item_id, int depth,
+                                 Context const& ctx)
+    : provider_(provider), base_url_(provider->base_url(ctx)), item_id_(item_id)
 {
-    QNetworkRequest request(base_url_);
-    request.setRawHeader(QByteArrayLiteral("Depth"), QByteArrayLiteral("0"));
+    QNetworkRequest request(id_to_url(item_id_, base_url_));
+    request.setRawHeader(QByteArrayLiteral("Depth"), QByteArray::number(depth));
     request.setHeader(QNetworkRequest::ContentTypeHeader,
                       QStringLiteral("application/xml; charset=\"utf-8\""));
     request.setHeader(QNetworkRequest::ContentLengthHeader, PROPFIND_BODY.size());
     request_body_.setData(PROPFIND_BODY);
     request_body_.open(QIODevice::ReadOnly);
 
-    reply_.reset(provider.send_request(request, QByteArrayLiteral("PROPFIND"),
-                                       &request_body_, ctx));
+    reply_.reset(provider->send_request(request, QByteArrayLiteral("PROPFIND"),
+                                        &request_body_, ctx));
     assert(reply_.get() != nullptr);
 
-    connect(reply_.get(), static_cast<void(QNetworkReply::*)(QNetworkReply::NetworkError)>(&QNetworkReply::error),
-            this, &RootsHandler::onError);
     connect(reply_.get(), &QIODevice::readyRead,
-            this, &RootsHandler::onReadyRead);
-}
-
-RootsHandler::~RootsHandler()
-{
-}
-
-boost::future<unity::storage::provider::ItemList> RootsHandler::get_future()
-{
-    return promise_.get_future();
-}
-
-void RootsHandler::sendError(StorageException const& error)
-{
-    if (promise_set_) {
-        return;
-    }
-
-    promise_.set_exception(error);
-    promise_set_ = true;
-
-    deleteLater();
-}
-
-void RootsHandler::sendResponse()
-{
-    if (promise_set_) {
-        return;
-    }
-
-    promise_.set_value(roots_);
-    promise_set_ = true;
-
-    deleteLater();
-}
-
-void RootsHandler::onError(QNetworkReply::NetworkError code)
-{
-    sendError(RemoteCommsException("Error from QNetworkReply: " +
-                                   to_string(code)));
-}
-
-void RootsHandler::onReadyRead()
-{
-    disconnect(reply_.get(), &QIODevice::readyRead,
-               this, &RootsHandler::onReadyRead);
-    auto status = reply_->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
-
-    if (status != 207)
-    {
-        sendError(RemoteCommsException("Expected 207 response, but got " + to_string(status)));
-        return;
-    }
-    parser_.reset(new MultiStatusParser(reply_->request().url(), reply_.get()));
-    connect(parser_.get(), &MultiStatusParser::response,
-            this, &RootsHandler::onParserResponse);
-    connect(parser_.get(), &MultiStatusParser::finished,
-            this, &RootsHandler::onParserFinished);
-}
-
-void RootsHandler::onParserResponse(QUrl const& href, std::vector<MultiStatusProperty> const& properties, int status)
-{
-    if (href != base_url_)
-    {
-        sendError(RemoteCommsException("PROPFIND returned information about a different URL"));
-        return;
-    }
+            this, &PropFindHandler::onReplyReadyRead);
+    connect(reply_.get(), &QNetworkReply::finished,
+            this, &PropFindHandler::onReplyFinished);
+}
+
+PropFindHandler::~PropFindHandler()
+{
+}
+
+void PropFindHandler::abort()
+{
+    if (finished_)
+    {
+        return;
+    }
+    finished_ = true;
+    reply_->abort();
+}
+
+void PropFindHandler::reportError(StorageException const& error)
+{
+    reportError(boost::copy_exception(error));
+}
+
+void PropFindHandler::reportError(boost::exception_ptr const& ep)
+{
+    if (finished_)
+    {
+        return;
+    }
+
+    error_ = ep;
+    finished_ = true;
+    finish();
+}
+
+void PropFindHandler::reportSuccess()
+{
+    if (finished_)
+    {
+        return;
+    }
+
+    finished_ = true;
+    finish();
+}
+
+void PropFindHandler::onReplyReadyRead()
+{
+    if (!seen_headers_)
+    {
+        seen_headers_ = true;
+        auto status = reply_->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+        if (status == 207)
+        {
+            disconnect(reply_.get(), &QIODevice::readyRead,
+                       this, &PropFindHandler::onReplyReadyRead);
+            parser_.reset(new MultiStatusParser(reply_->request().url(), reply_.get()));
+            connect(parser_.get(), &MultiStatusParser::response,
+                    this, &PropFindHandler::onParserResponse);
+            connect(parser_.get(), &MultiStatusParser::finished,
+                    this, &PropFindHandler::onParserFinished);
+        }
+        else
+        {
+            is_error_ = true;
+        }
+    }
+    if (is_error_)
+    {
+        if (error_body_.size() < MAX_ERROR_BODY_LENGTH)
+        {
+            error_body_.append(reply_->readAll());
+        }
+        else
+        {
+            reply_->close();
+        }
+    }
+}
+
+void PropFindHandler::onReplyFinished()
+{
+    if (!seen_headers_ || is_error_)
+    {
+        reportError(translate_http_error(reply_.get(), error_body_, item_id_));
+    }
+}
+
+void PropFindHandler::onParserResponse(QUrl const& href, vector<MultiStatusProperty> const& properties, int status)
+{
     if (status != 0 && status != 200)
     {
-        sendError(RemoteCommsException("Failed to look up properties for root: " + to_string(status)));
+        reportError(RemoteCommsException("PROPFIND for " + href.toEncoded().toStdString() + " gave status " +  to_string(status)));
         return;
     }
     try
     {
-        Item item;
-        item.item_id = url_to_id(href, base_url_);
-        item.name = "Root";
-        item.type = ItemType::root;
-
-        for (const auto& prop : properties)
-        {
-            if (prop.status != 200) {
-                // Don't warn about "404 Not Found" properties
-                if (prop.status != 404) {
-                    qWarning() << "Got status" << prop.status << "for property"
-                               << prop.ns << prop.name;
-                }
-                continue;
-            }
-            if (prop.ns == "DAV:")
-            {
-                if (prop.name == "getetag")
-                {
-                    item.etag = prop.value.toStdString();
-                }
-                else if (prop.name == "getcontentlength")
-                {
-                    item.metadata[SIZE_IN_BYTES] = static_cast<int64_t>(prop.value.toLongLong());
-                }
-                else if (prop.name == "creationdate")
-                {
-                    auto date = QDateTime::fromString(prop.value, Qt::RFC2822Date);
-                    if (date.isValid())
-                    {
-                        item.metadata[CREATION_TIME] = date.toString(Qt::ISODate).toStdString();
-                    }
-                }
-                else if (prop.name == "getlastmodified")
-                {
-                    auto date = QDateTime::fromString(prop.value, Qt::RFC2822Date);
-                    if (date.isValid())
-                    {
-                        item.metadata[LAST_MODIFIED_TIME] = date.toString(Qt::ISODate).toStdString();
-                    }
-                }
-            }
-        }
-        roots_.emplace_back(std::move(item));
+        Item item = provider_->make_item(href, base_url_, properties);
+        items_.emplace_back(move(item));
     }
     catch (StorageException const& error)
     {
-        sendError(error);
+        reportError(error);
     }
     catch (exception const& error)
     {
-        sendError(RemoteCommsException(string("Error creating item: ") + error.what()));
+        reportError(RemoteCommsException(string("Error creating item: ") + error.what()));
     }
 }
 
-void RootsHandler::onParserFinished()
+void PropFindHandler::onParserFinished()
 {
     if (parser_->errorString().isEmpty())
     {
-        sendResponse();
+        reportSuccess();
     }
     else
     {
-        sendError(RemoteCommsException("Error parsing Multi-Status response: " + parser_->errorString().toStdString()));
+        reportError(RemoteCommsException("Error parsing Multi-Status response: " + parser_->errorString().toStdString()));
     }
 }

=== renamed file 'src/RootsHandler.h' => 'src/PropFindHandler.h'
--- src/RootsHandler.h	2016-09-22 03:36:22 +0000
+++ src/PropFindHandler.h	2016-11-25 05:01:23 +0000
@@ -1,3 +1,21 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: James Henstridge <[e-mail]>
+ */
+
 #pragma once
 
 #include <QBuffer>
@@ -10,37 +28,46 @@
 #include "DavProvider.h"
 #include "MultiStatusParser.h"
 
-class RootsHandler : public QObject {
+class PropFindHandler : public QObject {
     Q_OBJECT
 public:
-    RootsHandler(DavProvider const& provider,
-                 unity::storage::provider::Context const& ctx);
-    ~RootsHandler();
-
-    boost::future<unity::storage::provider::ItemList> get_future();
-
-private:
-    void sendError(unity::storage::provider::StorageException const& error);
-    void sendResponse();
+    PropFindHandler(std::shared_ptr<DavProvider> const& provider,
+                    std::string const& item_id, int depth,
+                    unity::storage::provider::Context const& ctx);
+    ~PropFindHandler();
+
+    void abort();
 
 private Q_SLOTS:
     // From QNetworkReply
-    void onError(QNetworkReply::NetworkError code);
-    void onReadyRead();
+    void onReplyReadyRead();
+    void onReplyFinished();
 
     // From MultiStatusParser
     void onParserResponse(QUrl const& href, std::vector<MultiStatusProperty> const& properties, int status);
     void onParserFinished();
 
 private:
-    bool promise_set_ = false;
+    void reportError(unity::storage::provider::StorageException const& error);
+    void reportError(boost::exception_ptr const& ep);
+    void reportSuccess();
+
+    bool seen_headers_ = false;
+    bool is_error_ = false;
+    bool finished_ = false;
     boost::promise<unity::storage::provider::ItemList> promise_;
 
-    DavProvider const& provider_;
+    std::shared_ptr<DavProvider> const provider_;
     QUrl base_url_;
     QBuffer request_body_;
     std::unique_ptr<QNetworkReply> reply_;
-
     std::unique_ptr<MultiStatusParser> parser_;
-    unity::storage::provider::ItemList roots_;
+    QByteArray error_body_;
+
+protected:
+    virtual void finish() = 0;
+
+    std::string const item_id_;
+    unity::storage::provider::ItemList items_;
+    boost::exception_ptr error_;
 };

=== added file 'src/RetrieveMetadataHandler.cpp'
--- src/RetrieveMetadataHandler.cpp	1970-01-01 00:00:00 +0000
+++ src/RetrieveMetadataHandler.cpp	2016-11-25 05:01:23 +0000
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: James Henstridge <[e-mail]>
+ */
+
+#include "RetrieveMetadataHandler.h"
+
+#include <unity/storage/provider/Exceptions.h>
+
+#include <cassert>
+
+using namespace std;
+using namespace unity::storage::provider;
+
+RetrieveMetadataHandler::RetrieveMetadataHandler(shared_ptr<DavProvider> const& provider,
+                                                 string const& item_id,
+                                                 Context const& ctx,
+                                                 Callback callback)
+    : PropFindHandler(provider, item_id, 0, ctx), callback_(callback)
+{
+}
+
+RetrieveMetadataHandler::~RetrieveMetadataHandler() = default;
+
+void RetrieveMetadataHandler::finish()
+{
+    Item item;
+    boost::exception_ptr ex = error_;
+
+    if (items_.size() != 1)
+    {
+        ex = boost::copy_exception(RemoteCommsException("Unexpectedly received " + to_string(items_.size()) + " items from PROPFIND request"));
+    }
+    else
+    {
+        item = items_[0];
+    }
+    callback_(item, ex);
+}

=== added file 'src/RetrieveMetadataHandler.h'
--- src/RetrieveMetadataHandler.h	1970-01-01 00:00:00 +0000
+++ src/RetrieveMetadataHandler.h	2016-11-25 05:01:23 +0000
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: James Henstridge <[e-mail]>
+ */
+
+#pragma once
+
+#include <QObject>
+
+#include <functional>
+#include <memory>
+
+#include "PropFindHandler.h"
+
+class RetrieveMetadataHandler : public PropFindHandler {
+    Q_OBJECT
+public:
+    typedef std::function<void(unity::storage::provider::Item const& item,
+                               boost::exception_ptr const& error)> Callback;
+
+    RetrieveMetadataHandler(std::shared_ptr<DavProvider> const& provider,
+                            std::string const& item_id,
+                            unity::storage::provider::Context const& ctx,
+                            Callback callback);
+    ~RetrieveMetadataHandler();
+
+private:
+    Callback const callback_;
+
+protected:
+    void finish() override;
+};

=== added file 'src/RootsHandler.cpp'
--- src/RootsHandler.cpp	1970-01-01 00:00:00 +0000
+++ src/RootsHandler.cpp	2016-11-25 05:01:23 +0000
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: James Henstridge <[e-mail]>
+ */
+
+#include "RootsHandler.h"
+
+#include <cassert>
+
+using namespace std;
+using namespace unity::storage::provider;
+
+RootsHandler::RootsHandler(shared_ptr<DavProvider> const& provider,
+                           Context const& ctx)
+    : PropFindHandler(provider, ".", 0, ctx)
+{
+}
+
+RootsHandler::~RootsHandler() = default;
+
+boost::future<ItemList> RootsHandler::get_future()
+{
+    return promise_.get_future();
+}
+
+void RootsHandler::finish()
+{
+    deleteLater();
+
+    if (error_)
+    {
+        promise_.set_exception(error_);
+        return;
+    }
+    // Perform some sanity checks on the result
+    if (items_.size() != 1)
+    {
+        promise_.set_exception(RemoteCommsException("Unexpectedly received " + to_string(items_.size()) + " items from PROPFIND request"));
+        return;
+    }
+    if (items_[0].item_id != ".")
+    {
+        promise_.set_exception(RemoteCommsException("PROPFIND request returned data about the wrong item"));
+        return;
+    }
+
+    promise_.set_value(move(items_));
+}

=== added file 'src/RootsHandler.h'
--- src/RootsHandler.h	1970-01-01 00:00:00 +0000
+++ src/RootsHandler.h	2016-11-25 05:01:23 +0000
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: James Henstridge <[e-mail]>
+ */
+
+#pragma once
+
+#include <QObject>
+
+#include <memory>
+
+#include "PropFindHandler.h"
+
+class RootsHandler : public PropFindHandler {
+    Q_OBJECT
+public:
+    RootsHandler(std::shared_ptr<DavProvider> const& provider,
+                 unity::storage::provider::Context const& ctx);
+    ~RootsHandler();
+
+    boost::future<unity::storage::provider::ItemList> get_future();
+
+private:
+    boost::promise<unity::storage::provider::ItemList> promise_;
+
+protected:
+    void finish() override;
+};

=== added file 'src/http_error.cpp'
--- src/http_error.cpp	1970-01-01 00:00:00 +0000
+++ src/http_error.cpp	2016-11-25 05:01:23 +0000
@@ -0,0 +1,181 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: James Henstridge <[e-mail]>
+ */
+
+#include "http_error.h"
+
+#include <QNetworkReply>
+#include <QXmlDefaultHandler>
+#include <QXmlInputSource>
+#include <QXmlSimpleReader>
+#include <unity/storage/provider/Exceptions.h>
+
+#include <cassert>
+
+using namespace std;
+using namespace unity::storage::provider;
+
+namespace {
+
+class ErrorParser : public QXmlDefaultHandler
+{
+public:
+    bool startElement(QString const& namespace_uri, QString const& local_name,
+                      QString const& qname, QXmlAttributes const& attrs) override;
+    bool endElement(QString const& namespace_uri, QString const& local_name,
+                    QString const& qname) override;
+    bool characters(QString const& data) override;
+
+    string exception_;
+    string message_;
+
+private:
+    static QString const SABREDAV_NS;
+
+    QString char_data_;
+};
+
+QString const ErrorParser::SABREDAV_NS("http://sabredav.org/ns");
+
+bool ErrorParser::startElement(QString const& namespace_uri,
+                               QString const& local_name,
+                               QString const& qname,
+                               QXmlAttributes const& attrs)
+{
+    Q_UNUSED(namespace_uri);
+    Q_UNUSED(local_name);
+    Q_UNUSED(qname);
+    Q_UNUSED(attrs);
+
+    char_data_.clear();
+    return true;
+}
+
+bool ErrorParser::endElement(QString const& namespace_uri,
+                             QString const& local_name,
+                             QString const& qname)
+{
+    Q_UNUSED(qname);
+    if (namespace_uri == SABREDAV_NS)
+    {
+        if (local_name == "exception")
+        {
+            exception_ = char_data_.toStdString();
+        }
+        else if (local_name == "message")
+        {
+            message_ = char_data_.toStdString();
+        }
+    }
+    char_data_.clear();
+    return true;
+}
+
+bool ErrorParser::characters(QString const& data)
+{
+    char_data_ += data;
+    return true;
+}
+
+std::string make_message(QNetworkReply *reply,
+                         QByteArray body)
+{
+    if (body.isEmpty())
+    {
+        body = reply->readAll();
+    }
+    auto content_type = reply->header(QNetworkRequest::ContentTypeHeader).toString();
+    int semicolon = content_type.indexOf(';');
+    if (semicolon >= 0)
+    {
+        content_type = content_type.left(semicolon);
+    }
+    if (content_type == "text/plain")
+    {
+        return body.toStdString();
+    }
+    else if (content_type == "application/xml")
+    {
+        ErrorParser parser;
+        QXmlSimpleReader reader;
+        QXmlInputSource source;
+        reader.setContentHandler(&parser);
+        source.setData(body);
+        if (reader.parse(source)) {
+            return parser.exception_ + ": " + parser.message_;
+        }
+    }
+    // Fall back to returning the HTTP status string
+    return reply->attribute(
+        QNetworkRequest::HttpReasonPhraseAttribute).toString().toStdString();
+}
+
+}
+
+boost::exception_ptr translate_http_error(QNetworkReply *reply,
+                                          QByteArray const& body,
+                                          string const& item_id)
+{
+    assert(reply != nullptr);
+    assert(reply->isFinished());
+
+    auto status = reply->attribute(
+        QNetworkRequest::HttpStatusCodeAttribute).toInt();
+    if (status == 0)
+    {
+        return boost::copy_exception(
+            RemoteCommsException(reply->errorString().toStdString()));
+    }
+
+    auto message = make_message(reply, body);
+
+    switch (status)
+    {
+    case 400: // Bad Request
+        return boost::copy_exception(RemoteCommsException(message));
+
+    case 401: // Unauthorised
+        // This should be separate from Forbidden, triggering reauth.
+    case 403: // Forbidden
+    case 451: // Unavailable for Legal Reasons
+        return boost::copy_exception(PermissionException(message));
+
+    case 404: // Not found
+    case 410: // Gone
+        return boost::copy_exception(NotExistsException(message, item_id));
+
+    case 405: // Method Not Allowed
+        // MKCOL on an existing resource results in a 405 error
+        if (reply->request().attribute(QNetworkRequest::CustomVerbAttribute) == "MKCOL")
+        {
+            return boost::copy_exception(ExistsException(message, item_id, "fixme"));
+        }
+        break;
+
+    case 409: // Conflict
+    case 412: // Precondition failed
+        return boost::copy_exception(ConflictException(message));
+
+    case 507: // Insufficient Storage
+        return boost::copy_exception(QuotaException(message));
+
+    default:
+        break;
+    }
+    return boost::copy_exception(
+        UnknownException("HTTP " + to_string(status) + ": " + message));
+}

=== added file 'src/http_error.h'
--- src/http_error.h	1970-01-01 00:00:00 +0000
+++ src/http_error.h	2016-11-25 05:01:23 +0000
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: James Henstridge <[e-mail]>
+ */
+
+#pragma once
+
+#include <boost/thread.hpp>
+
+class QByteArray;
+class QNetworkReply;
+
+static constexpr int MAX_ERROR_BODY_LENGTH = 64 * 1024;
+
+boost::exception_ptr translate_http_error(QNetworkReply *reply,
+                                          QByteArray const& body,
+                                          std::string const& item_id={});

=== modified file 'src/item_id.cpp'
--- src/item_id.cpp	2016-09-18 23:12:40 +0000
+++ src/item_id.cpp	2016-11-25 05:01:23 +0000
@@ -1,3 +1,21 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: James Henstridge <[e-mail]>
+ */
+
 #include "item_id.h"
 
 #include <unity/storage/provider/Exceptions.h>
@@ -44,3 +62,44 @@
     }
     return item_id;
 }
+
+// Construct a possible ID for a named child of a parent ID
+string make_child_id(string const& parent_id, string const& name, bool is_folder)
+{
+    if (name == "." || name == "..")
+    {
+        throw InvalidArgumentException("Invalid name: " + name);
+    }
+
+    string item_id = parent_id;
+    if (item_id == ".")
+    {
+        item_id.clear();
+    }
+    else if (item_id.size() == 0 || item_id[item_id.size()-1] != '/')
+    {
+        item_id += '/';
+    }
+    item_id += QUrl::toPercentEncoding(QString::fromStdString(name)).toStdString();
+
+    if (is_folder)
+    {
+        item_id += '/';
+    }
+
+    return item_id;
+}
+
+bool is_folder(string const& item_id)
+{
+    auto size = item_id.size();
+    if (size == 0)
+    {
+        throw InvalidArgumentException("Invalid blank item ID");
+    }
+    if (size == 1 && item_id[0] == '.')
+    {
+        return true;
+    }
+    return item_id[size-1] == '/';
+}

=== modified file 'src/item_id.h'
--- src/item_id.h	2016-09-18 10:00:45 +0000
+++ src/item_id.h	2016-11-25 05:01:23 +0000
@@ -1,3 +1,21 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: James Henstridge <[e-mail]>
+ */
+
 #pragma once
 
 #include <QUrl>
@@ -6,3 +24,8 @@
 
 QUrl id_to_url(std::string const& item_id, QUrl const& base_url);
 std::string url_to_id(QUrl const& item_url, QUrl const& base_url);
+
+std::string make_child_id(std::string const& parent_id, std::string const& name,
+                          bool is_folder=false);
+
+bool is_folder(std::string const& item_id);

=== modified file 'src/main.cpp'
--- src/main.cpp	2016-09-22 06:40:07 +0000
+++ src/main.cpp	2016-11-25 05:01:23 +0000
@@ -1,3 +1,21 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: James Henstridge <[e-mail]>
+ */
+
 #include <unity/storage/provider/Server.h>
 
 #include "OwncloudProvider.h"
@@ -8,7 +26,7 @@
 int main(int argc, char **argv)
 {
     string const bus_name = "com.canonical.StorageFramework.Provider.OwnCloud";
-    string const account_service_id = "google-drive-scope"; //"storage-provider-owncloud";
+    string const account_service_id = "storage-provider-owncloud";
 
     Server<OwncloudProvider> server(bus_name, account_service_id);
     server.init(argc, argv);

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2016-09-23 03:28:37 +0000
+++ tests/CMakeLists.txt	2016-11-25 05:01:23 +0000
@@ -1,10 +1,4 @@
-# We add -g so we get debug info for the gtest stack frames with gdb.
-# The warnings are suppressed so we get a noise-free build for gtest and gmock.
-
-set(old_cxx_flags ${CMAKE_CXX_FLAGS})
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -Wno-old-style-cast -Wno-missing-field-initializers")
 find_package(GMock)
-set(CMAKE_CXX_FLAGS ${old_cxx_flags})
 
 configure_file(testsetup.h.in testsetup.h @ONLY)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})
@@ -15,6 +9,7 @@
   multistatus
   item_id
   davprovider
+  http_error
 )
 
 set(UNIT_TEST_TARGETS "")

=== modified file 'tests/davprovider/davprovider_test.cpp'
--- tests/davprovider/davprovider_test.cpp	2016-09-27 06:28:45 +0000
+++ tests/davprovider/davprovider_test.cpp	2016-11-25 05:01:23 +0000
@@ -1,26 +1,74 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: James Henstridge <[e-mail]>
+ */
+
 #include "../../src/DavProvider.h"
 #include <utils/DBusEnvironment.h>
 #include <utils/DavEnvironment.h>
 #include <utils/ProviderEnvironment.h>
 #include <testsetup.h>
 
+#include <gtest/gtest.h>
 #include <QCoreApplication>
-#include <QFutureWatcher>
 #include <QNetworkAccessManager>
 #include <QNetworkRequest>
 #include <QSignalSpy>
 #include <QTemporaryDir>
-#include <unity/storage/qt/client/Account.h>
-#include <unity/storage/qt/client/Root.h>
+#include <QTimer>
+#include <unity/storage/qt/Account.h>
+#include <unity/storage/qt/Downloader.h>
+#include <unity/storage/qt/Item.h>
+#include <unity/storage/qt/ItemJob.h>
+#include <unity/storage/qt/ItemListJob.h>
+#include <unity/storage/qt/StorageError.h>
+#include <unity/storage/qt/Uploader.h>
+#include <unity/storage/qt/VoidJob.h>
 
-#include <gtest/gtest.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <utime.h>
+#include <algorithm>
 
 using namespace std;
-using namespace unity::storage::provider;
-using namespace unity::storage::qt::client;
-using unity::storage::ItemType;
-
-static constexpr int SIGNAL_WAIT_TIME = 30000;
+using namespace unity::storage::qt;
+namespace provider = unity::storage::provider;
+
+void PrintTo(QString const& str, std::ostream* os)
+{
+    *os << "QString(\"" << str.toStdString() << "\")";
+}
+
+namespace
+{
+
+const string file_contents =
+    "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do "
+    "eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut "
+    "enim ad minim veniam, quis nostrud exercitation ullamco laboris "
+    "nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor "
+    "in reprehenderit in voluptate velit esse cillum dolore eu fugiat "
+    "nulla pariatur. Excepteur sint occaecat cupidatat non proident, "
+    "sunt in culpa qui officia deserunt mollit anim id est laborum.\n";
+
+constexpr int SIGNAL_WAIT_TIME = 30000;
+
+}
 
 class TestDavProvider : public DavProvider
 {
@@ -30,7 +78,7 @@
     {
     }
 
-    QUrl base_url(Context const& ctx) const override
+    QUrl base_url(provider::Context const& ctx) const override
     {
         Q_UNUSED(ctx);
         return base_url_;
@@ -38,10 +86,11 @@
 
     QNetworkReply *send_request(
         QNetworkRequest& request, QByteArray const& verb, QIODevice* data,
-        unity::storage::provider::Context const& ctx) const override
+        provider::Context const& ctx) const override
     {
-        const auto& creds = boost::get<PasswordCredentials>(ctx.credentials);
-        const auto credentials = QByteArray::fromStdString(creds.username + ":" + creds.password);;
+        const auto& creds = boost::get<provider::PasswordCredentials>(ctx.credentials);
+        const auto credentials = QByteArray::fromStdString(creds.username + ":" +
+                                                           creds.password);
         request.setRawHeader(QByteArrayLiteral("Authorization"),
                              QByteArrayLiteral("Basic ") + credentials.toBase64());
         return network_->sendCustomRequest(request, verb, data);
@@ -64,8 +113,8 @@
 
         dav_env_.reset(new DavEnvironment(tmp_dir_->path()));
         provider_env_.reset(new ProviderEnvironment(
-                                unique_ptr<ProviderBase>(new TestDavProvider(dav_env_->base_url())),
-                                3, *dbus_env_));
+                                make_shared<TestDavProvider>(dav_env_->base_url()),
+                                1, *dbus_env_));
     }
 
     void TearDown() override
@@ -76,11 +125,47 @@
         dbus_env_.reset();
     }
 
-    shared_ptr<Account> get_client() const
+    Account get_client() const
     {
         return provider_env_->get_client();
     }
 
+    string local_file(string const& path)
+    {
+        return tmp_dir_->path().toStdString() + "/" + path;
+    }
+
+    void make_file(string const& path)
+    {
+        string full_path = local_file(path);
+        int fd = open(full_path.c_str(), O_CREAT | O_EXCL, 0644);
+        ASSERT_GT(fd, 0);
+        ASSERT_EQ(0, close(fd));
+    }
+
+    void make_dir(string const& path)
+    {
+        string full_path = local_file(path);
+        ASSERT_EQ(0, mkdir(full_path.c_str(), 0755));
+    }
+
+    void touch_file(string const& path)
+    {
+        string full_path = local_file(path);
+        ASSERT_EQ(0, utime(full_path.c_str(), nullptr));
+    }
+
+    void offset_mtime(string const& path, int offset_seconds)
+    {
+        string full_path = local_file(path);
+        struct stat buf;
+        ASSERT_EQ(0, stat(full_path.c_str(), &buf));
+        struct utimbuf times;
+        times.actime = buf.st_atime + offset_seconds;
+        times.modtime = buf.st_mtime + offset_seconds;
+        ASSERT_EQ(0, utime(full_path.c_str(), &times));
+    }
+
 private:
     std::unique_ptr<DBusEnvironment> dbus_env_;
     std::unique_ptr<QTemporaryDir> tmp_dir_;
@@ -88,27 +173,753 @@
     std::unique_ptr<ProviderEnvironment> provider_env_;
 };
 
+namespace
+{
+
+template <typename Job>
+void wait_for(Job* job)
+{
+    QSignalSpy spy(job, &Job::statusChanged);
+    while (job->status() == Job::Loading)
+    {
+        if (!spy.wait(SIGNAL_WAIT_TIME))
+        {
+            throw runtime_error("Wait for statusChanged signal timed out");
+        }
+    }
+}
+
+QList<Item> get_items(ItemListJob *job)
+{
+    QList<Item> items;
+    auto connection = QObject::connect(
+        job, &ItemListJob::itemsReady,
+        [&](QList<Item> const& new_items)
+        {
+            items.append(new_items);
+        });
+    try
+    {
+        wait_for(job);
+    }
+    catch (...)
+    {
+        QObject::disconnect(connection);
+        throw;
+    }
+    QObject::disconnect(connection);
+    return items;
+}
+
+Item get_root(Account const& account)
+{
+    unique_ptr<ItemListJob> job(account.roots());
+    QList<Item> roots = get_items(job.get());
+    if (job->status() != ItemListJob::Finished)
+    {
+        throw runtime_error("Account.roots(): " +
+                            job->error().errorString().toStdString());
+    }
+    return roots.at(0);
+}
+
+}
+
 TEST_F(DavProviderTests, roots)
 {
     auto account = get_client();
-    auto future = account->roots();
-
-    QFutureWatcher<QVector<shared_ptr<Root>>> watcher;
-    QSignalSpy spy(&watcher, &decltype(watcher)::finished);
-    watcher.setFuture(account->roots());
-    if (spy.count() == 0)
-    {
-        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
-    }
-
-    auto roots = watcher.result();
+
+    unique_ptr<ItemListJob> job(account.roots());
+    QList<Item> roots = get_items(job.get());
+    ASSERT_EQ(ItemListJob::Finished, job->status())
+        << job->error().errorString().toStdString();
+
     ASSERT_EQ(1, roots.size());
     auto item = roots[0];
-    EXPECT_EQ(".", item->native_identity());
-    EXPECT_EQ("Root", item->name());
-    EXPECT_EQ(ItemType::root, item->type());
-    EXPECT_TRUE(item->parent_ids().isEmpty());
-    EXPECT_TRUE(item->last_modified_time().isValid());
+    EXPECT_EQ(".", item.itemId());
+    EXPECT_EQ("Root", item.name());
+    EXPECT_EQ(Item::Root, item.type());
+    EXPECT_TRUE(item.parentIds().isEmpty());
+    EXPECT_TRUE(item.lastModifiedTime().isValid());
+}
+
+TEST_F(DavProviderTests, list)
+{
+    auto account = get_client();
+    make_file("foo.txt");
+    make_file("bar.txt");
+    make_dir("folder");
+    make_file("I\u00F1t\u00EBrn\u00E2ti\u00F4n\u00E0liz\u00E6ti\u00F8n");
+
+    Item root = get_root(account);
+
+    unique_ptr<ItemListJob> job(root.list());
+    QList<Item> items = get_items(job.get());
+    ASSERT_EQ(ItemListJob::Finished, job->status())
+        << job->error().errorString().toStdString();
+
+    ASSERT_EQ(4, items.size());
+    sort(items.begin(), items.end(),
+         [](Item const& a, Item const& b) -> bool {
+             return a.itemId() < b.itemId();
+         });
+
+    EXPECT_EQ("I%C3%B1t%C3%ABrn%C3%A2ti%C3%B4n%C3%A0liz%C3%A6ti%C3%B8n", items[0].itemId());
+    EXPECT_EQ(".", items[0].parentIds().at(0));
+    EXPECT_EQ("I\u00F1t\u00EBrn\u00E2ti\u00F4n\u00E0liz\u00E6ti\u00F8n", items[0].name());
+    EXPECT_EQ(Item::File, items[0].type());
+
+    EXPECT_EQ("bar.txt", items[1].itemId());
+    EXPECT_EQ(".", items[1].parentIds().at(0));
+    EXPECT_EQ("bar.txt", items[1].name());
+    EXPECT_EQ(Item::File, items[1].type());
+
+    EXPECT_EQ("folder/", items[2].itemId());
+    EXPECT_EQ(".", items[2].parentIds().at(0));
+    EXPECT_EQ("folder", items[2].name());
+    EXPECT_EQ(Item::Folder, items[2].type());
+
+    EXPECT_EQ("foo.txt", items[3].itemId());
+    EXPECT_EQ(".", items[3].parentIds().at(0));
+    EXPECT_EQ("foo.txt", items[3].name());
+    EXPECT_EQ(Item::File, items[3].type());
+}
+
+TEST_F(DavProviderTests, lookup)
+{
+    auto account = get_client();
+    make_file("foo.txt");
+
+    Item root = get_root(account);
+
+    unique_ptr<ItemListJob> job(root.lookup("foo.txt"));
+    QList<Item> items = get_items(job.get());
+    ASSERT_EQ(ItemListJob::Finished, job->status())
+        << job->error().errorString().toStdString();
+
+    ASSERT_EQ(1, items.size());
+    EXPECT_EQ("foo.txt", items[0].itemId());
+    EXPECT_EQ(".", items[0].parentIds().at(0));
+    EXPECT_EQ("foo.txt", items[0].name());
+    EXPECT_EQ(Item::File, items[0].type());
+}
+
+TEST_F(DavProviderTests, metadata)
+{
+    auto account = get_client();
+    make_file("foo.txt");
+
+    unique_ptr<ItemJob> job(account.get("foo.txt"));
+    wait_for(job.get());
+    ASSERT_EQ(ItemJob::Finished, job->status())
+        << job->error().errorString().toStdString();
+
+    Item item = job->item();
+    EXPECT_EQ("foo.txt", item.itemId());
+    EXPECT_EQ(".", item.parentIds().at(0));
+    EXPECT_EQ("foo.txt", item.name());
+    EXPECT_EQ(Item::File, item.type());
+}
+
+TEST_F(DavProviderTests, metadata_not_found)
+{
+    auto account = get_client();
+
+    unique_ptr<ItemJob> job(account.get("foo.txt"));
+    wait_for(job.get());
+    ASSERT_EQ(ItemJob::Error, job->status());
+
+    auto error = job->error();
+    EXPECT_EQ(StorageError::NotExists, error.type());
+    EXPECT_TRUE(error.message().startsWith("Sabre\\DAV\\Exception\\NotFound: "))
+        << error.message().toStdString();
+}
+
+TEST_F(DavProviderTests, create_folder)
+{
+    auto account = get_client();
+
+    Item root = get_root(account);
+    unique_ptr<ItemJob> job(root.createFolder("folder"));
+    wait_for(job.get());
+    ASSERT_EQ(ItemJob::Finished, job->status())
+        << job->error().errorString().toStdString();
+
+    Item folder = job->item();
+    EXPECT_EQ("folder/", folder.itemId());
+    EXPECT_EQ(".", folder.parentIds().at(0));
+    EXPECT_EQ("folder", folder.name());
+    EXPECT_EQ(Item::Folder, folder.type());
+}
+
+TEST_F(DavProviderTests, create_folder_reserved_chars)
+{
+    auto account = get_client();
+
+    Item root = get_root(account);
+    unique_ptr<ItemJob> job(root.createFolder("14:19"));
+    wait_for(job.get());
+    ASSERT_EQ(ItemJob::Finished, job->status())
+        << job->error().errorString().toStdString();
+
+    Item folder = job->item();
+    EXPECT_EQ("14:19/", folder.itemId());
+    EXPECT_EQ(".", folder.parentIds().at(0));
+    EXPECT_EQ("14:19", folder.name());
+    EXPECT_EQ(Item::Folder, folder.type());
+}
+
+TEST_F(DavProviderTests, create_folder_overwrite_file)
+{
+    auto account = get_client();
+    make_file("folder");
+
+    Item root = get_root(account);
+    unique_ptr<ItemJob> job(root.createFolder("folder"));
+    wait_for(job.get());
+    ASSERT_EQ(ItemJob::Error, job->status());
+
+    auto error = job->error();
+    EXPECT_EQ(StorageError::Exists, error.type());
+    EXPECT_EQ("Sabre\\DAV\\Exception\\MethodNotAllowed: The resource you tried to create already exists", error.message());
+}
+
+TEST_F(DavProviderTests, create_folder_overwrite_folder)
+{
+    auto account = get_client();
+    ASSERT_EQ(0, mkdir(local_file("folder").c_str(), 0755));
+
+    Item root = get_root(account);
+    unique_ptr<ItemJob> job(root.createFolder("folder"));
+    wait_for(job.get());
+    ASSERT_EQ(ItemJob::Error, job->status());
+
+    auto error = job->error();
+    EXPECT_EQ(StorageError::Exists, error.type());
+    EXPECT_EQ("Sabre\\DAV\\Exception\\MethodNotAllowed: The resource you tried to create already exists", error.message());
+}
+
+TEST_F(DavProviderTests, create_file)
+{
+    int const segments = 50;
+
+    auto account = get_client();
+    Item root = get_root(account);
+
+    unique_ptr<Uploader> uploader(
+        root.createFile("filename.txt", Item::ErrorIfConflict,
+                        file_contents.size() * segments, "text/plain"));
+
+    int count = 0;
+    QTimer timer;
+    timer.setSingleShot(false);
+    timer.setInterval(10);
+    QObject::connect(&timer, &QTimer::timeout, [&] {
+            uploader->write(&file_contents[0], file_contents.size());
+            count++;
+            if (count == segments)
+            {
+                uploader->close();
+            }
+        });
+
+    QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
+    timer.start();
+    while (uploader->status() == Uploader::Loading ||
+           uploader->status() == Uploader::Ready)
+    {
+        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+    }
+    ASSERT_EQ(Uploader::Finished, uploader->status())
+        << uploader->error().errorString().toStdString();
+
+    auto file = uploader->item();
+    EXPECT_EQ("filename.txt", file.itemId());
+    ASSERT_EQ(1, file.parentIds().size());
+    EXPECT_EQ(".", file.parentIds().at(0));
+    EXPECT_EQ("filename.txt", file.name());
+    EXPECT_NE(0, file.etag().size());
+    EXPECT_EQ(Item::File, file.type());
+    EXPECT_EQ(int64_t(file_contents.size() * segments), file.sizeInBytes());
+
+    string full_path = local_file("filename.txt");
+    struct stat buf;
+    ASSERT_EQ(0, stat(full_path.c_str(), &buf));
+    EXPECT_EQ(off_t(file_contents.size() * segments), buf.st_size);
+}
+
+TEST_F(DavProviderTests, create_file_over_existing_file)
+{
+    auto account = get_client();
+    make_file("foo.txt");
+
+    Item root = get_root(account);
+    unique_ptr<Uploader> uploader(
+        root.createFile("foo.txt", Item::ErrorIfConflict, 0, "text/plain"));
+    QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
+    while (uploader->status() == Uploader::Loading)
+    {
+        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+    }
+
+    uploader->close();
+    while (uploader->status() == Uploader::Ready)
+    {
+        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+    }
+    ASSERT_EQ(Uploader::Error, uploader->status());
+
+    auto error = uploader->error();
+    EXPECT_EQ(StorageError::Conflict, error.type());
+    EXPECT_EQ("Sabre\\DAV\\Exception\\PreconditionFailed: An If-None-Match header was specified, but the ETag matched (or * was specified).", error.message());
+}
+
+TEST_F(DavProviderTests, create_file_overwrite_existing)
+{
+    auto account = get_client();
+    make_file("foo.txt");
+
+    Item root = get_root(account);
+    unique_ptr<Uploader> uploader(
+        root.createFile("foo.txt", Item::IgnoreConflict, 0, "text/plain"));
+    QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
+    while (uploader->status() == Uploader::Loading)
+    {
+        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+    }
+
+    uploader->close();
+    while (uploader->status() == Uploader::Ready)
+    {
+        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+    }
+    ASSERT_EQ(Uploader::Finished, uploader->status())
+        << uploader->error().errorString().toStdString();
+}
+
+TEST_F(DavProviderTests, update)
+{
+    int const segments = 50;
+
+    auto account = get_client();
+    make_file("foo.txt");
+    // Offset to ensure modification time changes
+    offset_mtime("foo.txt", -10);
+
+    unique_ptr<ItemJob> job(account.get("foo.txt"));
+    wait_for(job.get());
+    ASSERT_EQ(ItemJob::Finished, job->status())
+        << job->error().errorString().toStdString();
+
+    auto file = job->item();
+    QString old_etag = file.etag();
+
+    unique_ptr<Uploader> uploader(
+        file.createUploader(Item::ErrorIfConflict,
+                            file_contents.size() * segments));
+
+    int count = 0;
+    QTimer timer;
+    timer.setSingleShot(false);
+    timer.setInterval(10);
+    QObject::connect(&timer, &QTimer::timeout, [&] {
+            uploader->write(&file_contents[0], file_contents.size());
+            count++;
+            if (count == segments)
+            {
+                uploader->close();
+            }
+        });
+
+    QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
+    timer.start();
+    while (uploader->status() == Uploader::Loading ||
+           uploader->status() == Uploader::Ready)
+    {
+        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+    }
+    ASSERT_EQ(Uploader::Finished, uploader->status())
+        << uploader->error().errorString().toStdString();
+
+    file = uploader->item();
+    EXPECT_NE(old_etag, file.etag());
+    EXPECT_EQ(int64_t(file_contents.size() * segments), file.sizeInBytes());
+}
+
+TEST_F(DavProviderTests, update_conflict)
+{
+    auto account = get_client();
+    make_file("foo.txt");
+    // Offset to ensure modification time changes
+    offset_mtime("foo.txt", -10);
+
+    unique_ptr<ItemJob> job(account.get("foo.txt"));
+    wait_for(job.get());
+    ASSERT_EQ(ItemJob::Finished, job->status())
+        << job->error().errorString().toStdString();
+
+    // Change the file after metadata has been looked up
+    touch_file("foo.txt");
+
+    auto file = job->item();
+    unique_ptr<Uploader> uploader(
+        file.createUploader(Item::ErrorIfConflict, 0));
+    QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
+    while (uploader->status() == Uploader::Loading)
+    {
+        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+    }
+
+    uploader->close();
+    while (uploader->status() == Uploader::Ready)
+    {
+        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+    }
+    ASSERT_EQ(Uploader::Error, uploader->status());
+
+    auto error = uploader->error();
+    EXPECT_EQ(StorageError::Conflict, error.type());
+    EXPECT_EQ("Sabre\\DAV\\Exception\\PreconditionFailed: An If-Match header was specified, but none of the specified the ETags matched.", error.message());
+}
+
+TEST_F(DavProviderTests, upload_short_write)
+{
+    auto account = get_client();
+
+    Item root = get_root(account);
+    unique_ptr<Uploader> uploader(
+        root.createFile("foo.txt", Item::ErrorIfConflict, 1000, "text/plain"));
+    QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
+    while (uploader->status() == Uploader::Loading)
+    {
+        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+    }
+
+    uploader->close();
+    while (uploader->status() == Uploader::Ready)
+    {
+        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+    }
+    ASSERT_EQ(Uploader::Error, uploader->status());
+
+    auto error = uploader->error();
+    EXPECT_EQ(StorageError::RemoteCommsError, error.type());
+    EXPECT_EQ("Unknown error", error.message());
+}
+
+TEST_F(DavProviderTests, upload_cancel)
+{
+    auto account = get_client();
+
+    Item root = get_root(account);
+    unique_ptr<Uploader> uploader(
+        root.createFile("foo.txt", Item::ErrorIfConflict, 1000, "text/plain"));
+    QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
+    while (uploader->status() == Uploader::Loading)
+    {
+        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+    }
+
+    uploader->cancel();
+    while (uploader->status() == Uploader::Ready)
+    {
+        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+    }
+    ASSERT_EQ(Uploader::Cancelled, uploader->status());
+
+    auto error = uploader->error();
+    EXPECT_EQ(StorageError::Cancelled, error.type());
+    EXPECT_EQ("Uploader::cancel(): upload was cancelled", error.message());
+}
+
+TEST_F(DavProviderTests, download)
+{
+    int const segments = 1000;
+    string large_contents;
+    large_contents.reserve(file_contents.size() * segments);
+    for (int i = 0; i < segments; i++)
+    {
+        large_contents += file_contents;
+    }
+    string const full_path = local_file("foo.txt");
+    {
+        int fd = open(full_path.c_str(), O_WRONLY | O_CREAT | O_EXCL, 0644);
+        ASSERT_GT(fd, 0);
+        ASSERT_EQ(ssize_t(large_contents.size()), write(fd, &large_contents[0], large_contents.size())) << strerror(errno);
+        ASSERT_EQ(0, close(fd));
+    }
+
+    auto account = get_client();
+
+    unique_ptr<ItemJob> job(account.get("foo.txt"));
+    wait_for(job.get());
+    ASSERT_EQ(ItemJob::Finished, job->status())
+        << job->error().errorString().toStdString();
+
+    auto file = job->item();
+
+    unique_ptr<Downloader> downloader(
+        file.createDownloader(Item::ErrorIfConflict));
+
+    int64_t n_read = 0;
+    QObject::connect(downloader.get(), &QIODevice::readyRead,
+                     [&]() {
+                         auto bytes = downloader->readAll();
+                         string const expected = large_contents.substr(
+                             n_read, bytes.size());
+                         EXPECT_EQ(expected, bytes.toStdString());
+                         n_read += bytes.size();
+                     });
+    QSignalSpy read_finished_spy(
+        downloader.get(), &QIODevice::readChannelFinished);
+    ASSERT_TRUE(read_finished_spy.wait(SIGNAL_WAIT_TIME));
+
+    QSignalSpy status_spy(downloader.get(), &Downloader::statusChanged);
+    downloader->close();
+    while (downloader->status() == Downloader::Ready)
+    {
+        ASSERT_TRUE(status_spy.wait(SIGNAL_WAIT_TIME));
+    }
+    ASSERT_EQ(Downloader::Finished, downloader->status())
+        << downloader->error().errorString().toStdString();
+
+    EXPECT_EQ(int64_t(large_contents.size()), n_read);
+}
+
+TEST_F(DavProviderTests, download_short_read)
+{
+    int const segments = 1000;
+    {
+        string full_path = local_file("foo.txt");
+        int fd = open(full_path.c_str(), O_WRONLY | O_CREAT | O_EXCL, 0644);
+        ASSERT_GT(fd, 0);
+        for (int i = 0; i < segments; i++)
+        {
+            ASSERT_EQ(ssize_t(file_contents.size()), write(fd, &file_contents[0], file_contents.size())) << strerror(errno);
+        }
+        ASSERT_EQ(0, close(fd));
+    }
+
+    auto account = get_client();
+
+    unique_ptr<ItemJob> job(account.get("foo.txt"));
+    wait_for(job.get());
+    ASSERT_EQ(ItemJob::Finished, job->status())
+        << job->error().errorString().toStdString();
+
+    auto file = job->item();
+    unique_ptr<Downloader> downloader(
+        file.createDownloader(Item::ErrorIfConflict));
+
+    QSignalSpy spy(downloader.get(), &Downloader::statusChanged);
+    while (downloader->status() == Downloader::Loading)
+    {
+        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+    }
+
+    downloader->close();
+    while (downloader->status() == Downloader::Ready)
+    {
+        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+    }
+    ASSERT_EQ(Downloader::Error, downloader->status());
+
+    auto error = downloader->error();
+    EXPECT_EQ(StorageError::LogicError, error.type());
+    EXPECT_EQ("finish called before all data sent", error.message());
+}
+
+TEST_F(DavProviderTests, download_not_found)
+{
+    auto account = get_client();
+    make_file("foo.txt");
+
+    unique_ptr<ItemJob> job(account.get("foo.txt"));
+    wait_for(job.get());
+    ASSERT_EQ(ItemJob::Finished, job->status())
+        << job->error().errorString().toStdString();
+
+    auto file = job->item();
+
+    ASSERT_EQ(0, unlink(local_file("foo.txt").c_str()));
+
+    unique_ptr<Downloader> downloader(
+        file.createDownloader(Item::ErrorIfConflict));
+
+    QObject::connect(downloader.get(), &QIODevice::readyRead,
+                     [&]() {
+                         downloader->readAll();
+                     });
+    QSignalSpy read_finished_spy(
+        downloader.get(), &QIODevice::readChannelFinished);
+    ASSERT_TRUE(read_finished_spy.wait(SIGNAL_WAIT_TIME));
+
+    QSignalSpy status_spy(downloader.get(), &Downloader::statusChanged);
+    downloader->close();
+    while (downloader->status() == Downloader::Ready)
+    {
+        ASSERT_TRUE(status_spy.wait(SIGNAL_WAIT_TIME));
+    }
+    ASSERT_EQ(Downloader::Error, downloader->status());
+
+    auto error = downloader->error();
+    EXPECT_EQ(StorageError::NotExists, error.type());
+    EXPECT_TRUE(error.message().startsWith("Sabre\\DAV\\Exception\\NotFound: "))
+        << error.message().toStdString();
+}
+
+TEST_F(DavProviderTests, delete_item)
+{
+    auto account = get_client();
+    make_file("foo.txt");
+
+    unique_ptr<ItemJob> job(account.get("foo.txt"));
+    wait_for(job.get());
+    ASSERT_EQ(ItemJob::Finished, job->status())
+        << job->error().errorString().toStdString();
+
+    Item item = job->item();
+    unique_ptr<VoidJob> delete_job(item.deleteItem());
+    wait_for(delete_job.get());
+    ASSERT_EQ(VoidJob::Finished, delete_job->status())
+        << delete_job->error().errorString().toStdString();
+
+    struct stat buf;
+    EXPECT_EQ(-1, stat(local_file("foo.txt").c_str(), &buf));
+    EXPECT_EQ(ENOENT, errno);
+}
+
+TEST_F(DavProviderTests, delete_item_not_found)
+{
+    auto account = get_client();
+    make_file("foo.txt");
+
+    unique_ptr<ItemJob> job(account.get("foo.txt"));
+    wait_for(job.get());
+    ASSERT_EQ(ItemJob::Finished, job->status())
+        << job->error().errorString().toStdString();
+
+    Item item = job->item();
+
+    ASSERT_EQ(0, unlink(local_file("foo.txt").c_str()));
+
+    unique_ptr<VoidJob> delete_job(item.deleteItem());
+    wait_for(delete_job.get());
+    ASSERT_EQ(VoidJob::Error, delete_job->status());
+
+    auto error = delete_job->error();
+    EXPECT_EQ(StorageError::NotExists, error.type());
+    EXPECT_TRUE(error.message().startsWith("Sabre\\DAV\\Exception\\NotFound: "))
+        << error.message().toStdString();
+}
+
+TEST_F(DavProviderTests, move)
+{
+    string const full_path = local_file("foo.txt");
+    {
+        int fd = open(full_path.c_str(), O_WRONLY | O_CREAT | O_EXCL, 0644);
+        ASSERT_GT(fd, 0);
+        ASSERT_EQ(ssize_t(file_contents.size()), write(fd, &file_contents[0], file_contents.size())) << strerror(errno);
+        ASSERT_EQ(0, close(fd));
+    }
+
+    auto account = get_client();
+    Item root = get_root(account);
+
+    unique_ptr<ItemJob> job(account.get("foo.txt"));
+    wait_for(job.get());
+    ASSERT_EQ(ItemJob::Finished, job->status())
+        << job->error().errorString().toStdString();
+
+    Item item = job->item();
+
+    job.reset(item.move(root, "new-name.txt"));
+    wait_for(job.get());
+    ASSERT_EQ(ItemJob::Finished, job->status())
+        << job->error().errorString().toStdString();
+
+    item = job->item();
+    EXPECT_EQ("new-name.txt", item.itemId());
+    ASSERT_EQ(1, item.parentIds().size());
+    EXPECT_EQ(".", item.parentIds().at(0));
+    EXPECT_EQ("new-name.txt", item.name());
+    EXPECT_NE(0, item.etag().size());
+    EXPECT_EQ(Item::File, item.type());
+    EXPECT_EQ(int64_t(file_contents.size()), item.sizeInBytes());
+
+    // The old file no longer exists
+    struct stat buf;
+    EXPECT_EQ(-1, stat(full_path.c_str(), &buf));
+    EXPECT_EQ(ENOENT, errno);
+
+    // And the new one does
+    string const new_path = local_file("new-name.txt");
+    EXPECT_EQ(0, stat(new_path.c_str(), &buf));
+    EXPECT_EQ(off_t(file_contents.size()), buf.st_size);
+
+    // And its has the expected contents
+    {
+        int fd = open(new_path.c_str(), O_RDONLY);
+        ASSERT_GT(fd, 0);
+        string contents(file_contents.size(), '\0');
+        EXPECT_EQ(ssize_t(file_contents.size()), read(fd, &contents[0], contents.size()));
+        EXPECT_EQ(0, close(fd));
+        EXPECT_EQ(file_contents, contents);
+    }
+}
+
+TEST_F(DavProviderTests, copy)
+{
+    string const full_path = local_file("foo.txt");
+    {
+        int fd = open(full_path.c_str(), O_WRONLY | O_CREAT | O_EXCL, 0644);
+        ASSERT_GT(fd, 0);
+        ASSERT_EQ(ssize_t(file_contents.size()), write(fd, &file_contents[0], file_contents.size())) << strerror(errno);
+        ASSERT_EQ(0, close(fd));
+    }
+
+    auto account = get_client();
+    Item root = get_root(account);
+
+    unique_ptr<ItemJob> job(account.get("foo.txt"));
+    wait_for(job.get());
+    ASSERT_EQ(ItemJob::Finished, job->status())
+        << job->error().errorString().toStdString();
+
+    Item item = job->item();
+
+    job.reset(item.copy(root, "new-name.txt"));
+    wait_for(job.get());
+    ASSERT_EQ(ItemJob::Finished, job->status())
+        << job->error().errorString().toStdString();
+
+    item = job->item();
+    EXPECT_EQ("new-name.txt", item.itemId());
+    ASSERT_EQ(1, item.parentIds().size());
+    EXPECT_EQ(".", item.parentIds().at(0));
+    EXPECT_EQ("new-name.txt", item.name());
+    EXPECT_NE(0, item.etag().size());
+    EXPECT_EQ(Item::File, item.type());
+    EXPECT_EQ(int64_t(file_contents.size()), item.sizeInBytes());
+
+    // The old file still exists
+    struct stat buf;
+    EXPECT_EQ(0, stat(full_path.c_str(), &buf));
+
+    // And the new one does too
+    string const new_path = local_file("new-name.txt");
+    EXPECT_EQ(0, stat(new_path.c_str(), &buf));
+    EXPECT_EQ(off_t(file_contents.size()), buf.st_size);
+
+    // And its has the expected contents
+    {
+        int fd = open(new_path.c_str(), O_RDONLY);
+        ASSERT_GT(fd, 0);
+        string contents(file_contents.size(), '\0');
+        EXPECT_EQ(ssize_t(file_contents.size()), read(fd, &contents[0], contents.size()));
+        EXPECT_EQ(0, close(fd));
+        EXPECT_EQ(file_contents, contents);
+    }
 }
 
 int main(int argc, char**argv)

=== added directory 'tests/http_error'
=== added file 'tests/http_error/CMakeLists.txt'
--- tests/http_error/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tests/http_error/CMakeLists.txt	2016-11-25 05:01:23 +0000
@@ -0,0 +1,8 @@
+add_executable(http_error_test http_error_test.cpp)
+target_link_libraries(http_error_test
+  dav-provider-lib
+  testutils
+  Qt5::Test
+  gtest
+)
+add_test(http_error_test http_error_test)

=== added file 'tests/http_error/http_error_test.cpp'
--- tests/http_error/http_error_test.cpp	1970-01-01 00:00:00 +0000
+++ tests/http_error/http_error_test.cpp	2016-11-25 05:01:23 +0000
@@ -0,0 +1,278 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: James Henstridge <[e-mail]>
+ */
+
+#include "../../src/http_error.h"
+
+#include <gtest/gtest.h>
+#include <QBuffer>
+#include <QByteArray>
+#include <QCoreApplication>
+#include <QNetworkReply>
+#include <QNetworkRequest>
+#include <unity/storage/provider/Exceptions.h>
+
+using namespace std;
+using namespace unity::storage::provider;
+
+class FakeReply : public QNetworkReply
+{
+public:
+    FakeReply(QString const& method, int status, QString const& reason,
+              QString const& content_type, QByteArray const& body)
+    {
+        QNetworkRequest request;
+        request.setAttribute(QNetworkRequest::CustomVerbAttribute, method);
+        setRequest(request);
+
+        setAttribute(QNetworkRequest::HttpStatusCodeAttribute, status);
+        setAttribute(QNetworkRequest::HttpReasonPhraseAttribute, reason);
+
+        setHeader(QNetworkRequest::ContentTypeHeader, content_type);
+        setHeader(QNetworkRequest::ContentLengthHeader, body.size());
+        buffer_.setData(body);
+        buffer_.open(QIODevice::ReadOnly);
+        open(QIODevice::ReadOnly);
+        setFinished(true);
+    }
+
+    FakeReply(QNetworkReply::NetworkError code, QString const& message)
+    {
+        setError(code, message);
+        setFinished(true);
+    }
+
+    void abort() override
+    {
+        close();
+    }
+
+    qint64 bytesAvailable() const override
+    {
+        return QNetworkReply::bytesAvailable() + buffer_.bytesAvailable();
+    }
+
+    bool isSequential() const override
+    {
+        return true;
+    }
+
+    qint64 size() const override
+    {
+        return buffer_.size();
+    }
+
+    qint64 readData(char *data, qint64 length) override
+    {
+        return buffer_.read(data, length);
+    }
+
+private:
+    QBuffer buffer_;
+};
+
+template <typename E>
+E expect_throw(boost::exception_ptr p)
+{
+    try
+    {
+        boost::rethrow_exception(p);
+    }
+    catch (E const& e)
+    {
+        return e;
+    }
+    throw std::runtime_error("No exception thrown");
+}
+
+
+TEST(HttpErrorTests, network_error)
+{
+    FakeReply reply(QNetworkReply::HostNotFoundError, "Host not found");
+
+    auto e = expect_throw<RemoteCommsException>(
+        translate_http_error(&reply, QByteArray()));
+    EXPECT_EQ("Host not found", e.error_message());
+}
+
+TEST(HttpErrorTests, text_plain_body)
+{
+    FakeReply reply("GET", 400, "Bad Request",
+                    "text/plain;charset=US-ASCII", "error message");
+    auto e = expect_throw<RemoteCommsException>(
+        translate_http_error(&reply, QByteArray()));
+    EXPECT_EQ("error message", e.error_message());
+}
+
+TEST(HttpErrorTests, application_xml_body)
+{
+    static const char xml[] = R"(<?xml version="1.0" encoding="utf-8"?>
+<d:error xmlns:d='DAV:' xmlns:s='http://sabredav.org/ns'>
+  <s:exception>exception_name</s:exception>
+  <s:message>error message</s:message>
+  <s:sabredav-version>1.8.12</s:sabredav-version>
+</d:error>
+)";
+    FakeReply reply("GET", 400, "Bad Request",
+                    "application/xml;charset=utf-8", xml);
+
+    auto e = expect_throw<RemoteCommsException>(
+        translate_http_error(&reply, QByteArray()));
+    EXPECT_EQ("exception_name: error message", e.error_message());
+}
+
+TEST(HttpErrorTests, fallback_body)
+{
+    FakeReply reply("GET", 400, "Bad Request",
+                    "application/octet-stream", "foo");
+    auto e = expect_throw<RemoteCommsException>(
+        translate_http_error(&reply, QByteArray()));
+    EXPECT_EQ("Bad Request", e.error_message());
+}
+
+TEST(HttpErrorTests, body_provided_separately)
+{
+    static const char xml[] = R"(<?xml version="1.0" encoding="utf-8"?>
+<d:error xmlns:d='DAV:' xmlns:s='http://sabredav.org/ns'>
+  <s:exception>exception_name</s:exception>
+  <s:message>error message</s:message>
+  <s:sabredav-version>1.8.12</s:sabredav-version>
+</d:error>
+)";
+    FakeReply reply("GET", 400, "Bad Request",
+                    "application/xml;charset=utf-8", "foo");
+
+    auto e = expect_throw<RemoteCommsException>(
+        translate_http_error(&reply, xml));
+    EXPECT_EQ("exception_name: error message", e.error_message());
+}
+
+TEST(HttpErrorTests, 401)
+{
+    FakeReply reply("GET", 401, "Unauthorised", "text/plain", "message");
+
+    auto e = expect_throw<PermissionException>(
+        translate_http_error(&reply, QByteArray()));
+    EXPECT_EQ("message", e.error_message());
+}
+
+TEST(HttpErrorTests, 403)
+{
+    FakeReply reply("GET", 403, "Forbidden", "text/plain", "message");
+
+    auto e = expect_throw<PermissionException>(
+        translate_http_error(&reply, QByteArray()));
+    EXPECT_EQ("message", e.error_message());
+}
+
+TEST(HttpErrorTests, 451)
+{
+    FakeReply reply("GET", 451, "Unavailable for Legal Reasons",
+                    "text/plain", "message");
+
+    auto e = expect_throw<PermissionException>(
+        translate_http_error(&reply, QByteArray()));
+    EXPECT_EQ("message", e.error_message());
+}
+