1 package goqu_test
2
3 import (
4 "testing"
5
6 "github.com/DATA-DOG/go-sqlmock"
7 "github.com/doug-martin/goqu/v9"
8 "github.com/doug-martin/goqu/v9/exp"
9 "github.com/doug-martin/goqu/v9/internal/errors"
10 "github.com/doug-martin/goqu/v9/internal/sb"
11 "github.com/doug-martin/goqu/v9/mocks"
12 "github.com/stretchr/testify/mock"
13 "github.com/stretchr/testify/suite"
14 )
15
16 type (
17 truncateTestCase struct {
18 ds *goqu.TruncateDataset
19 clauses exp.TruncateClauses
20 }
21 truncateDatasetSuite struct {
22 suite.Suite
23 }
24 )
25
26 func (tds *truncateDatasetSuite) assertCases(cases ...truncateTestCase) {
27 for _, s := range cases {
28 tds.Equal(s.clauses, s.ds.GetClauses())
29 }
30 }
31
32 func (tds *truncateDatasetSuite) TestClone() {
33 ds := goqu.Truncate("test")
34 tds.Equal(ds, ds.Clone())
35 }
36
37 func (tds *truncateDatasetSuite) TestExpression() {
38 ds := goqu.Truncate("test")
39 tds.Equal(ds, ds.Expression())
40 }
41
42 func (tds *truncateDatasetSuite) TestDialect() {
43 ds := goqu.Truncate("test")
44 tds.NotNil(ds.Dialect())
45 }
46
47 func (tds *truncateDatasetSuite) TestWithDialect() {
48 ds := goqu.Truncate("test")
49 md := new(mocks.SQLDialect)
50 ds = ds.SetDialect(md)
51
52 dialect := goqu.GetDialect("default")
53 dialectDs := ds.WithDialect("default")
54 tds.Equal(md, ds.Dialect())
55 tds.Equal(dialect, dialectDs.Dialect())
56 }
57
58 func (tds *truncateDatasetSuite) TestPrepared() {
59 ds := goqu.Truncate("test")
60 preparedDs := ds.Prepared(true)
61 tds.True(preparedDs.IsPrepared())
62 tds.False(ds.IsPrepared())
63
64 tds.True(preparedDs.Restrict().IsPrepared())
65
66 defer goqu.SetDefaultPrepared(false)
67 goqu.SetDefaultPrepared(true)
68
69
70 ds = goqu.Truncate("test")
71 tds.True(ds.IsPrepared())
72 }
73
74 func (tds *truncateDatasetSuite) TestGetClauses() {
75 ds := goqu.Truncate("test")
76 ce := exp.NewTruncateClauses().SetTable(exp.NewColumnListExpression(goqu.I("test")))
77 tds.Equal(ce, ds.GetClauses())
78 }
79
80 func (tds *truncateDatasetSuite) TestTable() {
81 bd := goqu.Truncate("test")
82 tds.assertCases(
83 truncateTestCase{
84 ds: bd.Table("test2"),
85 clauses: exp.NewTruncateClauses().
86 SetTable(exp.NewColumnListExpression("test2")),
87 },
88 truncateTestCase{
89 ds: bd.Table("test1", "test2"),
90 clauses: exp.NewTruncateClauses().
91 SetTable(exp.NewColumnListExpression("test1", "test2")),
92 },
93 truncateTestCase{
94 ds: bd,
95 clauses: exp.NewTruncateClauses().
96 SetTable(exp.NewColumnListExpression("test")),
97 },
98 )
99 }
100
101 func (tds *truncateDatasetSuite) TestCascade() {
102 bd := goqu.Truncate("test")
103 tds.assertCases(
104 truncateTestCase{
105 ds: bd.Cascade(),
106 clauses: exp.NewTruncateClauses().
107 SetTable(exp.NewColumnListExpression("test")).
108 SetOptions(exp.TruncateOptions{Cascade: true}),
109 },
110 truncateTestCase{
111 ds: bd.Restrict().Cascade(),
112 clauses: exp.NewTruncateClauses().
113 SetTable(exp.NewColumnListExpression("test")).
114 SetOptions(exp.TruncateOptions{Cascade: true, Restrict: true}),
115 },
116 truncateTestCase{
117 ds: bd,
118 clauses: exp.NewTruncateClauses().
119 SetTable(exp.NewColumnListExpression("test")),
120 },
121 )
122 }
123
124 func (tds *truncateDatasetSuite) TestNoCascade() {
125 bd := goqu.Truncate("test").Cascade()
126 tds.assertCases(
127 truncateTestCase{
128 ds: bd.NoCascade(),
129 clauses: exp.NewTruncateClauses().
130 SetTable(exp.NewColumnListExpression("test")).
131 SetOptions(exp.TruncateOptions{}),
132 },
133 truncateTestCase{
134 ds: bd.Restrict().NoCascade(),
135 clauses: exp.NewTruncateClauses().
136 SetTable(exp.NewColumnListExpression("test")).
137 SetOptions(exp.TruncateOptions{Cascade: false, Restrict: true}),
138 },
139 truncateTestCase{
140 ds: bd,
141 clauses: exp.NewTruncateClauses().
142 SetTable(exp.NewColumnListExpression("test")).
143 SetOptions(exp.TruncateOptions{Cascade: true}),
144 },
145 )
146 }
147
148 func (tds *truncateDatasetSuite) TestRestrict() {
149 bd := goqu.Truncate("test")
150 tds.assertCases(
151 truncateTestCase{
152 ds: bd.Restrict(),
153 clauses: exp.NewTruncateClauses().
154 SetTable(exp.NewColumnListExpression("test")).
155 SetOptions(exp.TruncateOptions{Restrict: true}),
156 },
157 truncateTestCase{
158 ds: bd.Cascade().Restrict(),
159 clauses: exp.NewTruncateClauses().
160 SetTable(exp.NewColumnListExpression("test")).
161 SetOptions(exp.TruncateOptions{Cascade: true, Restrict: true}),
162 },
163 truncateTestCase{
164 ds: bd,
165 clauses: exp.NewTruncateClauses().
166 SetTable(exp.NewColumnListExpression("test")),
167 },
168 )
169 }
170
171 func (tds *truncateDatasetSuite) TestNoRestrict() {
172 bd := goqu.Truncate("test").Restrict()
173 tds.assertCases(
174 truncateTestCase{
175 ds: bd.NoRestrict(),
176 clauses: exp.NewTruncateClauses().
177 SetTable(exp.NewColumnListExpression("test")).
178 SetOptions(exp.TruncateOptions{}),
179 },
180 truncateTestCase{
181 ds: bd.Cascade().NoRestrict(),
182 clauses: exp.NewTruncateClauses().
183 SetTable(exp.NewColumnListExpression("test")).
184 SetOptions(exp.TruncateOptions{Cascade: true, Restrict: false}),
185 },
186 truncateTestCase{
187 ds: bd,
188 clauses: exp.NewTruncateClauses().
189 SetTable(exp.NewColumnListExpression("test")).
190 SetOptions(exp.TruncateOptions{Restrict: true}),
191 },
192 )
193 }
194
195 func (tds *truncateDatasetSuite) TestIdentity() {
196 bd := goqu.Truncate("test")
197 tds.assertCases(
198 truncateTestCase{
199 ds: bd.Identity("RESTART"),
200 clauses: exp.NewTruncateClauses().
201 SetTable(exp.NewColumnListExpression("test")).
202 SetOptions(exp.TruncateOptions{Identity: "RESTART"}),
203 },
204 truncateTestCase{
205 ds: bd.Identity("CONTINUE"),
206 clauses: exp.NewTruncateClauses().
207 SetTable(exp.NewColumnListExpression("test")).
208 SetOptions(exp.TruncateOptions{Identity: "CONTINUE"}),
209 },
210 truncateTestCase{
211 ds: bd.Cascade().Restrict().Identity("CONTINUE"),
212 clauses: exp.NewTruncateClauses().
213 SetTable(exp.NewColumnListExpression("test")).
214 SetOptions(exp.TruncateOptions{Cascade: true, Restrict: true, Identity: "CONTINUE"}),
215 },
216 truncateTestCase{
217 ds: bd,
218 clauses: exp.NewTruncateClauses().
219 SetTable(exp.NewColumnListExpression("test")),
220 },
221 )
222 }
223
224 func (tds *truncateDatasetSuite) TestToSQL() {
225 md := new(mocks.SQLDialect)
226 ds := goqu.Truncate("test").SetDialect(md)
227 c := ds.GetClauses()
228 sqlB := sb.NewSQLBuilder(false)
229 md.On("ToTruncateSQL", sqlB, c).Return(nil).Once()
230
231 sql, args, err := ds.ToSQL()
232 tds.NoError(err)
233 tds.Empty(sql)
234 tds.Empty(args)
235 md.AssertExpectations(tds.T())
236 }
237
238 func (tds *truncateDatasetSuite) TestToSQL__withPrepared() {
239 md := new(mocks.SQLDialect)
240 ds := goqu.Truncate("test").Prepared(true).SetDialect(md)
241 c := ds.GetClauses()
242 sqlB := sb.NewSQLBuilder(true)
243 md.On("ToTruncateSQL", sqlB, c).Return(nil).Once()
244
245 sql, args, err := ds.ToSQL()
246 tds.Empty(sql)
247 tds.Empty(args)
248 tds.Nil(err)
249 md.AssertExpectations(tds.T())
250 }
251
252 func (tds *truncateDatasetSuite) TestToSQL_withError() {
253 md := new(mocks.SQLDialect)
254 ds := goqu.Truncate("test").SetDialect(md)
255 c := ds.GetClauses()
256 ee := errors.New("expected error")
257 sqlB := sb.NewSQLBuilder(false)
258 md.On("ToTruncateSQL", sqlB, c).Run(func(args mock.Arguments) {
259 args.Get(0).(sb.SQLBuilder).SetError(ee)
260 }).Once()
261
262 sql, args, err := ds.ToSQL()
263 tds.Empty(sql)
264 tds.Empty(args)
265 tds.Equal(ee, err)
266 md.AssertExpectations(tds.T())
267 }
268
269 func (tds *truncateDatasetSuite) TestExecutor() {
270 mDB, _, err := sqlmock.New()
271 tds.NoError(err)
272
273 ds := goqu.New("mock", mDB).Truncate("table1", "table2")
274
275 tsql, args, err := ds.Executor().ToSQL()
276 tds.NoError(err)
277 tds.Empty(args)
278 tds.Equal(`TRUNCATE "table1", "table2"`, tsql)
279
280 tsql, args, err = ds.Prepared(true).Executor().ToSQL()
281 tds.NoError(err)
282 tds.Empty(args)
283 tds.Equal(`TRUNCATE "table1", "table2"`, tsql)
284
285 defer goqu.SetDefaultPrepared(false)
286 goqu.SetDefaultPrepared(true)
287
288 tsql, args, err = ds.Executor().ToSQL()
289 tds.NoError(err)
290 tds.Empty(args)
291 tds.Equal(`TRUNCATE "table1", "table2"`, tsql)
292 }
293
294 func (tds *truncateDatasetSuite) TestSetError() {
295 err1 := errors.New("error #1")
296 err2 := errors.New("error #2")
297 err3 := errors.New("error #3")
298
299
300 md := new(mocks.SQLDialect)
301 ds := goqu.Truncate("test").SetDialect(md)
302 ds = ds.SetError(err1)
303 tds.Equal(err1, ds.Error())
304 sql, args, err := ds.ToSQL()
305 tds.Empty(sql)
306 tds.Empty(args)
307 tds.Equal(err1, err)
308
309
310 ds = ds.SetError(err2)
311 tds.Equal(err1, ds.Error())
312 sql, args, err = ds.ToSQL()
313 tds.Empty(sql)
314 tds.Empty(args)
315 tds.Equal(err1, err)
316
317
318 ds = ds.Cascade()
319 tds.Equal(err1, ds.Error())
320 sql, args, err = ds.ToSQL()
321 tds.Empty(sql)
322 tds.Empty(args)
323 tds.Equal(err1, err)
324
325
326 c := ds.GetClauses()
327 sqlB := sb.NewSQLBuilder(false)
328 md.On("ToTruncateSQL", sqlB, c).Run(func(args mock.Arguments) {
329 args.Get(0).(sb.SQLBuilder).SetError(err3)
330 }).Once()
331
332 sql, args, err = ds.ToSQL()
333 tds.Empty(sql)
334 tds.Empty(args)
335 tds.Equal(err1, err)
336 }
337
338 func TestTruncateDataset(t *testing.T) {
339 suite.Run(t, new(truncateDatasetSuite))
340 }
341
View as plain text