func TestPriorityQueueInterrupt(t *testing.T) { b := inmem.NewInmemBroker() q, err := NewPriorityQueue(b, 1, "testing", MinQuietPeriod) if err != nil { t.Fatalf("err: %s", err) } var msg string cancelCh := make(chan struct{}) doneCh := make(chan struct{}) go func(doneCh chan struct{}) { q.ConsumeCancel(&msg, cancelCh) close(doneCh) }(doneCh) go func() { time.Sleep(10 * time.Millisecond) close(cancelCh) }() select { case <-doneCh: return case <-time.After(time.Second): t.Fatalf("should have been cancelled") } }
func TestPriorityQueuePublisher(t *testing.T) { b := inmem.NewInmemBroker() q, err := NewPriorityQueue(b, 10, "testing", MinQuietPeriod) if err != nil { t.Fatalf("err: %s", err) } defer q.Close() p0, err := q.publisher(0) if err != nil { t.Fatalf("err: %s", err) } if !reflect.DeepEqual(p0, q.publishers[0]) { t.Fatalf("bad: %#v", p0) } p9, err := q.publisher(9) if err != nil { t.Fatalf("err: %s", err) } if !reflect.DeepEqual(p9, q.publishers[9]) { t.Fatalf("bad: %#v", p9) } if _, err := q.publisher(10); err == nil { t.Fatalf("should have errored") } }
func TestPriorityQueueMinQuietPeriod(t *testing.T) { b := inmem.NewInmemBroker() // Create a priority queue with a quiet period below the minimum q, err := NewPriorityQueue(b, 1, "testing", 0) if err != nil { t.Fatalf("err: %s", err) } if err := q.Publish("hello", 0); err != nil { t.Fatalf("err: %s", err) } start := time.Now() var msg string cons, _, err := q.Consume(&msg) if err != nil { t.Fatalf("err: %s", err) } defer cons.Close() end := time.Now() if end.Sub(start) < MinQuietPeriod { t.Fatalf("MinQuietPeriod was not honored") } }
func TestPriorityQueueShutdown(t *testing.T) { b := inmem.NewInmemBroker() q, err := NewPriorityQueue(b, 1, "testing", MinQuietPeriod) if err != nil { t.Fatalf("err: %s", err) } defer q.Close() if err := q.Publish("hello", 0); err != nil { t.Fatalf("err: %s", err) } var msg string if _, _, err := q.Consume(&msg); err != nil { t.Fatalf("err: %s", err) } if q.publishers[0] == nil { t.Fatalf("bad: %#v", q.publishers[0]) } if err := q.Close(); err != nil { t.Fatalf("err: %s", err) } if q.publishers[0] != nil { t.Fatalf("bad: %#v", q.publishers[0]) } }
func TestPriorityQueue(t *testing.T) { b := inmem.NewInmemBroker() q, err := NewPriorityQueue(b, 10, "testing", MinQuietPeriod) if err != nil { t.Fatalf("err: %s", err) } defer q.Close() if q.Max() != 9 { t.Fatalf("bad: %d", q.Max()) } if q.Min() != 0 { t.Fatalf("bad: %d", q.Min()) } if _, err := NewPriorityQueue(b, 0, "testing", MinQuietPeriod); err == nil { t.Fatalf("should have errored") } if _, err := NewPriorityQueue(nil, 1, "testing", MinQuietPeriod); err == nil { t.Fatalf("should have errored") } }
func TestPriorityQueueQuietPeriod(t *testing.T) { b := inmem.NewInmemBroker() q, err := NewPriorityQueue(b, 2, "testing", 600*time.Millisecond) if err != nil { t.Fatalf("err: %s", err) } // Send the first message if err := q.Publish("hello0", 0); err != nil { t.Fatalf("err: %s", err) } // Delay a second message with higher priority for a little bit go func(t *testing.T) { time.Sleep(400 * time.Millisecond) if err := q.Publish("hello1", 1); err != nil { t.Fatalf("err: %s", err) } }(t) // Begin consuming with a quiet period longer than the delay. var msg string cons, pri, err := q.Consume(&msg) if err != nil { t.Fatalf("err: %s", err) } cons.Ack() cons.Close() // The message consumed should have been the higher priority message which // arrived after we began consuming messages from the queue. if pri != 1 || msg != "hello1" { t.Fatalf("bad: %d: %s", pri, msg) } // Consume again. The first message we published should have been requeued, // so here we will attempt to read again with no higher priority messages. cons, pri, err = q.Consume(&msg) if err != nil { t.Fatalf("err: %s", err) } cons.Ack() cons.Close() // The first message should now be delivered if pri != 0 || msg != "hello0" { t.Fatalf("bad: %d: %s", pri, msg) } }
func TestPriorityQueueConsume(t *testing.T) { b := inmem.NewInmemBroker() q, err := NewPriorityQueue(b, 10, "testing", MinQuietPeriod) if err != nil { t.Fatalf("err: %s", err) } defer q.Close() // Publish a few messages at different priorities for _, pri := range []int{6, 7, 1} { if err := q.Publish(fmt.Sprintf("hello%d", pri), pri); err != nil { t.Fatalf("err: %s", err) } } // Consume the messages one by one, we should get them back // in the correct priority order var msg string var msgs []string for i := 0; i < 3; i++ { cons, _, err := q.Consume(&msg) if err != nil { t.Fatalf("err: %s", err) } cons.Ack() cons.Close() msgs = append(msgs, msg) } if len(msgs) != 3 { t.Fatalf("bad: %#v", msgs) } expected := []string{"hello7", "hello6", "hello1"} if !reflect.DeepEqual(expected, msgs) { t.Fatalf("bad: %#v", msgs) } }
func TestPriorityQueueConsumer(t *testing.T) { b := inmem.NewInmemBroker() q, err := NewPriorityQueue(b, 1, "testing", MinQuietPeriod) if err != nil { t.Fatalf("err: %s", err) } // Should fail if priority is out of range if _, err := q.consumer(q.Min() - 1); err == nil { t.Fatalf("should have errored") } if _, err := q.consumer(q.Max() + 1); err == nil { t.Fatalf("should have errored") } // Should succeed with a valid priority level cons, err := q.consumer(q.Max()) if err != nil { t.Fatalf("err: %s", err) } defer cons.Close() }
func TestPriorityQueuePublishConsume(t *testing.T) { b := inmem.NewInmemBroker() q, err := NewPriorityQueue(b, 10, "testing", MinQuietPeriod) if err != nil { t.Fatalf("err: %s", err) } defer q.Close() if err := q.Publish("hello", 5); err != nil { t.Fatalf("err: %s", err) } var resp string cons, pri, err := q.Consume(&resp) if err != nil { t.Fatalf("err: %s", err) } defer cons.Close() if resp != "hello" { t.Fatalf("bad: %#v", resp) } if pri != 5 { t.Fatalf("bad: %d", pri) } // Publishing at out-of-range priorities should error if err := q.Publish("hello", q.Min()-1); err == nil { t.Fatalf("should have errored") } if err := q.Publish("hello", q.Max()+1); err == nil { t.Fatalf("should have errored") } }