Skip to content

Commit

Permalink
FAB-3880 rename sys testnames and descripts
Browse files Browse the repository at this point in the history 
Fixed one failing sample test, and corrected more
testcase descriptions to match testplan. Otherwise,
No functional changes, but per our modified test plans:
+ rename many testnames to refer to the new FAB numbers
  associated with each testcase, and
+ modify test descriptions.

Change-Id: I148916bead8cdaf98cc870629b1b192301f78953
Signed-off-by: Scott Zwierzynski <scottz@us.ibm.com>
  • Loading branch information
@scottz64
scottz64 committed May 12, 2017
1 parent 8f6a632 commit 0509bed
Show file tree
Hide file tree
Showing 3 changed files with 133 additions and 152 deletions.
3 changes: 3 additions & 0 deletions test/regression/daily/test_example.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -18,6 +18,9 @@ def test_skipped(self):
'''
self.fail("I should not see this")

# This runs on ubuntu x86 laptop, but it fails when run by CI, because
# "bc" is not installed on the servers used for CI jobs.
@unittest.skip("skipping")
def test_SampleAdditionTestWillPass(self):
'''
This test will pass.
Expand Down
189 changes: 54 additions & 135 deletions test/regression/daily/test_pte.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -16,11 +16,10 @@

class LevelDB_Perf_Stress(unittest.TestCase):
@unittest.skip("skipping")
def test_FAB3584_SkeletonQueries(self):
def test_FAB3808_TPS_Queries_1_Thread_TinyNtwk(self):
'''
FAB-2032,FAB-3584
Network: 1 Ord, 1 KB, 1 ZK, 2 Org, 2 Peers, 1 Chan, 1 CC
Launch skeleton network, use PTE in STRESS mode to continuously
Tiny Network: 1 Ord, 1 KB, 1 ZK, 2 Org, 2 Peers, 1 Chan, 1 CC, 2 thrds
Launch tiny network, use PTE in STRESS mode to continuously
send 10000 query transactions concurrently to 1 peer in both orgs,
calculate tps, and remove network and cleanup
'''
Expand All @@ -30,11 +29,10 @@ def test_FAB3584_SkeletonQueries(self):
self.assertIn(TEST_PASS_STRING, result)

