func (s *S) TestErrors(c *C) {
doc := bson.M{"foo": 1}
tests := []txn.Op{{
C: "c",
Id: 0,
}, {
C: "c",
Id: 0,
Insert: doc,
Remove: true,
}, {
C: "c",
Id: 0,
Insert: doc,
Update: doc,
}, {
C: "c",
Id: 0,
Update: doc,
Remove: true,
}, {
C: "c",
Assert: doc,
}, {
Id: 0,
Assert: doc,
}}
txn.SetChaos(txn.Chaos{KillChance: 1.0})
for _, op := range tests {
c.Logf("op: %v", op)
err := s.runner.Run([]txn.Op{op}, "", nil)
c.Assert(err, ErrorMatches, "error in transaction op 0: .*")
}
}
func (s *S) TestTxnQueueStashStressTest(c *C) {
txn.SetChaos(txn.Chaos{
SlowdownChance: 0.3,
Slowdown: 50 * time.Millisecond,
})
defer txn.SetChaos(txn.Chaos{})
// So we can run more iterations of the test in less time.
txn.SetDebug(false)
const runners = 10
const inserts = 10
const repeat = 100
for r := 0; r < repeat; r++ {
var wg sync.WaitGroup
wg.Add(runners)
for i := 0; i < runners; i++ {
go func(i, r int) {
defer wg.Done()
session := s.session.New()
defer session.Close()
runner := txn.NewRunner(s.tc.With(session))
for j := 0; j < inserts; j++ {
ops := []txn.Op{{
C: "accounts",
Id: fmt.Sprintf("insert-%d-%d", r, j),
Insert: bson.M{
"added-by": i,
},
}}
err := runner.Run(ops, "", nil)
if err != txn.ErrAborted {
c.Check(err, IsNil)
}
}
}(i, r)
}
wg.Wait()
}
}
func (s *S) SetUpTest(c *C) {
txn.SetChaos(txn.Chaos{})
txn.SetLogger(c)
txn.SetDebug(true)
s.MgoSuite.SetUpTest(c)
s.db = s.session.DB("test")
s.tc = s.db.C("tc")
s.sc = s.db.C("tc.stash")
s.accounts = s.db.C("accounts")
s.runner = txn.NewRunner(s.tc)
}
func (s *S) TestQueueStashing(c *C) {
txn.SetChaos(txn.Chaos{
KillChance: 1,
Breakpoint: "set-applying",
})
opses := [][]txn.Op{{{
C: "accounts",
Id: 0,
Insert: M{"balance": 100},
}}, {{
C: "accounts",
Id: 0,
Remove: true,
}}, {{
C: "accounts",
Id: 0,
Insert: M{"balance": 200},
}}, {{
C: "accounts",
Id: 0,
Update: M{"$inc": M{"balance": 100}},
}}}
var last bson.ObjectId
for _, ops := range opses {
last = bson.NewObjectId()
err := s.runner.Run(ops, last, nil)
c.Assert(err, Equals, txn.ErrChaos)
}
txn.SetChaos(txn.Chaos{})
err := s.runner.Resume(last)
c.Assert(err, IsNil)
var account Account
err = s.accounts.FindId(0).One(&account)
c.Assert(err, IsNil)
c.Assert(account.Balance, Equals, 300)
}
func (s *S) TestTxnQueueStressTest(c *C) {
txn.SetChaos(txn.Chaos{
SlowdownChance: 0.3,
Slowdown: 50 * time.Millisecond,
})
defer txn.SetChaos(txn.Chaos{})
// So we can run more iterations of the test in less time.
txn.SetDebug(false)
err := s.accounts.Insert(M{"_id": 0, "balance": 0}, M{"_id": 1, "balance": 0})
c.Assert(err, IsNil)
// Run half of the operations changing account 0 and then 1,
// and the other half in the opposite order.
ops01 := []txn.Op{{
C: "accounts",
Id: 0,
Update: M{"$inc": M{"balance": 1}},
}, {
C: "accounts",
Id: 1,
Update: M{"$inc": M{"balance": 1}},
}}
ops10 := []txn.Op{{
C: "accounts",
Id: 1,
Update: M{"$inc": M{"balance": 1}},
}, {
C: "accounts",
Id: 0,
Update: M{"$inc": M{"balance": 1}},
}}
ops := [][]txn.Op{ops01, ops10}
const runners = 4
const changes = 1000
var wg sync.WaitGroup
wg.Add(runners)
for n := 0; n < runners; n++ {
n := n
go func() {
defer wg.Done()
for i := 0; i < changes; i++ {
err = s.runner.Run(ops[n%2], "", nil)
c.Assert(err, IsNil)
}
}()
}
wg.Wait()
for id := 0; id < 2; id++ {
var account Account
err = s.accounts.FindId(id).One(&account)
if account.Balance != runners*changes {
c.Errorf("Account should have balance of %d, got %d", runners*changes, account.Balance)
}
}
}
func (s *S) TestPurgeMissing(c *C) {
txn.SetChaos(txn.Chaos{
KillChance: 1,
Breakpoint: "set-applying",
})
err := s.accounts.Insert(M{"_id": 0, "balance": 100})
c.Assert(err, IsNil)
err = s.accounts.Insert(M{"_id": 1, "balance": 100})
c.Assert(err, IsNil)
ops1 := []txn.Op{{
C: "accounts",
Id: 3,
Insert: M{"balance": 100},
}}
ops2 := []txn.Op{{
C: "accounts",
Id: 0,
Remove: true,
}, {
C: "accounts",
Id: 1,
Update: M{"$inc": M{"balance": 100}},
}, {
C: "accounts",
Id: 2,
Insert: M{"balance": 100},
}}
first := bson.NewObjectId()
c.Logf("---- Running ops1 under transaction %q, to be canceled by chaos", first.Hex())
err = s.runner.Run(ops1, first, nil)
c.Assert(err, Equals, txn.ErrChaos)
last := bson.NewObjectId()
c.Logf("---- Running ops2 under transaction %q, to be canceled by chaos", last.Hex())
err = s.runner.Run(ops2, last, nil)
c.Assert(err, Equals, txn.ErrChaos)
c.Logf("---- Removing transaction %q", last.Hex())
err = s.tc.RemoveId(last)
c.Assert(err, IsNil)
c.Logf("---- Disabling chaos and attempting to resume all")
txn.SetChaos(txn.Chaos{})
err = s.runner.ResumeAll()
c.Assert(err, IsNil)
again := bson.NewObjectId()
c.Logf("---- Running ops2 again under transaction %q, to fail for missing transaction", again.Hex())
err = s.runner.Run(ops2, again, nil)
c.Assert(err, ErrorMatches, "cannot find transaction .*")
c.Logf("---- Purging missing transactions")
err = s.runner.PurgeMissing("accounts")
c.Assert(err, IsNil)
c.Logf("---- Resuming pending transactions")
err = s.runner.ResumeAll()
c.Assert(err, IsNil)
expect := []struct{ Id, Balance int }{
{0, -1},
{1, 200},
{2, 100},
{3, 100},
}
var got Account
for _, want := range expect {
err = s.accounts.FindId(want.Id).One(&got)
if want.Balance == -1 {
if err != mgo.ErrNotFound {
c.Errorf("Account %d should not exist, find got err=%#v", err)
}
} else if err != nil {
c.Errorf("Account %d should have balance of %d, but wasn't found", want.Id, want.Balance)
} else if got.Balance != want.Balance {
c.Errorf("Account %d should have balance of %d, got %d", want.Id, want.Balance, got.Balance)
}
}
}
