The Dynamic Programmer

MongoDB provider for Blogengine.net, saving a Post – Part 2

Hernan — Wed, 10 Mar 2010 19:00:16 GMT

Yesterday we created our first method in the MongoDbProvider, our implementation of BlogProvider. We created a few supporting classes, but we don’t have test for those classes. We recognize that we went a little bit too far in our coding. We got carry away and we started to implement a little bit more than needed to make the test pass.

So let’s fix that. First we need to see our first test passing. We run it expecting to fail to save and load the post but we have a different Exception thrown.

If we look at the code we notice that we made a big mistake in the Mongo class. We declared a _server private field but we are initializing a local server variable.
So when calling Disconnect on _server inside the Dispose method we get the NullReferenceException.
Let’s write a test to reproduce that bug at the unit level and see what else we can fix in that class.

Looking at it we discover a few dependencies that can be brake. First we create an IMongoMapperFactory interface and we make MongoMapperFactory to implement it.
There is another dependency, the name of the database to use. We made both parameters for the constructor inverting the dependencies.


            1:         public MongoDb(IMongoMapperFactory
mongoMapperFactory, string dbName) 
            2:         {

            3:             _mongoMapperFactory = mongoMapperFactory;

            4:             _dbName = dbName;

            5:         }

We also changed the Insert method:


            1:         publicvoid Insert<TEntity>(TEntity
entity) 
            2:         {

            3:             var document = _mongoMapperFactory.GetMapper<TEntity>().Map(entity);

            4:             Db(db=> db.GetCollection(entity.GetType().Name+"Docs").Insert(document)); 
            5:         }

Notice that the private Db method now takes an Action<Database>


            1:         privatevoid Db(Action<Database>
action) 
            2:         {

            3:             using (var
server = getServer()) 
            4:             {

            5:                 var db = server.getDB(_dbName);

            6:                 action.Invoke(db);

            7:             }

            8:         }

            9: 

           10:         private Mongo
getServer() 
           11:         {

           12:             var server = new Mongo(); 
           13:             server.Connect();

           14:             return server; 
           15:         }

And the newly created getServer() helper method to clean up the code. We also made some changes on the query method but I will leave that for the next post.

Our passing test result indicates some success.

Next: Mapping from Document to Entity and back.

Creating a MongoDB provider for Blogengine.Net – Part 1

Hernan — Tue, 09 Mar 2010 04:31:11 GMT

The code in this post is of demo quality and should not be taken as production ready code. It’s a first take on the project and will evolve during a series of posts.

Blogengine.net is an open source blogging platform written in asp.net. The engine comes with two Data store providers a DB provider and an XML provider. Since the engine is using the provider model, it should be fairly easy to write a new data store provider.

As you may have noticed by some of my previous posts, I’m really interested in alternatives to relational databases, the so called NoSql movement.

Getting all the pieces together.

First download the Blogengine.net source code from codeplex.com, a mongodb driver for .net and mongodb.

At the moment I’m aware of two drivers for .net, the more mature mongodb-csharp and a more resent one NoRM. NoRM is trying to provide a more OO experience, avoiding the use of strings as much as possible and embracing Linq, it’s still very young but very promising. You can check an article by Rob Connery to learn some of the capabilities. We will be using mongodb-csharp in this example. (Build from 2010-03-01).

Be certain of download the proper version of MongoDB for your OS 32 or 64 bits.

Installing MongoDB

Unzip the files downloaded into a folder of your choice. I’m using c:\MongoDB.

Create a data and db folders under c, you should have something like c:\data\db

Run mongod.exe from the mobogodb bin folder.


          c:\MongoDB\bin>mongod.exe

          mongod.exe --help for help and startup options

          Fri Mar 05 23:09:29 Mongo DB : starting : pid = 0 port = 27017 dbpath = /data/db/ master = 0 slave = 0  64-bit

          Fri Mar 05 23:09:29 db version v1.2.4, pdfile version 4.5

          Fri Mar 05 23:09:29 git version: 5cf582d3d96b882c400c33e7670b811ccd47f477

          Fri Mar 05 23:09:29 sys info: windows (6, 0, 6002, 2, 'Service Pack 2') BOOST_LIB_VERSION=1_39

          Fri Mar 05 23:09:29 waiting for connections on port 27017

To stop the daemon just type Ctrl+c.

Setting up the project.

You can download the project as I have it set from my codeplex repo using Mercurial to save you some time.(Changeset 59b63f72169f)