@unittest.skip("skipping")
def test_FAB3586_SkeletonInvokes(self):
def test_FAB3811_TPS_Invokes_1_Thread_TinyNtwk(self):
'''
FAB-2032,FAB-3586
Network: 1 Ord, 1 KB, 1 ZK, 2 Org, 2 Peers, 1 Chan, 1 CC
Launch skeleton network, use PTE in STRESS mode to continuously
Tiny Network: 1 Ord, 1 KB, 1 ZK, 2 Org, 2 Peers, 1 Chan, 1 CC, 2 thrds
Launch tiny network, use PTE in STRESS mode to continuously
send 10000 query transactions concurrently to 1 peer in both orgs,
query the ledger to ensure the last transaction was written,
calculate tps, remove network and cleanup
Expand All @@ -43,52 +41,25 @@ def test_FAB3586_SkeletonInvokes(self):
self.assertIn(TEST_PASS_STRING, result)

@unittest.skip("skipping")
def test_FAB3593_Standard_basic_TLS(self):
def test_FAB3833_TPS_Queries_8_Thread_TinyNtwk(self):
'''
FAB-2032,FAB-3593
Network: 2 Ord, 5 KB, 3 ZK, 2 Org, 4 Peers, 10 Chan, 10 CC
Launch network, use PTE stress mode to send 100 invoke transactions
concurrently to all peers on all channels on all chaincodes,
query the ledger for each to ensure the last transaction was written,
calculate tps, remove network and cleanup
'''
result = subprocess.check_output("./TestPlaceholder.sh", shell=True)
self.assertIn(TEST_PASS_STRING, result)

@unittest.skip("skipping")
def test_FAB3595_Standard_basic_1M(self):
'''
FAB-2032,FAB-3595
Network: 2 Ord, 5 KB, 3 ZK, 2 Org, 4 Peers, 10 Chan, 10 CC
Launch network, use PTE stress mode to send 100 invoke transactions
concurrently to all peers on all channels on all chaincodes,
query the ledger for each to ensure the last transaction was written,
calculate tps, remove network and cleanup
'''
result = subprocess.check_output("./TestPlaceholder.sh", shell=True)
self.assertIn(TEST_PASS_STRING, result)

@unittest.skip("skipping")
def test_FAB3597_Standard_basic_Gossip(self):
'''
FAB-2032,FAB-3597
Network: 2 Ord, 5 KB, 3 ZK, 2 Org, 4 Peers, 10 Chan, 10 CC
Launch network, use PTE stress mode to send 100 invoke transactions
concurrently to all peers on all channels on all chaincodes,
query the ledger for each to ensure the last transaction was written,
calculate tps, remove network and cleanup
Tiny Network: 1 Ord, 1 KB, 1 ZK, 2 Org, 2 Peers, 1 Chan, 1 CC, 2 thrds
Launch tiny network, use PTE in STRESS mode to continuously
send 10000 query transactions concurrently to 1 peer in both orgs,
calculate tps, and remove network and cleanup
'''
# Replace TestPlaceholder.sh with actual test name, something like:
# ../../tools/PTE/tests/runSkeletonQueriesLevel.sh
result = subprocess.check_output("./TestPlaceholder.sh", shell=True)
self.assertIn(TEST_PASS_STRING, result)

@unittest.skip("skipping")
def test_FAB3599_Standard_12Hr(self):
def test_FAB3835_TPS_Invokes_8_Thread_TinyNtwk(self):
'''
FAB-2032,FAB-3599
Network: 2 Ord, 5 KB, 3 ZK, 2 Org, 4 Peers, 10 Chan, 10 CC
Launch network, use PTE stress mode to send invoke transactions
concurrently to all peers on all channels on all chaincodes,
query the ledger for each to ensure the last transaction was written,
Tiny Network: 1 Ord, 1 KB, 1 ZK, 2 Org, 2 Peers, 1 Chan, 1 CC, 2 thrds
Launch tiny network, use PTE in STRESS mode to continuously
send 10000 query transactions concurrently to 1 peer in both orgs,
query the ledger to ensure the last transaction was written,
calculate tps, remove network and cleanup
'''
result = subprocess.check_output("./TestPlaceholder.sh", shell=True)
Expand All @@ -101,11 +72,10 @@ def test_FAB3599_Standard_12Hr(self):

class CouchDB_Perf_Stress(unittest.TestCase):
@unittest.skip("skipping")
def test_FAB3585_SkeletonQueries(self):
def test_FAB3807_TPS_Queries_1_Thread_TinyNtwk(self):
'''
FAB-2032,FAB-3585
Network: 1 Ord, 1 KB, 1 ZK, 2 Org, 2 Peers, 1 Chan, 1 CC
Launch skeleton network, use PTE in STRESS mode to continuously
Tiny Network: 1 Ord, 1 KB, 1 ZK, 2 Org, 2 Peers, 1 Chan, 1 CC, 2 thrds
Launch tiny network, use PTE in STRESS mode to continuously
send 10000 query transactions concurrently to 1 peer in both orgs,
calculate tps, and remove network and cleanup
'''
Expand All @@ -115,11 +85,10 @@ def test_FAB3585_SkeletonQueries(self):
self.assertIn(TEST_PASS_STRING, result)

@unittest.skip("skipping")
def test_FAB3587_SkeletonInvokes(self):
def test_FAB3810_TPS_Invokes_1_Thread_TinyNtwk(self):
'''
FAB-2032,FAB-3587
Network: 1 Ord, 1 KB, 1 ZK, 2 Org, 2 Peers, 1 Chan, 1 CC
Launch skeleton network, use PTE in STRESS mode to continuously
Tiny Network: 1 Ord, 1 KB, 1 ZK, 2 Org, 2 Peers, 1 Chan, 1 CC, 2 thrds
Launch tiny network, use PTE in STRESS mode to continuously
send 10000 query transactions concurrently to 1 peer in both orgs,
query the ledger to ensure the last transaction was written,
calculate tps, remove network and cleanup
Expand All @@ -128,116 +97,66 @@ def test_FAB3587_SkeletonInvokes(self):
self.assertIn(TEST_PASS_STRING, result)

