Function TestMutex

pkg/redis/redis_test.go:654–747

(t *testing.T)

}

func TestMutex(t *testing.T) {
	a, ctx := test.New(t)

	ttl := (1 << 10) * test.Delay
	ctx, cancel := context.WithTimeout(ctx, 5*time.Second+ttl)
	defer cancel()

	cl, flush := test.NewRedis(ctx, "redis_test")
	defer flush()
	defer cl.Close()

	key := cl.Key("test1")

	err := LockMutex(ctx, cl, key, "test-id-1", ttl)
	if !a.So(err, should.BeNil) {
		t.Fatalf("Failed to lock mutex: %s", err)
	}

	lockTTL, err := cl.PTTL(ctx, LockKey(key)).Result()
	if !a.So(err, should.BeNil) {
		t.FailNow()
	}
	a.So(lockTTL, should.BeGreaterThan, 0)
	a.So(lockTTL, should.BeLessThanOrEqualTo, ttl)

	blockErrCh := make(chan error, 1)
	go func() {
		blockErrCh <- LockMutex(ctx, cl, key, "test-id-2", ttl)
	}()

	timeoutErrCh := make(chan error, 1)
	go func() {
		ctx, cancel := context.WithTimeout(ctx, (1<<8)*test.Delay)
		defer cancel()
		timeoutErrCh <- LockMutex(ctx, cl, key, "test-id-3", ttl)
	}()

	select {
	case <-ctx.Done():
		t.Fatalf("Timed out while waiting for LockMutex with a deadline to return")
	case err := <-timeoutErrCh:
		if !a.So(errors.IsDeadlineExceeded(err) || errors.IsUnavailable(err), should.BeTrue) {
			t.Fatal(err)
		}
	}
	select {
	case err := <-blockErrCh:
		t.Fatalf("LockMutex returned before previous caller unlocked: %s", err)
	default:
	}

	err = UnlockMutex(ctx, cl, key, "test-id-1", ttl)
	if !a.So(err, should.BeNil) {
		t.Fatalf("Failed to unlock mutex: %s", err)
	}

	select {
	case <-ctx.Done():