mirrors/bitcoin-s
1
0
Fork 0
mirror of https://github.com/bitcoin-s/bitcoin-s.git synced 2024-11-19 01:40:55 +01:00
Code Issues Packages Projects Releases Wiki Activity

Update scalatest to 3.2.0 (#1592)

Browse Source 
* Update scalatest to 3.2.0

* Fix tests to be compatible

Co-authored-by: Ben Carman <benthecarman@live.com>
This commit is contained in:
Scala Steward 2020-06-20 15:46:32 +02:00 committed by GitHub
parent ba39d9598a
commit ea39f38443
12 changed files with 132 additions and 155 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

192
app/server-test/src/test/scala/org/bitcoins/server/RoutesSpec.scala
View File

@ -33,18 +33,14 @@ import org.bitcoins.node.Node
import org.bitcoins.wallet.MockWalletApi
import org.bitcoins.wallet.models._
import org.scalamock.scalatest.MockFactory
import org.scalatest.{Matchers, WordSpec}
import org.scalatest.wordspec.AnyWordSpec
import scodec.bits.ByteVector
import ujson.Value.InvalidData
import ujson._
import scala.concurrent.Future
class RoutesSpec
extends WordSpec
with Matchers
with ScalatestRouteTest
with MockFactory {
class RoutesSpec extends AnyWordSpec with ScalatestRouteTest with MockFactory {
// the genesis address
val testAddressStr = "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"
@ -80,9 +76,9 @@ class RoutesSpec
Arr(Arr(Str(psbt1.base64), Str(psbt2.base64)))))
Get() ~> route ~> check {
contentType shouldEqual `application/json`
contentType == `application/json`
responseAs[
String] shouldEqual s"""{"result":"${expected.base64}","error":null}"""
String] == s"""{"result":"${expected.base64}","error":null}"""
}
val joinRoute =
@ -91,9 +87,9 @@ class RoutesSpec
Arr(Arr(Str(psbt1.base64), Str(psbt2.base64)))))
Get() ~> joinRoute ~> check {
contentType shouldEqual `application/json`
contentType == `application/json`
responseAs[
String] shouldEqual s"""{"result":"${expected.base64}","error":null}"""
String] == s"""{"result":"${expected.base64}","error":null}"""
}
}
@ -108,9 +104,9 @@ class RoutesSpec
ServerCommand("finalizepsbt", Arr(Str(psbt.hex))))
Get() ~> route ~> check {
contentType shouldEqual `application/json`
contentType == `application/json`
responseAs[
String] shouldEqual s"""{"result":"${expected.base64}","error":null}"""
String] == s"""{"result":"${expected.base64}","error":null}"""
}
}
@ -126,9 +122,8 @@ class RoutesSpec
ServerCommand("extractfrompsbt", Arr(Str(psbt.hex))))
Get() ~> route ~> check {
contentType shouldEqual `application/json`
responseAs[
String] shouldEqual s"""{"result":"${expected.hex}","error":null}"""
contentType == `application/json`
responseAs[String] == s"""{"result":"${expected.hex}","error":null}"""
}
}
@ -144,9 +139,9 @@ class RoutesSpec
ServerCommand("converttopsbt", Arr(Str(tx.hex))))
Get() ~> route ~> check {
contentType shouldEqual `application/json`
contentType == `application/json`
responseAs[
String] shouldEqual s"""{"result":"${expected.base64}","error":null}"""
String] == s"""{"result":"${expected.base64}","error":null}"""
}
}
@ -160,8 +155,8 @@ class RoutesSpec
chainRoutes.handleCommand(ServerCommand("getblockcount", Arr()))
Get() ~> route ~> check {
contentType shouldEqual `application/json`
responseAs[String] shouldEqual """{"result":1234567890,"error":null}"""
contentType == `application/json`
responseAs[String] == """{"result":1234567890,"error":null}"""
}
}
@ -174,8 +169,8 @@ class RoutesSpec
chainRoutes.handleCommand(ServerCommand("getfiltercount", Arr()))
Get() ~> route ~> check {
contentType shouldEqual `application/json`
responseAs[String] shouldEqual """{"result":1234567890,"error":null}"""
contentType == `application/json`
responseAs[String] == """{"result":1234567890,"error":null}"""
}
}
@ -188,8 +183,8 @@ class RoutesSpec
chainRoutes.handleCommand(ServerCommand("getfilterheadercount", Arr()))
Get() ~> route ~> check {
contentType shouldEqual `application/json`
responseAs[String] shouldEqual """{"result":1234567890,"error":null}"""
contentType == `application/json`
responseAs[String] == """{"result":1234567890,"error":null}"""
}
}
@ -202,8 +197,8 @@ class RoutesSpec
chainRoutes.handleCommand(ServerCommand("getbestblockhash", Arr()))
Get() ~> route ~> check {
contentType shouldEqual `application/json`
responseAs[String] shouldEqual """{"result":"0000000000000000000000000000000000000000000000000000000000000000","error":null}"""
contentType == `application/json`
responseAs[String] == """{"result":"0000000000000000000000000000000000000000000000000000000000000000","error":null}"""
}
}
@ -217,9 +212,8 @@ class RoutesSpec
ServerCommand("getbalance", Arr(Bool(false))))
Get() ~> route ~> check {
contentType shouldEqual `application/json`
responseAs[
String] shouldEqual """{"result":"50.00000000 BTC","error":null}"""
contentType == `application/json`
responseAs[String] == """{"result":"50.00000000 BTC","error":null}"""
}
}
@ -232,9 +226,8 @@ class RoutesSpec
walletRoutes.handleCommand(ServerCommand("getbalance", Arr(Bool(true))))
Get() ~> route ~> check {
contentType shouldEqual `application/json`
responseAs[
String] shouldEqual """{"result":"5000000000 sats","error":null}"""
contentType == `application/json`
responseAs[String] == """{"result":"5000000000 sats","error":null}"""
}
}
@ -248,9 +241,8 @@ class RoutesSpec
ServerCommand("getconfirmedbalance", Arr(Bool(false))))
Get() ~> route ~> check {
contentType shouldEqual `application/json`
responseAs[
String] shouldEqual """{"result":"50.00000000 BTC","error":null}"""
contentType == `application/json`
responseAs[String] == """{"result":"50.00000000 BTC","error":null}"""
}
}
@ -264,9 +256,8 @@ class RoutesSpec
ServerCommand("getconfirmedbalance", Arr(Bool(true))))
Get() ~> route ~> check {
contentType shouldEqual `application/json`
responseAs[
String] shouldEqual """{"result":"5000000000 sats","error":null}"""
contentType == `application/json`
responseAs[String] == """{"result":"5000000000 sats","error":null}"""
}
}
@ -280,9 +271,8 @@ class RoutesSpec
ServerCommand("getunconfirmedbalance", Arr(Bool(false))))
Get() ~> route ~> check {
contentType shouldEqual `application/json`
responseAs[
String] shouldEqual """{"result":"50.00000000 BTC","error":null}"""
contentType == `application/json`
responseAs[String] == """{"result":"50.00000000 BTC","error":null}"""
}
}
@ -296,9 +286,8 @@ class RoutesSpec
ServerCommand("getunconfirmedbalance", Arr(Bool(true))))
Get() ~> route ~> check {
contentType shouldEqual `application/json`
responseAs[
String] shouldEqual """{"result":"5000000000 sats","error":null}"""
contentType == `application/json`
responseAs[String] == """{"result":"5000000000 sats","error":null}"""
}
}
@ -311,8 +300,8 @@ class RoutesSpec
walletRoutes.handleCommand(ServerCommand("isempty", Arr()))
Get() ~> route ~> check {
contentType shouldEqual `application/json`
responseAs[String] shouldEqual """{"result":true,"error":null}"""
contentType == `application/json`
responseAs[String] == """{"result":true,"error":null}"""
}
}
@ -336,8 +325,8 @@ class RoutesSpec
walletRoutes.handleCommand(ServerCommand("getutxos", Arr()))
Get() ~> route ~> check {
contentType shouldEqual `application/json`
responseAs[String] shouldEqual """{"result":"0000000000000000000000000000000000000000000000000000000000000000ffffffff -1 sats\n","error":null}"""
contentType == `application/json`
responseAs[String] == """{"result":"0000000000000000000000000000000000000000000000000000000000000000ffffffff -1 sats\n","error":null}"""
}
}
@ -358,8 +347,8 @@ class RoutesSpec
walletRoutes.handleCommand(ServerCommand("getaddresses", Arr()))
Get() ~> route ~> check {
contentType shouldEqual `application/json`
responseAs[String] shouldEqual """{"result":["""" + testAddressStr + """"],"error":null}"""
contentType == `application/json`
responseAs[String] == """{"result":["""" + testAddressStr + """"],"error":null}"""
}
}
@ -380,8 +369,8 @@ class RoutesSpec
walletRoutes.handleCommand(ServerCommand("getspentaddresses", Arr()))
Get() ~> route ~> check {
contentType shouldEqual `application/json`
responseAs[String] shouldEqual """{"result":["""" + testAddressStr + """"],"error":null}"""
contentType == `application/json`
responseAs[String] == """{"result":["""" + testAddressStr + """"],"error":null}"""
}
}
@ -404,8 +393,8 @@ class RoutesSpec
walletRoutes.handleCommand(ServerCommand("getfundedaddresses", Arr()))
Get() ~> route ~> check {
contentType shouldEqual `application/json`
responseAs[String] shouldEqual
contentType == `application/json`
responseAs[String] ==
s"""{"result":["$testAddressStr ${Satoshis.zero}"],"error":null}""".stripMargin
}
}
@ -427,8 +416,8 @@ class RoutesSpec
walletRoutes.handleCommand(ServerCommand("getunusedaddresses", Arr()))
Get() ~> route ~> check {
contentType shouldEqual `application/json`
responseAs[String] shouldEqual """{"result":["""" + testAddressStr + """"],"error":null}"""
contentType == `application/json`
responseAs[String] == """{"result":["""" + testAddressStr + """"],"error":null}"""
}
}
@ -451,8 +440,9 @@ class RoutesSpec
walletRoutes.handleCommand(ServerCommand("getaccounts", Arr()))
Get() ~> route ~> check {
contentType shouldEqual `application/json`
responseAs[String] shouldEqual """{"result":["""" + xpub.toString + """"],"error":null}"""
contentType == `application/json`
responseAs[
String] == """{"result":["""" + xpub.toString + """"],"error":null}"""
}
}
@ -465,8 +455,9 @@ class RoutesSpec
walletRoutes.handleCommand(ServerCommand("getnewaddress", Arr()))
Get() ~> route ~> check {
contentType shouldEqual `application/json`
responseAs[String] shouldEqual """{"result":"""" + testAddressStr + """","error":null}"""
contentType == `application/json`
responseAs[
String] == """{"result":"""" + testAddressStr + """","error":null}"""
}
}
@ -485,9 +476,8 @@ class RoutesSpec
ServerCommand("sendrawtransaction", Arr(Str(tx.hex))))
Get() ~> route ~> check {
contentType shouldEqual `application/json`
responseAs[
String] shouldEqual s"""{"result":"${tx.txIdBE.hex}","error":null}"""
contentType == `application/json`
responseAs[String] == s"""{"result":"${tx.txIdBE.hex}","error":null}"""
}
}
@ -509,8 +499,8 @@ class RoutesSpec
Arr(Str(testAddressStr), Num(100), Num(4))))
Post() ~> route ~> check {
contentType shouldEqual `application/json`
responseAs[String] shouldEqual """{"result":"0000000000000000000000000000000000000000000000000000000000000000","error":null}"""
contentType == `application/json`
responseAs[String] == """{"result":"0000000000000000000000000000000000000000000000000000000000000000","error":null}"""
}
// negative cases
@ -519,7 +509,7 @@ class RoutesSpec
ServerCommand("sendtoaddress", Arr(Null, Null, Null)))
Post() ~> route1 ~> check {
rejection shouldEqual ValidationRejection(
rejection == ValidationRejection(
"failure",
Some(InvalidData(Null, "Expected ujson.Str")))
}
@ -528,7 +518,7 @@ class RoutesSpec
ServerCommand("sendtoaddress", Arr("Null", Null, Null)))
Post() ~> route2 ~> check {
rejection shouldEqual ValidationRejection(
rejection == ValidationRejection(
"failure",
Some(InvalidData("Null", "Expected a valid address")))
}
@ -537,7 +527,7 @@ class RoutesSpec
ServerCommand("sendtoaddress", Arr(Str(testAddressStr), Null, Null)))
Post() ~> route3 ~> check {
rejection shouldEqual ValidationRejection(
rejection == ValidationRejection(
"failure",
Some(InvalidData(Null, "Expected ujson.Num")))
}
@ -547,7 +537,7 @@ class RoutesSpec
Arr(Str(testAddressStr), Str("abc"), Null)))
Post() ~> route4 ~> check {
rejection shouldEqual ValidationRejection(
rejection == ValidationRejection(
"failure",
Some(InvalidData("abc", "Expected ujson.Num")))
}
@ -578,8 +568,8 @@ class RoutesSpec
Arr(Arr(), Str(testAddressStr), Num(100), Num(4))))
Post() ~> route ~> check {
contentType shouldEqual `application/json`
responseAs[String] shouldEqual """{"result":"0000000000000000000000000000000000000000000000000000000000000000","error":null}"""
contentType == `application/json`
responseAs[String] == """{"result":"0000000000000000000000000000000000000000000000000000000000000000","error":null}"""
}
// negative cases
@ -588,7 +578,7 @@ class RoutesSpec
ServerCommand("sendfromoutpoints", Arr(Arr(), Null, Null, Null)))
Post() ~> route1 ~> check {
rejection shouldEqual ValidationRejection(
rejection == ValidationRejection(
"failure",
Some(InvalidData(Null, "Expected ujson.Str")))
}
@ -597,7 +587,7 @@ class RoutesSpec
ServerCommand("sendfromoutpoints", Arr(Arr(), "Null", Null, Null)))
Post() ~> route2 ~> check {
rejection shouldEqual ValidationRejection(
rejection == ValidationRejection(
"failure",
Some(InvalidData("Null", "Expected a valid address")))
}
@ -607,7 +597,7 @@ class RoutesSpec
Arr(Arr(), Str(testAddressStr), Null, Null)))
Post() ~> route3 ~> check {
rejection shouldEqual ValidationRejection(
rejection == ValidationRejection(
"failure",
Some(InvalidData(Null, "Expected ujson.Num")))
}
@ -617,7 +607,7 @@ class RoutesSpec
Arr(Arr(), Str(testAddressStr), Str("abc"), Null)))
Post() ~> route4 ~> check {
rejection shouldEqual ValidationRejection(
rejection == ValidationRejection(
"failure",
Some(InvalidData("abc", "Expected ujson.Num")))
}
@ -627,7 +617,7 @@ class RoutesSpec
Arr(Null, Str(testAddressStr), Num(100), Num(4))))
Post() ~> route5 ~> check {
rejection shouldEqual ValidationRejection(
rejection == ValidationRejection(
"failure",
Some(InvalidData(Null, "Expected ujson.Arr")))
}
@ -660,8 +650,8 @@ class RoutesSpec
Str("AccumulateSmallestViable"))))
Post() ~> route ~> check {
contentType shouldEqual `application/json`
responseAs[String] shouldEqual """{"result":"0000000000000000000000000000000000000000000000000000000000000000","error":null}"""
contentType == `application/json`
responseAs[String] == """{"result":"0000000000000000000000000000000000000000000000000000000000000000","error":null}"""
}
// negative cases
@ -670,7 +660,7 @@ class RoutesSpec
ServerCommand("sendwithalgo", Arr(Null, Null, Null, Null)))
Post() ~> route1 ~> check {
rejection shouldEqual ValidationRejection(
rejection == ValidationRejection(
"failure",
Some(InvalidData(Null, "Expected ujson.Str")))
}
@ -679,7 +669,7 @@ class RoutesSpec
ServerCommand("sendwithalgo", Arr("Null", Null, Null, Null)))
Post() ~> route2 ~> check {
rejection shouldEqual ValidationRejection(
rejection == ValidationRejection(
"failure",
Some(InvalidData("Null", "Expected a valid address")))
}
@ -689,7 +679,7 @@ class RoutesSpec
Arr(Str(testAddressStr), Null, Null, Null)))
Post() ~> route3 ~> check {
rejection shouldEqual ValidationRejection(
rejection == ValidationRejection(
"failure",
Some(InvalidData(Null, "Expected ujson.Num")))
}
@ -699,7 +689,7 @@ class RoutesSpec
Arr(Str(testAddressStr), Str("abc"), Null, Null)))
Post() ~> route4 ~> check {
rejection shouldEqual ValidationRejection(
rejection == ValidationRejection(
"failure",
Some(InvalidData("abc", "Expected ujson.Num")))
}
@ -709,7 +699,7 @@ class RoutesSpec
Arr(Str(testAddressStr), Num(100), Num(4), Null)))
Post() ~> route5 ~> check {
rejection shouldEqual ValidationRejection(
rejection == ValidationRejection(
"failure",
Some(InvalidData(Null, "Expected ujson.Str")))
}
@ -733,8 +723,8 @@ class RoutesSpec
ServerCommand("opreturncommit", Arr(message, Bool(false), Num(4))))
Post() ~> route ~> check {
contentType shouldEqual `application/json`
responseAs[String] shouldEqual """{"result":"0000000000000000000000000000000000000000000000000000000000000000","error":null}"""
contentType == `application/json`
responseAs[String] == """{"result":"0000000000000000000000000000000000000000000000000000000000000000","error":null}"""
}
}
@ -743,8 +733,9 @@ class RoutesSpec
nodeRoutes.handleCommand(ServerCommand("getpeers", Arr()))
Get() ~> route ~> check {
contentType shouldEqual `application/json`
responseAs[String] shouldEqual """{"result":"TODO implement getpeers","error":null}"""
contentType == `application/json`
responseAs[
String] == """{"result":"TODO implement getpeers","error":null}"""
}
}
@ -771,8 +762,8 @@ class RoutesSpec
ServerCommand("rescan", Arr(Arr(), Null, Null, true, true)))
Post() ~> route1 ~> check {
contentType shouldEqual `application/json`
responseAs[String] shouldEqual """{"result":"scheduled","error":null}"""
contentType == `application/json`
responseAs[String] == """{"result":"scheduled","error":null}"""
}
(mockWalletApi.isEmpty: () => Future[Boolean])
@ -798,8 +789,8 @@ class RoutesSpec
Arr(Arr(), Str("2018-10-27T12:34:56Z"), Null, true, true)))
Post() ~> route2 ~> check {
contentType shouldEqual `application/json`
responseAs[String] shouldEqual """{"result":"scheduled","error":null}"""
contentType == `application/json`
responseAs[String] == """{"result":"scheduled","error":null}"""
}
(mockWalletApi.isEmpty: () => Future[Boolean])
@ -820,8 +811,8 @@ class RoutesSpec
Arr(Null, Null, Str(DoubleSha256DigestBE.empty.hex), true, true)))
Post() ~> route3 ~> check {
contentType shouldEqual `application/json`
responseAs[String] shouldEqual """{"result":"scheduled","error":null}"""
contentType == `application/json`
responseAs[String] == """{"result":"scheduled","error":null}"""
}
(mockWalletApi.isEmpty: () => Future[Boolean])
@ -841,8 +832,8 @@ class RoutesSpec
Arr(Arr(), Str("12345"), Num(67890), true, true)))
Post() ~> route4 ~> check {
contentType shouldEqual `application/json`
responseAs[String] shouldEqual """{"result":"scheduled","error":null}"""
contentType == `application/json`
responseAs[String] == """{"result":"scheduled","error":null}"""
}
// negative cases
@ -853,9 +844,8 @@ class RoutesSpec
Arr(Null, Str("abcd"), Str("efgh"), true, true)))
Post() ~> route5 ~> check {
rejection shouldEqual ValidationRejection(
"failure",
Some(InvalidBlockStamp("abcd")))
rejection == ValidationRejection("failure",
Some(InvalidBlockStamp("abcd")))
}
val route6 =
@ -865,7 +855,7 @@ class RoutesSpec
Arr(Arr(55), Null, Str("2018-10-27T12:34:56"), true, true)))
Post() ~> route6 ~> check {
rejection shouldEqual ValidationRejection(
rejection == ValidationRejection(
"failure",
Some(InvalidBlockStamp("2018-10-27T12:34:56")))
}
@ -875,7 +865,7 @@ class RoutesSpec
ServerCommand("rescan", Arr(Null, Num(-1), Null, true, false)))
Post() ~> route7 ~> check {
rejection shouldEqual ValidationRejection(
rejection == ValidationRejection(
"failure",
Some(InvalidData(Num(-1), "Expected a positive integer")))
}
@ -897,8 +887,8 @@ class RoutesSpec
Arr(Arr(55), Arr(), Arr(), Bool(true), Bool(true))))
Post() ~> route8 ~> check {
contentType shouldEqual `application/json`
responseAs[String] shouldEqual """{"result":"scheduled","error":null}"""
contentType == `application/json`
responseAs[String] == """{"result":"scheduled","error":null}"""
}
}