@unittest.skip("skipping")
def test_FAB3588_Scaleup1(self):
'''
FAB-2032,FAB-3588
Network: 2 Ord, 5 KB, 3 ZK, 2 Org, 4 Peers, 20 Chan, 2 CC
Launch network, use PTE stress mode to send 100 invoke transactions
concurrently to all peers on all channels on all chaincodes,
query the ledger for each to ensure the last transaction was written,
calculate tps, remove network and cleanup
'''
result = subprocess.check_output("./TestPlaceholder.sh", shell=True)
self.assertIn(TEST_PASS_STRING, result)

@unittest.skip("skipping")
def test_FAB3589_Scaleup2(self):
def test_FAB3832_TPS_Queries_8_Thread_TinyNtwk(self):
'''
FAB-2032,FAB-3589
Network: 2 Ord, 5 KB, 3 ZK, 4 Org, 8 Peers, 40 Chan, 4 CC
Launch network, use PTE stress mode to send 100 invoke transactions
concurrently to all peers on all channels on all chaincodes,
query the ledger for each to ensure the last transaction was written,
calculate tps, remove network and cleanup
'''
result = subprocess.check_output("./TestPlaceholder.sh", shell=True)
self.assertIn(TEST_PASS_STRING, result)

@unittest.skip("skipping")
def test_FAB3590_Scaleup3(self):
'''
FAB-2032,FAB-3590
Network: 2 Ord, 5 KB, 3 ZK, 8 Org, 16 Peers, 80 Chan, 8 CC
Launch network, use PTE stress mode to send 100 invoke transactions
concurrently to all peers on all channels on all chaincodes,
query the ledger for each to ensure the last transaction was written,
calculate tps, remove network and cleanup
'''
result = subprocess.check_output("./TestPlaceholder.sh", shell=True)
self.assertIn(TEST_PASS_STRING, result)

@unittest.skip("skipping")
def test_FAB3591_Scaleup4(self):
'''
FAB-2032,FAB-3591
Network: 4 Ord, 5 KB, 3 ZK, 16 Org, 32 Peers, 160 Chan, 16 CC
Launch network, use PTE stress mode to send 100 invoke transactions
concurrently to all peers on all channels on all chaincodes,
query the ledger for each to ensure the last transaction was written,
calculate tps, remove network and cleanup
'''
result = subprocess.check_output("./TestPlaceholder.sh", shell=True)
self.assertIn(TEST_PASS_STRING, result)

@unittest.skip("skipping")
def test_FAB3592_Scaleup5(self):
'''
FAB-2032,FAB-3592
Network: 4 Ord, 5 KB, 3 ZK, 32 Org, 64 Peers, 320 Chan, 32 CC
Launch network, use PTE stress mode to send 100 invoke transactions
concurrently to all peers on all channels on all chaincodes,
query the ledger for each to ensure the last transaction was written,
calculate tps, remove network and cleanup
Tiny Network: 1 Ord, 1 KB, 1 ZK, 2 Org, 2 Peers, 1 Chan, 1 CC, 2 thrds
Launch tiny network, use PTE in STRESS mode to continuously
send 10000 query transactions concurrently to 1 peer in both orgs,
calculate tps, and remove network and cleanup
'''
# Replace TestPlaceholder.sh with actual test name, something like:
# ../../tools/PTE/tests/runSkeletonQueriesCouch.sh
result = subprocess.check_output("./TestPlaceholder.sh", shell=True)
self.assertIn(TEST_PASS_STRING, result)

@unittest.skip("skipping")
def test_FAB3594_Standard_basic_TLS(self):
def test_FAB3834_TPS_Invokes_8_Thread_TinyNtwk(self):
'''
FAB-2032,FAB-3594
Network: 2 Ord, 5 KB, 3 ZK, 2 Org, 4 Peers, 10 Chan, 10 CC
Launch network, use PTE stress mode to send 100 invoke transactions
concurrently to all peers on all channels on all chaincodes,
query the ledger for each to ensure the last transaction was written,
Tiny Network: 1 Ord, 1 KB, 1 ZK, 2 Org, 2 Peers, 1 Chan, 1 CC, 2 thrds
Launch tiny network, use PTE in STRESS mode to continuously
send 10000 query transactions concurrently to 1 peer in both orgs,
query the ledger to ensure the last transaction was written,
calculate tps, remove network and cleanup
'''
result = subprocess.check_output("./TestPlaceholder.sh", shell=True)
self.assertIn(TEST_PASS_STRING, result)

