/// <summary>
/// Constructs a <see cref="UnexpectedInvocationException"/> with the given parameters.
/// </summary>
/// <param name="factory">The MockFactory that threw this exception</param>
/// <param name="invocation">The unexpected invocation</param>
/// <param name="expectations">The expectations collection to describe</param>
/// <param name="message">A message to help the user understand what was unexpected</param>
internal UnexpectedInvocationException(MockFactory factory, Invocation invocation, IExpectationList expectations, string message)
{
if (factory == null)
throw new ArgumentNullException("factory");
if (invocation == null)
throw new ArgumentNullException("invocation");
if (expectations == null)
throw new ArgumentNullException("expectations");
Factory = factory;
var writer = new DescriptionWriter();
writer.WriteLine();
if (invocation.IsPropertySetAccessor)
writer.WriteLine(UNEXPECTED_PROPERTY_SETTER_PREFIX);
else if (invocation.IsPropertyGetAccessor)
writer.WriteLine(UNEXPECTED_PROPERTY_GETTER_PREFIX);
else
writer.WriteLine(MESSAGE_PREFIX);
writer.Write(" ");
((ISelfDescribing)invocation).DescribeTo(writer);
writer.Write(message);
//expectations.DescribeActiveExpectationsTo(writer);
//expectations.DescribeUnmetExpectationsTo(writer);
expectations.DescribeTo(writer);
_message = writer.ToString();
}
public void DoNotIssueMoveIntoWater()
{
var mock = new MockFactory();
var outputAdapterMock = mock.CreateMock<IGameOutputAdapter>();
using (mock.Ordered)
{
outputAdapterMock.Expects.One.MethodWith(adapter => adapter.NotifyEndOfTurn());
}
var trackerManager = new OwnAntTrackingManager(outputAdapterMock.MockObject);
MapTile origin = GameContext.Map.At(3, 4);
MapTile destination = origin.North;
var ant = new Ant(origin);
destination.State = TileState.Water;
origin.CurrentAnt = ant;
trackerManager.HasProcessedAllInputMoves();
trackerManager.EnrollToMove(ant, destination);
trackerManager.FinalizeAllMoves();
Assert.IsNotNull(origin.CurrentAnt);
Assert.AreEqual(ant, origin.CurrentAnt);
mock.VerifyAllExpectationsHaveBeenMet();
}
public override object CreateMock(MockFactory mockFactory, CompositeType typesToMock, string name, MockStyle mockStyle, object[] constructorArgs)
{
if (typesToMock == null)
throw new ArgumentNullException("typesToMock");
Type primaryType = typesToMock.PrimaryType;
Type[] additionalInterfaces = BuildAdditionalTypeArrayForProxyType(typesToMock);
IInterceptor mockInterceptor = new MockObjectInterceptor(mockFactory, typesToMock, name, mockStyle);
object result;
/* ^ */ var _typeInfo = primaryType.GetTypeInfo(); /* [email protected] ^ */
if (/* ^ */ _typeInfo.IsInterface /* [email protected] ^ */)
{
result = generator.CreateInterfaceProxyWithoutTarget(primaryType, additionalInterfaces, new ProxyGenerationOptions {BaseTypeForInterfaceProxy = typeof (InterfaceMockBase)}, mockInterceptor);
((InterfaceMockBase) result).Name = name;
}
else
{
result = generator.CreateClassProxy(primaryType, additionalInterfaces, ProxyGenerationOptions.Default, constructorArgs, mockInterceptor);
//return generator.CreateClassProxy(primaryType, new []{typeof(IMockObject)}, mockInterceptor);
}
return result;
}
public void TestInitialize()
{
if (MockFactory != null)
return;
MockFactory = new MockFactory();
}
public void shouldAddIngredientToCurrentUser()
{
var mockFactory = new MockFactory(MockBehavior.Loose);
var userContextMock = GetSetuppedUserContextMock(mockFactory);
var userIngredientBusinessLogicMock = mockFactory.Create<IUserIngredientBusinessLogic>();
var userIngredient = new UserIngredient {
User = new User {Username = "******"},
Ingredient = new Ingredient {Name = "Pannbiff"},
Measure = 100
};
userIngredientBusinessLogicMock.Setup(x => x.GetUserIngredients(It.IsAny<User>(), It.IsAny<DateTime>())).Returns(new[] {userIngredient});
userIngredientBusinessLogicMock.Setup(x => x.AddUserIngredient(It.Is<User>(u => u.Username == "myUser"), It.IsAny<string>(), It.IsAny<int>(), It.IsAny<DateTime>())).Returns(userIngredient);
var inputFoodModel = new InputFoodModel {Ingredient = "Pannbiff", Measure = 100, Date = DateTime.Now};
var model = testController(x => x.Input(inputFoodModel), userIngredientBusinessLogicMock, userContextMock);
Assert.That(model, Is.Not.Null);
Assert.That(model.UserIngredients, Is.Not.Null);
Assert.That(model.UserIngredients.Any(x => x.Ingredient.Name == "Pannbiff"));
Assert.That(model.UserIngredients.Any(x => x.Measure == 100));
userIngredientBusinessLogicMock.VerifyAll();
}
public void TestPersist()
{
MockFactory factory = new MockFactory();
//Create mocks
Mock<IUserGateway> mockGateway = factory.CreateMock<IUserGateway>();
Mock<IUserValidator> mockValidator = factory.CreateMock<IUserValidator>();
//Create user
User user = new User();
//Expectations
using(factory.Ordered)
{
mockValidator.Expects.One.MethodWith(m => m.Validate(user)).WillReturn(true);
mockGateway.Expects.One.MethodWith(m => m.Persist(user)).WillReturn(true);
}
//Assign gateway
user.Gateway = mockGateway.MockObject;
//Test method
Assert.AreEqual(true, user.Persist(mockValidator.MockObject));
factory.VerifyAllExpectationsHaveBeenMet();
}
public void ShouldCreateAndEvaluateTest()
{
InstanceDependencyResolution instanceDependencyResolution;
IDependencyManager mockDependencyManager;
int value;
object result;
MockFactory mockFactory;
mockFactory = new MockFactory();
mockDependencyManager = mockFactory.CreateInstance<IDependencyManager>();
value = 11;
instanceDependencyResolution = new InstanceDependencyResolution(value);
Assert.AreEqual(DependencyLifetime.Instance, instanceDependencyResolution.DependencyLifetime);
result = instanceDependencyResolution.Resolve(mockDependencyManager, typeof(object), string.Empty);
Assert.IsNotNull(result);
Assert.AreEqual(11, result);
instanceDependencyResolution.Dispose();
mockFactory.VerifyAllExpectationsHaveBeenMet();
}
public LooseMocksRegistrationSource(MockRepository repository, bool onlyInterfaces)
{
_onlyInterfaces = onlyInterfaces;
_repository = repository;
_createMethod = repository.GetType().GetMethod("Create", new Type[] { });
_createWithArgsMethod = repository.GetType().GetMethod("Create", new [] { typeof(object[]) });
}
public void ShouldCreateAndEvaluateTest()
{
TransientFactoryMethodDependencyResolution transientFactoryMethodDependencyResolution;
IDependencyManager mockDependencyManager;
Func<object> value;
object result;
MockFactory mockFactory;
mockFactory = new MockFactory();
mockDependencyManager = mockFactory.CreateInstance<IDependencyManager>();
value = () => 11;
transientFactoryMethodDependencyResolution = new TransientFactoryMethodDependencyResolution(value);
Assert.AreEqual(DependencyLifetime.Transient, transientFactoryMethodDependencyResolution.DependencyLifetime);
result = transientFactoryMethodDependencyResolution.Resolve(mockDependencyManager, typeof(object), string.Empty);
Assert.IsNotNull(result);
Assert.AreEqual(11, result);
transientFactoryMethodDependencyResolution.Dispose();
mockFactory.VerifyAllExpectationsHaveBeenMet();
}
public void SetUp()
{
_factory = new MockFactory();
List<CommonEvent> mockResult;
var mock1 = _factory.CreateMock<BaseEventCollector>();
mockResult = new List<CommonEvent>();
mockResult.AddRange(new[]
{
new CommonEvent(0, "100", "Mock1Event1", new DateTime(2013,10,15), null, "", "", "", "", "", ""),
new CommonEvent(0, "100", "Mock1Event2", new DateTime(2013,10,1), null, "", "", "", "", "", ""),
});
mock1.Expects.One.MethodWith(x => x.GetEvents(201307, "松山")).WillReturn(mockResult);
var mock2 = _factory.CreateMock<BaseEventCollector>();
mockResult = new List<CommonEvent>();
mockResult.AddRange(new[]
{
new CommonEvent(0, "100", "Mock2Event1", new DateTime(2013,10,8), null, "", "", "", "", "", ""),
new CommonEvent(0, "100", "Mock2Event2", new DateTime(2013,10,30), null, "", "", "", "", "", ""),
new CommonEvent(0, "100", "Mock2Event3", new DateTime(2013,10,25), null, "", "", "", "", "", ""),
});
mock2.Expects.One.MethodWith(x => x.GetEvents(201307, "松山")).WillReturn(mockResult);
sut = new AllEventCollector(new[] { mock1.MockObject, mock2.MockObject });
}
public void ShouldCreateAndEvaluateTest()
{
TransientActivatorAutoWiringDependencyResolution<MockDependantObject> transientActivatorAutoWiringDependencyResolution;
IDependencyManager mockDependencyManager;
MockDependantObject result;
MockFactory mockFactory;
string _unusedString = null;
bool _unusedBoolean = false;
Type _unusedType = null;
mockFactory = new MockFactory();
mockDependencyManager = mockFactory.CreateInstance<IDependencyManager>();
Expect.On(mockDependencyManager).One.Method(m => m.ResolveDependency(_unusedType, _unusedString, _unusedBoolean)).With(typeof(MockDependantObject), "named_dep_obj", true).Will(Return.Value(new MockDependantObject("left")));
Expect.On(mockDependencyManager).One.Method(m => m.ResolveDependency(_unusedType, _unusedString, _unusedBoolean)).With(typeof(MockDependantObject), string.Empty, true).Will(Return.Value(new MockDependantObject("right")));
transientActivatorAutoWiringDependencyResolution = new TransientActivatorAutoWiringDependencyResolution<MockDependantObject>();
Assert.AreEqual(DependencyLifetime.Transient, transientActivatorAutoWiringDependencyResolution.DependencyLifetime);
result = transientActivatorAutoWiringDependencyResolution.Resolve(mockDependencyManager, string.Empty);
Assert.IsNotNull(result);
Assert.IsInstanceOf<MockDependantObject>(result);
Assert.IsNotNull(result.Text);
Assert.AreEqual(string.Empty, result.Text);
Assert.IsNotNull(result.Left);
Assert.IsNotNull(result.Right);
Assert.AreEqual("left", result.Left.Text);
Assert.AreEqual("right", result.Right.Text);
transientActivatorAutoWiringDependencyResolution.Dispose();
mockFactory.VerifyAllExpectationsHaveBeenMet();
}
public void Setup()
{
_factory = new MockFactory(MockBehavior.Strict);
_parserMock = _factory.Create<IConfigurationParser>();
_proxyMock = _factory.Create<IConfigurationProxyProvider>();
_sage = new Sage(_parserMock.Object, _proxyMock.Object);
}
public void shouldThrowIngredientInsertionExceptionWhenInsertingFails()
{
var factory = new MockFactory(MockBehavior.Strict);
var ingredientRepositoryMock = factory.Create<IIngredientRepository>();
ingredientRepositoryMock.Setup(x => x.SaveOrUpdate(It.IsAny<Ingredient>())).Throws(new Exception());
Assert.Throws<IngredientInsertionException>(() => new IngredientImporter(null, null, ingredientRepositoryMock.Object).SaveIngredient(new Ingredient()));
}
/// <summary>
/// Initializes a new instance of the <see cref="MockObject"/> class.
/// </summary>
/// <param name="mockFactory">The mockFactory.</param>
/// <param name="mockedType">Type of the mocked.</param>
/// <param name="name">The name.</param>
/// <param name="mockStyle">The mock style.</param>
protected MockObject(MockFactory mockFactory, CompositeType mockedType, string name, MockStyle mockStyle)
{
MockFactory = mockFactory;
MockStyle = mockStyle;
MockName = name;
eventHandlers = new Dictionary<string, List<Delegate>>();
MockedTypes = mockedType;
}
public void ShouldBeAbleToCreateAProxyForAnEnum()
{
var factory = new MockFactory(MockBehavior.Strict);
var @enum = factory.Create<Fixtures.Language>(MockBehavior.Strict, null, null);
@enum.Setup(e => e.IetfTag).Returns("CZ");
Assert.AreEqual("CZ", @enum.Object.IetfTag);
}
public void SetUp()
{
factory = new MockFactory();
camera = factory.CreateMock<Camera>();
sensor = factory.CreateMock<AbstractTouchSensor>();
sprite1 = factory.CreateMock<Sprite>();
sprite2 = factory.CreateMock<Sprite>();
sprites = new[] { sprite1.MockObject, sprite2.MockObject };
}
public void shouldGetUserFromUsername()
{
var mockFactory = new MockFactory(MockBehavior.Strict);
var userRepositoryMock = mockFactory.Create<IUserRepository>();
userRepositoryMock.Setup(x => x.Get(It.IsAny<string>())).Returns(new User());
var userBusinessLogic = new UserBusinessLogic(userRepositoryMock.Object, null);
userBusinessLogic.Get("myUser");
userRepositoryMock.VerifyAll();
}
public void IsLoginOK_WhenCalled_WritesToLog()
{
var factory = new MockFactory();
Mock<ILogger> logger = factory.CreateMock<ILogger>();
logger.Expects.One.Method(_ => _.Write(null)).WithAnyArguments();
var lm = new LoginManagerWithMock(logger.MockObject);
lm.IsLoginOK("a", "b");
logger.VerifyAllExpectations();
}
public void GetFieldByNameNoHeaderExceptionTest()
{
var data = new [] { "1", "2" };
var mockFactory = new MockFactory( MockBehavior.Default );
var parserMock = mockFactory.Create<ICsvParser>();
parserMock.Setup( m => m.Read() ).Returns( () => data );
var reader = new CsvReader( parserMock.Object, new CsvReaderOptions{ HasHeaderRecord = false } );
reader.Read();
Assert.AreEqual( Convert.ToInt32( data[0] ), reader.GetField<int>( "One" ) );
}
public void ShouldExecuteReaderCloseConnectionSprocWithParametersTest()
{
IAdoNetYieldingFascade adoNetYieldingFascade;
MockFactory mockFactory;
DbConnection mockDbConnection;
DbCommand mockDbCommand;
DbParameterCollection mockDbParameterCollection;
DbParameter[] mockDbParameters;
DbParameter mockDbParameter0;
DbParameter mockDbParameter1;
DbDataReader mockDbDataReader;
IReflectionFascade mockReflectionFascade;
DbDataReader dbDataReader;
CommandBehavior _unusedCommandBehavior = CommandBehavior.Default;
DbParameter _unusedDbParameter = null;
mockFactory = new MockFactory();
mockDbConnection = mockFactory.CreateInstance<DbConnection>();
mockDbCommand = mockFactory.CreateInstance<DbCommand>();
mockDbParameterCollection = mockFactory.CreateInstance<DbParameterCollection>();
mockDbParameter0 = mockFactory.CreateInstance<DbParameter>();
mockDbParameter1 = mockFactory.CreateInstance<DbParameter>();
mockDbParameters = new DbParameter[] { mockDbParameter0, mockDbParameter1 };
mockDbDataReader = mockFactory.CreateInstance<DbDataReader>();
mockReflectionFascade = mockFactory.CreateInstance<IReflectionFascade>();
Expect.On(mockDbConnection).One.Method(x => x.CreateCommand()).Will(Return.Value(mockDbCommand));
Expect.On(mockDbCommand).Exactly(2).GetProperty(x => x.Parameters).Will(Return.Value(mockDbParameterCollection));
Expect.On(mockDbCommand).One.Method(x => x.Dispose());
Expect.On(mockDbCommand).One.SetProperty(x => x.CommandType).To(CommandType.StoredProcedure);
Expect.On(mockDbCommand).One.SetProperty(x => x.CommandText).To("blah blah blah");
Expect.On(mockDbCommand).One.SetProperty(x => x.Transaction).To(null);
Expect.On(mockDbCommand).One.Method(x => x.ExecuteReader(_unusedCommandBehavior)).With(CommandBehavior.CloseConnection).Will(Return.Value(mockDbDataReader));
Expect.On(mockDbParameter0).One.GetProperty(x => x.Value).Will(Return.Value(1));
Expect.On(mockDbParameter1).One.GetProperty(x => x.Value).Will(Return.Value(null));
Expect.On(mockDbParameter1).One.SetProperty(x => x.Value).To(DBNull.Value);
Expect.On(mockDbParameterCollection).One.Method(x => x.Add(_unusedDbParameter)).With(mockDbParameter0).Will(Return.Value(0));
Expect.On(mockDbParameterCollection).One.Method(x => x.Add(_unusedDbParameter)).With(mockDbParameter1).Will(Return.Value(0));
Expect.On(mockDbDataReader).One.Method(x => x.Dispose());
adoNetYieldingFascade = new AdoNetYieldingFascade(mockReflectionFascade);
dbDataReader = adoNetYieldingFascade.ExecuteReader(mockDbConnection, null, CommandType.StoredProcedure, "blah blah blah", mockDbParameters, CommandBehavior.CloseConnection, null, false);
Assert.IsNotNull(dbDataReader);
dbDataReader.Dispose();
mockFactory.VerifyAllExpectationsHaveBeenMet();
}
public void ShouldFailOnDataTypeFascadeCreateTest()
{
AppConfigFascade appConfigFascade;
IConfigurationRoot mockConfigurationRoot;
IDataTypeFascade mockDataTypeFascade;
MockFactory mockFactory;
mockFactory = new MockFactory();
mockConfigurationRoot = mockFactory.CreateInstance<IConfigurationRoot>();
mockDataTypeFascade = null;
appConfigFascade = new AppConfigFascade(mockConfigurationRoot, mockDataTypeFascade);
}
public void shouldCallSaveOnRepository()
{
const string userName = "******";
var password = "******";
var factory = new MockFactory(MockBehavior.Strict);
var mock = factory.Create<IUserBusinessLogic>();
var userContextMock = new Mock<IUserContext>();
mock.Setup(x => x.Create(It.Is<User>(y => y.Username == userName))).Returns(new User());
var controller = new CarbonFitness.App.Web.Controllers.UserController(mock.Object, userContextMock.Object);
controller.Create(userName, password);
factory.VerifyAll();
}
public void GetFieldByIndexTest()
{
var data = new [] { "1", "2" };
var mockFactory = new MockFactory( MockBehavior.Default );
var parserMock = mockFactory.Create<ICsvParser>();
parserMock.Setup( m => m.Read() ).Returns( data );
var reader = new CsvReader( parserMock.Object );
reader.Read();
Assert.AreEqual( 1, reader.GetField<int>( 0 ) );
Assert.AreEqual( 2, reader.GetField<int>( 1 ) );
}
public void ShouldFailOnNullDependencyManagerResolveTest()
{
TransientDefaultConstructorDependencyResolution transientDefaultConstructorDependencyResolution;
IDependencyManager mockDependencyManager;
object result;
MockFactory mockFactory;
mockFactory = new MockFactory();
mockDependencyManager = null;
transientDefaultConstructorDependencyResolution = new TransientDefaultConstructorDependencyResolution(typeof(int));
result = transientDefaultConstructorDependencyResolution.Resolve(mockDependencyManager, typeof(object), string.Empty);
}
[Fact] // Issue #1168
public void ZeroValueInMetricColumnIsNotDashedWithCustomStyle()
{
// arrange
var config = ManualConfig.Create(DefaultConfig.Instance);
var metrics = new[] { new Metric(new FakeMetricDescriptor("metric1", "some legend", "0.0"), 0.0) };
var style = config.SummaryStyle.WithZeroMetricValuesInContent();
// act
var summary = MockFactory.CreateSummary(config, hugeSd: false, metrics);
var table = new SummaryTable(summary, style);
var actual = table.Columns.First(c => c.Header == "metric1").Content;
// assert
Assert.True(actual.All(value => "0.0" == value));
}
public void Can_Identify_MonthYear_Url_Without_Page_Number()
{
var context = MockFactory.GetMockContext(0, false, "~/2013/02");
var routes = new RouteCollection();
MvcApplication.RegisterRoutes(routes);
var routeData = routes.GetRouteData(context);
Assert.IsNotNull(routeData);
Assert.AreEqual("Home", routeData.Values["controller"]);
Assert.AreEqual("PostsByYearAndMonth", routeData.Values["action"]);
Assert.AreEqual("2013", routeData.Values["year"]);
Assert.AreEqual("02", routeData.Values["month"]);
}
public override object CreateMock(MockFactory mockFactory, CompositeType typesToMock, string name, MockStyle mockStyle, object[] constructorArgs)
{
_typesToMock = typesToMock;
_typesToMock.Add(typeof(IMockObject));
var reflectiveInterceptor = new ReflectiveInterceptor(mockFactory, typesToMock, name, mockStyle);
var proxy = CreateMock(reflectiveInterceptor, constructorArgs);
if (_typesToMock.PrimaryType.IsInterface)
((InterfaceMockBase) proxy).Name = name;
return proxy;
}
public void Can_Identify_Tag_Url_With_Page_Number()
{
var context = MockFactory.GetMockContext(0, false, "~/tag/asp-net/page/2");
var routes = new RouteCollection();
MvcApplication.RegisterRoutes(routes);
var routeData = routes.GetRouteData(context);
Assert.IsNotNull(routeData);
Assert.AreEqual("Home", routeData.Values["controller"]);
Assert.AreEqual("PostsByTag", routeData.Values["action"]);
Assert.AreEqual("asp-net", routeData.Values["tagName"]);
Assert.AreEqual("2", routeData.Values["pageNumber"]);
}
public void Can_Identify_Pages_Url_With_Status()
{
var context = MockFactory.GetMockContext(0, false, "~/pages/some-page/comment-posted");
var routes = new RouteCollection();
MvcApplication.RegisterRoutes(routes);
var routeData = routes.GetRouteData(context);
Assert.IsNotNull(routeData);
Assert.AreEqual("ViewPage", routeData.Values["controller"]);
Assert.AreEqual("Index", routeData.Values["action"]);
Assert.AreEqual("some-page", routeData.Values["pageUrl"]);
Assert.AreEqual("comment-posted", routeData.Values["status"]);
}
public void Can_Identify_Author_Posts_Url_With_Page_Number()
{
var context = MockFactory.GetMockContext(0, false, "~/authors/admin/page/2");
var routes = new RouteCollection();
MvcApplication.RegisterRoutes(routes);
var routeData = routes.GetRouteData(context);
Assert.IsNotNull(routeData);
Assert.AreEqual("Author", routeData.Values["controller"]);
Assert.AreEqual("PostsByAuthor", routeData.Values["action"]);
Assert.AreEqual("admin", routeData.Values["authorName"]);
Assert.AreEqual("2", routeData.Values["pageNumber"]);
}
public async Task Handle_WhenIncidentNotExist_ReturnNewIncident()
{
var serviceUnderTest = new GetIncidentsByTicketCreateIfNeededRequestHandler(
await MockFactory.IncidentContext(nameof(Handle_WhenIncidentNotExist_ReturnNewIncident)),
new NoConnector(new NoClient(), new StubLoggerFactory())
);
var request = new GetIncidentsByTicketCreateIfNeededRequest("100", new DummyAuthenticatedUserContext());
var result = (await serviceUnderTest.Handle(request, new System.Threading.CancellationToken())).ToList();
Assert.AreEqual(1, result.Count());
Assert.AreEqual("100", result[0].PrimaryTicket.OriginId);
}
public void TestAssemblyLoadedEvent()
{
MockFactory mockery = new MockFactory();
PluginRepository testRepository = new PluginRepository();
Mock <IAssemblyLoadedSubscriber> subscriber = mockSubscriber(mockery, testRepository);
subscriber.Expects.One.Method(m => m.AssemblyLoaded(null, null)).WithAnyArguments();
Assembly self = Assembly.GetAssembly(GetType());
testRepository.AddAssembly(self);
mockery.VerifyAllExpectationsHaveBeenMet();
}
public void it_should_do_a_pong()
{
//Arrange
MockFactory.UpdateContainer((builder) =>
{
builder.Register <IPingPongService>(b => new FakePingPongService());
});
MockFactory.CreateActor <PingPongActor <MockActor> >();
//Act
MockFactory.LocateActor(typeof(PingPongActor <>)).Tell(new PingMessage());
//Assert
AwaitAssert(() => ExpectMsg <PingMessageCompleted>(), TimeSpan.FromSeconds(5));
}
public void detailsShouldReturnUser()
{
var factory = new MockFactory(MockBehavior.Strict);
var mock = factory.Create<IUserBusinessLogic>();
mock.Setup(x => x.Get(1)).Returns(new User {Username = "******"});
var userBusinessLogic = mock.Object;
var controller = new CarbonFitness.App.Web.Controllers.UserController(userBusinessLogic, null);
var viewResult = (ViewResult) controller.Details(1);
var user = (User) viewResult.ViewData.Model;
Assert.That(user, Is.TypeOf(typeof(User)));
Assert.AreEqual("kalle", user.Username);
}
public void FileRegionsCache_PopulatesNullRegion()
{
Uri uri = new Uri(@"c:\temp\myFile.cpp");
var run = new Run();
IFileSystem mockFileSystem = MockFactory.MakeMockFileSystem(uri.LocalPath, SPEC_EXAMPLE);
var fileRegionsCache = new FileRegionsCache(fileSystem: mockFileSystem);
Region region = fileRegionsCache.PopulateTextRegionProperties(inputRegion: null, uri: uri, populateSnippet: false);
region.Should().BeNull();
region = fileRegionsCache.PopulateTextRegionProperties(inputRegion: null, uri: uri, populateSnippet: true);
region.Should().BeNull();
}
public void GetOrAddWithNoSetUp_TestObject_ReturnsExpectedResult()
{
var cacheKey = "SomethingInTheCache";
var expectedResult = new TestObject();
var cacheMock = MockFactory.CreateCachingServiceMock();
var mockedCache = cacheMock.Object;
var actualResult = mockedCache.GetOrAdd(cacheKey, () => expectedResult, DateTimeOffset.Now.AddMinutes(30));
Assert.Multiple(() => {
Assert.AreSame(expectedResult, actualResult);
cacheMock.Verify(m => m.GetOrAdd(It.IsAny <string>(), It.IsAny <Func <ICacheEntry, TestObject> >()), Times.Once);
});
}
// [ExpectedException]
public void actor_mocking013()
{
//Arrange
// mockFactory = new AkkaMockFactory(new ContainerBuilder().Build(), Sys);
var pingActor = MockFactory.WhenActorReceives <PingMessage>().ItShouldTellSender(new PongMessage()).CreateMockActor <MockActor>();
var pingPongActor = MockFactory.WhenActorReceives <PingMessage>().ItShouldForwardItToChildActor(typeof(MockActor), new PingMessage()).CreateMockActorRef <MockActor2 <MockActor> >();
//Act
pingPongActor.Tell(new PingMessage());
//Assert
MockFactory.ExpectMockActor(pingActor).WhoseParentIs(pingPongActor).NotToHaveReceivedMessage <PongMessage>();
Xunit.Assert.Throws <Exception>(() => MockFactory.ExpectMockActor(pingActor).WhoseParentIs(pingPongActor).ToHaveReceivedMessage <PingMessage>());
}
public static void ClassInitialize(TestContext context)
{
//INITIALIZED ALL THE MOCK OBJECTS NEEDED FOR TESTING
MockFactory mockFactory = new MockFactory();
_libraryConfigurationMocked = mockFactory.CreateMock <IXXXLibraryConfiguration>();
_IAircraftRecoverAndPersistMocked = mockFactory.CreateMock <IAircraftRecoverAndPersist>();
//INITIALIZED OBJECT CONTROLLER FOR UNIT TESTING
Sut = new SeatAssignment(_IAircraftRecoverAndPersistMocked.MockObject, _libraryConfigurationMocked.MockObject);
//COMPLETE SCENARIO
_libraryConfigurationMocked.Expects.One.GetProperty(v => v.TimeSalesCloseBeforeFlight).WillReturn(2);
_IAircraftRecoverAndPersistMocked.Expects.One.Method(x => x.UpdateAircraft(default(Aircraft))).WithAnyArguments().WillReturn(true);
}
public void CanBindToInstanceFactoryMethodWithParameters()
{
var factory = new MockFactory();
var module = new InlineModule(
m => m.Bind(typeof(IMock)).ToMethod(ctx => factory.Create("foo", 42))
);
using (var kernel = new StandardKernel(module))
{
var mock = kernel.Get<IMock>();
Assert.That(mock, Is.Not.Null);
Assert.That(mock, Is.InstanceOfType(typeof(ImplB)));
}
}
public void shouldReturnFalseWhenProvidingWrongPassword()
{
var username = "******";
var userPassword = "******";
var providedPassword = "******";
var factory = new MockFactory(MockBehavior.Strict);
var userRepositoryMock = factory.Create<IUserRepository>();
userRepositoryMock.Setup(x => x.Get(username)).Returns(new User(username, userPassword));
var membershipProvider = new MembershipBusinessLogic(userRepositoryMock.Object);
var loginResult = membershipProvider.ValidateUser(username, providedPassword);
Assert.That(loginResult, Is.False);
}
public void ShouldGetArgumentsOfInvokedMethod()
{
MockFactory mocks = new MockFactory();
string message = "hello";
Mock <IMessageService> serviceMock = mocks.CreateMock <IMessageService>();
MessageController controller = new MessageController(serviceMock.MockObject);
serviceMock.Expects.One.Method(_ => _.GetMessage(0, null)).With(Is.EqualTo(23), Is.Anything)
.Will(GetArguments.WhenCalled(arguments => (arguments[1] as Action <string>).Invoke(message)));
controller.GetMessage(23);
Assert.AreEqual(message, controller.Message);
}
public void ShouldFailOnDisposedClearAllResolutionsTest()
{
DependencyManager dependencyManager;
MockFactory mockFactory;
IDependencyResolution mockDependencyResolution;
bool result;
mockFactory = new MockFactory();
mockDependencyResolution = mockFactory.CreateInstance <IDependencyResolution>();
dependencyManager = new DependencyManager();
dependencyManager.Dispose();
result = dependencyManager.ClearAllResolutions();
}
public void it_should_send_it_out()
{
//Arrange
const string emailAddress = "*****@*****.**";
MockFactory.WhenActorReceives <SendEmailMessage>().ItShouldTellSender(new EmailSentMessage(emailAddress)).SetUpMockActor <MockActor>();
MockFactory.CreateActor <EmailSupervisorActor <MockActor> >();
//Act
MockFactory.LocateActor(typeof(EmailSupervisorActor <>)).Tell(new SendEmailMessage(emailAddress));
//Assert
AwaitAssert(() => ExpectMsg <EmailReadyToSendMessage>(message => message.EmailAddress == emailAddress), TimeSpan.FromMinutes(1));
}
public void ShouldCreateAndEvaluateSelectorKeyTest()
{
TransientActivatorAutoWiringDependencyResolution transientActivatorAutoWiringDependencyResolution;
IDependencyManager mockDependencyManager;
IReflectionFascade mockReflectionFascade;
Type activatorType;
object result;
MockFactory mockFactory;
string _unusedString = null;
bool _unusedBoolean = false;
Type _unusedType = null;
ConstructorInfo _unusedConstructorInfo = null;
mockFactory = new MockFactory();
mockDependencyManager = mockFactory.CreateInstance <IDependencyManager>();
mockReflectionFascade = mockFactory.CreateInstance <IReflectionFascade>();
// TODO: reflection to fascade classes
IReflectionFascade stubReflectionFascade;
stubReflectionFascade = new ReflectionFascade(new DataTypeFascade());
mockReflectionFascade = stubReflectionFascade;
activatorType = typeof(MockDependantObject);
//Expect.On(mockReflectionFascade).Exactly(4).Method(x => x.GetOneAttribute<DependencyInjectionAttribute>(_unusedConstructorInfo)).WithAnyArguments().Will(Return.Value<DependencyInjectionAttribute>((DependencyInjectionAttribute)null));
Expect.On(mockDependencyManager).One.Method(m => m.ResolveDependency(_unusedType, _unusedString, _unusedBoolean)).With(typeof(MockDependantObject), string.Empty, true).Will(Return.Value(new MockDependantObject("both")));
transientActivatorAutoWiringDependencyResolution = new TransientActivatorAutoWiringDependencyResolution(mockReflectionFascade, activatorType);
Assert.AreEqual(DependencyLifetime.Transient, transientActivatorAutoWiringDependencyResolution.DependencyLifetime);
result = transientActivatorAutoWiringDependencyResolution.Resolve(mockDependencyManager, typeof(object), "named_dep_obj");
Assert.IsNotNull(result);
Assert.IsInstanceOf <MockDependantObject>(result);
Assert.IsNotNull(((MockDependantObject)result).Text);
Assert.AreEqual(string.Empty, ((MockDependantObject)result).Text);
Assert.IsNotNull(((MockDependantObject)result).Left);
Assert.IsNotNull(((MockDependantObject)result).Right);
Assert.AreEqual("both", ((MockDependantObject)result).Left.Text);
Assert.AreEqual("both", ((MockDependantObject)result).Right.Text);
transientActivatorAutoWiringDependencyResolution.Dispose();
mockFactory.VerifyAllExpectationsHaveBeenMet();
}
public void ShouldFailOnNullTypeResolveUntypedTest()
{
SingletonWrapperDependencyResolution <int> singletonWrapperDependencyResolution;
IDependencyManager mockDependencyManager;
IDependencyResolution <int> mockDependencyResolution;
object result;
MockFactory mockFactory;
mockFactory = new MockFactory();
mockDependencyManager = mockFactory.CreateInstance <IDependencyManager>();
mockDependencyResolution = mockFactory.CreateInstance <IDependencyResolution <int> >();
singletonWrapperDependencyResolution = new SingletonWrapperDependencyResolution <int>(mockDependencyResolution);
result = singletonWrapperDependencyResolution.Resolve(mockDependencyManager, null, string.Empty);
}
public ActionResult Narrative(Guid id)
{
if (AppSetup.LoadMockData)
{
List <Annotation> annotations = MockFactory.MockAnnotations();
return(View(annotations));
}
else
{
DWSamplingPlan dw = new DWSamplingPlan {
Id = id
};
dw.RetrieveAnnotations();
return(View(dw.Annotations));
}
}
public void ShouldFailOnNullDependencyManagerResolveTest()
{
ContextWrapperDependencyResolution contextWrapperDependencyResolution;
IDependencyManager mockDependencyManager;
IDependencyResolution mockDependencyResolution;
object result;
MockFactory mockFactory;
mockFactory = new MockFactory();
mockDependencyManager = null;
mockDependencyResolution = mockFactory.CreateInstance <IDependencyResolution>();
contextWrapperDependencyResolution = new ContextWrapperDependencyResolution(ContextScope.LocalThreadSafe, mockDependencyResolution);
result = contextWrapperDependencyResolution.Resolve(mockDependencyManager, typeof(object), string.Empty);
}
public void ShouldFailOnNullTypeResolveUntypedTest()
{
TransientActivatorAutoWiringDependencyResolution <MockDependantObject> transientActivatorAutoWiringDependencyResolution;
IDependencyManager mockDependencyManager;
IReflectionFascade mockReflectionFascade;
object result;
MockFactory mockFactory;
mockFactory = new MockFactory();
mockDependencyManager = mockFactory.CreateInstance <IDependencyManager>();
mockReflectionFascade = mockFactory.CreateInstance <IReflectionFascade>();
transientActivatorAutoWiringDependencyResolution = new TransientActivatorAutoWiringDependencyResolution <MockDependantObject>(mockReflectionFascade);
result = transientActivatorAutoWiringDependencyResolution.Resolve(mockDependencyManager, null, string.Empty);
}
public void ShouldFailOnNullTypeResolveUntypedTest()
{
ContextWrapperDependencyResolution <int> contextWrapperDependencyResolution;
IDependencyManager mockDependencyManager;
IDependencyResolution <int> mockDependencyResolution;
object result;
MockFactory mockFactory;
mockFactory = new MockFactory();
mockDependencyManager = mockFactory.CreateInstance <IDependencyManager>();
mockDependencyResolution = mockFactory.CreateInstance <IDependencyResolution <int> >();
contextWrapperDependencyResolution = new ContextWrapperDependencyResolution <int>(ContextScope.LocalThreadSafe, mockDependencyResolution);
result = contextWrapperDependencyResolution.Resolve(mockDependencyManager, null, string.Empty);
}
public void GetFieldByNameNoHeaderExceptionTest()
{
var data = new [] { "1", "2" };
var mockFactory = new MockFactory(MockBehavior.Default);
var parserMock = mockFactory.Create <ICsvParser>();
parserMock.Setup(m => m.Read()).Returns(() => data);
var reader = new CsvReader(parserMock.Object, new CsvReaderOptions {
HasHeaderRecord = false
});
reader.Read();
Assert.AreEqual(Convert.ToInt32(data[0]), reader.GetField <int>("One"));
}
public void ShouldFailOnNullDependencyManagerResolveTest()
{
SingletonWrapperDependencyResolution singletonWrapperDependencyResolution;
IDependencyManager mockDependencyManager;
IDependencyResolution mockDependencyResolution;
object result;
MockFactory mockFactory;
mockFactory = new MockFactory();
mockDependencyManager = null;
mockDependencyResolution = mockFactory.CreateInstance <IDependencyResolution>();
singletonWrapperDependencyResolution = new SingletonWrapperDependencyResolution(mockDependencyResolution);
result = singletonWrapperDependencyResolution.Resolve(mockDependencyManager, typeof(object), string.Empty);
}
public void Can_Identify_Individual_Post()
{
var context = MockFactory.GetMockContext(0, false, "~/2013/03/some-post");
var routes = new RouteCollection();
MvcApplication.RegisterRoutes(routes);
var routeData = routes.GetRouteData(context);
Assert.IsNotNull(routeData);
Assert.AreEqual("Home", routeData.Values["controller"]);
Assert.AreEqual("View", routeData.Values["action"]);
Assert.AreEqual("2013", routeData.Values["year"]);
Assert.AreEqual("03", routeData.Values["month"]);
Assert.AreEqual("some-post", routeData.Values["url"]);
}
public void FalseIfClassHasNotTestAttribute()
{
var mocks = new Mocks(MockFactory);
var variableDeclaration = MockFactory.CreateMock <IVariableDeclaration>();
mocks.SelectedVariableProviderExpectGetValueOrDefault(variableDeclaration.MockObject);
mocks.IsVariableNotNullExpectValidate(variableDeclaration.MockObject, true);
var classDeclaration = MockFactory.CreateMock <IClassDeclaration>();
mocks.SelectedClassProviderExpectGetValueOrDefault(classDeclaration.MockObject);
mocks.IsClassHasTestClassAttributeExpectValidate(classDeclaration.MockObject, false);
Assert.IsFalse(mocks.Sut.Validate());
}
public void actor_mocking()
{
//Arrange
// mockFactory = new AkkaMockFactory(new ContainerBuilder().Build(), Sys);
var pingActor = MockFactory.WhenActorReceives <PingMessage>().ItShouldTellSender(new PongMessage()).CreateMockActorRef <MockActor>();
var pingPongActor = MockFactory.WhenActorReceives <PingMessage>().ItShouldForwardItTo(pingActor, new PingMessage()).CreateMockActorRef <MockActor2>();
//Act
pingPongActor.Tell(new PingMessage());
//Assert
AwaitAssert(() => ExpectMsg <PongMessage>(), TimeSpan.FromSeconds(5));
MockFactory.ExpectMockActor(pingActor).NotToHaveReceivedMessage <PongMessage>();
MockFactory.ExpectMockActor(pingActor).ToHaveReceivedMessage <PingMessage>();
}
public virtual void Setup()
{
CreateRunspace();
Mocks = new MockFactory(MockBehavior.Loose);
factory = Mocks.Create<IEmailApiFactory>();
EmailApiCommand.Factory = factory.Object;
client = Mocks.Create<IWebClient>();
client.SetupAllProperties();
client.Object.Headers = (Headers = new WebHeaderCollection());
factory.Setup(f => f.CreateWebClient())
.Returns(client.Object)
.AtMostOnce();
}
public void Test_CollectionConversion_MaintainListsOfSomeOperations_ExplicitTryGet()
{
// The demo code will throw exceptions, so just return.
return;
IRepository repository = null;
IList <Entity> entities = MockFactory.CreateMockEntities();
IList <ViewModel> viewModels = MockFactory.CreateMockViewModels();
IList <Entity> newEntities = CollectionConversionHelper.ConvertCollection_MaintainListsOfSomeOperations_ExplicitTryGet(viewModels, entities, repository);
foreach (Entity newEntity in newEntities)
{
// You might link the new entities to their parent here.
}
}
public void Test_CollectionConversion_CompareSetsOfIDs_GetAndDelete()
{
// The demo code will throw exceptions, so just return.
return;
IRepository repository = null;
IList <Entity> entities = MockFactory.CreateMockEntities();
IList <ViewModel> viewModels = MockFactory.CreateMockViewModels();
IList <Entity> newEntities = CollectionConversionHelper.ConvertCollection_CompareSetsOfIDs_GetAndDelete(viewModels, entities, repository);
foreach (Entity newEntity in newEntities)
{
// You might link the new entities to their parent here.
}
}
public void CreateMocksClass()
{
var mocks = new Mocks(MockFactory);
var expectedResult = MockFactory.CreateMock <ICSharpTypeMemberDeclaration>().MockObject;
mocks.TypeMemberTextDeclarationProvider.Expects.One
.MethodWith(o => o.Get())
.WillReturn("SomeDeclaration");
mocks.CSharpElementFactory.Expects.One
.MethodWith(o => o.CreateTypeMemberDeclaration("SomeDeclaration"))
.WillReturn(expectedResult);
var actualResult = mocks.Sut.Create();
Assert.AreSame(expectedResult, actualResult);
}
public void ShouldFailOnNullTypeResolveTest()
{
TransientActivatorAutoWiringDependencyResolution transientActivatorAutoWiringDependencyResolution;
IDependencyManager mockDependencyManager;
object result;
MockFactory mockFactory;
Type activatorType;
mockFactory = new MockFactory();
mockDependencyManager = mockFactory.CreateInstance <IDependencyManager>();
activatorType = typeof(int);
transientActivatorAutoWiringDependencyResolution = new TransientActivatorAutoWiringDependencyResolution(activatorType);
result = transientActivatorAutoWiringDependencyResolution.Resolve(mockDependencyManager, null, string.Empty);
}
public void shouldRedirectToReturnUrlWhenLoginIsSuccessfull()
{
var returnUrl = "~/Home/Index";
var mockFactory = new MockFactory(MockBehavior.Strict);
var membershipService = mockFactory.Create<IMembershipBusinessLogic>();
var formsAuthenticationService = mockFactory.Create<IFormsAuthenticationService>();
membershipService.Setup(x => x.ValidateUser("username", "password")).Returns(true);
formsAuthenticationService.Setup(x => x.SignIn("username", false));
var accountController = new CarbonFitness.App.Web.Controllers.AccountController(formsAuthenticationService.Object, membershipService.Object);
var actionResult = accountController.LogOn(new LogOnModel {UserName = "******", Password = "******"}, returnUrl);
Assert.That(((RedirectResult) actionResult).Url.Contains(returnUrl));
}
