Skip to content

Commit b315414

Browse files
agusduhaagusduha
authored
test: add more unit tests (#78)
1 parent 5fb3b6b commit b315414

7 files changed

+317
-0
lines changed

‎solidity/test/utils/ContractA.t.sol

+38
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,38 @@
1+
// SPDX-License-Identifier: MIT
2+
pragma solidity ^0.8.0;
3+
4+
import {Test} from 'forge-std/Test.sol';
5+
import {MockContractA} from 'test/smock/contracts/utils/MockContractA.sol';
6+
import {SmockHelper} from 'test/smock/SmockHelper.sol';
7+
8+
contract UnitMockContractA is Test, SmockHelper {
9+
address internal _owner = makeAddr('owner');
10+
MockContractA internal _contractTest;
11+
12+
uint256 internal _initialValue = 5;
13+
uint256 internal _newValue = 10;
14+
15+
function setUp() public {
16+
vm.prank(_owner);
17+
18+
_contractTest =
19+
MockContractA(deployMock('TestContractA', type(MockContractA).creationCode, abi.encode(_initialValue)));
20+
}
21+
22+
function test_Set_UintVariable() public {
23+
_contractTest.set_uintVariable(_newValue);
24+
assertEq(_contractTest.uintVariable(), _newValue);
25+
}
26+
27+
function test_Call_UintVariable() public {
28+
_contractTest.mock_call_uintVariable(_newValue);
29+
assertEq(_contractTest.uintVariable(), _newValue);
30+
}
31+
32+
function test_Call_SetVariablesA() public {
33+
bool _result = true;
34+
35+
_contractTest.mock_call_setVariablesA(_newValue, _result);
36+
assertEq(_contractTest.setVariablesA(_newValue), _result);
37+
}
38+
}

‎solidity/test/utils/ContractAbstract.t.sol

+91
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,91 @@
1+
// SPDX-License-Identifier: MIT
2+
pragma solidity ^0.8.0;
3+
4+
import {Test} from 'forge-std/Test.sol';
5+
import {MockContractAbstract} from 'test/smock/contracts/utils/MockContractAbstract.sol';
6+
import {SmockHelper} from 'test/smock/SmockHelper.sol';
7+
8+
contract UnitMockContractAbstract is Test, SmockHelper {
9+
address internal _owner = makeAddr('owner');
10+
MockContractAbstract internal _contractTest;
11+
12+
uint256 internal _initialValue = 5;
13+
uint256 internal _newValue = 10;
14+
string internal _someText = 'some text';
15+
bool internal _result = true;
16+
17+
function setUp() public {
18+
vm.prank(_owner);
19+
20+
_contractTest = MockContractAbstract(
21+
deployMock('TestContractAbstract', type(MockContractAbstract).creationCode, abi.encode(_initialValue))
22+
);
23+
}
24+
25+
function test_Set_UintVariable() public {
26+
_contractTest.set_uintVariable(_newValue);
27+
assertEq(_contractTest.uintVariable(), _newValue);
28+
}
29+
30+
function test_Call_UintVariable() public {
31+
_contractTest.mock_call_uintVariable(_newValue);
32+
assertEq(_contractTest.uintVariable(), _newValue);
33+
}
34+
35+
function test_Call_SetVariablesA() public {
36+
_contractTest.mock_call_setVariablesA(_newValue, _result);
37+
assertEq(_contractTest.setVariablesA(_newValue), _result);
38+
}
39+
40+
function test_Call_UndefinedFunc() public {
41+
_contractTest.mock_call_undefinedFunc(_someText, _result);
42+
assertEq(_contractTest.undefinedFunc(_someText), _result);
43+
}
44+
45+
function test_Call_UndefinedFuncNoInputNoOutput() public {
46+
vm.expectCall(address(_contractTest), abi.encodeCall(MockContractAbstract.undefinedFuncNoInputNoOutput, ()), 1);
47+
48+
_contractTest.mock_call_undefinedFuncNoInputNoOutput();
49+
_contractTest.undefinedFuncNoInputNoOutput();
50+
}
51+
52+
function test_Call_UndefinedViewFunc() public {
53+
_contractTest.mock_call_undefinedViewFunc(_someText, _result);
54+
assertEq(_contractTest.undefinedViewFunc(_someText), _result);
55+
}
56+
57+
function test_Call_UndefinedViewFuncNoInputNoOutput() public {
58+
vm.expectCall(address(_contractTest), abi.encodeCall(MockContractAbstract.undefinedViewFuncNoInputNoOutput, ()), 1);
59+
60+
_contractTest.mock_call_undefinedViewFuncNoInputNoOutput();
61+
_contractTest.undefinedViewFuncNoInputNoOutput();
62+
}
63+
64+
function test_Call_UndefinedInternalFunc() public {
65+
_contractTest.expectCall__undefinedInternalFunc(_someText);
66+
67+
_contractTest.mock_call__undefinedInternalFunc(_someText, _result);
68+
assertEq(_contractTest.call__undefinedInternalFunc(_someText), _result);
69+
}
70+
71+
function test_Call_UndefinedInternalFuncNoInputNoOutput() public {
72+
_contractTest.expectCall__undefinedInternalFuncNoInputNoOutput();
73+
74+
_contractTest.mock_call__undefinedInternalFuncNoInputNoOutput();
75+
_contractTest.call__undefinedInternalFuncNoInputNoOutput();
76+
}
77+
78+
function test_Call_UndefinedInternalViewFunc() public {
79+
_contractTest.expectCall__undefinedInternalViewFunc(_someText);
80+
81+
_contractTest.mock_call__undefinedInternalViewFunc(_someText, _result);
82+
assertEq(_contractTest.call__undefinedInternalViewFunc(_someText), _result);
83+
}
84+
85+
function test_Call_UndefinedInternalViewFuncNoInputNoOutput() public {
86+
_contractTest.expectCall__undefinedInternalViewFuncNoInputNoOutput();
87+
88+
_contractTest.mock_call__undefinedInternalViewFuncNoInputNoOutput();
89+
_contractTest.call__undefinedInternalViewFuncNoInputNoOutput();
90+
}
91+
}

‎solidity/test/utils/ContractB.t.sol

+36
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,36 @@
1+
// SPDX-License-Identifier: MIT
2+
pragma solidity ^0.8.0;
3+
4+
import {Test} from 'forge-std/Test.sol';
5+
import {MockContractB} from 'test/smock/contracts/utils/MockContractB.sol';
6+
import {SmockHelper} from 'test/smock/SmockHelper.sol';
7+
8+
contract UnitMockContractB is Test, SmockHelper {
9+
address internal _owner = makeAddr('owner');
10+
MockContractB internal _contractTest;
11+
12+
string internal _newValue = 'new value';
13+
14+
function setUp() public {
15+
vm.prank(_owner);
16+
17+
_contractTest = MockContractB(deployMock('TestContractB', type(MockContractB).creationCode, abi.encode()));
18+
}
19+
20+
function test_Set_StringVariable() public {
21+
_contractTest.set_stringVariable(_newValue);
22+
assertEq(_contractTest.stringVariable(), _newValue);
23+
}
24+
25+
function test_Call_StringVariable() public {
26+
_contractTest.mock_call_stringVariable(_newValue);
27+
assertEq(_contractTest.stringVariable(), _newValue);
28+
}
29+
30+
function test_Call_SetVariablesB() public {
31+
bool _result = true;
32+
33+
_contractTest.mock_call_setVariablesB(_newValue, _result);
34+
assertEq(_contractTest.setVariablesB(_newValue), _result);
35+
}
36+
}

‎solidity/test/utils/ContractBAbstract.t.sol

+52
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,52 @@
1+
// SPDX-License-Identifier: MIT
2+
pragma solidity ^0.8.0;
3+
4+
import {Test} from 'forge-std/Test.sol';
5+
import {MockContractBAbstract} from 'test/smock/contracts/utils/MockContractBAbstract.sol';
6+
import {SmockHelper} from 'test/smock/SmockHelper.sol';
7+
8+
contract UnitMockContractBAbstract is Test, SmockHelper {
9+
address internal _owner = makeAddr('owner');
10+
MockContractBAbstract internal _contractTest;
11+
12+
uint256 internal _initialValue = 5;
13+
uint256 internal _newValue = 10;
14+
bool internal _result = true;
15+
16+
function setUp() public {
17+
vm.prank(_owner);
18+
19+
_contractTest = MockContractBAbstract(
20+
deployMock('TestContractBAbstract', type(MockContractBAbstract).creationCode, abi.encode(_initialValue))
21+
);
22+
}
23+
24+
function test_Set_UintVariable() public {
25+
_contractTest.set_uintVariable(_newValue);
26+
assertEq(_contractTest.uintVariable(), _newValue);
27+
}
28+
29+
function test_Call_UintVariable() public {
30+
_contractTest.mock_call_uintVariable(_newValue);
31+
assertEq(_contractTest.uintVariable(), _newValue);
32+
}
33+
34+
function test_Call_SetVariablesA() public {
35+
_contractTest.mock_call_setVariablesA(_newValue, _result);
36+
assertEq(_contractTest.setVariablesA(_newValue), _result);
37+
}
38+
39+
function test_Call_UndefinedInterfaceFunc() public {
40+
vm.expectCall(address(_contractTest), abi.encodeCall(MockContractBAbstract.undefinedInterfaceFunc, (_newValue)), 1);
41+
42+
_contractTest.mock_call_undefinedInterfaceFunc(_newValue, _result);
43+
assertEq(_contractTest.undefinedInterfaceFunc(_newValue), _result);
44+
}
45+
46+
function test_Call_UndefinedInterfaceFunc2() public {
47+
vm.expectCall(address(_contractTest), abi.encodeCall(MockContractBAbstract.undefinedInterfaceFunc2, (_newValue)), 1);
48+
49+
_contractTest.mock_call_undefinedInterfaceFunc2(_newValue, _result);
50+
assertEq(_contractTest.undefinedInterfaceFunc2(_newValue), _result);
51+
}
52+
}

‎solidity/test/utils/ContractCA.t.sol

+38
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,38 @@
1+
// SPDX-License-Identifier: MIT
2+
pragma solidity ^0.8.0;
3+
4+
import {Test} from 'forge-std/Test.sol';
5+
import {MockContractCA} from 'test/smock/contracts/utils/MockContractCA.sol';
6+
import {SmockHelper} from 'test/smock/SmockHelper.sol';
7+
8+
contract UnitMockContractCA is Test, SmockHelper {
9+
address internal _owner = makeAddr('owner');
10+
MockContractCA internal _contractTest;
11+
12+
uint256 internal _initialValue = 5;
13+
uint256 internal _newValue = 10;
14+
15+
function setUp() public {
16+
vm.prank(_owner);
17+
18+
_contractTest =
19+
MockContractCA(deployMock('TestContractCA', type(MockContractCA).creationCode, abi.encode(_initialValue)));
20+
}
21+
22+
function test_Set_Uint256Variable() public {
23+
_contractTest.set_uint256Variable(_newValue);
24+
assertEq(_contractTest.uint256Variable(), _newValue);
25+
}
26+
27+
function test_Call_Uint256Variable() public {
28+
_contractTest.mock_call_uint256Variable(_newValue);
29+
assertEq(_contractTest.uint256Variable(), _newValue);
30+
}
31+
32+
function test_Call_SetVariablesC() public {
33+
bool _result = true;
34+
35+
_contractTest.mock_call_setVariablesC(_newValue, _result);
36+
assertEq(_contractTest.setVariablesC(_newValue), _result);
37+
}
38+
}

‎solidity/test/utils/ContractE.t.sol

+28
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
// SPDX-License-Identifier: MIT
2+
pragma solidity ^0.8.0;
3+
4+
import {Test} from 'forge-std/Test.sol';
5+
import {MockContractE} from 'test/smock/contracts/utils/MockContractE.sol';
6+
import {SmockHelper} from 'test/smock/SmockHelper.sol';
7+
8+
contract UnitMockContractE is Test, SmockHelper {
9+
address internal _owner = makeAddr('owner');
10+
MockContractE internal _contractTest;
11+
12+
uint256 internal _initialValue = 5;
13+
uint256 internal _initialValue2 = 10;
14+
uint256 internal _newValue = 15;
15+
16+
function setUp() public {
17+
vm.prank(_owner);
18+
19+
_contractTest = MockContractE(
20+
deployMock('TestContractE', type(MockContractE).creationCode, abi.encode(_initialValue, _initialValue2))
21+
);
22+
}
23+
24+
function test_Set_InternalUintVar2() public {
25+
_contractTest.set__internalUintVar2(_newValue);
26+
assertEq(_contractTest.call__internalUintVar2(), _newValue);
27+
}
28+
}

‎solidity/test/utils/ContractF.t.sol

+34
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,34 @@
1+
// SPDX-License-Identifier: MIT
2+
pragma solidity ^0.8.0;
3+
4+
import {Test} from 'forge-std/Test.sol';
5+
import {MockContractF} from 'test/smock/contracts/utils/MockContractF.sol';
6+
import {SmockHelper} from 'test/smock/SmockHelper.sol';
7+
8+
contract UnitMockContractF is Test, SmockHelper {
9+
address internal _owner = makeAddr('owner');
10+
MockContractF internal _contractTest;
11+
12+
uint256 internal _initialValue = 5;
13+
uint256 internal _newValue = 15;
14+
15+
function setUp() public {
16+
vm.prank(_owner);
17+
18+
_contractTest = MockContractF(deployMock('TestContractF', type(MockContractF).creationCode, abi.encode(_owner)));
19+
}
20+
21+
function test_Call_SetVariablesA() public {
22+
vm.expectCall(address(_contractTest), abi.encodeCall(MockContractF.setVariablesA, _newValue));
23+
_contractTest.mock_call_setVariablesA(_newValue, true);
24+
25+
assert(_contractTest.setVariablesA(_newValue));
26+
}
27+
28+
function test_Call_SetVariablesB() public {
29+
vm.expectCall(address(_contractTest), abi.encodeCall(MockContractF.setVariablesB, _newValue));
30+
_contractTest.mock_call_setVariablesB(_newValue, true);
31+
32+
assert(_contractTest.setVariablesB(_newValue));
33+
}
34+
}

0 commit comments

Comments
 (0)