public InputData(Guid diff, InputPosition position, string data)
{
DiffId = diff;
Position = position;
Data = data;
Timestamp = DateTime.UtcNow;
}
public static AnyValue Convert(IEnumerable <Notification> notifications)
{
IList <AnyValue> @out = new List <AnyValue>();
foreach (Notification notification in notifications)
{
InputPosition pos = notification.Position; // position is optional
bool includePosition = !pos.Equals(InputPosition.empty);
int size = includePosition ? 5 : 4;
MapValueBuilder builder = new MapValueBuilder(size);
builder.Add("code", stringValue(notification.Code));
builder.Add("title", stringValue(notification.Title));
builder.Add("description", stringValue(notification.Description));
builder.Add("severity", stringValue(notification.Severity.ToString()));
if (includePosition)
{
// only add the position if it is not empty
builder.Add("position", VirtualValues.map(new string[] { "offset", "line", "column" }, new AnyValue[] { intValue(pos.Offset), intValue(pos.Line), intValue(pos.Column) }));
}
@out.Add(builder.Build());
}
return(VirtualValues.fromList(@out));
}
/// <summary>
/// Gets the hash code
/// </summary>
/// <returns>Hash code</returns>
public override int GetHashCode()
{
unchecked // Overflow is fine, just wrap
{
var hashCode = 41;
// Suitable nullity checks etc, of course :)
if (Id != null)
{
hashCode = hashCode * 59 + Id.GetHashCode();
}
if (Name != null)
{
hashCode = hashCode * 59 + Name.GetHashCode();
}
if (InputPosition != null)
{
hashCode = hashCode * 59 + InputPosition.GetHashCode();
}
if (OutputPosition != null)
{
hashCode = hashCode * 59 + OutputPosition.GetHashCode();
}
if (Zone != null)
{
hashCode = hashCode * 59 + Zone.GetHashCode();
}
return(hashCode);
}
}
private void AssertInputCreatedOnPosition(
IActionResult response,
Guid expectedDiffId,
string data,
InputPosition expectedPosition,
Mock <IInputRepository> inputRepository
)
{
// AssertAssert
var createdResult = Assert.IsType <CreatedResult>(response);
var result = Assert.IsType <InputViewModel>(createdResult.Value);
Assert.NotNull(result);
Assert.Equal(expectedDiffId, result.DiffId);
Assert.Equal(Enum.GetName(typeof(InputPosition), expectedPosition), result.Position);
inputRepository.Verify(v =>
v.AddOneAsync(
It.Is <InputData>(i =>
i.DiffId == expectedDiffId &&
i.Data == data
)
)
);
}
public void RemoveUpListener(InputPosition toRemove)
{
if (_upListeners == null)
{
return;
}
_upListeners -= toRemove;
}
public TestNotification(string code, string title, string description, SeverityLevel severityLevel, InputPosition position)
{
this._code = code;
this._title = title;
this._description = description;
this._severityLevel = severityLevel;
this._position = position != null ? position : InputPosition.empty;
}
public void RemoveDoubleTapListener(InputPosition toRemove)
{
if (_doubleTapListeners == null)
{
return;
}
_doubleTapListeners -= toRemove;
}
public void RemoveDragListener(IDragListener listener)
{
if(_dragStartListeners != null)
_dragStartListeners -= listener.OnDragStart;
if(_dragUpdateListeners != null)
_dragUpdateListeners -= listener.OnDragUpdate;
if (_dragEndListeners != null)
_dragEndListeners -= listener.OnDragEnd;
}
public void GetOpposingPosition_returns_expected_opposing_position_for_given_position(
InputPosition position,
InputPosition expectedOpposingPosition
)
{
var result = _logic.GetOpposingPosition(position);
Assert.Equal(result, expectedOpposingPosition);
}
internal InputGroup(object inputIds, InputPosition position, object width, object height, int?rows, int?columns, string layer)
{
InputIds = inputIds;
Position = position;
Width = width;
Height = height;
Rows = rows;
Columns = columns;
Layer = layer;
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldNotifyWhenUsingCreateUniqueWhenCypherVersionIs3_5()
public virtual void ShouldNotifyWhenUsingCreateUniqueWhenCypherVersionIs3_5()
{
// when
Result result = Db().execute("CYPHER 3.5 MATCH (b) WITH b LIMIT 1 CREATE UNIQUE (b)-[:REL]->()");
InputPosition position = new InputPosition(36, 1, 37);
// then
assertThat(result.Notifications, ContainsItem(_deprecatedCreateUnique));
result.Close();
}
public Task <InputData> GetLastInputBeforeAsync(Guid diffId, InputPosition position, DateTime timestamp)
{
return(collection
.Find(input =>
input.DiffId == diffId &&
input.Position == position &&
input.Timestamp <= timestamp
)
.SortByDescending(input => input.Timestamp)
.FirstOrDefaultAsync());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldNotifyWhenUsingCreateUniqueWhenCypherVersionIsDefault()
public virtual void ShouldNotifyWhenUsingCreateUniqueWhenCypherVersionIsDefault()
{
// when
Result result = Db().execute("EXPLAIN MATCH (b) WITH b LIMIT 1 CREATE UNIQUE (b)-[:REL]->()");
InputPosition position = new InputPosition(33, 1, 34);
// then
assertThat(result.Notifications, ContainsNotification(CREATE_UNIQUE_UNAVAILABLE_FALLBACK.notification(position)));
IDictionary <string, object> arguments = result.ExecutionPlanDescription.Arguments;
assertThat(arguments["version"], equalTo("CYPHER 3.1"));
result.Close();
}
internal virtual void ShouldNotifyInStream(string version, string query, InputPosition pos, NotificationCode code)
{
//when
Result result = Db().execute(version + query);
//then
NotificationCode.Notification notification = code.notification(pos);
assertThat(Iterables.asList(result.Notifications), Matchers.hasItems(notification));
IDictionary <string, object> arguments = result.ExecutionPlanDescription.Arguments;
assertThat(arguments["version"], equalTo(version));
result.Close();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldNotifyWhenUsingCypher3_1ForTheRulePlannerWhenCypherVersionIsTheDefault()
public virtual void ShouldNotifyWhenUsingCypher3_1ForTheRulePlannerWhenCypherVersionIsTheDefault()
{
// when
Result result = Db().execute("CYPHER planner=rule RETURN 1");
InputPosition position = InputPosition.empty;
// then
assertThat(result.Notifications, ContainsItem(RulePlannerUnavailable));
IDictionary <string, object> arguments = result.ExecutionPlanDescription.Arguments;
assertThat(arguments["version"], equalTo("CYPHER 3.1"));
assertThat(arguments["planner"], equalTo("RULE"));
result.Close();
}
private static INotification CollectNotification(IDictionary <string, object> notificationDict)
{
var code = notificationDict.GetValue("code", string.Empty);
var title = notificationDict.GetValue("title", string.Empty);
var description = notificationDict.GetValue("description", string.Empty);
var posValue = notificationDict.GetValue("position", new Dictionary <string, object>());
var position = new InputPosition(
(int)posValue.GetValue("offset", 0L),
(int)posValue.GetValue("line", 0L),
(int)posValue.GetValue("column", 0L));
var severity = notificationDict.GetValue("severity", string.Empty);
return(new Notification(code, title, description, position, severity));
}
private static object[] NewExpectedResult(
string inputData,
string opposingData,
ResultType expectedResult,
IDictionary <int, int> expectedDifferences = null,
InputPosition inputPosition = InputPosition.Left,
InputPosition opposingPosition = InputPosition.Right
)
=> new object[]
{
new InputData(inputPosition, inputData),
new InputData(opposingPosition, opposingData),
new DiffResult(expectedResult, expectedDifferences)
};
public void CompareData_returns_expected_result_no_matter_input_position(
InputPosition largerInputPosition,
InputPosition smallerInputPosition,
ResultType expectedResult)
{
var input = new InputData()
{
Data = "aaa", Position = largerInputPosition
};
var opposingInput = new InputData {
Data = "a", Position = smallerInputPosition
};
var result = _logic.CompareData(input, opposingInput);
Assert.Equal(result.Result, expectedResult);
}
public void Handle_consider_input_larger_if_no_opposing_input_found(InputPosition position, ResultType expectedResultType)
{
// Arrange
var input = new InputData(position, "test");
var expectedResult = new DiffResult(expectedResultType, null);
var resultEvent = new NewResultIntegrationEvent(input, string.Empty, expectedResult);
var newInputEvent = new NewInputIntegrationEvent()
{
Position = input.Position
};
var eventBus = new Mock <IRabbitMQEventBus>();
var logic = new Mock <IDiffLogic>();
logic.Setup(s => s.CompareData(It.IsAny <InputData>(), It.IsAny <InputData>()))
.Returns(expectedResult);
var repository = new Mock <IInputRepository>();
repository
.Setup(s => s.FindAsync(It.IsAny <string>()))
.ReturnsAsync(() => input);
repository
.Setup(s => s.GetLastInputBeforeAsync(It.IsAny <Guid>(), It.IsAny <InputPosition>(), It.IsAny <DateTime>()))
.ReturnsAsync(() => null);
var handler = GetHandler(
eventBus: eventBus,
repository: repository,
logic: logic.Object
);
// Act
handler.Handle(newInputEvent);
// Assert
eventBus.Verify(
eb => eb.Publish(
It.Is <NewResultIntegrationEvent>(e => e.Result == expectedResult.Result)
)
);
}
private void AssertNewInputIntegrationEventPublished(
IActionResult response,
Guid expectedDiffId,
InputPosition expectedPosition,
Mock <IRabbitMQEventBus> eventBus
)
{
var createdResult = Assert.IsType <CreatedResult>(response);
var result = Assert.IsType <InputViewModel>(createdResult.Value);
eventBus.Verify(eb =>
eb.Publish(It.Is <NewInputIntegrationEvent>(ie =>
ie.DiffId == expectedDiffId.ToString() &&
ie.Position == expectedPosition &&
ie.InputId == result.Id &&
ie.Timestamp == result.Timestamp
))
);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("unchecked") public static org.neo4j.graphdb.Notification fromMap(java.util.Map<String,Object> notification)
public static Notification FromMap(IDictionary <string, object> notification)
{
assertThat(notification, hasKey("code"));
assertThat(notification, hasKey("title"));
assertThat(notification, hasKey("description"));
assertThat(notification, hasKey("severity"));
InputPosition position = null;
if (notification.ContainsKey("position"))
{
IDictionary <string, long> pos = (IDictionary <string, long>)notification["position"];
assertThat(pos, hasKey("offset"));
assertThat(pos, hasKey("line"));
assertThat(pos, hasKey("column"));
position = new InputPosition(pos["offset"].intValue(), pos["line"].intValue(), pos["column"].intValue());
}
return(new TestNotification(( string )notification["code"], ( string )notification["title"], ( string )notification["description"], Enum.Parse(typeof(SeverityLevel), ( string )notification["severity"]), position));
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void writePosition(org.neo4j.graphdb.InputPosition position) throws java.io.IOException
private void WritePosition(InputPosition position)
{
//do not add position if empty
if (position == InputPosition.empty)
{
return;
}
@out.writeObjectFieldStart("position");
try
{
@out.writeNumberField("offset", position.Offset);
@out.writeNumberField("line", position.Line);
@out.writeNumberField("column", position.Column);
}
finally
{
@out.writeEndObject();
}
}
/// <summary>
/// Returns true if TemperatureZone instances are equal
/// </summary>
/// <param name="other">Instance of TemperatureZone to be compared</param>
/// <returns>Boolean</returns>
public bool Equals(TemperatureZone other)
{
if (ReferenceEquals(null, other))
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return
((
Id == other.Id ||
Id != null &&
Id.Equals(other.Id)
) &&
(
Name == other.Name ||
Name != null &&
Name.Equals(other.Name)
) &&
(
InputPosition == other.InputPosition ||
InputPosition != null &&
InputPosition.Equals(other.InputPosition)
) &&
(
OutputPosition == other.OutputPosition ||
OutputPosition != null &&
OutputPosition.Equals(other.OutputPosition)
) &&
(
Zone == other.Zone ||
Zone != null &&
Zone.Equals(other.Zone)
));
}
public override bool Equals(object o)
{
if (this == o)
{
return(true);
}
if (o == null || this.GetType() != o.GetType())
{
return(false);
}
InputPosition that = ( InputPosition )o;
if (_offset != that._offset)
{
return(false);
}
if (_line != that._line)
{
return(false);
}
return(_column == that._column);
}
public InputData(InputPosition position, string data)
{
Position = position;
Data = data;
}
public void AddDragListener(IDragListener listener)
{
_dragStartListeners += listener.OnDragStart;
_dragUpdateListeners += listener.OnDragUpdate;
_dragEndListeners += listener.OnDragEnd;
}
internal static InputGroup DeserializeInputGroup(JsonElement element)
{
object inputIds = default;
Optional <InputPosition> position = default;
Optional <object> width = default;
Optional <object> height = default;
Optional <int> rows = default;
Optional <int> columns = default;
Optional <string> layer = default;
foreach (var property in element.EnumerateObject())
{
if (property.NameEquals("inputIds"))
{
inputIds = property.Value.GetObject();
continue;
}
if (property.NameEquals("position"))
{
if (property.Value.ValueKind == JsonValueKind.Null)
{
property.ThrowNonNullablePropertyIsNull();
continue;
}
position = InputPosition.DeserializeInputPosition(property.Value);
continue;
}
if (property.NameEquals("width"))
{
if (property.Value.ValueKind == JsonValueKind.Null)
{
property.ThrowNonNullablePropertyIsNull();
continue;
}
width = property.Value.GetObject();
continue;
}
if (property.NameEquals("height"))
{
if (property.Value.ValueKind == JsonValueKind.Null)
{
property.ThrowNonNullablePropertyIsNull();
continue;
}
height = property.Value.GetObject();
continue;
}
if (property.NameEquals("rows"))
{
if (property.Value.ValueKind == JsonValueKind.Null)
{
property.ThrowNonNullablePropertyIsNull();
continue;
}
rows = property.Value.GetInt32();
continue;
}
if (property.NameEquals("columns"))
{
if (property.Value.ValueKind == JsonValueKind.Null)
{
property.ThrowNonNullablePropertyIsNull();
continue;
}
columns = property.Value.GetInt32();
continue;
}
if (property.NameEquals("layer"))
{
layer = property.Value.GetString();
continue;
}
}
return(new InputGroup(inputIds, position.Value, width.Value, height.Value, Optional.ToNullable(rows), Optional.ToNullable(columns), layer.Value));
}
public override int GetHashCode() => Production.GetHashCode() + DotPosition.GetHashCode() * 17 + InputPosition.GetHashCode() * 31;
private async Task <IActionResult> HandlePostInputRequest(Guid diffId, NewInputViewModel input, InputPosition position)
{
if (!ModelState.IsValid)
{
_logger.LogWarning($"Post{Enum.GetName(typeof(InputPosition), position)}({diffId}) failed validation");
return(BadRequest(ModelState));
}
_logger.LogInformation($"Find({diffId}): retrieving item on repository");
var diff = await _diffRepository.FindAsync(_ => _.UUID == diffId);
if (diff == null)
{
_logger.LogWarning($"Find({diffId}): item not found on repository");
return(NotFound(new ResourceNotFoundForIdResultMessage <Diff>(diffId)));
}
var newInput = new InputData(diffId, position, input.Data);
_logger.LogInformation($"Save({diffId}, Diff obj): saving item on repository");
await _inputRepository.AddOneAsync(newInput);
_logger.LogInformation($"Save({diffId}, Diff obj): saving item on repository");
var eventMessage = new NewInputIntegrationEvent(newInput);
_logger.LogInformation($"Input registered, sending integration event ({eventMessage.Id})");
_eventBus.Publish(eventMessage);
_logger.LogInformation($"Integration event ({eventMessage.Id}) sent!");
var viewModel = _mapper.Map <InputViewModel>(newInput);
return(Created(newInput.Id, viewModel));
}
private async Task AssertInputCreatedOnDiffPosition(HttpResponseMessage response, Guid diffId, InputPosition position)
{
var strInputContent = await response.Content.ReadAsStringAsync();
var inputResult = JsonConvert.DeserializeObject <InputViewModel>(strInputContent);
// Assert
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
Assert.NotNull(inputResult);
Assert.Equal(diffId, inputResult.DiffId);
Assert.Equal(Enum.GetName(typeof(InputPosition), position), inputResult.Position);
Assert.NotEqual(default(DateTime), inputResult.Timestamp);
}
