github.com/GoogleContainerTools/skaffold@v1.39.18/pkg/skaffold/output/log/log_test.go (about)

     1  /*
     2  Copyright 2021 The Skaffold Authors
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8      http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package log
    18  
    19  import (
    20  	"context"
    21  	"testing"
    22  
    23  	ggcrlogs "github.com/google/go-containerregistry/pkg/logs"
    24  	"github.com/sirupsen/logrus"
    25  
    26  	"github.com/GoogleContainerTools/skaffold/pkg/skaffold/constants"
    27  	"github.com/GoogleContainerTools/skaffold/testutil"
    28  )
    29  
    30  func TestEntry(t *testing.T) {
    31  	tests := []struct {
    32  		name            string
    33  		task            constants.Phase
    34  		expectedTask    constants.Phase
    35  		subtask         string
    36  		expectedSubtask string
    37  		emptyContext    bool
    38  	}{
    39  		{
    40  			name:            "arbitrary task and subtask values",
    41  			task:            constants.Build,
    42  			subtask:         "test",
    43  			expectedTask:    constants.Build,
    44  			expectedSubtask: "test",
    45  		},
    46  		{
    47  			name:            "context missing values",
    48  			emptyContext:    true,
    49  			expectedTask:    constants.DevLoop,
    50  			expectedSubtask: constants.SubtaskIDNone,
    51  		},
    52  	}
    53  
    54  	for _, test := range tests {
    55  		t.Run(test.name, func(t *testing.T) {
    56  			ctx := context.Background()
    57  			if !test.emptyContext {
    58  				ctx = context.WithValue(ctx, ContextKey, EventContext{
    59  					Task:    test.task,
    60  					Subtask: test.subtask,
    61  				})
    62  			}
    63  
    64  			got := Entry(ctx)
    65  			testutil.CheckDeepEqual(t, test.expectedTask, got.Data["task"])
    66  			testutil.CheckDeepEqual(t, test.expectedSubtask, got.Data["subtask"])
    67  		})
    68  	}
    69  }
    70  
    71  func TestKanikoLogLevel(t *testing.T) {
    72  	tests := []struct {
    73  		logrusLevel logrus.Level
    74  		expected    logrus.Level
    75  	}{
    76  		{logrusLevel: logrus.TraceLevel, expected: logrus.DebugLevel},
    77  		{logrusLevel: logrus.DebugLevel, expected: logrus.DebugLevel},
    78  		{logrusLevel: logrus.InfoLevel, expected: logrus.InfoLevel},
    79  		{logrusLevel: logrus.WarnLevel, expected: logrus.InfoLevel},
    80  		{logrusLevel: logrus.ErrorLevel, expected: logrus.InfoLevel},
    81  		{logrusLevel: logrus.FatalLevel, expected: logrus.InfoLevel},
    82  		{logrusLevel: logrus.PanicLevel, expected: logrus.InfoLevel},
    83  	}
    84  	for _, test := range tests {
    85  		defer func(l logrus.Level) { logger.SetLevel(l) }(logger.GetLevel())
    86  		logger.SetLevel(test.logrusLevel)
    87  
    88  		kanikoLevel := KanikoLogLevel()
    89  
    90  		testutil.CheckDeepEqual(t, test.expected, kanikoLevel)
    91  	}
    92  }
    93  
    94  func TestSetupGGCRLogging(t *testing.T) {
    95  	tests := []struct {
    96  		description           string
    97  		logLevel              logrus.Level
    98  		expectWarnEnabled     bool
    99  		expectProgressEnabled bool
   100  		expectDebugEnabled    bool
   101  	}{
   102  		{
   103  			description: "fatal log level disables ggcr logging",
   104  			logLevel:    logrus.FatalLevel,
   105  		},
   106  		{
   107  			description:       "error log level enables ggcr warn logging",
   108  			logLevel:          logrus.ErrorLevel,
   109  			expectWarnEnabled: true,
   110  		},
   111  		{
   112  			description:       "warn log level enables ggcr warn logging",
   113  			logLevel:          logrus.WarnLevel,
   114  			expectWarnEnabled: true,
   115  		},
   116  		{
   117  			description:           "info log level enables ggcr warn and progress logging",
   118  			logLevel:              logrus.InfoLevel,
   119  			expectWarnEnabled:     true,
   120  			expectProgressEnabled: true,
   121  		},
   122  		{
   123  			description:           "debug log level enables ggcr warn and progress logging",
   124  			logLevel:              logrus.DebugLevel,
   125  			expectWarnEnabled:     true,
   126  			expectProgressEnabled: true,
   127  		},
   128  		{
   129  			description:           "trace log level enables ggcr warn and progress and debug logging",
   130  			logLevel:              logrus.TraceLevel,
   131  			expectWarnEnabled:     true,
   132  			expectProgressEnabled: true,
   133  			expectDebugEnabled:    true,
   134  		},
   135  	}
   136  	for _, test := range tests {
   137  		testutil.Run(t, test.description, func(t *testutil.T) {
   138  			setupGGCRLogging(logrus.New(), test.logLevel)
   139  			t.CheckDeepEqual(test.expectWarnEnabled, ggcrlogs.Enabled(ggcrlogs.Warn))
   140  			t.CheckDeepEqual(test.expectProgressEnabled, ggcrlogs.Enabled(ggcrlogs.Progress))
   141  			t.CheckDeepEqual(test.expectDebugEnabled, ggcrlogs.Enabled(ggcrlogs.Debug))
   142  			if test.expectWarnEnabled {
   143  				t.CheckDeepEqual(0, ggcrlogs.Warn.Flags())
   144  			}
   145  			if test.expectProgressEnabled {
   146  				t.CheckDeepEqual(0, ggcrlogs.Progress.Flags())
   147  			}
   148  			if test.expectDebugEnabled {
   149  				t.CheckDeepEqual(0, ggcrlogs.Debug.Flags())
   150  			}
   151  		})
   152  	}
   153  }