API simplification

api/etcd/create_test.go

@@ -0,0 +1,35 @@
+package etcd
+
+import (
+	"context"
+	"testing"
+
+	"github.com/gogo/protobuf/proto"
+	"github.com/heetch/regula"
+	"github.com/heetch/regula/api"
+	pb "github.com/heetch/regula/api/etcd/proto"
+	"github.com/stretchr/testify/require"
+)
+
+func TestCreate(t *testing.T) {
+	s, cleanup := newEtcdRulesetService(t)
+	defer cleanup()
+
+	sig := regula.Signature{ReturnType: "bool", Params: map[string]string{"id": "string"}}
+
+	// create a ruleset
+	err := s.Create(context.Background(), "a", &sig)
+	require.NoError(t, err)
+
+	// verify creation
+	resp, err := s.Client.Get(context.Background(), s.signaturesPath("a"))
+	require.NoError(t, err)
+	var pbsig pb.Signature
+	err = proto.Unmarshal(resp.Kvs[0].Value, &pbsig)
+	require.NoError(t, err)
+	require.EqualValues(t, &sig, signatureFromProtobuf(&pbsig))
+
+	// create with the same path
+	err = s.Create(context.Background(), "a", &sig)
+	require.Error(t, api.ErrAlreadyExists, err)
+}

api/etcd/eval_test.go

@@ -0,0 +1,62 @@
+package etcd
+
+import (
+	"context"
+	"testing"
+
+	"github.com/heetch/regula"
+	"github.com/heetch/regula/errors"
+	"github.com/heetch/regula/rule"
+	"github.com/stretchr/testify/require"
+)
+
+func TestEval(t *testing.T) {
+	s, cleanup := newEtcdRulesetService(t)
+	defer cleanup()
+
+	sig := &regula.Signature{ReturnType: "bool", Params: map[string]string{"id": "string"}}
+	require.NoError(t, s.Create(context.Background(), "a", sig))
+
+	r := rule.New(
+		rule.Eq(
+			rule.StringParam("id"),
+			rule.StringValue("123"),
+		),
+		rule.BoolValue(true),
+	)
+
+	ruleset := createRuleset(t, s, "a", r)
+	version := ruleset.Version
+
+	t.Run("SpecificVersion", func(t *testing.T) {
+		res, err := s.Eval(context.Background(), "a", version, regula.Params{
+			"id": "123",
+		})
+		require.NoError(t, err)
+		require.Equal(t, version, res.Version)
+		require.Equal(t, rule.BoolValue(true), res.Value)
+	})
+
+	t.Run("Latest", func(t *testing.T) {
+		res, err := s.Eval(context.Background(), "a", "", regula.Params{
+			"id": "123",
+		})
+		require.NoError(t, err)
+		require.Equal(t, version, res.Version)
+		require.Equal(t, rule.BoolValue(true), res.Value)
+	})
+
+	t.Run("NotFound", func(t *testing.T) {
+		_, err := s.Eval(context.Background(), "b", version, regula.Params{
+			"id": "123",
+		})
+		require.Equal(t, errors.ErrRulesetNotFound, err)
+	})
+
+	t.Run("BadVersion", func(t *testing.T) {
+		_, err := s.Eval(context.Background(), "a", "someversion", regula.Params{
+			"id": "123",
+		})
+		require.Equal(t, errors.ErrRulesetNotFound, err)
+	})
+}

api/etcd/get.go

@@ -11,7 +11,7 @@ import (
 	"github.com/pkg/errors"
 )
 
