public void PublishDacpac(string rFile)
{
var fs = new FileSystem();
var settings = new SqlSProcPublishSettings();
settings.TargetType = PublishTargetType.Dacpac;
SetupProjectMocks("project.rproj");
var builder = Substitute.For <IDacPacBuilder>();
builder.When(x => x.Build(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <IEnumerable <string> >())).Do(c => {
c.Args()[0].Should().Be("project.dacpac");
c.Args()[1].Should().Be("project");
var e = c.Args()[2] as IEnumerable <string>;
e.Should().HaveCount(1);
e.First().Should().StartWith("CREATE PROCEDURE ProcName");
});
_dacServices.GetBuilder().Returns(builder);
var files = new string[] { Path.Combine(_files.DestinationPath, rFile) };
var publisher = new SProcPublisher(_shell, _pss, fs, _dacServices);
publisher.Publish(settings, files);
builder.Received(1).Build(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <IEnumerable <string> >());
}
public async Task SelectTargetType()
{
var settings = new SqlSProcPublishSettings(_storage);
var model = await SqlPublishOptionsDialogViewModel.CreateAsync(settings, _coreShell, _pss, _pcsp);
await model.SelectTargetTypeAsync(1);
model.Settings.TargetType.Should().Be(PublishTargetType.Database);
model.TargetHasName.Should().BeTrue();
await model.SelectTargetTypeAsync(2);
model.Settings.TargetType.Should().Be(PublishTargetType.Project);
model.TargetHasName.Should().BeTrue();
await model.SelectTargetTypeAsync(3);
model.Settings.TargetType.Should().Be(PublishTargetType.File);
model.TargetHasName.Should().BeFalse();
await model.SelectTargetTypeAsync(0);
model.Settings.TargetType.Should().Be(PublishTargetType.Dacpac);
model.TargetHasName.Should().BeFalse();
}
private void Handle()
{
var project = _pss.GetSelectedProject <IVsHierarchy>()?.GetDTEProject();
if (project != null)
{
var sprocFiles = project.GetSProcFiles(_pss);
if (sprocFiles.Any())
{
try {
// Make sure all files are saved and up to date on disk.
var dte = _appShell.GetGlobalService <DTE>(typeof(DTE));
dte.ExecuteCommand("File.SaveAll");
var publisher = new SProcPublisher(_appShell, _pss, _fs, _dacServicesProvider.GetDacPackageServices());
var settings = new SqlSProcPublishSettings(_settings);
publisher.Publish(settings, sprocFiles);
} catch (Exception ex) {
_appShell.ShowErrorMessage(string.Format(CultureInfo.InvariantCulture, Resources.SqlPublish_PublishError, ex.Message));
}
}
else
{
_appShell.ShowErrorMessage(Resources.SqlPublishDialog_NoSProcFiles);
}
}
}
public void PublishDatabase(string rFile)
{
var fs = new FileSystem();
var settings = new SqlSProcPublishSettings();
settings.TargetType = PublishTargetType.Database;
var odbc = new OdbcConnectionStringBuilder();
odbc[ConnectionStringConverter.OdbcDriverKey] = "SQL Server";
odbc[ConnectionStringConverter.OdbcServerKey] = "(local)";
odbc[ConnectionStringConverter.OdbcDatabaseKey] = "AventureWorks";
settings.TargetDatabaseConnection = odbc.ConnectionString;
SetupProjectMocks("project.rproj");
var builder = Substitute.For <IDacPacBuilder>();
_dacServices.GetBuilder(null).ReturnsForAnyArgs(builder);
_dacServices.When(x => x.Deploy(Arg.Any <DacPackage>(), Arg.Any <string>(), Arg.Any <string>())).Do(c => {
((string)c.Args()[1]).Should().Be("Data Source=(local);Initial Catalog=AventureWorks;Integrated Security=True");
});
var files = new string[] { Path.Combine(_files.DestinationPath, rFile) };
var publisher = new SProcPublisher(_appShell, _pss, fs, _dacServices);
publisher.Publish(settings, files);
_dacServices.Received(1).Deploy(Arg.Any <DacPackage>(), Arg.Any <string>(), Arg.Any <string>());
}
public void GenerateEmpty()
{
var fs = new WindowsFileSystem();
var g = new SProcProjectFilesGenerator(_pss, fs);
var settings = new SqlSProcPublishSettings();
g.Generate(settings, Enumerable.Empty <string>(), _project);
}
public void GenerateEmpty()
{
var fs = new FileSystem();
var g = new SProcProjectFilesGenerator(_pss, fs);
var settings = new SqlSProcPublishSettings();
g.Generate(settings, _project);
}
public async Task NoDbProjectList()
{
_storage.GetSetting(SqlSProcPublishSettings.TargetTypeSettingName, PublishTargetType.Dacpac).Returns(PublishTargetType.Project);
var settings = new SqlSProcPublishSettings(_storage);
var model = await SqlPublishOptionsDialogViewModel.CreateAsync(settings, _coreShell, _pss, _pcsp);
model.Settings.TargetType.Should().Be(PublishTargetType.Project);
model.Targets.Should().HaveCount(1);
model.Targets[0].Should().Be(Resources.SqlPublishDialog_NoDatabaseProjects);
}
public async Task SelectQuoteType()
{
var settings = new SqlSProcPublishSettings(_storage);
var model = await SqlPublishOptionsDialogViewModel.CreateAsync(settings, _coreShell, _pss, _pcsp);
model.SelectQuoteType(1);
model.Settings.QuoteType.Should().Be(SqlQuoteType.Bracket);
model.SelectQuoteType(2);
model.Settings.QuoteType.Should().Be(SqlQuoteType.Quote);
model.SelectQuoteType(0);
model.Settings.QuoteType.Should().Be(SqlQuoteType.None);
}
public async Task SelectCodePlacement()
{
var settings = new SqlSProcPublishSettings(_storage);
var model = await SqlPublishOptionsDialogViewModel.CreateAsync(settings, _coreShell, _pss, _pcsp);
model.SelectCodePlacement(1);
model.Settings.CodePlacement.Should().Be(RCodePlacement.Table);
model.GenerateTable.Should().BeTrue();
model.SelectCodePlacement(0);
model.Settings.CodePlacement.Should().Be(RCodePlacement.Inline);
model.GenerateTable.Should().BeFalse();
}
public async Task NoDbConnections()
{
ConfigureSettingAccessMock(Enumerable.Empty <IConfigurationSetting>());
_storage.GetSetting(SqlSProcPublishSettings.TargetTypeSettingName, PublishTargetType.Dacpac).Returns(PublishTargetType.Database);
var settings = new SqlSProcPublishSettings(_storage);
var model = await SqlPublishOptionsDialogViewModel.CreateAsync(settings, _coreShell, _pss, _pcsp);
model.Settings.TargetType.Should().Be(PublishTargetType.Database);
model.Targets.Should().HaveCount(1);
model.Targets[0].Should().Be(Resources.SqlPublishDialog_NoDatabaseConnections);
}
public void Generate(string rFile, RCodePlacement codePlacement, SqlQuoteType quoteType, string sprocName)
{
var fs = new WindowsFileSystem();
var settings = new SqlSProcPublishSettings();
var g = new SProcProjectFilesGenerator(_pss, fs);
var targetProjItem = Substitute.For <EnvDTE.ProjectItem>();
var targetProjItems = Substitute.For <EnvDTE.ProjectItems>();
targetProjItem.ProjectItems.Returns(targetProjItems);
var rootProjItems = Substitute.For <EnvDTE.ProjectItems>();
rootProjItems.Item("R").Returns((EnvDTE.ProjectItem)null);
rootProjItems.AddFolder("R").Returns(targetProjItem);
_project.ProjectItems.Returns(rootProjItems);
var templateFile = Path.Combine(_files.DestinationPath, Path.GetFileNameWithoutExtension(rFile) + SProcFileExtensions.SProcFileExtension);
var sprocFiles = new string[] {
Path.Combine(_files.DestinationPath, rFile),
Path.Combine(_files.DestinationPath, Path.GetFileNameWithoutExtension(rFile) + SProcFileExtensions.QueryFileExtension),
templateFile
};
settings.CodePlacement = codePlacement;
settings.QuoteType = quoteType;
g.Generate(settings, sprocFiles, _project);
rootProjItems.Received().AddFolder("R");
var targetFolder = Path.Combine(_files.DestinationPath, "R\\");
var rFilePath = Path.Combine(targetFolder, rFile);
var sprocFile = Path.ChangeExtension(Path.Combine(targetFolder, sprocName), ".sql");
targetProjItem.ProjectItems.Received().AddFromFile(sprocFile);
if (codePlacement == RCodePlacement.Table)
{
targetProjItem.ProjectItems.Received().AddFromFile(Path.Combine(targetFolder, SProcProjectFilesGenerator.PostDeploymentScriptName));
targetProjItem.ProjectItems.Received().AddFromFile(Path.Combine(targetFolder, SProcProjectFilesGenerator.CreateRCodeTableScriptName));
}
var mode = codePlacement == RCodePlacement.Inline ? "inline" : "table";
var baseline = fs.ReadAllText(Path.Combine(_files.DestinationPath, Invariant($"{Path.GetFileNameWithoutExtension(rFile)}.{mode}.baseline.sql")));
string actual = fs.ReadAllText(sprocFile);
BaselineCompare.CompareStringLines(baseline, actual);
}
public async Task DbConnectionsList()
{
var s1 = Substitute.For <IConfigurationSetting>();
s1.Name.Returns("dbConn1");
s1.Value.Returns("dbConn1_String");
s1.EditorType.Returns(ConnectionStringEditor.ConnectionStringEditorName);
var s2 = Substitute.For <IConfigurationSetting>();
s2.Name.Returns("dbConn2");
s2.Value.Returns("dbConn2_String");
s2.EditorType.Returns(ConnectionStringEditor.ConnectionStringEditorName);
var s3 = Substitute.For <IConfigurationSetting>();
s3.Name.Returns("dbConn3");
s3.Value.Returns("dbConn3_String");
s3.EditorType.Returns(ConnectionStringEditor.ConnectionStringEditorName);
var s4 = Substitute.For <IConfigurationSetting>();
s4.Name.Returns("dbConn4");
s4.Value.Returns("dbConn4_String");
ConfigureSettingAccessMock(new IConfigurationSetting[] { s1, s4, s2, s3 });
_storage.GetSetting(SqlSProcPublishSettings.TargetTypeSettingName, PublishTargetType.Dacpac).Returns(PublishTargetType.Database);
_storage.GetSetting(SqlSProcPublishSettings.TargetDatabaseConnectionSettingName, Arg.Any <string>()).Returns(("dbConn2_String"));
var settings = new SqlSProcPublishSettings(_storage);
var model = await SqlPublishOptionsDialogViewModel.CreateAsync(settings, _coreShell, _pss, _pcsp);
model.Settings.TargetType.Should().Be(PublishTargetType.Database);
model.Settings.TargetDatabaseConnection.Should().Be("dbConn2_String");
model.Targets.Should().HaveCount(3);
model.Targets[0].Should().Be("dbConn1");
model.Targets[1].Should().Be("dbConn2");
model.Targets[2].Should().Be("dbConn3");
model.SelectedTargetIndex.Should().Be(1);
}
public async Task Constructor()
{
var settings = new SqlSProcPublishSettings(_storage);
var model = await SqlPublishOptionsDialogViewModel.CreateAsync(settings, _coreShell, _pss, _pcsp);
model.TargetTypeNames.Should().HaveCount(3);
model.SelectedTargetTypeIndex.Should().Be(0);
model.QuoteTypeNames.Should().HaveCount(3);
model.SelectedQuoteTypeIndex.Should().Be(0);
model.CodePlacementNames.Should().HaveCount(2);
model.SelectedCodePlacementIndex.Should().Be(0);
model.Targets.Should().BeEmpty();
model.TargetHasName.Should().BeFalse();
model.GenerateTable.Should().BeFalse();
model.Settings.Should().NotBeNull();
model.Settings.CodePlacement.Should().Be(RCodePlacement.Inline);
model.Settings.QuoteType.Should().Be(SqlQuoteType.None);
model.Settings.TargetType.Should().Be(PublishTargetType.Dacpac);
}
public async Task ProjectList()
{
var projects = Substitute.For <EnvDTE.Projects>();
var p1 = Substitute.For <EnvDTE.Project>();
p1.FileName.Returns("project1.sqlproj");
p1.Name.Returns("project1");
var p2 = Substitute.For <EnvDTE.Project>();
p2.FileName.Returns("project2.sqlproj");
p2.Name.Returns("project2");
var p3 = Substitute.For <EnvDTE.Project>();
p3.FileName.Returns("project3.csproj");
p3.Name.Returns("project3");
projects.GetEnumerator().Returns((new EnvDTE.Project[] { p1, p2, p3 }).GetEnumerator());
var sol = Substitute.For <EnvDTE.Solution>();
sol.Projects.Returns(projects);
_pss.GetSolution().Returns(sol);
_storage.GetSetting(SqlSProcPublishSettings.TargetTypeSettingName, PublishTargetType.Dacpac).Returns(PublishTargetType.Project);
_storage.GetSetting(SqlSProcPublishSettings.TargetProjectSettingName, Arg.Any <string>()).Returns(("project2"));
var settings = new SqlSProcPublishSettings(_storage);
var model = await SqlPublishOptionsDialogViewModel.CreateAsync(settings, _coreShell, _pss, _pcsp);
model.Settings.TargetType.Should().Be(PublishTargetType.Project);
model.Settings.TargetProject.Should().Be("project2");
model.Targets.Should().HaveCount(2);
model.Targets[0].Should().Be("project1");
model.Targets[1].Should().Be("project2");
model.SelectedTargetIndex.Should().Be(1);
}
