pr3-ws202526/go/06-airport/airport/gate_test.go

package airport_test

import (
	"reflect"
	"sync"
	"testing"
	"time"

	"gitty.informatik.hs-mannheim.de/steger/pr3-code/go/06-airport/airport"
)

func TestGateSingleFlight(t *testing.T) {

	sut := airport.NewGate(airport.GateNumber(25), time.Duration(3*time.Millisecond), time.Duration(1*time.Millisecond))
	flight := airport.Flight{"LH123", "FRA", 25, time.Now().Add(5 * time.Millisecond), time.Now().Add(10 * time.Millisecond)}
	sut.SetFlights([]airport.Flight{
		flight,
	})
	go sut.Start()

	start := time.Now()
	wg := sync.WaitGroup{}

	//the aircraft
	wg.Add(1)
	ac := airport.NewAircraft(flight)
	departureTime := time.Now()
	go func() { sut.ProcessAircraft(&ac); departureTime = time.Now(); wg.Done() }()

	//the baggage
	wg.Add(1)
	baggage := airport.Baggage{[]string{"socks", "shirt"}}
	var bag1err error
	go func() { bag1err = sut.ProcessBaggage("LH123", baggage); wg.Done() }()

	//a passenger arriving on time
	wg.Add(1)
	ticket1 := airport.Ticket{"John Doe", "FRA", "LH123"}
	pax1 := airport.Passenger{"John Doe", ticket1, &airport.BoardingPass{ticket1, 25}, []airport.Baggage{}, []string{}}
	pax1boardingTime := time.Now()
	var pax1err error
	go func() { pax1err = sut.Process(pax1); pax1boardingTime = time.Now(); wg.Done() }()

	//another passenger arriving too late
	wg.Add(1)
	ticket2 := airport.Ticket{"Jane Doe", "FRA", "LH123"}
	pax2 := airport.Passenger{"Jane Doe", ticket2, &airport.BoardingPass{ticket2, 25}, []airport.Baggage{}, []string{}}
	var pax2err error
	go func() { time.Sleep(8 * time.Millisecond); pax2err = sut.Process(pax2); wg.Done() }()

	//another passenger arriving sometime during boarding
	wg.Add(1)
	ticket3 := airport.Ticket{"Alex Smith", "FRA", "LH123"}
	pax3 := airport.Passenger{"Alex Smith", ticket3, &airport.BoardingPass{ticket3, 25}, []airport.Baggage{}, []string{}}
	pax3boardingTime := time.Now()
	var pax3err error
	go func() {
		time.Sleep(6 * time.Millisecond)
		pax3err = sut.Process(pax3)
		pax3boardingTime = time.Now()
		wg.Done()
	}()

	//------------------------FROM HERE: checking ----------------------------------
	wg.Wait()

	//--------------------------check aircraft-------------------
	if elapsed := departureTime.Sub(start); elapsed < 11*time.Millisecond {
		t.Errorf("departure time too short: got %v, want at least 11ms", elapsed)
	}

	expectedBoardedPax := []airport.Passenger{pax1, pax3}
	if !reflect.DeepEqual(expectedBoardedPax, ac.Passengers) {
		t.Errorf("boarded passengers mismatch: got %v, want %v", ac.Passengers, expectedBoardedPax)
	}

	expectedBaggageOnboard := []airport.Baggage{baggage}
	if !reflect.DeepEqual(expectedBaggageOnboard, ac.Baggage) {
		t.Errorf("baggage on board mismatch: got %v, want %v", ac.Baggage, expectedBaggageOnboard)
	}

	//----------------------------check baggage--------------------

	if bag1err != nil {
		t.Errorf("baggage encountered an error during processing: %v", bag1err)
	}

	//--------------------------check passengers-------------------

	//boarding can only happen between boarding (5ms from start) and departure (10ms from start)
	if elapsed := pax1boardingTime.Sub(start); elapsed < 5*time.Millisecond || elapsed > 10*time.Millisecond {
		t.Errorf("passenger 1 boarding time out of range: got %v, want between 5ms and 10ms", elapsed)
	}

	if pax1err != nil {
		t.Errorf("passenger 1 encountered an error during boarding: %v", pax1err)
	}

	if pax2err == nil {
		t.Errorf("passenger 2 did not encounter an error during boarding, but was expected to")
	}

	//boarding can only happen after boarding (5ms from start)
	if elapsed := pax3boardingTime.Sub(start); elapsed < 5*time.Millisecond {
		t.Errorf("passenger 3 boarding time out of range: got %v, want more than 5ms", elapsed)
	}

	if pax3err != nil {
		t.Errorf("passenger 3 encountered an error during boarding: %v", pax3err)
	}

}