public async void GenerateFromHttpWithSettingTest(string url, string version, int n)
{
PocoSetting setting = new PocoSetting
{
AddNullableDataType = true,
AddKeyAttribute = true,
AddTableAttribute = true,
AddRequiredAttribute = true,
AddNavigation = true
};
//var url = "http://services.odata.org/V4/OData/OData.svc";
O2P o2p = new O2P( setting);
var code = await o2p.GenerateAsync(new Uri(url));
Debug.WriteLine(code);
Assert.AreEqual(o2p.MetaDataVersion, version);
Assert.AreEqual(o2p.ClassList.Count, n);
Assert.IsTrue(code.Contains(o2p.SchemaNamespace));
StringAssert.Contains("[Key]", code);
StringAssert.Contains("[Required]", code);
StringAssert.Contains("[Table", code);
}
public O2P(string url, string user, string password)
{
Url = url;
User = user;
Password = password;
Setting = new PocoSetting();
}
public async void GenerateFromHttpWithSettingTest(string url, string version, int n)
{
PocoSetting setting = new PocoSetting
{
AddNullableDataType = true,
AddKeyAttribute = true,
AddTableAttribute = true,
AddRequiredAttribute = true,
AddNavigation = true
};
//var url = "http://services.odata.org/V4/OData/OData.svc";
O2P o2p = new O2P(setting);
var code = await o2p.GenerateAsync(new Uri(url));
Debug.WriteLine(code);
Assert.AreEqual(o2p.MetaDataVersion, version);
Assert.AreEqual(o2p.ClassList.Count, n);
Assert.IsTrue(code.Contains(o2p.SchemaNamespace));
StringAssert.Contains("[Key]", code);
StringAssert.Contains("[Required]", code);
StringAssert.Contains("[Table", code);
StringAssert.Contains("virtual public Supplier Supplier {get;set;}", code);
StringAssert.DoesNotContain("public class Product :", code);
StringAssert.Contains("System.ComponentModel.DataAnnotations.Schema", code);
StringAssert.Contains("System.ComponentModel.DataAnnotations", code);
}
public void Property_declaration_test()
{
// Arrange
var setting = new PocoSetting
{
AddEager = false,
AddNavigation = true,
Attributes = new List <string> {
"key", "json"
},
};
_attributeManager.Init(setting);
var property = new PropertyTemplate
{
PropName = "ProductId",
PropType = "int",
PropComment = "// not null",
IsKey = true
};
// Act
string sut = new PropertyGenerator(property, setting);
var expected = @"
[Key]
[JsonProperty(PropertyName = ""ProductId"")]
public virtual int ProductId {get;set;} // not null
";
// Assert
Assert.That(sut, Does.Match(expected.GetRegexPattern()));
}
public void JsonAttributeWithCamelCasePropertyDeclaration_test()
{
// Arrange
var setting = new PocoSetting
{
AddJsonAttribute = true,
NameCase = CaseEnum.Camel
};
_attributeManager.Init(setting);
PropertyTemplate property = new PropertyTemplate
{
PropName = "CategoryID",
PropType = "int",
IsKey = true
};
// Act
var sut = new PropertyGenerator(property, setting);
// Assert
var expected =
$"[JsonProperty(PropertyName = \"CategoryID\")] {Constant.NewLine}public int categoryID {{get;set;}} ";
Assert.AreEqual(sut.ToString().TrimAllSpace(), expected.TrimAllSpace());
}
public void Property_attributes_test(string att, string expected)
{
// Arrange
var setting = new PocoSetting
{
Attributes = new List <string> {
att
}
};
_attributeManager.Init(setting);
var property = new PropertyTemplate
{
PropName = "ProductId",
PropType = "string",
Serial = 1,
IsKey = true,
};
// Act
string sut = new PropertyGenerator(property, setting);
// Assert
Assert.IsTrue(sut.Contains(expected));
}
public void AllAttributesPropertyDeclaration_test()
{
// Arrange
var setting = new PocoSetting
{
AddKeyAttribute = true,
AddRequiredAttribute = true,
AddJsonAttribute = true
};
_attributeManager.Init(setting);
PropertyTemplate property = new PropertyTemplate
{
PropName = "CategoryID",
PropType = "int",
IsKey = true
};
// Act
var sut = new PropertyGenerator(property, setting);
// Assert
Assert.IsTrue(sut.ToString().Contains("[Key]") &&
sut.ToString().Contains("[Required]") &&
sut.ToString().Contains("[JsonProperty(PropertyName = \"CategoryID\")]"));
}
public O2P(string url, string user, string password)
{
Url = url;
User = user;
Password = password;
Setting = new PocoSetting();
}
/// <summary>
/// Initialize factory with setting.Attributes
/// </summary>
/// <param name="setting"></param>
/// <returns></returns>
public AttributeFactory Init(PocoSetting?setting = null)
{
if (setting == null)
{
setting = new PocoSetting();
}
//obsolet: -k -q -j -t are replaced by -a <names>
var list = setting.Attributes;
if (setting.AddKeyAttribute && !list.Contains("key"))
{
list.Add("key");
}
if (setting.AddRequiredAttribute && !list.Contains("req"))
{
list.Add("req");
}
if (setting.AddTableAttribute && !list.Contains("tab"))
{
list.Add("tab");
}
// case "json":
if (setting.AddJsonAttribute && !list.Contains("json"))
{
list.Add("json");
}
_attributes = new List <string>(setting.Attributes);//add attributes of commandline options
return(this);
}
public void Type_is_enum_with_flags_test()
{
//Arrange
var setting = new PocoSetting();
var ct = new ClassTemplate
{
Name = "Feature",
NameSpace = "SP",
IsEnum = true,
IsFlags = true,
EnumElements = new List <string> {
"Feature0", "Feature1"
}
};
var gen = Moq.Moq4IPocoGenerator(ct);
//Act
var sut = new PocoClassGeneratorCs(gen, setting);
var code = sut.ClassToString(ct);
//Assert
var expected = @"
[Flags] public enum Feature
{
Feature0,
Feature1
}
";
Assert.That(code.TrimAllSpace(), Does.Contain(expected.TrimAllSpace()));
}
internal Poco(MetaDataInfo metaData, PocoSetting setting)
{
_setting = setting ?? new PocoSetting();
MetaData = metaData;
SchemaErrors = new List <string>();
EntitySets = new List <IEdmEntitySet>();
}
public void ClassTemplate_All_Attributes_With_SettingTest()
{
// Arrange
var p = new ClassTemplate()
{
Name = "ProductDetail",
EntitySetName = "productDetail"
};
var setting = new PocoSetting()
{
Attributes = new List <string>(list),
};
var atts = AttributeFactory.Default
.Init(setting)
.GetAllAttributes(p);
var match = ListCheck(atts, new List <string>
{
"[DataContract]",
"[Table(\"productDetail\")]",
"[ProtoContract]",
});
Assert.IsTrue(match);
}
public void RequiredAttributePropertyDeclaration_test()
{
// Arrange
var setting = new PocoSetting
{
AddRequiredAttribute = true
};
_attributeManager.Init(setting);
PropertyTemplate property = new PropertyTemplate
{
PropName = "CategoryID",
PropType = "int",
IsKey = true
};
// Act
var sut = new PropertyGenerator(property, setting);
// Assert
var expected = @"
[Required]
public int CategoryID {get;set;} ";
Assert.AreEqual(sut.ToString().TrimAllSpace(), expected.TrimAllSpace());
}
public void PropertyTemplate_All_Attributes_With_SettingTest()
{
// Arrange
PropertyTemplate p = new PropertyTemplate
{
PropName = "FirstName",
PropType = "string",
IsKey = true,
Serial = 1,
};
var setting = new PocoSetting()
{
Attributes = new List <string>(list),
};
var atts = AttributeFactory.Default
.Init(setting)
.GetAllAttributes(p);
var match = ListCheck(atts, new List <string>
{
"[ProtoMember(1)]",
"[DataMember]",
" [Key]",
"[Required]",
"[Display(Name = \"First Name\")]",
"[JsonProperty(PropertyName = \"FirstName\")]",
});
Assert.IsTrue(match);
}
public void PropertyTemplate_with_seeting_Attribute_Test(string name, string expected)
{
// Arrange
PropertyTemplate p = new PropertyTemplate
{
PropName = "FirstName",
PropType = "string",
IsKey = true,
Serial = 1,
};
//Act
var setting = new PocoSetting
{
Attributes = new List <string> {
name
}
};
var sut = AttributeFactory.Default
.Init(setting)
.GetAllAttributes(p);
var att = string.Join(" ", sut);
//Assert
Assert.AreEqual(expected, att);
}
public void AddAsemplyTest()
{
var pocosetting = new PocoSetting();
AssemplyManager am = new AssemplyManager(pocosetting, new ConcurrentDictionary <string, ClassTemplate>());
am.AddAssemply("xyz");
Assert.IsTrue(am.AssemplyReference.Exists(m => m.Contains("xyz")));
}
/// <summary>
/// cto initialization
/// </summary>
/// <param name="pocoSetting">Seting parameters of generating code</param>
/// <param name="model">The model containing all classes </param>
public AssemplyManager(PocoSetting pocoSetting, IDictionary <string, ClassTemplate> model)
{
_pocoSetting = pocoSetting;
_model = model;
AssemplyReference = new List <string>();
AddAssemply(DefaultAssemply);//add default assemplies
AddAssemplyReferenceList();
}
public void AddAsemplyArrayTest()
{
var pocosetting = new PocoSetting();
AssemplyManager am = new AssemplyManager(pocosetting, new List <ClassTemplate>());
am.AddAssemply("xyz", "abc");
Assert.IsTrue(am.AssemplyReference.Exists(m => m.Contains("xyz")));
Assert.IsTrue(am.AssemplyReference.Exists(m => m.Contains("abc")));
}
public async Task web_api2_v3_mult_namespace_class_and_enum_Test()
{
var conn = new OdataConnectionString
{
ServiceUrl = TestSample.MultiSchemaV3,
};
var setting = new PocoSetting
{
Lang = Language.CS,
NameCase = CaseEnum.None,
};
var o2P = new O2P(setting);
var code = await o2P.GenerateAsync(conn);
var expected = @"
namespace ODataDemo
{
public partial class Customer
{
public int ID {get;set;} //PrimaryKey not null
public string CustomerName {get;set;}
public string Address {get;set;}
}
public partial class Location
{
public string Address {get;set;}
public string City {get;set;}
}
}
namespace ODataDemo2
{
public partial class Customer
{
public int ID {get;set;} //PrimaryKey not null
public string CustomerName {get;set;}
public string Address {get;set;}
}
public partial class Customer2
{
public int ID {get;set;} //PrimaryKey not null
public string CustomerName {get;set;}
public string Address {get;set;}
}
public enum Feature
{
Feature1=0,
Feature2=1,
Feature3=2,
Feature4=3
}
}
";
//Assert
Assert.That(code.TrimAllSpace(), Does.Contain(expected.TrimAllSpace()));
}
public void InheritanceDisabledWithInheritSettingTest()
{
var setting = new PocoSetting
{
Inherit = "MyBaseClass",
};
var o2p = new O2P(setting);
Assert.IsFalse(o2p.Setting.UseInheritance);
}
//{"required" ,"System.ComponentModel.DataAnnotations.Schema"},
//{"table" ,"System.ComponentModel.DataAnnotations.Schema"},
//{"json","Newtonsoft.Json"},
////assemplies for datatype
//{"geometry","Microsoft.Spatial"},
//{"geography", "Microsoft.Spatial"}
public void AddAsemplyByKey(string key, string value)
{
var pocosetting = new PocoSetting
{
AddKeyAttribute = true
};
AssemplyManager am = new AssemplyManager(pocosetting, new ConcurrentDictionary <string, ClassTemplate>());
Assert.IsTrue(am.AssemplyReference.Exists(m => m.Contains(value)));
}
public void AddAsemplyMultiAttributes()
{
var pocosetting = new PocoSetting
{
AddTableAttribute = true,
AddRequiredAttribute = true
};
AssemplyManager am = new AssemplyManager(pocosetting, new ConcurrentDictionary <string, ClassTemplate>());
Assert.IsTrue(am.AssemplyReference.Exists(m => m.Contains("System.ComponentModel.DataAnnotations.Schema")));
}
public void AddExternalAsemply()
{
var pocosetting = new PocoSetting
{
AddTableAttribute = true,
AddRequiredAttribute = true
};
AssemplyManager am = new AssemplyManager(pocosetting, new List <ClassTemplate>());
am.AddAssemply("xyz");
Assert.IsTrue(am.AssemplyReference.Exists(m => m.Contains("System.ComponentModel.DataAnnotations.Schema")));
Assert.IsTrue(am.AssemplyReference.Exists(m => m.Contains("xyz")));
}
public async Task Filter_by_namespace_Test()
{
var url = TestSample.NorthWindV4;
var connString = new OdataConnectionString {
ServiceUrl = url
};
var setting = new PocoSetting {
Include = new List <string> {
"NorthwindModel*"
}
};
var o2p = new O2P(setting);
var code = await o2p.GenerateAsync(connString);
Assert.IsTrue(code.Contains("public partial class Product"));
}
public void ReducedBaseTyp_in_the_same_namespace_test()
{
//Arrange
var setting = new PocoSetting();
var ct = new ClassTemplate {
Name = "Folder", NameSpace = "SP", BaseType = "SP.FileSystem"
};
var gen = Moq.Moq4IPocoGenerator(ct);
//Act
var sut = new PocoClassGeneratorCs(gen, setting);
var reducedType = sut.ReducedBaseTyp(ct);
//Assert
Assert.That(reducedType, Is.EqualTo("FileSystem"));
}
public void code_generation_with_multi_namespace_test()
{
//Arrange
var setting = new PocoSetting();
var list = new List <ClassTemplate>
{
new ClassTemplate {
Name = "Folder", NameSpace = "SP"
},
new ClassTemplate {
Name = "Folder", NameSpace = "SP2", BaseType = "SP.Folder"
},
new ClassTemplate {
Name = "File", NameSpace = "SP2"
},
};
var gen = Moq.Moq4IPocoGenerator(list);
//Act
var sut = new PocoClassGeneratorCs(gen, setting);
var code = sut.GeneratePoco();
//Assert
var expected = @"
using SP;
using SP2;
namespace SP
{
public partial class Folder
{
}
}
namespace SP2
{
public partial class Folder : SP.Folder
{
}
public partial class File
{
}
}
";
Assert.That(code.TrimAllSpace(), Does.Contain(expected.TrimAllSpace()));
}
public void Class_renamed_has_no_json_attribute_test()
{
//Arrange
var setting = new PocoSetting();
var ct = new ClassTemplate {
Name = "Event", NameSpace = "SP", OriginalName = "event"
};
var gen = Moq.Moq4IPocoGenerator(ct);
//Act
var sut = new PocoClassGeneratorCs(gen, setting);
var code = sut.ClassToString(ct);
//Assert
var expected = "public partial class Event";
Assert.That(code, Does.Contain(expected));
}
public CsCommand(Options options, IPocoFileSystem fileSystem)
{
if (fileSystem == null)
{
_fileSystem = new NullFileSystem();
}
else
{
_fileSystem = fileSystem;
}
Errors = new List <string>();
ArgOptions = optionManager = new OptionManager(options);
odataConnectionString = optionManager.GetOdataConnectionString();
PocoSettingOptions = optionManager.GetPocoSetting();
O2PGen = new O2P(PocoSettingOptions);
}
public void rename_reserved_keyword_test()
{
//Arrange
var setting = new PocoSetting();
var ct = new ClassTemplate {
Name = "event", NameSpace = "SP", BaseType = "SP.FileSystem", OriginalName = "event"
};
var gen = Moq.Moq4IPocoGenerator(ct);
//Act
var sut = new PocoClassGeneratorCs(gen, setting);
var name = sut.ClassList.FirstOrDefault()?.Name;
//Assert
Assert.That(sut.ClassList.Count, Is.EqualTo(1));
Assert.That(name, Is.EqualTo("Event"));
}
public void Property_has__type_collection_without_prefix_namespac_test()
{
// Arrange
var setting = new PocoSetting();
var property = new PropertyTemplate
{
PropName = "Table",
PropType = "List<SimpleDataTable>",
ClassNameSpace = "SP1",
};
var expected = "public List<SimpleDataTable> Table {get;set;}";
// Act
string sut = new PropertyGenerator(property, setting);
// Assert
Assert.IsTrue(sut.Contains(expected));
}
public void Class_basetype_has_different_namespace_test()
{
//Arrange
var setting = new PocoSetting();
var ct = new ClassTemplate {
Name = "Folder", NameSpace = "SP1", BaseType = "SP.FileSystemItem"
};
var gen = Moq.Moq4IPocoGenerator(ct);
var sut = new PocoClassGeneratorCs(gen, setting);
//Act
var code = sut.ClassToString(ct);
//Assert
var expected = "public partial class Folder : SP.FileSystemItem";
Assert.That(code, Does.Contain(expected));
}
public void Class_is_complex_test()
{
//Arrange
var setting = new PocoSetting();
var ct = new ClassTemplate {
Name = "Folder", NameSpace = "SP", IsComplex = true
};
var gen = Moq.Moq4IPocoGenerator(ct);
//Act
var sut = new PocoClassGeneratorCs(gen, setting);
var code = sut.ClassToString(ct);
//Assert
var expected = "public partial class Folder";
Assert.That(code, Does.Contain(expected));
}
public async Task<string> BaseTest(string url, string version, int n, PocoSetting setting )
{
O2P o2P = new O2P(setting);
var code = await o2P.GenerateAsync(new Uri(url) );
// var metaString = await o2P.SaveMetaDataTo("north.xml");
if (o2P.MediaType == Media.Http)
{
Assert.Greater(o2P.ServiceHeader.Count, 0);
}
Debug.WriteLine(code);
//Debug.WriteLine(metaString);
Assert.AreEqual(o2P.MetaDataVersion, version);
Assert.AreEqual(o2P.ClassList.Count, n);
Assert.IsTrue(code.Contains(o2P.SchemaNamespace));
//Assert.IsTrue(MatchFileContent("north.cs", code));
//Assert.IsTrue(MatchFileContent("north.xml", metaString));
return code;
}
public O2P()
{
// _fluent = new Api.O2P( )
Setting = new PocoSetting();
}
public O2P(string url)
{
Url = url;
Setting = new PocoSetting();
}
