WebApi2官网学习记录---单元测试

如果没有对应的web api模板，首先使用nuget进行安装

例子1：

ProductController 是以硬编码的方式使用StoreAppContext类的实例，可以使用依赖注入模式，在外部指定上下文实例

  public interface IStoreAppContext:IDisposable
     {
          DbSet<Product> Products { get; set; }
          int SaveChanges();
          void MarkAsModified(Product item);
     }

 public class StoreAppContext : DbContext,IStoreAppContext
     {
         // You can add custom code to this file. Changes will not be overwritten.
         //
         // If you want Entity Framework to drop and regenerate your database
         // automatically whenever you change your model schema, please use data migrations.
         // For more information refer to the documentation:
         // http://msdn.microsoft.com/en-us/data/jj591621.aspx

         public StoreAppContext() : base("name=StoreAppContext")
         {
         }

         public DbSet<Product> Products { get; set; }

         public void MarkAsModified(Product item)
         {
             Entry(item).State = EntityState.Modified;
         }
     }

 public class ProductsController : ApiController
     {
         private IStoreAppContext db = new StoreAppContext();

         public ProductsController() { }

         public ProductsController(IStoreAppContext context)
        {
           db = context;
         }
         // GET: api/Products
         public IQueryable<Product> GetProducts()
         {
             return db.Products;
         }

         // GET: api/Products/5
         [ResponseType(typeof(Product))]
         public IHttpActionResult GetProduct(int id)
         {
             Product product = db.Products.Find(id);
             if (product == null)
             {
                 return NotFound();
             }

             return Ok(product);
         }

         // PUT: api/Products/5
         [ResponseType(typeof(void))]
         public IHttpActionResult PutProduct(int id, Product product)
         {
             if (!ModelState.IsValid)
             {
                 return BadRequest(ModelState);
             }

             if (id != product.Id)
             {
                 return BadRequest();
             }

             db.MarkAsModified(product);

             try
             {
                 db.SaveChanges();
             }
             catch (DbUpdateConcurrencyException)
             {
                 if (!ProductExists(id))
                 {
                     return NotFound();
                 }
                 else
                 {
                     throw;
                 }
             }

             return StatusCode(HttpStatusCode.NoContent);
         }

         // POST: api/Products
         [ResponseType(typeof(Product))]
         public IHttpActionResult PostProduct(Product product)
         {
             if (!ModelState.IsValid)
             {
                 return BadRequest(ModelState);
             }

             db.Products.Add(product);
             db.SaveChanges();

             return CreatedAtRoute("DefaultApi", new { id = product.Id }, product);
         }

         // DELETE: api/Products/5
         [ResponseType(typeof(Product))]
         public IHttpActionResult DeleteProduct(int id)
         {
             Product product = db.Products.Find(id);
             if (product == null)
             {
                 return NotFound();
             }

             db.Products.Remove(product);
             db.SaveChanges();

             return Ok(product);
         }

         protected override void Dispose(bool disposing)
         {
             if (disposing)
             {
                 db.Dispose();
             }
             base.Dispose(disposing);
         }

         private bool ProductExists(int id)
         {
             return db.Products.Count(e => e.Id == id) > ;
         }
     }

