private static WebHostSettings GetDefaultSettings(ScriptSettingsManager settingsManager)
{
WebHostSettings settings = new WebHostSettings();
string home = settingsManager.GetSetting(EnvironmentSettingNames.AzureWebsiteHomePath);
bool isLocal = string.IsNullOrEmpty(home);
if (isLocal)
{
settings.ScriptPath = settingsManager.GetSetting(EnvironmentSettingNames.AzureWebJobsScriptRoot);
settings.LogPath = Path.Combine(Path.GetTempPath(), @"Functions");
settings.SecretsPath = HttpContext.Current.Server.MapPath("~/App_Data/Secrets");
}
else
{
// we're running in Azure
settings.ScriptPath = Path.Combine(home, @"site\wwwroot");
settings.LogPath = Path.Combine(home, @"LogFiles\Application\Functions");
settings.SecretsPath = Path.Combine(home, @"data\Functions\secrets");
}
if (string.IsNullOrEmpty(settings.ScriptPath))
{
throw new InvalidOperationException("Unable to determine function script root directory.");
}
return settings;
}
public SystemTraceWriter(IEventGenerator eventGenerator, ScriptSettingsManager settingsManager, TraceLevel level) : base(level)
{
_settingsManager = settingsManager;
_appName = _settingsManager.AzureWebsiteDefaultSubdomain;
_subscriptionId = Utility.GetSubscriptionId();
_eventGenerator = eventGenerator;
}
protected EndToEndTestFixture(string rootPath, string testId)
{
_settingsManager = ScriptSettingsManager.Instance;
FixtureId = testId;
string connectionString = AmbientConnectionStringProvider.Instance.GetConnectionString(ConnectionStringNames.Storage);
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(connectionString);
QueueClient = storageAccount.CreateCloudQueueClient();
BlobClient = storageAccount.CreateCloudBlobClient();
TableClient = storageAccount.CreateCloudTableClient();
CreateTestStorageEntities();
TraceWriter = new TestTraceWriter(TraceLevel.Verbose);
ApiHubTestHelper.SetDefaultConnectionFactory();
ScriptHostConfiguration config = new ScriptHostConfiguration()
{
RootScriptPath = rootPath,
TraceWriter = TraceWriter,
FileLoggingMode = FileLoggingMode.Always
};
RequestConfiguration = new HttpConfiguration();
RequestConfiguration.Formatters.Add(new PlaintextMediaTypeFormatter());
// Reset the timer logs first, since one of the tests will
// be checking them
TestHelpers.ClearFunctionLogs("TimerTrigger");
Host = ScriptHost.Create(_settingsManager, config);
Host.Start();
}
public TestScopedSettings(ScriptSettingsManager settingsManager, IDictionary<string, string> variables)
{
_settingsManager = settingsManager;
_variables = variables;
_existingVariables = new Dictionary<string, string>(variables.Count);
SetVariables();
}
public FunctionDescriptorProviderTests()
{
string rootPath = Path.Combine(Environment.CurrentDirectory, @"TestScripts\Node");
ScriptHostConfiguration config = new ScriptHostConfiguration
{
RootScriptPath = rootPath
};
_settingsManager = ScriptSettingsManager.Instance;
_host = ScriptHost.Create(_settingsManager, config);
_provider = new TestDescriptorProvider(_host, config);
}
public static void Register(HttpConfiguration config, ScriptSettingsManager settingsManager = null,
WebHostSettings settings = null, Action<ContainerBuilder, WebHostSettings> dependencyCallback = null)
{
if (config == null)
{
throw new ArgumentNullException("config");
}
settingsManager = settingsManager ?? ScriptSettingsManager.Instance;
settings = settings ?? GetDefaultSettings(settingsManager);
var builder = new ContainerBuilder();
builder.RegisterApiControllers(typeof(FunctionsController).Assembly);
AutofacBootstrap.Initialize(settingsManager, builder, settings);
// Invoke registration callback
dependencyCallback?.Invoke(builder, settings);
var container = builder.Build();
config.DependencyResolver = new AutofacWebApiDependencyResolver(container);
config.Formatters.Add(new PlaintextMediaTypeFormatter());
config.MessageHandlers.Add(new WebScriptHostHandler(config));
// Web API configuration and services
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "Home",
routeTemplate: string.Empty,
defaults: new { controller = "Home" });
config.Routes.MapHttpRoute(
name: "Functions",
routeTemplate: "{*uri}",
defaults: new { controller = "Functions" });
// Initialize WebHook Receivers
config.InitializeReceiveGenericJsonWebHooks();
config.InitializeReceiveAzureAlertWebHooks();
config.InitializeReceiveKuduWebHooks();
config.InitializeReceivePusherWebHooks();
config.InitializeReceiveStripeWebHooks();
config.InitializeReceiveTrelloWebHooks();
config.InitializeReceiveDynamicsCrmWebHooks();
config.InitializeReceiveMailChimpWebHooks();
config.InitializeReceiveSlackWebHooks();
config.InitializeReceiveBitbucketWebHooks();
config.InitializeReceiveDropboxWebHooks();
config.InitializeReceiveWordPressWebHooks();
config.InitializeReceiveGitHubWebHooks();
config.InitializeReceiveSalesforceWebHooks();
}
public static void Initialize(HttpConfiguration config, ScriptSettingsManager settingsManager = null,
WebHostSettings settings = null, Action<ContainerBuilder, WebHostSettings> dependencyCallback = null)
{
Register(config, settingsManager, settings, dependencyCallback);
var scriptHostManager = config.DependencyResolver.GetService<WebScriptHostManager>();
if (scriptHostManager != null && !scriptHostManager.Initialized)
{
scriptHostManager.Initialize();
}
}
public MetricsEventManager(ScriptSettingsManager settingsManager, IEventGenerator generator, int functionActivityFlushIntervalSeconds, int metricsFlushIntervalMS = DefaultFlushIntervalMS)
{
// we read these in the ctor (not static ctor) since it can change on the fly
appName = GetNormalizedString(settingsManager.AzureWebsiteDefaultSubdomain);
subscriptionId = Utility.GetSubscriptionId() ?? string.Empty;
_eventGenerator = generator;
_functionActivityFlushIntervalSeconds = functionActivityFlushIntervalSeconds;
QueuedEvents = new ConcurrentDictionary<string, SystemMetricEvent>(StringComparer.OrdinalIgnoreCase);
// Initialize the periodic log flush timer
_metricsFlushTimer = new Timer(TimerFlush, null, metricsFlushIntervalMS, metricsFlushIntervalMS);
}
public SystemTraceWriterTests()
{
_settingsManager = new ScriptSettingsManager();
_subscriptionId = "e3235165-1600-4819-85f0-2ab362e909e4";
_settingsManager.SetSetting(EnvironmentSettingNames.AzureWebsiteOwnerName, $"{_subscriptionId}+westuswebspace");
_websiteName = "functionstest";
_settingsManager.SetSetting(EnvironmentSettingNames.AzureWebsiteHostName, $"{_websiteName}.azurewebsites.net");
_mockEventGenerator = new Mock<IEventGenerator>(MockBehavior.Strict);
_traceWriter = new SystemTraceWriter(_mockEventGenerator.Object, _settingsManager, TraceLevel.Verbose);
}
internal static void Initialize(ScriptSettingsManager settingsManager, ContainerBuilder builder, WebHostSettings settings)
{
builder.RegisterInstance(settingsManager);
builder.RegisterType<WebHostResolver>().SingleInstance();
// these services are externally owned by the WebHostResolver, and will be disposed
// when the resolver is disposed
builder.RegisterType<DefaultSecretManagerFactory>().As<ISecretManagerFactory>().SingleInstance();
builder.Register<TraceWriter>(ct => ct.ResolveOptional<WebScriptHostManager>()?.Instance?.TraceWriter ?? NullTraceWriter.Instance).ExternallyOwned();
builder.Register<ISecretManager>(ct => ct.Resolve<WebHostResolver>().GetSecretManager(settings)).ExternallyOwned();
builder.Register<WebScriptHostManager>(ct => ct.Resolve<WebHostResolver>().GetWebScriptHostManager(settings)).ExternallyOwned();
builder.Register<WebHookReceiverManager>(ct => ct.Resolve<WebHostResolver>().GetWebHookReceiverManager(settings)).ExternallyOwned();
}
public AdminControllerTests()
{
_settingsManager = ScriptSettingsManager.Instance;
testFunctions = new Collection<FunctionDescriptor>();
var config = new ScriptHostConfiguration();
hostMock = new Mock<ScriptHost>(MockBehavior.Strict, new object[] { config });
hostMock.Setup(p => p.Functions).Returns(testFunctions);
WebHostSettings settings = new WebHostSettings();
managerMock = new Mock<WebScriptHostManager>(MockBehavior.Strict, new object[] { config, new TestSecretManagerFactory(), _settingsManager, settings });
managerMock.SetupGet(p => p.Instance).Returns(hostMock.Object);
testController = new AdminController(managerMock.Object);
}
public WebScriptHostHandlerTests()
{
_settingsManager = ScriptSettingsManager.Instance;
_managerMock = new Mock<WebScriptHostManager>(MockBehavior.Strict, new ScriptHostConfiguration(), new TestSecretManagerFactory(), _settingsManager, new WebHostSettings());
_managerMock.SetupGet(p => p.Initialized).Returns(true);
Mock<IDependencyResolver> mockResolver = new Mock<IDependencyResolver>(MockBehavior.Strict);
mockResolver.Setup(p => p.GetService(typeof(WebScriptHostManager))).Returns(_managerMock.Object);
HttpConfiguration config = new HttpConfiguration();
config.DependencyResolver = mockResolver.Object;
WebScriptHostHandler handler = new WebScriptHostHandler(config, hostTimeoutSeconds: 1, hostRunningPollIntervalMS: 50)
{
InnerHandler = new TestHandler()
};
_invoker = new HttpMessageInvoker(handler);
}
public PackageAssemblyResolverTests()
{
_settingsManager = ScriptSettingsManager.Instance;
_runPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
_lockFilePath = Path.Combine(_runPath, DotNetConstants.ProjectLockFileName);
_oldHomeEnv = _settingsManager.GetSetting(EnvironmentSettingNames.AzureWebsiteHomePath);
_targetAssemblyPath = Path.Combine(_runPath, "data\\Functions\\packages\\nuget\\Test.Package\\1.0.0\\lib\\net45");
_targetAssemblyFilePath = Path.Combine(_targetAssemblyPath, Path.GetFileName(this.GetType().Assembly.Location));
Directory.CreateDirectory(_targetAssemblyPath);
// Copy current assembly to target package reference location
File.Copy(this.GetType().Assembly.Location, _targetAssemblyFilePath);
// Create our Lock file using the current assembly as the target
File.WriteAllText(_lockFilePath, string.Format(Resources.ProjectLockFileFormatString, Path.GetFileName(this.GetType().Assembly.Location)));
_settingsManager.SetSetting(EnvironmentSettingNames.AzureWebsiteHomePath, _runPath);
}
public WebScriptHostManager(ScriptHostConfiguration config, ISecretManagerFactory secretManagerFactory, ScriptSettingsManager settingsManager, WebHostSettings webHostSettings, IScriptHostFactory scriptHostFactory = null)
: base(config, settingsManager, scriptHostFactory)
{
_config = config;
_metricsLogger = new WebHostMetricsLogger();
_exceptionHandler = new WebScriptHostExceptionHandler(this);
_webHostSettings = webHostSettings;
var systemEventGenerator = config.HostConfig.GetService<IEventGenerator>() ?? new EventGenerator();
var systemTraceWriter = new SystemTraceWriter(systemEventGenerator, settingsManager, TraceLevel.Verbose);
if (config.TraceWriter != null)
{
config.TraceWriter = new CompositeTraceWriter(new TraceWriter[] { config.TraceWriter, systemTraceWriter });
}
else
{
config.TraceWriter = systemTraceWriter;
}
_secretManager = secretManagerFactory.Create(settingsManager, config.TraceWriter, webHostSettings.SecretsPath);
}
public ControllerScenarioTestFixture()
{
_config = new HttpConfiguration();
_settingsManager = ScriptSettingsManager.Instance;
HostSettings = new WebHostSettings
{
IsSelfHost = true,
ScriptPath = Path.Combine(Environment.CurrentDirectory, @"..\..\..\..\sample"),
LogPath = Path.Combine(Path.GetTempPath(), @"Functions"),
SecretsPath = Path.Combine(Environment.CurrentDirectory, @"..\..\..\..\src\WebJobs.Script.WebHost\App_Data\Secrets")
};
WebApiConfig.Register(_config, _settingsManager, HostSettings, RegisterDependencies);
HttpServer = new HttpServer(_config);
this.HttpClient = new HttpClient(HttpServer);
this.HttpClient.BaseAddress = new Uri("https://localhost/");
WaitForHost();
}
public WebScriptHostManager(ScriptHostConfiguration config, ISecretManagerFactory secretManagerFactory, ScriptSettingsManager settingsManager, WebHostSettings webHostSettings)
: this(config, secretManagerFactory, settingsManager, webHostSettings, new ScriptHostFactory())
{
}
public DefaultKeyValueConverterFactory(ScriptSettingsManager settingsManager)
{
_settingsManager = settingsManager;
_encryptionSupported = IsEncryptionSupported();
}
public ISecretManager Create(ScriptSettingsManager settingsManager, TraceWriter traceWriter, string secretsPath)
=> new SecretManager(settingsManager, secretsPath, traceWriter);
public TestScopedSettings(ScriptSettingsManager settingsManager, string name, string value)
: this(settingsManager, new Dictionary<string, string> { { name, value } })
{
}
public WebHostMetricsLogger(ScriptSettingsManager settingsManager, IEventGenerator eventGenerator, int metricEventIntervalInSeconds)
{
_metricsEventManager = new MetricsEventManager(settingsManager, eventGenerator, metricEventIntervalInSeconds);
}
public ScriptHostManager(ScriptHostConfiguration config, ScriptSettingsManager settingsManager, IScriptHostFactory scriptHostFactory)
{
_config = config;
_settingsManager = settingsManager;
_scriptHostFactory = scriptHostFactory;
}
public ScriptHost Create(ScriptSettingsManager settingsManager, ScriptHostConfiguration config)
{
return ScriptHost.Create(settingsManager, config);
}
public static ScriptHost Create(ScriptSettingsManager settingsManager = null, ScriptHostConfiguration scriptConfig = null)
{
if (scriptConfig == null)
{
scriptConfig = new ScriptHostConfiguration();
}
_settingsManager = settingsManager;
if (settingsManager == null)
{
_settingsManager = ScriptSettingsManager.Instance;
}
if (!Path.IsPathRooted(scriptConfig.RootScriptPath))
{
scriptConfig.RootScriptPath = Path.Combine(Environment.CurrentDirectory, scriptConfig.RootScriptPath);
}
ScriptHost scriptHost = new ScriptHost(scriptConfig);
try
{
scriptHost.Initialize();
}
catch (Exception ex)
{
if (scriptHost.TraceWriter != null)
{
scriptHost.TraceWriter.Error("ScriptHost initialization failed", ex);
}
throw;
}
return scriptHost;
}
public WebHostResolver(ScriptSettingsManager settingsManager, ISecretManagerFactory secretManagerFactory)
{
_settingsManager = settingsManager;
_secretManagerFactory = secretManagerFactory;
}
public ScriptHost Create(ScriptSettingsManager settingsManager, ScriptHostConfiguration config)
{
if (Throw)
{
throw new Exception("Kaboom!");
}
var mockMetricsLogger = new Mock<IMetricsLogger>(MockBehavior.Strict);
config.HostConfig.AddService<IMetricsLogger>(mockMetricsLogger.Object);
mockMetricsLogger.Setup(p => p.BeginEvent(It.IsAny<string>())).Returns(new object());
mockMetricsLogger.Setup(p => p.EndEvent(It.IsAny<object>()));
mockMetricsLogger.Setup(p => p.LogEvent(It.IsAny<string>()));
mockMetricsLogger.Setup(p => p.LogEvent(It.IsAny<MetricEvent>()));
return ScriptHost.Create(settingsManager, config);
}
public ScriptHostManagerTests()
{
_settingsManager = ScriptSettingsManager.Instance;
}