GO :: ว่าด้วยเรื่องเครื่องมือสำหรับการตรวจสอบโค้ด

เมื่อเริ่มต้นพัฒนาระบบด้วยภาษา Go นั้น
สิ่งที่เราควรรู้และศึกษาก็คือ เครื่องมือต่างๆ ที่ Go เตรียมไว้ให้ใช้
เพื่อให้เข้าใจว่าเครื่องมือแต่ละอย่างมีไว้เพื่อประโยชน์อะไร
ดังนั้นเรามาดูกันว่ามีอะไรให้บ้าง

เครื่องมือที่ Go เตรียมไว้ให้ ประกอบไปด้วย
1. godoc
2. gofmt
3. gofix
หรือดูเพิ่มเติมได้จาก Go command
ซึ่งจะมีชุดโปรแกรมให้ใช้งานมากมาย เช่น

• การสร้างตัวติดตั้ง
• การ build code
• การทดสอบ

แต่มีเครื่องมือหนึ่งที่น่าสนใจก็คือ การตรวจสอบ Code coverage

คือ การตรวจดูว่า code ที่เราเขียนนั้น
มี code test คลุมหรือทดสอบมากน้อยเพียงใด

การใช้งานนั้นง่ายมาก

เริ่มต้นด้วยการสร้าง code และ code test ขึ้นมาก่อน
ดังตัวอย่าง

code หลักของเรา มี function Size สำหรับการแยกขนาด

ต่อมาคือ code test เพื่อนำมาทดสอบ code ใน size.go นั่นเอง

จากนั้นทำการ run คำสั่งเพื่อดูว่าค่า test coverage เป็นเท่าไร ด้วยคำสั่ง

$go test -cover

ผลที่ได้เป็นดังนี้

PASS
coverage: 42.9% of statements
ok       size     0.021s

จะพบว่ามีการทดสอบที่ครอบคลุม code อยู่ที่ 42% ซึ่งเป็นค่าที่ต่ำพอสมควร
แต่เพิ่มไปสนใจมากนัก มาสนใจที่การทำงานของ Go ดีกว่า
ว่า Go ทำงานอย่างไร เมื่อใช้คำสั่งจากข้างต้น
Go นั้นจะทำการเขียน code ขึ้นมาใหม่ ก่อนที่จะทำการ compile code
โดยเพิ่ม code ใหม่เข้าไปดังนี้

เมื่อใส่ code ดังกล่าวเข้าไปแล้ว ทำให้สามารถนับจำนวน test coverage มาได้แล้ว
ซึ่งการใส่ code ไปแบบนี้ทำให้กินเวลาไปประมาณ 3%
โดยตัวเลขมาจากทีมพัฒนานั่นเอง
ซึ่งเวลาการทำงานไม่ได้เพิ่มไปมากเท่าไร ยังยอมรับได้
ดังนั้น เราควรเพิ่ม test coverage เข้าไปในสายของการพัฒนาด้วยนะ

มาดูผลของ Test coverage แบบสวยๆ กัน

เนื่องจากตัวอย่างแรกนั้นหน้าตาผลการทำงานมันแย่มากๆ
ดังนั้นเรามาสร้างผลการแสดงผลแบบสวยๆ กันบ้าง

สามารถระบบได้ว่า จะเก็บผลการทำงานไปไว้ที่ไฟล์ไหน

$go test -coverprofile=coverage.out

ทำการเปิดไฟล์ coverage.out มีข้อมูลดังนี้

mode: set
size/size.go:3.25,4.9 1 1
size/size.go:16.2,16.19 1 0
size/size.go:5.2,6.20 1 1
size/size.go:7.2,8.16 1 0
size/size.go:9.2,10.17 1 1
size/size.go:11.2,12.15 1 0
size/size.go:13.2,14.16 1 0

จะเก็บผลการทำงานหรือการเข้าไปทำงานในแต่ละส่วนของ code
ตามที่ทาง Go ได้เพิ่ม code CodeCover เข้าไป

และเราสามารถดูได้ด้วยว่าแต่ละ function มี test coverage เท่าไร ด้วยคำสั่ง

$go tool cover -func=coverage.out

ผลการทำงานเป็นดังนี้

size/size.go:     Size          42.9%
total:          (statements)     42.9%

แต่รูปแบบยังไม่สวยงามเท่าไรนัก
ดังนั้นเราสามารถดูในรูปแบบ HTML ได้ด้วยคำสั่ง

$go tool cover -html=coverage.out

ผลแสดงดังรูป

เป็นไงบ้าง ดูสวยงามขึ้นเยอะเลย

แต่ยังไม่พอทาง Go ยังมีความสามารถให้อีก

นั่นก็คือการใส่ -coverage mode เข้าไปได้อีก ประกอบไปด้วย
1. set บอกว่าแต่ละ statement ถูกเรียกใช้งานหรือทำงานหรือไม่  ซึ่งเป็นค่า default ดังนั้นที่ผ่านมาจึงเป็น mode นี้
2. count ทำการนับว่าแต่ละ statementถูกเรียกใช้งานกี่ครั้ง
3. atomic จะทำงานเหมือนกับ count แต่ถูกใช้งานในโปรแกรมที่ทำงานแบบขนาน

ตัวอย่างการใช้งาน mode count เพื่อทดสอบ package fmt ของ Go ด้วยคำสั่ง

$go test -covermode=count -coverprofile=count.out fmt

ยังไม่หมด พอดีไปเห็นว่ามี Free service สำหรับการแสดง Test coverage

ที่  Coveralls.io   ดังนั้นลองใช้งานดูหน่อย
และที่ง่ายคือ มีคนพัฒนา package สำหรับส่งข้อมูลไปยัง Coveralls.io
ด้วยการใช้งาน package goveralls

ใช้งานดังนี้

$go get github.com/axw/gocov/gocov
$go get github.com/mattn/goveralls
goveralls -repotoken your_repos_coveralls_token

เท่านี้ก็สามารถเอา Test coverage ไปโชว์ชาวบ้านได้แล้ว
แต่ผลลัพธ์ของ Test coverage มันไม่เท่ากับการใช้งานบนเครื่อง
ซึ่งตรงนี้คงต้องไปดูเพิ่มเติมว่าสาเหตุคืออะไรต่อไป

และใน Github เราสามารถแสดงสวยๆ ได้เช่นกัน

ลองนำความสามารถของ Test coverage ไปใช้งานในการพัฒนาเถอะครับ …

ตัวอย่าง code ในการทำ demo อยู่ที่ Github :: Up1 coverage 

Reference Website
http://blog.golang.org/cover
http://jmcvetta.github.io/blog/2013/08/30/continuous-integration-for-go-code/
http://modocache.svbtle.com/continuous-integration-in-go