Merge lp:~vds/usso/better_interface into lp:usso

[Vincenzo Di Somma]

Refactoring the interface and handling errors a little better. There are no unit tests for the main interface, but the example shows that they work as expected. Tests will be added in a following branch, if we decide to spend more time on this project.

[Graham Binns (gmb)]

Hi Vincenzo,

Thanks for this branch. There are quite a few changes that need to be
made, but they're mostly cosmetic - don't be alarmed at the size of the
review :)

I've grouped things together under common headers (so [6] refers to all
the functions without documentation, for example). That makes it a bit
non-linear, but I think it's clearer that way.

I'm marking this needs-fixing because the review is so large - just to
make it disappear from the review queue, really.

[1]

19 +var email, password, tokenName, signature_method string

We should either be using camelCase or underscore_separated names, not
both, I think. It's up to you which.

[2]

56 + // This would be the easiest way to get the account data.
57 + //accounts, _ := server.GetAccounts(ssodata)
58 + //fmt.Printf("Got accounts info: %s\n", accounts)

I'm not overly fond of leaving commented-out lines in code just for
documentation purposes. We should add this to a README rather than
leaving it here.

[3]

74 + response, err := client.Do(request)
75 + if err != nil {
76 + fmt.Printf("Error: %s\n", err)
77 + }
78 + body, err := ioutil.ReadAll(response.Body)
79 + if err != nil {
80 + fmt.Println(err)
81 + }

I may be reading this wrong (not being a proper Gopher yet and all) but
I _think_ that if client.Do(request) returns an error we should probably
exit early rather than try to do something with the response, right?
Unless the response body has something useful in it, which we can't
guarantee.

[4]

82 + var b bytes.Buffer
83 + b.Write(body)
84 + fmt.Printf("response: %+v\n", b.String())

Is there any reason to print out the body here, other than to see what's
happened?

[5]

106 +func init() {
107 + // Initialize the random generator.
108 + rand.Seed(time.Now().UTC().UnixNano())
109 +}

111 +func timestamp() string {
112 + // Create a timestamp used in authorization header.
113 + return strconv.Itoa(int(time.Now().Unix()))
114 +}

116 +func nonce() string {
117 + // Create a nonce used in authorization header.
118 + return strconv.Itoa(rand.Intn(100000000))
119 +}

