1 package exp_test
2
3 import (
4 "testing"
5
6 "github.com/doug-martin/goqu/v9/exp"
7 "github.com/stretchr/testify/suite"
8 )
9
10 type insertClausesSuite struct {
11 suite.Suite
12 }
13
14 func TestInsertClausesSuite(t *testing.T) {
15 suite.Run(t, new(insertClausesSuite))
16 }
17
18 func (ics *insertClausesSuite) TestInto() {
19 c := exp.NewInsertClauses()
20 ti := exp.NewIdentifierExpression("", "test", "")
21 c2 := c.SetInto(ti)
22
23 ics.Nil(c.Into())
24
25 ics.Equal(ti, c2.Into())
26 }
27
28 func (ics *insertClausesSuite) TestHasInto() {
29 c := exp.NewInsertClauses()
30 ti := exp.NewIdentifierExpression("", "test", "")
31 c2 := c.SetInto(ti)
32
33 ics.False(c.HasInto())
34
35 ics.True(c2.HasInto())
36 }
37
38 func (ics *insertClausesSuite) TestFrom() {
39 c := exp.NewInsertClauses()
40 ae := newTestAppendableExpression("select * from test", nil)
41 c2 := c.SetFrom(ae)
42
43 ics.Nil(c.From())
44
45 ics.Equal(ae, c2.From())
46 }
47
48 func (ics *insertClausesSuite) TestHasFrom() {
49 c := exp.NewInsertClauses()
50 ae := newTestAppendableExpression("select * from test", nil)
51 c2 := c.SetFrom(ae)
52
53 ics.False(c.HasFrom())
54
55 ics.True(c2.HasFrom())
56 }
57
58 func (ics *insertClausesSuite) TestSetFrom() {
59 c := exp.NewInsertClauses()
60 ae := newTestAppendableExpression("select * from test", nil)
61 c2 := c.SetFrom(ae)
62
63 ics.Nil(c.From())
64
65 ics.Equal(ae, c2.From())
66 }
67
68 func (ics *insertClausesSuite) TestCols() {
69 c := exp.NewInsertClauses()
70 cle := exp.NewColumnListExpression("a", "b")
71 c2 := c.SetCols(cle)
72
73 ics.Nil(c.Cols())
74
75 ics.Equal(cle, c2.Cols())
76 }
77
78 func (ics *insertClausesSuite) TestHasCols() {
79 c := exp.NewInsertClauses()
80 cle := exp.NewColumnListExpression("a", "b")
81 c2 := c.SetCols(cle)
82
83 ics.False(c.HasCols())
84
85 ics.True(c2.HasCols())
86 }
87
88 func (ics *insertClausesSuite) TestColsAppend() {
89 cle := exp.NewColumnListExpression("a")
90 cle2 := exp.NewColumnListExpression("b")
91 c := exp.NewInsertClauses().SetCols(cle)
92 c2 := c.ColsAppend(cle2)
93
94 ics.Equal(cle, c.Cols())
95
96 ics.Equal(exp.NewColumnListExpression("a", "b"), c2.Cols())
97 }
98
99 func (ics *insertClausesSuite) TestVals() {
100 c := exp.NewInsertClauses()
101 vals := [][]interface{}{{"a", "b"}}
102 c2 := c.SetVals(vals)
103
104 ics.Nil(c.Vals())
105
106 ics.Equal(vals, c2.Vals())
107 }
108
109 func (ics *insertClausesSuite) TestHasVals() {
110 c := exp.NewInsertClauses()
111 vals := [][]interface{}{{"a", "b"}}
112 c2 := c.SetVals(vals)
113
114 ics.False(c.HasVals())
115
116 ics.True(c2.HasVals())
117 }
118
119 func (ics *insertClausesSuite) TestValsAppend() {
120 vals := [][]interface{}{{"a", "b"}}
121 vals2 := [][]interface{}{{"c", "d"}}
122 c := exp.NewInsertClauses().SetVals(vals)
123 c2 := c.ValsAppend(vals2)
124
125 ics.Equal(vals, c.Vals())
126
127 ics.Equal([][]interface{}{
128 {"a", "b"},
129 {"c", "d"},
130 }, c2.Vals())
131 }
132
133 func (ics *insertClausesSuite) TestRows() {
134 c := exp.NewInsertClauses()
135 rs := []interface{}{exp.Record{"a": "a1", "b": "b1"}}
136 c2 := c.SetRows(rs)
137
138 ics.Nil(c.Rows())
139
140 ics.Equal(rs, c2.Rows())
141 }
142
143 func (ics *insertClausesSuite) TestHasRows() {
144 c := exp.NewInsertClauses()
145 rs := []interface{}{exp.Record{"a": "a1", "b": "b1"}}
146 c2 := c.SetRows(rs)
147
148 ics.False(c.HasRows())
149
150 ics.True(c2.HasRows())
151 }
152
153 func (ics *insertClausesSuite) TestSetRows() {
154 rs := []interface{}{exp.Record{"a": "a1", "b": "b1"}}
155 c := exp.NewInsertClauses().SetRows(rs)
156 rs2 := []interface{}{exp.Record{"a": "a2", "b": "b2"}}
157 c2 := c.SetRows(rs2)
158
159 ics.Equal(rs, c.Rows())
160
161 ics.Equal(rs2, c2.Rows())
162 }
163
164 func (ics *insertClausesSuite) TestCommonTables() {
165 cte := exp.NewCommonTableExpression(true, "test", newTestAppendableExpression(`SELECT * FROM "foo"`, []interface{}{}))
166
167 c := exp.NewInsertClauses()
168 c2 := c.CommonTablesAppend(cte)
169
170 ics.Nil(c.CommonTables())
171
172 ics.Equal([]exp.CommonTableExpression{cte}, c2.CommonTables())
173 }
174
175 func (ics *insertClausesSuite) TestAddCommonTablesAppend() {
176 cte := exp.NewCommonTableExpression(true, "test", testSQLExpression("test_cte"))
177 cte2 := exp.NewCommonTableExpression(true, "test", testSQLExpression("test_cte2"))
178
179 c := exp.NewInsertClauses().CommonTablesAppend(cte)
180 c2 := c.CommonTablesAppend(cte2)
181
182 ics.Equal([]exp.CommonTableExpression{cte}, c.CommonTables())
183
184 ics.Equal([]exp.CommonTableExpression{cte, cte2}, c2.CommonTables())
185 }
186
187 func (ics *insertClausesSuite) TestOnConflict() {
188 ce := exp.NewDoNothingConflictExpression()
189
190 c := exp.NewInsertClauses()
191 c2 := c.SetOnConflict(ce)
192
193 ics.Nil(c.OnConflict())
194
195 ics.Equal(ce, c2.OnConflict())
196 }
197
198 func (ics *insertClausesSuite) TestSetOnConflict() {
199 ce := exp.NewDoNothingConflictExpression()
200
201 c := exp.NewInsertClauses().SetOnConflict(ce)
202 ce2 := exp.NewDoUpdateConflictExpression("test", exp.Record{"a": "a1"})
203 c2 := c.SetOnConflict(ce2)
204
205 ics.Equal(ce, c.OnConflict())
206
207 ics.Equal(ce2, c2.OnConflict())
208 }
209
210 func (ics *insertClausesSuite) TestReturning() {
211 cl := exp.NewColumnListExpression(exp.NewIdentifierExpression("", "", "col"))
212
213 c := exp.NewInsertClauses()
214 c2 := c.SetReturning(cl)
215
216 ics.Nil(c.Returning())
217
218 ics.Equal(cl, c2.Returning())
219 }
220
221 func (ics *insertClausesSuite) TestHasReturning() {
222 cl := exp.NewColumnListExpression(exp.NewIdentifierExpression("", "", "col"))
223
224 c := exp.NewInsertClauses()
225 c2 := c.SetReturning(cl)
226
227 ics.False(c.HasReturning())
228
229 ics.True(c2.HasReturning())
230 }
231
232 func (ics *insertClausesSuite) TestSetReturning() {
233 cl := exp.NewColumnListExpression(exp.NewIdentifierExpression("", "", "col"))
234 cl2 := exp.NewColumnListExpression(exp.NewIdentifierExpression("", "", "col2"))
235
236 c := exp.NewInsertClauses().SetReturning(cl)
237 c2 := c.SetReturning(cl2)
238
239 ics.Equal(cl, c.Returning())
240
241 ics.Equal(cl2, c2.Returning())
242 }
243
View as plain text