Add local integration test for stable tests (#20)

- TCLI_INTEGRATION=1 to run integration.
- currently turned on in `make test`

Author: ppadmavilasom

Makefile

@@ -39,7 +39,7 @@ lint:
 	./tools/run_linter.sh
 
 test:
-	go test ./...
+	TCLI_INTEGRATION=1 go test ./...
 
 docker:
 	docker build -t $(IMAGE) -f tools/Dockerfile .

internal/petstoretest/server.go

@@ -0,0 +1,130 @@
+// Copyright (c) 2025-2026 HP Development Company, L.P.
+// SPDX-License-Identifier: MIT
+
+// Package petstoretest provides an in-memory HTTP server that implements
+// the subset of the Swagger Petstore API tcli's example pipelines exercise.
+// Intended for CI integration tests replaces the external
+// petstore.swagger.io dependency with a fast, deterministic local server.
+package petstoretest
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strconv"
+	"sync"
+)
+
+// Pet mirrors the minimal shape addPet accepts and getPetById returns.
+// Fields not used by tcli pipelines are not included.
+type Pet struct {
+	ID        int64    `json:"id"`
+	Name      string   `json:"name"`
+	PhotoUrls []string `json:"photoUrls"`
+	Status    string   `json:"status,omitempty"`
+	Tags      []any    `json:"tags"`
+	Category  any      `json:"category,omitempty"`
+}
+
+// apiResponse mirrors the real petstore's ApiResponse envelope, used for
+// delete confirmation and 404 replies.
+type apiResponse struct {
+	Code    int    `json:"code"`
+	Type    string `json:"type"`
+	Message string `json:"message"`
+}
+
+// NewServer returns a running httptest.Server serving the pet endpoints
+// under `/v2/`. Callers must call Close(). Each server has its own
+// in-memory store, so tests are isolated from one another.
+func NewServer() *httptest.Server {
+	st := &store{pets: make(map[int64]*Pet)}
+	mux := http.NewServeMux()
+	mux.HandleFunc("POST /v2/pet", st.addPet)
+	mux.HandleFunc("GET /v2/pet/findByStatus", st.findByStatus)
+	mux.HandleFunc("GET /v2/pet/{petId}", st.getPetByID)
+	mux.HandleFunc("DELETE /v2/pet/{petId}", st.deletePet)
+	return httptest.NewServer(mux)
+}
+
+type store struct {
+	mu   sync.Mutex
+	pets map[int64]*Pet
+}
+
+func (s *store) addPet(w http.ResponseWriter, r *http.Request) {
+	var pet Pet
+	if err := json.NewDecoder(r.Body).Decode(&pet); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	// Default an empty status so findByStatus behaves predictably when the
+	// caller omits it (the real petstore does the same coercion in practice).
+	if pet.Status == "" {
+		pet.Status = "available"
+	}
+	if pet.Tags == nil {
+		pet.Tags = []any{}
+	}
+	s.mu.Lock()
+	s.pets[pet.ID] = &pet
+	s.mu.Unlock()
+	writeJSON(w, http.StatusOK, pet)
+}
+
+func (s *store) getPetByID(w http.ResponseWriter, r *http.Request) {
+	id, err := strconv.ParseInt(r.PathValue("petId"), 10, 64)
+	if err != nil {
+		http.Error(w, "invalid petId", http.StatusBadRequest)
+		return
+	}
+	s.mu.Lock()
+	pet, ok := s.pets[id]
+	s.mu.Unlock()
+	if !ok {
+		writeJSON(w, http.StatusNotFound, apiResponse{
+			Code: 1, Type: "error", Message: "Pet not found",
+		})
+		return
+	}
+	writeJSON(w, http.StatusOK, pet)
+}
+
+// deletePet mirrors the real petstore's response: the `message` field
+// carries the deleted id back, which the CRUD pipeline relies on for its
+// `{petId:.message}` format expression to chain into verify_gone.
+func (s *store) deletePet(w http.ResponseWriter, r *http.Request) {
+	idStr := r.PathValue("petId")
+	id, err := strconv.ParseInt(idStr, 10, 64)
+	if err != nil {
+		http.Error(w, "invalid petId", http.StatusBadRequest)
+		return
+	}
+	s.mu.Lock()
+	delete(s.pets, id)
+	s.mu.Unlock()
+	writeJSON(w, http.StatusOK, apiResponse{
+		Code: 200, Type: "unknown", Message: idStr,
+	})
+}
+
+func (s *store) findByStatus(w http.ResponseWriter, r *http.Request) {
+	want := r.URL.Query().Get("status")
+	s.mu.Lock()
+	// Always return [] (never null) so the pipeline runner's array-flatten
+	// logic sees a well-formed JSON array even when no pets match.
+	out := make([]*Pet, 0, len(s.pets))
+	for _, p := range s.pets {
+		if want == "" || p.Status == want {
+			out = append(out, p)
+		}
+	}
+	s.mu.Unlock()
+	writeJSON(w, http.StatusOK, out)
+}
+
+func writeJSON(w http.ResponseWriter, status int, v any) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	_ = json.NewEncoder(w).Encode(v)
+}