What I did was to create a new folder \lib under the solution root (of the BlogEngine.Net code), added Nunit, Rhino Mocks and the MongoDb drivers libraries. Them from within VS I added an Specs project to hold my test and a second project to hold the code for the provider.

You should have something like this right now.

And the following directory structure.

You may not have the Resharper files and folders, that depends if you have Resharper installed or not.

Lets write the first test for our MongoDBProvider and generate the class, it needs to inherit from BlogProvider.

Even when I have the source I’m treating BlogEngine.Net as a close system. This change a little bit the way I will develop such a provider. I have control of the code there are a bunch of stuff that I will probably refactor or move around. But in this case I can’t since I don’t want to fork the project.

The first test will be to insert a new post. The code will look something like this.


          
            public
            override
            void InsertPost(Post
post) 
                  {

          
            using (var
db = new MongoDB()) 
                      {

                          db.Insert(post);

                      }

                  }

Let’s take a look at the MongoDB class.


            1:     publicclass MongoDB
: IDisposable 
            2:     {

            3:         private Mongo
_server; 
            4:         private Database
_db; 
            5: 

            6:         public MongoDB() 
            7:         {

            8:             _server = new Mongo(); 
            9:         }

           10: 

           11:         private Database
Db() 
           12:         {

           13:             if (_db
!= null) return _db; 
           14:             var server = new Mongo(); 
           15:             server.Connect();

           16:             _db = server.getDB(BlogSettings.Instance.Name.Replace("",
"_")); 
           17:             return _db; 
           18:         }

           19:         publicvoid Insert<TEntity>(TEntity
entity) 
           20:         {

           21:             Document document = DocumentMapperFactory.GetMapper<TEntity>().Map(entity);

           22:             Db().GetCollection(entity.GetType().Name+"Docs").Insert(document); 
           23:         }

           24:         

           25:         publicvoid Dispose() 
           26:         {

           27:             _server.Disconnect();

           28:             _server.Dispose();

           29:         }

           30:     }

In line 27 I made sure we disconnect from the db. Note in line 21 that I’m getting a mapper from a factory. This is an obvious requirement since we need a mechanism to map from our objects to the documents and back.

In the next article we will take a look at the Mapper class for Post, save and update our first entity.

Clone a project on Codeplex to your own Codeplex repo with Mercurial.

Hernan — Wed, 03 Mar 2010 04:48:20 GMT

If you use Github (Git) or Bitbucket (Mercurial) you are familiar with the ability to fork a project into your own repository in those sites.

Once forked you can start working in your own repo and once you are ready to integrate you will send a pull request to the master repository.
Codeplex recently started using Mercurial but it doesn’t have (or I couldn’t find) a way to clone a project directly from inside Codeplex.

UPDATED March 5: Yesterday Codeplex added support for forks, check this article here .

First, cloning to your local computer

You need to have TortoiseHg installed on your computer before going forward with this tutorial.

First you need to check out the project you want to fork using the clone url:

Go to the source control page of the project and click on the source control connection instructions.

Copy the clone url and open the TortoiseHg clone window.

Enter the repository url as the source path and select a folder where to clone the repository. If you don’t have a folder already created for this repo, just add the name in the destination path text field and the folder will be create.

Second create a project on Codeplex and add as a Sync source.

Log into Codeplex (or create an account) and create a project where you want to work on, make sure you select Mercurial as your source control.
You should be able to also use Google code to host your clone, everything should work the same, just make sure you use Mercurial as well.

Once the project is created go to your new project source control page and copy the address to your repository.

In your computer open the properties of your cloned repository (the one we cloned in the previous step).

Go to the sync tab and click in the Add button.

Notice that the default (an only) repository is the original one, we want to add the repo to our newly created project and set it as default.

If you are using https authentication make sure you add your username and password following this form: https://username:password@hg01.codeplex.com/repository
Add any Alias name but not “default”, not now. Click Ok.

Select the Remote repository marked as default and click the edit button, change the alias from default to “origin”

Now in the sync dialog select the new repository (the one pointing to your project) and click the Set as default button.

Once done you should have something like this, the name of the projects should reflect the projects you are working with.

At this moment you are ready to push the code to your new project, just open the synchronize window from TortoiseHg and click push.

Once this is done, go to the source code tab in Codeplex and take a look, notice that you should have all commits from the original project plus any new commits done into your clone, in this case I added three commits after cloning.

