单元测试和集成测试业务

public class PageRepository : IPageRepository

{

#region Fields

private readonly IDropthingsDataContext _database;

private readonly ICache _cacheResolver;

#endregion Fields

#region Constructors

public PageRepository(IDropthingsDataContext database, ICache cacheResolver)

{

this._database = database;

this._cacheResolver = cacheResolver;

}

#endregion Constructors

#region Methods

public Page GetPageById(int pageId)

{

string cacheKey = CacheSetup.CacheKeys.PageId(pageId);

object cachedPage = _cacheResolver.Get(cacheKey);

if (null == cachedPage)

{

var page = _database.GetSingle<Page, int>(

DropthingsDataContext.SubsystemEnum.Page,

pageId,

LinqQueries.CompiledQuery_GetPageById);

page.Detach();

_cacheResolver.Add(cacheKey, page);

return page;

}

else

{

return cachedPage as Page;

}

}

}

public void GetPage_Should _Return_A_Page_ from_database _when_cache_is_empty_and_ then_caches_it ()

{

var cache = new Mock();

var database = new Mock();

IPageRepository pageRepository = new PageRepository (database.Object, cache.Object);

const int pageId = 1;

var page = default(Page);

var samplePage = new Page() { ID = pageId, Title = "Test Page", ...};

database

.Expect (d => d.GetSingle<Page, int> (

DropthingsDataContext.SubsystemEnum.Page,

1, LinqQueries.CompiledQuery_GetPageById))

.Returns(samplePage);

"Given PageRepository and empty cache".Context(() =>

{

// cache is empty

cache.Expect (c => c.Get(It.IsAny())) .Returns (default(object));

// It will cache the Page object afte loading from database

cache.Expect(c =>

c.Add(It.Is(cacheKey =>

cacheKey == CacheSetup.CacheKeys.PageId(pageId)),

It.Is(cachePage =>

object.ReferenceEquals(cachePage, samplePage))))

.AtMostOnce().Verifiable();

});

"when GetPageById is called".Do(() =>

page = pageRepository.GetPageById(1));

"it checks in the cache first and finds nothing and then caches it" .Assert(() =>

cache.VerifyAll());

"it loads the page from database".Assert(() =>

database.VerifyAll());

"it returns the page as expected".Assert(() =>

{

Assert.Equal(pageId, page.ID);

});

}

public Page GetPageById(int pageId)

{

return AspectF.Define

.Cache(_cacheResolver, CacheSetup.CacheKeys.PageId(pageId))

.Return(() =>

_database.GetSingle<Page, int>(DropthingsDataContext.SubsystemEnum.Page,

pageId, LinqQueries.CompiledQuery_GetPageById).Detach());

}

[Specification]

public void GetPage_Should_Return_A_Page_from _cache_when_it_is_already_cached()

{

var cache = new Mock();

var database = new Mock();

IPageRepository pageRepository = new PageRepository (database.Object, cache.Object);

const int pageId = 1;

var page = default(Page);

var samplePage = new Page() { ID = pageId, Title = "Test Page",

ColumnCount = 3 , LayoutType = 3 , UserId = Guid.Empty, VersionNo = 1,

PageType = Enumerations.PageTypeEnum .PersonalPage,

CreatedDate = DateTime.Now };

"Given PageRepository and the requested page in cache".Context(() =>

{

cache.Expect (c => c.Get (CacheSetup.CacheKeys.PageId (samplePage.ID)))

.Returns(samplePage);

});

" when GetPageById is called".Do(() =>

page = pageRepository.GetPageById (1));

"it checks in the cache first and finds the object is in cache".Assert(() =>

{

cache.VerifyAll();

});

"it returns the page as expected".Assert(() =>

{

Assert.Equal(pageId, page.ID);

});

}

public class TestUserVisit

