에뮬레이터를 사용하여 Sharepoint 2010 응용 프로그램용 단위 테스트 격리Using emulators to isolate unit tests for Sharepoint 2010 applications

Microsoft.SharePoint.Emulators 패키지는 Microsoft SharePoint 2010 응용 프로그램에 대한 격리된 단위 테스트를 만들도록 도와주는 라이브러리 집합을 제공합니다.The Microsoft.SharePoint.Emulators package provides a set of libraries that help you to create isolated unit tests for Microsoft SharePoint 2010 applications. 에뮬레이터는 Microsoft Fakes 격리 프레임워크의 shim을 사용하여 SharePoint API의 가장 일반적인 개체 및 메서드를 가장하는 간단한 메모리 내 개체를 만듭니다.Emulators use shims from the Microsoft Fakes isolation framework to create lightweight in-memory objects that mimic the most common objects and methods of the SharePoint API. SharePoint 메서드가 에뮬레이트되지 않는 경우가 에뮬레이터의 기본 동작을 변경하려면 Fakes shim을 만들어서 원하는 결과를 제공할 수 있습니다.When a SharePoint method is not emulated, or when you want to change the default behavior of an emulator, you can create Fakes shims to provide the results that you want.

기존 테스트 메서드 및 클래스는 에뮬레이터 컨텍스트에서 실행되도록 쉽게 변환될 수 있습니다.Existing test methods and classes can be easily converted to run in the Emulator context. 이 기능을 통해 이중 사용 테스트를 만들 수 있습니다.This capability lets you create dual-use tests. 이중 사용 테스트는 실제 SharePoint API에 대한 통합 테스트와 에뮬레이터를 사용하는 격리된 단위 테스트 간에 전환할 수 있습니다.A dual-use test can toggle between integration tests against the real SharePoint API and isolated unit tests that use the emulators.

항목 내용In this topic

RequirementsRequirements

AppointmentsWebPart 예제The AppointmentsWebPart example

기존 테스트 변환Converting an existing test

요구 사항Requirements

AppointmentsWebPart 예제The AppointmentsWebPart example

AppointmentsWebPart를 사용하여 약속의 SharePoint 목록을 보고 관리할 수 있습니다.The AppointmentsWebPart lets you view and manage a SharePoint list of your appointments.

약속 웹 파트Appointments Web Part

이 예제에서는 웹 파트의 두 가지 메서드를 테스트해 보겠습니다.We'll test two methods of the web part in this example:

  • ScheduleAppointment 메서드는 메서드에 전달되는 목록 항목 값의 유효성을 검사하고 지정된 SharePoint 웹에서 목록에 새 항목을 만듭니다.The ScheduleAppointment method validates the list item values passed to the method and creates a new entry in a list on a specified SharePoint web.

  • GetAppointmentsForToday 메서드는 오늘 약속의 세부 정보를 반환합니다.The GetAppointmentsForToday method returns the details of today's appointments.

    항목 내용In this topic

기존 테스트 변환Converting an existing test

SharePoint 구성 요소의 일반적인 메서드 테스트에서 테스트 메서드는 SharePoint Foundation에서 임시 사이트를 만들고 테스트 중인 코드에 필요한 SharePoint 구성 요소를 사이트에 추가합니다.In a typical test of a method in a SharePoint component, the test method creates a temporary site in SharePoint Foundation and adds the SharePoint components to the site that the code under test requires. 그다음에 테스트 메서드는 구성 요소 인스턴스를 만들고 실행합니다.The test method then creates and exercises an instance of the component. 테스트가 끝나면 사이트가 삭제됩니다.At the end of the test, the site is torn down.

테스트 중인 코드의 ScheduleAppointment 메서드는 구성 요소에 대해 작성된 첫 번째 메서드의 하나일 수 있습니다.The ScheduleAppointment method of our code under test is probably one of the first methods written for the component:

// method under test  
public bool ScheduleAppointment(SPWeb web, string listName, string name,   
    string phone, string email, string age, DateTime date, out string errorMsg)  
{  
    errorMsg = string.Empty;  
    var badFormat = this.checkInput(name, phone, email, age);  
    if (badFormat)  
    {  
        errorMsg = "Bad Format";  
        return false;  
    }  
    var exists = this.CheckDuplicate(listName, web, name, phone, email, age, date);  
    if (exists)  
    {  
        errorMsg = "Item already exists";  
        return false;  
    }  
    SPListItemCollection items = web.Lists[listName].Items;  
    // create item and populate fields  
    SPListItem item = items.Add();  
    item["Name"] = name;  
    item["Phone"] = phone;  
    item["Email"] = email;  
    item["Age"] = age;  
    item["Date"] = date.ToString("D");  
    item.Update();  
    return true;  
}  

ScheduleAppointment의 첫 번째 기능 테스트는 다음과 같이 표시됩니다.The first test of the functionality in ScheduleAppointment method might look like this:


