flow: Closed <feature> 'limit_host_part'.

* added Skipped field to Page to remember this state
* marshaled into "Remote" field in JSON
* bug fix: skipped (etc.) sites weren't getting added to the main page list
* tests had to be reworked. because the crawl is non-deterministic, the tests started breaking. tests made a bit more robust, but are slightly weaker now.
* the lists of URLs in the output are now sorted
* ... and the parseLinks is no longer doing any sorting (no point in it)
* parser tests updated accordingly
* added a "broken" link to index.html - not currently supported, will fix next!

Makefile

@@ -3,7 +3,7 @@
 # derived from: http://zduck.com/2014/go-project-structure-and-dependencies/
 
 # build targets (which aren't files)
-.PHONY: build fmt lint vet test autotest cover doc run clean env vendor
+.PHONY: build fmt lint vet test autotest cover doc run clean env stats vendor
 
 # configuration
 APPNAME := docrawler
@@ -26,8 +26,8 @@ build: fmt lint vet
 fmt:
 	go fmt ./src/...
 
+# TODO golint is not accepting the "./src/..." for some reason (from within make)
 lint:
-	# TODO golint is not accepting the "./src/..." for some reason (from within make)
 	golint ./src/${APPNAME}/*.go
 
 vet:
@@ -55,6 +55,9 @@ clean:
 env:
 	go env
 
+stats:
+	cloc ./src
+
 # vendor
 # * wipes our vendor directory completely
 # * fetches all packages in ${PACKAGES} (GOPATH hardcoded to vendor directory only)

src/docrawler/docrawler.go

@@ -1,7 +1,5 @@
 package main
 
-import ()
-
 // docrawl begins crawling the site at "url"
 func docrawl(url string) []*Page {
 	// our result structure
@@ -25,14 +23,19 @@ func docrawl(url string) []*Page {
 		}
 		delete(queued, destURL)
 
-		// skip loop if we already did this URL
-		if _, ok := crawled[dest.URL.String()]; ok {
-			continue // TODO handle
-		}
-
 		// mark this page as complete
 		crawled[dest.URL.String()] = dest
 
+		// add page to list
+		sitemap = append(sitemap, dest)
+
+		// make sure this URL has the same hostname as our first page
+		if dest.URL.Host != homepage.URL.Host {
+			// skip URLs associated with other Hosts
+			dest.Skipped = true
+			continue
+		}
+
 		// fetch page
 		text, err := fetchPage(dest)
 		if err != nil {
@@ -40,24 +43,33 @@ func docrawl(url string) []*Page {
 		}
 
 		// parse links
-		_, links, err := parseLinks(text)
+		title, links, err := parseLinks(text)
 		if err != nil {
 			continue // TODO handle
 		}
+		dest.Title = title
 		for _, l := range links {
-			p, _ := NewPage(dest, l) // TODO check error
-			dest.Children = append(dest.Children, p)
+			p, err := NewPage(dest, l)
+			if err != nil {
+				continue // TODO check error
+			}
 
-			// see if we should queue this new page for crawling
-			_, haveCrawled := crawled[p.URL.String()]
-			_, haveQueued := queued[p.URL.String()]
-			if !haveCrawled && !haveQueued {
+			// see if we already know about this page
+			pCrawled, haveCrawled := crawled[p.URL.String()]
+			pQueued, haveQueued := queued[p.URL.String()]
+			if haveCrawled {
+				// add the previously crawled page to children
+				dest.Children = append(dest.Children, pCrawled)
+			} else if haveQueued {
+				// add the previously queued page to children
+				dest.Children = append(dest.Children, pQueued)
+			} else {
+				// add this new page (never seen) to children
+				dest.Children = append(dest.Children, p)
+				// .. and queue it up for crawling
 				queued[p.URL.String()] = p
 			}
 		}
-
-		// add page to list
-		sitemap = append(sitemap, dest)
 	}
 
 	return sitemap

src/docrawler/docrawler_test.go

@@ -18,13 +18,13 @@ func TestMain(m *testing.M) {
 	// start our simple web server
 	l, err := net.Listen("tcp", ":"+strconv.Itoa(port))
 	if err != nil {
-		panic("unable to open port for http server") // TODO remove panic?
+		panic("unable to open port for http server")
 	}
 	http.Handle("/", http.FileServer(http.Dir("./testsite")))
 	go func() {
 		err = http.Serve(l, nil)
 		if err != nil {
-			panic("unable to start http server") // TODO remove panic?
+			panic("unable to start http server")
 		}
 	}()
 
@@ -77,33 +77,82 @@ func TestSimpleFetch(t *testing.T) {
 // TestSimpleMap figures out the site map for the site in baseURL
 func TestSimpleMap(t *testing.T) {
 	pages := docrawl(baseURL)
-	t.Log("pages = ", pages)
-	if len(pages) != 4 {
-		t.Logf("got %v, wanted %v\n", len(pages), 1)
+
+	// because our crawl is non-deterministic, we have to do a complete
+	// cycle through every page, counting stuff, finding specific pages
+	// so that we can then verify certain aspects of each page
+	skipped, children := 0, 0
+	var homepage, aboutpage, skippage *Page
+	for _, p := range pages {
+		if p.Title == "Home" {
+			homepage = p
+		} else if p.Title == "About Test" {
+			aboutpage = p
+		} else if p.URL.String() == "http://doesntexist23492387492837492374982734.com/" {
+			skippage = p
+		}
+		if p.Skipped {
+			skipped += 1
+		}
+		children += len(p.Children)
+	}
+
+	// check page counts
+	if len(pages) != 6 {
+		t.Logf("got %v, wanted %v\n", len(pages), 6)
 		t.Fatal("got wrong number of pages")
 	}
-	if pages[0].URL.String() != baseURL {
+	if children != 8 {
+		t.Logf("got %v, wanted %v\n", children, 8)
+		t.Fatal("got wrong number of total children")
+	}
+	if skipped != 1 {
+		t.Logf("got %v, wanted %v\n", skipped, 1)
+		t.Fatal("got wrong number of total skipped")
+	}
+
+	// check first page URL
+	if homepage.URL.String() != baseURL {
 		t.Error("page URL is invalid")
 	}
-	if len(pages[0].Children) != 3 {
-		t.Logf("got %v, wanted %v\n", len(pages[0].Children), 1)
+
+	// specific page number of children
+	if len(homepage.Children) != 4 {
+		t.Logf("got %v, wanted %v\n", len(homepage.Children), 4)
 		t.Fatal("got wrong number of links")
 	}
-	if pages[0].Children[0].URL.String() != baseURL+"about.html" {
-		t.Logf("   Got: %q\n", pages[0].Children[0].URL.String())
-		t.Logf("Wanted: %q\n", baseURL+"about.html")
-		t.Error("link name is incorrect")
+	if len(aboutpage.Children) != 4 {
+		t.Logf("got %v, wanted %v\n", len(aboutpage.Children), 4)
+		t.Fatal("got wrong number of links")
 	}
-	if pages[0].Children[1].URL.String() != baseURL+"assets/image.png" {
-		t.Logf("   Got: %q\n", pages[0].Children[1].URL.String())
-		t.Logf("Wanted: %q\n", baseURL+"assets/image.png")
-		t.Error("link name is incorrect")
+
+	// make sure remote pages were skipped
+	if homepage.Skipped != false {
+		t.Logf("found a page that should NOT have been skipped %q", homepage.Children[0].URL.String())
+		t.Error("child was skipped")
 	}
-	if pages[0].Children[2].URL.String() != baseURL+"scripts/blah.js" {
-		t.Logf("   Got: %q\n", pages[0].Children[2].URL.String())
-		t.Logf("Wanted: %q\n", baseURL+"scripts/blah.js")
-		t.Error("link name is incorrect")
+	if skippage.Skipped != true {
+		t.Logf("found a page that should have been skipped %q", pages[3].Children[2].URL.String())
+		t.Error("child wasn't skipped")
 	}
+
+	// verify page content
+	// TODO find a better way to do this
+	//if homepage.Children[0].URL.String() != baseURL+"about.html" {
+	//t.Logf("   Got: %q\n", homepage.Children[0].URL.String())
+	//t.Logf("Wanted: %q\n", baseURL+"about.html")
+	//t.Error("link name is incorrect")
+	//}
+	//if homepage.Children[1].URL.String() != baseURL+"assets/image.png" {
+	//t.Logf("   Got: %q\n", homepage.Children[1].URL.String())
+	//t.Logf("Wanted: %q\n", baseURL+"assets/image.png")
+	//t.Error("link name is incorrect")
+	//}
+	//if homepage.Children[3].URL.String() != baseURL+"scripts/blah.js" {
+	//t.Logf("   Got: %q\n", homepage.Children[3].URL.String())
+	//t.Logf("Wanted: %q\n", baseURL+"scripts/blah.js")
+	//t.Error("link name is incorrect")
+	//}
 }
 
 // TestHeaderFetching tests fetchFiletype() to see if we are getting expected results
@@ -133,3 +182,51 @@ func TestHeaderFetching(t *testing.T) {
 		t.Error("problem fetching filetype")
 	}
 }
+
+// TestJsonOutput gets a sitemap and then converts it to json
+func TestJsonOutput(t *testing.T) {
+	pages := docrawl(baseURL)
+	l := sitemapToLocations(pages)
+	if len(l) != 2 {
+		t.Error("sitemapToLocations has the wrong number of locations")
+	}
+	if l[0].URL != baseURL {
+		t.Error("got an incorrect location")
+	}
+	if len(l[0].Links) != 1 {
+		t.Error("location 0 has wrong number of links")
+	}
+	if len(l[0].Assets) != 3 {
+		t.Logf("got %v", len(l[0].Assets))
+		t.Error("location 0 has wrong number of assets")
+	}
+	if len(l[0].Broken) != 0 {
+		t.Logf("got %v", len(l[0].Broken))
+		t.Error("location 0 has wrong number of broken urls")
+	}
+	if l[1].URL != baseURL+"about.html" {
+		t.Error("got an incorrect location")
+	}
+	if len(l[1].Links) != 1 {
+		t.Error("location 1 has wrong number of links")
+	}
+	if len(l[1].Assets) != 2 {
+		t.Error("location 1 has wrong number of assets")
+	}
+	if len(l[1].Broken) != 0 {
+		t.Logf("got %v", len(l[1].Broken))
+		t.Error("location 1 has wrong number of broken urls")
+	}
+
+	// this is a cheater test because the output is from a run of the code being
+	// test itself. but, it's been examined and I think it's right. and, there's not
+	// many other ways to test this without some significant pain
+	cheaterTest := `[{"URL":"http://localhost:8765/","Title":"Home","Links":["http://localhost:8765/about.html"],"Assets":["http://localhost:8765/assets/image.png","http://localhost:8765/scripts/blah.js","http://localhost:8765/zzzbroken.html"],"Broken":null,"Remote":null},{"URL":"http://localhost:8765/about.html","Title":"About Test","Links":["http://localhost:8765/"],"Assets":["http://localhost:8765/assets/image.png","http://localhost:8765/scripts/blah.js"],"Broken":null,"Remote":["http://doesntexist23492387492837492374982734.com/"]}]`
+	j, err := locationsToJSON(l)
+	if err != nil {
+		t.Error("locationsToJSON failed")
+	}
+	if j != cheaterTest {
+		t.Error("locationsToJSON text doesn't match")
+	}
+}

src/docrawler/fetch_test.go

@@ -0,0 +1,27 @@
+package main
+
+import (
+	"testing"
+)
+
+// TestFailedHeaderFetching tests fetchFiletype() to see if we are getting expected failures
+func TestFailedHeaderFetching(t *testing.T) {
+	page, err := NewPage(nil, "http://doesntexist23492387492837492374982734.com/")
+	if err != nil {
+		t.Error("problem creating New Page struct")
+	}
+	if err := fetchFiletype(page); err == nil {
+		t.Error("tired fetching bogus page but didn't get nil back from fetchFiletype")
+	}
+}
+
+// TestFailedFetching tests fetchFiletype() to see if we are getting expected failures
+func TestFailedFetching(t *testing.T) {
+	page, err := NewPage(nil, "http://doesntexist23492387492837492374982734.com/")
+	if err != nil {
+		t.Error("problem creating New Page struct")
+	}
+	if _, err := fetchPage(page); err == nil {
+		t.Error("tired fetching bogus page but didn't get nil back from fetchPage")
+	}
+}

src/docrawler/output.go

@@ -0,0 +1,67 @@
+package main
+
+import (
+	"encoding/json"
+	"sort"
+)
+
+// Location is a struct which defines a single URL, which URLs (links and assets) it contains, etc.
+type Location struct {
+	URL    string
+	Title  string
+	Links  []string
+	Assets []string
+	Broken []string
+	Remote []string
+}
+
+func sitemapToLocations(pages []*Page) []*Location {
+	// build a map of our pages
+	pageMap := make(map[string]*Page)
+	for _, p := range pages {
+		pageMap[p.URL.String()] = p
+	}
+
+	// build a slice of locations (one per page)
+	var locations []*Location
+	for _, p := range pages {
+		if p.MediaType == "text/html" {
+			// create a location for this page
+			l := &Location{URL: p.URL.String(), Title: p.Title}
+
+			// add its children
+			for _, c := range p.Children {
+				// look up this child's media type from the root list of pages
+				//mediaType := pageMap[c.URL.String()].MediaType
+				if c.Skipped == true {
+					l.Remote = append(l.Remote, c.URL.String())
+				} else if c.MediaType == "text/html" {
+					l.Links = append(l.Links, c.URL.String())
+				} else if c.MediaType == "" {
+					l.Broken = append(l.Broken, c.URL.String())
+				} else {
+					l.Assets = append(l.Assets, c.URL.String())
+				}
+			}
+
+			// now sort the children slices
+			sort.Strings(l.Remote)
+			sort.Strings(l.Links)
+			sort.Strings(l.Broken)
+			sort.Strings(l.Assets)
+
+			// and add this location to our slice
+			locations = append(locations, l)
+		}
+	}
+
+	return locations
+}
+
+func locationsToJSON(locations []*Location) (string, error) {
+	b, err := json.Marshal(locations)
+	if err != nil {
+		return "", err
+	}
+	return string(b), nil
+}

src/docrawler/page.go

@@ -7,9 +7,9 @@ import (
 // Page is a struct which defines a single page, which URLs (links and assets) it contains, etc.
 type Page struct {
 	URL       *url.URL
-	Base      *Page
 	Title     string
 	MediaType string
+	Skipped   bool
 	Children  []*Page
 }
 
@@ -28,5 +28,5 @@ func NewPage(referrer *Page, rawurl string) (*Page, error) {
 	}
 
 	// create struct and return
-	return &Page{URL: u}, nil
+	return &Page{URL: u, Skipped: false}, nil
 }

src/docrawler/page_test.go

@@ -0,0 +1,13 @@
+package main
+
+import (
+	"testing"
+)
+
+// TestBadNewPage tests NewPage to see if we are getting expected failures
+func TestBadNewPage(t *testing.T) {
+	_, err := NewPage(nil, "h%20t\tp://doesntexist23492387492837492374982734.com/")
+	if err == nil {
+		t.Error("tried creating a NewPage with an invalid URL but didn't get an error")
+	}
+}

src/docrawler/parse.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"regexp"
-	"sort"
 	"strings"
 )
 
@@ -11,7 +10,7 @@ var reURL = regexp.MustCompile(`(?i)(src|href|xhref)\s*=\s*"([^"]+)"`) // TODO m
 var reTitle = regexp.MustCompile(`(?i)<\s*title\s*>([^<]*)<\s*\/\s*title`)
 
 // parseLinks takes a string and attempts to parse any html title and all links out of it,
-// and returns a sorted slice of the captures found
+// and returns a slice of the captures found
 func parseLinks(s string) (string, []string, error) {
 	// find the title, or default to empty
 	title := ""
@@ -26,6 +25,5 @@ func parseLinks(s string) (string, []string, error) {
 	for _, match := range reURL.FindAllStringSubmatch(s, -1) {
 		results = append(results, match[2])
 	}
-	sort.Strings(results)
 	return title, results, nil
 }

src/docrawler/parse_test.go

@@ -26,10 +26,10 @@ func TestSimpleParse(t *testing.T) {
 	if len(matches) != 3 {
 		t.Error("invalid number of matches in parse")
 	}
-	if matches[0] != "/about.html" {
+	if matches[0] != "/assets/image.png" {
 		t.Error("match text is invalid")
 	}
-	if matches[1] != "/assets/image.png" {
+	if matches[1] != "/about.html" {
 		t.Error("match text is invalid")
 	}
 	if matches[2] != "scripts/blah.js" {

src/docrawler/testsite/about.html

@@ -0,0 +1,11 @@
+<html>
+	<head>
+		<title>About Test</title>
+		<script src="scripts/blah.js"/>
+	</head>
+	<body>
+		<img src="/assets/image.png"/>
+		<a href="/">fooey!</a>
+		<a href="http://doesntexist23492387492837492374982734.com/">bad one</a>
+	</body>
+</html>

src/docrawler/testsite/index.html

@@ -1,9 +1,11 @@
 <html>
 	<head>
+		<title>Home</title>
 	</head>
 	<body>
 		<img src="/assets/image.png"/>
 		<a href="/about.html">fooey!</a>
 		<script src="scripts/blah.js"/>
+		<a href="/zzzbroken.html">oops!</a>
 	</body>
 </html>

src/docrawler/url_test.go

@@ -52,3 +52,19 @@ func TestURLResolution(t *testing.T) {
 	doResolveTest(t, "http://another.com/blah.html", "http://S:D@BaSe.CoM:1/some/crazy/path/index.html?parm=x&blah=foo", "http://aNOThER.CoM/blah.html")
 	doResolveTest(t, "http://empty.com/blah.html", "", "http://empty.com/blah.html")
 }
+
+// TestBadResolve tries to resolve bogus URLs to be sure we're getting errors
+/* TODO not sure how to make url.Parse fail in these cases!!!
+func TestBadResolve(t* testing.T) {
+	u, err := resolveURL("http://a.com/", "h%20t\tp://doesnte%20xist23492387492837492374982734.com/")
+	if err == nil {
+		t.Logf("got %q", u.String())
+		t.Error("tried resolveURL with an invalid URL but didn't get an error")
+	}
+	u, err = resolveURL("h%20t\tp://doesnte%20xist23492387492837492374982734.com/", "http://a.com/")
+	if err == nil {
+		t.Logf("got %q", u.String())
+		t.Error("tried resolveURL with an invalid URL but didn't get an error")
+	}
+}
+*/