While at the Danish Developer Conference in Copenhagen, Jon sat down with Mark Seemann to talk about AutoFixture and Unit Testing.
Download / Listen:
Herding Code 165: Mark Seemann on AutoFixture and Unit Testing [audio:http://herdingcode.com/wp-content/uploads/HerdingCode-0165-Mark-Seemann-on-AutoFixture-and-Unit-Testing.mp3]
- (00:44) AutoFixture is an open source library that simplifies the "Arrange" part of the standard Arrange / Act / Assert steps in unit tests.
- (01:20) Jon asks about anonymous variables. Mark says he got that terminology from Gerard Meszaros’ book, xUnit Test Patterns. Anonymous methods and variables are necessary for a test, but their implementation doesn’t matter.
- (02:23) Mark describes the test data builder pattern, from the book Growing Object-Oriented Software. The pattern works well, but it gets to be repetitive and mechanical to write and maintain, so he wanted to automate it. AutoFixture uses reflection to create the needed instances.
- (04:00) Jon asks about the usage pattern for AutoFixture.(04:16) Jon asks about the different values returned for strings, ints, etc. Mark explains how that’s changed over time – numbers no longer just return sequential values, they now return random small numbers.
- (05:20) Mark explains equivalence classes. Jon says "Okay" a lot. You can use AutoFixture in cases where you don’t care about the value; in cases where you do, you can configure what you want to. Mark explains some of the different ways you can use the AutoFixture API to set specific values when needed.
- (09:15) Jon asks how AutoFixture works with mocking. Mark says there are NuGet packages which will interface with Moq, Rhino Mocks, FakeItEasy and NSubstitute.
- (10:25) Jon asks Mark what his talk said about equivalence. Mark explains identity and value objects with an example with overriding the equals operator on a money value object. The more you can model your domain as value objects, the easier your tests become. Jon asks if this is an example of TDD driving a good design. Mark says that he tried letting tests completely drive his design a few years ago, but he found that it alone didn’t drive a very good overall design.
- Testing philosophy, Testing Trivial Methods
- (15:56) Jon asks Mark about his recent post advocating testing trivial methods. Mark says that his post was in response to Robert C. Martin’s post, The Pragmatics of TDD. Mark makes a case for testing getters and setters – if you decide to use a property rather than a field, that decision probably warrants a test to verify the property is maintaining the behavior that drove the original decision.
- (20:38) Jon asks how this applies to the example of testing ASP.NET MVC controller code. Mark says he’s in the habit of testing everything, and has written a lot of tools to make writing the tests easy enough that it’s not a concern. The question is, how much does it cost you if a unit of code doesn’t function as designed? Mark explains how a controller action models the data flow in an MVC application, and decomposing the flow allows you to write smaller, simpler, more targeted tests.
- (25:03) Jon asks how this relates to outside-in testing using tools like Selenium. Mark says that testing at the external boundary is fine if you can, but most applications become complex enough that boundary testing would require an impractical number of test cases.
- Wrap up
- (26:04) Mark says that many of these concepts are covered in more detail in Mark’s Pluralsight course.
This week on Herding Code, the guys talk to Louis DeJardin about OWIN – the Open Web Interface for .NET – and Katana, an open source OWIN implementation for ASP.NET and IIS.
Download / Listen:
Herding Code 164: OWIN and Katana with Louis DeJardin [audio:http://herdingcode.com/wp-content/uploads/HerdingCode-0164-OWIN.mp3]
- (00:44) Scott and Louis explain what OWIN is.
- (01:33) Louis explains the difference between OWIN (the community standard) and Katana (actual bits – an implementation of the OWIN standard for ASP.NET).
- (03:18) Jon asks if this is similar to the distinction between HTTP / HTML standards and browser implementations. Louis explains what’s required for an implementer to participate in a request. Each request calls a simple func with an IDictionary<string> which returns a task.
- The killer app: middleware
- (04:54) Scott talks about how the pipeline might not sound like much, but it can support a lot of really useful middleware scenarios like static caching and domain splitting – especially in a way that’s common across frameworks.
- (06:05) Louis talks about the challenge they’ve had in describing the benefit of OWIN in non-academic terms, and that it’s not until you want to apply cross-framework concerns like authentication that OWIN really shines.
- (07:52) Scott says that previously these kinds of concerns – logging, etc. – were wrapped up in System.Web, and they had performance implications regardless of whether you used them. The pipeline model lets you avoid those hits unless you explicitly want the features.
- (10:03) Scott mentions some of the frameworks which have implemented OWIN, including NancyFx, Fubu, ServiceStack.
- (10:50) Kevin says that the current implementation examples are full web frameworks rather than middleware. Louis says that probably because ASP.NET and IIS already had pipeline implementations so there’s less of a forcing function than there was with Node and Ruby. Scott says that since the current implementations already have full stacks, there’s less need to plug in modular solutions. Jon says he thinks that the late arrival of NuGet and other open modular systems like this mean it’ll take a while to get traction.
- (14:40) Louis says we’ll need a killer app, and HttpListener hosting alone isn’t that. Jon asks if you’d host Katana under IIS to manage the process. Louis says yes, and until there are other hosts than IIS he doesn’t see the hosting as a big draw – he thinks auth is probably it.
- 1640 Scott says he could see auth frameworks and scaling middleware. Louis says that David Fowler updated JabbR to run on OWIN, and was able to move some of the scale pieces into OWIN middleware.
- (18:25) Jon asks if he can take an existing ASP.NET application to start taking advantage of middleware without rewriting the application. Louis says that if you add the Microsoft.Owin.Host.SystemWeb NuGet package, you can put an OWIN pipeline on the route table. You can also use an IHttpHandler to plug in middleware. They’re looking at third option – an integrated pipeline module which will delegate to the application if an OWIN handler doesn’t pick it up.
- (22:22) Jon asks Louis has some other ideas for middleware, and Louis lists several (static file handlers, authentication, etc.) and points to Rack and Node as examples. He lists another example – anti-bot protection that returns an HTTP 200 for a URL pattern.
- (23:50) Jon asks if it’s possible to plug things in at runtime. Louis talks about the Startup class – it’s a POCO class so you can easily work with it via IoC, plug things in whenever – it’s just code.
- (25:05) Scott says he looked at implementing URL rewriting in middleware. Louis explains how this works perfectly with the pipeline and describes how you could also use this to monitor 404s.
- (26:45) Scott says hosters could implement middleware to set ETAGS, enforce things, etc.
- (27:40) Louis explains why it’s really powerful to have middleware that’s not coupled to a specific implementation like ASP.NET MVC.
- (28:35) Jon asks if it’s possible that some of this middleware could run on hardware. Louis says it is, and gives an example with a reverse proxy.
- (29:57) Scott talks about breaking middleware into application and networking uses and talks of some optimizations that could be done in middleware.
- (31:48) Scott asks where we go from here – are done? What’s the next goal? Louis says the current 1.0 version of Katana has IIS hosting; the 1.1 version will add production grade HttpListener and self host story, and after that it’s about supporting emerging standards and looking for synergies. Louis says documentation would be nice, but Scott says that the model is so simple that there’s not a lot to document.
- (34:50) Scott and Louis talk about how this will affect the ecosystem in general, with an example of how smoothly the SignalR implementation worked.
- (35:25) Jon asks about the future for hosters like Azure, AppHarbor, etc. Louis talks about an example for supporting zip file based deployment, Mono hosting.
- Getting involved
- (37:05) Louis talks about what’s available in the Katana Project, including sample code and pre-release packages. The Google Group – net-http-abstractions – is the best place to discus OWIN.
- (38:15) Jon asks if the Katana project takes pull requests. Louis says it’s run under the MS Open Tech organization and is clear to take pull requests from developers who have signed a contributor license agreement. Jon asks for areas where they’d like help. Scott says he’d like to see lots of middleware; Louis he’d love to see an OWIN Contrib project emerge.
- Questions from Twitter
- (41:05) Sean Massa (@endangeredmassa): Is it possible to use the DLR?
- (41:45) Eric Hexter (@ehexter): what do MVC and Web Forms look like on OWIN. Louis says there are two exciting things there – you can have an Owin pipeline running in front of your application, or you can use self hosting to put an application inside of your own process (not supported but fun!).
This week on Herding Code, the guys talk to Damien Guard and Robert Sweeney about Sticker Tales (a Windows Store application for kids), some challenges in building touch applications for kids, their CSharpAnalytics open source library, and a companion app they built for Western Digital.
Download / Listen:
Herding Code 163: Sticker Tales and Building Windows Store apps [audio:http://herdingcode.com/wp-content/uploads/HerdingCode-0163-Sticker-Tales-and-Building-Windows-Store-apps.mp3]
- (00:39) Damien describes what he’s been up to since we last talked to him.
- (01:25) Robert worked on the Windows user interface, then XBox.com, then several apps for NetFlix.
- (02:57) Jon asked about the experience of building high scale customer facing applications at XBox and NetFlix. Damian tells about how they ran the XBox store on two servers.
- Building Sticker Tales
- (03:38) Jon asks how they decided to build a sticker book app. Robert explains how they got started.
- (04:45) Robert describes how they decided to spend some money on professional illustration.
- (05:40) Jon describes how Sticker Tales works and how he loves watching what his five year old daughter comes up with, especially how she plays with scale. Robert says he sees the same as his daughter
- (6:57) Damien describes some of the surprises they saw in user testing.
- (8:30) Scott K asks if their experiences in watching how kids interact with touch gestures will influence their design in general.
- (9:18) Damien talks about some of the changes the kids inspired, especially using direction of motion to flip things. Jon says he wants this flip gesture everywhere, and Scott K says he thinks kids should be interaction testing all touch interfaces.
- (10:44) Damien gives another example with how pinch / zoom didn’t work well for kids, and they added a handle instead.
- (11:26) Jon asks about how they were interacting with the illustrators. Robert describes the interaction and how they handled different image sizes, exporting, etc.
- In-app purchases
- (13:37) Jon asks about the "free app + in app purchase" model. Robert explains why they chose that model.
- (14:48) Jon asks if the in-app purchases were difficult to set up. Damien says yes and explains how it was set up. Robert says the purchasing is easy, but the delivery is up to you as the developer.
- Google Analytics and the CSharpAnalytics library
- (17:00) K Scott asks about what kind of analytics they were using. Damien explains how they used Google Analytics and explains they published that library as CSharpAnalytics on GitHub. Damien likes tracking usage patterns, Robert says he loves the real-time and geographic views.
- (18:19) Robert says they track initiated vs. completed purchases, and they see it’s only about 10%. Jon speculates that’s because kids start the purchase and the parents veto it.
- (19:08) K Scott asks if it’s only available for Windows 8. Damien says that’s all that’s documented, but he’s set it up to work with Windows Phone as well.
- (19:30) Jon asks about how auto-analytics work.
- Platform targeting – iPad future, Windows 8 implementation
- (20:40) Kevin asks if they’re looking at porting this to iPad. Robert says they’re looking at using Xamarin for that.
- (21:24) Jon asks about what Windows 8 integration points they’re using. Robert discusses live tiles, sharing, search, and background download API support.
- (22:58) Jon asks if they used C# / XAML or HTML. Damien says they went with C# / XAML partly because the touch API support seemed better early on.
- SharpDX and performance
- (23:30) Damien explains that they’re using SharpDX to be able to take screenshots for live tiles, sharing, etc. Jon gets confused and thinks they’re using SharpDX everywhere, but Robert explains it’s only for saving screenshots – everything else is using image controls.
- (26:54) Jon asks if they ran into any performance issues. Robert explains some of the guidelines they’d learned at NetFlix and says that everything’s worked really well in StickerTales. Damien says they’ve seen great performance on Surface / ARM as well. Jon says he’s seen Audacity recompiled for ARM and it worked great on Surface, too.
- Data storage and MVVM perspective
- (28:34) Jon asks what they’re using for data storage; Damien says using XML.
- (28:46) Robert says they’re not using MVVM because it just doesn’t work with the Microsoft tools and isn’t worth it for the kinds of thin clients they’ve been building, even at NetFlix.
- Western Digital companion application
- (30:07) Jon asks how about their next project, a companion application for Western Digital. Damien describes how Western Digital wanted an application that would present an all-up aggregate view of media on external media.
- (30:42) Damien says they using SQLite for that project and explains the challenges they ran into with hierarchical data storage in a relational database engine.
- Unit Testing Windows Store application code
- (32:52) Kevin asks about the testing story. Damien says they used MSTest and it all worked fine, with the exception of determining code coverage. Jon asks some questions about testing frameworks and test focus for Windows Store applications.
- (35:20) Robert says the WinRT platform wasn’t written in a very testable manner – there are lots of static classes and a generally test resistant API.
- Business Challenges and Opportunity for Windows Store Developers
- (36:38) Jon asks about the challenges of building and running a company that’s building Windows 8 applications. Robert describes some of the perception and education issues they face in selling the potential to customers.
- (38:20) Scott K compares the current Windows Store opportunity to the pre-iOS Mac development market – a nice place to create a niche product and make a good living. Damien says it is nice to be featured in the store, and that’s difficult on other platforms. Robert says that ease of developing Windows Store applications means that you still need to market your applications.