[TestMethod]  
public void ScheduleAppointmentReturnsTrueWhenNewAppointmentIsCreated()  
{  
    using( var site = new SPSite("http://localhost"))  
    using (var webPart = new BookAnAppointmentWebPart())  
    {  
        // Arrange  
        string errorMsg = string.Empty;  
        DateTime date = DateTime.Now;  
        SPList list = AddListToSiteHelper(site);  

        // Act  
        bool success = webPart.ScheduleAppointment(site.RootWeb, list.Title,  
            "Raisa Pokrovskaya", "425-555-0163", "raisa@outlook.com", "55", date,   
            out errorMsg);  
        list.Delete();  

        // Assert  
        Assert.IsTrue(success);  
    }  
}  

이 테스트 메서드는 ScheduleAppointment 메서드가 목록에 새 항목을 제대로 추가하는지 확인하지만, 코드의 특정 동작에 대한 테스트보다 더 통합적인 웹 파트 테스트입니다.Although this test method does verify that the ScheduleAppointment method correctly adds a new entry to the list, it is more an integration test of the web part than a test of the specific behavior of your code. ScheduleAppointment 메서드의 사용자 코드 이외의 이유로 SharePoint 및 SharePoint API에 대한 외부 종속성 때문에 테스트가 실패할 수 있습니다.The external dependencies to SharePoint and the SharePoint API can cause the test to fail for reasons other than the user code in the ScheduleAppointment method. SharePoint 사이트를 만들고 배포할 때 발생하는 오버헤드로 인해 테스트가 너무 느려져서 코딩 프로세스의 일반 파트로 실행될 수 없습니다.The overhead in creating and destroying the SharePoint site can also make the test too slow to run as a regular part of the coding process. 모든 테스트 메서드에 대한 사이트 설정 및 제거를 수행하면 효율적인 개발자 단위 테스트를 만들 때 문제가 악화됩니다.Performing the setup and destruction of the site for every test method only compounds the problem of creating efficient developer unit tests.

Microsoft SharePoint 에뮬레이터에서는 가장 일반적인 SharePoint API의 동을 가장하는 개체 및 메서드 "doubles" 집합을 제공합니다.Microsoft SharePoint emulators give you a set of object and method "doubles" that mimic the behavior of the most common SharePoint APIs. 에뮬레이트된 메서드는 SharePoint를 실행할 필요가 없는 SharePoint API의 간단한 구현입니다.The emulated methods are lightweight implementations of the SharePoint API that do not require SharePoint to run. Microsoft Fakes를 사용하여 SharePoint API에 대한 호출을 SharePoint 에뮬레이터의 메서드 doubles로 우회하면 테스트를 격리하고 원하는 코드를 테스트하고 있는지 확인합니다.By using Microsoft Fakes to detour calls to the SharePoint API to the method doubles of SharePoint Emulators, you isolate your tests and make sure that you are testing the code you want. 에뮬레이트되지 않는 SharePoint 메서드를 호출할 때 Fakes를 직접 사용하여 원하는 동작을 만들 수 있습니다.When you call SharePoint methods that are not emulated, you can use Fakes directly to create the desired behavior.

항목 내용In this topic

테스트 프로젝트에 에뮬레이터 패키지 추가Adding the Emulators package to a test project

테스트 프로젝트에 SharePoint 에뮬레이터를 추가하려면To add the SharePoint emulators to a test project:

  1. 솔루션 탐색기에서 테스트 프로젝트를 선택합니다.Select the test project in Solution Explorer.

  2. 바로 가기 메뉴에서 NuGet 패키지 관리...를 선택합니다.Choose Manage NuGet Packages ... on the shortcut menu.

  3. Microsoft.SharePoint.Emulators에 대한 온라인 범주를 검색한 다음 설치를 선택합니다.Search the Online category for Microsoft.SharePoint.Emulators, and then choose Install.

    SharePoint 에뮬레이터 NuGet 패키지Sharepoint Emulators NuGet package

    항목 내용In this topic

에뮬레이션을 통해 테스트 메서드 실행Running a test method with emulation

패키지를 설치하면 필요한 라이브러리에 대한 참조가 프로젝트에 추가됩니다.Installing the package adds references to the required libraries to your projects. 기존 테스트 클래스에서 에뮬레이터를 쉽게 사용하려면 네임스페이스 Microsoft.SharePoint.EmulatorsMicrosoft.QualityTools.Testing.Emulators를 추가합니다.To make it easy to use emulators in an existing test class, add the namespaces Microsoft.SharePoint.Emulators and Microsoft.QualityTools.Testing.Emulators.

테스트 메서드에서 에뮬레이션을 사용하려면 SharePointEmulationScope 개체를 만드는 using 문으로 메서드 본문을 래핑합니다.To enable emulation in your test methods, wrap the method body in a using statement that creates a SharePointEmulationScope object. 예:For example:


[TestMethod]  
public void ScheduleAppointmentReturnsTrueWhenNewAppointmentIsCreated()  
{  
    // create the emulation scope with a using statement  
    using (new SharePointEmulationScope())  
    using( var site = new SPSite("http://localhost"))  
    using (var webPart = new BookAnAppointmentWebPart())  
    {  
        // Arrange  
        string errorMsg = string.Empty;  
        DateTime date = DateTime.Now;  
        SPList list = AddListToSiteHelper(site);  

        // Act  
        bool success = webPart.ScheduleAppointment(site.RootWeb, list.Title,  
            "Raisa Pokrovskaya", "425-555-0163", "raisa@outlook.com", "55", date,   
            out errorMsg);  
        list.Delete();  

        // Assert  
        Assert.IsTrue(success);  
    }  
}  

테스트 메서드가 실행되면 에뮬레이터 런타임에서는 Microsoft Fakes를 호출하여 SharePoint 메서드에 코드를 동적으로 주입하고 이들 메서드에 대한 호출을 Microsoft.SharePoint.Fakes.dll에 선언된 대리자로 전환합니다.When the test method is executed, the Emulator runtime calls Microsoft Fakes to dynamically inject code into SharePoint methods to divert the calls to these methods to delegates that are declared in Microsoft.SharePoint.Fakes.dll. Microsoft.SharePoint.Emulators.dll은 에뮬레이트된 메서드에 대한 대리자를 구현하여 실제 SharePoint 동작을 매우 비슷하게 가장합니다.Microsoft.SharePoint.Emulators.dll implements the delegates for emulated methods, closely mimicking the actual SharePoint behavior. 테스트 중인 구성 요소 또는 테스트 메서드가 SharePoint 메서드를 호출하면 에뮬레이션의 동작이 생성됩니다.When the test method or the component under test calls a SharePoint method, the behavior that results is that of the emulation.

에뮬레이터 실행 흐름Emulator execution flow

항목 내용In this topic

이중 사용할 클래스 및 메서드 만들기Creating dual-use classes and methods

실제 SharePoint API에 대한 통합 테스트 및 에뮬레이터를 사용하는 격리된 단위 테스트에 둘 다 사용할 수 있는 메서드를 만들려면 오버로드된 생성자 SharePointEmulationScope(EmulationMode)를 사용하여 테스트 메서드 코드를 래핑합니다.To create methods that can be used for both integration tests against the real SharePoint API and isolated unit tests that use emulators, use the overloaded constructor SharePointEmulationScope(EmulationMode) to wrap your test method code. EmulationMode 열거형의 두 값은 범위에서 에뮬레이터를 사용할지 여부(EmulationMode.Enabled) 또는 범위에서 SharePoint API를 사용할지 여부(EmulationMode.Passthrough)를 지정합니다.The two values of the EmulationMode enum specify whether the scope uses emulators (EmulationMode.Enabled) or whether the scope uses the SharePoint API (EmulationMode.Passthrough).

예를 들어 다음은 이전 테스트를 이중 사용으로 수정하는 방법입니다.For example, here's how you can modify the previous test to be dual-use:


// class level field specifies emulation mode  
private const EmulationMode emulatorMode = EmulationMode.Enabled;  

[TestMethod]  
public void ScheduleAppointmentReturnsTrueWhenNewAppointmentIsCreated()  
{  
    // emulation scope determined by emulatorMode  
    using( SharePointEmulationScope(emulatorMode))  
    using( var site = new SPSite("http://localhost"))  
    using (var webPart = new BookAnAppointmentWebPart())  
    {  
        // Arrange  
        string errorMsg = string.Empty;  
        DateTime date = DateTime.Now;  
        SPList list = AddListToSiteHelper(site);  

        // Act  
        bool success = webPart.ScheduleAppointment(site.RootWeb, list.Title,  
            "Raisa Pokrovskaya", "425-555-0163", "raisa@outlook.com", "55", date,   
            out errorMsg);  
        list.Delete();  

        // Assert  
        Assert.IsTrue(success);  
    }  
}  

항목 내용In this topic

TestInitialize 및 TestCleanup 특성을 사용하여 이중 사용 테스트 클래스 만들기Using TestInitialize and TestCleanup attributes to create a dual-use test class

