From 55e713348901248d9a4807a21bf6f3fb9ad2da34 Mon Sep 17 00:00:00 2001 From: Marten Seemann Date: Fri, 7 Jan 2022 10:49:36 +0400 Subject: [PATCH 1/2] add mocks for the resource manager --- go.mod | 5 +- go.sum | 35 +++- mocks/network/mock_conn_management_scope.go | 131 +++++++++++++ mocks/network/mock_peer_scope.go | 105 +++++++++++ mocks/network/mock_protocol_scope.go | 105 +++++++++++ mocks/network/mock_resource_manager.go | 151 +++++++++++++++ mocks/network/mock_stream_management_scope.go | 173 ++++++++++++++++++ mocks/network/network.go | 7 + suites/mux/muxer_suite.go | 18 +- 9 files changed, 709 insertions(+), 21 deletions(-) create mode 100644 mocks/network/mock_conn_management_scope.go create mode 100644 mocks/network/mock_peer_scope.go create mode 100644 mocks/network/mock_protocol_scope.go create mode 100644 mocks/network/mock_resource_manager.go create mode 100644 mocks/network/mock_stream_management_scope.go create mode 100644 mocks/network/network.go diff --git a/go.mod b/go.mod index 92fc922..0e6d8d4 100644 --- a/go.mod +++ b/go.mod @@ -3,9 +3,10 @@ module github.com/libp2p/go-libp2p-testing go 1.16 require ( + github.com/golang/mock v1.6.0 github.com/ipfs/go-log/v2 v2.4.0 - github.com/libp2p/go-libp2p-core v0.10.0 - github.com/multiformats/go-multiaddr v0.3.1 + github.com/libp2p/go-libp2p-core v0.13.1-0.20220114101623-6b8d8bf59647 + github.com/multiformats/go-multiaddr v0.4.1 go.uber.org/atomic v1.7.0 google.golang.org/grpc v1.31.1 ) diff --git a/go.sum b/go.sum index 91b01bb..bfcee79 100644 --- a/go.sum +++ b/go.sum @@ -27,6 +27,8 @@ github.com/gogo/protobuf v1.3.1 h1:DqDEcV5aeaTmdFBePNpYsp3FlcVH/2ISVVM9Qf8PSls= github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o= github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= +github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc= +github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs= github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= @@ -49,9 +51,8 @@ github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= github.com/libp2p/go-buffer-pool v0.0.2 h1:QNK2iAFa8gjAe1SPz6mHSMuCcjs+X1wlHzeOSqcmlfs= github.com/libp2p/go-buffer-pool v0.0.2/go.mod h1:MvaB6xw5vOrDl8rYZGLFdKAuk/hRoRZd1Vi32+RXyFM= github.com/libp2p/go-flow-metrics v0.0.3/go.mod h1:HeoSNUrOJVK1jEpDqVEiUOIXqhbnS27omG0uWU5slZs= -github.com/libp2p/go-libp2p-core v0.10.0 h1:jFy7v5Muq58GTeYkPhGzIH8Qq4BFfziqc0ixPd/pP9k= -github.com/libp2p/go-libp2p-core v0.10.0/go.mod h1:ECdxehoYosLYHgDDFa2N4yE8Y7aQRAMf0sX9mf2sbGg= -github.com/libp2p/go-maddr-filter v0.1.0/go.mod h1:VzZhTXkMucEGGEOSKddrwGiOv0tUhgnKqNEmIAz/bPU= +github.com/libp2p/go-libp2p-core v0.13.1-0.20220114101623-6b8d8bf59647 h1:r72wIR0ywdBUSTodR3WyY1Fdb9FUCHcYGT8NWxQH7wY= +github.com/libp2p/go-libp2p-core v0.13.1-0.20220114101623-6b8d8bf59647/go.mod h1:KlkHsZ0nKerWsXLZJm3LfFQwusI5k3iN4BgtYTE4IYE= github.com/libp2p/go-msgio v0.0.6/go.mod h1:4ecVB6d9f4BDSL5fqvPiC4A3KivjWn+Venn/1ALLMWA= github.com/libp2p/go-openssl v0.0.7 h1:eCAzdLejcNVBzP/iZM9vqHnQm+XyCEbSSIheIPRGNsw= github.com/libp2p/go-openssl v0.0.7/go.mod h1:unDrJpgy3oFr+rqXsarWifmJuNnJR4chtO1HmaZjggc= @@ -70,11 +71,8 @@ github.com/multiformats/go-base32 v0.0.3 h1:tw5+NhuwaOjJCC5Pp82QuXbrmLzWg7uxlMFp github.com/multiformats/go-base32 v0.0.3/go.mod h1:pLiuGC8y0QR3Ue4Zug5UzK9LjgbkL8NSQj0zQ5Nz/AA= github.com/multiformats/go-base36 v0.1.0 h1:JR6TyF7JjGd3m6FbLU2cOxhC0Li8z8dLNGQ89tUg4F4= github.com/multiformats/go-base36 v0.1.0/go.mod h1:kFGE83c6s80PklsHO9sRn2NCoffoRdUUOENyW/Vv6sM= -github.com/multiformats/go-multiaddr v0.2.2/go.mod h1:NtfXiOtHvghW9KojvtySjH5y0u0xW5UouOmQQrn6a3Y= -github.com/multiformats/go-multiaddr v0.3.0/go.mod h1:dF9kph9wfJ+3VLAaeBqo9Of8x4fJxp6ggJGteB8HQTI= -github.com/multiformats/go-multiaddr v0.3.1 h1:1bxa+W7j9wZKTZREySx1vPMs2TqrYWjVZ7zE6/XLG1I= -github.com/multiformats/go-multiaddr v0.3.1/go.mod h1:uPbspcUPd5AfaP6ql3ujFY+QWzmBD8uLLL4bXW0XfGc= -github.com/multiformats/go-multiaddr-net v0.2.0/go.mod h1:gGdH3UXny6U3cKKYCvpXI5rnK7YaOIEOPVDI9tsJbEA= +github.com/multiformats/go-multiaddr v0.4.1 h1:Pq37uLx3hsyNlTDir7FZyU8+cFCTqd5y1KiM2IzOutI= +github.com/multiformats/go-multiaddr v0.4.1/go.mod h1:3afI9HfVW8csiF8UZqtpYRiDyew8pRX7qLIGHu9FLuM= github.com/multiformats/go-multibase v0.0.3 h1:l/B6bJDQjvQ5G52jw4QGSYeOTZoAwIO77RblWplfIqk= github.com/multiformats/go-multibase v0.0.3/go.mod h1:5+1R4eQrT3PkYZ24C3W2Ue2tPwIdYQD509ZjSb5y9Oc= github.com/multiformats/go-multihash v0.0.13/go.mod h1:VdAWLKTwram9oKAatUcLxBNUjdtcVwxObEQBtRfuyjc= @@ -101,6 +99,7 @@ github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UV github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= go.uber.org/atomic v1.6.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ= go.uber.org/atomic v1.7.0 h1:ADUqmZGgLDDfbSL9ZmPxKTybcoEYHgpYfELNoN+7hsw= go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= @@ -113,8 +112,9 @@ go.uber.org/zap v1.16.0/go.mod h1:MA8QOfq0BHJwdXa996Y4dYkAqRKB8/1K1QMMZVaNZjQ= golang.org/x/crypto v0.0.0-20170930174604-9419663f5a44/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= -golang.org/x/crypto v0.0.0-20190611184440-5c40567a22f8 h1:1wopBVtVdWnn03fZelqdXTqk7U7zPQCb+T4rbU9ZEoU= golang.org/x/crypto v0.0.0-20190611184440-5c40567a22f8/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550 h1:ObdrDkeb4kJdCP557AjRjq69pTHfNouLtWZG7j9rPN8= +golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU= @@ -122,6 +122,8 @@ golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHl golang.org/x/lint v0.0.0-20190930215403-16217165b5de h1:5hukYrvBGR8/eNkX5mdUezrA6JiaEZDtJb9Ei+1LlBs= golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc= +golang.org/x/mod v0.4.2 h1:Gz96sIWK3OalVv/I/qNygP42zyoKp3xptRVCWRFEBvo= +golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= @@ -129,18 +131,26 @@ golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73r golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190626221950-04f50cda93cb/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c h1:F1jZWGFhYfh0Ci55sIpILtKKK8p3i2/krTr0H1rg74I= golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20181030221726-6c7e314b6563/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY= @@ -148,10 +158,15 @@ golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3 golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5 h1:hKsoRgsbwY1NafxrwTs+k64bikrLBkAgPir1TNCj3Zs= golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.1.1 h1:wGiQel/hW0NnEkJUk8lbzkX2gFJU6PFxf1v5OlCfuOs= +golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE= +golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= diff --git a/mocks/network/mock_conn_management_scope.go b/mocks/network/mock_conn_management_scope.go new file mode 100644 index 0000000..3db3692 --- /dev/null +++ b/mocks/network/mock_conn_management_scope.go @@ -0,0 +1,131 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/libp2p/go-libp2p-core/network (interfaces: ConnManagementScope) + +// Package network is a generated GoMock package. +package network + +import ( + reflect "reflect" + + gomock "github.com/golang/mock/gomock" + network "github.com/libp2p/go-libp2p-core/network" + peer "github.com/libp2p/go-libp2p-core/peer" +) + +// MockConnManagementScope is a mock of ConnManagementScope interface. +type MockConnManagementScope struct { + ctrl *gomock.Controller + recorder *MockConnManagementScopeMockRecorder +} + +// MockConnManagementScopeMockRecorder is the mock recorder for MockConnManagementScope. +type MockConnManagementScopeMockRecorder struct { + mock *MockConnManagementScope +} + +// NewMockConnManagementScope creates a new mock instance. +func NewMockConnManagementScope(ctrl *gomock.Controller) *MockConnManagementScope { + mock := &MockConnManagementScope{ctrl: ctrl} + mock.recorder = &MockConnManagementScopeMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockConnManagementScope) EXPECT() *MockConnManagementScopeMockRecorder { + return m.recorder +} + +// BeginSpan mocks base method. +func (m *MockConnManagementScope) BeginSpan() (network.ResourceScopeSpan, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BeginSpan") + ret0, _ := ret[0].(network.ResourceScopeSpan) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BeginSpan indicates an expected call of BeginSpan. +func (mr *MockConnManagementScopeMockRecorder) BeginSpan() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BeginSpan", reflect.TypeOf((*MockConnManagementScope)(nil).BeginSpan)) +} + +// Done mocks base method. +func (m *MockConnManagementScope) Done() { + m.ctrl.T.Helper() + m.ctrl.Call(m, "Done") +} + +// Done indicates an expected call of Done. +func (mr *MockConnManagementScopeMockRecorder) Done() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Done", reflect.TypeOf((*MockConnManagementScope)(nil).Done)) +} + +// PeerScope mocks base method. +func (m *MockConnManagementScope) PeerScope() network.PeerScope { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PeerScope") + ret0, _ := ret[0].(network.PeerScope) + return ret0 +} + +// PeerScope indicates an expected call of PeerScope. +func (mr *MockConnManagementScopeMockRecorder) PeerScope() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PeerScope", reflect.TypeOf((*MockConnManagementScope)(nil).PeerScope)) +} + +// ReleaseMemory mocks base method. +func (m *MockConnManagementScope) ReleaseMemory(arg0 int) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "ReleaseMemory", arg0) +} + +// ReleaseMemory indicates an expected call of ReleaseMemory. +func (mr *MockConnManagementScopeMockRecorder) ReleaseMemory(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseMemory", reflect.TypeOf((*MockConnManagementScope)(nil).ReleaseMemory), arg0) +} + +// ReserveMemory mocks base method. +func (m *MockConnManagementScope) ReserveMemory(arg0 int, arg1 byte) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReserveMemory", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ReserveMemory indicates an expected call of ReserveMemory. +func (mr *MockConnManagementScopeMockRecorder) ReserveMemory(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReserveMemory", reflect.TypeOf((*MockConnManagementScope)(nil).ReserveMemory), arg0, arg1) +} + +// SetPeer mocks base method. +func (m *MockConnManagementScope) SetPeer(arg0 peer.ID) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetPeer", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetPeer indicates an expected call of SetPeer. +func (mr *MockConnManagementScopeMockRecorder) SetPeer(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPeer", reflect.TypeOf((*MockConnManagementScope)(nil).SetPeer), arg0) +} + +// Stat mocks base method. +func (m *MockConnManagementScope) Stat() network.ScopeStat { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Stat") + ret0, _ := ret[0].(network.ScopeStat) + return ret0 +} + +// Stat indicates an expected call of Stat. +func (mr *MockConnManagementScopeMockRecorder) Stat() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stat", reflect.TypeOf((*MockConnManagementScope)(nil).Stat)) +} diff --git a/mocks/network/mock_peer_scope.go b/mocks/network/mock_peer_scope.go new file mode 100644 index 0000000..ca77940 --- /dev/null +++ b/mocks/network/mock_peer_scope.go @@ -0,0 +1,105 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/libp2p/go-libp2p-core/network (interfaces: PeerScope) + +// Package network is a generated GoMock package. +package network + +import ( + reflect "reflect" + + gomock "github.com/golang/mock/gomock" + network "github.com/libp2p/go-libp2p-core/network" + peer "github.com/libp2p/go-libp2p-core/peer" +) + +// MockPeerScope is a mock of PeerScope interface. +type MockPeerScope struct { + ctrl *gomock.Controller + recorder *MockPeerScopeMockRecorder +} + +// MockPeerScopeMockRecorder is the mock recorder for MockPeerScope. +type MockPeerScopeMockRecorder struct { + mock *MockPeerScope +} + +// NewMockPeerScope creates a new mock instance. +func NewMockPeerScope(ctrl *gomock.Controller) *MockPeerScope { + mock := &MockPeerScope{ctrl: ctrl} + mock.recorder = &MockPeerScopeMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockPeerScope) EXPECT() *MockPeerScopeMockRecorder { + return m.recorder +} + +// BeginSpan mocks base method. +func (m *MockPeerScope) BeginSpan() (network.ResourceScopeSpan, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BeginSpan") + ret0, _ := ret[0].(network.ResourceScopeSpan) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BeginSpan indicates an expected call of BeginSpan. +func (mr *MockPeerScopeMockRecorder) BeginSpan() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BeginSpan", reflect.TypeOf((*MockPeerScope)(nil).BeginSpan)) +} + +// Peer mocks base method. +func (m *MockPeerScope) Peer() peer.ID { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Peer") + ret0, _ := ret[0].(peer.ID) + return ret0 +} + +// Peer indicates an expected call of Peer. +func (mr *MockPeerScopeMockRecorder) Peer() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Peer", reflect.TypeOf((*MockPeerScope)(nil).Peer)) +} + +// ReleaseMemory mocks base method. +func (m *MockPeerScope) ReleaseMemory(arg0 int) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "ReleaseMemory", arg0) +} + +// ReleaseMemory indicates an expected call of ReleaseMemory. +func (mr *MockPeerScopeMockRecorder) ReleaseMemory(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseMemory", reflect.TypeOf((*MockPeerScope)(nil).ReleaseMemory), arg0) +} + +// ReserveMemory mocks base method. +func (m *MockPeerScope) ReserveMemory(arg0 int, arg1 byte) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReserveMemory", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ReserveMemory indicates an expected call of ReserveMemory. +func (mr *MockPeerScopeMockRecorder) ReserveMemory(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReserveMemory", reflect.TypeOf((*MockPeerScope)(nil).ReserveMemory), arg0, arg1) +} + +// Stat mocks base method. +func (m *MockPeerScope) Stat() network.ScopeStat { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Stat") + ret0, _ := ret[0].(network.ScopeStat) + return ret0 +} + +// Stat indicates an expected call of Stat. +func (mr *MockPeerScopeMockRecorder) Stat() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stat", reflect.TypeOf((*MockPeerScope)(nil).Stat)) +} diff --git a/mocks/network/mock_protocol_scope.go b/mocks/network/mock_protocol_scope.go new file mode 100644 index 0000000..4dbfcee --- /dev/null +++ b/mocks/network/mock_protocol_scope.go @@ -0,0 +1,105 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/libp2p/go-libp2p-core/network (interfaces: ProtocolScope) + +// Package network is a generated GoMock package. +package network + +import ( + reflect "reflect" + + gomock "github.com/golang/mock/gomock" + network "github.com/libp2p/go-libp2p-core/network" + protocol "github.com/libp2p/go-libp2p-core/protocol" +) + +// MockProtocolScope is a mock of ProtocolScope interface. +type MockProtocolScope struct { + ctrl *gomock.Controller + recorder *MockProtocolScopeMockRecorder +} + +// MockProtocolScopeMockRecorder is the mock recorder for MockProtocolScope. +type MockProtocolScopeMockRecorder struct { + mock *MockProtocolScope +} + +// NewMockProtocolScope creates a new mock instance. +func NewMockProtocolScope(ctrl *gomock.Controller) *MockProtocolScope { + mock := &MockProtocolScope{ctrl: ctrl} + mock.recorder = &MockProtocolScopeMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockProtocolScope) EXPECT() *MockProtocolScopeMockRecorder { + return m.recorder +} + +// BeginSpan mocks base method. +func (m *MockProtocolScope) BeginSpan() (network.ResourceScopeSpan, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BeginSpan") + ret0, _ := ret[0].(network.ResourceScopeSpan) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BeginSpan indicates an expected call of BeginSpan. +func (mr *MockProtocolScopeMockRecorder) BeginSpan() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BeginSpan", reflect.TypeOf((*MockProtocolScope)(nil).BeginSpan)) +} + +// Protocol mocks base method. +func (m *MockProtocolScope) Protocol() protocol.ID { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Protocol") + ret0, _ := ret[0].(protocol.ID) + return ret0 +} + +// Protocol indicates an expected call of Protocol. +func (mr *MockProtocolScopeMockRecorder) Protocol() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Protocol", reflect.TypeOf((*MockProtocolScope)(nil).Protocol)) +} + +// ReleaseMemory mocks base method. +func (m *MockProtocolScope) ReleaseMemory(arg0 int) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "ReleaseMemory", arg0) +} + +// ReleaseMemory indicates an expected call of ReleaseMemory. +func (mr *MockProtocolScopeMockRecorder) ReleaseMemory(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseMemory", reflect.TypeOf((*MockProtocolScope)(nil).ReleaseMemory), arg0) +} + +// ReserveMemory mocks base method. +func (m *MockProtocolScope) ReserveMemory(arg0 int, arg1 byte) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReserveMemory", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ReserveMemory indicates an expected call of ReserveMemory. +func (mr *MockProtocolScopeMockRecorder) ReserveMemory(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReserveMemory", reflect.TypeOf((*MockProtocolScope)(nil).ReserveMemory), arg0, arg1) +} + +// Stat mocks base method. +func (m *MockProtocolScope) Stat() network.ScopeStat { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Stat") + ret0, _ := ret[0].(network.ScopeStat) + return ret0 +} + +// Stat indicates an expected call of Stat. +func (mr *MockProtocolScopeMockRecorder) Stat() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stat", reflect.TypeOf((*MockProtocolScope)(nil).Stat)) +} diff --git a/mocks/network/mock_resource_manager.go b/mocks/network/mock_resource_manager.go new file mode 100644 index 0000000..bf416a6 --- /dev/null +++ b/mocks/network/mock_resource_manager.go @@ -0,0 +1,151 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/libp2p/go-libp2p-core/network (interfaces: ResourceManager) + +// Package network is a generated GoMock package. +package network + +import ( + reflect "reflect" + + gomock "github.com/golang/mock/gomock" + network "github.com/libp2p/go-libp2p-core/network" + peer "github.com/libp2p/go-libp2p-core/peer" + protocol "github.com/libp2p/go-libp2p-core/protocol" +) + +// MockResourceManager is a mock of ResourceManager interface. +type MockResourceManager struct { + ctrl *gomock.Controller + recorder *MockResourceManagerMockRecorder +} + +// MockResourceManagerMockRecorder is the mock recorder for MockResourceManager. +type MockResourceManagerMockRecorder struct { + mock *MockResourceManager +} + +// NewMockResourceManager creates a new mock instance. +func NewMockResourceManager(ctrl *gomock.Controller) *MockResourceManager { + mock := &MockResourceManager{ctrl: ctrl} + mock.recorder = &MockResourceManagerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockResourceManager) EXPECT() *MockResourceManagerMockRecorder { + return m.recorder +} + +// Close mocks base method. +func (m *MockResourceManager) Close() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Close") + ret0, _ := ret[0].(error) + return ret0 +} + +// Close indicates an expected call of Close. +func (mr *MockResourceManagerMockRecorder) Close() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockResourceManager)(nil).Close)) +} + +// OpenConnection mocks base method. +func (m *MockResourceManager) OpenConnection(arg0 network.Direction, arg1 bool) (network.ConnManagementScope, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "OpenConnection", arg0, arg1) + ret0, _ := ret[0].(network.ConnManagementScope) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// OpenConnection indicates an expected call of OpenConnection. +func (mr *MockResourceManagerMockRecorder) OpenConnection(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenConnection", reflect.TypeOf((*MockResourceManager)(nil).OpenConnection), arg0, arg1) +} + +// OpenStream mocks base method. +func (m *MockResourceManager) OpenStream(arg0 peer.ID, arg1 network.Direction) (network.StreamManagementScope, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "OpenStream", arg0, arg1) + ret0, _ := ret[0].(network.StreamManagementScope) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// OpenStream indicates an expected call of OpenStream. +func (mr *MockResourceManagerMockRecorder) OpenStream(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenStream", reflect.TypeOf((*MockResourceManager)(nil).OpenStream), arg0, arg1) +} + +// ViewPeer mocks base method. +func (m *MockResourceManager) ViewPeer(arg0 peer.ID, arg1 func(network.PeerScope) error) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ViewPeer", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ViewPeer indicates an expected call of ViewPeer. +func (mr *MockResourceManagerMockRecorder) ViewPeer(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ViewPeer", reflect.TypeOf((*MockResourceManager)(nil).ViewPeer), arg0, arg1) +} + +// ViewProtocol mocks base method. +func (m *MockResourceManager) ViewProtocol(arg0 protocol.ID, arg1 func(network.ProtocolScope) error) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ViewProtocol", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ViewProtocol indicates an expected call of ViewProtocol. +func (mr *MockResourceManagerMockRecorder) ViewProtocol(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ViewProtocol", reflect.TypeOf((*MockResourceManager)(nil).ViewProtocol), arg0, arg1) +} + +// ViewService mocks base method. +func (m *MockResourceManager) ViewService(arg0 string, arg1 func(network.ServiceScope) error) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ViewService", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ViewService indicates an expected call of ViewService. +func (mr *MockResourceManagerMockRecorder) ViewService(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ViewService", reflect.TypeOf((*MockResourceManager)(nil).ViewService), arg0, arg1) +} + +// ViewSystem mocks base method. +func (m *MockResourceManager) ViewSystem(arg0 func(network.ResourceScope) error) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ViewSystem", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// ViewSystem indicates an expected call of ViewSystem. +func (mr *MockResourceManagerMockRecorder) ViewSystem(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ViewSystem", reflect.TypeOf((*MockResourceManager)(nil).ViewSystem), arg0) +} + +// ViewTransient mocks base method. +func (m *MockResourceManager) ViewTransient(arg0 func(network.ResourceScope) error) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ViewTransient", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// ViewTransient indicates an expected call of ViewTransient. +func (mr *MockResourceManagerMockRecorder) ViewTransient(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ViewTransient", reflect.TypeOf((*MockResourceManager)(nil).ViewTransient), arg0) +} diff --git a/mocks/network/mock_stream_management_scope.go b/mocks/network/mock_stream_management_scope.go new file mode 100644 index 0000000..d5beeba --- /dev/null +++ b/mocks/network/mock_stream_management_scope.go @@ -0,0 +1,173 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/libp2p/go-libp2p-core/network (interfaces: StreamManagementScope) + +// Package network is a generated GoMock package. +package network + +import ( + reflect "reflect" + + gomock "github.com/golang/mock/gomock" + network "github.com/libp2p/go-libp2p-core/network" + protocol "github.com/libp2p/go-libp2p-core/protocol" +) + +// MockStreamManagementScope is a mock of StreamManagementScope interface. +type MockStreamManagementScope struct { + ctrl *gomock.Controller + recorder *MockStreamManagementScopeMockRecorder +} + +// MockStreamManagementScopeMockRecorder is the mock recorder for MockStreamManagementScope. +type MockStreamManagementScopeMockRecorder struct { + mock *MockStreamManagementScope +} + +// NewMockStreamManagementScope creates a new mock instance. +func NewMockStreamManagementScope(ctrl *gomock.Controller) *MockStreamManagementScope { + mock := &MockStreamManagementScope{ctrl: ctrl} + mock.recorder = &MockStreamManagementScopeMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockStreamManagementScope) EXPECT() *MockStreamManagementScopeMockRecorder { + return m.recorder +} + +// BeginSpan mocks base method. +func (m *MockStreamManagementScope) BeginSpan() (network.ResourceScopeSpan, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BeginSpan") + ret0, _ := ret[0].(network.ResourceScopeSpan) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BeginSpan indicates an expected call of BeginSpan. +func (mr *MockStreamManagementScopeMockRecorder) BeginSpan() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BeginSpan", reflect.TypeOf((*MockStreamManagementScope)(nil).BeginSpan)) +} + +// Done mocks base method. +func (m *MockStreamManagementScope) Done() { + m.ctrl.T.Helper() + m.ctrl.Call(m, "Done") +} + +// Done indicates an expected call of Done. +func (mr *MockStreamManagementScopeMockRecorder) Done() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Done", reflect.TypeOf((*MockStreamManagementScope)(nil).Done)) +} + +// PeerScope mocks base method. +func (m *MockStreamManagementScope) PeerScope() network.PeerScope { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PeerScope") + ret0, _ := ret[0].(network.PeerScope) + return ret0 +} + +// PeerScope indicates an expected call of PeerScope. +func (mr *MockStreamManagementScopeMockRecorder) PeerScope() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PeerScope", reflect.TypeOf((*MockStreamManagementScope)(nil).PeerScope)) +} + +// ProtocolScope mocks base method. +func (m *MockStreamManagementScope) ProtocolScope() network.ProtocolScope { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ProtocolScope") + ret0, _ := ret[0].(network.ProtocolScope) + return ret0 +} + +// ProtocolScope indicates an expected call of ProtocolScope. +func (mr *MockStreamManagementScopeMockRecorder) ProtocolScope() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProtocolScope", reflect.TypeOf((*MockStreamManagementScope)(nil).ProtocolScope)) +} + +// ReleaseMemory mocks base method. +func (m *MockStreamManagementScope) ReleaseMemory(arg0 int) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "ReleaseMemory", arg0) +} + +// ReleaseMemory indicates an expected call of ReleaseMemory. +func (mr *MockStreamManagementScopeMockRecorder) ReleaseMemory(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseMemory", reflect.TypeOf((*MockStreamManagementScope)(nil).ReleaseMemory), arg0) +} + +// ReserveMemory mocks base method. +func (m *MockStreamManagementScope) ReserveMemory(arg0 int, arg1 byte) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReserveMemory", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ReserveMemory indicates an expected call of ReserveMemory. +func (mr *MockStreamManagementScopeMockRecorder) ReserveMemory(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReserveMemory", reflect.TypeOf((*MockStreamManagementScope)(nil).ReserveMemory), arg0, arg1) +} + +// ServiceScope mocks base method. +func (m *MockStreamManagementScope) ServiceScope() network.ServiceScope { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ServiceScope") + ret0, _ := ret[0].(network.ServiceScope) + return ret0 +} + +// ServiceScope indicates an expected call of ServiceScope. +func (mr *MockStreamManagementScopeMockRecorder) ServiceScope() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServiceScope", reflect.TypeOf((*MockStreamManagementScope)(nil).ServiceScope)) +} + +// SetProtocol mocks base method. +func (m *MockStreamManagementScope) SetProtocol(arg0 protocol.ID) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetProtocol", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetProtocol indicates an expected call of SetProtocol. +func (mr *MockStreamManagementScopeMockRecorder) SetProtocol(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetProtocol", reflect.TypeOf((*MockStreamManagementScope)(nil).SetProtocol), arg0) +} + +// SetService mocks base method. +func (m *MockStreamManagementScope) SetService(arg0 string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetService", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetService indicates an expected call of SetService. +func (mr *MockStreamManagementScopeMockRecorder) SetService(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetService", reflect.TypeOf((*MockStreamManagementScope)(nil).SetService), arg0) +} + +// Stat mocks base method. +func (m *MockStreamManagementScope) Stat() network.ScopeStat { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Stat") + ret0, _ := ret[0].(network.ScopeStat) + return ret0 +} + +// Stat indicates an expected call of Stat. +func (mr *MockStreamManagementScopeMockRecorder) Stat() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stat", reflect.TypeOf((*MockStreamManagementScope)(nil).Stat)) +} diff --git a/mocks/network/network.go b/mocks/network/network.go new file mode 100644 index 0000000..1007213 --- /dev/null +++ b/mocks/network/network.go @@ -0,0 +1,7 @@ +package network + +//go:generate sh -c "mockgen -package network -destination mock_resource_manager.go github.com/libp2p/go-libp2p-core/network ResourceManager" +//go:generate sh -c "mockgen -package network -destination mock_conn_management_scope.go github.com/libp2p/go-libp2p-core/network ConnManagementScope" +//go:generate sh -c "mockgen -package network -destination mock_stream_management_scope.go github.com/libp2p/go-libp2p-core/network StreamManagementScope" +//go:generate sh -c "mockgen -package network -destination mock_peer_scope.go github.com/libp2p/go-libp2p-core/network PeerScope" +//go:generate sh -c "mockgen -package network -destination mock_protocol_scope.go github.com/libp2p/go-libp2p-core/network ProtocolScope" diff --git a/suites/mux/muxer_suite.go b/suites/mux/muxer_suite.go index b8d2228..5d72775 100644 --- a/suites/mux/muxer_suite.go +++ b/suites/mux/muxer_suite.go @@ -108,7 +108,7 @@ func GoServe(t *testing.T, tr mux.Multiplexer, l net.Listener) (done func()) { } log("accepted connection") - sc1, err := tr.NewConn(c1, true) + sc1, err := tr.NewConn(c1, true, nil) checkErr(t, err) go func() { for { @@ -140,7 +140,7 @@ func SubtestSimpleWrite(t *testing.T, tr mux.Multiplexer) { defer nc1.Close() log("wrapping conn") - c1, err := tr.NewConn(nc1, false) + c1, err := tr.NewConn(nc1, false, nil) checkErr(t, err) defer c1.Close() @@ -254,7 +254,7 @@ func SubtestStress(t *testing.T, opt Options) { return } - c, err := opt.tr.NewConn(nc, false) + c, err := opt.tr.NewConn(nc, false, nil) if err != nil { t.Fatal(fmt.Errorf("a.AddConn(%s <--> %s): %s", nc.LocalAddr(), nc.RemoteAddr(), err)) return @@ -343,7 +343,7 @@ func SubtestStreamOpenStress(t *testing.T, tr mux.Multiplexer) { workers := 5 go func() { defer wg.Done() - muxa, err := tr.NewConn(a, true) + muxa, err := tr.NewConn(a, true, nil) if err != nil { t.Error(err) return @@ -376,7 +376,7 @@ func SubtestStreamOpenStress(t *testing.T, tr mux.Multiplexer) { } }() - muxb, err := tr.NewConn(b, false) + muxb, err := tr.NewConn(b, false, nil) if err != nil { t.Fatal(err) } @@ -429,7 +429,7 @@ func SubtestStreamReset(t *testing.T, tr mux.Multiplexer) { wg.Add(1) go func() { defer wg.Done() - muxa, err := tr.NewConn(a, true) + muxa, err := tr.NewConn(a, true, nil) if err != nil { t.Error(err) return @@ -449,7 +449,7 @@ func SubtestStreamReset(t *testing.T, tr mux.Multiplexer) { s.Close() }() - muxb, err := tr.NewConn(b, false) + muxb, err := tr.NewConn(b, false, nil) if err != nil { t.Fatal(err) } @@ -465,10 +465,10 @@ func SubtestStreamReset(t *testing.T, tr mux.Multiplexer) { func SubtestWriteAfterClose(t *testing.T, tr mux.Multiplexer) { a, b := tcpPipe(t) - muxa, err := tr.NewConn(a, true) + muxa, err := tr.NewConn(a, true, nil) checkErr(t, err) - muxb, err := tr.NewConn(b, false) + muxb, err := tr.NewConn(b, false, nil) checkErr(t, err) err = muxa.Close() From 45bda9d5fca4b75a8a29afd6e70589dc460eaf91 Mon Sep 17 00:00:00 2001 From: Marten Seemann Date: Fri, 7 Jan 2022 10:55:40 +0400 Subject: [PATCH 2/2] run go generate on CI --- .github/actions/go-check-setup/action.yml | 6 ++++ .github/workflows/go-check-config.json | 3 ++ go.mod | 2 +- go.sum | 7 ++-- suites/mux/muxer_suite.go | 40 +++++++++++------------ suites/transport/stream_suite.go | 12 +++---- 6 files changed, 40 insertions(+), 30 deletions(-) create mode 100644 .github/actions/go-check-setup/action.yml create mode 100644 .github/workflows/go-check-config.json diff --git a/.github/actions/go-check-setup/action.yml b/.github/actions/go-check-setup/action.yml new file mode 100644 index 0000000..5334988 --- /dev/null +++ b/.github/actions/go-check-setup/action.yml @@ -0,0 +1,6 @@ +runs: + using: "composite" + steps: + - name: Install mockgen + shell: bash + run: go install github.com/golang/mock/mockgen@v1.6.0 diff --git a/.github/workflows/go-check-config.json b/.github/workflows/go-check-config.json new file mode 100644 index 0000000..4b37308 --- /dev/null +++ b/.github/workflows/go-check-config.json @@ -0,0 +1,3 @@ +{ + "gogenerate": true +} diff --git a/go.mod b/go.mod index 0e6d8d4..597e584 100644 --- a/go.mod +++ b/go.mod @@ -5,7 +5,7 @@ go 1.16 require ( github.com/golang/mock v1.6.0 github.com/ipfs/go-log/v2 v2.4.0 - github.com/libp2p/go-libp2p-core v0.13.1-0.20220114101623-6b8d8bf59647 + github.com/libp2p/go-libp2p-core v0.14.0 github.com/multiformats/go-multiaddr v0.4.1 go.uber.org/atomic v1.7.0 google.golang.org/grpc v1.31.1 diff --git a/go.sum b/go.sum index bfcee79..2d097a3 100644 --- a/go.sum +++ b/go.sum @@ -51,8 +51,8 @@ github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= github.com/libp2p/go-buffer-pool v0.0.2 h1:QNK2iAFa8gjAe1SPz6mHSMuCcjs+X1wlHzeOSqcmlfs= github.com/libp2p/go-buffer-pool v0.0.2/go.mod h1:MvaB6xw5vOrDl8rYZGLFdKAuk/hRoRZd1Vi32+RXyFM= github.com/libp2p/go-flow-metrics v0.0.3/go.mod h1:HeoSNUrOJVK1jEpDqVEiUOIXqhbnS27omG0uWU5slZs= -github.com/libp2p/go-libp2p-core v0.13.1-0.20220114101623-6b8d8bf59647 h1:r72wIR0ywdBUSTodR3WyY1Fdb9FUCHcYGT8NWxQH7wY= -github.com/libp2p/go-libp2p-core v0.13.1-0.20220114101623-6b8d8bf59647/go.mod h1:KlkHsZ0nKerWsXLZJm3LfFQwusI5k3iN4BgtYTE4IYE= +github.com/libp2p/go-libp2p-core v0.14.0 h1:0kYSgiK/D7Eo28GTuRXo5YHsWwAisVpFCqCVPUd/vJs= +github.com/libp2p/go-libp2p-core v0.14.0/go.mod h1:tLasfcVdTXnixsLB0QYaT1syJOhsbrhG7q6pGrHtBg8= github.com/libp2p/go-msgio v0.0.6/go.mod h1:4ecVB6d9f4BDSL5fqvPiC4A3KivjWn+Venn/1ALLMWA= github.com/libp2p/go-openssl v0.0.7 h1:eCAzdLejcNVBzP/iZM9vqHnQm+XyCEbSSIheIPRGNsw= github.com/libp2p/go-openssl v0.0.7/go.mod h1:unDrJpgy3oFr+rqXsarWifmJuNnJR4chtO1HmaZjggc= @@ -182,8 +182,9 @@ gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI= gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys= gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw= gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= -gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw= gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10= +gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= diff --git a/suites/mux/muxer_suite.go b/suites/mux/muxer_suite.go index 5d72775..69b62ac 100644 --- a/suites/mux/muxer_suite.go +++ b/suites/mux/muxer_suite.go @@ -18,7 +18,7 @@ import ( crand "crypto/rand" mrand "math/rand" - "github.com/libp2p/go-libp2p-core/mux" + "github.com/libp2p/go-libp2p-core/network" "github.com/libp2p/go-libp2p-testing/ci" ) @@ -43,7 +43,7 @@ func getFunctionName(i interface{}) string { } type Options struct { - tr mux.Multiplexer + tr network.Multiplexer connNum int streamNum int msgNum int @@ -74,7 +74,7 @@ func log(s string, v ...interface{}) { } } -func echoStream(s mux.MuxedStream) { +func echoStream(s network.MuxedStream) { defer s.Close() log("accepted stream") io.Copy(&LogWriter{s}, s) // echo everything @@ -92,7 +92,7 @@ func (lw *LogWriter) Write(buf []byte) (int, error) { return lw.W.Write(buf) } -func GoServe(t *testing.T, tr mux.Multiplexer, l net.Listener) (done func()) { +func GoServe(t *testing.T, tr network.Multiplexer, l net.Listener) (done func()) { closed := make(chan struct{}, 1) go func() { @@ -127,7 +127,7 @@ func GoServe(t *testing.T, tr mux.Multiplexer, l net.Listener) (done func()) { } } -func SubtestSimpleWrite(t *testing.T, tr mux.Multiplexer) { +func SubtestSimpleWrite(t *testing.T, tr network.Multiplexer) { l, err := net.Listen("tcp", "localhost:0") checkErr(t, err) log("listening at %s", l.Addr().String()) @@ -185,7 +185,7 @@ func SubtestStress(t *testing.T, opt Options) { rateLimitChan <- struct{}{} } - writeStream := func(s mux.MuxedStream, bufs chan<- []byte) { + writeStream := func(s network.MuxedStream, bufs chan<- []byte) { log("writeStream %p, %d msgNum", s, opt.msgNum) for i := 0; i < opt.msgNum; i++ { @@ -199,7 +199,7 @@ func SubtestStress(t *testing.T, opt Options) { } } - readStream := func(s mux.MuxedStream, bufs <-chan []byte) { + readStream := func(s network.MuxedStream, bufs <-chan []byte) { log("readStream %p, %d msgNum", s, opt.msgNum) buf2 := make([]byte, msgsize) @@ -219,7 +219,7 @@ func SubtestStress(t *testing.T, opt Options) { } } - openStreamAndRW := func(c mux.MuxedConn) { + openStreamAndRW := func(c network.MuxedConn) { log("openStreamAndRW %p, %d opt.msgNum", c, opt.msgNum) s, err := c.OpenStream(context.Background()) @@ -329,7 +329,7 @@ func tcpPipe(t *testing.T) (net.Conn, net.Conn) { return con1, con2 } -func SubtestStreamOpenStress(t *testing.T, tr mux.Multiplexer) { +func SubtestStreamOpenStress(t *testing.T, tr network.Multiplexer) { wg := new(sync.WaitGroup) a, b := tcpPipe(t) @@ -418,7 +418,7 @@ func SubtestStreamOpenStress(t *testing.T, tr mux.Multiplexer) { } } -func SubtestStreamReset(t *testing.T, tr mux.Multiplexer) { +func SubtestStreamReset(t *testing.T, tr network.Multiplexer) { wg := new(sync.WaitGroup) defer wg.Wait() @@ -442,7 +442,7 @@ func SubtestStreamReset(t *testing.T, tr mux.Multiplexer) { time.Sleep(time.Millisecond * 50) _, err = s.Write([]byte("foo")) - if err != mux.ErrReset { + if err != network.ErrReset { t.Error("should have been stream reset") } @@ -462,7 +462,7 @@ func SubtestStreamReset(t *testing.T, tr mux.Multiplexer) { } // check that Close also closes the underlying net.Conn -func SubtestWriteAfterClose(t *testing.T, tr mux.Multiplexer) { +func SubtestWriteAfterClose(t *testing.T, tr network.Multiplexer) { a, b := tcpPipe(t) muxa, err := tr.NewConn(a, true, nil) @@ -485,7 +485,7 @@ func SubtestWriteAfterClose(t *testing.T, tr mux.Multiplexer) { } } -func SubtestStress1Conn1Stream1Msg(t *testing.T, tr mux.Multiplexer) { +func SubtestStress1Conn1Stream1Msg(t *testing.T, tr network.Multiplexer) { SubtestStress(t, Options{ tr: tr, connNum: 1, @@ -496,7 +496,7 @@ func SubtestStress1Conn1Stream1Msg(t *testing.T, tr mux.Multiplexer) { }) } -func SubtestStress1Conn1Stream100Msg(t *testing.T, tr mux.Multiplexer) { +func SubtestStress1Conn1Stream100Msg(t *testing.T, tr network.Multiplexer) { SubtestStress(t, Options{ tr: tr, connNum: 1, @@ -507,7 +507,7 @@ func SubtestStress1Conn1Stream100Msg(t *testing.T, tr mux.Multiplexer) { }) } -func SubtestStress1Conn100Stream100Msg(t *testing.T, tr mux.Multiplexer) { +func SubtestStress1Conn100Stream100Msg(t *testing.T, tr network.Multiplexer) { SubtestStress(t, Options{ tr: tr, connNum: 1, @@ -518,7 +518,7 @@ func SubtestStress1Conn100Stream100Msg(t *testing.T, tr mux.Multiplexer) { }) } -func SubtestStress10Conn10Stream50Msg(t *testing.T, tr mux.Multiplexer) { +func SubtestStress10Conn10Stream50Msg(t *testing.T, tr network.Multiplexer) { SubtestStress(t, Options{ tr: tr, connNum: 10, @@ -529,7 +529,7 @@ func SubtestStress10Conn10Stream50Msg(t *testing.T, tr mux.Multiplexer) { }) } -func SubtestStress1Conn1000Stream10Msg(t *testing.T, tr mux.Multiplexer) { +func SubtestStress1Conn1000Stream10Msg(t *testing.T, tr network.Multiplexer) { SubtestStress(t, Options{ tr: tr, connNum: 1, @@ -540,7 +540,7 @@ func SubtestStress1Conn1000Stream10Msg(t *testing.T, tr mux.Multiplexer) { }) } -func SubtestStress1Conn100Stream100Msg10MB(t *testing.T, tr mux.Multiplexer) { +func SubtestStress1Conn100Stream100Msg10MB(t *testing.T, tr network.Multiplexer) { SubtestStress(t, Options{ tr: tr, connNum: 1, @@ -567,7 +567,7 @@ var subtests = []TransportTest{ // SubtestAll runs all the stream multiplexer tests against the target // transport. -func SubtestAll(t *testing.T, tr mux.Multiplexer) { +func SubtestAll(t *testing.T, tr network.Multiplexer) { for name, f := range Subtests { t.Run(name, func(t *testing.T) { f(t, tr) @@ -576,4 +576,4 @@ func SubtestAll(t *testing.T, tr mux.Multiplexer) { } // TransportTest is a stream multiplex transport test case -type TransportTest func(t *testing.T, tr mux.Multiplexer) +type TransportTest func(t *testing.T, tr network.Multiplexer) diff --git a/suites/transport/stream_suite.go b/suites/transport/stream_suite.go index f02824d..a2a4706 100644 --- a/suites/transport/stream_suite.go +++ b/suites/transport/stream_suite.go @@ -15,7 +15,7 @@ import ( crand "crypto/rand" mrand "math/rand" - "github.com/libp2p/go-libp2p-core/mux" + "github.com/libp2p/go-libp2p-core/network" "github.com/libp2p/go-libp2p-core/peer" "github.com/libp2p/go-libp2p-core/transport" "github.com/libp2p/go-libp2p-testing/race" @@ -53,7 +53,7 @@ type Options struct { MsgMax int } -func fullClose(t *testing.T, s mux.MuxedStream) { +func fullClose(t *testing.T, s network.MuxedStream) { if err := s.CloseWrite(); err != nil { t.Error(err) s.Reset() @@ -87,7 +87,7 @@ func debugLog(t *testing.T, s string, args ...interface{}) { } } -func echoStream(t *testing.T, s mux.MuxedStream) { +func echoStream(t *testing.T, s network.MuxedStream) { // echo everything var err error if VerboseDebugging { @@ -164,7 +164,7 @@ func SubtestStress(t *testing.T, ta, tb transport.Transport, maddr ma.Multiaddr, rateLimitChan <- struct{}{} } - writeStream := func(s mux.MuxedStream, bufs chan<- []byte) { + writeStream := func(s network.MuxedStream, bufs chan<- []byte) { debugLog(t, "writeStream %p, %d MsgNum", s, opt.MsgNum) for i := 0; i < opt.MsgNum; i++ { @@ -178,7 +178,7 @@ func SubtestStress(t *testing.T, ta, tb transport.Transport, maddr ma.Multiaddr, } } - readStream := func(s mux.MuxedStream, bufs <-chan []byte) { + readStream := func(s network.MuxedStream, bufs <-chan []byte) { debugLog(t, "readStream %p, %d MsgNum", s, opt.MsgNum) buf2 := make([]byte, msgsize) @@ -198,7 +198,7 @@ func SubtestStress(t *testing.T, ta, tb transport.Transport, maddr ma.Multiaddr, } } - openStreamAndRW := func(c mux.MuxedConn) { + openStreamAndRW := func(c network.MuxedConn) { debugLog(t, "openStreamAndRW %p, %d opt.MsgNum", c, opt.MsgNum) s, err := c.OpenStream(context.Background())