k6deps/analyze_internal_test.go at main · grafana-cold-storage/k6deps · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
package k6deps

import (
	"bytes"
	"io"
	"testing"

	"github.com/stretchr/testify/require"
)

func TestEmpty(t *testing.T) {
	t.Parallel()

	inst, err := newEmptyAnalyzer().analyze()
	require.NoError(t, err)
	require.Empty(t, inst)
}

func TestFilterInvalid(t *testing.T) {
	t.Parallel()

	deps := Dependencies{
		"k6":               &Dependency{Name: "k6"},
		"foo":              &Dependency{Name: "foo"},
		"bar":              &Dependency{Name: "bar"},
		"k6/x/faker":       &Dependency{Name: "k6/x/faker"},
		"xk6-foo":          &Dependency{Name: "xk6-foo"},
		"@grafana/xk6-bar": &Dependency{Name: "@grafana/xk6-bar"},
	}

	valid := filterInvalid(deps)

	require.Len(t, valid, 4)
	require.Contains(t, valid, "k6")
	require.Contains(t, valid, "k6/x/faker")
	require.Contains(t, valid, "xk6-foo")
	require.Contains(t, valid, "@grafana/xk6-bar")
}

func TestManifestAnalyzer(t *testing.T) {
	t.Parallel()

	// test empty manifest
	src := io.NopCloser(bytes.NewBuffer(nil))
	deps, err := newManifestAnalyzer(src).analyze()
	require.NoError(t, err)
	require.Empty(t, deps)

	// test manifest
	content := []byte(`{"dependencies":{"@grafana/xk6-faker":"*"}}`)
	src = io.NopCloser(bytes.NewBuffer(content))
	deps, err = newManifestAnalyzer(src).analyze()
	require.NoError(t, err)
	require.NotEmpty(t, deps)
	require.Len(t, deps, 1)
	require.Equal(t, deps["@grafana/xk6-faker"].Constraints.String(), "*")

	// test invalid manifest
	content = []byte(`{`)
	src = io.NopCloser(bytes.NewBuffer(content))
	deps, err = newManifestAnalyzer(src).analyze()
	require.Error(t, err)
	require.Len(t, deps, 0)
}

func TestScriptAnalyzer(t *testing.T) {
	t.Parallel()

	// test scanning script
	content := []byte(`"use k6 with @grafana/xk6-faker>v0.3.0";`)
	src := io.NopCloser(bytes.NewBuffer(content))
	deps, err := newScriptAnalyzer(src).analyze()
	require.NoError(t, err)
	require.NotEmpty(t, deps)
	require.Len(t, deps, 1)
	require.Equal(t, deps["@grafana/xk6-faker"].Constraints.String(), ">v0.3.0")

	// test invalid pragmas
	content = []byte(`"use k6 with k6/x/faker>>1.0";`)
	src = io.NopCloser(bytes.NewBuffer(content))
	deps, err = newScriptAnalyzer(src).analyze()
	require.Error(t, err)
	require.Empty(t, deps)
}

func TestTextAnalyzer(t *testing.T) {
	t.Parallel()

	// test empty text source
	content := []byte{}
	src := io.NopCloser(bytes.NewBuffer(content))
	deps, err := newTextAnalyzer(src).analyze()
	require.NoError(t, err)
	require.Empty(t, deps)

	// test text source
	content = []byte(`@grafana/xk6-faker>v0.3.0`)
	src = io.NopCloser(bytes.NewBuffer(content))
	deps, err = newTextAnalyzer(src).analyze()
	require.NoError(t, err)
	require.NoError(t, err)
	require.NotEmpty(t, deps)
	require.Len(t, deps, 1)
	require.Equal(t, deps["@grafana/xk6-faker"].Constraints.String(), ">v0.3.0")

	// test invalid text source
	content = []byte(`k6/x/faker>>1.0`)
	src = io.NopCloser(bytes.NewBuffer(content))
	deps, err = newTextAnalyzer(src).analyze()
	require.Error(t, err)
	require.Empty(t, deps)
}