fix: v2 human command (#3435)

* add/register human command done

* validations

* crypto

* move clientid

* keys

* fix: clientID

* remove v2 package

* tests

* tests running

* revert old code

* instance domain from ctx

* chore: rename zitadel app ids

* comments

* fix: test

internal/command/preparation/command_test.go

@@ -0,0 +1,176 @@
+package preparation
+
+import (
+	"context"
+	"errors"
+	"reflect"
+	"testing"
+
+	"github.com/caos/zitadel/internal/eventstore"
+)
+
+var errTest = errors.New("test")
+
+func Test_validate(t *testing.T) {
+	type args struct {
+		validations []Validation
+	}
+	type want struct {
+		len int
+		err error
+	}
+	tests := []struct {
+		name string
+		args args
+		want want
+	}{
+		{
+			name: "no validations",
+			args: args{},
+			want: want{
+				err: ErrNotExecutable,
+			},
+		},
+		{
+			name: "error in validation",
+			args: args{
+				validations: []Validation{
+					func() (CreateCommands, error) {
+						return nil, errTest
+					},
+				},
+			},
+			want: want{
+				err: errTest,
+			},
+		},
+		{
+			name: "correct",
+			args: args{
+				validations: []Validation{
+					func() (CreateCommands, error) {
+						return func(_ context.Context, _ FilterToQueryReducer) ([]eventstore.Command, error) {
+							return nil, nil
+						}, nil
+					},
+				},
+			},
+			want: want{
+				len: 1,
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := validate(tt.args.validations)
+			if !errors.Is(err, tt.want.err) {
+				t.Errorf("validate() error = %v, wantErr %v", err, tt.want.err)
+				return
+			}
+			if len(got) != tt.want.len {
+				t.Errorf("validate() len = %v, want %v", len(got), tt.want.len)
+			}
+		})
+	}
+}
+
+func Test_create(t *testing.T) {
+	type args struct {
+		commanders []CreateCommands
+	}
+	type want struct {
+		err error
+		len int
+	}
+	tests := []struct {
+		name string
+		args args
+		want want
+	}{
+		{
+			name: "error in command",
+			want: want{
+				err: errTest,
+			},
+			args: args{
+				commanders: []CreateCommands{
+					func(_ context.Context, _ FilterToQueryReducer) ([]eventstore.Command, error) {
+						return nil, errTest
+					},
+				},
+			},
+		},
+		{
+			name: "no commands",
+			want: want{},
+			args: args{
+				commanders: []CreateCommands{
+					func(_ context.Context, _ FilterToQueryReducer) ([]eventstore.Command, error) {
+						return nil, nil
+					},
+				},
+			},
+		},
+		{
+			name: "multiple commands",
+			want: want{
+				len: 3,
+			},
+			args: args{
+				commanders: []CreateCommands{
+					func(_ context.Context, _ FilterToQueryReducer) ([]eventstore.Command, error) {
+						return []eventstore.Command{new(testCommand), new(testCommand)}, nil
+					},
+					func(_ context.Context, _ FilterToQueryReducer) ([]eventstore.Command, error) {
+						return []eventstore.Command{new(testCommand)}, nil
+					},
+				},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotCmds, err := create(context.Background(), nil, tt.args.commanders)
+			if !errors.Is(err, tt.want.err) {
+				t.Errorf("create() error = %v, wantErr %v", err, tt.want.err)
+				return
+			}
+			if len(gotCmds) != tt.want.len {
+				t.Errorf("create() len = %d, want %d", len(gotCmds), tt.want.len)
+			}
+		})
+	}
+}
+
+func Test_transactionFilter(t *testing.T) {
+	type args struct {
+		filter   FilterToQueryReducer
+		commands []eventstore.Command
+	}
+	tests := []struct {
+		name string
+		args args
+		want FilterToQueryReducer
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := transactionFilter(tt.args.filter, tt.args.commands); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("transactionFilter() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+type testCommand struct {
+	eventstore.BaseEvent
+}
+
+func (c *testCommand) Data() interface{} {
+	return nil
+}
+
+func (c *testCommand) UniqueConstraints() []*eventstore.EventUniqueConstraint {
+	return nil
+}