Richie's World

Missing webapplication.targets error on a build server

noreply@blogger.com (Richard Allen) — Thu, 14 Jun 2012 09:18:00 +0000

Another quick note for myself about a problem when setting up a new build server, if you come across a problem with an error that looks like this:

‘The imported project "C:\Program Files\MSBuild\Microsoft\VisualStudio\v10.0\ WebApplications\Microsoft.WebApplication.targets" was not found. Confirm that the path in the <Import> declaration is correct, and that the file exists on disk.’

A quick bit of Googling found this article which resolves the problem, I chose the copy the file to the build machine option – installing VS2010 on a build server seems a little bit like overkill.

Scott Hanselman User Group Tour of Scotland

noreply@blogger.com (Richard Allen) — Wed, 16 May 2012 07:32:00 +0000

Well I am not quite sure how they managed it, something to do with tracing his ancestry – I am sure he will could find a long lost uncle in Southampton/Bournemouth (mmm does anyone know anyone with the last name Hanselman in the local area?).

Anyway, here are the details for those that will be lucky enough to attend:

http://www.gep13.co.uk/blog/scott-hanselman-doing-user-group-tour-of-scotland/

http://www.hanselman.com/scotland

http://scottishdevelopers.com/2012/05/15/scott-hansleman-scotland-tour/

For getting the most up to date information regarding each of the events, make sure that you follow the following Twitter accounts:

Gary Ewan Park @gep13
The Aberdeen Developers Account @adnuguk
The Scottish Developers Accounts @scottishdevs

The details for these sessions are as follows:

9 July – Edinburgh: Developing for the Mobile Web

Mobile traffic on the web is exploding. Are you ready? ASP.NET MVC 4 includes new mobile-friendly templates, a focus on responsive design as well as dedicated mobile templates that leverage jQuery and jQuery mobile. Scott Hanselman will show you what you can do today and tomorrow to make your site friendly on a mobile device. When should your mobile site become a mobile application? Should you use CSS3 media queries, or go “all in” and use jQuery mobile or another mobile framework?
10 July – Dundee: Personal Productivity – Scaling yourself in the face of Information Overload

As information workers, we are asked to absorb even more information than ever before. More blogs, more documentation, more patterns, more layers of abstraction. Now Twitter and Facebook compete with Email and Texts for our attention, keeping us up-to-date on our friends dietary details and movie attendance second-by-second. Does all this information take a toll on your psyche or sharpen the saw? Is it a matter of finding the right tools and filters to capture what you need, or do you just need to unplug. Is ZEB (zero email bounce) a myth or are there substantive techniques for prioritizing your life one the web? Join Scott Hanselman as we explore how you can be truly productive.
12 July – Aberdeen: One ASP.NET – Open Source, .NET and the Cloud

It’s an exciting time for ASP.NET and Open Source. What does the next version of Visual Studio and ASP.NET bring to the world of web development? How will you use HTML5, CSS3 and new advances in JavaScript with ASP.NET? There’s new advances in ASP.NET with the addition of real-time (Signalr), new features in WebForms as well as support for mobile. How will it all snap together in a way that makes sense? Join Scott Hanselman as he shares some internal documents and exciting surprises about the future of ASP.NET. What about Azure? We’ll talk about the world’s most misunderstood cloud and it means for developers of all flavours and persuasions.
13 July – Glasgow: One ASP.NET – Open Source, .NET and the Cloud

It’s an exciting time for ASP.NET and Open Source. What does the next version of Visual Studio and ASP.NET bring to the world of web development? How will you use HTML5, CSS3 and new advances in JavaScript with ASP.NET? There’s new advances in ASP.NET with the addition of real-time (Signalr), new features in WebForms as well as support for mobile. How will it all snap together in a way that makes sense? Join Scott Hanselman as he shares some internal documents and exciting surprises about the future of ASP.NET. What about Azure? We’ll talk about the world’s most misunderstood cloud and it means for developers of all flavours and persuasions.

A breakdown of the Given, When, Then steps

noreply@blogger.com (Richard Allen) — Wed, 02 May 2012 08:46:00 +0000

In this post I try to explain what I think the various step blocks in the GWT structure are for.

Given

The “Given” part of a scenario is probably the hardest thing to implement and get right. The reason for this difficulty is that you have to balance the need for reducing complexity of the scenario by ensuring that only relevant context is stated whilst implementing the functionality to allow the context to be defined in this way. The “Given” step forms the configuration or setup phase, you are defining what context the scenario is running in and as such you need to manage datasets, add data, remove data, modify data, create users etc whatever is necessary to get the system into the correct state ready for the scenario to executed.

As an example, imagine a scenario where a member of a gym walks into a club, they have been sick for a long period so they “froze” their membership (this means paying a smaller amount for the duration of their sickness but keeping the membership open), and they ask the receptionist to unfreeze their membership.

The story:

Feature: Unfreeze membership
In order to resume a membership after returning from a long term sickness period
As a receptionist
I want to unfreeze a membership

The following two scenarios show two different ways of representing the same scenario, the first uses multiple Given steps to set the context where the second looks to simplify this into:

Example Scenario 1:

Scenario: Unfreeze regular monthly payer
Given a member joined on 01/01/2010 onto plan ‘Monthly’
And the member freezes their account on 01/02/2011 for 12 periods
And the current business day is 15/04/2011
When I unfreeze their membership
Then the member should be charged £10 freeze fee
And their status should be ‘OK’
And their payment status should be ‘Arrears’

Example Scenario 2:

Scenario: Unfreeze regular monthly payer
Given a frozen member
When I unfreeze their membership
Then the member should be charged £10 freeze fee
And their status should be ‘OK’
And their payment status should be ‘Arrears’

You can see that we have taken what was three separate steps has been combined into a simple “Given a frozen member” statement. The first thing you will probably ask is but what about the information such as join date and the freeze date and duration pieces of information, well what we really want to do here is have this information “inferred” so whenever members of the team refer to “a frozen member” they know that it refers to a member that joined on 01/01/2010 onto a monthly plan etc and we would set that information up as defaults which can be overridden if required. So you could do something like:

Given a frozen member with the following properties
| Key | Value |
| JoinDate | 15/01/2010 |

This gives us the ability to take all of the defaults of a frozen member and yet override them with values that are relevant and mean something within the current scenario. Keeping your Given statements concise and to the point plays valuable role in ensuring your tests remain readable and maintainable over the long term.

My personal preference is to make all “Given” steps non-UI based actions, this is because using the UI is the slowest and most brittle way to get things done and the point of the “Given” is to get your tests setup as quickly as possible.

When

The “When” phase is the event under test. This should be the main action that is being defined by the specification and I normally find this step to be the easiest to define and implement as it is the step that makes the call to the api or executes the UI automation code. There should be an obvious tie between the scenario title and the actions performed in the “When” steps otherwise you will have a mismatch between what you expected the specification to do and what it actually does.

Then

Finally, the “Then” phase is where you perform any assertions of correctness and you can run numerous checks and validations to ensure that the action that was performed during the “When” phase actually completed successfully and that all of the relevant data sets, files, databases etc have be been updated according to the expected behaviour.

When executing “Then” steps I try to use routes through the system such as alternative apis or use an external mechanism such as an Entity Framework, LINQ to SQL to validate databases or the .NET System.IO classes to validate the file system etc.

Getting automation done - inside an iteration!

noreply@blogger.com (Richard Allen) — Fri, 27 Apr 2012 18:30:00 +0000

In my previous post I talked about what I believe to be the key to implementing a successful automation strategy which was building on good foundations using a process that encourages communication and collaboration between team members in order to define your requirements in a more automatable way. This process is known as Behaviour Driven Development (BDD) and it defines a structure for your stories and more importantly your acceptance criteria which promotes re-use and makes the application of automation a lot easier in the long term.