@unittest.skip("skipping")
def test_FAB3596_Standard_basic_1M(self):
def test_FAB3813_Baseline_StandardNtwk_8_Thread(self):
'''
FAB-2032,FAB-3596
Network: 2 Ord, 5 KB, 3 ZK, 2 Org, 4 Peers, 10 Chan, 10 CC
Launch network, use PTE stress mode to send 100 invoke transactions
concurrently to all peers on all channels on all chaincodes,
"Standard Network": 2 Orderers, 3 KafkaBrokers, 3 ZooKeepers,
2 Certificate Authorities (CAs - 1 per Org), 2 Organizations,
2 Peers per Org, 4 Peers, 2 Channels, 2 ChainCodes, 8 total threads.
Launch network, use PTE stress mode to send 10000 invoke transactions
concurrently to a peer in each org on all channels on all chaincodes,
query the ledger for each to ensure the last transaction was written,
calculate tps, remove network and cleanup
'''
result = subprocess.check_output("./TestPlaceholder.sh", shell=True)
self.assertIn(TEST_PASS_STRING, result)

@unittest.skip("skipping")
def test_FAB3598_Standard_basic_Gossip(self):
def test_FAB3814_Payload_1Meg(self):
'''
FAB-2032,FAB-3598
Network: 2 Ord, 5 KB, 3 ZK, 2 Org, 4 Peers, 10 Chan, 10 CC
Launch network, use PTE stress mode to send 100 invoke transactions
concurrently to all peers on all channels on all chaincodes,
Standard Network: 2 Orderers, 3 KafkaBrokers, 3 ZooKeepers,
2 Certificate Authorities (CAs - 1 per Org), 2 Organizations,
2 Peers per Org, 4 Peers, 2 Channels, 2 ChainCodes, 8 total threads.
Launch network, use PTE stress mode to send 10000 invoke transactions
concurrently to a peer in each org on all channels on all chaincodes,
query the ledger for each to ensure the last transaction was written,
calculate tps, remove network and cleanup
'''
result = subprocess.check_output("./TestPlaceholder.sh", shell=True)
self.assertIn(TEST_PASS_STRING, result)

@unittest.skip("skipping")
def test_FAB3600_Standard_12Hr(self):
def test_FAB3816_GossipStress_10_PeersPerOrg(self):
'''
FAB-2032,FAB-3600
Network: 2 Ord, 5 KB, 3 ZK, 2 Org, 4 Peers, 10 Chan, 10 CC
Launch network, use PTE stress mode to send invoke transactions
concurrently to all peers on all channels on all chaincodes,
Standard Network plus extra peers: 2 Orderers, 3 KafkaBrokers, 3 ZKs,
2 Certificate Authorities (CAs - 1 per Org), 2 Organizations,
10 Peers per Org, 4 Peers, 2 Channels, 2 ChainCodes, 8 total threads.
Launch network, use PTE stress mode to send 10000 invoke transactions
concurrently to a peer in each org on all channels on all chaincodes,
query the ledger for each to ensure the last transaction was written,
calculate tps, remove network and cleanup
'''
Expand Down
93 changes: 76 additions & 17 deletions test/regression/weekly/test_pte.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -11,39 +11,98 @@


######################################################################
### LEVELDB
### COUCHDB
######################################################################

class LevelDB_Perf_Stress(unittest.TestCase):
class CouchDB_Perf_Stress(unittest.TestCase):

@unittest.skip("skipping")
def test_FAB3601_Standard_72Hr(self):
def test_FAB3820_TimedRun_12Hr(self):
'''
FAB-2032,FAB-3601
Network: 2 Ord, 5 KB, 3 ZK, 2 Org, 4 Peers, 10 Chan, 10 CC
Standard Network: 2 Orderers, 3 KafkaBrokers, 3 ZooKeepers,
2 Certificate Authorities (CAs - 1 per Org), 2 Organizations,
2 Peers per Org, 4 Peers, 2 Channels, 2 ChainCodes, 8 total threads.
Launch network, use PTE stress mode to send invoke transactions
concurrently to all peers on all channels on all chaincodes,
with 1K Payload concurrently to one peer in each organization
on all channels on all chaincodes, for the specified duration.
Query the ledger for each to ensure the last transaction was written,
calculate tps, remove network and cleanup.
'''
result = subprocess.check_output("./TestPlaceholder.sh", shell=True)
self.assertIn(TEST_PASS_STRING, result)

