defmodule CClientWriteAttrTest do use ExUnit.Case, async: false doctest Opex62541 alias OpcUA.{NodeId, Server, QualifiedName} setup do {:ok, s_pid} = Server.start_link() :ok = Server.set_default_config(s_pid) {:ok, ns_index} = Server.add_namespace(s_pid, "Room") # Object Type Node requested_new_node_id = NodeId.new(ns_index: 1, identifier_type: "integer", identifier: 10000) parent_node_id = NodeId.new(ns_index: 0, identifier_type: "integer", identifier: 58) reference_type_node_id = NodeId.new(ns_index: 0, identifier_type: "integer", identifier: 45) browse_name = QualifiedName.new(ns_index: 1, name: "Obj") :ok = Server.add_object_type_node(s_pid, requested_new_node_id: requested_new_node_id, parent_node_id: parent_node_id, reference_type_node_id: reference_type_node_id, browse_name: browse_name ) :ok = Server.write_node_write_mask(s_pid, requested_new_node_id, 0x3FFFFF) # Object Node requested_new_node_id = NodeId.new(ns_index: 1, identifier_type: "integer", identifier: 10002) parent_node_id = NodeId.new(ns_index: 0, identifier_type: "integer", identifier: 85) reference_type_node_id = NodeId.new(ns_index: 0, identifier_type: "integer", identifier: 35) browse_name = QualifiedName.new(ns_index: 1, name: "Test1") type_definition = NodeId.new(ns_index: 0, identifier_type: "integer", identifier: 58) :ok = Server.add_object_node(s_pid, requested_new_node_id: requested_new_node_id, parent_node_id: parent_node_id, reference_type_node_id: reference_type_node_id, browse_name: browse_name, type_definition: type_definition ) requested_new_node_id = NodeId.new(ns_index: ns_index, identifier_type: "string", identifier: "R1_TS1_Sensor") parent_node_id = NodeId.new(ns_index: 0, identifier_type: "integer", identifier: 85) reference_type_node_id = NodeId.new(ns_index: 0, identifier_type: "integer", identifier: 35) browse_name = QualifiedName.new(ns_index: ns_index, name: "Temperature sensor") type_definition = NodeId.new(ns_index: 0, identifier_type: "integer", identifier: 58) :ok = Server.add_object_node(s_pid, requested_new_node_id: requested_new_node_id, parent_node_id: parent_node_id, reference_type_node_id: reference_type_node_id, browse_name: browse_name, type_definition: type_definition ) # Variable Node requested_new_node_id = NodeId.new(ns_index: 1, identifier_type: "integer", identifier: 10001) parent_node_id = NodeId.new(ns_index: 1, identifier_type: "integer", identifier: 10002) reference_type_node_id = NodeId.new(ns_index: 0, identifier_type: "integer", identifier: 47) browse_name = QualifiedName.new(ns_index: 1, name: "Var") type_definition = NodeId.new(ns_index: 0, identifier_type: "integer", identifier: 63) :ok = Server.add_variable_node(s_pid, requested_new_node_id: requested_new_node_id, parent_node_id: parent_node_id, reference_type_node_id: reference_type_node_id, browse_name: browse_name, type_definition: type_definition ) :ok = Server.write_node_write_mask(s_pid, requested_new_node_id, 0x3FFFFF) :ok = Server.write_node_access_level(s_pid, requested_new_node_id, 3) requested_new_node_id = NodeId.new(ns_index: ns_index, identifier_type: "string", identifier: "R1_TS1_Temperature") parent_node_id = NodeId.new(ns_index: ns_index, identifier_type: "string", identifier: "R1_TS1_Sensor") reference_type_node_id = NodeId.new(ns_index: 0, identifier_type: "integer", identifier: 47) browse_name = QualifiedName.new(ns_index: ns_index, name: "Temperature") type_definition = NodeId.new(ns_index: 0, identifier_type: "integer", identifier: 63) :ok = Server.add_variable_node(s_pid, requested_new_node_id: requested_new_node_id, parent_node_id: parent_node_id, reference_type_node_id: reference_type_node_id, browse_name: browse_name, type_definition: type_definition ) # CurrentWrite, CurrentRead :ok = Server.write_node_access_level(s_pid, requested_new_node_id, 3) :ok = Server.start(s_pid) # {:ok, c_pid} = Client.start_link() # state = :sys.get_state(c_pid) # :ok = Client.set_config(c_pid) # url = "opc.tcp://localhost:4840/" # :ok = Client.connect_by_url(c_pid, url: url) executable = :code.priv_dir(:opex62541) ++ '/opc_ua_client' port = Port.open({:spawn_executable, executable}, [ {:args, []}, {:packet, 2}, :use_stdio, :binary, :exit_status ]) %{port: port, ns_index: ns_index} end test "Write and Read Attribute Value", %{port: port, ns_index: ns_index} do msg = {:set_client_config, %{}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) _c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end msg = {:connect_client_by_url, "opc.tcp://localhost:4840/"} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) _c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end msg = {:write_node_value, {{1, ns_index, "R1_TS1_Temperature"}, 0, true}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == :ok msg = {:read_node_value, {1, ns_index, "R1_TS1_Temperature"}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == {:ok, true} msg = {:write_node_value, {{1, ns_index, "R1_TS1_Temperature"}, 1, 21}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == :ok msg = {:read_node_value, {1, ns_index, "R1_TS1_Temperature"}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == {:ok, 21} msg = {:write_node_value, {{1, ns_index, "R1_TS1_Temperature"}, 2, 22}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == :ok msg = {:read_node_value, {1, ns_index, "R1_TS1_Temperature"}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == {:ok, 22} msg = {:write_node_value, {{1, ns_index, "R1_TS1_Temperature"}, 3, 23}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == :ok msg = {:read_node_value, {1, ns_index, "R1_TS1_Temperature"}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == {:ok, 23} msg = {:write_node_value, {{1, ns_index, "R1_TS1_Temperature"}, 4, 24}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == :ok msg = {:read_node_value, {1, ns_index, "R1_TS1_Temperature"}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == {:ok, 24} msg = {:write_node_value, {{1, ns_index, "R1_TS1_Temperature"}, 5, 25}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == :ok msg = {:read_node_value, {1, ns_index, "R1_TS1_Temperature"}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == {:ok, 25} msg = {:write_node_value, {{1, ns_index, "R1_TS1_Temperature"}, 6, 26}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == :ok msg = {:read_node_value, {1, ns_index, "R1_TS1_Temperature"}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == {:ok, 26} msg = {:write_node_value, {{1, ns_index, "R1_TS1_Temperature"}, 7, 27}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == :ok msg = {:read_node_value, {1, ns_index, "R1_TS1_Temperature"}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == {:ok, 27} msg = {:write_node_value, {{1, ns_index, "R1_TS1_Temperature"}, 8, 28}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == :ok msg = {:read_node_value, {1, ns_index, "R1_TS1_Temperature"}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == {:ok, 28} msg = {:write_node_value, {{1, ns_index, "R1_TS1_Temperature"}, 9, 21.5}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == :ok msg = {:read_node_value, {1, ns_index, "R1_TS1_Temperature"}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == {:ok, 21.5} msg = {:write_node_value, {{1, ns_index, "R1_TS1_Temperature"}, 10, 22.5}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == :ok msg = {:read_node_value, {1, ns_index, "R1_TS1_Temperature"}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == {:ok, 22.5} msg = {:write_node_value, {{1, ns_index, "R1_TS1_Temperature"}, 11, "Hola"}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == :ok msg = {:read_node_value, {1, ns_index, "R1_TS1_Temperature"}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == {:ok, "Hola"} msg = {:write_node_value, {{1, ns_index, "R1_TS1_Temperature"}, 12, 132304152032503440}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == :ok msg = {:read_node_value, {1, ns_index, "R1_TS1_Temperature"}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == {:ok, 132304152032503440} msg = {:write_node_value, {{1, ns_index, "R1_TS1_Temperature"}, 13, {103,103,103, "holahola"}}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == :ok msg = {:read_node_value, {1, ns_index, "R1_TS1_Temperature"}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == {:ok, {103,103,103, "holahola"}} msg = {:write_node_value, {{1, ns_index, "R1_TS1_Temperature"}, 14, "holahola"}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == :ok msg = {:read_node_value, {1, ns_index, "R1_TS1_Temperature"}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == {:ok, "holahola"} xml = "\nTove\nJani\nReminder\nDon't forget me this weekend!\n\n" msg = {:write_node_value, {{1, ns_index, "R1_TS1_Temperature"}, 15, xml}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == :ok msg = {:read_node_value, {1, ns_index, "R1_TS1_Temperature"}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == {:ok, xml} msg = {:write_node_value, {{1, ns_index, "R1_TS1_Temperature"}, 16, {1, ns_index, "R1_TS1_Temperature"}}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == :ok msg = {:read_node_value, {1, ns_index, "R1_TS1_Temperature"}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == {:ok, {2, "string", "R1_TS1_Temperature"}} msg = {:write_node_value, {{1, ns_index, "R1_TS1_Temperature"}, 17, {1, ns_index, "R1_TS1_Temperature"}}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == :ok msg = {:read_node_value, {1, ns_index, "R1_TS1_Temperature"}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == {:ok, {2, "string", "R1_TS1_Temperature", "", 0}} msg = {:write_node_value, {{1, ns_index, "R1_TS1_Temperature"}, 18, 0}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == :ok msg = {:read_node_value, {1, ns_index, "R1_TS1_Temperature"}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == {:ok, "Good"} msg = {:write_node_value, {{1, ns_index, "R1_TS1_Temperature"}, 19, {ns_index, "TEMMPERATURE"}}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == :ok msg = {:read_node_value, {1, ns_index, "R1_TS1_Temperature"}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == {:ok, {ns_index, "TEMMPERATURE"}} msg = {:write_node_value, {{1, ns_index, "R1_TS1_Temperature"}, 20, {"en-US", "A String"}}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == :ok msg = {:read_node_value, {1, ns_index, "R1_TS1_Temperature"}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == {:ok, {"en-US", "A String"}} msg = {:write_node_value, {{1, ns_index, "R1_TS1_Temperature"}, 25, {{1, ns_index, "R1_TS1_Temperature"}, {1, ns_index, "R1_TS1_Temperature"}}}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == :ok msg = {:read_node_value, {1, ns_index, "R1_TS1_Temperature"}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == {:ok, {{2, "string", "R1_TS1_Temperature"}, {2, "string", "R1_TS1_Temperature"}}} msg = {:write_node_value, {{1, ns_index, "R1_TS1_Temperature"}, 26, "10/02/20"}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == :ok msg = {:read_node_value, {1, ns_index, "R1_TS1_Temperature"}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == {:ok, "10/02/20"} msg = {:write_node_value, {{1, ns_index, "R1_TS1_Temperature"}, 28, 0x7fffffff}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == :ok msg = {:read_node_value, {1, ns_index, "R1_TS1_Temperature"}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == {:ok, 0x7fffffff} msg = {:write_node_value, {{1, ns_index, "R1_TS1_Temperature"}, 29, {103.1, 103.0}}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == :ok msg = {:read_node_value, {1, ns_index, "R1_TS1_Temperature"}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == {:ok, {103.0999984741211, 103.0}} msg = {:write_node_value, {{1, ns_index, "R1_TS1_Temperature"}, 30, 0x7fffffff}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == :ok msg = {:read_node_value, {1, ns_index, "R1_TS1_Temperature"}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == {:ok, 0x7fffffff} end test "Write and Read Attibutes", %{port: port, ns_index: _ns_index} do msg = {:set_client_config, %{}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) _c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end msg = {:connect_client_by_url, "opc.tcp://localhost:4840/"} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) _c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end msg = {:read_node_id, {0, 1, 10001}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == {:ok, {1, "integer", 10001}} msg = {:write_node_browse_name, {{0, 1, 10001}, {1, "Var_N"}}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == :ok msg = {:read_node_browse_name, {0, 1, 10001}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == {:ok, {1, "Var_N"}} msg = {:write_node_display_name, {{0, 1, 10001}, "en-US", "var"}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == :ok msg = {:read_node_display_name, {0, 1, 10001}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == {:ok, {"en-US", "var"}} msg = {:write_node_description, {{0, 1, 10001}, "en-US", "variable"}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == :ok msg = {:read_node_description, {0, 1, 10001}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == {:ok, {"en-US", "variable"}} msg = {:write_node_write_mask, {{0, 1, 10001}, 0x3BFFFF}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == :ok msg = {:read_node_write_mask, {0, 1, 10001}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == {:ok, 0x3BFFFF} msg = {:write_node_is_abstract, {{0, 1, 10000}, true}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == :ok msg = {:read_node_is_abstract, {0, 1, 10000}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == {:ok, true} msg = {:write_node_data_type, {{0, 1, 10001}, {0, 0, 63}}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == :ok msg = {:read_node_data_type, {0, 1, 10001}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == {:ok, {0, "integer", 63}} msg = {:write_node_value_rank, {{0, 1, 10001}, 3}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == :ok msg = {:read_node_value_rank, {0, 1, 10001}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == {:ok, 3} msg = {:write_node_access_level, {{0, 1, 10001}, 3}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == :ok msg = {:read_node_access_level, {0, 1, 10001}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == {:ok, 3} msg = {:write_node_minimum_sampling_interval, {{0, 1, 10001}, 100.0}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == :ok msg = {:read_node_minimum_sampling_interval, {0, 1, 10001}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == {:ok, 100.0} msg = {:write_node_historizing, {{0, 1, 10001}, true}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == :ok msg = {:read_node_historizing, {0, 1, 10001}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == {:ok, true} msg = {:write_node_executable, {{0, 1, 10001}, false}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == :ok # Must be a MethodNode. msg = {:read_node_executable, {0, 1, 10001}} send(port, {self(), {:command, :erlang.term_to_binary(msg)}}) c_response = receive do {_, {:data, <>}} -> :erlang.binary_to_term(response) x -> IO.inspect(x) :error after 1000 -> # Not sure how this can be recovered exit(:port_timed_out) end assert c_response == {:error, "BadAttributeIdInvalid"} end end