When teams start to implement automation they often find that they find it difficult to deliver completed automation tests within the same time frame as the developed code, for example a two week iteration. I think this tends to happen when the team are not working closely together to achieve the goal of automation and you will tend to find that testers are “waiting for developers to complete the code” before they begin writing the tests.

In my mind one of the most important things you are trying to do when defining your scenarios is to think of as many possible ways in which the feature may be executed, you are trying to brain storm all of the possible permutations of the feature and capturing them in simple one line scenario statements. Another important thing to note here though is that whatever scenarios you come up with initially do not have to remain fixed for the entire iteration, you should be able to manipulate them and the combine or split them where appropriate when going through a formalisation phase – provided that you continue to communicate that with the rest of the team!

Laying the foundations

During the early stages of implementing automation there will be a fair amount of setup required in order to get just a single test running from end to end, some of the things you need to consider are:

Do you have a Continuous Integration (CI) server?
This is an absolute must have, if you are not running your tests on a regular basis and immediately responding to broken builds then you will not be gaining the full benefit of implementing test automation – I would definitely recommend Team City by Jet Brains for this
Is your product deployable automatically?
One of the first questions you need to ask is whether your product can actually be automatically deployed to a test server during the CI build. If not, what are the steps that you will need to take in order to make this happen – talk with the other developers on your team and plan to get this done as soon as possible
Do you have a dedicated build server?
Acceptance Tests, especially UI based tests, can be impacted by conditions on the server. Simple things such as how long it takes to open IE, FF or Chrome can cause tests to break and give you a false negative. By running your acceptance tests on a separate server you are giving yourself the best chance of making your tests stable. If your tests break too often due to environment issues you can quickly lose the confidence of your development team and eventually they will no longer trust the build results.
Can all members of the team run tests at any time?
Having thousands of tests running over night on a remote server reporting failing tests is pretty good for nothing if it takes a developer hours to recreate the problem, when building your test set consider all of the potential running modes such as whether it is on the build server or it is a single developer trying to isolate a problem. Think about how you can automate the setup of the environment for running the tests in a couple of clicks
What is your data set management strategy?
The nature of your problem domain will largely dictate this. You are generally aiming to produce tests which execute as quickly as possible but with as much coverage as possible. Deciding how you setup and tear down your data set will play a significant role in the time it takes to run each test. If all of your tests are date dependant and require modifying the current system date it might make sense to organise your test steps to execute over a common timeline to get the most test coverage over the shortest test time – backing up and restoring a database can take a significant amount of time and can quickly become a non-starter. An alternative might be to make each test responsible for creating it’s test data and clear up after itself.
What is the skill set of the team?
This will have a big impact on the tools that you might choose to implement your automation strategy. I prefer to write tests in the same programming language that is used by the production code and in my case this is C# but you could look to Ruby or Python or some other language that your team feel comfortable taking on. My theory behind using the language of your production code is that you should already have “experts” in this language within your team that can provide support when building your automation framework and you may also gain more traction and “buy in” from them. Using a different language can potentially further exacerbate the problem of separate test and development teams but if your team is up for a bit of ployglot programming then go for it.
What automation tools do you want/need to use?
This may well be led by the skillset of your team but there are a vast array of options when it comes to choosing automation tools in my experience if you are automating web applications then you cannot go far wrong with Selenium 2 Web Driver, WatiN or WebAii, for Windows or Silverlight you could look at Project White or if you have a fair bit of cash to throw behind it you could look at Coded UI and Visual Studio Lab Manager or a multitude of other tooling options. In my next post I’ll talk about the tools I have been using.

These are just some of the things you might need to consider and you will need to assess your own environment to identify any of the key blockers to making automation happen – once you start on the road of automation the overwhelming expectation from your bosses will be that “it just works” and provides value for money and a good return on investment so you to need to remove any impediments that might prevent this from happening as soon as you find them.

The importance of Given, When, Then

In my mind using Given, When, Then to describe a ubiquitous language provides the corner stone for building automated tests but the challenge tends to be getting everyone to talk in terms of that ubiquitous language and this can take longer than you might first expect. It seems that although using these simple words, from the English language combined with whatever terms are relative to the business, can still be considered alien because of the structure of the paragraph. There is still a need to “manipulate” the requirement into the “automatable language of the business”. What this means is that it may well take several iterations before everyone just “gets it” and you can become truly productive because there is no more learning or debating about the structure. So do not get disheartened when it feels like you are not making traction, there will almost certainly be an uphill struggle to convince everybody that this is the way to go but once you reach the summit it will be worth the effort.

So don’t expect everybody to just “get it”, as with any new technology, things take time and different people take different amounts of time to truly grasp the underlying concepts. Begin by drip feeding the concepts of GWT acceptance criteria and then look to automate a single end to end test using it and build from there.

I cannot stress enough the importance of using Given, When, Then when defining automated tests. Each step type plays a key role in enabling the test developer to break down the scenario into manageable, reusable fragments of functionality which can be combined to form numerous other scenarios to ensure greater coverage of the system. I have tried to explain what I think the various step blocks in the GWT structure are for in the following breakdown of Given, When, Then steps.

Phases of the Iteration

In Agile we are looking to get things done and accepted as early as possible in order to gain feedback and continuously deliver working software without risk of destabilising the product. The following is a breakdown of some of the key stages prior to and throughout an iteration that help to make automation happen.

Pre-Iteration Planning

Story Definition - Customer Team works with Stakeholders to get basic Story definition
This happens prior to the iteration starting and should include sufficient acceptance criteria to estimate, at this point I would look to capture key information points in an informal manner that help to promote the right discussion of the story when moving into the elaboration phase

During the Iteration

Story Elaboration - Product Owner, Testers and Developers work together
During planning and the early stages of the iteration scenarios are discussed in detail and evaluated for how best to accept the story – this requires an understanding of what unit, acceptance and end to end tests will be written - I would generally expect at least the high level scenario titles to be defined at this point to give a “feel” for the number of scenarios associated with the feature, we do not necessarily need the full GWT break down and this could be done by smaller teams or pairs
Get to work
After working together to to elaborate the stories the Product Owner focuses on getting answers to any initial questions raised. Taking each story the team should start to white board/blog/wiki designs discussing implementation strategies to gain agreement of the right approach to deliver the requirements. After this testers can set to work on creating “failing” acceptance tests including developing the underlying supporting framework and Developers start developing “failing” unit tests and implementing the required business logic. You should be able to identify key interfaces that allow the developers and testers to work on separate parts of the same feature at the same time and then tie it all together as and when it makes sense to
Review - Daily Stand Up
As the understanding of requirements increases and code begins to be implemented the failing tests should start to go green, Developers continue to implement scenarios to make more tests pass, Testers begin to do more exploratory testing and communicate any undefined scenarios found with the Product Owner to determine whether or not the scenarios should be supported in the current version
Revise
As more tests go green the code should be modified and refactored where appropriate to ensure code quality is high and maintainable whilst keeping tests green. The Developers should be putting more effort into testing towards the end of the iteration, the code to implement a feature should be done as early as possible. If you are checking in code to start a new feature in the last few days of the iteration then you should seriously consider whether it will be feasible to complete that story end to end – would your time be better spent making sure the current product you have is truly “ready to ship”?
Done
All UI, acceptance and unit tests go green, manual exploratory tests have been done and application is considered “ready to ship”

Summary

When you first start to implement an automation strategy (especially on a brownfield project) try not to set yourself up for a fall by committing to too much, the introduction of automation will be an alien concept and a complete paradigm shift to most people. This will take time for them to “get their heads around”. Try to start by introducing the concept of automatable requirements and get the team talking in those business terms and look to configure your environment to support automation. Plan in setting up of your continuous integration and build server configurations and start to get your team up to speed on your chosen technologies.

Next Steps