单元测试代码：

  public  class TestDbSet<T>:DbSet<T>,IQueryable,IEnumerable<T>
         where T:class
     {
         ObservableCollection<T> _data;
         IQueryable _query;

         public TestDbSet()
         {
             _data = new ObservableCollection<T>();
             _query = _data.AsQueryable();
         }

         public override T Add(T item)
         {
             _data.Add(item);
             return item;
         }

         public override T Remove(T item)
         {
             _data.Remove(item);
             return item;
         }

         public override T Attach(T item)
         {
             _data.Add(item);
             return item;
         }

         public override T Create()
         {
             return Activator.CreateInstance<T>();
         }

         public override TDerivedEntity Create<TDerivedEntity>()
         {
             return Activator.CreateInstance<TDerivedEntity>();
         }

         public override ObservableCollection<T> Local
         {
             get { return new ObservableCollection<T>(_data); }
         }

         Type IQueryable.ElementType
         {
             get { return _query.ElementType; }
         }

         System.Linq.Expressions.Expression IQueryable.Expression
         {
             get { return _query.Expression; }
         }

         IQueryProvider IQueryable.Provider
         {
             get { return _query.Provider; }
         }

         System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
         {
             return _data.GetEnumerator();
         }

         IEnumerator<T> IEnumerable<T>.GetEnumerator()
         {
             return _data.GetEnumerator();
         }
     }

 class TestProductDbSet:TestDbSet<Product>
     {
         public override Product Find(params object[] keyValues)
         {
             return this.SingleOrDefault(p=>p.Id==(int)keyValues.Single());
         }
     }

  class TestStoreAppContext : IStoreAppContext
     {
         public TestStoreAppContext()
         {
             this.Products = new TestProductDbSet();
         }

         public System.Data.Entity.DbSet<Product> Products { get; set; }

         public int SaveChanges()
         {
             return ;
         }

         public void MarkAsModified(Product item)
         {

         }

         public void Dispose()
         {

         }
     }

  public class TestProductController
     {
         [TestMethod]
         public void PostProduct_ShouldReturnSameProduct()
         {
             var controller = new ProductsController(new TestStoreAppContext());
             var item = GetDemoProduct();

             var result=controller.PostProduct(item) as  CreatedAtRouteNegotiatedContentResult<Product>;
             Assert.IsNotNull(result);
             Assert.AreEqual(result.RouteName, "DefaultApi");
             Assert.AreEqual(result.RouteValues["id"], result.Content.Id);
             Assert.AreEqual(result.Content.Name, item.Name);
         }
         [TestMethod]
         public void PutProduct_ShouldReturnStatusCode()
         {
             var controller = new ProductsController(new TestStoreAppContext());

             var item = GetDemoProduct();

             var result = controller.PutProduct(item.Id, item) as StatusCodeResult;
             Assert.IsNotNull(result);
             Assert.IsInstanceOfType(result, typeof(StatusCodeResult));
             Assert.AreEqual(HttpStatusCode.NoContent, result.StatusCode);
         }

         [TestMethod]
         public void PutProduct_ShouldFail_WhenDifferentID()
         {
             var controller = new ProductsController(new TestStoreAppContext());

             var badresult = controller.PutProduct(, GetDemoProduct());
             Assert.IsInstanceOfType(badresult, typeof(BadRequestResult));
         }

         [TestMethod]
         public void GetProduct_ShouldReturnProductWithSameID()
         {
             var context = new TestStoreAppContext();
             context.Products.Add(GetDemoProduct());

             var controller = new ProductsController(context);
             var result = controller.GetProduct() as OkNegotiatedContentResult<Product>;

             Assert.IsNotNull(result);
             Assert.AreEqual(, result.Content.Id);
         }

         [TestMethod]
         public void GetProducts_ShouldReturnAllProducts()
         {
             var context = new TestStoreAppContext();
             context.Products.Add(new Product { Id = , Name = "Demo1", Price =  });
             context.Products.Add(new Product { Id = , Name = "Demo2", Price =  });
             context.Products.Add(new Product { Id = , Name = "Demo3", Price =  });

             var controller = new ProductsController(context);
             var result = controller.GetProducts() as TestProductDbSet;

             Assert.IsNotNull(result);
             Assert.AreEqual(, result.Local.Count);
         }

         [TestMethod]
         public void DeleteProduct_ShouldReturnOK()
         {
             var context = new TestStoreAppContext();
             var item = GetDemoProduct();
             context.Products.Add(item);

             var controller = new ProductsController(context);
             var result = controller.DeleteProduct() as OkNegotiatedContentResult<Product>;

             Assert.IsNotNull(result);
             Assert.AreEqual(item.Id, result.Content.Id);
         }
         Product GetDemoProduct()
         {
             return new Product() { Id = , Name = "Demo name", Price =  };
         }
     }

具体的代码参见：Mocking Entity Framework when Unit Testing ASP.NET Web API 2