public bool EndDateLaterThanStartDate(DiscountShortDto discount)
{
if (discount.EndDate != null)
{
return(discount.EndDate.Value.Date >= discount.StartDate.Date);
}
return(true);
}
public async Task CanValidateAddressesAreFromVendor()
{
var discount = new DiscountShortDto {
AddressesIds = new List <int> {
1
}
};
Assert.True(await Task.FromResult(_validationService.AddressesAreFromVendor(_mapper.Map <VendorDto>(_vendor),
new List <DiscountShortDto> {
discount
})));
discount.AddressesIds = new List <int> {
2
};
Assert.False(await Task.FromResult(
_validationService.AddressesAreFromVendor(_mapper.Map <VendorDto>(_vendor),
new List <DiscountShortDto> {
discount
})));
}
public VendorValidatorTests()
{
_tagValidationService = new Mock <ITagValidationService>();
_categoryValidationService = new Mock <ICategoryValidationService>();
_vendorValidationService = new Mock <IVendorValidationService>();
_discountValidationService = new Mock <IDiscountValidationService>();
_methodProvider = new Mock <IMethodProvider>();
_vendorValidator = new VendorValidator(_vendorValidationService.Object,
_discountValidationService.Object, _categoryValidationService.Object,
_tagValidationService.Object, _methodProvider.Object);
_vendors = new List <VendorDto>
{
new VendorDto
{
Id = Guid.NewGuid(),
Name = "Food vendor",
Addresses = new List <AddressDto>
{
new AddressDto
{
Id = 1,
CountryId = Guid.NewGuid(),
CityId = Guid.NewGuid(),
Street = "Street"
}
},
Phones = new List <PhoneDto>
{
new PhoneDto
{
Id = 1,
Number = "201-20-12"
}
}
},
new VendorDto
{
Id = Guid.NewGuid(),
Name = "Sport vendor",
Addresses = new List <AddressDto>
{
new AddressDto
{
CountryId = Guid.NewGuid(),
CityId = Guid.NewGuid(),
Street = "Street2"
}
}
}
};
_vendorValidationService.Setup(s => s.VendorExistsAsync(It.IsAny <Guid>(), CancellationToken.None))
.Returns((Guid id, CancellationToken token) =>
Task.FromResult(_vendors.Any(c => c.Id == id)));
_vendorValidationService.Setup(s => s.VendorNotExistsAsync(It.IsAny <Guid>(), CancellationToken.None))
.Returns((Guid id, CancellationToken token) =>
Task.FromResult(_vendors.All(c => c.Id != id)));
_vendorValidationService.Setup(s => s.VendorNameNotExists(It.IsAny <string>(), CancellationToken.None))
.Returns((string name, CancellationToken token) =>
Task.FromResult(_vendors.All(c => c.Name != name)));
_vendorValidationService.Setup(s => s.VendorNameChangedAndNotExists(It.IsAny <Guid>(),
It.IsAny <string>(), CancellationToken.None))
.Returns((Guid id, string name, CancellationToken token) =>
{
var category = _vendors.First(c => c.Id == id);
if (category.Name == name)
{
return(Task.FromResult(true));
}
return(Task.FromResult(_vendors.All(c => c.Name != name)));
});
_vendorValidationService.Setup(s => s.PhonesAreUnique(It.IsAny <IEnumerable <int> >()))
.Returns((IEnumerable <int> ids) =>
{
var list = ids.ToList();
return(list.Count == list.Distinct().Count());
});
_vendorValidationService.Setup(s => s.AddressesIdsAreUnique(It.IsAny <IEnumerable <int> >()))
.Returns((IEnumerable <int> ids) =>
{
var list = ids.ToList();
return(list.Count == list.Distinct().Count());
});
_vendorValidationService.Setup(s => s.StreetWithCity(It.IsAny <AddressDto>()))
.Returns((AddressDto address) =>
{
if (string.IsNullOrEmpty(address.Street))
{
return(true);
}
return(address.CityId.HasValue);
});
_vendorValidationService
.Setup(s => s.AddressExists(It.IsAny <Guid>(), It.IsAny <Guid?>(), CancellationToken.None))
.Returns(Task.FromResult(true));
_vendorValidationService
.Setup(s => s.AddressesAreUnique(It.IsAny <IEnumerable <AddressDto> >()))
.Returns((IEnumerable <AddressDto> addresses) =>
{
var addressesList = addresses.ToList();
return(addressesList.Count == addressesList
.GroupBy(a => new { a.CountryId, a.CityId, a.Street })
.Select(g => g)
.Count());
});
_vendorValidationService
.Setup(s => s.AddressesAreFromVendor(It.IsAny <VendorDto>(), It.IsAny <IEnumerable <DiscountShortDto> >()))
.Returns((VendorDto vendor, IEnumerable <DiscountShortDto> vendorDiscounts) =>
{
var discountAddressesIds = vendorDiscounts.SelectMany(d => d.AddressesIds)
.Distinct()
.ToList();
var vendorAddressesIds = vendor.Addresses.Select(p => p.Id);
return(discountAddressesIds.All(id => vendorAddressesIds.Contains(id)));
});
_vendorValidationService
.Setup(s => s.PhonesAreFromVendorAsync(It.IsAny <VendorDto>(), It.IsAny <IEnumerable <DiscountShortDto> >(), CancellationToken.None))
.Returns((VendorDto vendor, IEnumerable <DiscountShortDto> vendorDiscounts, CancellationToken token) =>
{
var discountPhonesIds = vendorDiscounts.SelectMany(d =>
{
if (d.PhonesIds != null)
{
return(d.PhonesIds);
}
return(new List <int>());
})
.Distinct()
.ToList();
if (vendor.Phones != null)
{
var newPhonesIds = vendor.Phones.Select(p => p.Id).ToList();
if (vendor.Id != Guid.Empty)
{
var oldVendor = _vendors.First(v => v.Id == vendor.Id);
if (oldVendor != null)
{
var vendorPhonesIds = oldVendor.Phones.Select(a => a.Id);
var phonesToBeRemoved = vendorPhonesIds
.Where(p => !newPhonesIds.Contains(p)).ToList();
if (phonesToBeRemoved.Any())
{
return(Task.FromResult(discountPhonesIds.All(p => newPhonesIds.Contains(p) ||
phonesToBeRemoved.Contains(p))));
}
return(Task.FromResult(discountPhonesIds.All(p => newPhonesIds.Contains(p))));
}
}
else
{
return(Task.FromResult(discountPhonesIds.All(p => newPhonesIds.Contains(p))));
}
}
else
{
if (discountPhonesIds.Any() && vendor.Id == Guid.Empty)
{
return(Task.FromResult(false));
}
}
return(Task.FromResult(true));
});
_vendorValidationService
.Setup(s => s.AddressesCanBeRemovedAsync(It.IsAny <VendorDto>(), CancellationToken.None))
.Returns((VendorDto vendor, CancellationToken token) =>
{
var oldVendor = _vendors.First(v => v.Id == vendor.Id);
var vendorAddressesIds = oldVendor.Addresses.Select(a => a.Id);
var newAddressesIds = vendor.Addresses.Select(a => a.Id).ToList();
var addressesToBeRemoved = vendorAddressesIds
.Where(a => !newAddressesIds.Contains(a)).ToList();
if (addressesToBeRemoved.Any())
{
var discountAddresses = vendor.Discounts
.SelectMany(d => d.AddressesIds)
.Distinct()
.ToList();
if (discountAddresses.Any(a => addressesToBeRemoved.Contains(a)))
{
return(Task.FromResult(false));
}
}
return(Task.FromResult(true));
});
_discount = new DiscountShortDto
{
Id = Guid.NewGuid(),
VendorId = _vendors[0].Id,
VendorName = _vendors[0].Name,
AddressesIds = new List <int>
{
_vendors[0].Addresses.ElementAt(0).Id
},
PhonesIds = new List <int>
{
_vendors[0].Phones.ElementAt(0).Id
}
};
var discounts = new List <DiscountShortDto>
{
_discount
};
_discountValidationService.Setup(s => s.DiscountNotExists(It.IsAny <Guid>(), CancellationToken.None))
.Returns((Guid id, CancellationToken token) =>
Task.FromResult(discounts.All(d => d.Id != id)));
_discountValidationService.Setup(s => s.EndDateLaterThanStartDate(It.IsAny <DiscountShortDto>()))
.Returns((DiscountShortDto discount) =>
{
if (discount.EndDate != null)
{
return(discount.EndDate.Value.Date >= discount.StartDate.Date);
}
return(true);
});
_categories = new List <CategoryDto>
{
new CategoryDto
{
Id = Guid.NewGuid(),
Name = "Food"
},
new CategoryDto
{
Id = Guid.NewGuid(),
Name = "Sport"
}
};
_categoryValidationService.Setup(s => s.CategoryExistsAsync(It.IsAny <Guid>(), CancellationToken.None))
.Returns((Guid id, CancellationToken token) =>
Task.FromResult(_categories.Any(c => c.Id == id)));
var tags = new List <TagDto>
{
new TagDto
{
Id = Guid.NewGuid(),
Name = "Pizza"
},
new TagDto
{
Id = Guid.NewGuid(),
Name = "Sushi"
}
};
_tagValidationService.Setup(s => s.TagExistsAsync(It.IsAny <Guid>(), CancellationToken.None))
.Returns((Guid id, CancellationToken token) =>
Task.FromResult(tags.Any(c => c.Id == id)));
}