Take a look at your current development environment, is it geared up to start automating immediately – if not, what is missing and what are you going to do about getting it sorted? In my next post I’ll take a bit more of a deeper dive into tool sets of choice and how to apply them to create a maintainable test set.

What is the key to successful test automation?

noreply@blogger.com (Richard Allen) — Tue, 24 Apr 2012 07:30:00 +0000

Wouldn’t it be nice if I had the definitive answer! Well certainly do have an answer, but whether it is something you agree with I shall leave up to you to decide, here are my thoughts on it anyway:

I believe that the key to successful test automation begins not with thinking about “how” to automate but instead concentrating on “what” to automate.

Do not start by thinking about the tools you are going to use, whether it be Selenium, WatiN, WebAii, Project White, <InsertYourFavouriteTestToolHere>, but focus more the input into the automation process. You have to look to the start of the development process, the requirements capture, and ensure that your approach to this provides you with a solid foundation for the creation of automated tests. If you are already on an existing project and you are looking to implement automation try not to be overwhelmed by the sheer scale of the task. You can very easily be “scared off” of implementing automation because it just looks too big but as with anything in Agile by taking small iterative steps and learning from your mistakes you can start to make a dent and let’s face it any automation (done right) must be better than no automation?

You do not need to commit to automating everything straight away but you can start to make your requirements more automatable. Avoiding the ‘overwhelm’ of automation is an important part of making the first steps into reducing your technical debt.

How do I make requirements more automatable?

There are numerous theories on how this can be done but the theory I prefer is to use Behaviour Driven Development (BDD) and it is something I truly believe can help to bridge the communication gap, reduce time spent maintaining requirement specs and increase the team’s overall understanding of the business requirements and therefore lead to a better implemented product.

Now I do not profess to be an expert in BDD in anyway but this is my general understanding of the concepts:

“Software delivery is about writing software to achieve business outcomes” – Dan North

Dan North is generally considered to be the father of BDD and a simple Google search on his name will reveal numerous articles on the subject and I would encourage any reader of this article to take a look at his blog and specifically introducing BDD. The concept behind BDD is that is takes the idea that you “can” turn an idea for a requirement into implemented, tested, production-ready code simply and effectively and in order to achieve this any requirement needs to be specific enough so that “everyone” knows what is going on. The overall goal of BDD is to achieve a common definition of “Done” in order to avoid “that’s not what I asked for” or “I forgot to tell you about this other thing”.

BDD takes the general Agile concept of User Stories and looks to extend them with acceptance criteria that is defined in the form of scenarios, a typical BDD user story is defined as follows:

Title (One line describing the story)
Narrative:
In order to [benefit]
As a [role]
I want [feature]

Scenario 1: Title
Given [context]
And [some more context]
When [event]
Then [outcome]
And [some other outcome]

Scenario 2: …

By working together to define a user story and all of it’s associated scenarios the team gains more knowledge of the requirement and they have one place (the user story) that can form the focal point for the definition of the feature. Any new scenarios that are thought of at any point prior or during the iteration should be added to the user story at the very least as a Scenario title that can be expanded at implementation time.

Who writes the user story?

This seems to be a common question especially amongst new Agile teams and I believe the answer is that everyone writes the user story. That is not to say that everyone writes the story at the same time but that the story will evolve over time and become more detailed as it touches on each discipline within the development team.

Product Owner communicates with the Stakeholders and help them to frame the narrative i.e. what is the high level feature?, and capture salient elements of that story in an informal way – the stakeholder does not always want or need to get bogged down in the language used to formally define a user story and scenarios
Testers help to further define the scope of the story and extract acceptance criteria by determining which scenarios matter and which are less useful
Developers may provide alternative approaches to delivering the story which in turn may influence the structure and focus of the story

More complex stories should involve whiteboard discussions to ensure that each member of the team has a common understanding of the story. Whether the story is elicited from end to end in a single meeting or over numerous time boxed iterative reviews the key to delivering a successful user story is communicating with the stakeholder to ensure that what you intend to deliver is what they expect you to deliver. Obviously in order to achieve this giving the team as much access to the stakeholder as possible would be ideal but where this is not possible then the Product Owner should take responsibility for ensuring that the stakeholder is kept up to date with any changes to the story definition.

Elaborating and formalising the story

The output from the story elicitation meetings will generally be in the form of a fairly loosely defined story with some informal concepts and ideas that capture the essence of the story and promote discussion about the key areas of the feature. The next phase is to begin taking those ideas and formalising them into well defined scenarios using a Given, When, Then (GWT) notation.

The goal of using GWT steps is to achieve a common language to describe the domain in which the feature exists. Having a structured common language makes automation far more achievable because it begins to make each team member talk using the same business terms and it defines steps that may apply to numerous test steps and aids the longer term maintainability of the specifications. By defining the feature in business terms and not being implementation specific you can achieve scenarios that are robust on top of an ever changing system – the goal of the feature should not have to change even if the application is re-written from a web app to a WPF app. “How” you prove that the system still meets the expected behaviour may change but the definition of “What” the system should do should remain fairly consistent and this should be a design goal when creating scenarios for your user stories. This blog post is a useful read to clarify the domain of a specification who's domain is it anyway.

Summary

Getting a handle on your requirements will play a major role in your ability to automate your acceptance tests and start on the road to reducing your technical debt, but once you have laid the foundations you will begin to see the opportunities to automate open up and become apparent in ways that you never thought would be possible.

Next Steps

Why not take either a new requirement or a relatively simple existing requirement and focus some energy to make the requirement more automatable, can you apply the ideas promoted by BDD to your user stories? Have a play with different ways of expressing your scenarios in the Given, When, Then format and then start to capture user stories in this format in your next elicitation or elaboration sessions.

In my next post I’ll discuss some practices to help getting automation done within the time scales of an iteration.

Automated testing: you know you need it, but how do you do it?

noreply@blogger.com (Richard Allen) — Mon, 23 Apr 2012 20:01:00 +0000

The world is becoming more and more Agile and many companies are discovering the undeniable truth that Agile software development provides a cost effective solution for delivering working software. Adopting Agile processes within your company and changing the general ethos of your working environment can be harder than it might first appear. Sure, the introduction of daily stand ups, user stories, story points, planning sessions and retrospectives all help to improve the efficiency and communication within your company but there is one important part to the process that gets left out because it is deemed "too hard" to start doing immediately - and that is Automation.

Automation is a fundamental piece to the Agile development puzzle that often gets overlooked and it is only when a development team is struggling to cover all of it's regression tests and bugs are starting to be found by customers that companies generally look to do anything about it. Without automation, every piece of software that gets written, tested and shipped to the customer becomes another piece of technical debt that must be manually tested in order to ensure that any future work does not impact the original expected behaviour of that software. Most software development teams try to negate this by hand picking "just enough" regression tests to cover what they believe should have been impacted by any changes within the current release and generally this works well enough until something "just gets missed".

Numerous studies have been made into the cost effectiveness of finding a bug as early as possible and it should be no different for finding regression bugs, but without increasing your test team exponentially as your technical debt grows it is inevitable that you will have to face the fact that you will need to automate your software testing, the question then becomes how?

Getting started with test automation?

I believe a good place to start is to look at what your current testing practices look like in the Automation triangle. There have been a number of authors (including but not limited to Cohn, Mezaro and Crispin) that have written about the concept of an automation triangle and this something that I wholly believe in. The image below shows some of the subtle variations of the automation triangle amongst authors and I recommend that you do some further reading around.

The base of the triangle represents your unit testing level and this should contain the vast majority of your tests. The second level are tests that check the service or api layer, this is where I believe you can obtain the most "bang for your buck" in testing and yet it seems to be the area where most test teams are lacking. The third level of the automation triangle is UI automation tests and finally at the fourth level there is still some need for exploratory manual testing but the critical point here is that if an issue is found whilst manually testing the system then this should be captured as an automation test as soon as possible in order to minimise the technical debt.

