REST API

package main

import (
	"encoding/json"
	"fmt"
	"net/http"
	"strconv"
	"sync"
)

// Todo is one record. The JSON tags control the field names the client sees.
type Todo struct {
	ID   int    `json:"id"`
	Task string `json:"task"`
	Done bool   `json:"done"`
}

// Store holds the todos in memory. A mutex guards it because HTTP handlers
// can run concurrently — this is the piece Python's single-threaded
// http.server example does not need to worry about.
type Store struct {
	mu     sync.Mutex
	todos  map[int]Todo
	nextID int
}

func newStore() *Store {
	return &Store{todos: make(map[int]Todo), nextID: 1}
}

func (s *Store) create(task string) Todo {
	s.mu.Lock()
	defer s.mu.Unlock()
	todo := Todo{ID: s.nextID, Task: task, Done: false}
	s.todos[todo.ID] = todo
	s.nextID++
	return todo
}

func (s *Store) list() []Todo {
	s.mu.Lock()
	defer s.mu.Unlock()
	out := make([]Todo, 0, len(s.todos))
	for _, t := range s.todos {
		out = append(out, t)
	}
	return out
}

func (s *Store) delete(id int) bool {
	s.mu.Lock()
	defer s.mu.Unlock()
	if _, ok := s.todos[id]; !ok {
		return false
	}
	delete(s.todos, id)
	return true
}

func sendJSON(w http.ResponseWriter, status int, data any) {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(status)
	json.NewEncoder(w).Encode(data)
}

func main() {
	store := newStore()
	mux := http.NewServeMux()

	// GET /todos -> list every todo.
	mux.HandleFunc("GET /todos", func(w http.ResponseWriter, r *http.Request) {
		sendJSON(w, http.StatusOK, store.list())
	})

	// POST /todos -> create a todo from the JSON body.
	mux.HandleFunc("POST /todos", func(w http.ResponseWriter, r *http.Request) {
		var body struct {
			Task string `json:"task"`
		}
		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
			sendJSON(w, http.StatusBadRequest, map[string]string{"error": "invalid JSON body"})
			return
		}
		todo := store.create(body.Task)
		sendJSON(w, http.StatusCreated, todo)
	})

	// DELETE /todos/{id} -> remove that todo.
	mux.HandleFunc("DELETE /todos/{id}", func(w http.ResponseWriter, r *http.Request) {
		id, err := strconv.Atoi(r.PathValue("id"))
		if err != nil {
			sendJSON(w, http.StatusBadRequest, map[string]string{"error": "invalid id"})
			return
		}
		if store.delete(id) {
			sendJSON(w, http.StatusOK, map[string]int{"deleted": id})
		} else {
			sendJSON(w, http.StatusNotFound, map[string]string{"error": "not found"})
		}
	})

	fmt.Println("Listening on http://localhost:8000")
	http.ListenAndServe("localhost:8000", mux)
}

package main

import "testing"

func TestCreate(t *testing.T) {
	s := newStore()
	todo := s.create("Buy milk")
	if todo.ID != 1 {
		t.Errorf("todo.ID = %d; want 1", todo.ID)
	}
	if todo.Task != "Buy milk" {
		t.Errorf("todo.Task = %q; want %q", todo.Task, "Buy milk")
	}
	if todo.Done {
		t.Errorf("todo.Done = true; want false for a new todo")
	}
}

func TestDelete(t *testing.T) {
	s := newStore()
	todo := s.create("Walk the dog")
	if !s.delete(todo.ID) {
		t.Errorf("delete(%d) = false; want true", todo.ID)
	}
	if len(s.list()) != 0 {
		t.Errorf("list() after delete = %v; want empty", s.list())
	}
}

func TestDeleteMissing(t *testing.T) {
	s := newStore()
	if s.delete(99) {
		t.Errorf("delete(99) on empty store = true; want false")
	}
}

$ curl -X POST localhost:8000/todos -d '{"task":"Buy milk"}'
{"id":1,"task":"Buy milk","done":false}

$ curl localhost:8000/todos
[{"id":1,"task":"Buy milk","done":false}]

$ curl -X DELETE localhost:8000/todos/1
{"deleted":1}

// Jenkinsfile — runs the tests automatically every time the code changes.
pipeline {
    agent any                                  // run on any available machine

    stages {
        stage('Get the code') {
            steps { checkout scm }             // download the latest code
        }
        stage('Set up Go') {
            steps {
                sh 'go version'                                 // confirm Go is installed
                sh 'test -f go.mod || go mod init rest_api'  // create a module if none exists
            }
        }
        stage('Run the tests') {
            steps {
                sh 'go vet ./...'                    // catch obvious mistakes before running
                sh 'go test -v ./...'                // run every test, show each result
            }
        }
    }

    post {
        success { echo 'All tests passed.' }
        failure { echo 'A test failed — look above.' }
    }
}