Merge lp:~mandel/ubuntu-download-manager/update-go-bindings into lp:ubuntu-download-manager

[Manuel de la Peña]

Add the SetLocationDir method that was missing from the golang API. Add missing tests to ensure the correct use of dbus.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:258
http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-ci/631/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-trusty-amd64-ci/521
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-trusty-armhf-ci/520

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-download-manager-ci/631/rebuild

review: Approve (continuous-integration)

[Sergio Schvezov (sergiusens)]

433 + . "gopkg.in/check.v1"

just use the real name, it's packaged as such in the archives.

review: Needs Fixing

[lp:~mandel/ubuntu-download-manager/update-go-bindings]

259. By Manuel de la Peña on 2014-04-29

Merged filter-all-per-app into update-go-bindings.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:259
http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-ci/637/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-trusty-amd64-ci/527
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-trusty-armhf-ci/526

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-download-manager-ci/637/rebuild

review: Approve (continuous-integration)

[lp:~mandel/ubuntu-download-manager/update-go-bindings]

260. By Manuel de la Peña on 2014-04-29

Merged filter-all-per-app into update-go-bindings.

261. By Manuel de la Peña on 2014-04-30

Merged filter-all-per-app into update-go-bindings.

262. By Manuel de la Peña on 2014-05-07

Reduce the diff in the following branches by making the generalized moves in this branch.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:262
http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-ci/644/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-utopic-amd64-ci/3/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-utopic-armhf-ci/3/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-download-manager-ci/644/rebuild

review: Needs Fixing (continuous-integration)

[lp:~mandel/ubuntu-download-manager/update-go-bindings]

263. By Manuel de la Peña on 2014-05-08

Merged filter-all-per-app into update-go-bindings.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:263
http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-ci/652/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-utopic-amd64-ci/11/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-utopic-armhf-ci/11/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-download-manager-ci/652/rebuild

review: Needs Fixing (continuous-integration)

[lp:~mandel/ubuntu-download-manager/update-go-bindings]

264. By Manuel de la Peña on 2014-05-09

Fix criss-cross issues.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:264
http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-ci/657/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-utopic-amd64-ci/16
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-utopic-armhf-ci/16
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-utopic-armhf-ci/16/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-download-manager-ci/657/rebuild

review: Approve (continuous-integration)

=== added file 'bindings/golang/common.go'
--- bindings/golang/common.go	1970-01-01 00:00:00 +0000
+++ bindings/golang/common.go	2014-05-09 08:51:26 +0000
@@ -0,0 +1,78 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * Authors:
+ * Manuel de la Pena: [e-mail]
+ *
+ * This file is part of ubuntu-download-manager.
+ *
+ * ubuntu-download-manager 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; version 3.
+ *
+ * ubuntu-download-manager 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/>.
+ */
+
+// Package udm provides a go interface to work with the ubuntu download manager
+package udm
+
+import (
+	"launchpad.net/go-dbus/v1"
+)
+
+// Progress provides how much progress has been performed in a download that was
+// already started.
+type Progress struct {
+	Received uint64
+	Total    uint64
+}
+
+// internal interface used to simplify testing
+type watch interface {
+	Cancel() error
+	Chanel() chan *dbus.Message
+}
+
+// small wrapper used to simplify testing by using the watch interface
+type watchWrapper struct {
+	watch *dbus.SignalWatch
+}
+
+func newWatchWrapper(sw *dbus.SignalWatch) *watchWrapper {
+	w := watchWrapper{}
+	return &w
+}
+
+func (w *watchWrapper) Cancel() error {
+	return w.watch.Cancel()
+}
+
+func (w *watchWrapper) Chanel() chan *dbus.Message {
+	return w.watch.C
+}
+
+// interface added to simplify testing
+type proxy interface {
+	Call(iface, method string, args ...interface{}) (*dbus.Message, error)
+}
+
+var readArgs = func(msg *dbus.Message, args ...interface{}) error {
+	return msg.Args(args)
+}
+
+func connectToSignal(conn *dbus.Connection, path dbus.ObjectPath, signal string) (watch, error) {
+	sw, err := conn.WatchSignal(&dbus.MatchRule{
+		Type:      dbus.TypeSignal,
+		Sender:    DOWNLOAD_SERVICE,
+		Interface: DOWNLOAD_INTERFACE,
+		Member:    signal,
+		Path:      path})
+	w := newWatchWrapper(sw)
+	return w, err
+}

