public async Task TestBasic()
{
string authType = BasicGenerator.AuthorizationHeaderMarker;
string userName = "******";
string password = "******";
string relativeUri = "/api/auth/basic";
Uri fullUri = new Uri(baseUri, relativeUri);
string initialRequest = CreateInitialRequest(fullUri);
using (Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
{
await socket.ConnectAsync("localhost", port);
HttpResponse initialResponse = await SendRequestAndGetResponse(socket, initialRequest);
Assert.That(initialResponse.StatusCode, Is.EqualTo(401));
Assert.That(initialResponse.Headers.ContainsKey("WWW-Authenticate"));
string authHeader = GetDesiredAuthHeader(authType, initialResponse);
Assert.That(authHeader, Is.Not.Null);
BasicGenerator generator = new BasicGenerator(userName, password);
string authorizeRequest = CreateRequest(fullUri, generator.GenerateAuthorizationHeader());
HttpResponse authorizedResponse = await SendRequestAndGetResponse(socket, authorizeRequest);
Assert.That(authorizedResponse.StatusCode, Is.EqualTo(200));
socket.Close();
}
}
private void DbDeleteBtn_OnClick(object sender, RoutedEventArgs e)
{
string txt = inputTextBox.Text;
BasicGenerator generator = new BasicGenerator(BasicGenerator.DummyConfiguration);
outPutTextBox.Text = generator.Parse(txt, tbReplacement.Text).Generate().GetDeleteTablesSql();
}
public static List <DataTypePattern> GetPatterns()
{
List <DataTypePattern> list = new List <DataTypePattern>();
BasicGenerator gen = BasicGenerator.Instance;
list.Add(new DataTypePattern(EnumDataTypes.ByteInt, gen.TypeByteInt, false));
list.Add(new DataTypePattern(EnumDataTypes.SmallInt, gen.TypeSmallInt, false));
list.Add(new DataTypePattern(EnumDataTypes.Boolean, gen.TypeBoolean, false));
list.Add(new DataTypePattern(EnumDataTypes.Int, gen.TypeInt, false));
list.Add(new DataTypePattern(EnumDataTypes.Varchar, gen.TypeVarchar, true));
list.Add(new DataTypePattern(EnumDataTypes.Char, gen.TypeChar, true));
list.Add(new DataTypePattern(EnumDataTypes.LongText, gen.TypeLongText, false));
list.Add(new DataTypePattern(EnumDataTypes.Text, gen.TypeText, false));
list.Add(new DataTypePattern(EnumDataTypes.DateTime, gen.TypeDateTime, false));
list.Add(new DataTypePattern(EnumDataTypes.Bit, gen.TypeBit, false));
list.Add(new DataTypePattern(EnumDataTypes.Float, gen.TypeFloat, false));
list.Add(new DataTypePattern(EnumDataTypes.TimeStamp, gen.TypeTimeStamp, false));
list.Add(new DataTypePattern(EnumDataTypes.Date, gen.TypeDate, false));
list.Add(new DataTypePattern(EnumDataTypes.Decimal, gen.TypeDecimal, true)
{
HasAddistinalSize = true
});
if (OnTypePatternsGeneration != null)
{
return(OnTypePatternsGeneration.Invoke(list));
}
return(list);
}
private void LoadChunk(ChunkIndex index, Chunk c)
{
BasicGenerator.GenerateChunkAt(index, ref c);
c.Compile();
c.RenderChunk = true;
AddChunk(c);
lock (chunkLoadingList)
{
chunkLoadingList.Remove(index);
}
}
public static T OtherThan <T>(this BasicGenerator gen, params T[] omittedValues)
{
if (ValueTypes.Contains(typeof(T)))
{
return(gen.InstanceOf(InlineGenerators.ValueOtherThan(omittedValues)));
}
else
{
return(gen.InstanceOf(InlineGenerators.OtherThan(omittedValues)));
}
}
public void TestUserNamePasswordAndNullHeader()
{
BasicGenerator generator = new BasicGenerator(userName, password, null);
byte[] actualAuthBytes = generator.GetAuthorizationBytes();
string actualAuthValue = generator.GetAuthorizationValue();
string calculatedValue = Convert.ToBase64String(actualAuthBytes);
Assert.That(calculatedValue, Is.EqualTo(expectedValue));
Assert.That(actualAuthValue, Is.EqualTo(expectedValue));
}
public void TestUserNamePasswordAndHeader()
{
string header = "realm=\"Protected Area\", charset=\"UTF-8\"";
BasicGenerator generator = new BasicGenerator(userName, password, header);
byte[] actualAuthBytes = generator.GetAuthorizationBytes();
string actualAuthValue = generator.GetAuthorizationValue();
string calculatedValue = Convert.ToBase64String(actualAuthBytes);
Assert.That(calculatedValue, Is.EqualTo(expectedValue));
Assert.That(actualAuthValue, Is.EqualTo(expectedValue));
}
/// <summary>
/// Handles the OnResponseReceived for the proxy, which occurs after the response is
/// received from the web server, but before it is forwarded on to the browser.
/// </summary>
/// <param name="context">A <see cref="BenderProxy.ProcessingContext"/> object.</param>
public override void OnResponseReceived(ProcessingContext context)
{
// These are valid credentials for the Basic case.
string userName = "******";
string password = "******";
// Only do any processing on the response if the response is 401,
// or "Unauthorized".
if (context.ResponseHeader != null && context.ResponseHeader.StatusCode == 401)
{
// Read the headers from the response and finish reading the response
// body, if any.
Console.WriteLine("Received 401 - Unauthorized response");
context.ServerStream.ReadTimeout = 5000;
context.ServerStream.WriteTimeout = 5000;
StreamReader reader = new StreamReader(context.ServerStream);
HttpHeaderReader headerReader = new HttpHeaderReader(reader);
if (context.ResponseHeader.EntityHeaders.ContentLength != 0)
{
string drainBody = ReadFromStream(reader);
}
// We do not want the proxy to do any further processing after
// handling this message.
context.StopProcessing();
// Read the WWW-Authenticate header. Because of the way the test
// web app is configured, it returns multiple headers, with
// different schemes. We need to select the correct one.
string authHeader = GetAuthenticationHeader(context.ResponseHeader.WWWAuthenticate, BasicGenerator.AuthorizationHeaderMarker);
Console.WriteLine("Processing WWW-Authenticate header: {0}", authHeader);
// Calculate the value for the Authorization header, and resend
// the request (with the Authorization header) to the server
// using BenderProxy's HttpMessageWriter.
Console.WriteLine("Generating authorization header value for user name '{0}' and password '{1}'", userName, password);
BasicGenerator generator = new BasicGenerator(userName, password, authHeader);
string authorizationHeaderValue = generator.GenerateAuthorizationHeader();
Console.WriteLine("Resending request with Authorization header: {0}", authorizationHeaderValue);
context.RequestHeader.Authorization = authorizationHeaderValue;
HttpMessageWriter writer = new HttpMessageWriter(context.ServerStream);
writer.Write(context.RequestHeader);
// Get the authorized response, and forward it on to the browser, using
// BenderProxy's HttpHeaderReader and support classes.
HttpResponseHeader header = new HttpResponseHeader(headerReader.ReadHttpMessageHeader());
string body = ReadFromStream(reader);
Stream bodyStream = new MemoryStream(Encoding.UTF8.GetBytes(body));
new HttpResponseWriter(context.ClientStream).Write(header, bodyStream, bodyStream.Length);
}
}
private void DbInsertBtn_OnClick(object sender, RoutedEventArgs e)
{
try
{
if (insertFile == null)
{
DbInsertFileBtn_OnClick(sender, e);
}
var data = File.ReadAllText(insertFile);
BasicGenerator generator = new BasicGenerator(BasicGenerator.DummyConfiguration);
outPutTextBox.Text = generator.Parse(inputTextBox.Text, tbReplacement.Text).GetInsertDataSql(data);
}
catch (Exception exception)
{
MessageBox.Show(exception.Message, "Error while openning file!");
}
}
public Boolean TryGenerate(String edmxFileFullPath,
String dbConnectionString,
String generatorAssemblyFileFullPath,
String generatorTypeFulleName = "",
String outputFileFullPath = "")
{
try
{
BasicGenerator generator = GetGenerateor(edmxFileFullPath, dbConnectionString, generatorAssemblyFileFullPath, generatorTypeFulleName, outputFileFullPath);
return(generator.TryDoGenerate());
}
catch (Exception ex)
{
//throw;
WriteLogMsg(ex);
}
return(false);
}
private void generateBtn_Click(object sender, RoutedEventArgs e)
{
string txt = inputTextBox.Text;
if (txt.Length == 0)
{
return;
}
try
{
BasicGenerator generator = new BasicGenerator(BasicGenerator.DummyConfiguration);
outPutTextBox.Text = generator.Parse(txt, tbReplacement.Text).Generate().ToSql();
string h = generator.ToHtmlWithHeader();
WriteHtml(h);
tableOutTextBox.Text = h;
}
catch (Exception exception)
{
MessageBox.Show($"{exception.Message}\n\n{exception.StackTrace}", "Error while generating");
}
//outPutTextBox.Text = Generate(txt);
}
public static T OtherThan <T>(this BasicGenerator gen, params T[]?skippedValues)
{
if (skippedValues == null)
{
return(gen.Instance <T>());
}
if (ThereAreRepeatedItemsIn(skippedValues))
{
throw new ArgumentException(
"there is no point in passing a single value twice for skip",
nameof(skippedValues));
}
if (ValueTypes.Contains(typeof(T)))
{
return(gen.InstanceOf(InlineGenerators.ValueOtherThan(skippedValues)));
}
else
{
return(gen.InstanceOf(InlineGenerators.OtherThan(skippedValues)));
}
}
public static long Long(this BasicGenerator gen)
{
return(gen.InstanceOf(InlineGenerators.Long()));
}
public static IReadOnlyList <T> ReadOnlyList <T>(this BasicGenerator gen, int length)
{
return(gen.InstanceOf(InlineGenerators.List <T>(length)));
}
public static double Double(this BasicGenerator gen)
{
return(gen.InstanceOf(InlineGenerators.Double()));
}
public static List <T> ListWith <T>(this BasicGenerator gen, params T[] included)
{
return(gen.InstanceOf(InlineGenerators.ListWith(included)));
}
public static List <T> ListWith <T>(this BasicGenerator gen, IEnumerable <T> included)
{
return(gen.InstanceOf(InlineGenerators.ListWith(included.ToArray())));
}
public static List <T> List <T>(this BasicGenerator gen)
{
return(gen.InstanceOf(InlineGenerators.List <T>()));
}
public static ulong UnsignedLong(this BasicGenerator gen)
{
return(gen.InstanceOf(InlineGenerators.UnsignedLong()));
}
public static byte PositiveDigit(this BasicGenerator gen)
{
return(gen.InstanceOf(InlineGenerators.PositiveDigit()));
}
public static short Short(this BasicGenerator gen)
{
return(gen.InstanceOf(InlineGenerators.Short()));
}
public static decimal Decimal(this BasicGenerator gen)
{
return(gen.InstanceOf(InlineGenerators.Decimal()));
}
public static byte Byte(this BasicGenerator gen)
{
return(gen.InstanceOf(InlineGenerators.Byte()));
}
public static ImmutableStack <T> ImmutableStack <T>(this BasicGenerator gen)
{
return(gen.InstanceOf(InlineGenerators.ImmutableStack <T>()));
}
public static ushort UnsignedShort(this BasicGenerator gen)
{
return(gen.InstanceOf(InlineGenerators.UnsignedShort()));
}
public static T[] Array <T>(this BasicGenerator gen, int length)
{
return(gen.InstanceOf(InlineGenerators.Array <T>(length)));
}
public static int IntegerFromSequence(this BasicGenerator gen, int startingValue = 0, int step = 1)
{
return(gen.InstanceOf(InlineGenerators.IntegerFromSequence(startingValue, step)));
}
public static T[] ArrayWithout <T>(this BasicGenerator gen, params T[] excluded)
{
return(gen.InstanceOf(InlineGenerators.ArrayWithout(excluded)));
}
public static int Integer(this BasicGenerator gen)
{
return(gen.InstanceOf(InlineGenerators.Integer()));
}
public static T[] ArrayWithout <T>(this BasicGenerator gen, IEnumerable <T> excluded)
{
return(gen.InstanceOf(InlineGenerators.ArrayWithout(excluded.ToArray())));
}