From inside Visual Studio

Or course this works from inside Visual Studio as well if you have the Hg plug-in installed

Videos of the PyCon 2010 sessions.

Hernan — Thu, 25 Feb 2010 14:15:03 GMT

If you, like me, haven’t been able to go to PyCon don’t despair. The videos of the sessions are available at blip.tv, just visited http://pycon.blip.tv/ or http://pycon.blip.tv/posts?view=archive&nsfw=dc for a list of all the videos.

Some of my recommendation so far.

Test and Testability, http://pycon.blip.tv/file/3261272/

Selenium RC with Python, http://pycon.blip.tv/file/3264579/

What every developer should know about database scalability: http://pycon.blip.tv/file/3261223/

Going mobile with Mippin.

Hernan — Thu, 25 Feb 2010 13:35:11 GMT

This blog is going mobile. I will be using the services of Mippin. To visit the mobile version of the site just go to: http://mippin.com/dynamicprogrammer

Digging SpecFlow, misspelling Gerkhin files

Hernan — Tue, 23 Feb 2010 15:39:55 GMT

I’m a proponent of dynamic languages and I love Ruby and Cucumber but I have to admit that this is cool. I was writing a set of specifications with SpecFlow today and suddenly I saw this error in Visual Studio.

Double clicking the line takes you to the misspelling error in the Specification file.

I though that was really cool, specially for the slightly dyslexic programmers like myself. :-)

Mercurial integration with Visual Studio

Hernan — Sat, 20 Feb 2010 04:57:28 GMT

I recently posted about how to integrate Git with Visual Studio. Of course Git is not the only DVCS out there.

Mercurial is another source control system similar to Git that is having more and more relevance. Google code have been supporting it for quite a while and recently Microsoft announced that Codeplex is adding it as an option for new projects. (Codeplex already supported TFS and Subversion).

At work we use Fogbugz as our bug tracking/project management tool. A few months ago the people at Fogcreek started a beta for Kiln a code review/source control system that runs on top of mercurial.

I sign up for the beta and have been running a pilot project on it. Since I really like it I decided to start moving all our projects to Kiln and ditch Subversion. The piece that I was missing was a good integration into VS for the rest of my team.

A few day ago I found Mercurial VSS an integration package for Mercurial into VS.

The installation is very simple, just select the version of VS you want to install against (version 1.0.7 released today integrates without problems with both VS 2008 and 2010 RC).

After installed go to Tools –> Options and make sure you select display all options (only in VS 2008).

Select the Source Control option and in the Plug-in Selection option change it to Mercurial.

After open a project (even one that is already under source control) you will need to select the Add to source control option from the contextual menu inside the Solution explorer.

After added you will se a tilde besides each project.

This are the options available from the contextual menu.

And a few screen captures of the different options.

Change log

Commit

History

Pull

Push

Revert

Conclusion

WIth the support from Codeplex and Google code to Mercurial and the tight integration that this plug in presents I see no reason why people will not use it as the DVCS of choice for .net open source projects hosted on those sites.

Book review: Agile Retrospectives – Making good teams great.

Hernan — Fri, 19 Feb 2010 04:00:16 GMT

This is a very short book on a great practice for any agile team. The book walk you through a lot of techniques an exercises that will help you and your team to have successful retrospectives.

The first 3 chapters provide information on what retrospectives are about. How to create one for your team and what you need to learn to lead them.

The next 5 chapters provide techniques that will help you to go through the different stages of the retrospective. Each technique is clearly explained, with step by step guides and diagrams (when necessary) to provide more information. In some cases, when some techniques are complimentary, this is clearly indicated.

The authors also provide guidance on the scope where to apply the activities and a time estimate.

The previous to last chapter talk briefly about release retrospectives and the last one give some pointers in how to act on the actions, resolutions and experiments the team agree to follow.

If you work as a team lead in an agile team and you are in charge of facilitating the retrospectives, this book is a good tool to have.

Continuous Improvement: my list of books for the next little while.

Hernan — Thu, 18 Feb 2010 03:55:56 GMT

Yesterday I received another box of books from Amazon.ca with 6 more books in it. After taking them out and putting them down into my already filled shelves I sat down and look at the pile of books. 17 computer books in all that I haven’t started or haven’t finished.

I decided that it was time to make a list and put some kind of priority/order on the reading ahead.

So here it goes, this is the list (in order for now) of books that I plan to read in the next 6-9 months.