=== added file 'bindings/golang/common_test.go'
--- bindings/golang/common_test.go	1970-01-01 00:00:00 +0000
+++ bindings/golang/common_test.go	2014-05-09 08:51:26 +0000
@@ -0,0 +1,83 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * Authors:
+ * Manuel de la Pena: [e-mail]
+ *
+ * This file is part of ubuntu-download-manager.
+ *
+ * ubuntu-download-manager 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; version 3.
+ *
+ * ubuntu-download-manager 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/>.
+ */
+
+package udm
+
+import (
+	. "gopkg.in/check.v1"
+	"launchpad.net/go-dbus/v1"
+	"testing"
+)
+
+func Test(t *testing.T) { TestingT(t) }
+
+type fakeProxy struct {
+	Interface  string
+	MethodName string
+	Args       []interface{}
+	Err        error
+	Result     *dbus.Message
+}
+
+func (f *fakeProxy) Call(iface, method string, args ...interface{}) (*dbus.Message, error) {
+	// store the called method and return Result
+	f.Interface = iface
+	f.MethodName = method
+	f.Args = args
+	if f.Err == nil {
+		return f.Result, nil
+	}
+	return nil, f.Err
+}
+
+type FakeWatch struct {
+	Canceled bool
+	Ch       chan *dbus.Message
+}
+
+func newFakeWatch() *FakeWatch {
+	ch := make(chan *dbus.Message)
+	fw := FakeWatch{false, ch}
+	return &fw
+}
+
+func (w *FakeWatch) Cancel() error {
+	w.Canceled = true
+	return nil
+}
+
+func (w *FakeWatch) Chanel() chan *dbus.Message {
+	return w.Ch
+}
+
+// returns a new error that can be used in the tests
+func newDBusError() *dbus.Message {
+	msg := dbus.NewMethodCallMessage("com.destination", "/path", "com.interface", "method")
+	msg.Type = dbus.TypeError
+	msg.ErrorName = "com.testing.udm"
+	return msg
+}
+
+func newDBusReturn() *dbus.Message {
+	msg := dbus.NewMethodCallMessage("com.destination", "/path", "com.interface", "method")
+	msg.Type = dbus.TypeMethodReturn
+	return msg
+}

=== renamed file 'bindings/golang/udm.go' => 'bindings/golang/downloader.go'
--- bindings/golang/udm.go	2014-03-19 11:57:35 +0000
+++ bindings/golang/downloader.go	2014-05-09 08:51:26 +0000
@@ -24,6 +24,7 @@
 
 import (
 	"errors"
+	"fmt"
 	"launchpad.net/go-dbus/v1"
 	"runtime"
 )
@@ -51,13 +52,6 @@
 	POST_DOWNLOAD_COMMAND = "post-download-command"
 )
 
-// Progress provides how much progress has been performed in a download that was
-// already started.
-type Progress struct {
-	Received uint64
-	Total    uint64
-}
-
 // Download is the common interface of a download. It provides all the required
 // methods to interact with a download created by udm.
 type Download interface {
@@ -67,6 +61,7 @@
 	SetThrottle(uint64) error
 	Throttle() (uint64, error)
 	AllowMobileDownload(bool) error
+	SetDestinationDir(string) error
 	IsMobileDownload() (bool, error)
 	Start() error
 	Pause() error
@@ -81,42 +76,25 @@
 	Error() chan error
 }
 