SharePointEmulationScope를 사용하여 클래스의 모든 또는 대부분 테스트를 실행하면 클래스 수준 방법을 사용하여 에뮬레이션 모드를 설정할 수 있습니다.If you run all or most of the tests in a class using SharePointEmulationScope, you can take advantage of class-level techniques to set the emulation mode.

  • <xref:Microsoft.VisualStudio.TestTools.UnitTesting.TestInitializeAttribute> 및 <xref:Microsoft.VisualStudio.TestTools.UnitTesting.TestCleanupAttribute> 특성을 사용하는 테스트 클래스 메서드는 범위를 만들고 제거할 수 있습니다.Test class methods that attributed with <xref:Microsoft.VisualStudio.TestTools.UnitTesting.TestInitializeAttribute> and <xref:Microsoft.VisualStudio.TestTools.UnitTesting.TestCleanupAttribute> can create and destroy the scope.

  • 클래스 수준에서 EmulationMode를 설정하면 EmulationMode.EnabledEmulationMode.Passthrough 간의 모드 변경을 자동화할 수 있습니다.Setting the EmulationMode at the class level can let you automate the mode change between EmulationMode.Enabled and EmulationMode.Passthrough.

    [TestInitialize] 특성이 사용된 클래스 메서드는 각 테스트 메서드가 시작될 때 실행되고 [TestCleanup] 특성이 사용된 메서드는 각 테스트 메서드가 종료될 때 실행됩니다.A class method that is attributed with [TestInitialize] is run at the start of each test method and a method that is attributed with [TestCleanup] runs at the end of each test method. 클래스 수준에서 SharePointEmulationScope 개체에 대한 전용 필드를 선언하고, TestInitialize 특성 사용 메서드에서 초기화하고, TestCleanup 특성 사용 메서드에서 개체를 삭제할 수 있습니다.You can declare a private field for the SharePointEmulationScope object at the class level, initialize it in the TestInitialize attributed method, and then dispose of the object in the TestCleanup attributed method.

    선택한 메서드를 사용하여 EmulationMode 선택을 자동화할 수 있습니다.You can use any method that you choose to automate the selection of the EmulationMode. 한 가지 방법은 전처리기 지시문을 사용하여 기호가 있는지 확인하는 것입니다.One way is to check for the existence of a symbol by using preprocessor directives. 예를 들어 에뮬레이터를 사용하여 클래스에서 테스트 메서드를 실행하려면 테스트 프로젝트 파일이나 빌드 명령줄에서 USE_EMULATION과 같은 기호를 정의하면 됩니다.For example, to run the test methods in a class using emulators, you can define a symbol such as USE_EMULATION in the test project file or on the build command line. 기호가 정의되면 클래스 수준 EmulationMode 상수가 선언되고 Enabled로 설정됩니다.If the symbol is defined, a class level EmulationMode constant is declared and set to Enabled. 그렇지 않으면 상수가 Passthrough로 설정됩니다.Otherwise, the constant is set to Passthrough.

    다음은 전처리기 지시문과 TestInitializeTestCleanup 특성 사용 메서드를 사용하여 에뮬레이션 모드를 설정하는 방법을 보여 주는 테스트 클래스의 예제입니다.Here's an example of the test class that demonstrates how to use preprocessor directives and the TestInitialize and TestCleanup attributed methods to set the emulation mode.

//namespace declarations  
...  

namspace MySPAppTests   
{  
    [TestClass]  
    public class BookAnAppointmentWebPartTests  
    {  

        // emulationScope is a class level field  
        private SharePointEmulationScope emulationScope;  

        // preprocessor directives determine the value of emulatorMode  
        #if USE_EMULATIONprivate const EmulationMode emulatorMode = EmulationMode.Enabled;#elseprivate const EmulationMode emulatorMode = EmulationMode.Passthrough;#endif  

        // InitializeTest sets the emulation scope at the beginning of each test method  
        [TestInitialize]public void InitializeTest(){this.emulationScope = new SharePointEmulationScope(emulatorMode);}  

        // CleanupTest disposes the emulation scope at the end of each test method  
        [TestCleanup]public void CleanupTest(){this.emulationScope.Dispose();}  

        [TestMethod]  
        public void ScheduleAppointmentReturnsTrueWhenNewAppointmentIsCreated()  
        {  
            // remove the SharePointEmulationScope using statement from the method  
            using( var site = new SPSite("http://localhost"))  
            using (var webPart = new BookAnAppointmentWebPart())  
            {  
                // Arrange  
                string errorMsg = string.Empty;  
                DateTime date = DateTime.Now;  
                SPList list = AddListToSiteHelper(site);  

                // Act  
                bool success = webPart.ScheduleAppointment(site.RootWeb, list.Title,  
                    "Raisa Pokrovskaya", "425-555-0163", "raisa@outlook.com", "55", date,   
                    out errorMsg);  
                list.Delete()  

                // Assert  
                Assert.IsTrue(success);  
            }  
        }  

        ...// More tests  

    }  
}  

항목 내용In this topic

에뮬레이트되지 않은 SharePoint 메서드 처리Handling non-emulated SharePoint methods

일부 SharePoint 형식이 에뮬레이트되지 않고 일부 에뮬레이트된 형식의 일부 메서드는 에뮬레이트되지 않습니다.Not all SharePoint types are emulated, and not all methods in some emulated types are emulated. 테스트 중인 코드가 에뮬레이트되지 않은 SharePoint 메서드를 호출하면 메서드는 NotSupportedException 예외를 throw합니다.If the code under test calls a SharePoint method that is not emulated, the method throws a NotSupportedException exception. 예외가 발생하면 SharePoint 메서드에 대한 Fakes shim을 추가합니다.When an exception occurs, you add a Fakes shim for the SharePoint method.