{

public TestUserVisit()

{

Facade.BootStrap();

}

/// <summary>

/// Ensure the first visit produces the pages and widgets defined in the template user

/// </summary>

[Specification]

public void First_visit_should_ create_same_pages_and _widgets_as_the _template_user()

{

MembershipHelper .UsingNewAnonUser ((profile) =>

{

using (var facade = new Facade (new AppContext (string.Empty, profile.UserName)))

{

UserSetup userVisitModel = null;

// Load the anonymous user pages and widgets

string anonUserName = facade.GetUserSettingTemplate()

.AnonUserSetting Template.UserName;

var anonPages = facade.GetPagesOfUser (facade.GetUserGuidFromUserName (anonUserName));

"Given anonymous user who has never visited the site before"

.Context(() => { });

"when the user visits for the first time".Do(() =>

{

userVisitModel = facade.FirstVisitHomePage (profile.UserName,

string.Empty, true, false);

});

"it creates widgets on the newly created page at exact columns and

positions as the anon user's pages".Assert(() =>

{

anonPages.Each(anonPage =>

{

var userPage = userVisitModel.UserPages.First(page =>

page.Title == anonPage.Title

&& page.OrderNo == anonPage.OrderNo

&& page.PageType == anonPage.PageType);

facade.GetColumnsInPage (anonPage.ID).Each(anonColumn =>

{

var userColumns = facade.GetColumnsInPage (userPage.ID);

var userColumn = userColumns.First (column =>

column.ColumnNo == anonColumn.ColumnNo);

var anonColumnWidgets =

facade.GetWidgetInstancesInZone WithWidget (anonColumn.WidgetZoneId);

var userColumnWidgets =

facade .GetWidgetInstancesInZoneWithWidget (userColumn.WidgetZoneId);

// Ensure the widgets from the anonymous user template's columns are

// in the same column and row.

anonColumnWidgets.Each (anonWidget =>

Assert.True (userColumnWidgets.Where (userWidget =>

userWidget.Title == anonWidget.Title

&& userWidget.Expanded == anonWidget.Expanded

&& userWidget.State == anonWidget.State

&& userWidget.Resized == anonWidget.Resized

&& userWidget.Height == anonWidget.Height

&& userWidget.OrderNo == anonWidget.OrderNo).Count() == 1));

});

});

});

}

});

}

[Specification]

public void InsertPage_should_insert_a_page _in_database_and_cache_it()

{

var cache = new Mock();

var database = new Mock();

IPageRepository pageRepository = new PageRepository(database.Object, cache.Object);

const int pageId = 1;

var page = default(Page);

var samplePage = new Page() { ID = pageId, Title = "Test Page", ColumnCount = 3,

LayoutType = 3, UserId = Guid.NewGuid(), VersionNo = 1,

PageType = Enumerations.PageTypeEnum .PersonalPage, CreatedDate = DateTime.Now };

database

.Expect(d = > d.Insert ( DropthingsDataContext .SubsystemEnum.Page,

It.IsAny()))

.Returns(samplePage);

"Given PageRepository" .Context(() =>

{

// It will clear items from cache

cache.Expect (c => c.Remove (CacheSetup.CacheKeys.PagesOfUser (samplePage.UserId)));

});

" when Insert is called".Do(() =>

page = pageRepository .Insert((newPage) =>

{

newPage.Title = samplePage.Title;

newPage.ColumnCount = samplePage.ColumnCount;

newPage.LayoutType = samplePage.LayoutType;

newPage.UserId = samplePage.UserId;

newPage.VersionNo = samplePage.VersionNo;

newPage.PageType = samplePage.PageType;

}));

("then it should insert the page in database" +

"and clear any cached collection of pages for the user who gets the new page" +

"and it returns the newly inserted page").Assert(() =>

{

database.VerifyAll();

cache.VerifyAll();

Assert.Equal(pageId, page.ID);

});

}

public Page Insert(Action populate)

{

return new Page();

}

public Page Insert(Action populate)

{

var newPage = _database.Insert(

DropthingsDataContext.SubsystemEnum.Page, populate);

RemoveUserPagesCollection(newPage.UserId);

return newPage.Detach();

}

public void Revisit_should_load_the _pages_and_widgets_exactly_the_same()

{

MembershipHelper .UsingNewAnonUser ((profile) =>

{

using (var facade = ew Facade (new AppContext (string.Empty, profile.UserName)))

{

UserSetup userVisitModel = null;

UserSetup userRevisitModel = null;

"Given an anonymous user who visited first".Context(() =>

{

userVisitModel = facade.FirstVisitHomePage(profile.UserName, ...);

});

"when the same user visits again".Do(() =>

{

userRevisitModel = facade.RepeatVisitHomePage (profile.UserName, ...);

});

"it should load the exact same pages, column and

widgets as the first visit produced".Assert(() =>

{

userVisitModel.UserPages.Each (firstVisitPage =>

{

Assert.True (userRevisitModel.UserPages.Exists (page =>

page.ID == firstVisitPage.ID));

var revisitPage = userRevisitModel.UserPages.First (page =>

page.ID == firstVisitPage.ID);

var revisitPageColumns = facade.GetColumnsInPage (revisitPage.ID);

facade.GetColumnsInPage (firstVisitPage.ID) .Each(firstVisitColumn =>

{

var revisitColumn = revisitPageColumns.First (column =>

column.ID == firstVisitColumn.ID);

var firstVisitWidgets = facade

.GetWidgetInstancesInZone WithWidget (firstVisitColumn.WidgetZoneId);

var revisitWidgets = facade

.GetWidgetInstancesInZoneWithWidget (revisitColumn.WidgetZoneId);

firstVisitWidgets.Each (firstVisitWidget =>

Assert.True (revisitWidgets.Where(revisitWidget =>

revisitWidget.Id == firstVisitWidget.Id).Count() == 1));

});

});

});

}

});

}