forked from looplab/eventhorizon
-
Notifications
You must be signed in to change notification settings - Fork 0
/
aggregate_test.go
129 lines (108 loc) · 3.72 KB
/
aggregate_test.go
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
// Copyright (c) 2014 - The Event Horizon authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package eventhorizon
import (
"context"
"testing"
)
func TestCreateAggregate(t *testing.T) {
id := NewUUID()
aggregate, err := CreateAggregate(TestAggregateRegisterType, id)
if err != ErrAggregateNotRegistered {
t.Error("there should be a aggregate not registered error:", err)
}
RegisterAggregate(func(id UUID) Aggregate {
return &TestAggregateRegister{id: id}
})
aggregate, err = CreateAggregate(TestAggregateRegisterType, id)
if err != nil {
t.Error("there should be no error:", err)
}
// NOTE: The aggregate type used to register with is another than the aggregate!
if aggregate.AggregateType() != TestAggregateRegisterType {
t.Error("the aggregate type should be correct:", aggregate.AggregateType())
}
if aggregate.EntityID() != id {
t.Error("the ID should be correct:", aggregate.EntityID())
}
}
func TestRegisterAggregateEmptyName(t *testing.T) {
defer func() {
if r := recover(); r == nil || r != "eventhorizon: attempt to register empty aggregate type" {
t.Error("there should have been a panic:", r)
}
}()
RegisterAggregate(func(id UUID) Aggregate {
return &TestAggregateRegisterEmpty{id: id}
})
}
func TestRegisterAggregateNil(t *testing.T) {
defer func() {
if r := recover(); r == nil || r != "eventhorizon: created aggregate is nil" {
t.Error("there should have been a panic:", r)
}
}()
RegisterAggregate(func(id UUID) Aggregate { return nil })
}
func TestRegisterAggregateTwice(t *testing.T) {
defer func() {
if r := recover(); r == nil || r != "eventhorizon: registering duplicate types for \"TestAggregateRegisterTwice\"" {
t.Error("there should have been a panic:", r)
}
}()
RegisterAggregate(func(id UUID) Aggregate {
return &TestAggregateRegisterTwice{id: id}
})
RegisterAggregate(func(id UUID) Aggregate {
return &TestAggregateRegisterTwice{id: id}
})
}
const (
TestAggregateRegisterType AggregateType = "TestAggregateRegister"
TestAggregateRegisterEmptyType AggregateType = ""
TestAggregateRegisterTwiceType AggregateType = "TestAggregateRegisterTwice"
)
type TestAggregateRegister struct {
id UUID
}
var _ = Aggregate(&TestAggregateRegister{})
func (a *TestAggregateRegister) EntityID() UUID { return a.id }
func (a *TestAggregateRegister) AggregateType() AggregateType {
return TestAggregateRegisterType
}
func (a *TestAggregateRegister) HandleCommand(ctx context.Context, cmd Command) error {
return nil
}
type TestAggregateRegisterEmpty struct {
id UUID
}
var _ = Aggregate(&TestAggregateRegisterEmpty{})
func (a *TestAggregateRegisterEmpty) EntityID() UUID { return a.id }
func (a *TestAggregateRegisterEmpty) AggregateType() AggregateType {
return TestAggregateRegisterEmptyType
}
func (a *TestAggregateRegisterEmpty) HandleCommand(ctx context.Context, cmd Command) error {
return nil
}
type TestAggregateRegisterTwice struct {
id UUID
}
var _ = Aggregate(&TestAggregateRegisterTwice{})
func (a *TestAggregateRegisterTwice) EntityID() UUID { return a.id }
func (a *TestAggregateRegisterTwice) AggregateType() AggregateType {
return TestAggregateRegisterTwiceType
}
func (a *TestAggregateRegisterTwice) HandleCommand(ctx context.Context, cmd Command) error {
return nil
}