internal/petstoretest/server_test.go

@@ -0,0 +1,108 @@
+// Copyright (c) 2025-2026 HP Development Company, L.P.
+// SPDX-License-Identifier: MIT
+
+package petstoretest
+
+import (
+	"bytes"
+	"encoding/json"
+	"io"
+	"net/http"
+	"strings"
+	"testing"
+)
+
+// Sanity tests for the fake server. These run every time (no gate) because
+// they are self-contained and fast no external tcli invocation involved.
+
+func TestServer_AddThenGet(t *testing.T) {
+	srv := NewServer()
+	defer srv.Close()
+
+	got := doJSON(t, srv.URL, "POST", "/v2/pet", `{"id":7,"name":"a","photoUrls":["x"]}`)
+	if got["id"] != float64(7) {
+		t.Errorf("addPet returned id=%v, want 7", got["id"])
+	}
+	got = doJSON(t, srv.URL, "GET", "/v2/pet/7", "")
+	if got["name"] != "a" {
+		t.Errorf("getPetById returned name=%v, want a", got["name"])
+	}
+}
+
+func TestServer_GetMissingReturns404(t *testing.T) {
+	srv := NewServer()
+	defer srv.Close()
+	resp := do(t, srv.URL, "GET", "/v2/pet/999", "")
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusNotFound {
+		t.Errorf("status = %d, want 404", resp.StatusCode)
+	}
+}
+
+func TestServer_DeleteThenGet404(t *testing.T) {
+	srv := NewServer()
+	defer srv.Close()
+	doJSON(t, srv.URL, "POST", "/v2/pet", `{"id":1,"name":"x","photoUrls":[]}`)
+	got := doJSON(t, srv.URL, "DELETE", "/v2/pet/1", "")
+	if got["message"] != "1" {
+		t.Errorf("deletePet.message = %v, want \"1\" (id echoed back)", got["message"])
+	}
+	resp := do(t, srv.URL, "GET", "/v2/pet/1", "")
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusNotFound {
+		t.Errorf("after delete, GET status = %d, want 404", resp.StatusCode)
+	}
+}
+
+func TestServer_FindByStatusReturnsArray(t *testing.T) {
+	srv := NewServer()
+	defer srv.Close()
+	doJSON(t, srv.URL, "POST", "/v2/pet", `{"id":1,"name":"a","photoUrls":[],"status":"available"}`)
+	doJSON(t, srv.URL, "POST", "/v2/pet", `{"id":2,"name":"b","photoUrls":[],"status":"sold"}`)
+
+	resp := do(t, srv.URL, "GET", "/v2/pet/findByStatus?status=available", "")
+	defer resp.Body.Close()
+	var arr []map[string]any
+	if err := json.NewDecoder(resp.Body).Decode(&arr); err != nil {
+		t.Fatalf("decode array: %v", err)
+	}
+	if len(arr) != 1 || arr[0]["id"] != float64(1) {
+		t.Errorf("findByStatus(available) = %+v, want single pet id=1", arr)
+	}
+}
+
+func do(t *testing.T, base, method, path, body string) *http.Response {
+	t.Helper()
+	var b io.Reader
+	if body != "" {
+		b = strings.NewReader(body)
+	}
+	req, err := http.NewRequest(method, base+path, b)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if body != "" {
+		req.Header.Set("Content-Type", "application/json")
+	}
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return resp
+}
+
+func doJSON(t *testing.T, base, method, path, body string) map[string]any {
+	t.Helper()
+	resp := do(t, base, method, path, body)
+	defer resp.Body.Close()
+	var buf bytes.Buffer
+	_, _ = io.Copy(&buf, resp.Body)
+	if resp.StatusCode >= 300 {
+		t.Fatalf("%s %s -> %d: %s", method, path, resp.StatusCode, buf.String())
+	}
+	var out map[string]any
+	if err := json.Unmarshal(buf.Bytes(), &out); err != nil {
+		t.Fatalf("decode %s %s: %v (body=%q)", method, path, err, buf.String())
+	}
+	return out
+}