@unittest.skip("skipping")
def test_FAB3821_TimedRun_72Hr(self):
'''
Standard Network: 2 Orderers, 3 KafkaBrokers, 3 ZooKeepers,
2 Certificate Authorities (CAs - 1 per Org), 2 Organizations,
2 Peers per Org, 4 Peers, 2 Channels, 2 ChainCodes, 8 total threads.
Launch network, use PTE stress mode to send invoke transactions
with 1K Payload concurrently to one peer in each organization
on all channels on all chaincodes, for the specified duration.
Query the ledger for each to ensure the last transaction was written,
calculate tps, remove network and cleanup.
'''
result = subprocess.check_output("../daily/TestPlaceholder.sh", shell=True)
self.assertIn(TEST_PASS_STRING, result)

@unittest.skip("skipping")
def test_FAB3822_Scaleup1(self):
'''
Network: 2 Ord, 5 KB, 3 ZK, 2 Org, 2 PeersPerOrg, 2 Chan, 1 CC, 4 thrds
Launch network, use PTE stress mode to send 10000 invoke transactions
concurrently to a peer in each org on all channels on all chaincodes,
query the ledger for each to ensure the last transaction was written,
calculate tps, remove network and cleanup
'''
result = subprocess.check_output("../daily/TestPlaceholder.sh", shell=True)
result = subprocess.check_output("./TestPlaceholder.sh", shell=True)
self.assertIn(TEST_PASS_STRING, result)

@unittest.skip("skipping")
def test_FAB3823_Scaleup2(self):
'''
Network: 2 Ord, 5 KB, 3 ZK, 2 Org, 2 PeersPerOrg, 2 Chan, 2 CC, 8 thrds
Launch network, use PTE stress mode to send 10000 invoke transactions
concurrently to a peer in each org on all channels on all chaincodes,
query the ledger for each to ensure the last transaction was written,
calculate tps, remove network and cleanup
'''
result = subprocess.check_output("./TestPlaceholder.sh", shell=True)
self.assertIn(TEST_PASS_STRING, result)

######################################################################
### COUCHDB
######################################################################
@unittest.skip("skipping")
def test_FAB3824_Scaleup3(self):
'''
Network: 2 Ord, 5 KB, 3 ZK, 2 Org, 4 PeersPerOrg, 4 Chan, 2 CC, 16 thrds
Launch network, use PTE stress mode to send 10000 invoke transactions
concurrently to a peer in each org on all channels on all chaincodes,
query the ledger for each to ensure the last transaction was written,
calculate tps, remove network and cleanup
'''
result = subprocess.check_output("./TestPlaceholder.sh", shell=True)
self.assertIn(TEST_PASS_STRING, result)

class CouchDB_Perf_Stress(unittest.TestCase):
@unittest.skip("skipping")
def test_FAB3602_Standard_72Hr(self):
def test_FAB3825_Scaleup4(self):
'''
FAB-2032,FAB-3602
Network: 2 Ord, 5 KB, 3 ZK, 2 Org, 4 Peers, 10 Chan, 10 CC
Launch network, use PTE stress mode to send invoke transactions
concurrently to all peers on all channels on all chaincodes,
Network: 4 Ord, 5 KB, 3 ZK, 2 Org, 4 PeersPerOrg, 8 Chan, 2 CC, 32 thrds
Launch network, use PTE stress mode to send 10000 invoke transactions
concurrently to a peer in each org on all channels on all chaincodes,
query the ledger for each to ensure the last transaction was written,
calculate tps, remove network and cleanup
'''
result = subprocess.check_output("../daily/TestPlaceholder.sh", shell=True)
result = subprocess.check_output("./TestPlaceholder.sh", shell=True)
self.assertIn(TEST_PASS_STRING, result)

@unittest.skip("skipping")
def test_FAB3826_Scaleup5(self):
'''
Network: 4 Ord, 5 KB, 3 ZK, 3 Org, 4 PeersPerOrg (12 Peers), 8 Chan, 2 CC, 48 thrds
Launch network, use PTE stress mode to send 10000 invoke transactions
concurrently to a peer in each org on all channels on all chaincodes,
query the ledger for each to ensure the last transaction was written,
calculate tps, remove network and cleanup
'''
result = subprocess.check_output("./TestPlaceholder.sh", shell=True)
self.assertIn(TEST_PASS_STRING, result)

0 comments on commit 0509bed

Please sign in to comment.