public async Task Insert_With_AutoId_And_Reread()
{
using (var db = new LiteDatabaseAsync(new MemoryStream()))
{
var users = db.GetCollection <User>("TEST");
var u1 = new User {
Name = "John"
};
var u2 = new User {
Name = "Zarlos"
};
var u3 = new User {
Name = "Ana"
};
// insert ienumerable
await users.InsertAsync(new User[] { u1, u2, u3 });
// Reopen the collection
var users2 = db.GetCollection <User>("TEST");
var result = users2.FindAllAsync().GetAwaiter().GetResult();
Assert.Equal(3, result.Count());
var resultList = result.Select(u => u.Name).ToList();
Assert.Contains("John", resultList);
Assert.Contains("Zarlos", resultList);
Assert.Contains("Ana", resultList);
}
}
public async Task Delete_Many()
{
using (var db = new LiteDatabaseAsync(new MemoryStream()))
{
var users = db.GetCollection <User>("users");
var u1 = new User {
Id = 1, Name = "John"
};
var u2 = new User {
Id = 2, Name = "Zarlos"
};
var u3 = new User {
Id = 3, Name = "Ana"
};
await users.InsertAsync(new User[] { u1, u2, u3 });
var ids = new int[] { 1, 2, 3 };
await users.DeleteManyAsync(x => ids.Contains(x.Id));
(await users.CountAsync()).Should().Be(0);
}
}
public async Task Query_Min_Max()
{
using (var f = new TempFile())
using (var db = new LiteDatabaseAsync(f.Filename))
{
var c = db.GetCollection <EntityMinMax>("col");
await c.InsertAsync(new EntityMinMax { });
await c.InsertAsync(new EntityMinMax
{
ByteValue = 200,
IntValue = 443500,
LongValue = 443500,
UintValue = 443500
});
await c.EnsureIndexAsync(x => x.ByteValue);
await c.EnsureIndexAsync(x => x.IntValue);
await c.EnsureIndexAsync(x => x.LongValue);
await c.EnsureIndexAsync(x => x.UintValue);
(await c.MaxAsync(x => x.ByteValue)).Should().Be(200);
(await c.MaxAsync(x => x.IntValue)).Should().Be(443500);
(await c.MaxAsync(x => x.LongValue)).Should().Be(443500);
(await c.MaxAsync(x => x.UintValue)).Should().Be(443500);
}
}
public async Task Transaction_Avoid_Dirty_Read()
{
var data1 = DataGen.Person(1, 100).ToArray();
var data2 = DataGen.Person(101, 200).ToArray();
using (var db = new LiteDatabase(new MemoryStream()))
using (var asyncDb = new LiteDatabaseAsync(db, false))
{
var asyncPerson = asyncDb.GetCollection <Person>();
var person = db.GetCollection <Person>();
// init person collection with 100 document
await asyncPerson.InsertAsync(data1);
var taskASemaphore = new SemaphoreSlim(0, 1);
var taskBSemaphore = new SemaphoreSlim(0, 1);
// task A will open transaction and will insert +100 documents
// but will commit only 1s later - this plus +100 document must be visible only inside task A
var ta = Task.Run(async() =>
{
await asyncDb.BeginTransAsync();
await asyncPerson.InsertAsync(data2);
taskBSemaphore.Release();
await taskASemaphore.WaitAsync();
var count = await asyncPerson.CountAsync();
count.Should().Be(data1.Length + data2.Length);
await asyncDb.CommitAsync();
taskBSemaphore.Release();
});
// task B will not open transaction and will wait 250ms before and count collection -
// at this time, task A already insert +100 document but here I can't see (are not committed yet)
// after task A finish, I can see now all 200 documents
var tb = Task.Run(() =>
{
taskBSemaphore.Wait();
var count = person.Count();
// read 100 documents
count.Should().Be(data1.Length);
taskASemaphore.Release();
taskBSemaphore.Wait();
// read 200 documents
count = person.Count();
count.Should().Be(data1.Length + data2.Length);
});
await Task.WhenAll(ta, tb);
}
}
public UnAuthorizeCommand(AppConfig appConfig, LiteDatabaseAsync liteDb, IEasyCachingProvider easyCachingProvider, AuthService authService)
{
_appConfig = appConfig;
_easyCachingProvider = easyCachingProvider;
_authService = authService;
_liteDb = liteDb;
}
public void Database_Pragmas_Get_Set()
{
using (var db = new LiteDatabaseAsync(":memory:"))
{
db.Timeout.TotalSeconds.Should().Be(60.0);
db.UtcDate.Should().Be(false);
db.Collation.SortOptions.Should().Be(CompareOptions.IgnoreCase);
db.LimitSize.Should().Be(long.MaxValue);
db.UserVersion.Should().Be(0);
db.CheckpointSize.Should().Be(1000);
// changing values
db.Timeout = TimeSpan.FromSeconds(30);
db.UtcDate = true;
db.LimitSize = 1024 * 1024;
db.UserVersion = 99;
db.CheckpointSize = 0;
// testing again
db.Timeout.TotalSeconds.Should().Be(30);
db.UtcDate.Should().Be(true);
db.LimitSize.Should().Be(1024 * 1024);
db.UserVersion.Should().Be(99);
db.CheckpointSize.Should().Be(0);
}
}
public async Task FindAll()
{
using (var f = new TempFile())
{
using (var db = new LiteDatabaseAsync(f.Filename))
{
var col = db.GetCollection <Person>("Person");
await col.InsertAsync(new Person { Fullname = "John" });
await col.InsertAsync(new Person { Fullname = "Doe" });
await col.InsertAsync(new Person { Fullname = "Joana" });
await col.InsertAsync(new Person { Fullname = "Marcus" });
}
// close datafile
using (var db = new LiteDatabaseAsync(f.Filename))
{
var p = await db.GetCollection <Person>("Person").FindAsync(Query.All("Fullname", Query.Ascending));
p.Count().Should().Be(4);
}
}
}
public async Task Rebuild_Change_Culture_Error()
{
using (var file = new TempFile())
using (var db = new LiteDatabaseAsync(file.Filename))
{
// remove string comparer ignore case
await db.RebuildAsync(new RebuildOptions { Collation = new Collation("en-US/None") });
// insert 2 documents with different ID in case sensitive
await db.GetCollection("col1").InsertAsync(new BsonDocument[]
{
new BsonDocument {
["_id"] = "ana"
},
new BsonDocument {
["_id"] = "ANA"
}
});
// try migrate to ignorecase
this.Invoking(async x =>
{
await db.RebuildAsync(new RebuildOptions {
Collation = new Collation("en-US/IgnoreCase")
});
}).Should().Throw <LiteAsyncException>();
// test if current pragma still with collation none
(await db.PragmaAsync(Pragmas.COLLATION)).AsString.Should().Be("en-US/None");
}
}
public IndexSortAndFilterTest()
{
_tempFile = new TempFile();
_database = new LiteDatabaseAsync(_tempFile.Filename);
_collection = _database.GetCollection <Item>("items");
var task1 = _collection.UpsertAsync(new Item()
{
Id = "C", Value = "Value 1"
});
var task2 = _collection.UpsertAsync(new Item()
{
Id = "A", Value = "Value 2"
});
var task3 = _collection.UpsertAsync(new Item()
{
Id = "B", Value = "Value 1"
});
Task.WaitAll(task1, task2, task3);
var task4 = _collection.EnsureIndexAsync("idx_value", x => x.Value);
task4.Wait();
}
public DateTime_Tests()
{
_databasePath = Path.Combine(Path.GetTempPath(), $"litedbn-async-testing-{Path.GetRandomFileName()}.db");
_db = new LiteDatabaseAsync(_databasePath)
{
UtcDate = true
};
}
public void Only_One_LiteDbAsync_Per_LiteDb()
{
using (var wrappedDb = new LiteDatabase(new MemoryStream()))
using (var db1 = new LiteDatabaseAsync(wrappedDb)) {
var exception = Assert.Throws <LiteAsyncException>(() => { var db1 = new LiteDatabaseAsync(wrappedDb); });
Assert.Equal("You can only have one LiteDatabaseAsync per LiteDatabase.", exception.Message);
}
}
public async Task Transaction_Read_Version()
{
var data1 = DataGen.Person(1, 100).ToArray();
var data2 = DataGen.Person(101, 200).ToArray();
using (var db = new LiteDatabase(new MemoryStream()))
using (var asyncDb = new LiteDatabaseAsync(db, false))
{
var asyncPerson = asyncDb.GetCollection <Person>();
var person = db.GetCollection <Person>();
// init person collection with 100 document
await asyncPerson.InsertAsync(data1);
var taskASemaphore = new SemaphoreSlim(0, 1);
var taskBSemaphore = new SemaphoreSlim(0, 1);
// task A will insert more 100 documents but will commit only 1s later
var ta = Task.Run(async() =>
{
await asyncDb.BeginTransAsync();
await asyncPerson.InsertAsync(data2);
taskBSemaphore.Release();
taskASemaphore.Wait();
await asyncDb.CommitAsync();
taskBSemaphore.Release();
});
// task B will open transaction too and will count 100 original documents only
// but now, will wait task A finish - but is in transaction and must see only initial version
var tb = Task.Run(() =>
{
db.BeginTrans();
taskBSemaphore.Wait();
var count = person.Count();
// read 100 documents
count.Should().Be(data1.Length);
taskASemaphore.Release();
taskBSemaphore.Wait();
// keep reading 100 documents because i'm still in same transaction
count = person.Count();
count.Should().Be(data1.Length);
});
await Task.WhenAll(ta, tb);
}
}
public async Task Rebuild_Large_Files()
{
// do some tests
async Task DoTestAsync(ILiteDatabaseAsync db, ILiteCollectionAsync <Zip> col)
{
Assert.Equal(1, await col.CountAsync());
Assert.Equal(99, db.UserVersion);
};
using (var file = new TempFile())
{
using (var db = new LiteDatabaseAsync(file.Filename))
{
var col = db.GetCollection <Zip>();
db.UserVersion = 99;
await col.EnsureIndexAsync("city", false);
var inserted = await col.InsertAsync(DataGen.Zip()); // 29.353 docs
var deleted = await col.DeleteManyAsync(x => x.Id != "01001"); // delete 29.352 docs
Assert.Equal(29353, inserted);
Assert.Equal(29352, deleted);
Assert.Equal(1, await col.CountAsync());
// must checkpoint
await db.CheckpointAsync();
// file still large than 5mb (even with only 1 document)
Assert.True(file.Size > 5 * 1024 * 1024);
// reduce datafile
var reduced = await db.RebuildAsync();
// now file are small than 50kb
Assert.True(file.Size < 50 * 1024);
await DoTestAsync(db, col);
}
// re-open and rebuild again
using (var db = new LiteDatabaseAsync(file.Filename))
{
var col = db.GetCollection <Zip>();
await DoTestAsync(db, col);
await db.RebuildAsync();
await DoTestAsync(db, col);
}
}
}
public async Task Transaction_Write_Lock_Timeout()
{
var data1 = DataGen.Person(1, 100).ToArray();
var data2 = DataGen.Person(101, 200).ToArray();
using (var db = new LiteDatabase("filename=:memory:"))
using (var asyncDb = new LiteDatabaseAsync(db, false))
{
// small timeout
await asyncDb.PragmaAsync(Pragmas.TIMEOUT, 1);
var asyncPerson = asyncDb.GetCollection <Person>();
var person = db.GetCollection <Person>();
// init person collection with 100 document
await asyncPerson.InsertAsync(data1);
var taskASemaphore = new SemaphoreSlim(0, 1);
var taskBSemaphore = new SemaphoreSlim(0, 1);
// task A will open transaction and will insert +100 documents
// but will commit only 2s later
var ta = Task.Run(async() =>
{
await asyncDb.BeginTransAsync();
await asyncPerson.InsertAsync(data2);
taskBSemaphore.Release();
taskASemaphore.Wait();
var count = await asyncPerson.CountAsync();
count.Should().Be(data1.Length + data2.Length);
await asyncDb.CommitAsync();
});
// task B will try delete all documents but will be locked during 1 second
var tb = Task.Run(() =>
{
taskBSemaphore.Wait();
db.BeginTrans();
person
.Invoking(personCol => personCol.DeleteMany("1 = 1"))
.Should()
.Throw <LiteException>()
.Where(ex => ex.ErrorCode == LiteException.LOCK_TIMEOUT);
taskASemaphore.Release();
});
await Task.WhenAll(ta, tb);
}
}
public Person_Tests()
{
this.local = DataGen.Person().ToArray();
_db = new LiteDatabaseAsync(":memory:");
_collection = _db.GetCollection <Person>("person");
var task = _collection.InsertAsync(this.local);
task.Wait();
}
public ConnectionStringObjectTest()
{
_connectionString = new ConnectionString()
{
Filename = Path.Combine(Path.GetTempPath(), "litedbn-async-testing-" + Path.GetRandomFileName() + ".db"),
Connection = ConnectionType.Shared,
Password = "******"
};
_db = new LiteDatabaseAsync(_connectionString);
}
public AuthorizeCommand(
LiteDatabaseAsync liteDb,
IEasyCachingProvider easyCachingProvider,
AuthService authService
)
{
_easyCachingProvider = easyCachingProvider;
_authService = authService;
_liteDb = liteDb;
}
public void Disposes_Wrapped_LiteDb()
{
var mockWrappedDb = new Mock <ILiteDatabase>();
using (var db = new LiteDatabaseAsync(mockWrappedDb.Object))
{
// Do nothing
}
mockWrappedDb.Verify(x => x.Dispose(), Times.Once);
}
public static async Task Main(string[] args)
{
var cts = new CancellationTokenSource();
if (DataDir != null)
{
Directory.SetCurrentDirectory(DataDir);
}
var audioTmpDir = Path.Join(_audioDir, "tmp");
if (Directory.Exists(audioTmpDir))
{
Directory.Delete(audioTmpDir, recursive: true);
}
Directory.CreateDirectory(audioTmpDir);
var secrets = JsonConvert.DeserializeObject <Secrets>(File.ReadAllText("secrets.json"));
if (secrets == null)
{
throw new Exception("secrets object was null");
}
secrets.DiscordApiKey = DiscordApiKeyOverride ?? secrets.DiscordApiKey;
secrets.WitAiApiKey = WitAiApiKeyOverride ?? secrets.WitAiApiKey;
using var db = new LiteDatabaseAsync($"Filename=metadata.db;Connection=shared");
using var metadataManager = new MetadataManager(db);
using var playHistoryManager = new PlayHistoryManager(db);
_metadataManager = metadataManager;
#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
Task.Run(() => _autoPopulate(cts.Token));
Task.Run(() => _autoPrefetch(cts.Token));
#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
if (secrets.WitAiApiKey == null)
{
throw new ArgumentNullException("WitAiApiKey must be provided.");
}
var aiClient = new WitAiClient(secrets.WitAiApiKey);
if (secrets.DiscordApiKey == null)
{
throw new ArgumentNullException("DiscordApiKey must be provided.");
}
var client = new DiscordClient(secrets.DiscordApiKey, aiClient, _metadataManager, playHistoryManager);
await client.StartAsync();
Console.CancelKeyPress += (o, e) => cts.Cancel();
AppDomain.CurrentDomain.ProcessExit += (s, ev) => cts.Cancel();
await cts.Token.WhenCancelled();
}
public async Task MultiKey_Mapper()
{
using (var db = new LiteDatabaseAsync(":memory:"))
{
var col = db.GetCollection <MultiKeyDoc>("col");
await col.InsertAsync(new MultiKeyDoc
{
Id = 1,
Keys = new int[] { 1, 2, 3 },
Customers = new List <Customer>()
{
new Customer {
Name = "John"
},
new Customer {
Name = "Ana"
},
new Customer {
Name = "Doe"
},
new Customer {
Name = "Dante"
}
}
});
await col.InsertAsync(new MultiKeyDoc
{
Id = 2,
Keys = new int[] { 2 },
Customers = new List <Customer>()
{
new Customer {
Name = "Ana"
}
}
});
await col.EnsureIndexAsync(x => x.Keys);
await col.EnsureIndexAsync(x => x.Customers.Select(z => z.Name));
// Query.EQ("Keys", 2)
(await col.CountAsync(Query.Any().EQ("Keys", 2))).Should().Be(2);
(await col.CountAsync(x => x.Keys.Contains(2))).Should().Be(2);
(await col.CountAsync(Query.StartsWith("Customers[*].Name ANY", "Ana"))).Should().Be(2);
(await col.CountAsync(x => x.Customers.Select(z => z.Name).Any(z => z.StartsWith("Ana")))).Should().Be(2);
(await col.CountAsync(Query.StartsWith("Customers[*].Name ANY", "D"))).Should().Be(1);
(await col.CountAsync(x => x.Customers.Select(z => z.Name).Any(z => z.StartsWith("D")))).Should().Be(1);
}
}
public void Dont_Dispose_Wrapped_LiteDb()
// Don't dispose of the wrapped LiteDB instance if the correct parameter is passed in
{
var mockWrappedDb = new Mock <ILiteDatabase>();
using (var db = new LiteDatabaseAsync(mockWrappedDb.Object, false))
{
// Do nothing
}
mockWrappedDb.Verify(x => x.Dispose(), Times.Never);
}
public async Task AutoId_Zero_Int()
{
using (var db = new LiteDatabaseAsync(":memory:"))
{
var test = db.GetCollection("Test", BsonAutoId.Int32);
var doc = new BsonDocument()
{
["_id"] = 0, ["p1"] = 1
};
await test.InsertAsync(doc); // -> NullReferenceException
}
}
public void TestCanOpenThenCloseThenReopenDatabase()
{
string databasePath = Path.Combine(Path.GetTempPath(), "litedbn-async-testing-" + Path.GetRandomFileName() + ".db");
using (var db1 = new LiteDatabaseAsync(databasePath))
{
}
using (var db2 = new LiteDatabaseAsync(databasePath))
{
}
File.Delete(databasePath);
}
public void TestOpeningDatabaseASecondTimeCausesAnException()
{
string databasePath = Path.Combine(Path.GetTempPath(), "litedbn-async-testing-" + Path.GetRandomFileName() + ".db");
using (var db1 = new LiteDatabaseAsync(databasePath))
{
Assert.Throws <IOException>(() => {
var db2 = new LiteDatabaseAsync(databasePath);
});
}
File.Delete(databasePath);
}
public async Task UpsertManyAsync()
{
using (var db = new LiteDatabaseAsync(new MemoryStream()))
{
var manyUsers = Enumerable.Range(1, 100).Select(i => new User()
{
Id = i, Name = $"Example {i}"
}).ToList();
var users = db.GetCollection <User>("users");
Assert.Equal(100, await users.UpsertAsync(manyUsers));
Assert.Equal(100, await users.CountAsync());
// Read back from the database
var users2 = await db.GetCollection <User>("users").Query().ToListAsync();
// Are the id values the expected ones
Assert.True(Enumerable.Range(1, 100).ToHashSet().SetEquals(users2.Select(u => u.Id)));
// Are the names correct?
foreach (var user in users2)
{
Assert.Equal($"Example {user.Id}", user.Name);
}
// Update with new names
manyUsers = Enumerable.Range(1, 100).Select(i => new User()
{
Id = i, Name = $"User {i}"
}).ToList();
await users.UpsertAsync(manyUsers);
Assert.Equal(100, await users.CountAsync());
// Read back from the database
users2 = await db.GetCollection <User>("users").Query().ToListAsync();
// Are the id values the expected ones
Assert.True(Enumerable.Range(1, 100).ToHashSet().SetEquals(users2.Select(u => u.Id)));
// Are the names correct?
foreach (var user in users2)
{
Assert.Equal($"User {user.Id}", user.Name);
}
}
}
public void Can_Wrap_LiteDb_Twice()
{
var mockWrappedDb = new Mock <ILiteDatabase>();
using (var db = new LiteDatabaseAsync(mockWrappedDb.Object, false))
{
// Do nothing
}
using (var db2 = new LiteDatabaseAsync(mockWrappedDb.Object, false))
{
// Do nothing
}
mockWrappedDb.Verify(x => x.Dispose(), Times.Never);
}
public async Task TestOpeningDatabaseASecondTimeCausesAnException()
{
string databasePath = Path.Combine(Path.GetTempPath(), "litedbn-async-testing-" + Path.GetRandomFileName() + ".db");
using (var db1 = new LiteDatabaseAsync(databasePath))
{
await db1.GetCollection <SimplePerson>().InsertAsync(new SimplePerson());
await Assert.ThrowsAsync <IOException>(async() => {
using var db2 = new LiteDatabaseAsync(databasePath);
await db2.GetCollection <SimplePerson>().InsertAsync(new SimplePerson());
});
}
File.Delete(databasePath);
}
public TestCommand(
LiteDatabaseAsync liteDatabaseAsync,
IEasyCachingProvider easyCachingProvider,
TelegramService telegramService,
DeepAiService deepAiService,
SettingsService settingsService,
BlockListService blockListService
)
{
_telegramService = telegramService;
_liteDatabaseAsync = liteDatabaseAsync;
_deepAiService = deepAiService;
_easyCachingProvider = easyCachingProvider;
_settingsService = settingsService;
_blockListService = blockListService;
}
public async Task TestCanDisposeDatabaseTimely()
{
string databasePath = Path.Combine(Path.GetTempPath(),
"litedbn-async-testing-" + Path.GetRandomFileName() + ".db");
var db = new LiteDatabaseAsync(databasePath);
// Ensure to do some stuff to open the database
var collection = db.GetCollection <SimplePerson>();
await collection.InsertAsync(new SimplePerson()).ConfigureAwait(false);
var stopwatch = Stopwatch.StartNew();
db.Dispose();
stopwatch.Stop();
Assert.InRange(stopwatch.Elapsed.TotalSeconds, 0, 4.99);
}
public async Task DropCollection()
{
using (var file = new TempFile())
using (var db = new LiteDatabaseAsync(file.Filename))
{
(await db.GetCollectionNamesAsync()).Should().NotContain("col");
var col = db.GetCollection("col");
await col.InsertAsync(new BsonDocument { ["a"] = 1 });
(await db.GetCollectionNamesAsync()).Should().Contain("col");
await db.DropCollectionAsync("col");
(await db.GetCollectionNamesAsync()).Should().NotContain("col");
}
}
