public async Task write_fills_out_descriptor()
{
var poco = new Poco {
Foo = "test"
};
IEnumerable <IFullEvent> savedEvents = null;
_store.Setup(
x =>
x.WriteEvents(Moq.It.IsAny <string>(), Moq.It.IsAny <IEnumerable <IFullEvent> >(),
Moq.It.IsAny <IDictionary <string, string> >(), Moq.It.IsAny <long?>()))
.Returns(Task.FromResult(0L))
.Callback <string, IEnumerable <IFullEvent>, IDictionary <string, string>, long?>(
(stream, events, headers, version) =>
{
savedEvents = events;
});
await _pocoStore.Write <Poco>(new Tuple <long, Poco>(0, poco), "test", "test", null,
new Dictionary <string, string>()).ConfigureAwait(false);
Assert.NotNull(savedEvents);
var dto = savedEvents.First();
Assert.AreEqual(dto.Event, poco);
Assert.AreEqual((dto.Event as Poco).Foo, "test");
var descriptor = dto.Descriptor;
Assert.AreEqual(descriptor.EntityType, typeof(Poco).AssemblyQualifiedName);
Assert.AreEqual(descriptor.StreamType, StreamTypes.Poco);
}
public void Clear_Test()
{
var op = new Mock <IOperationResult <Dictionary <string, object> > >(); //value is null
var bucket = new Mock <IBucket>();
bucket.Setup(x => x.GetAsync <Dictionary <string, object> >(It.IsAny <string>()))
.Returns(Task.FromResult(op.Object));
var provider = new Mock <ICouchbaseCacheBucketProvider>();
provider.Setup(x => x.GetBucket()).Returns(bucket.Object);
var cache = new CouchbaseCache(provider.Object, new CouchbaseCacheOptions());
var session = new CouchbaseSession(cache, "thesessionkey", new TimeSpan(0, 0, 10, 0), () => true, new LoggerFactory(), true);
var poco = new Poco {
Name = "jeff"
};
session.Set("Clear_Test", poco);
Assert.NotEmpty(session.Keys);
session.Clear();
Assert.Empty(session.Keys);
}
public static Poco CreatePoco()
{
var poco = new Poco();
new PropertyEmptySetter <POCO>(poco);
return(poco);
}
public void SetOfT_Test()
{
var op = new Mock <IOperationResult <Dictionary <string, object> > >(); //value is null
var bucket = new Mock <IBucket>();
bucket.Setup(x => x.GetAsync <Dictionary <string, object> >(It.IsAny <string>()))
.Returns(Task.FromResult(op.Object));
var provider = new Mock <ICouchbaseCacheBucketProvider>();
provider.Setup(x => x.GetBucket()).Returns(bucket.Object);
var cache = new CouchbaseCache(provider.Object, new CouchbaseCacheOptions());
var session = new CouchbaseSession(cache, "thesessionkey", new TimeSpan(0, 0, 10, 0), () => true, new LoggerFactory(), true);
var poco = new Poco {
Name = "jeff"
};
session.Set("SetOfT_Tests", poco);
Poco actual;
var result = session.TryGetValue("SetOfT_Tests", out actual);
Assert.True(result);
Assert.Same(poco, actual);
}
public async Task Test_Get()
{
var cache = GetCache();
var poco = new Poco {
Name = "poco1", Age = 12
};
const string key = "CouchbaseCacheTests.Test_Get";
var collection = await _fixture.GetDefaultCollectionAsync();
try
{
await collection.RemoveAsync(key);
}
catch (DocumentNotFoundException)
{
// Ignore
}
await collection.InsertAsync(key, GetBytes(poco), new InsertOptions().Transcoder(_transcoder));
var bytes = cache.Get(key);
var actual = GetObject <Poco>(bytes);
Assert.Equal(actual.ToString(), poco.ToString());
}
public void When_Cipher_Is_Modified_HMAC_Throws_AuthException()
{
var providers = new Dictionary <string, ICryptoProvider>
{
{ "AES-256-HMAC-SHA256", new AesCryptoProvider(new InsecureKeyStore("thekeyname", "!mysecretkey#9^5"))
{
KeyName = "thekeyname",
PrivateKeyName = "123teuwoeiwkwkey"
} }
};
var serializer = new EncryptedFieldSerializer(
new JsonSerializerSettings {
ContractResolver = new FieldEncryptorContractResolver(providers)
},
new JsonSerializerSettings {
ContractResolver = new FieldEncryptorContractResolver(providers)
});
var poco = new Poco
{
StringField = "Woot!"
};
var bytes = serializer.Serialize(poco);
bytes[90] = Convert.FromBase64String(Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes("s")))[0];
Assert.Throws <AuthenticationException>(() => serializer.Deserialize <Poco>(bytes, 0, bytes.Length));
}
public async Task <IActionResult> Build()
{
Poco model = new Poco
{
ClassComment = "用户信息",
ClassName = "UserInfo",
NameSpace = "App.Entity",
Properties = new List <PocoProperty>
{
new PocoProperty {
Comment = "用户ID", Name = "ID", TypeName = "int"
},
new PocoProperty {
Comment = "用户名称", Name = "Name", TypeName = "string"
},
new PocoProperty {
Comment = "用户年龄", Name = "Age", TypeName = "int"
},
new PocoProperty {
Comment = "用户性别", Name = "Gender", TypeName = "bool"
}
}
};
string result = await _viewRenderService.RenderToStringAsync("Test/Poco", model);
byte[] fileBuffer = BuildZipFile(new List <(string fileName, string fileContent)> {
("UserInfo.cs", result)
});
return(File(fileBuffer, "application/zip", "code.zip"));
}
public async Task NodesAsPocoProperties()
{
const string Expected = "{\"MyString\":null,\"Node\":42,\"Array\":[43],\"Value\":44,\"IntValue\":45,\"Object\":{\"Property\":46}}";
var poco = new Poco
{
Node = 42,
Array = new JsonArray(43),
Value = (JsonValue)44,
IntValue = (JsonValue)45,
Object = new JsonObject
{
["Property"] = 46
}
};
string json = await Serializer.SerializeWrapper(poco);
Assert.Equal(Expected, json);
poco = await Serializer.DeserializeWrapper <Poco>(json);
Assert.Equal(42, (int)poco.Node);
Assert.Equal(43, (int)poco.Array[0]);
Assert.Equal(44, (int)poco.Value);
Assert.Equal(45, (int)poco.IntValue);
Assert.Equal(46, (int)poco.Object["Property"]);
}
public void ExecuteUpdate(string ticket, string attributeID, string changeValue, string catAttrID, string endpoint)
{
int id = 0;
// Setting the URL with for the search method with its endpoint
Rclient.BaseUrl = new Uri(string.Format("{0}/api/v2/search", endpoint));
// Setting the request type and adding the respective headers and parameters
var request = new RestRequest(Method.POST).
AddParameter("where", attributeID);
request.AddHeader("otcsticket", ticket);
string response = Rclient.Execute(request).Content;
Poco item = JsonConvert.DeserializeObject <Poco>(response);
//countLabel.Text = (item.Results.Count).ToString();
int i = 0;
foreach (var obj in item.Results)
{
// Getting the id from the seach results and setting it to the variable idS
id = obj.Data.properties.Id;
// Inserting the id value to be used for changing the category attribute
InsertAttributeValues(ticket, id, changeValue, catAttrID, ++i, endpoint);
}
}// EOM
public void Test_Serialize()
{
var providers = new Dictionary <string, ICryptoProvider>
{
{ "AES-256-HMAC-SHA256", new AesCryptoProvider(new InsecureKeyStore("thekeyname", "!mysecretkey#9^5"))
{
KeyName = "thekeyname",
PrivateKeyName = "123teuwoeiwkwkey"
} }
};
var serializer = new EncryptedFieldSerializer(
new JsonSerializerSettings {
ContractResolver = new FieldEncryptorContractResolver(providers)
},
new JsonSerializerSettings {
ContractResolver = new FieldEncryptorContractResolver(providers)
});
var poco = new Poco
{
StringField = "Woot!"
};
var bytes = serializer.Serialize(poco);
var poco2 = serializer.Deserialize <Poco>(bytes, 0, bytes.Length);
Assert.Equal(poco.StringField, poco2.StringField);
}
public CreateFromPocoWindowViewModel()
{
// バインド方式:TwoWay
// TwoWay: ToReactivePropertyAsSynchronized()
FirstNameTwoWay = Poco.ToReactivePropertyAsSynchronized(x => x.FirstName)
.AddTo(Disposables);
LastNameTwoWay = Poco.ToReactivePropertyAsSynchronized(x => x.LastName)
.AddTo(Disposables);
// バインド方式:OneWay
// OneWay: ObserveProperty().ToReadOnlyReactiveProperty()
FirstNameOneWay = Poco.ObserveProperty(x => x.FirstName)
.ToReadOnlyReactiveProperty()
.AddTo(Disposables);
LastNameOneWay = Poco.ObserveProperty(x => x.LastName)
.ToReadOnlyReactiveProperty()
.AddTo(Disposables);
// バインド方式:OneWayToSource
// OneWayToSource: ReactiveProperty.FromObject()
FirstNameToSource = ReactiveProperty.FromObject(Poco, x => x.FirstName);
//.AddTo(Disposables); // TODO:不要？
LastNameToSource = ReactiveProperty.FromObject(Poco, x => x.LastName);
//.AddTo(Disposables); // TODO:不要？
}
public async Task Test_RemoveAsync()
{
var cache = GetCache();
var poco = new Poco {
Name = "poco1", Age = 12
};
const string key = "CouchbaseCacheTests.Test_RemoveAsync";
var collection = await _fixture.GetDefaultCollectionAsync();
try
{
await collection.RemoveAsync(key);
}
catch (DocumentNotFoundException)
{
// Ignore
}
await collection.InsertAsync(key, GetBytes(poco), new InsertOptions().Transcoder(_transcoder));
await cache.RemoveAsync(key);
await Assert.ThrowsAsync <DocumentNotFoundException>(() => collection.GetAsync(key));
}
public void Remove_Success()
{
var op = new Mock <IOperationResult <Dictionary <string, object> > >(); //value is null
var bucket = new Mock <IBucket>();
bucket.Setup(x => x.GetAsync <Dictionary <string, object> >(It.IsAny <string>()))
.Returns(Task.FromResult(op.Object));
var provider = new Mock <ICouchbaseCacheBucketProvider>();
provider.Setup(x => x.GetBucket()).Returns(bucket.Object);
var cache = new CouchbaseCache(provider.Object, new CouchbaseCacheOptions());
var session = new CouchbaseSession(cache, "thesessionkey", new TimeSpan(0, 0, 10, 0), () => true, new LoggerFactory(), true);
var poco = new Poco {
Name = "jeff"
};
session.Set("remove_success", poco);
Assert.Contains("remove_success", session.Keys.Cast <string>());
session.Remove("remove_success");
Assert.DoesNotContain("remove_success", session.Keys.Cast <string>());
}
public void Test_Insert()
{
//arrange
var builder = new Mock <IMutateInBuilder <List <Poco> > >();
builder.Setup(x => x.ArrayInsert("[0]", It.IsAny <Poco>(), It.IsAny <bool>())).Returns(builder.Object);
builder.Setup(x => x.Execute()).Returns(new DocumentFragment <List <Poco> >(builder.Object)
{
Success = true
});
var bucket = MockHelper.CreateBucket(BucketKey, new Poco {
Key = "Poco-1", Name = "Poco #1"
});
bucket.Setup(x => x.MutateIn <List <Poco> >(BucketKey)).Returns(builder.Object);
var collection = new CouchbaseList <Poco>(bucket.Object, BucketKey);
var poco = new Poco {
Key = "Poco-2", Name = "Poco #2"
};
//act/assert
Assert.DoesNotThrow(() => collection.Insert(0, poco));
builder.Verify(x => x.ArrayInsert("[0]", poco, true), Times.Once());
builder.Verify(x => x.Execute(), Times.Once());
}
public void QueueTrigger_ProvidesPocoComplexPropertyBindingData()
{
// Arrange
Poco expectedChild = new Poco
{
Value = "abc",
Int32Value = 123
};
IStorageAccount account = CreateFakeStorageAccount();
IStorageQueue queue = CreateQueue(account, QueueName);
Poco value = new Poco {
Child = expectedChild
};
string content = JsonConvert.SerializeObject(value, typeof(Poco), settings: null);
IStorageQueueMessage message = queue.CreateMessage(content);
queue.AddMessage(message);
// Act
Poco result = RunTrigger <Poco>(account, typeof(BindToPocoComplexPropertyBindingDataProgram),
(s) => BindToPocoComplexPropertyBindingDataProgram.TaskSource = s);
// Assert
AssertEqual(expectedChild, result);
}
public static void Run([Table(TableName)] CustomTableBinding <Poco> table)
{
Poco entity = new Poco();
table.Add(entity);
table.Delete(entity);
}
public void Test_Remove()
{
//arrange
var poco = new Poco {
Key = "Poco", Name = "Poco #1"
};
var builder = new Mock <IMutateInBuilder <List <Poco> > >();
builder.Setup(x => x.Remove("[0]")).Returns(builder.Object);
builder.Setup(x => x.Execute()).Returns(new DocumentFragment <List <Poco> >(builder.Object)
{
Success = true
});
var bucket = MockHelper.CreateBucket(BucketKey, poco);
bucket.Setup(x => x.MutateIn <List <Poco> >(BucketKey)).Returns(builder.Object);
var collection = new CouchbaseList <Poco>(bucket.Object, BucketKey);
//act/assert
Assert.DoesNotThrow(() => collection.Remove(poco));
builder.Verify(x => x.Remove("[0]"), Times.Once());
builder.Verify(x => x.Execute(), Times.Once());
}
public void IgnoreIfPath()
{
TypeAdapterConfig <Poco, Dto> .NewConfig()
.Map(dest => dest.Address, src => src.Child.Address)
.IgnoreIf((src, dest) => src.Child.Address.Number == "100", dest => dest.Address.Location);
var poco = new Poco
{
Id = Guid.NewGuid(),
Child = new ChildPoco
{
Address = new Address
{
Number = "123",
Location = "10,10"
}
}
};
var dto = poco.Adapt <Dto>();
dto.Id.ShouldBe(poco.Id);
dto.Address.Number.ShouldBe(poco.Child.Address.Number);
dto.Address.Location.ShouldBe(poco.Child.Address.Location);
poco.Child.Address.Number = "100";
var dto2 = poco.Adapt <Dto>();
dto2.Id.ShouldBe(poco.Id);
dto2.Address.Number.ShouldBe(poco.Child.Address.Number);
dto2.Address.Location.ShouldBeNull();
}
public void MapPath()
{
TypeAdapterConfig <Poco, Dto> .NewConfig()
.Map(dest => dest.Address.Number, src => src.Child.Address.Number);
TypeAdapterConfig <ChildPoco, Dto> .NewConfig()
.Map(dest => dest.Address.Number, src => src.Address.Number + "test");
var poco = new Poco
{
Id = Guid.NewGuid(),
Child = new ChildPoco
{
Address = new Address
{
Number = "123",
Location = "10,10"
}
}
};
var dto = poco.Adapt <Dto>();
dto.Id.ShouldBe(poco.Id);
dto.Address.Number.ShouldBe(poco.Child.Address.Number);
dto.Address.Location.ShouldBeNull();
var dto2 = poco.Child.Adapt <Dto>();
dto2.Address.Number.ShouldBe(poco.Child.Address.Number + "test");
}
public async Task TableEntity_IfBoundToExistingPoco_Binds()
{
// Arrange
const string expectedValue = "abc";
StorageAccount account = CreateFakeStorageAccount();
CloudQueue triggerQueue = await account.CreateQueueAsync(TriggerQueueName);
await triggerQueue.AddMessageAsync(new CloudQueueMessage("ignore"));
CloudTable table = await account.CreateTableAsync(TableName);
Dictionary <string, EntityProperty> properties = new Dictionary <string, EntityProperty>
{
{ "Value", new EntityProperty(expectedValue) }
};
table.Insert(new DynamicTableEntity(PartitionKey, RowKey, etag: null, properties: properties));
// Act
Poco result = RunTrigger <Poco>(account, typeof(BindToPocoProgram),
(s) => BindToPocoProgram.TaskSource = s);
// Assert
Assert.NotNull(result);
Assert.Equal(expectedValue, result.Value);
}
public async Task Test_RefreshAsync_WithTimeSpan()
{
var cache = GetCache(new TimeSpan(0, 0, 0, 4));
var poco = new Poco {
Name = "poco1", Age = 12
};
const string key = "CouchbaseCacheTests.Test_RefreshAsync_WithTimeSpan";
var collection = await _fixture.GetDefaultCollectionAsync();
try
{
await collection.RemoveAsync(key);
}
catch (DocumentNotFoundException)
{
// Ignore
}
var v = await collection.InsertAsync(key, GetBytes(poco),
new InsertOptions().Transcoder(_transcoder).Expiry(new TimeSpan(0, 0, 0, 2)));
await cache.RefreshAsync(key);
await Task.Delay(2000);
await collection.GetAsync(key, new GetOptions().Transcoder(_transcoder));
}
public void QueueTrigger_IfBoundToPoco_Binds()
{
Poco expectedContent = new Poco {
Value = "abc"
};
TestBindToPoco(expectedContent);
}
public static void Run([QueueTrigger(TriggerQueueName)] CloudQueueMessage ignore,
[Table(TableName)] CustomTableBinding <Poco> table)
{
Poco entity = new Poco();
table.Add(entity);
table.Delete(entity);
}
public async Task QueueTrigger_IfBoundToPoco_Binds()
{
Poco expectedContent = new Poco {
Value = "abc"
};
await TestBindToPoco(expectedContent);
}
public async Task GetValueAsync_Poco_ReturnsValue()
{
Mock <IConnection> rethinkDbConnectionMock = PrepareRethinkDbConnectionMock();
RethinkDbValueBinder <Poco> rethinkDbValueBinder = PrepareRethinkDbValueBinder <Poco>(rethinkDbConnectionMock.Object);
Poco value = (await rethinkDbValueBinder.GetValueAsync()) as Poco;
Assert.NotNull(value);
}
public void Should_Ignore_GetType()
{
var poco = new Poco {
FirstName = "Foo", LastName = "Bar"
};
var dto = poco.Adapt <Dto2>();
dto.Type.ShouldBeNull();
}
public async Task GetValueAsync_Poco_RunsGetOnTable()
{
Mock <IConnection> rethinkDbConnectionMock = PrepareRethinkDbConnectionMock();
RethinkDbValueBinder <Poco> rethinkDbValueBinder = PrepareRethinkDbValueBinder <Poco>(rethinkDbConnectionMock.Object);
Poco value = (await rethinkDbValueBinder.GetValueAsync()) as Poco;
rethinkDbConnectionMock.Verify(m => m.RunResultAsync <JObject>(It.Is <ReqlAst>(reql => GET_DOCUMENT_REQL_MATCH(reql)), It.IsAny <Object>(), It.IsAny <CancellationToken>()), Times.Once);
}
public void Should_Copy_Value_From_Get_Method()
{
var poco = new Poco {
FirstName = "Foo", LastName = "Bar"
};
var dto = poco.Adapt <Dto>();
dto.FullName.ShouldBe("Foo Bar");
}
public void Poco_DeserializedCorrectly()
{
var poco = new Poco {
Foo = "foo", Bar = 1
};
var result = poco.ToJsonString(false, false, false);
result.Replace(" ", "").Should().Be("{\"Foo\":\"foo\",\"Bar\":1}");
}
public void Allow_GetType_If_Property_Is_Type()
{
var poco = new Poco {
FirstName = "Foo", LastName = "Bar"
};
var dto = poco.Adapt <Dto3>();
dto.Type.ShouldBe(typeof(Poco));
}
public void TestPocoArray()
{
var arr = new Poco[200];
for (int i = 0; i < arr.Length; i++)
{
arr[i] = new Poco()
{
Name = "Foo" + i,
Age = i
};
}
Test(arr);
}
protected override void Main()
{
TraceLine(Instructions.PressAnyKeyToCancel);
// Start with a typical object...
Poco obj = new Poco();
// and wrap it with a dynamic proxy.
dynamic asyncObj = ObservableDynamicObject.Create(obj);
// Properties, events and methods will now return observables.
IObservable<string> messageChanged = asyncObj.Message;
IObservable<EventPattern<PongEventArgs>> pongRaised = asyncObj.Pong;
IObservable<int> pong = pongRaised.Select(e => e.EventArgs.Value);
using (messageChanged.Subscribe(ConsoleOutput("Message changed")))
using (pong.Subscribe(ConsoleOutput("Pong")))
{
TraceLine(Text.ObservableDynamicObjectLabAssigningMessage);
asyncObj.Message = "New Message";
TraceLine(Text.ObservableDynamicObjectLabCallingPing);
IObservable<Unit> ping = asyncObj.Ping(12345);
TraceLine(Text.ObservableDynamicObjectLabCallingCalculate);
IObservable<int> calculate = asyncObj.Calculate("Hello World");
using (ping.Subscribe(ConsoleOutput("Ping")))
using (calculate.Subscribe(ConsoleOutput("Calculate")))
{
WaitForKey();
}
}
}
public void Can_change_serialization_options()
{
var mockResponse = new MockHttpResponse();
var dto = new Poco();
Assert.That(dto.ToJson(), Is.EqualTo("{}"));
var httpResult = new HttpResult(dto)
{
ResultScope = () => JsConfig.With(includeNullValues:true)
};
var reponseWasAutoHandled = mockResponse.WriteToResponse(httpResult, MimeTypes.Html);
Assert.That(reponseWasAutoHandled.Result, Is.True);
Assert.That(mockResponse.ReadAsString(), Is.EqualTo("{\"Text\":null}"));
}
private void SyntaxAppend(StringBuilder syntax, dynamic value, Poco.Columns col)
{
if (value != null)
{
if (col.DataType.Contains("char"))
{
syntax.AppendFormat(" {0} = \"{1}\",", col.Name, value);
}
else if (col.DataType.Contains("bit"))
{
syntax.AppendFormat(" {0} = \"{1}\",", col.Name, value.ToString().ToLower());
}
else if (col.DataType.Contains("date"))
{
syntax.AppendFormat(" {0} = DateTime.Parse(\"{1}\"),", col.Name, value);
}
else
{
syntax.AppendFormat(" {0} = {1},", col.Name, value);
}
}
}
private void SetInsert(dynamic row, StringBuilder syntax, Poco.Columns col)
{
var value = GetProperty(row, col.Name);
SyntaxAppend(syntax, value, col);
}
public void Deserializes_Poco_with_string_with_quotes_correctly()
{
var original = new Poco {Name = "\"This is a string surrounded with quotes\""};
var json = JsonSerializer.SerializeToString(original);
var fromJson = JsonSerializer.DeserializeFromString<Poco>(json);
var fromJsonType = (Poco)JsonSerializer.DeserializeFromString(json, typeof(Poco));
"{0}||{1}".Print(json, fromJson);
Assert.That(fromJson.Name, Is.EqualTo(original.Name));
Assert.That(fromJsonType.Name, Is.EqualTo(original.Name));
}
private void FallbackInsert(dynamic row, StringBuilder syntax, Poco.Columns col)
{
var value = GetProperty(row, col.Name);
if (value != null)
{
syntax.AppendFormat(" {0} = {1},", col.Name, value);
}
}
private void GuidInsert(dynamic row, StringBuilder syntax, Poco.Columns col)
{
var value = GetProperty(row, col.Name);
if (value != null)
{
syntax.AppendFormat(" {0} = Guid.Parse(\"{1}\"),", col.Name, value.ToString().ToLower());
}
}
private void DateTimeInsert(dynamic row, StringBuilder syntax, Poco.Columns col)
{
var value = GetProperty(row, col.Name);
if (value != null)
{
syntax.AppendFormat(" {0} = DateTime.Parse(\"{1}\"),", col.Name, value);
}
}
protected bool Equals(Poco other)
{
return string.Equals(Key, other.Key, StringComparison.OrdinalIgnoreCase);
}
private void CharInsert(dynamic row, StringBuilder syntax, Poco.Columns col)
{
var value = GetProperty(row, col.Name);
if (value != null)
{
syntax.AppendFormat(" {0} = \"{1}\",", col.Name, value.Replace("\"", "\\\""));
}
}
private void BinaryInsert(dynamic row, StringBuilder syntax, Poco.Columns col)
{
var value = GetProperty(row, col.Name);
if (value != null)
{
syntax.AppendFormat(" {0} = Convert.FromBase64String(\"{1}\"),", col.Name, Convert.ToBase64String(value));
}
}
public void Test_Indexer_Set()
{
const string key = "CouchbaseDictionaryTests.Test_Add";
_bucket.Remove(key);
var dictionary = new CouchbaseDictionary<string, Poco>(_bucket, key);
dictionary.Add("somekey1", new Poco { Name = "poco1" });
dictionary.Add("somekey2", new Poco { Name = "poco2" });
var item = dictionary["somekey1"] = new Poco {Name = "poco3"};
Assert.AreEqual("poco3", item.Name);
}
public void Create_OtherType_CanConvert()
{
// Act
IConverter<Poco, EntityProperty> converter = TToEntityPropertyConverterFactory.Create<Poco>();
// Assert
Assert.NotNull(converter);
Poco original = new Poco { Value = "abc" };
EntityProperty property = converter.Convert(original);
Assert.NotNull(property);
Assert.Equal(EdmType.String, property.PropertyType);
string expected = JsonConvert.SerializeObject(original, Formatting.Indented);
Assert.Equal(expected, property.StringValue);
}
public void Starting_with_quotes_inside_POCOs()
{
var dto = new Poco {Name = "\"starting with\" POCO"};
var json = dto.ToJson();
var fromDto = json.FromJson<Poco>();
Assert.That(fromDto.Name, Is.EqualTo(dto.Name));
}
private bool SpecialIgnoreFound(dynamic row, Poco.Columns col)
{
var value = GetProperty(row, col.Name);
foreach (var item in Program.SpecialIgnores)
{
if (table == item.Item1 && item.Item2 == col.Name && item.Item3 == value)
{
return true;
}
}
return false;
}
