Advanced Go Training Workshop

Advanced Go Training was designed with the experienced developer in mind. It assumes that you have already learned the day to day Go concepts, and are ready to master concepts such as Concurrency and advanced testing methodologies. It finishes with a comprehensive tour of the pprof tool and how to profile your Go code and determine how to make it more performant.
Our classes are priced for small and large classes. We offer classes starting at only five students, up to 100 students. We recognize that each company has specific needs and budgets.
For pricing, fill out our contact us form and you'll receive an automated reply with our current rates.
45m · 1 Shared Lab, 1 Student Labs
Automating testing is crucial for maintaining code quality and reducing bugs during the development process. This chapter will teach you how to efficiently run and automate tests in Go using the go test command, alongside various useful options such as running specific tests, enabling verbose outputs, handling race conditions, and running tests in parallel. Additionally, you’ll learn how to incorporate tests into Continuous Integration (CI) pipelines for robust and automated feedback on your codebase. By the end, you’ll understand how to structure your tests for fast and effective validation.
30m · 1 Shared Lab, 1 Student Labs
This chapter explores advanced tools and techniques for increasing your test coverage and improving overall code quality. You will learn how to generate code coverage reports, interpret coverage statistics, and utilize heatmaps to identify untested code. Additionally, we'll cover isolating specific tests, testing in parallel, and how to leverage Go’s built-in coverage tools to maximize testing efficiency. By the end of this chapter, you'll be equipped to improve your Go project's coverage and maintain high testing standards.
30m · 1 Shared Lab, 1 Student Labs
No project is complete without great documentation. Example tests are a great way to not only document your code, but ensure that the examples you use always work as they are actually a test in addition to the documentation.
45m · 1 Shared Lab, 1 Student Lab
In Go, decoupling components and isolating dependencies during testing can be easily achieved using interfaces. This chapter explores how to create stubs and fakes to test functionality independently and ensure reliability without the need for external dependencies. By simulating different behaviors in your components, you can improve test accuracy and efficiency. You'll learn how to replace real implementations with stubs in unit tests, handle various scenarios like errors and success cases, and maintain high test coverage. With these techniques, you can create more maintainable and flexible test suites for your Go applications.
1h30m · 2 Shared Labs, 2 student labs
In this chapter, we dive into testing HTTP handlers in Go, leveraging the net/http/httptest package. Testing HTTP handlers can be approached in two distinct styles: Unit Style Testing and Integration Style Testing. Each style serves different purposes in ensuring that your web applications work as expected. We will explore both approaches, demonstrating how to mock HTTP requests, simulate responses, and write efficient tests for your web services. Additionally, you'll learn how to create test servers, utilize middleware, and handle request bodies and form data. By the end of this module, you’ll have the skills to write comprehensive and reliable tests for Go-based web applications.
30m · 1 Shared Lab, 1 Student Lab
Testing asynchronous and concurrent code introduces unique challenges, such as dealing with unknown execution times and ensuring test reliability in multi-threaded environments. This chapter focuses on how to efficiently test asynchronous operations, such as database writes, service queues, and distributed system calls, using Go's concurrency primitives like goroutines and channels. We will cover key techniques for handling these complexities in your tests, including timeouts, retries, and using channels to synchronize test execution. By the end of this chapter, you'll know how to design tests that effectively handle non-blocking, asynchronous processes while maintaining test stability and minimizing bloated test durations. This chapter assumes familiarity with basic concurrency concepts in Go, including the httptest package, channels, and goroutines.
1h · 2 Shared Lab, 2 Student Labs
This chapter introduces advanced tools and techniques to improve testing in Go. It covers topics such as: Comparing Complex Structures: A deeper look into comparing values in Go, going beyond reflect.DeepEqual, which often leads to unexpected results, and exploring better alternatives like go-cmp. Using the testing/quick Package: This section explains how to automate tests for a wide variety of input scenarios by leveraging the testing/quick package, which allows for rapid generation of test cases with minimal setup. Fuzz Testing: The chapter also introduces fuzzing as a way to discover edge cases and vulnerabilities in your API. It highlights tools and methods for integrating fuzz testing into your testing strategy to improve code reliability and security. This chapter provides detailed insights into best practices for using Go’s tooling ecosystem for more effective and comprehensive testing.
30m · 1 Shared Lab, 2 Student Labs
Workflow automation can significantly improve developer productivity. This chapter will show how to implement some very simple, lightweight automation to automatically run tests and coverage.
45m · 1 Shared Lab, 1 Student Lab
Handling input/output (IO) operations is a crucial part of many software applications, especially when interacting with files, network connections, or other external systems. Testing such interactions presents unique challenges, such as dealing with external dependencies, ensuring proper data flow, and maintaining test isolation. In this chapter, we will explore how to design Go pr