public async Task Update()
{
IMeasurementDao measurementDao = new AdoMeasurementDao(DefaultConnectionFactory.FromConfiguration(configName));
Measurement measurement = await measurementDao.FindByIdAsync(1);
double originalTemperature = measurement.Value;
measurement.Value = 100;
bool update1 = await measurementDao.UpdateMeasurementAsync(measurement);
Assert.IsTrue(update1);
measurement = await measurementDao.FindByIdAsync(1);
Assert.AreEqual(measurement.Value, 100);
measurement.Value = originalTemperature;
bool update2 = await measurementDao.UpdateMeasurementAsync(measurement);
Assert.IsTrue(update2);
measurement = await measurementDao.FindByIdAsync(1);
Assert.AreEqual(measurement.Value, originalTemperature);
}
private static IConnectionFactory CreateDefaultConnectionFactory(ClusterElement cluster)
{
List <EndPoint> endpoints = new List <EndPoint>();
foreach (EndPointElement ep in cluster.EndPoints)
{
IPAddress ip;
if (IPAddress.TryParse(ep.Address, out ip))
{
endpoints.Add(new IPEndPoint(ip, ep.Port));
}
else
{
endpoints.Add(new DnsEndPoint(ep.Address, ep.Port));
}
}
var connectionFactory = new DefaultConnectionFactory(endpoints);
if (!String.IsNullOrEmpty(cluster.AuthorizationKey))
{
connectionFactory.AuthorizationKey = cluster.AuthorizationKey;
}
if (cluster.DefaultLogger != null && cluster.DefaultLogger.Enabled)
{
connectionFactory.Logger = new DefaultLogger(cluster.DefaultLogger.Category, Console.Out);
}
return(connectionFactory);
}
public async Task Update()
{
IUnitDao unitDao = new AdoUnitDao(DefaultConnectionFactory.FromConfiguration(configName));
Unit unit = await unitDao.FindByIdAsync(1);
string originalLongName = unit.LongName;
unit.LongName = "New long name";
bool update1 = await unitDao.UpdateUnitAsync(unit);
Assert.IsTrue(update1);
unit = await unitDao.FindByIdAsync(1);
Assert.AreEqual(unit.LongName, "New long name");
unit.LongName = originalLongName;
bool update2 = await unitDao.UpdateUnitAsync(unit);
Assert.IsTrue(update2);
unit = await unitDao.FindByIdAsync(1);
Assert.AreEqual(unit.LongName, originalLongName);
}
public async Task Update()
{
IUserDao userDao =
new AdoUserDao(DefaultConnectionFactory.FromConfiguration(_connectionStringConfigName));
User user = await userDao.FindByIdAsync(1);
string email = user.Email;
user.Email = "*****@*****.**";
bool update1 = await userDao.UpdateAllAsync(user);
Assert.IsTrue(update1);
User user1 = await userDao.FindByIdAsync(1);
Assert.IsTrue(user1.Email == user.Email);
user.Email = email;
bool update2 = await userDao.UpdateAllAsync(user);
Assert.IsTrue(update2);
User user2 = await userDao.FindByIdAsync(1);
Assert.IsTrue(user2.Email == email);
}
public async Task Update()
{
ICommunityDao communityDao = new AdoCommunityDao(DefaultConnectionFactory.FromConfiguration(configName));
Community community = await communityDao.FindByIdAsync(1);
string originalName = community.Name;
community.Name = "New name";
bool update1 = await communityDao.UpdateCommunityAsync(community);
Assert.IsTrue(update1);
community = await communityDao.FindByIdAsync(1);
Assert.AreEqual(community.Name, "New name");
community.Name = originalName;
bool update2 = await communityDao.UpdateCommunityAsync(community);
Assert.IsTrue(update2);
community = await communityDao.FindByIdAsync(1);
Assert.AreEqual(community.Name, originalName);
}
public async Task Update()
{
IProvinceDao provinceDao = new AdoProvinceDao(DefaultConnectionFactory.FromConfiguration(configName));
Province province = await provinceDao.FindByIdAsync(1);
string originalName = province.Name;
province.Name = "New name";
bool update1 = await provinceDao.UpdateProvinceAsync(province);
Assert.IsTrue(update1);
province = await provinceDao.FindByIdAsync(1);
Assert.AreEqual(province.Name, "New name");
province.Name = originalName;
bool update2 = await provinceDao.UpdateProvinceAsync(province);
Assert.IsTrue(update2);
province = await provinceDao.FindByIdAsync(1);
Assert.AreEqual(province.Name, originalName);
}
public async Task Update()
{
IDistrictDao districtDao = new AdoDistrictDao(DefaultConnectionFactory.FromConfiguration(configName));
District district = await districtDao.FindByIdAsync(101);
string originalName = district.Name;
district.Name = "New name";
bool update1 = await districtDao.UpdateDistrictAsync(district);
Assert.IsTrue(update1);
district = await districtDao.FindByIdAsync(101);
Assert.AreEqual(district.Name, "New name");
district.Name = originalName;
bool update2 = await districtDao.UpdateDistrictAsync(district);
Assert.IsTrue(update2);
district = await districtDao.FindByIdAsync(101);
Assert.AreEqual(district.Name, originalName);
}
public async Task CreateWithSqlInjectionTest()
{
var connectionFactory = new DefaultConnectionFactory();
var seasonDao = new GenericDao <Entities.Season>(connectionFactory);
var expectedDomainObject = new Entities.Season()
{
Name = "'DELETE FROM [Hurace].[Sex];--",
StartDate = DateTime.Now.AddDays(-365).Date,
EndDate = DateTime.Now.Date
};
var actualDomainObjectId = await seasonDao.CreateAsync(expectedDomainObject)
.ConfigureAwait(false);
var actualDomainObject = await seasonDao.GetByIdAsync(actualDomainObjectId)
.ConfigureAwait(false);
Assert.Equal(expectedDomainObject.Name, actualDomainObject.Name);
Assert.Equal(expectedDomainObject.StartDate, actualDomainObject.StartDate);
Assert.Equal(expectedDomainObject.EndDate, actualDomainObject.EndDate);
var sexDao = new GenericDao <Entities.Sex>(connectionFactory);
Assert.Equal(2, (await sexDao.GetAllConditionalAsync().ConfigureAwait(false)).Count());
}
private static IConnectionProvider GetConnectionProvider(IConfiguration configuration)
{
string hostName = configuration.GetValue <string>("RabbitMq:HostName");
IConnectionFactory connectionFactory = new DefaultConnectionFactory(hostName);
return(new ConnectionProvider(connectionFactory));
}
public async Task Update()
{
IStationTypeDao stationTypeDao =
new AdoStationTypeDao(DefaultConnectionFactory.FromConfiguration(_connectionStringConfigName));
StationType stationType = await stationTypeDao.FindByIdAsync(1);
string manufacturer = stationType.Manufacturer;
stationType.Manufacturer = "Test";
bool update1 = await stationTypeDao.UpdateAllAsync(stationType);
Assert.IsTrue(update1);
StationType stationType1 = await stationTypeDao.FindByIdAsync(1);
Assert.IsTrue(stationType1.Manufacturer == "Test");
stationType.Manufacturer = manufacturer;
bool update2 = await stationTypeDao.UpdateAllAsync(stationType);
Assert.IsTrue(update2);
StationType stationType2 = await stationTypeDao.FindByIdAsync(1);
Assert.IsTrue(stationType2.Manufacturer == manufacturer);
}
public async Task Update()
{
IStationDao stationDao =
new AdoStationDao(DefaultConnectionFactory.FromConfiguration(_connectionStringConfigName));
Station station = await stationDao.FindByIdAsync(1);
string name = station.Name;
station.Name = "TEST UPDATE";
bool update1 = await stationDao.UpdateAllAsync(station);
Assert.IsTrue(update1);
Station station1 = await stationDao.FindByIdAsync(1);
Assert.IsTrue(station1.Name == "TEST UPDATE");
station.Name = name;
bool update2 = await stationDao.UpdateAllAsync(station);
Assert.IsTrue(update2);
Station station2 = await stationDao.FindByIdAsync(1);
Assert.IsTrue(station2.Name == name);
}
public async Task Update()
{
IMeasurementTypeDao measurementTypeDao = new AdoMeasurementTypeDao(DefaultConnectionFactory.FromConfiguration(configName));
MeasurementType measurementType = await measurementTypeDao.FindByIdAsync(1);
string originalName = measurementType.Name;
measurementType.Name = "New name";
bool update1 = await measurementTypeDao.UpdateMeasurementTypeAsync(measurementType);
Assert.IsTrue(update1);
measurementType = await measurementTypeDao.FindByIdAsync(1);
Assert.AreEqual(measurementType.Name, "New name");
measurementType.Name = originalName;
bool update2 = await measurementTypeDao.UpdateMeasurementTypeAsync(measurementType);
Assert.IsTrue(update2);
measurementType = await measurementTypeDao.FindByIdAsync(1);
Assert.AreEqual(measurementType.Name, originalName);
}
public async Task TestFindByStationId()
{
IMeasurementDao measurementDao = new AdoMeasurementDao(DefaultConnectionFactory.FromConfiguration(configName));
IEnumerable <Measurement> measurements = await measurementDao.FindByStationIdAsync(1);
Assert.IsTrue(measurements.Any());
}
public async Task TestFindByLongName()
{
IUnitDao unitDao = new AdoUnitDao(DefaultConnectionFactory.FromConfiguration(configName));
IEnumerable <Unit> units = await unitDao.FindByLongNameAsync("Percent");
Assert.IsNotNull(units.Any());
}
public async Task TestFindAll()
{
IUnitDao unitDao = new AdoUnitDao(DefaultConnectionFactory.FromConfiguration(configName));
IEnumerable <Unit> units = await unitDao.FindAllAsync();
Assert.IsTrue(units.Any());
}
public async Task TestFindAll()
{
IMeasurementTypeDao measurementTypeDao = new AdoMeasurementTypeDao(DefaultConnectionFactory.FromConfiguration(configName));
IEnumerable <MeasurementType> measurementTypes = await measurementTypeDao.FindAllAsync();
Assert.IsTrue(measurementTypes.Any());
}
public async Task TestFindLatestMeasurementsForStation()
{
IMeasurementDao measurementDao = new AdoMeasurementDao(DefaultConnectionFactory.FromConfiguration(configName));
IEnumerable <Measurement> measurements = await measurementDao.GetLastMeasurementsForStation(47, 0, 10);
Assert.IsTrue(measurements.Any());
}
/// <summary>
///
/// </summary>
/// <param name="db"></param>
/// <returns></returns>
public static IOrmLiteDialectProvider GetOrmLiteDialectProvider(this DefaultConnectionFactory factory)
{
if (factory is OrmLiteConnectionFactory)
{
return(factory.DialectProvider as IOrmLiteDialectProvider);
}
return(DialectProvider);
}
public void SetUp()
{
var ipEndpoint = UriExtensions.GetEndPoint(Address);
var factory = DefaultConnectionFactory.GetDefault();
_configuration = new PoolConfiguration(MaxSize, MinSize, WaitTimeout, RecieveTimeout, ShutdownTimeout, SendTimeout);
_connectionPool = new DefaultConnectionPool(_configuration, ipEndpoint, factory);
_connectionPool.Initialize();
}
public async Task CheckPassword()
{
IUserDao userDao =
new AdoUserDao(DefaultConnectionFactory.FromConfiguration(_connectionStringConfigName));
bool verify = await userDao.CheckPasswordAsync("max.müller", "max8");
Assert.IsTrue(verify);
}
public async Task FindByEmail()
{
IUserDao userDao =
new AdoUserDao(DefaultConnectionFactory.FromConfiguration(_connectionStringConfigName));
User user = await userDao.FindByEmailAsync("*****@*****.**");
Assert.IsTrue(user.Email == "*****@*****.**");
}
public async Task FindByUsername()
{
IUserDao userDao =
new AdoUserDao(DefaultConnectionFactory.FromConfiguration(_connectionStringConfigName));
User user = await userDao.FindByUsernameAsync("max.müller");
Assert.IsTrue(user.Username == "max.müller");
}
public async Task FindById()
{
IUserDao userDao =
new AdoUserDao(DefaultConnectionFactory.FromConfiguration(_connectionStringConfigName));
User user = await userDao.FindByIdAsync(1);
Assert.IsTrue(user.Id == 1);
}
public async Task FindAll()
{
IUserDao userDao =
new AdoUserDao(DefaultConnectionFactory.FromConfiguration(_connectionStringConfigName));
IEnumerable <User> users = await userDao.FindAllAsync();
Assert.IsTrue(users.Count() > 1);
}
public void SetUp()
{
var ipEndpoint = UriExtensions.GetEndPoint(_address);
var factory = DefaultConnectionFactory.GetGeneric <Connection>();
_configuration = new PoolConfiguration(MaxSize, MinSize, WaitTimeout, RecieveTimeout, ShutdownTimeout, SendTimeout, ConnectTimeout, MaxConnectionAcquireCount, BucketName);
_connectionPool = new ConnectionPool <Connection>(_configuration, ipEndpoint, factory, new DefaultConverter());
_connectionPool.Initialize();
}
public async Task FindByName()
{
IStationDao stationDao =
new AdoStationDao(DefaultConnectionFactory.FromConfiguration(_connectionStringConfigName));
Station station = (await stationDao.FindByNameAsync("ANDAU")).FirstOrDefault();
Assert.IsTrue(station != null && station.Name == "ANDAU");
}
public async Task FindByProvinceId()
{
IStationDao stationDao =
new AdoStationDao(DefaultConnectionFactory.FromConfiguration(_connectionStringConfigName));
Station station = (await stationDao.FindByProvinceIdAsync(1)).FirstOrDefault();
Assert.IsTrue(station != null && station.CommunityId == 85);
}
private RaceManagementLogic()
{
var configuration = ConfigurationUtil.GetConfiguration();
connectionFactory = DefaultConnectionFactory.FromConfiguration(configuration, "HuraceDbConnection");
raceDao = new AdoRaceDao(connectionFactory);
raceTypeDao = new AdoRaceTypeDao(connectionFactory);
statusDao = new AdoStatusDao(connectionFactory);
}
public async Task FindById()
{
IStationTypeDao stationTypeDao =
new AdoStationTypeDao(DefaultConnectionFactory.FromConfiguration(_connectionStringConfigName));
StationType stationType = await stationTypeDao.FindByIdAsync(1);
Assert.IsTrue(stationType != null && stationType.Id == 1);
}
public async Task TestFindAll()
{
ICommunityDao communityDao = new AdoCommunityDao(DefaultConnectionFactory.FromConfiguration(configName));
IEnumerable <Community> communities;
communities = await communityDao.FindAllAsync();
Assert.IsTrue(communities.Any());
}
public void ShouldVisitTopologyMultipleTimesExclusiveQueue()
{
var factory = new DefaultConnectionFactory();
using (var connection = factory.Create(new Uri("amqp://localhost/integration")))
{
var model = connection.CreateModel();
var topology = new Topology();
topology.DefineQueue();
var builder = new TopologyBuilder(model);
topology.Visit(builder);
topology.Visit(builder);
}
}
public void ShouldVisitExclusiveQueue()
{
var factory = new DefaultConnectionFactory();
using (var connection = factory.Create(new Uri("amqp://localhost/integration")))
{
var model = connection.CreateModel();
var topology = new Topology();
var q1 = topology.DefineQueue();
topology.Visit(new TopologyBuilder(model));
Assert.That(q1.HasName);
var queues = admin.Queues(IntegrationVHost);
Assert.That(queues.Any(e => e.Name == q1.Name));
}
}
public void ShouldVisitTopologyWithQueueBoundToExchange()
{
var factory = new DefaultConnectionFactory();
using (var connection = factory.Create(new Uri("amqp://localhost/integration")))
{
var model = connection.CreateModel();
var topology = new Topology();
var e1 = topology.DefineExchange("exchange1", ExchangeType.Topic);
var q1 = topology.DefineQueue("queue");
q1.BindTo(e1);
topology.Visit(new TopologyBuilder(model));
var exchanges = admin.Exchanges(IntegrationVHost);
Assert.That(exchanges.Any(e => e.Name == e1.Name));
var queues = admin.Queues(IntegrationVHost);
Assert.That(queues.Any(e => e.Name == q1.Name));
}
}
static void Main(string[] args)
{
var connectionFactory = new DefaultConnectionFactory("localhost");
using(var connection = connectionFactory.CreateConnection())
{
var model = connection.CreateModel();
model.ExchangeDeclare("RabbusChat", ExchangeType.Topic, false);
}
var consumerContainer = new SimpleConsumerContainer();
var bus = new RogerBus(connectionFactory, consumerContainer, exchangeResolver: new StaticExchangeResolver("RabbusChat"));
var chat = new ChatServer(bus);
consumerContainer.Register(chat);
bus.Start();
Console.ReadLine();
bus.Dispose();
}
