public async Task TestAddCosmosBookWithReviewsOk()
{
//SETUP
var options = this.GetCosmosDbToEmulatorOptions <CosmosDbContext>();
using var context = new CosmosDbContext(options);
await context.Database.EnsureDeletedAsync();
await context.Database.EnsureCreatedAsync();
//ATTEMPT
var cBook = new CosmosBook
{
CosmosBookId = 1, //NOTE: You have to provide a key value!
Title = "Book Title",
PublishedDate = new DateTime(2019, 1, 1),
Reviews = new List <CosmosReview>
{
new CosmosReview {
Comment = "Great!", NumStars = 5, VoterName = "Reviewer1"
},
new CosmosReview {
Comment = "Hated it", NumStars = 1, VoterName = "Reviewer2"
}
}
};
context.Add(cBook);
await context.SaveChangesAsync();
//VERIFY
(await context.Books.FindAsync(1)).Reviews.Count.ShouldEqual(2);
}
public async Task TestFromSqlRaw()
{
//SETUP
var options = this.GetCosmosDbOptions <CosmosDbContext>();
using var context = new CosmosDbContext(options);
await context.Database.EnsureDeletedAsync();
await context.Database.EnsureCreatedAsync();
var book1 = new CosmosBook
{
BookId = 123,
Title = "Year2000",
PublishedOn = new DateTime(2000, 1, 1),
YearPublished = 2000
};
var book2 = new CosmosBook
{
BookId = 567,
Title = "Year3000",
PublishedOn = new DateTime(3000, 1, 1),
YearPublished = 3000
};
context.AddRange(book1, book2);
await context.SaveChangesAsync();
//ATTEMPT
var list =
await context.Books.FromSqlRaw("SELECT * FROM c ORDER BY c.BookId").ToListAsync();
//VERIFY
list.Select(x => x.BookId).ShouldEqual(new[] { 123, 567 }); //WRONG IN EF CORE 5
}
public async Task TestAddCosmosBookHowToUpdateOk()
{
//SETUP
var options = this.GetCosmosDbToEmulatorOptions <CosmosDbContext>();
using (var context = new CosmosDbContext(options))
{
await context.Database.EnsureDeletedAsync();
await context.Database.EnsureCreatedAsync();
var cBook = new CosmosBook {
CosmosBookId = 1, Title = "Book1"
};
context.Add(cBook);
await context.SaveChangesAsync();
}
using (var context = new CosmosDbContext(options))
{
//ATTEMPT
var cBook = await context.Books.FindAsync(1); //You must read to get the "id"
cBook.Title = "Book2";
await context.SaveChangesAsync();
}
using (var context = new CosmosDbContext(options))
{
//VERIFY
context.Books.Find(1).Title.ShouldEqual("Book2");
}
}
public async Task TestNullableIntWhereOk()
{
//SETUP
var options = this.GetCosmosDbToEmulatorOptions <CosmosDbContext>();
using (var context = new CosmosDbContext(options))
{
await context.Database.EnsureDeletedAsync();
await context.Database.EnsureCreatedAsync();
var cBook1 = new CosmosBook {
CosmosBookId = 1, NullableInt = null
};
var cBook2 = new CosmosBook {
CosmosBookId = 2, NullableInt = 1
};
context.AddRange(cBook1, cBook2);
await context.SaveChangesAsync();
}
using (var context = new CosmosDbContext(options))
{
//ATTEMPT
var book = await context.Books.SingleOrDefaultAsync(x => x.NullableInt > 0);
//VERIFY
book.CosmosBookId.ShouldEqual(2);
}
}
public async Task TestAddCosmosBookAddSameKeyOk()
{
//SETUP
var options = this.GetCosmosDbToEmulatorOptions <CosmosDbContext>();
using (var context = new CosmosDbContext(options))
{
await context.Database.EnsureDeletedAsync();
await context.Database.EnsureCreatedAsync();
var cBook = new CosmosBook {
CosmosBookId = 1, Title = "Book1"
};
context.Add(cBook);
await context.SaveChangesAsync();
}
using (var context = new CosmosDbContext(options))
{
//ATTEMPT
var cBook = new CosmosBook {
CosmosBookId = 1, Title = "Book2"
};
context.Add(cBook);
context.Entry(cBook).State.ShouldEqual(EntityState.Added);
var ex = await Assert.ThrowsAsync <CosmosException>(async() => await context.SaveChangesAsync());
//VERIFY
ex.Message.ShouldContain("Resource with specified id or name already exists.");
}
using (var context = new CosmosDbContext(options))
{
context.Books.Find(1).Title.ShouldEqual("Book1");
}
}
public async Task TestNullableIntOk()
{
//SETUP
var options = this.GetCosmosDbToEmulatorOptions <CosmosDbContext>();
using (var context = new CosmosDbContext(options))
{
await context.Database.EnsureDeletedAsync();
await context.Database.EnsureCreatedAsync();
var cBook1 = new CosmosBook {
CosmosBookId = 1, NullableInt = null
};
var cBook2 = new CosmosBook {
CosmosBookId = 2, NullableInt = 1
};
context.AddRange(cBook1, cBook2);
await context.SaveChangesAsync();
}
using (var context = new CosmosDbContext(options))
{
//ATTEMPT
var cBook1 = await context.Books.FindAsync(1);
var cBook2 = await context.Books.FindAsync(2);
//VERIFY
cBook1.NullableInt.ShouldBeNull();
cBook2.NullableInt.ShouldEqual(1);
}
}
public async Task TestStringWithNullOrderByOk()
{
//SETUP
var options = this.GetCosmosDbToEmulatorOptions <CosmosDbContext>();
using (var context = new CosmosDbContext(options))
{
await context.Database.EnsureDeletedAsync();
await context.Database.EnsureCreatedAsync();
var cBook1 = new CosmosBook {
CosmosBookId = 1,
};
var cBook2 = new CosmosBook {
CosmosBookId = 2, Title = "Book2"
};
context.AddRange(cBook1, cBook2);
await context.SaveChangesAsync();
}
using (var context = new CosmosDbContext(options))
{
//ATTEMPT
var ex = await Assert.ThrowsAsync <NotSupportedException>(async() =>
await context.Books.OrderBy(x => x.Title).ToListAsync());
//VERIFY
ex.Message.ShouldStartWith("Cannot execute cross partition order-by queries on mix types. " +
"Consider using IS_STRING/IS_NUMBER to get around this exception.");
}
}
public async Task TestAccessCosmosEmulatorUniqueToMethod()
{
//SETUP
var options = this.CreateUniqueMethodCosmosDbEmulator
<CosmosDbContext>();
using var context = new CosmosDbContext(options);
await context.Database.EnsureDeletedAsync();
await context.Database.EnsureCreatedAsync();
//ATTEMPT
var book = new CosmosBook
{
BookId = 123,
Title = "Test",
Tags = new List <CosmosTag> {
new CosmosTag("Tag1"), new CosmosTag("Tag2")
}
};
context.Add(book);
await context.SaveChangesAsync();
//VERIFY
context.ChangeTracker.Clear();
var readBook = await context.Books.SingleAsync();
readBook.BookId.ShouldEqual(123);
readBook.Tags.Select(x => x.TagId).ShouldEqual(new[] { "Tag1", "Tag2" });
}
public static Container GetCosmosContainerFromDbContext(this CosmosDbContext context, string databaseName)
{
var cosmosClient = context.Database.GetCosmosClient();
var database = cosmosClient.GetDatabase(databaseName);
return(database.GetContainer(nameof(CosmosDbContext)));
}
public virtual async Task <T> GetById <T>(Guid id) where T : class, ISqlEntry
{
using (var context = new CosmosDbContext(_settings))
{
return(await AsyncEnumerable.FirstOrDefaultAsync(context.Set <T>(), w => w.Id == id));
}
}
public AzureCosmosData(AppSettings settings)
{
_settings = settings;
using (var context = new CosmosDbContext(settings))
{
context.Database.EnsureCreated();
}
}
public virtual async Task <bool> RemoveManyAsync <T>(IEnumerable <T> items, CancellationToken token = default) where T : class
{
using (var context = new CosmosDbContext(_settings))
{
context.AttachRange(items);
context.RemoveRange(items);
return(await context.SaveChangesAsync(token) == items.Count());
}
}
public async Task StartAsync(CancellationToken cancellationToken)
{
_serviceProvider.GetRequiredService <IConfiguration>();
using var scoped = _serviceProvider.CreateScope();
var configuration = scoped.ServiceProvider.GetRequiredService <CosmosConfiguration>();
var client = new CosmosClient(configuration.AccountEndpoint, configuration.AccountKey);
var context = new CosmosDbContext(client, configuration);
await context.StartProcessor <EventDocument>("event", Handle);
}
public CovidResponseWindow(CosmosDbContext context)
{
InitializeComponent();
_context = context;
CovidResponse = new CovidResponses()
{
Id = Guid.NewGuid().ToString()
};
DataChanged = false;
}
public override ICosmosDbContext CreateObjNoSqlContext(IAppDataProvider provider)
{
var objNoSQLHelper = new CosmosDbContext(provider);
objNoSQLHelper.AddEntity <BotUserOption>("BotUserOption");
objNoSQLHelper.AddEntity <BotGroupOption>("BotGroupOption");
objNoSQLHelper.AddEntity <BotGroupUser>("BotGroupUser");
return(objNoSQLHelper);
}
public virtual async Task <bool> RemoveAsync <T>(T item, CancellationToken token = default) where T : class, ISqlEntry
{
using (var context = new CosmosDbContext(_settings))
{
var dbSet = context.Set <T>();
var entity = dbSet.AsEnumerable().FirstOrDefault(w => w.Id == item.Id);
context.Remove(entity);
return(await context.SaveChangesAsync(token) == 1);
}
}
public DbSeeder(
MyHelperContext dbContext,
IWebHostEnvironment hostingEnvironment,
CosmosDbContext cosmosDbContext
)
{
_myHelperDbContext = dbContext;
_hostingEnvironment = hostingEnvironment;
_cosmosDbContext = cosmosDbContext;
}
public TacticWindow(CosmosDbContext context)
{
_context = context;
InitializeComponent();
DataChanged = false;
Tactic = new ARTactics()
{
Id = Guid.NewGuid().ToString()
};
}
public AusterityWindow(CosmosDbContext context)
{
InitializeComponent();
DataChanged = false;
_context = context;
Austerity = new Austeritys()
{
Id = Guid.NewGuid().ToString()
};
}
public TestBookToCosmosBookService()
{
var cosmosOptions = this.GetCosmosDbOptions <CosmosDbContext>();
_cosmosContext = new CosmosDbContext(cosmosOptions);
var sqlOptions = SqliteInMemory.CreateOptions <BookDbContext>();
_sqlContext = new BookDbContext(sqlOptions);
}
public virtual async Task <bool> UpdateAsync <T>(T item, CancellationToken token = default) where T : class
{
using (var context = new CosmosDbContext(_settings))
{
var db = context.Set <T>();
db.Update(item);
return(await context.SaveChangesAsync(token) == 1);
}
}
public TacticWindow(CosmosDbContext context, ARTactics tactic)
{
_context = context;
InitializeComponent();
DataChanged = false;
Tactic = tactic;
tbString.Text = Tactic.String;
tbSubstring.Text = Tactic.Substring;
tbLink.Text = Tactic.WikiLink;
}
public CovidResponseWindow(CosmosDbContext context, CovidResponses response)
{
InitializeComponent();
_context = context;
CovidResponse = response;
ctrlSources.SourceItems = response.Sources;
DataChanged = false;
tbString.Text = response.String;
tbDate.Text = response.Date;
}
public CosmosClient CreateCosmosClient()
{
CosmosDbContext cosmosStoreContext = this.GetCosmosDbContext();
return(new CosmosClient(cosmosStoreContext.CosmosStoreEndpointUri,
cosmosStoreContext.CosmosStoreAuthKey, new CosmosClientOptions()
{
MaxRetryAttemptsOnRateLimitedRequests = cosmosStoreContext.CosmosStoreMaxRetryAttempts,
RequestTimeout = cosmosStoreContext.OperationTimeOut
}));
}
public AusterityWindow(CosmosDbContext context, Austeritys austerity)
{
InitializeComponent();
DataChanged = false;
_context = context;
Austerity = austerity;
tbString.Text = Austerity.String;
cbType.Text = Austerity.Type;
ctrlSources.SourceItems = Austerity.Sources;
}
public virtual IEnumerable <T> Get <T>(Func <T, bool> filter = null) where T : class
{
using (var context = new CosmosDbContext(_settings))
{
var dbSet = context.Set <T>().AsEnumerable();
return(filter != null
? dbSet?.Where(filter).ToList()
: dbSet.ToList());
}
}
public async Task <JsonResult> GetFilterSearchContent(SortFilterPageOptions options,
[FromServices] CosmosDbContext context,
[FromServices] BookAppSettings settings)
{
var traceIdent = HttpContext.TraceIdentifier;
var dropdowns = await context.GetFilterDropDownValuesAsync(options.FilterBy, settings.CosmosDatabaseName);
return(Json(
new TraceIndentGeneric <IEnumerable <DropdownTuple> >(
traceIdent, dropdowns)));
}
public async Task <IActionResult> Index(SortFilterPageOptions options,
[FromServices] CosmosDbContext context,
[FromServices] BookAppSettings settings)
{
options.SetupRestOfDto(await context.CosmosDirectCountAsync(options, settings.CosmosDatabaseName));
var bookList = (await context.CosmosDirectQueryAsync(options, settings.CosmosDatabaseName)).ToList();
SetupTraceInfo();
return(View(new CosmosDirectBookListCombinedDto(options, bookList)));
}
public async Task StartAsync(CancellationToken aCancellationToken)
{
Logger.LogInformation($"{nameof(StartupHostedService)} has started.");
using IServiceScope scope = ServiceProvider.CreateScope();
//SqlDbContext sqlDbContext = scope.ServiceProvider.GetRequiredService<SqlDbContext>();
//await sqlDbContext.Database.MigrateAsync(aCancellationToken);
CosmosDbContext cosmosDbContext = scope.ServiceProvider.GetRequiredService <CosmosDbContext>();
await cosmosDbContext.Database.EnsureCreatedAsync(aCancellationToken);
}
public void TestAccessCosmosEmulator()
{
//SETUP
var options = this.GetCosmosDbOptions <CosmosDbContext>();
using var context = new CosmosDbContext(options);
//ATTEMPT
context.Database.EnsureCreated();
//VERIFY
}