process_test.go

Documentation: go.opentelemetry.io/otel/sdk/resource

     1  // Copyright The OpenTelemetry Authors
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //     http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  package resource_test
    16  
    17  import (
    18  	"context"
    19  	"fmt"
    20  	"os"
    21  	"os/user"
    22  	"runtime"
    23  	"testing"
    24  
    25  	"github.com/stretchr/testify/require"
    26  
    27  	"go.opentelemetry.io/otel/sdk/resource"
    28  )
    29  
    30  var (
    31  	fakePID            = 123
    32  	fakeExecutablePath = "/fake/path/mock"
    33  	fakeCommandArgs    = []string{"mock", "-t", "30"}
    34  	fakeOwner          = "gopher"
    35  	fakeRuntimeName    = "gcmock"
    36  	fakeRuntimeVersion = "go1.2.3"
    37  	fakeRuntimeOS      = "linux"
    38  	fakeRuntimeArch    = "amd64"
    39  )
    40  
    41  var (
    42  	fakeExecutableName     = "mock"
    43  	fakeRuntimeDescription = "go version go1.2.3 linux/amd64"
    44  )
    45  
    46  var (
    47  	fakePidProvider            = func() int { return fakePID }
    48  	fakeExecutablePathProvider = func() (string, error) { return fakeExecutablePath, nil }
    49  	fakeCommandArgsProvider    = func() []string { return fakeCommandArgs }
    50  	fakeOwnerProvider          = func() (*user.User, error) { return &user.User{Username: fakeOwner}, nil }
    51  	fakeRuntimeNameProvider    = func() string { return fakeRuntimeName }
    52  	fakeRuntimeVersionProvider = func() string { return fakeRuntimeVersion }
    53  	fakeRuntimeOSProvider      = func() string { return fakeRuntimeOS }
    54  	fakeRuntimeArchProvider    = func() string { return fakeRuntimeArch }
    55  )
    56  
    57  var (
    58  	fakeExecutablePathProviderWithError = func() (string, error) {
    59  		return "", fmt.Errorf("unable to get process executable")
    60  	}
    61  	fakeOwnerProviderWithError = func() (*user.User, error) {
    62  		return nil, fmt.Errorf("unable to get process user")
    63  	}
    64  )
    65  
    66  func mockProcessAttributesProviders() {
    67  	resource.SetOSProviders(
    68  		fakePidProvider,
    69  		fakeExecutablePathProvider,
    70  		fakeCommandArgsProvider,
    71  	)
    72  	resource.SetRuntimeProviders(
    73  		fakeRuntimeNameProvider,
    74  		fakeRuntimeVersionProvider,
    75  		fakeRuntimeOSProvider,
    76  		fakeRuntimeArchProvider,
    77  	)
    78  	resource.SetUserProviders(
    79  		fakeOwnerProvider,
    80  	)
    81  }
    82  
    83  func mockProcessAttributesProvidersWithErrors() {
    84  	resource.SetOSProviders(
    85  		fakePidProvider,
    86  		fakeExecutablePathProviderWithError,
    87  		fakeCommandArgsProvider,
    88  	)
    89  	resource.SetRuntimeProviders(
    90  		fakeRuntimeNameProvider,
    91  		fakeRuntimeVersionProvider,
    92  		fakeRuntimeOSProvider,
    93  		fakeRuntimeArchProvider,
    94  	)
    95  	resource.SetUserProviders(
    96  		fakeOwnerProviderWithError,
    97  	)
    98  }
    99  
   100  func restoreAttributesProviders() {
   101  	resource.SetDefaultOSProviders()
   102  	resource.SetDefaultRuntimeProviders()
   103  	resource.SetDefaultUserProviders()
   104  	resource.SetDefaultOSDescriptionProvider()
   105  	resource.SetDefaultContainerProviders()
   106  }
   107  
   108  func TestWithProcessFuncsErrors(t *testing.T) {
   109  	mockProcessAttributesProvidersWithErrors()
   110  
   111  	t.Run("WithExecutablePath", testWithProcessExecutablePathError)
   112  	t.Run("WithOwner", testWithProcessOwnerError)
   113  
   114  	restoreAttributesProviders()
   115  }
   116  
   117  func TestCommandArgs(t *testing.T) {
   118  	require.EqualValues(t, os.Args, resource.CommandArgs())
   119  }
   120  
   121  func TestRuntimeName(t *testing.T) {
   122  	if runtime.Compiler == "gc" {
   123  		require.EqualValues(t, "go", resource.RuntimeName())
   124  	} else {
   125  		require.EqualValues(t, runtime.Compiler, resource.RuntimeName())
   126  	}
   127  }
   128  
   129  func TestRuntimeOS(t *testing.T) {
   130  	require.EqualValues(t, runtime.GOOS, resource.RuntimeOS())
   131  }
   132  
   133  func TestRuntimeArch(t *testing.T) {
   134  	require.EqualValues(t, runtime.GOARCH, resource.RuntimeArch())
   135  }
   136  
   137  func testWithProcessExecutablePathError(t *testing.T) {
   138  	ctx := context.Background()
   139  
   140  	res, err := resource.New(ctx,
   141  		resource.WithProcessExecutablePath(),
   142  	)
   143  
   144  	require.Error(t, err)
   145  	require.EqualValues(t, map[string]string{}, toMap(res))
   146  }
   147  
   148  func testWithProcessOwnerError(t *testing.T) {
   149  	ctx := context.Background()
   150  
   151  	res, err := resource.New(ctx,
   152  		resource.WithProcessOwner(),
   153  	)
   154  
   155  	require.Error(t, err)
   156  	require.EqualValues(t, map[string]string{}, toMap(res))
   157  }
   158
View as plain text