github.com/kamilsk/grafaman@v1.0.0-beta3.0.20201207211242-3e0d02dd84ce/internal/provider/grafana/provider_test.go (about)

     1  package grafana_test
     2  
     3  import (
     4  	"bytes"
     5  	"context"
     6  	"encoding/json"
     7  	"io/ioutil"
     8  	"net/http"
     9  	"os"
    10  	"testing"
    11  
    12  	"github.com/golang/mock/gomock"
    13  	"github.com/pkg/errors"
    14  	"github.com/sirupsen/logrus"
    15  	"github.com/stretchr/testify/assert"
    16  	"github.com/stretchr/testify/require"
    17  	"go.octolab.org/safe"
    18  	"go.octolab.org/unsafe"
    19  
    20  	. "github.com/kamilsk/grafaman/internal/provider/grafana"
    21  )
    22  
    23  func TestProvider(t *testing.T) {
    24  	ctx := context.Background()
    25  
    26  	logger := logrus.New()
    27  	logger.SetOutput(ioutil.Discard)
    28  
    29  	t.Run("success fetch", func(t *testing.T) {
    30  		ctrl := gomock.NewController(t)
    31  		defer ctrl.Finish()
    32  
    33  		client := NewMockClient(ctrl)
    34  		client.EXPECT().
    35  			Do(gomock.Any()).
    36  			Return(response("testdata/success.json")) // nolint:bodyclose
    37  
    38  		progress := NewMockProgressListener(ctrl)
    39  		progress.EXPECT().OnStepDone().Times(1)
    40  		progress.EXPECT().OnStepQueued().Times(1)
    41  
    42  		provider, err := New("test", client, logger, progress)
    43  		require.NoError(t, err)
    44  
    45  		dashboard, err := provider.Fetch(ctx, "dashboard")
    46  		assert.NoError(t, err)
    47  		assert.NotNil(t, dashboard)
    48  	})
    49  
    50  	t.Run("bad endpoint", func(t *testing.T) {
    51  		ctrl := gomock.NewController(t)
    52  		defer ctrl.Finish()
    53  
    54  		progress := NewMockProgressListener(ctrl)
    55  		progress.EXPECT().OnStepDone().Times(0)
    56  		progress.EXPECT().OnStepQueued().Times(0)
    57  
    58  		provider, err := New(":invalid", nil, logger, progress)
    59  		assert.Error(t, err)
    60  		assert.Nil(t, provider)
    61  	})
    62  
    63  	t.Run("nil context", func(t *testing.T) {
    64  		ctrl := gomock.NewController(t)
    65  		defer ctrl.Finish()
    66  
    67  		progress := NewMockProgressListener(ctrl)
    68  		progress.EXPECT().OnStepDone().Times(1)
    69  		progress.EXPECT().OnStepQueued().Times(1)
    70  
    71  		provider, err := New("test", nil, logger, progress)
    72  		require.NoError(t, err)
    73  
    74  		dashboard, err := provider.Fetch(nil, "dashboard") // nolint:staticcheck
    75  		assert.Error(t, err)
    76  		assert.Nil(t, dashboard)
    77  	})
    78  
    79  	t.Run("service unavailable", func(t *testing.T) {
    80  		ctrl := gomock.NewController(t)
    81  		defer ctrl.Finish()
    82  
    83  		client := NewMockClient(ctrl)
    84  		client.EXPECT().
    85  			Do(gomock.Any()).
    86  			Return(nil, errors.New(http.StatusText(http.StatusServiceUnavailable)))
    87  
    88  		progress := NewMockProgressListener(ctrl)
    89  		progress.EXPECT().OnStepDone().Times(1)
    90  		progress.EXPECT().OnStepQueued().Times(1)
    91  
    92  		provider, err := New("test", client, logger, progress)
    93  		require.NoError(t, err)
    94  
    95  		dashboard, err := provider.Fetch(ctx, "dashboard")
    96  		assert.Error(t, err)
    97  		assert.Nil(t, dashboard)
    98  	})
    99  
   100  	t.Run("bad response", func(t *testing.T) {
   101  		ctrl := gomock.NewController(t)
   102  		defer ctrl.Finish()
   103  
   104  		client := NewMockClient(ctrl)
   105  		client.EXPECT().
   106  			Do(gomock.Any()).
   107  			Return(response("testdata/invalid.json")) // nolint:bodyclose
   108  
   109  		progress := NewMockProgressListener(ctrl)
   110  		progress.EXPECT().OnStepDone().Times(1)
   111  		progress.EXPECT().OnStepQueued().Times(1)
   112  
   113  		provider, err := New("test", client, logger, progress)
   114  		require.NoError(t, err)
   115  
   116  		dashboard, err := provider.Fetch(ctx, "dashboard")
   117  		assert.Error(t, err)
   118  		assert.Nil(t, dashboard)
   119  	})
   120  }
   121  
   122  // helpers
   123  
   124  func response(filename string) (*http.Response, error) {
   125  	resp := new(http.Response)
   126  	file, err := os.Open(filename)
   127  	if err != nil {
   128  		return nil, err
   129  	}
   130  	defer safe.Close(file, unsafe.Ignore)
   131  
   132  	var dto struct {
   133  		Code int             `json:"code,omitempty"`
   134  		Body json.RawMessage `json:"body,omitempty"`
   135  	}
   136  	if err := json.NewDecoder(file).Decode(&dto); err != nil {
   137  		return nil, err
   138  	}
   139  
   140  	resp.StatusCode = dto.Code
   141  	resp.Body = ioutil.NopCloser(bytes.NewReader(dto.Body))
   142  	return resp, nil
   143  }