Computer programming and methodology)

Agile Retrospectives: Making good teams great (~~in progress~~ Finished) (BTW: I just found this presentation from the authors at Google)
Growing object-oriented software guided by test (in progress)
User stories applied.
Testing ASP.NET Web applications.
Debug it!
Ship it!
IronPython in Action (finish this one. It’s a great book. I’m just busy)
Beginning Scala.

[The order after this one is just tentative]

Designing the obvious.
C.O.D.E The hidden language of computer software and hardware (in progress – fantastic book, geeky, deep and incredible well written)
Designing the moment.
Expert F#.
Release it!
DSLs in Boo.
Web application hackers handbook. (probably need to read this sooner)
Agile principles, patterns and practices in c#.
ASP.NET MVC framework unleashed.
Foundation Expression Blend 3 with Silverlight. (Finish this one, but since Silverlight 4 is coming I may just wait).

General reading.

Brain rules.
Once more around the park.
The boys of summer.

I will try to keep this list updated (I make no promise though) and post a brief review of the books that I like the most.

Git integration with Visual Studio

Hernan — Mon, 15 Feb 2010 22:45:16 GMT

I started to use Git seriously 5 months ago when I sign up for my Github account on September 1st 2009. Before that I was a ~~very~~ happy subversion user. One of the things that I really like about Git is the speed.

I decided to use Git from the command line to learn and understand the commands really well. I occasionally used the GUI to perform some tasks that seemed easier to do that way.

Git within VS.

Even when I really enjoy working from the command line I know that some developers prefer to stay within the IDE and I understand that. Yesterday while installing VS 2010 RC in my newly paved laptop I decided to check out the Git Extensions.

After installing it VS presents a new menu item for Git.

From this menu you have access to the most common commands for Git.

For example you can commit after doing some work on your project (Note: It looks like you have to be in at the project level and not at the solution level in the solution explorer for the commands to work. Although they work in the whole solution as expected.)
One thing to notice is that the dialog pick up changes to files modified or added outside the IDE as well.

This is the push dialog box, you can select the Remote to push to and the branch from where you want to push.

If you need to enter a passphrase a command prompt window pops up:

After entering the passphrase you get a confirmation dialog:

You can also pull from remote, where you can select to merge, do a rebase or just pull changes.

Conclusion.

I don’t see myself moving away from the command line but I think is a good alternative

Technorati Tags: Git,Visual Studio,Integration

Using SpecFlow + WatiN or BDD for web applications without leaving the CLR.

Hernan — Wed, 03 Feb 2010 04:45:36 GMT

Last week I wrote about using cucumber to test your web applications outside in. In the post I showed a simple example (actually comes with cucumber) to open a browser, go to a site and perform some actions.

I showed the same to my team at work and they mention that could be nice to been able to use c# and Visual Studio to do something similar.

After thinking about it I decided to give another try to a tool I check a few month ago. SpecFlow.

SpecFlow is a tool and a set of libraries to write specifications using Gherkin. You can check the screencast here or read this post from Ryan Lanciaux. SpecFlow can use either NUnit or MsTest as the engine.

Now I needed something to drive the browser. WatiN is the .Net port of WatiR and is very easy to use. The problem is that needs to run in a single thread process, so when called from inside an NUnit test we need to add the STAThreadAttribute to the Test method.

Of course, this is not a problem when you are writing the Test methods yourself but the way SpecFlow works is that the actual Test method is generated by a tool from your .feature file.

The code looks like this (actually I edited it a little bit to make it nicer).

So you need to add the STAThreadAttribute to this method.

This works great and I was able to drive the browser and write a few test in no time. The problem is that ~~if you edit~~ every time you edit the .feature file this class will be re-generated and you will have to re-add this attribute. (Note: I forked the repo on GitHub, made a change to the source code and sent a pull request to add this attribute by default, not sure if it will be accepted or not).

I think that the integration from SpecFlow with VS is great. If you or your team feel very strong on using VS this is a very good tool (there are versions for both VS 2008 and 2010). After writing the features and running the test you will have hints and code to copy and paste from the TestRunner into the specification class.

You will generate the specification from an item template.

Conclusion:

I think that this is a great tool, specially if you are using it to develop desktop apps or library code in c#. You can use tools like R# to generate your classes and methods from the step definition class directly.

For using with WatiN or similar tools to drive the browser I will probably keep using pure cucumber with Ruby at least until the STAThread issue gets solved.