In my experience, most software development teams already do a lot of unit testing which is ideal for working in small units and testing elements in isolation but when it comes to automation of acceptance tests they are somewhat lacking. When the discussion of automation of acceptance tests begins it almost certainly starts by looking at automating the user interface (UI) of the product, after all this is what the customer sees, right? Unfortunately there is an implied cost to implementing UI automation tests that means they are generally the most brittle, the most costly to write and they take the longest time to run. That is not to say that there is no place for automation of the UI, quite the contrary in fact there is immense value in performing UI tests but these must be carefully chosen to ensure you are getting the most value in the least brittle way and the least time possible.

As companies start to implement automation tests the trend to gravitate towards implementing UI automation tests ends up making the automation triangle look a bit more like an hour glass shaped automation rhomboid with few if any service/api level tests. I believe the reason for this is that UI testing does not generally require a technical understanding of how the application works underneath. Tests can be written (using a huge variety of different types of tool) from the view of a system user and as such only tests things that the user can see through the UI of the system. This generally results in all test setup, execution and assertions to be performed via the UI which all takes time (too much time in most cases).

Typically the UI tests will be created using a point and click style of UI testing tool that allows the test team to learn and embrace a tool that they can own and take control of that will free themselves from some of the manual day to day grind of regression testing without the need for the developer team's involvement. Unfortunately choosing UI automation test tool is not enough to ensure the successful implementation of an automation test strategy.

How can I implement a successful automation strategy?

In my opinion, communication and collaboration is one of the most important aspects of Agile software development. Any tools that a development team chooses should first and foremost help to radiate knowledge and increase the overall ability of the team to interact and adapt to their ever changing environment in the quickest way possible. What I mean by this is that the process of determining what automation is necessary should be an integral part of the development teams process from the very start of the project and each subsequent iteration instead of something that the test team goes off and just gets done.

Summary

I thoroughly believe that in order to get the most bang for your buck from your test automation strategy you need to implement of a process that helps improve the communication and collaboration within your team so that testers are working closely with developers at all levels of the automation triangle, the goal of this process is to make your developers better testers and your testers better developers. After all each member of an Agile team should be cross functional – it may well be that your testers are your worst developers and your developers are your worst testers but the key thing to strive for is that they work together in order to deliver a better quality product.

Next Steps

Why not have a think about different ways that you could try and improve the way in which your development team members (Product Owner, Developers and Testers) collaborate and in my next post I’ll look at what I believe is the key to implementing a successful automation test strategy.

Getting the current framework SDK path from within MS Build

noreply@blogger.com (Richard Allen) — Fri, 20 Apr 2012 21:39:00 +0000

In LeaveWizard we currently use Linq To Sql and to generate a data context we use SqlMetal as part of the pre-build process of our data access assembly, the xml looks something like this:

 <Target Name="BeforeBuild">
    <Exec Command="&quot;C:\Program Files\Microsoft SDKs\Windows\v6.0A\bin\SqlMetal.exe&quot;  /server:.\HEATHERSQL01 /Database:LeaveWizard_UnitTests /code:LeaveWizardDataContext.cs /context:LeaveWizardDataContext /namespace:FeatureBase.LeaveWizard.DataAccess /views /sprocs /functions /pluralize /timeout:1200" WorkingDirectory="$(ProjectDir)" />
</Target>

As you can see the path to the SDK version number was being hard coded, which has been fine for a long time until I configured a brand new build server which did not have v6.0a of the SDK installed it had v7.1, so I needed a solution.

Thankfully it seems easy enough to do this, simply get the current framework SDK path location like so:

  <Target Name="BeforeBuild">
    <GetFrameworkSdkPath>
      <Output TaskParameter="Path" PropertyName="WindowsSdkPath" />
    </GetFrameworkSdkPath>
    <Exec Command="&quot;$(WindowsSdkPath)bin\SqlMetal.exe&quot;  /server:.\HEATHERSQL01 /Database:LeaveWizard_UnitTests /code:LeaveWizardDataContext.cs /context:LeaveWizardDataContext /namespace:FeatureBase.LeaveWizard.DataAccess /views /sprocs /functions /pluralize /timeout:1200" WorkingDirectory="$(ProjectDir)" />
  </Target>

Job done!

“sgen.exe” error while setting up Team City Build Server

noreply@blogger.com (Richard Allen) — Fri, 20 Apr 2012 21:26:00 +0000

I’ve recently set up a local build server for LeaveWizard and came across an issue:

“C:\WINDOWS\Microsoft.NET\Framework\v4.0.30319\Microsoft.Common.targets(2249, 9): error MSB3086: Task could not find "sgen.exe" using the SdkToolsPath "" or the registry key "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Microsoft SDKs\Windows\v7.0A". Make sure the SdkToolsPath is set and the tool exists in the correct processor specific location under the SdkToolsPath and that the Microsoft Windows SDK is installed”

After a bit of Google searching the answer was pretty simple, just download the latest version of the Windows SDK and then install the .NET Development Tools, simples .

Update:

I came across the same issue whilst installing another build server, this time it was on a Windows 2008 Server. I installed the SDK as stated previously but I was still getting the problem. It seems that the registry key for v7.0A just did not exist. Further Googling identified that you can configure which SDK version should be used by performing the following steps:

Go to “Start | All Programs | Microsoft Windows SDK 7.1” and start the “Windows SDK 7.1 Command Prompt”.

Type:

cd Setup
WindowsSdkVer.exe –version:v7.1

Now re-run your build and hopefully the problem has gone away, if not good luck finding the issue.

Life, Times and LeaveWizard

noreply@blogger.com (Richard Allen) — Fri, 20 Apr 2012 20:00:00 +0000

Well it has been far too long since I last ventured into the world of blogging but it seems that life suddenly got a little busy for me. What with having my family growing with the addition of two fantastic boys Jacob and Lucas and the very latest arrival (just over 1 week old) is my new beautiful baby girl Isabelle, co-coordinating of NxtGenUG Southampton, software contracting with Fitness First and more recently Active Navigation, working on a fantastic online leave management product with my good friend Plamen Balkanski time just seems to slip away from me.

Plamen wrote a post a little while ago about our product LeaveWizard for the first time since we’ve been developing it and this prompted me to think about my own blog (albeit a couple of months later) and how I could resurrect it by starting to talk about the kind of things we are doing with LeaveWizard. Previously most of my posts have had a bit of technical bias and I am sure that there will be plenty more of that to come but to kick the blog off again I thought I would just talk about what we’ve been doing with LeaveWizard.

So what is LeaveWizard anyway?

LeaveWizard is something that both Plamen and I are completely passionate about, we both seemed to have generally bad experiences when it came to holiday bookings. It always seemed like a hassle going something a little like this:

Go the HR team to pick up a holiday card
Determine what holiday allowance you actually have remaining (after a few discussions with the HR team about what leave you didn’t end up taking in the end)
Fill in all the relevant details and dates
Put the holiday card on your managers desk for approval (it generally goes straight into their in-tray because they are very busy and they are never at their desk)
Wait a couple of hours/days/weeks and ask your manager whether the holiday has been approved or not
Your manager finally approves the holiday and passes it on to the secondary approver (once again going into an in-tray because they are not at their desk)
Wait a couple more hours/days/weeks and ask the secondary approver if it has been approved or not
The secondary approver finally approves the holiday and gets the card back to HR without actually telling you whether it was approved or not
You then have to chase HR or the secondary approver to ask whether the holiday has been approved and you eventually get the confirmation you needed (this is normally the day before you are actually leaving for your holiday)
At this point all is well from your point of view but more times than not it turns out that during the time it took to get your holiday approved, a couple of other people on the team also had their leave approved and they end up being on leave at the same time as you!!!
This eventually causes a nightmare because you and this other guy should never be off at the same time and you end up getting in the neck because you didn’t collaborate over when you should or should not be on holiday!!

