TypeLoadException ao tentar zombar IObjectSet com Moq

Question

Eu tenho o seguinte código de programa de configuração:

MockOf<IObjectSet<Dummy>>().Setup(c => c.AddObject(dummy)).Verifiable();
MockOf<IObjectContextWrapper>().Setup(c => c.GetObjectSet<Dummy>()).Returns(MockOf<IObjectSet<Dummy>>().Object);

onde Dummy é um vazio definição de classe, e dummy é um Dummy. MockOf<T>() é uma simulação de gestão de recurso em uma classe base, que, basicamente, certifica-se de que a cada vez que é chamado em um tipo, ele devolve a mesma simulação de instância.

O teste contém este código de programa de configuração falha com um TypeLoadException e a seguinte mensagem:

Do sistema.TypeLoadException :Tipo 'IObjectSet'1Proxy389e220f10aa4d9281d0b9e136edc1d4' do assembly 'DynamicProxyGenAssembly2, Versão=0.0.0.0, Culture=neutral, PublicKeyToken=a621a9e7e5c32e69' está a tentar implementar um inacessíveis interface.

em Sistema.Reflexão.Emitem.TypeBuilder.TermCreateClass(RuntimeModule módulo, Int32 tk, ObjectHandleOnStack tipo)
em Sistema.Reflexão.Emitem.TypeBuilder.CreateTypeNoLock()
em Sistema.Reflexão.Emitem.TypeBuilder.CreateType()
em Castelo.DynamicProxy.Os geradores.Emissores.AbstractTypeEmitter.BuildType()
em Castelo.DynamicProxy.Os geradores.InterfaceProxyWithTargetGenerator.GenerateCode(Tipo proxyTargetType, Digite[] interfaces, ProxyGenerationOptions opções)
em Castelo.DynamicProxy.ProxyGenerator.CreateInterfaceProxyWithoutTarget(Tipo interfaceToProxy, Digite[] additionalInterfacesToProxy, ProxyGenerationOptions opções, IInterceptor[] interceptores)
em Moq.Simulação1.<InitializeInstance>b__0()
at Moq.Mock1.InitializeInstance()
em Moq.Simulação de`1.get_Object()
em OddEnds.Testes.Dados.EntityFramework.RepositoryTest.Delete_DeletesObjectFromObjectSet() em RepositoryTest.cs:linha 43

Eu tenho importado System.Data.Objects e referenciados System.Data.Entity.dll e Microsoft.Data.Entity.CTP.dll tanto o projeto de teste e o projeto em que a classe a ser testada reside.A compilação tiver êxito sem erros, avisos ou mensagens (exceto alguns relacionados com Contratos de Código...)

Como faço para corrigir isso?

Answer 1

Qualquer uma das interfaces ou na classe que você está usando em seus testes internos?Você está usando algo como [assembly: InternalsVisibleTo("YourTestAssembly")] a fim de obter coisas para compilar?

Se assim for, você também precisará adicionar um para DynamicProxyGenAssembly2 para Moq para gerar dinamicamente o proxy para as classes.

//goes in the AssemblyInfo.cs where the internal interfaces / classes are defined
[assembly: InternalsVisibleTo("DynamicProxyGenAssembly2")]  

Aqui é um pertinentes ao post sobre o tema

http://sonofpirate.blogspot.com/2009/09/my-first-foray-into-unit-testing-with.html

Espero que isso ajude

Answer 2

Eu achei que no meu caso, eu tinha criado um Manequim instância da classe para ser usado no meu teste de unidade que passou a ser privada (como eu realmente não quero compartilhar o objeto de teste do lado de fora).

Meu código foi ao longo destas linhas:

var mockMonitor = new Mock<ICacheMonitor<int, PrivateObject>>();

onde o PrivateObject foi uma definição de classe privada dentro do meu TestClass.A correção no meu caso é, portanto, para garantir que qualquer dos tipos a sua Simulação construtor são públicos.

public class PrivateObject () {}

(Obviamente, eu não diria que o meu público objeto de um PrivateObject tanto...)

Answer 3

Eu tropecei em um outro caso que eu não conseguia descobrir em primeiro lugar.Eu estava trabalhando em um proxy para uma interface criada dentro do meu teste de unidade...

public IDoWork
{
    void DoWork();
}

Ele levou-me para sempre a descobrir que o problema não foi com essa interface, mas foi, ao invés, que a unidade de teste em si não foi públicos:

class TestSomething // missing public keyword
{

// .. some test which tries to create a mock of the interface


    public IDoWork
    {
        void DoWork();
    }

}

Assim, enquanto IDoWork é diz que é público, ele realmente não é, já que é incluído em uma classe privada.

Espero que isso ajude alguém.