paul/yavsc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

new mailling for not confirmed emails

Browse Source
This commit is contained in:
Paul Schneider
2021-05-30 12:30:39 +01:00
parent 79d4d64071
commit 0201ea64e6
25 changed files with 46 additions and 31 deletions
Download Patch File Download Diff File Expand all files Collapse all files

203
test/yavscTests/Mandatory/BatchTests.cs Normal file
View File

@ -0,0 +1,203 @@
using System;
using Microsoft.AspNet.Builder;
using Microsoft.AspNet.Builder.Internal;
using Microsoft.AspNet.Razor;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Localization;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.PlatformAbstractions;
using Xunit;
using Yavsc;
using Yavsc.Models;
using Yavsc.Services;
using System.Runtime.Versioning;
using Microsoft.AspNet.Mvc.Razor;
using System.Diagnostics;
using Microsoft.Dnx.Compilation.CSharp;
using Microsoft.Extensions.OptionsModel;
using Yavsc.Helpers;
using Microsoft.Data.Entity;
using Xunit.Abstractions;
using System.IO;
using System.Linq;
using Yavsc.Server.Models.IT.SourceCode;
namespace test
{
[Collection("Yavsc mandatory success story")]
[Trait("regression", "oui")]
public class BatchTests: BaseTestContext, IClassFixture<ServerSideFixture>, IDisposable
{
ServerSideFixture _fixture;
public BatchTests(ITestOutputHelper output, ServerSideFixture fixture) : base (output, fixture)
{
_fixture = fixture;
}
[Fact]
public void GitClone()
{
Assert.True(_serverFixture.EnsureTestDb());
Assert.NotNull (_fixture.DbContext.Project);
var firstProject = _fixture.DbContext.Project.Include(p=>p.Repository).FirstOrDefault();
Assert.NotNull (firstProject);
var di = new DirectoryInfo(_serverFixture.SiteSetup.GitRepository);
if (!di.Exists) di.Create();
var clone = new GitClone(_serverFixture.SiteSetup.GitRepository);
clone.Launch(firstProject);
gitRepo = di.FullName;
}
string gitRepo=null;
[Fact]
void AnsiToHtml()
{
var procStart = new ProcessStartInfo("ls", "-l --color=always")
{
UseShellExecute = false,
RedirectStandardInput = false,
RedirectStandardOutput = true
};
var proc = Process.Start(procStart);
var encoded = AnsiToHtmlEncoder.GetStream(proc.StandardOutput);
using (var reader = new StreamReader(encoded))
{
var txt = reader.ReadToEnd();
_output.WriteLine(txt);
}
}
[Fact]
public void MvcRazorHostAndParser()
{
string cache = System.IO.Directory.GetCurrentDirectory();
MvcRazorHost host = new MvcRazorHost(cache);
var parser = host.CreateMarkupParser();
}
[Fact]
void HaveHost()
{
}
[Fact]
public void EnsureConfigurationRoot()
{
var builder = new ConfigurationBuilder();
builder.AddJsonFile( "appsettings.json", false);
builder.AddJsonFile( "appsettings.Development.json", true);
configurationRoot = builder.Build();
}
internal static BeforeCompileContext CreateYavscCompilationContext()
{
var projectContext = new ProjectContext
{
Name = "Yavsc",
ProjectDirectory = "../Yavsc",
ProjectFilePath = "../Yavsc/project.json",
TargetFramework = new FrameworkName("DNX", new Version(4, 5, 1)),
Configuration = Environment.GetEnvironmentVariable("ASPNET_ENV")
};
return new BeforeCompileContext(
null, projectContext, () => null, () => null, () => null);
}
internal static IConfigurationRoot CreateConfiguration(string prjDir)
{
var builder = new ConfigurationBuilder();
builder.AddJsonFile(Path.Combine(prjDir, "appsettings.json"), false);
builder.AddJsonFile(Path.Combine(prjDir, "appsettings.Development.json"), true);
return builder.Build();
}
internal static void ConfigureServices
(ServiceCollection serviceCollection,
string prjDir,
out IConfigurationRoot configuration,
out IServiceProvider provider)
{
configuration = CreateConfiguration(prjDir);
serviceCollection.AddOptions();
var siteSettingsconf = configuration.GetSection("Site");
serviceCollection.Configure<SiteSettings>(siteSettingsconf);
var smtpSettingsconf = configuration.GetSection("Smtp");
serviceCollection.Configure<SmtpSettings>(smtpSettingsconf);
var locOptions = configuration.GetSection("Localization");
serviceCollection.Configure<LocalizationOptions>(locOptions);
serviceCollection.AddSingleton(typeof(ILoggerFactory), typeof(LoggerFactory));
serviceCollection.AddTransient(typeof(IEmailSender), typeof(MailSender));
serviceCollection.AddTransient(typeof(RazorEngineHost));
serviceCollection.AddTransient((s) => new RazorTemplateEngine(s.GetService<RazorEngineHost>()));
serviceCollection.AddLogging();
serviceCollection.AddMvcCore();
serviceCollection.AddLocalization(options =>
{
options.ResourcesPath = "Resources";
});
AppDomain.CurrentDomain.SetData("YAVSC_DB_CONNECTION", Startup.Testing.ConnectionStrings.Default);
serviceCollection.AddEntityFramework()
.AddNpgsql()
.AddDbContext<ApplicationDbContext>(
db => db.UseNpgsql(Startup.Testing.ConnectionStrings.Default)
);
provider = serviceCollection.BuildServiceProvider();
}
[Fact]
public void ARequestAppDelegate()
{
var services = new ServiceCollection();
services.AddTransient<IRuntimeEnvironment>(
svs => PlatformServices.Default.Runtime
);
beforeCompileContext = CreateYavscCompilationContext();
var prjDir = this.beforeCompileContext.ProjectContext.ProjectDirectory;
ConfigureServices(services, prjDir, out configurationRoot, out serviceProvider);
IApplicationBuilder app = new ApplicationBuilder(serviceProvider);
var rtd = app.Build();
}
[Fact]
public void InitApplicationBuilder()
{
var services = new ServiceCollection();
services.AddTransient<IRuntimeEnvironment>(
svs => PlatformServices.Default.Runtime
);
beforeCompileContext = CreateYavscCompilationContext();
var prjDir = beforeCompileContext.ProjectContext.ProjectDirectory;
ConfigureServices(services, prjDir, out configuration, out provider);
IApplicationBuilder app = new ApplicationBuilder(provider);
app.UseMvc();
var rtd = app.Build();
IOptions<LocalizationOptions> localOptions = ActivatorUtilities.GetServiceOrCreateInstance<IOptions<LocalizationOptions>>(provider); ;
}
public void Dispose()
{
if (gitRepo!=null)
{
Directory.Delete(Path.Combine(gitRepo,"yavsc"), true);
}
_fixture.DropTestDb();
}
}
}

