1package dag
2
3import (
4 "encoding/json"
5 "fmt"
6 "testing"
7
8 "github.com/stretchr/testify/require"
9
10 "github.com/git-bug/git-bug/entities/identity"
11 "github.com/git-bug/git-bug/entity"
12 "github.com/git-bug/git-bug/repository"
13)
14
15// This file contains an example dummy entity to be used in the tests
16
17/*
18 Operations
19*/
20
21const (
22 _ OperationType = iota
23 Op1
24 Op2
25)
26
27type op1 struct {
28 OpBase
29 Field1 string `json:"field_1"`
30 Files []repository.Hash `json:"files"`
31}
32
33func newOp1(author identity.Interface, field1 string, files ...repository.Hash) *op1 {
34 return &op1{OpBase: NewOpBase(Op1, author, 0), Field1: field1, Files: files}
35}
36
37func (op *op1) Id() entity.Id {
38 return IdOperation(op, &op.OpBase)
39}
40
41func (op *op1) Validate() error { return nil }
42
43func (op *op1) GetFiles() []repository.Hash {
44 return op.Files
45}
46
47type op2 struct {
48 OpBase
49 Field2 string `json:"field_2"`
50}
51
52func newOp2(author identity.Interface, field2 string) *op2 {
53 return &op2{OpBase: NewOpBase(Op2, author, 0), Field2: field2}
54}
55
56func (op *op2) Id() entity.Id {
57 return IdOperation(op, &op.OpBase)
58}
59
60func (op *op2) Validate() error { return nil }
61
62func unmarshaler(raw json.RawMessage, resolvers entity.Resolvers) (Operation, error) {
63 var t struct {
64 OperationType OperationType `json:"type"`
65 }
66
67 if err := json.Unmarshal(raw, &t); err != nil {
68 return nil, err
69 }
70
71 var op Operation
72
73 switch t.OperationType {
74 case Op1:
75 op = &op1{}
76 case Op2:
77 op = &op2{}
78 default:
79 return nil, fmt.Errorf("unknown operation type %v", t.OperationType)
80 }
81
82 err := json.Unmarshal(raw, &op)
83 if err != nil {
84 return nil, err
85 }
86
87 return op, nil
88}
89
90/*
91 Entity
92*/
93
94type Foo struct {
95 *Entity
96}
97
98func wrapper(e *Entity) *Foo {
99 return &Foo{Entity: e}
100}
101
102/*
103 Identities + repo + definition
104*/
105
106func makeTestContext() (repository.ClockedRepo, identity.Interface, identity.Interface, entity.Resolvers, Definition) {
107 repo := repository.NewMockRepo()
108 id1, id2, resolvers, def := makeTestContextInternal(repo)
109 return repo, id1, id2, resolvers, def
110}
111
112func makeTestContextGoGit(t *testing.T) (repository.ClockedRepo, identity.Interface, identity.Interface, entity.Resolvers, Definition) {
113 repo := repository.CreateGoGitTestRepo(t, false)
114 id1, id2, resolvers, def := makeTestContextInternal(repo)
115 return repo, id1, id2, resolvers, def
116}
117
118func makeTestContextRemote(t *testing.T) (repository.ClockedRepo, repository.ClockedRepo, repository.ClockedRepo, identity.Interface, identity.Interface, entity.Resolvers, Definition) {
119 repoA := repository.CreateGoGitTestRepo(t, false)
120 repoB := repository.CreateGoGitTestRepo(t, false)
121 remote := repository.CreateGoGitTestRepo(t, true)
122
123 err := repoA.AddRemote("remote", remote.GetLocalRemote())
124 require.NoError(t, err)
125 err = repoA.AddRemote("repoB", repoB.GetLocalRemote())
126 require.NoError(t, err)
127 err = repoB.AddRemote("remote", remote.GetLocalRemote())
128 require.NoError(t, err)
129 err = repoB.AddRemote("repoA", repoA.GetLocalRemote())
130 require.NoError(t, err)
131
132 id1, id2, resolver, def := makeTestContextInternal(repoA)
133
134 // distribute the identities
135 _, err = identity.Push(repoA, "remote")
136 require.NoError(t, err)
137 err = identity.Pull(repoB, "remote")
138 require.NoError(t, err)
139
140 return repoA, repoB, remote, id1, id2, resolver, def
141}
142
143func makeTestContextInternal(repo repository.ClockedRepo) (identity.Interface, identity.Interface, entity.Resolvers, Definition) {
144 id1, err := identity.NewIdentity(repo, "name1", "email1")
145 if err != nil {
146 panic(err)
147 }
148 err = id1.Commit(repo)
149 if err != nil {
150 panic(err)
151 }
152 id2, err := identity.NewIdentity(repo, "name2", "email2")
153 if err != nil {
154 panic(err)
155 }
156 err = id2.Commit(repo)
157 if err != nil {
158 panic(err)
159 }
160
161 resolvers := entity.Resolvers{
162 &identity.Identity{}: entity.MakeResolver(id1, id2),
163 }
164
165 def := Definition{
166 Typename: "foo",
167 Namespace: "foos",
168 OperationUnmarshaler: unmarshaler,
169 FormatVersion: 1,
170 }
171
172 return id1, id2, resolvers, def
173}