File inter-server-sync-0.2.4.obscpio of Package inter-server-sync

Overview Repositories Revisions Requests Users Attributes Meta

File inter-server-sync-0.2.4.obscpio of Package inter-server-sync (Revision c96fcd353fee9b73ae36777d91de6264)

Currently displaying revision c96fcd353fee9b73ae36777d91de6264 , Show latest

07070100000000000041ED0000000000000000000000036346BD6400000000000000000000000000000000000000000000002000000000inter-server-sync-0.2.4/.github07070100000001000041ED0000000000000000000000026346BD6400000000000000000000000000000000000000000000002A00000000inter-server-sync-0.2.4/.github/workflows07070100000002000081A40000000000000000000000016346BD64000001A0000000000000000000000000000000000000004300000000inter-server-sync-0.2.4/.github/workflows/github-actions-tests.ymlon: [push, pull_request]
name: Test
jobs:
  test:
    strategy:
      matrix:
        go-version: [1.17.x]
        os: [ubuntu-latest]
    runs-on: ${{ matrix.os }}
    steps:
      - name: Install Go
        uses: actions/setup-go@v2
        with:
          go-version: ${{ matrix.go-version }}
      - name: Checkout code
        uses: actions/checkout@v2
      - name: Test
        run: go test ./... -cover -race07070100000003000081A40000000000000000000000016346BD640000000F000000000000000000000000000000000000002300000000inter-server-sync-0.2.4/.gitignore.idea/
rhn.conf07070100000004000081A40000000000000000000000016346BD640000042E000000000000000000000000000000000000002000000000inter-server-sync-0.2.4/LICENSEMIT License

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
07070100000005000081A40000000000000000000000016346BD6400000C01000000000000000000000000000000000000002200000000inter-server-sync-0.2.4/README.md# Inter Server Sync (ISS)

