博客园_天下無雙

(转)MongoDB——安装篇（windows）

2011-10-29T04:26:00Z

1、下载MongoDB数据库http://fastdl.mongodb.org/win32/mongodb-win32-i386-1.6.5.zip；

2、将安装文件解压到C盘（注意：安装路径中不能出现空格），配置“环境变量”，将 %MONGODB_HOME%\bin 添加到“Path”中；

3、进入DOS窗口，设置数据保存目录（与端口）和日志输出目录。
DOS命令：

Dos代码

mongod --port <端口> --dbpath <数据路径> --logpath <日志路径> --logappend --directoryperdb

mongod --port <端口> --dbpath <数据路径> --logpath <日志路径> --logappend --directoryperdb

参数说明：
--port 表示数据库端口，默认27017；
--dbpath 表示数据文件存储路径，一般设置为%MONGODB_HOME%\data；
--logpath 表示日志文件存储路径，一般设置为%MONGODB_HOME%\logs\mongodb.log；
--logappend 表示日志追加，默认是覆盖；
--directoryperdb 表示每个db一个目录；

4、完成以上设置，MongoDB已经启动，新开启DOS窗口，执行“mongo.exe”，出现“MongoDB shell version: 1.8.1”表示安装成功了。

5、目前是以无权限限制的方式启动的，你可以做任何操作。那么我们先切换到admin下，创建一个root用户吧。执行命令:
"use admin" -> "db.addUser('root','root')" -> "db.auth('root','root')"，如下图所示：

6、把MongoDB注册为Windows Service，让它开机自动启动；执行命令：

Dos代码

mongod --bind_ip 127.0.0.1 --logpath %MONGODB_HOME%\logs\mongodb.log --logappend --dbpath %MONGODB_HOME%\data --directoryperdb --auth --install

mongod --bind_ip 127.0.0.1 --logpath %MONGODB_HOME%\logs\mongodb.log --logappend --dbpath %MONGODB_HOME%\data --directoryperdb --auth --install

注意：
    a.必须切换到bin目录下执行该条指令。
    b.必须添加--auth用户权限才会生效。
    c.除了“--auth”和“--install”两个参数，别的参数要跟你设置用户时启动服务的参数一致，尤其是“--directoryperdb”。
    第一次配置完成后，一定要重启才会有效果重启mongo客户端，不输入-u-p可以直接进入，但是不具有任何权限。正确的访问方式为：mongo 数据库名 -u 用户名 -p。另外设置用户

7、服务安装成功后的界面：

8、如果安装失败：
删除MongoDB服务，执行命令：

Dos代码

sc delete MongoDB

sc delete MongoDB

启动MongoDB服务，执行命令：

Dos代码

net start "MongoDB"

net start "MongoDB"

9、在cmd下可有两种方法打开，net和sc，net用于打开没有被禁用的服务，语法是：
启动：net/sc start 服务名
停止：net/sc stop 服务名

10、另外，sc可用于打开被禁用的服务，语法是：
sc config 服务名 start= demand //手动
sc condig 服务名 start= auto //自动
sc config 服务名 start= disabled //禁用
注意：以上三个命令“=”号后面必须有一个空格

http://hdxiong.iteye.com/blog/1018821

本文链接

(转)MongoDB 增加用户删除用户修改用户读写权限只读权限,

2011-10-29T04:23:00Z

MongoDB 增加用户删除用户修改用户读写权限只读权限,

MongoDB用户权限分配的操作是针对某个库来说的。--这句话很重要。

1、进入ljc 数据库：

use ljc; --ljc为数据库名称。

2、添加用户（读写权限，readOnly-->false）：

db.addUser("java","java");

3、查看一下所有的用户

db.system.users.find();

{ "_id" : ObjectId("4e02a89fb841deb5fda3e5e2"), "user" : "java", "readOnly" : fa
lse, "pwd" : "59cf7cc156874cbd35cb00869126f569" }

4、用户授权。

db.auth("java","java");

1 显示为1 表示授权成功，0表示不成功。

5、添加用户（只读权限，readOnly-->true）：

db.addUser("java1","java1",true);

db.system.users.find();
{ "_id" : ObjectId("4e02a89fb841deb5fda3e5e2"), "user" : "java", "readOnly" : fa
lse, "pwd" : "59cf7cc156874cbd35cb00869126f569" }
{ "_id" : ObjectId("4e02aae6b841deb5fda3e5e3"), "user" : "java1", "readOnly" : t
rue, "pwd" : "fca6bda05c87a72cce0a4a6458d1e266" }

注意上面标红的位置的readOnly 只读于可写是有区别的。

6、更改密码（为已经存在的用户更改密码）：

db.addUser("java","java1");

7、删除用户：

db.system.users.remove({user:"java1"});

关于库权限,如果用户需要全局的权限,可以在admin和local的两个库里添加,但是需要重启库,

有待验证。

本文链接

（转）MongoDB设置访问权限、设置用户

2011-10-29T04:21:00Z

MongoDB已经使用很长一段时间了，基于MongoDB的数据存储也一直没有使用到权限访问（MongoDB默认设置为无权限访问限制），今天特地花了一点时间研究了一下，研究成果如下：

注：研究成果基于Windows平台

MongoDB在本机安装部署好后

1. 输入命令：show dbs，你会发现它内置有两个数据库，一个名为admin，一个名为local。local好像没啥用，如果哪位在使用过程中发现了这个local表的用途，希望能够留言提醒，那我们就专心来说说admin表

2. 输入命令：use admin，你会发现该DB下包含了一个system.user表，呵呵，没错，这个表就等同于MsSql中的用户表，用来存放超级管理员的，那我们就往它里面添加一个超级管理员试试看

3. 输入命令：db.addUser('sa','sa')，这里我添加一个超级管理员用户，username为sa，password也为sa，即然我们添加了超级管理员，那咱们就来测试下，看看咱们再次连接MongoDB需不需要提示输入用户名、密码，我们先退出来(ctrl+c)

