/**
* Create Mock Staff Object for test purposes
*/
private Staff createStaffMock()
{
var dummyStaff = new Moq.Mock<Staff>();
dummyStaff.SetupProperty(staff => staff.FirstName, "First")
.SetupProperty(staff => staff.LastName, "Last")
.SetupProperty(staff => staff.Role, "Agent")
.SetupProperty(staff => staff.DistributionCentre, new DistributionCentre());
return dummyStaff.Object;
}
public void BuildReturnsCallableDelegate()
{
var builder = new ApplicationBuilder(null);
var app = builder.Build();
var mockHttpContext = new Moq.Mock<HttpContext>();
var mockHttpResponse = new Moq.Mock<HttpResponse>();
mockHttpContext.SetupGet(x => x.Response).Returns(mockHttpResponse.Object);
mockHttpResponse.SetupProperty(x => x.StatusCode);
app.Invoke(mockHttpContext.Object);
Assert.Equal(mockHttpContext.Object.Response.StatusCode, 404);
}
public void PrintRoverPosition()
{
var mock = new Moq.Mock <IRoverPosition>();
mock.SetupProperty(m => m.RoverFacingPosition, RoverFacing.North);
mock.SetupProperty(m => m.RoverPositionX, 1);
mock.SetupProperty(m => m.RoverPositionY, 1);
string expectedText = $"Rover is now at {mock.Object.RoverPositionX}, {mock.Object.RoverPositionY} - facing {mock.Object.RoverFacingPosition}";
try
{
using (var writer = new StreamWriter("ConsoleOut.txt", false, UTF8Encoding.UTF8))
{
var currOut = Console.Out;
Console.SetOut(writer);
Rover.PrintRoverPosition(mock.Object.RoverPositionX, mock.Object.RoverPositionY, mock.Object.RoverFacingPosition);
}
using (var reader = new StreamReader("ConsoleOut.txt", UTF8Encoding.UTF8))
{
var textFromFile = reader.ReadToEnd().Trim();
Assert.IsTrue(expectedText.Equals(textFromFile));
}
}
catch (Exception)
{
Assert.IsTrue(false);
}
}
public void MoveRoverOutOfGtrid_North()
{
var mock = new Moq.Mock <IRoverPosition>();
mock.SetupProperty(m => m.RoverFacingPosition, RoverFacing.North);
mock.SetupProperty(m => m.RoverPositionX, 0);
mock.SetupProperty(m => m.RoverPositionY, 0);
Rover.ExecuteCommand("F", mock.Object);
Assert.AreEqual <int>(mock.Object.RoverPositionX, 0);
Assert.AreEqual <int>(mock.Object.RoverPositionY, 0);
}
public void SetPropertiesFromDgpHeaderWithInvalidHeaderReturnsValidationException()
{
var header = "someheader";
var httpContext = new DefaultHttpContext
{
RequestServices = new Moq.Mock <IServiceProvider>().Object
};
httpContext.Request.Headers.Add(CorrelationHeader.Key, header);
var httpContextAccessor = new Moq.Mock <IHttpContextAccessor>();
httpContextAccessor.SetupProperty <HttpContext>(x => x.HttpContext, httpContext);
var contextFormatter = new CorrelationContextFormatter(new TestLogger <CorrelationContextFormatter>(new List <string>()), httpContextAccessor.Object);
var ex = Assert.Throws <ValidationException>(() => contextFormatter.ValidateAndSetPropertiesFromDgpHeader(header));
Assert.Contains("Invalid correlationheader", ex.Message);
Assert.Equal(httpContextAccessor.Object.HttpContext.Request.Headers[CorrelationHeader.Key], CorrelationHeader.Default);
Assert.Contains(header, String.Join(",", ex.Messages.SelectMany(x => x.Value.Select(y => y.ToString()))));
Assert.Equal(ErrorCode.InvalidCorrelationHeader, ex.Code);
}
public void WhenHeaderIsPresentExistingCorrelationContextIsAvailable()
{
var httpContext = new DefaultHttpContext
{
RequestServices = new Moq.Mock <IServiceProvider>().Object
};
var header = "eyJpZCI6ImNvcnJlbGF0aW9uaWQiLAoic291cmNlSWQiOiIxIiwKInNvdXJjZU5hbWUiOiJ0ZXN0bmFtZSIsCiJpbnN0YW5jZUlkIjoiMiIsCiJpbnN0YW5jZU5hbWUiOiJ0ZXN0aW5zdGFuY2UiLAp1c2VySWQiOiJ1bmtvd251c2VyIiwKImlwQWRkcmVzcyI6IjEyMy4xMjMuMTIzLjEyMyJ9";
httpContext.Request.Headers.Add(CorrelationHeader.Key, header);
var httpContextAccessor = new Moq.Mock <IHttpContextAccessor>();
httpContextAccessor.SetupProperty <HttpContext>(x => x.HttpContext, httpContext);
var applicationContext = new Moq.Mock <IApplicationContext>().Object;
var logger = new Moq.Mock <ILogger <CorrelationService> >().Object;
var correlationContextFormatter = new Moq.Mock <ICorrelationContextFormatter>();
correlationContextFormatter.Setup(x => x.ValidateAndSetPropertiesFromDgpHeader(header)).Returns(new CorrelationContext {
DgpHeader = header
});
var correlationContext = new Moq.Mock <IScopedCorrelationContext>().Object;
var service = new CorrelationService(httpContextAccessor.Object, applicationContext, logger, correlationContextFormatter.Object, correlationContext);
var context = service.GetContext();
Assert.Equal(header, context.DgpHeader);
}
public void Login_AdminPassword_True()
{
var dummyUser = new Moq.Mock<User>();
dummyUser.SetupProperty(user => user.Email, "*****@*****.**")
.SetupProperty(user => user.Password, "password");
User userObject = dummyUser.Object;
Assert.AreNotEqual(null, userObject.login("*****@*****.**", "password"));
}
public void SetUp()
{
controller = new ArtistController(null, null, null);
var responseMock = new Moq.Mock <HttpResponseBase>();
responseMock.SetupProperty(m => m.StatusCode);
responseMock.SetupProperty(m => m.StatusDescription);
response = responseMock.Object;
var context = new Moq.Mock <HttpContextBase>();
context.SetupGet(m => m.Response).Returns(response);
var controllerContext = new Moq.Mock <ControllerContext>();
controllerContext.SetupGet(m => m.HttpContext).Returns(context.Object);
controller.ControllerContext = controllerContext.Object;
}
/**
* Addition method to create a mock object
* */
private MedicationStandardType createMockMedication()
{
var dummyMedication = new Moq.Mock<MedicationStandardType>();
dummyMedication.SetupProperty(medication => medication.Quantity, 100)
.SetupProperty(medication => medication.Description, "Medication Pills")
.SetupProperty(medication => medication.Cost, 30.00)
.SetupProperty(medication => medication.IsTempSensitive, false)
.SetupProperty(medication => medication.ShelfLife, "12/12/17");
return dummyMedication.Object;
}
public void RotateRoverFromWest_InvalidRotationPoint()
{
var mock = new Moq.Mock <IRoverPosition>();
mock.SetupProperty(m => m.RoverFacingPosition, RoverFacing.West);
Rover.ExecuteCommand("R", mock.Object);
Rover.ExecuteCommand("R", mock.Object);
Rover.ExecuteCommand("R", mock.Object);
Rover.ExecuteCommand("R", mock.Object);
Assert.AreNotEqual <int>((int)mock.Object.RoverFacingPosition, (int)RoverFacing.North);
}
public void RotateRoverRightFromNorthToNorth()
{
var mock = new Moq.Mock <IRoverPosition>();
mock.SetupProperty(m => m.RoverFacingPosition, RoverFacing.North);
Rover.ExecuteCommand("R", mock.Object);
Rover.ExecuteCommand("R", mock.Object);
Rover.ExecuteCommand("R", mock.Object);
Rover.ExecuteCommand("R", mock.Object);
Assert.AreEqual <int>((int)mock.Object.RoverFacingPosition, (int)RoverFacing.North);
}
public void BuildReturnsCallableDelegate()
{
var builder = new Builder();
var app = builder.Build();
var mockHttpContext = new Moq.Mock<HttpContextBase>();
var mockHttpResponse = new Moq.Mock<HttpResponseBase>();
mockHttpContext.SetupGet(x => x.Response).Returns(mockHttpResponse.Object);
mockHttpResponse.SetupProperty(x => x.StatusCode);
app.Invoke(mockHttpContext.Object);
mockHttpContext.Object.Response.StatusCode.ShouldBe(404);
}
public void SaveOpenFile()
{
string filePath = "C:\\Users\\Evgeny\\Desktop\\test.bin";
var saver = new HDDDataManager();
var savedFile = saver.CreateFile(filePath);
int moqPointsCount = 2; //Количество точек-заглушек
int moqPointValuesCount = 1000000; //Количество значений, которые вернет точка-заглушка
for (int i = 0; i < moqPointsCount; i++)
{
var moqPoint = new Moq.Mock <IHdaPoint>();
moqPoint.SetupProperty(T => T.Item, $"TestPoint_{i}");
moqPoint.SetupProperty(T => T.Description, $"TestDescription_{i}");
moqPoint.SetupProperty(T => T.EngUnit, $"TestEngUnit_{i}");
//
moqPoint.Setup(T => T.GetValues()).Returns(() => GetTestValues(moqPointValuesCount));
savedFile.AddPoint(moqPoint.Object);
}
savedFile.Save();
var loader = new HDDDataManager();
var loadedFile = loader.LoadFile(filePath);
var firstPoint = loadedFile.Points.First();
var values = firstPoint.GetValues();
Assert.AreEqual(loadedFile.Points.Count(), moqPointsCount);
Assert.AreEqual(values.Count(), moqPointValuesCount);
}
public void BuildReturnsCallableDelegate()
{
var builder = new ApplicationBuilder(null);
var app = builder.Build();
var mockHttpContext = new Moq.Mock <HttpContext>();
var mockHttpResponse = new Moq.Mock <HttpResponse>();
mockHttpContext.SetupGet(x => x.Response).Returns(mockHttpResponse.Object);
mockHttpResponse.SetupProperty(x => x.StatusCode);
app.Invoke(mockHttpContext.Object);
Assert.Equal(mockHttpContext.Object.Response.StatusCode, 404);
}
internal static ControllerContext MockContollerContext()
{
var httpContextMock = new Moq.Mock <HttpContext>();
httpContextMock.Setup(r => r.RequestServices.GetService(typeof(DbContextOptions <BloggingContext>))).Returns(() =>
{
var opts = new DbContextOptions <BloggingContext>();
return(opts);
});
httpContextMock.Setup(r => r.RequestServices.GetService(typeof(ITempDataDictionaryFactory))).Returns(() =>
{
var tdp = new Moq.Mock <ITempDataProvider>();
tdp.Setup(p => p.LoadTempData(Moq.It.IsAny <HttpContext>())).Returns(() =>
{
return(new Dictionary <string, object>());
});
var tddf = new Moq.Mock <ITempDataDictionaryFactory>();
tddf.Setup(f => f.GetTempData(Moq.It.IsAny <HttpContext>())).Returns(() =>
{
return(new TempDataDictionary(httpContextMock.Object, tdp.Object));
});
return(tddf.Object);
});
CancellationToken token;
httpContextMock.SetupProperty(r => r.RequestAborted, token).SetReturnsDefault(token);
httpContextMock.Setup(r => r.RequestServices.GetService(typeof(Microsoft.AspNetCore.Mvc.ModelBinding.Validation.IObjectModelValidator))).Returns(() =>
{
var omv = new Moq.Mock <Microsoft.AspNetCore.Mvc.ModelBinding.Validation.IObjectModelValidator>();
omv.Setup(p => p.Validate(Moq.It.IsAny <ActionContext>(),
Moq.It.IsAny <Microsoft.AspNetCore.Mvc.ModelBinding.Validation.ValidationStateDictionary>(),
Moq.It.IsAny <string>(), Moq.It.IsAny <object>()))
.Callback(() =>
{
});
return(omv.Object);
});
var cc = new ControllerContext(new ActionContext(httpContextMock.Object, new RouteData(), new ControllerActionDescriptor()));
return(cc);
}
public void Homepage_Recognizes_New_Visitor_And_Sets_Cookie_UsingVirtualPropertiesToSimplifyMocking()
{
// Arrange
var controller = new Moq.Mock <SimpleController> {
CallBase = true
};
controller.Setup(x => x.IncomingHasVisitedBeforeCookie).Returns((HttpCookie)null);
controller.SetupProperty(x => x.OutgoingHasVisitedBeforeCookie);
// Act
ViewResult result = controller.Object.Homepage();
// Assert
Assert.IsEmpty(result.ViewName);
Assert.IsTrue((bool)result.ViewData["IsFirstVisit"]);
Assert.AreEqual("True", controller.Object.OutgoingHasVisitedBeforeCookie.Value);
}
public void SetUp()
{
_controller = new ArtistController(null, null, null);
var responseMock = new Moq.Mock <HttpResponse>();
responseMock.SetupProperty(m => m.StatusCode);
_response = responseMock.Object;
var context = new Moq.Mock <HttpContext>();
context.SetupGet(m => m.Response).Returns(_response);
var controllerContextMock = new Moq.Mock <ControllerContext>();
var controllerContext = controllerContextMock.Object;
controllerContext.HttpContext = context.Object;
_controller.ControllerContext = controllerContext;
}
public CustomTestControllerBuilder()
{
var httpContext = new Moq.Mock<HttpContextBase>();
var request = new Moq.Mock<HttpRequestBase>();
var response = new Moq.Mock<HttpResponseBase>();
var server = new Moq.Mock<HttpServerUtilityBase>();
var _cache = HttpRuntime.Cache;
httpContext.Setup(x=> x.Request).Returns(request.Object);
httpContext.Setup(x => x.Response).Returns(response.Object);
httpContext.Setup(x => x.Session).Returns(Session);
httpContext.Setup(x => x.Server).Returns(server.Object);
httpContext.Setup(x => x.Cache).Returns(_cache);
var items = new Dictionary<object, object>();
httpContext.Setup(x => x.Items).Returns(items);
QueryString = new NameValueCollection();
request.Setup(x => x.QueryString).Returns(QueryString);
Form = new NameValueCollection();
request.Setup(x => x.Form).Returns(Form);
request.Setup(x => x.AcceptTypes).Returns((Func<string[]>)(() => AcceptTypes));
var files = new WriteableHttpFileCollection();
Files = files;
request.Setup(x => x.Files).Returns(files);
Func<NameValueCollection> paramsFunc = () => new NameValueCollection { QueryString, Form };
request.Setup(x => x.Params).Returns(paramsFunc);
request.Setup(x => x.AppRelativeCurrentExecutionFilePath).Returns(
(Func<string>)(() => AppRelativeCurrentExecutionFilePath));
request.Setup(x => x.ApplicationPath).Returns((Func<string>)(() => ApplicationPath));
request.Setup(x => x.PathInfo).Returns((Func<string>)(() => PathInfo));
request.Setup(x => x.RawUrl).Returns((Func<string>)(() => RawUrl));
response.SetupProperty(x => x.Status);
httpContext.SetupProperty(x=>x.User);
var ms = new MemoryStream(65536);
var sw = new StreamWriter(ms);
response.SetupGet(x=>x.Output).Returns(sw);
response.SetupGet(x => x.OutputStream).Returns(ms);
response.Setup(x => x.Write(It.IsAny<string>())).Callback((string s) => { sw.Write(s); });
response.Setup(x => x.Write(It.IsAny<char>())).Callback((char s) => { sw.Write(s); });
response.Setup(x => x.Write(It.IsAny<object>())).Callback((object s) => { sw.Write(s); });
//_mocks.Replay(HttpContext);
//_mocks.Replay(request);
//_mocks.Replay(response);
TempDataDictionary = new TempDataDictionary();
HttpContext = httpContext.Object;
}
public void WhenDuplicateHeaderCorrelationContextIsCreated()
{
var httpContext = new DefaultHttpContext
{
RequestServices = new Moq.Mock <IServiceProvider>().Object
};
var httpContextAccessor = new Moq.Mock <IHttpContextAccessor>();
httpContextAccessor.SetupProperty <HttpContext>(x => x.HttpContext, httpContext);
var applicationContext = new Moq.Mock <IApplicationContext>().Object;
var logger = new TestLogger <CorrelationService>(new List <string>());
var correlationContextFormatter = new Moq.Mock <ICorrelationContextFormatter>();
var service = new CorrelationService(httpContextAccessor.Object, applicationContext, logger, correlationContextFormatter.Object);
var context = service.GetContext();
Assert.NotNull(context.DgpHeader);
Assert.NotNull(context.Id);
}
public void EncoderTest1()
{
byte[] bmpData;
byte[] referenceData;
using (FileStream fs = new FileStream("sample1.bmp", FileMode.Open))
{
bmpData = new byte[fs.Length];
fs.Read(bmpData, 0, bmpData.Length);
fs.Close();
}
using (FileStream fs = new FileStream("sample1.group4", FileMode.Open))
{
referenceData = new byte[fs.Length];
fs.Read(referenceData, 0, referenceData.Length);
fs.Close();
}
var encoder = new CCITTCodecs.CCITTEncoder();
var outputStreamMock = new Moq.Mock <Stream>(Moq.MockBehavior.Strict);
//we do NOT setup .Seek() as the encoder should not be calling it.
//the position property is used int he encoder (to return bytes written) and by the below .WriteByte() test
outputStreamMock.SetupProperty(o => o.Position, 0);
// this compares each byte as it's written to the reference encoding. It failed immadiately if the wrong byte is written
//it also causes the position to be incremented and it there for essential to the operation of the encoder
outputStreamMock.Setup(o => o.WriteByte(Moq.It.Is <byte>(b => TestByte(b, referenceData, outputStreamMock.Object))));
using (var inputStream = new MemoryStream(bmpData, 62, bmpData.Length - 62, false))
{
encoder.Encode(inputStream, 0, 1702, 746, outputStreamMock.Object);
}
Assert.AreEqual(referenceData.LongLength, outputStreamMock.Object.Position, "Incorrect number of bytes encoded.");
}
public void Test_080()
{
// ********************************************************
Test_030();
// ********************************************************
var mock =
new Moq.Mock <WebApplicationTest.Services.ISmsService>();
string erroeMessage = "Server Not Found!";
System.Exception exception =
new System.Exception(message: erroeMessage);
int credit = 10;
//mock.Setup(current => current.Credit).Returns(credit);
//mock.SetupGet(current => current.Credit).Returns(credit);
// Initial Value!
mock.SetupProperty(current => current.Credit, credit);
mock.Setup(current => current.IsCellPhoneNumberValid(Moq.It.IsAny <string>())).Returns(true);
mock.Setup(current => current.SendSms(Moq.It.IsAny <string>(), Moq.It.IsAny <string>())).Verifiable();
WebApplicationTest.Controllers.SmsController smsController =
new WebApplicationTest.Controllers.SmsController(smsService: mock.Object);
var result =
smsController.Send
(cellPhoneNumber: "09351008895", message: "Hello, World!")
as Microsoft.AspNetCore.Mvc.ViewResult;
int expectedCredit = credit - 1;
int actualCredit = mock.Object.Credit;
Xunit.Assert.Equal
(expected: expectedCredit, actual: actualCredit);
}
public void SetPropertiesFromDgpHeaderWithIdNullReturnsValidationException()
{
var context = new CorrelationContext
{
Id = null,
SourceId = Guid.NewGuid().ToString(),
SourceName = "appName",
InstanceId = Guid.NewGuid().ToString(),
InstanceName = "appName-instanceName",
UserId = "userId",
IpAddress = "194.25.76.122"
};
context.SetDgpHeader();
var httpContext = new DefaultHttpContext
{
RequestServices = new Moq.Mock <IServiceProvider>().Object
};
httpContext.Request.Headers.Add(CorrelationHeader.Key, context.DgpHeader);
var httpContextAccessor = new Moq.Mock <IHttpContextAccessor>();
httpContextAccessor.SetupProperty <HttpContext>(x => x.HttpContext, httpContext);
var contextFormatter = new CorrelationContextFormatter(new TestLogger <CorrelationContextFormatter>(new List <string>()), httpContextAccessor.Object);
var ex = Assert.Throws <ValidationException>(() => contextFormatter.ValidateAndSetPropertiesFromDgpHeader(context.DgpHeader));
Assert.Contains("Invalid correlationheader", ex.Message);
Assert.Equal(httpContextAccessor.Object.HttpContext.Request.Headers[CorrelationHeader.Key], CorrelationHeader.Default);
Assert.Contains(context.DgpHeader, String.Join(",", ex.Messages.SelectMany(x => x.Value.Select(y => y.ToString()))));
Assert.Equal(ErrorCode.InvalidCorrelationHeader, ex.Code);
}
/**
* Addition method to create a mock object
* */
private Package createMockPackage()
{
var dummyPackage = new Moq.Mock<Package>();
dummyPackage.SetupProperty(package => package.BarCode, 123456)
.SetupProperty(package => package.ExpiryDate, new DateTime(17, 12, 12));
return dummyPackage.Object;
}
