Remove all references to version.Current.Arch and remove the field.
By definition the value of version.Current.Arch will be the same as
arch.HostArch(), so use that value wherever required to make this
explicit.

api/provisioner/provisioner_test.go

@@ -805,7 +805,13 @@ func (s *provisionerSuite) TestFindToolsLogicError(c *gc.C) {
 }
 
 func (s *provisionerSuite) testFindTools(c *gc.C, matchArch bool, apiError, logicError error) {
-	var toolsList = coretools.List{&coretools.Tools{Version: version.Current}}
+	current := version.Binary{
+		Number: version.Current.Number,
+		Series: version.Current.Series,
+		Arch:   arch.HostArch(),
+		OS:     version.Current.OS,
+	}
+	var toolsList = coretools.List{&coretools.Tools{Version: current}}
 	var called bool
 	var a string
 	if matchArch {

api/upgrader/unitupgrader_test.go

@@ -12,6 +12,7 @@ import (
 	"github.com/juju/juju/api"
 	"github.com/juju/juju/api/upgrader"
 	"github.com/juju/juju/apiserver/params"
+	"github.com/juju/juju/juju/arch"
 	jujutesting "github.com/juju/juju/juju/testing"
 	"github.com/juju/juju/state"
 	statetesting "github.com/juju/juju/state/testing"
@@ -62,19 +63,36 @@ func (s *unitUpgraderSuite) addMachineServiceCharmAndUnit(c *gc.C, serviceName s
 }
 
 func (s *unitUpgraderSuite) TestSetVersionWrongUnit(c *gc.C) {
-	err := s.st.SetVersion("unit-wordpress-42", version.Current)
+	current := version.Binary{
+		Number: version.Current.Number,
+		Series: version.Current.Series,
+		Arch:   arch.HostArch(),
+		OS:     version.Current.OS,
+	}
+	err := s.st.SetVersion("unit-wordpress-42", current)
 	c.Assert(err, gc.ErrorMatches, "permission denied")
 	c.Assert(err, jc.Satisfies, params.IsCodeUnauthorized)
 }
 
 func (s *unitUpgraderSuite) TestSetVersionNotUnit(c *gc.C) {
-	err := s.st.SetVersion("foo-42", version.Current)
+	current := version.Binary{
+		Number: version.Current.Number,
+		Series: version.Current.Series,
+		Arch:   arch.HostArch(),
+		OS:     version.Current.OS,
+	}
+	err := s.st.SetVersion("foo-42", current)
 	c.Assert(err, gc.ErrorMatches, "permission denied")
 	c.Assert(err, jc.Satisfies, params.IsCodeUnauthorized)
 }
 
 func (s *unitUpgraderSuite) TestSetVersion(c *gc.C) {
-	cur := version.Current
+	cur := version.Binary{
+		Number: version.Current.Number,
+		Series: version.Current.Series,
+		Arch:   arch.HostArch(),
+		OS:     version.Current.OS,
+	}
 	agentTools, err := s.rawUnit.AgentTools()
 	c.Assert(err, jc.Satisfies, errors.IsNotFound)
 	c.Assert(agentTools, gc.IsNil)
@@ -101,7 +119,12 @@ func (s *unitUpgraderSuite) TestToolsNotUnit(c *gc.C) {
 }
 
 func (s *unitUpgraderSuite) TestTools(c *gc.C) {
-	cur := version.Current
+	cur := version.Binary{
+		Number: version.Current.Number,
+		Series: version.Current.Series,
+		Arch:   arch.HostArch(),
+		OS:     version.Current.OS,
+	}
 	curTools := &tools.Tools{Version: cur, URL: ""}
 	curTools.Version.Minor++
 	s.rawMachine.SetAgentVersion(cur)
@@ -146,7 +169,12 @@ func (s *unitUpgraderSuite) TestWatchAPIVersionNotUnit(c *gc.C) {
 }
 
 func (s *unitUpgraderSuite) TestDesiredVersion(c *gc.C) {
-	cur := version.Current
+	cur := version.Binary{
+		Number: version.Current.Number,
+		Series: version.Current.Series,
+		Arch:   arch.HostArch(),
+		OS:     version.Current.OS,
+	}
 	curTools := &tools.Tools{Version: cur, URL: ""}
 	curTools.Version.Minor++
 	s.rawMachine.SetAgentVersion(cur)

api/upgrader/upgrader_test.go

@@ -14,6 +14,7 @@ import (
 	"github.com/juju/juju/api"
 	"github.com/juju/juju/api/upgrader"
 	"github.com/juju/juju/apiserver/params"
+	"github.com/juju/juju/juju/arch"
 	"github.com/juju/juju/juju/testing"
 	"github.com/juju/juju/state"
 	statetesting "github.com/juju/juju/state/testing"
@@ -56,19 +57,36 @@ func (s *machineUpgraderSuite) TestNew(c *gc.C) {
 }
 
 func (s *machineUpgraderSuite) TestSetVersionWrongMachine(c *gc.C) {
-	err := s.st.SetVersion("machine-42", version.Current)
+	current := version.Binary{
+		Number: version.Current.Number,
+		Series: version.Current.Series,
+		Arch:   arch.HostArch(),
+		OS:     version.Current.OS,
+	}
+	err := s.st.SetVersion("machine-42", current)
 	c.Assert(err, gc.ErrorMatches, "permission denied")
 	c.Assert(err, jc.Satisfies, params.IsCodeUnauthorized)
 }
 
 func (s *machineUpgraderSuite) TestSetVersionNotMachine(c *gc.C) {
-	err := s.st.SetVersion("foo-42", version.Current)
+	current := version.Binary{
+		Number: version.Current.Number,
+		Series: version.Current.Series,
+		Arch:   arch.HostArch(),
+		OS:     version.Current.OS,
+	}
+	err := s.st.SetVersion("foo-42", current)
 	c.Assert(err, gc.ErrorMatches, "permission denied")
 	c.Assert(err, jc.Satisfies, params.IsCodeUnauthorized)
 }
 
 func (s *machineUpgraderSuite) TestSetVersion(c *gc.C) {
-	cur := version.Current
+	cur := version.Binary{
+		Number: version.Current.Number,
+		Series: version.Current.Series,
+		Arch:   arch.HostArch(),
+		OS:     version.Current.OS,
+	}
 	agentTools, err := s.rawMachine.AgentTools()
 	c.Assert(err, jc.Satisfies, errors.IsNotFound)
 	c.Assert(agentTools, gc.IsNil)
@@ -95,7 +113,12 @@ func (s *machineUpgraderSuite) TestToolsNotMachine(c *gc.C) {
 }
 
 func (s *machineUpgraderSuite) TestTools(c *gc.C) {
-	cur := version.Current
+	cur := version.Binary{
+		Number: version.Current.Number,
+		Series: version.Current.Series,
+		Arch:   arch.HostArch(),
+		OS:     version.Current.OS,
+	}
 	curTools := &tools.Tools{Version: cur, URL: ""}
 	curTools.Version.Minor++
 	s.rawMachine.SetAgentVersion(cur)
@@ -134,7 +157,12 @@ func (s *machineUpgraderSuite) TestWatchAPIVersion(c *gc.C) {
 }
 
 func (s *machineUpgraderSuite) TestDesiredVersion(c *gc.C) {
-	cur := version.Current
+	cur := version.Binary{
+		Number: version.Current.Number,
+		Series: version.Current.Series,
+		Arch:   arch.HostArch(),
+		OS:     version.Current.OS,
+	}
 	curTools := &tools.Tools{Version: cur, URL: ""}
 	curTools.Version.Minor++
 	s.rawMachine.SetAgentVersion(cur)

apiserver/common/tools_test.go

@@ -48,7 +48,13 @@ func (s *toolsSuite) TestTools(c *gc.C) {
 	tg := common.NewToolsGetter(s.State, s.State, s.State, sprintfURLGetter("tools:%s"), getCanRead)
 	c.Assert(tg, gc.NotNil)
 
-	err := s.machine0.SetAgentVersion(version.Current)
+	current := version.Binary{
+		Number: version.Current.Number,
+		Series: version.Current.Series,
+		Arch:   arch.HostArch(),
+		OS:     version.Current.OS,
+	}
+	err := s.machine0.SetAgentVersion(current)
 	c.Assert(err, jc.ErrorIsNil)
 
 	args := params.Entities{
@@ -62,8 +68,8 @@ func (s *toolsSuite) TestTools(c *gc.C) {
 	c.Assert(result.Results, gc.HasLen, 3)
 	c.Assert(result.Results[0].Error, gc.IsNil)
 	c.Assert(result.Results[0].Tools, gc.NotNil)
-	c.Assert(result.Results[0].Tools.Version, gc.DeepEquals, version.Current)
-	c.Assert(result.Results[0].Tools.URL, gc.Equals, "tools:"+version.Current.String())
+	c.Assert(result.Results[0].Tools.Version, gc.DeepEquals, current)
+	c.Assert(result.Results[0].Tools.URL, gc.Equals, "tools:"+current.String())
 	c.Assert(result.Results[0].DisableSSLHostnameVerification, jc.IsTrue)
 	c.Assert(result.Results[1].Error, gc.DeepEquals, apiservertesting.ErrUnauthorized)
 	c.Assert(result.Results[2].Error, gc.DeepEquals, apiservertesting.NotFoundError("machine 42"))
@@ -91,24 +97,30 @@ func (s *toolsSuite) TestSetTools(c *gc.C) {
 	ts := common.NewToolsSetter(s.State, getCanWrite)
 	c.Assert(ts, gc.NotNil)
 
-	err := s.machine0.SetAgentVersion(version.Current)
+	current := version.Binary{
+		Number: version.Current.Number,
+		Series: version.Current.Series,
+		Arch:   arch.HostArch(),
+		OS:     version.Current.OS,
+	}
+	err := s.machine0.SetAgentVersion(current)
 	c.Assert(err, jc.ErrorIsNil)
 
 	args := params.EntitiesVersion{
 		AgentTools: []params.EntityVersion{{
 			Tag: "machine-0",
 			Tools: &params.Version{
-				Version: version.Current,
+				Version: current,
 			},
 		}, {
 			Tag: "machine-1",
 			Tools: &params.Version{
-				Version: version.Current,
+				Version: current,
 			},
 		}, {
 			Tag: "machine-42",
 			Tools: &params.Version{
-				Version: version.Current,
+				Version: current,
 			},
 		}},
 	}
@@ -118,7 +130,7 @@ func (s *toolsSuite) TestSetTools(c *gc.C) {
 	c.Assert(result.Results[0].Error, gc.IsNil)
 	agentTools, err := s.machine0.AgentTools()
 	c.Assert(err, jc.ErrorIsNil)
-	c.Assert(agentTools.Version, gc.DeepEquals, version.Current)
+	c.Assert(agentTools.Version, gc.DeepEquals, current)
 	c.Assert(result.Results[1].Error, gc.DeepEquals, apiservertesting.ErrUnauthorized)
 	c.Assert(result.Results[2].Error, gc.DeepEquals, apiservertesting.NotFoundError("machine 42"))
 }
@@ -127,12 +139,18 @@ func (s *toolsSuite) TestToolsSetError(c *gc.C) {
 	getCanWrite := func() (common.AuthFunc, error) {
 		return nil, fmt.Errorf("splat")
 	}
+	current := version.Binary{
+		Number: version.Current.Number,
+		Series: version.Current.Series,
+		Arch:   arch.HostArch(),
+		OS:     version.Current.OS,
+	}
 	ts := common.NewToolsSetter(s.State, getCanWrite)
 	args := params.EntitiesVersion{
 		AgentTools: []params.EntityVersion{{
 			Tag: "machine-42",
 			Tools: &params.Version{
-				Version: version.Current,
+				Version: current,
 			},
 		}},
 	}
@@ -196,18 +214,25 @@ func (s *toolsSuite) TestFindToolsNotFound(c *gc.C) {
 	c.Assert(result.Error, jc.Satisfies, params.IsCodeNotFound)
 }
 
+func (s *toolsSuite) patchVersion(v version.Binary) {
+	s.PatchValue(&arch.HostArch, func() string { return v.Arch })
+	fake := version.Current
+	fake.Number = v.Number
+	fake.Series = v.Series
+	fake.OS = v.OS
+	s.PatchValue(&version.Current, fake)
+}
+
 func (s *toolsSuite) TestFindToolsExactInStorage(c *gc.C) {
 	mockToolsStorage := &mockToolsStorage{
 		metadata: []toolstorage.Metadata{
 			{Version: version.MustParseBinary("1.22-beta1-trusty-amd64")},
 			{Version: version.MustParseBinary("1.22.0-trusty-amd64")},
 		},
 	}
-
-	s.PatchValue(&arch.HostArch, func() string { return arch.AMD64 })
-	s.PatchValue(&version.Current, version.MustParseBinary("1.22-beta1-trusty-amd64"))
+	s.patchVersion(version.MustParseBinary("1.22-beta1-trusty-amd64"))
 	s.testFindToolsExact(c, mockToolsStorage, true, true)
-	s.PatchValue(&version.Current, version.MustParseBinary("1.22.0-trusty-amd64"))
+	s.patchVersion(version.MustParseBinary("1.22.0-trusty-amd64"))
 	s.testFindToolsExact(c, mockToolsStorage, true, false)
 }
 
@@ -274,13 +299,25 @@ func (s *toolsSuite) TestFindToolsToolsStorageError(c *gc.C) {
 
 func (s *toolsSuite) TestToolsURLGetterNoAPIHostPorts(c *gc.C) {
 	g := common.NewToolsURLGetter("my-uuid", mockAPIHostPortsGetter{})
-	_, err := g.ToolsURL(version.Current)
+	current := version.Binary{
+		Number: version.Current.Number,
+		Series: version.Current.Series,
+		Arch:   arch.HostArch(),
+		OS:     version.Current.OS,
+	}
+	_, err := g.ToolsURL(current)
 	c.Assert(err, gc.ErrorMatches, "no API host ports")
 }
 
 func (s *toolsSuite) TestToolsURLGetterAPIHostPortsError(c *gc.C) {
 	g := common.NewToolsURLGetter("my-uuid", mockAPIHostPortsGetter{err: errors.New("oh noes")})
-	_, err := g.ToolsURL(version.Current)
+	current := version.Binary{
+		Number: version.Current.Number,
+		Series: version.Current.Series,
+		Arch:   arch.HostArch(),
+		OS:     version.Current.OS,
+	}
+	_, err := g.ToolsURL(current)
 	c.Assert(err, gc.ErrorMatches, "oh noes")
 }
 
@@ -290,7 +327,13 @@ func (s *toolsSuite) TestToolsURLGetter(c *gc.C) {
 			network.NewHostPorts(1234, "0.1.2.3"),
 		},
 	})
-	url, err := g.ToolsURL(version.Current)
+	current := version.Binary{
+		Number: version.Current.Number,
+		Series: version.Current.Series,
+		Arch:   arch.HostArch(),
+		OS:     version.Current.OS,
+	}
+	url, err := g.ToolsURL(current)
 	c.Assert(err, jc.ErrorIsNil)
 	c.Assert(url, gc.Equals, "https://0.1.2.3:1234/environment/my-uuid/tools/"+version.Current.String())
 }