136 +func (oauth *SSOData) signature() (string, error) {
137 + // Depending on the signature method, create the signature from the
138 + // consumer secret, the token secret and, if required, the URL.
139 + // Supported signature methods are PLAINTEXT and HMAC-SHA1.

457 +func (server UbuntuSSOServer) GetToken(
458 + // Giving user credentials and token name, retrieves oauth credentials
459 + // for the users, the oauth credentials can be used later to sign requests.
460 + email string, password string, tokenName string) (*SSOData, error) {

481 +func (server UbuntuSSOServer) GetAccounts(ssodata *SSOData) (string, error) {

508 +func SignRequest(ssodata *SSOData, request *http.Request) error {
509 + // Given oauth credentials and a request, return it signed.

513 +func GetAuthorizationHeader(ssodata *SSOData) (string, error) {
514 + // Given oauth credentials return a valid http authorization header.

These comments should go before the function declaration (I don't know
if godoc does The Right Thing with comments after the declaration, but
most other places do it before.)

[6]

181 +func (oauth *SSOData) GetAut...

review: Needs Fixing (code)

[Vincenzo Di Somma (vds)]

> [1]

Right, I'll fix that.

> [2]
> [3]
> [4]

All this comments are about example/usso_example.go, that's just an example of how to use the library, that's why there's some commented code and the error checking is not very accurate, I can still fix them if you like.

> [5]
> [6]

Will do.

[Graham Binns (gmb)]

> > [1]
>
> Right, I'll fix that.
>
> > [2]
> > [3]
> > [4]
>
> All this comments are about example/usso_example.go, that's just an example of
> how to use the library, that's why there's some commented code and the error
> checking is not very accurate, I can still fix them if you like.

Ah, I see. Sorry :). That's fine then :).

review: Approve (code)

[lp:~vds/usso/better_interface]

18. By Vincenzo Di Somma on 2013-01-29

Fixing comments and little code style.

19. By Vincenzo Di Somma on 2013-01-29

Commented tests.

[Graham Binns (gmb)]

Hi Vincenzo,

Thanks for addressing my concerns. I still think the documentation on the tests needs tweaking. The documentation you've added does describe the expected behaviour for which we're testing, but it does it in a rather opaque way. I've pastebinned a diff of how I think the documentation should read: https://pastebin.canonical.com/83278/

Generally, comments on tests should be written as something like:

// Foo() returns an instance of Bar when its returnBar parameter is set to true.
func (suite *FooTestSuite) TestFooReturnsBarWhenReturnBarParameterIsTrue (c *gocheck.C) {
    ...
}

review: Approve (code)

[Vincenzo Di Somma (vds)]

Ok, you are right, I'll fix it.

[lp:~vds/usso/better_interface]

20. By Vincenzo Di Somma on 2013-01-29

Commented tests in a more reasonable way thanks to gmb.

=== modified file 'example/usso_example.go'
--- example/usso_example.go	2013-01-21 16:57:31 +0000
+++ example/usso_example.go	2013-01-29 14:29:23 +0000
@@ -1,23 +1,27 @@
 package main
 
 import (
+	"bytes"
 	"encoding/json"
 	"fmt"
+	"io/ioutil"
 	"launchpad.net/usso"
+	"net/http"
 )
 
-var email string
-var password string
-var tokenName string
+var email, password, tokenName, signature_method string
 
 func inputParams() {
-	fmt.Println("This application will query the staging Ubuntu SSO Server to fetch authorisation tokens.")
+	fmt.Println("This application will query the staging Ubuntu SSO Server" +
+		" to fetch authorisation tokens.")
 	fmt.Print("Enter email: ")
 	fmt.Scanf("%s", &email)
 	fmt.Print("Enter password: ")
 	fmt.Scanf("%s", &password)
 	fmt.Print("Enter token name: ")
 	fmt.Scanf("%s", &tokenName)
+	fmt.Print("Enter signature method (PLAINTEXT or HMAC-SHA1): ")
+	fmt.Scanf("%s", &signature_method)
 }
 
 func main() {
@@ -26,16 +30,46 @@
 	// Fetch the tokens using usso.GetToken.
 	fmt.Println("Fetching tokens from staging server...")
 	server := usso.StagingUbuntuSSOServer
-	// One would use server := usso.ProductionUbuntuSSOServer to use the production Ubuntu SSO Server.
-	token, err := server.GetToken(email, password, tokenName)
+	// One would use server := usso.ProductionUbuntuSSOServer 
+	// to use the production Ubuntu SSO Server.
+	ssodata, err := server.GetToken(email, password, tokenName)
 	if err != nil {
 		panic(err)
 	}
 	// Format the result as json for displaying it:
-	json_token, err := json.Marshal(token)
+	json_token, err := json.Marshal(ssodata)
 	if err != nil {
 		panic(err)
 	}
 	fmt.Printf("Got tokens: %s\n", json_token)
 
+	// This would be the easiest way to get the account data.
+	//accounts, _ := server.GetAccounts(ssodata)
+	//fmt.Printf("Got accounts info: %s\n", accounts)
+
+	// But this shows how to sign a generic request.
+	ssodata.BaseURL = fmt.Sprintf(
+		"https://login.staging.ubuntu.com/api/v2/accounts/%s",
+		ssodata.ConsumerKey)
+	ssodata.HTTPMethod = "GET"
+	ssodata.SignatureMethod = signature_method
+	request, _ := http.NewRequest(ssodata.HTTPMethod, ssodata.BaseURL, nil)
+	usso.SignRequest(ssodata, request)
+
+	if err != nil {
+		fmt.Printf("Error: %s\n", err)
+	}
+	// run the request
+	client := &http.Client{}
+	response, err := client.Do(request)
+	if err != nil {
+		fmt.Printf("Error: %s\n", err)
+	}
+	body, err := ioutil.ReadAll(response.Body)
+	if err != nil {
+		fmt.Println(err)
+	}
+	var b bytes.Buffer
+	b.Write(body)
+	fmt.Printf("response: %+v\n", b.String())
 }

=== added file 'oauth.go'
--- oauth.go	1970-01-01 00:00:00 +0000
+++ oauth.go	2013-01-29 14:29:23 +0000
@@ -0,0 +1,126 @@
+package usso
+
+import (
+	"crypto/hmac"
+	"crypto/sha1"
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"math/rand"
+	"net/http"
+	"net/url"
+	"strconv"
+	"time"
+)
+
+// Initialize the random generator.
+func init() {
+	rand.Seed(time.Now().UTC().UnixNano())
+}
+
+// Create a timestamp used in authorization header.
+func timestamp() string {
+	return strconv.Itoa(int(time.Now().Unix()))
+}
+
+// Create a nonce used in authorization header.
+func nonce() string {
+	return strconv.Itoa(rand.Intn(100000000))
+}
+
+// Contains the oauth data to perform a request.
+type SSOData struct {
+	HTTPMethod      string     `json:"-"`
+	BaseURL         string     `json:"-"`
+	Params          url.Values `json:"-"`
+	Nonce           string     `json:"-"`
+	Timestamp       string     `json:"-"`
+	SignatureMethod string     `json:"-"`
+	ConsumerKey     string     `json:"consumer_key"`
+	ConsumerSecret  string     `json:"consumer_secret"`
+	TokenKey        string     `json:"token_key"`
+	TokenName       string     `json:"token_name"`
+	TokenSecret     string     `json:"token_secret"`
+}
+
+// Depending on the signature method, create the signature from the 
+// consumer secret, the token secret and, if required, the URL.
+// Supported signature methods are PLAINTEXT and HMAC-SHA1.
+func (oauth *SSOData) signature() (string, error) {
+	switch oauth.SignatureMethod {
+	case "PLAINTEXT":
+		return fmt.Sprintf(
+			`%s%%26%s`,
+			oauth.ConsumerSecret,
+			oauth.TokenSecret), nil
+	case "HMAC-SHA1":
+		base_url, err := NormalizeURL(oauth.BaseURL)
+		if err != nil {
+			return "", err
+		}
+		params, err := NormalizeParameters(oauth.Params)
+		if err != nil {
+			return "", err
+		}
+		base_string := fmt.Sprintf(`%s&%s&%s%s%s%s%s%s%s`,
+			oauth.HTTPMethod,
+			url.QueryEscape(base_url),
+			url.QueryEscape(params),
+			url.QueryEscape("oauth_consumer_key="+oauth.ConsumerKey),
+			url.QueryEscape("&oauth_nonce="+oauth.Nonce),
+			url.QueryEscape("&oauth_signature_method="+oauth.SignatureMethod),
+			url.QueryEscape("&oauth_timestamp="+oauth.Timestamp),
+			url.QueryEscape("&oauth_token="+oauth.TokenKey),
+			url.QueryEscape("&oauth_version=1.0"))
+		hashfun := hmac.New(sha1.New, []byte(
+			oauth.ConsumerSecret+"&"+oauth.TokenSecret))
+		hashfun.Write([]byte(base_string))
+		rawsignature := hashfun.Sum(nil)
+		base64signature := make(
+			[]byte, base64.StdEncoding.EncodedLen(len(rawsignature)))
+		base64.StdEncoding.Encode(base64signature, rawsignature)
+		return string(base64signature), nil
+	default:
+		return "", errors.New(
+			"usso/oauth: Oauth Signature Method not supported.")
+	}
+	return "", nil
+}
+
+// Sign the provided request.
+func (oauth *SSOData) GetAuthorizationHeader() (string, error) {
+	if oauth.Nonce == "" {
+		oauth.Nonce = nonce()
+	}
+	if oauth.Timestamp == "" {
+		oauth.Timestamp = timestamp()
+	}
+	signature, err := oauth.signature()
+	if err != nil {
+		return "", err
+	}
+	auth := fmt.Sprintf(
+		`OAuth realm="API", `+
+			`oauth_consumer_key="%s", `+
+			`oauth_token="%s", `+
+			`oauth_signature_method="%s", `+
+			`oauth_signature="%s", `+
+			`oauth_timestamp="%s", `+
+			`oauth_nonce="%s", `+
+			`oauth_version="1.0"`,
+		url.QueryEscape(oauth.ConsumerKey),
+		url.QueryEscape(oauth.TokenKey),
+		oauth.SignatureMethod,
+		signature,
+		url.QueryEscape(oauth.Timestamp),
+		url.QueryEscape(oauth.Nonce))
+
+	return auth, nil
+}
+
+// Sign the provided request.
+func (oauth *SSOData) SignRequest(req *http.Request) error {
+	auth, error := oauth.GetAuthorizationHeader()
+	req.Header.Add("Authorization", auth)
+	return error
+}

=== added file 'oauth_test.go'
--- oauth_test.go	1970-01-01 00:00:00 +0000
+++ oauth_test.go	2013-01-29 14:29:23 +0000
@@ -0,0 +1,52 @@
+package usso
+
+import (
+	. "launchpad.net/gocheck"
+	"net/http"
+	"net/url"
+)
+
+func (suite *USSOTestSuite) TestSignRequestPlainText(c *C) {
+	baseUrl := "https://localhost"
+	ssodata := SSOData{BaseURL: baseUrl, ConsumerKey: consumerKey,
+		ConsumerSecret: consumerSecret, TokenKey: tokenKey,
+		TokenName: tokenName, TokenSecret: tokenSecret}
+	request, _ := http.NewRequest("GET", baseUrl, nil)
+	ssodata.HTTPMethod = "GET"
+	ssodata.SignatureMethod = "PLAINTEXT"
+	err := ssodata.SignRequest(request)
+	c.Assert(err, IsNil)
+	authHeader := request.Header["Authorization"][0]
+	c.Assert(authHeader, Matches, `^OAuth.*`)
+	c.Assert(authHeader, Matches, `.*realm="API".*`)
+	c.Assert(authHeader, Matches,
+		`.*oauth_consumer_key="`+url.QueryEscape(ssodata.ConsumerKey)+`".*`)
+	c.Assert(authHeader, Matches,
+		`.*oauth_token="`+url.QueryEscape(ssodata.TokenKey)+`".*`)
+	c.Assert(authHeader, Matches,
+		`.*oauth_signature="`+url.QueryEscape(
+			ssodata.ConsumerSecret+`&`+ssodata.TokenSecret)+`.*`)
+}
+
+// Test the request signing with oauth_signature_method = SHA1
+func (suite *USSOTestSuite) TestSignRequestSHA1(c *C) {
+	baseUrl := "https://localhost"
+	ssodata := SSOData{BaseURL: baseUrl, ConsumerKey: consumerKey,
+		ConsumerSecret: consumerSecret, TokenKey: tokenKey,
+		TokenName: tokenName, TokenSecret: tokenSecret,
+		Nonce: "10888885", Timestamp: "1358853126"}
+	request, _ := http.NewRequest("GET", baseUrl, nil)
+	ssodata.HTTPMethod = "GET"
+	ssodata.SignatureMethod = "HMAC-SHA1"
+	err := ssodata.SignRequest(request)
+	c.Assert(err, IsNil)
+	authHeader := request.Header["Authorization"][0]
+	c.Assert(authHeader, Matches, `^OAuth.*`)
+	c.Assert(authHeader, Matches, `.*realm="API".*`)
+	c.Assert(authHeader, Matches,
+		`.*oauth_consumer_key="`+url.QueryEscape(ssodata.ConsumerKey)+`".*`)
+	c.Assert(authHeader, Matches,
+		`.*oauth_token="`+url.QueryEscape(ssodata.TokenKey)+`".*`)
+	c.Assert(authHeader, Matches,
+		`.*oauth_signature="`+"amJnYeek4G9ObTgTiE2y6cwTyPg="+`.*`)
+}

=== added file 'url.go'
--- url.go	1970-01-01 00:00:00 +0000
+++ url.go	2013-01-29 14:29:23 +0000
@@ -0,0 +1,45 @@
+package usso
+
+import (
+	"fmt"
+	"net/url"
+	"strings"
+)
+
+// Remove the standard ports from the URL.
+func normalizeHost(scheme, host_spec string) string {
+	standard_ports := map[string]string{
+		"http":  "80",
+		"https": "443",
+	}
+	host_parts := strings.Split(host_spec, ":")
+	if len(host_parts) == 2 && host_parts[1] == standard_ports[scheme] {
+		// There's a port, but it's the default one.  Leave it out.
+		return host_parts[0]
+	}
+	return host_spec
+}
+
+// Normalize the URL according to OAuth specs.
+func NormalizeURL(input_url string) (string, error) {
+	parsed_url, err := url.Parse(input_url)
+	if err != nil {
+		return "", err
+	}
+
+	host := normalizeHost(parsed_url.Scheme, parsed_url.Host)
+	normalized_url := fmt.Sprintf(
+		"%v://%v%v", parsed_url.Scheme, host, parsed_url.Path)
+	return normalized_url, nil
+}
+
+// Normalize the parameters in the query string according to OAuth specs.
+func NormalizeParameters(parameters url.Values) (string, error) {
+	filtered_map := make(url.Values, len(parameters))
+	for param, value := range parameters {
+		if param != "oauth_signature" {
+			filtered_map[param] = value
+		}
+	}
+	return filtered_map.Encode(), nil
+}

=== added file 'url_test.go'
--- url_test.go	1970-01-01 00:00:00 +0000
+++ url_test.go	2013-01-29 14:29:23 +0000
@@ -0,0 +1,88 @@
+package usso
+
+import (
+	"launchpad.net/gocheck"
+	"net/url"
+)
+
+// When NormalizeURL() is passed a simple URL, it will make no changes
+// to it.
+func (suite *USSOTestSuite) TestNormalizeURLReturnsBasicURL(c *gocheck.C) {
+	output, err := NormalizeURL("http://example.com/path")
+	c.Check(err, gocheck.Equals, nil)
+	c.Check(output, gocheck.Equals, "http://example.com/path")
+}
+
+// NormalizeURL() strips the ":80" from http:// URLs that contain it.
+func (suite *USSOTestSuite) TestNormalizeURLStripsStandardHTTPPort(
+	c *gocheck.C) {
+	output, err := NormalizeURL("http://example.com:80/path")
+	c.Check(err, gocheck.Equals, nil)
+	c.Check(output, gocheck.Equals, "http://example.com/path")
+}
+
+// NormalizeURL() strips the ":443" from https:// URLs that contain it.
+func (suite *USSOTestSuite) TestNormalizeURLStripsStandardHTTPSPort(
+	c *gocheck.C) {
+	output, err := NormalizeURL("https://example.com:443/path")
+	c.Check(err, gocheck.Equals, nil)
+	c.Check(output, gocheck.Equals, "https://example.com/path")
+}
+
+// NormalizeURL() does not remove non-standard ports from the URL.
+func (suite *USSOTestSuite) TestNormalizeURLLeavesNonstandardPort(
+	c *gocheck.C) {
+	output, err := NormalizeURL("http://example.com:8080/")
+	c.Check(err, gocheck.Equals, nil)
+	c.Check(output, gocheck.Equals, "http://example.com:8080/")
+}
+
+// NormalizeURL() strips the query string from URLs.
+func (suite *USSOTestSuite) TestNormalizeURLStripsParameters(c *gocheck.C) {
+	output, err := NormalizeURL("http://example.com/path?query=value&param=arg")
+	c.Check(err, gocheck.Equals, nil)
+	c.Check(output, gocheck.Equals, "http://example.com/path")
+}
+
+// NormalizeParameters() takes a url.Values instance and returns an
+// encoded key=value string containing the parameters in that instance.
+func (suite *USSOTestSuite) TestNormalizeParametersReturnsParameters(
+	c *gocheck.C) {
+	output, err := NormalizeParameters(url.Values{"param": []string{"value"}})
+	c.Check(err, gocheck.Equals, nil)
+	c.Check(output, gocheck.Equals, "param=value")
+}
+
+// NormalizeParameters() encodes multiple key/value parameters as a
+// query string.
+func (suite *USSOTestSuite) TestNormalizeParametersConcatenatesParameters(
+	c *gocheck.C) {
+	output, err := NormalizeParameters(
+		url.Values{"a": []string{"1"}, "b": []string{"2"}})
+	c.Check(err, gocheck.Equals, nil)
+	c.Check(output, gocheck.Matches, "(a=1&b=2|b=2&a=1)")
+}
+
+// NormalizeParameters() escapes the parameters correctly when encoding
+// them as a query string.
+func (suite *USSOTestSuite) TestNormalizeParametersEscapesParameters(
+	c *gocheck.C) {
+	output, err := NormalizeParameters(url.Values{"a&b": []string{"1"}})
+	c.Check(err, gocheck.Equals, nil)
+	c.Check(output, gocheck.Equals, "a%26b=1")
+}
+
+// If oauth_signature appears in the parameters passed to
+// NormalizeParameters(), it is omitted in the returned string as it does not
+// have to be included in the computation of the new oauth_signature.
+func (suite *USSOTestSuite) TestNormalizeParametersOmitsOAuthSignature(
+	c *gocheck.C) {
+	params := url.Values{
+		"a":               []string{"1"},
+		"oauth_signature": []string{"foobarsplatszot"},
+		"z":               []string{"26"},
+	}
+	output, err := NormalizeParameters(params)
+	c.Check(err, gocheck.Equals, nil)
+	c.Check(output, gocheck.Matches, "(a=1&z=26|z=26&a=1)")
+}

=== modified file 'usso.go'
--- usso.go	2013-01-25 11:38:14 +0000
+++ usso.go	2013-01-29 14:29:23 +0000
@@ -1,13 +1,13 @@
 package usso
 
 import (
+	"bytes"
 	"encoding/json"
+	"fmt"
 	"io/ioutil"
 	"log"
 	"math/rand"
 	"net/http"
-	"net/url"
-	"strconv"
 	"strings"
 	"time"
 )
@@ -26,6 +26,12 @@
 	return server.baseUrl + "/api/v2/tokens"
 }
 
+// AccountURL returns the URL where the Ubuntu SSO account information can be 
+// requested.
+func (server UbuntuSSOServer) AccountsURL() string {
+	return server.baseUrl + "/api/v2/accounts/"
+}
+
 // ProductionUbuntuSSOServer represents the production Ubuntu SSO server
 // located at https://login.ubuntu.com.
 var ProductionUbuntuSSOServer = UbuntuSSOServer{"https://login.ubuntu.com"}
@@ -34,16 +40,10 @@
 // at https://login.staging.ubuntu.com. Use it for testing.
 var StagingUbuntuSSOServer = UbuntuSSOServer{"https://login.staging.ubuntu.com"}
 
-type SSOData struct {
-	BaseURL        string
-	ConsumerKey    string `json:"consumer_key"`
-	ConsumerSecret string `json:"consumer_secret"`
-	TokenKey       string `json:"token_key"`
-	TokenName      string `json:"token_name"`
-	TokenSecret    string `json:"token_secret"`
-}
-
-func (server UbuntuSSOServer) GetToken(email string, password string, tokenName string) (*SSOData, error) {
+// Giving user credentials and token name, retrieves oauth credentials
+// for the users, the oauth credentials can be used later to sign requests.
+func (server UbuntuSSOServer) GetToken(
+	email string, password string, tokenName string) (*SSOData, error) {
 	credentials := map[string]string{
 		"email":      email,
 		"password":   password,
@@ -75,17 +75,40 @@
 	return &ssodata, nil
 }
 
-func (oauth *SSOData) Sign(req *http.Request) error {
-	// Sign the provided request.
-	auth := `OAuth realm="API", ` +
-		`oauth_consumer_key="` + url.QueryEscape(oauth.ConsumerKey) + `", ` +
-		`oauth_token="` + url.QueryEscape(oauth.TokenKey) + `", ` +
-		`oauth_signature_method="PLAINTEXT", ` +
-		`oauth_signature="` + url.QueryEscape(
-		oauth.ConsumerSecret+`&`+oauth.TokenSecret) + `", ` +
-		`oauth_timestamp="` + strconv.FormatInt(time.Now().Unix(), 10) + `", ` +
-		`oauth_nonce="` + strconv.Itoa(int(rand.Intn(99999999))) + `", ` +
-		`oauth_version="1.0"`
-	req.Header.Add("Authorization", auth)
-	return nil
+// Returns all the Ubuntu SSO information related to this account.
+func (server UbuntuSSOServer) GetAccounts(ssodata *SSOData) (string, error) {
+	ssodata.BaseURL = server.AccountsURL() + ssodata.ConsumerKey
+	ssodata.HTTPMethod = "GET"
+	ssodata.SignatureMethod = "HMAC-SHA1"
+	request, err := http.NewRequest(ssodata.HTTPMethod, ssodata.BaseURL, nil)
+	if err != nil {
+		return "", err
+	}
+	err = SignRequest(ssodata, request)
+	if err != nil {
+		return "", err
+	}
+	client := &http.Client{}
+	response, err := client.Do(request)
+	if err != nil {
+		fmt.Printf("Error: %s\n", err)
+	}
+	body, err := ioutil.ReadAll(response.Body)
+	if err != nil {
+		fmt.Println(err)
+	}
+	var b bytes.Buffer
+	b.Write(body)
+	return fmt.Sprint(b.String()), nil
+}
+
+// Given oauth credentials and a request, return it signed.
+func SignRequest(ssodata *SSOData, request *http.Request) error {
+	return ssodata.SignRequest(request)
+}
+
+// Given oauth credentials return a valid http authorization header.
+func GetAuthorizationHeader(ssodata *SSOData) (string, error) {
+	header, err := ssodata.GetAuthorizationHeader()
+	return header, err
 }

=== modified file 'usso_test.go'
--- usso_test.go	2013-01-25 11:38:14 +0000
+++ usso_test.go	2013-01-29 14:29:23 +0000
@@ -7,7 +7,6 @@
 	. "launchpad.net/gocheck"
 	"net/http"
 	"net/http/httptest"
-	"net/url"
 	"testing"
 )
 
@@ -46,7 +45,8 @@
 
 // newSingleServingServer create a single-serving test http server which will
 // return only one response as defined by the passed arguments.
-func newSingleServingServer(uri string, response string, code int) *SingleServingServer {
+func newSingleServingServer(
+	uri string, response string, code int) *SingleServingServer {
 	var requestContent string
 	var requested bool
 	handler := func(w http.ResponseWriter, r *http.Request) {
@@ -86,16 +86,19 @@
 	if err != nil {
 		panic(err)
 	}
-	server := newSingleServingServer("/api/v2/tokens", string(jsonServerResponseData), 200)
+	server := newSingleServingServer("/api/v2/tokens",
+		string(jsonServerResponseData), 200)
 	var testSSOServer = &UbuntuSSOServer{server.URL}
 	defer server.Close()
 
 	// The returned information is correct.
 	ssodata, err := testSSOServer.GetToken(email, password, tokenName)
 	c.Assert(err, IsNil)
-	expectedSSOData := &SSOData{ConsumerKey: consumerKey, ConsumerSecret: consumerSecret, TokenKey: tokenKey, TokenSecret: tokenSecret, TokenName: tokenName}
+	expectedSSOData := &SSOData{ConsumerKey: consumerKey,
+		ConsumerSecret: consumerSecret, TokenKey: tokenKey,
+		TokenSecret: tokenSecret, TokenName: tokenName}
 	c.Assert(ssodata, DeepEquals, expectedSSOData)
-	// The request that the fake Ubuntu SSO Server got contained the credentials.
+	//The request that the fake Ubuntu SSO Server got contained the credentials.
 	credentials := map[string]string{
 		"email":      email,
 		"password":   password,
@@ -107,18 +110,3 @@
 	}
 	c.Assert(*server.requestContent, Equals, string(expectedRequestContent))
 }
-
-func (suite *USSOTestSuite) TestSignRequestPlainText(c *C) {
-	baseUrl := "https://localhost"
-	ssoData := SSOData{BaseURL: baseUrl, ConsumerKey: consumerKey, ConsumerSecret: consumerSecret, TokenKey: tokenKey, TokenName: tokenName, TokenSecret: tokenSecret}
-	request, _ := http.NewRequest("GET", baseUrl, nil)
-
-	err := ssoData.Sign(request)
-
-	c.Assert(err, IsNil)
-	authHeader := request.Header["Authorization"][0]
-	c.Assert(authHeader, Matches, `.*OAuth realm="API".*`)
-	c.Assert(authHeader, Matches, `.*oauth_consumer_key="`+url.QueryEscape(ssoData.ConsumerKey)+`".*`)
-	c.Assert(authHeader, Matches, `.*oauth_token="`+url.QueryEscape(ssoData.TokenKey)+`".*`)
-	c.Assert(authHeader, Matches, `.*oauth_signature="`+url.QueryEscape(ssoData.ConsumerSecret+`&`+ssoData.TokenSecret)+`.*`)
-}