46
test/yavscTests/Mandatory/RegisterApi.cs Normal file
View File

@ -0,0 +1,46 @@
// // YavscWorkInProgress.cs
// /*
// paul 21/06/2018 10:11 20182018 6 21
// */
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading.Tasks;
using Microsoft.AspNet.Hosting;
using Microsoft.Extensions.PlatformAbstractions;
using Xunit;
using Xunit.Abstractions;
using Yavsc.Authentication;
using static OAuth.AspNet.AuthServer.Constants;
using Microsoft.AspNet.Mvc;
using Microsoft.AspNet.Mvc.Filters;
using Microsoft.AspNet.Mvc.Razor;
namespace test
{
[Collection("Yavsc Work In Progress")]
[Trait("regression", "oui")]
[Trait("module", "api")]
public class RegiserAPI : BaseTestContext, IClassFixture<ServerSideFixture>
{
public RegiserAPI(ServerSideFixture serverFixture, ITestOutputHelper output)
: base(output, serverFixture)
{
}
[Fact]
public void EnsureWeb()
{
var host = new WebHostBuilder();
host.UseEnvironment("Development")
.UseServer("Microsoft.AspNet.Server.Kestrel")
.UseStartup<test.Startup>()
.Build().Start();
}
}
}

114
test/yavscTests/Mandatory/Remoting.cs Normal file
View File

