terraform/helper/shadow/keyed_value_test.go

337 lines
5.1 KiB
Go
Raw Normal View History

2016-10-01 03:48:53 +02:00
package shadow
import (
"testing"
"time"
)
func TestKeyedValue(t *testing.T) {
var v KeyedValue
// Start trying to get the value
valueCh := make(chan interface{})
go func() {
valueCh <- v.Value("foo")
}()
// We should not get the value
select {
case <-valueCh:
t.Fatal("shouldn't receive value")
case <-time.After(10 * time.Millisecond):
}
// Set the value
v.SetValue("foo", 42)
val := <-valueCh
// Verify
if val != 42 {
t.Fatalf("bad: %#v", val)
}
// We should get the next value
val = v.Value("foo")
if val != 42 {
t.Fatalf("bad: %#v", val)
}
}
func TestKeyedValue_setFirst(t *testing.T) {
var v KeyedValue
// Set the value
v.SetValue("foo", 42)
val := v.Value("foo")
// Verify
if val != 42 {
t.Fatalf("bad: %#v", val)
}
}
2016-10-01 22:10:07 +02:00
func TestKeyedValueOk(t *testing.T) {
var v KeyedValue
// Try
val, ok := v.ValueOk("foo")
if ok {
t.Fatal("should not be ok")
}
// Set
v.SetValue("foo", 42)
// Try again
val, ok = v.ValueOk("foo")
if !ok {
t.Fatal("should be ok")
}
// Verify
if val != 42 {
t.Fatalf("bad: %#v", val)
}
}
2016-10-05 05:20:07 +02:00
func TestKeyedValueClose(t *testing.T) {
var v KeyedValue
// Close
v.Close()
// Try again
val, ok := v.ValueOk("foo")
if !ok {
t.Fatal("should be ok")
}
// Verify
if val != ErrClosed {
t.Fatalf("bad: %#v", val)
}
}
func TestKeyedValueClose_blocked(t *testing.T) {
var v KeyedValue
// Start reading this should be blocking
valueCh := make(chan interface{})
go func() {
valueCh <- v.Value("foo")
}()
// We should not get the value
select {
case <-valueCh:
t.Fatal("shouldn't receive value")
case <-time.After(10 * time.Millisecond):
}
// Close
v.Close()
// Verify
val := <-valueCh
if val != ErrClosed {
t.Fatalf("bad: %#v", val)
}
}
func TestKeyedValueClose_existing(t *testing.T) {
var v KeyedValue
// Set a value
v.SetValue("foo", "bar")
// Close
v.Close()
// Try again
val, ok := v.ValueOk("foo")
if !ok {
t.Fatal("should be ok")
}
// Verify
if val != "bar" {
t.Fatalf("bad: %#v", val)
}
}
func TestKeyedValueClose_existingBlocked(t *testing.T) {
var v KeyedValue
// Start reading this should be blocking
valueCh := make(chan interface{})
go func() {
valueCh <- v.Value("foo")
}()
// Wait
time.Sleep(10 * time.Millisecond)
// Set a value
v.SetValue("foo", "bar")
// Close
v.Close()
// Try again
val, ok := v.ValueOk("foo")
if !ok {
t.Fatal("should be ok")
}
// Verify
if val != "bar" {
t.Fatalf("bad: %#v", val)
}
}
2016-10-12 12:45:40 +02:00
func TestKeyedValueInit(t *testing.T) {
var v KeyedValue
v.Init("foo", 42)
// We should get the value
val := v.Value("foo")
if val != 42 {
t.Fatalf("bad: %#v", val)
}
// We should get the value
val = v.Value("foo")
if val != 42 {
t.Fatalf("bad: %#v", val)
}
// This should do nothing
v.Init("foo", 84)
// We should get the value
val = v.Value("foo")
if val != 42 {
t.Fatalf("bad: %#v", val)
}
}
func TestKeyedValueInit_set(t *testing.T) {
var v KeyedValue
v.SetValue("foo", 42)
// We should get the value
val := v.Value("foo")
if val != 42 {
t.Fatalf("bad: %#v", val)
}
// We should get the value
val = v.Value("foo")
if val != 42 {
t.Fatalf("bad: %#v", val)
}
// This should do nothing
v.Init("foo", 84)
// We should get the value
val = v.Value("foo")
if val != 42 {
t.Fatalf("bad: %#v", val)
}
}
func TestKeyedValueWaitForChange(t *testing.T) {
var v KeyedValue
// Set a value
v.SetValue("foo", 42)
// Start reading this should be blocking
valueCh := make(chan interface{})
go func() {
valueCh <- v.WaitForChange("foo")
}()
// We should not get the value
select {
case <-valueCh:
t.Fatal("shouldn't receive value")
case <-time.After(10 * time.Millisecond):
}
// Set a new value
v.SetValue("foo", 84)
// Verify
val := <-valueCh
if val != 84 {
t.Fatalf("bad: %#v", val)
}
}
func TestKeyedValueWaitForChange_initial(t *testing.T) {
var v KeyedValue
// Start reading this should be blocking
valueCh := make(chan interface{})
go func() {
valueCh <- v.WaitForChange("foo")
}()
// We should not get the value
select {
case <-valueCh:
t.Fatal("shouldn't receive value")
case <-time.After(10 * time.Millisecond):
}
// Set a new value
v.SetValue("foo", 84)
// Verify
val := <-valueCh
if val != 84 {
t.Fatalf("bad: %#v", val)
}
}
func TestKeyedValueWaitForChange_closed(t *testing.T) {
var v KeyedValue
// Start reading this should be blocking
valueCh := make(chan interface{})
go func() {
valueCh <- v.WaitForChange("foo")
}()
// We should not get the value
select {
case <-valueCh:
t.Fatal("shouldn't receive value")
case <-time.After(10 * time.Millisecond):
}
// Close
v.Close()
// Verify
val := <-valueCh
if val != ErrClosed {
t.Fatalf("bad: %#v", val)
}
// Set a value
v.SetValue("foo", 42)
// Try again
val = v.WaitForChange("foo")
if val != ErrClosed {
t.Fatalf("bad: %#v", val)
}
}
func TestKeyedValueWaitForChange_closedFirst(t *testing.T) {
var v KeyedValue
// Close
v.Close()
// Verify
val := v.WaitForChange("foo")
if val != ErrClosed {
t.Fatalf("bad: %#v", val)
}
// Set a value
v.SetValue("foo", 42)
// Try again
val = v.WaitForChange("foo")
if val != ErrClosed {
t.Fatalf("bad: %#v", val)
}
}