SharePoint Fakes 설정Setting up Sharepoint Fakes

Microsoft Fakes shim을 명시적으로 호출하려면:To explicitly call Microsoft Fakes shims:

  1. 에뮬레이트되지 않은 SharePoint 클래스를 shim하려면 Microsoft.SharePoint.fakes 파일을 편집하고 shim된 클래스 목록에 클래스를 추가합니다.If you want to shim a SharePoint class that is not emulated, edit the Microsoft.SharePoint.fakes file and add the class to the list of shimmed classes. Microsoft Fakes의 코드 생성, 컴파일 및 명명 규칙스텁 및 shim의 코드 생성 구성 섹션을 참조하세요.See the Configuring code generation of stubs and shims section of Code generation, compilation, and naming conventions in Microsoft Fakes.

    솔루션 탐색기의 Fakes 폴더Fakes folder in Solution Explorer

  2. Microsoft SharePoint Emulators 패키지를 설치한 후와 Microsoft.SharePoint.Fakes 파일을 편집한 경우 테스트 프로젝트를 한 번 이상 다시 빌드해야 합니다.Rebuild the test project at least once after you have installed the Microsoft SharePoint Emulators package and if you have edited the Microsoft.SharePoint.Fakes file. 프로젝트를 빌드하면 디스크에 있는 프로젝트 루트 폴더에 FakesAssembly 폴더가 만들어지고 채워집니다.Building the project creates and populates a FakesAssembly folder in your on-disk project root folder.

    FakesAssembly 폴더FakesAssembly folder

  3. FakesAssembly 폴더에 위치한 Microsoft.SharePoint.14.0.0.0.Fakes.dll에 대한 참조를 추가합니다.Add a reference to the Microsoft.SharePoint.14.0.0.0.Fakes.dll assembly that is located in the FakesAssembly folder.

  4. (선택 사항) Microsoft.QualityTools.Testing.Fakes, Microsoft.SharePoint.Fakes 및 사용할 Microsoft.SharePoint.Fakes의 모든 중첩된 네임스페이스에 대한 테스트 클래스에 네임스페이스 지시문을 추가합니다.(Optional) Add a namespace directive for to the test class for Microsoft.QualityTools.Testing.Fakes, Microsoft.SharePoint.Fakes and any nested namespace of Microsoft.SharePoint.Fakesthat you want to use.

    SharePoint 메서드에 대한 shim 대리자 구현Implementing the shim delegate for a SharePoint method

    이 예제 프로젝트에서 GetAppointmentsForToday 메서드는 SPList.GetItems(SPQuery) SharePoint API 메서드를 호출합니다.In our example project, the GetAppointmentsForToday method calls the SPList.GetItems(SPQuery) SharePoint API method.

// method under test  
public string GetAppointmentsForToday(string listName, SPWeb web)  
{  
    SPList list = web.Lists[listName];  
    DateTime today = DateTime.Now;  
    var listQuery = new SPQuery{Query = String.Format("<Where><Eq><FieldRef Name='Date'/>" +"<Value Type='Text'>{0}</Value>" +"</Eq></Where>", today.ToString("D"))};  
    var result = new System.Text.StringBuilder();  
    foreach (SPListItem item in list.GetItems(listQuery))  
    {  
        result.AppendFormat("Name: {0}, Phone: {1}, Email: {2}, Age: {3}, Date: {4}\n",   
            item["Name"], item["Phone"], item["Email"], item["Age"], item["Date"]);  
    }  
    return result.ToString();  
}  

오버로드된 GetItems 메서드의 SPList.GetItems(SPQuery) 버전은 에뮬레이트되지 않습니다.The SPList.GetItems(SPQuery) version of the overloaded GetItems method is not emulated. 따라서 SharePoint.Emulation.Scope에서 GetAppointmentsForToday에 대한 기존 테스트를 래핑하는 작업은 실패합니다.Therefore, just wrapping an existing test for GetAppointmentsForToday in SharePoint.Emulation.Scope would fail. 작업 테스트를 만들려면 테스트 기준으로 사용할 결과를 반환하는 Fakes 대리자 ShimSPList.GetItemsSPQuery의 구현을 작성해야 합니다.To create a working test, you have to write an implementation of the Fakes delegate ShimSPList.GetItemsSPQuery that returns the results that you want to test against.

다음은 Fakes 대리자를 구현하는 기존 테스트 메서드 GetAppointmentsForTodayReturnsOnlyTodaysAppointments를 수정한 결과입니다.Here's a modification of an existing test method, GetAppointmentsForTodayReturnsOnlyTodaysAppointments, that implements a Fakes delegate. 필요한 변경 내용은 주석으로 설명됩니다.The required changes are called out in comments:

