public void Test_CreateDeployemntTask_RunsProperly_WhenAllIsWell()
{
var objectFactory = new Mock <IObjectFactory>(MockBehavior.Strict);
var prjInfoRepository = new Mock <IProjectInfoRepository>(MockBehavior.Loose);
var envInfoRepository = new Mock <IEnvironmentInfoRepository>(MockBehavior.Loose);
var artifactsRepository = new Mock <IArtifactsRepository>(MockBehavior.Loose);
var taskScheduler = new Mock <ITaskScheduler>(MockBehavior.Loose);
var passwordCollector = new Mock <IPasswordCollector>(MockBehavior.Loose);
var directoryAdapter = new Mock <IDirectoryAdapter>(MockBehavior.Loose);
var fileAdapter = new Mock <IFileAdapter>(MockBehavior.Loose);
var zipFileAdapter = new Mock <IZipFileAdapter>(MockBehavior.Loose);
var schedulerAppProjectInfo =
new SchedulerAppProjectInfo(
_ProjectName,
_ArtifactsRepositoryName,
_AllowedEnvironmentNames,
_ArtifactsRepositoryDirName,
_ArtifactsAreNotEnvirionmentSpecific,
_SchedulerAppDirName,
_SchedulerAppExeName,
new List <SchedulerAppTask>
{
new SchedulerAppTask(
_SchedulerAppName,
_SchedulerAppName,
_SchedulerAppUserId,
_ScheduledHour,
_ScheduledMinute,
_ExecutionTimeLimitInMinutes,
_Repetition)
});
objectFactory.Setup(o => o.CreateProjectInfoRepository()).Returns(prjInfoRepository.Object);
objectFactory.Setup(o => o.CreateEnvironmentInfoRepository()).Returns(envInfoRepository.Object);
objectFactory.Setup(o => o.CreateArtifactsRepository()).Returns(artifactsRepository.Object);
objectFactory.Setup(o => o.CreateTaskScheduler()).Returns(taskScheduler.Object);
objectFactory.Setup(o => o.CreatePasswordCollector()).Returns(passwordCollector.Object);
objectFactory.Setup(o => o.CreateDirectoryAdapter()).Returns(directoryAdapter.Object);
objectFactory.Setup(o => o.CreateFileAdapter()).Returns(fileAdapter.Object);
objectFactory.Setup(o => o.CreateZipFileAdapter()).Returns(zipFileAdapter.Object);
schedulerAppProjectInfo.CreateDeploymentTask(objectFactory.Object);
}
protected override void DoPrepare()
{
EnvironmentInfo environmentInfo = GetEnvironmentInfo();
_projectInfo = GetProjectInfo <SchedulerAppProjectInfo>();
_collectedPasswordsByUserName = new Dictionary <string, string>();
_existingTaskDetailsByMachineNameAndTaskName = new Dictionary <Tuple <string, string>, ScheduledTaskDetails>();
foreach (string tmpSchedulerServerTasksMachineName in environmentInfo.SchedulerServerTasksMachineNames)
{
string schedulerServerTasksMachineName = tmpSchedulerServerTasksMachineName;
_projectInfo.SchedulerAppTasks
.ForEach(
schedulerAppTask =>
{
ScheduledTaskDetails taskDetails =
_taskScheduler.GetScheduledTaskDetails(schedulerServerTasksMachineName, schedulerAppTask.Name);
_existingTaskDetailsByMachineNameAndTaskName.Add(
Tuple.Create(schedulerServerTasksMachineName, schedulerAppTask.Name),
taskDetails);
EnsureTaskIsNotRunning(taskDetails, schedulerServerTasksMachineName);
// create a step to disable scheduler task
if (taskDetails != null && taskDetails.IsEnabled)
{
AddToggleSchedulerAppTaskEnabledStep(schedulerServerTasksMachineName, taskDetails.Name, false);
}
});
}
Lazy <string> binariesDirPathProvider =
AddStepsToObtainBinaries(environmentInfo);
/* // TODO IMM HI: xxx we don't need this for now - should we parameterize this somehow?
* if (_directoryAdapter.Exists(targetDirNetworkPath))
* {
* AddSubTask(
* new BackupFilesDeploymentStep(
* targetDirNetworkPath));
* }
*/
// create steps for copying the binaries to target binaries machines
foreach (string schedulerServerBinariesMachineName in environmentInfo.SchedulerServerBinariesMachineNames)
{
string targetDirPath = GetTargetDirPath(environmentInfo);
string targetDirNetworkPath = environmentInfo.GetSchedulerServerNetworkPath(schedulerServerBinariesMachineName, targetDirPath);
AddSubTask(
new CleanDirectoryDeploymentStep(
_directoryAdapter,
_fileAdapter,
new Lazy <string>(() => targetDirNetworkPath),
excludedDirs: new string[] { }));
AddSubTask(
new CopyFilesDeploymentStep(
_directoryAdapter,
binariesDirPathProvider,
new Lazy <string>(() => targetDirNetworkPath)));
}
foreach (string tmpSchedulerServerTasksMachineName in environmentInfo.SchedulerServerTasksMachineNames)
{
string schedulerServerTasksMachineName = tmpSchedulerServerTasksMachineName;
_projectInfo.SchedulerAppTasks
.ForEach(
schedulerAppTask =>
{
string taskName = schedulerAppTask.Name;
Tuple <string, string> machineNameAndTaskName =
Tuple.Create(schedulerServerTasksMachineName, taskName);
ScheduledTaskDetails existingTaskDetails =
_existingTaskDetailsByMachineNameAndTaskName[machineNameAndTaskName];
AddTaskConfigurationSteps(
environmentInfo,
schedulerServerTasksMachineName,
schedulerAppTask,
existingTaskDetails);
// create a step to toggle scheduler task enabled
if (existingTaskDetails == null || existingTaskDetails.IsEnabled)
{
AddToggleSchedulerAppTaskEnabledStep(
schedulerServerTasksMachineName,
taskName,
true);
}
});
}
}
public void SetUp()
{
_projectInfoRepositoryFake = new Mock <IProjectInfoRepository>();
_environmentInfoRepositoryFake = new Mock <IEnvironmentInfoRepository>();
_artifactsRepositoryFake = new Mock <IArtifactsRepository>();
_taskSchedulerFake = new Mock <ITaskScheduler>();
_passwordCollectorFake = new Mock <IPasswordCollector>();
_directoryAdapterFake = new Mock <IDirectoryAdapter>();
_fileAdapterFake = new Mock <IFileAdapter>();
_zipFileAdapterFake = new Mock <IZipFileAdapter>();
_projectInfo = ProjectInfoGenerator.GetSchedulerAppProjectInfo();
SchedulerAppTask schedulerAppTask1 = _projectInfo.SchedulerAppTasks.First();
SchedulerAppTask schedulerAppTask2 = _projectInfo.SchedulerAppTasks.Second();
_environmentInfo =
DeploymentDataGenerator.GetEnvironmentInfo(
new[]
{
new EnvironmentUser(schedulerAppTask1.UserId, "user_name_1"),
new EnvironmentUser(schedulerAppTask2.UserId, "user_name_2"),
});
_projectInfoRepositoryFake.Setup(pir => pir.FindByName(It.IsAny <string>()))
.Returns(_projectInfo);
string exeAbsolutePath1 =
Path.Combine(
_environmentInfo.SchedulerAppsBaseDirPath,
_projectInfo.SchedulerAppDirName,
schedulerAppTask1.ExecutableName);
var scheduledTaskRepetition1 =
new ScheduledTaskRepetition(
schedulerAppTask1.Repetition.Interval,
schedulerAppTask1.Repetition.Duration,
schedulerAppTask1.Repetition.StopAtDurationEnd);
ScheduledTaskDetails taskDetails1 =
GetTaskDetails(schedulerAppTask1, exeAbsolutePath1, true, false, scheduledTaskRepetition1);
ScheduledTaskDetails taskDetailsDisabled1 =
GetTaskDetails(schedulerAppTask1, exeAbsolutePath1, false, false, scheduledTaskRepetition1);
int timesCalled11 = 0;
_taskSchedulerFake
.Setup(x => x.GetScheduledTaskDetails(_environmentInfo.SchedulerServerTasksMachineNames.First(), schedulerAppTask1.Name))
.Returns(() =>
{
timesCalled11++;
if (timesCalled11 == 1)
{
return(taskDetails1);
}
if (timesCalled11 == 2)
{
return(taskDetailsDisabled1);
}
throw new Exception("Unexpected number of calls!");
});
int timesCalled21 = 0;
_taskSchedulerFake
.Setup(x => x.GetScheduledTaskDetails(_environmentInfo.SchedulerServerTasksMachineNames.Second(), schedulerAppTask1.Name))
.Returns(() =>
{
timesCalled21++;
if (timesCalled21 == 1)
{
return(taskDetails1);
}
if (timesCalled21 == 2)
{
return(taskDetailsDisabled1);
}
throw new Exception("Unexpected number of calls!");
});
string exeAbsolutePath2 =
Path.Combine(
_environmentInfo.SchedulerAppsBaseDirPath,
_projectInfo.SchedulerAppDirName,
schedulerAppTask2.ExecutableName);
var scheduledTaskRepetition2 =
new ScheduledTaskRepetition(
schedulerAppTask2.Repetition.Interval,
schedulerAppTask2.Repetition.Duration,
schedulerAppTask2.Repetition.StopAtDurationEnd);
ScheduledTaskDetails taskDetails2 =
GetTaskDetails(schedulerAppTask2, exeAbsolutePath2, true, false, scheduledTaskRepetition2);
ScheduledTaskDetails taskDetailsDisabled2 =
GetTaskDetails(schedulerAppTask2, exeAbsolutePath2, false, false, scheduledTaskRepetition2);
int timesCalled12 = 0;
_taskSchedulerFake
.Setup(x => x.GetScheduledTaskDetails(_environmentInfo.SchedulerServerTasksMachineNames.First(), schedulerAppTask2.Name))
.Returns(() =>
{
timesCalled12++;
if (timesCalled12 == 1)
{
return(taskDetails2);
}
if (timesCalled12 == 2)
{
return(taskDetailsDisabled2);
}
throw new Exception("Unexpected number of calls!");
});
int timesCalled22 = 0;
_taskSchedulerFake
.Setup(x => x.GetScheduledTaskDetails(_environmentInfo.SchedulerServerTasksMachineNames.Second(), schedulerAppTask2.Name))
.Returns(() =>
{
timesCalled22++;
if (timesCalled22 == 1)
{
return(taskDetails2);
}
if (timesCalled22 == 2)
{
return(taskDetailsDisabled2);
}
throw new Exception("Unexpected number of calls!");
});
_environmentInfoRepositoryFake
.Setup(x => x.FindByName(It.IsAny <string>()))
.Returns(_environmentInfo);
_directoryAdapterFake
.Setup(x => x.Exists(It.IsAny <string>()))
.Returns(true);
_deployTask =
new DeploySchedulerAppDeploymentTask(
_projectInfoRepositoryFake.Object,
_environmentInfoRepositoryFake.Object,
_artifactsRepositoryFake.Object,
_taskSchedulerFake.Object,
_passwordCollectorFake.Object,
_directoryAdapterFake.Object,
_fileAdapterFake.Object,
_zipFileAdapterFake.Object);
_deployTask.Initialize(DeploymentInfoGenerator.GetSchedulerAppDeploymentInfo());
}
public void Test_GetTargetFolde_RunsProperly_WhenAllIsWell()
{
string machine = Environment.MachineName;
const string baseDirPath = "c:\\basedir";
var envInfo =
new EnvironmentInfo(
"name",
true,
"templates",
"appservermachine",
"failover",
new[] { "webmachine" },
"terminalmachine",
new[] { machine },
new[] { machine },
baseDirPath,
"webbasedir",
"c:\\scheduler",
"terminal",
false,
TestData.EnvironmentUsers,
TestData.AppPoolInfos,
TestData.DatabaseServers,
TestData.ProjectToFailoverClusterGroupMappings,
TestData.WebAppProjectConfigurationOverrides,
TestData.DbProjectConfigurationOverrides,
"terminalAppsShortcutFolder",
"artifactsDeploymentDirPath",
"domain-name",
TestData.CustomEnvMachines);
var schedulerAppProjectInfo =
new SchedulerAppProjectInfo(
_ProjectName,
_ArtifactsRepositoryName,
_AllowedEnvironmentNames,
_ArtifactsRepositoryDirName,
_ArtifactsAreNotEnvirionmentSpecific,
_SchedulerAppDirName,
_SchedulerAppExeName,
new List <SchedulerAppTask>
{
new SchedulerAppTask(
_SchedulerAppName,
_SchedulerAppName,
_SchedulerAppUserId,
_ScheduledHour,
_ScheduledMinute,
_ExecutionTimeLimitInMinutes,
_Repetition)
});
List <string> targetFolders =
schedulerAppProjectInfo.GetTargetFolders(_objectFactoryFake.Object, envInfo)
.ToList();
Assert.IsNotNull(targetFolders);
Assert.AreEqual(1, targetFolders.Count);
Assert.AreEqual("\\\\" + machine + "\\c$\\scheduler\\" + _SchedulerAppDirName, targetFolders[0]);
}