4. 输入命令：use admin

5. 输入命令：show collections，查看该库下所有的表，你会发现，MongoDB并没有提示你输入用户名、密码，那就奇怪了，这是怎么回事呢？在文章最开始提到了，

MongoDB默认设置为无权限访问限制，即然这样，那我们就先把它设置成为需要权限访问限制，咱们再看看效果，怎么设置呢？

6. 在注册表中，找到MongoDB的节点，在它的ImgPath中，我们修改一下，加入 -auth，如下所示：

"D:\Program Files\mongodb\bin\mongod" -dbpath e:\work\data\mongodb\db -logpath e:\work\data\mongodb\log -auth -service

7. 输入命令：use admin

8. 输入命令：show collections，呵呵，我们发现无法查看该库下的表了，提示："$err" : "unauthorized db:admin lock type:-1 client:127.0.0.1"，很明显，提示没有权限，看来关键就在于这里，我们在启动MongoDB时，需要加上-auth参数，这样我们设置的权限才能生效，好，接下来我们使用刚刚之前设置的用户名、密码来访问

9. 输入命令：db.auth('sa','sa')，输出一个结果值为1，说明这个用户匹配上了，如果用户名、密码不对，会输入0

10. 输入命令：show collections，呵呵，结果出来了，到这里，权限设置还只讲到一多半，接着往下讲，我们先退出来(ctrl+c)

11. 输入命令：mongo TestDB，我们尝试连接一个新的库（无论这个库是否存在，如果不存在，往该库中添加数据，会默认创建该库），然后，我们想看看该库中的表

12. 输入命令：show collections，好家伙，没权限，我们输入上面创建的用户名、密码

13. 输入命令：db.auth('sa','sa')，输入结果0，用户不存在，这下有人可能就不明白了，刚刚前面才创建，怎么会不存在呢？原因在于：当我们单独访问MongoDB的数据库时，需要权限访问的情况下，用户名密码并非超级管理员，而是该库的system.user表中的用户，注意，我这里说的是单独访问的情况，什么是不单独访问的情况呢？接下来再讲，现在咋办，没权限，那我们就尝试给库的system.user表中添加用户

14. 输入命令：db.addUser('test','111111')，哇靠，仍然提示没有权限，这可咋办，新的数据库使用超级管理员也无法访问，创建用户也没有权限，呵呵，别急，即然设定了超级管理员用户，那它就一定有权限访问所有的库

15. 输入命令：use admin

16. 输入命令：db.auth('sa','sa')

17. 输入命令：use TestDB

18. 输入命令：show collections，哈哈，一路畅通无阻，我们发现可以利用超级管理员用户访问其它库了，呵呵，这个就是不单独访问的情况，不难发现，我们是先进入admin库，再转到其它库来的，admin相当于是一个最高级别官员所在区域，如果你是个地产商，想在地方弄个大工程做做，你想不经过那些高级官员就做，这是行不通的，你需要先去到他们那里，送点礼，再顺着下到地方，工程你就可以拿到手了，此言论仅为个人观点，不代表博客园；即然工程拿到手了，就要开始建了，那我们不至于每加块砖、添个瓦都得去和那帮高级官员打招呼吧，所以我们得让这个工程合法化，咱们得把相关的手续和证件弄齐全，不至于是违建

19. 输入命令：db.addUser('test','111111')，我们给TestDB库添加一个用户，以后每次访问该库，我都使用刚刚创建的这个用户，我们先退出（ctrl+c）

20. 输入命令：mongo TestDB

21. 输入命令：show collections，提示没有权限

22. 输入命令：db.auth('test','111111')，输出结果1，用户存在，验证成功

23. 输入命令：show collections，没再提示我没有权限，恭喜您，成功了

好累啊！一口气写完，呵呵

注：当需要使用权限才能访问MongoDB时，如果需要查看MongoDB中所有的库，我们只能通过超级管理员权限，输入命令show dbs来查看了。

FROM URL:http://www.cnblogs.com/zengen/archive/2011/04/23/2025722.html

本文链接

赎回收益率（Yield to Call，YTC）

2011-09-28T08:42:00Z

赎回收益率

