Fix more linting errors

Author: bchen528

extension/bearertokenauthextension/bearertokenauth.go

@@ -64,15 +64,16 @@ func newBearerTokenAuth(cfg *Config, logger *zap.Logger) *BearerTokenAuth {
 		filename: cfg.Filename,
 		logger:   logger,
 	}
-	if len(cfg.Tokens) > 0 {
+	switch {
+	case len(cfg.Tokens) > 0:
 		tokens := make([]string, len(cfg.Tokens))
 		for i, token := range cfg.Tokens {
 			tokens[i] = string(token)
 		}
 		a.setAuthorizationValues(tokens) // Store tokens
-	} else if cfg.BearerToken != "" {
+	case cfg.BearerToken != "":
 		a.setAuthorizationValues([]string{string(cfg.BearerToken)}) // Store token
-	} else if cfg.Filename != "" {
+	case cfg.Filename != "":
 		a.refreshToken() // Load tokens from file
 	}
 	return a

extension/bearertokenauthextension/bearertokenauth_test.go

@@ -287,56 +287,56 @@ func TestBearerServerAuthenticate(t *testing.T) {
 }
 
 func TestBearerTokenMultipleTokens(t *testing.T) {
-    cfg := createDefaultConfig().(*Config)
-    cfg.Scheme = "Bearer"
-    cfg.Tokens = []configopaque.String{"token1", "token2"}
-
-    bauth := newBearerTokenAuth(cfg, zaptest.NewLogger(t))
-    assert.NotNil(t, bauth)
-
-    assert.NoError(t, bauth.Start(context.Background(), componenttest.NewNopHost()))
-    credential, err := bauth.PerRPCCredentials()
-    assert.NoError(t, err)
-    assert.NotNil(t, credential)
-
-    md, err := credential.GetRequestMetadata(context.Background())
-    expectedMd := map[string]string{
-        "authorization": "Bearer token1",
-    }
-    assert.Equal(t, expectedMd, md)
-    assert.NoError(t, err)
-    assert.True(t, credential.RequireTransportSecurity())
-
-    // Test Authenticate with multiple tokens
-    headers := map[string][]string{
-        "authorization": {"Bearer token1"},
-    }
-    ctx := context.Background()
-    newCtx, err := bauth.Authenticate(ctx, headers)
-    assert.NoError(t, err)
-    assert.Equal(t, ctx, newCtx)
-
-    headers = map[string][]string{
-        "authorization": {"Bearer token2"},
-    }
-    newCtx, err = bauth.Authenticate(ctx, headers)
-    assert.NoError(t, err)
-    assert.Equal(t, ctx, newCtx)
-
-    headers = map[string][]string{
-        "authorization": {"Bearer invalidtoken"},
-    }
-    _, err = bauth.Authenticate(ctx, headers)
-    assert.Error(t, err)
-
-    assert.NoError(t, bauth.Shutdown(context.Background()))
+	cfg := createDefaultConfig().(*Config)
+	cfg.Scheme = "Bearer"
+	cfg.Tokens = []configopaque.String{"token1", "token2"}
+
+	bauth := newBearerTokenAuth(cfg, zaptest.NewLogger(t))
+	assert.NotNil(t, bauth)
+
+	assert.NoError(t, bauth.Start(context.Background(), componenttest.NewNopHost()))
+	credential, err := bauth.PerRPCCredentials()
+	assert.NoError(t, err)
+	assert.NotNil(t, credential)
+
+	md, err := credential.GetRequestMetadata(context.Background())
+	expectedMd := map[string]string{
+		"authorization": "Bearer token1",
+	}
+	assert.Equal(t, expectedMd, md)
+	assert.NoError(t, err)
+	assert.True(t, credential.RequireTransportSecurity())
+
+	// Test Authenticate with multiple tokens
+	headers := map[string][]string{
+		"authorization": {"Bearer token1"},
+	}
+	ctx := context.Background()
+	newCtx, err := bauth.Authenticate(ctx, headers)
+	assert.NoError(t, err)
+	assert.Equal(t, ctx, newCtx)
+
+	headers = map[string][]string{
+		"authorization": {"Bearer token2"},
+	}
+	newCtx, err = bauth.Authenticate(ctx, headers)
+	assert.NoError(t, err)
+	assert.Equal(t, ctx, newCtx)
+
+	headers = map[string][]string{
+		"authorization": {"Bearer invalidtoken"},
+	}
+	_, err = bauth.Authenticate(ctx, headers)
+	assert.Error(t, err)
+
+	assert.NoError(t, bauth.Shutdown(context.Background()))
 }
 
 func TestBearerTokenMultipleTokensInFile(t *testing.T) {
 	scheme := "Bearer"
 	filename := filepath.Join("testdata", t.Name()+".tokens")
 	fileContent := "token1\ntoken2"
-	err := os.WriteFile(filename, []byte(fileContent), 0600)
+	err := os.WriteFile(filename, []byte(fileContent), 0o600)
 	assert.NoError(t, err)
 	defer os.Remove(filename)
 

extension/bearertokenauthextension/config.go

@@ -26,9 +26,9 @@ type Config struct {
 }
 
 var (
-	_                  component.Config = (*Config)(nil)
-	errNoTokenProvided                  = errors.New("no bearer token provided")
-	errTokensAndTokenProvided           = errors.New("either tokens or token should be provided, not both")
+	_                         component.Config = (*Config)(nil)
+	errNoTokenProvided                         = errors.New("no bearer token provided")
+	errTokensAndTokenProvided                  = errors.New("either tokens or token should be provided, not both")
 )
 
 // Validate checks if the extension configuration is valid

extension/bearertokenauthextension/config_test.go

@@ -44,44 +44,44 @@ func TestLoadConfig(t *testing.T) {
 			},
 		},
 		{
-            id: component.NewIDWithName(metadata.Type, "multipletokens"),
-            expected: &Config{
-                Scheme: "Bearer",
-                Tokens: []configopaque.String{"token1", "thistokenalsoworks"},
-            },
-        },
-        {
-            id: component.NewIDWithName(metadata.Type, "withfilename"),
-            expected: &Config{
-                Scheme:   "Bearer",
-                Filename: "file-containing.token",
-            },
-        },
-        {
-            id: component.NewIDWithName(metadata.Type, "both"),
-            expected: &Config{
-                Scheme:      "Bearer",
-                BearerToken: "ignoredtoken",
-                Filename:    "file-containing.token",
-            },
-        },
-        {
-            id: component.NewIDWithName(metadata.Type, "tokensandtoken"),
-            expected: &Config{
-                Scheme:      "Bearer",
-                BearerToken: "sometoken",
-                Tokens:      []configopaque.String{"token1", "thistokenalsoworks"},
-            },
-            expectedErr: true,
-        },
-        {
-            id: component.NewIDWithName(metadata.Type, "withtokensandfilename"),
-            expected: &Config{
-                Scheme:   "Bearer",
-                Tokens:   []configopaque.String{"ignoredtoken1", "ignoredtoken2"},
-                Filename: "file-containing.token",
-            },
-        },
+			id: component.NewIDWithName(metadata.Type, "multipletokens"),
+			expected: &Config{
+				Scheme: "Bearer",
+				Tokens: []configopaque.String{"token1", "thistokenalsoworks"},
+			},
+		},
+		{
+			id: component.NewIDWithName(metadata.Type, "withfilename"),
+			expected: &Config{
+				Scheme:   "Bearer",
+				Filename: "file-containing.token",
+			},
+		},
+		{
+			id: component.NewIDWithName(metadata.Type, "both"),
+			expected: &Config{
+				Scheme:      "Bearer",
+				BearerToken: "ignoredtoken",
+				Filename:    "file-containing.token",
+			},
+		},
+		{
+			id: component.NewIDWithName(metadata.Type, "tokensandtoken"),
+			expected: &Config{
+				Scheme:      "Bearer",
+				BearerToken: "sometoken",
+				Tokens:      []configopaque.String{"token1", "thistokenalsoworks"},
+			},
+			expectedErr: true,
+		},
+		{
+			id: component.NewIDWithName(metadata.Type, "withtokensandfilename"),
+			expected: &Config{
+				Scheme:   "Bearer",
+				Tokens:   []configopaque.String{"ignoredtoken1", "ignoredtoken2"},
+				Filename: "file-containing.token",
+			},
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.id.String(), func(t *testing.T) {