c# itextsharp pdfreader not opened with owner password : Delete page pdf file Library SDK component asp.net .net winforms mvc The%20Art%20of%20Unit%20Testing%20with%20Examples%20in%20.NET%20(Manning%202009)12-part1043

Stub chains: stubs that produce mocks or other stubs
95
One of the most common scamming techniques online these days fol-
lows a simple path. A fake email is sent to a massive number of recipi-
ents. The fake email is from a fake bank or online service claiming that 
the potential customer needs to have a balance checked or to change 
some account details on the online site.
All the links in the email point to a fake site. It looks exactly like the 
real thing, but its only purpose is to collect data from innocent custom-
ers of that business. This simple “chain of lies” is known as a “phishing” 
attack, and is more lucrative that you’d imagine. Most people respond 
instinctively  to these emails and do  what’s  asked. Consequently,  it’s 
one of the biggest threats to identity theft in the world.
How does this “chain of lies” matter to us? Sometimes we want to have 
a fake component return another fake component, producing our own 
little chain of stubs in our tests, so that we can end up collecting some 
data during our test. A stub leads to a mock object that records data. 
The  design  of  many  systems  under  test  allows  for  complex  object 
chains to be created. It’s not uncommon to find code like this:
IServiceFactory factory = GetServiceFactory();
IService service = factory.GetService();
Or like this:
String connstring =
GlobalUtil.Configuration.DBConfiguration.ConnectionString;
Suppose you wanted to replace the connection string with one of your 
own during a test. You could set up the 
Configuration
property of the 
GlobalUtil
object to be a stub object. Then, you could set the 
DBConfig-
uration
property on that object to be another stub object, and so on.
It’s  a  powerful  technique,  but  you  need  to  ask  yourself  whether  it 
might not be better to refactor your code to do something like this:
4.6 Stub chains: stubs that produce mocks or other stubs
Delete page pdf file - remove PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Provides Users with Mature Document Manipulating Function for Deleting PDF Pages
delete page on pdf document; delete a page from a pdf without acrobat
Delete page pdf file - VB.NET PDF Page Delete Library: remove PDF pages in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Visual Basic Sample Codes to Delete PDF Document Page in .NET
delete pages out of a pdf; delete page from pdf acrobat
96
CHAPTER 4    Interaction testing using mock objects
String connstring =GetConnectionString();
Protected virtual string GetConnectionString()
{
Return GlobalUtil.Configuration.DBConfiguration.ConnectionString;
}
You  could  then override  the  virtual  method  as  described  in  section 
3.4.5 in chapter 3. This can make the code easier to read and maintain, 
and it doesn’t require adding new interfaces to insert two more stubs 
into the system.
TIP
Another  good  way  to  avoid  call  chains  is  to  create  special  wrapper 
classes  around  the  API  that  simplify  using  and  testing  it.  For  more 
about this method, see Michael Feathers’ book, 
Working Effectively with 
Legacy Code
. The pattern is called “Adapt Parameter” in that book.
Handwritten mocks and stubs have benefits, but they also have their 
share of problems. Let’s take a look at them.
There are several issues that crop up when using manual mocks and 
stubs:
It takes time to write the mocks and stubs.
It’s difficult to write stubs and mocks for classes and interfaces that 
have many methods, properties, and events.
To save state for multiple calls of a mock method, you need to write a 
lot of boilerplate code to save the data.
If you want to verify all parameters on a method call, you need to 
write multiple asserts. If the first assert fails, the others will never 
run, because a failed assert throws an exception.
It’s hard to reuse mock and stub code for other tests.
These  problems  are  inherent  in  manually  written  mocks  and  stubs. 
Fortunately, there are other ways to create mocks and stubs, as you’ll 
see in the next chapter.
4.7 The problems with handwritten mocks and stubs
C# PDF File & Page Process Library SDK for C#.net, ASP.NET, MVC
C# File: Merge PDF; C# File: Split PDF; C# Page: Insert PDF pages; C# Page: Delete PDF pages; C# Read: PDF Text Extract; C# Read: PDF
delete blank pages in pdf; delete page from pdf online
VB.NET PDF File & Page Process Library SDK for vb.net, ASP.NET
your PDF document is unnecessary, you may want to delete this page adding a page into PDF document, deleting unnecessary page from PDF file and changing
delete pdf pages reader; cut pages out of pdf online
Summary 
97
This chapter covered the distinction between stub and mock objects. A 
mock object is like a stub, but it also helps you to assert something in 
your test.  A stub,  on the other hand, can never fail your test and  is 
strictly there to simulate various situations. This distinction is impor-
tant because many of the mock object frameworks you’ll see in the next 
chapter have  these definitions  engrained  in  them, and you’ll need to 
know when to use which.
Combining stubs and mocks in the same test is a powerful technique, 
but you must take care to have no more than one mock in each test. 
The rest of the fake objects should be stubs that can’t break your test. 
Following this practice can lead to more maintainable tests that break 
less often when internal code changes.
Stubs that  produce  other stubs or  mocks  can be a powerful way to 
inject  fake  dependencies into  code that uses  other  objects  to  get  its 
data.  It’s a great technique to use with  factory  classes and methods. 
You can even have stubs that return other stubs that return other stubs 
and so on, but at some point you’ll wonder if it’s all worth it. In that 
case, take a look at the techniques described in chapter 3 for injecting 
stubs into  your design. (Only one mock framework currently allows 
stubbing a full call chain in one line of code—creating stubs that return 
stubs—and that’s Typemock Isolator.)
One of the most common problems encountered by people who write 
tests is using mocks too much in their tests. You should rarely verify 
calls to fake objects that are used both as mocks and as stubs in the 
same test. (This is quite a narrow corner case. You verify a function 
was called. Because it’s still a function, it must return some value, and 
because you’re faking that method, you’ll need to tell the test what that 
value will be. This value is the part in the test that’s a stub, because it 
has nothing to do with asserting whether the test passes or fails.) If you 
see “verify” and “stub” on the same variable in the same test, you most 
likely are overspecifying your test, which will make it more brittle.
4.8 Summary 
C# PDF Page Insert Library: insert pages into PDF file in C#.net
page processing functions, such as how to merge PDF document files by C# code, how to rotate PDF document page, how to delete PDF page using C#
delete page in pdf; delete pages from pdf
C# PDF File Split Library: Split, seperate PDF into multiple files
Besides, in the process of splitting PDF document, developers can also remove certain PDF page from target PDF file using C#.NET PDF page deletion API.
delete blank pages from pdf file; add and delete pages in pdf
98
CHAPTER 4    Interaction testing using mock objects
You can have multiple stubs in a test, because a class may have multiple 
dependencies. Just  make  sure your test remains  readable.  Structure 
your code nicely so the reader of the test understands what’s going on.
You may find that writing manual mocks and stubs is inconvenient for 
large interfaces or for complicated interaction-testing scenarios. It is, 
and there are better ways to do this, as we’ll see in the next chapter. But 
often you’ll  find  that  handwritten mocks  and  stubs still  beat  frame-
works for simplicity and readability. The art lies in when you use which.
Our next chapter deals with mock object frameworks, which allow you 
to automatically create, at runtime, stub or mock objects and use them 
with at least the same power as manual mocks and stubs, if not more.
VB.NET PDF File Compress Library: Compress reduce PDF size in vb.
Since images are usually or large size, images size reducing can help to reduce PDF file size effectively. Delete unimportant contents Embedded page thumbnails.
delete pages on pdf; delete pages from pdf in reader
VB.NET PDF Page Insert Library: insert pages into PDF file in vb.
using RasterEdge.XDoc.PDF; Add and Insert a Page to PDF File Using VB. doc2.Save( outPutFilePath). Add and Insert Blank Page to PDF File Using VB.
delete page in pdf reader; add and remove pages from a pdf
99
Isolation (mock object) 
frameworks
This chapter covers
•Understanding isolation frameworks
•Defining fake objects
•Using Rhino Mocks to create stubs and mocks
•Surveying advanced use cases for mocks and stubs
•Exploring arrange-act-assert and record-and-replay syntax
•Avoiding common misuses of isolation frameworks
n the previous chapter, we looked at writing mocks and stubs manually
and  saw  the  challenges  involved.  In  this  chapter,  we’ll  look  at  some
elegant  solutions  for  these  problems  in  the  form  of  a 
mock  object
framework
—a reusable library that can create and configure stub and mock
objects 
at runtime
. These objects are usually referred to as 
dynamic stubs 
and
dynamic mocks
.
We’ll start this chapter off with an overview of mock object frameworks
(or isolation frameworks—the word 
mock
is too overloaded already) and
what they  can do  for us.  We’ll then take  a  closer look at one  specific
framework: Rhino Mocks. We’ll see  how we  can use it  to test  various
things and to create stubs, mocks, and other interesting things.
I
VB.NET PDF File Split Library: Split, seperate PDF into multiple
The VB.NET PDF document splitter control provides VB.NET developers an easy to use solution that they can split target multi-page PDF document file to one-page
delete pages in pdf; delete pages pdf file
C# PDF File Compress Library: Compress reduce PDF size in C#.net
Since images are usually or large size, images size reducing can help to reduce PDF file size effectively. Delete unimportant contents Embedded page thumbnails.
add and remove pages from pdf file online; delete a page from a pdf without acrobat
100
CHAPTER 5
Isolation (mock object) frameworks
Later in this  chapter, we’ll contrast  Rhino Mocks with other frame-
works currently available to .NET developers, and we’ll finish with a
list of things to watch out for when using such frameworks in your tests. 
Let’s start at the beginning: What are isolation frameworks?
We’ll start with a basic definition.
DEFINITION
An 
isolation framework
is a set of programmable APIs that make creat-
ing mock and stub objects much easier. Isolation frameworks save the
developer  from the  need to  write  repetitive  code to  test  or  simulate
object interactions.
This  definition may  sound a  bit  bland, but it needs to  be  generic in
order to include the various isolation frameworks out there.
Isolation frameworks exist for most languages that have a unit-testing
framework associated with them. For example, C++ has mockpp and
other frameworks, and Java has jMock and EasyMock, among others.
.NET has NMock, Moq, Typemock Isolator, and Rhino Mocks.
Using isolation frameworks instead of writing mocks and stubs manu-
ally, as in previous chapters, has several advantages that make develop-
ing more elaborate and complex tests easier, faster, and less error-prone.
The best way to understand the value of an isolation framework is to
see a problem and solution. One problem that might occur when using
handwritten mocks and stubs is repetitive code.
Assume you have an interface a little more complicated than the ones
shown so far:
public interface IComplicatedInterface
{
void Method1(string a, string b, bool c, int x, object o);
void Method2(string b, bool c, int x, object o);
void Method3(bool c, int x, object o);
}
5.1 Why use isolation frameworks?
Why use isolation frameworks?
101
Creating a handwritten stub or mock for this interface may be time-
consuming, because we’d need to remember the parameters on a per-
method basis, as listing 5.1 shows.
Listing 5.1 Implementing complicated interfaces with handwritten stubs
class MytestableComplicatedInterface:IComplicatedInterface
{
public string meth1_a;
public string meth1_b,meth2_b;
public bool meth1_c,meth2_c,meth3_c;
public int meth1_x,meth2_x,meth3_x;
public int meth1_0,meth2_0,meth3_0;
public void Method1(string a,
string b, bool c,
int x, object o)
{
meth1_a = a;
meth1_b = b;
meth1_c = c;
meth1_x = x;
meth1_0 = 0;
}
public void Method2(string b, bool c, int x, object o)
{
meth2_b = b;
meth2_c = c;
meth2_x = x;
meth2_0 = 0;
}
public void Method3(bool c, int x, object o)
{
meth3_c = c;
meth3_x = x;
meth3_0 = 0;
}
}
Not only is this test time-consuming and cumbersome to write, what
happens if we want to test that a method is called many times? Or if we
102
CHAPTER 5
Isolation (mock object) frameworks
want it to return a specific value based on the parameters it receives, or
to remember all the values for all the method calls on the same method
(the parameter history)? The code gets ugly fast.
Using an isolation framework, the code for doing this becomes trivial,
readable, and much shorter, as you’ll see when you create your first
dynamic mock object.
NOTE
The  word 
fake
was  introduced in  chapter 4  as a  generic term for
either a stub or a mock.
Let’s define 
dynamic fake objects
, and how they’re different from regular
mocks.
DEFINITION
dynamic fake object
is any stub or mock that’s created at runtime with-
out needing  to  use  a handwritten  implementation  of an  interface  or
subclass.
Using dynamic fakes removes the need to hand-code classes that imple-
ment interfaces or that derive from other classes, because this can be
generated for the developer at runtime by a simple line of code. 
5.2.1 Introducing Rhino Mocks into your tests
In this chapter, we’ll use Rhino Mocks, an isolation framework that’s
open source and freely downloadable from http://ayende.com . It’s sim-
ple and quick to use, with little overhead in learning how to use the
API.  I’ll  walk  you  through  a  few  examples,  and  then  we’ll  explore
other frameworks and discuss the differences among them.
The only thing you’ll need to do to use Rhino Mocks, after download-
ing  and  unzipping  it,  (assuming  you  have  NUnit  installed  on  your
machine) is to  add  a  reference  to the  Rhino.Mocks.Dll.  In the  Add
Reference dialog of the test project, click Browse, and locate the down-
loaded DLL file (which you can get from http://www.ayende.com/proj-
ects/rhino-mocks/downloads.aspx).
Rhino Mocks allows us to create and use fakes in two different ways.
The first one is the 
record-and-replay
model, and is the one you’ll be see-
5.2 Dynamically creating a fake object
Dynamically creating a fake object
103
ing most in this chapter. The other is the 
arrange-act-assert
model, which
I’ll be discussing near the end of this chapter.
Rhino Mocks contains in its API a class called 
MockRepository
that has
special methods for creating mocks and stubs. The first one we’ll look
at  is 
StrictMock()
.  The  method  is  called  with  a  generic  parameter
matching the type of an interface or class that you’d like to fake, and it
dynamically
creates a fake object that adheres to that interface at run-
time. You don’t need to implement that new object in real code.
5.2.2 Replacing a handwritten mock object with a dynamic one
As an example, let’s look at a handwritten mock object used to check
whether a call to the log was performed correctly. Listing 5.2 shows the
test class and the handwritten mock.
Listing 5.2 Asserting against a handwritten mock object
[TestFixture]
public class LogAnalyzerTests
{
[Test]
public void Analyze_TooShortFileName_CallsWebService()
{
ManualMockService mockService = new ManualMockService ();
LogAnalyzer log = new LogAnalyzer(mockService);
string tooShortFileName="abc.ext";
log.Analyze(tooShortFileName);
Assert.AreEqual("Filename too short:abc.ext",
mockService.LastError);
}
}
public class ManualMockService:IWebService
{
public string LastError;
public void LogError(string message)
{
LastError = message;
}
}
104
CHAPTER 5
Isolation (mock object) frameworks
The parts of the code in bold are the parts that will change when we
start using dynamic mock objects.
We’ll now create a dynamic mock object, and eventually replace the
earlier test. Listing 5.3 shows a simple piece of code that creates a sim-
ulated object based on an interface using the record-and-replay syntax
in Rhino Mocks.
Listing 5.3 Creating a dynamic mock object using Rhino Mocks 
[Test]
public void Analyze_TooShortFileName_ErrorLoggedToService()
{
MockRepository mocks = new MockRepository();
IWebService simulatedService =       
mocks.StrictMock<IWebService>(); 
using(mocks.Record())       
                     
simulatedService
.LogError("Filename too short:abc.ext");
                                    
LogAnalyzer log = 
new LogAnalyzer(simulatedService); 
string tooShortFileName="abc.ext"; 
log.Analyze(tooShortFileName);  
mocks.Verify(simulatedService); 
}
A couple of lines rid us of the need to use a handwritten stub or mock,
because  they  generate  one  dynamically ?.  The 
simulatedService
object instance is a dynamically generated object that implements the
IWebService
interface, but there’s no implementation inside any of the
IWebService
methods. 
Next, we set the simulated service object into a “record” state. This is a
special state where each method call on the simulated object is recorded
as an 
expectation
that something should happen to our simulated object
w
. These 
expectations
will later be verified by calling 
mockEngine.Verify-
Creates dynamic 
mock object
?
Sets 
expectation
w
Invokes 
LogAnalyzer
e
Asserts expectations 
have been met
?
Documents you may be interested
Documents you may be interested