CodeBlanks Logo Icon CodeBlanks
Login Register

Challenge 2 - HTTP service

Write a JSON-returning service with net/http.

Challenge: a notes API

You will write a small HTTP service that keeps notes in memory:

  • POST /notlar: adds a note with a {"metin":"..."} body and returns 201 with the added note (including its id). An empty text gives 400.
  • GET /notlar: returns all notes as a JSON array.
type Not struct {
    ID    int    `json:"id"`
    Metin string `json:"metin"`
}

The notes are kept in a slice protected by a sync.Mutex.

Plan

1) type Depo struct { mu sync.Mutex; notlar []Not; sonID int }. 2) mux.HandleFunc("POST /notlar", ...): decode the body, 400 if empty, otherwise lock, sonID++, append, 201 + JSON. 3) mux.HandleFunc("GET /notlar", ...): lock and write the list as JSON. 4) Send a POST and a GET with httptest and check the result.

Practice Build the service

Implement the plan. Send a POST with the body {"metin":"süt al"}, then print the body of the GET response.

Starter code

main.go
package main

import (
    "encoding/json"
    "fmt"
    "net/http"
    "net/http/httptest"
    "strings"
    "sync"
)

func main() {
    // buraya yaz
}

Sample solution

main.go
package main

import (
    "encoding/json"
    "fmt"
    "net/http"
    "net/http/httptest"
    "strings"
    "sync"
)

type Not struct {
    ID    int    `json:"id"`
    Metin string `json:"metin"`
}

type Depo struct {
    mu     sync.Mutex
    notlar []Not
    sonID  int
}

func main() {
    d := &Depo{notlar: []Not{}}
    mux := http.NewServeMux()
    mux.HandleFunc("POST /notlar", func(w http.ResponseWriter, r *http.Request) {
        var n Not
        if err := json.NewDecoder(r.Body).Decode(&n); err != nil || n.Metin == "" {
            http.Error(w, "geçersiz not", http.StatusBadRequest)
            return
        }
        d.mu.Lock()
        d.sonID++
        n.ID = d.sonID
        d.notlar = append(d.notlar, n)
        d.mu.Unlock()
        w.Header().Set("Content-Type", "application/json")
        w.WriteHeader(http.StatusCreated)
        json.NewEncoder(w).Encode(n)
    })
    mux.HandleFunc("GET /notlar", func(w http.ResponseWriter, r *http.Request) {
        d.mu.Lock()
        defer d.mu.Unlock()
        w.Header().Set("Content-Type", "application/json")
        json.NewEncoder(w).Encode(d.notlar)
    })

    mux.ServeHTTP(httptest.NewRecorder(), httptest.NewRequest("POST", "/notlar", strings.NewReader(`{"metin":"süt al"}`)))
    rec := httptest.NewRecorder()
    mux.ServeHTTP(rec, httptest.NewRequest("GET", "/notlar", nil))
    fmt.Print(rec.Body.String())
}

Expected output

[{"id":1,"metin":"süt al"}]

Questions and answers

Review the lesson questions together with their answers. To test yourself, solve the lesson interactively.

1 If you want the GET response to be <code>[]</code> instead of <code>null</code> when the list is empty, what do you do?

  • Add omitempty
  • Write the response as a string
  • It isn't possible
  • Initialize the slice with []Not{} Correct answer

Explanation: A nil slice encodes as null in JSON; an empty non-nil slice encodes as [].

2 Created code

Question 
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.____)
json.NewEncoder(w).Encode(n)
Answer 
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusCreated)
json.NewEncoder(w).Encode(n)

Explanation: 201 Created is returned when a new resource is added.

3 Request and response

Term Meaning
POST with valid text 201 + note
POST with empty text 400
GET 200 + array
PUT /notlar 405

All lessons in Intermediate

1 Goroutines

  1. What is a goroutine?
  2. The go keyword
  3. Goroutine and function
  4. The main goroutine
  5. Number of goroutines
  6. Summary - Goroutines

2 Channels

  1. What is a channel?
  2. Channel with make
  3. Sending data
  4. Receiving data
  5. Buffered channel
  6. Summary - Channels

3 Select

  1. What is select?
  2. Multiple channels
  3. default and non-blocking
  4. Select with timeout
  5. Closing a channel
  6. Summary - Select

4 sync package

  1. sync.Mutex
  2. sync.RWMutex
  3. sync.WaitGroup
  4. sync.Once
  5. sync.Pool
  6. Summary - sync package

5 Project: Concurrency

  1. Worker pool skeleton
  2. Job queue
  3. Collecting results
  4. Error handling

6 Context

  1. context.Background
  2. WithCancel
  3. WithTimeout
  4. WithValue
  5. WithDeadline
  6. Summary - Context

7 io package

  1. io.Reader
  2. io.Writer
  3. os.Stdin and os.Stdout
  4. bufio.Scanner
  5. io.Copy
  6. Summary - io package

8 Testing

  1. Test function
  2. t.Error and t.Fatal
  3. Table-driven tests
  4. Test helpers
  5. Example tests
  6. Summary - Testing

9 Benchmark

  1. Benchmark function
  2. b.ResetTimer
  3. Memory benchmark
  4. Sub-benchmark
  5. Comparing benchmarks
  6. Summary - Benchmark

10 fmt package

  1. fmt.Printf
  2. Format verbs
  3. fmt.Sprintf
  4. fmt.Errorf
  5. fmt.Fprintln
  6. Summary - fmt package

11 encoding/json

  1. The encoding/json package
  2. Struct tags
  3. Marshal and Unmarshal
  4. Encoder and Decoder
  5. JSON and map
  6. Summary - encoding/json

12 net/http

  1. Client with net/http
  2. http.Get
  3. http.Handler
  4. http.HandleFunc
  5. JSON API
  6. Summary - net/http

13 flag package

  1. The flag package
  2. flag.String and flag.Int
  3. flag.Parse
  4. Subcommand
  5. os.Args
  6. Summary - flag package

14 Intermediate final

  1. Challenge 1 - Concurrency
  2. Challenge 2 - HTTP service
  3. Challenge 3 - Test and benchmark
  4. Challenge 4 - CLI tool