[![Test](https://github.com/uyuni-project/inter-server-sync/actions/workflows/github-actions-tests.yml/badge.svg)](https://github.com/uyuni-project/inter-server-sync/actions/workflows/github-actions-tests.yml)

## Usage
run the command for more information:
`inter-server-sync -h`

## Known limitations 
- Source and target servers need to be on the same version.
- Export and import organization should have the same name.
- Export folder needs to be sync by hand to the target server.

### on source server
- **Create export dir**: `mkdir ~/export`
- **Run command**: `inter-server-sync export --serverConfig=/etc/rhn/rhn.conf --outputDir=~/export --channels=channel_label,channel_label`
- **Copy export directory to target server**: `rsync -r ~/export root@<Target_server>:~/`

### on target server
- **Run command: `inter-server-sync import --importDir ~/export/`

## Database connection configuration

Database connection configuration are loaded by default from `/etc/rhn/rhn.conf`.
File location can be overwritten.
For development environments one can use a sample file in this project.

Steps to run in locally in development mode:
1. copy sample file `cp rhn.conf.exaple rhn.conf`
2. fill all properties in `rhn.conf` with the appropriated values
3. use this configuration file by specifying the config parameter: `go run . -config=rhn.conf`

## Extra

### Dot graph with schema metadata

`go run . dot --serverConfig=rhn.conf |  dot -Tx11`

## Build and release

### 1. Update cmd version

- Edit file `cmd/root.go` "Version" property to the desire version
- On project root folder run `osc vc` to update the changes file with the release data
- Manually update changes file with the release number for the next release
- commit and push to github

### 2. Create tag

- Create a tag with the version number using the format "v0.0.0" and push it to github
```
git tag v0.0.0
git push origin v0.0.0
```

### 3. Create a github release (optional)

- On github create a new version release based on the previous tag

### 4. OBS: project preparetion

- Projects names:
    - Uyuni: `systemsmanagement:Uyuni:Master`
    - Head: Devel: `Galaxy:Manager:Head`
    - Manager 4.2: `Devel:Galaxy:Manager:4.2`
- Pakcage name: `inter-server-sync`

On porject working directory:

1. Adapt the `_services` file to be able to download the correct tag for the version
2. Run all services: `osc service runall`
3. Check the changes files is correctly updated
4. Check spec file was correctly updated with the release version
5. Add all files: `osc ar`
6. Remove old version files `tar` and `osinfo` (`osc rm filename`)
7. Commit everything with `osc commit`

### 5. OBS: create submit requests

Uyuni: `osc sr --no-cleanup <your_project> inter-server-sync systemsmanagement:Uyuni:Master`
Manager Head: `iosc sr --no-cleanup openSUSE.org:<your_project> inter-server-sync Devel:Galaxy:Manager:Head`
For each maintained SUSE Manager version, one SR in the form: `iosc sr --no-cleanup openSUSE.org:<your_project> inter-server-sync Devel:Galaxy:Manager:X.Y`
07070100000006000041ED0000000000000000000000026346BD6400000000000000000000000000000000000000000000001C00000000inter-server-sync-0.2.4/cmd07070100000007000081A40000000000000000000000016346BD6400000261000000000000000000000000000000000000002300000000inter-server-sync-0.2.4/cmd/dot.gopackage cmd

import (
	"github.com/spf13/cobra"
	"github.com/uyuni-project/inter-server-sync/entityDumper"
	"github.com/uyuni-project/inter-server-sync/schemareader"
)

// dotCmd represents the dot command
var dotCmd = &cobra.Command{
	Use:   "dot",
	Short: "export database schema as dot diagram",
	Hidden: true,
	Run: func(cmd *cobra.Command, args []string) {
		db := schemareader.GetDBconnection(serverConfig)
		defer db.Close()
		tables := schemareader.ReadTablesSchema(db, entityDumper.SoftwareChannelTableNames())
		schemareader.DumpToGraphviz(tables)
	},
}

func init() {
	rootCmd.AddCommand(dotCmd)
}
07070100000008000081A40000000000000000000000016346BD6400000BFC000000000000000000000000000000000000002600000000inter-server-sync-0.2.4/cmd/export.gopackage cmd

import (
	"os"
	"path"
	"strings"

"github.com/rs/zerolog/log"
	"github.com/spf13/cobra"
	"github.com/uyuni-project/inter-server-sync/entityDumper"
	"github.com/uyuni-project/inter-server-sync/utils"
)

var exportCmd = &cobra.Command{
	Use:   "export",
	Short: "Export server entities to be imported in other server",
	Run:   runExport,
}

var channels []string
var channelWithChildren []string
var configChannels []string
var outputDir string
var metadataOnly bool
var startingDate string
var includeImages bool
var includeContainers bool
var orgs []uint

func init() {
	exportCmd.Flags().StringSliceVar(&channels, "channels", nil, "Channels to be exported")
	exportCmd.Flags().StringSliceVar(&channelWithChildren, "channel-with-children", nil, "Channels to be exported")
	exportCmd.Flags().StringVar(&outputDir, "outputDir", ".", "Location for generated data")
	exportCmd.Flags().BoolVar(&metadataOnly, "metadataOnly", false, "export only metadata")
	exportCmd.Flags().StringVar(&startingDate, "packagesOnlyAfter", "", "Only export packages added or modified after the specified date (date format can be 'YYYY-MM-DD' or 'YYYY-MM-DD hh:mm:ss')")
	exportCmd.Flags().StringSliceVar(&configChannels, "configChannels", nil, "Configuration Channels to be exported")
	exportCmd.Flags().BoolVar(&includeImages, "images", false, "Export OS images and associated metadata")
	exportCmd.Flags().BoolVar(&includeContainers, "containers", false, "Export containers metadata")
	exportCmd.Flags().UintSliceVar(&orgs, "orgLimit", nil, "Export only for specified organizations")
	exportCmd.Args = cobra.NoArgs

rootCmd.AddCommand(exportCmd)
}

func runExport(cmd *cobra.Command, args []string) {
	log.Debug().Msg("export called")
	log.Debug().Msg(strings.Join(channels, ","))
	log.Debug().Msg(outputDir)
	// check output dir existence and create it if needed.

// Validate data
	validatedDate, ok := utils.ValidateDate(startingDate)
	if !ok {
		log.Fatal().Msg("Unable to validate the date. Allowed formats are 'YYYY-MM-DD' or 'YYYY-MM-DD hh:mm:ss'")
	}

options := entityDumper.DumperOptions{
		ServerConfig:              serverConfig,
		ChannelLabels:             channels,
		ConfigLabels:              configChannels,
		ChannelWithChildrenLabels: channelWithChildren,
		OutputFolder:              outputDir,
		MetadataOnly:              metadataOnly,
		StartingDate:              validatedDate,
		OSImages:                  includeImages,
		Containers:                includeContainers,
		Orgs:                      orgs,
	}
	entityDumper.DumpAllEntities(options)
	var versionfile string
	versionfile = path.Join(utils.GetAbsPath(outputDir), "version.txt")
	vf, err := os.Open(versionfile)
	defer vf.Close()
	if os.IsNotExist(err) {
		f, err := os.Create(versionfile)
		if err != nil {
			log.Panic().Msg("Unable to create version file")
		}
		vf = f
	}
	version, product := utils.GetCurrentServerVersion(serverConfig)
	vf.WriteString("product_name = " + product + "\n" + "version = " + version + "\n")

log.Info().Msgf("Export done. Directory: %s", outputDir)
}
07070100000009000081ED0000000000000000000000016346BD6400001955000000000000000000000000000000000000002600000000inter-server-sync-0.2.4/cmd/import.gopackage cmd

import (
	"fmt"
	"io"
	"os"
	"os/exec"
	"path"
	"strings"

"github.com/rs/zerolog/log"
	"github.com/spf13/cobra"
	"github.com/uyuni-project/inter-server-sync/dumper/pillarDumper"
	"github.com/uyuni-project/inter-server-sync/utils"
	"github.com/uyuni-project/inter-server-sync/xmlrpc"
)

var importCmd = &cobra.Command{
	Use:   "import",
	Short: "Import data to server",
	Run:   runImport,
}

var importDir string
var xmlRpcUser string
var xmlRpcPassword string

func init() {

importCmd.Flags().StringVar(&importDir, "importDir", ".", "Location import data from")
	importCmd.Flags().StringVar(&xmlRpcUser, "xmlRpcUser", "admin", "A username to access the XML-RPC Api")
	importCmd.Flags().StringVar(&xmlRpcPassword, "xmlRpcPassword", "admin", "A password to access the XML-RPC Api")
	importCmd.Args = cobra.NoArgs

rootCmd.AddCommand(importCmd)
}

func runImport(cmd *cobra.Command, args []string) {
	absImportDir := utils.GetAbsPath(importDir)
	log.Info().Msg(fmt.Sprintf("starting import from dir %s", absImportDir))
	fversion, fproduct := getImportVersionProduct(absImportDir)
	sversion, sproduct := utils.GetCurrentServerVersion(serverConfig)
	if fversion != sversion || fproduct != sproduct {
		log.Panic().Msgf("Wrong version detected. Fileversion = %s ; Serverversion = %s", fversion, sversion)
	}
	validateFolder(absImportDir)
	runPackageFileSync(absImportDir)

runImageFileSync(absImportDir, serverConfig)

runImportSql(absImportDir)
	log.Info().Msg("import finished")
}

func getImportVersionProduct(path string) (string, string) {
	var versionfile string
	versionfile = path + "/version.txt"
	version, err := utils.ScannerFunc(versionfile, "version")
	if err != nil {
		log.Error().Msg("Version not found.")
	}
	product, err := utils.ScannerFunc(versionfile, "product_name")
	if err != nil {
		log.Fatal().Msg("Product not found")
	}
	log.Debug().Msgf("Import Product: %s; Version: %s", product, version)
	return version, product
}

func validateFolder(absImportDir string) {
	_, err := os.Stat(fmt.Sprintf("%s/sql_statements.sql.gz", absImportDir))
	if err != nil {
		if os.IsNotExist(err) {
			_, err = os.Stat(fmt.Sprintf("%s/sql_statements.sql", absImportDir))
			if err != nil {
				log.Fatal().Err(err).Msg("No usable .sql or .gz file found in import directory")
			}
		} else {
			log.Fatal().Err(err)
		}
	}
}

func hasConfigChannels(absImportDir string) bool {
	_, err := os.Stat(fmt.Sprintf("%s/exportedConfigs.txt", absImportDir))
	log.Info().Err(err).Msg(fmt.Sprintf("no export config file found: %s/exportedConfigs.txt", absImportDir))
	return err == nil || os.IsExist(err)
}

func runPackageFileSync(absImportDir string) {
	packagesImportDir := fmt.Sprintf("%s/packages/", absImportDir)
	err := utils.FolderExists(packagesImportDir)
	if err != nil {
		if os.IsNotExist(err) {
			log.Info().Msg("no package files to import")
			return
		} else {
			log.Fatal().Err(err).Msg("Error getting import packages folder")
		}
	}

debugFlag := ""
	if log.Debug().Enabled() {
		debugFlag = "-v"
	}

cmd := exec.Command("rsync", debugFlag, "-og", "--chown=wwwrun:www", "-r",
		packagesImportDir, "/var/spacewalk/packages/")
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	log.Info().Msg("starting importing package files")
	err = cmd.Run()
	if err != nil {
		log.Fatal().Err(err).Msg("error importing package files")
	}
}

func runConfigFilesSync(labels []string, user string, password string) (interface{}, error) {
	client := xmlrpc.NewClient(user, password)
	return client.SyncConfigFiles(labels)
}

func runImageFileSync(absImportDir string, serverFQDN string) {
	imagesImportDir := path.Join(absImportDir, "images")
	err := utils.FolderExists(imagesImportDir)
	if err != nil {
		if os.IsNotExist(err) {
			log.Info().Msg("No image files to import")
			return
		} else {
			log.Fatal().Err(err).Msg("Error reading import folder for images")
		}
	}

debugFlag := ""
	if log.Debug().Enabled() {
		debugFlag = "-v"
	}

cmd := exec.Command("rsync", debugFlag, "-og", "--chown=salt:susemanager", "--chmod=Du=rwx,Dgo=rx,Fu=rw,Fgo=r",
		"-r", "--exclude=pillars", imagesImportDir+"/", "/srv/www/os-images")
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	log.Info().Msg("Copying image files")
	err = cmd.Run()
	if err != nil {
		log.Fatal().Err(err).Msg("Error importing image files")
	}

pillarImportDir := path.Join(absImportDir, "images", "pillars")
	err = utils.FolderExists(pillarImportDir)
	if err != nil {
		if os.IsNotExist(err) {
			log.Info().Msg("No pillar files to import")
			return
		} else {
			log.Fatal().Err(err).Msg("Error reading import folder for pillars")
		}
	}

log.Info().Msg("Copying image pillar files")
	pillarDumper.ImportImagePillars(pillarImportDir, serverConfig)
}

func importSqlFile(absImportDir string) {
	cmd := exec.Command("spacewalk-sql", fmt.Sprintf("%s/sql_statements.sql", absImportDir))
	cmd.Stdin = os.Stdin
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	log.Info().Msg("Starting SQL import")
	err := cmd.Run()
	if err != nil {
		log.Fatal().Err(err).Msgf("Error running the SQL script")
	}
}

func importGzFile(absImportDir string) {
	cUnzip := exec.Command("gunzip", "-c", fmt.Sprintf("%s/sql_statements.sql.gz", absImportDir))
	cImport := exec.Command("spacewalk-sql", "-")

pr, pw := io.Pipe()
	cUnzip.Stdout = pw
	cUnzip.Stderr = os.Stderr

cImport.Stdin = pr
	cImport.Stdout = os.Stdout
	cImport.Stderr = os.Stderr

log.Info().Msg("Starting SQL/GZ import")
	cUnzip.Start()
	cImport.Start()

go func() {
		defer pw.Close()
		cUnzip.Wait()
	}()
	err := cImport.Wait()
	if err != nil {
		log.Fatal().Err(err).Msgf("Error running the SQL script")
	}
}

func runImportSql(absImportDir string) {

if _, err := os.Stat(fmt.Sprintf("%s/sql_statements.sql.gz", absImportDir)); err == nil {
		importGzFile(absImportDir)
	} else {
		if _, err := os.Stat(fmt.Sprintf("%s/sql_statements.sql", absImportDir)); err == nil {
			importSqlFile(absImportDir)
		}
	}

if hasConfigChannels(absImportDir) {
		labels := utils.ReadFileByLine(fmt.Sprintf("%s/exportedConfigs.txt", absImportDir))
		log.Debug().Msg("Will call xml-rpc API to update filesystem")
		_, err := runConfigFilesSync(labels, xmlRpcUser, xmlRpcPassword)
		if err != nil {
			log.Error().Err(err).Msgf(
				"Error recreating configuration files. Please run spacecmd api configchannel.syncSaltFilesOnDisk -A '[[%s]]'",
				strings.Join(labels, ", "),
			)
		}
	} else {
		log.Debug().Msg("No configuration channels, NO CALL to xml-rpc API")
	}
}
0707010000000A000081A40000000000000000000000016346BD6400000C57000000000000000000000000000000000000002400000000inter-server-sync-0.2.4/cmd/root.gopackage cmd

import (
	"fmt"
	"log/syslog"
	"os"
	"runtime/pprof"
	"strconv"
	"strings"
	"time"

"github.com/rs/zerolog"
	"github.com/rs/zerolog/log"
	"github.com/spf13/cobra"
)

var rootCmd = &cobra.Command{
	Use:     "inter-server-sync",
	Short:   "Uyuni Inter Server Sync tool",
	Version: "0.2.4",
}

func Execute() {
	cobra.CheckErr(rootCmd.Execute())
}

//var cfgFile string
var logLevel string
var serverConfig string
var cpuProfile string
var memProfile string

func init() {
	rootCmd.PersistentPreRun = func(cmd *cobra.Command, args []string) {
		logInit()
		cpuProfileInit()
		memProfileDump()
	}
	rootCmd.PersistentPostRun = func(cmd *cobra.Command, args []string) {
		cpuProfileTearDown()
	}
	rootCmd.PersistentFlags().StringVar(&logLevel, "logLevel", "error", "application log level")
	rootCmd.PersistentFlags().StringVar(&serverConfig, "serverConfig", "/etc/rhn/rhn.conf", "Server configuration file")
	rootCmd.PersistentFlags().StringVar(&cpuProfile, "cpuProfile", "", "cpuProfile export folder location")
	rootCmd.PersistentFlags().StringVar(&memProfile, "memProfile", "", "memProfile export folder location")
}

func logCallerMarshalFunction(file string, line int) string {
	paths := strings.Split(file, "/")
	callerFile := file
	foundSubDir := false
	for _, currentPath := range paths {
		if foundSubDir {
			if callerFile != "" {
				callerFile = callerFile + "/"
			}
			callerFile = callerFile + currentPath
		} else {
			if strings.Contains(currentPath, "inter-server-sync") {
				foundSubDir = true
				callerFile = ""
			}
		}
	}
	return callerFile + ":" + strconv.Itoa(line)
}

func logInit() {
	syslogger, err := syslog.New(syslog.LOG_INFO|syslog.LOG_DEBUG|syslog.LOG_WARNING|syslog.LOG_ERR, "inter-server-sync")

syslogwriter := zerolog.SyslogLevelWriter(syslogger)

multi := zerolog.MultiLevelWriter(syslogwriter, os.Stdout)
	log.Logger = zerolog.New(multi).With().Timestamp().Caller().Logger()
	zerolog.CallerMarshalFunc = logCallerMarshalFunction
	level, err := zerolog.ParseLevel(logLevel)
	if err != nil {
		level = zerolog.InfoLevel
	}
	zerolog.SetGlobalLevel(level)
	log.Info().Msg("Inter server sync started")
}

func cpuProfileInit() {
	if cpuProfile != "" {
		f, err := os.Create(cpuProfile + "end_cpu_profile.prof")
		if err != nil {
			log.Error().Err(err).Msg("could not create CPU profile: ")
		}
		defer f.Close() // error handling omitted for example
		if err := pprof.StartCPUProfile(f); err != nil {
			log.Panic().Err(err).Msg("could not start CPU profile: ")
		}
	}
}

func cpuProfileTearDown() {
	if cpuProfile != "" {
		pprof.StopCPUProfile()
	}
}

func memProfileDump() {
	if log.Debug().Enabled() && len(memProfile) > 0 {

go func() {

count := 0
			for {
				time.Sleep(30 * time.Second)
				fileName := fmt.Sprintf("%s/memory_profile_%d.prof", memProfile, count)
				f, err := os.Create(fileName)
				if err != nil {
					log.Error().Err(err).Msg(fmt.Sprintf("could not create memory profile file: %s", fileName))
					break
				}
				if err := pprof.WriteHeapProfile(f); err != nil {
					log.Error().Err(err).Msg("could not write memory profile: ")
				}
				f.Close()
				count++
			}
		}()
	}
}
0707010000000B000041ED0000000000000000000000056346BD6400000000000000000000000000000000000000000000001F00000000inter-server-sync-0.2.4/dumper0707010000000C000081A40000000000000000000000016346BD6400001845000000000000000000000000000000000000002F00000000inter-server-sync-0.2.4/dumper/crawler_test.gopackage dumper

import (
	"reflect"
	"testing"

"github.com/uyuni-project/inter-server-sync/schemareader"
	"github.com/uyuni-project/inter-server-sync/tests"
)

// crawlerTestCase lays down a test scenario for the DataCrawler func
type crawlerTestCase struct {
	repo               *tests.DataRepository
	schemaMetadata     MetaDataGraph
	startTable         schemareader.Table
	startQueryFilter   string
	expectedDataDumper DataDumper
}

func TestShouldCreateDataDumper(t *testing.T) {

// Arrange
	graph := TablesGraph{
		// first order
		"root": []string{"v31", "v32"},
		"v31":  []string{"v35", "v36"},
		"v32":  []string{"v33"},
		// second order
		"v33": []string{"v34"},
		// third order with circular dependency
		"v34": []string{"v35", "v36"},
		"v35": []string{"v34"},
		"v36": []string{},
	}
	root := "root"
	testCase := createDataCrawlerTestCase(graph, root)

// the data repository expect these statements in the exact same order
	testCase.repo.Expect("SELECT * FROM root WHERE CUSTOM ;", testCase.schemaMetadata["root"].Columns, 1)
	testCase.repo.Expect("SELECT id, v35_fk_id, v36_fk_id FROM v31 WHERE id = $1;", testCase.schemaMetadata["v31"].Columns, 1)
	testCase.repo.Expect("SELECT id, v33_fk_id FROM v32 WHERE id = $1;", testCase.schemaMetadata["v32"].Columns, 1)
	testCase.repo.Expect("SELECT id, v34_fk_id FROM v33 WHERE id = $1;", testCase.schemaMetadata["v33"].Columns, 1)
	testCase.repo.Expect("SELECT id, v35_fk_id, v36_fk_id FROM v34 WHERE id = $1;", testCase.schemaMetadata["v34"].Columns, 1)
	testCase.repo.Expect("SELECT id, v34_fk_id FROM v35 WHERE id = $1;", testCase.schemaMetadata["v35"].Columns, 1)
	testCase.repo.Expect("SELECT id FROM v36 WHERE id = $1;", testCase.schemaMetadata["v36"].Columns, 1)

testCase.repo.Expect("SELECT id, v34_fk_id FROM v35 WHERE id = $1;", testCase.schemaMetadata["v35"].Columns, 1)
	testCase.repo.Expect("SELECT id FROM v36 WHERE id = $1;", testCase.schemaMetadata["v36"].Columns, 1)

// Act
	dataDumper := DataCrawler(
		testCase.repo.DB,
		testCase.schemaMetadata,
		testCase.startTable,
		testCase.startQueryFilter,
		"2022-01-01",
	)

// Assert
	if dataDumper.TableData == nil || dataDumper.Paths == nil {
		t.Errorf("DataDumper was not initiated")
	}
	tableDataEqual := reflect.DeepEqual(dataDumper.TableData, testCase.expectedDataDumper.TableData)
	if !tableDataEqual {
		t.Errorf("DataDumper.TableData is not expected")
	}
	pathsEqual := reflect.DeepEqual(dataDumper.Paths, testCase.expectedDataDumper.Paths)
	if !pathsEqual {
		t.Errorf("DataDumper.Paths is not expected")
	}
}

// createTestCase is a factory method for writerTestCase
func createDataCrawlerTestCase(graph TablesGraph, root string) crawlerTestCase {
	repo := tests.CreateDataRepository()
	tablesMetaData, dataDumper := initializeMetaDataGraph(graph, root)
	return crawlerTestCase{
		repo:               repo,
		schemaMetadata:     tablesMetaData,
		startTable:         tablesMetaData[root],
		startQueryFilter:   "CUSTOM",
		expectedDataDumper: dataDumper,
	}
}

// followLinkTestCase lays down a test scenario for the shouldFollowReferenceToLink func
type followLinkTestCase struct {
	path            []string // path constructed by a recursive function so far
	currentTable    schemareader.Table
	referencedTable schemareader.Table
}

func TestShouldFollowForcedNavigations(t *testing.T) {

// Arrange
	var shouldFollow bool
	testCase := followLinkTestCase{
		path: []string{},
		currentTable: schemareader.Table{
			Name: "rhnchannel",
		},
		referencedTable: schemareader.Table{
			Name: "susemddata",
		},
	}