If this kind of thing sounds in anyway familiar then you will totally understand why we created LeaveWizard, we just figured it shouldn’t be that hard. So we set about creating a tool that would make the process something a bit more like this:

Log on to an online system that is available any time and anywhere across the globe
Instantly have access to your current leave allowance
Click a request leave button and enter your leave dates and submit your request (if too many people in your department are off on those dates already you are instantly notified)
Your leave request is instantly sent to your manager via email who can quickly see who else is on leave at the same time and instantly approve the leave request
You are sent an email stating “<ManagersName> has approved your leave and it has now been sent to <SecondaryApproversName> for secondary approver” so you know exactly what stage your leave request is at
The secondary approver receives an email detailing the leave request and can also see who is on leave at the same time and simply clicks “Approve” directly from the email content
You are then sent a confirmation email stating that your leave has been approved…woo hoo time to go on holiday!

Now I don’t know about you but I know which process I prefer which is why we created a tool to allow us to do exactly that and a whole lot more from request and approving overtime, defining flexible work patterns, configuring time off in lieu LeaveWizard has become an extremely flexible holiday management tool.

If you think that you company could benefit from using a tool like LeaveWizard to management your staff holiday, absences and vacations then why not try it out, it is totally free to use for up to 5 users. I would also love to get your feedback on anything you would care to comment on.

Deploying a VSTO Click Once Add-in - don't forget your MIME Types!

noreply@blogger.com (Richard Allen) — Mon, 07 Nov 2011 16:24:00 +0000

I just wanted to make a note of this for future reference and to help any one that might be struggling with this in the future:

I have just created a simple Excel 2007 office add-in and I wanted to deploy it to a local server on my intranet and allow other users to click a url and install the application. Using the project properties page I configured the relevant server details and successfully published the add-on on to the server.

But when I navigated to the specified install url I received 403 error This website requires you to login. After searching the web for a suitable answer I finally stumbled upon the answer on this web site:

http://social.msdn.microsoft.com/Forums/en-MY/winformssetup/thread/10ee1ca1-b3ae-4a6f-98ba-125179b9e417

In summary, don't forget to configure the .'vsto' MIME type with 'application/x-ms-vsto' on the virtual directory containing the add-in.

CodeKen - the replacement conference for StackOverflow DevDays

noreply@blogger.com (Richard Allen) — Wed, 05 Oct 2011 07:16:00 +0000

CodeKen London 2011 is a brand new developer conference delivering two days of hands-on coding oriented content over the 14 - 15th November in London. The event was organised in response to the cancellation of the Stackoverflow DevDays conferences and includes many of the original speakers like Jon Skeet, Robert Pickering and Richard Marr.

The talks cover a wide range of subjects including programming style, MongoDB, NodeJS, HTML5, REST services and more.

In addition to an eclectic mix of talks CodeKen 2011 is launching a developer side project competition. The goal is to encourage and publicise developers that are spending their spare time working on interesting projects. Five finalists will be given a free ticket to the conference and a chance to present their project at the event.

See the full conference schedule and more information on the CodeKen Side Project competition on the conference site - http://london2011.codeken.com

NxtGenUG Fest 10 - “Beside the C# side” – Bournemouth 16th July

noreply@blogger.com (Richard Allen) — Mon, 05 Jul 2010 23:06:00 +0000

NxtGenUG are pleased to announce their annual conference Fest10 will be taking place on Bournemouth Pier this year on Friday the 16^th July 2010 – It’s a great opportunity to take the family to the Seaside for the weekend, and catch up on technology. The best thing is attendance to the conference is free to members and just £59.95 for non-members.

Speakers

We have a great speaker line up this year, Google’s Jon Skeet will be talking about C#, Microsoft’s Glenn Block is coming over from Redmond to talk about MEF, Ryan Simpson will be giving us the lowdown on F#. We’ll also be having NxtGenUG veterans Mike Taulty, on OData and Chris Hay on Azure, Plus Marcus Perryman will be talking about one of the hottest technologies this year Windows Phone 7.

You can find a list of speakers and their sessions here

http://www.nxtgenug.net/fest10/Sessions.aspx

To register simply go to the following link and follow the instructions on screen.

http://www.nxtgenug.net/fest10

Parking, Hotels and Timings

Upto date Details on parking, hotel accommodation and timings for the day can be found on the Fest10 site. The nearest parking for Bournemouth Pier is either in the Bournemouth International Centre (BIC - 20) car park, the Bournemouth Pavilion car parks (19/24) or the car park next to the Royal Bath hotel (18). However, there is also further car parking available at Eden Glen car park (21), Winter Gardens car park (22) and Beacon Road car park (25). For Hotels, the RusselCourt is where the evening entertainment will be Quote: NxtGenUG when booking, otherwise Bournemouth has a large amount of hotels, including the Best Western Hotel Royale.

http://www.nxtgenug.net/fest10/

Geek Dinner

It's the Fest10 geek dinner - normal rules apply - pay for your own food/drink, and engage in great conversation, and eat fish and chips at Harry Ramsden’s. To register for the geek dinner

http://www.nxtgenug.net/ViewEvent.aspx?EventID=322

Post Fest Party

We’ll also be having a post Fest Party at the RusselCourt Hotel – If you’ve brought your family down for the weekend feel free to bring them along. Just register on the site and drop us an email on how many people you’ll be bringing with you toenquiries@nxtgenug.net

http://www.nxtgenug.net/ViewEvent.aspx?EventID=325

Sponsorship

NxtGenUG would like to thank DevExpress, our gold sponsor, along with Microsoft, RedGate, PluralSight and Apress for their support in making this event possible.

CSM course in Bournemouth 23 & 24 November

noreply@blogger.com (Richard Allen) — Mon, 02 Nov 2009 20:17:00 +0000

Geoff Watts will be holding a CSM training course in Bournemouth on the 23/11/2009 and 24/11/2009. For full details see here

An ASP .NET Testing Time Ahead

noreply@blogger.com (Richard Allen) — Mon, 17 Aug 2009 21:50:00 +0000

Thursday 20th August sees NxtGenUG Southampton hosting a web application testing session that is not to be missed. Testing guru and general all round community good guy Ben Hall is coming down to pay us a visit and talk about all things web test, Ben will be looking at how you can test different aspects of ASP .NET from the core engine to the UI and databases. Topics will include test driven development, mocking of external services as well as UI automation but probably most importantly Ben will be describing the best way to get started with testing you web application.

All in all this looks like a great session and if you are in the area I would definitely recommend paying us a visit.

Unit Testing ASP.NET? ASP.NET unit testing has never been this easy.

noreply@blogger.com (Richard Allen) — Wed, 20 May 2009 19:38:00 +0000

Typemock is launching a new product for ASP.NET developers – the ASP.NET Bundle - and for the launch will be giving out FREE licenses to bloggers and their readers.

