// TestHTTPTrackerScrape verifies that the HTTP tracker scrape format is correct func TestHTTPTrackerScrape(t *testing.T) { log.Println("TestHTTPTrackerScrape()") // Generate mock data.FileRecord file := data.FileRecord{ InfoHash: "6465616462656566", Verified: true, } // Save mock file if !file.Save() { t.Fatalf("Failed to save mock file") } // Store file in slice files := make([]data.FileRecord, 0) files = append(files[:], file) // Create a HTTP tracker, trigger a scrape tracker := HTTPTracker{} res := tracker.Scrape(files) log.Println(string(res)) // Unmarshal response scrape := scrapeResponse{} if err := bencode.Unmarshal(bytes.NewReader(res), &scrape); err != nil { t.Fatalf("Failed to unmarshal bencode scrape response") } // Delete mock file if !file.Delete() { t.Fatalf("Failed to delete mock file") } }
// TestGetFilesJSON verifies that /api/files returns proper JSON output func TestGetFilesJSON(t *testing.T) { log.Println("TestGetFilesJSON()") // Load config config := common.LoadConfig() common.Static.Config = config // Generate mock data.FileRecord file := data.FileRecord{ InfoHash: "deadbeef", Verified: true, } // Save mock file if !file.Save() { t.Fatalf("Failed to save mock file") } // Load mock file to fetch ID file = file.Load(file.InfoHash, "info_hash") if file == (data.FileRecord{}) { t.Fatalf("Failed to load mock file") } // Request output JSON from API for this file var file2 data.FileRecord err := json.Unmarshal(getFilesJSON(file.ID), &file2) if err != nil { t.Fatalf("Failed to unmarshal result JSON for single file") } // Verify objects are the same if file.ID != file2.ID { t.Fatalf("ID, expected %d, got %d", file.ID, file2.ID) } // Request output JSON from API for all files var allFiles []data.FileRecord err = json.Unmarshal(getFilesJSON(-1), &allFiles) if err != nil { t.Fatalf("Failed to unmarshal result JSON for all files") } // Verify known file is in result set found := false for _, f := range allFiles { if f.ID == file.ID { found = true } } if !found { t.Fatalf("Expected file not found in all files result set") } // Delete mock file if !file.Delete() { t.Fatalf("Failed to delete mock file") } }
// TestUDPAnnounce verifies that the UDP tracker announce output format is correct func TestUDPAnnounce(t *testing.T) { log.Println("TestUDPAnnounce()") // Load config config := common.LoadConfig() common.Static.Config = config // Generate mock data.FileRecord file := data.FileRecord{ InfoHash: "6465616462656566", Verified: true, } // Save mock file if !file.Save() { t.Fatalf("Failed to save mock file") } // Generate fake announce query query := url.Values{} query.Set("info_hash", "deadbeef") query.Set("ip", "127.0.0.1") query.Set("port", "5000") query.Set("uploaded", "0") query.Set("downloaded", "0") query.Set("left", "0") query.Set("numwant", "50") // Create a UDP tracker, trigger an announce tracker := UDPTracker{TransID: uint32(1234)} res := tracker.Announce(query, file) // Decode response announce := new(udp.AnnounceResponse) err := announce.UnmarshalBinary(res) if err != nil { t.Fatalf("Failed to decode UDP announce response") } log.Println(announce) // Verify correct action if announce.Action != 1 { t.Fatalf("Incorrect UDP action, expected 1") } // Encode response, verify same as before announceBuf, err := announce.MarshalBinary() if err != nil { t.Fatalf("Failed to encode UDP announce response") } if !bytes.Equal(res, announceBuf) { t.Fatalf("Byte slices are not identical") } // Delete mock file if !file.Delete() { t.Fatalf("Failed to delete mock file") } }
// TestHTTPRouter verifies that the main HTTP router is working properly func TestHTTPRouter(t *testing.T) { log.Println("TestHTTPRouter()") // Load config config, err := common.LoadConfig() if err != nil { t.Fatalf("Could not load configuration: %s", err.Error()) } common.Static.Config = config // Generate mock data.FileRecord file := data.FileRecord{ InfoHash: "6465616462656566303030303030303030303030", Verified: true, } // Save mock file if err := file.Save(); err != nil { t.Fatalf("Failed to save mock file: %s", err.Error()) } // Generate mock data.FileRecord file2 := data.FileRecord{ InfoHash: "6265656664656164", Verified: true, } // Save mock file if err := file2.Save(); err != nil { t.Fatalf("Failed to save mock file: %s", err.Error()) } // Iterate all HTTP tests for _, test := range httpTests { // Generate mock HTTP request r, err := http.NewRequest("GET", "http://localhost:8080"+test.url, nil) r.Header.Set("User-Agent", "goat_test") if err != nil { t.Fatalf("Failed to create HTTP request") } // Capture HTTP writer response with recorder w := httptest.NewRecorder() // Invoke HTTP router parseHTTP(w, r) log.Println("TEST:", test.url) log.Println(w.Body.String()) } // Delete mock file2 err = file.Delete() err2 := file2.Delete() if err != nil || err2 != nil { t.Fatalf("Failed to delete mock file : %s %s", err.Error(), err2.Error()) } }
// TestUDPTrackerScrape verifies that the UDP tracker scrape format is correct func TestUDPTrackerScrape(t *testing.T) { log.Println("TestUDPTrackerScrape()") // Generate mock data.FileRecord file := data.FileRecord{ InfoHash: "6465616462656566", Verified: true, } // Save mock file if !file.Save() { t.Fatalf("Failed to save mock file") } // Store file in slice files := make([]data.FileRecord, 0) files = append(files[:], file) // Create a UDP tracker, trigger a scrape tracker := UDPTracker{TransID: uint32(1234)} res := tracker.Scrape(files) // Decode response scrape := new(udp.ScrapeResponse) err := scrape.UnmarshalBinary(res) if err != nil { t.Fatalf("Failed to decode UDP scrape response") } log.Println(scrape) // Verify correct action if scrape.Action != 2 { t.Fatalf("Incorrect UDP action, expected 2") } // Encode response, verify same as before scrapeBuf, err := scrape.MarshalBinary() if err != nil { t.Fatalf("Failed to encode UDP scrape response") } if !bytes.Equal(res, scrapeBuf) { t.Fatalf("Byte slices are not identical") } // Delete mock file if !file.Delete() { t.Fatalf("Failed to delete mock file") } }
// TestHTTPAnnounce verifies that the HTTP tracker announce output format is correct func TestHTTPAnnounce(t *testing.T) { log.Println("TestHTTPAnnounce()") // Load config config, err := common.LoadConfig() if err != nil { t.Fatalf("Could not load configuration: %s", err.Error()) } common.Static.Config = config // Generate mock data.FileRecord file := data.FileRecord{ InfoHash: "6465616462656566303030303030303030303030", Verified: true, } // Save mock file if err := file.Save(); err != nil { t.Fatalf("Failed to save mock file: %s", err.Error()) } // Generate fake announce query query := url.Values{} query.Set("info_hash", "deadbeef") query.Set("ip", "127.0.0.1") query.Set("port", "5000") query.Set("uploaded", "0") query.Set("downloaded", "0") query.Set("left", "0") // Create a HTTP tracker, trigger an announce tracker := HTTPTracker{} res := tracker.Announce(query, file) log.Println(string(res)) // Unmarshal response announce := AnnounceResponse{} if err := bencode.Unmarshal(bytes.NewReader(res), &announce); err != nil { t.Fatalf("Failed to unmarshal bencode announce response") } // Delete mock file if err := file.Delete(); err != nil { t.Fatalf("Failed to delete mock file: %s", err.Error()) } }
// TestUDPRouter verifies that the main UDP router is working properly func TestUDPRouter(t *testing.T) { log.Println("TestUDPRouter()") // Load config config, err := common.LoadConfig() if err != nil { t.Fatalf("Could not load configuration: %s", err.Error()) } common.Static.Config = config // Generate mock data.FileRecord file := data.FileRecord{ InfoHash: "6465616462656566303030303030303030303030", Verified: true, } // Save mock file if err := file.Save(); err != nil { t.Fatalf("Failed to save mock file: %s", err.Error()) } // Fake UDP address addr, err := net.ResolveUDPAddr("udp", "127.0.0.1:0") if err != nil { t.Fatalf("Failed to create fake UDP address") } // Connect packet with handshake connect := udp.Packet{udpInitID, 0, 1234} connectBuf, err := connect.MarshalBinary() if err != nil { t.Fatalf("Failed to create UDP connect packet") } // Perform connection handshake res, err := parseUDP(connectBuf, addr) if err != nil { errRes := new(udp.ErrorResponse) err2 := errRes.UnmarshalBinary(res) if err2 != nil { t.Fatalf(err.Error()) } log.Println("ERROR:", errRes.Error) t.Fatalf(err.Error()) } // Retrieve response, get new connection ID, which will be expected by router connRes := new(udp.ConnectResponse) err = connRes.UnmarshalBinary(res) if err != nil { t.Fatalf(err.Error()) } // Create announce request announce := udp.AnnounceRequest{ ConnID: connRes.ConnID, Action: 1, TransID: connRes.TransID, InfoHash: []byte("deadbeef000000000000"), PeerID: []byte("00001111222233334444"), Downloaded: 0, Left: 0, Uploaded: 0, IP: 0, Key: 1234, Port: 5000, } // Get announce bytes announceBuf, err := announce.MarshalBinary() if err != nil { t.Fatalf(err.Error()) } // Send announce to UDP router res, err = parseUDP(announceBuf, addr) if err != nil { errRes := new(udp.ErrorResponse) err2 := errRes.UnmarshalBinary(res) if err2 != nil { t.Fatalf(err.Error()) } log.Println("ERROR:", errRes.Error) t.Fatalf(err.Error()) } // Get UDP announce response announceRes := new(udp.AnnounceResponse) err = announceRes.UnmarshalBinary(res) if err != nil { errRes := new(udp.ErrorResponse) err2 := errRes.UnmarshalBinary(res) if err2 != nil { t.Fatalf(err.Error()) } log.Println("ERROR:", errRes.Error) t.Fatalf(err.Error()) } log.Println(announceRes) // Create scrape request scrape := udp.ScrapeRequest{ ConnID: connRes.ConnID, Action: 2, TransID: connRes.TransID, InfoHashes: [][]byte{[]byte("deadbeef000000000000")}, } // Get scrape bytes scrapeBuf, err := scrape.MarshalBinary() if err != nil { t.Fatalf(err.Error()) } // Send scrape to UDP router res, err = parseUDP(scrapeBuf, addr) if err != nil { errRes := new(udp.ErrorResponse) err2 := errRes.UnmarshalBinary(res) if err2 != nil { t.Fatalf(err.Error()) } log.Println("ERROR:", errRes.Error) t.Fatalf(err.Error()) } // Get UDP scrape response scrapeRes := new(udp.ScrapeResponse) err = scrapeRes.UnmarshalBinary(res) if err != nil { errRes := new(udp.ErrorResponse) err2 := errRes.UnmarshalBinary(res) if err2 != nil { t.Fatalf(err.Error()) } log.Println("ERROR:", errRes.Error) t.Fatalf(err.Error()) } log.Println(scrapeRes) // Delete mock file if err := file.Delete(); err != nil { t.Fatalf("Failed to delete mock file: %s", err.Error()) } }