public void TestEqualsTrue()
{
IFilter filter1 = new PropertyTypeFilter("casa");
IFilter filter2 = new PropertyTypeFilter("casa");
Assert.IsTrue(filter1.Equals(filter2));
}
public void TestEqualsFalse()
{
IFilter filter1 = new PropertyTypeFilter("casa");
IFilter filter2 = new PropertyTypeFilter("apartamento");
Assert.IsFalse(filter1.Equals(filter2));
}
public void TestParseInputMultiplesFiltros()
{
Database database = SingleInstance <DatabaseMap> .GetInstance.GetDatabaseInstance(1);
IInterpreter interpreter = new SimpleInterpreter();
// se la crea para setearla en la database debido a que eso solo se realiza de forma
// automática en el programa al recibir mensajes
ConsoleChannel console = new ConsoleChannel();
database.SetAdapter(console);
TransactionTypeFilter transactionTypeFilter = new TransactionTypeFilter("compra");
DepartmentFilter departmentFilter = new DepartmentFilter("canelones");
PropertyTypeFilter propertyTypeFilter = new PropertyTypeFilter("casa");
List <IFilter> filters = new List <IFilter>();
filters.Add(transactionTypeFilter);
filters.Add(departmentFilter);
filters.Add(propertyTypeFilter);
database.SetState(Status.WaitingTransactionType);
interpreter.ParseInput(1, "2");
interpreter.ParseInput(1, "canelones");
interpreter.ParseInput(1, "1");
Assert.IsTrue(database.GetFilters().SequenceEqual(filters));
}
public void TestAskAndParseAPI()
{
Database database = new Database(1);
Database database2 = new Database(5);
APIInfoCasas apiCore = new APIInfoCasas();
ICApi api = new ICApi();
api.SetDepartment("montevideo");
api.SetPropertyTypes(new PropertyType[] { PropertyType.Apartamento });
api.SetTransactionType(TransactionType.Alquiler);
api.SetCitiesAndNeighbourhoods(new string[] { "buceo" });
List <IFilter> filters = new List <IFilter>();
DepartmentFilter department = new DepartmentFilter("montevideo");
PropertyTypeFilter propertyTypeFilter = new PropertyTypeFilter("apartamento");
TransactionTypeFilter transactionTypeFilter = new TransactionTypeFilter("alquiler");
NeighbourhoodFilter neighbourhoodFilter = new NeighbourhoodFilter("buceo");
filters.Add(department);
filters.Add(propertyTypeFilter);
filters.Add(transactionTypeFilter);
filters.Add(neighbourhoodFilter);
apiCore.AskAPI(filters, 1);
List <ICApiSearchResult> apiResult = api.Search();
apiCore.Parse(apiResult, 5, "buceo");
Assert.IsTrue(database.GetPropertyList().SequenceEqual(database2.GetPropertyList()));
}
public void ReturnsPropertyWithGivenType()
{
Assert.Same(selected, members.Property(propertyType));
PropertyTypeFilter filter = VerifyFilter(selection, propertyType);
Assert.Same(properties, filter.Source);
}
public static Property Property(this IMembers members, Type propertyType, string propertyName)
{
var typed = new PropertyTypeFilter(members.Properties(), propertyType);
var named = new MemberNameFilter <Property, PropertyInfo>(typed, propertyName);
return(named.Single());
}
public void ReturnsPropertyWithGivenType()
{
Assert.Same(selected, instance.Property(propertyType));
PropertyTypeFilter named = VerifyFilter(selection, propertyType);
VerifyInstanceProperties(named.Source, instance);
}
public void ReturnsPropertyWithGivenTypeAndName()
{
Assert.Same(selected, members.Property(propertyType, propertyName));
MemberNameFilter <Property, PropertyInfo> nameFilter = VerifyFilter(selection, propertyName);
PropertyTypeFilter typeFilter = VerifyFilter(nameFilter.Source, propertyType);
Assert.Same(properties, typeFilter.Source);
}
public void ReturnsGenericPropertyOfGivenType()
{
Property <PropertyValue> generic = instance.Property <PropertyValue>();
VerifyGenericProperty(selected, generic);
PropertyTypeFilter typed = VerifyFilter(selection, typeof(PropertyValue));
VerifyInstanceProperties(typed.Source, instance);
}
public void ReturnsPropertyWithGivenTypeAndName()
{
Assert.Same(selected, instance.Property(propertyType, propertyName));
MemberNameFilter <Property, PropertyInfo> named = VerifyFilter(selection, propertyName);
PropertyTypeFilter typed = VerifyFilter(named.Source, propertyType);
VerifyInstanceProperties(typed.Source, instance);
}
public void ReturnsGenericPropertyWithGivenType()
{
Property <PropertyValue> generic = members.Property <PropertyValue>();
VerifyGenericProperty(selected, generic);
PropertyTypeFilter typeFilter = VerifyFilter(selection, typeof(PropertyValue));
Assert.Same(properties, typeFilter.Source);
}
public void TestAddFilter()
{
Database database = new Database(1);
database.AddFilter(new PropertyTypeFilter("casa"));
IFilter filter = new PropertyTypeFilter("casa");
Assert.IsTrue(database.GetFilters()[0].Equals(filter));
}
public void ReturnsGenericPropertyWithGivenTypeAndName()
{
Property <PropertyValue> generic = members.Property <PropertyValue>(propertyName);
VerifyGenericProperty(selected, generic);
MemberNameFilter <Property, PropertyInfo> nameFilter = VerifyFilter(selection, propertyName);
PropertyTypeFilter typeFilter = VerifyFilter(nameFilter.Source, propertyType);
Assert.Same(properties, typeFilter.Source);
}
public void ReturnsGenericPropertyWithGivenTypeAndName()
{
Property <PropertyValue> generic = instance.Property <PropertyValue>(propertyName);
VerifyGenericProperty(selected, generic);
MemberNameFilter <Property, PropertyInfo> named = VerifyFilter(selection, propertyName);
PropertyTypeFilter typed = VerifyFilter(named.Source, typeof(PropertyValue));
VerifyInstanceProperties(typed.Source, instance);
}
public void AddProperties(StringBuilderWrapper sb, MetadataType type, bool includeResponseStatus)
{
var wasAdded = false;
var isClass = Config.ExportAsTypes && !type.IsInterface.GetValueOrDefault();
var modifier = isClass ? "public " : "";
var dataMemberIndex = 1;
if (type.Properties != null)
{
foreach (var prop in type.Properties)
{
if (wasAdded)
{
sb.AppendLine();
}
var propType = Type(prop.GetTypeName(Config, allTypes), prop.GenericArgs);
var optionalProperty = propType.EndsWith("?");
if (optionalProperty)
{
propType = propType.Substring(0, propType.Length - 1);
}
propType = PropertyTypeFilter?.Invoke(this, type, prop) ?? propType;
var optional = IsPropertyOptional(this, type, prop) ?? optionalProperty
? "?"
: "";
wasAdded = AppendComments(sb, prop.Description);
wasAdded = AppendDataMember(sb, prop.DataMember, dataMemberIndex++) || wasAdded;
wasAdded = AppendAttributes(sb, prop.Attributes) || wasAdded;
sb.AppendLine(modifier + "{1}{2}: {0};".Fmt(propType, prop.Name.SafeToken().PropertyStyle(), optional));
}
}
if (includeResponseStatus)
{
if (wasAdded)
{
sb.AppendLine();
}
AppendDataMember(sb, null, dataMemberIndex++);
sb.AppendLine(modifier + "{0}{1}: ResponseStatus;".Fmt(
nameof(ResponseStatus).PropertyStyle(), Config.ExportAsTypes ? "" : "?"));
}
}
public void TestEqualsNullException()
{
IFilter filter1 = new PropertyTypeFilter("casa");
IFilter filter2 = null;
// el test pasa dado que nunca se llega al Assert.Fail (el equals lanza excepción)
// y se hace el catch del tipo correcto (NullReferenceException)
try
{
filter1.Equals(filter2);
Assert.Fail();
}
catch (NullReferenceException)
{
}
}
public void TestGetFilters()
{
Database database = new Database(1);
List <IFilter> filters = new List <IFilter>();
database.AddFilter(new PropertyTypeFilter("casa"));
database.AddFilter(new NeighbourhoodFilter("axh"));
database.AddFilter(new DepartmentFilter("fsgf"));
IFilter filter1 = new PropertyTypeFilter("casa");
IFilter filter2 = new NeighbourhoodFilter("axh");
IFilter filter3 = new DepartmentFilter("fsgf");
filters.Add(filter1);
filters.Add(filter2);
filters.Add(filter3);
Assert.IsTrue(database.GetFilters().SequenceEqual(filters));
}
