diff --git a/circle.yml b/circle.yml
index dc831410ff11a1306fff000bc239cba3e93facc1..b2bacf4641c6511bf28c775beba3082d12fa6381 100644
--- a/circle.yml
+++ b/circle.yml
@@ -41,7 +41,11 @@ test:
- cd $GOPATH_REPO && go install ./cmd/eris-db
override:
# We only wish to test our packages not vendored ones
+ - echo "Running unit tests..."
- cd $GOPATH_REPO && glide novendor | xargs go test -v
+ - echo "Running integration tests..."
+ - cd $GOPATH_REPO && glide novendor | xargs go test -v -tags integration
+
deployment:
master:
diff --git a/consensus/tendermint/version.go b/consensus/tendermint/version.go
index 04dfcef7aebaf5d92543bd4bc6d0ba669ddd615e..870d1313bf43977a8976f0415d07f1aa5d1f2b2d 100644
--- a/consensus/tendermint/version.go
+++ b/consensus/tendermint/version.go
@@ -17,6 +17,10 @@
package tendermint
import (
+ "strconv"
+
+ tendermint_version "github.com/tendermint/tendermint/version"
+
version "github.com/eris-ltd/eris-db/version"
)
@@ -24,14 +28,51 @@ const (
// Client identifier to advertise over the network
tendermintClientIdentifier = "tendermint"
// Major version component of the current release
- tendermintVersionMajor = 0
+ tendermintVersionMajorConst uint8 = 0
// Minor version component of the current release
- tendermintVersionMinor = 6
+ tendermintVersionMinorConst uint8 = 6
// Patch version component of the current release
- tendermintVersionPatch = 0
+ tendermintVersionPatchConst uint8 = 0
+)
+
+var (
+ tendermintVersionMajor uint8
+ tendermintVersionMinor uint8
+ tendermintVersionPatch uint8
)
+func init() {
+ // discard error because we test for this in Continuous Integration tests
+ tendermintVersionMajor, _ = getTendermintMajorVersionFromSource()
+ tendermintVersionMinor, _ = getTendermintMinorVersionFromSource()
+ tendermintVersionPatch, _ = getTendermintPatchVersionFromSource()
+}
+
func GetTendermintVersion() *version.VersionIdentifier {
return version.New(tendermintClientIdentifier, tendermintVersionMajor,
tendermintVersionMinor, tendermintVersionPatch)
}
+
+func getTendermintMajorVersionFromSource() (uint8, error) {
+ majorVersionUint, err := strconv.ParseUint(tendermint_version.Maj, 10, 8)
+ if err != nil {
+ return tendermintVersionMajorConst, err
+ }
+ return uint8(majorVersionUint), nil
+}
+
+func getTendermintMinorVersionFromSource() (uint8, error) {
+ minorVersionUint, err := strconv.ParseUint(tendermint_version.Min, 10, 8)
+ if err != nil {
+ return tendermintVersionMinorConst, err
+ }
+ return uint8(minorVersionUint), nil
+}
+
+func getTendermintPatchVersionFromSource() (uint8, error) {
+ patchVersionUint, err := strconv.ParseUint(tendermint_version.Fix, 10, 8)
+ if err != nil {
+ return tendermintVersionPatchConst, err
+ }
+ return uint8(patchVersionUint), nil
+}
diff --git a/consensus/tendermint/version_test.go b/consensus/tendermint/version_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..2896e8e55822431eace1599a10d6396930d20050
--- /dev/null
+++ b/consensus/tendermint/version_test.go
@@ -0,0 +1,58 @@
+// Copyright 2015, 2016 Eris Industries (UK) Ltd.
+// This file is part of Eris-RT
+
+// Eris-RT is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Eris-RT is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Eris-RT. If not, see <http://www.gnu.org/licenses/>.
+
+package tendermint
+
+import (
+ "fmt"
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+)
+
+func TestMinorVersionTendermintEqual(t *testing.T) {
+ // assert explicitly on major and minor version number
+ assert.Equal(t, tendermintVersionMajorConst, tendermintVersionMajor,
+ fmt.Sprintf("Major version number for Tendermint consensus is not %v as expected: %v",
+ tendermintVersionMajorConst, tendermintVersionMajor))
+ assert.Equal(t, tendermintVersionMinorConst, tendermintVersionMinor,
+ fmt.Sprintf("Minor version number for Tendermint consensus is not %v as expected: %v",
+ tendermintVersionMinorConst, tendermintVersionMinor))
+ // assert patch number can not regress
+ if tendermintVersionPatchConst > tendermintVersionPatch {
+ t.Errorf("Patch version has regressed for Tendermint consensus: expected minimally %v, got %v",
+ tendermintVersionPatchConst, tendermintVersionPatch)
+ t.Fail()
+ }
+}
+
+func TestSemanticVersioningTendermint(t *testing.T) {
+ // assert that reading the semantic version from Tendermint vendored source
+ // succeeds without error; at runtime initialisation, on error we default
+ // to hard-coded semantic version
+ if _, err := getTendermintMajorVersionFromSource(); err != nil {
+ t.Errorf("Failed to read Major version from Tendermint source code: %s", err)
+ t.Fail()
+ }
+ if _, err := getTendermintMinorVersionFromSource(); err != nil {
+ t.Errorf("Failed to read Minor version from Tendermint source code: %s", err)
+ t.Fail()
+ }
+ if _, err := getTendermintPatchVersionFromSource(); err != nil {
+ t.Errorf("Failed to read Patch version from Tendermint source code: %s", err)
+ t.Fail()
+ }
+}
\ No newline at end of file
diff --git a/definitions/tendermint_pipe.go b/definitions/tendermint_pipe.go
index 76e7a2a617d8ed39b865f435d5acf2d532a450d5..bffa94ad935ba507e82f97f9c87cde93abbe480b 100644
--- a/definitions/tendermint_pipe.go
+++ b/definitions/tendermint_pipe.go
@@ -33,9 +33,9 @@ type TendermintPipe interface {
// Subscribe attempts to subscribe the listener identified by listenerId to
// the event named event. The Event result is written to rpcResponseWriter
// which must be non-blocking
- Subscribe(listenerId, event string,
+ Subscribe(event string,
rpcResponseWriter func(result rpc_tm_types.ErisDBResult)) (*rpc_tm_types.ResultSubscribe, error)
- Unsubscribe(listenerId, event string) (*rpc_tm_types.ResultUnsubscribe, error)
+ Unsubscribe(subscriptionId string) (*rpc_tm_types.ResultUnsubscribe, error)
// Net
Status() (*rpc_tm_types.ResultStatus, error)
diff --git a/event/event_cache_test.go b/event/event_cache_test.go
index 021c7e49abde4e2f9da79dbd8e50e7dff76dbd95..9c1cd06e402209140b429df0367d06aa0218a5ee 100644
--- a/event/event_cache_test.go
+++ b/event/event_cache_test.go
@@ -28,6 +28,8 @@ type mockEventData struct {
eventId string
}
+func (eventData mockEventData) AssertIsEventData() { }
+
// A mock event
func newMockSub(subId, eventId string, f func(txs.EventData)) mockSub {
return mockSub{subId, eventId, f, false, make(chan struct{})}
diff --git a/event/events.go b/event/events.go
index fab369680988f7040b0b854407762299e63eb295..08899c95aa3aa98053f2f422b57c55eec5f80bbc 100644
--- a/event/events.go
+++ b/event/events.go
@@ -134,7 +134,8 @@ func GenerateSubId() (string, error) {
b := make([]byte, 32)
_, err := rand.Read(b)
if err != nil {
- return "", err
+ return "", fmt.Errorf("Could not generate random bytes for a subscription" +
+ " id: %v", err)
}
rStr := hex.EncodeToString(b)
return strings.ToUpper(rStr), nil
diff --git a/event/events_test.go b/event/events_test.go
index 2927589e24f17c397326b97b62c27f2bbf49dd38..51d185ecb0ad5c012c528c2cf1eeb7e3165ab182 100644
--- a/event/events_test.go
+++ b/event/events_test.go
@@ -6,9 +6,8 @@ import (
"sync"
"time"
- "github.com/stretchr/testify/assert"
- evts "github.com/tendermint/go-events"
"github.com/eris-ltd/eris-db/txs"
+ "github.com/stretchr/testify/assert"
)
func TestMultiplexedEvents(t *testing.T) {
diff --git a/manager/eris-mint/pipe.go b/manager/eris-mint/pipe.go
index 1c01c75bb11172575c438e946d500c013f93d50f..3783a5720ecb21f1341f6593d8c4436ad3c2cb16 100644
--- a/manager/eris-mint/pipe.go
+++ b/manager/eris-mint/pipe.go
@@ -232,31 +232,34 @@ func (pipe *erisMintPipe) consensusAndManagerEvents() edb_event.EventEmitter {
//------------------------------------------------------------------------------
// Implement definitions.TendermintPipe for erisMintPipe
-func (pipe *erisMintPipe) Subscribe(listenerId, event string,
+func (pipe *erisMintPipe) Subscribe(event string,
rpcResponseWriter func(result rpc_tm_types.ErisDBResult)) (*rpc_tm_types.ResultSubscribe, error) {
- log.WithFields(log.Fields{"listenerId": listenerId, "event": event}).
+ subscriptionId, err := edb_event.GenerateSubId()
+ if err != nil {
+ return nil, err
+ }
+
+ log.WithFields(log.Fields{"event": event, "subscriptionId": subscriptionId}).
Info("Subscribing to event")
- pipe.consensusAndManagerEvents().Subscribe(subscriptionId(listenerId, event), event,
+ pipe.consensusAndManagerEvents().Subscribe(subscriptionId, event,
func(eventData txs.EventData) {
result := rpc_tm_types.ErisDBResult(&rpc_tm_types.ResultEvent{event,
txs.EventData(eventData)})
// NOTE: EventSwitch callbacks must be nonblocking
rpcResponseWriter(result)
})
- return &rpc_tm_types.ResultSubscribe{}, nil
+ return &rpc_tm_types.ResultSubscribe{
+ SubscriptionId: subscriptionId,
+ Event: event,
+ }, nil
}
-func (pipe *erisMintPipe) Unsubscribe(listenerId,
- event string) (*rpc_tm_types.ResultUnsubscribe, error) {
- log.WithFields(log.Fields{"listenerId": listenerId, "event": event}).
+func (pipe *erisMintPipe) Unsubscribe(subscriptionId string) (*rpc_tm_types.ResultUnsubscribe, error) {
+ log.WithFields(log.Fields{"subscriptionId": subscriptionId}).
Info("Unsubscribing from event")
- pipe.consensusAndManagerEvents().Unsubscribe(subscriptionId(listenerId, event))
- return &rpc_tm_types.ResultUnsubscribe{}, nil
-}
-
-func subscriptionId(listenerId, event string) string {
- return fmt.Sprintf("%s#%s", listenerId, event)
+ pipe.consensusAndManagerEvents().Unsubscribe(subscriptionId)
+ return &rpc_tm_types.ResultUnsubscribe{SubscriptionId: subscriptionId}, nil
}
func (pipe *erisMintPipe) Status() (*rpc_tm_types.ResultStatus, error) {
diff --git a/rpc/tendermint/client/client.go b/rpc/tendermint/client/client.go
index 9750b373c8f8978e38af9a6770f54b3c3fdfc7af..0758eb20f487ea230557acf905fe6a55738b6a3b 100644
--- a/rpc/tendermint/client/client.go
+++ b/rpc/tendermint/client/client.go
@@ -141,6 +141,7 @@ func performCall(client rpcclient.Client, method string,
return
}
+
func mapAndValues(orderedKeyVals ...interface{}) (map[string]interface{},
[]interface{}, error) {
if len(orderedKeyVals)%2 != 0 {
@@ -158,7 +159,7 @@ func mapAndValues(orderedKeyVals ...interface{}) (map[string]interface{},
}
val := orderedKeyVals[i+1]
paramsMap[key] = val
- paramsSlice = append(paramsSlice, val)
+ paramsSlice[i/2] = val
}
return paramsMap, paramsSlice, nil
}
diff --git a/rpc/tendermint/client/client_test.go b/rpc/tendermint/client/client_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..b860fefbd54e5e9d505df49e09939a9237a71ce2
--- /dev/null
+++ b/rpc/tendermint/client/client_test.go
@@ -0,0 +1,34 @@
+package client
+
+import (
+ "testing"
+ "github.com/stretchr/testify/assert"
+)
+
+func TestMapsAndValues(t *testing.T) {
+ type aStruct struct {
+ Baz int
+ }
+ dict, vals, err := mapAndValues("Foo", aStruct{5},
+ "Bar", "Nibbles")
+ assert.Equal(t, map[string]interface{}{
+ "Foo": aStruct{5},
+ "Bar": "Nibbles",
+ }, dict)
+ assert.Equal(t, []interface{}{aStruct{5}, "Nibbles"}, vals)
+
+ // Empty map
+ dict, vals, err = mapAndValues()
+ assert.Equal(t, map[string]interface{}{}, dict)
+ assert.Equal(t, []interface{}{}, vals)
+ assert.NoError(t, err, "Empty mapsAndValues call should be fine")
+
+ // Invalid maps
+ assert.NoError(t, err, "Empty mapsAndValues call should be fine")
+ _, _, err = mapAndValues("Foo", 4, "Bar")
+ assert.Error(t, err, "Should be an error to get an odd number of arguments")
+
+ _, _, err = mapAndValues("Foo", 4, 4, "Bar")
+ assert.Error(t, err, "Should be an error to provide non-string keys")
+
+}
diff --git a/rpc/tendermint/core/routes.go b/rpc/tendermint/core/routes.go
index 02ffadfbf3a2bc07d1d5ce6ee5d565d2b677cd95..7fc6b03f6e17052779761b4189b8beb86e09fd8c 100644
--- a/rpc/tendermint/core/routes.go
+++ b/rpc/tendermint/core/routes.go
@@ -25,7 +25,7 @@ type TendermintRoutes struct {
func (tmRoutes *TendermintRoutes) GetRoutes() map[string]*rpc.RPCFunc {
var routes = map[string]*rpc.RPCFunc{
"subscribe": rpc.NewWSRPCFunc(tmRoutes.Subscribe, "event"),
- "unsubscribe": rpc.NewWSRPCFunc(tmRoutes.Unsubscribe, "event"),
+ "unsubscribe": rpc.NewWSRPCFunc(tmRoutes.Unsubscribe, "subscriptionId"),
"status": rpc.NewRPCFunc(tmRoutes.StatusResult, ""),
"net_info": rpc.NewRPCFunc(tmRoutes.NetInfoResult, ""),
"genesis": rpc.NewRPCFunc(tmRoutes.GenesisResult, ""),
@@ -61,8 +61,9 @@ func (tmRoutes *TendermintRoutes) Subscribe(wsCtx rpctypes.WSRPCContext,
// and return it in the result. This would require clients to hang on to a
// subscription id if they wish to unsubscribe, but then again they can just
// drop their connection
- result, err := tmRoutes.tendermintPipe.Subscribe(wsCtx.GetRemoteAddr(), event,
+ result, err := tmRoutes.tendermintPipe.Subscribe(event,
func(result ctypes.ErisDBResult) {
+ wsCtx.GetRemoteAddr()
// NOTE: EventSwitch callbacks must be nonblocking
wsCtx.TryWriteRPCResponse(
rpctypes.NewRPCResponse(wsCtx.Request.ID+"#event", &result, ""))
@@ -75,9 +76,8 @@ func (tmRoutes *TendermintRoutes) Subscribe(wsCtx rpctypes.WSRPCContext,
}
func (tmRoutes *TendermintRoutes) Unsubscribe(wsCtx rpctypes.WSRPCContext,
- event string) (ctypes.ErisDBResult, error) {
- result, err := tmRoutes.tendermintPipe.Unsubscribe(wsCtx.GetRemoteAddr(),
- event)
+ subscriptionId string) (ctypes.ErisDBResult, error) {
+ result, err := tmRoutes.tendermintPipe.Unsubscribe(subscriptionId)
if err != nil {
return nil, err
} else {
diff --git a/rpc/tendermint/core/types/responses.go b/rpc/tendermint/core/types/responses.go
index 179e26dab7afac286f0aa9b890276f29cb5f8813..ed050c03e8be5d16372f88283563eaa3d707824c 100644
--- a/rpc/tendermint/core/types/responses.go
+++ b/rpc/tendermint/core/types/responses.go
@@ -60,9 +60,12 @@ type ResultStatus struct {
}
type ResultSubscribe struct {
+ Event string `json:"event"`
+ SubscriptionId string `json:"subscription_id"`
}
type ResultUnsubscribe struct {
+ SubscriptionId string `json:"subscription_id"`
}
type ResultNetInfo struct {
diff --git a/rpc/tendermint/core/websocket.go b/rpc/tendermint/core/websocket.go
index c15ee966829e55216e659dbcebda092852884d0f..6824b78e052becb787ccf8092870cb4a73b37c2a 100644
--- a/rpc/tendermint/core/websocket.go
+++ b/rpc/tendermint/core/websocket.go
@@ -67,3 +67,9 @@ func NewTendermintWebsocketServer(config *server.ServerConfig,
listeners: listeners,
}, nil
}
+
+func (tmServer *TendermintWebsocketServer) Shutdown() {
+ for _, listener := range tmServer.listeners {
+ listener.Close()
+ }
+}
diff --git a/rpc/tendermint/test/client_rpc_test.go b/rpc/tendermint/test/client_rpc_test.go
index e6db77128e1ee7f9674d11523c7efeb0604e55fe..1bb84efc2d4e2b94beb4c60fc23a115f1803bd00 100644
--- a/rpc/tendermint/test/client_rpc_test.go
+++ b/rpc/tendermint/test/client_rpc_test.go
@@ -1,3 +1,6 @@
+// +build integration
+
+// Space above here matters
package test
import (
diff --git a/rpc/tendermint/test/client_ws_test.go b/rpc/tendermint/test/client_ws_test.go
index 2f55ebf9ccb803378d319b2b268816c71df26c8a..76c61fde59a4bf39d5973a3981c14333f3433e37 100644
--- a/rpc/tendermint/test/client_ws_test.go
+++ b/rpc/tendermint/test/client_ws_test.go
@@ -1,3 +1,6 @@
+// +build integration
+
+// Space above here matters
package test
import (
@@ -24,9 +27,9 @@ func TestWSConnect(t *testing.T) {
func TestWSNewBlock(t *testing.T) {
wsc := newWSClient(t)
eid := txs.EventStringNewBlock()
- subscribe(t, wsc, eid)
+ subId := subscribeAndGetSubscriptionId(t, wsc, eid)
defer func() {
- unsubscribe(t, wsc, eid)
+ unsubscribe(t, wsc, subId)
wsc.Stop()
}()
waitForEvent(t, wsc, eid, func() {},
@@ -43,9 +46,9 @@ func TestWSBlockchainGrowth(t *testing.T) {
}
wsc := newWSClient(t)
eid := txs.EventStringNewBlock()
- subscribe(t, wsc, eid)
+ subId := subscribeAndGetSubscriptionId(t, wsc, eid)
defer func() {
- unsubscribe(t, wsc, eid)
+ unsubscribe(t, wsc, subId)
wsc.Stop()
}()
// listen for NewBlock, ensure height increases by 1
@@ -80,11 +83,11 @@ func TestWSSend(t *testing.T) {
wsc := newWSClient(t)
eidInput := txs.EventStringAccInput(user[0].Address)
eidOutput := txs.EventStringAccOutput(toAddr)
- subscribe(t, wsc, eidInput)
- subscribe(t, wsc, eidOutput)
+ subIdInput := subscribeAndGetSubscriptionId(t, wsc, eidInput)
+ subIdOutput := subscribeAndGetSubscriptionId(t, wsc, eidOutput)
defer func() {
- unsubscribe(t, wsc, eidInput)
- unsubscribe(t, wsc, eidOutput)
+ unsubscribe(t, wsc, subIdInput)
+ unsubscribe(t, wsc, subIdOutput)
wsc.Stop()
}()
waitForEvent(t, wsc, eidInput, func() {
@@ -103,9 +106,9 @@ func TestWSDoubleFire(t *testing.T) {
}
wsc := newWSClient(t)
eid := txs.EventStringAccInput(user[0].Address)
- subscribe(t, wsc, eid)
+ subId := subscribeAndGetSubscriptionId(t, wsc, eid)
defer func() {
- unsubscribe(t, wsc, eid)
+ unsubscribe(t, wsc, subId)
wsc.Stop()
}()
amt := int64(100)
@@ -134,9 +137,9 @@ func TestWSCallWait(t *testing.T) {
}
wsc := newWSClient(t)
eid1 := txs.EventStringAccInput(user[0].Address)
- subscribe(t, wsc, eid1)
+ subId1 := subscribeAndGetSubscriptionId(t, wsc, eid1)
defer func() {
- unsubscribe(t, wsc, eid1)
+ unsubscribe(t, wsc, subId1)
wsc.Stop()
}()
amt, gasLim, fee := int64(10000), int64(1000), int64(1000)
@@ -152,9 +155,9 @@ func TestWSCallWait(t *testing.T) {
// susbscribe to the new contract
amt = int64(10001)
eid2 := txs.EventStringAccOutput(contractAddr)
- subscribe(t, wsc, eid2)
+ subId2 := subscribeAndGetSubscriptionId(t, wsc, eid2)
defer func() {
- unsubscribe(t, wsc, eid2)
+ unsubscribe(t, wsc, subId2)
}()
// get the return value from a call
data := []byte{0x1}
@@ -182,9 +185,9 @@ func TestWSCallNoWait(t *testing.T) {
// susbscribe to the new contract
amt = int64(10001)
eid := txs.EventStringAccOutput(contractAddr)
- subscribe(t, wsc, eid)
+ subId := subscribeAndGetSubscriptionId(t, wsc, eid)
defer func() {
- unsubscribe(t, wsc, eid)
+ unsubscribe(t, wsc, subId)
wsc.Stop()
}()
// get the return value from a call
@@ -215,25 +218,29 @@ func TestWSCallCall(t *testing.T) {
receipt = broadcastTx(t, wsTyp, tx)
contractAddr2 := receipt.ContractAddr
- // susbscribe to the new contracts
+ // subscribe to the new contracts
amt = int64(10001)
- eid1 := txs.EventStringAccCall(contractAddr1)
- subscribe(t, wsc, eid1)
+ eid := txs.EventStringAccCall(contractAddr1)
+ subId := subscribeAndGetSubscriptionId(t, wsc, eid)
defer func() {
- unsubscribe(t, wsc, eid1)
+ unsubscribe(t, wsc, subId)
wsc.Stop()
}()
// call contract2, which should call contract1, and wait for ev1
// let the contract get created first
- waitForEvent(t, wsc, eid1, func() {
+ waitForEvent(t, wsc, eid, func() {
}, func(eid string, b txs.EventData) (bool, error) {
return true, nil
})
// call it
- waitForEvent(t, wsc, eid1, func() {
+ waitForEvent(t, wsc, eid, func() {
tx := makeDefaultCallTx(t, wsTyp, contractAddr2, nil, amt, gasLim, fee)
broadcastTx(t, wsTyp, tx)
*txid = txs.TxHash(chainID, tx)
}, unmarshalValidateCall(user[0].Address, returnVal, txid))
}
+
+func TestSubscribe(t *testing.T) {
+ testSubscribe(t)
+}
diff --git a/rpc/tendermint/test/common.go b/rpc/tendermint/test/common.go
index b0d2f07eb76a8a0ff5123306b2d6b5746005489d..81832215a3fec3adc6293091bc16a6e7fc1f5399 100644
--- a/rpc/tendermint/test/common.go
+++ b/rpc/tendermint/test/common.go
@@ -2,6 +2,7 @@ package test
import (
"github.com/eris-ltd/eris-db/test/fixtures"
+ rpc_core "github.com/eris-ltd/eris-db/rpc/tendermint/core"
"testing"
)
@@ -19,7 +20,14 @@ func TestWrapper(runner func() int) int {
// start a node
ready := make(chan error)
- go newNode(ready)
+ server := make(chan *rpc_core.TendermintWebsocketServer)
+ defer func(){
+ // Shutdown -- make sure we don't hit a race on ffs.RemoveAll
+ tmServer := <-server
+ tmServer.Shutdown()
+ }()
+
+ go newNode(ready, server)
err = <-ready
if err != nil {
diff --git a/rpc/tendermint/test/common_test.go b/rpc/tendermint/test/common_test.go
index 988f249b180f97861cf6b090288f48705d7f60de..aabfc84f3388060f1831a623812e097eef74dbf2 100644
--- a/rpc/tendermint/test/common_test.go
+++ b/rpc/tendermint/test/common_test.go
@@ -1,3 +1,6 @@
+// +build integration
+
+// Space above here matters
package test
import (
diff --git a/rpc/tendermint/test/shared.go b/rpc/tendermint/test/shared.go
index 2bcffc1f28d1cdf1024700be3216a020c8720437..d705d27857ecc5db7223f5ecddf5cb3d31a91c5b 100644
--- a/rpc/tendermint/test/shared.go
+++ b/rpc/tendermint/test/shared.go
@@ -9,6 +9,7 @@ import (
"github.com/eris-ltd/eris-db/core"
core_types "github.com/eris-ltd/eris-db/core/types"
edbcli "github.com/eris-ltd/eris-db/rpc/tendermint/client"
+ rpc_core "github.com/eris-ltd/eris-db/rpc/tendermint/core"
rpc_types "github.com/eris-ltd/eris-db/rpc/tendermint/core/types"
"github.com/eris-ltd/eris-db/server"
"github.com/eris-ltd/eris-db/test/fixtures"
@@ -102,10 +103,12 @@ func makeUsers(n int) []*acm.PrivAccount {
return accounts
}
-func newNode(ready chan error) {
+func newNode(ready chan error,
+ tmServer chan *rpc_core.TendermintWebsocketServer) {
// Run the 'tendermint' rpc server
- _, err := testCore.NewGatewayTendermint(config)
+ server, err := testCore.NewGatewayTendermint(config)
ready <- err
+ tmServer <- server
}
func saveNewPriv() {
diff --git a/rpc/tendermint/test/tests.go b/rpc/tendermint/test/tests.go
index f1eac5cba98557aeca1ad8964952e95089c48c83..c8fac0d627b5e60c18dad3b6b3e997893994a2b1 100644
--- a/rpc/tendermint/test/tests.go
+++ b/rpc/tendermint/test/tests.go
@@ -6,9 +6,12 @@ import (
"testing"
edbcli "github.com/eris-ltd/eris-db/rpc/tendermint/client"
+ core_types "github.com/eris-ltd/eris-db/rpc/tendermint/core/types"
"github.com/eris-ltd/eris-db/txs"
-
"github.com/stretchr/testify/assert"
+
+ "time"
+
tm_common "github.com/tendermint/go-common"
"golang.org/x/crypto/ripemd160"
)
@@ -88,22 +91,19 @@ func testGetStorage(t *testing.T, typ string) {
amt, gasLim, fee := int64(1100), int64(1000), int64(1000)
code := []byte{0x60, 0x5, 0x60, 0x1, 0x55}
+ // Call with nil address will create a contract
tx := makeDefaultCallTx(t, typ, nil, code, amt, gasLim, fee)
- receipt := broadcastTx(t, typ, tx)
- if receipt.CreatesContract == 0 {
- t.Fatal("This tx creates a contract")
- }
- if len(receipt.TxHash) == 0 {
- t.Fatal("Failed to compute tx hash")
+ receipt, err := broadcastTxAndWaitForBlock(t, typ, wsc, tx)
+ if err != nil {
+ t.Fatalf("Problem broadcasting transaction: %v", err)
}
+ assert.Equal(t, uint8(1), receipt.CreatesContract, "This transaction should"+
+ " create a contract")
+ assert.NotEqual(t, 0, len(receipt.TxHash), "Receipt should contain a"+
+ " transaction hash")
contractAddr := receipt.ContractAddr
- if len(contractAddr) == 0 {
- t.Fatal("Creates contract but resulting address is empty")
- }
-
- // allow it to get mined
- waitForEvent(t, wsc, eid, func() {}, doNothing)
- mempoolCount = 0
+ assert.NotEqual(t, 0, len(contractAddr), "Transactions claims to have"+
+ " created a contract but the contract address is empty")
v := getStorage(t, typ, contractAddr, []byte{0x1})
got := tm_common.LeftPadWord256(v)
@@ -148,22 +148,17 @@ func testCall(t *testing.T, typ string) {
amt, gasLim, fee := int64(6969), int64(1000), int64(1000)
code, _, _ := simpleContract()
tx := makeDefaultCallTx(t, typ, nil, code, amt, gasLim, fee)
- receipt := broadcastTx(t, typ, tx)
-
- if receipt.CreatesContract == 0 {
- t.Fatal("This tx creates a contract")
- }
- if len(receipt.TxHash) == 0 {
- t.Fatal("Failed to compute tx hash")
+ receipt, err := broadcastTxAndWaitForBlock(t, typ, wsc, tx)
+ if err != nil {
+ t.Fatalf("Problem broadcasting transaction: %v", err)
}
+ assert.Equal(t, uint8(1), receipt.CreatesContract, "This transaction should"+
+ " create a contract")
+ assert.NotEqual(t, 0, len(receipt.TxHash), "Receipt should contain a"+
+ " transaction hash")
contractAddr := receipt.ContractAddr
- if len(contractAddr) == 0 {
- t.Fatal("Creates contract but resulting address is empty")
- }
-
- // allow it to get mined
- waitForEvent(t, wsc, eid, func() {}, doNothing)
- mempoolCount = 0
+ assert.NotEqual(t, 0, len(contractAddr), "Transactions claims to have"+
+ " created a contract but the contract address is empty")
// run a call through the contract
data := []byte{}
@@ -207,7 +202,7 @@ func testNameReg(t *testing.T, typ string) {
assert.Equal(t, user[0].Address, entry.Owner)
// update the data as the owner, make sure still there
- numDesiredBlocks = int64(4)
+ numDesiredBlocks = int64(3)
const updatedData = "these are amongst the things I wish to bestow upon the youth of generations come: a safe supply of honey, and a better money. For what else shall they need"
amt = fee + numDesiredBlocks*txs.NameByteCostMultiplier*txs.NameBlockCostMultiplier*txs.NameBaseCost(name, updatedData)
tx = makeDefaultNameTx(t, typ, name, updatedData, amt, fee)
@@ -218,15 +213,17 @@ func testNameReg(t *testing.T, typ string) {
assert.Equal(t, updatedData, entry.Data)
// try to update as non owner, should fail
- //waitBlocks(t, wsc, 4)
tx = txs.NewNameTxWithNonce(user[1].PubKey, name, "never mind", amt, fee,
getNonce(t, typ, user[1].Address)+1)
tx.Sign(chainID, user[1])
_, err := broadcastTxAndWaitForBlock(t, typ, wsc, tx)
-
assert.Error(t, err, "Expected error when updating someone else's unexpired"+
" name registry entry")
+
+ // Wait a couple of blocks to make sure name registration expires
+ waitNBlocks(t, wsc, 2)
+
//now the entry should be expired, so we can update as non owner
const data2 = "this is not my beautiful house"
tx = txs.NewNameTxWithNonce(user[1].PubKey, name, data2, amt, fee,
@@ -251,7 +248,58 @@ func asEventDataTx(t *testing.T, eventData txs.EventData) txs.EventDataTx {
return eventDataTx
}
-func doNothing(eventId string, eventData txs.EventData) (bool, error) {
+func doNothing(_ string, _ txs.EventData) (bool, error) {
// And ask waitForEvent to stop waiting
return true, nil
}
+
+func testSubscribe(t *testing.T) {
+ var subId string
+ wsc := newWSClient(t)
+ subscribe(t, wsc, txs.EventStringNewBlock())
+
+ timeout := time.NewTimer(timeoutSeconds * time.Second)
+Subscribe:
+ for {
+ select {
+ case <-timeout.C:
+ t.Fatal("Timed out waiting for subscription result")
+
+ case bs := <-wsc.ResultsCh:
+ resultSubscribe, ok := readResult(t, bs).(*core_types.ResultSubscribe)
+ if ok {
+ assert.Equal(t, txs.EventStringNewBlock(), resultSubscribe.Event)
+ subId = resultSubscribe.SubscriptionId
+ break Subscribe
+ }
+ }
+ }
+
+ seenBlock := false
+ timeout = time.NewTimer(timeoutSeconds * time.Second)
+ for {
+ select {
+ case <-timeout.C:
+ if !seenBlock {
+ t.Fatal("Timed out without seeing a NewBlock event")
+ }
+ return
+
+ case bs := <-wsc.ResultsCh:
+ resultEvent, ok := readResult(t, bs).(*core_types.ResultEvent)
+ if ok {
+ _, ok := resultEvent.Data.(txs.EventDataNewBlock)
+ if ok {
+ if seenBlock {
+ // There's a mild race here, but when we enter we've just seen a block
+ // so we should be able to unsubscribe before we see another block
+ t.Fatal("Continued to see NewBlock event after unsubscribing")
+ } else {
+ seenBlock = true
+ unsubscribe(t, wsc, subId)
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/rpc/tendermint/test/ws_helpers.go b/rpc/tendermint/test/ws_helpers.go
index bd694259e390b1e011284176ec21a9a8594330a6..ed92bca14d5414cfb024895c69ff2a27577b1b05 100644
--- a/rpc/tendermint/test/ws_helpers.go
+++ b/rpc/tendermint/test/ws_helpers.go
@@ -36,15 +36,35 @@ func newWSClient(t *testing.T) *client.WSClient {
}
// subscribe to an event
-func subscribe(t *testing.T, wsc *client.WSClient, eventid string) {
- if err := wsc.Subscribe(eventid); err != nil {
+func subscribe(t *testing.T, wsc *client.WSClient, eventId string) {
+ if err := wsc.Subscribe(eventId); err != nil {
t.Fatal(err)
}
}
+func subscribeAndGetSubscriptionId(t *testing.T, wsc *client.WSClient,
+ eventId string) string {
+ if err := wsc.Subscribe(eventId); err != nil {
+ t.Fatal(err)
+ }
+
+ timeout := time.NewTimer(timeoutSeconds * time.Second)
+ for {
+ select {
+ case <-timeout.C:
+ t.Fatal("Timeout waiting for subscription result")
+ case bs := <-wsc.ResultsCh:
+ resultSubscribe, ok := readResult(t, bs).(*ctypes.ResultSubscribe)
+ if ok {
+ return resultSubscribe.SubscriptionId
+ }
+ }
+ }
+}
+
// unsubscribe from an event
-func unsubscribe(t *testing.T, wsc *client.WSClient, eventid string) {
- if err := wsc.Unsubscribe(eventid); err != nil {
+func unsubscribe(t *testing.T, wsc *client.WSClient, subscriptionId string) {
+ if err := wsc.Unsubscribe(subscriptionId); err != nil {
t.Fatal(err)
}
}
@@ -93,13 +113,13 @@ func runThenWaitForBlock(t *testing.T, wsc *client.WSClient,
func subscribeAndWaitForNext(t *testing.T, wsc *client.WSClient, event string,
runner func(),
eventDataChecker func(string, txs.EventData) (bool, error)) {
- subscribe(t, wsc, event)
+ subId := subscribeAndGetSubscriptionId(t, wsc, event)
+ defer unsubscribe(t, wsc, subId)
waitForEvent(t,
wsc,
event,
runner,
eventDataChecker)
- unsubscribe(t, wsc, event)
}
// waitForEvent executes runner that is expected to trigger events. It then
@@ -299,3 +319,13 @@ func UnmarshalEvent(b json.RawMessage) (string, events.EventData) {
}
return event.Event, event.Data
}
+
+func readResult(t *testing.T, bs []byte) ctypes.ErisDBResult {
+ var err error
+ result := new(ctypes.ErisDBResult)
+ wire.ReadJSONPtr(result, bs, &err)
+ if err != nil {
+ t.Fatal(err)
+ }
+ return *result
+}
diff --git a/version/version.go b/version/version.go
index d921f591ddd73857199f7b639a4fce02766708d2..d285dbecac9f2028de9896410cebf1caf07d721d 100644
--- a/version/version.go
+++ b/version/version.go
@@ -125,11 +125,8 @@ func (version *VersionIdentifier) MatchesMinorVersion(
}
//------------------------------------------------------------------------------
-// Version number for DOCKER/build.sh
-
-// NOTE [ben]: deprecate public const version string
-const TENDERMINT_VERSION = "0.5.0"
+// Version number for tests/build_tool.sh
// IMPORTANT: Eris-DB version must be on the last line of this file for
-// the deployment script DOCKER/build.sh to pick up the right label.
+// the deployment script tests/build_tool.sh to pick up the right label.
const VERSION = "0.12.0-rc3"