test(control): share mockConn helper and add SCI PR summary bot

Author: MaurUppi

.github/workflows/policy-smart-sci.yml

@@ -22,7 +22,9 @@ on:
       - ".github/workflows/policy-smart-sci.yml"
   workflow_dispatch:
 
-permissions: read-all
+permissions:
+  contents: read
+  pull-requests: write
 
 jobs:
   sci-1:
@@ -140,3 +142,83 @@ jobs:
             echo "SCI-3 failed: no tests to run"
             exit 1
           fi
+
+  report:
+    name: SCI PR Comment
+    if: always() && github.event_name == 'pull_request'
+    needs: [sci-1, sci-2, sci-3]
+    runs-on: ubuntu-22.04
+    permissions:
+      contents: read
+      pull-requests: write
+    steps:
+      - name: Update PR Comment
+        uses: actions/github-script@v7
+        env:
+          SCI1_RESULT: ${{ needs.sci-1.result }}
+          SCI2_RESULT: ${{ needs.sci-2.result }}
+          SCI3_RESULT: ${{ needs.sci-3.result }}
+          RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+        with:
+          script: |
+            const marker = "<!-- dae-policy-smart-sci -->";
+            const toIcon = (result) => {
+              switch (result) {
+                case "success":
+                  return "✅";
+                case "failure":
+                  return "❌";
+                case "cancelled":
+                  return "⚪";
+                case "skipped":
+                  return "⏭️";
+                default:
+                  return "❔";
+              }
+            };
+
+            const jobs = [
+              { name: "SCI-1 Strategy Correctness", result: process.env.SCI1_RESULT || "unknown" },
+              { name: "SCI-2 TCP Retry Semantics", result: process.env.SCI2_RESULT || "unknown" },
+              { name: "SCI-3 Concurrency Race", result: process.env.SCI3_RESULT || "unknown" },
+            ];
+
+            const allSuccess = jobs.every((j) => j.result === "success");
+            const summary = allSuccess ? "pass" : "not pass";
+            const body = [
+              marker,
+              "## Policy Smart SCI",
+              "",
+              `- Summary: **${summary}**`,
+              `- Workflow run: ${process.env.RUN_URL}`,
+              "",
+              "### Job Status",
+              "",
+              ...jobs.map((j) => `- ${toIcon(j.result)} ${j.name}: \`${j.result}\``),
+            ].join("\n");
+
+            const { owner, repo } = context.repo;
+            const issue_number = context.issue.number;
+            const comments = await github.paginate(github.rest.issues.listComments, {
+              owner,
+              repo,
+              issue_number,
+              per_page: 100,
+            });
+
+            const existing = comments.find((c) => c.body && c.body.includes(marker));
+            if (existing) {
+              await github.rest.issues.updateComment({
+                owner,
+                repo,
+                comment_id: existing.id,
+                body,
+              });
+            } else {
+              await github.rest.issues.createComment({
+                owner,
+                repo,
+                issue_number,
+                body,
+              });
+            }

control/mock_conn_shared_test.go

@@ -0,0 +1,88 @@
+package control
+
+import (
+	"io"
+	"os"
+	"sync"
+	"time"
+
+	"github.com/daeuniverse/outbound/netproxy"
+)
+
+// Ensure mockConn implements netproxy.Conn.
+var _ netproxy.Conn = (*mockConn)(nil)
+
+// mockConn implements netproxy.Conn for control package tests.
+type mockConn struct {
+	readBlock  chan struct{}
+	readRetErr error
+	deadline   time.Time
+	mu         sync.Mutex
+	once       sync.Once
+	closed     bool
+}
+
+func newMockConn(block bool, retErr error) *mockConn {
+	m := &mockConn{
+		readBlock:  make(chan struct{}),
+		readRetErr: retErr,
+	}
+	if !block {
+		m.once.Do(func() {
+			close(m.readBlock)
+		})
+	}
+	return m
+}
+
+func (m *mockConn) Read(b []byte) (n int, err error) {
+	if m.closed {
+		return 0, io.EOF
+	}
+	<-m.readBlock
+
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if !m.deadline.IsZero() && m.deadline.Before(time.Now()) {
+		return 0, os.ErrDeadlineExceeded
+	}
+	if m.readRetErr != nil {
+		return 0, m.readRetErr
+	}
+	return 0, io.EOF
+}
+
+func (m *mockConn) Write(b []byte) (n int, err error) {
+	return len(b), nil
+}
+
+func (m *mockConn) Close() error {
+	m.closed = true
+	return nil
+}
+
+func (m *mockConn) SetDeadline(t time.Time) error {
+	return m.SetReadDeadline(t)
+}
+
+func (m *mockConn) SetReadDeadline(t time.Time) error {
+	m.mu.Lock()
+	m.deadline = t
+	m.mu.Unlock()
+
+	if !t.IsZero() && t.Before(time.Now()) {
+		m.once.Do(func() {
+			close(m.readBlock)
+		})
+	}
+	return nil
+}
+
+func (m *mockConn) SetWriteDeadline(time.Time) error {
+	return nil
+}
+
+func (m *mockConn) CloseWrite() error {
+	return nil
+}

control/tcp_test.go

@@ -2,97 +2,11 @@ package control
 
 import (
 	"errors"
-	"io"
 	"os"
-	"sync"
 	"testing"
 	"time"
-
-	"github.com/daeuniverse/outbound/netproxy"
 )
 
-// Ensure mockConn implements netproxy.Conn
-var _ netproxy.Conn = (*mockConn)(nil)
-
-// Mock connection implementing netproxy.Conn
-type mockConn struct {
-	readBlock  chan struct{}
-	readRetErr error
-	deadline   time.Time
-	mu         sync.Mutex
-	once       sync.Once
-	closed     bool
-}
-
-func newMockConn(block bool, retErr error) *mockConn {
-	m := &mockConn{
-		readBlock:  make(chan struct{}),
-		readRetErr: retErr,
-	}
-	if !block {
-		m.once.Do(func() {
-			close(m.readBlock)
-		})
-	}
-	return m
-}
-
-func (m *mockConn) Read(b []byte) (n int, err error) {
-	if m.closed {
-		return 0, io.EOF
-	}
-	<-m.readBlock
-
-	m.mu.Lock()
-	defer m.mu.Unlock()
-
-	// Check if deadline triggered
-	if !m.deadline.IsZero() && m.deadline.Before(time.Now()) {
-		return 0, os.ErrDeadlineExceeded
-	}
-
-	if m.readRetErr != nil {
-		return 0, m.readRetErr
-	}
-	return 0, io.EOF
-}
-
-func (m *mockConn) Write(b []byte) (n int, err error) {
-	return len(b), nil
-}
-
-func (m *mockConn) Close() error {
-	m.closed = true
-	return nil
-}
-
-func (m *mockConn) SetDeadline(t time.Time) error {
-	return m.SetReadDeadline(t)
-}
-
-func (m *mockConn) SetReadDeadline(t time.Time) error {
-	m.mu.Lock()
-	m.deadline = t
-	m.mu.Unlock()
-
-	// If deadline is in the past, unblock Read
-	if !t.IsZero() && t.Before(time.Now()) {
-		m.once.Do(func() {
-			close(m.readBlock)
-		})
-	}
-	return nil
-}
-
-func (m *mockConn) SetWriteDeadline(t time.Time) error {
-	return nil
-}
-
-// Satisfy WriteCloser interface check in RelayTCP
-func (m *mockConn) CloseWrite() error {
-	return nil
-}
-
 func TestRelayTCP_Cancellation(t *testing.T) {
 	// Scenario:
 	// lConn is blocked on Read.