FilesExpand file tree

main

/

run-all-tests.sh

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

executable file

·

216 lines (172 loc) · 5.86 KB

main

/

run-all-tests.sh

Copy path

Top

File metadata and controls

• Code
• Blame

executable file

·

216 lines (172 loc) · 5.86 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

#!/bin/bash

set -e

# Colors for output

RED='\033[0;31m'

GREEN='\033[0;32m'

YELLOW='\033[1;33m'

BLUE='\033[0;34m'

NC='\033[0m' # No Color

# Configuration

MCPPROXY_BINARY="./mcpproxy"

COVERAGE_FILE="coverage.out"

COVERAGE_HTML="coverage.html"

export MCPPROXY_BINARY_PATH="$(pwd)/mcpproxy"

export MCPPROXY_BINARY="$MCPPROXY_BINARY_PATH"

# Test results tracking

TOTAL_TESTS=0

PASSED_TESTS=0

FAILED_TESTS=0

echo -e "${GREEN}MCPProxy Complete Test Suite${NC}"

echo "================================"

echo ""

# Helper functions

run_test_stage() {

local stage_name="$1"

local command="$2"

local required="$3" # "required" or "optional"

echo -e "${BLUE}[STAGE]${NC} $stage_name"

echo "Command: $command"

echo ""

TOTAL_TESTS=$((TOTAL_TESTS + 1))

if eval "$command"; then

echo -e "${GREEN}✓ $stage_name PASSED${NC}"

PASSED_TESTS=$((PASSED_TESTS + 1))

echo ""

return 0

else

echo -e "${RED}✗ $stage_name FAILED${NC}"

FAILED_TESTS=$((FAILED_TESTS + 1))

echo ""

if [ "$required" = "required" ]; then

echo -e "${RED}Required stage failed. Stopping test suite.${NC}"

exit 1

else

echo -e "${YELLOW}Optional stage failed. Continuing...${NC}"

return 1

fi

fi

}

cleanup() {

echo -e "\n${YELLOW}Cleaning up...${NC}"

# Kill any remaining mcpproxy processes

pkill -f "mcpproxy.*serve" 2>/dev/null || true

# Clean up binary

rm -f ./mcpproxy 2>/dev/null || true

# Clean up any test data directories

rm -rf ./test-data 2>/dev/null || true

# Clean up temporary log files

rm -f /tmp/mcpproxy_*.log 2>/dev/null || true

}

# Set up cleanup trap

trap cleanup EXIT

# Print environment info

echo -e "${YELLOW}Environment Information${NC}"

echo "======================="

echo -e "Go version: ${BLUE}$(go version)${NC}"

echo -e "Node.js version: ${BLUE}$(node --version 2>/dev/null || echo 'Not installed')${NC}"

echo -e "npm version: ${BLUE}$(npm --version 2>/dev/null || echo 'Not installed')${NC}"

echo -e "jq version: ${BLUE}$(jq --version 2>/dev/null || echo 'Not installed')${NC}"

echo ""

# Check prerequisites

echo -e "${YELLOW}Checking Prerequisites${NC}"

echo "====================="

missing_deps=0

if ! command -v go &> /dev/null; then

echo -e "${RED}✗ Go is not installed${NC}"

missing_deps=1

fi

if ! command -v node &> /dev/null; then

echo -e "${RED}✗ Node.js is not installed (required for everything server)${NC}"

missing_deps=1

fi

if ! command -v npm &> /dev/null; then

echo -e "${RED}✗ npm is not installed (required for everything server)${NC}"

missing_deps=1

fi

if ! command -v jq &> /dev/null; then

echo -e "${RED}✗ jq is not installed (required for E2E tests)${NC}"

missing_deps=1

fi

if [ $missing_deps -eq 1 ]; then

echo ""

echo -e "${RED}Missing required dependencies. Please install them and try again.${NC}"

exit 1

fi

echo -e "${GREEN}✓ All prerequisites satisfied${NC}"

echo ""

# Stage 1: Build

run_test_stage "Build mcpproxy binary" \

"go build -o mcpproxy ./cmd/mcpproxy" \

"required"

# Stage 2: Unit Tests (exclude E2E tests that run in dedicated stages)

run_test_stage "Unit tests" \

"go test ./internal/... -v -race -timeout=5m -skip '^Test(E2E_|Binary|MCPProtocol)'" \

"required"

# Stage 3: Unit Tests with Coverage (exclude E2E tests that run in dedicated stages)

run_test_stage "Unit tests with coverage" \

"go test -coverprofile=$COVERAGE_FILE -covermode=atomic ./internal/... -timeout=5m -skip '^Test(E2E_|Binary|MCPProtocol)'" \

"optional"

# Generate coverage report if coverage file exists

if [ -f "$COVERAGE_FILE" ]; then

echo -e "${YELLOW}Generating coverage report...${NC}"

go tool cover -html="$COVERAGE_FILE" -o "$COVERAGE_HTML"

echo -e "${GREEN}Coverage report generated: $COVERAGE_HTML${NC}"

# Show coverage summary

echo -e "${YELLOW}Coverage Summary:${NC}"

go tool cover -func="$COVERAGE_FILE" | tail -1

echo ""

fi

# Stage 4: Linting

run_test_stage "Code linting" \

"./scripts/run-linter.sh" \

"optional"

# Stage 5: Original E2E Tests (internal mocks)

run_test_stage "Original E2E tests (mocked)" \

"./scripts/run-e2e-tests.sh" \

"required"

# Stage 6: API E2E Tests (with everything server)

run_test_stage "API E2E tests (with everything server)" \

"./scripts/test-api-e2e.sh" \

"required"

# Stage 7: Binary E2E Tests

run_test_stage "Binary E2E tests" \

"go test ./internal/server -run TestBinary -v -timeout=10m" \

"required"

# Stage 8: MCP Protocol E2E Tests

run_test_stage "MCP Protocol E2E tests" \

"go test ./internal/server -run TestMCP -v -timeout=10m" \

"required"

# Stage 9: Performance/Load Tests (optional)

run_test_stage "Performance tests" \

"go test ./internal/server -run TestBinaryPerformance -v -timeout=5m" \

"optional"

# Final cleanup

cleanup

# Results Summary

echo ""

echo -e "${YELLOW}Test Suite Summary${NC}"

echo "=================="

echo -e "Total test stages: ${BLUE}$TOTAL_TESTS${NC}"

echo -e "Passed stages: ${GREEN}$PASSED_TESTS${NC}"

echo -e "Failed stages: ${RED}$FAILED_TESTS${NC}"

if [ $FAILED_TESTS -eq 0 ]; then

echo ""

echo -e "${GREEN}🎉 ALL TESTS PASSED! 🎉${NC}"

echo -e "${GREEN}The code is ready for commit/deployment.${NC}"

if [ -f "$COVERAGE_FILE" ]; then

echo ""

echo -e "${YELLOW}Coverage report available at: $COVERAGE_HTML${NC}"

fi

exit 0

else

echo ""

echo -e "${RED}⚠️ $FAILED_TESTS stage(s) failed${NC}"

# Check if any required stages failed

required_failed=false

if [ $FAILED_TESTS -gt 0 ]; then

# Since we exit on required failures, any failures here are optional

echo -e "${YELLOW}All failures were in optional stages.${NC}"

echo -e "${YELLOW}Core functionality is working, but some optimizations may be needed.${NC}"

fi

exit 1

fi