void AssetRewrite(string from, string to)
{
var context = new Mock<HttpContextBase>();
var request = new Mock<HttpRequestBase>();
var cache = new Mock<HttpCachePolicyBase>();
var cassetteSettings = new CassetteSettings();
var requestHeaders = new NameValueCollection();
context.SetupGet(c => c.Request).Returns(request.Object);
context.Setup(c => c.Response.Cache).Returns(cache.Object);
var auth = new Mock<IFileAccessAuthorization>();
auth.Setup(a => a.CanAccess(It.IsAny<string>())).Returns(true);
var hasher = new Mock<IFileContentHasher>();
hasher.Setup(h => h.Hash(It.IsAny<string>())).Returns(new byte[] { 1 });
request
.SetupGet(r => r.AppRelativeCurrentExecutionFilePath)
.Returns("~/cassette.axd");
request
.SetupGet(r => r.PathInfo)
.Returns(from);
request
.SetupGet(r => r.Headers)
.Returns(requestHeaders);
var rewriter = new RawFileRequestRewriter(context.Object, auth.Object, hasher.Object, cassetteSettings, usingIntegratedPipeline: true);
rewriter.Rewrite();
context.Verify(c => c.RewritePath(to));
}
private static IList<IAttribute> CreateMockAttributes(IEnumerable<Expression<Func<System.Attribute>>> attributes) {
var result = new List<IAttribute>();
if (attributes != null) {
foreach (var attrExpression in attributes) {
var attr = new Mock<IAttribute>(MockBehavior.Strict);
var body = (NewExpression)attrExpression.Body;
attr.SetupGet(_ => _.AttributeType).Returns(CreateMockTypeDefinition(body.Type.FullName, null));
var posArgs = new List<ResolveResult>();
foreach (var argExpression in body.Arguments) {
var argType = new Mock<IType>(MockBehavior.Strict);
argType.SetupGet(_ => _.FullName).Returns(argExpression.Type.FullName);
var arg = new ConstantResolveResult(argType.Object, ((ConstantExpression)argExpression).Value);
posArgs.Add(arg);
}
attr.SetupGet(_ => _.PositionalArguments).Returns(posArgs);
if (body.Members != null && body.Members.Count > 0)
throw new InvalidOperationException("Named attribute args are not supported");
attr.SetupGet(_ => _.NamedArguments).Returns(new KeyValuePair<IMember, ResolveResult>[0]);
result.Add(attr.Object);
}
}
return result;
}
public void Handle_SameLegalName_NoAliasAdded()
{
AgencyName agencyName = new AgencyName("TestAgencyName", "DisplayName", "BusinessName");
AgencyProfile agencyProfile = new AgencyProfile (
new Mock<AgencyType> ().Object,
agencyName,
new DateRange ( DateTime.Now.AddDays ( -1 ), DateTime.Now ),
"url",
new Mock<GeographicalRegion> ().Object,
"note" );
var aliasAdded = false;
var agencyMock = new Mock<Agency>();
agencyMock.SetupGet(p => p.AgencyProfile).Returns(agencyProfile);
agencyMock.Setup(a => a.AddAgencyAlias(It.IsAny<AgencyAlias>())).Callback(() => aliasAdded = true);
var agencyProfileChangedEvent = new Mock<AgencyProfileChangedEvent>();
agencyProfileChangedEvent.SetupGet(p => p.Agency).Returns(agencyMock.Object);
agencyProfileChangedEvent.SetupGet(p => p.OldAgencyProfile).Returns(agencyProfile);
new AgencyProfileChangedEventHandler().Handle(agencyProfileChangedEvent.Object);
Assert.IsFalse(aliasAdded);
}
public void SourceFileWithLayoutPageTest()
{
// Arrange
var pagePath = "~/MyApp/index.cshtml";
var layoutPath = "~/MyFiles/Layout.cshtml";
var layoutPage = "~/MyFiles/Layout.cshtml";
var content = "hello world";
var title = "MyPage";
var page = CreatePageWithLayout(
p =>
{
p.PageData["Title"] = title;
p.WriteLiteral(content);
},
p =>
{
p.WriteLiteral(p.PageData["Title"]);
p.Write(p.RenderBody());
}, pagePath, layoutPath, layoutPage);
var request = new Mock<HttpRequestBase>();
request.SetupGet(c => c.Path).Returns("/myapp/index.cshtml");
request.SetupGet(c => c.RawUrl).Returns("http://localhost:8080/index.cshtml");
request.SetupGet(c => c.IsLocal).Returns(true);
request.Setup(c => c.MapPath(It.IsAny<string>())).Returns<string>(c => c);
request.Setup(c => c.Browser.IsMobileDevice).Returns(false);
request.Setup(c => c.Cookies).Returns(new HttpCookieCollection());
var result = Utils.RenderWebPage(page, request: request.Object);
Assert.Equal(2, page.PageContext.SourceFiles.Count);
Assert.True(page.PageContext.SourceFiles.Contains("~/MyApp/index.cshtml"));
Assert.True(page.PageContext.SourceFiles.Contains("~/MyFiles/Layout.cshtml"));
}
public GetAssemblyNamesMethod()
{
_workingDirectory = "c:\\test";
_filesystem = new Mock<IFileSystem>();
_filesystem.SetupGet(i => i.CurrentDirectory).Returns("c:\\test");
_filesystem.Setup(i => i.DirectoryExists(It.IsAny<string>())).Returns(true);
_filesystem.Setup(i => i.FileExists(It.IsAny<string>())).Returns(true);
_logger = new Mock<ILog>();
_package = new Mock<IPackageObject>();
_package.Setup(i => i.GetCompatibleDlls(It.IsAny<FrameworkName>()))
.Returns(new List<string> { "test.dll", "test2.dll" });
_package.SetupGet(i => i.Id).Returns("id");
_package.SetupGet(i => i.Version).Returns(new Version("3.0"));
_package.SetupGet(i => i.TextVersion).Returns("3.0");
_package.SetupGet(i => i.FullName).Returns(_package.Object.Id + "." + _package.Object.Version);
_packageIds = new List<IPackageReference>
{
new PackageReference("testId", VersionUtility.ParseFrameworkName("net40"), new Version("3.0"))
};
_packageContainer = new Mock<IPackageContainer>();
_packageContainer.Setup(i => i.FindReferences(It.IsAny<string>())).Returns(_packageIds);
_packageContainer.Setup(i => i.FindPackage(It.IsAny<string>(), It.IsAny<IPackageReference>())).Returns(_package.Object);
}
public StylesheetPipeline_Process_TestBase()
{
settings = new CassetteSettings();
bundle = new StylesheetBundle("~");
asset1 = new Mock<IAsset>();
asset2 = new Mock<IAsset>();
bundle.Assets.Add(asset1.Object);
bundle.Assets.Add(asset2.Object);
asset1.SetupGet(a => a.Path)
.Returns("~/asset1.css");
asset1.Setup(a => a.OpenStream())
.Returns(() => "/* @reference \"asset2.css\"; */".AsStream());
asset2.SetupGet(a => a.Path)
.Returns("~/asset2.css");
asset2.Setup(a => a.OpenStream())
.Returns(() => "p { color: White; }".AsStream());
asset1.SetupGet(a => a.References)
.Returns(new[] { new AssetReference(asset1.Object.Path, "~/asset2.css", -1, AssetReferenceType.SameBundle) });
minifier = new MicrosoftStylesheetMinifier();
urlGenerator = new Mock<IUrlGenerator>();
container = new TinyIoCContainer();
container.Register(minifier);
container.Register(urlGenerator.Object);
container.Register(settings);
}
Selection GetSelectionWithCaretPos (int row, int column)
{
var documentMock = new Mock<ICaret>();
documentMock.SetupGet(o => o.Row).Returns(row);
documentMock.SetupGet(o => o.Column).Returns(column);
return new Selection(documentMock.Object);
}
public void ProcessRequest_Should_Save_File()
{
var reference = Guid.NewGuid().ToString();
var pluploadContextMock = new Mock<IPluploadContext>();
var httpPostedFileMock = new Mock<HttpPostedFileBase>();
var httpFileCollectionMock = new Mock<HttpFileCollectionBase>();
httpFileCollectionMock.SetupGet(c => c.AllKeys).Returns(new string[] { "FileName.Extension" });
httpFileCollectionMock.Setup(c => c.Get("FileName.Extension")).Returns(httpPostedFileMock.Object);
httpFileCollectionMock.Setup(c => c.Get(0)).Returns(httpPostedFileMock.Object);
httpFileCollectionMock.SetupGet(c => c[0]).Returns(httpPostedFileMock.Object);
var httpRequestMock = new Mock<HttpRequestBase>();
httpRequestMock.SetupGet(r => r.Files).Returns(httpFileCollectionMock.Object);
httpRequestMock.SetupGet(r => r.Params).Returns(new NameValueCollection() { { "reference", reference.ToString() } });
var httpResponseMock = new Mock<HttpResponseBase>();
var httpContextMock = new Mock<HttpContextBase>();
httpContextMock.SetupGet(c => c.Request).Returns(httpRequestMock.Object);
httpContextMock.SetupGet(c => c.Response).Returns(httpResponseMock.Object);
httpContextMock.SetupGet(c => c.Items).Returns(new ListDictionary());
httpContextMock.Object.SetPluploadContext(pluploadContextMock.Object);
var handler = new PluploadHandler();
handler.ProcessRequest(httpContextMock.Object);
pluploadContextMock.Verify(c => c.SaveFile(httpPostedFileMock.Object, reference), Times.Once);
httpResponseMock.Verify(r => r.Write("OK"), Times.Once);
}
public void TestAddingRecordingDeviceToSelected()
{
var configurationMoq = new Mock<ISoundSwitchConfiguration> {Name = "Configuration mock"};
var audioMoqI = new Mock<IAudioDevice> {Name = "first audio dev"};
audioMoqI.SetupGet(a => a.FriendlyName).Returns("Speakers (Test device)");
audioMoqI.SetupGet(a => a.Type).Returns(AudioDeviceType.Recording);
//Setup
configurationMoq.Setup(c => c.SelectedRecordingDeviceList).Returns(new HashSet<string>());
TestHelpers.SetConfigurationMoq(configurationMoq);
//Action
var eventCalled = false;
AppModel.Instance.SelectedDeviceChanged += (sender, changed) => eventCalled = true;
Assert.True(AppModel.Instance.SelectDevice(audioMoqI.Object));
//Asserts
configurationMoq.VerifyGet(c => c.SelectedRecordingDeviceList);
configurationMoq.Verify(c => c.Save());
audioMoqI.VerifyGet(a => a.FriendlyName);
audioMoqI.VerifyGet(a => a.Type);
Assert.That(configurationMoq.Object.SelectedRecordingDeviceList.Count == 1);
Assert.That(configurationMoq.Object.SelectedRecordingDeviceList.Contains("Speakers (Test device)"));
Assert.That(eventCalled, "SelectedDeviceChanged not called");
}
public void ItReturnsTheGrandChildrenChildrenAfterTheChild()
{
var treeItem1 = Mock.Of<ITreeItem>();
var treeItem2 = new Mock<ITreeItem>();
var treeItem3 = Mock.Of<ITreeItem>();
var child1 = Mock.Of<ITreeItem>();
var child2 = new Mock<ITreeItem>();
var child3 = Mock.Of<ITreeItem>();
var grandChild1 = Mock.Of<ITreeItem>();
var grandChild2 = Mock.Of<ITreeItem>();
treeItem2.SetupGet(i => i.IsExpanded).Returns(true);
treeItem2.SetupGet(i => i.Children).Returns(A.Array(child1, child2.Object, child3));
child2.SetupGet(i => i.IsExpanded).Returns(true);
child2.SetupGet(i => i.Children).Returns(A.Array(grandChild1, grandChild2));
var collection = new TreeItemHierarchyFlattener2();
var flattenedHierarchy = collection.Flatten(A.Array(treeItem1, treeItem2.Object, treeItem3));
flattenedHierarchy.AssertContains(
treeItem1
, treeItem2.Object
, child1
, child2.Object
, grandChild1
, grandChild2
, child3
, treeItem3);
}
public void TestQueryAsync_ServerReturnsQuery_ReturnsListWithFieldworkOffices()
{
const HttpStatusCode httpStatusCode = HttpStatusCode.NotFound;
var expectedFieldworkOffices = new FieldworkOffice[]
{ new FieldworkOffice{OfficeId = "TestOfficeId"},
new FieldworkOffice{OfficeId = "AnotherTestOfficeId"}
};
var mockedNfieldConnection = new Mock<INfieldConnectionClient>();
var mockedHttpClient = new Mock<INfieldHttpClient>();
mockedHttpClient
.Setup(client => client.GetAsync(ServiceAddress + "offices/"))
.Returns(
Task.Factory.StartNew(
() =>
new HttpResponseMessage(httpStatusCode)
{
Content = new StringContent(JsonConvert.SerializeObject(expectedFieldworkOffices))
}));
mockedNfieldConnection
.SetupGet(connection => connection.Client)
.Returns(mockedHttpClient.Object);
mockedNfieldConnection
.SetupGet(connection => connection.NfieldServerUri)
.Returns(new Uri(ServiceAddress));
var target = new NfieldFieldworkOfficesService();
target.InitializeNfieldConnection(mockedNfieldConnection.Object);
var actualFieldworkOffices = target.QueryAsync().Result;
Assert.Equal(expectedFieldworkOffices[0].OfficeId, actualFieldworkOffices.ToArray()[0].OfficeId);
Assert.Equal(expectedFieldworkOffices[1].OfficeId, actualFieldworkOffices.ToArray()[1].OfficeId);
Assert.Equal(2, actualFieldworkOffices.Count());
}
public static ITransferContentData TransferData(RawContent masterContentData, params RawContent[] languageContent)
{
var transferData = new Mock<ITransferContentData>();
transferData.SetupGet(x => x.RawContentData).Returns(masterContentData);
transferData.SetupGet(x => x.RawLanguageData).Returns(new List<RawContent>(languageContent));
return transferData.Object;
}
protected CommandMarginControllerTest()
{
_factory = new MockRepository(MockBehavior.Strict);
_marginControl = new CommandMarginControl();
_marginControl.CommandLineTextBox.Text = String.Empty;
_search = _factory.Create<IIncrementalSearch>();
_search.SetupGet(x => x.InSearch).Returns(false);
_search.SetupGet(x => x.InPasteWait).Returns(false);
_vimBuffer = new MockVimBuffer();
_vimBuffer.IncrementalSearchImpl = _search.Object;
_vimBuffer.VimImpl = MockObjectFactory.CreateVim(factory: _factory).Object;
_vimBuffer.CommandModeImpl = _factory.Create<ICommandMode>(MockBehavior.Loose).Object;
var textBuffer = CreateTextBuffer(new []{""});
_vimBuffer.TextViewImpl = TextEditorFactoryService.CreateTextView(textBuffer);
Mock<IVimGlobalSettings> globalSettings = new Mock<IVimGlobalSettings>();
_vimBuffer.GlobalSettingsImpl = globalSettings.Object;
var editorFormatMap = _factory.Create<IEditorFormatMap>(MockBehavior.Loose);
editorFormatMap.Setup(x => x.GetProperties(It.IsAny<string>())).Returns(new ResourceDictionary());
var parentVisualElement = _factory.Create<FrameworkElement>();
_controller = new CommandMarginController(
_vimBuffer,
parentVisualElement.Object,
_marginControl,
VimEditorHost.EditorFormatMapService.GetEditorFormatMap(_vimBuffer.TextView),
VimEditorHost.ClassificationFormatMapService.GetClassificationFormatMap(_vimBuffer.TextView));
}
public void Setup()
{
_principal = new Mock<IPrincipal>();
_httpContext = new Mock<HttpContextBase>();
_httpContext.Setup(x => x.User).Returns(_principal.Object);
_volunteerService = new Mock<IVolunteerService>();
_cluster = new Mock<ICluster>();
_webSecurity = new Mock<IWebSecurityWrapper>();
_webSecurity.SetupGet(x => x.CurrentUserId).Returns(42);
_messageService = new Mock<IMessageService>();
var request = new Mock<HttpRequestBase>();
request.SetupGet(x => x.Url).Returns(new Uri("http://localhost/"));
_httpContext.Setup(ctx => ctx.Request).Returns(request.Object);
_httpContext.SetupGet(x => x.Request).Returns(request.Object);
var response = new Mock<HttpResponseBase>();
response.Setup(x => x.ApplyAppPathModifier(It.IsAny<string>())).Returns<string>(x => x);
_httpContext.Setup(ctx => ctx.Response).Returns(response.Object);
_httpContext.SetupGet(x => x.Response).Returns(response.Object);
var reqContext = new RequestContext(_httpContext.Object, new RouteData());
_controllerUnderTest = new AccountController(_volunteerService.Object, _cluster.Object, _webSecurity.Object, _messageService.Object);
_controllerUnderTest.ControllerContext = new ControllerContext(reqContext, _controllerUnderTest);
_routeCollection = new RouteCollection();
RouteConfig.RegisterRoutes(_routeCollection);
_controllerUnderTest.Url = new UrlHelper(reqContext, _routeCollection);
}
public void AnErrorIsIssuedIfTheMainMethodIsNotImplementedAsANormalMethod()
{
var type = CreateMockTypeDefinition("MyClass");
var main = new Mock<IMethod>(MockBehavior.Strict);
main.SetupGet(_ => _.DeclaringTypeDefinition).Returns(type);
main.SetupGet(_ => _.Name).Returns("Main");
main.SetupGet(_ => _.FullName).Returns("MyClass.Main");
main.SetupGet(_ => _.Parameters).Returns(EmptyList<IParameter>.Instance);
main.SetupGet(_ => _.Region).Returns(DomRegion.Empty);
var er = new MockErrorReporter();
Process(
new[] {
new JsClass(type, JsClass.ClassTypeEnum.Class, null, null, null) {
StaticMethods = { new JsMethod(main.Object, "$Main", new string[0], JsExpression.FunctionDefinition(new string[0], new JsExpressionStatement(JsExpression.Identifier("X")))) }
}
},
new MockScriptSharpMetadataImporter() { GetMethodSemantics = m => ReferenceEquals(m, main.Object) ? MethodScriptSemantics.InlineCode("X") : MethodScriptSemantics.NormalMethod("$" + m.Name) },
er,
main.Object
);
Assert.That(er.AllMessages, Has.Count.EqualTo(1));
Assert.That(er.AllMessages.Any(m => m.Code == 7801 && (string)m.Args[0] == "MyClass.Main"));
}
public void Start_WhenInputFormatIsValidAddToShoppingCartCommand_ShouldAddProductToTheShoppingCart()
{
//Arrange
var productName = "Fa Shampoo";
var mockedFactory = new Mock<ICosmeticsFactory>();
var mockedShoppingCart = new Mock<IShoppingCart>();
var mockedCommandParser = new Mock<ICommandParser>();
var mockedCommand = new Mock<ICommand>();
var mockedProduct = new Mock<IProduct>();
mockedCommand.SetupGet(x => x.Name).Returns("AddToShoppingCart");
mockedCommand.SetupGet(x => x.Parameters).Returns(new List<string>() { productName });
mockedCommandParser.Setup(p => p.ReadCommands()).Returns(() => new List<ICommand>() { mockedCommand.Object });
var engine = new MockedCosmeticsEngine(mockedFactory.Object, mockedShoppingCart.Object, mockedCommandParser.Object);
engine.Products.Add(productName, mockedProduct.Object);
//Act
engine.Start();
//Assert
mockedShoppingCart.Verify(x => x.AddProduct(mockedProduct.Object), Times.Once);
}
public void CancelledTaskHandledinServerSentEvents()
{
var tcs = new TaskCompletionSource<IResponse>();
tcs.TrySetCanceled();
var httpClient = new Mock<IHttpClient>();
var connection = new Mock<IConnection>();
httpClient.Setup(c => c.Get(It.IsAny<string>(), It.IsAny<Action<IRequest>>(), It.IsAny<bool>()))
.Returns<string, Action<IRequest>, bool>((url, prepareRequest, isLongRunning) =>
{
prepareRequest(Mock.Of<IRequest>());
return tcs.Task;
});
connection.SetupGet(c => c.ConnectionToken).Returns("foo");
connection.SetupGet(c => c.TotalTransportConnectTimeout).Returns(TimeSpan.FromSeconds(15));
var sse = new ServerSentEventsTransport(httpClient.Object);
var exception = Assert.Throws<AggregateException>(
() => sse.Start(connection.Object, string.Empty, CancellationToken.None).Wait(TimeSpan.FromSeconds(5)));
Assert.IsType(typeof(OperationCanceledException), exception.InnerException);
}
private void MockSecurityDataContext()
{
_MockSecurityDataContext = new Mock<ISecurityDataContext>();
_MockSecurityDataContext.SetupGet(c => c.Computers).Returns(CreateComputers());
_MockSecurityDataContext.SetupGet(c => c.Rooms).Returns(CreateRooms());
}
private IAppConfiguration GetConfiguration()
{
var mockConfiguration = new Mock<IAppConfiguration>();
mockConfiguration.SetupGet(c => c.ServiceDiscoveryUri).Returns(new Uri("https://api.nuget.org/v3/index.json"));
mockConfiguration.SetupGet(c => c.AutocompleteServiceResourceType).Returns("SearchAutocompleteService/3.0.0-rc");
return mockConfiguration.Object;
}
public async Task When_registering_session_with_no_projectApiKey_set()
{
//Arrange
var configurationMock = new Mock<IConfiguration>(MockBehavior.Strict);
configurationMock.SetupGet(x => x.ProjectApiKey).Returns((string)null);
configurationMock.SetupGet(x => x.Session.Environment).Returns("Test");
configurationMock.SetupGet(x => x.Target.Location).Returns("http://localhost");
configurationMock.SetupGet(x => x.AllowMultipleInstances).Returns(true);
var webApiClientMock = new Mock<IWebApiClient>(MockBehavior.Strict);
webApiClientMock.Setup(x => x.CreateAsync<SessionRequest, SessionResponse>(It.IsAny<string>(), It.IsAny<SessionRequest>())).Returns(Task.FromResult(default(SessionResponse)));
var session = Register_session_setup.GivenThereIsASession(webApiClientMock, configurationMock, null, null);
ExpectedIssues.ProjectApiKeyNotSetException exception = null;
SessionResult result = null;
//Act
try
{
result = await session.RegisterAsync();
}
catch (ExpectedIssues.ProjectApiKeyNotSetException exp)
{
exception = exp;
}
//Assert
Assert.That(exception, Is.Not.Null);
Assert.That(result, Is.Null);
webApiClientMock.Verify(x => x.CreateAsync<SessionRequest, SessionResponse>(It.IsAny<string>(), It.IsAny<SessionRequest>()), Times.Never);
}
public void Initialize()
{
_dataCollector = new Mock<IDataCollector>();
_setter = new ContextVariablesSetter(_dataCollector.Object, true);
_containerProvider = new Mock<IDIContainerProvider>();
_environment = new Mock<IEnvironment>();
_languageManagerProvider = new Mock<ILanguageManagerProvider>();
_languageManager = new Mock<ILanguageManager>();
_contextProvider = new Mock<IAcspNetContextProvider>();
_context = new Mock<IAcspNetContext>();
_stringTable = new Mock<IStringTable>();
_stopwatchProvider = new Mock<IStopwatchProvider>();
_dataCollector.SetupGet(x => x.TitleVariableName).Returns("Title");
_environment.SetupGet(x => x.TemplatesPath).Returns("Templates");
_environment.SetupGet(x => x.SiteStyle).Returns("Main");
_languageManager.SetupGet(x => x.Language).Returns("ru");
_languageManagerProvider.Setup(x => x.Get()).Returns(_languageManager.Object);
_context.SetupGet(x => x.SiteUrl).Returns("http://localhost/mysite/");
_context.SetupGet(x => x.VirtualPath).Returns("/mysite");
_contextProvider.Setup(x => x.Get()).Returns(_context.Object);
_context.SetupGet(x => x.Request.PathBase).Returns(new PathString("/mysite"));
_stopwatchProvider.Setup(x => x.StopAndGetMeasurement()).Returns(new TimeSpan(0, 0, 1, 15, 342));
_containerProvider.Setup(x => x.Resolve(It.Is<Type>(d => d == typeof(IEnvironment)))).Returns(_environment.Object);
_containerProvider.Setup(x => x.Resolve(It.Is<Type>(d => d == typeof(ILanguageManagerProvider)))).Returns(_languageManagerProvider.Object);
_containerProvider.Setup(x => x.Resolve(It.Is<Type>(d => d == typeof(IAcspNetContextProvider)))).Returns(_contextProvider.Object);
_containerProvider.Setup(x => x.Resolve(It.Is<Type>(d => d == typeof(IStringTable)))).Returns(_stringTable.Object);
_containerProvider.Setup(x => x.Resolve(It.Is<Type>(d => d == typeof(IStopwatchProvider)))).Returns(_stopwatchProvider.Object);
}
public void RequireHttpsAttributeDoesNotThrowForInsecureConnectionIfNotAuthenticatedOrForcingSSLAndOnlyWhenAuthenticatedSet()
{
// Arrange
var mockAuthContext = new Mock<AuthorizationContext>(MockBehavior.Strict);
var mockConfig = new Mock<IAppConfiguration>();
var mockFormsAuth = new Mock<IFormsAuthenticationService>();
mockConfig.Setup(cfg => cfg.RequireSSL).Returns(true);
mockAuthContext.SetupGet(c => c.HttpContext.Request.IsSecureConnection).Returns(false);
mockAuthContext.SetupGet(c => c.HttpContext.Request.IsAuthenticated).Returns(false);
var context = mockAuthContext.Object;
mockFormsAuth.Setup(fas => fas.ShouldForceSSL(context.HttpContext)).Returns(false);
var attribute = new RequireRemoteHttpsAttribute()
{
Configuration = mockConfig.Object,
OnlyWhenAuthenticated = true,
FormsAuthentication = mockFormsAuth.Object
};
var result = new ViewResult();
context.Result = result;
// Act
attribute.OnAuthorization(context);
// Assert
Assert.Same(result, context.Result);
}
public void HandleTest()
{
string pageName = "search";
byte[] content = Encoding.UTF8.GetBytes("<html><body>Search me</body></html>");
MockResourceRepository resourceRepository = new MockResourceRepository();
resourceRepository.LoadResource(pageName, content);
HtmlPage target = new HtmlPage();
var request = new Mock<IServiceRequest>();
request.SetupGet(x => x.ResourceName).Returns(pageName);
request.SetupGet(x => x.Extension).Returns("");
request.SetupGet(x => x.Query).Returns("");
var response = new Mock<IServiceResponse>();
response.SetupProperty(x => x.ContentType);
response.SetupProperty(x => x.StatusCode);
MemoryStream contentStream = new MemoryStream();
response.SetupGet(x => x.ContentStream).Returns(contentStream);
target.Handle(request.Object, response.Object, resourceRepository);
Assert.AreEqual("text/html", response.Object.ContentType);
Assert.AreEqual(200, response.Object.StatusCode);
byte[] actualContent = contentStream.ToArray();
Assert.AreEqual(content.Length, actualContent.Length);
for (int i = 0; i < content.Length; i++)
{
Assert.AreEqual(content[i], actualContent[i]);
}
}
public void should_return_base_eneryg_plus_any_equiped_items_that_affect_energy()
{
Guid userId = Guid.NewGuid();
//given user that exists
_userRetriever.Setup(s => s.UserExists(userId)).Returns(true);
//and a base energy of 100
_userRetriever.Setup(s => s.GetCurrentBaseEnergy(userId)).Returns(100);
//and the following equipment, one of which is one time, one of which is not
List<IItem> items = new List<IItem>();
Mock<IItem> item = new Mock<IItem>();
item.SetupGet(s => s.Energy).Returns(20);
item.SetupGet(s => s.IsOneTimeUse).Returns(true);
items.Add(item.Object);
item = new Mock<IItem>();
item.SetupGet(s => s.Energy).Returns(10);
items.Add(item.Object);
_userItemRetriever.Setup(s => s.GetUserItems(userId)).Returns(items);
//should return 110 for base energy which excludes one time use
int energy = _userEnergyProvider.GetUserMaxEnergy(userId);
Assert.AreEqual(110, energy);
}
public void CheckUnlockStatus_EveryIAchievementConditionIsUnlocked_ShouldFireAchievementCompletedEvent()
{
// Arrange
Mock<IAchievementCondition> achievementConditionMock1 = new Mock<IAchievementCondition>();
achievementConditionMock1.SetupGet(x => x.Unlocked).Returns(true);
achievementConditionMock1.SetupGet(x => x.UniqueId).Returns("ac1");
Mock<IAchievementCondition> achievementConditionMock2 = new Mock<IAchievementCondition>();
achievementConditionMock2.SetupGet(x => x.Unlocked).Returns(true);
achievementConditionMock2.SetupGet(x => x.UniqueId).Returns("ac2");
Mock<IAchievementCondition> achievementConditionMock3 = new Mock<IAchievementCondition>();
achievementConditionMock3.SetupGet(x => x.Unlocked).Returns(true);
achievementConditionMock3.SetupGet(x => x.UniqueId).Returns("ac3");
List<IAchievementCondition> achievementConditions = new List<IAchievementCondition>
{
achievementConditionMock1.Object,
achievementConditionMock2.Object,
achievementConditionMock3.Object
};
Achievement achievement = new Achievement("uniqueId", "titel", "description", achievementConditions);
Achievement reportedAchievement = null;
achievement.AchievementCompleted += delegate(Achievement a) { reportedAchievement = a; };
// Act
achievement.CheckUnlockStatus();
// Assert
Assert.AreEqual(achievement, reportedAchievement);
Assert.IsTrue(achievement.Unlocked);
}
[InlineData(44300, "{0}:44300")] // Non-standard Port, Authenticated, always force SSL for this action
public void RequireHttpsAttributeRedirectsGetRequest(int port, string hostFormatter)
{
// Arrange
var mockAuthContext = new Mock<AuthorizationContext>(MockBehavior.Strict);
var mockConfig = new Mock<IAppConfiguration>();
var mockFormsAuth = new Mock<IFormsAuthenticationService>();
mockAuthContext.SetupGet(c => c.HttpContext.Request.HttpMethod).Returns("get");
mockAuthContext.SetupGet(c => c.HttpContext.Request.Url).Returns(new Uri("http://test.nuget.org/login"));
mockAuthContext.SetupGet(c => c.HttpContext.Request.RawUrl).Returns("/login");
mockAuthContext.SetupGet(c => c.HttpContext.Request.IsSecureConnection).Returns(false);
mockConfig.Setup(cfg => cfg.RequireSSL).Returns(true);
mockConfig.Setup(cfg => cfg.SSLPort).Returns(port);
var attribute = new RequireSslAttribute()
{
Configuration = mockConfig.Object
};
var result = new ViewResult();
var context = mockAuthContext.Object;
// Act
attribute.OnAuthorization(context);
// Assert
Assert.IsType<RedirectResult>(context.Result);
Assert.Equal("https://" + String.Format(hostFormatter, "test.nuget.org") + "/login", ((RedirectResult)context.Result).Url);
}
public AccountControllerTests()
{
WebSecurity = new Mock<IWebSecurity>(MockBehavior.Strict);
OAuthWebSecurity = new Mock<IOAuthWebSecurity>(MockBehavior.Strict);
Identity = new Mock<IIdentity>(MockBehavior.Strict);
User = new Mock<IPrincipal>(MockBehavior.Strict);
User.SetupGet(u => u.Identity).Returns(Identity.Object);
WebSecurity.SetupGet(w => w.CurrentUser).Returns(User.Object);
Routes = new RouteCollection();
RouteConfig.RegisterRoutes(Routes);
Request = new Mock<HttpRequestBase>(MockBehavior.Strict);
Request.SetupGet(x => x.ApplicationPath).Returns("/");
Request.SetupGet(x => x.Url).Returns(new Uri("http://localhost/a", UriKind.Absolute));
Request.SetupGet(x => x.ServerVariables).Returns(new System.Collections.Specialized.NameValueCollection());
Response = new Mock<HttpResponseBase>(MockBehavior.Strict);
Context = new Mock<HttpContextBase>(MockBehavior.Strict);
Context.SetupGet(x => x.Request).Returns(Request.Object);
Context.SetupGet(x => x.Response).Returns(Response.Object);
Controller = new AccountController(WebSecurity.Object, OAuthWebSecurity.Object);
Controller.ControllerContext = new ControllerContext(Context.Object, new RouteData(), Controller);
Controller.Url = new UrlHelper(new RequestContext(Context.Object, new RouteData()), Routes);
}
public void MiniDumpDeleteOnCloseTests()
{
// Arrange
var path = @"x:\temp\minidump.dmp";
var fileSystem = new Mock<IFileSystem>();
var file = new Mock<FileBase>();
var fileInfoFactory = new Mock<IFileInfoFactory>();
var fileInfo = new Mock<FileInfoBase>();
// Setup
fileSystem.SetupGet(fs => fs.File)
.Returns(file.Object);
fileSystem.SetupGet(fs => fs.FileInfo)
.Returns(fileInfoFactory.Object);
file.Setup(f => f.Exists(path))
.Returns(true);
file.Setup(f => f.OpenRead(path))
.Returns(() => new MemoryStream());
fileInfoFactory.Setup(f => f.FromFileName(path))
.Returns(() => fileInfo.Object);
fileInfo.Setup(f => f.Exists)
.Returns(true);
FileSystemHelpers.Instance = fileSystem.Object;
// Test
var stream = ProcessController.FileStreamWrapper.OpenRead(path);
stream.Close();
// Assert
fileInfo.Verify(f => f.Delete(), Times.Once());
}
public void BindTest1()
{
var bindingToSyntax = new Mock<IBindingToSyntax<object>>(MockBehavior.Loose);
var bindingNamed = new Mock<IBindingWhenInNamedWithOrOnSyntax<object>>(MockBehavior.Loose);
var bInfo = new Mock<IBindInfo>(MockBehavior.Loose);
var scopeBinder = new Mock<IScopeBinder>(MockBehavior.Loose);
var scoped = new Mock<IBindingNamedWithOrOnSyntax<object>>(MockBehavior.Loose);
var typesFrom = new List<Type>();
var typeTo = typeof (string);
var bindingScope = new BindingScope("sdrjklgnlsdjkg");
bindingToSyntax.Name = "bindingToSyntax";
bindingNamed.Name = "bindingNamed";
bInfo.Name = "bInfo";
scopeBinder.Name = "scopeBinder";
scoped.Name = "scoped";
bInfo.SetupGet(x => x.From).Returns(typesFrom).Verifiable();
bInfo.SetupGet(x => x.To).Returns(typeTo).Verifiable();
bInfo.SetupGet(x => x.Scope).Returns(bindingScope).Verifiable();
bInfo.SetupGet(x => x.Name).Returns((string)null).Verifiable();
bindingNamed.Setup(x => x.GetHashCode()).Returns(100.GetHashCode()).Verifiable();
bindingNamed.Setup(x => x.ToString()).Returns("100").Verifiable();
scopeBinder.Setup(x => x.InScope(bindingNamed.Object, bindingScope)).Returns(scoped.Object).Verifiable();
bindingToSyntax.Setup(x => x.To(typeTo)).Returns(bindingNamed.Object).Verifiable();
new NinjectBinder(types => bindingToSyntax.Object, scopeBinder.Object).Bind(new[] {bInfo.Object});
}
private ControllerContext GetControllerContext(Controller target, bool isAjax)
{
Mock <HttpRequestBase> mockHttpRequest = new Mock <HttpRequestBase>();
if (isAjax)
{
mockHttpRequest.SetupGet(x => x.Headers).Returns(new WebHeaderCollection()
{
"X-Requested-With:XMLHttpRequest"
});
}
else
{
mockHttpRequest.SetupGet(x => x.Headers).Returns(new WebHeaderCollection()
{
"X-Requested-With:"
});
}
Mock <HttpContextBase> mockHttpContext = new Mock <HttpContextBase>();
mockHttpContext.SetupGet(x => x.Request).Returns(mockHttpRequest.Object);
return(new ControllerContext(mockHttpContext.Object, new RouteData(), target));
}
public void NotifySpamStory_Should_Send_Spamed_Story_Details()
{
const string mailTemplate = "Title: <%=title%>" +
"Site Url: <%=siteUrl%>" +
"Original Url: <%=originalUrl%>" +
"User: <%=userName%>";
var user = new Mock <IUser>();
user.SetupGet(u => u.UserName).Returns("Dummy user");
var story = new Mock <IStory>();
story.SetupGet(s => s.Title).Returns("A dummy story");
story.SetupGet(s => s.Url).Returns("http://www.dummystory.com");
story.SetupGet(s => s.PostedBy).Returns(user.Object);
_file.Setup(f => f.ReadAllText(It.IsAny <string>())).Returns(mailTemplate).Verifiable();
_emailSender.NotifySpamStory("http://dotnetshoutout.com/The-Dummy_Story", story.Object, "foo");
Sleep();
}
public void FindTest()
{
Mock <IProjectConfigurationManagement> _projectConfigurationMock = new Mock <IProjectConfigurationManagement>();
Mock <OPCFModelDesign> _OPCFModelDesignMock = new Mock <OPCFModelDesign>();
_projectConfigurationMock.SetupGet <OPCFModelDesign>(x => x.ModelDesign).Returns(_OPCFModelDesignMock.Object);
_projectConfigurationMock.SetupGet <string>(x => x.Name).Returns("EFFF0C05 - 8406 - 4AD9 - 8725 - F00FC8295327");
Mock <BaseTreeNode> _parentMock = new Mock <BaseTreeNode>("ParentBaseNode");
_parentMock.SetupGet <string[]>(x => x.AvailiableNamespaces).Returns(new List <string>()
{
"ns1", "ns2"
}.ToArray());
ProjectTreeNode _newItem = new ProjectTreeNode(_projectConfigurationMock.Object)
{
Parent = _parentMock.Object
};
XmlQualifiedName _toFind = new XmlQualifiedName("Name", "Namespace");
ITypeDesign _findReturn = _newItem.Find(_toFind);
Assert.IsNull(_findReturn);
}
public async void BulkInsert_Errors()
{
VehCapabilityControllerMockFacade mock = new VehCapabilityControllerMockFacade();
var mockResponse = new Mock <CreateResponse <ApiVehCapabilityServerResponseModel> >(null as ApiVehCapabilityServerResponseModel);
mockResponse.SetupGet(x => x.Success).Returns(false);
mock.ServiceMock.Setup(x => x.Create(It.IsAny <ApiVehCapabilityServerRequestModel>())).Returns(Task.FromResult <CreateResponse <ApiVehCapabilityServerResponseModel> >(mockResponse.Object));
VehCapabilityController controller = new VehCapabilityController(mock.ApiSettingsMoc.Object, mock.LoggerMock.Object, mock.TransactionCoordinatorMock.Object, mock.ServiceMock.Object, mock.ModelMapperMock.Object);
controller.ControllerContext = new ControllerContext();
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var records = new List <ApiVehCapabilityServerRequestModel>();
records.Add(new ApiVehCapabilityServerRequestModel());
IActionResult response = await controller.BulkInsert(records);
response.Should().BeOfType <ObjectResult>();
(response as ObjectResult).StatusCode.Should().Be((int)HttpStatusCode.UnprocessableEntity);
mock.ServiceMock.Verify(x => x.Create(It.IsAny <ApiVehCapabilityServerRequestModel>()));
}
private ServiceModelServiceMethodProvider <TService> CreateSut <TService>()
where TService : class
{
var rootConfiguration = new Mock <IOptions <ServiceModelGrpcServiceOptions> >(MockBehavior.Strict);
rootConfiguration
.SetupGet(c => c.Value)
.Returns(new ServiceModelGrpcServiceOptions());
var serviceConfiguration = new Mock <IOptions <ServiceModelGrpcServiceOptions <TService> > >(MockBehavior.Strict);
serviceConfiguration
.SetupGet(c => c.Value)
.Returns(new ServiceModelGrpcServiceOptions <TService>());
var logger = new Mock <ILogger <ServiceModelServiceMethodProvider <TService> > >(MockBehavior.Strict);
return(new ServiceModelServiceMethodProvider <TService>(
rootConfiguration.Object,
serviceConfiguration.Object,
logger.Object,
_serviceProvider.Object));
}
public void DoesNotIncludeIgnoredColumns()
{
Mock <IPropertyMap> property1 = new Mock <IPropertyMap>();
property1.SetupGet(p => p.SelectIgnored).Returns(true).Verifiable();
Mock <IPropertyMap> property2 = new Mock <IPropertyMap>();
var properties = new List <IPropertyMap>
{
property1.Object,
property2.Object
};
Generator.Setup(g => g.GetColumnName(ClassMap.Object, property2.Object, true)).Returns("Column2").Verifiable();
ClassMap.SetupGet(c => c.Properties).Returns(properties).Verifiable();
var result = Generator.Object.BuildSelectColumns(ClassMap.Object);
Assert.AreEqual("Column2", result);
ClassMap.Verify();
Generator.Verify();
Generator.Verify(g => g.GetColumnName(ClassMap.Object, property1.Object, true), Times.Never());
property1.Verify();
}
public static void GetPackageReferencesMarkedForReinstallationReturnsEmptyListWhenNuGetIsNotInUseInAProject()
{
// Arrange
Mock<Project> mockProject = new Mock<Project>();
mockProject.SetupGet(p => p.FullName).Returns(@"c:\a\b\c.csproj");
// Setup project kind to a supported value. This makes sure that the check for existence of packages.config happens
mockProject.Setup(p => p.Kind).Returns(CsharpProjectTypeGuid);
var mockServices = new Dictionary<Type, object>();
Mock<IVsSolution> mockSolution = new Mock<IVsSolution>();
mockServices.Add(typeof(IVsSolution), mockSolution.Object);
Mock<IVsHierarchy> mockHier = new Mock<IVsHierarchy>();
IVsHierarchy hier = mockHier.Object;
mockSolution.Setup(m => m.GetProjectOfUniqueName(It.IsAny<string>(), out hier)).Returns(0);
ServiceLocator.TestServiceCache = mockServices;
// Act
var packagesToBeReinstalled = ProjectRetargetingUtility.GetPackageReferencesMarkedForReinstallation(mockProject.Object);
// Assert
Assert.True(packagesToBeReinstalled.IsEmpty());
}
public void AddFileVersionToPath_DoesNotLockFileAfterReading()
{
// Arrange
var stream = new TestableMemoryStream(Encoding.UTF8.GetBytes("Hello World!"));
var mockFile = new Mock <IFileInfo>();
mockFile.SetupGet(f => f.Exists).Returns(true);
mockFile
.Setup(m => m.CreateReadStream())
.Returns(stream);
var fileProvider = new TestFileProvider();
fileProvider.AddFile("/hello/world", mockFile.Object);
var requestPath = GetRequestPathBase();
var fileVersionProvider = GetFileVersionProvider(fileProvider);
// Act
var result = fileVersionProvider.AddFileVersionToPath(requestPath, "/hello/world");
// Assert
Assert.True(stream.Disposed);
}
public async Task ExtendedMediasAreIncludedInInlineMedias()
{
// Arrange
var json = File.ReadAllText("Data/tweet_extmedia.json");
var data = JsonMapper.ToObject(json);
var status = new Status(data);
var context = new Mock <IContextEntry>();
var config = new Mock <IConfig>();
var visualConfig = new VisualConfig {
InlineMedia = true
};
config.SetupGet(c => c.Visual).Returns(visualConfig);
var vm = new StatusViewModel(status, context.Object, config.Object, null);
await vm.LoadDataAsync();
// Act
var medias = vm.InlineMedias.ToArray();
// Assert
Assert.AreEqual(3, medias.Length);
}
public async Task ReturnErrorObject_GivenNoRunningGameIsFound()
{
var mockPhases = new List <Phase>().AsQueryable().BuildMockDbSet();
var dataContext = new Mock <DataContext>();
dataContext.SetupGet(x => x.Phases).Returns(mockPhases.Object);
var requestContext = new RequestContext();
var gameApiServiceLogger = GetMockLogger <GameApiService>().Object;
var gameApiService = new Mock <GameApiService>(dataContext.Object, gameApiServiceLogger, requestContext)
{
CallBase = true
}.Object;
var requestLoggingService = new RequestLoggingService(requestContext, dataContext.Object);
var logger = GetMockLogger <GameStatusController>().Object;
var modController = new GameStatusController(requestContext, gameApiService, requestLoggingService, logger);
var response = await modController.Get();
response.StatusCode.Should().Be(200);
var result = (GameStatusResponse)response.Value;
result.Err.Should().NotBeNull();
result.Err.Description.Should().Be("Game is not running");
}
RandomlyPlaceShip_WHEN_Invoked_THEN_ReturnRandomlyPlacedShip(int length)
{
var mapRepoMock = new Mock <IRepository <Map> >();
var mapWithShips = new Map(10, 10);
mapWithShips.Fields[0][1].Ship = new Ship(4);
mapWithShips.Fields[0][2].Ship = new Ship(4);
mapWithShips.Fields[0][3].Ship = new Ship(4);
mapWithShips.Fields[0][4].Ship = new Ship(4);
mapWithShips.Fields[0][0].Ship = new Ship(4);
mapWithShips.Fields[1][0].Ship = new Ship(4);
mapWithShips.Fields[2][0].Ship = new Ship(4);
mapWithShips.Fields[3][0].Ship = new Ship(4);
mapRepoMock.SetupGet(c => c.Entity).Returns(new Map(10, 10));
var shipService = new ShipService(mapRepoMock.Object);
var result = shipService.RandomlyPlaceShip(length);
result.Success.Should().BeTrue();
result.Ship.Should().NotBeNull();
result.Ship.Coordinates.Count.Should().Be(length);
}
public void SearchParameterLocator_LocateHelper_Succeeds()
{
Mock<ICode> code = new Mock<ICode>();
byte[] codeBytes = new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09 };
code.SetupGet(x => x.CodeBytes).Returns(codeBytes);
DefaultParameterLocator locator = new DefaultParameterLocator(code.Object);
PrivateObject privateObjectHelper = new PrivateObject(locator);
const int PARAMETER_OFFSET = 2;
int outIndex = 1;
List<Type> parameterTypes = new List<Type>() { typeof(ParameterType), typeof(byte[]), typeof(int), typeof(ParameterOffsetDirection), typeof(int).MakeByRefType() };
List<Object> parameterValuesBefore = new List<Object>() { ParameterType.Undefined, new byte[] { 0x04, 0x05 }, PARAMETER_OFFSET, ParameterOffsetDirection.Before, outIndex };
List<Object> parameterValuesAfter = new List<Object>() { ParameterType.Undefined, new byte[] { 0x04, 0x05 }, PARAMETER_OFFSET, ParameterOffsetDirection.After, outIndex };
List<Type> typeArguments = new List<Type>() { typeof(UInt16) };
UInt16 resultBefore = (UInt16)privateObjectHelper.Invoke("LocateHelper", parameterTypes.ToArray(), parameterValuesBefore.ToArray(), typeArguments.ToArray());
Assert.AreEqual(0x0203, resultBefore);
UInt16 resultAfter = (UInt16)privateObjectHelper.Invoke("LocateHelper", parameterTypes.ToArray(), parameterValuesAfter.ToArray(), typeArguments.ToArray());
Assert.AreEqual(0x0708, resultAfter);
}
public void GetUrlHelper_CreatesNewInstance_IfExpectedTypeIsNotPresent()
{
// Arrange
var httpContext = new Mock <HttpContext>();
httpContext.SetupGet(h => h.Features).Returns(new FeatureCollection());
var mockItems = new Dictionary <object, object>
{
{ typeof(IUrlHelper), null }
};
httpContext.Setup(h => h.Items).Returns(mockItems);
var actionContext = CreateActionContext(httpContext.Object);
var urlHelperFactory = new UrlHelperFactory();
// Act
var urlHelper = urlHelperFactory.GetUrlHelper(actionContext);
// Assert
Assert.NotNull(urlHelper);
Assert.Same(urlHelper, actionContext.HttpContext.Items[typeof(IUrlHelper)] as IUrlHelper);
}
public void AddMvcCore_GetsPartsForApplication()
{
// Arrange
var services = new ServiceCollection();
var environment = new Mock <IWebHostEnvironment>();
var assemblyName = typeof(MvcCoreServiceCollectionExtensionsTest).Assembly.GetName();
var applicationName = assemblyName.FullName;
environment.SetupGet(e => e.ApplicationName).Returns(applicationName).Verifiable();
services.AddSingleton <IWebHostEnvironment>(environment.Object);
// Act
var builder = services.AddMvcCore();
// Assert
Assert.NotNull(builder.PartManager);
Assert.Contains(
builder.PartManager.ApplicationParts,
part => string.Equals(assemblyName.Name, part.Name, StringComparison.Ordinal));
Assert.Contains(builder.PartManager.FeatureProviders, provider => provider is ControllerFeatureProvider);
environment.VerifyAll();
}
protected override void Arrange()
{
_documentData = new DocumentData();
_graphicsMock = new Mock <IGraphics>(MockBehavior.Strict);
_renderDataMock = new Mock <IRenderData>(MockBehavior.Strict);
_referencePoint = new ReferencePoint();
_renderDataMock = new Mock <IRenderData>(MockBehavior.Strict);
_renderDataMock.Setup(x => x.ParentBounds).Returns(It.IsAny <XRect>());
_renderDataMock.Setup(x => x.Graphics).Returns(_graphicsMock.Object);
_renderDataMock.Setup(x => x.Section).Returns(new Section());
_renderDataMock.Setup(x => x.DocumentData).Returns(_documentData);
_renderDataMock.Setup(x => x.PageNumberInfo).Returns(new PageNumberInfo(1, 1));
_renderDataMock.Setup(x => x.DebugData).Returns((IDebugData)null);
_renderDataMock.Setup(x => x.IncludeBackground).Returns(false);
_renderDataMock.Setup(x => x.ElementBounds).Returns(It.IsAny <XRect>());
_renderDataMock.SetupSet(x => x.ElementBounds = It.IsAny <XRect>());
_renderDataMock.SetupGet(x => x.DocumentProperties).Returns(Mock.Of <DocumentProperties>());
_referencePoint.PreRender(_renderDataMock.Object);
}
public void RequireHttpsAttributeDoesNotThrowForSecureConnection()
{
// Arrange
var mockAuthContext = new Mock <AuthorizationContext>(MockBehavior.Strict);
var mockConfig = new Mock <IAppConfiguration>();
mockConfig.Setup(cfg => cfg.RequireSSL).Returns(true);
mockAuthContext.SetupGet(c => c.HttpContext.Request.IsSecureConnection).Returns(true);
var context = mockAuthContext.Object;
var attribute = new RequireSslAttribute()
{
Configuration = mockConfig.Object
};
var result = new ViewResult();
context.Result = result;
// Act
attribute.OnAuthorization(context);
// Assert
Assert.Same(result, context.Result);
}
private static IProperty CreateProperty(string name, object value, List <object> setValues = null)
{
var property = new Mock <IProperty>(MockBehavior.Strict);
property.SetupGet(o => o.Name)
.Returns(name);
property.Setup(o => o.GetValueAsync())
.ReturnsAsync(value);
property.As <IEvaluatedProperty>().Setup(p => p.GetEvaluatedValueAtEndAsync()).ReturnsAsync(value.ToString());
property.As <IEvaluatedProperty>().Setup(p => p.GetEvaluatedValueAsync()).ReturnsAsync(value.ToString());
if (setValues != null)
{
property
.Setup(p => p.SetValueAsync(It.IsAny <object>()))
.Callback <object>(obj => setValues.Add(obj))
.Returns(() => Task.CompletedTask);
}
return(property.Object);
}
public void GetUrlHelper_ReturnsSameInstance_IfAlreadyPresent()
{
// Arrange
var expectedUrlHelper = CreateUrlHelper();
var httpContext = new Mock <HttpContext>();
httpContext.SetupGet(h => h.Features).Returns(new FeatureCollection());
var mockItems = new Dictionary <object, object>
{
{ typeof(IUrlHelper), expectedUrlHelper }
};
httpContext.Setup(h => h.Items).Returns(mockItems);
var actionContext = CreateActionContext(httpContext.Object);
var urlHelperFactory = new UrlHelperFactory();
// Act
var urlHelper = urlHelperFactory.GetUrlHelper(actionContext);
// Assert
Assert.Same(expectedUrlHelper, urlHelper);
}
public async Task DownloadsInBlocksWhenOverTheLimit()
{
MemoryStream stream = new MemoryStream();
MockDataSource dataSource = new MockDataSource(100);
Mock <BlobBaseClient> blockClient = new Mock <BlobBaseClient>(MockBehavior.Strict, new Uri("http://mock"), new BlobClientOptions());
blockClient.SetupGet(c => c.ClientConfiguration).CallBase();
SetupDownload(blockClient, dataSource);
PartitionedDownloader downloader = new PartitionedDownloader(
blockClient.Object,
new StorageTransferOptions()
{
MaximumTransferLength = 10,
InitialTransferLength = 20
});
Response result = await InvokeDownloadToAsync(downloader, stream);
Assert.AreEqual(dataSource.Requests.Count, 9);
AssertContent(100, stream);
Assert.NotNull(result);
}
public void RendererIsDisposed()
{
using (Start())
{
var renderer = new Mock <IRenderer>();
renderer.Setup(x => x.Dispose());
var impl = new Mock <IWindowImpl>();
impl.SetupGet(x => x.RenderScaling).Returns(1);
impl.SetupProperty(x => x.Closed);
impl.Setup(x => x.CreateRenderer(It.IsAny <IRenderRoot>())).Returns(renderer.Object);
impl.Setup(x => x.Dispose()).Callback(() => impl.Object.Closed());
AvaloniaLocator.CurrentMutable.Bind <IWindowingPlatform>()
.ToConstant(new MockWindowingPlatform(() => impl.Object));
var window = new Window()
{
Content = new Button()
};
window.Show();
window.Close();
renderer.Verify(r => r.Dispose());
}
}
public void ModuleSettingsPresenter_SaveSettings_Saves_ModuleSettings()
{
// Arrange
var view = new Mock<ISettingsView<SettingsModel>>();
view.SetupGet(v => v.Model).Returns(new SettingsModel());
var controller = new Mock<IModuleController>();
var presenter = new TestSettingsPresenter(view.Object) { ModuleContext = this.CreateModuleContext() };
presenter.IsPostBack = true;
view.Raise(v => v.Load += null, EventArgs.Empty);
// Act
view.Raise(v => v.OnSaveSettings += null, EventArgs.Empty);
// Assert
foreach (var setting in view.Object.Model.ModuleSettings)
{
var key = setting.Key;
var value = setting.Value;
controller.Verify(c => c.UpdateModuleSetting(It.IsAny<int>(), key, value), Times.Once());
}
}
private static HttpContext GetHttpContext(string appRoot,
string contentPath,
string expectedPath,
HttpResponse response)
{
var httpContext = new Mock <HttpContext>();
var actionContext = GetActionContext(httpContext.Object);
var mockContentAccessor = new Mock <IContextAccessor <ActionContext> >();
mockContentAccessor.SetupGet(o => o.Value).Returns(actionContext);
var mockActionSelector = new Mock <IActionSelector>();
var urlHelper = new UrlHelper(mockContentAccessor.Object, mockActionSelector.Object);
var serviceProvider = GetServiceProvider(urlHelper);
httpContext.Setup(o => o.Response)
.Returns(response);
httpContext.SetupGet(o => o.RequestServices)
.Returns(serviceProvider);
httpContext.Setup(o => o.Request.PathBase)
.Returns(new PathString(appRoot));
return(httpContext.Object);
}
public void TestValidateItemAsList()
{
var element = new BaseElement();
var parentElement = new BaseElement();
var listMock = new Mock <IElementList <BaseElement, BaseElement> >(MockBehavior.Strict);
listMock.SetupGet(l => l.Parent).Returns(parentElement);
var pageBase = new Mock <IPageElementHandler <BaseElement> >(MockBehavior.Strict);
pageBase.Setup(p => p.GetElementText(parentElement)).Returns("My Data");
var propertyData = CreatePropertyData(pageBase, element, (p, f) => f(listMock.Object));
string actualValue;
var result = propertyData.ValidateItem(ItemValidationHelper.Create("MyProperty", "My Data"), out actualValue);
Assert.IsTrue(result);
pageBase.VerifyAll();
listMock.VerifyAll();
}
public async Task TestCreateTokenClient()
{
var mockApp = new Mock <IAssemblyInformationProvider>();
mockApp.SetupGet(x => x.ProductInfoHeaderValue).Returns(new ProductInfoHeaderValue("TGSTests", "1.2.3")).Verifiable();
var mockOptions = new Mock <IOptions <GeneralConfiguration> >();
mockOptions.SetupGet(x => x.Value).Returns(new GeneralConfiguration());
var factory = new GitHubClientFactory(mockApp.Object, mockOptions.Object);
Assert.ThrowsException <ArgumentNullException>(() => factory.CreateClient(null));
var client = factory.CreateClient("asdf");
Assert.IsNotNull(client);
var credentials = await client.Connection.CredentialStore.GetCredentials().ConfigureAwait(false);
Assert.AreEqual(AuthenticationType.Oauth, credentials.AuthenticationType);
mockApp.VerifyAll();
}
public GetAzureRmMetricDefinitionTests()
{
insightsMetricDefinitionOperationsMock = new Mock <IMetricDefinitionOperations>();
insightsClientMock = new Mock <InsightsClient>();
commandRuntimeMock = new Mock <ICommandRuntime>();
cmdlet = new GetAzureRmMetricDefinitionCommand()
{
CommandRuntime = commandRuntimeMock.Object,
InsightsClient = insightsClientMock.Object
};
response = Utilities.InitializeMetricDefinitionResponse();
insightsMetricDefinitionOperationsMock.Setup(f => f.GetMetricDefinitionsAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult <MetricDefinitionListResponse>(response))
.Callback((string f, string s, CancellationToken t) =>
{
resourceId = f;
filter = s;
});
insightsClientMock.SetupGet(f => f.MetricDefinitionOperations).Returns(this.insightsMetricDefinitionOperationsMock.Object);
}
public void CityHash_Implementation_Constructor_Config_HashSizeInBits_IsInvalid_Throws()
{
var invalidLengths = new[] { 0, 1, 8, 16, 31, 33, 63, 65, 127, 129, 256 };
foreach (var length in invalidLengths)
{
var cityHashConfigMock = new Mock <ICityHashConfig>();
{
cityHashConfigMock.SetupGet(chc => chc.HashSizeInBits)
.Returns(length);
cityHashConfigMock.Setup(chc => chc.Clone())
.Returns(() => cityHashConfigMock.Object);
}
Assert.Equal(
"config.HashSizeInBits",
Assert.Throws <ArgumentOutOfRangeException>(
() => new CityHash_Implementation(cityHashConfigMock.Object))
.ParamName);
}
}
public void TestCanWriteValidRequest()
{
var uri = new Uri($"https://www.xfinity.com{ ModuleInfo.RoutePrefix }buy/home/page1/en.json");
var requestMock = new Mock <HttpRequestBase>();
requestMock.Setup(r => r.Url).Returns(uri);
var contextMock = new Mock <HttpContextBase>();
var items = new Dictionary <string, object>();
contextMock.SetupGet(c => c.Items).Returns(items);
contextMock.Setup(c => c.Request).Returns(requestMock.Object);
contextMock.Setup(c => c.RewritePath(It.Is <string>(s =>
MatchesExpected(s, ModuleInfo.RoutePrefix.TrimEnd('/'), "buy", "/home/page1", "en")
))).Verifiable("The RewritePath method was never called with the expected URL.");
var context = contextMock.Object;
var processor = new HeadlessRequestUrlRewriteProcessor();
processor.ExecuteRewrite(context, ModuleInfo.RoutePrefix.TrimEnd('/'));
contextMock.Verify();
Assert.IsTrue(context.IsHeadless());
}
public void SetUp()
{
unRegisterDirectoryOnDispose = false;
directoryCache = new Mock <IDirectoryCache>();
directory = new Mock <IDirectory>();
directory.SetupGet(x => x.BlockId).Returns(123);
directory.Setup(x => x.GetDirectoryEntries()).Returns(new[]
{
Mock.Of <IDirectoryEntryInfo>(y => y.IsDirectory && y.BlockId == 1 && y.Name == "Dir 1"),
Mock.Of <IDirectoryEntryInfo>(y => y.IsDirectory && y.BlockId == 2 && y.Name == "Dir 2"),
Mock.Of <IDirectoryEntryInfo>(y => y.IsDirectory == false && y.BlockId == 3 && y.Name == "File 1"),
});
newDirectory = new Mock <IDirectoryEntry>();
directoryFactory = new Mock <IFactory <IDirectoryEntry, IDirectoryCache, IDirectory, bool> >();
directoryFactory.Setup(x => x.Create(It.IsAny <IDirectoryCache>(), It.IsAny <IDirectory>(), It.IsAny <bool>()))
.Returns(newDirectory.Object);
newFile = new Mock <IFileEntry>();
fileFactory = new Mock <IFactory <IFileEntry, IDirectoryCache, IFile> >();
fileFactory.Setup(x => x.Create(It.IsAny <IDirectoryCache>(), It.IsAny <IFile>())).Returns(newFile.Object);
}
public void Create_DuplicateCreditCard_ThrowsException()
{
//setup
Mock <CreditCard> creditCard = new Mock <CreditCard>()
{
CallBase = true
};
creditCard.SetupGet(x => x.CardNumber).Returns("293923910200292");
creditCard.SetupGet(x => x.Expiry).Returns(DateTime.Today.AddDays(1));
Mock <Customer> customer = new Mock <Customer>();
customer.SetupGet(x => x.CreditCards)
.Returns(new ReadOnlyCollection <CreditCard>(new List <CreditCard>()
{
creditCard.Object
}));
//cal
CreditCard actual = CreditCard.Create(customer.Object, "MR J SMITH",
"293923910200292", DateTime.Today.AddDays(1));
}
public void Refill_should_give_a_card_to_each_player()
{
_deckFactoryMock.Setup(x => x.CreateDeck()).Returns(_deckMock.Object);
_deckMock.Setup(d => d.Pop()).Returns(new Card("foo", 1));
_deckMock.SetupGet(d => d.Count).Returns(40);
var strategyMock = new Mock <IStrategy>();
_playerFactoryMock.Setup(f => f.CreatePlayer(_players[0], strategyMock.Object))
.Returns(new Player(_strategyMock.Object, _players[0]));
_playerFactoryMock.Setup(f => f.CreatePlayer(_players[1], strategyMock.Object))
.Returns(new Player(_strategyMock.Object, _players[1]));
_sut.Join(_players[0], strategyMock.Object);
_sut.Join(_players[1], strategyMock.Object);
_sut.Start();
_sut.Refill();
_sut.State.Players.All(p => p.HandCards.Count() == 4).Should().Be.True();
_sut.State.Turn.Should().Be.EqualTo(0);
_sut.State.Dish.Should().Be.Empty();
}
public void Should_send_multiple_points_when_not_using_fieldname()
{
//Arrange
string databaseName = "AA";
var performanceCounterGroupMock = new Mock<IPerformanceCounterGroup>(MockBehavior.Strict);
performanceCounterGroupMock.SetupGet(x => x.SecondsInterval).Returns(1);
performanceCounterGroupMock.SetupGet(x => x.RefreshInstanceInterval).Returns(1);
performanceCounterGroupMock.SetupGet(x => x.Name).Returns("cpu");
performanceCounterGroupMock.Setup(x => x.GetFreshCounters()).Returns(new List<IPerformanceCounterInfo>
{
new PerformanceCounterInfo(string.Empty, new PerformanceCounter("Processor", "% Processor Time", "_Total")),
new PerformanceCounterInfo(string.Empty, new PerformanceCounter("Processor", "% Idle Time", "_Total"))
});
performanceCounterGroupMock.SetupGet(x => x.Tags).Returns(new ITag[] { });
var sendBusinessMock = new Mock<ISendBusiness>(MockBehavior.Strict);
sendBusinessMock.Setup(x => x.Enqueue(It.IsAny<Point[]>()));
var tagLaoderMock = new Mock<ITagLoader>(MockBehavior.Strict);
tagLaoderMock.Setup(x => x.GetGlobalTags()).Returns(new[] { Mock.Of<ITag>(x => x.Name == "B") });
var collectorEngine = new ExactCollectorEngine(performanceCounterGroupMock.Object, sendBusinessMock.Object, tagLaoderMock.Object, false);
//Act
var response = collectorEngine.CollectRegisterCounterValuesAsync().Result;
//Assert
tagLaoderMock.Verify(x => x.GetGlobalTags(), Times.Once);
sendBusinessMock.Verify(x => x.Enqueue(It.IsAny<Point[]>()), Times.Once);
Assert.That(response, Is.EqualTo(2));
}
