PHXH
/
csharp-sdk-upm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

* ACLTest.cs: chore: 完善 query 实现和测试 

* LCObject.cs:
* QueryTest.cs:
* LCHttpClient.cs:
* LeanCloudJsonConverter.cs:
* LCCompositionalCondition.cs:
oneRain 2020-02-26 13:01:22 +08:00
parent 788f0bf1c3
commit 00941b3082
6 changed files with 292 additions and 85 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
Storage/Storage.Test/ACLTest.cs Normal file
View File

@ -0,0 +1,54 @@
using NUnit.Framework;
using System.Threading.Tasks;
using LeanCloud.Storage;
namespace LeanCloud.Test {
public class ACLTest {
[SetUp]
public void SetUp() {
Logger.LogDelegate += Utils.Print;
LeanCloud.Initialize("ikGGdRE2YcVOemAaRbgp1xGJ-gzGzoHsz", "NUKmuRbdAhg1vrb2wexYo1jo", "https://ikggdre2.lc-cn-n1-shared.com");
}
[TearDown]
public void TearDown() {
Logger.LogDelegate -= Utils.Print;
}
[Test]
public async Task PrivateReadAndWrite() {
LCObject account = new LCObject("Account");
LCACL acl = new LCACL();
acl.PublicReadAccess = false;
acl.PublicWriteAccess = false;
account.ACL = acl;
account["balance"] = 1024;
await account.Save();
Assert.IsFalse(acl.PublicReadAccess);
Assert.IsFalse(acl.PublicWriteAccess);
}
[Test]
public async Task UserReadAndWrite() {
//await LCUser.Login('hello', 'world');
//LCObject account = new LCObject('Account');
//LCUser currentUser = await LCUser.getCurrent();
//LCACL acl = LCACL.createWithOwner(currentUser);
//account.acl = acl;
//account['balance'] = 512;
//await account.save();
//assert(acl.getUserReadAccess(currentUser) == true);
//assert(acl.getUserWriteAccess(currentUser) == true);
//LCQuery<LCObject> query = new LCQuery('Account');
//LCObject result = await query.get(account.objectId);
//print(result.objectId);
//assert(result.objectId != null);
//LCUser.logout();
//result = await query.get(account.objectId);
//assert(result == null);
}
}
}

310
Storage/Storage.Test/QueryTest.cs
View File