3
core-test/src/test/scala/org/bitcoins/core/crypto/TransactionSignatureCreatorTest.scala
View File

@ -9,15 +9,12 @@ import org.bitcoins.core.script.PreExecutionScriptProgram
import org.bitcoins.core.script.crypto.HashType
import org.bitcoins.core.script.interpreter.ScriptInterpreter
import org.bitcoins.core.script.result.ScriptOk
import org.bitcoins.core.util.BitcoinSLogger
import org.bitcoins.crypto.{
ECDigitalSignature,
ECPrivateKey,
EmptyDigitalSignature
}
import org.bitcoins.testkit.util.{BitcoinSAsyncTest, TransactionTestUtil}
import org.scalatest.concurrent.ScalaFutures
import org.scalatest.{FlatSpec, MustMatchers}
import scodec.bits.ByteVector
import scala.concurrent.Future

7
core-test/src/test/scala/org/bitcoins/core/crypto/TransactionSignatureSerializerTest.scala
View File

@ -1,7 +1,7 @@
package org.bitcoins.core.crypto
import org.bitcoins.core.currency.{Bitcoins, CurrencyUnits, Satoshis}
import org.bitcoins.core.number.{Int32, Int64, UInt32}
import org.bitcoins.core.number.{Int32, UInt32}
import org.bitcoins.core.policy.Policy
import org.bitcoins.core.protocol.script._
import org.bitcoins.core.protocol.transaction._
@ -9,15 +9,14 @@ import org.bitcoins.core.script.crypto._
import org.bitcoins.core.serializers.script.ScriptParser
import org.bitcoins.core.util._
import org.bitcoins.crypto.DoubleSha256Digest
import org.scalatest.{FlatSpec, MustMatchers}
import org.bitcoins.testkit.util.BitcoinSAsyncTest
import scala.util.Try
/**
* Created by chris on 2/19/16.
*/
class TransactionSignatureSerializerTest extends FlatSpec with MustMatchers {
private def logger = BitcoinSLogger.logger
class TransactionSignatureSerializerTest extends BitcoinSAsyncTest {
"TransactionSignatureSerializer" must "correctly serialize an input that is being checked where another input in the same tx is using SIGHASH_ANYONECANPAY" in {
//this is from a test case inside of tx_valid.json

6
core-test/src/test/scala/org/bitcoins/core/protocol/script/P2SHScriptSignatureTest.scala
View File

@ -7,14 +7,12 @@ import org.bitcoins.core.script.constant.{
}
import org.bitcoins.core.util.BitcoinSLogger
import org.bitcoins.crypto.ECPublicKey
import org.bitcoins.testkit.util.TestUtil
import org.scalatest.{FlatSpec, MustMatchers}
import org.bitcoins.testkit.util.{BitcoinSAsyncTest, TestUtil}
/**
* Created by chris on 3/8/16.
*/
class P2SHScriptSignatureTest extends FlatSpec with MustMatchers {
private def logger = BitcoinSLogger.logger
class P2SHScriptSignatureTest extends BitcoinSAsyncTest {
"P2SHScriptSignature" must "find the public keys embedded inside of the redeemScript" in {
val rawP2SHScriptSig = TestUtil.rawP2shInputScript2Of2

12
core-test/src/test/scala/org/bitcoins/core/protocol/script/ScriptSignatureTest.scala
View File

@ -6,7 +6,6 @@ import org.bitcoins.core.number.Int32
import org.bitcoins.core.policy.Policy
import org.bitcoins.core.protocol.script.testprotocol.SignatureHashTestCase
import org.bitcoins.core.protocol.transaction.{
BaseTransaction,
NonWitnessTransaction,
Transaction,
TransactionOutput,
@ -16,8 +15,7 @@ import org.bitcoins.core.script.crypto.{HashType, SIGHASH_ALL}
import org.bitcoins.core.serializers.script.RawScriptSignatureParser
import org.bitcoins.core.util.{BitcoinSLogger, BytesUtil}
import org.bitcoins.crypto.{DoubleSha256Digest, ECDigitalSignature}
import org.bitcoins.testkit.util.TestUtil
import org.scalatest.{FlatSpec, MustMatchers}
import org.bitcoins.testkit.util.{BitcoinSAsyncTest, TestUtil}
import scodec.bits.ByteVector
import spray.json._
@ -26,8 +24,7 @@ import scala.io.Source
/**
* Created by chris on 2/17/16.
*/
class ScriptSignatureTest extends FlatSpec with MustMatchers {
private val logger = BitcoinSLogger.logger
class ScriptSignatureTest extends BitcoinSAsyncTest {
"ScriptSignature" must "find the digital signature for the transaction inside of a p2pkh script signature" in {
val scriptSig = ScriptSignature(TestUtil.rawScriptSig)
@ -145,7 +142,7 @@ class ScriptSignatureTest extends FlatSpec with MustMatchers {
val testCases: Seq[SignatureHashTestCase] =
lines.parseJson.convertTo[Seq[SignatureHashTestCase]]
for {
val allTests = for {
testCase <- testCases
} yield {
Transaction(testCase.transaction.hex) must be(testCase.transaction)
@ -166,8 +163,9 @@ class ScriptSignatureTest extends FlatSpec with MustMatchers {
TransactionSignatureSerializer.hashForSignature(txSigComponent,
testCase.hashType)
val flipHash = BytesUtil.flipEndianness(testCase.hash.hex)
hashForSig must be(DoubleSha256Digest(flipHash))
hashForSig == DoubleSha256Digest(flipHash)
}
assert(allTests.forall(x => x))
}
}

28
core-test/src/test/scala/org/bitcoins/core/script/control/ControlOperationsInterpreterTest.scala
View File

@ -15,15 +15,16 @@ import org.bitcoins.core.script.result.{
}
import org.bitcoins.core.serializers.script.ScriptParser
import org.bitcoins.core.util._
import org.bitcoins.testkit.util.TestUtil
import org.scalatest.{FlatSpec, MustMatchers}
import org.bitcoins.testkit.util.{BitcoinSAsyncTest, TestUtil}
import scala.concurrent.Future
/**
* Created by chris on 1/6/16.
*/
class ControlOperationsInterpreterTest extends FlatSpec with MustMatchers {
private def logger = BitcoinSLogger.logger
val COI = ControlOperationsInterpreter
class ControlOperationsInterpreterTest extends BitcoinSAsyncTest {
val COI: ControlOperationsInterpreter = ControlOperationsInterpreter
"ControlOperationsInterpreter" must "have OP_VERIFY evaluate to true with '1' on the stack" in {
val stack = List(OP_TRUE)
val script = List(OP_VERIFY)
@ -44,6 +45,7 @@ class ControlOperationsInterpreterTest extends FlatSpec with MustMatchers {
TestUtil.testProgramExecutionInProgress.updateStackAndScript(stack,
script)
val result = COI.opVerify(program)
result.stackTopIsTrue must be(true)
}
it must "have OP_VERIFY evaluate to false with '0' on the stack" in {
@ -70,13 +72,15 @@ class ControlOperationsInterpreterTest extends FlatSpec with MustMatchers {
}
it must "fail for verify when there is nothing on the script stack" in {
intercept[IllegalArgumentException] {
val stack = List(ScriptConstant("1"))
val script = List()
val program =
TestUtil.testProgramExecutionInProgress.updateStackAndScript(stack,
script)
val result = COI.opVerify(program)
recoverToSucceededIf[IllegalArgumentException] {
Future {
val stack = List(ScriptConstant("1"))
val script = List()
val program =
TestUtil.testProgramExecutionInProgress.updateStackAndScript(stack,
script)
COI.opVerify(program)
}
}
}

12
core-test/src/test/scala/org/bitcoins/core/script/crypto/CryptoInterpreterTest.scala
View File

@ -7,23 +7,17 @@ import org.bitcoins.core.protocol.script.ScriptSignature
import org.bitcoins.core.protocol.transaction._
import org.bitcoins.core.script._
import org.bitcoins.core.script.constant._
import org.bitcoins.core.script.flag.{
ScriptFlagFactory,
ScriptVerifyDerSig,
ScriptVerifyNullDummy
}
import org.bitcoins.core.script.flag.{ScriptVerifyDerSig, ScriptVerifyNullDummy}
import org.bitcoins.core.script.result._
import org.bitcoins.core.util.{BitcoinSLogger, ScriptProgramTestUtil}
import org.bitcoins.testkit.util.TestUtil
import org.scalatest.{FlatSpec, MustMatchers}
import org.bitcoins.testkit.util.{BitcoinSAsyncTest, TestUtil}
import scala.util.Try
/**
* Created by chris on 1/6/16.
*/
class CryptoInterpreterTest extends FlatSpec with MustMatchers {
private def logger = BitcoinSLogger.logger
class CryptoInterpreterTest extends BitcoinSAsyncTest {
val stack = List(ScriptConstant(
"02218AD6CDC632E7AE7D04472374311CEBBBBF0AB540D2D08C3400BB844C654231".toLowerCase))

6
core-test/src/test/scala/org/bitcoins/core/serializers/transaction/RawTransactionInputParserTest.scala
View File

@ -6,15 +6,13 @@ import org.bitcoins.core.protocol.transaction.{
TransactionInput
}
import org.bitcoins.core.util.{BitcoinSLogger, BytesUtil}
import org.bitcoins.testkit.util.TestUtil
import org.scalatest.{FlatSpec, MustMatchers}
import org.bitcoins.testkit.util.{BitcoinSAsyncTest, TestUtil}
import scodec.bits.ByteVector
/**
* Created by chris on 1/13/16.
*/
class RawTransactionInputParserTest extends FlatSpec with MustMatchers {
private val logger = BitcoinSLogger.logger
class RawTransactionInputParserTest extends BitcoinSAsyncTest {
//txid cad1082e674a7bd3bc9ab1bc7804ba8a57523607c876b8eb2cbe645f2b1803d6
val rawTxInput =

11
core-test/src/test/scala/org/bitcoins/core/util/FutureUtilTest.scala
View File

@ -1,13 +1,12 @@
package org.bitcoins.core.util
import org.bitcoins.testkit.util.BitcoinSUnitTest
import scala.concurrent.duration._
import scala.concurrent._
import org.scalatest.compatible.Assertion
import org.scalatest.AsyncFlatSpec
import akka.actor.ActorSystem
import org.bitcoins.testkit.util.BitcoinSAsyncTest
import org.scalatest.compatible.Assertion
class FutureUtilTest extends AsyncFlatSpec with BitcoinSLogger {
import scala.concurrent._
class FutureUtilTest extends BitcoinSAsyncTest with BitcoinSLogger {
it must "execute futures sequentially in the correct order" in {
val actorSystem = ActorSystem()

4
eclair-rpc-test/src/test/scala/org/bitcoins/eclair/network/NodeUriTest.scala
View File

@ -1,9 +1,9 @@
package org.bitcoins.eclair.network
import org.bitcoins.eclair.rpc.network.NodeUri
import org.scalatest.FlatSpec
import org.bitcoins.testkit.util.BitcoinSAsyncTest
class NodeUriTest extends FlatSpec {
class NodeUriTest extends BitcoinSAsyncTest {
behavior of "NodeUri"

2
project/Deps.scala
View File

@ -6,7 +6,7 @@ object Deps {
val bouncyCastle = "1.65.01"
val logback = "1.2.3"
val scalacheck = "1.14.3"
val scalaTest = "3.1.2"
val scalaTest = "3.2.0"
val scalaTestPlus = "3.2.0.0" //super annoying... https://oss.sonatype.org/content/groups/public/org/scalatestplus/
val slf4j = "1.7.30"

4
zmq/src/test/scala/org/bitcoins/zmq/ZMQSubscriberTest.scala
View File

@ -3,14 +3,14 @@ package org.bitcoins.zmq
import java.net.InetSocketAddress
import org.bitcoins.core.util.BytesUtil
import org.scalatest.{AsyncFlatSpec, MustMatchers}
import org.scalatest.flatspec.AsyncFlatSpec
import org.slf4j.LoggerFactory
import org.zeromq.{ZFrame, ZMQ, ZMsg}
import scodec.bits.ByteVector
import scala.concurrent.Promise
class ZMQSubscriberTest extends AsyncFlatSpec with MustMatchers {
class ZMQSubscriberTest extends AsyncFlatSpec {
private val logger = LoggerFactory.getLogger(this.getClass().toString)
behavior of "ZMQSubscriber"