public void ShouldAssertOccrenceForNonPublicFunction()
{
var foo = Mock.Create <Foo>(Behavior.CallOriginal);
Mock.NonPublic.Assert <int>(foo, "IntValue", Occurs.Never());
}
public void ScaleSelectFigureTest()
{
var rect = Mock.Create <RectangleFigure>(() => new RectangleFigure());
Figure figure = new Figure(new Pen(Color.AliceBlue), new GraphicsPath(), Color.Bisque, 1, false);
Pivots pivots = new Pivots(new Pen(Color.AliceBlue), new GraphicsPath());
rect.ScaleSelectFigure(figure, pivots, new int(), new int());
Mock.Assert(() => rect.ScaleSelectFigure(figure, pivots, new int(), new int()), Occurs.AtLeastOnce());
}
public void Assert(object target, string methodName, Type[] methodParamTypes, string localFunctionName, Occurs occurs, Type[] methodGenericTypes, params object[] args)
{
ProfilerInterceptor.GuardInternal(() =>
{
Type[] emptyLocalFunctionGenericTypes = new Type[] { };
this.Assert(target, methodName, methodParamTypes, localFunctionName, occurs, methodGenericTypes, emptyLocalFunctionGenericTypes, args);
});
}
public void Assert(object target, string methodName, Type[] methodParamTypes, string localFunctionName, Occurs occurs, params object[] args)
{
ProfilerInterceptor.GuardInternal(() =>
{
MethodInfo method = MockingUtil.GetMethodWithLocalFunction(target, methodName, methodParamTypes, null);
this.Assert(target, method, localFunctionName, occurs, args);
});
}
private static void DoAssert(string message, object obj, Type objType, LambdaExpression expression, Args args, Occurs occurs)
{
var repo = MockingContext.CurrentRepository;
Expression parameterlessArrangeStmt = null;
if (expression != null)
{
var instanceParam = expression.Parameters[0];
var instanceConstant = Expression.Constant(obj);
var parameterlessBody = ExpressionReplacer.Replace(expression.Body, instanceParam, instanceConstant);
parameterlessArrangeStmt = Expression.Lambda(parameterlessBody);
}
repo.Assert(message, obj, parameterlessArrangeStmt, args, occurs);
}
public void ShouldAssertNonPublicMethodViaDynaMock()
{
var mock = Mock.Create <TestBed>();
var wrapper = Mock.NonPublic.Wrap(mock);
Assert.Throws <AssertionException>(() => Mock.NonPublic.Assert(wrapper.Value = 123, Occurs.Once()));
Assert.Throws <AssertionException>(() => Mock.NonPublic.Assert(wrapper.Value = ArgExpr.IsAny <int>(), Occurs.Once()));
new TestBed.Accessor(mock).Value = 123;
Mock.NonPublic.Assert(wrapper.Value = 123, Occurs.Once());
Mock.NonPublic.Assert(wrapper.Value = ArgExpr.IsAny <int>(), Occurs.Once());
}
public void Not_Update_Title_On_Edit() //Remove if we later decide to handle all title changes from El Dorado
{
Target.SyncToWordpress(Post);
Client.Assert(cl => cl.GetRawResultOfBearerRequest(HttpMethod.Post, EditUrl, Arg.AnyString, Arg.Matches <string>(s => s.Contains($"\"title\":"))), Occurs.Never());
}
/// <summary>
/// Assert a method on an registered mock.
/// </summary>
/// <typeparam name="TDependency">The type of the registered mock.</typeparam>
/// <param name="container">The mocking container.</param>
/// <param name="name">The contract name identifying the registered mock.</param>
/// <param name="expression">The method to assert.</param>
/// <param name="occurs">Occurrence expectation.</param>
public static void Assert <TDependency>(this IUnityContainer container, string name, Expression <Action <TDependency> > expression, Occurs occurs)
{
container.RegisterMock <TDependency>(name).Assert(expression, occurs);
}
public void RegisterCommand_WhenThrows_ShouldCatch()
{
Mock.Arrange(() => _remoteApiMap.RegisterCommand("action", Arg.IsAny <Action>(), string.Empty)).Throws <Exception>();
_sut = new TraceableRemoteApiMap(_remoteApiMap, _remoteRecordsSender, _recorder);
Action a = () => { };
_sut.RegisterCommand("action", a, string.Empty);
Mock.Assert(() => _recorder.DefaultException(Arg.IsAny <Object>(), Arg.IsAny <Exception>()), Occurs.Exactly(1));
}
public void When_no_events_are_published_then_no_events_are_reported_to_agent_health()
{
// Act
_harvestAction();
// Assert
Mock.Assert(() => _agentHealthReporter.ReportCustomEventCollected(), Occurs.Never());
Mock.Assert(() => _agentHealthReporter.ReportCustomEventsRecollected(Arg.IsAny <int>()), Occurs.Never());
Mock.Assert(() => _agentHealthReporter.ReportCustomEventReservoirResized(Arg.IsAny <int>()), Occurs.Never());
Mock.Assert(() => _agentHealthReporter.ReportCustomEventsSent(Arg.IsAny <int>()), Occurs.Never());
}
public void ShouldVerifyThatMockArgumentIsNotAssertedInsteadOfExpected()
{
var viewServiceMock = Mock.Create <IViewService>();
var view1 = Mock.Create <IView>();
var view2 = Mock.Create <IView>();
var view3 = Mock.Create <IView>();
Mock.Arrange(() => viewServiceMock.Views).Returns(new[] { view1, view2, view3 });
Mock.Arrange(() => viewServiceMock.ActiveView).Returns(view2);
Mock.Arrange(() => viewServiceMock.TryCloseViews(Arg.IsAny <IEnumerable <IView> >()));
viewServiceMock.TryCloseViews(viewServiceMock.Views.Except(new[] { viewServiceMock.ActiveView }));
// this will increase the execution number of GetHashCode()
Assert.True(new[] { view1, view3 }.All((view) => view == view1 || view == view3));
Mock.Assert(() => viewServiceMock.TryCloseViews(Arg.Matches <IEnumerable <IView> >((views) => views.All((view) => view == view1 || view == view3))), Occurs.Once());
}
public void ShouldAssertForArgMatchesWhenArgumentCalulatedBasedOnMockValues()
{
var viewServiceMock = Mock.Create <IViewService>();
var view1 = Mock.Create <IView>();
var view2 = Mock.Create <IView>();
var view3 = Mock.Create <IView>();
Mock.Arrange(() => viewServiceMock.Views).Returns(new[] { view1, view2, view3 });
Mock.Arrange(() => viewServiceMock.ActiveView).Returns(view2);
Mock.Arrange(() => viewServiceMock.TryCloseViews(Arg.IsAny <IEnumerable <IView> >()));
viewServiceMock.TryCloseViews(viewServiceMock.Views.Except(new[] { viewServiceMock.ActiveView }));
Mock.Assert(() => viewServiceMock.TryCloseViews(Arg.Matches <IEnumerable <IView> >((views) => views.All((view) => view == view1 || view == view3))), Occurs.Once());
}
public void ShouldAssertForAnyArgumentsWhenIgnoreSwitchAndOccursSpecified()
{
var region = Mock.Create <IRegionManager>();
Mock.Assert(() => region.RequestNavigate(RegionNames.OperationsEditRegion, null), Args.Ignore(), Occurs.Never());
}
internal ClrWildCardPropertyInfo(string ns, string targetNs, bool addToType, Occurs schemaOccurs)
{
namespaces = ns;
targetNamespace = targetNs;
this.contentType = ContentType.WildCardProperty;
this.addToTypeDef = addToType;
this.occursInSchema = schemaOccurs;
}
public void Create_A_New_Draft_When_Post_Has_No_Wordpress_Id()
{
Post.WordpressId = 0;
Target.SyncToWordpress(Post);
Client.Assert(cl => cl.GetRawResultOfBearerRequest(HttpMethod.Post, CreateUrl, Arg.AnyString, Arg.AnyString), Occurs.Once());
}
public void ShouldAssertCallWhenCombinedWithEnumFollowedByAnyTypeArgs()
{
var region = Mock.Create <IRegionManager>();
region.RequestNavigate(RegionNames.OperationsEditRegion, new FooExrepssion());
Mock.Assert(() => region.RequestNavigate(RegionNames.OperationsEditRegion, Arg.IsAny <FooExrepssion>()), Occurs.Once());
}
public void SendTwoMesssagesTest()
{
IMessageBus messageBus = new SimpleMessageBus();
IFakeHost host = GetFakeHostMocked(messageBus);
host.Init(messageBus);
messageBus.SendMessage(MESSAGE_STRING, this, MessageActionType.Add);
messageBus.SendMessage(MESSAGE_INT, this, MessageActionType.Add);
Mock.Assert(() => host.OnMessageOneReceived(Arg.IsAny <Message>()), Occurs.Once());
Mock.Assert(() => host.OnMessageOneReceivedExtended(Arg.IsAny <Message>()), Occurs.Exactly(2));
Mock.Assert(() => host.OnMessageTwoReceived(Arg.IsAny <Message>()), Occurs.Once());
}
/// <summary>
/// Asserts the specific call
/// </summary>
/// <typeparam name="T">Type of the mock.</typeparam>
/// <param name="obj">Target mock object</param>
/// <param name="expression">Target expression</param>
/// <param name="occurs">Specifies the number of times a mock call should occur.</param>
public static void Assert <T>(this T obj, Expression <Action <T> > expression, Occurs occurs, string message = null)
{
ProfilerInterceptor.GuardInternal(() =>
{
DoAssert(message, obj, typeof(T), expression, null, occurs);
});
}
public void DontSendMesssageTest()
{
IMessageBus messageBus = new SimpleMessageBus();
IFakeHost host = GetFakeHostMocked(messageBus);
host.Init(messageBus);
Mock.Assert(() => host.OnMessageOneReceived(Arg.IsAny <Message>()), Occurs.Never());
Mock.Assert(() => host.OnMessageOneReceivedExtended(Arg.IsAny <Message>()), Occurs.Never());
Mock.Assert(() => host.OnMessageTwoReceived(Arg.IsAny <Message>()), Occurs.Never());
}
public async Task Test1()
{
var entityId = new EntityId(nameof(LastChargeState), "*****@*****.**");
Mock.Arrange(() => _durableOrchestrationContextMock.GetInput <OrchestrationData>()).Returns(new OrchestrationData()
{
EntityId = entityId
});
Mock.Arrange(() => _durableOrchestrationContextMock.CallActivityAsync <ChargeState>("CallTeslaAPI", Arg.IsAny <TeslaLogin>()))
.Returns(Task.FromResult(new ChargeState()
{
ChargingState = ChargingStatus.Disconnected
}));
Mock.Arrange(() => _durableOrchestrationContextMock.CallEntityAsync <ChargingStatus>(entityId, "Get"))
.Returns(Task.FromResult(ChargingStatus.Other));
Mock.Arrange(() => _durableOrchestrationContextMock.CallActivityAsync("SaveCharge", Arg.IsAny <ChargeState>()));
await CheckChargeStatus.RunOrchestrator(_durableOrchestrationContextMock, _loggerMock);
Mock.Assert(() => _durableOrchestrationContextMock.CallActivityAsync("SaveCharge", Arg.IsAny <ChargeState>()), Occurs.Never());
Mock.Assert(() => _durableOrchestrationContextMock.SignalEntity(entityId, "Set", Arg.IsAny <ChargingStatus>()), Occurs.Once());
}
public void SendUnknownMesssageTest()
{
IMessageBus messageBus = new SimpleMessageBus();
IFakeHost host = GetFakeHostMocked(messageBus);
host.Init(messageBus);
messageBus.SendMessage(MESSAGE_UNKNOWN, this, MessageActionType.Add);
Mock.Assert(() => host.OnMessageOneReceived(Arg.IsAny <Message>()), Occurs.Never());
Mock.Assert(() => host.OnMessageOneReceivedExtended(Arg.IsAny <Message>()), Occurs.Never());
Mock.Assert(() => host.OnMessageTwoReceived(Arg.IsAny <Message>()), Occurs.Never());
}
public void Assert(object target, MethodInfo method, string localFunctionName, Occurs occurs, params object[] args)
{
ProfilerInterceptor.GuardInternal(() =>
{
Type type = target.GetType();
MethodInfo localFunction = MockingUtil.GetLocalFunction(type, method, localFunctionName, null);
Mock.NonPublic.Assert(target, localFunction, occurs, args);
});
}
/// <summary>
/// Assert a method on an exported mock.
/// </summary>
/// <typeparam name="TObject">The type of the exported mock.</typeparam>
/// <param name="this">The mocking container.</param>
/// <param name="expression">The method to assert.</param>
/// <param name="occurs">Occurrence expectation.</param>
public static void Assert<TObject>(this MockExportProvider @this, Expression<Func<TObject, object>> expression, Occurs occurs)
{
@this.GetExportedValue<TObject>().Assert(expression, occurs);
}
public void Assert(object target, string methodName, Type[] methodParamTypes, string localFunctionName, Occurs occurs, Type[] methodGenericTypes, Type[] localFunctionGenericTypes, params object[] args)
{
ProfilerInterceptor.GuardInternal(() =>
{
MethodInfo method = MockingUtil.GetMethodWithLocalFunction(target, methodName, methodParamTypes, methodGenericTypes);
List <Type> combinedTypes = new List <Type>();
combinedTypes.AddRange(methodGenericTypes);
combinedTypes.AddRange(localFunctionGenericTypes);
MethodInfo localMethod = MockingUtil.GetLocalFunction(target.GetType(), method, localFunctionName, combinedTypes.ToArray());
Mock.NonPublic.Assert(target, localMethod, occurs, args);
});
}
/// <summary>
/// Assert a method on an exported mock.
/// </summary>
/// <typeparam name="TObject">The type of the exported mock.</typeparam>
/// <param name="this">The mocking container.</param>
/// <param name="contractName">The contract name identifying the exported mock.</param>
/// <param name="expression">The method to assert.</param>
/// <param name="occurs">Occurrence expectation.</param>
public static void Assert<TObject>(this MockExportProvider @this, string contractName, Expression<Action<TObject>> expression, Occurs occurs)
{
@this.GetExportedValue<TObject>(contractName).Assert(expression, occurs);
}
public void ShouldAssertSetPropertyOccurenceForAnyValue()
{
var foo = Mock.Create <IFoo>();
Mock.ArrangeSet(() => foo.EffectiveFrom = DateTime.Now).IgnoreArguments();
foo.EffectiveFrom = DateTime.Now;
Assert.Throws <AssertionException>(() => Mock.AssertSet(() => foo.EffectiveFrom = Arg.IsAny <DateTime>(), Occurs.Never()));
}
public void Encode_The_Password()
{
const string password = "******";
Client.Arrange(cl => cl.GetRawResultOfBasicPostRequest(Arg.AnyString)).Returns(RawResponseJson);
Target.AuthorizeUser(Username, password);
Client.Assert(cl => cl.GetRawResultOfBasicPostRequest($"{WordpressService.AuthEndpoint}?username={Username}&password=badpass%26"), Occurs.Once());
}
public void MouseDownTest()
{
var rect = Mock.Create <RectangleFigure>(() => new RectangleFigure());
MouseEventArgs e = new MouseEventArgs(MouseButtons.Left, new int(), new int(), new int(), new int());
rect.MouseDown(new List <PointF>(), e, new int(), new List <ITypesFigures>());
Mock.Assert(() => rect.MouseDown(new List <PointF>(), e, new int(), new List <ITypesFigures>()), Occurs.AtLeastOnce());
}
public void OnTransactionFinalized_DoesNotCallTransform_IfTransactionWasAlreadyFinished()
{
var startTime = DateTime.Now;
var segments = new Segment[]
{
GetFinishedSegment(startTime, startTime.AddSeconds(0), TimeSpan.FromSeconds(3)),
GetFinishedSegment(startTime, startTime.AddSeconds(1), TimeSpan.FromSeconds(1)),
GetFinishedSegment(startTime, startTime.AddSeconds(2), TimeSpan.FromSeconds(1)),
};
var transaction = BuildTestTransaction(segments, startTime);
var mockedTransaction = Mock.Create <IInternalTransaction>();
Mock.Arrange(() => mockedTransaction.Finish()).Returns(false);
Mock.Arrange(() => mockedTransaction.ConvertToImmutableTransaction()).Returns(transaction);
var transactionMetricName = new TransactionMetricName("c", "d");
Mock.Arrange(() => _transactionMetricNameMaker.GetTransactionMetricName(Arg.IsAny <ITransactionName>())).Returns(transactionMetricName);
EventBus <TransactionFinalizedEvent> .Publish(new TransactionFinalizedEvent(mockedTransaction));
Mock.Assert(() => _transactionTransformer.Transform(Arg.IsAny <IInternalTransaction>()), Occurs.Never());
}
internal GroupingInfo(ContentModelType cmType, Occurs occursInSchema) {
this.contentModelType = cmType;
this.occursInSchema = occursInSchema;
this.contentType = ContentType.Grouping;
if ((int)occursInSchema > (int)Occurs.ZeroOrOne) {
groupingFlags |= GroupingFlags.Repeating;
}
}
/// <summary>
/// Assert a method on an registered mock.
/// </summary>
/// <typeparam name="TDependency">The type of the registered mock.</typeparam>
/// <param name="container">The mocking container.</param>
/// <param name="expression">The method to assert.</param>
/// <param name="occurs">Occurrence expectation.</param>
public static void Assert <TDependency>(this IUnityContainer container, Expression <Func <TDependency, object> > expression, Occurs occurs)
{
container.RegisterMock <TDependency>().Assert(expression, occurs);
}
internal ClrPropertyInfo(
string propertyName,
string propertyNs,
string schemaName,
Occurs occursInSchema)
{
this.contentType = ContentType.Property;
this.propertyName = propertyName;
this.propertyNs = propertyNs;
this.schemaName = schemaName;
this.hasSet = true;
this.returnType = null;
this.clrTypeName = null;
this.occursInSchema = occursInSchema;
if (this.occursInSchema > Occurs.ZeroOrOne)
{
this.propertyFlags |= PropertyFlags.IsList;
}
if (this.IsOptional)
{
this.propertyFlags |= PropertyFlags.IsNullable;
}
XNameGetExpression();
}
public void ShouldNotThrowDuringAssertForCallOriginalWhenNoArrangeSpecified()
{
var foo = Mock.Create <FooWithSetThatThows>(Behavior.CallOriginal);
Mock.AssertSet(() => foo.Value = Arg.AnyInt, Occurs.Never());
}
