← Back to branch summary

~juju-qa/ubuntu/xenial/juju/2.0-rc2

« back to all changes in this revision

Viewing changes to src/github.com/juju/txn/txn_test.go

  • Committer: Nicholas Skaggs
  • Date: 2016-09-30 14:39:30 UTC
  • mfrom: (1.8.1)
  • Revision ID: nicholas.skaggs@canonical.com-20160930143930-vwwhrefh6ftckccy
import upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/juju/txn/txn_test.go
4
4
package txn_test
5
5
 
6
6
import (
 
7
        "errors"
 
8
 
7
9
        "github.com/juju/testing"
8
10
        gc "gopkg.in/check.v1"
9
11
        "gopkg.in/mgo.v2"
197
199
 
198
200
func (s *txnSuite) TestExcessiveContention(c *gc.C) {
199
201
        maxAttempt := 0
 
202
        // This keeps failing because the Assert is wrong.
200
203
        buildTxn := func(attempt int) ([]txn.Op, error) {
201
204
                maxAttempt = attempt
202
205
                ops := []txn.Op{{
247
250
        err = s.collection.FindId("1").One(&found)
248
251
        c.Assert(found, gc.DeepEquals, doc)
249
252
}
 
253
 
 
254
func (s *txnSuite) TestRunFailureIntermittentUnexpectedMessage(c *gc.C) {
 
255
        runner := jujutxn.NewRunner(jujutxn.RunnerParams{})
 
256
        fake := &fakeRunner{errors: []error{errors.New("unexpected message")}}
 
257
        jujutxn.SetRunnerFunc(runner, fake.new)
 
258
        tries := 0
 
259
        // Doesn't matter what this returns as long as it isn't an error.
 
260
        buildTxn := func(attempt int) ([]txn.Op, error) {
 
261
                tries++
 
262
                return nil, nil
 
263
        }
 
264
        err := runner.Run(buildTxn)
 
265
        c.Check(err, gc.Equals, nil)
 
266
        c.Check(tries, gc.Equals, 2)
 
267
}
 
268
 
 
269
func (s *txnSuite) TestRunFailureAlwaysUnexpectedMessage(c *gc.C) {
 
270
        runner := jujutxn.NewRunner(jujutxn.RunnerParams{})
 
271
        fake := &fakeRunner{errors: []error{
 
272
                errors.New("unexpected message"),
 
273
                errors.New("unexpected message"),
 
274
                errors.New("unexpected message"),
 
275
                errors.New("unexpected message"),
 
276
        }}
 
277
        jujutxn.SetRunnerFunc(runner, fake.new)
 
278
        tries := 0
 
279
        // Doesn't matter what this returns as long as it isn't an error.
 
280
        buildTxn := func(attempt int) ([]txn.Op, error) {
 
281
                tries++
 
282
                return nil, nil
 
283
        }
 
284
        err := runner.Run(buildTxn)
 
285
        c.Check(err, gc.ErrorMatches, "unexpected message")
 
286
        c.Check(tries, gc.Equals, 3)
 
287
}
 
288
 
 
289
type fakeRunner struct {
 
290
        jujutxn.TxnRunner
 
291
        errors []error
 
292
}
 
293
 
 
294
// Since a new transaction runner is created each time the code
 
295
// is retried, we want to have a single source of errors, so make the
 
296
// fake a factory that returns itself.
 
297
func (f *fakeRunner) new() jujutxn.TxnRunner {
 
298
        return f
 
299
}
 
300
 
 
301
func (f *fakeRunner) Run([]txn.Op, bson.ObjectId, interface{}) error {
 
302
        if len(f.errors) == 0 {
 
303
                return nil
 
304
        }
 
305
        err := f.errors[0]
 
306
        f.errors = f.errors[1:]
 
307
        return err
 
308
}