The ASP.NET Bundle is the ultimate ASP.NET unit testing solution, and offers both Typemock Isolator, a unit test tool and Ivonna, the Isolator add-on for ASP.NET unit testing, for a bargain price.
Typemock Isolator is a leading .NET unit testing tool (C# and VB.NET) for many ‘hard to test’ technologies such as SharePoint, ASP.NET, MVC, WCF, WPF, Silverlight and more. Note that for unit testing Silverlight there is an open source Isolator add-on called SilverUnit.

The first 60 bloggers who will blog this text in their blog and tell us about it, will get a Free Isolator ASP.NET Bundle license (Typemock Isolator + Ivonna). If you post this in an ASP.NET dedicated blog, you'll get a license automatically (even if more than 60 submit) during the first week of this announcement.

Also 8 bloggers will get an additional 2 licenses (each) to give away to their readers / friends.
Go ahead, click the following link for more information on how to get your free license.

Using Linq to SQL to validate Data Access Logic

noreply@blogger.com (Richard Allen) — Wed, 29 Apr 2009 15:36:00 +0000

So Microsoft aren't going to be supporting Linq to SQL (L2S) see "Microsoft Kills Linq to SQL" for more info, but there are still some great situations that it can be really useful in your environment with it going into a production build and one of those is using L2S for testing your data access logic.

This post aims to talk you through a way of using L2S to confirm that what you think your data access logic is doing is what your data access logic is actually doing.

A really useful tool that comes with L2S is called SQLMetal, this tool is used to automatically generate a data context based on the current schema of a given database. So instead of using the fancy designer front end, you auto generate the whole database schema including Stored Procedures and Views if you want but you can restrict this if you want by simply not including the required input parameter. To do this every time your application builds simply amend your project file with the following ensuring that you replace the text in [] with your specific fields:

<Target Name="BeforeBuild">
    <Exec Command="&quot;C:\Program Files\Microsoft SDKs\Windows\v6.0A\bin\SqlMetal.exe&quot;  /server:[ServerName] /Database:[DatabaseName] /code:[MyDataContext].cs /context:[MyDataContext] /namespace:[MyCompany].[MyProject].DataAccess /views /sprocs /functions /pluralize  WorkingDirectory="$(ProjectDir)" />
</Target>

The parameters /views /sprocs /functions will expose all of the views, stored procedures and functions accordingly. The /pluralize parameter indicates that you want to generate plural names for tables so a table called "Customer" will be exposed as "Customers" in the data context. For full details of the parameter list go here. Once you've modified the project file reload it and when you next build the project file it will generate a data context for you with as much of your database exposed as you would like.

So now that we have our data context we can put this to good effect when testing our database access logic, for example take the following data portal insert method from a CSLA business object which will be called when our business object is new and the Save method is called:

protected override void DataPortal_Insert()
{
    using (var connection = ConnectionManager<SqlConnection>.GetManager("MyDatabase").Connection)
    {
        SqlCommand cmd = new SqlCommand();
        cmd.CommandType = CommandType.StoredProcedure;
        cmd.Connection = connection;
        cmd.CommandText = "usp_CreateEmployee";
        cmd.Parameters.AddWithValue("@FirstName", ReadProperty(FirstNameProperty));
        cmd.Parameters.AddWithValue("@LastName", ReadProperty(LastNameProperty));
        cmd.Parameters.AddWithValue("@EmailAddress", ReadProperty(EmailAddressProperty));
        cmd.ExecuteNonQuery();
    }
}

This method quite simply executes a stored procedure called "usp_CreateEmployee" and passes in the parameters from the business object. What we want to do here is validate that the parameters are correctly passed from our business object into our stored procedure and the stored procedure correctly performs an operation to insert a new employee with the details set on the business object. What we don't want to do here is have to write a whole bunch of code in order to do this, step in L2S.

So now back in our unit test we can do the following:

        [TestMethod]
        public void EmployeeIsCreatedInDatabase()
        {
            TestDataContext = new MyTestDataContext(CreateConnection());

            int initialCount = TestDataContext.Employees.Count();

            const string FirstName = "TestFirstName";
            const string LastName = "TestLastName";
            const string EmailAddress = "test@test.com";

            // Create business object and set values
            var employee = Employee.NewEmployee(CompanyId);
            employee.FirstName = FirstName;
            employee.LastName = LastName;
            employee.EmailAddress = EmailAddress;

            // Call save on business object, this will execute data portal logic 
            // and insert a new row in the database with the new values
            employee.Save();

            // Refresh our data context with data from the database
            TestDataContext.Refresh(RefreshMode.OverwriteCurrentValues);

            // Now get the new employee table count and assert it has increased by 1
            int newCount = TestDataContext.Employees.Count();
            Assert.AreEqual(initialCount + 1, newCount);

            // Now get a Linq Employee object directly from the data context and verify that
            // the all of the fields have been populated as we expected them to.
            LinqEmployee linqEmployee = TestDataContext.Employees.OrderByDescending(e => e.ID).FirstOrDefault();
            Assert.IsNotNull(linqEmployee);
            Assert.AreEqual(linqEmployee.FirstName, FirstName, "Expected first names to match");
            Assert.AreEqual(linqEmployee.LastName, LastName, "Expected last names to match");
            Assert.AreEqual(linqEmployee.Email, EmailAddress, "Expected email addresses to match");
        }

As you can see from the above code, the test creates a TestDataContext L2S object and takes an initial count of the number of employees in the Employee table and defines our test values as constants.

Next we create a new employee business object and set the appropriate values with the test data. We then call the Save method on the business object, this is the method we are actually testing and we want to ensure that it correctly passes the information set on the business object down to our data access layer and then the data access layer inserts the appropriate data into the relevant tables.

We can then verify that the Save method has done what it needed to do by using out TestDataContext, we simply refresh the data with values from the database and then perform some assertions. Firstly, we check that the employee count has incremented by 1, this ensures that an insert was performed on the table. Next, we sort the employees by Id and order descending ensuring that we get the latest Id generated by the table - our new employee should be the last row in the table (unfortunately the Last() function in L2S does not work so we have to do this order by descending approach). We then get an instance of this L2S object and perform assertions on its properties ensuring that the data we set on our business object has been set on the L2S object.

Conclusion

Linq to SQL may no longer be supported by Microsoft and as such might not be suitable for production ready systems, but it can still be a really useful tool especially when performing data tests to ensure our data access layers are performing as we expect. I hope you find this post useful and it helps you to get a bit more data access testing done. Let me know your comments.

Unit Testing CSLA with Type Mock Isolator

noreply@blogger.com (Richard Allen) — Tue, 28 Apr 2009 14:51:00 +0000

I am a huge fan of CSLA and look to try and use it in projects where ever I can as it just makes life so much simpler by taking some of the major decision points out of the development cycle allowing you to focus on the real problem which is defining and designing your business logic layer for what ever project you are working on.

As with any framework, CSLA has its benefits and it has its drawbacks, I am not going to go into all these in this post as there are plenty of people that have already had these discussions already but one of the major drawbacks I found was when trying to unit test my CSLA objects.

In a nutshell your CSLA based business objects inherit from a base class called BusinessBase<T>, this class implements a whole bunch of useful features such as authorisation rule checking, validation rule checking, n-level undo, distributed business objects via the data portal etc that can be utilised by any inheriting class.

Probably the key area is the Data Portal mechanism which performs the following (please note this is over simplified for clarity) when the Save() method is called on your business class:

Determine the state of your class, is it Valid (all data is correct) and Dirty (some data has changed)
Determine what kind of operation to perform (If the object is new then Insert else Update etc)
Serializing your business object
Transport the business object to your data access layer (which could be across a server boundary)
De-serializing the business object
Executing any required data access logic i.e. Insert, Update, Fetch operations
Perform any validation rules required
Serialize the object again
Transport the business object back to the application layer (which could be across a server boundary)
De-serializing the business object
Return a new instance of the application logic

As you can see CSLA does a lot of work under the hood which involves a lot (and I do mean a lot) of reflection which is all good for making your life as a developer great when developing the business domain but this becomes a problem when coming to unit test and mock out parts of the system.

CSLA encapsulates the data access logic methods i.e. DataPortal_XYZ within the business object, which is probably its most controversial point, but this does not restrict your choice of the actual data access mechanism that you want to use, I personally am using Linq to SQL as my data access layer and find that it is extremely quick and easy to:

Add new columns to the database
Expose them via Linq to SQL
Expose them in the business object
Add any validation rules in the business object
Put a field on the UI

That said, any other type of data access could easily used instead such as Linq to Entities, NHibernate, ADO .NET etc etc.

So hopefully you are starting to see the problem we might have with unit testing, essentially as soon as you perform an action on an object such as set a property, CLSA will perform some behind the scenes work to execute authorisation and validation rules to determine whether the current user is permitted to perform the action and then determine whether the property is valid after its value has been set. It is this "behind the scenes" work that is absolutely awesome and makes CSLA a great framework but makes the mocking and unit testing almost impossible as it becomes very difficult to isolate the various parts of the business object.

I have been working Rhino Mocks for a while and found that this has been great especially when compared to NMock but when I tried mocking a CSLA object it let me down. It seems that the problem is that Rhino Mocks relies on Dependency Injection to perform its mocking and because CSLA objects are generally closed and do not expose ways of injecting mocks into the objects it is impossible to replace the data access logic with a mock replacement - or so I thought until I came across TypeMock.

TypeMock Isolater uses Aspect Oriented Programming to create a mock aspect, it essentially monitors the applications execution and registers an interest in specific methods on an object with the .NET framework API, when the method is called the .NET framework notifies the TypeMock and allows it to return mocked objects or values. What this means is that we don't need to change our objects and sacrifice our "good OO design" in order to perform unit testing of our objects.

Here is a very simple example of how I have used Type Mock to fake a couple of child objects that exist on my Employee class, I want to test the validation rules on the Employee object but I do not want to have to load or create a new instance of either Workgroup or Role properties so I simply create a "fake" instance using the Isolate class:

        private Employee CreateEmployee()
        {
            var employee = Employee.NewEmployee(CompanyId);
            employee.FirstName = "Test";
            employee.LastName = "Employee";
            employee.EmailAddress = "test.employee@testcompany.com";
            employee.Workgroup = Isolate.Fake.Instance<Workgroup>();
            employee.Role = Isolate.Fake.Instance<Role>();
            return employee;
        }

Now my Employee class has all of its properties set (two of them with fake objects) and therefore will be valid, I can independently test each validation rule to ensure that they are fired correctly when the relevant property on the object changes, in the following case I ensure that the "Email address is required" rule is fired:

        [TestMethod]
        public void EmailAddressIsRequired()
        {
            var employee = CreateEmployee();
            employee.EmailAddress = null;

            Assert.AreEqual(1, employee.BrokenRulesCollection.Count());
            Assert.IsTrue(employee.BrokenRulesCollection[0].Property == "EmailAddress");
            Assert.IsFalse(employee.IsValid);
        }

Now admittedly I could have achieved the same thing here using Rhino Mocks and creating a mock instance of each of the classes, but lets say for example the Employee object has a custom validation method that using a command object to determine whether an employee with the same email address already exists, the command object might look something like this:

        class EmployeeExistsCommand : CommandBase
        {
            public bool EmployeeExists { get; set; }
            public string EmailAddress { get; set; }

            private EmployeeExistsCommand(string emailAddress)
            {
                EmailAddress = emailAddress;
            }

            public static bool CheckIfEmployeeExists(string emailAddress)
            {
                var cmd = new EmployeeExistsCommand(emailAddress);
                cmd = DataPortal.Execute(cmd);
                return cmd.EmployeeExists;
            }

            protected override void DataPortal_Execute()
            {
                using (var ctx = Csla.Data.ContextManager<HolidayPlanrDataContext>.GetManager(HolidayPlanr.DataAccess.Database.HolidayPlanrDb))
                {
                    var data = from e in ctx.DataContext.Employees
                               where e.Email == EmailAddress
                               select e;

                    EmployeeExists = data.SingleOrDefault() != null;
                }
            }
        }

The main thing to note here is that this command makes a trip to the database via Linq to SQL in order to determine whether an employee with the same email address already exists. If we add a custom validation rule to our Employee class to execute this command like so...

protected override void AddBusinessRules()
{
    ValidationRules.AddRule(CommonRules.StringRequired, FirstNameProperty);
    ValidationRules.AddRule(CommonRules.StringRequired, LastNameProperty);
    ValidationRules.AddRule(CommonRules.RegExMatch, new CommonRules.RegExRuleArgs(EmailAddressProperty, @"\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*"));
    ValidationRules.AddRule(Rules.ObjectRequired, FirstNameProperty);
    ValidationRules.AddRule(Rules.ObjectRequired, LastNameProperty);
    ValidationRules.AddRule(Rules.ObjectRequired, EmailAddressProperty);
    ValidationRules.AddRule(Rules.ObjectRequired, RoleProperty);
    ValidationRules.AddRule(Rules.ObjectRequired, WorkgroupProperty);
    ValidationRules.AddRule(EmployeeAlreadyExists, EmailAddressProperty);
}

And the static method that implements the logic looks like this:

        private static bool EmployeeAlreadyExists(object target, RuleArgs args)
        {
            if (target is Employee)
            {
                var employee = target as Employee;
                if (employee.IsNew)
                {
                    if (EmployeeExistsCommand.CheckIfEmployeeExists(employee.EmailAddress))
                    {
                        args.Description = string.Format("An employee already exists with email address {0}", employee.EmailAddress);
                        return false;
                    }
                }
            }
            return true;
        }

Now when we run our unit tests the creation of our Employee object will execute the validation rules and therefore call the static method and make a call to the database to determine whether the employee already exists which is what we don't want to happen because now this rule will fire for all of my other tests.

This is, as I see it, where the power of Type Mock Isolator comes in, what I can do now is define an Isolate command to intercept any calls to the EmployeeAlreadyExists method and simply return the validation result I want. So I can do this by declaring the following in my CreateEmployee method:

private Employee CreateEmployee()
{
    Isolate.NonPublic.WhenCalled(typeof(Employee), "EmployeeAlreadyExists").WillReturn(true);
    
    var employee = Employee.NewEmployee(CompanyId);
    employee.FirstName = "Test";
    employee.LastName = "Employee";
    employee.EmailAddress = "test.employee@testcompany.com";
    employee.Workgroup = Isolate.Fake.Instance<Workgroup>(Members.CallOriginal);
    employee.Role = Isolate.Fake.Instance<Role>(Members.CallOriginal);

    Isolate.Verify.NonPublic.WasCalled(typeof (Employee), "EmployeeAlreadyExists");

    return employee;
}

So now prior to creating a new instance of the Employee object I define an isolation of a non-public method called "EmployeeAlreadyExists" on the class Employee and set its return value to "true" ensuring that by default this validation rule will always be true allowing me to continue and isolate my other validation rules.

The second statement I added was just a verify statement which ensures that a call was actually made to the "EmployeeAlreadyExists" command, so this lets me know if there was a problem in the actual call to the method.

Conclusion

Type Mock Isolator allows areas of a system that were previously un-testable/mockable to now be tested and mocked in a nice and easy to understand way, I like it very much because it now gives me the ability to write some much more in depth CSLA unit tests without breaking my OO design.

It is very powerful and could easily be mis-used or over-used but with benefits of increasing general unit test coverage it is probably worth it.

One major drawback is the lack of a community edition, the product comes with a 21 day enterprise license that reverts to the free features after the trial period. The single user license priced at 89 euros which I suppose could be well worth the price considering the peace of mind that could be achieved after unit testing those hard to reach places - all in all I like it and would recommend others at least give it a try.

UK South Scrum User Group (UKSSUG)

noreply@blogger.com (Richard Allen) — Tue, 28 Apr 2009 07:08:00 +0000

It's been a while since I last blogged, can't really think of a decent reason apart this thing called Twitter taking up a fair bit of time recently, I've not been twittering myself all that much but doing lots of reading of tweeple's tweets in the twittersphere.

Anyway, with that out of the way, last night I went to the second meeting of the UK South Scrum User Group to talk about "The Definition of Done", something that seems to plaque the majority of people developing software.

It was a great evening lead by Mike Williams, we discussed the various stages of "done" including Tasks, User Stories, Iterations and Releases and everybody suggested ways in which it is possible to define "done" and talked about ways in which any problems we were facing could be addressed.

All in all a great second night of the user group, its great to be apart of a group that I am not running so that I can actually participate rather than constantly trying to organise the next thing for NxtGenUG. If you fancy coming along to UKSSUG, it's an open invite and totally free, keep an eye on the linked in group and we'll get the next meeting date posted up soon.

New South Coast Scrum User Group

noreply@blogger.com (Richard Allen) — Tue, 31 Mar 2009 12:47:00 +0000

The South Coast now has a new user group for all those interested in Scrum and anything Agile. Plamen Balkanski and a couple of other Agile enthusiasts have setup this user group to help spread the word of Scrum within the local area, anyone is welcome whether you are new to Agile or an experienced Scrum Master.

The next session will be on 27th April and the topic is "Getting acceptable definition of done" - which seems to be a bit of a classic Agile development issue.

The meeting starts at 19:00 and will continue until 21:00 and can be found at:

The Inn on the Furlong
Meeting House Lane
Ringwood
Hampshire
BH24 1EY

http://www.ringwoodbrewery.co.uk/iof.htm

To register for the event go to: http://ukssug.eventbrite.com , it's free but this is necessary so we know how many people are going to attend. You can also join the LinkedIn group here, where you will find discussions, notes and links with details from previous meetings.

Look forward to seeing you there.

I am on Twitter

noreply@blogger.com (Richard Allen) — Fri, 06 Feb 2009 12:07:00 +0000

For anyone interested, I am now on Twitter: http://www.twitter.com/rich_allen.

Subtle changes to Tortoise SVN increase machine performance

noreply@blogger.com (Richard Allen) — Fri, 06 Feb 2009 11:59:00 +0000

For the last I don't know how long, I've been complaining about the speed of my work desktop machine. It's a dual-core with 2GB RAM running XP but it runs like an absolute pig. A colleague of mine recently did some digging and found that unless you make some subtle changes to Tortoise SVN it does quite a bit of unnecessary work in the background.

Quote from colleague:

"I think a significant factor in our machines being slow is Tortoise performance as it is monitoring and caching all file modifications (it is the biggest user of CPU time on my box).

This article makes some recommendations - http://tortoisesvn.net/node/267.

I’ve followed a couple and it seems to have made some difference:

1. Right Click->Tortoise->Settings – Icon Overlays Tab

Add excludes to all drives.

Add an include to your working directory only.

2. Remove all currently unused source directories - > I have removed the branches etc and only have MF and MIS trunk checked out for instance."

Also, doing the following can help if you don't mind losing the pretty overlay icons on some of your files:

Select status cache = none.

This means you lose having meaningful icons on the your source folders, but the rest of tortoise works – commit/update/get modifications etc.

I can live without the icons….

Since making these changes I have seen a marked difference in how my machine responds...hooray!

BHF - Bournemouth Bay 10K Run 2009

noreply@blogger.com (Richard Allen) — Thu, 08 Jan 2009 11:22:00 +0000

Now I am a little confused as to how I have actually got myself into this but in the whirl wind return to work after a great Christmas and New Year, a colleague at Fitness First decided to send a link around and say that he was taking part in the Bournemouth Bay 10K Run for the British Heart Foundation.

Before I knew it a couple of other colleagues had signed up to it and I compulsively found myself stating something like "...yeah sounds good to me, where to I sign...". So I am firmly signed up to this huge challenge (I am a software developer not a road runner by any means) and so the training has started and the plea for aid and donations has begun.

I've not really done anything like this before but if anybody is interested in helping me raise money for the British Heart Foundation or simply wants to be bet that I cannot do it (should encourage me some more), then please feel free to pop along to My Fundraising Page or use the widget in the side bar and donate as much as you can afford.

Many thanks

The Tricky Design Experience with Dr. Neil Roodyn

noreply@blogger.com (Richard Allen) — Thu, 08 Jan 2009 10:13:00 +0000

Next week on Thursday January 15th we've got Tricky Basset coming to show us the 'Tricky Design Experience' at NxtGenUG Southampton. After seeing Bill Buxton's key note at Remix '08 it became clear that Microsoft is really moving into this design space with some considerable vigour, the concept of people not buying products but buying experiences is something that Microsoft seem to have missed over the years whereas companies like Apple have seemed to excel.

Tricky will talking us through his team's iterative approach to design including Branding, Ideation, Research, Sketching and Conceptualisation and showing off some great WPF and Silverlight projects.

As a special treat Tricky has invited Dr. Neil Roodyn (MVP) to travel all the way from the land of Oz to join him for this exclusive session at NxtGenUG Southampton, together they shall be providing an interactive session with lots of audience interaction.

Design is something that I've always wanted to get a grip on (in that I have no design skills whatsoever) and I personally can't wait for this session it is stacking up to be an awesome experience and one not to be missed.

See you there!

Awesome WPF Data Binding Session

noreply@blogger.com (Richard Allen) — Fri, 12 Dec 2008 11:25:00 +0000

Last night saw a great session at NxtGenUG Southampton with Josh Twist showing us his WPF data binding and Expression Blend skills. It was the second time I've seen him do this session and its still great.

For anyone interested Josh's blog is: http://www.thejoyofcode.com

Lets Twist Again

noreply@blogger.com (Richard Allen) — Wed, 10 Dec 2008 13:50:00 +0000

If anybody attended Fest '08 this year and you managed to see Josh Twist perform his WPF and data binding magic then you will know that this guy is an excellent speaker who delivers a fun packed informative session that certainly left me thinking "wow...so that is how you are supposed to use all of this Expression Blend stuff".

Well tomorrow sees the return of the Twist to NxtGenUG but this time we have the pleasure of his company down on the south coast in the Southampton region, Josh will be giving us a WPF and data binding refresher with some new stuff for those that managed to catch the Fest 08 session.

Of course there will be the usual pizza and swag and hey as it's the festive may be there will some merriment of some kind.

Hope to see you there

Richie's World

Missing webapplication.targets error on a build server

Scott Hanselman User Group Tour of Scotland

9 July – Edinburgh: Developing for the Mobile Web

10 July – Dundee: Personal Productivity – Scaling yourself in the face of Information Overload

12 July – Aberdeen: One ASP.NET – Open Source, .NET and the Cloud

13 July – Glasgow: One ASP.NET – Open Source, .NET and the Cloud

A breakdown of the Given, When, Then steps

Given

When

Then

Getting automation done - inside an iteration!

Laying the foundations

The importance of Given, When, Then

Phases of the Iteration

Summary

Next Steps

What is the key to successful test automation?

How do I make requirements more automatable?

Who writes the user story?

Elaborating and formalising the story

Summary

Next Steps

Automated testing: you know you need it, but how do you do it?

Getting started with test automation?

How can I implement a successful automation strategy?

Summary

Next Steps

Getting the current framework SDK path from within MS Build

“sgen.exe” error while setting up Team City Build Server

Life, Times and LeaveWizard

So what is LeaveWizard anyway?

Deploying a VSTO Click Once Add-in - don't forget your MIME Types!

CodeKen - the replacement conference for StackOverflow DevDays

NxtGenUG Fest 10 - “Beside the C# side” – Bournemouth 16th July

CSM course in Bournemouth 23 & 24 November

An ASP .NET Testing Time Ahead

Unit Testing ASP.NET? ASP.NET unit testing has never been this easy.

Using Linq to SQL to validate Data Access Logic

Unit Testing CSLA with Type Mock Isolator

UK South Scrum User Group (UKSSUG)

New South Coast Scrum User Group

I am on Twitter

Subtle changes to Tortoise SVN increase machine performance

BHF - Bournemouth Bay 10K Run 2009

The Tricky Design Experience with Dr. Neil Roodyn

Awesome WPF Data Binding Session

Lets Twist Again