public void WhenMinimumValueIsNull_ShouldNotThrow()
{
const string?myArgument = "A";
var result = Should.NotThrow(() => GuardAgainst.ArgumentBeingLessThanMinimum(myArgument, null));
Assert.Equal(myArgument, result);
}
/// <summary>
/// Creates a new Authenticated Session
/// </summary>
/// <param name="authenticator"><see cref="IAuthenticator"/> and its implementations:
/// <seealso cref="StoredAuthenticator"/>
/// <seealso cref="UserPassAuthenticator"/>
/// </param>
/// <param name="cts">Cancellation token for the asynchronous operation.</param>
/// <param name="deviceType"><see cref="DeviceType"/></param>
/// <param name="deviceName">string to display on spotify connect</param>
/// <param name="conf">Configuration file. See <see cref="Configuration"/></param>
/// <param name="ws">An implementation of the abstract class: <see cref="WebsocketHandler"/></param>
/// <param name="preferredLocale">2 letter locale code. Default = English</param>
/// <param name="overrideAdress"></param>
/// <returns><see cref="SpotifySession"/></returns>
/// <exception cref="UnauthorizedAccessException">When trying to authenticated with <seealso cref="StoredAuthenticator"/> but no file is saved</exception>
/// <exception cref="SpotifyAuthenticatedException">When credentials are invalid.</exception>
public static async Task <SpotifySession> CreateAsync(
IAuthenticator authenticator,
CancellationToken cts,
DeviceType deviceType,
string deviceName,
Configuration conf,
WebsocketHandler ws,
string preferredLocale = "en",
string overrideAdress = null)
{
Cache = new MemoryCache(new MemoryCacheOptions());
GuardAgainst.ArgumentBeingNull(authenticator);
// TimeProvider.Init(conf);
var deviceId = Utils.RandomHexString(new Random(), 40).ToLower();
var session =
new SpotifySession(
new Inner(deviceType,
deviceName,
deviceId,
preferredLocale,
conf),
cts,
overrideAdress)
{
loginCredentials = await authenticator.Get()
};
await session.conn;
session.Connect();
await session.Authenticate(session.loginCredentials, ws);
return(session);
}
public void WhenArgumentIsInRange_ShouldNotThrow()
{
const int myArgument = 3;
var result = Should.NotThrow(() => GuardAgainst.ArgumentBeingOutOfRange(myArgument, 2, 4));
Assert.Equal(myArgument, result);
}
public void WhenArgumentIsNotEmptyGuid_ShouldNotThrow()
{
var myArgument = new Guid("1e750e0a-f9be-4d31-a78e-590325cb7045");
var result = Should.NotThrow(() => GuardAgainst.ArgumentBeingEmpty(myArgument));
Assert.Equal(myArgument, result);
}
public Task <PagedNameViewModel> Handle(GetContinentNamesLikeNameQuery request, CancellationToken cancellationToken)
{
var name = request.Name;
var pageNumber = request.PageNumber;
var pageSize = request.PageSize;
GuardAgainst.LessThanOrEqualToZero(pageNumber, nameof(pageNumber));
GuardAgainst.LessThanOrEqualToZero(pageSize, nameof(pageSize));
return(_repository.GetContinentNamesLikeName(name, pageNumber, pageSize)
.ContinueWith(t =>
{
GuardAgainst.FaultedOrCancelled(t);
var count = _repository
.GetTotalCountOfContinentNamesLikeName(name)
.ResultIfGreaterThanZero(cancellationToken);
return new PagedNameViewModel
{
Count = count,
PageNumber = pageNumber,
PageSize = pageSize,
Items = t.Result.ToList()
};
}, cancellationToken));
}
public void WhenArgumentIsLessThanMaximum_ShouldNotThrow()
{
const int myArgument = 1;
var result = Should.NotThrow(() => GuardAgainst.ArgumentBeingGreaterThanMaximum(myArgument, 2));
Assert.Equal(myArgument, result);
}
public void WhenArgumentValueIsNull_ShouldNotThrow()
{
const string?myArgument = null;
var result = Should.NotThrow(() => GuardAgainst.ArgumentBeingOutOfRange(myArgument, "B", "D"));
Assert.Equal(myArgument, result);
}
public IPlayableId GetCurrentPlayableOrThrow()
{
var id = GetCurrentPlayable();
GuardAgainst.ArgumentBeingNull(id);
return(id);
}
/// <inheritdoc/>
public Task <Province?> GetProvinceByName(string name)
{
var query = $"select * from Provinces where Name = '{name}'";
return(_dbContext.Provinces.FromSqlRaw(query).AsNoTracking().FirstOrDefaultAsync()
.ContinueWith(t =>
{
GuardAgainst.FaultedOrCancelled(t);
var province = t.Result;
if (province == null)
{
return null;
}
var country = _dbContext.Countries
.AsNoTracking()
.FirstOrDefault(c => c.Id == province.CountryId);
if (country != null)
{
province.SetCountry(country);
}
return province;
}));
}
/// <inheritdoc/>
public Task <PagedNameViewModel> Handle(GetProvinceNamesLikeNameQuery request, CancellationToken cancellationToken)
{
GuardAgainst.NullOrEmpty(request.Name, "name");
GuardAgainst.LessThanOrEqualToZero(request.PageNumber, "pageNumber");
GuardAgainst.LessThanOrEqualToZero(request.PageSize, "pageSize");
var pageNumber = request.PageNumber;
var pageSize = request.PageSize;
return(_repository.GetProvinceNamesLikeName(request.Name, pageNumber, pageSize)
.ContinueWith(fetchTask =>
{
GuardAgainst.FaultedOrCancelled(fetchTask);
var countTask = _repository.GetTotalCountOfProvinceNamesLikeName(request.Name);
countTask.Wait(cancellationToken);
return new PagedNameViewModel
{
Count = countTask.Result,
PageNumber = pageNumber,
PageSize = pageSize,
Items = fetchTask.Result.ToList()
};
}, cancellationToken));
}
public async Task <bool> Handle(CreateCustomerRequest request, CancellationToken cancellationToken)
{
GuardAgainst.ArgumentBeingNull(request);
var customerDetail = mapper.Map <Customer>(request.CustomerViewModel);
return(await Task.Run(() => customerRedisContext.SetCustomer(customerDetail)));
}
/// <inheritdoc/>
public Task <City?> GetCityByName(string name)
{
// intentional SQL Injeciton risk
var query = $"select * from Cities where Name = '{name}'";
return(_dbContext.Cities.FromSqlRaw(query).AsNoTracking().FirstOrDefaultAsync()
.ContinueWith(t =>
{
GuardAgainst.FaultedOrCancelled(t);
var city = t.Result;
if (city == null)
{
return null;
}
var province = _dbContext.Provinces
.AsNoTracking()
.Include(p => p.Country)
.FirstOrDefault(p => p.Id == city.ProvinceId);
if (province != null)
{
city.SetCountryAndProvince(province);
}
return city;
}));
}
/// <inheritdoc/>
public Task <PagedIdNameViewModel> Handle(GetContinentsQuery request, CancellationToken cancellationToken)
{
var pageNumber = request.PageNumber;
var pageSize = request.PageSize;
GuardAgainst.LessThanOrEqualToZero(pageNumber, nameof(pageNumber));
GuardAgainst.LessThanOrEqualToZero(pageSize, nameof(pageSize));
return(_repository.GetContinents(pageNumber, pageSize)
.ContinueWith(t =>
{
GuardAgainst.FaultedOrCancelled(t);
var items = t.Result;
// would prefer to go parallel but entityframework doesn't support parallel operations against
// the same dbContext, at least EF6 doesn't
var count = _repository.GetTotalCountOfContinents().ResultIfGreaterThanZero(cancellationToken);
return new PagedIdNameViewModel
{
Count = count,
PageNumber = pageNumber,
PageSize = pageSize,
Items = items.Select(tuple => new IdNameViewModel {
Id = tuple.Id, Name = tuple.Name
}).ToList()
};
}, cancellationToken));
}
public void WhenArgumentIsNullEnumerable_ShouldNotThrow()
{
const int[]? myArgument = null;
var result = Should.NotThrow(() => GuardAgainst.ArgumentBeingEmpty(myArgument));
Assert.Equal(myArgument, result);
}
public UrlTenentResolver(ICurrentHost host, ITenantService service)
{
GuardAgainst.Null(service);
GuardAgainst.Null(host);
_host = host;
_service = service;
}
public void WhenArgumentIsNull_ShouldThrowArgumentNullException()
{
const string?myArgument = null;
var ex = Should.Throw <ArgumentNullException>(() => GuardAgainst.ArgumentBeingNullOrWhitespace(myArgument));
ex.ParamName.ShouldBe(nameof(myArgument));
}
public async Task <CustomerViewModel> Handle(GetCustomerRequest request, CancellationToken cancellationToken)
{
GuardAgainst.ArgumentBeingNull(request);
var customerDetail = customerRedisContext.GetCustomer(request.Id);
return(await Task.Run(() => mapper.Map <CustomerViewModel>(customerDetail)));
}
public void WhenArgumentIsNull_ShouldThrowArgumentNullException()
{
const IEnumerable <string>?myArgument = null;
var ex = Should.Throw <ArgumentNullException>(() => GuardAgainst.ArgumentBeingNullOrEmpty(myArgument));
ex.ParamName.ShouldBe(nameof(myArgument));
}
public void WhenArgumentIsFalse_ShouldNotThrow()
{
const bool myArgument = false;
var result = Should.NotThrow(() => GuardAgainst.OperationBeingInvalid(myArgument));
Assert.Equal(myArgument, result);
}
public void WhenArgumentIsEqualToMinimum_ShouldNotThrow()
{
var myArgument = 1;
var result = Should.NotThrow(() => GuardAgainst.ArgumentBeingLessThanMinimum(myArgument, myArgument));
Assert.Equal(myArgument, result);
}
public void WhenArgumentIsWhitespace_ShouldThrowArgumentException()
{
const string myArgument = " ";
var ex = Should.Throw <ArgumentException>(() => GuardAgainst.ArgumentBeingWhitespace(myArgument));
ex.ParamName.ShouldBe(nameof(myArgument));
}
public ITypeSelector Except(Func <ITypeFilter, bool> predicate)
{
GuardAgainst.Null(predicate, nameof(predicate));
_exceptPredicates.Add(predicate);
return(this);
}
public void WhenArgumentIsNull_ShouldNotThrowArgumentNullException()
{
const string?myArgument = null;
var result = Should.NotThrow(() => GuardAgainst.ArgumentBeingWhitespace(myArgument));
Assert.Equal(myArgument, result);
}
public Task <PagedIdNameViewModel> Handle(GetCitiesQuery request, CancellationToken cancellationToken)
{
var pageNumber = request.PageNumber;
var pageSize = request.PageSize;
GuardAgainst.LessThanOrEqualToZero(pageNumber, nameof(pageNumber));
GuardAgainst.LessThanOrEqualToZero(pageSize, nameof(pageSize));
return(_repository.GetCities(pageNumber, pageSize)
.ContinueWith(fetchTask =>
{
GuardAgainst.FaultedOrCancelled(fetchTask);
// would prefer to go parallel but entityframework doesn't support parallel operations against
// the same dbContext, at least EF6 doesn't
var count = _repository.GetTotalCountOfCities().ResultIfGreaterThanZero(cancellationToken);
return new PagedIdNameViewModel
{
Count = count,
PageNumber = pageNumber,
PageSize = pageSize,
Items = _mapper.Map <List <IdNameViewModel> >(fetchTask.Result.ToList())
};
}, cancellationToken));
}
public void WhenMaximumValueIsNull_ShouldThrowArgumentNullException()
{
const string myArgument = "A";
var ex = Should.Throw <ArgumentOutOfRangeException>(() =>
GuardAgainst.ArgumentBeingOutOfRange(myArgument, "B", null));
ex.ParamName.ShouldBe("myArgument");
}
public void WhenArgumentIsNotNullOrEmpty_ShouldNotThrow()
{
var myArgument = new[] { "blah" };
var result = Should.NotThrow(() => GuardAgainst.ArgumentBeingNullOrEmpty(myArgument));
Assert.NotNull(result);
Assert.Equal(myArgument, result);
}
public void WhenArgumentIsGreaterThanMinimum_ShouldNotThrow()
{
var myArgument = 2;
var result = Should.NotThrow(() => GuardAgainst.ArgumentBeingLessThanMinimum(myArgument, 1));
Assert.NotNull(result);
Assert.Equal(myArgument, result);
}
public void WhenArgumentIsNotWhitespace_ShouldNotThrow()
{
const string myArgument = " blah ";
var result = Should.NotThrow(() => GuardAgainst.ArgumentBeingWhitespace(myArgument));
Assert.NotNull(result);
Assert.Equal(myArgument, result);
}
public void WhenMinimumValueIsNull_ShouldNotThrow()
{
const string myArgument = "A";
var result = Should.NotThrow(() => GuardAgainst.ArgumentBeingOutOfRange(myArgument, null, "D"));
Assert.NotNull(result);
Assert.Equal(myArgument, result);
}
public void WhenArgumentIsLessThanMaximum_ShouldNotThrow()
{
const string?myArgument = "A";
var result = Should.NotThrow(() => GuardAgainst.ArgumentBeingNullOrGreaterThanMaximum(myArgument, "B"));
Assert.NotNull(result);
Assert.Equal(myArgument, result);
}
