public void Flatten_Returns_ListOfTwoItems()
{
var flattener = new JsonFlattener();
var items = new List <Person>
{
new Person("John", 18, DateTime.Now.AddYears(-18)),
new Person("Lisa", 18, DateTime.Now.AddYears(-18).AddDays(1)),
new Person("Barbara", 18, DateTime.Now.AddYears(-18).AddDays(-1)),
new Person("Peter", 18, DateTime.Now.AddYears(-18).AddMinutes(5)),
new Person("Carl", 23, DateTime.Now.AddYears(-23))
};
var result = flattener.Flatten(JsonSerializer.Serialize(items));
//Assert.Equal(5, result?.Count);
//Assert.Equal("John", result?[0]["Name"]);
//Assert.Equal("18", result?[0]["Age"]);
//Assert.Equal(NullValue, result?[0]["MyAddress"]);
//Assert.Equal("[\"Red\",\"Blue\"]", result?[0]["Colours"]);
Assert.Equal("John", result?[0].Name);
Assert.Equal("18", result?[0].Age);
Assert.Equal(NullValue, result?[0].MyAddress);
Assert.Equal("[\"Red\",\"Blue\"]", result?[0].Colours);
}
public GrainsRefreshed(KatalyeContext context, IBackgroundJobClient jobClient, JsonFlattener jsonFlattener, IMediator mediator)
{
_context = context;
_jobClient = jobClient;
_jsonFlattener = jsonFlattener;
_mediator = mediator;
}
public void Flatten_Returns_Exception_NoJson()
{
var flattener = new JsonFlattener();
var exception = Assert.ThrowsAny <Exception>(() => flattener.Flatten(""));
Assert.Contains("The input does not contain any JSON tokens", exception.Message);
}
public void Fact2()
{
var data = JObject.Parse(File.ReadAllText(@"jsonStructure1.json"));
var flattened = JsonFlattener.Flatten(data);
var unflattened = JsonFlattener.Unflatten(flattened);
Assert.True(JToken.DeepEquals(data, unflattened));
}
public void Fact4()
{
var data = JObject.Parse(File.ReadAllText(@"jsonStructure1.json"));
var flattened = JsonFlattener.Flatten(data);
var unflattened = JsonFlattener.Unflatten(flattened);
_outputHelper.WriteLine(unflattened.ToString());
}
public void Fact3()
{
var data = JObject.Parse(File.ReadAllText(@"jsonStructure1.json"));
var flattened = JsonFlattener.Flatten(data);
foreach (var key in flattened.Keys)
{
_outputHelper.WriteLine($"{key}, {flattened[key]}");
}
}
public void Supports_empty_arrays()
{
var flattener = new JsonFlattener();
var fixture = JsonConvert.DeserializeObject <JToken>(GrainFixture);
// Act
var result = flattener.Flatten(fixture);
// Assert
result.Should().NotContainKey("SSDs");
}
public void GetFlattenedJsonKeyValuePair_GivenValidJsonString_ShouldReturnKeyValuePairObject()
{
// Arrange
var sampleData = "{ }";
// Act
var result = JsonFlattener.GetFlattenedJsonKeyValuePair(sampleData);
// Assert
Assert.NotNull(result);
Assert.Empty(result);
}
public void Supports_numbers()
{
var flattener = new JsonFlattener();
var fixture = JsonConvert.DeserializeObject <JToken>(GrainFixture);
// Act
var result = flattener.Flatten(fixture);
// Assert
result.Should().ContainKey("uid")
.WhichValue.Should().ContainSingle(x => x == 0.ToString());
}
public void Supports_arrays()
{
var flattener = new JsonFlattener();
var fixture = JsonConvert.DeserializeObject <JToken>(GrainFixture);
// Act
var result = flattener.Flatten(fixture);
// Assert
result.Should().ContainKey("pythonpath")
.WhichValue.Should().ContainSingle(x => x == "/usr/bin");
}
public void Supports_nesting()
{
var flattener = new JsonFlattener();
var fixture = JsonConvert.DeserializeObject <JToken>(GrainFixture);
// Act
var result = flattener.Flatten(fixture);
// Assert
result.Should().ContainKey("ip_interfaces.br-950befb17084")
.WhichValue.Should().HaveCount(2)
.And.Subject.Should().Contain(x => x == "172.18.0.1");
}
public void FlattenTest()
{
using var doc = JsonDocument.Parse(@"
{
""application"": ""hiking"",
""reputons"": [
{
""rater"": ""HikingAsylum"",
""assertion"": ""advanced"",
""rated"": ""Marilyn C"",
""rating"": 0.90
},
{
""rater"": ""HikingAsylum"",
""assertion"": ""intermediate"",
""rated"": ""Hongmin"",
""rating"": 0.75
}
]
}
");
using var expected = JsonDocument.Parse(@"
{
""/application"": ""hiking"",
""/reputons/0/rater"": ""HikingAsylum"",
""/reputons/0/assertion"": ""advanced"",
""/reputons/0/rated"": ""Marilyn C"",
""/reputons/0/rating"": 0.90,
""/reputons/1/rater"": ""HikingAsylum"",
""/reputons/1/assertion"": ""intermediate"",
""/reputons/1/rated"": ""Hongmin"",
""/reputons/1/rating"": 0.75
}
");
JsonDocument flattenedDoc = JsonFlattener.Flatten(doc.RootElement);
Assert.IsTrue(JsonElementEqualityComparer.Instance.Equals(flattenedDoc.RootElement, expected.RootElement));
using JsonDocument unflattenedDoc = JsonFlattener.Unflatten(flattenedDoc.RootElement);
var options = new JsonSerializerOptions()
{
WriteIndented = true
};
Assert.IsTrue(JsonElementEqualityComparer.Instance.Equals(unflattenedDoc.RootElement, doc.RootElement));
}
public void GetFlattenedJsonKeyValuePair_GivenValidJObject_ShouldReturnFlattenedJson()
{
// Arrange
var sampleData = JObject.Parse(GetSimpleSampleJson());
// Act
var result = JsonFlattener.GetFlattenedJsonKeyValuePair(sampleData).ToList();
// Assert
Assert.NotEmpty(result);
Assert.Equal("firstName", result[0].Key);
Assert.Equal("John", result[0].Value.ToString());
Assert.Equal("age", result[3].Key);
Assert.Equal(25, int.Parse(result[3].Value.ToString()));
}
public void FlattenObjectTest()
{
// Perform the flatten on test input 1 (this is given already in object form)
var testResults = JsonFlattener.Flatten(TestData.Input1);
var expectedResults = TestData.Output1;
// Are all result groups equal to the expected groups?
for (int i = 0; i < testResults.Count; i++)
{
var testResult = testResults[i];
var expectedResult = expectedResults[i];
Assert.IsTrue(testResult.RecursivelyEquals(expectedResult));
}
}
public async Task <ResultContainer> Upload(string path)
{
FileLoader fl = new FileLoader();
var json = fl.Get(path);
JsonFlattener jf = new JsonFlattener();
var dataList = jf.Flatten(json);
ParameterUploadClient puc = new ParameterUploadClient(dataList);
await puc.Upload();
ResultContainer result = puc.GetResults();
return(result);
}
public void Fact1()
{
var data = JObject.Parse(File.ReadAllText(@"jsonStructure1.json"));
var flattened = JsonFlattener.Flatten(data);
Assert.True(flattened.ContainsKey("firstName"));
Assert.True(flattened.ContainsKey("lastName"));
Assert.True(flattened.ContainsKey("address.street"));
Assert.True(flattened.ContainsKey("address.city"));
Assert.True(flattened.ContainsKey("address.state"));
Assert.True(flattened.ContainsKey("address.phone[0].mobile"));
Assert.True(flattened.ContainsKey("address.phone[0].home"));
Assert.True(flattened.ContainsKey("address.phone[0].work"));
Assert.True(flattened.ContainsKey("address.phone[1].mobile"));
Assert.True(flattened.ContainsKey("address.phone[1].home"));
Assert.True(flattened.ContainsKey("address.phone[1].work"));
}
static void FlattenAndUnflatten()
{
using var doc = JsonDocument.Parse(@"
{
""application"": ""hiking"",
""reputons"": [
{
""rater"": ""HikingAsylum"",
""assertion"": ""advanced"",
""rated"": ""Marilyn C"",
""rating"": 0.90
},
{
""rater"": ""HikingAsylum"",
""assertion"": ""intermediate"",
""rated"": ""Hongmin"",
""rating"": 0.75
}
]
}
");
using JsonDocument flattened = JsonFlattener.Flatten(doc.RootElement);
var options = new JsonSerializerOptions()
{
WriteIndented = true
};
Console.WriteLine($"{JsonSerializer.Serialize(flattened, options)}\n");
using JsonDocument unflattened = JsonFlattener.Unflatten(flattened.RootElement);
var comparer = JsonElementEqualityComparer.Instance;
Debug.Assert(comparer.Equals(unflattened.RootElement, doc.RootElement));
}
public void GetFlattenedTreeBundle_GivenValidJsonString_ShouldReturnFlattenedBundle()
{
// Arrange
var sampleData = GetSimpleSampleJson();
// Arrange
var result = JsonFlattener.GetFlattenedTreeBundle(sampleData).ToList();
// Act
Assert.NotNull(result);
Assert.Equal(15, result.Count);
Assert.Equal("firstName", result[0].FullPath);
Assert.Equal("firstName", result[0].Item);
Assert.Equal("John", result[0].Value);
Assert.Equal(string.Empty, result[0].Parent);
Assert.Equal("address", result[4].Parent);
Assert.Equal("address.streetAddress", result[4].FullPath);
Assert.Equal("streetAddress", result[4].Item);
Assert.Equal("21 2nd Street", result[4].Value);
Assert.Equal("phoneNumbers[0]", result[8].Parent);
Assert.Equal("phoneNumbers[0].type", result[8].FullPath);
Assert.Equal("type", result[8].Item);
Assert.Equal("home", result[8].Value);
}
static void UnflattenAssumingObject()
{
using var doc = JsonDocument.Parse(@"
{
""discards"": {
""1000"": ""Record does not exist"",
""1004"": ""Queue limit exceeded"",
""1010"": ""Discarding timed-out partial msg""
},
""warnings"": {
""0"": ""Phone number missing country code"",
""1"": ""State code missing"",
""2"": ""Zip code missing""
}
}
");
var options = new JsonSerializerOptions()
{
WriteIndented = true
};
using JsonDocument flattened = JsonFlattener.Flatten(doc.RootElement);
Console.WriteLine("The flattened document:\n");
Console.WriteLine($"{JsonSerializer.Serialize(flattened, options)}\n");
Console.WriteLine("Unflatten integer tokens as array indices if possible:\n");
using JsonDocument unflattened1 = JsonFlattener.Unflatten(flattened.RootElement,
IntegerTokenUnflattening.TryIndex);
Console.WriteLine($"{JsonSerializer.Serialize(unflattened1, options)}\n");
Console.WriteLine("Always unflatten integer tokens as object names:\n");
using JsonDocument unflattened2 = JsonFlattener.Unflatten(flattened.RootElement,
IntegerTokenUnflattening.AssumeName);
Console.WriteLine($"{JsonSerializer.Serialize(unflattened2, options)}\n");
}
public void FlattenFileTest()
{
// Perform the flatten on test input file
var testInput = JsonFlattener.LoadJson(".\\testdata\\input2.json");
var testResults = JsonFlattener.Flatten(testInput);
// Load the expected output from file
List <Group> expectedResults = null;
using (StreamReader r = new StreamReader(".\\testdata\\output2.json"))
{
expectedResults = JsonConvert.DeserializeObject <List <Group> >(r.ReadToEnd());
}
Assert.IsNotNull(expectedResults);
// Are all result groups equal to the expected groups?
for (int i = 0; i < testResults.Count; i++)
{
var testResult = testResults[i];
var expectedResult = expectedResults[i];
Assert.IsTrue(testResult.RecursivelyEquals(expectedResult));
}
}
public void Flatten_Returns_ArgumentNullException()
{
var flattener = new JsonFlattener();
Assert.Throws <ArgumentNullException>(() => flattener.Flatten(null));
}
public void Setup()
{
FileLoader = new FileLoader();
JsonFlattener = new JsonFlattener();
}
public JObject Unflatten()
{
return(JsonFlattener.UnflattenJObject(Dictionary));
}
public FlatJsonObject(JObject jsonObject, string prefix = "")
{
Dictionary = JsonFlattener.FlattenJObject(jsonObject, prefix);
}