중요

Fakes shim을 명시적으로 만드는 테스트 메서드는 테스트가 EmulationMode.Passthrough 컨텍스트에서 실행될 때 ShimNotSupported 예외를 throw합니다.Test methods that explicitly create Fakes shims throw a ShimNotSupported exception when the test is run in the EmulationMode.Passthrough context. 이 문제를 방지하려면 변수를 사용하여 EmulationMode 값을 설정하고 값을 테스트하는 if 문으로 Fakes 코드를 래핑합니다.To avoid this issue, use a variable to set the EmulationMode value and wrap any Fakes code in an if statement that tests the value.

// class level field to set emulation mode  
private const EmulationMode emulatorMode = EmulationMode.Enabled  

[TestMethod]  
public void GetAppointmentsForTodayReturnsOnlyTodaysAppointments()  
{  

    // create the emulation scope with a using statement  
    using (var emulationScope = new SharePointEmulationScope(emulatorMode))  
    using( var site = new SPSite("http://localhost"))  
    using (var webPart = new BookAnAppointmentWebPart())  
    {  
        // Arrange  
        DateTime date = DateTime.Now;  
        SPList list = AddListToSiteHelper(site);  
        // insert 2 items into list  
        AddItemsToListHelper(list, new string[] {"Raisa Pokrovskaya", "425-555-0163",  
            "raisa@outlook.com", "55", date.ToString("D") });  
        AddItemsToListHelper(list, new string[] {"Francis Totten", "313-555-0100",  
            "francis@contoso.com", "42", date.AddDays(1).ToString("D") });  

        // use Fakes shims only if emulation is enabled  
        if (emulatorMode == EmulationMode.Enabled){var sList = new ShimSPList(list);sList.GetItemsSPQuery = (query) =>{var shim = new ShimSPListItemCollection();shim.Bind(new[] { list.Items[0] });return shim.Instance;}}  

        // Act  
        string result = webPart.GetAppointmentsForToday(list.Title, site.RootWeb);  
        list.Delete();  

        // Assert  
        Assert.IsTrue(result.Contains(String.Format(  
            "Name: Raisa Pokrovskaya, Phone: 425-555-0163, Email: raisa@outlook.com," +  
            "Age: 55, Date: {0}", date.ToString("D"))));  
        Assert.IsFalse(result.Contains("Name: Francis Totten"));  
    }  
}  

이 메서드에서는 먼저 에뮬레이션이 사용하도록 설정되었는지 테스트합니다.In this method, we first test that emulation is enabled. 사용하도록 설정되었으면 SPList 목록에 대한 Fakes shim 개체를 만들고 해당 GetItemsSPQuery 대리자에 메서드를 할당합니다.If it is, we create a Fakes shim object for our SPList list and then create and assign a method to its GetItemsSPQuery delegate. 대리자는 Fakes Bind 메서드를 사용하여 호출자에게 반환되는 ShimSPListItemCollection에 올바른 목록 항목을 추가합니다.The delegate uses the Fakes Bind method to add the correct list item to the ShimSPListItemCollection that is returned to the caller.

항목 내용In this topic

에뮬레이션 테스트를 처음부터 다시 작성하고 요약 작성Writing emulation tests from scratch, and a summary