出自 MBA智库百科(http://wiki.mbalib.com/)

赎回收益率（Yield to Call，YTC）

[编辑]

什么是赎回收益率

若市场利率下调，对于不可赎回的债券来说，价格会上涨；但对于可赎回债券来说，当市场利率下调，债券价格上涨至赎回价格时，就存在被赎回的可能性，因此价格上涨存在压力。

若债券被赎回，投资者不可能将债券持有到期，因此到期收益率失去意义，从而需要引进赎回收益率的概念(yield to call)。

赎回收益率（YTC）以平均年收益率表示，用以衡量从购买日到债券被发行人购回日，个人从债券投资中得到的收益。YTC一般指的是第一赎回收益率，即假设赎回发生在第一次可赎回的时间，从购买到赎回的内在收益率。

[编辑]

赎回收益率的计算

首次赎回收益率是累计到首次赎回日止，利息支付额与指定的赎回价格加总的现金流量酌现值等于债券赎回价格的利率。赎回收益率的计算公式为：

式中：

n^——直至第一个赎回日的时期数(年数)；
M^——赎回价格。

举例说明:

甲、乙两债券均为10年期的可赎回债券(第一赎回时间为5年后)，赎回价格均为1100元，目前两债券的到期收益率均为7%。其中债券甲的息票率为5%，乙为8%。假设当债券的未来现金流的现值超过赎回价格时就立即执行赎回条款。若5年后市场利率下降到5%，问哪种债券会被赎回,赎回收益率为多少?

解:债券甲目前的价值为：

当市场利率下降到5%时，债券甲的价值上升到1000元，债券甲不会被赎回。

债券乙目前的价值为：

5年后市场利率下降到5%，则其价值上升到：

这时债券乙将会以1100元的价格被赎回。

债券乙的第一赎回收益率为:

k=3.96%

来自"http://wiki.mbalib.com/wiki/%E8%B5%8E%E5%9B%9E%E6%94%B6%E7%9B%8A%E7%8E%87"

本文链接

YTC, YTM, YTW

2011-09-28T07:42:00Z

Yield To Call (YTC) 买回收益率投资者买入并持有债券直至买回日可得的收益率。这个收益率只有在证券在到期前被买回才有效。买回收益率根据息票率、当时与买回日期相隔的距离以及市场价格而定

Yield To Maturity (YTM) 到期收益率投资者买入并持有债券直至到期日所得的收益。到期收益率被视为长期债券收益率，一般以年百分比表达计算根据当时市场价格、面值、息票利率以及距离到期日时间，也假设所有息票以同样的利率进行再投资

Yield To Worst (YTW) 取Min(YTC,YTM)

Yield 收益率 1. 债券带来的收益，计算方法为债券利息除以价格 2. 投资的回报率，一般以年度百分比表达

本文链接

(转)测试 MVC 之 Mock HttpContext

2011-09-15T09:08:00Z

在 Web 中进行测试驱动的开发，比较大的困难是模拟 HttpContext ，它太复杂了。

moq 框架提供了强大的模拟能力，但是，模拟一个 HttpContext 对象还是需要自己来动手。

为此，我自己写了一个方法来完成这个工作。其中，还顺便使用 Log4Net 来输出一下它的工作情况。

view source print ?

`01`	`/// <summary>`

`02`	`/// 创建上下文模拟对象`

`03`	`/// 至少需要支持`

`04`	`/// Request 中`

`05`	`/// AppRelativeCurrentExecutionFilePath，`

`06`	`/// ApplicationPath`

`07`	`/// PathInfo`

`08`	`/// Response 中`

`09`	`/// ApplyAppPathModifier`

`10`	`/// </summary>`

`11`	`/// <returns></returns>`

`12`	`private` `Moq.Mock<System.Web.HttpContextBase> CreateHttpContext()`

13 {

`14`	`log4net.ILog log = log4net.LogManager.GetLogger("CreateHttpContext");`

15

`16`	`string` `ApplicationPath =` `"/";`

`17`	`string` `PathInfo =` `"";`

`18`	`string` `AppRelativeCurrentExecutionFilePath =` `"~/";`

19

`20`	`var contextMock =` `new` `Moq.Mock<System.Web.HttpContextBase>();`

21

`22`	`contextMock`

`23`	`.Setup(c => c.Request.AppRelativeCurrentExecutionFilePath)`

`24`	`.Returns(AppRelativeCurrentExecutionFilePath)`

`25`	`.Callback(() => log.Info("Calling AppRelativeCurrentExecutionFilePath"));`

26

`27`	`contextMock`

`28`	`.Setup(c => c.Request.ApplicationPath)`

`29`	`.Returns(ApplicationPath)`

`30`	`.Callback(() => log.Info("Calling ApplicationPath"));`

`31`	`contextMock.Setup(rc => rc.Request.PathInfo)`

`32`	`.Returns(PathInfo)`

`33`	`.Callback(() => log.Info("Calling PathInfo"));`

34

`35`	`contextMock`

`36`	`.Setup(rc => rc.Response.ApplyAppPathModifier(Moq.It.IsAny<string>()))`

`37`	`.Returns((string` `s) => s)`

`38`	`.Callback((string` `s) => log.InfoFormat("Calling ApplyAppPathModifier: {0}.", s));`

39

`40`	`return` `contextMock;`

41 }

虽然这个方法已经能够完成我需要的测试，但是，我希望能将它提炼一下，得到一个更加通用的 Mock 方法。

很快，我发现这个工作已经在很久以前被 Scott Hanselman 介绍过一次了，其中甚至还写了不同的 Mock 框架下的提供方法。不过 moq 版本的作者不是他，而是另外一个人 Daniel Cazzulino，这篇文章你可以在这里找到：http://www.hanselman.com/blog/ASPNETMVCSessionAtMix08TDDAndMvcMockHelpers.aspx，还可以顺便看一下 Daniel Cazzulino 的博客：http://blogs.clariusconsulting.net/kzu/

不过，他的文章是在 2008 年写的，实在太古老了。当时还是 MVC 的 Preview2 ，moq 在那个时候就已经诞生了，看来我太孤陋寡闻了。

回到我们的主题，经过了这么长的时间，moq 已经有了一些变化，使用最新的 moq 语法修改之后，发现他的的代码没有能够通过测试。

与我的比较一下，发现其中少了对 Response 中 ApplyAppPathModifier 方法的支持，增加之后就正常了。

下面是修改之后的代码，希望能给你带来方便。

view source print ?

001 using System;

002 using System.Web;

003 using System.Text.RegularExpressions;

004 using System.IO;

005 using System.Collections.Specialized;

006 using System.Web.Mvc;

007 using System.Web.Routing;

008

009 using Moq;

010

011 namespace UnitTests

012 {

013 public static class MvcMockHelpers

014 {

015 public static HttpContextBase FakeHttpContext()

016 {

017 var context = new Mock<HttpContextBase>();

018 var request = new Mock<HttpRequestBase>();

019 var response = new Mock<HttpResponseBase>();

020 var session = new Mock<HttpSessionStateBase>();

021 var server = new Mock<HttpServerUtilityBase>();

022

023 // 必须要设置 Response 的 ApplyAppPathModifier 方法支持

024 response

025 .Setup(rsp => rsp.ApplyAppPathModifier(Moq.It.IsAny<string>()))

026 .Returns((string s) => s);

027

028 context.Setup(ctx => ctx.Request).Returns(request.Object);

029 context.Setup(ctx => ctx.Response).Returns(response.Object);

030 context.Setup(ctx => ctx.Session).Returns(session.Object);

031 context.Setup(ctx => ctx.Server).Returns(server.Object);

032

033 return context.Object;

034 }

035

036 public static HttpContextBase FakeHttpContext(string url)

037 {

038 HttpContextBase context = FakeHttpContext();

039 context.Request.SetupRequestUrl(url);

040 return context;

041 }

042

043 // Controller 的一个扩展方法

044 public static void SetFakeControllerContext(this Controller controller)

045 {

046 var httpContext = FakeHttpContext();

047 ControllerContext context = new ControllerContext(new RequestContext(httpContext, new RouteData()), controller);

048 controller.ControllerContext = context;

049 }

050

051 static string GetUrlFileName(string url)

052 {

053 if (url.Contains("?"))

054 return url.Substring(0, url.IndexOf("?"));

055 else

056 return url;

057 }

058

059 static NameValueCollection GetQueryStringParameters(string url)

060 {

061 if (url.Contains("?"))

062 {

063 NameValueCollection parameters = new NameValueCollection();

064

065 string[] parts = url.Split("?".ToCharArray());

066 string[] keys = parts[1].Split("&".ToCharArray());

067

068 foreach (string key in keys)

069 {

070 string[] part = key.Split("=".ToCharArray());

071 parameters.Add(part[0], part[1]);

072 }

073

074 return parameters;

075 }

076 else

077 {

078 return null;

079 }

080 }

081

082 // 扩展 HttpRequestBase

083 public static void SetHttpMethodResult(this HttpRequestBase request, string httpMethod)

084 {

085 Mock.Get(request)

086 .Setup(req => req.HttpMethod)

087 .Returns(httpMethod);

088 }

089

090 // 设置请求的地址

091 public static void SetupRequestUrl(this HttpRequestBase request, string url)

092 {

093 log4net.ILog log = log4net.LogManager.GetLogger("CreateHttpContext");

094

095 if (url == null)

096 throw new ArgumentNullException("url");

097

098 if (!url.StartsWith("~/"))

099 throw new ArgumentException("Sorry, we expect a virtual url starting with \"~/\".");

100

101 var mock = Mock.Get(request);

102

103 mock.Setup(req => req.QueryString)

104 .Returns(GetQueryStringParameters(url));

105 mock.Setup(req => req.AppRelativeCurrentExecutionFilePath)

106 .Returns(GetUrlFileName(url))

107 .Callback(() => log.Info("Calling AppRelativeCurrentExecutionFilePath"));

108

109

110 mock.Setup(req => req.PathInfo)

111 .Returns(string.Empty);

112

113 }

114

115 }

116 }

FROM: http://www.cnblogs.com/haogj/archive/2011/07/24/2115575.html

本文链接

(转)使用 NUnit Mocking .NET 对象

2011-09-15T09:07:00Z

原文名称：Mocking .NET Objects with NUnit

原文地址：http://www.zorched.net/2007/03/10/mocking-net-objects-with-nunit/

NUnit 是我进行 .NET 开发的单元测试工具，Microsoft 也提供了一个测试框架，但是只能与高版本的 Visual Studio 一起工作，这个框架与 NUnit 非常相像。在 Java 中，通过 Mocking 来帮助测试非常方便，我曾经写过一篇使用 Java 的文章 using JMock for Unit Tesing，在这里，我会讨论一下 NUnit 现在支持的开箱即用的 Mock 支持。

什么是 Mock 对象？

Mock 对象是用来隔离测试依赖目标的技术，通过隔离使得我们可以细粒度地测试单个类中的单个方法，可能在依赖的类完全实现之前进行。隔离可以使你的测试更快进行，使得测试一小片功能更加容易。当你通过隔离完成分离的一部分测试之后，就可以有信心进行更大粒度的测试，当你在处理像数据访问层或者 Web 服务层的依赖的时候，隔离会更有意义，外部的调用会花费很多的时间，或者在远程系统当机的时候可能会失败。

对于使用 Mock 对象来说，重要的是逼迫你考虑你的类和方法依赖的东西，它强迫你考虑你的类之间的耦合性，如果耦合性很高的话，就很难测试，如果耦合性弱的话，就非常容易测试。有关这些早期概念设计的考虑可以帮助你更加轻松地管理随时间推移带来变化。

要点

好的设计强于坏的设计
低耦合的对象经常好于强耦合的对象
随着时间的推移，测试可以提高代码的质量和开发效率
低耦合的设计容易测试

示例项目

下面我们使用一个例子来演示一下，我们创建一个 Person 的领域对象，和一个名为 IPersonRepository 的数据访问接口，这时候非常简单。

view source print ?

public class Person

{

public string Id;

public string FirstName;

public string LastName;

public Person(string newId, string fn, string ln)

{

Id = newId;

FirstName = fn;

LastName = ln;

}

接口的定义

view source print ?

public interface IPersonRepository

{

List<Person> GetPeople();

Person GetPersonById(string id);

}

然后，我们创建一个 PersonService 类，在我们的程序中，用来实现业务逻辑，它将使用数据访问层，然后为 UI 层返回信息。

我们使用 DI 的构造函数注入来把他们连接在一起，所有依赖的对象都通过构造函数来传送。这样 PersonService 除了接口之外，就不需要知道具体的实现类，以实现低耦合。这样，在构造函数中我们不能传递一个无效的 PersonService 。

下面是一个简单的实现，但是我希望它能够表达它的使用。

view source print ?

public class PersonService

{

private IPersonRepository personRepos;

public PersonService(IPersonRepository repos)

{

personRepos = repos;

}

public List<Person> GetAllPeople()

{

return personRepos.GetPeople();

}

public List<Person> GetAllPeopleSorted()

{

List<Person> people = personRepos.GetPeople();

people.Sort(delegate(Person lhp, Person rhp) {

return lhp.LastName.CompareTo(rhp.LastName);

});

return people;

}

public Person GetPerson(string id)

{

try

{

return personRepos.GetPersonById(id);

}

catch (ArgumentException)

{

return null; // no person with that id was found

}

使用 NUnit 进行 Mock

现在，我们可以开始测试我们的 PersonService。甚至我们还没有任何 IPersonRepository 的实现，使用 Mock 我们不需要考虑应用程序中其他层，就可以检查我们的 PersonService 是否如我们希望的完成任何任务。

view source print ?

using System;

using System.Collections.Generic;

using NUnit.Framework;

using NUnit.Mocks;

[TestFixture]

public class PersonServiceTest

{

// 我们用来实现 IPersonRepository 的动态代理

private DynamicMock personRepositoryMock;

// 一些测试数据

private Person onePerson = new Person("1", "Wendy", "Whiner");

private Person secondPerson = new Person("2", "Aaron", "Adams");

private List<Person> peopleList;

[SetUp]

public void TestInit()

{

peopleList = new List<Person>();

peopleList.Add(onePerson);

peopleList.Add(secondPerson);

// 使用接口 IPersonRepository 创建动态 Mock 对象

personRepositoryMock = new DynamicMock(typeof (IPersonRepository));

}

[Test]

public void TestGetAllPeople()

{

// 当调用 "GetPeople" 方法的时候，返回一个

// 预定义列表

view source print ?

personRepositoryMock.ExpectAndReturn("GetPeople", peopleList);

// 使用 IPersonRepository 的 Mock 对象来创建 PersonService

PersonService service = new PersonService(

(IPersonRepository) personRepositoryMock.MockInstance);

// 调用方法并进行断言

Assert.AreEqual(2, service.GetAllPeople().Count);

}

[Test]

public void TestGetAllPeopleSorted()

{

personRepositoryMock.ExpectAndReturn("GetPeople", peopleList);

PersonService service = new PersonService(

(IPersonRepository) personRepositoryMock.MockInstance);

// This method really has "business logic" in it - the sorting of people

List<Person> people = service.GetAllPeopleSorted();

Assert.IsNotNull(people);

Assert.AreEqual(2, people.Count);

// Make sure the first person returned is the correct one

Person p = people[0];

Assert.AreEqual("Adams", p.LastName);

}

[Test]

public void TestGetSinglePersonWithValidId()

{

// 当调用 "GetPerson" 方法的时候返回一个预定义的 Person

personRepositoryMock.ExpectAndReturn("GetPersonById", onePerson, "1");

PersonService service = new PersonService(

(IPersonRepository) personRepositoryMock.MockInstance);

Person p = service.GetPerson("1");

Assert.IsNotNull(p);

Assert.AreEqual(p.Id, "1");

}

[Test]

public void TestGetSinglePersonWithInalidId()

{

// 当传递一个 null 调用 "GetPersonById" 方法的时候

// 抛出异常 ArgumentException

personRepositoryMock.ExpectAndThrow("GetPersonById",

new ArgumentException("Invalid person id."), null);

PersonService service = new PersonService(

(IPersonRepository) personRepositoryMock.MockInstance);

// The only way to get null is if the underlying IPersonRepository

// threw an ArgumentException

Assert.IsNull(service.GetPerson(null));

}

现在的 PersonService 没有什么真正的逻辑，我希望它能帮助你理解如何简单地通过 Mock 对象来进行各种条件的测试。

虽然 NUnit 内置的 Mock 库不是最强大的 Mock 库，还是应该充分使用它，我相信随着时间的推移，它将会变得更加强大。

源码下载：NMock C# Example Project

FROM: http://www.cnblogs.com/haogj/archive/2011/06/24/2088788.html

本文链接

(转)moq 的常用使用方法

2011-09-15T09:05:00Z

测试方法

1 // 准备 Mock IFoo 接口
2 var mock = new Mock<IFoo>();
3 // 配置准备模拟的方法，当调用接口中的 DoSomething 方法，并传递参数 "bing" 的时候，返回 true
4 mock.Setup(foo => foo.DoSomething("ping")).Returns(true);
5
6 // 方法的参数中使用了 out 参数
7 // out arguments
8 var outString = "ack";
9 // 当调用 TryParse 方法的时候，out 参数返回 "ack", 方法返回 true, lazy evaluated
10 mock.Setup(foo => foo.TryParse("ping", out outString)).Returns(true);
11
12 // ref 参数
13 var instance = new Bar();
14 // 仅仅在使用 ref 调用的时候，才会匹配下面的测试
15 mock.Setup(foo => foo.Submit(ref instance)).Returns(true);
16
17 // 当方法返回值得时候，还可以访问返回的值
18 // 这里可以使用多个参数
19 mock.Setup(x => x.DoSomething(It.IsAny<string>()))
20                  .Returns((string s) => s.ToLower());
21
22 // 在被调用的时候抛出异常
23 mock.Setup(foo => foo.DoSomething("reset")).Throws<InvalidOperationException>();
24 mock.Setup(foo => foo.DoSomething("")).Throws(new ArgumentException("command");
25
26 // 延迟计算返回的结果
27 mock.Setup(foo => foo.GetCount()).Returns(() => count);
28
29 // 在每一次调用的时候，返回不同的值
30 var mock = new Mock<IFoo>();
31 var calls = 0;
32 mock.Setup(foo => foo.GetCountThing())
33      .Returns(() => calls)
34      .Callback(() => calls++);
35
36 // 第一次调用返回 0，下一次是 1，依次类推
37 Console.WriteLine(mock.Object.GetCountThing());

匹配参数

1 // 任意值
2 mock.Setup(foo => foo.DoSomething(It.IsAny<string>())).Returns(true);
3
4 // 提供的值必须匹配一个函数, lazy evaluated
5 mock.Setup(foo => foo.Add(It.Is<int>(i => i % 2 == 0))).Returns(true);
6
7 // 匹配一个范围
8 mock.Setup(foo => foo.Add(It.IsInRange<int>(0, 10, Range.Inclusive))).Returns(true);
9
10 // 匹配正则表达式
11 mock.Setup(x => x.DoSomething(It.IsRegex("[a-d]+", RegexOptions.IgnoreCase))).Returns("foo");

属性

1 // 普通属性
2 mock.Setup(foo => foo.Name).Returns("bar");
3
4 // 多层的属性
5 mock.Setup(foo => foo.Bar.Baz.Name).Returns("baz");
6
7 // 期望设置属性的值为 "foo"
8 mock.SetupSet(foo => foo.Name = "foo");
9
10 // 或者直接验证赋值
11 mock.VerifySet(foo => foo.Name = "foo");

设置属性，以便自动跟踪它的值

1 // 开始 "tracking" 属性的 sets/gets
2 mock.SetupProperty(f => f.Name);
3
4 // 提供一个默认的值
5 mock.SetupProperty(f => f.Name, "foo");
6
7 // 现在，你可以:
8 IFoo foo = mock.Object;
9
10 // 保存的值
11 Assert.Equal("foo", foo.Name);
12
13 // 重新设置一个值
14 foo.Name = "bar";
15 Assert.Equal("bar", foo.Name);

还可以准备所有的属性

mock.SetupAllProperties();

事件

1 // 抛出一个事件
2 mock.Raise(m => m.FooEvent += null, new FooEventArgs(fooValue));
3
4 // 多层的后代中的事件
5 mock.Raise(m => m.Child.First.FooEvent += null, new FooEventArgs(fooValue));
6
7 // 当 Submit 方法被调用的时候，抛出一个事件
8 mock.Setup(foo => foo.Submit()).Raises(f => f.Sent += null, EventArgs.Empty);
9
10 // 抛出异常将会触发对象底层的行为
11 // 你可能需要在后面进行断言处理
12
13 // 抛出一个自定义的事件
14 public delegate void MyEventHandler(int i, bool b);
15 public interface IFoo {   event MyEventHandler MyEvent;  }
16 var mock = new Mock<IFoo>();
17 ...
18
19 // 传递自定义的事件参数
20 mock.Raise(foo => foo.MyEvent += null, 25, true);

回调

1 var mock = new Mock<IFoo>();
2 mock.Setup(foo => foo.Execute("ping"))
3      .Returns(true)
4      .Callback(() => calls++);
5
6 // 使用调用的参数
7 mock.Setup(foo => foo.Execute(It.IsAny<string>()))
8      .Returns(true)
9      .Callback((string s) => calls.Add(s));
10
11 // 使用泛型语法
12 mock.Setup(foo => foo.Execute(It.IsAny<string>()))
13      .Returns(true)
14      .Callback<string>(s => calls.Add(s));
15
16 // 使用多个参数
17 mock.Setup(foo => foo.Execute(It.IsAny<int>(), It.IsAny<string>()))
18      .Returns(true)
19      .Callback<int, string>((i, s) => calls.Add(s));
20
21 // 调用之前和之后的回调
22 mock.Setup(foo => foo.Execute("ping"))
23      .Callback(() => Console.WriteLine("Before returns"))
24      .Returns(true)
25      .Callback(() => Console.WriteLine("After returns"));

验证

1 mock.Verify(foo => foo.Execute("ping"));
2
3 // 在验证失败的时候，提供自定义的错误提示信息
4 mock.Verify(foo => foo.Execute("ping"), "When doing operation X, the service should be pinged always");
5
6 // 从没有被调用的方法
7 mock.Verify(foo => foo.Execute("ping"), Times.Never());
8
9 // 至少调用过一次
10 mock.Verify(foo => foo.Execute("ping"), Times.AtLeastOnce());
11 mock.VerifyGet(foo => foo.Name);
12
13 // 验证对属性的赋值.
14 mock.VerifySet(foo => foo.Name);
15
16 // 验证对于属性设置特定的值
17 mock.VerifySet(foo => foo.Name ="foo");
18
19 // 验证匹配的参数
20 mock.VerifySet(foo => foo.Value = It.IsInRange(1, 5, Range.Inclusive));

自定义 Mock 行为

Mock 的行为分为严格的 Strict 和宽松的 Loose，默认为宽松的。在严格模式下，使用任何没有被指定的行为，都将会抛出异常，宽松模式下，不会抛出任何异常，方法将会返回默认值或者空的数组等等。

var mock = new Mock<IFoo>(MockBehavior.Strict);

如果没有重写基类的实现，默认将不会调用基类，在 Mock Web/Html 控件的是必须的。

var mock = new Mock<IFoo> { CallBase = true };

创造自动递归的 Mock, Mock 对象对于它的任何成员将会返回一个新的 Mock 对象。

var mock = new Mock<IFoo> { DefaultValue = DefaultValue.Mock };

// 默认是 DefaultValue.Empty
// 现在这个属性将会返回一个新的 Mock 对象
IBar value = mock.Object.Bar;

// 可以使用返回的 Mock 对象, 后即对属性的访问返回相同的对象实例
// 这就允许我们可以进行后继的设置
// set further expectations on it if we want
var barMock = Mock.Get(value);
barMock.Setup(b => b.Submit()).Returns(true);

中心化的 Mock 实例创建和管理：你可以在一个地方使用 MockRepository 创建和验证所有的 Mock 对象，设置 MockBehavior, CallBse 和 DefaultValue 约束。

var factory = new MockFactory(MockBehavior.Strict) { DefaultValue = DefaultValue.Mock };

// 创建 Mock 对象
var fooMock = factory.Create<IFoo>();

// 在创建的时候重写仓库的设置
var barMock = factory.Create<IBar>(MockBehavior.Loose);

// 验证通过仓库创建的对象
factory.Verify();

其它

// 用在测试用例的开始
using Moq.Protected()

// 测试中
var mock = new Mock<CommandBase>(); mock.Protected()
      .Setup<int>("Execute")
      .Returns(5);

// 如果用到了参数匹配, 必须使用 ItExpr 来代替 It
// 以后计划改进
mock.Protected()
     .Setup<string>("Execute",         ItExpr.IsAny<string>())
     .Returns(true);

高级特性

1 // 从 Mock 实例重新获得 Mock 对象
2 IFoo foo = // get mock instance somehow
3 var fooMock = Mock.Get(foo);
4 fooMock.Setup(f => f.Submit()).Returns(true);
5
6 // 实现多个接口
7 var foo = new Mock<IFoo>();
8 var disposableFoo = foo.As<IDisposable>();
9
10 // 现在 IFoo mock 已经实现了接口 IDisposable :) disposableFoo.Setup(df => df.Dispose());
11
12 // 定制匹配
13 mock.Setup(foo => foo.Submit(IsLarge())).Throws<ArgumentException>(); ...
14 public string IsLarge()
15 {
16     return Match<string>.Create(s => !String.IsNullOrEmpty(s) && s.Length > 100);
17 }

FROM: http://www.cnblogs.com/haogj/archive/2011/07/22/2113496.html

本文链接

（转）如何测试私有/受保护的方法

2011-09-15T06:59:00Z

1. 简介

Test Driven Development 的步骤是先写测试，然后写代码让测试通过，然后再重构。这些概念在.net环境中由于对软件质量要求的提高，越来越受到重视。测试公有方法是很容易的，自然而然的就有问题产生了“如何测试protected或private方法”？本文包括：

l 总结一些测试私有方法的常用做法；

l 给出一些有用的方法，即使你不知道哪种方法最优；

l 提高代码演示这些测试技术。

2. 背景

2.1. 是否应该测试私有方法？

在GOOGLE(Google search)上搜索一下就会发现无数相关讨论，更不用说实际的测试实现了。下面的表格对这些讨论做了总结，并把利弊都列出如下：

观点

利

弊

使用私有方法

封装- 私有函数提供了封装，方便了客户端的调用。
重构- 重构私有方法很容易，因为没有被外部调用，因此修改其声明方式不会破坏外面的任何调用。
校验- 不象公有方法必须要校验外部的输入数据，私有方法不需要复杂的校验（因为在公有方法中已经校验过）。
测试范围- 将所有方法设成公有，扩大了测试的范围。私有方法只有在开发人员需要时才测试，公有方法使用广泛，必须要全部测试。

不重构- 如果一个类复杂到不需要使用私有方法，则应该进行重构。
功能隐藏- 私有方法（如果设计正确的话）提供了有用的特性，如果需要客户端访问而测试的话，则应该设置为公有。

测试私有方法

测试控制- 私有方法可能包含了复杂的逻辑，测试应该包含这些方法的测试，而不能因为公有方法中调用了这些方法就认为没有问题。
原则- 单元测试用于测试最小的代码片段，私有方法是一段功能代码，因此应该被测试。

已经覆盖- 只有公共接口应该被测试，在测试公有方法时已经内部调用测试了私有方法。
不好的代码 – 如果你重构代码的时候改变了私有方法，并且你的测试中连接到了相关的私有方法，则你需要再修改测试代码。

赞成和反对的人都是比较厉害的角色。我既不打算也不期望结束这些争论，我只想了解他们各自在测试中的用处。即使你不想测试私有方法：

l 但如果你知道如何测试，你的意见就更有效（而不会因为你不知道就简单的说“不测试”）；

l 针对测试非公有方法可以帮助你的团队工作的更好；

l 只要可能，就值得找到一个简便的方法测试他们。

2.2. 好的标准和不准确的技术

Andrew Hunt and David Thomas 在他的书中, Pragmatic Unit Testing in C# with NUnit, 说明好的单元测试应该具有下面的特点（ATRIP）：

l 自动化；

l 充分；

l 可重复；

l 独立的；

l 专业的；

针对私有/保护方法的完全测试，还有其它三项标准

l 透明：不要修改系统到测试环境（system under test），如在发布代码中封装测试代码；

l 范围：能在debug/release模式下运行；

l 简单性：使用简单，易于修改且风险小。

记住这些标准，这里有几个简单的策略：

策略

问题

不要有任何私有方法

回避了这个问题。

使用#if DEBUG ... #endif 封装私有方法为公有方法，这样测试方法就可以通过公有的封装接口访问私有方法。（但此方法背离了OO思想）.

这种方法只能在调试模式有效。
过程式而非OO。需要在发布和单元测试中封装各个方法。
通过增加公有方法违背了上面的准则。

在封装私有方法的公有接口上使用[Conditional("DEBUG")] 属性

只能在调试模式下工作。

创建内部方法访问这些私有方法，并在程序集中其它地方声明一些公有方法封装这些内部方法。

这修改了发布产品的代码，并使得发布产品中包含有测试代码。
需要大量额外的编程，而且容易有问题。

3. 测试Protected 方法

Protected方法只在派生类可见，因此测试类中不能直接看到。如测试ClassLibrary1.MyObject下面的方法：

protected string MyProtectedMethod(string strInput, int i32Value)

{

return this.Name + ": " + strInput + ", " +

i32Value.ToString();

}

Pragmatic Unit Testing in C# with NUnit 中提供了一个方法，从MyObject派生一个类MyObjectTester，然后建立一个公有方法TestMyProtectedMethod，封装上面的protected方法，如下：

public new string TestMyProtectedMethod(string strInput, int i32Value)

{

return base.MyProtectedMethod(strInput,

i32Value);

}

该方法很简单，满足了上面的所有标准：

标准

满足性

透明性

使用继承将MyObjectTester 类放到UnitTests 程序集中，没有在产品代码中添加新的代码。

范围

与是否调试模式无关。

简单性

虽然本方法需要一个继承的类，但符合OO思想。

4. 测试私有方法

测试私有方法稍微复杂些，但我们可以利用System.Reflection。你可以利用反射动态的访问一个类型的方法，包括实例和静态的私有方法。要注意的是访问私有方法需要ReflectionPermission，但在开发机或BUILD机上运行单元测试不是问题。

假设我们要测试ClassLibrary1.MyObject类的MyPrivateMethod私有方法：

private string MyPrivateMethod(string strInput, DateTime dt, double

dbl)

{

return this.Name + ": " + strInput + ", " +

dt.ToString() + ", " + dbl.ToString();

}

一种解决方法是建立一个UnitTestUtilities 工程包含一个UnitTestUtilities.Helper类，用于通过反射调用测试方法。

public static object RunStaticMethod(System.Type t, string strMethod,

object [] aobjParams)

{

BindingFlags eFlags =

BindingFlags.Static | BindingFlags.Public |

BindingFlags.NonPublic;

return RunMethod(t, strMethod,

null, aobjParams, eFlags);

} //end of method

public static object RunInstanceMethod(System.Type t, string strMethod,

object objInstance, object [] aobjParams)

{

BindingFlags eFlags = BindingFlags.Instance | BindingFlags.Public |

BindingFlags.NonPublic;

return RunMethod(t, strMethod,

objInstance, aobjParams, eFlags);

} //end of method

private static object RunMethod(System.Type t, string

strMethod, object objInstance, object [] aobjParams, BindingFlags eFlags)

{

MethodInfo m;

try

{

m = t.GetMethod(strMethod, eFlags);

if (m == null)

{

throw new ArgumentException("There is no method '" +

strMethod + "' for type '" + t.ToString() + "'.");

}

object objRet = m.Invoke(objInstance, aobjParams);

return objRet;

}

catch

{

throw;

}

} //end of method

私有方法RunMethod利用反射时必须的参数，调用相关的被测试方法并返回值。这里有两个封装的方法RunStaticMethod和RunInstanceMethod，分别针对静太方法和实例方法。

大概看一下这两个方法的代码，首先取得类型的MethodInfo，因为我们调用的是已经存在的方法，如果是空方法，则产生一个异常。一旦有了MethodInfo，我们就可以调用实例（如果是static，则为null）的私有方法，并传入参数数组。

我们可以在NUnit中这样使用：

[Test] public void TestPrivateInstanceMethod()

{

string strExpected = "MyName: Hello, 5/24/2004

12:00:00 AM, 2.1";

ClassLibrary1.MyObject objInstance

= new MyObject("MyName");

object obj =

UnitTestUtilities.Helper.RunInstanceMethod(

typeof(ClassLibrary1.MyObject), "MyPrivateMethod",

objInstance, new object[3] {"Hello",

new DateTime(2004,05,24), 2.1});

string strActual = Convert.ToString(obj);

Assert.AreEqual(strExpected,strActual);

}

标准

满足性

透明性

唯一的额外代码- UnitTestUtilities,不会包含在产品中一起发布。

范围

该方法中没有任何东西是仅依赖于调试模式。

简单性

该方法可以在一个单独调用中调用任何方法。利用UnitTestUtilities的唯一问题就是为RunInstanceMethod或RunStaticMethod创建正确的参数（方法名、数据类型等）。因为方法是动态调用的，参数在编译时不会被检查。

5. 结论

虽然对私有方法的测试存在争论，至少我们现在知道如何进行测试了。我们可以通过包装基类建立一个派生类TesterClass用于测试其protected方法，通过UnitTestUtility帮助类利用反射可以测试类中的私有方法。所有这些技术都可利于提高测试覆盖率。

参考:

http://www.codeproject.com/csharp/TestNonPublicMembers.asp

FROM: http://jane3s.bokee.com/6967889.html

Other: http://jane3s.bokee.com/catalog_140822.html

本文链接

(转) SQL替换多个特殊字符

2011-09-13T07:03:00Z

CREATE TABLE ErrorMessage ( NA VARCHAR(20))
INSERT INTO ErrorMessage VALUES('')
INSERT INTO ErrorMessage VALUES('★')
INSERT INTO ErrorMessage VALUES('△')
GO


CREATE TABLE Erro ( NA1 VARCHAR(20))
INSERT INTO Erro VALUES('实打实的大★厦')
INSERT INTO Erro VALUES('实打大★厦')
GO


DECLARE @REPLACECMD VARCHAR(2000)='NA1'
SELECT @REPLACECMD ='REPLACE('+ @REPLACECMD+','''+NA+''' ,'''')' FROM ErrorMessage
print @REPLACECMD
DECLARE @SQLCMD VARCHAR(4000)=''
SET @SQLCMD = 'select '+@REPLACECMD+'AS NECOL FROM Erro'
EXEC (@SQLCMD)

--NECOL
实打实的大厦
实打大厦

FROM:http://topic.csdn.net/u/20100928/13/0b89a46c-4927-4986-8f27-99b4d8d8ecea.html

本文链接

博客园_天下無雙

(转)MongoDB——安装篇（windows）

(转)MongoDB 增加用户 删除用户 修改用户 读写权限 只读权限,

（转）MongoDB设置访问权限、设置用户

赎回收益率（Yield to Call，YTC）

YTC, YTM, YTW

(转)测试 MVC 之 Mock HttpContext

(转)使用 NUnit Mocking .NET 对象

(转)moq 的常用使用方法

（转）如何测试私有/受保护的方法

(转) SQL替换多个特殊字符

(转)MongoDB 增加用户删除用户修改用户读写权限只读权限,