protected void Application_Start()
{
// Bot Storage: This is a great spot to register the private state storage for your bot.
// We provide adapters for Azure Table, CosmosDb, SQL Azure, or you can implement your own!
// For samples and documentation, see: https://github.com/Microsoft/BotBuilder-Azure
var store = new InMemoryDataStore();
Conversation.UpdateContainer(
builder =>
{
builder.RegisterModule(new AzureModule(Assembly.GetExecutingAssembly()));
builder.Register(c => store)
.Keyed <IBotDataStore <BotData> >(AzureModule.Key_DataStore)
.AsSelf()
.SingleInstance();
builder.Register(c => new CachingBotDataStore(store,
CachingBotDataStoreConsistencyPolicy
.ETagBasedConsistency))
.As <IBotDataStore <BotData> >()
.AsSelf()
.InstancePerLifetimeScope();
});
GlobalConfiguration.Configure(WebApiConfig.Register);
}
public void InMemoryDataStoreShouldAddOneItem()
{
InMemoryDataStore.Clear();
InMemoryDataStore.Add("item1");
Assert.AreEqual(1, InMemoryDataStore.Get().Count);
}
public async Task Memory_TestBotUserDataMigration()
{
var sourceStore = GetSourceStore();
var targetStore = new InMemoryDataStore();
await TestStoreType(BotStoreType.BotUserData, 10, sourceStore, targetStore);
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
DocumentDBRepository <Passenger> .Initialize(); // Initialize DB
Conversation.UpdateContainer(
builder =>
{
builder.RegisterModule(new AzureModule(Assembly.GetExecutingAssembly()));
// Using Azure Table Storage
//var store = new TableBotDataStore(ConfigurationManager.AppSettings["AzureWebJobsStorage"]); // requires Microsoft.BotBuilder.Azure Nuget package
// To use CosmosDb or InMemory storage instead of the default table storage, uncomment the corresponding line below
// var store = new DocumentDbBotDataStore("cosmos db uri", "cosmos db key"); // requires Microsoft.BotBuilder.Azure Nuget package
var store = new InMemoryDataStore(); // volatile in-memory store
builder.Register(c => store)
.Keyed <IBotDataStore <BotData> >(AzureModule.Key_DataStore)
.AsSelf()
.SingleInstance();
});
// GlobalConfiguration.Configure(WebApiConfig.Register);
}
public virtual void SetUp()
{
data = new InMemoryDataStore();
session = data.OpenSession();
mappingDSL = session.MappingDSL();
selectionDSL = session.SelectionDSL();
}
private void RegisterBotModules()
{
#if DEBUG
var store = new InMemoryDataStore();
#else
var storageConnectionString = ConfigurationManager.ConnectionStrings["StorageConnectionString"].ConnectionString;
var store = new TableBotDataStore(storageConnectionString);
#endif
Conversation.UpdateContainer(builder =>
{
builder.RegisterModule(new ReflectionSurrogateModule());
builder.RegisterModule <GlobalMessageHandlersBotModule>();
builder.Register(c => store)
.Keyed <IBotDataStore <BotData> >(AzureModule.Key_DataStore)
.AsSelf()
.SingleInstance();
builder.Register(c => new CachingBotDataStore(store,
CachingBotDataStoreConsistencyPolicy
.ETagBasedConsistency))
.As <IBotDataStore <BotData> >()
.AsSelf()
.InstancePerLifetimeScope();
});
}
static Environment()
{
DataStore = new InMemoryDataStore();
Logger = new ConsoleWindowLogger();
ShellCommands = new Dictionary<string, IShellCommand>();
RegisterCommands();
}
public void BasketsController_Update_Basket_Order_Line_Return_Correct_Updated_Order_Line()
{
var baskets = new InMemoryDataStore <Basket>();
var products = new InMemoryDataStore <Product>();
products.Seed();
baskets.Seed(products);
var bc = new BasketsController(products, baskets, _mapper);
var actionResult = bc.PatchOrderLine(_testBasketId, _testProductId, new JsonPatchDocument <OrderLineUpdateDto>().Add(p => p.Quantity, 12));
OkObjectResult okresult = actionResult as OkObjectResult;
Assert.IsNotNull(okresult);
OrderLineDto resultOrderLine = okresult.Value as OrderLineDto;
Assert.IsNotNull(resultOrderLine);
Assert.IsTrue(resultOrderLine.Quantity == 12);
OrderLine orderline = null;
baskets.Get(_testBasketId)?.OrderLines.TryGetValue(resultOrderLine.ProductId, out orderline);
Assert.IsNotNull(orderline);
Assert.IsTrue(orderline.Quantity == 12);
}
public App()
{
InitializeComponent();
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
var documentsPath = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
//MSSqlServer
//string connectionString = MSSqlConnectionProvider.GetConnectionString("YOUR_SERVER_NAME", "sa", "", "XamarinDemo");
//SQLite
//var filePath = Path.Combine(documentsPath, "xpoXamarinDemo.db");
//string connectionString = SQLiteConnectionProvider.GetConnectionString(filePath) + ";Cache=Shared;";
//In-memory data store with saving/loading from the xml file
var filePath = Path.Combine(documentsPath, "xpoXamarinDemo.xml");
string connectionString = InMemoryDataStore.GetConnectionString(filePath);
XpoHelper.InitXpo(connectionString);
if (Device.RuntimePlatform == Device.iOS)
{
MainPage = new MainPage();
}
else
{
MainPage = new NavigationPage(new MainPage());
}
}
protected void Application_Start()
{
//var uri = new System.Uri(KeyPassAndPhrase._cosmoDburi);
//var key = KeyPassAndPhrase._cosmokey;
//var store = new DocumentDbBotDataStore(uri, key);
var store = new InMemoryDataStore();
Conversation.UpdateContainer(
builder =>
{
builder.Register(c => store)
.Keyed <IBotDataStore <BotData> >(AzureModule.Key_DataStore)
.AsSelf()
.SingleInstance();
builder.Register(c => new CachingBotDataStore(store, CachingBotDataStoreConsistencyPolicy.ETagBasedConsistency))
.As <IBotDataStore <BotData> >()
.AsSelf()
.InstancePerLifetimeScope();
});
Thread.CurrentThread.CurrentCulture = new CultureInfo("pt-BR");
Thread.CurrentThread.CurrentUICulture = new CultureInfo("pt-BR");
GlobalConfiguration.Configure(WebApiConfig.Register);
}
protected void Application_Start()
{
var store = new InMemoryDataStore();
Conversation.UpdateContainer(
builder =>
{
builder.Register(c => store)
.Keyed <IBotDataStore <BotData> >(AzureModule.Key_DataStore)
.AsSelf()
.SingleInstance();
builder.Register(c => new CachingBotDataStore(store,
CachingBotDataStoreConsistencyPolicy
.ETagBasedConsistency))
.As <IBotDataStore <BotData> >()
.AsSelf()
.InstancePerLifetimeScope();
});
///*Azure storage*/
//Conversation.UpdateContainer(
// builder =>
// {
// builder.RegisterModule(new AzureModule(Assembly.GetExecutingAssembly()));
// var store = new TableBotDataStore(ConfigurationManager.ConnectionStrings["StorageConnectionString"].ConnectionString);
// builder.Register(c => store)
// .Keyed<IBotDataStore<BotData>>(AzureModule.Key_DataStore)
// .AsSelf()
// .SingleInstance();
// });
GlobalConfiguration.Configure(WebApiConfig.Register);
}
protected void Application_Start()
{
// Bot Storage: This is a great spot to register the private state storage for your bot.
// We provide adapters for Azure Table, CosmosDb, SQL Azure, or you can implement your own!
// For samples and documentation, see: https://github.com/Microsoft/BotBuilder-Azure
Conversation.UpdateContainer(
builder =>
{
builder.RegisterModule(new AzureModule(Assembly.GetExecutingAssembly()));
// Using Azure Table Storage
//var store = new TableBotDataStore(ConfigurationManager.AppSettings["AzureWebJobsStorage"]);
// requires Microsoft.BotBuilder.Azure Nuget package
// To use CosmosDb or InMemory storage instead of the default table storage,
// uncomment the corresponding line below
//var store = new DocumentDbBotDataStore("https://codtropy-dev.documents.azure.com:443/", "KZjSz0qOyRfTp1JStTid8WInyuEtQgE65nDM9Tu5WgjUFuFP29p2vxyFdS870UODVAbTR6jxGm1fXc1PL7aFFQ==");
// requires Microsoft.BotBuilder.Azure Nuget package
var store = new InMemoryDataStore(); // volatile in-memory store
builder.Register(c => store)
.Keyed <IBotDataStore <BotData> >(AzureModule.Key_DataStore)
.AsSelf()
.SingleInstance();
});
GlobalConfiguration.Configure(WebApiConfig.Register);
}
public void The_same_Id_exists_only_once()
{
//Arrange
var datastore = new InMemoryDataStore <IData>();
var id = 42;
var item1 = new Mock <IData>();
item1.SetupGet(fake => fake.Id).Returns(id);
var item2 = new Mock <IData>();
item2.SetupGet(fake => fake.Id).Returns(id);
var items = new[]
{
item1.Object,
item2.Object
};
//Act
datastore.AddOrUpdateAsync(items).Wait();
var retrieved = datastore.GetAllAsync().Result;
//Assert
Assert.AreEqual(1, retrieved.Count(item => item.Id == id));
}
public static void Register(HttpConfiguration config)
{
#if DEBUG
Conversation.UpdateContainer(
builder =>
{
var store = new InMemoryDataStore();
builder.Register(c => store)
.Keyed <IBotDataStore <BotData> >(AzureModule.Key_DataStore)
.AsSelf()
.SingleInstance();
});
#else
Conversation.UpdateContainer(
builder =>
{
//builder.RegisterModule(new AzureModule(Assembly.GetExecutingAssembly()));
var appKey = ConfigurationManager.ConnectionStrings["StorageConnectionString"];
var store = new TableBotDataStore(appKey.ConnectionString);
builder.Register(c => store)
.Keyed <IBotDataStore <BotData> >(AzureModule.Key_DataStore)
.AsSelf()
.SingleInstance();
// Register your Web API controllers.
// builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
// builder.RegisterWebApiFilterProvider(config);
});
//config.DependencyResolver = new AutofacWebApiDependencyResolver(Conversation.Container);
#endif
}
protected void Application_Start()
{
// Bot Storage: This is a great spot to register the private state storage for your bot.
// We provide adapters for Azure Table, CosmosDb, SQL Azure, or you can implement your own!
// For samples and documentation, see: https://github.com/Microsoft/BotBuilder-Azure
Conversation.UpdateContainer(
builder =>
{
builder.RegisterModule(new AzureModule(Assembly.GetExecutingAssembly()));
// Using Azure Table Storage
//var store = new TableBotDataStore(ConfigurationManager.AppSettings["AzureWebJobsStorage"]); // requires Microsoft.BotBuilder.Azure Nuget package
// To use CosmosDb or InMemory storage instead of the default table storage, uncomment the corresponding line below
// var store = new DocumentDbBotDataStore("cosmos db uri", "cosmos db key"); // requires Microsoft.BotBuilder.Azure Nuget package
var store = new InMemoryDataStore(); // volatile in-memory store
builder.Register(c => store)
.Keyed <IBotDataStore <BotData> >(AzureModule.Key_DataStore)
.AsSelf()
.SingleInstance();
});
GlobalConfiguration.Configure(WebApiConfig.Register);
}
public BaseRepositoryTest()
{
data = new InMemoryDataStore(Guid.NewGuid().ToString());
session = data.OpenSession();
mappingDSL = session.MappingDSL();
selectionDSL = session.SelectionDSL();
}
protected void Application_Start()
{
// Try to get the connection string
BotSettings botSettings = new BotSettings();
string connectionString = botSettings[BotSettings.KeyRoutingDataStorageConnectionString];
Conversation.UpdateContainer(
builder =>
{
builder.RegisterModule(new AzureModule(Assembly.GetExecutingAssembly()));
// Bot Storage: register state storage for your bot
IBotDataStore <BotData> botDataStore = null;
if (string.IsNullOrEmpty(connectionString))
{
// Default store: volatile in-memory store - Only for prototyping!
System.Diagnostics.Debug.WriteLine("WARNING!!! Using InMemoryDataStore, which should be only used for prototyping, for the bot state!");
botDataStore = new InMemoryDataStore();
}
else
{
// Azure Table Storage
System.Diagnostics.Debug.WriteLine("Using Azure Table Storage for the bot state");
botDataStore = new TableBotDataStore(connectionString);
}
builder.Register(c => botDataStore)
.Keyed <IBotDataStore <BotData> >(AzureModule.Key_DataStore)
.AsSelf()
.SingleInstance();
});
GlobalConfiguration.Configure(WebApiConfig.Register);
}
protected void Application_Start()
{
Conversation.UpdateContainer(
builder =>
{
// Bot Storage: Here we register the state storage for your bot.
// Default store: volatile in-memory store - Only for prototyping!
// We provide adapters for Azure Table, CosmosDb, SQL Azure, or you can implement your own!
// For samples and documentation, see: https://github.com/Microsoft/BotBuilder-Azure
var store = new InMemoryDataStore();
// Other storage options
// var store = new TableBotDataStore("...DataStorageConnectionString..."); // requires Microsoft.BotBuilder.Azure Nuget package
// var store = new DocumentDbBotDataStore("cosmos db uri", "cosmos db key"); // requires Microsoft.BotBuilder.Azure Nuget package
var memorystore = new InMemoryDataStore();
builder
.RegisterType <InMemoryDataStore>()
.Keyed <IBotDataStore <BotData> >(typeof(ConnectorStore));
builder.Register(c => new CachingBotDataStore(memorystore, CachingBotDataStoreConsistencyPolicy.ETagBasedConsistency))
.As <IBotDataStore <BotData> >()
.AsSelf()
.SingleInstance();
});
GlobalConfiguration.Configure(WebApiConfig.Register);
}
public static IDataStore CreateProviderFromString(string connectionString, AutoCreateOption autoCreateOption, out IDisposable[] objectsToDisposeOnDisconnect)
{
InMemoryDataStore result = new InMemoryDataStore(dataSet, autoCreateOption);
objectsToDisposeOnDisconnect = new IDisposable[] { };
return(result);
}
protected void Application_Start()
{
var store = new InMemoryDataStore();
var config = GlobalConfiguration.Configuration;
Conversation.UpdateContainer(
builder =>
{
builder.RegisterModule(new AzureModule(Assembly.GetExecutingAssembly()));
builder.RegisterModule <MainModule>();
builder.Register(c => store)
.Keyed <IBotDataStore <BotData> >(AzureModule.Key_DataStore)
.AsSelf()
.SingleInstance();
builder.Register(c => new CachingBotDataStore(store,
CachingBotDataStoreConsistencyPolicy
.ETagBasedConsistency))
.As <IBotDataStore <BotData> >()
.AsSelf()
.InstancePerLifetimeScope();
builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
builder.RegisterWebApiFilterProvider(config);
});
config.DependencyResolver = new AutofacWebApiDependencyResolver(Conversation.Container);
GlobalConfiguration.Configure(WebApiConfig.Register);
}
protected void Application_Start()
{
Conversation.UpdateContainer(
builder =>
{
builder.RegisterModule(new AzureModule(Assembly.GetExecutingAssembly()));
// Bot Storage: Here we register the state storage for your bot.
// Default store: volatile in-memory store - Only for prototyping!
// We provide adapters for Azure Table, CosmosDb, SQL Azure, or you can implement your own!
// For samples and documentation, see: https://github.com/Microsoft/BotBuilder-Azure
var store = new InMemoryDataStore();
// Other storage options
// var store = new TableBotDataStore("...DataStorageConnectionString..."); // requires Microsoft.BotBuilder.Azure Nuget package
// var store = new DocumentDbBotDataStore("cosmos db uri", "cosmos db key"); // requires Microsoft.BotBuilder.Azure Nuget package
builder.Register(c => store)
.Keyed <IBotDataStore <BotData> >(AzureModule.Key_DataStore)
.AsSelf()
.SingleInstance();
});
GlobalConfiguration.Configure(WebApiConfig.Register);
}
protected void Application_Start()
{
var store = new InMemoryDataStore();
Conversation.UpdateContainer(
builder =>
{
builder.Register(c => store)
.Keyed <IBotDataStore <BotData> >(AzureModule.Key_DataStore)
.AsSelf()
.SingleInstance();
builder.Register(c => new CachingBotDataStore(store,
CachingBotDataStoreConsistencyPolicy
.ETagBasedConsistency))
.As <IBotDataStore <BotData> >()
.AsSelf()
.InstancePerLifetimeScope();
});
//Conversation.UpdateContainer(builder =>
//{
// builder.RegisterModule(new DefaultExceptionMessageOverrideModule());
//});
GlobalConfiguration.Configure(WebApiConfig.Register);
}
public async Task Should_log_writes()
{
var model = CreateModel();
var configuration = CreateConfiguration();
var entityType = model.GetEntityType(typeof(Customer));
var customer = new Customer {
Id = 42, Name = "Unikorn"
};
var entityEntry = new ClrStateEntry(configuration, entityType, customer);
await entityEntry.SetEntityStateAsync(EntityState.Added);
var mockLogger = new Mock <ILogger>();
var mockFactory = new Mock <ILoggerFactory>();
mockFactory.Setup(m => m.Create(It.IsAny <string>())).Returns(mockLogger.Object);
var inMemoryDataStore = new InMemoryDataStore(configuration, new InMemoryDatabase(new[] { mockFactory.Object }));
await inMemoryDataStore.SaveChangesAsync(new[] { entityEntry });
mockLogger.Verify(
l => l.WriteCore(
TraceType.Information,
0,
It.IsAny <string>(),
null,
It.IsAny <Func <object, Exception, string> >()),
Times.Once);
}
public static void Register(HttpConfiguration config)
{
// Json settings
config.Formatters.JsonFormatter.SerializerSettings.NullValueHandling = NullValueHandling.Ignore;
config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
config.Formatters.JsonFormatter.SerializerSettings.Formatting = Formatting.Indented;
JsonConvert.DefaultSettings = () => new JsonSerializerSettings()
{
ContractResolver = new CamelCasePropertyNamesContractResolver(),
Formatting = Newtonsoft.Json.Formatting.Indented,
NullValueHandling = NullValueHandling.Ignore,
};
// Web API configuration and services
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
var memorystore = new InMemoryDataStore();
}
public async Task Save_changes_removes_deleted_objects_from_store()
{
var model = CreateModel();
var configuration = CreateConfiguration();
var entityType = model.GetEntityType(typeof(Customer));
var customer = new Customer {
Id = 42, Name = "Unikorn"
};
var entityEntry = new ClrStateEntry(configuration, entityType, customer);
await entityEntry.SetEntityStateAsync(EntityState.Added);
var inMemoryDataStore = new InMemoryDataStore(configuration, new InMemoryDatabase(new[] { new NullLoggerFactory() }));
await inMemoryDataStore.SaveChangesAsync(new[] { entityEntry });
// Because the data store is being used directly the entity state must be manually changed after saving.
await entityEntry.SetEntityStateAsync(EntityState.Unchanged);
customer.Name = "Unikorn, The Return";
await entityEntry.SetEntityStateAsync(EntityState.Deleted);
await inMemoryDataStore.SaveChangesAsync(new[] { entityEntry });
Assert.Equal(0, inMemoryDataStore.Database.SelectMany(t => t).Count());
}
public void StoreAndRetrieveItem()
{
var store = new InMemoryDataStore <int>();
var ft = new Template <int>(store, "test")
{
Id = 1
};
ft.FieldDefinitions.Add(new FieldDefinition <int> {
Id = 1, Name = "test", FieldType = FieldType.Amount
});
ft.FieldDefinitions.Add(new FieldDefinition <int> {
Id = 2, Name = "test2", FieldType = FieldType.SingleLineText, DefaultValue = "a"
});
var fi = ft.CreateNew();
Assert.IsNotNull(fi);
Assert.IsTrue(fi.Fields.Count == 2);
fi.Id = 1;
// Make at least one change, non dirty items are not stored
fi["test"] = "value";
fi["test2"] = "b";
fi.Save();
var fi2 = store.LoadItem(1);
Assert.AreEqual(fi2.Fields.Count, fi.Fields.Count);
}
private void RegisterBotDependencies()
{
Conversation.UpdateContainer(builder =>
{
builder.RegisterModule(new ReflectionSurrogateModule());
builder.RegisterModule <HabitatHomeBotModule>();
builder.RegisterControllers(typeof(WebApiApplication).Assembly);
builder.RegisterModule(new AzureModule(Assembly.GetExecutingAssembly()));
// Bot Storage: Here we register the state storage for your bot.
// Default store: volatile in-memory store - Only for prototyping!
// We provide adapters for Azure Table, CosmosDb, SQL Azure, or you can implement your own!
// For samples and documentation, see: https://github.com/Microsoft/BotBuilder-Azure
var store = new InMemoryDataStore();
// Other storage options
// var store = new TableBotDataStore("...DataStorageConnectionString..."); // requires Microsoft.BotBuilder.Azure Nuget package
// var store = new DocumentDbBotDataStore("cosmos db uri", "cosmos db key"); // requires Microsoft.BotBuilder.Azure Nuget package
builder.Register(c => store)
.Keyed <IBotDataStore <BotData> >(AzureModule.Key_DataStore)
.AsSelf()
.SingleInstance();
});
DependencyResolver.SetResolver(new AutofacDependencyResolver(Conversation.Container));
}
private static void ConfigureServices(HttpConfiguration config)
{
Conversation.UpdateContainer(
builder =>
{
// Register the Bot Builder module
builder.RegisterModule(new DialogModule());
// Register the alarm dependencies
builder.RegisterModule(new TeamsTalentMgmtAppModule());
// Bot Storage: Here we register the state storage for your bot.
// Default store: volatile in-memory store - Only for prototyping!
// In production you need to use adapters for Azure Table, CosmosDb, SQL Azure, or you can implement your own!
// For samples and documentation, see: https://github.com/Microsoft/BotBuilder-Azure
var store = new InMemoryDataStore();
// Other storage options
// var store = new TableBotDataStore("...DataStorageConnectionString..."); // requires Microsoft.BotBuilder.Azure Nuget package
// var store = new DocumentDbBotDataStore("cosmos db uri", "cosmos db key"); // requires Microsoft.BotBuilder.Azure Nuget package
builder.Register(c => store)
.Keyed <IBotDataStore <BotData> >(typeof(ConnectorStore))
.AsSelf()
.SingleInstance();
// Register your Web API controllers.
builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
builder.RegisterWebApiFilterProvider(config);
});
// Set the dependency resolver to be Autofac.
config.DependencyResolver = new AutofacWebApiDependencyResolver(Conversation.Container);
}
public virtual void Setup()
{
DictionaryNode.ReaderWriterLockWrapperCreator = new ReaderWriterLockWrapper();
elDictionary = new Dictionary(new DictionaryXmlReader().ReadFromString(elClassXml), Schema.GetCommonSchema());
DefaultDictionary = new Dictionary(new DictionaryXmlReader().ReadFromString(DefaultClassXml),
Schema.GetCommonSchema());
PersistentAppDictionary = new Dictionary(new DictionaryXmlReader().ReadFromString(PersistentAppClassXml),
Schema.GetCommonSchema());
DefaultDictionary2 = new Dictionary(new DictionaryXmlReader().ReadFromString(DefaultClassXml2),
Schema.GetCommonSchema());
Session.DefaultSession.Disconnect();
// dataSet = new DataSet();
XafTypesInfo.Reset(true);
var dataStore = new InMemoryDataStore( AutoCreateOption.DatabaseAndSchema);
dataLayer = new SimpleDataLayer(XafTypesInfo.XpoTypeInfoSource.XPDictionary, dataStore);
XpoDefault.DataLayer = dataLayer;
// Isolate.Fake.ISecurityComplex();
}
static Environment()
{
DataStore = new InMemoryDataStore();
Logger = new ConsoleWindowLogger();
CommandBuilders = new Dictionary<string, ICommandBuilder>();
RegisterCommandBuilders();
}
public void BasketsController_Create_Basket_Order_Line_Return_Correct_Order_Line()
{
var baskets = new InMemoryDataStore <Basket>();
var products = new InMemoryDataStore <Product>();
products.Seed();
baskets.Seed(products);
var orderLine = new OrderLineCreateDto()
{
ProductId = new Guid("3aee1758-77b9-4e86-9c57-77adbbc0956f"), //Watermelon
Quantity = 5
};
var bc = new BasketsController(products, baskets, _mapper);
var actionResult = bc.PostAddOrderLineToBasket(_testBasketId, orderLine);
CreatedAtRouteResult createdresult = actionResult as CreatedAtRouteResult;
Assert.IsNotNull(createdresult);
OrderLineDto resultOrderLine = createdresult.Value as OrderLineDto;
Assert.IsNotNull(resultOrderLine);
Assert.AreEqual(resultOrderLine.ProductId, orderLine.ProductId);
}
static Environment()
{
DataStore = new InMemoryDataStore();
Logger = new ConsoleWindowLogger();
CommandBuilders = new Dictionary <string, ICommandBuilder>();
RegisterCommandBuilders();
}
protected void Application_Start()
{
try
{
var logger = new LoggerService <ILogger>();
logger.Info("Starting service...");
var config = GlobalConfiguration.Configuration;
Conversation.UpdateContainer(
builder =>
{
builder.RegisterGeneric(typeof(LoggerService <>)).As(typeof(ILoggerService <>))
.InstancePerDependency();
// Register your Web API controllers.
builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
builder.RegisterWebApiFilterProvider(config);
builder.RegisterType <RootDialog>().AsSelf().InstancePerDependency();
builder.RegisterType <QnaDialog>().AsSelf().InstancePerDependency();
//BOT Data storage
builder.RegisterModule(new AzureModule(Assembly.GetExecutingAssembly()));
var store = new InMemoryDataStore();
builder.Register(c => store)
.Keyed <IBotDataStore <BotData> >(AzureModule.Key_DataStore)
.AsSelf()
.SingleInstance();
});
// Set the dependency resolver to be Autofac.
config.DependencyResolver = new AutofacWebApiDependencyResolver(Conversation.Container);
GlobalConfiguration.Configure(cfg =>
{
cfg.MapHttpAttributeRoutes();
cfg.Routes.MapHttpRoute(
"DefaultApi",
"api/{controller}/{id}",
new { id = RouteParameter.Optional }
);
// Register your Web API controllers.
});
logger.Info("Service successfully started.");
}
catch (Exception e)
{
var logger = new LoggerService <ILogger>();
logger.Error(e);
Console.WriteLine(e);
throw;
}
}
public void Rollback()
{
if (this.CurrentTransactionDataStore != null)
{
this.CurrentTransactionDataStore.Clear();
this.CurrentTransactionDataStore = null;
}
}
public void Uses_persistent_database_by_default()
{
var configuration = CreateConfiguration();
var persistentDatabase = new InMemoryDatabase(new[] { new NullLoggerFactory() });
var inMemoryDataStore = new InMemoryDataStore(configuration, persistentDatabase);
Assert.Same(persistentDatabase, inMemoryDataStore.Database);
}
public void should_find_the_entity()
{
var datastore = new InMemoryDataStore();
var fish = new Fish();
datastore.Save(fish);
datastore.Contains(fish).ShouldBeEqualTo(true);
}
private IDataLayer CreateDataLayer()
{
XPDictionary dictionary = new ReflectionDictionary();
dictionary.CollectClassInfos(typeof(XpoAsyncTests).Assembly);
var memoryDataStore = new InMemoryDataStore(AutoCreateOption.DatabaseAndSchema);
return new ThreadSafeDataLayer(dictionary, memoryDataStore);
}
private void InitSeedData()
{
DataStore = new InMemoryDataStore();
var unitOfWork = new InMemoryUnitOfWork(DataStore);
unitOfWork.GetRepository<Client>()
.Add(new Client("Adrian Freemantle", "0845140900"));
unitOfWork.Commit();
}
public void Uses_persistent_database_if_configured_as_persistent()
{
var options = CreateConfiguration(new DbContextOptions().UseInMemoryStore(persist: true));
var persistentDatabase = new InMemoryDatabase(new[] { new NullLoggerFactory() });
var inMemoryDataStore = new InMemoryDataStore(options, persistentDatabase);
Assert.Same(persistentDatabase, inMemoryDataStore.Database);
}
static Environment()
{
DataStore = new InMemoryDataStore();
Logger = new ConsoleWindowLogger();
CommandBuilders = new Dictionary<string, ICommandBuilder>();
SystemCommands = new Dictionary<string, ISystemCommand>();
ScriptRecorder = new ScriptRecorder();
RegsiterSystemCommands();
RegsiterCommandBuilders();
}
private static IDataStore GetDataStore()
{
var dataStore = new InMemoryDataStore();
var firstChangeSet = new UncommittedChangeSet(null, "First change set");
dataStore.Store(firstChangeSet);
var secondChangeSet = new UncommittedChangeSet(firstChangeSet.Id, "Second change set");
dataStore.Store(secondChangeSet);
dataStore.Store(new UncommittedChangeSet(secondChangeSet.Id, "First alternative branch after second change set"));
dataStore.Store(new UncommittedChangeSet(secondChangeSet.Id, "Second alternative"));
return dataStore;
}
public void should_find_the_entity_using_a_custom_equality_comparer()
{
var datastore = new InMemoryDataStore();
var fishA = new Fish { Id = 2 };
datastore.Save(fishA);
var fishB = new Fish { Id = 55 };
datastore.Save(fishB);
var fishToTest = new Fish { Id = 2 };
datastore.Contains(fishToTest, new FishIdEqualityComparer()).ShouldBeEqualTo(true);
}
public void TestInMemoryDataStore()
{
Assert.IsFalse(File.Exists(dataPersistFile));
IDataStore<JObject> dataStore = new InMemoryDataStore<JObject>();
dataStore.PersistPath = dataPersistFile;
string key1 = "testkey1";
string key2 = "testkey2";
JObject json1 = TestUtils.GenerateJson();
JObject json2 = TestUtils.GenerateJson();
JObject json3 = TestUtils.GenerateJson();
dataStore.Insert(key1, json1);
dataStore.Insert(key2, json2);
Dictionary<string, JObject> listResult = dataStore.List();
Assert.AreEqual(2, listResult.Count);
Assert.IsNotNull(listResult[key1]);
Assert.IsNotNull(listResult[key2]);
JObject getResult = dataStore.Get(key1);
Assert.IsTrue(JsonConvert.SerializeObject(getResult).Equals(JsonConvert.SerializeObject(json1)));
dataStore.Insert(key2, json3);
JObject getResult2 = dataStore.Get(key2);
Assert.IsTrue(JsonConvert.SerializeObject(getResult2).Equals(JsonConvert.SerializeObject(json3)));
dataStore.Save();
Assert.IsTrue(File.Exists(dataPersistFile));
string savedFileContent = null;
StreamReader reader = new StreamReader(dataPersistFile);
savedFileContent = reader.ReadToEnd();
reader.Close();
Debug.WriteLine(String.Format("Save file content = {0}", savedFileContent));
Assert.IsTrue(savedFileContent.Length > 0);
IDataStore<JObject> loadedDataStore = InMemoryDataStore<JObject>.Load<JObject>(dataPersistFile);
Dictionary<string, JObject> listResult2 = loadedDataStore.List();
Assert.AreEqual(2, listResult2.Count);
Assert.IsNotNull(listResult2[key1]);
Assert.IsNotNull(listResult2[key2]);
JObject getResult3 = loadedDataStore.Get(key2);
Assert.IsTrue(JsonConvert.SerializeObject(getResult3).Equals(JsonConvert.SerializeObject(json3)));
loadedDataStore.Delete(key1);
listResult2 = loadedDataStore.List();
Assert.AreEqual(1, listResult2.Count);
Assert.IsNull(loadedDataStore.Get(key1));
}
public async Task Save_changes_adds_new_objects_to_store()
{
var model = CreateModel();
var configuration = CreateConfiguration();
var entityType = model.GetEntityType(typeof(Customer));
var customer = new Customer { Id = 42, Name = "Unikorn" };
var entityEntry = new ClrStateEntry(configuration, entityType, customer);
await entityEntry.SetEntityStateAsync(EntityState.Added);
var inMemoryDataStore = new InMemoryDataStore(configuration, new InMemoryDatabase(new[] { new NullLoggerFactory() }));
await inMemoryDataStore.SaveChangesAsync(new[] { entityEntry });
Assert.Equal(1, inMemoryDataStore.Database.SelectMany(t => t).Count());
Assert.Equal(new object[] { 42, "Unikorn" }, inMemoryDataStore.Database.Single().Single());
}
public void TestSaveDataStoreToJson()
{
//given
IDataStore<JObject> dataStore = new InMemoryDataStore<JObject>();
dataStore.PersistPath = _dataPersistFile;
var obj = new JObject();
obj["key"] = "value";
//when
dataStore.Insert("main-key", obj);
dataStore.Save();
//then
Assert.IsTrue(_ioService.Exists(_dataPersistFile));
var content = _ioService.ReadFile(_dataPersistFile);
Assert.AreEqual("{\"main-key\":{\"key\":\"value\"}}", content);
}
public static void PrepareDB() {
string _ConnectionString = Common.GetConfigParam("ConnectionString");
if (_ConnectionString == "InMemory") {
// Create the data store and a DataCacheRoot
dataStore = new InMemoryDataStore(AutoCreateOption.DatabaseAndSchema);
/*
// ---------------------------------
// Образец с применением кэшей
DataCacheRoot cacheRoot = new DataCacheRoot((IDataStoreForTests)dataStore);
// Create two DataCacheNodes for the same DataCacheRoot
cacheNode1 = new DataCacheNode(cacheRoot);
//cacheNode2 = new DataCacheNode(cacheRoot);
// Create two data layers and two sessions
dataLayer1 = new SimpleDataLayer(cacheNode1);
//dataLayer2 = new SimpleDataLayer(cacheNode2);
session1 = new Session(dataLayer1);
//session2 = new Session(dataLayer2);
// ---------------------------------
*/
// Образец без создания кэшей
dataLayer = new SimpleDataLayer(dataStore);
//session1 = new Session(dataLayer1);
XpoDefault.DataLayer = dataLayer as IDataLayer;
XpoDefault.Session = null;
} else if (_ConnectionString == "DefaultAccess") {
session0 = new Session();
//dataStore = session0.;
dataLayer = session0.DataLayer as SimpleDataLayer;
} else {
// Испольуется полученная строка подключения
IDataLayer dl = XpoDefault.GetDataLayer(_ConnectionString, AutoCreateOption.DatabaseAndSchema);
dataLayer = dl;
XpoDefault.DataLayer = dl;
XpoDefault.Session = null;
}
CheckValidationRule = (Common.GetConfigParam("CheckValidationRule") == "Y") ? true : false;
}
public void TestInsertIntoDataStore()
{
//given
IDataStore<JObject> dataStore = new InMemoryDataStore<JObject>();
var obj = new JObject();
obj["key"] = "value";
//when
dataStore.Insert("key1", obj);
dataStore.Insert("key2", obj);
//then
var list = dataStore.List();
Assert.AreEqual(2, list.Count);
Assert.IsNotNull(list["key1"]);
var result = dataStore.Get("key1");
Assert.AreEqual(obj, result);
}
private void InitSeedData()
{
DataStore = new InMemoryDataStore();
var unitOfWork = new InMemoryUnitOfWork(DataStore);
unitOfWork.GetRepository<Client>()
.Add(new Client
{
ClientName = "Adrian Freemantle",
Email = "*****@*****.**",
PhoneNumber = "0125551111",
Street = "Alon road",
City = "Sandton",
StreetNumber = "9",
PostalCode = "0001",
});
unitOfWork.Commit();
}
public void SetUp()
{
var dataStore = new InMemoryDataStore();
var commandExecutor = new CommandExecutor()
.RegisterCommandHandler(new CreateUnitCommandHandler())
.RegisterCommandHandler(new CreateHierarchyCommandHandler())
.RegisterCommandHandler(new SetHierarchyRootCommandHandler())
.RegisterCommandHandler(new MoveUnitCommandHandler())
.RegisterCommandHandler(new CreateHierarchyNodeCommandHandler())
.RegisterCommandHandler(new AttachToHierarchyCommandHandler())
.RegisterCommandHandler(new AttachChildCommandHandler())
.RegisterCommandHandler(new DetachChildCommandHandler())
.RegisterCommandHandler(new SetParentCommandHandler());
var typeRepository = new ObjectTypeDescriptorRepository()
.RegisterUsingReflection<Unit>()
.RegisterUsingReflection<HierarchyNode>()
.RegisterUsingReflection<Hierarchy>();
dataFacade = new DataFacade(commandExecutor, dataStore, new IncrementalCachingSnapshotFactory());
objectFacade = new ObjectFacade(dataFacade, typeRepository, commandExecutor);
}
public InMemoryDataStoreServices(
[NotNull] InMemoryDataStore store,
[NotNull] InMemoryDataStoreCreator creator,
[NotNull] InMemoryConnection connection,
[NotNull] InMemoryValueGeneratorCache valueGeneratorCache,
[NotNull] Database database,
[NotNull] ModelBuilderFactory modelBuilderFactory)
{
Check.NotNull(store, "store");
Check.NotNull(creator, "creator");
Check.NotNull(connection, "connection");
Check.NotNull(valueGeneratorCache, "valueGeneratorCache");
Check.NotNull(database, "database");
Check.NotNull(modelBuilderFactory, "modelBuilderFactory");
_store = store;
_creator = creator;
_connection = connection;
_valueGeneratorCache = valueGeneratorCache;
_database = database;
_modelBuilderFactory = modelBuilderFactory;
}
public void It_can_handle_1000_objects_with_10_changes_each()
{
var dataStore = new InMemoryDataStore();
var objectIds = GenerateObjectIds(1000);
ChangeSetId? previousChangeSetId = null;
ChangeSetId currentChangeSetId = ChangeSetId.NewUniqueId();
dataStore.ChangeSets.Add(new ChangeSet(currentChangeSetId, previousChangeSetId, "Some comment", GenerateCreateCommands(objectIds)));
previousChangeSetId = currentChangeSetId;
for (int i = 0; i < 9; i++)
{
currentChangeSetId = ChangeSetId.NewUniqueId();
dataStore.ChangeSets.Add(new ChangeSet(currentChangeSetId, previousChangeSetId, "Some comment", GenerateUpdateCommands(i, objectIds)));
previousChangeSetId = currentChangeSetId;
}
var commandExecutor = new CommandExecutor()
.RegisterCommandHandler(new CreateObjectCommandHandler())
.RegisterCommandHandler(new ModifyAttributeCommandHandler());
var objectTypeRepository = new ObjectTypeDescriptorRepository()
.RegisterUsingReflection<TestingObject>();
var dataFacade = new DataFacade(commandExecutor, dataStore, new IncrementalCachingSnapshotFactory());
var objectFacade = new ObjectFacade(dataFacade, objectTypeRepository, commandExecutor);
var stopwatch = new Stopwatch();
stopwatch.Start();
var currentView = objectFacade.GetSnapshot(currentChangeSetId);
var allObjects = currentView.List<TestingObject>().ToList();
stopwatch.Stop();
Console.WriteLine(stopwatch.ElapsedMilliseconds);
Assert.AreEqual(1000, allObjects.Count);
foreach (var testingObject in allObjects)
{
Assert.AreEqual("8", testingObject.TextValue);
}
}
private void InitSeedData()
{
DataStore = new InMemoryDataStore();
var unitOfWork = new InMemoryUnitOfWork(DataStore);
unitOfWork.GetRepository<Client>()
.Add(new Client
{
ClientName = "Adrian Freemantle",
Email = "*****@*****.**",
PhoneNumber = "0125551111",
Street = "Alon road",
City = "Sandton",
StreetNumber = "9",
PostalCode = "0001"
});
unitOfWork.GetRepository<Account>()
.Add(new Account
{
AccountNumber = "1048163555",
Balance = 1000,
Closed = false,
ClientId = 1
});
unitOfWork.GetRepository<BankCard>()
.Add(new BankCard
{
AccountId = 1,
ClientId = 1,
Disabled = false
});
unitOfWork.Commit();
}
public void TearDown()
{
this.dataStore = null;
}
public void SetUp()
{
this.dataStore = new InMemoryDataStore();
}
public void SetUp()
{
dataStore = new InMemoryDataStore();
commandExecutor = new CommandExecutor()
.RegisterCommandHandler(new AttachObjectCommandHandler())
.RegisterCommandHandler(new CreateObjectCommandHandler())
.RegisterCommandHandler(new ModifyAttributeCommandHandler());
}
public InMemoryDataStoreCreator([NotNull] InMemoryDataStore dataStore)
{
Check.NotNull(dataStore, "dataStore");
_dataStore = dataStore;
}
private UnitOfWork GetXmlUnitOfWork() {
var reflectionDictionary = new ReflectionDictionary();
var appSetting = string.Format(ConfigurationManager.AppSettings["VideoRentLegacyPath"], AssemblyInfo.VersionShort);
var fullPath = Environment.ExpandEnvironmentVariables(appSetting);
var legacyAssembly = Assembly.LoadFrom(Path.Combine(fullPath + @"\bin", @"DevExpress.VideoRent.dll"));
reflectionDictionary.CollectClassInfos(legacyAssembly);
var inMemoryDataStore = new InMemoryDataStore();
inMemoryDataStore.ReadXml(Path.Combine(fullPath + @"\CS\DevExpress.VideoRent\Data", @"VideoRent.xml"));
var simpleDataLayer = new SimpleDataLayer(reflectionDictionary, inMemoryDataStore);
return new UnitOfWork(simpleDataLayer);
}
static Environment()
{
DataStore = new InMemoryDataStore();
Logger = new ConsoleWindowLogger();
CommandFactory = new CommandFactory();
}
static DataStoreFactory()
{
DataStore = new InMemoryDataStore();
}
public InMemoryUnitOfWork(InMemoryDataStore dataStore)
{
this.DataStore = dataStore;
}
