public void FixtureSetup()
{
_cx = ConnectionTests.CreateConnection();
if (_cx.ListDatabases().Contains("relax-reference-tests"))
{
_cx.DeleteDatabase("relax-reference-tests");
}
_cx.CreateDatabase("relax-reference-tests");
_sx = _cx.CreateSession("relax-reference-tests");
_sx2 = _cx.CreateSession("relax-reference-tests");
_sx.Save(new Widget { Id = "w1", Name = "Widget", Cost = 30 });
_sx.Save(new Widget { Id = "w2", Name = "Gadget", Cost = 30 });
_sx.Save(new Widget { Id = "w3", Name = "Foo", Cost = 35 });
_sx.Save(new Widget { Id = "w4", Name = "Bar", Cost = 35 });
_sx.Save(new Widget { Id = "w5", Name = "Biz", Cost = 45 });
_sx.Save(new Widget { Id = "w6", Name = "Bang", Cost = 55 });
_sx.SaveRaw(JObject.Parse(
@"{
_id: 'g1',
Name: 'Gadget #1',
Primary: 'w1'
}"));
_sx.SaveRaw(JObject.Parse(
@"{
_id: 'g2',
Name: 'Gadget #1',
Secondary: ['w1', 'w2', 'w3']
}"));
}
protected void Page_Load( object sender, EventArgs e )
{
var url = ConfigurationManager.AppSettings.Get( "CLOUDANT_URL" );
var connection = new Connection( new Uri( url ) );
if ( !connection.ListDatabases().Contains( "gmkreports" ) )
{
connection.CreateDatabase( "gmkreports" );
}
var repository = new Repository<Report>( connection.CreateSession( "gmkreports" ) );
var report = new Report { ID = Guid.NewGuid(), Type = 1, AccessionNumber = "123", Contents = "abcd" };
System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch();
watch.Reset();
watch.Start();
var id = repository.Save( report ).Id;
var retrievedReport = repository.Get( id );
watch.Stop();
if ( retrievedReport.ID == report.ID && retrievedReport.Type == report.Type && retrievedReport.AccessionNumber == report.AccessionNumber && retrievedReport.Contents == report.Contents )
{
_label.Text = watch.ElapsedMilliseconds.ToString();
}
else
{
_label.Text = "Error";
}
}
public override Exchange Process(Exchange exchange, UriDescriptor endPointDescriptor)
{
try
{
Camel.TryLog(exchange, "provider", endPointDescriptor.ComponentName);
var dbHost = endPointDescriptor.ComponentPath;
var port = endPointDescriptor.GetUriProperty<int>("port");
var couchDbDatabase = exchange.InMessage.GetHeader("CouchDbDatabase");
var createDb = endPointDescriptor.GetUriProperty<bool>("createDb");
var document = exchange.InMessage.Body;
var dbUrl = string.Format("http://{0}:{1}", dbHost, port);
var conn = new Connection(new Uri(dbUrl));
if (createDb && !conn.ListDatabases().Contains(couchDbDatabase))
{
conn.CreateDatabase(couchDbDatabase.ToString());
}
}
catch (Exception exception)
{
}
return base.Process(exchange, endPointDescriptor);
}
public void FixtureSetup()
{
_cx = ConnectionTests.CreateConnection();
if (_cx.ListDatabases().Contains("relax-repository-tests"))
{
_cx.DeleteDatabase("relax-repository-tests");
}
_cx.CreateDatabase("relax-repository-tests");
_sx = _cx.CreateSession("relax-repository-tests");
_sx2 = _cx.CreateSession("relax-repository-tests");
_sx.Save(new Gizmo {
Name = "Widget", Cost = 30, Manufacturer = "ACME"
});
_sx.Save(new Gizmo {
Name = "Gadget", Cost = 30, Manufacturer = "ACME"
});
_sx.Save(new Gizmo {
Name = "Foo", Cost = 35, Manufacturer = "ACME"
});
_sx.Save(new Gizmo {
Name = "Bar", Cost = 35, Manufacturer = "Widgetco"
});
_sx.Save(new Gizmo {
Name = "Biz", Cost = 45, Manufacturer = "Widgetco"
});
_sx.Save(new Gizmo {
Name = "Bang", Cost = 55, Manufacturer = "Widgetco"
});
}
private void InitDb()
{
Connection connection = new Connection(new Uri(Config.HOST));
connection.DeleteDatabase(Config.CLOTHES_DB_NAME);
//if (!connection.ListDatabases().Any(db => db == Config.CLOTHES_DB_NAME))
//{
connection.CreateDatabase(Config.CLOTHES_DB_NAME);
Session session = connection.CreateSession(Config.CLOTHES_DB_NAME);
string allClothesScript =
File.ReadAllText(HttpContext.Current.Server.MapPath("~/App_Data/all-clothes-map.js"));
string colorsMap =
File.ReadAllText(HttpContext.Current.Server.MapPath("~/App_Data/colors-map.js"));
string colorsReduce =
File.ReadAllText(HttpContext.Current.Server.MapPath("~/App_Data/colors-reduce.js"));
DesignDocument designDocument = new DesignDocument();
designDocument.Language = "javascript";
designDocument.Views = new Dictionary<string, View>();
designDocument.Views.Add("all-clothes", new View { Map = allClothesScript });
designDocument.Views.Add("colors-breakdown", new View { Map = colorsMap, Reduce = colorsReduce });
session.Save(designDocument, "_design/clothes-queries");
//}
}
public void FixtureSetup()
{
_cx = ConnectionTests.CreateConnection();
if (_cx.ListDatabases().Contains("relax-query-tests"))
{
_cx.DeleteDatabase("relax-query-tests");
}
_cx.CreateDatabase("relax-query-tests");
_sx = _cx.CreateSession("relax-query-tests");
// populate a few widgets & a simple design doc
_sx.Save(new Widget { Name = "widget", Manufacturer = "acme" });
_sx.Save(new Widget { Name = "sprocket", Manufacturer = "acme" });
_sx.Save(new Widget { Name = "doodad", Manufacturer = "widgetco" });
_sx.Save(
new DesignDocument {
Language = "javascript",
Views = new Dictionary<string, View>
{
{ "all-widgets", new View {
Map = @"function(doc) { emit(null, null); }"
}},
{ "all-manufacturers", new View() {
Map = @"function(doc) { emit(doc.Manufacturer, 1); }",
Reduce = @"function(keys, values, rereduce) { return sum(values); }"
}}
}
},
"_design/widgets"
);
}
public void FixtureSetup()
{
_cx = ConnectionTests.CreateConnection();
if (_cx.ListDatabases().Contains("relax-observer-tests"))
{
_cx.DeleteDatabase("relax-observer-tests");
}
_cx.CreateDatabase("relax-observer-tests");
}
public void FixtureSetup()
{
_cx = ConnectionTests.CreateConnection();
if (_cx.ListDatabases().Contains("relax-observer-tests"))
{
_cx.DeleteDatabase("relax-observer-tests");
}
_cx.CreateDatabase("relax-observer-tests");
}
public async Task Should_create_database()
{
var createResult = await Connection.CreateDatabase(TestDatabaseOneTime);
Assert.AreEqual(201, createResult.StatusCode);
Assert.IsTrue(createResult.Success);
Assert.IsTrue(createResult.HasValue);
Assert.IsTrue(createResult.Value);
}
public async Task Should_fail_create_already_existing_database()
{
await Connection.CreateDatabase(TestDatabaseGeneral);
Assert.ThrowsAsync <DatabaseAlreadyExistsException>(() =>
{
return(Connection.CreateDatabase(TestDatabaseGeneral));
});
}
public CloudantDataService()
{
var url = ConfigurationManager.AppSettings.Get( "CLOUDANT_URL" );
var connection = new Connection( new Uri( url ) );
if ( !connection.ListDatabases().Contains( "reports" ) )
{
connection.CreateDatabase( "reports" );
}
_repository = new Repository<Report>( connection.CreateSession( "reports" ) );
}
public CouchRepositar(string jmenoDatabaze)
{
_jmenoDatabaze = jmenoDatabaze;
var host = ConfigurationManager.AppSettings["CouchDB/Host"] ?? "localhost";
var port = Convert.ToInt32(ConfigurationManager.AppSettings["CouchDB/Port"] ?? "5984");
_store = new RedBranch.Hammock.Connection(new Uri(string.Format("http://{0}:{1}", host, port)));
if(!_store.ListDatabases().Contains(_jmenoDatabaze)) {
_store.CreateDatabase(_jmenoDatabaze);
}
}
public async Task Setup()
{
await Connection.CreateDatabase(TestDatabaseGeneral);
_db = Connection.GetDatabase(TestDatabaseGeneral);
await _db.CreateCollection(TestDocumentCollectionName)
.Type(ACollectionType.Document)
.Create();
}
public async Task Should_get_list_of_accessible_databases()
{
await Connection.CreateDatabase(TestDatabaseOneTime);
var resultList = await Connection.GetAccessibleDatabases();
Assert.AreEqual(200, resultList.StatusCode);
Assert.IsTrue(resultList.Success);
Assert.IsTrue(resultList.HasValue);
Assert.IsTrue(resultList.Value.Contains(TestDatabaseOneTime));
}
public async Task Should_delete_database()
{
await Connection.CreateDatabase(TestDatabaseOneTime);
var deleteResult = await Connection.DropDatabase(TestDatabaseOneTime);
Assert.AreEqual(200, deleteResult.StatusCode);
Assert.IsTrue(deleteResult.Success);
Assert.IsTrue(deleteResult.HasValue);
Assert.IsTrue(deleteResult.Value);
}
public async Task Should_get_current_database()
{
await Connection.CreateDatabase(TestDatabaseOneTime);
var resultCurrent = await Connection.GetDatabase(TestDatabaseOneTime).GetCurrent();
Assert.AreEqual(200, resultCurrent.StatusCode);
Assert.IsTrue(resultCurrent.Success);
Assert.IsTrue(resultCurrent.HasValue);
Assert.AreEqual(TestDatabaseOneTime, resultCurrent.Value["name"]);
Assert.AreEqual(false, string.IsNullOrEmpty((string)resultCurrent.Value["id"]));
Assert.AreEqual(false, string.IsNullOrEmpty((string)resultCurrent.Value["path"]));
Assert.AreEqual(false, resultCurrent.Value["isSystem"]);
}
public void FixtureSetup()
{
_cx = ConnectionTests.CreateConnection();
if (_cx.ListDatabases().Contains("relax-session-tests"))
{
_cx.DeleteDatabase("relax-session-tests");
}
_cx.CreateDatabase("relax-session-tests");
_sx = _cx.CreateSession("relax-session-tests");
// create an initial document on a seperate session
var x = _cx.CreateSession(_sx.Database);
var w = new Widget {Name = "gizmo", Tags = new[] {"whizbang", "geegollie"}};
_doc = x.Save(w);
}
public void FixtureSetup()
{
_cx = ConnectionTests.CreateConnection();
if (_cx.ListDatabases().Contains("relax-session-tests"))
{
_cx.DeleteDatabase("relax-session-tests");
}
_cx.CreateDatabase("relax-session-tests");
_sx = _cx.CreateSession("relax-session-tests");
// create an initial document on a seperate session
var x = _cx.CreateSession(_sx.Database);
var w = new Widget {
Name = "gizmo", Tags = new[] { "whizbang", "geegollie" }
};
_doc = x.Save(w);
}
public void FixtureSetup()
{
_cx = ConnectionTests.CreateConnection();
if (_cx.ListDatabases().Contains("relax-reference-tests"))
{
_cx.DeleteDatabase("relax-reference-tests");
}
_cx.CreateDatabase("relax-reference-tests");
_sx = _cx.CreateSession("relax-reference-tests");
_sx2 = _cx.CreateSession("relax-reference-tests");
_sx.Save(new Widget {
Id = "w1", Name = "Widget", Cost = 30
});
_sx.Save(new Widget {
Id = "w2", Name = "Gadget", Cost = 30
});
_sx.Save(new Widget {
Id = "w3", Name = "Foo", Cost = 35
});
_sx.Save(new Widget {
Id = "w4", Name = "Bar", Cost = 35
});
_sx.Save(new Widget {
Id = "w5", Name = "Biz", Cost = 45
});
_sx.Save(new Widget {
Id = "w6", Name = "Bang", Cost = 55
});
_sx.SaveRaw(JObject.Parse(
@"{
_id: 'g1',
Name: 'Gadget #1',
Primary: 'w1'
}"));
_sx.SaveRaw(JObject.Parse(
@"{
_id: 'g2',
Name: 'Gadget #1',
Secondary: ['w1', 'w2', 'w3']
}"));
}
public async Task Should_create_database_with_users()
{
var users = new List <AUser>()
{
new AUser {
Username = "******", Password = "******", Active = true
},
new AUser {
Username = "******", Password = "******", Active = false
}
};
var createResult = await Connection.CreateDatabase(TestDatabaseOneTime, users);
Assert.AreEqual(201, createResult.StatusCode);
Assert.IsTrue(createResult.Success);
Assert.IsTrue(createResult.HasValue);
Assert.IsTrue(createResult.Value);
}
public void FixtureSetup()
{
_cx = ConnectionTests.CreateConnection();
if (_cx.ListDatabases().Contains("relax-query-tests"))
{
_cx.DeleteDatabase("relax-query-tests");
}
_cx.CreateDatabase("relax-query-tests");
_sx = _cx.CreateSession("relax-query-tests");
// populate a few widgets & a simple design doc
_sx.Save(new Widget {
Name = "widget", Manufacturer = "acme"
});
_sx.Save(new Widget {
Name = "sprocket", Manufacturer = "acme"
});
_sx.Save(new Widget {
Name = "doodad", Manufacturer = "widgetco"
});
_sx.Save(
new DesignDocument {
Language = "javascript",
Views = new Dictionary <string, View>
{
{ "all-widgets", new View {
Map = @"function(doc) { emit(null, null); }"
} },
{ "all-manufacturers", new View()
{
Map = @"function(doc) { emit(doc.Manufacturer, 1); }",
Reduce = @"function(keys, values, rereduce) { return sum(values); }"
} }
}
},
"_design/widgets"
);
}
public async Task Should_get_database_collections()
{
await Connection.CreateDatabase(TestDatabaseOneTime);
var db = Connection.GetDatabase(TestDatabaseOneTime);
var createResult = await db.CreateCollection(TestDocumentCollectionName).Create();
var getResult = await db
//.ExcludeSystem(true)
.GetAllCollections();
Assert.AreEqual(200, getResult.StatusCode);
Assert.IsTrue(getResult.Success);
Assert.IsTrue(getResult.HasValue);
var foundCreatedCollection = getResult.Value.FirstOrDefault(col => (string)col["name"] == (string)createResult.Value["name"]);
Assert.IsNotNull(foundCreatedCollection);
var foundSystemCollection = getResult.Value.FirstOrDefault(col => (string)col["name"] == "_system");
Assert.IsNull(foundSystemCollection);
}
/// <summary>
/// Perfromance tests should run in around 1 minute.
/// </summary>
/// <param name="connection"></param>
public async Task Performance(Connection connection, string databaseName, int rows)
{
await connection.CreateDatabase(databaseName, CancellationToken.None);
//create a table that utilizes every available datatype.
var table = new Table("LargeTable" + (DataSets.counter++));
table.Columns.Add(new TableColumn("SurrogateKey", ETypeCode.Int64, TableColumn.EDeltaType.SurrogateKey));
table.Columns.Add(new TableColumn("UpdateTest", ETypeCode.Int32));
foreach (ETypeCode typeCode in Enum.GetValues(typeof(ETypeCode)))
{
if (typeCode == ETypeCode.Binary && !connection.CanUseBinary)
{
continue;
}
table.Columns.Add(new TableColumn()
{
Name = "column" + typeCode,
DataType = typeCode,
MaxLength = 50,
DeltaType = TableColumn.EDeltaType.TrackingField
});
}
//create the table
await connection.CreateTable(table, true, CancellationToken.None);
//add rows using the min/max values for each of the datatypes.
var buffer = 0;
for (long i = 0; i < rows; i++)
{
var row = new object[table.Columns.Count];
row[0] = i; //surrogate key column
row[1] = 0;
//load the rows with min and max values.
for (var j = 2; j < table.Columns.Count; j++)
{
var dataType = DataType.GetType(table.Columns[j].DataType);
if (i % 2 == 0)
{
row[j] = connection.GetConnectionMaxValue(table.Columns[j].DataType, 20);
}
else
{
row[j] = connection.GetConnectionMinValue(table.Columns[j].DataType);
}
}
table.Data.Add(row);
buffer++;
if (buffer >= 5000 || rows == i + 1)
{
//start a datawriter and insert the test data
await connection.DataWriterStart(table);
await connection.ExecuteInsertBulk(table, new ReaderMemory(table), CancellationToken.None);
table.Data.Clear();
buffer = 0;
}
}
//count rows using reader
var count = 0;
var reader = connection.GetTransformReader(table);
var sortQuery = new SelectQuery()
{
Sorts = new List <Sort>()
{
new Sort("SurrogateKey")
},
Table = table.Name
};
await reader.Open(0, sortQuery, CancellationToken.None);
while (await reader.ReadAsync())
{
if (count == 0)
{
for (var j = 2; j < table.Columns.Count; j++)
{
Assert.Equal(connection.GetConnectionMaxValue(table.Columns[j].DataType, 20), reader[j]);
}
}
if (count == 1)
{
for (var j = 2; j < table.Columns.Count; j++)
{
Assert.Equal(connection.GetConnectionMinValue(table.Columns[j].DataType), reader[j]);
}
}
count++;
}
Assert.Equal(rows, count);
var updateQueries = new List <UpdateQuery>();
//run a update on 10% of rows
for (long i = 0; i < (rows / 10); i++)
{
var updateColumns = new List <QueryColumn>();
//use this column to validate the update success
var updateColumn = new QueryColumn(table.Columns[1], 1);
updateColumns.Add(updateColumn);
//load the columns with random values.
for (var j = 2; j < table.Columns.Count; j++)
{
updateColumn = new QueryColumn(table.Columns[j],
connection.GetConnectionMaxValue(table.Columns[j].DataType));
updateColumns.Add(updateColumn);
}
updateQueries.Add(new UpdateQuery()
{
Filters = new List <Filter>()
{
new Filter("SurrogateKey", Filter.ECompare.IsEqual, i)
},
Table = table.Name,
UpdateColumns = updateColumns
});
}
await connection.ExecuteUpdate(table, updateQueries, CancellationToken.None);
//check the table loaded 1,000 rows updated successully
var selectQuery = new SelectQuery()
{
Columns = new List <SelectColumn>()
{
new SelectColumn("UpdateTest")
},
Filters = new List <Filter>()
{
new Filter(new TableColumn("UpdateTest", ETypeCode.Int32), Filter.ECompare.IsEqual, 1)
},
Rows = -1,
Table = table.Name
};
//count rows using reader
count = 0;
reader = connection.GetTransformReader(table);
await reader.Open(0, selectQuery, CancellationToken.None);
while (await reader.ReadAsync())
{
count++;
}
Assert.True(count == rows / 10, "row count = " + count);
var deleteQueries = new List <DeleteQuery>
{
//delete 10,000 rows
new DeleteQuery()
{
Filters = new List <Filter>()
{
new Filter(new TableColumn("UpdateTest", ETypeCode.Int32), Filter.ECompare.IsEqual, 1)
},
Table = table.Name,
}
};
await connection.ExecuteDelete(table, deleteQueries, CancellationToken.None);
selectQuery = new SelectQuery()
{
Columns = new List <SelectColumn>()
{
new SelectColumn("SurrogateKey")
},
// Filters = new List<Filter>() { new Filter() { Column1 = "column1", CompareDataType = DataType.ETypeCode.String, Operator = Filter.ECompare.NotEqual, Value2 = "updated" } },
Rows = -1,
Table = table.Name
};
//count rows using reader
count = 0;
reader = connection.GetTransformReader(table);
await reader.Open(0, null, CancellationToken.None);
while (await reader.ReadAsync())
{
count++;
}
Assert.True(count == rows - rows / 10, "row count = " + count);
//run a preview
var query = table.DefaultSelectQuery(50);
var previewTable = await connection.GetPreview(table, query, CancellationToken.None);
Assert.NotNull(previewTable);
Assert.Equal(50, previewTable.Data.Count);
}
public async Task Setup()
{
await Connection.CreateDatabase(TestDatabaseGeneral);
_db = Connection.GetDatabase(TestDatabaseGeneral);
}
protected void InstallPersistence(ContainerBuilder builder)
{
// register the connection used for products, tenants, and ticket jones
builder.Register(c => {
var cfg = c.Resolve <IInfrastructureConfiguration>();
var x = new Connection(new Uri(cfg.CouchServer));
var dbs = x.ListDatabases();
if (!dbs.Contains(cfg.CouchCatalogDatabase))
{
x.CreateDatabase(cfg.CouchCatalogDatabase);
}
if (!dbs.Contains(cfg.CouchTenantsDatabase))
{
x.CreateDatabase(cfg.CouchTenantsDatabase);
}
if (!dbs.Contains(cfg.CouchTicketJonesDatabase))
{
x.CreateDatabase(cfg.CouchTicketJonesDatabase);
}
if (!dbs.Contains(cfg.CouchErrorsDatabase))
{
x.CreateDatabase(cfg.CouchErrorsDatabase);
}
x.Observers.Add(y => new EntityAuditObserver());
return(x);
})
.Named <Connection>("global-connection")
.As <Connection>()
.SingleInstance();
// register a single connection, shared globally, and also create the database if needed
builder
.Register(c =>
{
var cfg = c.Resolve <IInfrastructureConfiguration>();
var x = new Connection(new Uri(cfg.CouchServer));
// todo: SessionObserver's are VERY hard to wire with IoC in the
// multi-tenant context. I think the solution is one connection
// instance per tenant, but not sure how that works with autofac.
// Tagged containers?
var h = c.ResolveNamed <ICacheStore>("http-context-cache-store");
var s = c.Resolve <ITenantResolverService>();
x.Observers.Add(y => new EntityAuditObserver());
x.Observers.Add(y => new EntityCache <User> .SessionObserver(h, s));
x.Observers.Add(y => new EntityCache <Group> .SessionObserver(h, s));
x.Observers.Add(y => new EntityCache <Menu> .SessionObserver(h, s));
x.Observers.Add(y => new EntityCache <Page> .SessionObserver(h, s));
x.Observers.Add(y => new EntityCache <ApplicationConfiguration> .SessionObserver(h, s));
x.Observers.Add(y => new EntityCache <Theme> .SessionObserver(h, s));
x.Observers.Add(y => new UserSummaryCache.SessionObserver(h, s));
x.Observers.Add(y => new GroupSummaryCache.SessionObserver(h, s));
return(x);
})
.As(typeof(Connection))
.SingleInstance();
// register sessions, using the connection as a factory. register the two shared sessions first (catalog and tenants),
// then register the tenant-specific session last, which makes it the default when an ISession is asked for. Catalog and
// tenant session must therefore be requested explicitly by service name.
builder
.Register(c => c.ResolveNamed <Connection>("global-connection").CreateSession(c.Resolve <IInfrastructureConfiguration>().CouchCatalogDatabase))
.InstancePerLifetimeScope()
.Named <Session>("catalog-session");
builder
.Register(c => c.ResolveNamed <Connection>("global-connection").CreateSession(c.Resolve <IInfrastructureConfiguration>().CouchTenantsDatabase))
.SingleInstance()
.Named <Session>("tenants-session");
builder
.Register(c => c.ResolveNamed <Connection>("global-connection").CreateSession(c.Resolve <IInfrastructureConfiguration>().CouchErrorsDatabase))
.SingleInstance()
.Named <Session>("errors-session");
builder
.Register(c => c.ResolveNamed <Connection>("global-connection").CreateSession(c.Resolve <IInfrastructureConfiguration>().CouchMailDatabase))
.SingleInstance()
.Named <Session>("mail-session");
builder
.Register(c => c.ResolveNamed <Connection>("global-connection").CreateSession(c.Resolve <IInfrastructureConfiguration>().CouchTicketJonesDatabase))
.InstancePerLifetimeScope()
.Named <Session>("ticketjones-session");
builder
.Register(c =>
{
// default session service must determine the current tenant
// and create a session on that tenant's db
var t = c.Resolve <Tenant>();
if (null == t)
{
throw new Exception("No tenant found to respond to this url.");
}
var cx = c.Resolve <Connection>();
if (!cx.ListDatabases(true).Contains(t.Database))
{
cx.CreateDatabase(t.Database);
}
return(cx.CreateSession(t.Database));
})
.As <Session>()
.InstancePerLifetimeScope();
// explicit repositories (i.e. classes in .Infrastructure that inherit from Repository<>) will
// be registered as services and override this registration. this means that requesting an
// IRepository<User> will return UserRepository instead of Repository<User>.
builder
.RegisterGeneric(typeof(Repository <>))
.As(typeof(IRepository <>))
.InstancePerLifetimeScope();
// register the catalog and tenant repositories seperatly, so that they are forced to attach to their special
// databases, and not the current tenant's database
builder
.Register(c => new ProductRepository(c.ResolveNamed <Session>("catalog-session")))
.As(typeof(ProductRepository), typeof(IProductRepository), typeof(IRepository <Product>))
.InstancePerLifetimeScope();
builder
.Register(c => new TenantRepository(c.ResolveNamed <Session>("tenants-session")))
.As(typeof(TenantRepository), typeof(ITenantRepository), typeof(IRepository <Tenant>))
.InstancePerLifetimeScope();
builder
.Register(c => new ErrorRepository(c.ResolveNamed <Session>("errors-session")))
.As(typeof(ErrorRepository), typeof(IErrorRepository), typeof(IRepository <Error>))
.InstancePerLifetimeScope();
builder
.Register(c => new EmailRepository(c.ResolveNamed <Session>("mail-session")))
.As(typeof(EmailRepository), typeof(IEmailRepository), typeof(IRepository <Email>))
.InstancePerLifetimeScope();
builder
.Register(c => new TicketJonesCategoryRepository(c.ResolveNamed <Session>("ticketjones-session")))
.As(typeof(TicketJonesCategoryRepository), typeof(ITicketJonesCategoryRepository), typeof(IRepository <TicketJonesCategory>))
.InstancePerLifetimeScope();
builder
.Register(c => new TicketJonesVenueRepository(c.ResolveNamed <Session>("ticketjones-session")))
.As(typeof(TicketJonesVenueRepository), typeof(ITicketJonesVenueRepository), typeof(IRepository <TicketJonesVenue>))
.InstancePerLifetimeScope();
builder
.Register(c => new TicketJonesPerformerRepository(c.ResolveNamed <Session>("ticketjones-session")))
.As(typeof(TicketJonesPerformerRepository), typeof(ITicketJonesPerformerRepository), typeof(IRepository <TicketJonesPerformer>))
.InstancePerLifetimeScope();
builder
.Register(c => new TicketJonesEventRepository(c.ResolveNamed <Session>("ticketjones-session")))
.As(typeof(TicketJonesEventRepository), typeof(ITicketJonesEventRepository), typeof(IRepository <TicketJonesEvent>))
.InstancePerLifetimeScope();
// register the 2nd-level caching system
builder
.RegisterGeneric(typeof(EntityCache <>))
.As(typeof(IEntityCache <>))
.InstancePerLifetimeScope();
// register the product entity cache using the http cache store instead
// of the default per-tenant cache store
builder.Register(c => new EntityCache <Product>(
c.Resolve <IRepository <Product> >(),
c.ResolveNamed <ICacheStore>("http-context-cache-store")
))
.As <IEntityCache <Product> >()
.InstancePerLifetimeScope();
}
/// <summary>
/// Perfromance tests should run in around 1 minute.
/// </summary>
/// <param name="connection"></param>
public async Task PerformanceTransformWriter(Connection connection, string databaseName, long rows)
{
await connection.CreateDatabase(databaseName, CancellationToken.None);
//create a table that utilizes every available datatype.
var table = new Table("LargeTable" + (DataSets.counter++));
table.Columns.Add(
new TableColumn("SurrogateKey", ETypeCode.Int32, TableColumn.EDeltaType.SurrogateKey)
{
IsIncrementalUpdate = true
});
table.Columns.Add(new TableColumn("UpdateTest", ETypeCode.Int32));
foreach (ETypeCode typeCode in Enum.GetValues(typeof(ETypeCode)))
{
if (typeCode == ETypeCode.Binary && connection.CanUseBinary)
{
continue;
}
if (typeCode != ETypeCode.Binary)
{
continue;
}
table.Columns.Add(new TableColumn()
{
Name = "column" + typeCode,
DataType = typeCode,
MaxLength = 50,
DeltaType = TableColumn.EDeltaType.TrackingField
});
}
//create the table
await connection.CreateTable(table, true, CancellationToken.None);
//add rows.
var buffer = 0;
for (var i = 0; i < rows; i++)
{
var row = new object[table.Columns.Count];
row[0] = i;
row[1] = 0;
//load the rows with random values.
for (var j = 2; j < table.Columns.Count; j++)
{
var dataType = DataType.GetType(table.Columns[j].DataType);
if (i % 2 == 0)
{
row[j] = connection.GetConnectionMaxValue(table.Columns[j].DataType, 20);
}
else
{
row[j] = connection.GetConnectionMinValue(table.Columns[j].DataType);
}
}
table.Data.Add(row);
buffer++;
if (buffer >= 5000 || rows == i + 1)
{
//start a datawriter and insert the test data
await connection.DataWriterStart(table);
await connection.ExecuteInsertBulk(table, new ReaderMemory(table), CancellationToken.None);
table.Data.Clear();
buffer = 0;
}
}
var targetTable = table.Copy();
targetTable.AddAuditColumns();
targetTable.Name = "TargetTable";
await connection.CreateTable(targetTable, false, CancellationToken.None);
var targetTransform = connection.GetTransformReader(targetTable);
//count rows using reader
var transform = connection.GetTransformReader(table);
transform = new TransformMapping(transform, true, null, null);
transform = new TransformValidation(transform, null, false);
transform = new TransformDelta(transform, targetTransform, TransformDelta.EUpdateStrategy.Reload, 1, false);
var writer = new TransformWriter();
var writerResult = new TransformWriterResult();
await connection.InitializeAudit(writerResult, 0, "Datalink", 1, 2, "Test", 1, "Source", 2, "Target",
TransformWriterResult.ETriggerMethod.Manual, "Test", CancellationToken.None);
Assert.NotNull(writerResult);
var result = await writer.WriteAllRecords(writerResult, transform, targetTable, connection, null, null,
null, null, CancellationToken.None);
Assert.Equal(rows, writerResult.RowsCreated);
//check the audit table loaded correctly.
var auditTable = await connection.GetTransformWriterResults(0, null, "Datalink", writerResult.AuditKey, null, true,
false, false, null, 1, 2, false, CancellationToken.None);
Assert.Equal(writerResult.RowsCreated, auditTable[0].RowsCreated);
Assert.Equal(rows - 1, Convert.ToInt64(auditTable[0].MaxIncrementalValue));
}
public async Task Unit(Connection connection, string databaseName)
{
await connection.CreateDatabase(databaseName, CancellationToken.None);
var newTable = DataSets.CreateTable();
var table = await connection.InitializeTable(newTable, 1000);
//create the table
await connection.CreateTable(table, true, CancellationToken.None);
//insert a single row
InsertQuery insertQuery = new InsertQuery("test_table", new List <QueryColumn>()
{
new QueryColumn(new TableColumn("IntColumn", ETypeCode.Int32), 1),
new QueryColumn(new TableColumn("StringColumn", ETypeCode.String), "value1"),
new QueryColumn(new TableColumn("DateColumn", ETypeCode.DateTime), new DateTime(2001, 01, 21, 0, 0, 0, DateTimeKind.Utc)),
new QueryColumn(new TableColumn("BooleanColumn", ETypeCode.Boolean), true),
new QueryColumn(new TableColumn("DoubleColumn", ETypeCode.Double), 1.1),
new QueryColumn(new TableColumn("DecimalColumn", ETypeCode.Decimal), 1.1m),
new QueryColumn(new TableColumn("GuidColumn", ETypeCode.Guid), Guid.NewGuid())
});
await connection.ExecuteInsert(table, new List <InsertQuery>() { insertQuery }, CancellationToken.None);
//insert a second row
insertQuery = new InsertQuery("test_table", new List <QueryColumn>()
{
new QueryColumn(new TableColumn("IntColumn", ETypeCode.Int32), 2),
new QueryColumn(new TableColumn("StringColumn", ETypeCode.String), "value2"),
new QueryColumn(new TableColumn("BooleanColumn", ETypeCode.Boolean), false),
new QueryColumn(new TableColumn("DateColumn", ETypeCode.DateTime), new DateTime(2001, 01, 21, 0, 0, 0, DateTimeKind.Utc)),
new QueryColumn(new TableColumn("DoubleColumn", ETypeCode.Double), 1.1),
new QueryColumn(new TableColumn("DecimalColumn", ETypeCode.Decimal), 1.2m),
new QueryColumn(new TableColumn("GuidColumn", ETypeCode.Guid), Guid.NewGuid())
});
await connection.ExecuteInsert(table, new List <InsertQuery>() { insertQuery }, CancellationToken.None);
////if the write was a file. move it back to the incoming directory to read it.
if (connection.DatabaseConnectionCategory == Connection.EConnectionCategory.File)
{
var fileConnection = (ConnectionFlatFile)connection;
var filename = fileConnection.LastWrittenFile;
var filemoveResult = await fileConnection.MoveFile((FlatFile)table, filename,
EFlatFilePath.Outgoing, EFlatFilePath.Incoming);
Assert.True(filemoveResult);
}
SelectQuery selectQuery;
//run a select query with one row, sorted descending.
if (connection.CanFilter)
{
selectQuery = new SelectQuery()
{
Columns = new List <SelectColumn>()
{
new SelectColumn(new TableColumn("StringColumn"))
},
Sorts = new List <Sort>()
{
new Sort {
Column = new TableColumn("IntColumn"), Direction = Sort.EDirection.Descending
}
},
Rows = 1,
Table = "test_table"
};
//should return value2 from second row
var returnScalar = await connection.ExecuteScalar(table, selectQuery, CancellationToken.None);
Assert.NotNull(returnScalar);
//if the connection doesn't support sorting, don't bother with this test.
if (connection.CanSort == true)
{
Assert.Equal("value2", (string)returnScalar);
}
}
if (connection.CanUpdate)
{
//run an update query which will change the second date value to 2001-01-21
var updateQuery = new UpdateQuery()
{
UpdateColumns = new List <QueryColumn>()
{
new QueryColumn(new TableColumn("DateColumn", ETypeCode.DateTime), new DateTime(2001, 01, 21, 0, 0, 0, DateTimeKind.Utc))
},
Filters = new List <Filter>()
{
new Filter()
{
Column1 = new TableColumn("IntColumn"), Operator = Filter.ECompare.IsEqual, Value2 = 2, CompareDataType = ETypeCode.Int32
}
}
};
await connection.ExecuteUpdate(table, new List <UpdateQuery>() { updateQuery }, CancellationToken.None);
//run a select query to validate the updated row.
selectQuery = new SelectQuery()
{
Columns = new List <SelectColumn>()
{
new SelectColumn(new TableColumn("DateColumn", ETypeCode.DateTime))
},
Filters = new List <Filter>()
{
new Filter(new TableColumn("IntColumn"), Filter.ECompare.IsEqual, 2)
},
Rows = 1,
Table = "test_table"
};
//should return updated date
var returnScalar = await connection.ExecuteScalar(table, selectQuery, CancellationToken.None);
Assert.True((DateTime)returnScalar == new DateTime(2001, 01, 21), "DateTime didn't match");
}
//run a simple aggregate query to get max value from decimaColumn
if (connection.CanAggregate)
{
selectQuery = new SelectQuery()
{
Columns = new List <SelectColumn>()
{
new SelectColumn("DecimalColumn", SelectColumn.EAggregate.Max)
},
Sorts = new List <Sort>()
{
new Sort("DateColumn")
},
Groups = new List <TableColumn>()
{
new TableColumn("DateColumn")
},
Rows = 1,
Table = "test_table"
};
//should return value2 from second row
var returnScalar = await connection.ExecuteScalar(table, selectQuery, CancellationToken.None);
Assert.True(Decimal.Compare(Convert.ToDecimal(returnScalar), (Decimal)1.2) == 0, "SelectQuery2 - returned value: " + returnScalar.ToString());
}
if (connection.CanDelete)
{
//run a delete query.
var deleteQuery = new DeleteQuery()
{
Filters = new List <Filter>()
{
new Filter("IntColumn", Filter.ECompare.IsEqual, 1)
},
Table = "test_table"
};
//should return value2 from second row
await connection.ExecuteDelete(table, new List <DeleteQuery>() { deleteQuery }, CancellationToken.None);
//run a select query to check row is deleted
selectQuery = new SelectQuery()
{
Columns = new List <SelectColumn>()
{
new SelectColumn("DateColumn")
},
Filters = new List <Filter>()
{
new Filter("IntColumn", Filter.ECompare.IsEqual, 1)
},
Rows = 1,
Table = "test_table"
};
//should return null
var returnScalar = await connection.ExecuteScalar(table, selectQuery, CancellationToken.None);
Assert.True(returnScalar == null);
//run an aggregate query to check rows left
if (connection.CanAggregate)
{
selectQuery = new SelectQuery()
{
Columns = new List <SelectColumn>()
{
new SelectColumn("IntColumn", SelectColumn.EAggregate.Count)
},
Rows = 1000,
Table = "test_table"
};
returnScalar = await connection.ExecuteScalar(table, selectQuery, CancellationToken.None);
Assert.True(Convert.ToInt64(returnScalar) == 1, "Select count");
}
//run a truncate
await connection.TruncateTable(table, CancellationToken.None);
//check the table is empty following truncate
selectQuery = new SelectQuery()
{
Columns = new List <SelectColumn>()
{
new SelectColumn("StringColumn")
},
Rows = 1,
Table = "test_table"
};
//should return null
returnScalar = await connection.ExecuteScalar(table, selectQuery, CancellationToken.None);
Assert.True(returnScalar == null);
// }
}
if (connection.CanBulkLoad)
{
await connection.TruncateTable(table, CancellationToken.None);
//start a datawriter and insert the test data
await connection.DataWriterStart(table);
var testData = DataSets.CreateTestData();
await connection.ExecuteInsertBulk(table, testData, CancellationToken.None);
await connection.DataWriterFinish(table);
////if the write was a file. move it back to the incoming directory to read it.
if (connection.DatabaseConnectionCategory == Connection.EConnectionCategory.File)
{
var fileConnection = (ConnectionFlatFile)connection;
var filename = fileConnection.LastWrittenFile;
var filemoveResult = await fileConnection.MoveFile((FlatFile)table, filename,
EFlatFilePath.Outgoing, EFlatFilePath.Incoming);
Assert.True(filemoveResult);
}
//check the table loaded 10 rows successully
Transform reader = connection.GetTransformReader(table, true);
int count = 0;
var openResult = await reader.Open(0, null, CancellationToken.None);
Assert.True(openResult, "Open Reader");
while (await reader.ReadAsync())
{
count++;
}
Assert.True(count == 10, "Select count - value :" + count);
}
if (connection.CanFilter == true)
{
//run a lookup query.
var filters = new List <Filter> {
new Filter("IntColumn", Filter.ECompare.IsEqual, 5)
};
var query = new SelectQuery()
{
Filters = filters
};
//should return value5
var reader = connection.GetTransformReader(table, true);
// if (reader.CanLookupRowDirect)
// {
// var openResult = await reader.Open(0, null, CancellationToken.None);
// Assert.True(openResult, "Open Reader");
var returnLookup = await reader.Lookup(query, Transform.EDuplicateStrategy.Abend, CancellationToken.None);
Assert.True(Convert.ToString(returnLookup.First()[0]) == "value5", "LookupValue :" + returnLookup.First()[0]);
//run lookup again with caching set.
reader = connection.GetTransformReader(table);
// var openResult = await reader.Open(0, null, CancellationToken.None);
// Assert.True(openResult, "Open Reader");
reader.SetCacheMethod(Transform.ECacheMethod.PreLoadCache);
returnLookup = await reader.Lookup(query, Transform.EDuplicateStrategy.Abend, CancellationToken.None);
Assert.True(Convert.ToString(returnLookup.First()[0]) == "value5", "Select count - value :" + returnLookup.First()[0]);
// }
reader.Close();
}
}
public async Task Unit(Connection connection, string databaseName)
{
await connection.CreateDatabase(databaseName, CancellationToken.None);
var newTable = DataSets.CreateTable();
var table = await connection.InitializeTable(newTable, 1000);
//create the table
await connection.CreateTable(table, true, CancellationToken.None);
var guid = Guid.NewGuid();
//insert a single row
var insertQuery = new InsertQuery("test_table", new List <QueryColumn>()
{
new QueryColumn(new TableColumn("IntColumn", ETypeCode.Int32), 1),
new QueryColumn(new TableColumn("StringColumn", ETypeCode.String), "value1"),
new QueryColumn(new TableColumn("DateColumn", ETypeCode.DateTime), new DateTime(2001, 01, 21)),
new QueryColumn(new TableColumn("DoubleColumn", ETypeCode.Decimal), 1.1),
new QueryColumn(new TableColumn("DecimalColumn", ETypeCode.Decimal), 1.1m),
new QueryColumn(new TableColumn("BooleanColumn", ETypeCode.Boolean), true),
new QueryColumn(new TableColumn("GuidColumn", ETypeCode.Guid), guid)
});
var insertReturn = await connection.ExecuteInsert(table, new List <InsertQuery>() { insertQuery }, CancellationToken.None);
// Assert.True(insertReturn > 0, "InsertQuery");
Table sqlTable;
if (connection.CanUseSql)
{
// create a simple table with a sql query.
sqlTable = new Table("SqlTest")
{
UseQuery = true,
QueryString = $"select * from {table.Name}"
};
}
else
{
sqlTable = table;
}
// check the columns can be imported.
var importTable = await connection.GetSourceTableInfo(sqlTable, CancellationToken.None);
Assert.Equal(7, importTable.Columns.Count);
Assert.Equal("IntColumn", importTable.Columns["IntColumn"].Name);
Assert.True(ETypeCode.Int32 == importTable.Columns["IntColumn"].DataType || ETypeCode.Int64 == importTable.Columns["IntColumn"].DataType);
Assert.Equal("StringColumn", importTable.Columns["StringColumn"].Name);
Assert.Equal(ETypeCode.String, importTable.Columns["StringColumn"].DataType);
// commented date check as sqlite treats dates as string. Value check below does the test adequately.
// Assert.Equal("DateColumn", importTable.Columns["DateColumn"].Name);
// Assert.Equal(ETypeCode.DateTime, importTable.Columns["DateColumn"].Datatype);
// Assert.Equal("DecimalColumn", importTable.Columns["DecimalColumn"].Name);
// Assert.Equal(ETypeCode.Decimal, importTable.Columns["DecimalColumn"].Datatype);
Assert.Equal("GuidColumn", importTable.Columns["GuidColumn"].Name);
Assert.True(ETypeCode.String == importTable.Columns["GuidColumn"].DataType || ETypeCode.Guid == importTable.Columns["GuidColumn"].DataType);
// check rows can be read.
var reader = connection.GetTransformReader(importTable);
var openResult = await reader.Open(0, null, CancellationToken.None);
Assert.True(openResult);
var finished = await reader.ReadAsync();
Assert.True(finished);
Assert.Equal((Int64)1, Int64.Parse(reader["IntColumn"].ToString()));
Assert.Equal("value1", reader["StringColumn"]);
Assert.Equal(new DateTime(2001, 01, 21), DateTime.Parse(reader["DateColumn"].ToString()));
Assert.Equal((decimal)1.1, reader.GetDecimal(reader.GetOrdinal("DecimalColumn")));
Assert.Equal(guid.ToString(), reader["GuidColumn"].ToString());
// test the preview function returns one row.
var previewResult = await connection.GetPreview(importTable, null, CancellationToken.None);
Assert.Single(previewResult.Data);
}
public async Task Transform(Connection connection, string databaseName)
{
Table table = DataSets.CreateTable();
await connection.CreateDatabase(databaseName, CancellationToken.None);
//create a new table and write some data to it.
Transform reader = DataSets.CreateTestData();
await connection.CreateTable(table, true, CancellationToken.None);
TransformWriter writer = new TransformWriter();
TransformWriterResult writerResult = new TransformWriterResult();
await connection.InitializeAudit(writerResult, 0, "DataLink", 1, 2, "Test", 1, "Source", 2, "Target", TransformWriterResult.ETriggerMethod.Manual, "Test", CancellationToken.None);
var writeRecords = await writer.WriteAllRecords(writerResult, reader, table, connection, null, null, null, null, CancellationToken.None);
Assert.True(writeRecords, $"WriteAllRecords failed with message {writerResult.Message}. Details:{writerResult.ExceptionDetails}");
//check database can sort
if (connection.CanSort)
{
//use the new table test the data base is sorting
reader = connection.GetTransformReader(table);
SelectQuery query = new SelectQuery()
{
Sorts = new List <Sort>()
{
new Sort("IntColumn", Sort.EDirection.Descending)
}
};
await reader.Open(0, query, CancellationToken.None);
int sortValue = 10;
while (await reader.ReadAsync())
{
Assert.Equal(sortValue, Convert.ToInt32(reader["IntColumn"]));
sortValue--;
}
Assert.Equal(0, sortValue);
}
//check database can filter
if (connection.CanFilter)
{
//use the new table to test database is filtering
reader = connection.GetTransformReader(table);
SelectQuery query = new SelectQuery()
{
Filters = new List <Filter>()
{
new Filter("IntColumn", Filter.ECompare.LessThanEqual, 5)
}
};
await reader.Open(0, query, CancellationToken.None);
int count = 0;
while (await reader.ReadAsync())
{
Assert.True(Convert.ToInt32(reader["IntColumn"]) <= 5);
count++;
}
Assert.Equal(5, count);
}
Table deltaTable = DataSets.CreateTable();
deltaTable.AddAuditColumns();
deltaTable.Name = "DeltaTable";
await connection.CreateTable(deltaTable, true, CancellationToken.None);
Transform targetReader = connection.GetTransformReader(deltaTable);
reader = connection.GetTransformReader(table);
TransformDelta transformDelta = new TransformDelta(reader, targetReader, TransformDelta.EUpdateStrategy.AppendUpdate, 1, false);
writerResult = new TransformWriterResult();
await connection.InitializeAudit(writerResult, 0, "Datalink", 1, 2, "Test", 1, "Source", 2, "Target", TransformWriterResult.ETriggerMethod.Manual, "Test", CancellationToken.None);
var writeAllResult = await writer.WriteAllRecords(writerResult, transformDelta, deltaTable, connection, CancellationToken.None);
Assert.True(writeAllResult, writerResult.Message);
Assert.Equal(10L, writerResult.RowsCreated);
//check the audit table loaded correctly.
var auditTable = await connection.GetTransformWriterResults(0, null, "Datalink", writerResult.AuditKey, null, true, false, false, null, 1, null, false, CancellationToken.None);
Assert.Equal(10L, auditTable[0].RowsCreated);
}