@ -1,121 +1,267 @@
using NUnit.Framework;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Linq;
using Newtonsoft.Json;
using LeanCloud.Storage;
namespace LeanCloud.Test {
public class QueryTest {
[SetUp]
public void SetUp() {
Utils.InitNorthChina();
Logger.LogDelegate += Utils.Print;
LeanCloud.Initialize("ikGGdRE2YcVOemAaRbgp1xGJ-gzGzoHsz", "NUKmuRbdAhg1vrb2wexYo1jo", "https://ikggdre2.lc-cn-n1-shared.com");
}
[TearDown]
public void TearDown() {
Logger.LogDelegate -= Utils.Print;
}
[Test]
public async Task BasicQuery() {
var query = new AVQuery<AVObject>("Account");
query.WhereGreaterThanOrEqualTo("balance", 100);
query.WhereLessThanOrEqualTo("balance", 100);
var results = await query.FindAsync();
foreach (var result in results) {
TestContext.Out.WriteLine(result.ObjectId);
public async Task BaseQuery() {
LCQuery<LCObject> query = new LCQuery<LCObject>("Hello");
query.Limit(2);
List<LCObject> list = await query.Find();
TestContext.WriteLine(list.Count);
Assert.AreEqual(list.Count, 2);
foreach (LCObject item in list) {
Assert.NotNull(item.ClassName);
Assert.NotNull(item.ObjectId);
Assert.NotNull(item.CreatedAt);
Assert.NotNull(item.UpdatedAt);
TestContext.WriteLine(item.ClassName);
TestContext.WriteLine(item.ObjectId);
TestContext.WriteLine(item.CreatedAt);
TestContext.WriteLine(item.UpdatedAt);
TestContext.WriteLine(item["intValue"]);
TestContext.WriteLine(item["boolValue"]);
TestContext.WriteLine(item["stringValue"]);
}
}
[Test]
public async Task Count() {
var query = new AVQuery<AVObject>("Foo");
query.WhereEqualTo("content", "hello, world");
var count = await query.CountAsync();
Assert.Greater(count, 8);
LCQuery<LCObject> query = new LCQuery<LCObject>("Account");
query.WhereGreaterThan("balance", 200);
int count = await query.Count();
TestContext.WriteLine(count);
Assert.Greater(count, 0);
}
[Test]
public async Task Or() {
AVQuery<AVObject> q1 = new AVQuery<AVObject>("Foo");
q1.WhereEqualTo("content", "hello");
AVQuery<AVObject> q2 = new AVQuery<AVObject>("Foo");
q2.WhereEqualTo("content", "world");
AVQuery<AVObject> query = AVQuery<AVObject>.Or(new List<AVQuery<AVObject>> { q1, q2 });
IEnumerable<AVObject> results = await query.FindAsync();
foreach (AVObject result in results) {
TestContext.Out.WriteLine(result.ObjectId);
}
public async Task OrderBy() {
LCQuery<LCObject> query = new LCQuery<LCObject>("Account");
query.OrderBy("balance");
List<LCObject> results = await query.Find();
Assert.LessOrEqual((int)results[0]["balance"], (int)results[1]["balance"]);
query = new LCQuery<LCObject>("Account");
query.OrderByDescending("balance");
results = await query.Find();
Assert.GreaterOrEqual((int)results[0]["balance"], (int)results[1]["balance"]);
}
[Test]
public async Task Include() {
LCQuery<LCObject> query = new LCQuery<LCObject>("Hello");
query.Include("objectValue");
LCObject hello = await query.Get("5e0d55aedd3c13006a53cd87");
LCObject world = hello["objectValue"] as LCObject;
TestContext.WriteLine(world["content"]);
Assert.AreEqual(world["content"], "7788");
}
[Test]
public async Task Get() {
LCQuery<LCObject> query = new LCQuery<LCObject>("Account");
LCObject account = await query.Get("5e0d9f7fd4b56c008e5d048a");
Assert.AreEqual(account["balance"], 400);
}
[Test]
public async Task First() {
LCQuery<LCObject> query = new LCQuery<LCObject>("Account");
LCObject account = await query.First();
Assert.NotNull(account.ObjectId);
}
[Test]
public async Task GreaterQuery() {
LCQuery<LCObject> query = new LCQuery<LCObject>("Account");
query.WhereGreaterThan("balance", 200);
List<LCObject> list = await query.Find();
TestContext.WriteLine(list.Count);
Assert.Greater(list.Count, 0);
}
[Test]
public async Task And() {
AVQuery<AVObject> q1 = new AVQuery<AVObject>("Foo");
q1.WhereContains("content", "hello");
AVQuery<AVObject> q2 = new AVQuery<AVObject>("Foo");
q2.WhereContains("content", "world");
AVQuery<AVObject> query = AVQuery<AVObject>.And(new List<AVQuery<AVObject>> { q1, q2 });
IEnumerable<AVObject> results = await query.FindAsync();
TestContext.Out.WriteLine($"Count: {results.Count()}");
foreach (AVObject result in results) {
TestContext.Out.WriteLine(result.ObjectId);
}
LCQuery<LCObject> q1 = new LCQuery<LCObject>("Account");
q1.WhereGreaterThan("balance", 100);
LCQuery<LCObject> q2 = new LCQuery<LCObject>("Account");
q2.WhereLessThan("balance", 500);
LCQuery<LCObject> query = LCQuery<LCObject>.And(new List<LCQuery<LCObject>> { q1, q2 });
List<LCObject> results = await query.Find();
TestContext.WriteLine(results.Count);
results.ForEach(item => {
int balance = (int)item["balance"];
Assert.IsTrue(balance >= 100 || balance <= 500);
});
}
[Test]
public async Task OrPro() {
AVQuery<AVObject> q1 = AVQuery<AVObject>.Or(new List<AVQuery<AVObject>> {
new AVQuery<AVObject>("Account").WhereEqualTo("balance", 100)
public async Task Or() {
LCQuery<LCObject> q1 = new LCQuery<LCObject>("Account");
q1.WhereLessThanOrEqualTo("balance", 100);
LCQuery<LCObject> q2 = new LCQuery<LCObject>("Account");
q2.WhereGreaterThanOrEqualTo("balance", 500);
LCQuery<LCObject> query = LCQuery<LCObject>.Or(new List<LCQuery<LCObject>> { q1, q2 });
List<LCObject> results = await query.Find();
TestContext.WriteLine(results.Count);
results.ForEach(item => {
int balance = (int)item["balance"];
Assert.IsTrue(balance <= 100 || balance >= 500);
});
AVQuery<AVObject> q2 = AVQuery<AVObject>.Or(new List<AVQuery<AVObject>> {
new AVQuery<AVObject>("Account").WhereEqualTo("balance", 200)
});
AVQuery<AVObject> query = AVQuery<AVObject>.Or(new List<AVQuery<AVObject>> {
q1, q2
});
query.WhereEqualTo("balance", 100);
IEnumerable<AVObject> results = await query.FindAsync();
foreach (AVObject result in results) {
TestContext.Out.WriteLine(result.ObjectId);
}
}
[Test]
public async Task Related() {
AVObject todo = AVObject.CreateWithoutData("Todo", "5d71f798d5de2b006c0136bc");
AVQuery<AVObject> query = new AVQuery<AVObject>("Tag");
query.WhereRelatedTo(todo, "tags");
IEnumerable<AVObject> results = await query.FindAsync();
foreach (AVObject tag in results) {
TestContext.Out.WriteLine(tag.ObjectId);
}
public async Task WhereObjectEquals() {
LCQuery<LCObject> worldQuery = new LCQuery<LCObject>("World");
LCObject world = await worldQuery.Get("5e0d55ae21460d006a1ec931");
LCQuery<LCObject> helloQuery = new LCQuery<LCObject>("Hello");
helloQuery.WhereEqualTo("objectValue", world);
LCObject hello = await helloQuery.First();
TestContext.WriteLine(hello.ObjectId);
Assert.AreEqual(hello.ObjectId, "5e0d55aedd3c13006a53cd87");
}
[Test]
public void Where() {
AVQuery<AVObject> q1 = new AVQuery<AVObject>();
q1.WhereEqualTo("aa", "bb");
AVQuery<AVObject> q2 = new AVQuery<AVObject>();
q2.WhereEqualTo("cc", "dd");
q2.WhereEqualTo("ee", "ff");
List<AVQuery<AVObject>> queryList = new List<AVQuery<AVObject>> {
q1, q2
};
AVQuery<AVObject> query = AVQuery<AVObject>.Or(queryList);
IDictionary<string, object> obj = query.BuildWhere();
TestContext.Out.WriteLine(JsonConvert.SerializeObject(obj));
public async Task Exist() {
LCQuery<LCObject> query = new LCQuery<LCObject>("Account");
query.WhereExists("user");
List<LCObject> results = await query.Find();
results.ForEach(item => {
Assert.NotNull(item["user"]);
});
AVQuery<AVObject> q3 = new AVQuery<AVObject>();
q3.WhereEqualTo("xx", "yy");
IDictionary<string, object> q3Obj = q3.BuildWhere();
TestContext.Out.WriteLine(JsonConvert.SerializeObject(q3Obj));
query = new LCQuery<LCObject>("Account");
query.WhereDoesNotExist("user");
results = await query.Find();
results.ForEach(item => {
Assert.IsNull(item["user"]);
});
}
AVQuery<AVObject> q4 = new AVQuery<AVObject>();
q4.WhereEqualTo("aaa", "bbb");
q4.WhereEqualTo("ccc", "ddd");
IDictionary<string, object> q4Obj = q4.BuildWhere();
TestContext.Out.WriteLine(JsonConvert.SerializeObject(q4Obj));
[Test]
public async Task Select() {
LCQuery<LCObject> query = new LCQuery<LCObject>("Account");
query.Select("balance");
List<LCObject> results = await query.Find();
results.ForEach(item => {
Assert.NotNull(item["balance"]);
Assert.IsNull(item["user"]);
});
}
AVQuery<AVObject> q5 = new AVQuery<AVObject>();
q5.WhereEqualTo("aaa", "bbb");
q5.WhereEqualTo("aaa", "ccc");
IDictionary<string, object> q5Obj = q5.BuildWhere();
TestContext.Out.WriteLine(JsonConvert.SerializeObject(q5Obj));
[Test]
public async Task String() {
// Start
LCQuery<LCObject> query = new LCQuery<LCObject>("Hello");
query.WhereStartsWith("stringValue", "hello");
List<LCObject> results = await query.Find();
results.ForEach(item => {
string str = item["stringValue"] as string;
Assert.IsTrue(str.StartsWith("hello"));
});
// End
query = new LCQuery<LCObject>("Hello");
query.WhereEndsWith("stringValue", "world");
results = await query.Find();
results.ForEach(item => {
string str = item["stringValue"] as string;
Assert.IsTrue(str.EndsWith("world"));
});
// Contains
query = new LCQuery<LCObject>("Hello");
query.WhereContains("stringValue", ",");
results = await query.Find();
results.ForEach(item => {
string str = item["stringValue"] as string;
Assert.IsTrue(str.Contains(','));
});
}
[Test]
public async Task Array() {
// equal
LCQuery<LCObject> query = new LCQuery<LCObject>("Book");
query.WhereEqualTo("pages", 3);
List<LCObject>results = await query.Find();
results.ForEach(item => {
List<object> pages = item["pages"] as List<object>;
Assert.IsTrue(pages.Contains(3));
});
// contain all
List<int> containAlls = new List<int> { 1, 2, 3, 4, 5, 6, 7 };
query = new LCQuery<LCObject>("Book");
query.WhereContainsAll("pages", containAlls);
results = await query.Find();
results.ForEach(item => {
List<object> pages = item["pages"] as List<object>;
pages.ForEach(i => {
Assert.IsTrue(pages.Contains(i));
});
});
// contain in
List<int> containIns = new List<int> { 4, 5, 6 };
query = new LCQuery<LCObject>("Book");
query.WhereContainedIn("pages", containIns);
results = await query.Find();
results.ForEach(item => {
List<object> pages = item["pages"] as List<object>;
bool f = false;
containIns.ForEach(i => {
f |= pages.Contains(i);
});
Assert.IsTrue(f);
});
// size
query = new LCQuery<LCObject>("Book");
query.WhereSizeEqualTo("pages", 7);
results = await query.Find();
results.ForEach(item => {
List<object> pages = item["pages"] as List<object>;
Assert.AreEqual(pages.Count, 7);
});
}
[Test]
public async Task Geo() {
LCObject obj = new LCObject("Todo");
LCGeoPoint location = new LCGeoPoint(39.9, 116.4);
obj["location"] = location;
await obj.Save();
// near
LCQuery<LCObject> query = new LCQuery<LCObject>("Todo");
LCGeoPoint point = new LCGeoPoint(39.91, 116.41);
query.WhereNear("location", point);
List<LCObject> results = await query.Find();
Assert.Greater(results.Count, 0);
// in box
query = new LCQuery<LCObject>("Todo");
LCGeoPoint southwest = new LCGeoPoint(30, 115);
LCGeoPoint northeast = new LCGeoPoint(40, 118);
query.WhereWithinGeoBox("location", southwest, northeast);
results = await query.Find();
Assert.Greater(results.Count, 0);
}
}
}

4
Storage/Storage/Internal/Http/LCHttpClient.cs
View File

@ -118,7 +118,7 @@ namespace LeanCloud.Storage.Internal.Http {
try {
// 尝试获取 LeanCloud 返回错误信息
Dictionary<string, object> error = JsonConvert.DeserializeObject<Dictionary<string, object>>(resultString, new LeanCloudJsonConverter());
code = (int)(long)error["code"];
code = (int)error["code"];
message = error["error"].ToString();
} catch (Exception e) {
Logger.Error(e.Message);
@ -162,7 +162,7 @@ namespace LeanCloud.Storage.Internal.Http {
try {
// 尝试获取 LeanCloud 返回错误信息
Dictionary<string, object> error = JsonConvert.DeserializeObject<Dictionary<string, object>>(resultString, new LeanCloudJsonConverter());
code = (int)(long)error["code"];
code = (int)error["code"];
message = error["error"].ToString();
} catch (Exception e) {
Logger.Error(e.Message);

5
Storage/Storage/Internal_/Utilities/LeanCloudJsonConverter.cs → Storage/Storage/Internal/Http/LeanCloudJsonConverter.cs
View File

@ -23,6 +23,11 @@ namespace LeanCloud.Storage.Internal {
serializer.Populate(reader, arr);
return arr;
}
if (reader.TokenType == JsonToken.Integer) {
if ((long)reader.Value < int.MaxValue) {
return Convert.ToInt32(reader.Value);
}
}
return serializer.Deserialize(reader);
}

2
Storage/Storage/Internal/Query/LCCompositionalCondition.cs
View File

@ -72,7 +72,7 @@ namespace LeanCloud.Storage.Internal.Query {
}
internal void WhereLessThan(string key, object value) {
AddOperation(key, "$lt$lt", value);
AddOperation(key, "$lt", value);
}
internal void WhereLessThanOrEqualTo(string key, object value) {

2
Storage/Storage/LCObject.cs
View File

@ -57,6 +57,8 @@ namespace LeanCloud.Storage {
public LCACL ACL {
get {
return this["ACL"] as LCACL ;
} set {
this["ACL"] = value;
}
}