@ -0,0 +1,114 @@
// // YavscWorkInProgress.cs
// /*
// paul 21/06/2018 10:11 20182018 6 21
// */
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading.Tasks;
using Microsoft.AspNet.Hosting;
using Microsoft.Extensions.PlatformAbstractions;
using Xunit;
using Xunit.Abstractions;
using Yavsc.Authentication;
using static OAuth.AspNet.AuthServer.Constants;
namespace test
{
[Collection("Yavsc Work In Progress")]
[Trait("regression", "oui")]
public class Remoting : BaseTestContext, IClassFixture<ServerSideFixture>
{
readonly RegiserAPI r;
public Remoting(ServerSideFixture serverFixture, ITestOutputHelper output)
: base(output, serverFixture)
{
r = new RegiserAPI(serverFixture, output);
}
[Theory]
[MemberData(nameof(GetLoginIntentData), parameters: 1)]
public async Task TestUserMayLogin
(
string clientId,
string clientSecret,
string scope,
string authorizeUrl,
string redirectUrl,
string accessTokenUrl,
string login,
string pass
)
{
try
{
r.EnsureWeb();
var oauthor = new OAuthenticator(clientId, clientSecret, scope,
new Uri(authorizeUrl), new Uri(redirectUrl), new Uri(accessTokenUrl));
var query = new Dictionary<string, string>
{
[Parameters.Username] = Startup.Testing.ValidCreds[0].UserName,
[Parameters.Password] = Startup.Testing.ValidCreds[0].Password,
[Parameters.GrantType] = GrantTypes.Password
};
var result = await oauthor.RequestAccessTokenAsync(query);
Console.WriteLine(">> Got an output");
Console.WriteLine(Parameters.AccessToken + ": " + result[Parameters.AccessToken]);
Console.WriteLine(Parameters.TokenType + ": " + result[Parameters.TokenType]);
Console.WriteLine(Parameters.ExpiresIn + ": " + result[Parameters.ExpiresIn]);
Console.WriteLine(Parameters.RefreshToken + ": " + result[Parameters.RefreshToken]);
}
catch (Exception ex)
{
var webex = ex as WebException;
if (webex != null && webex.Status == (WebExceptionStatus)400)
{
if (login == "joe")
{
Console.WriteLine("Bad pass joe!");
return;
}
}
throw;
}
}
public static IEnumerable<object[]> GetLoginIntentData(int numTests)
{
var allData = new List<object[]>();
for (int iTest=0; iTest < numTests && iTest < Startup.Testing.ValidCreds.Length; iTest++)
{
var login = Startup.Testing.ValidCreds[iTest].UserName;
var pass = Startup.Testing.ValidCreds[iTest].Password;
allData.Add(new object[] { ServerSideFixture.ApiKey, "blouh", "profile",
"http://localhost:5000/authorize", "http://localhost:5000/oauth/success",
"http://localhost:5000/token",login, pass});
}
var valid = allData.Count;
for (int iTest=0; iTest + valid < numTests && iTest < Startup.Testing.InvalidCreds.Length; iTest++)
{
var login = Startup.Testing.InvalidCreds[iTest].UserName;
var pass = Startup.Testing.InvalidCreds[iTest].Password;
allData.Add(new object[] { ServerSideFixture.ApiKey, "blouh", "profile",
"http://localhost:5000/authorize", "http://localhost:5000/oauth/success",
"http://localhost:5000/token",login, 0 });
}
return allData.Take(numTests);
}
}
}

22
test/yavscTests/Mandatory/Resources.cs Normal file
View File

@ -0,0 +1,22 @@
namespace test {
public class ResxResources {
const string resPath = "Resources/Test.TestResources.resx";
public void HaveAResxLoader()
{
System.Resources.ResourceReader loader = new System.Resources.ResourceReader(resPath);
// IDictionary
var etor = loader.GetEnumerator();
while (etor.Current !=null)
{
byte[] data;
string stringdata;
string resName = etor.Key.ToString();
loader.GetResourceData(resName, out stringdata, out data);
}
}
}
}

221
test/yavscTests/Mandatory/ServerSideFixture.cs Normal file
View File

