wartank/pkg/mock/mock_env/mockenv_test.go

package mock_env

import (
	"testing"
)

/*
	Тест для отладочных переменных окружения
*/

// Тестер для переменных окружения
type tester struct {
	t  *testing.T
	me *МокОкружение
}

func TestMockEnv(t *testing.T) {
	test := &tester{
		t: t,
	}
	test.create()
	test.initFake()
	test.readFile()
	test.getPairs()
	test.initLocal()
	test.stage()
}

// Плохой STAGE
func (сам *tester) stage() {
	сам.t.Logf("stage()\n")
	сам.badStage1()
	сам.badStage2()
}

// STAGE имеет неизвестное значение
func (сам *tester) badStage2() {
	сам.t.Logf("badStage2()\n")
	defer func() {
		if _panic := recover(); _panic == nil {
			сам.t.Errorf("badStage2(): panic==nil\n")
		}
	}()
	сам.me.dict["STAGE"] = "bad_local"
	сам.me.checkStage()
}

// Нет STAGE
func (сам *tester) badStage1() {
	сам.t.Logf("badStage1()\n")
	defer func() {
		if _panic := recover(); _panic == nil {
			сам.t.Errorf("badStage1(): panic==nil\n")
		}
	}()
	delete(сам.me.dict, "STAGE")
	сам.me.checkStage()
}

// Локальная инициализация
func (сам *tester) initLocal() {
	сам.initLocalBad1()
	сам.initLocalBad2()
	сам.initLocalBad3()
	сам.initLocalBad4()
	сам.initLocalGood1()
	сам.me.Unset()
}

func (сам *tester) initLocalGood1() {
	if err := сам.me.ИнитЛокал(); err != nil {
		сам.t.Errorf("initLocalGood1(): err=\n\t%v\n", err)
	}
}

// Вообще нет STAGE
func (сам *tester) initLocalBad4() {
	_fileEnv := fileEnv
	fileEnv = "./test_data/env_bad2"
	if err := сам.me.ИнитЛокал(); err == nil {
		сам.t.Errorf("initLocalBad4(): err==nil\n")
	}
	fileEnv = _fileEnv
}

// Кривое значение STAGE
func (сам *tester) initLocalBad3() {
	_fileEnv := fileEnv
	fileEnv = "./test_data/env_bad1"
	if err := сам.me.ИнитЛокал(); err == nil {
		сам.t.Errorf("initLocalBad3(): err==nil\n")
	}
	fileEnv = _fileEnv
}

// Кривое содержимое файла
func (сам *tester) initLocalBad2() {
	_fileEnv := fileEnv
	fileEnv = "./test_data/env_bad"
	if err := сам.me.ИнитЛокал(); err == nil {
		сам.t.Errorf("initLocalBad2(): err==nil\n")
	}
	fileEnv = _fileEnv
}

// Кривое имя файла
func (сам *tester) initLocalBad1() {
	_fileEnv := fileEnv
	fileEnv = "4"
	if err := сам.me.ИнитЛокал(); err == nil {
		сам.t.Errorf("initLocalBad1(): err==nil\n")
	}
	fileEnv = _fileEnv
}

// Получение пар значений
func (сам *tester) getPairs() {
	сам.getPairsBad1()
	сам.getPairsBad2()
	сам.getPairsBad3()
	сам.getPairsBad4()
	сам.getPairsGood1()
}

func (сам *tester) getPairsGood1() {
	dict, err := сам.me.getPairs("\nPARAM=\"123\"\nPARAM2=\"param2\"\n")
	if err != nil {
		сам.t.Errorf("getPairsGood1(): err=\n\t%v\n", err)
	}
	if dict == nil {
		сам.t.Errorf("getPairsGood1(): dict == nil\n")
	}
}

// Кривая пара
func (сам *tester) getPairsBad4() {
	dict, err := сам.me.getPairs("\nPARAM=\"=\"=\"\"\nPARAM2=\"param2\"\n")
	if err == nil {
		сам.t.Errorf("getPairsBad4(): err==nil\n")
	}
	if dict != nil {
		сам.t.Errorf("getPairsBad4(): dict != nil\n")
	}
}

// Кривое значение
func (сам *tester) getPairsBad3() {
	dict, err := сам.me.getPairs("\nPARAM=\"\"\nPARAM2=\"param2\"\n")
	if err == nil {
		сам.t.Errorf("getPairsBad3(): err==nil\n")
	}
	if dict != nil {
		сам.t.Errorf("getPairsBad3(): dict != nil\n")
	}
}

// Кривой ключ
func (сам *tester) getPairsBad2() {
	dict, err := сам.me.getPairs("\n=\"param\"\nPARAM2=\"param2\"\n")
	if err == nil {
		сам.t.Errorf("getPairsBad2(): err==nil\n")
	}
	if dict != nil {
		сам.t.Errorf("getPairsBad2(): dict != nil\n")
	}
}

// Пустой текст
func (сам *tester) getPairsBad1() {
	dict, err := сам.me.getPairs("\n\n\n")
	if err == nil {
		сам.t.Errorf("getPairsBad1(): err==nil\n")
	}
	if dict != nil {
		сам.t.Errorf("getPairsBad1(): dict != nil\n")
	}
}

// Чтение файла переменных окружения
func (сам *tester) readFile() {
	сам.readFileBad1()
	сам.readFileBad2()
	сам.readFileBad3()
	сам.readFileGood1()
}

func (сам *tester) readFileGood1() {
	strData, err := сам.me.readFile()
	if err != nil {
		сам.t.Errorf("readFileGood1(): err=\n\t%v\n", err)
	}
	if strData == "" {
		сам.t.Errorf("readFileGood1(): strData is empty\n")
	}
}

// Кривой путь-2
func (сам *tester) readFileBad3() {
	_selfPath := selfPath
	selfPath = "me/"
	strData, err := сам.me.readFile()
	if err == nil {
		сам.t.Errorf("readFileBad3(): err==nil\n")
	}
	if strData != "" {
		сам.t.Errorf("readFileBad3(): strData not empty\n")
	}
	selfPath = _selfPath
}

// Неправильное имя файла
func (сам *tester) readFileBad2() {
	_fileEnv := fileEnv
	fileEnv = ""
	strData, err := сам.me.readFile()
	if err == nil {
		сам.t.Errorf("readFileBad2(): err==nil\n")
	}
	if strData != "" {
		сам.t.Errorf("readFileBad2(): strData not empty\n")
	}
	fileEnv = _fileEnv
}

// Кривой путь
func (сам *tester) readFileBad1() {
	_selfPath := selfPath
	selfPath = "#"
	strData, err := сам.me.readFile()
	if err == nil {
		сам.t.Errorf("readFileBad1(): err==nil\n")
	}
	if strData != "" {
		сам.t.Errorf("readFileBad1(): strData not empty\n")
	}
	selfPath = _selfPath
}

// Иницилизация фейковыми данными
func (сам *tester) initFake() {
	сам.me.ИнитФейк()
}

// Создание объекта переменных окружения
func (сам *tester) create() {
	сам.me = НовМокОкружение()
	if сам.me == nil {
		сам.t.Errorf("create(): mockEnv is nil\n")
	}
	if сам.me.dict == nil {
		сам.t.Errorf("create(): dict env is nil")
	}
	if len_ := len(сам.me.dict); len_ != 0 {
		сам.t.Errorf("create(): len dict(%v)!=0\n", len_)
	}
}