Many developers forget about good object-oriented design techniques when developing in SharePoint, most of the time because they get overwhelmed by the framework. Unit testing often gets thrown out of the window, and most of the time the application becomes very tightly coupled to the SharePoint object model. This talk will demonstrate how to overcome these obstacles and build solid SharePoint application code that is much more testable and is easier to maintain.
Polkadot JAM Slides - Token2049 - By Dr. Gavin Wood
Writing Testable Code in SharePoint
1. Writing Testable Code in SharePoint
Tim McCarthy
Senior Technical Architect
Perficient
2. Agenda
• Introduction
• Repository Pattern
• IoC and Dependency Injection Patterns
• Model View Presenter Pattern
• Unit Testing strategies
• Summary
3. Introduction
• Tightly-coupled SharePoint Code
• Difficult to test Web Parts and Pages
• Need a better way to organize the code
• The answer: Design Patterns!
4. What is the Repository Pattern?
• Isolates the domain model from data access
• Encapsulates the domain object persistence
• Persistence Ignorance is bliss!
• Works well when used with interfaces…
6. What is IoC?
• Inversion of Control
• Depend upon abstract types, not concrete
types
7. Benefits of Inversion of Control
• Can swap out implementations later (such as
different repositories)
• Allows parts of the application to be built
independently with no complicated
dependencies
• Can work in ASP.NET and switch over to
SharePoint later
8. What is DI?
• DI = Dependency Injection
• One solution to the problem instantiating
abstract types
• Available DI frameworks
– Castle
– Unity
– MEF
– Etc.
9. Benefits of Dependency Injection
• Can write more granular unit tests
• Don’t need to hit the database for testing UI
logic
• Allows parts of an application to be easily
swapped out without re-compiling
• Using a DI framework makes it almost
seamless!
11. Model View Presenter Pattern
• Gets the logic out of your UI so it can be
tested!
• Forced separation of concerns
• Can enable UI logic to be shared
• Side Point: Why not use MVC in SharePoint?
13. Unit Testing Strategies
• Test the presenters separately
• Use mock views and mock repositories when
testing the presenters
• Test the concrete repositories separately
15. Summary
• Design Patterns are the key to better
SharePoint code!
• Repository, IoC and DI patterns make testing
way easier
• MVP pattern gets the logic out of your UI code
17. Contact Info
Tim McCarthy
tim.mccarthy@perficient.com
18. We want your feedback!
Use this QR code or visit:
http://sps.la/feedback
Silver Sponsors:
19. Victory Lap- social event
"SharePoint Victory Lap" Social Event for
SPSLA will be at: 5:30pm to 8pm at
Di Piazzas (5205 E. Pacific Coast Hwy, 90804)
Notes de l'éditeur
Many developers forget good object-oriented design techniques when developing in SharePoint, most of the time because they get overwhelmed by the framework. Unit testing often gets thrown out of the window, and most of the time the application becomes very tightly coupled to the SharePoint object model. This talk will demonstrate how to overcome these obstacles and build solid SharePoint application code that is much more testable and is easier to maintain.The vehicle for this goodness is design patterns!
Using the repository pattern will allow you to develop outside of the SharePoint environment "up until the last minute"
Depend on abstract types (interfaces) instead of concrete classes!Don’t need a big bulky 64-bit Windows 2008 Server virtual machine until much later!
MVP is good for web forms projects, which is what SharePoint is based uponModel: Defines the data to be displayed or acted upon in the UIView: UI that displays data from the Model and routes user commands to the Presenter to act upon the dataPresenter: Acts upon the model and the ViewWith MVP, the idea is to strip as much logic and code out of the UI and make it do simple things, like data binding and and acting as a facade to the various UI element properties, i.e. expose TextBox.Text property as FirstName.This pattern really pays for itself when you find bugs in the UI logic…just write a failing unit test and fix the code so it passes the test!Very difficult to use MVC in SharePoint, not worth the effort
Doing TDD by the letter takes a lot of discipline. Once you start doing it, it can become a habit. But even if you don't write your tests first, if you use DI + MVP + tests later, you still will benefit from the modularity and freedom to refactor your code.Writing tests can take up time initially, but the payoff happens in spades once you have to identify and fix bugs, or refactor your code with confidence of not breaking anything else.Mock up your views and repositories so you only test what is necessary...that way your tests are really focused. You can (and should) do integration tests later where you use the real repositories. Once you have a pretty good suite of tests developed, you can freely make changes to your code and see if your tests still pass. Refactor, compile, re-test.Rinse, lather, repeat!