ccx_notification_writer_test.go

/*
Copyright © 2021, 2022, 2023 Red Hat, Inc.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package main_test

// Unit test definitions for functions and methods defined in source file
// ccx_notification_writer.go
//
// Documentation in literate-programming-style is available at:
// https://redhatinsights.github.io/ccx-notification-writer/packages/ccx_notification_writer_test.html

import (
	"os"
	"testing"

	"github.com/rs/zerolog"
	"github.com/rs/zerolog/log"
	"github.com/stretchr/testify/assert"
	"github.com/tisnik/go-capture"

	main "github.com/RedHatInsights/ccx-notification-writer"
)

// init function is called before tests
func init() {
	// set default logging level regardles of config made in code
	zerolog.SetGlobalLevel(zerolog.InfoLevel)
}

// TestShowVersion checks the function showVersion
func TestShowVersion(t *testing.T) {
	// try to call the tested function and capture its output
	output, err := capture.StandardOutput(func() {
		main.ShowVersion()
	})

	// check the captured text
	checkCapture(t, err)

	// expected content printed by tested function
	assert.Contains(t, output, "CCX Notification Writer version")
}

// TestShowAuthors checks the function showAuthors
func TestShowAuthors(t *testing.T) {
	// try to call the tested function and capture its output
	output, err := capture.StandardOutput(func() {
		main.ShowAuthors()
	})

	// check the captured text
	checkCapture(t, err)

	// expected content printed by tested function
	assert.Contains(t, output, "Pavel Tisnovsky")
	assert.Contains(t, output, "Red Hat Inc.")
}

// TestShowConfiguration checks the function ShowConfiguration
func TestShowConfiguration(t *testing.T) {
	// fill in configuration structure
	configuration := main.ConfigStruct{}
	configuration.Broker = main.BrokerConfiguration{
		Addresses: "broker_address",
		Topic:     "broker_topic",
	}
	configuration.Metrics = main.MetricsConfiguration{
		Namespace: "metrics_namespace",
	}

	// try to call the tested function and capture its output
	output, err := capture.ErrorOutput(func() {
		log.Logger = log.Output(zerolog.New(os.Stderr))
		main.ShowConfiguration(&configuration)
	})

	// check the captured text
	checkCapture(t, err)

	print(output)
	// expected content printed by tested function
	assert.Contains(t, output, "broker_address")
	assert.Contains(t, output, "broker_topic")
	assert.Contains(t, output, "metrics_namespace")
}

// TestDoSelectedOperationShowVersion checks the function showVersion called
// via doSelectedOperation function
func TestDoSelectedOperationShowVersion(t *testing.T) {
	// stub for structures needed to call the tested function
	configuration := main.ConfigStruct{}
	cliFlags := main.CliFlags{
		ShowVersion:       true,
		ShowAuthors:       false,
		ShowConfiguration: false,
	}

	// try to call the tested function and capture its output
	output, err := capture.StandardOutput(func() {
		code, err := main.DoSelectedOperation(&configuration, cliFlags)
		assert.Equal(t, code, main.ExitStatusOK)
		assert.Nil(t, err)
	})

	// check the captured text
	checkCapture(t, err)

	// expected content printed by tested function
	assert.Contains(t, output, "CCX Notification Writer version")
}

// TestDoSelectedOperationShowAuthors checks the function showAuthors called
// via doSelectedOperation function
func TestDoSelectedOperationShowAuthors(t *testing.T) {
	// stub for structures needed to call the tested function
	configuration := main.ConfigStruct{}
	cliFlags := main.CliFlags{
		ShowVersion:       false,
		ShowAuthors:       true,
		ShowConfiguration: false,
	}

	// try to call the tested function and capture its output
	output, err := capture.StandardOutput(func() {
		code, err := main.DoSelectedOperation(&configuration, cliFlags)
		assert.Equal(t, code, main.ExitStatusOK)
		assert.Nil(t, err)
	})

	// check the captured text
	checkCapture(t, err)

	// expected content printed by tested function
	assert.Contains(t, output, "Pavel Tisnovsky")
	assert.Contains(t, output, "Red Hat Inc.")
}

// TestDoSelectedOperationShowConfiguration checks the function
// showConfiguration called via doSelectedOperation function
func TestDoSelectedOperationShowConfiguration(t *testing.T) {
	// fill in configuration structure
	configuration := main.ConfigStruct{}
	configuration.Broker = main.BrokerConfiguration{
		Addresses: "broker_address",
		Topic:     "broker_topic",
	}
	configuration.Metrics = main.MetricsConfiguration{
		Namespace: "metrics_namespace",
	}

	cliFlags := main.CliFlags{
		ShowVersion:       false,
		ShowAuthors:       false,
		ShowConfiguration: true,
	}

	// try to call the tested function and capture its output
	output, err := capture.ErrorOutput(func() {
		log.Logger = log.Output(zerolog.New(os.Stderr))
		code, err := main.DoSelectedOperation(&configuration, cliFlags)
		assert.Equal(t, code, main.ExitStatusOK)
		assert.NoError(t, err)
	})

	// check the captured text
	checkCapture(t, err)

	// expected content printed by tested function
	assert.Contains(t, output, "broker_address")
	assert.Contains(t, output, "broker_topic")
	assert.Contains(t, output, "metrics_namespace")
}

// TestConvertLogLevel tests the convertLogLevel function.
func TestConvertLogLevel(t *testing.T) {
	type TestData struct {
		Input  string
		Output zerolog.Level
	}

	testData := []TestData{
		{
			Input:  "",
			Output: zerolog.DebugLevel,
		},
		{
			Input:  "debug",
			Output: zerolog.DebugLevel,
		},
		{
			Input:  " debug",
			Output: zerolog.DebugLevel,
		},
		{
			Input:  " debug ",
			Output: zerolog.DebugLevel,
		},
		{
			Input:  "info",
			Output: zerolog.InfoLevel,
		},
		{
			Input:  "warn",
			Output: zerolog.WarnLevel,
		},
		{
			Input:  "warning",
			Output: zerolog.WarnLevel,
		},
		{
			Input:  "error",
			Output: zerolog.ErrorLevel,
		},
		{
			Input:  "fatal",
			Output: zerolog.FatalLevel,
		},
		{
			Input:  " fatal",
			Output: zerolog.FatalLevel,
		},
		{
			Input:  "fatal ",
			Output: zerolog.FatalLevel,
		},
	}

	for _, td := range testData {
		// perform conversion
		output := main.ConvertLogLevel(td.Input)
		// check if converted value is equal to expected one
		assert.Equal(t, output, td.Output)
	}
}

// TestDoSelectedOperationCheckConnectionToKafka checks the function
// CheckConnectionToKafka called via doSelectedOperation function
func TestDoSelectedOperationCheckConnectionToKafka(t *testing.T) {
	// fill in configuration structure
	configuration := main.ConfigStruct{}
	configuration.Broker = main.BrokerConfiguration{
		Addresses: "broker_address:9092, broker_address:9093",
		Topic:     "broker_topic",
	}
	cliFlags := main.CliFlags{
		CheckConnectionToKafka: true,
	}

	// try to call the tested function and capture its output
	output, err := capture.ErrorOutput(func() {
		log.Logger = log.Output(zerolog.New(os.Stderr))
		code, err := main.DoSelectedOperation(&configuration, cliFlags)
		assert.Equal(t, code, main.ExitStatusKafkaError)
		assert.NoError(t, err)
	})

	// check the captured text
	checkCapture(t, err)

	// expected content printed by tested function
	assert.Contains(t, output, main.ConnectionToBrokerMessage)
	assert.Contains(t, output, main.AllBrokerConnectionAttemptsMessage)
}