public void Can_deserialize_with_existing_structure()
{
// given
var json = JObject.Parse(@"
{
'@context': {
'foaf': 'http://xmlns.com/foaf/0.1/',
'name': 'foaf:name',
'lastName': 'foaf:familyName',
'Person': 'foaf:Person'
},
'@id': 'http://t-code.pl/#tomasz',
'@type': 'Person',
'name': 'Tomasz',
'lastName': 'Pluskiewicz'
}");
// when
IEntitySerializer serializer = new EntitySerializer(new StaticContextProvider());
var person = serializer.Deserialize<Person>(json);
// then
Assert.That(person.Name, Is.EqualTo("Tomasz"));
Assert.That(person.LastName, Is.EqualTo("Pluskiewicz"));
Assert.That(person.Id, Is.EqualTo(new Uri("http://t-code.pl/#tomasz")));
}
public void Entity_serializer_can_deserialize_byte_array_as_json_array_of_bytes()
{
var serializer = new EntitySerializer(null);
var obj = JObject.Parse(@"{ _id: ""foo"", PasswordHash: [1,2,3,4] }");
var doc = new Document();
var ent = serializer.Read<EntityWithByteArray>(obj, ref doc);
Assert.That(ent.PasswordHash.Length, Is.EqualTo(4));
}
public void Should_deserialize_when_entity_serializer_was_created_with_paremterless_constructor()
{
// given
dynamic raw = JsonConvert.DeserializeObject("{ 'uriProperty': null }");
// when
var deserialized = new EntitySerializer().Deserialize <ClassWithSomeUris>((JToken)raw);
// then
Assert.That(deserialized.UriProperty, Is.Null);
}
private List <string> slotstrings = new List <string>(); //serialization
public override void ExposeData(EntitySerializer serializer)
{
base.ExposeData(serializer);
serializer.DataField(ref slotstrings, "Slots", new List <string>(0));
foreach (var slotflagsloaded in slotstrings)
{
SlotFlags |= (SlotFlags)Enum.Parse(typeof(SlotFlags), slotflagsloaded.ToUpper());
}
}
public void SaveGridEntities(EntitySerializer serializer, GridId gridId)
{
// serialize all entities to disk
foreach (var entity in _allEntities)
{
if (entity.TryGetComponent <ITransformComponent>(out var transform) && transform.GridID == gridId)
{
entity.ExposeData(serializer);
}
}
}
public void SaveSystem_GetSaveState_WithEntity_ReturnsSaveStateWithSerialisedEntity()
{
var entity = new Entity(0, "New Entity", new IEntityComponent[0]);
_mutableEntities.Add(entity);
var result = _saveSystem.GetSaveState();
var expected = EntitySerializer.Serialize(entity);
result.Entities.Single().Should().Be(expected);
}
public void CreateReport(ErrorReportEntity report)
{
if (report == null)
{
throw new ArgumentNullException(nameof(report));
}
if (string.IsNullOrEmpty(report.Title) && report.Exception != null)
{
report.Title = report.Exception.Message;
if (report.Title == null)
{
report.Title = "[Exception message was not specified]";
}
else if (report.Title.Length > 100)
{
report.Title = report.Title.Substring(0, 100);
}
}
var collections = new List <string>();
foreach (var context in report.ContextCollections)
{
var data = EntitySerializer.Serialize(context);
if (data.Length > MaxCollectionSize)
{
var tooLargeCtx = new ErrorReportContextCollection(context.Name,
new Dictionary <string, string>()
{
{
"Error",
$"This collection was larger ({data.Length}bytes) than the threshold of {MaxCollectionSize}bytes"
}
});
data = EntitySerializer.Serialize(tooLargeCtx);
}
collections.Add(data);
}
_unitOfWork.Insert(report);
var cols = string.Join(", ", collections);
var inboound = new InboundCollection
{
JsonData = $"[{cols}]",
ReportId = report.Id
};
_unitOfWork.Insert(inboound);
}
public void AddSerializer()
{
var provider = new EntitySerializerProvider();
Assert.IsFalse(provider.IsSerializable(typeof(object)));
var serializer = new EntitySerializer(typeof(object));
provider.AddSerializer(typeof(object), serializer);
Assert.AreEqual(serializer, provider.GetSerizliser(typeof(object)));
Assert.IsTrue(provider.IsSerializable(typeof(object)));
}
public void UsesGetContextMethodSerializing()
{
// given
const string expected = "{ '@context': { '@base': 'http://example.com/test/' } }";
var entity = new ContextInlineMethod("test");
var serializer = new EntitySerializer();
// when
var json = serializer.Serialize(entity);
// then
Assert.True(JToken.DeepEquals(json, JObject.Parse(expected)), $"Actual object is {json}");
}
public void UsesInlineContextWhenSerializing(Type entityType)
{
// given
const string expected = "{ '@context': { '@base': 'http://example.com/' } }";
var entity = Activator.CreateInstance(entityType);
var serializer = new EntitySerializer();
// when
var json = serializer.Serialize(entity);
// then
Assert.That(JToken.DeepEquals(json, JObject.Parse(expected)), "Actual object is {0}", json);
}
public void SerializesTypesPropertyAsAtTypes(Type type, string expectedJson)
{
// given
var expected = JObject.Parse(expectedJson);
var entity = Activator.CreateInstance(type);
var serializer = new EntitySerializer();
// when
var json = serializer.Serialize(entity);
// then
Assert.That(JToken.DeepEquals(json, expected), "Actual object was {0}", json);
}
public static Concept DeSerializeJSON(string jsonString)
{
Debug.Log(jsonString);
var json = JObject.Parse(jsonString);
// when
IEntitySerializer serializer = new EntitySerializer(new StaticContextProvider());
var person = serializer.Deserialize <Concept>(json);
return(person);
}
public void SerializesTypesPropertyAsAtTypes(Type type, string expectedJson)
{
// given
var expected = JObject.Parse(expectedJson);
var entity = Activator.CreateInstance(type);
var serializer = new EntitySerializer();
// when
var json = serializer.Serialize(entity);
// then
Assert.That(JToken.DeepEquals(json, expected), "Actual object was {0}", json);
}
public void UsesInlineContextPropertyWhenSerializing(Type entityType)
{
// given
const string expected = "{ '@context': { '@base': 'http://example.com/' } }";
var entity = Activator.CreateInstance(entityType);
var serializer = new EntitySerializer();
// when
var json = serializer.Serialize(entity);
// then
Assert.True(JToken.DeepEquals(json, JObject.Parse(expected)), $"Actual object is {json}");
}
public async Task ExecuteAsync()
{
var sw = Stopwatch.StartNew();
while (sw.ElapsedMilliseconds < 2000)
{
var reportIds = new List <int>();
using (var cmd = _analysisDbContext.UnitOfWork.CreateDbCommand())
{
cmd.CommandText = "SELECT TOP(10) Id, ContextInfo FROM ErrorReports WHERE cast([ContextInfo] as nvarchar(max)) != ''";
using (var reader = await cmd.ExecuteReaderAsync())
{
while (await reader.ReadAsync())
{
var reportId = reader.GetInt32(0);
var json = reader.GetString(1);
var contexts = EntitySerializer.Deserialize <ErrorReportContext[]>(json);
_importer.AddContextCollections(reportId, contexts);
reportIds.Add(reportId);
}
}
}
if (!reportIds.Any())
{
break;
}
await _importer.Execute();
_importer.Clear();
using (var cmd = _analysisDbContext.UnitOfWork.CreateDbCommand())
{
var idStr = string.Join(",", reportIds);
cmd.CommandText = $"UPDATE ErrorReports SET ContextInfo='' WHERE Id IN({idStr})";
using (var reader = await cmd.ExecuteReaderAsync())
{
while (await reader.ReadAsync())
{
var reportId = reader.GetInt32(0);
var json = reader.GetString(1);
var contexts = EntitySerializer.Deserialize <ErrorReportContext[]>(json);
_importer.AddContextCollections(reportId, contexts);
}
}
}
}
_analysisDbContext.SaveChanges();
}
public void DeserializeMultiple_ReturnsMultipleEntities()
{
var multipleSerialised = LoadFile("EntityEngineSystem/TestData/ExpectedSerialization_MultipleEntities.txt");
var entities = EntitySerializer.DeserializeAll(SystemContainer, new[] { multipleSerialised });
var expected = new List <Entity>
{
GetTestEntity(0),
GetTestEntity(0)
};
entities.Should().BeEquivalentTo(expected, options => options.Using(new EntityListEquivalence()));
}
public async Task UpdateAsync(CollectionMetadata collection)
{
var props = EntitySerializer.Serialize(collection.Properties);
using (var cmd = _unitOfWork.CreateDbCommand())
{
cmd.CommandText = @"UPDATE CollectionMetadata SET Properties = @Properties
WHERE Id = @id";
cmd.AddParameter("Id", collection.Id);
cmd.AddParameter("Properties", props);
await cmd.ExecuteNonQueryAsync();
}
}
public async Task CreateAsync(CollectionMetadata entity)
{
var props = EntitySerializer.Serialize(entity.Properties);
using (var cmd = _unitOfWork.CreateDbCommand())
{
cmd.CommandText =
@"INSERT INTO CollectionMetadata (Name, ApplicationId, Properties) VALUES(@Name, @ApplicationId, @Properties)";
cmd.AddParameter("Name", entity.Name);
cmd.AddParameter("ApplicationId", entity.ApplicationId);
cmd.AddParameter("Properties", props);
await cmd.ExecuteNonQueryAsync();
}
}
public void TestEntity_Deserialize_MatchesTestEntity(int testCase)
{
string testData = LoadSerializedData(testCase);
var entity = new List <IEntity> {
EntitySerializer.Deserialize(SystemContainer, testData)
};
var expected = new List <IEntity> {
GetTestEntity(testCase)
};
entity.Should().BeEquivalentTo(expected, options => options.Using(new EntityListEquivalence()));
}
public RepositoryScenarioContext()
{
Store = new TripleStore();
var contextProvider = new StaticContextProvider();
var jObject = new JObject(
"hydra".IsPrefixOf(Hydra.Hydra.BaseUri),
"member".IsProperty(Hydra.Hydra.member).Container().Set(),
"totalItems".IsProperty(Hydra.Hydra.totalItems));
contextProvider.SetContext(typeof(Collection <Book>), jObject);
var frameProvider = new WikibusModelFrames();
var serializer = new EntitySerializer(contextProvider, frameProvider);
Repository = new Wikibus.Sources.DotNetRDF.SourcesRepository(new Lazy <ISparqlQueryProcessor>(() => new LeviathanQueryProcessor(Store)), serializer);
}
private void SetKeyBindings()
{
var keyBindingsData = keyBindingsDataProvider.GetData();
var bindings = EntitySerializer.DeserializeAll(_systemContainer, keyBindingsData).SingleOrDefault();
if (bindings != null)
{
_keyBindings = bindings.Components.OfType <KeyBinding>().ToList();
}
else
{
_keyBindings = new List <KeyBinding>();
}
}
public EntityPack GenerateShipLoadout(Predicate <HullData> hullFilter = null)
{
var hullData = RandomHull(HullType.Ship, hullFilter);
var hull = ItemManager.CreateInstance(hullData) as EquippableItem;
if (hull == null)
{
ItemManager.Log("WHAT???");
}
var entity = new Ship(ItemManager, null, hull, ItemManager.GameplaySettings.DefaultEntitySettings);
entity.Faction = Faction;
OutfitEntity(entity);
return(EntitySerializer.Pack(entity));
}
protected override Event InitialMasterOperation()
{
string rawData = EntitySerializer.Serialize <ICalendarInteropSeriesAction>(this.actionToPropagate);
Event initialMasterValue = this.actionToPropagate.GetInitialMasterValue();
IActionQueue actionQueue = initialMasterValue;
ActionInfo actionInfo = new ActionInfo(this.actionToPropagate.CommandId, DateTime.UtcNow, this.actionToPropagate.GetType().Name, rawData);
actionQueue.ActionsToAdd = new ActionInfo[]
{
actionInfo
};
Event @event = base.ExecuteOnMasterWithConflictRetries(new Func <Event, Event>(this.actionToPropagate.InitialMasterOperation), initialMasterValue, true);
this.precedingAction = SeriesInlineInterop.GetPrecedingActionFromQueue(@event);
return(@event);
}
public Task Import(Stream xmlData, bool append)
{
return(Task.Run(() =>
{
var import = EntitySerializer.Deserialize <Note[]>(xmlData);
if (append)
{
_db.Notes.Save(import);
}
else
{
_db.Notes.DeleteAll();
_db.Notes.Save(import);
}
}));
}
protected CalendarEventContentAction(byte[] itemId, byte[] folderId, string watermark, Event theEvent, IList <Event> exceptionalOccurrences = null, IList <string> deletedOccurrences = null) : base(watermark)
{
base.ItemId = itemId;
base.FolderId = folderId;
this.EventData = EntitySerializer.Serialize <Event>(theEvent);
this.DeletedOccurrences = deletedOccurrences;
if (exceptionalOccurrences != null)
{
List <string> list = new List <string>();
foreach (Event obj in exceptionalOccurrences)
{
list.Add(EntitySerializer.Serialize <Event>(obj));
}
this.ExceptionalEventsData = list;
}
}
public override void Start()
{
Engine.AddSystem(new FollowSystem());
Engine.AddSystem(new TouchTrackingSystem());
Engine.AddSystem(new BuildingRenderer());
Engine.AddSystem(new CharacterSystem());
Engine.AddSystem(new Mover());
Engine.AddSystem(new Roller());
Engine.AddSystem(new Clamberer());
Engine.AddSystem(new Slider());
Engine.AddSystem(new Diver());
Engine.AddSystem(new PlayerInput());
Engine.AddSystem(new DiveInitiator());
base.Start();
Input.AddButton("jump", new InputButton(Keys.Space, Keys.W, Keys.Up));
Input.AddButton("slide", new InputButton(Keys.S, Keys.LeftShift, Keys.Down));
PrefabInitializer.AddRunnerGamePrefabs(PrefabManager);
var player = PrefabManager.Instantiate("player", new Vector2(2, -.25f));
PrefabManager.Instantiate("platform", new Vector2(0, 0), 0, new Vector2(48, 1));
PrefabManager.Instantiate("platform", new Vector2(-23.5f, -10), 0, new Vector2(1, 20));
PrefabManager.Instantiate("platform", new Vector2(23.5f, -10), 0, new Vector2(1, 20));
PrefabManager.Instantiate("platform", new Vector2(21f, -2.5f), 0, new Vector2(4, 4));
PrefabManager.Instantiate("platform", new Vector2(-10, -3f), 0, new Vector2(4, 4));
PrefabManager.Instantiate("divable", new Vector2(0f, -1.5f), 0, new Vector2(1, 1));
PrefabManager.Instantiate("buildings", new Vector2(0, 15));
camera = new CameraPrefab(player.Get <Transform>()).Build();
var json = new EntitySerializer().Serialize(camera);
File.WriteAllText("entity.json", json);
var result = new EntitySerializer().Deserialize(json);
Engine.AddEntity(camera);
}
public override string Serialize(object obj, Dictionary <int, object> moduleDictionary)
{
string output = "";
PropertyInfo[] properties = obj.GetType().GetProperties();
output += "<\n";
if (moduleDictionary.Values.Contains(obj))
{
foreach (var item in moduleDictionary)
{
if (item.Value == obj)
{
output += $"%ID={item.Key}\n";
}
}
}
else
{
moduleDictionary.Add(moduleDictionary.Count, obj);
output += $"%ID={moduleDictionary.Count - 1}\n";
}
output += $"%Type={obj.GetType().FullName}\n";
for (int i = 0; i < properties.Count(); i++)
{
var prop = properties[i];
object value = prop.GetValue(obj);
EntitySerializer serializer = serializers.Single(s => s.CanSerialize(value));
output += prop.Name + "=" + serializer.Serialize(value, moduleDictionary);
if (i != properties.Count() - 1)
{
output += "\n";
}
}
output += "\n>";
return(output);
}
public Task Import(Stream xmlData, bool append)
{
return(Task.Run(() =>
{
var import = EntitySerializer.Deserialize <FolderLink[]>(xmlData);
if (append)
{
_db.FavoriteFolders.Save(import);
}
else
{
_db.FavoriteFolders.DeleteAll();
_db.FavoriteFolders.Save(import);
}
_app.CurrentDispatcher.Invoke(() => Folders.UpdateWith(_db.FavoriteFolders.GetAll()));
}));
}
public ErrorReportDtoMapper()
: base("ErrorReports")
{
Property(x => x.ContextCollections)
.ColumnName("ContextInfo")
.ToColumnValue(EntitySerializer.Serialize)
.ToPropertyValue(colValue => EntitySerializer.Deserialize <ContextCollectionDTO[]>((string)colValue));
Property(x => x.ReportVersion).Ignore();
Property(x => x.Exception)
.ToPropertyValue(EntitySerializer.Deserialize <ReportExeptionDTO>)
.ToColumnValue(EntitySerializer.Serialize);
Property(x => x.ReportId)
.ColumnName("ErrorId");
}
public Task Import(Stream xmlData, bool append)
{
return(Task.Run(() =>
{
var import = EntitySerializer.Deserialize <LauncherProgram[]>(xmlData);
if (append)
{
_db.Programs.Save(import);
}
else
{
_db.Programs.DeleteAll();
_db.Programs.Save(import);
}
_application.CurrentDispatcher.Invoke(() => Programs.UpdateWith(_db.Programs.GetAll()));
}));
}
private void FillData()
{
lvGrid.Items.Clear();
var no = 0;
foreach (var entity in entities.Entities)
{
var item = lvGrid.Items.Add((++no).ToString());
item.SubItems.Add(entity.Id.Equals(Guid.Empty) ? "" : entity.Id.ToString());
foreach (var column in columns)
{
var col = column.Key;
var valuestr = "";
if (entity.Contains(col))
{
var value = entity[col];
if (value != null)
{
try
{
if (form.currentSettings.gridFriendly)
{
valuestr = EntitySerializer.AttributeToString(value, column.Value.Metadata);
}
else
{
var basevalue = EntitySerializer.AttributeToBaseType(value);
valuestr = basevalue != null?basevalue.ToString() : "";
}
}
catch
{
MessageBox.Show("Attribute " + col + " failed");
}
}
}
if (string.IsNullOrEmpty(valuestr))
{
valuestr = "<null>";
}
item.SubItems.Add(valuestr);
}
}
lvGrid.AutoResizeColumns(ColumnHeaderAutoResizeStyle.ColumnContent);
}
/// <summary>
/// Persist the entity.
/// </summary>
/// <param name="entityType">
/// The entity type.
/// </param>
/// <param name="entity">
/// The entity.
/// </param>
/// <param name="write">
/// if <c>true</c> writes the entity, otherwise only traversing.
/// </param>
/// <param name="isRoot">
/// if <c>true</c> if entity is the root, otherwise <c>false</c>.
/// </param>
/// <returns>
/// The entity key.
/// </returns>
/// <exception cref="PersistenceException">
/// If entity is not recognized as a valid entity.
/// </exception>
private Key Persist(Type entityType, object entity, bool write = true, bool isRoot = false)
{
if (this.entitiesWritten.Add(entity))
{
var value = EntitySerializer.Serialize(this.entityContext, entityType, entity,
SerializationBase.DefaultCapacity, write, this.SerializingEntity);
if (this.entityReference == null)
{
throw new PersistenceException(string.Format(CultureInfo.InvariantCulture,
@"{0} is not a valid entity", entityType));
}
write = write && (this.newEntity || !this.behaviors.WriteNewOnly());
var dontCache = this.behaviors.DoNotCache();
var bypassEntitySpecsFetched =
this.newEntity || this.behaviors.IsCreateNew() || this.behaviors.BypassReadCache();
var entitySpec = !dontCache || !bypassEntitySpecsFetched
? new EntitySpec(this.entityReference, new Key(this.key))
: null;
if (dontCache || this.entityContext.EntitySpecsWritten.Add(entitySpec) || (isRoot && this.behaviors.IsCreateNew()) || this.behaviors.BypassWriteCache())
{
if (write)
{
if (bypassEntitySpecsFetched || !this.entityContext.EntitySpecsFetched.Contains(entitySpec))
{
var type = this.entityReference.EntityType;
if (this.tableMutatorType != type)
{
this.tableMutatorType = type;
this.tableMutator = this.entityContext.GetTableMutator(this.entityReference.Namespace,
this.entityReference.TableName);
}
//// TODO verbosity?
//// Logging.TraceEvent(TraceEventType.Verbose, () => string.Format(CultureInfo.InvariantCulture, @"Set {0}@{1}", this.tableMutator.Key, this.key));
this.tableMutator.Set(this.key, value);
}
}
}
}
return(this.key);
}
public void SerializeTest()
{
var container = UnityConfigurator.Configure();
World.Instance = container.Resolve <World>();
var entity = new Character {
Id = "test_entity",
Names = "test entity",
ShortDescr = "test entity"
};
var data = EntitySerializer.Serialize(entity);
Assert.AreEqual("test_entity", data["Vnum"], "Vnum");
Assert.AreEqual("test entity", data["Names"], "Names");
Assert.AreEqual("test entity", data["ShortDescr"], "ShortDescr");
}
public async Task CreateAsync(Trigger trigger)
{
using (var cmd = _unitOfWork.CreateDbCommand())
{
cmd.CommandText =
"INSERT INTO Triggers (ApplicationId, Name, Description, Rules, Actions, LastTriggerAction, RunForNewIncidents, RunForExistingIncidents) " +
"VALUES(@ApplicationId, @Name, @Description, @Rules, @Actions, @LastTriggerAction, @RunForNewIncidents, @RunForExistingIncidents)";
cmd.AddParameter("ApplicationId", trigger.ApplicationId);
cmd.AddParameter("Name", trigger.Name);
cmd.AddParameter("Description", trigger.Description);
cmd.AddParameter("Rules", EntitySerializer.Serialize(trigger.Rules));
cmd.AddParameter("Actions", EntitySerializer.Serialize(trigger.Actions));
cmd.AddParameter("LastTriggerAction", trigger.LastTriggerAction);
cmd.AddParameter("RunForNewIncidents", trigger.RunForNewIncidents);
cmd.AddParameter("RunForExistingIncidents", trigger.RunForExistingIncidents);
await cmd.ExecuteNonQueryAsync();
}
}
public void Setup()
{
_provider = A.Fake<IContextProvider>();
_serializer = new EntitySerializer(_provider);
}
public SerializerTestContext()
{
_contextProvider = A.Fake<IContextProvider>();
_frameProvider = A.Fake<IFrameProvider>();
_serializer = new EntitySerializer(_contextProvider, _frameProvider);
}
public void Can_deserialize_expanded_literal()
{
// given
var jsonLd = JObject.Parse(@"
{
'@context': {
'age': {
'@id': 'http://example.com/onto#age'
}
},
'age': {
'@value': '28',
'@type': 'http://www.w3.org/2001/XMLSchema#integer'
}
}");
// when
IEntitySerializer serializer = new EntitySerializer(new StaticContextProvider());
var person = serializer.Deserialize<PersonWithAge>(jsonLd);
// then
Assert.That(person.Age, Is.EqualTo(28));
}
public void Can_serialize_class_instance_to_literal()
{
// given
var entity = new RequestLogItem { Ip = IPAddress.Parse("148.9.20.34") };
var contextProvider = new StaticContextProvider();
var context = JObject.Parse(@"
{
'ip': {
'@id': 'http://rdfs.org/sioc/ns#ip_address'
}
}");
contextProvider.SetContext(typeof(RequestLogItem), context);
// when
IEntitySerializer serializer = new EntitySerializer(contextProvider);
dynamic jsonLd = serializer.Serialize(entity);
// then
Assert.That((string)jsonLd.ip, Is.EqualTo("148.9.20.34"));
}
public void Can_deserialize_class_from_expanded_literal()
{
// given
var jsonLd = JObject.Parse(@"
{
'@context': {
'ip': {
'@id': 'http://rdfs.org/sioc/ns#ip_address'
}
},
'ip': { '@value': '148.9.20.34' }
}");
// when
IEntitySerializer serializer = new EntitySerializer(new StaticContextProvider());
var person = serializer.Deserialize<RequestLogItem>(jsonLd);
// then
Assert.That(person.Ip, Is.EqualTo(IPAddress.Parse("148.9.20.34")));
}
internal EntityDiffData(EntitySerializer serializer, BinaryReader reader)
{
_serializer = serializer;
_reader = reader;
}
public void Can_serialize_object_to_JSON_LD()
{
// given
var person = new Person
{
Id = new Uri("http://t-code.pl/#tomasz"),
Name = "Tomasz",
LastName = "Pluskiewicz"
};
var @context = JObject.Parse("{ '@context': 'http://example.org/context/Person' }");
var contextProvider = new StaticContextProvider();
contextProvider.SetContext(typeof(Person), @context);
// when
IEntitySerializer serializer = new EntitySerializer(contextProvider);
dynamic json = serializer.Serialize(person);
// then
Assert.That((string)json.name, Is.EqualTo("Tomasz"));
Assert.That((string)json.lastName, Is.EqualTo("Pluskiewicz"));
Assert.That((string)json["@id"], Is.EqualTo("http://t-code.pl/#tomasz"));
Assert.That((string)json["@type"][0], Is.EqualTo("http://xmlns.com/foaf/0.1/Person"));
Assert.That(json["@context"], Is.Not.Null);
}
public void Can_deserialize_with_changed_context()
{
// given
var expanded = JObject.Parse(@"
{
'@id': 'http://t-code.pl/#tomasz',
'@type': 'http://xmlns.com/foaf/0.1/Person',
'http://xmlns.com/foaf/0.1/name': 'Tomasz',
'http://xmlns.com/foaf/0.1/familyName': 'Pluskiewicz'
}");
var @context = JObject.Parse(@"
{
'foaf': 'http://xmlns.com/foaf/0.1/',
'name': 'foaf:name',
'lastName': 'foaf:familyName',
'Person': 'foaf:Person'
}");
var contextProvider = new StaticContextProvider();
contextProvider.SetContext(typeof(Person), @context);
// when
IEntitySerializer serializer = new EntitySerializer(contextProvider);
var person = serializer.Deserialize<Person>(expanded);
// then
Assert.That(person.Name, Is.EqualTo("Tomasz"));
Assert.That(person.LastName, Is.EqualTo("Pluskiewicz"));
Assert.That(person.Id, Is.EqualTo(new Uri("http://t-code.pl/#tomasz")));
}
