Example #1
0
func (context *ElasticRuntime) getReadWriter(fpath string, action int) (rw io.ReadWriter, err error) {
	switch action {
	case IMPORT_ARCHIVE:
		var exists bool

		if exists, err = osutils.Exists(fpath); exists && err == nil {
			rw, err = os.Open(fpath)

		} else {
			var pathError os.PathError
			pathError = *ER_ERROR_INVALID_PATH
			pathError.Path = fpath
			err = &pathError
		}

	case EXPORT_ARCHIVE:
		rw, err = osutils.SafeCreate(fpath)
	}
	return
}
func testERWithVersionSpecificFile(installationSettingsFilePath string) {
	Describe("Backup / Restore", func() {
		Context("with valid properties (DirectorInfo)", func() {
			var (
				product   = BoshName()
				component = "director"
				username  = "******"
				target    string
				er        ElasticRuntime
				info      = SystemsInfo{
					SystemDumps: map[string]SystemDump{
						"DirectorInfo": &SystemInfo{
							Product:   product,
							Component: component,
							Identity:  username,
						},
						"ConsoledbInfo": &PgInfoMock{
							SystemInfo: SystemInfo{
								Product:   product,
								Component: component,
								Identity:  username,
							},
						},
					},
				}
				ps = []SystemDump{info.SystemDumps["ConsoledbInfo"]}
			)

			BeforeEach(func() {
				target, _ = ioutil.TempDir("/tmp", "spec")
				er = ElasticRuntime{
					JSONFile:          installationSettingsFilePath,
					HTTPGateway:       &MockHttpGateway{},
					BackupContext:     NewBackupContext(target, cfenv.CurrentEnv()),
					SystemsInfo:       info,
					PersistentSystems: ps,
				}
			})

			AfterEach(func() {
				os.Remove(target)
			})

			Context("With valid list of stores", func() {
				Context("Backup", func() {
					It("Should return nil error", func() {
						err := er.Backup()
						Ω(err).Should(BeNil())
					})
				})

				Context("Restore", func() {
					var filename = fmt.Sprintf("%s.backup", component)

					BeforeEach(func() {
						file, _ := os.Create(path.Join(target, filename))
						file.Close()
					})

					AfterEach(func() {
						os.Remove(path.Join(target, filename))
					})

					It("Should return nil error ", func() {
						err := er.Restore()
						Ω(err).Should(BeNil())
					})
				})
			})

			Context("With empty list of stores", func() {
				var psOrig []SystemDump
				BeforeEach(func() {
					psOrig = ps
					er.PersistentSystems = []SystemDump{}
				})

				AfterEach(func() {
					er.PersistentSystems = psOrig
				})
				Context("Backup", func() {
					It("Should return error on empty list of persistence stores", func() {
						err := er.Backup()
						Ω(err).ShouldNot(BeNil())
						Ω(err).Should(Equal(ErrEREmptyDBList))
					})
				})

				Context("Restore", func() {
					It("Should return error on empty list of persistence stores", func() {
						err := er.Restore()
						Ω(err).ShouldNot(BeNil())
						Ω(err).Should(Equal(ErrEREmptyDBList))
					})
				})
			})

			Context("When db backup fails", func() {
				var psOrig []SystemDump
				BeforeEach(func() {
					psOrig = ps
					er.PersistentSystems = []SystemDump{
						&PgInfoMock{
							SystemInfo: SystemInfo{
								Product:   product,
								Component: component,
								Identity:  username,
							},
						},
						&PgInfoMock{
							SystemInfo: SystemInfo{
								Product:   product,
								Component: component,
								Identity:  username,
							},
							failDump: true,
						},
					}
				})

				AfterEach(func() {
					er.PersistentSystems = psOrig
				})
				Context("Backup", func() {
					It("should return error if db backup fails", func() {
						err := er.Backup()
						Ω(err).ShouldNot(BeNil())
						Ω(err).Should(Equal(ErrERDBBackup))
					})
				})

				Context("Restore", func() {
					It("should return error if db backup fails", func() {
						err := er.Backup()
						Ω(err).ShouldNot(BeNil())
						Ω(err).Should(Equal(ErrERDBBackup))
					})
				})
			})

		})

		Context("with invalid properties", func() {
			var (
				product   = "cf"
				component = "consoledb"
				username  = "******"
				target    string
				er        ElasticRuntime
				info      = SystemsInfo{
					SystemDumps: map[string]SystemDump{
						"ConsoledbInfo": &SystemInfo{
							Product:   product,
							Component: component,
							Identity:  username,
						},
					},
				}
			)

			BeforeEach(func() {
				target, _ = ioutil.TempDir("/tmp", "spec")
				er = ElasticRuntime{
					JSONFile:      installationSettingsFilePath,
					HTTPGateway:   &MockHttpGateway{true, 500, `{"state":"notdone"}`},
					BackupContext: NewBackupContext(target, cfenv.CurrentEnv()),
					SystemsInfo:   info,
				}
			})

			AfterEach(func() {
				os.Remove(target)
			})

			Context("Backup", func() {

				It("Should not return nil error", func() {
					err := er.Backup()
					Ω(err).ShouldNot(BeNil())
					Ω(err).Should(Equal(ErrERDirectorCreds))
				})

				It("Should not panic", func() {
					var err error
					Ω(func() {
						err = er.Backup()
					}).ShouldNot(Panic())
				})
			})

			Context("Restore", func() {

				It("Should not return nil error", func() {
					err := er.Restore()
					Ω(err).ShouldNot(BeNil())
					Ω(err).Should(Equal(ErrERDirectorCreds))
				})

				It("Should not panic", func() {
					var err error
					Ω(func() {
						err = er.Restore()
					}).ShouldNot(Panic())
				})
			})
		})
	})

	Describe("RunDbBackups function", func() {
		Context("with a valid product and component for ccdb", func() {
			var (
				product   = "cf"
				component = "consoledb"
				username  = "******"
				target    string
				er        ElasticRuntime
				info      = SystemsInfo{
					SystemDumps: map[string]SystemDump{
						"ConsoledbInfo": &PgInfoMock{
							SystemInfo: SystemInfo{
								Product:   product,
								Component: component,
								Identity:  username,
							},
						},
					},
				}
			)

			BeforeEach(func() {
				target, _ = ioutil.TempDir("/tmp", "spec")
				er = ElasticRuntime{
					JSONFile:      installationSettingsFilePath,
					HTTPGateway:   &MockHttpGateway{},
					BackupContext: NewBackupContext(target, cfenv.CurrentEnv()),
					SystemsInfo:   info,
				}
				er.ReadAllUserCredentials()
			})

			AfterEach(func() {
				os.Remove(target)
			})

			Context("Backup", func() {
				It("Should write the dumped output to a file in the databaseDir", func() {
					er.RunDbAction([]SystemDump{info.SystemDumps["ConsoledbInfo"]}, ExportArchive)
					filename := fmt.Sprintf("%s.backup", component)
					exists, _ := osutils.Exists(path.Join(target, filename))
					Ω(exists).Should(BeTrue())
				})

				It("Should have a nil error and not panic", func() {
					var err error
					Ω(func() {
						err = er.RunDbAction([]SystemDump{info.SystemDumps["ConsoledbInfo"]}, ExportArchive)
					}).ShouldNot(Panic())
					Ω(err).Should(BeNil())
				})
			})

			Context("Restore", func() {
				It("should return error if local file does not exist", func() {
					err := er.RunDbAction([]SystemDump{info.SystemDumps["ConsoledbInfo"]}, ImportArchive)
					Ω(err).ShouldNot(BeNil())
					Ω(err).Should(BeAssignableToTypeOf(ErrERInvalidPath))
				})

				Context("local file exists", func() {
					var filename = fmt.Sprintf("%s.backup", component)

					BeforeEach(func() {
						file, _ := os.Create(path.Join(target, filename))
						file.Close()
					})

					AfterEach(func() {
						os.Remove(path.Join(target, filename))
					})

					It("should upload file to remote w/o error", func() {
						err := er.RunDbAction([]SystemDump{info.SystemDumps["ConsoledbInfo"]}, ImportArchive)
						Ω(err).Should(BeNil())
					})

					Context("write failure", func() {
						var origInfo map[string]SystemDump

						BeforeEach(func() {
							origInfo = info.SystemDumps
							info = SystemsInfo{
								SystemDumps: map[string]SystemDump{
									"ConsoledbInfo": &PgInfoMock{
										failImport: true,
										SystemInfo: SystemInfo{
											Product:   product,
											Component: component,
											Identity:  username,
										},
									},
								},
							}
						})

						AfterEach(func() {
							info.SystemDumps = origInfo
						})
						It("should return error", func() {
							err := er.RunDbAction([]SystemDump{info.SystemDumps["ConsoledbInfo"]}, ImportArchive)
							Ω(err).ShouldNot(BeNil())
							Ω(err).ShouldNot(Equal(ErrorImport))
						})
					})
				})
			})
		})

		Context("with a valid product and component for consoledb", func() {
			var (
				product   = "cf"
				component = "consoledb"
				username  = "******"
				target    string
				er        ElasticRuntime
				info      = SystemsInfo{
					SystemDumps: map[string]SystemDump{
						"ConsoledbInfo": &PgInfoMock{
							SystemInfo: SystemInfo{
								Product:   product,
								Component: component,
								Identity:  username,
							},
						},
					},
				}
			)

			BeforeEach(func() {
				target, _ = ioutil.TempDir("/tmp", "spec")
				er = ElasticRuntime{
					JSONFile:      installationSettingsFilePath,
					HTTPGateway:   &MockHttpGateway{},
					BackupContext: NewBackupContext(target, cfenv.CurrentEnv()),
					SystemsInfo:   info,
				}
				er.ReadAllUserCredentials()
			})

			AfterEach(func() {
				os.Remove(target)
			})

			Context("Backup", func() {

				It("Should write the dumped output to a file in the databaseDir", func() {
					er.RunDbAction([]SystemDump{info.SystemDumps["ConsoledbInfo"]}, ExportArchive)
					filename := fmt.Sprintf("%s.backup", component)
					exists, _ := osutils.Exists(path.Join(target, filename))
					Ω(exists).Should(BeTrue())
				})

				It("Should have a nil error and not panic", func() {
					var err error
					Ω(func() {
						err = er.RunDbAction([]SystemDump{info.SystemDumps["ConsoledbInfo"]}, ExportArchive)
					}).ShouldNot(Panic())
					Ω(err).Should(BeNil())
				})
			})
		})

		Context("with a valid product and component for uaadb", func() {
			var (
				product   = "cf"
				component = "uaadb"
				username  = "******"
				target    string
				er        ElasticRuntime
				info      = SystemsInfo{
					SystemDumps: map[string]SystemDump{
						"UaadbInfo": &PgInfoMock{
							SystemInfo: SystemInfo{
								Product:   product,
								Component: component,
								Identity:  username,
							},
						},
					},
				}
			)

			BeforeEach(func() {
				target, _ = ioutil.TempDir("/tmp", "spec")
				er = ElasticRuntime{
					JSONFile:      installationSettingsFilePath,
					HTTPGateway:   &MockHttpGateway{},
					BackupContext: NewBackupContext(target, cfenv.CurrentEnv()),
					SystemsInfo:   info,
				}
				er.ReadAllUserCredentials()
			})

			AfterEach(func() {
				os.Remove(target)
			})

			Context("Backup", func() {

				It("Should write the dumped output to a file in the databaseDir", func() {
					er.RunDbAction([]SystemDump{info.SystemDumps["UaadbInfo"]}, ExportArchive)
					filename := fmt.Sprintf("%s.backup", component)
					exists, _ := osutils.Exists(path.Join(target, filename))
					Ω(exists).Should(BeTrue())
				})

				It("Should have a nil error and not panic", func() {
					var err error
					Ω(func() {
						err = er.RunDbAction([]SystemDump{info.SystemDumps["UaadbInfo"]}, ExportArchive)
					}).ShouldNot(Panic())
					Ω(err).Should(BeNil())
				})
			})

			Context("Restore", func() {

			})
		})

		Context("with a invalid product, username and component", func() {
			var (
				product   = "aaaaaaaa"
				component = "aaaaaaaa"
				username  = "******"
				target    string
				er        ElasticRuntime
				info      = SystemsInfo{
					SystemDumps: map[string]SystemDump{
						"ConsoledbInfo": &SystemInfo{
							Product:   product,
							Component: component,
							Identity:  username,
						},
					},
				}
			)

			BeforeEach(func() {
				target, _ = ioutil.TempDir("/tmp", "spec")
				er = ElasticRuntime{
					JSONFile:      installationSettingsFilePath,
					HTTPGateway:   &MockHttpGateway{},
					BackupContext: NewBackupContext(target, cfenv.CurrentEnv()),
					SystemsInfo:   info,
				}
				er.ReadAllUserCredentials()
			})

			AfterEach(func() {
				os.Remove(target)
			})

			Context("Backup", func() {

				It("Should not write the dumped output to a file in the databaseDir", func() {
					er.RunDbAction([]SystemDump{info.SystemDumps["ConsoledbInfo"]}, ExportArchive)
					filename := fmt.Sprintf("%s.sql", component)
					exists, _ := osutils.Exists(path.Join(target, filename))
					Ω(exists).ShouldNot(BeTrue())
				})

				It("Should have a non nil error and not panic", func() {
					var err error
					Ω(func() {
						err = er.RunDbAction([]SystemDump{info.SystemDumps["ConsoledbInfo"]}, ExportArchive)
					}).ShouldNot(Panic())
					Ω(err).ShouldNot(BeNil())
				})
			})

			Context("Restore", func() {
				It("Should have a non nil error and not panic", func() {
					var err error
					Ω(func() {
						err = er.RunDbAction([]SystemDump{info.SystemDumps["ConsoledbInfo"]}, ImportArchive)
					}).ShouldNot(Panic())
					Ω(err).ShouldNot(BeNil())
				})
			})
		})
	})
}
					Username:            "******",
					Password:            "******",
					BackupContext:       fakes.NewFakeBackupContext(path.Join(tmpDir, "backup"), cfenv.CurrentEnv(), new(cfbackup.DiskProvider)),
					Executer:            &fakes.FailExecuter{},
					LocalExecuter:       fakes.NewLocalMockExecuter(),
					DeploymentDir:       "fixtures/encryptionkey",
					OpsmanagerBackupDir: "opsmanager",
				}

			})

			It("should return non nil error and not write installation.json", func() {
				err := opsManager.Backup()
				filepath := path.Join(backupDir, "installation.json")
				Ω(err).ShouldNot(BeNil())
				Ω(osutils.Exists(filepath)).Should(BeFalse())
			})

			It("should return non nil error and not write deployments.tar.gz", func() {
				err := opsManager.Backup()
				filepath := path.Join(backupDir, "deployments.tar.gz")
				Ω(err).ShouldNot(BeNil())
				Ω(osutils.Exists(filepath)).Should(BeTrue())
			})
		})

		Context("called yielding a successful rest call", func() {

			BeforeEach(func() {
				tmpDir, _ = ioutil.TempDir("/tmp", "test")
				backupDir = path.Join(tmpDir, "backup", "opsmanager")
Example #4
0
func testERWithVersionSpecificFile(installationSettingsFilePath string) {
	Describe("Backup / Restore", func() {
		Context("with valid properties (DirectorInfo)", func() {
			var (
				product   string = "microbosh"
				component string = "director"
				username  string = "director"
				target    string
				er        ElasticRuntime
				info      map[string]SystemDump = map[string]SystemDump{
					"DirectorInfo": &SystemInfo{
						Product:   product,
						Component: component,
						Identity:  username,
					},
					"ConsoledbInfo": &PgInfoMock{
						SystemInfo: SystemInfo{
							Product:   product,
							Component: component,
							Identity:  username,
						},
					},
				}
				ps []SystemDump = []SystemDump{info["ConsoledbInfo"]}
			)

			BeforeEach(func() {
				target, _ = ioutil.TempDir("/tmp", "spec")
				er = ElasticRuntime{
					JsonFile:    installationSettingsFilePath,
					HttpGateway: &MockHttpGateway{},
					BackupContext: BackupContext{
						TargetDir: target,
					},
					SystemsInfo:       info,
					PersistentSystems: ps,
					Logger:            Logger(),
				}
			})

			AfterEach(func() {
				os.Remove(target)
			})

			Context("With valid list of stores", func() {
				Context("Backup", func() {
					It("Should return nil error", func() {
						err := er.Backup()
						Ω(err).Should(BeNil())
					})
				})

				Context("Restore", func() {
					var filename string = fmt.Sprintf("%s.backup", component)

					BeforeEach(func() {
						file, _ := os.Create(path.Join(target, filename))
						file.Close()
					})

					AfterEach(func() {
						os.Remove(path.Join(target, filename))
					})

					It("Should return nil error ", func() {
						err := er.Restore()
						Ω(err).Should(BeNil())
					})
				})
			})

			Context("With empty list of stores", func() {
				var psOrig []SystemDump
				BeforeEach(func() {
					psOrig = ps
					er.PersistentSystems = []SystemDump{}
				})

				AfterEach(func() {
					er.PersistentSystems = psOrig
				})
				Context("Backup", func() {
					It("Should return error on empty list of persistence stores", func() {
						err := er.Backup()
						Ω(err).ShouldNot(BeNil())
						Ω(err).Should(Equal(ER_ERROR_EMPTY_DB_LIST))
					})
				})

				Context("Restore", func() {
					It("Should return error on empty list of persistence stores", func() {
						err := er.Restore()
						Ω(err).ShouldNot(BeNil())
						Ω(err).Should(Equal(ER_ERROR_EMPTY_DB_LIST))
					})
				})
			})

			Context("When db backup fails", func() {
				var psOrig []SystemDump
				BeforeEach(func() {
					psOrig = ps
					er.PersistentSystems = []SystemDump{
						&PgInfoMock{
							SystemInfo: SystemInfo{
								Product:   product,
								Component: component,
								Identity:  username,
							},
						},
						&PgInfoMock{
							SystemInfo: SystemInfo{
								Product:   product,
								Component: component,
								Identity:  username,
							},
							failDump: true,
						},
					}
				})

				AfterEach(func() {
					er.PersistentSystems = psOrig
				})
				Context("Backup", func() {
					It("should return error if db backup fails", func() {
						err := er.Backup()
						Ω(err).ShouldNot(BeNil())
						Ω(err).Should(Equal(ER_DB_BACKUP))
					})
				})

				Context("Restore", func() {
					It("should return error if db backup fails", func() {
						err := er.Backup()
						Ω(err).ShouldNot(BeNil())
						Ω(err).Should(Equal(ER_DB_BACKUP))
					})
				})
			})

		})

		Context("with invalid properties", func() {
			var (
				product   string = "cf"
				component string = "consoledb"
				username  string = "root"
				target    string
				er        ElasticRuntime
				info      map[string]SystemDump = map[string]SystemDump{
					"ConsoledbInfo": &SystemInfo{
						Product:   product,
						Component: component,
						Identity:  username,
					},
				}
			)

			BeforeEach(func() {
				target, _ = ioutil.TempDir("/tmp", "spec")
				er = ElasticRuntime{
					JsonFile:    installationSettingsFilePath,
					HttpGateway: &MockHttpGateway{true, 500, `{"state":"notdone"}`},
					BackupContext: BackupContext{
						TargetDir: target,
					},
					SystemsInfo: info,
					Logger:      Logger(),
				}
			})

			AfterEach(func() {
				os.Remove(target)
			})

			Context("Backup", func() {

				It("Should not return nil error", func() {
					err := er.Backup()
					Ω(err).ShouldNot(BeNil())
					Ω(err).Should(Equal(ER_ERROR_DIRECTOR_CREDS))
				})

				It("Should not panic", func() {
					var err error
					Ω(func() {
						err = er.Backup()
					}).ShouldNot(Panic())
				})
			})

			Context("Restore", func() {

				It("Should not return nil error", func() {
					err := er.Restore()
					Ω(err).ShouldNot(BeNil())
					Ω(err).Should(Equal(ER_ERROR_DIRECTOR_CREDS))
				})

				It("Should not panic", func() {
					var err error
					Ω(func() {
						err = er.Restore()
					}).ShouldNot(Panic())
				})
			})
		})
	})

	Describe("RunDbBackups function", func() {
		Context("with a valid product and component for ccdb", func() {
			var (
				product   string = "cf"
				component string = "consoledb"
				username  string = "root"
				target    string
				er        ElasticRuntime
				info      map[string]SystemDump = map[string]SystemDump{
					"ConsoledbInfo": &PgInfoMock{
						SystemInfo: SystemInfo{
							Product:   product,
							Component: component,
							Identity:  username,
						},
					},
				}
			)

			BeforeEach(func() {
				target, _ = ioutil.TempDir("/tmp", "spec")
				er = ElasticRuntime{
					JsonFile:    installationSettingsFilePath,
					HttpGateway: &MockHttpGateway{},
					BackupContext: BackupContext{
						TargetDir: target,
					},
					SystemsInfo: info,
					Logger:      Logger(),
				}
				er.ReadAllUserCredentials()
			})

			AfterEach(func() {
				os.Remove(target)
			})

			Context("Backup", func() {
				It("Should write the dumped output to a file in the databaseDir", func() {
					er.RunDbAction([]SystemDump{info["ConsoledbInfo"]}, EXPORT_ARCHIVE)
					filename := fmt.Sprintf("%s.backup", component)
					exists, _ := osutils.Exists(path.Join(target, filename))
					Ω(exists).Should(BeTrue())
				})

				It("Should have a nil error and not panic", func() {
					var err error
					Ω(func() {
						err = er.RunDbAction([]SystemDump{info["ConsoledbInfo"]}, EXPORT_ARCHIVE)
					}).ShouldNot(Panic())
					Ω(err).Should(BeNil())
				})
			})

			Context("Restore", func() {
				It("should return error if local file does not exist", func() {
					err := er.RunDbAction([]SystemDump{info["ConsoledbInfo"]}, IMPORT_ARCHIVE)
					Ω(err).ShouldNot(BeNil())
					Ω(err).Should(BeAssignableToTypeOf(ER_ERROR_INVALID_PATH))
				})

				Context("local file exists", func() {
					var filename string = fmt.Sprintf("%s.backup", component)

					BeforeEach(func() {
						file, _ := os.Create(path.Join(target, filename))
						file.Close()
					})

					AfterEach(func() {
						os.Remove(path.Join(target, filename))
					})

					It("should upload file to remote w/o error", func() {
						err := er.RunDbAction([]SystemDump{info["ConsoledbInfo"]}, IMPORT_ARCHIVE)
						Ω(err).Should(BeNil())
					})

					Context("write failure", func() {
						var origInfo map[string]SystemDump

						BeforeEach(func() {
							origInfo = info
							info = map[string]SystemDump{
								"ConsoledbInfo": &PgInfoMock{
									failImport: true,
									SystemInfo: SystemInfo{
										Product:   product,
										Component: component,
										Identity:  username,
									},
								},
							}
						})

						AfterEach(func() {
							info = origInfo
						})
						It("should return error", func() {
							err := er.RunDbAction([]SystemDump{info["ConsoledbInfo"]}, IMPORT_ARCHIVE)
							Ω(err).ShouldNot(BeNil())
							Ω(err).ShouldNot(Equal(ERROR_IMPORT))
						})
					})
				})
			})
		})

		Context("with a valid product and component for consoledb", func() {
			var (
				product   string = "cf"
				component string = "consoledb"
				username  string = "root"
				target    string
				er        ElasticRuntime
				info      map[string]SystemDump = map[string]SystemDump{
					"ConsoledbInfo": &PgInfoMock{
						SystemInfo: SystemInfo{
							Product:   product,
							Component: component,
							Identity:  username,
						},
					},
				}
			)

			BeforeEach(func() {
				target, _ = ioutil.TempDir("/tmp", "spec")
				er = ElasticRuntime{
					JsonFile:    installationSettingsFilePath,
					HttpGateway: &MockHttpGateway{},
					BackupContext: BackupContext{
						TargetDir: target,
					},
					SystemsInfo: info,
					Logger:      Logger(),
				}
				er.ReadAllUserCredentials()
			})

			AfterEach(func() {
				os.Remove(target)
			})

			Context("Backup", func() {

				It("Should write the dumped output to a file in the databaseDir", func() {
					er.RunDbAction([]SystemDump{info["ConsoledbInfo"]}, EXPORT_ARCHIVE)
					filename := fmt.Sprintf("%s.backup", component)
					exists, _ := osutils.Exists(path.Join(target, filename))
					Ω(exists).Should(BeTrue())
				})

				It("Should have a nil error and not panic", func() {
					var err error
					Ω(func() {
						err = er.RunDbAction([]SystemDump{info["ConsoledbInfo"]}, EXPORT_ARCHIVE)
					}).ShouldNot(Panic())
					Ω(err).Should(BeNil())
				})
			})
		})

		Context("with a valid product and component for uaadb", func() {
			var (
				product   string = "cf"
				component string = "uaadb"
				username  string = "root"
				target    string
				er        ElasticRuntime
				info      map[string]SystemDump = map[string]SystemDump{
					"UaadbInfo": &PgInfoMock{
						SystemInfo: SystemInfo{
							Product:   product,
							Component: component,
							Identity:  username,
						},
					},
				}
			)

			BeforeEach(func() {
				target, _ = ioutil.TempDir("/tmp", "spec")
				er = ElasticRuntime{
					JsonFile:    installationSettingsFilePath,
					HttpGateway: &MockHttpGateway{},
					BackupContext: BackupContext{
						TargetDir: target,
					},
					SystemsInfo: info,
					Logger:      Logger(),
				}
				er.ReadAllUserCredentials()
			})

			AfterEach(func() {
				os.Remove(target)
			})

			Context("Backup", func() {

				It("Should write the dumped output to a file in the databaseDir", func() {
					er.RunDbAction([]SystemDump{info["UaadbInfo"]}, EXPORT_ARCHIVE)
					filename := fmt.Sprintf("%s.backup", component)
					exists, _ := osutils.Exists(path.Join(target, filename))
					Ω(exists).Should(BeTrue())
				})

				It("Should have a nil error and not panic", func() {
					var err error
					Ω(func() {
						err = er.RunDbAction([]SystemDump{info["UaadbInfo"]}, EXPORT_ARCHIVE)
					}).ShouldNot(Panic())
					Ω(err).Should(BeNil())
				})
			})

			Context("Restore", func() {

			})
		})

		Context("with a invalid product, username and component", func() {
			var (
				product   string = "aaaaaaaa"
				component string = "aaaaaaaa"
				username  string = "aaaaaaaa"
				target    string
				er        ElasticRuntime
				info      map[string]SystemDump = map[string]SystemDump{
					"ConsoledbInfo": &SystemInfo{
						Product:   product,
						Component: component,
						Identity:  username,
					},
				}
			)

			BeforeEach(func() {
				target, _ = ioutil.TempDir("/tmp", "spec")
				er = ElasticRuntime{
					JsonFile:    installationSettingsFilePath,
					HttpGateway: &MockHttpGateway{},
					BackupContext: BackupContext{
						TargetDir: target,
					},
					SystemsInfo: info,
					Logger:      Logger(),
				}
				er.ReadAllUserCredentials()
			})

			AfterEach(func() {
				os.Remove(target)
			})

			Context("Backup", func() {

				It("Should not write the dumped output to a file in the databaseDir", func() {
					er.RunDbAction([]SystemDump{info["ConsoledbInfo"]}, EXPORT_ARCHIVE)
					filename := fmt.Sprintf("%s.sql", component)
					exists, _ := osutils.Exists(path.Join(target, filename))
					Ω(exists).ShouldNot(BeTrue())
				})

				It("Should have a non nil error and not panic", func() {
					var err error
					Ω(func() {
						err = er.RunDbAction([]SystemDump{info["ConsoledbInfo"]}, EXPORT_ARCHIVE)
					}).ShouldNot(Panic())
					Ω(err).ShouldNot(BeNil())
				})
			})

			Context("Restore", func() {
				It("Should have a non nil error and not panic", func() {
					var err error
					Ω(func() {
						err = er.RunDbAction([]SystemDump{info["ConsoledbInfo"]}, IMPORT_ARCHIVE)
					}).ShouldNot(Panic())
					Ω(err).ShouldNot(BeNil())
				})
			})
		})
	})
}