이전 섹션에 설명된 에뮬레이션 및 이중 사용 테스트를 만드는 방법에서는 기존 테스트를 변환한다고 가정하지만 테스트를 처음부터 작성하는 방법을 사용할 수도 있습니다.Although the techniques to create emulation and dual-use tests that are described in the previous sections assume that you are converting existing tests, you can also use the techniques to write tests from scratch. 다음 목록에서는 이들 방법을 요약하여 보여 줍니다.The following list summarizes these techniques:

  • 테스트 프로젝트에서 에뮬레이터를 사용하려면 Microsoft.SharePoint.Emulators NuGet 패키지를 프로젝트에 추가합니다.To use emulators in a test project, add the Microsoft.SharePoint.Emulators NuGet package to the project.

  • 테스트 메서드에서 에뮬레이터를 사용하려면 메서드의 시작 부분에서 SharePointEmulationScope 개체를 만듭니다.To use emulators in a test method, create a SharePointEmulationScope object at the beginning of the method. 지원되는 모든 SharePoint API는 범위가 삭제될 때까지 에뮬레이트됩니다.All supported SharePoint APIs will be emulated until the scope is disposed.

  • 실제 SharePoint API에 대해 작성한 것처럼 테스트 코드를 작성합니다.Write your test code as if you were writing it against the real SharePoint API. 에뮬레이션 컨텍스트는 자동으로 SharePoint 메서드에 대한 호출을 해당 에뮬레이터로 우회합니다.The emulation context automatically detours the calls to SharePoint methods to their emulators.

  • 일부 SharePoint 개체가 에뮬레이트되지 않고 일부 에뮬레이트된 개체의 일부 메서드는 에뮬레이트되지 않습니다.Not all SharePoint objects are emulated, and not all methods of some emulated objects are emulated. 에뮬레이트되지 않은 개체 또는 메서드를 사용하면 NotSupportedException 예외가 throw됩니다.A NotSupportedException exception is thrown when you use a non-emulated object or method. 이 예외가 발생하면 메서드에 대한 Fakes shim 대리자를 명시적으로 만들어서 필요한 동작을 반환합니다.When this occurs, explicitly create a Fakes shim delegate for the method to return the required behavior.

  • 이중 사용 테스트를 만들려면 SharePointEmulationScope(EmulationMode) 생성자를 사용하여 에뮬레이션 범위 개체를 만듭니다.To create dual-use tests, use the SharePointEmulationScope(EmulationMode) constructor to create the emulation scope object. EmulationMode 값은 SharePoint 호출이 실제 SharePoint 사이트에 대해 에뮬레이트 또는 실행되는지를 지정합니다.The EmulationMode value specifies whether the SharePoint calls are emulated or executed against a real SharePoint site.

  • 테스트 클래스의 모든 또는 대부분 테스트 메서드가 에뮬레이션 컨텍스트에서 실행되면 클래스 수준 TestInitialize 특성 사용 메서드를 사용하여 SharePointEmulationScope 개체를 만들고 클래스 수준 필드를 사용하여 에뮬레이션 모드를 설정할 수 있습니다.If all or most of your test methods in a test class execute in the emulation context, you can use a class-level TestInitialize attributed method to create the SharePointEmulationScope object and a class-level field to set the emulation mode. 이렇게 하면 에뮬레이션 모드의 변경을 자동화할 수 있습니다.This will help you to automate the changing of the emulation mode. 그다음에 TestCleanup 특성 사용 메서드를 사용하여 범위 개체를 삭제합니다.Then use a TestCleanup attributed method to dispose of the scope object.

    항목 내용In this topic

예제Example

다음은 위에 설명된 SharePoint 에뮬레이터 방법을 통합하는 마지막 예제입니다.Here's a final example that incorporates the SharePoint emulator techniques that are described above:

using System;   
//other namespace declarations  
...   
// code under test  
using MySPApps;  
using Microsoft.SharePoint;  
// unit testing and emulators  
using Microsoft.VisualStudio.TestTools.UnitTesting;  
using Microsoft.QualityTools.Testing.Emulators;  
using Microsoft.SharePoint.Emulators;  
// explicit Fakes shims  
using Microsoft.QualityTools.Testing.Fakes;  
using Microsoft.SharePoint.Fakes  

namspace MySPAppTests   
{  
    [TestClass]  
    public class BookAnAppointmentWebPartTests  
    {  

        // emulationScope is a class level field  
        private SharePointEmulationScope emulationScope;  

        // preprocessor directives determine the value of emulatorMode  
        #if USE_EMULATION  
            private const EmulationMode emulatorMode = EmulationMode.Enabled;  
        #else  
            private const EmulationMode emulatorMode = EmulationMode.Passthrough;  
        #endif  

        // InitializeTest sets the emulation scope at the beginning of each test method  
        [TestInitialize]  
        public void InitializeTest()  
        {  
            this.emulationScope = new SharePointEmulationScope(emulatorMode);  
        }  

        // CleanupTest disposes the emulation scope at the end of each test method  
        [TestCleanup]  
        public void Cleanup()  
        {  
            this.emulationScope.Dispose();  
        }  

        [TestMethod]  
        public void ScheduleAppointmentReturnsTrueWhenNewAppointmentIsCreated()  
        {  
            // remove the SharePointEmulationScope using statement from the method  
            using( var site = new SPSite("http://localhost"))  
            using (var webPart = new BookAnAppointmentWebPart())  
            {  
                // Arrange  
                string errorMsg = string.Empty;  
                DateTime date = DateTime.Now;  
                SPList list = AddListToSiteHelper(site);  

                // Act  
                bool success = webPart.ScheduleAppointment(site.RootWeb, list.Title,  
                    "Raisa Pokrovskaya", "425-555-0163", "raisa@outlook.com", "55", date,   
                    out errorMsg);  
                list.Delete()  

                // Assert  
                Assert.IsTrue(success);  
            }  
        }  

        [TestMethod]  
        public void GetAppointmentsForTodayReturnsOnlyTodaysAppointments()  
        {  

            // remove the SharePointEmulationScope using statement from the method  
            using( var site = new SPSite("http://localhost"))  
            using (var webPart = new BookAnAppointmentWebPart())  
            {  
                // Arrange  
                DateTime date = DateTime.Now;  
                SPList list = AddListToSiteHelper(site);  
                // insert 2 items into list  
                AddItemsToListHelper(list, new string[] {"Raisa Pokrovskaya", "425-555-0163",  
                    "raisa@outlook.com", "55", date.ToString("D") });  
                AddItemsToListHelper(list, new string[] {"Francis Totten", "313-555-0100",  
                    "francis@contoso.com", "42", date.AddDays(1).ToString("D") });  

                // use Fakes shims only if emulation is enabled  
                if (emulatorMode == EmulationMode.Enabled)  
                {  
                    var sList = new ShimSPList(list);  

                    sList.GetItemsSPQuery = (query) =>  
                    {  
                        var shim = new ShimSPListItemCollection();  
                        shim.Bind(new[] { list.Items[0] });  
                        return shim.Instance;  
                    }  
                }  

                // Act  
                string result = webPart.GetAppointmentsForToday(list.Title, site.RootWeb);  
                list.Delete();  

                // Assert  
                Assert.IsTrue(result.Contains(String.Format(  
                    "Name: Raisa Pokrovskaya, Phone: 425-555-0163, Email: raisa@outlook.com," +  
                    "Age: 55, Date: {0}", date.ToString("D"))));  
                Assert.IsFalse(result.Contains("Name: Francis Totten"));  
            }  
        }  

        ...// More tests  

    }  
}  