@ -0,0 +1,221 @@
using System;
using System.Data.Common;
using Microsoft.AspNet.Hosting;
using Microsoft.AspNet.Hosting.Internal;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.OptionsModel;
using Yavsc.Lib;
using Yavsc.Services;
using Yavsc;
using Yavsc.Models;
using Xunit;
using Npgsql;
using test.Settings;
using Microsoft.Data.Entity;
using Microsoft.Data.Entity.Metadata.Conventions;
namespace test
{
[Trait("regression", "II")]
public class ServerSideFixture : IDisposable
{
SiteSettings _siteSetup;
ILogger _logger;
IApplication _app;
readonly EMailer _mailer;
readonly ILoggerFactory _loggerFactory;
IEmailSender _mailSender;
public static string ApiKey => "53f4d5da-93a9-4584-82f9-b8fdf243b002";
public ApplicationDbContext DbContext { get; private set; }
public SiteSettings SiteSetup
{
get
{
return _siteSetup;
}
set
{
_siteSetup = value;
}
}
/// <summary>
/// initialized by Init
/// </summary>
/// <value></value>
public static object TestingSetup { get; private set; }
public IEmailSender MailSender
{
get
{
return _mailSender;
}
set
{
_mailSender = value;
}
}
public IApplication App
{
get
{
return _app;
}
set
{
_app = value;
}
}
internal void UpgradeDb()
{
Microsoft.Data.Entity.Commands.Program.Main(
new string[] { "database", "update" });
}
public ILogger Logger
{
get
{
return _logger;
}
set
{
_logger = value;
}
}
bool dbCreated;
private readonly WebHostBuilder host;
private readonly IHostingEngine hostengnine;
void AssertNotNull(object obj, string msg)
{
if (obj == null)
throw new Exception(msg);
}
//
public ServerSideFixture()
{
host = new WebHostBuilder();
AssertNotNull(host, nameof(host));
hostengnine = host
.UseEnvironment("Development")
.UseServer("test")
.UseStartup<test.Startup>()
.Build();
AssertNotNull(hostengnine, nameof(hostengnine));
App = hostengnine.Start();
AssertNotNull(App, nameof(App));
// hostengnine.ApplicationServices
_mailer = App.Services.GetService(typeof(EMailer)) as EMailer;
AssertNotNull(_mailer, nameof(_mailer));
MailSender = App.Services.GetService(typeof(IEmailSender)) as IEmailSender;
AssertNotNull(MailSender, nameof(MailSender));
_loggerFactory = App.Services.GetService(typeof(ILoggerFactory)) as ILoggerFactory;
AssertNotNull(_loggerFactory, nameof(_loggerFactory));
var siteSetup = App.Services.GetService(typeof(IOptions<SiteSettings>)) as IOptions<SiteSettings>;
AssertNotNull(siteSetup, nameof(siteSetup));
var testingSetup = App.Services.GetService(typeof(IOptions<Testing>)) as IOptions<Testing>;
DbContext = App.Services.GetService(typeof(ApplicationDbContext)) as ApplicationDbContext;
SiteSetup = siteSetup.Value;
TestingSetup = testingSetup.Value;
Logger = _loggerFactory.CreateLogger<ServerSideFixture>();
var builder = new DbConnectionStringBuilder
{
ConnectionString = Startup.Testing.ConnectionStrings.Default
};
ConventionSet conventions = new ConventionSet();
modelBuilder = new ModelBuilder(conventions);
ApplicationDbContext context = new ApplicationDbContext();
TestingDatabase = (string)builder["Database"];
Logger.LogInformation("ServerSideFixture created.");
}
private readonly ModelBuilder modelBuilder;
public string TestingDatabase { get; private set; }
public void CheckDbExistence()
{
using (
NpgsqlConnection cx = new NpgsqlConnection(Startup.Testing.ConnectionStrings.DatabaseCtor))
{
cx.Open();
_logger.LogInformation($"check db for TestingDatabase:{TestingDatabase}");
var command = cx.CreateCommand();
command.CommandText = $"SELECT 1 FROM pg_database WHERE datname='{TestingDatabase}';";
dbCreated = (command.ExecuteScalar()!=null);
_logger.LogInformation($"DbCreated:{dbCreated}");
cx.Close();
}
}
public bool EnsureTestDb()
{
if (!DbCreated)
{
using (NpgsqlConnection cx = new NpgsqlConnection(Startup.Testing.ConnectionStrings.DatabaseCtor))
{
_logger.LogInformation($"create database for TestingDatabase : {TestingDatabase}");
cx.Open();
var command = cx.CreateCommand();
using (NpgsqlConnection ownercx = new NpgsqlConnection(Startup.Testing.ConnectionStrings.Default))
command.CommandText = $"create database \"{TestingDatabase}\" OWNER \"{ownercx.UserName}\";";
_logger.LogInformation(command.CommandText);
command.ExecuteNonQuery();
}
dbCreated = true;
}
return dbCreated;
}
public void DropTestDb()
{
if (dbCreated)
DbContext.Database.EnsureDeleted();
dbCreated = false;
}
public void Dispose()
{
Logger.LogInformation("Disposing");
}
public bool DbCreated { get {
CheckDbExistence();
return dbCreated; } }
}
}