Add relative path rule

Signed-off-by: Djordje Lukic <[email protected]>

Author: rumpl

internal/validator/rules/relativepath.go

@@ -0,0 +1,74 @@
+package rules
+
+import (
+	"fmt"
+	"path/filepath"
+	"regexp"
+	"strings"
+)
+
+type relativePathRule struct {
+	volumes map[string]interface{}
+	service string
+}
+
+func NewRelativePathRule() Rule {
+	return &relativePathRule{
+		volumes: map[string]interface{}{},
+	}
+}
+
+func (s *relativePathRule) Collect(parent string, key string, value interface{}) {
+	if parent == "volumes" {
+		s.volumes[key] = value
+	}
+}
+
+func (s *relativePathRule) Accept(parent string, key string) bool {
+	if parent == "services" {
+		s.service = key
+	}
+	return regexp.MustCompile("services.(.*).volumes").MatchString(parent + "." + key)
+}
+
+func (s *relativePathRule) Validate(value interface{}) []error {
+	if m, ok := value.(map[string]interface{}); ok {
+		src, ok := m["source"]
+		if !ok {
+			return []error{fmt.Errorf("invalid volume in service %q", s.service)}
+		}
+		_, volumeExists := s.volumes[src.(string)]
+		if !filepath.IsAbs(src.(string)) && !volumeExists {
+			return []error{fmt.Errorf("1 can't use relative path as volume source (%q) in service %q", src, s.service)}
+		}
+	}
+
+	if m, ok := value.([]interface{}); ok {
+		errs := []error{}
+		for _, p := range m {
+			str, ok := p.(string)
+			if !ok {
+				errs = append(errs, fmt.Errorf("invalid volume in service %q", s.service))
+				continue
+			}
+
+			parts := strings.Split(str, ":")
+			if len(parts) != 2 {
+				errs = append(errs, fmt.Errorf("invalid volume definition (%q) in service %q", str, s.service))
+				continue
+			}
+
+			volumeName := parts[0]
+			_, volumeExists := s.volumes[volumeName]
+			if !filepath.IsAbs(volumeName) && !volumeExists {
+				errs = append(errs, fmt.Errorf("can't use relative path as volume source (%q) in service %q", str, s.service))
+				continue
+			}
+		}
+
+		if len(errs) > 0 {
+			return errs
+		}
+	}
+	return nil
+}

internal/validator/rules/relativepath_test.go

@@ -0,0 +1,88 @@
+package rules
+
+import (
+	"fmt"
+	"testing"
+
+	"gotest.tools/assert"
+)
+
+func TestRelativePathRule(t *testing.T) {
+	s := NewRelativePathRule()
+
+	t.Run("should accept only volume paths", func(t *testing.T) {
+		assert.Equal(t, s.Accept("services", "test"), false)
+		assert.Equal(t, s.Accept("services.test.volumes", "my_volume"), true)
+		assert.Equal(t, s.Accept("services.test", "volumes"), true)
+	})
+
+	t.Run("should validate named volume paths", func(t *testing.T) {
+		input := map[string]string{
+			"toto": "tata",
+		}
+		errs := s.Validate(input)
+		assert.Equal(t, len(errs), 0)
+	})
+
+	t.Run("should return error if short syntax volume path is relative", func(t *testing.T) {
+		input := []interface{}{
+			"./foo:/data",
+		}
+		errs := s.Validate(input)
+		assert.Equal(t, len(errs), 1)
+
+		assert.ErrorContains(t, errs[0], `can't use relative path as volume source ("./foo:/data") in service "test"`)
+	})
+
+	t.Run("should return error if the volume definition is invalid", func(t *testing.T) {
+		input := []interface{}{
+			"foo",
+		}
+		errs := s.Validate(input)
+		assert.Equal(t, len(errs), 1)
+
+		assert.ErrorContains(t, errs[0], `invalid volume definition ("foo") in service "test"`)
+	})
+
+	t.Run("should return all volume errors", func(t *testing.T) {
+		input := []interface{}{
+			"./foo:/data1",
+			"./bar:/data2",
+		}
+		errs := s.Validate(input)
+		assert.Equal(t, len(errs), 2)
+
+		assert.ErrorContains(t, errs[0], `can't use relative path as volume source ("./foo:/data1") in service "test"`)
+		assert.ErrorContains(t, errs[1], `can't use relative path as volume source ("./bar:/data2") in service "test"`)
+	})
+
+	// When a volume is in short syntax, the list of volumes must be strings
+	t.Run("shoud return error if volume list is invalid", func(t *testing.T) {
+		input := []interface{}{
+			1,
+		}
+		errs := s.Validate(input)
+		fmt.Println(errs)
+		assert.Equal(t, len(errs), 1)
+
+		assert.ErrorContains(t, errs[0], `invalid volume in service "test"`)
+	})
+
+	t.Run("should return error if long syntax volume path is relative", func(t *testing.T) {
+		input := map[string]interface{}{
+			"source": "./foo",
+		}
+		errs := s.Validate(input)
+		assert.Equal(t, len(errs), 1)
+
+		assert.ErrorContains(t, errs[0], `can't use relative path as volume source ("./foo") in service "test"`)
+	})
+
+	t.Run("shoud return error if volume map is invalid", func(t *testing.T) {
+		input := map[string]interface{}{}
+		errs := s.Validate(input)
+		assert.Equal(t, len(errs), 1)
+
+		assert.ErrorContains(t, errs[0], `invalid volume in service "test"`)
+	})
+}