-// Manager is the single point of entry of the API. Allows to interact with the
-// general setting of udm as well as to create downloads at will.
-type Manager interface {
-	CreateDownload(string, string, string, map[string]interface{}, map[string]string) (Download, error)
-	CreateMmsDownload(string, string, int, string, string) (Download, error)
-}
-
 // FileDownload represents a single file being downloaded by udm.
 type FileDownload struct {
 	conn       *dbus.Connection
-	proxy      *dbus.ObjectProxy
+	proxy      proxy
 	path       dbus.ObjectPath
 	started    chan bool
-	started_w  *dbus.SignalWatch
+	started_w  watch
 	paused     chan bool
-	paused_w   *dbus.SignalWatch
+	paused_w   watch
 	resumed    chan bool
-	resumed_w  *dbus.SignalWatch
+	resumed_w  watch
 	canceled   chan bool
-	canceled_w *dbus.SignalWatch
+	canceled_w watch
 	finished   chan string
-	finished_w *dbus.SignalWatch
+	finished_w watch
 	errors     chan error
-	error_w    *dbus.SignalWatch
+	error_w    watch
 	progress   chan Progress
-	progress_w *dbus.SignalWatch
-}
-
-func connectToSignal(conn *dbus.Connection, path dbus.ObjectPath, signal string) (*dbus.SignalWatch, error) {
-	w, err := conn.WatchSignal(&dbus.MatchRule{
-		Type:      dbus.TypeSignal,
-		Sender:    DOWNLOAD_SERVICE,
-		Interface: DOWNLOAD_INTERFACE,
-		Member:    signal,
-		Path:      path})
-	return w, err
+	progress_w watch
 }
 
 func (down *FileDownload) free() {
@@ -197,10 +175,15 @@
 // TotalSize returns the total size of the file being downloaded.
 func (down *FileDownload) TotalSize() (size uint64, err error) {
 	reply, err := down.proxy.Call(DOWNLOAD_INTERFACE, "totalSize")
-	if err != nil || reply.Type == dbus.TypeError {
+	if err != nil {
 		return 0, err
 	}
-	if err = reply.Args(&size); err != nil {
+
+	if reply.Type == dbus.TypeError {
+		return 0, fmt.Errorf("DBus Error: %", reply.ErrorName)
+	}
+
+	if err = readArgs(reply, &size); err != nil {
 		return 0, err
 	}
 	return size, nil
@@ -209,10 +192,15 @@
 // Process returns the process so far in downloading the file.
 func (down *FileDownload) Progress() (progress uint64, err error) {
 	reply, err := down.proxy.Call(DOWNLOAD_INTERFACE, "progress")
-	if err != nil || reply.Type == dbus.TypeError {
+	if err != nil {
 		return 0, err
 	}
-	if err = reply.Args(&progress); err != nil {
+
+	if reply.Type == dbus.TypeError {
+		return 0, fmt.Errorf("DBus Error: %", reply.ErrorName)
+	}
+
+	if err = readArgs(reply, &progress); err != nil {
 		return 0, err
 	}
 	return progress, nil
@@ -221,10 +209,15 @@
 // Metadata returns the metadata that was provided at creating time to the download.
 func (down *FileDownload) Metadata() (metadata map[string]string, err error) {
 	reply, err := down.proxy.Call(DOWNLOAD_INTERFACE, "metadata")
-	if err != nil || reply.Type == dbus.TypeError {
+	if err != nil {
 		return nil, err
 	}
-	if err = reply.Args(&metadata); err != nil {
+
+	if reply.Type == dbus.TypeError {
+		return nil, fmt.Errorf("DBus Error: %", reply.ErrorName)
+	}
+
+	if err = readArgs(reply, &metadata); err != nil {
 		return nil, err
 	}
 	return metadata, nil
@@ -233,19 +226,29 @@
 // SetThrottle sets the network throttle to be used in the download.
 func (down *FileDownload) SetThrottle(throttle uint64) (err error) {
 	reply, err := down.proxy.Call(DOWNLOAD_INTERFACE, "setThrottle", throttle)
-	if err != nil || reply.Type == dbus.TypeError {
+	if err != nil {
 		return err
 	}
+
+	if reply.Type == dbus.TypeError {
+		return fmt.Errorf("DBus Error: %", reply.ErrorName)
+	}
+
 	return nil
 }
 
 // Throttle returns the network throttle that is currently used in the download.
 func (down *FileDownload) Throttle() (throttle uint64, err error) {
 	reply, err := down.proxy.Call(DOWNLOAD_INTERFACE, "throttle")
-	if err != nil || reply.Type == dbus.TypeError {
+	if err != nil {
 		return 0, err
 	}
-	if err = reply.Args(&throttle); err != nil {
+
+	if reply.Type == dbus.TypeError {
+		return 0, fmt.Errorf("DBus Error: %", reply.ErrorName)
+	}
+
+	if err = readArgs(reply, &throttle); err != nil {
 		return 0, err
 	}
 	return throttle, nil
@@ -255,26 +258,52 @@
 // connection.
 func (down *FileDownload) AllowMobileDownload(allowed bool) (err error) {
 	reply, err := down.proxy.Call(DOWNLOAD_INTERFACE, "allowGSMDownload", allowed)
-	if err != nil || reply.Type == dbus.TypeError {
-		return err
-	}
+	if err != nil {
+		return err
+	}
+
+	if reply.Type == dbus.TypeError {
+		return fmt.Errorf("DBus Error: %", reply.ErrorName)
+	}
+
+	return nil
+}
+
+// SetDestinationDir permits unconfined applications to set the destination
+// directory of the download. This method must be called BEFORE the download
+// is started else an error will be returned.
+func (down *FileDownload) SetDestinationDir(path string) (err error) {
+	reply, err := down.proxy.Call(DOWNLOAD_INTERFACE, "setDestinationDir", path)
+	if err != nil {
+		return err
+	}
+
+	if reply.Type == dbus.TypeError {
+		return fmt.Errorf("DBus Error: %", reply.ErrorName)
+	}
+
 	return nil
 }
 
 // IsMobileDownload returns if the download will be performed over the mobile data.
 func (down *FileDownload) IsMobileDownload() (allowed bool, err error) {
 	reply, err := down.proxy.Call(DOWNLOAD_INTERFACE, "isGSMDownloadAllowed", allowed)
-	if err != nil || reply.Type == dbus.TypeError {
+	if err != nil {
 		return false, err
 	}
-	if err = reply.Args(&allowed); err != nil {
+
+	if reply.Type == dbus.TypeError {
+		return false, fmt.Errorf("DBus Error: %", reply.ErrorName)
+	}
+
+	if err = readArgs(reply, &allowed); err != nil {
 		return false, err
 	}
 	return allowed, nil
 }
 
 // Start tells udm that the download is ready to be peformed and that the client is
-// ready to recieve signals. The following is a commong pattern to be used when
+// ready to recieve signals. The following is a common pattern to be used when
 // creating downloads in udm.
 //
 //     man, err := udm.NewDownloadManager()
@@ -317,27 +346,42 @@
 //     <- finished_signal
 func (down *FileDownload) Start() (err error) {
 	reply, err := down.proxy.Call(DOWNLOAD_INTERFACE, "start")
-	if err != nil || reply.Type == dbus.TypeError {
+	if err != nil {
 		return err
 	}
+
+	if reply.Type == dbus.TypeError {
+		return fmt.Errorf("DBus Error: %", reply.ErrorName)
+	}
+
 	return nil
 }
 
 // Pause pauses a download that was started and if not nothing is done.
 func (down *FileDownload) Pause() (err error) {
 	reply, err := down.proxy.Call(DOWNLOAD_INTERFACE, "pause")
-	if err != nil || reply.Type == dbus.TypeError {
+	if err != nil {
 		return err
 	}
+
+	if reply.Type == dbus.TypeError {
+		return fmt.Errorf("DBus Error: %", reply.ErrorName)
+	}
+
 	return nil
 }
 
 // Resumes a download that was paused or does nothing otherwise.
 func (down *FileDownload) Resume() (err error) {
 	reply, err := down.proxy.Call(DOWNLOAD_INTERFACE, "resume")
-	if err != nil || reply.Type == dbus.TypeError {
+	if err != nil {
 		return err
 	}
+
+	if reply.Type == dbus.TypeError {
+		return fmt.Errorf("DBus Error: %", reply.ErrorName)
+	}
+
 	return nil
 }
 
@@ -345,17 +389,22 @@
 // that were created.
 func (down *FileDownload) Cancel() (err error) {
 	reply, err := down.proxy.Call(DOWNLOAD_INTERFACE, "cancel")
-	if err != nil || reply.Type == dbus.TypeError {
+	if err != nil {
 		return err
 	}
+
+	if reply.Type == dbus.TypeError {
+		return fmt.Errorf("DBus Error: %", reply.ErrorName)
+	}
+
 	return nil
 }
 
 func (down *FileDownload) connectToStarted() {
 	go func() {
-		for msg := range down.started_w.C {
+		for msg := range down.started_w.Chanel() {
 			var started bool
-			msg.Args(&started)
+			readArgs(msg, &started)
 			down.started <- started
 		}
 		close(down.started)
@@ -369,9 +418,9 @@
 
 func (down *FileDownload) connectToPaused() {
 	go func() {
-		for msg := range down.paused_w.C {
+		for msg := range down.paused_w.Chanel() {
 			var paused bool
-			msg.Args(&paused)
+			readArgs(msg, &paused)
 			down.paused <- paused
 		}
 		close(down.paused)
@@ -385,10 +434,10 @@
 
 func (down *FileDownload) connectToProgress() {
 	go func() {
-		for msg := range down.progress_w.C {
+		for msg := range down.progress_w.Chanel() {
 			var received uint64
 			var total uint64
-			msg.Args(&received, &total)
+			readArgs(msg, &received, &total)
 			down.progress <- Progress{received, total}
 		}
 		close(down.progress)
@@ -403,9 +452,9 @@
 
 func (down *FileDownload) connectToResumed() {
 	go func() {
-		for msg := range down.resumed_w.C {
+		for msg := range down.resumed_w.Chanel() {
 			var resumed bool
-			msg.Args(&resumed)
+			readArgs(msg, &resumed)
 			down.resumed <- resumed
 		}
 		close(down.resumed)
@@ -419,9 +468,9 @@
 
 func (down *FileDownload) connectToCanceled() {
 	go func() {
-		for msg := range down.canceled_w.C {
+		for msg := range down.canceled_w.Chanel() {
 			var canceled bool
-			msg.Args(&canceled)
+			readArgs(msg, &canceled)
 			down.canceled <- canceled
 		}
 		close(down.canceled)
@@ -435,9 +484,9 @@
 
 func (down *FileDownload) connectToFinished() {
 	go func() {
-		for msg := range down.finished_w.C {
+		for msg := range down.finished_w.Chanel() {
 			var path string
-			msg.Args(&path)
+			readArgs(msg, &path)
 			down.finished <- path
 		}
 		close(down.finished)
@@ -451,9 +500,9 @@
 
 func (down *FileDownload) connectToError() {
 	go func() {
-		for msg := range down.error_w.C {
+		for msg := range down.error_w.Chanel() {
 			var reason string
-			msg.Args(&reason)
+			readArgs(msg, &reason)
 			down.errors <- errors.New(reason)
 		}
 		close(down.errors)
@@ -527,7 +576,7 @@
 	if err != nil || reply.Type == dbus.TypeError {
 		return nil, err
 	}
-	if err = reply.Args(&path); err != nil {
+	if err = readArgs(reply, &path); err != nil {
 		return nil, err
 	}
 	down, err = newFileDownload(man.conn, path)
@@ -543,7 +592,7 @@
 	if err != nil || reply.Type == dbus.TypeError {
 		return nil, err
 	}
-	if err = reply.Args(&path); err != nil {
+	if err = readArgs(reply, &path); err != nil {
 		return nil, err
 	}
 	down, err = newFileDownload(man.conn, path)

=== added file 'bindings/golang/downloader_test.go'
--- bindings/golang/downloader_test.go	1970-01-01 00:00:00 +0000
+++ bindings/golang/downloader_test.go	2014-05-09 08:51:26 +0000
@@ -0,0 +1,306 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * Authors:
+ * Manuel de la Pena: [e-mail]
+ *
+ * This file is part of ubuntu-download-manager.
+ *
+ * ubuntu-download-manager 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; version 3.
+ *
+ * ubuntu-download-manager 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/>.
+ */
+
+package udm
+
+import (
+	"errors"
+	. "gopkg.in/check.v1"
+	"launchpad.net/go-dbus/v1"
+	"reflect"
+)
+
+type DownloadSuite struct {
+	proxy        *fakeProxy
+	download     *FileDownload
+	msg_args     []interface{}
+	msg_args_err error
+	started_ch   chan bool
+	started_w    watch
+	paused_ch    chan bool
+	paused_w     watch
+	resumed_ch   chan bool
+	resumed_w    watch
+	canceled_ch  chan bool
+	canceled_w   watch
+	finished_ch  chan string
+	finished_w   watch
+	errors_ch    chan error
+	errors_w     watch
+	progress_ch  chan Progress
+	progress_w   watch
+}
+
+var _ = Suite(&DownloadSuite{})
+
+func (s *DownloadSuite) SetUpTest(c *C) {
+	s.proxy = &fakeProxy{}
+	s.started_ch = make(chan bool)
+	s.started_w = newFakeWatch()
+	s.paused_ch = make(chan bool)
+	s.paused_w = newFakeWatch()
+	s.resumed_ch = make(chan bool)
+	s.resumed_w = newFakeWatch()
+	s.canceled_ch = make(chan bool)
+	s.canceled_w = newFakeWatch()
+	s.finished_ch = make(chan string)
+	s.finished_w = newFakeWatch()
+	s.errors_ch = make(chan error)
+	s.errors_w = newFakeWatch()
+	s.progress_ch = make(chan Progress)
+	s.progress_w = newFakeWatch()
+	s.download = &FileDownload{nil, s.proxy, "", s.started_ch, s.started_w, s.paused_ch, s.paused_w, s.resumed_ch, s.resumed_w, s.canceled_ch, s.canceled_w, s.finished_ch, s.finished_w, s.errors_ch, s.errors_w, s.progress_ch, s.progress_w}
+
+	readArgs = func(msg *dbus.Message, args ...interface{}) error {
+		for i, arg := range args {
+			v := reflect.ValueOf(arg)
+			e := v.Elem()
+			switch s.msg_args[i].(type) {
+			default:
+				return errors.New("unexpected type")
+			case bool:
+				e.SetBool(s.msg_args[i].(bool))
+			case uint64:
+				e.SetUint(s.msg_args[i].(uint64))
+			}
+		}
+		return s.msg_args_err
+	}
+}
+
+func (s *DownloadSuite) TestTotalSizeError(c *C) {
+	s.proxy.Result = newDBusError()
+	size, err := s.download.TotalSize()
+	c.Assert(s.proxy.Interface, Equals, DOWNLOAD_INTERFACE)
+	c.Assert(s.proxy.MethodName, Equals, "totalSize")
+	c.Assert(size, Equals, uint64(0))
+	c.Assert(err, NotNil)
+}
+
+func (s *DownloadSuite) TestTotalSize(c *C) {
+	expected_size := uint64(98)
+	s.proxy.Result = newDBusReturn()
+	s.msg_args = make([]interface{}, 1)
+	s.msg_args[0] = expected_size
+	s.msg_args_err = nil
+	size, err := s.download.TotalSize()
+	c.Assert(s.proxy.Interface, Equals, DOWNLOAD_INTERFACE)
+	c.Assert(s.proxy.MethodName, Equals, "totalSize")
+	c.Assert(err, IsNil)
+	c.Assert(size, Equals, expected_size)
+}
+
+func (s *DownloadSuite) TestProgressError(c *C) {
+	s.proxy.Result = newDBusError()
+	progress, err := s.download.Progress()
+	c.Assert(s.proxy.Interface, Equals, DOWNLOAD_INTERFACE)
+	c.Assert(s.proxy.MethodName, Equals, "progress")
+	c.Assert(progress, Equals, uint64(0))
+	c.Assert(err, NotNil)
+}
+
+func (s *DownloadSuite) TestProgress(c *C) {
+	expected_progress := uint64(98)
+	s.proxy.Result = newDBusReturn()
+	s.msg_args = make([]interface{}, 1)
+	s.msg_args[0] = expected_progress
+	s.msg_args_err = nil
+	progress, err := s.download.Progress()
+	c.Assert(s.proxy.Interface, Equals, DOWNLOAD_INTERFACE)
+	c.Assert(s.proxy.MethodName, Equals, "progress")
+	c.Assert(err, IsNil)
+	c.Assert(progress, Equals, expected_progress)
+}
+
+func (s *DownloadSuite) TestMetadataError(c *C) {
+	s.proxy.Result = newDBusError()
+	metadata, err := s.download.Metadata()
+	c.Assert(s.proxy.Interface, Equals, DOWNLOAD_INTERFACE)
+	c.Assert(s.proxy.MethodName, Equals, "metadata")
+	c.Assert(metadata, IsNil)
+	c.Assert(err, NotNil)
+}
+
+func (s *DownloadSuite) TestSetThrotthleError(c *C) {
+	throttle := uint64(9)
+	s.proxy.Result = newDBusError()
+	err := s.download.SetThrottle(throttle)
+	c.Assert(s.proxy.Interface, Equals, DOWNLOAD_INTERFACE)
+	c.Assert(s.proxy.MethodName, Equals, "setThrottle")
+	c.Assert(err, NotNil)
+	c.Assert(s.proxy.Args[0], Equals, throttle)
+}
+
+func (s *DownloadSuite) TestSetThrottle(c *C) {
+	s.proxy.Result = newDBusReturn()
+	err := s.download.SetThrottle(uint64(9))
+	c.Assert(s.proxy.Interface, Equals, DOWNLOAD_INTERFACE)
+	c.Assert(s.proxy.MethodName, Equals, "setThrottle")
+	c.Assert(err, IsNil)
+}
+
+func (s *DownloadSuite) TestThrottleError(c *C) {
+	s.proxy.Result = newDBusError()
+	size, err := s.download.Throttle()
+	c.Assert(s.proxy.Interface, Equals, DOWNLOAD_INTERFACE)
+	c.Assert(s.proxy.MethodName, Equals, "throttle")
+	c.Assert(size, Equals, uint64(0))
+	c.Assert(err, NotNil)
+}
+
+func (s *DownloadSuite) TestThrottle(c *C) {
+	expected_throttle := uint64(98)
+	s.proxy.Result = newDBusReturn()
+	s.msg_args = make([]interface{}, 1)
+	s.msg_args[0] = expected_throttle
+	s.msg_args_err = nil
+	throttle, err := s.download.Throttle()
+	c.Assert(s.proxy.Interface, Equals, DOWNLOAD_INTERFACE)
+	c.Assert(s.proxy.MethodName, Equals, "throttle")
+	c.Assert(err, IsNil)
+	c.Assert(throttle, Equals, expected_throttle)
+}
+
+func (s *DownloadSuite) TestAllowMobileDownloadError(c *C) {
+	s.proxy.Result = newDBusError()
+	err := s.download.AllowMobileDownload(true)
+	c.Assert(s.proxy.Interface, Equals, DOWNLOAD_INTERFACE)
+	c.Assert(s.proxy.MethodName, Equals, "allowGSMDownload")
+	c.Assert(err, NotNil)
+}
+
+func (s *DownloadSuite) TestAllowMobileDownload(c *C) {
+	expected_allowed := true
+	s.proxy.Result = newDBusReturn()
+	err := s.download.AllowMobileDownload(expected_allowed)
+	c.Assert(s.proxy.Interface, Equals, DOWNLOAD_INTERFACE)
+	c.Assert(s.proxy.MethodName, Equals, "allowGSMDownload")
+	c.Assert(err, IsNil)
+	c.Assert(s.proxy.Args[0], Equals, expected_allowed)
+}
+
+func (s *DownloadSuite) TestSetDestinationDirError(c *C) {
+	s.proxy.Result = newDBusError()
+	err := s.download.SetDestinationDir("/new/path")
+	c.Assert(s.proxy.Interface, Equals, DOWNLOAD_INTERFACE)
+	c.Assert(s.proxy.MethodName, Equals, "setDestinationDir")
+	c.Assert(err, NotNil)
+}
+
+func (s *DownloadSuite) TestSetDestinationDir(c *C) {
+	expected_dir := "/path/to/use"
+	s.proxy.Result = newDBusReturn()
+	err := s.download.SetDestinationDir(expected_dir)
+	c.Assert(s.proxy.Interface, Equals, DOWNLOAD_INTERFACE)
+	c.Assert(s.proxy.MethodName, Equals, "setDestinationDir")
+	c.Assert(err, IsNil)
+	c.Assert(s.proxy.Args[0], Equals, expected_dir)
+}
+
+func (s *DownloadSuite) TestIsMobileDownloadError(c *C) {
+	s.proxy.Result = newDBusError()
+	allowed, err := s.download.IsMobileDownload()
+	c.Assert(s.proxy.Interface, Equals, DOWNLOAD_INTERFACE)
+	c.Assert(s.proxy.MethodName, Equals, "isGSMDownloadAllowed")
+	c.Assert(allowed, Equals, false)
+	c.Assert(err, NotNil)
+}
+
+func (s *DownloadSuite) TestIsMobileDownload(c *C) {
+	expected_allowed := true
+	s.proxy.Result = newDBusReturn()
+	s.msg_args = make([]interface{}, 1)
+	s.msg_args[0] = expected_allowed
+	s.msg_args_err = nil
+	allowed, err := s.download.IsMobileDownload()
+	c.Assert(s.proxy.Interface, Equals, DOWNLOAD_INTERFACE)
+	c.Assert(s.proxy.MethodName, Equals, "isGSMDownloadAllowed")
+	c.Assert(err, IsNil)
+	c.Assert(allowed, Equals, expected_allowed)
+}
+
+func (s *DownloadSuite) TestStartDBusError(c *C) {
+	s.proxy.Result = newDBusError()
+	err := s.download.Start()
+	c.Assert(s.proxy.Interface, Equals, DOWNLOAD_INTERFACE)
+	c.Assert(s.proxy.MethodName, Equals, "start")
+	c.Assert(err, NotNil)
+}
+
+func (s *DownloadSuite) TestStartError(c *C) {
+	s.proxy.Result = newDBusReturn()
+	s.proxy.Err = errors.New("Fake error")
+	err := s.download.Start()
+	c.Assert(s.proxy.Interface, Equals, DOWNLOAD_INTERFACE)
+	c.Assert(s.proxy.MethodName, Equals, "start")
+	c.Assert(err, NotNil)
+}
+
+func (s *DownloadSuite) TestPauseDBusError(c *C) {
+	s.proxy.Result = newDBusError()
+	err := s.download.Pause()
+	c.Assert(s.proxy.Interface, Equals, DOWNLOAD_INTERFACE)
+	c.Assert(s.proxy.MethodName, Equals, "pause")
+	c.Assert(err, NotNil)
+}
+
+func (s *DownloadSuite) TestPauseError(c *C) {
+	s.proxy.Result = newDBusReturn()
+	s.proxy.Err = errors.New("Fake error")
+	err := s.download.Pause()
+	c.Assert(s.proxy.Interface, Equals, DOWNLOAD_INTERFACE)
+	c.Assert(s.proxy.MethodName, Equals, "pause")
+	c.Assert(err, NotNil)
+}
+
+func (s *DownloadSuite) TestResumeDBusError(c *C) {
+	s.proxy.Result = newDBusError()
+	err := s.download.Resume()
+	c.Assert(s.proxy.Interface, Equals, DOWNLOAD_INTERFACE)
+	c.Assert(s.proxy.MethodName, Equals, "resume")
+	c.Assert(err, NotNil)
+}
+
+func (s *DownloadSuite) TestResumeError(c *C) {
+	s.proxy.Result = newDBusReturn()
+	s.proxy.Err = errors.New("Fake error")
+	err := s.download.Resume()
+	c.Assert(s.proxy.Interface, Equals, DOWNLOAD_INTERFACE)
+	c.Assert(s.proxy.MethodName, Equals, "resume")
+	c.Assert(err, NotNil)
+}
+
+func (s *DownloadSuite) TestCancelDBusError(c *C) {
+	s.proxy.Result = newDBusError()
+	err := s.download.Cancel()
+	c.Assert(s.proxy.Interface, Equals, DOWNLOAD_INTERFACE)
+	c.Assert(s.proxy.MethodName, Equals, "cancel")
+	c.Assert(err, NotNil)
+}
+
+func (s *DownloadSuite) TestCancelError(c *C) {
+	s.proxy.Result = newDBusReturn()
+	s.proxy.Err = errors.New("Fake error")
+	err := s.download.Cancel()
+	c.Assert(s.proxy.Interface, Equals, DOWNLOAD_INTERFACE)
+	c.Assert(s.proxy.MethodName, Equals, "cancel")
+	c.Assert(err, NotNil)
+}