github.com/newrelic/newrelic-client-go@v1.1.0/pkg/region/region_test.go (about)

     1  //go:build unit
     2  // +build unit
     3  
     4  package region
     5  
     6  import (
     7  	"testing"
     8  
     9  	"github.com/stretchr/testify/assert"
    10  )
    11  
    12  func TestParse(t *testing.T) {
    13  	t.Parallel()
    14  
    15  	pairs := map[string]Name{
    16  		"us":      US,
    17  		"Us":      US,
    18  		"uS":      US,
    19  		"US":      US,
    20  		"eu":      EU,
    21  		"Eu":      EU,
    22  		"eU":      EU,
    23  		"EU":      EU,
    24  		"staging": Staging,
    25  		"Staging": Staging,
    26  		"STAGING": Staging,
    27  		"local":   Local,
    28  		"Local":   Local,
    29  		"LOCAL":   Local,
    30  	}
    31  
    32  	for k, v := range pairs {
    33  		result, err := Parse(k)
    34  		assert.NoError(t, err)
    35  		assert.Equal(t, v, result)
    36  	}
    37  
    38  	// Default is US
    39  	result, err := Parse("")
    40  	assert.Error(t, err)
    41  	assert.IsType(t, UnknownError{}, err)
    42  	assert.Equal(t, Name(""), result)
    43  }
    44  
    45  func TestRegionGet(t *testing.T) {
    46  	t.Parallel()
    47  
    48  	pairs := map[Name]*Region{
    49  		US:      Regions[US],
    50  		EU:      Regions[EU],
    51  		Staging: Regions[Staging],
    52  	}
    53  
    54  	for k, v := range pairs {
    55  		result, err := Get(k)
    56  		assert.NoError(t, err)
    57  		assert.Equal(t, v, result)
    58  	}
    59  
    60  	// Throws error, still returns the default
    61  	var unk Name = "(unknown)"
    62  	result, err := Get(unk)
    63  	assert.Error(t, err)
    64  	assert.IsType(t, UnknownUsingDefaultError{}, err)
    65  	assert.Equal(t, Regions[Default], result)
    66  }
    67  
    68  func TestRegionString(t *testing.T) {
    69  	t.Parallel()
    70  
    71  	pairs := map[Name]string{
    72  		US:      "US",
    73  		EU:      "EU",
    74  		Staging: "Staging",
    75  		Local:   "Local",
    76  	}
    77  
    78  	for k, v := range pairs {
    79  		result := Regions[k].String()
    80  		assert.Equal(t, result, v)
    81  	}
    82  
    83  	// Verify that an uninitialized Region (should be 0) isn't known
    84  	var unk Region
    85  	result := unk.String()
    86  	assert.Equal(t, result, "(Unknown)")
    87  }
    88  
    89  func TestInfrastructureURLs(t *testing.T) {
    90  	t.Parallel()
    91  
    92  	pairs := map[Name]string{
    93  		US:      "https://infra-api.newrelic.com/v2",
    94  		EU:      "https://infra-api.eu.newrelic.com/v2",
    95  		Staging: "https://staging-infra-api.newrelic.com/v2",
    96  		Local:   "http://localhost:3000/v2",
    97  	}
    98  
    99  	for k, v := range pairs {
   100  		assert.Equal(t, v, Regions[k].InfrastructureURL())
   101  	}
   102  }
   103  
   104  func TestSyntheticsURLs(t *testing.T) {
   105  	t.Parallel()
   106  
   107  	pairs := map[Name]string{
   108  		US:      "https://synthetics.newrelic.com/synthetics/api",
   109  		EU:      "https://synthetics.eu.newrelic.com/synthetics/api",
   110  		Staging: "https://staging-synthetics.newrelic.com/synthetics/api",
   111  		Local:   "http://localhost:3000/synthetics/api",
   112  	}
   113  
   114  	for k, v := range pairs {
   115  		assert.Equal(t, v, Regions[k].SyntheticsURL())
   116  	}
   117  }
   118  
   119  func TestLogsURLs(t *testing.T) {
   120  	t.Parallel()
   121  
   122  	pairs := map[Name]string{
   123  		US:      "https://log-api.newrelic.com/log/v1",
   124  		EU:      "https://log-api.eu.newrelic.com/log/v1",
   125  		Staging: "https://staging-log-api.newrelic.com/log/v1",
   126  		Local:   "http://localhost:3000/log/v1",
   127  	}
   128  
   129  	for k, v := range pairs {
   130  		assert.Equal(t, v, Regions[k].LogsURL())
   131  	}
   132  }
   133  
   134  func TestNerdgraphURLs(t *testing.T) {
   135  	t.Parallel()
   136  
   137  	pairs := map[Name]string{
   138  		US:      "https://api.newrelic.com/graphql",
   139  		EU:      "https://api.eu.newrelic.com/graphql",
   140  		Staging: "https://staging-api.newrelic.com/graphql",
   141  		Local:   "http://localhost:3000/graphql",
   142  	}
   143  
   144  	for k, v := range pairs {
   145  		assert.Equal(t, v, Regions[k].NerdGraphURL())
   146  	}
   147  }
   148  
   149  func TestRESTURLs(t *testing.T) {
   150  	t.Parallel()
   151  
   152  	pairs := map[Name]string{
   153  		US:      "https://api.newrelic.com/v2",
   154  		EU:      "https://api.eu.newrelic.com/v2",
   155  		Staging: "https://staging-api.newrelic.com/v2",
   156  		Local:   "http://localhost:3000/v2",
   157  	}
   158  
   159  	for k, v := range pairs {
   160  		assert.Equal(t, v, Regions[k].RestURL())
   161  	}
   162  }
   163  
   164  func TestConcatURLPaths(t *testing.T) {
   165  	t.Parallel()
   166  
   167  	res, err := concatURLPaths("http://localhost/", []string{"one", "/two", "//three", "four/", "five//"})
   168  
   169  	assert.NoError(t, err)
   170  	assert.Equal(t, "http://localhost/one/two/three/four/five", res)
   171  }