Realizar Assert.AreMatch() para comparar propiedades en dos objetos

Question

Estoy escribiendo pruebas en contra de nuestro mecanismo de caché y quiero estar seguro de que lo que entra en la caché es igual a lo que sale, es decir, que todas las propiedades coinciden. Aquí es un ejemplo ficticio de cómo me gustaría que funcione

[Test] 
    public void add_client_model_member_to_cache_then_retreve() 
    { 
     //arrange 
     MemcachedClient client = new MemcachedClient(); 
     Member member = GetMember(); 
     client.Store(StoreMode.Set, "membertest", member); 

     // act 
     var result = client.Get<Member>("membertest"); 

     // assert 
     Assert.AreMatch(result, member); 
    } 

No es factible realizar Assert.AreEqual en cada propiedad, ya que habrá muchas de estas pruebas con muchas propiedades en cada uno.

Wow, gracias Jon. Creo que respondiste eso en menos de un minuto. Aquí está mi solución resultante para cualquier parte interesada. Implementé como Jon sugirió (creo) sin embargo, tuve un pequeño problema con las propiedades de la matriz y, como tal, mi solución solo maneja matrices de entradas (todo lo que actualmente necesito).

También tiene que ser una pendiente bastante resbaladiza si trato de comprobar más profundo que un nivel. Estoy seguro de que esto se puede lograr; sin embargo, para mis propósitos, no es obligatorio.

private bool AreMatch(object initial, object result) 
    { 
     if (initial.Equals(result)) 
      return true; 

     foreach (var property in initial.GetType().GetProperties()) 
     { 
      var initialPropValue = property.GetValue(initial,null); 
      var resultPropValue = result.GetType().GetProperty(property.Name).GetValue(result,null); 

      if (property.PropertyType.IsArray) 
      { 
       if ((initialPropValue != null && resultPropValue != null) && !Enumerable.SequenceEqual((int[])initialPropValue, (int[])resultPropValue)) 
         return false;     
      } 
      else if (!object.Equals(initialPropValue, resultPropValue)) 
      { 
       return false; 
      } 
      else if (initialPropValue != null && property.PropertyType.IsClass) 
      { 
       // Don't go deeper than one level, this got me into trouble 
       //if (!AreMatch(initialPropValue, resultPropValue)) 
       // return false; 
      } 
     } 
     return true; 
    } 

El método anterior se puede utilizar en las siguientes situaciones

[Test] 
    public void cached_result_is_same_as_original() 
    { 
     //arrange 
     Member member = GetMember(); 
     client.Store(StoreMode.Set, "membertest", member); 

     // act 
     var result = client.Get<Member>("membertest"); 

     // assert 
     Assert.IsTrue(AreMatch(member, result)); 
    } 

    [Test] 
    public void cached_result_is_same_as_original() 
    { 
     //arrange 
     Member member = GetMember(); 
     client.Store(StoreMode.Set, "membertest", member); 

     // act 
     var result = client.Get<Member>("membertest"); 
     result.FirstName = "Result is different"; 

     // assert 
     Assert.IsFalse(AreMatch(member, result)); 
    } 

Answer 1

Bueno, ciertamente se podría escribir algo a recursiva a través de todas las propiedades y llamar object.Equals en el resultado de ir a buscar el valor de la propiedad de los esperados y reales. Use Type.GetProperties() para obtener las propiedades, y PropertyInfo.GetValue para obtener el valor.

Va a ser algo tosco, pero siempre podría modificarlo si es necesario.