-// Get returns the ruleset related to the given path. By default, it returns the latest one.
+// Get returns the ruleset related to the given path.By default, it returns the latest one.
 // It returns the related ruleset version if it's specified.
 func (s *RulesetService) Get(ctx context.Context, path, version string) (*regula.Ruleset, error) {
 	if path == "" {
@@ -20,14 +20,15 @@ func (s *RulesetService) Get(ctx context.Context, path, version string) (*regula
 
 	ops := []clientv3.Op{
 		clientv3.OpGet(s.signaturesPath(path)),
-		clientv3.OpGet(s.versionsPath(path)),
+		clientv3.OpGet(s.rulesPath(path, "")+versionSeparator, clientv3.WithPrefix(), clientv3.WithKeysOnly()),
 	}
 
 	if version == "" {
 		ops = append(ops, clientv3.OpGet(s.rulesPath(path, "")+versionSeparator, clientv3.WithLastKey()...))
 	} else {
 		ops = append(ops, clientv3.OpGet(s.rulesPath(path, version)))
 	}
+
 	// running all the requests within a single transaction so only one network round trip is performed.
 	resp, err := s.Client.KV.Txn(ctx).Then(ops...).Commit()
 	if err != nil {
@@ -49,28 +50,35 @@ func (s *RulesetService) Get(ctx context.Context, path, version string) (*regula
 		return nil, errors.Wrap(err, "failed to unmarshal signature")
 	}
 
-	// decode versions
-	var versions pb.Versions
-	err = proto.Unmarshal(resp.Responses[1].GetResponseRange().Kvs[0].Value, &versions)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to unmarshal versions")
+	// the versions must be parsed from the keys returned by the second operation
+	kvs := resp.Responses[1].GetResponseRange().Kvs
+	versions := make([]string, len(kvs))
+	for i, kv := range kvs {
+		_, versions[i] = s.pathVersionFromKey(string(kv.Key))
 	}
 
-	// decode rules
+	// decode rules, might not be filled if only the signature was created
 	var rules pb.Rules
-	err = proto.Unmarshal(resp.Responses[2].GetResponseRange().Kvs[0].Value, &rules)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to unmarshal ruleset")
+	if resp.Responses[2].GetResponseRange().Count > 0 {
+		err = proto.Unmarshal(resp.Responses[2].GetResponseRange().Kvs[0].Value, &rules)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to unmarshal rules")
+		}
+	} else if version != "" {
+		// if no rules are returned but a version is specified, it means that the version doesn't exist
+		return nil, api.ErrRulesetNotFound
 	}
+
+	// if the version wasn't specified, get the latest returned
 	if version == "" {
-		_, version = s.pathVersionFromKey(string(resp.Responses[2].GetResponseRange().Kvs[0].Key))
+		version = versions[len(versions)-1]
 	}
 
 	return &regula.Ruleset{
 		Path:      path,
 		Version:   version,
 		Rules:     rulesFromProtobuf(&rules),
 		Signature: signatureFromProtobuf(&sig),
-		Versions:  versions.Versions,
+		Versions:  versions,
 	}, nil
 }

api/etcd/get_test.go

@@ -0,0 +1,76 @@
+package etcd
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/heetch/regula"
+	"github.com/heetch/regula/api"
+	"github.com/heetch/regula/rule"
+	"github.com/stretchr/testify/require"
+)
+
+func TestGet(t *testing.T) {
+	t.Parallel()
+
+	s, cleanup := newEtcdRulesetService(t)
+	defer cleanup()
+
+	path := "p/a/t/h"
+	sig := &regula.Signature{ReturnType: "bool", Params: make(map[string]string)}
+
+	t.Run("OK", func(t *testing.T) {
+		rules1 := []*rule.Rule{rule.New(rule.True(), rule.BoolValue(true))}
+		createBoolRuleset(t, s, path, rules1...)
+
+		ruleset1, err := s.Get(context.Background(), path, "")
+		require.NoError(t, err)
+		require.Equal(t, path, ruleset1.Path)
+		require.Len(t, ruleset1.Versions, 1)
+		require.NotEmpty(t, rules1, ruleset1.Version)
+		require.Equal(t, rules1, ruleset1.Rules)
+		require.Equal(t, sig, ruleset1.Signature)
+
+		// we are waiting 1 second here to avoid creating the new version in the same second as the previous one
+		// ksuid gives a sorting with a one second precision
+		time.Sleep(time.Second)
+		rules2 := []*rule.Rule{rule.New(rule.Eq(rule.StringValue("foo"), rule.StringValue("foo")), rule.BoolValue(true))}
+		createBoolRuleset(t, s, path, rules2...)
+
+		// it should return the second version
+		ruleset2, err := s.Get(context.Background(), path, "")
+		require.NoError(t, err)
+		require.Equal(t, path, ruleset2.Path)
+		require.Len(t, ruleset2.Versions, 2)
+		require.Equal(t, ruleset1.Version, ruleset2.Versions[0])
+		require.Equal(t, ruleset2.Version, ruleset2.Versions[1])
+		require.Equal(t, rules2, ruleset2.Rules)
+		require.Equal(t, sig, ruleset2.Signature)
+
+		// it should return the first version
+		rs, err := s.Get(context.Background(), path, ruleset1.Version)
+		require.NoError(t, err)
+		require.Equal(t, ruleset1.Path, rs.Path)
+		require.Equal(t, ruleset1.Version, rs.Version)
+		require.Equal(t, ruleset1.Rules, rs.Rules)
+
+		// it should return the second version
+		rs, err = s.Get(context.Background(), path, ruleset2.Version)
+		require.NoError(t, err)
+		require.Equal(t, ruleset2, rs)
+	})
+
+	t.Run("Path Not found", func(t *testing.T) {
+		_, err := s.Get(context.Background(), "doesntexist", "")
+		require.Equal(t, err, api.ErrRulesetNotFound)
+	})
+
+	t.Run("Version Not found", func(t *testing.T) {
+		rules := []*rule.Rule{rule.New(rule.True(), rule.BoolValue(true))}
+		createBoolRuleset(t, s, path, rules...)
+
+		_, err := s.Get(context.Background(), path, "doesntexist")
+		require.Equal(t, err, api.ErrRulesetNotFound)
+	})
+}