func (s *BootstrapSuite) SetUpTest(c *gc.C) { s.FakeJujuHomeSuite.SetUpTest(c) s.MgoSuite.SetUpTest(c) s.ToolsFixture.SetUpTest(c) // Set version.Current to a known value, for which we // will make tools available. Individual tests may // override this. s.PatchValue(&version.Current, v100p64.Number) s.PatchValue(&arch.HostArch, func() string { return v100p64.Arch }) s.PatchValue(&series.HostSeries, func() string { return v100p64.Series }) s.PatchValue(&jujuos.HostOS, func() jujuos.OSType { return jujuos.Ubuntu }) // Set up a local source with tools. sourceDir := createToolsSource(c, vAll) s.PatchValue(&envtools.DefaultBaseURL, sourceDir) s.PatchValue(&envtools.BundleTools, toolstesting.GetMockBundleTools(c)) s.mockBlockClient = &mockBlockClient{} s.PatchValue(&blockAPI, func(c *modelcmd.ModelCommandBase) (block.BlockListAPI, error) { return s.mockBlockClient, nil }) s.modelFlags = []string{"-m", "--model"} }
func (s *BootstrapSuite) SetUpTest(c *gc.C) { s.FakeJujuXDGDataHomeSuite.SetUpTest(c) s.MgoSuite.SetUpTest(c) s.ToolsFixture.SetUpTest(c) // Set jujuversion.Current to a known value, for which we // will make tools available. Individual tests may // override this. s.PatchValue(&jujuversion.Current, v100p64.Number) s.PatchValue(&arch.HostArch, func() string { return v100p64.Arch }) s.PatchValue(&series.HostSeries, func() string { return v100p64.Series }) s.PatchValue(&jujuos.HostOS, func() jujuos.OSType { return jujuos.Ubuntu }) // Set up a local source with tools. sourceDir := createToolsSource(c, vAll) s.PatchValue(&envtools.DefaultBaseURL, sourceDir) s.PatchValue(&envtools.BundleTools, toolstesting.GetMockBundleTools(c)) s.PatchValue(&waitForAgentInitialisation, func(*cmd.Context, *modelcmd.ModelCommandBase, string) error { return nil }) // TODO(wallyworld) - add test data when tests are improved s.store = jujuclienttesting.NewMemStore() }
func (s *uploadSuite) TestSyncTools(c *gc.C) { s.PatchValue(&envtools.BundleTools, toolstesting.GetMockBundleTools(c)) builtTools, err := sync.BuildToolsTarball(nil) c.Assert(err, gc.IsNil) t, err := sync.SyncBuiltTools(s.env.Storage(), builtTools) c.Assert(err, gc.IsNil) c.Assert(t.Version, gc.Equals, version.Current) c.Assert(t.URL, gc.Not(gc.Equals), "") }
func (t *LiveTests) SetUpTest(c *gc.C) { t.CleanupSuite.SetUpTest(c) storageDir := c.MkDir() t.DefaultBaseURL = "file://" + storageDir + "/tools" t.ToolsFixture.SetUpTest(c) stor, err := filestorage.NewFileStorageWriter(storageDir) c.Assert(err, jc.ErrorIsNil) t.UploadFakeTools(c, stor, "released", "released") t.toolsStorage = stor t.CleanupSuite.PatchValue(&envtools.BundleTools, envtoolstesting.GetMockBundleTools(c)) }
func (s *BootstrapSuite) SetUpTest(c *gc.C) { s.FakeJujuHomeSuite.SetUpTest(c) s.MgoSuite.SetUpTest(c) s.ToolsFixture.SetUpTest(c) // Set up a local source with tools. sourceDir := createToolsSource(c, vAll) s.PatchValue(&envtools.DefaultBaseURL, sourceDir) s.PatchValue(&envtools.BundleTools, toolstesting.GetMockBundleTools(c)) }
func (s *bootstrapSuite) TestBootstrapTools(c *gc.C) { s.PatchValue(&envtools.BundleTools, toolstesting.GetMockBundleTools(c)) allTests := append(envtesting.BootstrapToolsTests, bootstrapSetAgentVersionTests...) // version.Current is set in the loop so ensure it is restored later. s.PatchValue(&version.Current, version.Current) for i, test := range allTests { c.Logf("\ntest %d: %s", i, test.Info) dummy.Reset() attrs := dummy.SampleConfig().Merge(coretesting.Attrs{ "state-server": false, "development": test.Development, "default-series": test.DefaultSeries, }) if test.AgentVersion != version.Zero { attrs["agent-version"] = test.AgentVersion.String() } cfg, err := config.New(config.NoDefaults, attrs) c.Assert(err, gc.IsNil) env, err := environs.Prepare(cfg, coretesting.Context(c), configstore.NewMem()) c.Assert(err, gc.IsNil) envtesting.RemoveAllTools(c, env) version.Current = test.CliVersion envtesting.AssertUploadFakeToolsVersions(c, env.Storage(), test.Available...) // Remove the default tools URL from the search path, just look in cloud storage. s.PatchValue(&envtools.DefaultBaseURL, "") cons := constraints.Value{} if test.Arch != "" { cons = constraints.MustParse("arch=" + test.Arch) } err = bootstrap.Bootstrap(coretesting.Context(c), env, environs.BootstrapParams{Constraints: cons}) if test.Err != "" { c.Check(err, gc.NotNil) if err != nil { stripped := strings.Replace(err.Error(), "\n", "", -1) c.Check(stripped, gc.Matches, ".*"+stripped) } continue } else { c.Check(err, gc.IsNil) } unique := map[version.Number]bool{} for _, expected := range test.Expect { unique[expected.Number] = true } for expectAgentVersion := range unique { agentVersion, ok := env.Config().AgentVersion() c.Check(ok, gc.Equals, true) c.Check(agentVersion, gc.Equals, expectAgentVersion) } } }
func (s *badBuildSuite) TestBuildToolsBadBuild(c *gc.C) { // Test that original BuildAgentTarball fails builtTools, err := sync.BuildAgentTarball(true, nil, "released") c.Assert(err, gc.ErrorMatches, `cannot build jujud agent binary from source: build command \"go\" failed: exit status 1; `) c.Assert(builtTools, gc.IsNil) // Test that BuildAgentTarball func passes after BundleTools func is // mocked out s.PatchValue(&envtools.BundleTools, toolstesting.GetMockBundleTools(c, nil)) builtTools, err = sync.BuildAgentTarball(true, nil, "released") s.assertEqualsCurrentVersion(c, builtTools.Version) c.Assert(err, jc.ErrorIsNil) }
func (t *LiveTests) SetUpTest(c *gc.C) { t.CleanupSuite.SetUpTest(c) t.PatchValue(&jujuversion.Current, coretesting.FakeVersionNumber) storageDir := c.MkDir() baseUrlPath := filepath.Join(storageDir, "tools") t.DefaultBaseURL = utils.MakeFileURL(baseUrlPath) t.ToolsFixture.SetUpTest(c) stor, err := filestorage.NewFileStorageWriter(storageDir) c.Assert(err, jc.ErrorIsNil) t.UploadFakeTools(c, stor, "released", "released") t.toolsStorage = stor t.CleanupSuite.PatchValue(&envtools.BundleTools, envtoolstesting.GetMockBundleTools(c)) }
func (s *badBuildSuite) TestUploadToolsBadBuild(c *gc.C) { // Test that original Upload Func fails as expected t, err := sync.Upload(s.env.Storage(), nil) c.Assert(t, gc.IsNil) c.Assert(err, gc.ErrorMatches, `build command "go" failed: exit status 1; `) // Test that Upload func passes after BundleTools func is mocked out s.PatchValue(&envtools.BundleTools, toolstesting.GetMockBundleTools(c)) t, err = sync.Upload(s.env.Storage(), nil) c.Assert(err, gc.IsNil) c.Assert(t.Version, gc.Equals, version.Current) c.Assert(t.URL, gc.Not(gc.Equals), "") }
func (s *badBuildSuite) TestBuildToolsBadBuild(c *gc.C) { // Test that original BuildToolsTarball fails builtTools, err := sync.BuildToolsTarball(nil) c.Assert(err, gc.ErrorMatches, `build command "go" failed: exit status 1; `) c.Assert(builtTools, gc.IsNil) // Test that BuildToolsTarball func passes after BundleTools func is // mocked out s.PatchValue(&envtools.BundleTools, toolstesting.GetMockBundleTools(c)) builtTools, err = sync.BuildToolsTarball(nil) c.Assert(builtTools.Version, gc.Equals, version.Current) c.Assert(err, gc.IsNil) }
func (s *BootstrapSuite) setupAutoUploadTest(c *gc.C, vers, series string) environs.Environ { s.PatchValue(&envtools.BundleTools, toolstesting.GetMockBundleTools(c)) sourceDir := createToolsSource(c, vAll) s.PatchValue(&envtools.DefaultBaseURL, sourceDir) // Change the tools location to be the test location and also // the version and ensure their later restoring. // Set the current version to be something for which there are no tools // so we can test that an upload is forced. s.PatchValue(&version.Current, version.MustParseBinary(vers+"-"+series+"-"+arch.HostArch())) // Create home with dummy provider and remove all // of its envtools. return resetJujuHome(c, "devenv") }
func (s *BootstrapSuite) setupAutoUploadTest(c *gc.C, vers, ser string) { s.PatchValue(&envtools.BundleTools, toolstesting.GetMockBundleTools(c)) sourceDir := createToolsSource(c, vAll) s.PatchValue(&envtools.DefaultBaseURL, sourceDir) // Change the tools location to be the test location and also // the version and ensure their later restoring. // Set the current version to be something for which there are no tools // so we can test that an upload is forced. s.PatchValue(&jujuversion.Current, version.MustParse(vers)) s.PatchValue(&series.HostSeries, func() string { return ser }) // Create home with dummy provider and remove all // of its envtools. resetJujuXDGDataHome(c) }
func (s *badBuildSuite) TestUploadToolsBadBuild(c *gc.C) { stor, err := filestorage.NewFileStorageWriter(c.MkDir()) c.Assert(err, jc.ErrorIsNil) // Test that original Upload Func fails as expected t, err := sync.Upload(stor, "released", nil) c.Assert(t, gc.IsNil) c.Assert(err, gc.ErrorMatches, `cannot build jujud agent binary from source: build command \"go\" failed: exit status 1; `) // Test that Upload func passes after BundleTools func is mocked out s.PatchValue(&envtools.BundleTools, toolstesting.GetMockBundleTools(c, nil)) t, err = sync.Upload(stor, "released", nil) c.Assert(err, jc.ErrorIsNil) s.assertEqualsCurrentVersion(c, t.Version) c.Assert(t.URL, gc.Not(gc.Equals), "") }
func (s *uploadSuite) SetUpTest(c *gc.C) { if runtime.GOOS == "windows" { c.Skip("issue 1403084: Currently does not work because of jujud problems") } s.FakeJujuHomeSuite.SetUpTest(c) s.ToolsFixture.SetUpTest(c) // Create a target storage. stor, err := filestorage.NewFileStorageWriter(c.MkDir()) c.Assert(err, jc.ErrorIsNil) s.targetStorage = stor // Mock out building of tools. Sync should not care about the contents // of tools archives, other than that they hash correctly. s.PatchValue(&envtools.BundleTools, toolstesting.GetMockBundleTools(c)) }
func (s *badBuildSuite) TestBundleToolsBadBuild(c *gc.C) { // Test that original bundleTools Func fails as expected vers, sha256Hash, err := bundleTools(c) c.Assert(vers, gc.DeepEquals, version.Binary{}) c.Assert(sha256Hash, gc.Equals, "") c.Assert(err, gc.ErrorMatches, `build command "go" failed: exit status 1; `) s.PatchValue(&envtools.BundleTools, toolstesting.GetMockBundleTools(c)) // Test that BundleTools func passes after it is // mocked out vers, sha256Hash, err = bundleTools(c) c.Assert(err, gc.IsNil) c.Assert(vers.Number, gc.Equals, version.Current.Number) c.Assert(sha256Hash, gc.Equals, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855") }
func (s *BootstrapSuite) setupAutoUploadTest(c *gc.C, vers, series string) environs.Environ { s.PatchValue(&envtools.BundleTools, toolstesting.GetMockBundleTools(c)) sourceDir := createToolsSource(c, vAll) s.PatchValue(&envtools.DefaultBaseURL, sourceDir) // Change the tools location to be the test location and also // the version and ensure their later restoring. // Set the current version to be something for which there are no tools // so we can test that an upload is forced. origVersion := version.Current version.Current.Number = version.MustParse(vers) version.Current.Series = series s.AddCleanup(func(*gc.C) { version.Current = origVersion }) // Create home with dummy provider and remove all // of its envtools. return resetJujuHome(c) }
func (s *bootstrapSuite) assertUploadTools(c *gc.C, vers version.Binary, forceVersion bool, extraConfig map[string]interface{}, errMessage string) { s.PatchValue(&version.Current, vers) // If we allow released tools to be uploaded, the build number is incremented so in that case // we need to ensure the environment is set up to allow dev tools to be used. env := newEnviron("foo", useDefaultKeys, extraConfig) s.setDummyStorage(c, env) envtesting.RemoveFakeTools(c, env.Storage()) // At this point, as a result of setDummyStorage, env has tools for amd64 uploaded. // Set version.Current to be arm64 to simulate a different CLI version. cliVersion := version.Current cliVersion.Arch = "arm64" version.Current = cliVersion s.PatchValue(&envtools.BundleTools, toolstesting.GetMockBundleTools(c)) // Host runs arm64, environment supports arm64. s.PatchValue(&arch.HostArch, func() string { return "arm64" }) arch := "arm64" err := bootstrap.UploadTools(coretesting.Context(c), env, &arch, forceVersion, "precise") if errMessage != "" { c.Assert(err, gc.NotNil) stripped := strings.Replace(err.Error(), "\n", "", -1) c.Assert(stripped, gc.Matches, errMessage) return } c.Assert(err, gc.IsNil) params := envtools.BootstrapToolsParams{ Arch: &arch, Series: version.Current.Series, } agentTools, err := envtools.FindBootstrapTools(env, params) c.Assert(err, gc.IsNil) c.Assert(agentTools, gc.HasLen, 1) expectedVers := vers expectedVers.Number.Build++ expectedVers.Series = version.Current.Series c.Assert(agentTools[0].Version, gc.DeepEquals, expectedVers) }
func (s *BootstrapSuite) SetUpTest(c *gc.C) { s.FakeJujuHomeSuite.SetUpTest(c) s.MgoSuite.SetUpTest(c) s.ToolsFixture.SetUpTest(c) // Set version.Current to a known value, for which we // will make tools available. Individual tests may // override this. s.PatchValue(&version.Current, v100p64) // Set up a local source with tools. sourceDir := createToolsSource(c, vAll) s.PatchValue(&envtools.DefaultBaseURL, sourceDir) s.PatchValue(&envtools.BundleTools, toolstesting.GetMockBundleTools(c)) s.mockBlockClient = &mockBlockClient{} s.PatchValue(&blockAPI, func(c *envcmd.EnvCommandBase) (block.BlockListAPI, error) { return s.mockBlockClient, nil }) }
func (s *bootstrapSuite) TestEnsureToolsAvailability(c *gc.C) { existingToolsVersion := version.MustParseBinary("1.19.0-trusty-amd64") s.PatchValue(&version.Current, existingToolsVersion) env := newEnviron("foo", useDefaultKeys, nil) s.setDummyStorage(c, env) // At this point, as a result of setDummyStorage, env has tools for amd64 uploaded. // Set version.Current to be arm64 to simulate a different CLI version. cliVersion := version.Current cliVersion.Arch = "arm64" version.Current = cliVersion s.PatchValue(&envtools.BundleTools, toolstesting.GetMockBundleTools(c)) // Host runs arm64, environment supports arm64. s.PatchValue(&arch.HostArch, func() string { return "arm64" }) arch := "arm64" agentTools, err := bootstrap.EnsureToolsAvailability(coretesting.Context(c), env, config.PreferredSeries(env.Config()), &arch) c.Assert(err, gc.IsNil) c.Assert(agentTools, gc.HasLen, 1) expectedVers := version.Current expectedVers.Number.Build++ expectedVers.Series = config.PreferredSeries(env.Config()) c.Assert(agentTools[0].Version, gc.DeepEquals, expectedVers) }
func (s *BootstrapSuite) SetUpTest(c *gc.C) { s.FakeJujuXDGDataHomeSuite.SetUpTest(c) s.MgoSuite.SetUpTest(c) s.ToolsFixture.SetUpTest(c) // Set jujuversion.Current to a known value, for which we // will make tools available. Individual tests may // override this. s.PatchValue(&jujuversion.Current, v100p64.Number) s.PatchValue(&arch.HostArch, func() string { return v100p64.Arch }) s.PatchValue(&series.HostSeries, func() string { return v100p64.Series }) s.PatchValue(&jujuos.HostOS, func() jujuos.OSType { return jujuos.Ubuntu }) // Set up a local source with tools. sourceDir := createToolsSource(c, vAll) s.PatchValue(&envtools.DefaultBaseURL, sourceDir) s.PatchValue(&envtools.BundleTools, toolstesting.GetMockBundleTools(c)) s.mockBlockClient = &mockBlockClient{} s.PatchValue(&blockAPI, func(c *modelcmd.ModelCommandBase) (block.BlockListAPI, error) { err := s.mockBlockClient.loginError if err != nil { s.mockBlockClient.loginError = nil return nil, err } if s.mockBlockClient.discoveringSpacesError > 0 { s.mockBlockClient.discoveringSpacesError -= 1 return nil, errors.New("spaces are still being discovered") } return s.mockBlockClient, nil }) // TODO(wallyworld) - add test data when tests are improved s.store = jujuclienttesting.NewMemStore() }
func (s *uploadSuite) patchBundleTools(c *gc.C, v *version.Number) { // Mock out building of tools. Sync should not care about the contents // of tools archives, other than that they hash correctly. s.PatchValue(&envtools.BundleTools, toolstesting.GetMockBundleTools(c, v)) }