에뮬레이트된 SharePoint 형식Emulated SharePoint types

Microsoft.SharePoint.SPFieldMicrosoft.SharePoint.SPField

Microsoft.SharePoint.SPFieldIndexMicrosoft.SharePoint.SPFieldIndex

Microsoft.SharePoint.SPFieldIndexCollectionMicrosoft.SharePoint.SPFieldIndexCollection

Microsoft.SharePoint.SPFieldLinkMicrosoft.SharePoint.SPFieldLink

Microsoft.SharePoint.SPFieldLinkCollectionMicrosoft.SharePoint.SPFieldLinkCollection

Microsoft.SharePoint.SPFieldUrlValueMicrosoft.SharePoint.SPFieldUrlValue

Microsoft.SharePoint.SPFileMicrosoft.SharePoint.SPFile

Microsoft.SharePoint.SPFileCollectionMicrosoft.SharePoint.SPFileCollection

Microsoft.SharePoint.SPFolderMicrosoft.SharePoint.SPFolder

Microsoft.SharePoint.SPFolderCollectionMicrosoft.SharePoint.SPFolderCollection

Microsoft.SharePoint.SPItemMicrosoft.SharePoint.SPItem

Microsoft.SharePoint.SPItemEventDataCollectionMicrosoft.SharePoint.SPItemEventDataCollection

Microsoft.SharePoint.SPItemEventPropertiesMicrosoft.SharePoint.SPItemEventProperties

Microsoft.SharePoint.SPListMicrosoft.SharePoint.SPList

Microsoft.SharePoint.SPListCollectionMicrosoft.SharePoint.SPListCollection

Microsoft.SharePoint.SPListEventPropertiesMicrosoft.SharePoint.SPListEventProperties

Microsoft.SharePoint.SPListItemMicrosoft.SharePoint.SPListItem

Microsoft.SharePoint.SPListItemCollectionMicrosoft.SharePoint.SPListItemCollection

Microsoft.SharePoint.SPQueryMicrosoft.SharePoint.SPQuery

Microsoft.SharePoint.SPRoleAssignmentMicrosoft.SharePoint.SPRoleAssignment

Microsoft.SharePoint.SPRoleAssignmentCollectionMicrosoft.SharePoint.SPRoleAssignmentCollection

Microsoft.SharePoint.SPSecurableObjectMicrosoft.SharePoint.SPSecurableObject

Microsoft.SharePoint.SPSecurityMicrosoft.SharePoint.SPSecurity

Microsoft.SharePoint.SPSiteMicrosoft.SharePoint.SPSite

Microsoft.SharePoint.SPUserMicrosoft.SharePoint.SPUser

Microsoft.SharePoint.SPUserCollectionMicrosoft.SharePoint.SPUserCollection

Microsoft.SharePoint.SPViewMicrosoft.SharePoint.SPView

Microsoft.SharePoint.SPViewCollectionMicrosoft.SharePoint.SPViewCollection

Microsoft.SharePoint.SPViewContextMicrosoft.SharePoint.SPViewContext

Microsoft.SharePoint.SPWebMicrosoft.SharePoint.SPWeb

Microsoft.SharePoint.SPWebCollectionMicrosoft.SharePoint.SPWebCollection

항목 내용In this topic

참고 항목See Also

코드 단위 테스트 Unit Test Your Code
코딩된 UI 테스트를 사용하여 SharePoint 2010 응용 프로그램 테스트 Testing SharePoint 2010 Applications with Coded UI Tests
SharePoint 2010 및 2013 응용 프로그램 웹 성능 및 부하 테스트 Web performance and load testing SharePoint 2010 and 2013 applications
SharePoint 솔루션 개발Developing SharePoint Solutions