102 lines
1.8 KiB
Go
102 lines
1.8 KiB
Go
package rpc
|
|
|
|
import (
|
|
"github.com/mitchellh/packer/packer"
|
|
"net/rpc"
|
|
"testing"
|
|
)
|
|
|
|
type testCache struct {
|
|
lockCalled bool
|
|
lockKey string
|
|
unlockCalled bool
|
|
unlockKey string
|
|
rlockCalled bool
|
|
rlockKey string
|
|
runlockCalled bool
|
|
runlockKey string
|
|
}
|
|
|
|
func (t *testCache) Lock(key string) string {
|
|
t.lockCalled = true
|
|
t.lockKey = key
|
|
return "foo"
|
|
}
|
|
|
|
func (t *testCache) RLock(key string) (string, bool) {
|
|
t.rlockCalled = true
|
|
t.rlockKey = key
|
|
return "foo", true
|
|
}
|
|
|
|
func (t *testCache) Unlock(key string) {
|
|
t.unlockCalled = true
|
|
t.unlockKey = key
|
|
}
|
|
|
|
func (t *testCache) RUnlock(key string) {
|
|
t.runlockCalled = true
|
|
t.runlockKey = key
|
|
}
|
|
|
|
func TestCache_Implements(t *testing.T) {
|
|
var raw interface{}
|
|
raw = Cache(nil)
|
|
if _, ok := raw.(packer.Cache); !ok {
|
|
t.Fatal("Cache must be a cache.")
|
|
}
|
|
}
|
|
|
|
func TestCacheRPC(t *testing.T) {
|
|
// Create the interface to test
|
|
c := new(testCache)
|
|
|
|
// Start the server
|
|
server := rpc.NewServer()
|
|
RegisterCache(server, c)
|
|
address := serveSingleConn(server)
|
|
|
|
// Create the client over RPC and run some methods to verify it works
|
|
rpcClient, err := rpc.Dial("tcp", address)
|
|
if err != nil {
|
|
t.Fatalf("bad: %s", err)
|
|
}
|
|
client := Cache(rpcClient)
|
|
|
|
// Test Lock
|
|
client.Lock("foo")
|
|
if !c.lockCalled {
|
|
t.Fatal("should be called")
|
|
}
|
|
if c.lockKey != "foo" {
|
|
t.Fatalf("bad: %s", c.lockKey)
|
|
}
|
|
|
|
// Test Unlock
|
|
client.Unlock("foo")
|
|
if !c.unlockCalled {
|
|
t.Fatal("should be called")
|
|
}
|
|
if c.unlockKey != "foo" {
|
|
t.Fatalf("bad: %s", c.unlockKey)
|
|
}
|
|
|
|
// Test RLock
|
|
client.RLock("foo")
|
|
if !c.rlockCalled {
|
|
t.Fatal("should be called")
|
|
}
|
|
if c.rlockKey != "foo" {
|
|
t.Fatalf("bad: %s", c.rlockKey)
|
|
}
|
|
|
|
// Test RUnlock
|
|
client.RUnlock("foo")
|
|
if !c.runlockCalled {
|
|
t.Fatal("should be called")
|
|
}
|
|
if c.runlockKey != "foo" {
|
|
t.Fatalf("bad: %s", c.runlockKey)
|
|
}
|
|
}
|