Please address the comments from this code review:
## Overall Comments
- Consider making the UpdateComputer implementation injectable via NewManager options rather than hardcoding NewLegacy, to improve configurability and facilitate future implementations.
- Since updateComputer is always initialized in NewManager, you can remove the redundant nil checks around m.updateComputer to simplify the code.
- Add an integration test in networkFlowManager to ensure it correctly delegates to the UpdateComputer and maintains equivalent state transitions across ticks.

## Individual Comments

### Comment 1
<location> `sensor/common/networkflow/updatecomputer/update_computer_test.go:154` </location>
<code_context>
+	}
+}
+
+func TestComputeUpdatedEndpoints(t *testing.T) {
+	entity1 := networkgraph.Entity{Type: storage.NetworkEntityInfo_DEPLOYMENT, ID: "deployment-1"}
+
</code_context>

<issue_to_address>
Endpoint update tests lack coverage for state transitions and removals.

Please add tests for endpoints transitioning from open to closed, and for endpoints that are removed from the state, to match the coverage of connection tests and address possible edge cases.
</issue_to_address>

<suggested_fix>
<<<<<<< SEARCH
func TestComputeUpdatedEndpoints(t *testing.T) {
	entity1 := networkgraph.Entity{Type: storage.NetworkEntityInfo_DEPLOYMENT, ID: "deployment-1"}

=======
func TestComputeUpdatedEndpoints(t *testing.T) {
	entity1 := networkgraph.Entity{Type: storage.NetworkEntityInfo_DEPLOYMENT, ID: "deployment-1"}

	// Endpoint transitions from open to closed
	t.Run("endpoint transitions from open to closed", func(t *testing.T) {
		openEndpoint := indicator.Endpoint{
			Entity:    entity1,
			Port:      8080,
			Protocol:  storage.L4Protocol_L4_PROTOCOL_TCP,
			State:     indicator.EndpointStateOpen,
			FirstSeen: timestamp.Now(),
		}
		closedEndpoint := openEndpoint
		closedEndpoint.State = indicator.EndpointStateClosed

		initialState := []*indicator.Endpoint{&openEndpoint}
		currentState := []*indicator.Endpoint{&closedEndpoint}

		computer := NewUpdateComputer()
		computer.UpdateState(nil, initialState, nil)
		updates := computer.ComputeUpdatedEndpoints(currentState)
		assert.Len(t, updates, 1)
		assert.Equal(t, indicator.EndpointStateClosed, updates[0].State)
	})

	// Endpoint removed from state
	t.Run("endpoint removed from state", func(t *testing.T) {
		endpoint := indicator.Endpoint{
			Entity:    entity1,
			Port:      8081,
			Protocol:  storage.L4Protocol_L4_PROTOCOL_TCP,
			State:     indicator.EndpointStateOpen,
			FirstSeen: timestamp.Now(),
		}

		initialState := []*indicator.Endpoint{&endpoint}
		currentState := []*indicator.Endpoint{}

		computer := NewUpdateComputer()
		computer.UpdateState(nil, initialState, nil)
		updates := computer.ComputeUpdatedEndpoints(currentState)
		// Expect an update indicating removal (implementation may vary)
		assert.True(t, len(updates) == 1 || len(updates) == 0, "Should handle endpoint removal gracefully")
	})
>>>>>>> REPLACE

</suggested_fix>

### Comment 2
<location> `sensor/common/networkflow/updatecomputer/update_computer_test.go:205` </location>
<code_context>
+
+// TestComputeUpdatedProcesses relies on exactly the same method as for endpoints.
+// Adding this test despite that to ensure test coverage.
+func TestComputeUpdatedProcesses(t *testing.T) {
+	process1 := indicator.ProcessListening{
+		Process: indicator.ProcessInfo{
</code_context>

<issue_to_address>
Process update tests do not verify feature flag behavior.

Please add a test case with ProcessesListeningOnPort set to false to confirm that no updates are produced when the flag is disabled.
</issue_to_address>