public void Configure_ConfiguresOptionsUsingHostingEnvironmentState(Dictionary <string, string> dummyExistingEnvironmentVariables,
string dummyEnvironmentName,
Dictionary <string, string> expectedEnvironmentVariables)
{
// Arrange
const string dummyContentRootPath = "dummyContentRootPath";
Mock <IHostingEnvironment> mockHostingEnvironment = _mockRepository.Create <IHostingEnvironment>();
mockHostingEnvironment.Setup(h => h.ContentRootPath).Returns(dummyContentRootPath);
mockHostingEnvironment.Setup(h => h.EnvironmentName).Returns(dummyEnvironmentName); // Called by IsDevelopment()
Mock <IServiceProvider> mockServiceProvider = _mockRepository.Create <IServiceProvider>();
mockServiceProvider.Setup(s => s.GetService(typeof(IHostingEnvironment))).Returns(mockHostingEnvironment.Object); // Called by the extension method GetService<T>
Mock <IServiceScope> mockServiceScope = _mockRepository.Create <IServiceScope>();
mockServiceScope.Setup(s => s.ServiceProvider).Returns(mockServiceProvider.Object);
Mock <IServiceScopeFactory> mockServiceScopeFactory = _mockRepository.Create <IServiceScopeFactory>();
mockServiceScopeFactory.Setup(s => s.CreateScope()).Returns(mockServiceScope.Object);
var dummyOptions = new NodeJSProcessOptions {
ProjectPath = dummyContentRootPath, EnvironmentVariables = dummyExistingEnvironmentVariables
};
ConfigureNodeJSProcessOptions testSubject = CreateConfigureNodeJSProcessOptions(mockServiceScopeFactory.Object);
// Act
testSubject.Configure(dummyOptions);
// Assert
_mockRepository.VerifyAll();
Assert.Equal(dummyContentRootPath, dummyOptions.ProjectPath);
Assert.Equal(expectedEnvironmentVariables, dummyOptions.EnvironmentVariables);
}
public void Configure_DoesNotOverwriteNodeEnvIfItIsSpecified()
{
// Arrange
const string nodeEnvVarName = "NODE_ENV";
const string dummyNodeEnvValue = "dummyEnvironmentState";
var dummyEnvironmentVariables = new Dictionary <string, string> {
{ nodeEnvVarName, dummyNodeEnvValue }
};
Mock <IHostingEnvironment> mockHostingEnvironment = _mockRepository.Create <IHostingEnvironment>();
mockHostingEnvironment.Setup(h => h.ContentRootPath).Returns("dummyContentRootPath");
Mock <IServiceProvider> mockServiceProvider = _mockRepository.Create <IServiceProvider>();
mockServiceProvider.Setup(s => s.GetService(typeof(IHostingEnvironment))).Returns(mockHostingEnvironment.Object); // Called by the extension method GetService<T>
Mock <IServiceScope> mockServiceScope = _mockRepository.Create <IServiceScope>();
mockServiceScope.Setup(s => s.ServiceProvider).Returns(mockServiceProvider.Object);
Mock <IServiceScopeFactory> mockServiceScopeFactory = _mockRepository.Create <IServiceScopeFactory>();
mockServiceScopeFactory.Setup(s => s.CreateScope()).Returns(mockServiceScope.Object);
var dummyOptions = new NodeJSProcessOptions
{
ProjectPath = null, // So we don't return early
EnvironmentVariables = dummyEnvironmentVariables
};
ConfigureNodeJSProcessOptions testSubject = CreateConfigureNodeJSProcessOptions(mockServiceScopeFactory.Object);
// Act
testSubject.Configure(dummyOptions);
// Assert
_mockRepository.VerifyAll();
Assert.Equal(dummyNodeEnvValue, dummyOptions.EnvironmentVariables[nodeEnvVarName]); // Unchanged
}
public void Configure_DoesNothingIfThereIsNoHostingEnvironmentService()
{
// Arrange
const string dummyProjectPath = "dummyProjectPath";
Mock <IServiceProvider> mockServiceProvider = _mockRepository.Create <IServiceProvider>();
mockServiceProvider.Setup(s => s.GetService(typeof(IHostingEnvironment))).Returns(null); // Called by the extension method GetService<T>
Mock <IServiceScope> mockServiceScope = _mockRepository.Create <IServiceScope>();
mockServiceScope.Setup(s => s.ServiceProvider).Returns(mockServiceProvider.Object);
Mock <IServiceScopeFactory> mockServiceScopeFactory = _mockRepository.Create <IServiceScopeFactory>();
mockServiceScopeFactory.Setup(s => s.CreateScope()).Returns(mockServiceScope.Object);
var dummyOptions = new NodeJSProcessOptions {
ProjectPath = dummyProjectPath
};
ConfigureNodeJSProcessOptions testSubject = CreateConfigureNodeJSProcessOptions(mockServiceScopeFactory.Object);
// Act
testSubject.Configure(dummyOptions);
// Assert
_mockRepository.VerifyAll();
Assert.Equal(dummyProjectPath, dummyOptions.ProjectPath);
Assert.Empty(dummyOptions.EnvironmentVariables);
}
public void Configure_ConfiguresProjectPathIfItIsNullWhitespaceOrAnEmptyString(string dummyProjectPath)
{
// Arrange
const string dummyContentRootPath = "dummyContentRootPath";
Mock <IHostingEnvironment> mockHostingEnvironment = _mockRepository.Create <IHostingEnvironment>();
mockHostingEnvironment.Setup(h => h.ContentRootPath).Returns(dummyContentRootPath);
Mock <IServiceProvider> mockServiceProvider = _mockRepository.Create <IServiceProvider>();
mockServiceProvider.Setup(s => s.GetService(typeof(IHostingEnvironment))).Returns(mockHostingEnvironment.Object); // Called by the extension method GetService<T>
Mock <IServiceScope> mockServiceScope = _mockRepository.Create <IServiceScope>();
mockServiceScope.Setup(s => s.ServiceProvider).Returns(mockServiceProvider.Object);
Mock <IServiceScopeFactory> mockServiceScopeFactory = _mockRepository.Create <IServiceScopeFactory>();
mockServiceScopeFactory.Setup(s => s.CreateScope()).Returns(mockServiceScope.Object);
var dummyOptions = new NodeJSProcessOptions
{
ProjectPath = dummyProjectPath, // Since it's null, whitespace or an empty string, we won't return early
EnvironmentVariables = new Dictionary <string, string> {
{ "NODE_ENV", "dummyEnvironmentState" }
}
};
ConfigureNodeJSProcessOptions testSubject = CreateConfigureNodeJSProcessOptions(mockServiceScopeFactory.Object);
// Act
testSubject.Configure(dummyOptions);
// Assert
_mockRepository.VerifyAll();
Assert.Equal(dummyContentRootPath, dummyOptions.ProjectPath);
}
public void Configure_DoesNotOverwriteProjectPathIfItIsNotNullWhitespaceOrAnEmptyString()
{
// Arrange
const string dummyProjectPath = "dummyProjectPath";
Mock <IHostingEnvironment> mockHostingEnvironment = _mockRepository.Create <IHostingEnvironment>();
mockHostingEnvironment.Setup(h => h.EnvironmentName).Returns("dummyEnvironmentName"); // Called by IsDevelopment()
Mock <IServiceProvider> mockServiceProvider = _mockRepository.Create <IServiceProvider>();
mockServiceProvider.Setup(s => s.GetService(typeof(IHostingEnvironment))).Returns(mockHostingEnvironment.Object); // Called by the extension method GetService<T>
Mock <IServiceScope> mockServiceScope = _mockRepository.Create <IServiceScope>();
mockServiceScope.Setup(s => s.ServiceProvider).Returns(mockServiceProvider.Object);
Mock <IServiceScopeFactory> mockServiceScopeFactory = _mockRepository.Create <IServiceScopeFactory>();
mockServiceScopeFactory.Setup(s => s.CreateScope()).Returns(mockServiceScope.Object);
var dummyOptions = new NodeJSProcessOptions
{
ProjectPath = dummyProjectPath,
EnvironmentVariables = null // So we don't return early
};
ConfigureNodeJSProcessOptions testSubject = CreateConfigureNodeJSProcessOptions(mockServiceScopeFactory.Object);
// Act
testSubject.Configure(dummyOptions);
// Assert
_mockRepository.VerifyAll();
Assert.Equal(dummyProjectPath, dummyOptions.ProjectPath); // Unchanged
}
public void Create_CreatesFileWatcher()
{
// Arrange
const string dummyDirectoryPath = "dummyDirectoryPath";
const string dummyResolvedDirectoryPath = "dummyResolvedDirectoryPath";
const bool dummyIncludeSubdirectories = false;
var dummyFileNamePatterns = new string[0];
var dummyNodeJSProcessOptions = new NodeJSProcessOptions();
Mock <IOptions <NodeJSProcessOptions> > mockNodeJSProcessOptionsAccessor = _mockRepository.Create <IOptions <NodeJSProcessOptions> >();
mockNodeJSProcessOptionsAccessor.Setup(n => n.Value).Returns(dummyNodeJSProcessOptions);
Mock <FileWatcherFactory> mockFileWatcherFactory = CreateMockFileWatcherFactory(mockNodeJSProcessOptionsAccessor.Object);
mockFileWatcherFactory.CallBase = true;
mockFileWatcherFactory.
Setup(f => f.ResolveDirectoryPath(dummyDirectoryPath, dummyNodeJSProcessOptions)).
Returns(dummyResolvedDirectoryPath);
mockFileWatcherFactory.Setup(f => f.ResolveFilters(dummyFileNamePatterns)).Returns(new ReadOnlyCollection <Regex>(new[] { new Regex("dummy") }));
// Act
IFileWatcher result = mockFileWatcherFactory.Object.Create(dummyDirectoryPath, dummyIncludeSubdirectories, dummyFileNamePatterns, (_) => { });
// Assert
_mockRepository.VerifyAll();
}
public void ResolveDirectoryPath_ResolvesDirectoryPath(string dummyDirectoryPath, string dummyProjectPath, string expectedResult)
{
// Arrange
var dummyNodeJSProcessOptions = new NodeJSProcessOptions()
{
ProjectPath = dummyProjectPath
};
FileWatcherFactory testSubject = CreateFileWatcherFactory();
// Act
string result = testSubject.ResolveDirectoryPath(dummyDirectoryPath, dummyNodeJSProcessOptions);
// Assert
Assert.Equal(expectedResult, result);
}
public void Configure_DoesNothingIfProjectPathAndNodeEnvAlreadySpecified()
{
// Arrange
const string dummyProjectPath = "dummyProjectPath";
const string nodeEnvVarName = "NODE_ENV";
const string dummyEnvironmentState = "dummyEnvironmentState";
var dummyEnvironmentVariables = new Dictionary <string, string> {
{ nodeEnvVarName, dummyEnvironmentState }
};
var dummyOptions = new NodeJSProcessOptions {
ProjectPath = dummyProjectPath, EnvironmentVariables = dummyEnvironmentVariables
};
ConfigureNodeJSProcessOptions testSubject = CreateConfigureNodeJSProcessOptions();
// Act
testSubject.Configure(dummyOptions);
// Assert
Assert.Equal(dummyProjectPath, dummyOptions.ProjectPath); // Unchanged
Assert.Equal(dummyEnvironmentState, dummyOptions.EnvironmentVariables[nodeEnvVarName]); // Unchanged
}
public void CreateStartInfo_CreatesStartInfo()
{
// Arrange
const string dummyNodeServerScript = "dummyNodeServerScript";
const string dummyNodeAndV8Options = "dummyNodeAndV8Options";
const int dummyPort = 123; // Arbitrary
const string dummyProjectPath = "dummyProjectPath";
const string dummyEnvironmentVariable = "dummyEnvironmentVariable";
const string dummyEnvironmentVariableValue = "dummyEnvironmentVariableValue";
var dummyEnvironmentVariables = new Dictionary <string, string> {
{ dummyEnvironmentVariable, dummyEnvironmentVariableValue }
};
var dummyNodeJSProcessOptions = new NodeJSProcessOptions
{
NodeAndV8Options = dummyNodeAndV8Options,
Port = dummyPort,
ProjectPath = dummyProjectPath,
EnvironmentVariables = dummyEnvironmentVariables
};
Mock <IOptions <NodeJSProcessOptions> > mockOptionsAccessor = _mockRepository.Create <IOptions <NodeJSProcessOptions> >();
mockOptionsAccessor.Setup(o => o.Value).Returns(dummyNodeJSProcessOptions);
NodeJSProcessFactory testSubject = CreateNodeJSProcessFactory(mockOptionsAccessor.Object);
// Act
ProcessStartInfo result = testSubject.CreateStartInfo(dummyNodeServerScript);
// Assert
int currentProcessPid = Process.GetCurrentProcess().Id;
Assert.Equal($"{dummyNodeAndV8Options} -e \"{dummyNodeServerScript}\" -- --parentPid {currentProcessPid} --port {dummyPort}", result.Arguments);
Assert.False(result.UseShellExecute);
Assert.True(result.RedirectStandardInput);
Assert.True(result.RedirectStandardOutput);
Assert.True(result.RedirectStandardError);
Assert.Equal(dummyProjectPath, result.WorkingDirectory);
result.Environment.TryGetValue(dummyEnvironmentVariable, out string resultEnvironmentVariableValue);
Assert.NotNull(resultEnvironmentVariableValue);
Assert.Equal(dummyEnvironmentVariableValue, resultEnvironmentVariableValue);
}
public void Configure_SetsExecutablePathIfItIsNullWhitespaceOrAnEmptyString(string dummyExecutablePath)
{
// Arrange
Mock <IServiceProvider> mockServiceProvider = _mockRepository.Create <IServiceProvider>();
mockServiceProvider.Setup(s => s.GetService(typeof(IHostingEnvironment))).Returns(null); // Called by the extension method GetService<T>
Mock <IServiceScope> mockServiceScope = _mockRepository.Create <IServiceScope>();
mockServiceScope.Setup(s => s.ServiceProvider).Returns(mockServiceProvider.Object);
Mock <IServiceScopeFactory> mockServiceScopeFactory = _mockRepository.Create <IServiceScopeFactory>();
mockServiceScopeFactory.Setup(s => s.CreateScope()).Returns(mockServiceScope.Object);
var dummyOptions = new NodeJSProcessOptions {
ExecutablePath = dummyExecutablePath
};
ConfigureNodeJSProcessOptions testSubject = CreateConfigureNodeJSProcessOptions(mockServiceScopeFactory.Object);
// Act
testSubject.Configure(dummyOptions);
// AssertS
Assert.Equal("node", dummyOptions.ExecutablePath);
}
